Load. Shape. Deliver.

Add an iso-surface node on the deficit field and set the threshold to 0.15. A ghostly tube appears behind the rotor in the 3D viewer, showing exactly where the wake has and hasn't recovered. Drag the threshold slider to tighten or loosen the envelope — the mesh rebuilds live from the cached field.

Chain a @shape spatial-join node that drops each meter coordinate into the building footprint it falls inside. The preview draws a line from every meter to its host building so stray gauges stand out. Each reading is now tagged with a building ID.

Drop the bridge's glTF export next to it and the structure renders around the floating gauge points. Line the two up and the gauges settle onto the girders and deck where they are actually bonded. Now every reading has a place to land on the geometry.

Style the joined layer with a zone-color palette, then wire a @deliver node that writes styled Shapefile layers plus a clean parcel-to-zone table. Export drops the layers for GIS and a flat CSV the planning team can open in a spreadsheet — parcel ID, zone, and conflict flag, no geometry. When the zoning table updates in PostGIS, re-run and both exports refresh.

Point the @deliver export at `scored/` and toggle the report on. You get one scored Parquet file plus a dashboard — score distribution, null counts, rows per second, and drift against the training feature stats.

Wire the hourly table into a @deliver node that colors each building blue-to-red by current draw — the campus repaints as the feed updates. Add a report delivery set to weekly and it bakes trends, top buildings, and heat-map snapshots into a PDF. Both outputs rebuild from the same canvas.

Add the drift detector and set two thresholds with sliders — slope per day for slow drift, jump size for step changes. Flags appear on the chart the moment a tag crosses either one. Tighten a slider and watch borderline sensors flip in and out of the flagged list.

Add a motion-artifact node that scores each volume for ghosting and ringing. Borderline studies surface for a quick look in the viewer; the obviously corrupted ones light up red on their own. Scrub any flagged study and the offending slices are already centered for you.

Wire the risk grid into the 3D viewer and drape it over the LiDAR terrain. Scrub the camera down each valley to see which streets and parcels sit inside the 100-year footprint, and toggle return periods to compare scenarios in place. When a stakeholder asks about one block, you fly straight to it instead of re-rendering.

Wire the grid into a @deliver node set to GeoTIFF and send the fused cloud out as glTF for the sim team. Hit export and both files land in the nav stack's map folder. When new sweeps arrive, the same canvas rebuilds both exports untouched.

Chain a baseline step that takes each tag's Monday median as its reference and rescales the week to percent-of-baseline. Sensors with different units and ranges become directly comparable. Flat lines mean healthy; anything sloping is a suspect.

Chain a sync node and pick a one-minute common grid. Set interpolation for the analog channels and hold-last for the slow ones, and watch 200 ragged timelines snap into one aligned table. That aligned table is a cached intermediate, so every statistic downstream recomputes instantly.

Drag the trial folder — 12 units, six sensor CSVs each — onto the canvas. LSD groups them into one @load node keyed by unit ID and previews the first rows with inferred types. IMU at 200 Hz, GPS at 5 Hz, and battery at 1 Hz land as separate time-series entities.

Drop your ONNX organ model onto the canvas and wire the resampled volume into the @deliver node it becomes. Labels stream back a slice block at a time, and the viewer paints each organ its own color as they arrive. A flipped orientation or wrong label index shows up in seconds — long before the full volume finishes.

Add two flag nodes — a rolling MAD outlier check on every numeric channel, and a gap detector that marks any silence over 500 ms as a dropout. Flags paint straight onto the timeline as red and amber bands. Unit 7's IMU lights up immediately with forty dropouts an hour.

Drag twelve monthly `snapshot_*.parquet` files onto the canvas together. LSD unions them into one entity, derives a `snapshot_month` column from the filenames, and caches the result — 2.1M account rows with a `churned_within_90d` label.

Wire the calibrated stress into a @deliver node that colors the mesh green-to-red by live load — the bridge repaints as each axle rolls across. Set an alert-log delivery that writes every exceedance window to CSV with gauge, time, and peak. Drop a new telemetry batch and both rebuild from cached intermediates.

Add a @shape node that subtracts the matched dark frame and divides by the flat-field response for every run. The corrected preview updates live as you choose which dark to pair by exposure time. The full corrected stack becomes a cached intermediate, so every step after it stays instant.

