@field/cascade 0.4.0 → 0.5.1

package/dist/runtime/builtins/pop/definitions.d.ts

@@ -0,0 +1,2120 @@
+import { type NodeExecutionContext } from "@field/cascade/contracts";
+import type { DefinitionNodeRegistration } from "../../types.js";
+/**
+ * `cascade.pop.*` - the minimum useful particle set.
+ *
+ * Step 2 of `PLAN particles.md`, and the step that carries the risk: a source,
+ * a solver, and forces, on **re-simulation only**. There is no cache. The plan
+ * argues for that order - re-simulation from the start frame is the definition
+ * of correctness, and a cache is an accelerator holding nothing re-simulation
+ * would not have produced, so it is built second and can be cleared at any
+ * time without changing a result.
+ *
+ * The arithmetic lives in `packages/runtime/src/pop`, deliberately: these
+ * nodes are thin, the risk is in the stepping, and the stepping is testable
+ * without a graph.
+ */
+declare const sourceDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "POP Source";
+    readonly description: "Birth particles from a geometry's points.";
+    readonly icon: "Sparkles";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly impulse: {
+            readonly type: "int";
+            readonly default: 8;
+            readonly min: 0;
+            readonly max: 100000;
+        };
+        readonly life: {
+            readonly type: "float";
+            readonly default: 3;
+            readonly min: 0;
+            readonly max: 3600;
+            readonly step: 0.1;
+        };
+        readonly lifevar: {
+            readonly type: "float";
+            readonly default: 0.3;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly velocity: {
+            readonly type: "vec2";
+            readonly default: readonly [0, 0];
+        };
+        readonly seed: {
+            readonly type: "int";
+            readonly default: 7;
+            readonly min: 0;
+            readonly max: 999999;
+        };
+    };
+};
+export declare function executeSource(context: NodeExecutionContext<typeof sourceDefinition>): void;
+declare const solverDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "POP Solver";
+    readonly description: "Advance a particle system by one timestep.";
+    readonly icon: "Play";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        /**
+         * Where the timestep comes from. Marcus's ruling, 2026-09-09: *"Let the
+         * user choose nodes fixed or variable."*
+         *
+         * `fixed` is the default on the ordinary grounds that the safer of two
+         * behaviours is the one you get without asking - a simulation whose result
+         * depends on a playback setting is not reproducible from the document
+         * alone. With `fps` the render rate becomes part of what determines the
+         * output, which is correct for a mode called variable and must not be
+         * silent: it belongs in the cache key, and `cascade check` should say so.
+         */
+        readonly timestep_mode: {
+            readonly type: "string";
+            readonly default: "fixed";
+            readonly control: "select";
+            readonly options: readonly [{
+                readonly value: "fixed";
+                readonly label: "Fixed - reproducible from the document";
+            }, {
+                readonly value: "fps";
+                readonly label: "Variable - derived from the render rate";
+            }];
+        };
+        readonly timestep: {
+            readonly type: "float";
+            readonly default: number;
+            readonly min: number;
+            readonly max: 1;
+            readonly step: number;
+        };
+        readonly maxspeed: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 10000;
+            readonly step: 0.5;
+        };
+        readonly force: {
+            readonly type: "vec2";
+            readonly default: readonly [0, 0];
+        };
+        readonly airresist: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 20;
+            readonly step: 0.05;
+        };
+    };
+};
+export declare function executeSolver(context: NodeExecutionContext<typeof solverDefinition>): void;
+declare const noiseForceDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "POP Noise Force";
+    readonly description: "Push particles along a heading read from a noise field.";
+    readonly icon: "Wind";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly amplitude: {
+            readonly type: "float";
+            readonly default: 6;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.5;
+        };
+        readonly frequency: {
+            readonly type: "float";
+            readonly default: 0.3;
+            readonly min: 0.001;
+            readonly max: 10;
+            readonly step: 0.01;
+        };
+        readonly evolve: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: -1000;
+            readonly max: 1000;
+            readonly step: 0.01;
+        };
+        readonly timestep: {
+            readonly type: "float";
+            readonly default: number;
+            readonly min: number;
+            readonly max: 1;
+            readonly step: number;
+        };
+        readonly seed: {
+            readonly type: "int";
+            readonly default: 7;
+            readonly min: 0;
+            readonly max: 999999;
+        };
+    };
+};
+/**
+ * Accumulates into `force` and moves nothing — Houdini's POP model.
+ *
+ * Changed 2026-09-09, and it is a correctness fix rather than a refinement.
+ * This node used to call `step()`, which integrates. Chain two force nodes
+ * inside a `cascade.core.Feedback` and time then advances **twice per step**:
+ * the particles travel further than the timestep says, reordering nodes that
+ * ought to commute changes the result, and nothing reports anything. That is
+ * unreadable from a picture, so the model has to be right rather than tested.
+ */
+export declare function executeNoiseForce(context: NodeExecutionContext<typeof noiseForceDefinition>): void;
+declare const separateDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "POP Separate";
+    readonly description: "Push neighbours apart within a radius.";
+    readonly icon: "Move3d";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly radius: {
+            readonly type: "float";
+            readonly default: 0.5;
+            readonly min: 0;
+            readonly max: 100;
+            readonly step: 0.01;
+        };
+        readonly strength: {
+            readonly type: "float";
+            readonly default: 4;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.1;
+        };
+        readonly timestep: {
+            readonly type: "float";
+            readonly default: number;
+            readonly min: number;
+            readonly max: 1;
+            readonly step: number;
+        };
+    };
+};
+export declare function executeSeparate(context: NodeExecutionContext<typeof separateDefinition>): void;
+/**
+ * `cascade.pop.FieldForce` — the flow field, as a node.
+ *
+ * Extracted from `pop.Simulate`'s `field_*` props on 2026-09-09 so that the
+ * force which actually makes the calligraphy is a node you can see inside the
+ * container, reorder, and drive from a ramp. Two components, and they are the
+ * whole effect: `normal` pulls along the field's `N` toward the spine of the
+ * type, `tangential` pushes perpendicular to it, around the outline. The
+ * balance between them is what turns a hairball into a stroke.
+ *
+ * `level` and `hold` are the reason the lines follow the letters rather than
+ * collapsing onto them: instead of climbing to the field's peak, a particle
+ * holds a chosen contour. Marcus's own note on wanting this: *"we want the
+ * lines to extend and really flow around the letters, creating an elegant
+ * calligraphy… not hairballs or knots."*
+ */
+declare const fieldForceDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "POP Field Force";
+    readonly description: "Pull particles along a field's gradient and around its contours. The calligraphy force.";
+    readonly icon: "Waves";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        /** The field: points carrying `N` (the gradient) and optionally `level`. */
+        readonly field: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly normal: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: -100000;
+            readonly max: 100000;
+            readonly label: "Normal";
+            readonly description: "Along N, toward the spine. Negative pushes away.";
+        };
+        readonly tangential: {
+            readonly type: "float";
+            readonly default: 2600;
+            readonly min: -100000;
+            readonly max: 100000;
+            readonly label: "Tangential";
+            readonly description: "Perpendicular to N, around the outline. Sign picks the direction.";
+        };
+        readonly radius: {
+            readonly type: "float";
+            readonly default: 20;
+            readonly min: 0;
+            readonly max: 10000;
+            readonly label: "Radius";
+            readonly description: "How far a field sample reaches.";
+        };
+        readonly level: {
+            readonly type: "float";
+            readonly default: 0.28;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+            readonly label: "Level";
+            readonly description: "The contour to hold, rather than climbing to the peak.";
+        };
+        readonly hold: {
+            readonly type: "float";
+            readonly default: 5200;
+            readonly min: 0;
+            readonly max: 100000;
+            readonly label: "Hold";
+            readonly description: "How hard to hold that contour.";
+        };
+    };
+};
+export declare function executeFieldForce(context: NodeExecutionContext<typeof fieldForceDefinition>): void;
+/**
+ * `cascade.pop.Trail` — trails from a Feedback container's history.
+ *
+ * The node that makes the network version of the piece possible at all. A trail
+ * needs the *frames*, and a node downstream of a simulation sees one — which
+ * draws nothing. `cascade.core.Feedback` keeps a bounded history for exactly
+ * this, and this node consumes it.
+ *
+ * The parameter names are Houdini's Trail SOP: `result`, `length`,
+ * `increment`, `velocityscale`.
+ */
+declare const trailDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "POP Trail";
+    readonly description: "Build trails from a Feedback container's history.";
+    readonly icon: "Activity";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        /** The container's `history` output: every kept step, oldest first. */
+        readonly history: {
+            readonly kind: "data";
+            readonly type: "array";
+        };
+        /** The current state, for `preserve` and for the newest point of each trail. */
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly result: {
+            readonly type: "string";
+            readonly default: "polylines";
+            readonly control: "select";
+            readonly options: readonly [{
+                readonly value: "polylines";
+                readonly label: "Polylines - one line per particle";
+            }, {
+                readonly value: "preserve";
+                readonly label: "Preserve - pass the points through";
+            }];
+            readonly label: "Result";
+        };
+        readonly length: {
+            readonly type: "int";
+            readonly default: 12;
+            readonly min: 1;
+            readonly max: 100000;
+            readonly label: "Length";
+        };
+        readonly increment: {
+            readonly type: "int";
+            readonly default: 1;
+            readonly min: 1;
+            readonly max: 1000;
+            readonly label: "Increment";
+        };
+        readonly velocityscale: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0;
+            readonly max: 100;
+            readonly step: 0.01;
+            readonly label: "Velocity Scale";
+        };
+    };
+};
+export declare function executeTrail(context: NodeExecutionContext<typeof trailDefinition>): void;
+declare const simulateDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "POP Simulate";
+    readonly description: "Re-simulate a particle system from frame zero to this frame.";
+    readonly icon: "Rewind";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        /** Where particles are born. Its points are the birth positions. */
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        /** The frame to simulate up to. Drive it with `$F`. An input rather than
+         *  a prop because the whole node is a function of it, and because a node
+         *  that read the clock itself would be the thing `AGENTS.md` forbids. */
+        readonly frame: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 1;
+        };
+        /**
+         * Points particles are drawn toward. Houdini's POP Attract.
+         *
+         * **Geometry rather than an image, and that was a correction.** The
+         * original piece renders its word to a canvas, blurs it, reads the pixels
+         * back and takes central differences — so its target really is a raster
+         * field, and an `image` input was the first thing tried here. It was wrong
+         * for this node: decoding an image needs a capability, the media
+         * capability hands back a host-specific lease rather than a portable
+         * raster, and a POP node doing IO stops being the pure arithmetic that
+         * makes it cook identically in both hosts.
+         *
+         * So the rasterising belongs upstream, in whatever node knows about text
+         * or photographs, and what reaches the solver is a set of target points.
+         * `fieldForce` in `pop/forces.ts` still takes a sampled raster for a node
+         * that has one; this input is the composable half.
+         */
+        readonly attract: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        /**
+         * A flow field, as points carrying `N`.
+         *
+         * Marcus's description of the original: *"a delicate balance between a
+         * force pulling the particles towards the centre spine of the type and
+         * tangentially around their outlines."* This is that field — the gradient
+         * of a BLURRED letterform, whose ridge runs down each stroke's middle, so
+         * the gradient points at the spine and its perpendicular runs along the
+         * outline. `field_normal` and `field_tangential` are the two halves of the
+         * balance.
+         */
+        readonly field: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        /** The particles, one point each. */
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        /**
+         * The trails, one open polyline per particle.
+         *
+         * Emitted here rather than by a standalone `Trail` node, and that is a
+         * consequence of re-simulation rather than a shortcut. Houdini's Trail SOP
+         * reads a rolling window the cook already holds, because Houdini's cook is
+         * stateful; Cascade's node is a pure function of its inputs, so a
+         * standalone `Trail` can only see the frame on its port — one frame, which
+         * draws nothing. This node replays every frame from zero, so it has the
+         * whole history for free, and a node that draws nothing would be worse than
+         * no node.
+         *
+         * When `CookScheduler` owns the rolling window the plan describes,
+         * `cascade.pop.Trail` becomes a real node and this output stays as the
+         * cheap path. The parameters are Houdini's either way.
+         */
+        readonly trails: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        /** Frames of history in the trails. Houdini's Trail `length`. */
+        readonly trail_length: {
+            readonly type: "int";
+            readonly default: 14;
+            readonly min: 1;
+            readonly max: 500;
+        };
+        /** Use every nth frame. Houdini's `increment`. */
+        readonly trail_increment: {
+            readonly type: "int";
+            readonly default: 1;
+            readonly min: 1;
+            readonly max: 32;
+        };
+        /**
+         * Re-simulation, and why this is the first implementation rather than a
+         * placeholder for a cached one.
+         *
+         * `PLAN particles.md`: re-simulation from the start frame is the
+         * *definition* of correctness, and a cache is an accelerator holding
+         * nothing re-simulation would not have produced. So this node is the
+         * reference: it reads a frame, replays every step from zero, and depends on
+         * no state whatsoever. Scrubbing is O(frame) and that is the honest cost —
+         * a checkpoint cache makes it fast later without changing a single output,
+         * which is exactly the property a cache should have.
+         */
+        readonly substeps: {
+            readonly type: "int";
+            readonly default: 1;
+            readonly min: 1;
+            readonly max: 32;
+        };
+        readonly timestep: {
+            readonly type: "float";
+            readonly default: number;
+            readonly min: number;
+            readonly max: 1;
+            readonly step: number;
+        };
+        /** Per frame, as on Source. */
+        readonly impulse: {
+            readonly type: "int";
+            readonly default: 6;
+            readonly min: 0;
+            readonly max: 100000;
+        };
+        readonly life: {
+            readonly type: "float";
+            readonly default: 4;
+            readonly min: 0;
+            readonly max: 3600;
+            readonly step: 0.1;
+        };
+        readonly lifevar: {
+            readonly type: "float";
+            readonly default: 0.4;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly force: {
+            readonly type: "vec2";
+            readonly default: readonly [0, 0];
+        };
+        readonly airresist: {
+            readonly type: "float";
+            readonly default: 0.4;
+            readonly min: 0;
+            readonly max: 20;
+            readonly step: 0.05;
+        };
+        readonly noise_amplitude: {
+            readonly type: "float";
+            readonly default: 14;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.5;
+        };
+        readonly noise_frequency: {
+            readonly type: "float";
+            readonly default: 0.02;
+            readonly min: 0.001;
+            readonly max: 10;
+            readonly step: 0.001;
+        };
+        /** Turns per second of field evolution. */
+        readonly noise_evolve: {
+            readonly type: "float";
+            readonly default: 0.08;
+            readonly min: -10;
+            readonly max: 10;
+            readonly step: 0.01;
+        };
+        /** Toward the spine, up the field's gradient. */
+        readonly field_normal: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: -20000;
+            readonly max: 20000;
+            readonly step: 1;
+        };
+        /** Around the outline, perpendicular to the gradient. Sign picks which way. */
+        readonly field_tangential: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: -20000;
+            readonly max: 20000;
+            readonly step: 1;
+        };
+        /** Field samples beyond this are ignored, and it is the grid's cell size. */
+        readonly field_radius: {
+            readonly type: "float";
+            readonly default: 24;
+            readonly min: 0.5;
+            readonly max: 2000;
+            readonly step: 0.5;
+        };
+        /**
+         * The contour to hold, as a field level 0..1, with `field_hold` as how
+         * firmly.
+         *
+         * Marcus: *"the lines flow tangentially around the letters in a bundle …
+         * loosely describing the type."* A bundle is a contour, so holding a level
+         * and letting the tangent carry particles round it is the mechanism —
+         * pulling them to the spine instead collapses each letter to a point, and
+         * pure tangential flow lets every particle converge onto one level set.
+         */
+        readonly field_level: {
+            readonly type: "float";
+            readonly default: 0.35;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly field_hold: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 40000;
+            readonly step: 10;
+        };
+        /**
+         * Scatter births across this box instead of on the source geometry's
+         * points, `[minX, minY, maxX, maxY]`. All zero uses the points.
+         *
+         * Houdini's POP Source has the same choice — *Scatter onto Surface* against
+         * *Points* — and Marcus's note is that the original spawns *around* the
+         * type rather than on it: *"The particles should spawn in the area around
+         * the type … and then the forces should drag them around."* Birthing on
+         * the letterforms puts every particle where it is already going, so
+         * nothing travels and the field has nothing to reveal.
+         */
+        readonly birth_area: {
+            readonly type: "vec4";
+            readonly default: readonly [0, 0, 0, 0];
+        };
+        /**
+         * A colour per particle, drawn at birth and fixed for its life.
+         *
+         * Hashed on the id, so the same particle gets the same colour however many
+         * times the frame is re-simulated — a colour drawn from a stream would
+         * change on every scrub, which reads as the render being unstable.
+         *
+         * `[from, to]` in turns around the wheel. Equal values give one hue; a
+         * narrow span is usually what a piece wants, because a full-spectrum
+         * random set reads as a test pattern rather than as a palette.
+         */
+        readonly birth_hue: {
+            readonly type: "vec2";
+            readonly default: readonly [0, 0];
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly birth_saturation: {
+            readonly type: "float";
+            readonly default: 0.6;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly birth_value: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        /** How hard the targets pull. Houdini's POP Attract strength. */
+        readonly attract_amplitude: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 20000;
+            readonly step: 1;
+        };
+        /** Beyond this distance a target is ignored, which is what keeps the pull
+         *  local and the cost bounded. 0 means every target pulls every particle. */
+        readonly attract_radius: {
+            readonly type: "float";
+            readonly default: 60;
+            readonly min: 0;
+            readonly max: 5000;
+            readonly step: 1;
+        };
+        readonly separate_radius: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.5;
+        };
+        readonly separate_strength: {
+            readonly type: "float";
+            readonly default: 12;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.5;
+        };
+        readonly maxspeed: {
+            readonly type: "float";
+            readonly default: 60;
+            readonly min: 0;
+            readonly max: 10000;
+            readonly step: 1;
+        };
+        /** `[minX, minY, maxX, maxY]`, or all zero for open space. The original
+         *  piece is toroidal. */
+        readonly wrap: {
+            readonly type: "vec4";
+            readonly default: readonly [0, 0, 0, 0];
+        };
+        readonly seed: {
+            readonly type: "int";
+            readonly default: 7;
+            readonly min: 0;
+            readonly max: 999999;
+        };
+    };
+};
+export declare function executeSimulate(context: NodeExecutionContext<typeof simulateDefinition>): void;
+export declare const simulateRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "POP Simulate";
+        readonly description: "Re-simulate a particle system from frame zero to this frame.";
+        readonly icon: "Rewind";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            /** Where particles are born. Its points are the birth positions. */
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+            /** The frame to simulate up to. Drive it with `$F`. An input rather than
+             *  a prop because the whole node is a function of it, and because a node
+             *  that read the clock itself would be the thing `AGENTS.md` forbids. */
+            readonly frame: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 1;
+            };
+            /**
+             * Points particles are drawn toward. Houdini's POP Attract.
+             *
+             * **Geometry rather than an image, and that was a correction.** The
+             * original piece renders its word to a canvas, blurs it, reads the pixels
+             * back and takes central differences — so its target really is a raster
+             * field, and an `image` input was the first thing tried here. It was wrong
+             * for this node: decoding an image needs a capability, the media
+             * capability hands back a host-specific lease rather than a portable
+             * raster, and a POP node doing IO stops being the pure arithmetic that
+             * makes it cook identically in both hosts.
+             *
+             * So the rasterising belongs upstream, in whatever node knows about text
+             * or photographs, and what reaches the solver is a set of target points.
+             * `fieldForce` in `pop/forces.ts` still takes a sampled raster for a node
+             * that has one; this input is the composable half.
+             */
+            readonly attract: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+            /**
+             * A flow field, as points carrying `N`.
+             *
+             * Marcus's description of the original: *"a delicate balance between a
+             * force pulling the particles towards the centre spine of the type and
+             * tangentially around their outlines."* This is that field — the gradient
+             * of a BLURRED letterform, whose ridge runs down each stroke's middle, so
+             * the gradient points at the spine and its perpendicular runs along the
+             * outline. `field_normal` and `field_tangential` are the two halves of the
+             * balance.
+             */
+            readonly field: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly outputs: {
+            /** The particles, one point each. */
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+            /**
+             * The trails, one open polyline per particle.
+             *
+             * Emitted here rather than by a standalone `Trail` node, and that is a
+             * consequence of re-simulation rather than a shortcut. Houdini's Trail SOP
+             * reads a rolling window the cook already holds, because Houdini's cook is
+             * stateful; Cascade's node is a pure function of its inputs, so a
+             * standalone `Trail` can only see the frame on its port — one frame, which
+             * draws nothing. This node replays every frame from zero, so it has the
+             * whole history for free, and a node that draws nothing would be worse than
+             * no node.
+             *
+             * When `CookScheduler` owns the rolling window the plan describes,
+             * `cascade.pop.Trail` becomes a real node and this output stays as the
+             * cheap path. The parameters are Houdini's either way.
+             */
+            readonly trails: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly props: {
+            /** Frames of history in the trails. Houdini's Trail `length`. */
+            readonly trail_length: {
+                readonly type: "int";
+                readonly default: 14;
+                readonly min: 1;
+                readonly max: 500;
+            };
+            /** Use every nth frame. Houdini's `increment`. */
+            readonly trail_increment: {
+                readonly type: "int";
+                readonly default: 1;
+                readonly min: 1;
+                readonly max: 32;
+            };
+            /**
+             * Re-simulation, and why this is the first implementation rather than a
+             * placeholder for a cached one.
+             *
+             * `PLAN particles.md`: re-simulation from the start frame is the
+             * *definition* of correctness, and a cache is an accelerator holding
+             * nothing re-simulation would not have produced. So this node is the
+             * reference: it reads a frame, replays every step from zero, and depends on
+             * no state whatsoever. Scrubbing is O(frame) and that is the honest cost —
+             * a checkpoint cache makes it fast later without changing a single output,
+             * which is exactly the property a cache should have.
+             */
+            readonly substeps: {
+                readonly type: "int";
+                readonly default: 1;
+                readonly min: 1;
+                readonly max: 32;
+            };
+            readonly timestep: {
+                readonly type: "float";
+                readonly default: number;
+                readonly min: number;
+                readonly max: 1;
+                readonly step: number;
+            };
+            /** Per frame, as on Source. */
+            readonly impulse: {
+                readonly type: "int";
+                readonly default: 6;
+                readonly min: 0;
+                readonly max: 100000;
+            };
+            readonly life: {
+                readonly type: "float";
+                readonly default: 4;
+                readonly min: 0;
+                readonly max: 3600;
+                readonly step: 0.1;
+            };
+            readonly lifevar: {
+                readonly type: "float";
+                readonly default: 0.4;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+            };
+            readonly force: {
+                readonly type: "vec2";
+                readonly default: readonly [0, 0];
+            };
+            readonly airresist: {
+                readonly type: "float";
+                readonly default: 0.4;
+                readonly min: 0;
+                readonly max: 20;
+                readonly step: 0.05;
+            };
+            readonly noise_amplitude: {
+                readonly type: "float";
+                readonly default: 14;
+                readonly min: 0;
+                readonly max: 500;
+                readonly step: 0.5;
+            };
+            readonly noise_frequency: {
+                readonly type: "float";
+                readonly default: 0.02;
+                readonly min: 0.001;
+                readonly max: 10;
+                readonly step: 0.001;
+            };
+            /** Turns per second of field evolution. */
+            readonly noise_evolve: {
+                readonly type: "float";
+                readonly default: 0.08;
+                readonly min: -10;
+                readonly max: 10;
+                readonly step: 0.01;
+            };
+            /** Toward the spine, up the field's gradient. */
+            readonly field_normal: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: -20000;
+                readonly max: 20000;
+                readonly step: 1;
+            };
+            /** Around the outline, perpendicular to the gradient. Sign picks which way. */
+            readonly field_tangential: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: -20000;
+                readonly max: 20000;
+                readonly step: 1;
+            };
+            /** Field samples beyond this are ignored, and it is the grid's cell size. */
+            readonly field_radius: {
+                readonly type: "float";
+                readonly default: 24;
+                readonly min: 0.5;
+                readonly max: 2000;
+                readonly step: 0.5;
+            };
+            /**
+             * The contour to hold, as a field level 0..1, with `field_hold` as how
+             * firmly.
+             *
+             * Marcus: *"the lines flow tangentially around the letters in a bundle …
+             * loosely describing the type."* A bundle is a contour, so holding a level
+             * and letting the tangent carry particles round it is the mechanism —
+             * pulling them to the spine instead collapses each letter to a point, and
+             * pure tangential flow lets every particle converge onto one level set.
+             */
+            readonly field_level: {
+                readonly type: "float";
+                readonly default: 0.35;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+            };
+            readonly field_hold: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: 0;
+                readonly max: 40000;
+                readonly step: 10;
+            };
+            /**
+             * Scatter births across this box instead of on the source geometry's
+             * points, `[minX, minY, maxX, maxY]`. All zero uses the points.
+             *
+             * Houdini's POP Source has the same choice — *Scatter onto Surface* against
+             * *Points* — and Marcus's note is that the original spawns *around* the
+             * type rather than on it: *"The particles should spawn in the area around
+             * the type … and then the forces should drag them around."* Birthing on
+             * the letterforms puts every particle where it is already going, so
+             * nothing travels and the field has nothing to reveal.
+             */
+            readonly birth_area: {
+                readonly type: "vec4";
+                readonly default: readonly [0, 0, 0, 0];
+            };
+            /**
+             * A colour per particle, drawn at birth and fixed for its life.
+             *
+             * Hashed on the id, so the same particle gets the same colour however many
+             * times the frame is re-simulated — a colour drawn from a stream would
+             * change on every scrub, which reads as the render being unstable.
+             *
+             * `[from, to]` in turns around the wheel. Equal values give one hue; a
+             * narrow span is usually what a piece wants, because a full-spectrum
+             * random set reads as a test pattern rather than as a palette.
+             */
+            readonly birth_hue: {
+                readonly type: "vec2";
+                readonly default: readonly [0, 0];
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+            };
+            readonly birth_saturation: {
+                readonly type: "float";
+                readonly default: 0.6;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+            };
+            readonly birth_value: {
+                readonly type: "float";
+                readonly default: 1;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+            };
+            /** How hard the targets pull. Houdini's POP Attract strength. */
+            readonly attract_amplitude: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: 0;
+                readonly max: 20000;
+                readonly step: 1;
+            };
+            /** Beyond this distance a target is ignored, which is what keeps the pull
+             *  local and the cost bounded. 0 means every target pulls every particle. */
+            readonly attract_radius: {
+                readonly type: "float";
+                readonly default: 60;
+                readonly min: 0;
+                readonly max: 5000;
+                readonly step: 1;
+            };
+            readonly separate_radius: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: 0;
+                readonly max: 500;
+                readonly step: 0.5;
+            };
+            readonly separate_strength: {
+                readonly type: "float";
+                readonly default: 12;
+                readonly min: 0;
+                readonly max: 500;
+                readonly step: 0.5;
+            };
+            readonly maxspeed: {
+                readonly type: "float";
+                readonly default: 60;
+                readonly min: 0;
+                readonly max: 10000;
+                readonly step: 1;
+            };
+            /** `[minX, minY, maxX, maxY]`, or all zero for open space. The original
+             *  piece is toroidal. */
+            readonly wrap: {
+                readonly type: "vec4";
+                readonly default: readonly [0, 0, 0, 0];
+            };
+            readonly seed: {
+                readonly type: "int";
+                readonly default: 7;
+                readonly min: 0;
+                readonly max: 999999;
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeSimulate>;
+};
+export declare const sourceRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "POP Source";
+        readonly description: "Birth particles from a geometry's points.";
+        readonly icon: "Sparkles";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+            readonly particles: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly outputs: {
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly props: {
+            readonly impulse: {
+                readonly type: "int";
+                readonly default: 8;
+                readonly min: 0;
+                readonly max: 100000;
+            };
+            readonly life: {
+                readonly type: "float";
+                readonly default: 3;
+                readonly min: 0;
+                readonly max: 3600;
+                readonly step: 0.1;
+            };
+            readonly lifevar: {
+                readonly type: "float";
+                readonly default: 0.3;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+            };
+            readonly velocity: {
+                readonly type: "vec2";
+                readonly default: readonly [0, 0];
+            };
+            readonly seed: {
+                readonly type: "int";
+                readonly default: 7;
+                readonly min: 0;
+                readonly max: 999999;
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeSource>;
+};
+export declare const solverRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "POP Solver";
+        readonly description: "Advance a particle system by one timestep.";
+        readonly icon: "Play";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly particles: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly outputs: {
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly props: {
+            /**
+             * Where the timestep comes from. Marcus's ruling, 2026-09-09: *"Let the
+             * user choose nodes fixed or variable."*
+             *
+             * `fixed` is the default on the ordinary grounds that the safer of two
+             * behaviours is the one you get without asking - a simulation whose result
+             * depends on a playback setting is not reproducible from the document
+             * alone. With `fps` the render rate becomes part of what determines the
+             * output, which is correct for a mode called variable and must not be
+             * silent: it belongs in the cache key, and `cascade check` should say so.
+             */
+            readonly timestep_mode: {
+                readonly type: "string";
+                readonly default: "fixed";
+                readonly control: "select";
+                readonly options: readonly [{
+                    readonly value: "fixed";
+                    readonly label: "Fixed - reproducible from the document";
+                }, {
+                    readonly value: "fps";
+                    readonly label: "Variable - derived from the render rate";
+                }];
+            };
+            readonly timestep: {
+                readonly type: "float";
+                readonly default: number;
+                readonly min: number;
+                readonly max: 1;
+                readonly step: number;
+            };
+            readonly maxspeed: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: 0;
+                readonly max: 10000;
+                readonly step: 0.5;
+            };
+            readonly force: {
+                readonly type: "vec2";
+                readonly default: readonly [0, 0];
+            };
+            readonly airresist: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: 0;
+                readonly max: 20;
+                readonly step: 0.05;
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeSolver>;
+};
+export declare const noiseForceRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "POP Noise Force";
+        readonly description: "Push particles along a heading read from a noise field.";
+        readonly icon: "Wind";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly particles: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly outputs: {
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly props: {
+            readonly amplitude: {
+                readonly type: "float";
+                readonly default: 6;
+                readonly min: 0;
+                readonly max: 500;
+                readonly step: 0.5;
+            };
+            readonly frequency: {
+                readonly type: "float";
+                readonly default: 0.3;
+                readonly min: 0.001;
+                readonly max: 10;
+                readonly step: 0.01;
+            };
+            readonly evolve: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: -1000;
+                readonly max: 1000;
+                readonly step: 0.01;
+            };
+            readonly timestep: {
+                readonly type: "float";
+                readonly default: number;
+                readonly min: number;
+                readonly max: 1;
+                readonly step: number;
+            };
+            readonly seed: {
+                readonly type: "int";
+                readonly default: 7;
+                readonly min: 0;
+                readonly max: 999999;
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeNoiseForce>;
+};
+export declare const separateRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "POP Separate";
+        readonly description: "Push neighbours apart within a radius.";
+        readonly icon: "Move3d";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly particles: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly outputs: {
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly props: {
+            readonly radius: {
+                readonly type: "float";
+                readonly default: 0.5;
+                readonly min: 0;
+                readonly max: 100;
+                readonly step: 0.01;
+            };
+            readonly strength: {
+                readonly type: "float";
+                readonly default: 4;
+                readonly min: 0;
+                readonly max: 500;
+                readonly step: 0.1;
+            };
+            readonly timestep: {
+                readonly type: "float";
+                readonly default: number;
+                readonly min: number;
+                readonly max: 1;
+                readonly step: number;
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeSeparate>;
+};
+export declare const fieldForceRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "POP Field Force";
+        readonly description: "Pull particles along a field's gradient and around its contours. The calligraphy force.";
+        readonly icon: "Waves";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly particles: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+            /** The field: points carrying `N` (the gradient) and optionally `level`. */
+            readonly field: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly outputs: {
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly props: {
+            readonly normal: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: -100000;
+                readonly max: 100000;
+                readonly label: "Normal";
+                readonly description: "Along N, toward the spine. Negative pushes away.";
+            };
+            readonly tangential: {
+                readonly type: "float";
+                readonly default: 2600;
+                readonly min: -100000;
+                readonly max: 100000;
+                readonly label: "Tangential";
+                readonly description: "Perpendicular to N, around the outline. Sign picks the direction.";
+            };
+            readonly radius: {
+                readonly type: "float";
+                readonly default: 20;
+                readonly min: 0;
+                readonly max: 10000;
+                readonly label: "Radius";
+                readonly description: "How far a field sample reaches.";
+            };
+            readonly level: {
+                readonly type: "float";
+                readonly default: 0.28;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+                readonly label: "Level";
+                readonly description: "The contour to hold, rather than climbing to the peak.";
+            };
+            readonly hold: {
+                readonly type: "float";
+                readonly default: 5200;
+                readonly min: 0;
+                readonly max: 100000;
+                readonly label: "Hold";
+                readonly description: "How hard to hold that contour.";
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeFieldForce>;
+};
+export declare const trailRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "POP Trail";
+        readonly description: "Build trails from a Feedback container's history.";
+        readonly icon: "Activity";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            /** The container's `history` output: every kept step, oldest first. */
+            readonly history: {
+                readonly kind: "data";
+                readonly type: "array";
+            };
+            /** The current state, for `preserve` and for the newest point of each trail. */
+            readonly particles: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly outputs: {
+            readonly geometry: {
+                readonly kind: "data";
+                readonly type: "geometry";
+            };
+        };
+        readonly props: {
+            readonly result: {
+                readonly type: "string";
+                readonly default: "polylines";
+                readonly control: "select";
+                readonly options: readonly [{
+                    readonly value: "polylines";
+                    readonly label: "Polylines - one line per particle";
+                }, {
+                    readonly value: "preserve";
+                    readonly label: "Preserve - pass the points through";
+                }];
+                readonly label: "Result";
+            };
+            readonly length: {
+                readonly type: "int";
+                readonly default: 12;
+                readonly min: 1;
+                readonly max: 100000;
+                readonly label: "Length";
+            };
+            readonly increment: {
+                readonly type: "int";
+                readonly default: 1;
+                readonly min: 1;
+                readonly max: 1000;
+                readonly label: "Increment";
+            };
+            readonly velocityscale: {
+                readonly type: "float";
+                readonly default: 1;
+                readonly min: 0;
+                readonly max: 100;
+                readonly step: 0.01;
+                readonly label: "Velocity Scale";
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeTrail>;
+};
+export declare const popNodeRegistrations: readonly DefinitionNodeRegistration[];
+/** `[moduleId, definition]` pairs, for a host building a node palette. The
+ *  same shape `geoNodeDefinitions` has, so Studio's library builder needs no
+ *  second branch. */
+export declare const popNodeDefinitions: readonly [readonly ["cascade.pop.Simulate", {
+    readonly apiVersion: 1;
+    readonly label: "POP Simulate";
+    readonly description: "Re-simulate a particle system from frame zero to this frame.";
+    readonly icon: "Rewind";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        /** Where particles are born. Its points are the birth positions. */
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        /** The frame to simulate up to. Drive it with `$F`. An input rather than
+         *  a prop because the whole node is a function of it, and because a node
+         *  that read the clock itself would be the thing `AGENTS.md` forbids. */
+        readonly frame: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 1;
+        };
+        /**
+         * Points particles are drawn toward. Houdini's POP Attract.
+         *
+         * **Geometry rather than an image, and that was a correction.** The
+         * original piece renders its word to a canvas, blurs it, reads the pixels
+         * back and takes central differences — so its target really is a raster
+         * field, and an `image` input was the first thing tried here. It was wrong
+         * for this node: decoding an image needs a capability, the media
+         * capability hands back a host-specific lease rather than a portable
+         * raster, and a POP node doing IO stops being the pure arithmetic that
+         * makes it cook identically in both hosts.
+         *
+         * So the rasterising belongs upstream, in whatever node knows about text
+         * or photographs, and what reaches the solver is a set of target points.
+         * `fieldForce` in `pop/forces.ts` still takes a sampled raster for a node
+         * that has one; this input is the composable half.
+         */
+        readonly attract: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        /**
+         * A flow field, as points carrying `N`.
+         *
+         * Marcus's description of the original: *"a delicate balance between a
+         * force pulling the particles towards the centre spine of the type and
+         * tangentially around their outlines."* This is that field — the gradient
+         * of a BLURRED letterform, whose ridge runs down each stroke's middle, so
+         * the gradient points at the spine and its perpendicular runs along the
+         * outline. `field_normal` and `field_tangential` are the two halves of the
+         * balance.
+         */
+        readonly field: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        /** The particles, one point each. */
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        /**
+         * The trails, one open polyline per particle.
+         *
+         * Emitted here rather than by a standalone `Trail` node, and that is a
+         * consequence of re-simulation rather than a shortcut. Houdini's Trail SOP
+         * reads a rolling window the cook already holds, because Houdini's cook is
+         * stateful; Cascade's node is a pure function of its inputs, so a
+         * standalone `Trail` can only see the frame on its port — one frame, which
+         * draws nothing. This node replays every frame from zero, so it has the
+         * whole history for free, and a node that draws nothing would be worse than
+         * no node.
+         *
+         * When `CookScheduler` owns the rolling window the plan describes,
+         * `cascade.pop.Trail` becomes a real node and this output stays as the
+         * cheap path. The parameters are Houdini's either way.
+         */
+        readonly trails: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        /** Frames of history in the trails. Houdini's Trail `length`. */
+        readonly trail_length: {
+            readonly type: "int";
+            readonly default: 14;
+            readonly min: 1;
+            readonly max: 500;
+        };
+        /** Use every nth frame. Houdini's `increment`. */
+        readonly trail_increment: {
+            readonly type: "int";
+            readonly default: 1;
+            readonly min: 1;
+            readonly max: 32;
+        };
+        /**
+         * Re-simulation, and why this is the first implementation rather than a
+         * placeholder for a cached one.
+         *
+         * `PLAN particles.md`: re-simulation from the start frame is the
+         * *definition* of correctness, and a cache is an accelerator holding
+         * nothing re-simulation would not have produced. So this node is the
+         * reference: it reads a frame, replays every step from zero, and depends on
+         * no state whatsoever. Scrubbing is O(frame) and that is the honest cost —
+         * a checkpoint cache makes it fast later without changing a single output,
+         * which is exactly the property a cache should have.
+         */
+        readonly substeps: {
+            readonly type: "int";
+            readonly default: 1;
+            readonly min: 1;
+            readonly max: 32;
+        };
+        readonly timestep: {
+            readonly type: "float";
+            readonly default: number;
+            readonly min: number;
+            readonly max: 1;
+            readonly step: number;
+        };
+        /** Per frame, as on Source. */
+        readonly impulse: {
+            readonly type: "int";
+            readonly default: 6;
+            readonly min: 0;
+            readonly max: 100000;
+        };
+        readonly life: {
+            readonly type: "float";
+            readonly default: 4;
+            readonly min: 0;
+            readonly max: 3600;
+            readonly step: 0.1;
+        };
+        readonly lifevar: {
+            readonly type: "float";
+            readonly default: 0.4;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly force: {
+            readonly type: "vec2";
+            readonly default: readonly [0, 0];
+        };
+        readonly airresist: {
+            readonly type: "float";
+            readonly default: 0.4;
+            readonly min: 0;
+            readonly max: 20;
+            readonly step: 0.05;
+        };
+        readonly noise_amplitude: {
+            readonly type: "float";
+            readonly default: 14;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.5;
+        };
+        readonly noise_frequency: {
+            readonly type: "float";
+            readonly default: 0.02;
+            readonly min: 0.001;
+            readonly max: 10;
+            readonly step: 0.001;
+        };
+        /** Turns per second of field evolution. */
+        readonly noise_evolve: {
+            readonly type: "float";
+            readonly default: 0.08;
+            readonly min: -10;
+            readonly max: 10;
+            readonly step: 0.01;
+        };
+        /** Toward the spine, up the field's gradient. */
+        readonly field_normal: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: -20000;
+            readonly max: 20000;
+            readonly step: 1;
+        };
+        /** Around the outline, perpendicular to the gradient. Sign picks which way. */
+        readonly field_tangential: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: -20000;
+            readonly max: 20000;
+            readonly step: 1;
+        };
+        /** Field samples beyond this are ignored, and it is the grid's cell size. */
+        readonly field_radius: {
+            readonly type: "float";
+            readonly default: 24;
+            readonly min: 0.5;
+            readonly max: 2000;
+            readonly step: 0.5;
+        };
+        /**
+         * The contour to hold, as a field level 0..1, with `field_hold` as how
+         * firmly.
+         *
+         * Marcus: *"the lines flow tangentially around the letters in a bundle …
+         * loosely describing the type."* A bundle is a contour, so holding a level
+         * and letting the tangent carry particles round it is the mechanism —
+         * pulling them to the spine instead collapses each letter to a point, and
+         * pure tangential flow lets every particle converge onto one level set.
+         */
+        readonly field_level: {
+            readonly type: "float";
+            readonly default: 0.35;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly field_hold: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 40000;
+            readonly step: 10;
+        };
+        /**
+         * Scatter births across this box instead of on the source geometry's
+         * points, `[minX, minY, maxX, maxY]`. All zero uses the points.
+         *
+         * Houdini's POP Source has the same choice — *Scatter onto Surface* against
+         * *Points* — and Marcus's note is that the original spawns *around* the
+         * type rather than on it: *"The particles should spawn in the area around
+         * the type … and then the forces should drag them around."* Birthing on
+         * the letterforms puts every particle where it is already going, so
+         * nothing travels and the field has nothing to reveal.
+         */
+        readonly birth_area: {
+            readonly type: "vec4";
+            readonly default: readonly [0, 0, 0, 0];
+        };
+        /**
+         * A colour per particle, drawn at birth and fixed for its life.
+         *
+         * Hashed on the id, so the same particle gets the same colour however many
+         * times the frame is re-simulated — a colour drawn from a stream would
+         * change on every scrub, which reads as the render being unstable.
+         *
+         * `[from, to]` in turns around the wheel. Equal values give one hue; a
+         * narrow span is usually what a piece wants, because a full-spectrum
+         * random set reads as a test pattern rather than as a palette.
+         */
+        readonly birth_hue: {
+            readonly type: "vec2";
+            readonly default: readonly [0, 0];
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly birth_saturation: {
+            readonly type: "float";
+            readonly default: 0.6;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly birth_value: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        /** How hard the targets pull. Houdini's POP Attract strength. */
+        readonly attract_amplitude: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 20000;
+            readonly step: 1;
+        };
+        /** Beyond this distance a target is ignored, which is what keeps the pull
+         *  local and the cost bounded. 0 means every target pulls every particle. */
+        readonly attract_radius: {
+            readonly type: "float";
+            readonly default: 60;
+            readonly min: 0;
+            readonly max: 5000;
+            readonly step: 1;
+        };
+        readonly separate_radius: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.5;
+        };
+        readonly separate_strength: {
+            readonly type: "float";
+            readonly default: 12;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.5;
+        };
+        readonly maxspeed: {
+            readonly type: "float";
+            readonly default: 60;
+            readonly min: 0;
+            readonly max: 10000;
+            readonly step: 1;
+        };
+        /** `[minX, minY, maxX, maxY]`, or all zero for open space. The original
+         *  piece is toroidal. */
+        readonly wrap: {
+            readonly type: "vec4";
+            readonly default: readonly [0, 0, 0, 0];
+        };
+        readonly seed: {
+            readonly type: "int";
+            readonly default: 7;
+            readonly min: 0;
+            readonly max: 999999;
+        };
+    };
+}], readonly ["cascade.pop.Source", {
+    readonly apiVersion: 1;
+    readonly label: "POP Source";
+    readonly description: "Birth particles from a geometry's points.";
+    readonly icon: "Sparkles";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly impulse: {
+            readonly type: "int";
+            readonly default: 8;
+            readonly min: 0;
+            readonly max: 100000;
+        };
+        readonly life: {
+            readonly type: "float";
+            readonly default: 3;
+            readonly min: 0;
+            readonly max: 3600;
+            readonly step: 0.1;
+        };
+        readonly lifevar: {
+            readonly type: "float";
+            readonly default: 0.3;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        readonly velocity: {
+            readonly type: "vec2";
+            readonly default: readonly [0, 0];
+        };
+        readonly seed: {
+            readonly type: "int";
+            readonly default: 7;
+            readonly min: 0;
+            readonly max: 999999;
+        };
+    };
+}], readonly ["cascade.pop.Solver", {
+    readonly apiVersion: 1;
+    readonly label: "POP Solver";
+    readonly description: "Advance a particle system by one timestep.";
+    readonly icon: "Play";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        /**
+         * Where the timestep comes from. Marcus's ruling, 2026-09-09: *"Let the
+         * user choose nodes fixed or variable."*
+         *
+         * `fixed` is the default on the ordinary grounds that the safer of two
+         * behaviours is the one you get without asking - a simulation whose result
+         * depends on a playback setting is not reproducible from the document
+         * alone. With `fps` the render rate becomes part of what determines the
+         * output, which is correct for a mode called variable and must not be
+         * silent: it belongs in the cache key, and `cascade check` should say so.
+         */
+        readonly timestep_mode: {
+            readonly type: "string";
+            readonly default: "fixed";
+            readonly control: "select";
+            readonly options: readonly [{
+                readonly value: "fixed";
+                readonly label: "Fixed - reproducible from the document";
+            }, {
+                readonly value: "fps";
+                readonly label: "Variable - derived from the render rate";
+            }];
+        };
+        readonly timestep: {
+            readonly type: "float";
+            readonly default: number;
+            readonly min: number;
+            readonly max: 1;
+            readonly step: number;
+        };
+        readonly maxspeed: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 10000;
+            readonly step: 0.5;
+        };
+        readonly force: {
+            readonly type: "vec2";
+            readonly default: readonly [0, 0];
+        };
+        readonly airresist: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly max: 20;
+            readonly step: 0.05;
+        };
+    };
+}], readonly ["cascade.pop.NoiseForce", {
+    readonly apiVersion: 1;
+    readonly label: "POP Noise Force";
+    readonly description: "Push particles along a heading read from a noise field.";
+    readonly icon: "Wind";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly amplitude: {
+            readonly type: "float";
+            readonly default: 6;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.5;
+        };
+        readonly frequency: {
+            readonly type: "float";
+            readonly default: 0.3;
+            readonly min: 0.001;
+            readonly max: 10;
+            readonly step: 0.01;
+        };
+        readonly evolve: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: -1000;
+            readonly max: 1000;
+            readonly step: 0.01;
+        };
+        readonly timestep: {
+            readonly type: "float";
+            readonly default: number;
+            readonly min: number;
+            readonly max: 1;
+            readonly step: number;
+        };
+        readonly seed: {
+            readonly type: "int";
+            readonly default: 7;
+            readonly min: 0;
+            readonly max: 999999;
+        };
+    };
+}], readonly ["cascade.pop.Separate", {
+    readonly apiVersion: 1;
+    readonly label: "POP Separate";
+    readonly description: "Push neighbours apart within a radius.";
+    readonly icon: "Move3d";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly radius: {
+            readonly type: "float";
+            readonly default: 0.5;
+            readonly min: 0;
+            readonly max: 100;
+            readonly step: 0.01;
+        };
+        readonly strength: {
+            readonly type: "float";
+            readonly default: 4;
+            readonly min: 0;
+            readonly max: 500;
+            readonly step: 0.1;
+        };
+        readonly timestep: {
+            readonly type: "float";
+            readonly default: number;
+            readonly min: number;
+            readonly max: 1;
+            readonly step: number;
+        };
+    };
+}], readonly ["cascade.pop.FieldForce", {
+    readonly apiVersion: 1;
+    readonly label: "POP Field Force";
+    readonly description: "Pull particles along a field's gradient and around its contours. The calligraphy force.";
+    readonly icon: "Waves";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+        /** The field: points carrying `N` (the gradient) and optionally `level`. */
+        readonly field: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly normal: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: -100000;
+            readonly max: 100000;
+            readonly label: "Normal";
+            readonly description: "Along N, toward the spine. Negative pushes away.";
+        };
+        readonly tangential: {
+            readonly type: "float";
+            readonly default: 2600;
+            readonly min: -100000;
+            readonly max: 100000;
+            readonly label: "Tangential";
+            readonly description: "Perpendicular to N, around the outline. Sign picks the direction.";
+        };
+        readonly radius: {
+            readonly type: "float";
+            readonly default: 20;
+            readonly min: 0;
+            readonly max: 10000;
+            readonly label: "Radius";
+            readonly description: "How far a field sample reaches.";
+        };
+        readonly level: {
+            readonly type: "float";
+            readonly default: 0.28;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+            readonly label: "Level";
+            readonly description: "The contour to hold, rather than climbing to the peak.";
+        };
+        readonly hold: {
+            readonly type: "float";
+            readonly default: 5200;
+            readonly min: 0;
+            readonly max: 100000;
+            readonly label: "Hold";
+            readonly description: "How hard to hold that contour.";
+        };
+    };
+}], readonly ["cascade.pop.Trail", {
+    readonly apiVersion: 1;
+    readonly label: "POP Trail";
+    readonly description: "Build trails from a Feedback container's history.";
+    readonly icon: "Activity";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        /** The container's `history` output: every kept step, oldest first. */
+        readonly history: {
+            readonly kind: "data";
+            readonly type: "array";
+        };
+        /** The current state, for `preserve` and for the newest point of each trail. */
+        readonly particles: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly outputs: {
+        readonly geometry: {
+            readonly kind: "data";
+            readonly type: "geometry";
+        };
+    };
+    readonly props: {
+        readonly result: {
+            readonly type: "string";
+            readonly default: "polylines";
+            readonly control: "select";
+            readonly options: readonly [{
+                readonly value: "polylines";
+                readonly label: "Polylines - one line per particle";
+            }, {
+                readonly value: "preserve";
+                readonly label: "Preserve - pass the points through";
+            }];
+            readonly label: "Result";
+        };
+        readonly length: {
+            readonly type: "int";
+            readonly default: 12;
+            readonly min: 1;
+            readonly max: 100000;
+            readonly label: "Length";
+        };
+        readonly increment: {
+            readonly type: "int";
+            readonly default: 1;
+            readonly min: 1;
+            readonly max: 1000;
+            readonly label: "Increment";
+        };
+        readonly velocityscale: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0;
+            readonly max: 100;
+            readonly step: 0.01;
+            readonly label: "Velocity Scale";
+        };
+    };
+}]];
+export {};
+//# sourceMappingURL=definitions.d.ts.map