Finish with a @deliver report node and set the trial thresholds — dropouts under 0.5%, outliers under 1%, live heartbeat present. Every unit gets a pass/fail badge with its flagged windows attached as evidence. Export as CSV and post it before anyone loads the truck.

Drag the archive of long-run CSVs — 200 sensors, months of samples each — onto the canvas. The @load node groups them into one array entity keyed by sensor ID, infers the timestamp and value columns, and previews row counts per sensor. Files parse lazily, so a multi-gigabyte archive opens at once.

Add a slice node and drag the plane through the domain in the 3D viewer. Snap it to hub height, then add a second vertical plane down the rotor axis. Both previews update as you drag — the full-resolution volume stays on disk as a cached intermediate.

Sort the feature preview by correlation with the label and `days_since_last_login` glows at 0.96, its histogram split into two clean islands. Click the node and the cause is right there in the expression — the window was anchored to the export date, not the snapshot date. Re-anchor it and the histogram relaxes into honest overlap.

Drop the ONNX U-Net onto the canvas and wire the normalized tiles into the @deliver node it becomes. Predictions stream back a batch at a time, and the viewer paints class colors over the imagery as they arrive — a wrong class index shows up in seconds, not after the full run.

Scrub the time axis and the slices, iso-surface, and deficit colors all follow. Set the playback range to the last 400 timesteps — one full rotor revolution — and let the viewer loop it. When the wake meandering reads clearly, queue the animation for export at 1600 × 900.

Point an indicator-kriging node at the validated intervals and set 10 m blocks with a 150 m search radius. The block model previews with cutaway slices, and nudging the radius re-krigs only the volume — the validated logs stay cached upstream.

Chain a @shape sync node and pick a 10 Hz common clock. Set linear interpolation for IMU and battery, hold-last for GPS fixes, and watch the merged timeline preview line up. The synced table is a cached intermediate, so the flagging downstream stays instant.

Add an @deliver node set to glTF. The nominal mesh is baked with a blue-to-red deviation map and exported as one portable file. Anyone can spin it in a browser viewer — no metrology software needed.

Finish with a @deliver node set to glTF and get one 48 MB file with every lithology unit as a tagged, georeferenced mesh. It opens in any glTF viewer — nobody downstream needs geology software installed.

Drop the 1991–2020 climatology as a second @load and wire a @shape expression that subtracts it — anomaly = season_mean - baseline. Expose the baseline period as a live parameter. Every member's map recolors around zero the moment you connect the node.

Add a filter node that flags any parcel intersecting more than one zone — the boundary straddlers the planning team actually cares about. The map lights those lots up in red while clean matches fade back, and the live count tells you exactly how many need review. Drag the overlap tolerance to ignore slivers from imperfect edges.

Drop the cohort root — 400 studies, mixed scanners and sites — onto the canvas. LSD walks the tree and groups every series into one @load node keyed by study and subject ID, reading tags without decoding pixel data. Four hundred studies index in under a minute, and the preview table lists each one with its sequence, field strength, and acquisition date.

Add a windowed-stats node and compute mean, standard deviation, and a standard-error band per sensor over a rolling window. Expose the window length as a live parameter and drag it; every curve and its uncertainty band rebreathe from the cached aligned table. No rerun, no waiting.

Finish the shaping with a @deliver report node and set the cohort rules — protocol orientation, spacing within tolerance, motion score under threshold, required sequences present. Every study earns a pass/fail badge with its failing checks listed as evidence. The table sorts failures to the top so you see the damage first.

Open the 3D viewer and turn each predicted organ into a shaded surface floating inside the windowed volume. Rotate it to catch the classic failures — a liver that leaks into the ribcage, a kidney with a hole punched through it. Toggle organs on and off and scrub the slice overlay to confirm the surface tracks the boundary on every plane.

Select all 63 LAS files and drop them on the canvas as one @load node. LSD reads each header, aligns the GR, density, and LITH code channels across holes, and previews the merged interval table — 9,400 logged metres in a single entity.

Difference each quarterly surface against the 1998 pre-mining baseline and stack the results into one time-enabled volume. Scrub the time slider in the 3D viewer to watch the drawdown cone relax and the pit lake step toward its spill level.

Line-scan frames are 8192 × 2048 — far too big for the model. Add a tile step set to 1024 × 1024 with 128 px overlap; the preview draws the cut grid over a sample frame. The tiled set becomes a cached intermediate, so downstream tweaks never re-cut it.

Drop a kriging node on the head table and set a spherical variogram with a 1,200 m range on 250 m cells. LSD grids all 112 quarters in one pass, and the variance map shades the pit's north wall red — that's where the next bore should go.

Import the @shape normalize step saved from the training pipeline instead of rewriting it. Its fitted means and scales come along as cached params, and the preview shows standardized columns immediately — zero train/serve skew by construction.

Finish with a @deliver node. Render the stacked spectrum as a publication figure with labelled axes and the uncertainty band, then export the corrected, calibrated dataset as NetCDF alongside it. The pipeline file travels with the export, so a reviewer can rebuild every spectrum from the raw CSVs.

Drag the solver's output folder onto the canvas — 412 NetCDF files, about 200 GB. The @load node reads headers only, so u, v, w, and pressure appear with their dimensions in seconds, and the timesteps stack into a single time axis automatically. Nothing is pulled into memory until a downstream step actually needs it.

Add a @shape crop node and drag a lat/lon box over the region in the map preview, snapping it to the basin you care about. All 40 members crop together and the preview redraws as you drag. The global grid stays on disk as a cached intermediate, so nothing gets copied.

Drop a rasterize node and set 10 cm cells over a 0.2–1.8 m height band. Points inside the band mark cells occupied; everything scanned but empty becomes free space. The grid renders beneath the 3D cloud so you can check each rack against its footprint.

Add the interval-check step and LSD flags 41 problems — overlapping intervals, gaps, and codes like GRNT that aren't in the 11-code legend. Fix the mapping in the side panel and watch the strip logs re-render clean, hole by hole.

Drag the climate model's NetCDF onto the canvas and pick the rch variable from the node's dropdown. The 500 m recharge grid drapes over the terrain in the 3D viewer, and a time chip appears on the node showing 336 monthly slices.

Wire an @deliver dashboard showing every flagged tag with its drift score, plus a CSV export of the maintenance shortlist ranked by severity. Next week, drop the new folder on the same canvas — cached intermediates mean only the new files recompute.

CT slices are usually thicker than they are wide, which skews any 3D measurement. Chain a resample @shape node set to 1 mm isotropic voxels and watch the axial, coronal, and sagittal previews line up to true proportions. The resampled volume caches, so the model step downstream never recomputes it.

Drag the county parcels Shapefile — all 80,000 polygons — onto the canvas. The @load node reads the geometry and the full attribute table without choking, and the preview draws every lot colored by its current land-use code. The inspector shows the file's CRS so you know exactly what you're reprojecting from.

Chain a spatial-join node and set the predicate to intersects, matching each parcel to the zoning polygon it falls in. LSD tags all 80,000 parcels with their zone code in one pass, and the preview recolors the map by zone as the join completes. The joined layer is a cached intermediate the rest of the canvas reuses.

Hit run and the inference step streams the entity through ONNX Runtime in 64k-row batches. A progress bar tracks throughput, and scores append as a new `p_convert` column you can preview while the run is still going.

Add a @deliver map node and set it to facet by member. Forty little anomaly maps tile into one figure with a shared diverging colorbar, so the spread across the ensemble reads at a glance. Nudge the color limits once and every panel follows.

Drag all 38 .laz files from the robot's scan folder onto the canvas. LSD stacks them into a single @load node and previews the raw cloud — 212 million points, colored by intensity. Open the inspector to confirm each sweep's odometry pose came along for the ride.

Add a tile step set to 512 × 512 with 64 px overlap. The preview draws the cut grid over the imagery, and each tile keeps its geotransform so predictions land back in the right place. The tiled set caches, so later re-runs skip straight past it.

Add a @shape registration node and feed it the embedded odometry poses. Toggle ICP refinement and watch the doubled-up aisle walls snap into single crisp planes in the preview. The registered cloud is a cached intermediate, so nothing downstream ever re-runs the alignment.

Add an @shape alignment step and pick best-fit registration. The solver snaps the measured points onto the nominal mesh and reports an RMS residual per part. Toggle datum-based alignment instead if your drawing calls one out — the preview re-renders either way.

A @deliver step writes both splits to Parquet for your trainer. When training finishes, drop the exported `churn.onnx` back on the canvas, wire it to the test split, and the confusion matrix fills in right next to the pipeline that built the data.

Drag `customers_2026-06.parquet` onto the canvas — 1.04M rows appear as a typed entity with a live preview and per-column stats. An Arrow feed works identically if the batch comes straight from your warehouse exporter.

Drop the flight's GeoTIFFs — six tiles, around 2 GB each — onto the canvas. The @load node reads CRS, ground resolution, and band count without decoding the full rasters, and the footprint preview shows all six sitting in their correct EPSG positions.

Drag the study folder onto the canvas — a few hundred axial slices land as one @load node keyed by series UID. LSD reads slice spacing, orientation, and rescale tags without decoding every image, so the volume previews in seconds. Scroll the slice slider to confirm the series loaded top-to-bottom in the right order.

Drop your trained model file onto the canvas and LSD wraps it in a @deliver node. Wire in the batched tiles and hit run — masks stream back batch by batch, and the viewer overlays each one on its source tile so you can QA predictions while the set is still scoring.

Drag the LiDAR tiles, the rainfall GeoTIFFs, and the drainage Shapefile onto the canvas together. LSD reads each into its own @load node — ground-classified returns, one raster per return period, and the storm-drain network — and previews all three in place. The inspector confirms every layer's CRS so nothing silently lands in the wrong spot.

Drag the whole logs folder — one CSV per machine per day — onto the canvas. A single @load node batches all 35 files, unions their columns, and previews the merged table. Timestamps parse automatically, even with mixed formats across machines.

Chain a @shape calibration node and apply each gauge's gauge-factor and zero offset from the CSV. Raw counts become engineering stress in MPa, and the preview replots the corrected values live. Nudge a zero offset and the whole channel re-baselines instantly.

Drop the per-coil capture folders onto the canvas. An @load node indexes every frame into one browsable image set — forty-thousand-odd strips, thumbnails and all — without copying a single file. Filenames like coil-1187_cam2_00412.png stay attached as metadata you can filter on later.

Add a stacking node and choose a robust mean with outlier rejection across the 900 corrected, calibrated runs. Because each upstream step is cached, changing the rejection threshold restacks in a blink instead of rereading a single CSV. The combined spectrum and its per-wavelength spread appear together.

Drag the folder of 85 building meshes onto the canvas and LSD stacks them into one @load node, rendering the whole campus in the 3D viewer. Each building keeps its ID from the filename, so it is already an addressable entity. Spin the campus to confirm nothing landed in the wrong coordinate frame.

Chain a validation @shape node that reads orientation, slice spacing, and matrix size off every series. It flags the study that came in sagittal when the protocol says axial, and the one resampled to 2 mm when the cohort standard is 1 mm. Flags paint straight onto the study table as red and amber cells — no slice-by-slice hunting.

Finish with a @deliver node. Render a small-multiples figure of the per-sensor trends with their uncertainty bands, and export a per-sensor summary table — count, mean, spread, and window settings — as CSV. The pipeline file ships with it, so a co-author reproduces every number by reopening the canvas.

Drag the folder of 40 NetCDF members onto the canvas. The @load node stacks them into one entity along a member axis, reads headers only, and previews near-surface temperature with its lat, lon, and time dimensions. Forty files become one thing you can slice.

Drag the folder of 900 instrument CSVs onto the canvas. The @load node groups them into one runs entity keyed by timestamp, infers the wavelength and counts columns, and previews the first rows. Nothing parses fully until a step downstream asks for it, so the whole season opens in seconds.

Add a node that spreads each rainfall raster across the accumulated flow to estimate standing depth, then expose a return-period slider and a depth-threshold slider. Drag from the 10-year to the 100-year storm and watch the inundation footprint grow live over the map. Cells past the threshold flag as at-risk, everything below as dry.

Chain a deviation step. Every point gets a signed distance to the nearest mesh surface, and a histogram of deviations appears in the step's preview. Drag the tolerance sliders — say ±0.05 mm — and points re-classify to pass, warn, or fail instantly.

Drag the folder of CMM CSVs onto the canvas and an @load node appears with every file batched into one table. LSD sniffs the columns — part ID, feature, and measured XYZ — and previews the first rows. Nothing to configure yet; the raw point cloud already renders in the 3D viewer.