@field/cascade 0.10.0 → 0.12.0

package/dist/cli/chunk-KH4MUBKF.js

@@ -0,0 +1,1551 @@
+import {
+  GeometryBuilder,
+  createAttribute
+} from "./chunk-HSNOBIVT.js";
+import {
+  POSITION_ATTRIBUTE
+} from "./chunk-J7VK7MNF.js";
+
+// packages/contracts/src/particles.ts
+var P = {
+  name: POSITION_ATTRIBUTE,
+  level: "point",
+  storage: "f64",
+  size: [2, 3],
+  required: true,
+  note: "Position. Shared with every other geometry node, not a particle attribute."
+};
+var PARTICLE_ATTRIBUTES = Object.freeze([
+  P,
+  {
+    name: "v",
+    level: "point",
+    storage: "f32",
+    size: [2, 3],
+    required: true,
+    note: "Velocity, in units per second. f32 rather than f64: a velocity is not a coordinate, so the precision argument for P does not carry over."
+  },
+  {
+    name: "age",
+    level: "point",
+    storage: "f32",
+    size: 1,
+    required: true,
+    units: "seconds",
+    // The one place this departs from the sketch it is modelled on.
+    note: "Seconds, not frames. A frame count changes meaning with fps, and a graph whose particles die at a different point when rendered at 60 is not deterministic in any useful sense."
+  },
+  {
+    name: "life",
+    level: "point",
+    storage: "f32",
+    size: 1,
+    required: true,
+    units: "seconds",
+    note: "Life expectancy in seconds. A particle dies when age >= life."
+  },
+  {
+    name: "id",
+    level: "point",
+    storage: "i32",
+    size: 1,
+    required: true,
+    note: "Stable across frames and across kills. Mandatory: a particle array reorders on every kill, so anything durable and per-particle must key on this rather than on an index."
+  },
+  {
+    name: "nextid",
+    level: "detail",
+    storage: "i32",
+    size: 1,
+    required: true,
+    note: "The next id to hand out. Houdini's own mechanism for keeping id monotonic, and what stops an id being reused after a kill."
+  },
+  {
+    name: "Cd",
+    level: "point",
+    storage: "f32",
+    size: 4,
+    required: false,
+    note: "Colour. Owned by the style vocabulary in PLAN geometry, which refuses a Cd that is a string or numeric with any size but four."
+  },
+  {
+    name: "pscale",
+    level: "point",
+    storage: "f32",
+    size: 1,
+    required: false,
+    note: "Not a POP attribute in Houdini's sense. Writing it is what makes CopyToPoints scale its instances, which is how oriented marks get drawn without a new node."
+  },
+  {
+    name: "N",
+    level: "point",
+    storage: "f32",
+    size: [2, 3],
+    required: false,
+    note: "Orientation, read by CopyToPoints alongside pscale."
+  }
+]);
+var BY_NAME = new Map(
+  PARTICLE_ATTRIBUTES.map((spec) => [spec.name, spec])
+);
+function sizeMatches(spec, size) {
+  return typeof spec.size === "number" ? size === spec.size : size >= spec.size[0] && size <= spec.size[1];
+}
+function describeSize(spec) {
+  return typeof spec.size === "number" ? String(spec.size) : `${spec.size[0]} or ${spec.size[1]}`;
+}
+function checkParticleContract(geometry) {
+  const violations = [];
+  for (const spec of PARTICLE_ATTRIBUTES) {
+    if (spec.level === "detail") {
+      const value = geometry.detail[spec.name];
+      if (value === void 0) {
+        if (spec.required) {
+          violations.push({
+            attribute: spec.name,
+            reason: `missing detail attribute ${spec.name} \u2014 ${spec.note}`
+          });
+        }
+        continue;
+      }
+      if (typeof value !== "number") {
+        violations.push({
+          attribute: spec.name,
+          reason: `detail ${spec.name} must be a number, not ${typeof value}`
+        });
+      }
+      continue;
+    }
+    const attribute = geometry.point[spec.name];
+    if (attribute === void 0) {
+      if (spec.required) {
+        violations.push({
+          attribute: spec.name,
+          reason: `missing point attribute ${spec.name} \u2014 ${spec.note}`
+        });
+      }
+      continue;
+    }
+    if (attribute.storage === "string") {
+      violations.push({
+        attribute: spec.name,
+        reason: `${spec.name} is a string attribute; a solver reads it as ${spec.storage}`
+      });
+      continue;
+    }
+    if (!sizeMatches(spec, attribute.size)) {
+      violations.push({
+        attribute: spec.name,
+        reason: `${spec.name} has size ${attribute.size}; expected ${describeSize(spec)}`
+      });
+    }
+  }
+  return violations;
+}
+
+// packages/runtime/src/pop/state.ts
+var ParticleState = class _ParticleState {
+  /**
+   * Internal, and taking the arrays by reference rather than copying.
+   *
+   * `@internal` rather than `private` because `step` and `select` are module
+   * functions rather than methods — they are the arithmetic, and putting them
+   * on the class would make a state object that can step itself, which is one
+   * short hop from a state object that holds a clock.
+   *
+   * @internal
+   */
+  static of(fields) {
+    return new _ParticleState(fields);
+  }
+  constructor(fields) {
+    this.count = fields.count;
+    this.size = fields.size;
+    this.position = fields.position;
+    this.velocity = fields.velocity;
+    this.age = fields.age;
+    this.life = fields.life;
+    this.id = fields.id;
+    this.colour = fields.colour ?? null;
+    this.nextId = fields.nextId;
+  }
+  /** An empty system. `nextId` starts at 0 and only ever increases. */
+  static empty(size = 2) {
+    return new _ParticleState({
+      count: 0,
+      size,
+      position: new Float64Array(0),
+      velocity: new Float32Array(0),
+      age: new Float32Array(0),
+      life: new Float32Array(0),
+      id: new Int32Array(0),
+      colour: null,
+      nextId: 0
+    });
+  }
+  /**
+   * Read a state out of a geometry.
+   *
+   * Refuses rather than repairs. `checkParticleContract` returns every
+   * violation, and a solver handed a geometry without `id` cannot invent one:
+   * inventing ids per frame is precisely the fault the mandatory `id` exists to
+   * prevent, because it would silently make every particle new every step.
+   */
+  static fromGeometry(geometry) {
+    const violations = checkParticleContract(geometry);
+    if (violations.length > 0) {
+      throw new Error(
+        `not a particle geometry: ${violations.map((v) => v.reason).join("; ")}`
+      );
+    }
+    const position = geometry.point[POSITION_ATTRIBUTE];
+    const velocity = geometry.point.v;
+    return new _ParticleState({
+      count: geometry.pointCount,
+      size: position.size,
+      position: Float64Array.from(position.data),
+      velocity: Float32Array.from(velocity.data),
+      age: Float32Array.from(geometry.point.age.data),
+      life: Float32Array.from(geometry.point.life.data),
+      id: Int32Array.from(geometry.point.id.data),
+      colour: geometry.point.Cd && geometry.point.Cd.storage !== "string" ? Float32Array.from(geometry.point.Cd.data) : null,
+      nextId: Number(geometry.detail.nextid ?? geometry.pointCount)
+    });
+  }
+  /** Write the state back out as geometry, one point per particle. */
+  toGeometry() {
+    const builder = new GeometryBuilder({ positionSize: this.size });
+    for (let index = 0; index < this.count; index += 1) {
+      builder.addPoint(
+        this.position[index * this.size],
+        this.position[index * this.size + 1],
+        this.size === 3 ? this.position[index * this.size + 2] : 0
+      );
+    }
+    builder.setAttribute("point", "v", { storage: "f32", size: this.size, data: this.velocity });
+    builder.setAttribute("point", "age", { storage: "f32", size: 1, data: this.age });
+    builder.setAttribute("point", "life", { storage: "f32", size: 1, data: this.life });
+    builder.setAttribute("point", "id", { storage: "i32", size: 1, data: this.id });
+    if (this.colour) {
+      builder.setAttribute("point", "Cd", { storage: "f32", size: 4, data: this.colour });
+    }
+    builder.setDetail("nextid", this.nextId);
+    return builder.build();
+  }
+  /** Add particles, handing each a fresh id. Returns the new state; the
+   *  receiver is not mutated, so a source can be applied to a cached frame. */
+  born(points) {
+    const added = points.life.length;
+    if (added === 0) return this;
+    const count = this.count + added;
+    const position = new Float64Array(count * this.size);
+    const velocity = new Float32Array(count * this.size);
+    const age = new Float32Array(count);
+    const life = new Float32Array(count);
+    const id = new Int32Array(count);
+    const wantsColour = this.colour !== null || points.colour !== void 0;
+    const colour = wantsColour ? new Float32Array(count * 4) : null;
+    if (colour) {
+      colour.fill(1, 0, this.count * 4);
+      if (this.colour) colour.set(this.colour);
+    }
+    position.set(this.position);
+    velocity.set(this.velocity);
+    age.set(this.age);
+    life.set(this.life);
+    id.set(this.id);
+    for (let index = 0; index < added; index += 1) {
+      const at = this.count + index;
+      for (let component = 0; component < this.size; component += 1) {
+        position[at * this.size + component] = points.position[index * this.size + component] ?? 0;
+        velocity[at * this.size + component] = points.velocity?.[index * this.size + component] ?? 0;
+      }
+      life[at] = points.life[index];
+      if (colour) {
+        for (let channel = 0; channel < 4; channel += 1) {
+          colour[at * 4 + channel] = points.colour ? Number(points.colour[index * 4 + channel] ?? 1) : 1;
+        }
+      }
+      id[at] = this.nextId + index;
+    }
+    return _ParticleState.of({
+      count,
+      size: this.size,
+      position,
+      velocity,
+      age,
+      life,
+      id,
+      colour,
+      nextId: this.nextId + added
+    });
+  }
+};
+function step(state, forces, options) {
+  const { timestep, maxSpeed = 0, wrap } = options;
+  const { count, size } = state;
+  if (count === 0) return state;
+  const acceleration = new Float32Array(count * size);
+  for (const force of forces) {
+    const contribution = force.accelerate(state, size);
+    if (contribution.length !== count * size) {
+      throw new Error(
+        `force ${force.label} returned ${contribution.length} values for ${count} particles of size ${size}`
+      );
+    }
+    for (let index = 0; index < acceleration.length; index += 1) {
+      acceleration[index] = acceleration[index] + contribution[index];
+    }
+  }
+  const position = Float64Array.from(state.position);
+  const velocity = Float32Array.from(state.velocity);
+  const age = Float32Array.from(state.age);
+  for (let index = 0; index < count; index += 1) {
+    let speedSquared = 0;
+    for (let component = 0; component < size; component += 1) {
+      const at = index * size + component;
+      velocity[at] = velocity[at] + acceleration[at] * timestep;
+      speedSquared += velocity[at] * velocity[at];
+    }
+    if (maxSpeed > 0 && speedSquared > maxSpeed * maxSpeed) {
+      const scale = maxSpeed / Math.sqrt(speedSquared);
+      for (let component = 0; component < size; component += 1) {
+        velocity[index * size + component] = velocity[index * size + component] * scale;
+      }
+    }
+    for (let component = 0; component < size; component += 1) {
+      const at = index * size + component;
+      position[at] = position[at] + velocity[at] * timestep;
+    }
+    if (wrap) {
+      position[index * size] = wrapInto(position[index * size], wrap[0], wrap[2]);
+      position[index * size + 1] = wrapInto(position[index * size + 1], wrap[1], wrap[3]);
+    }
+    age[index] = age[index] + timestep;
+  }
+  return kill(ParticleState.of({
+    count,
+    size: state.size,
+    position,
+    velocity,
+    age,
+    life: Float32Array.from(state.life),
+    id: Int32Array.from(state.id),
+    colour: state.colour ? Float32Array.from(state.colour) : null,
+    nextId: state.nextId
+  }));
+}
+function wrapInto(value, low, high) {
+  const span = high - low;
+  if (span <= 0) return value;
+  return low + ((value - low) % span + span) % span;
+}
+function kill(state) {
+  const keep = [];
+  for (let index = 0; index < state.count; index += 1) {
+    const life = state.life[index];
+    if (life <= 0 || state.age[index] < life) keep.push(index);
+  }
+  if (keep.length === state.count) return state;
+  return select(state, keep);
+}
+function select(state, indices) {
+  const count = indices.length;
+  const { size } = state;
+  const position = new Float64Array(count * size);
+  const velocity = new Float32Array(count * size);
+  const age = new Float32Array(count);
+  const life = new Float32Array(count);
+  const id = new Int32Array(count);
+  const colour = state.colour ? new Float32Array(count * 4) : null;
+  indices.forEach((from, to) => {
+    for (let component = 0; component < size; component += 1) {
+      position[to * size + component] = state.position[from * size + component];
+      velocity[to * size + component] = state.velocity[from * size + component];
+    }
+    age[to] = state.age[from];
+    life[to] = state.life[from];
+    id[to] = state.id[from];
+    if (colour && state.colour) {
+      for (let channel = 0; channel < 4; channel += 1) {
+        colour[to * 4 + channel] = state.colour[from * 4 + channel];
+      }
+    }
+  });
+  return ParticleState.of({
+    count,
+    size,
+    position,
+    velocity,
+    age,
+    life,
+    id,
+    colour,
+    nextId: state.nextId
+  });
+}
+function emptyParticleGeometry(size = 2) {
+  const builder = new GeometryBuilder({ positionSize: size });
+  builder.setAttribute("point", "v", createAttribute(0, size, "f32"));
+  builder.setAttribute("point", "age", createAttribute(0, 1, "f32"));
+  builder.setAttribute("point", "life", createAttribute(0, 1, "f32"));
+  builder.setAttribute("point", "id", createAttribute(0, 1, "i32"));
+  builder.setDetail("nextid", 0);
+  return builder.build();
+}
+
+// packages/runtime/src/pop/cache.ts
+var DEFAULT_STRIDE = 8;
+var MAX_CHECKPOINTS = 64;
+var entries = /* @__PURE__ */ new Map();
+var clock = 0;
+function cloneState(state) {
+  return ParticleState.of({
+    count: state.count,
+    size: state.size,
+    position: Float64Array.from(state.position),
+    velocity: Float32Array.from(state.velocity),
+    age: Float32Array.from(state.age),
+    life: Float32Array.from(state.life),
+    id: Int32Array.from(state.id),
+    ...state.colour ? { colour: Float32Array.from(state.colour) } : {},
+    nextId: state.nextId
+  });
+}
+function checkpointAtOrBefore(key, fingerprint, frame) {
+  const entry = entries.get(key);
+  if (!entry) return null;
+  if (entry.fingerprint !== fingerprint) {
+    entries.delete(key);
+    return null;
+  }
+  entry.touched = clock += 1;
+  let best = null;
+  for (const checkpoint of entry.checkpoints) {
+    if (checkpoint.frame > frame) break;
+    best = checkpoint;
+  }
+  return best ? { frame: best.frame, state: cloneState(best.state) } : null;
+}
+function offerCheckpoint(key, fingerprint, frame, state, stride = DEFAULT_STRIDE) {
+  if (frame % stride !== 0) return;
+  let entry = entries.get(key);
+  if (!entry || entry.fingerprint !== fingerprint) {
+    entry = { fingerprint, checkpoints: [], touched: clock += 1 };
+    entries.set(key, entry);
+  }
+  if (entry.checkpoints.some((checkpoint) => checkpoint.frame === frame)) return;
+  entry.checkpoints.push({ frame, state: cloneState(state) });
+  entry.checkpoints.sort((a, b) => a.frame - b.frame);
+  entry.touched = clock += 1;
+  evict();
+}
+function evict() {
+  let total = 0;
+  for (const entry of entries.values()) total += entry.checkpoints.length;
+  while (total > MAX_CHECKPOINTS && entries.size > 1) {
+    let oldest = null;
+    let oldestTouched = Infinity;
+    for (const [key, entry] of entries) {
+      if (entry.touched < oldestTouched) {
+        oldestTouched = entry.touched;
+        oldest = key;
+      }
+    }
+    if (oldest === null) return;
+    total -= entries.get(oldest).checkpoints.length;
+    entries.delete(oldest);
+  }
+  if (total > MAX_CHECKPOINTS) {
+    const remaining = entries.values().next().value;
+    if (!remaining) return;
+    remaining.checkpoints.splice(0, total - MAX_CHECKPOINTS);
+  }
+}
+
+// packages/runtime/src/pop/forces.ts
+function gravity(force) {
+  return {
+    label: "gravity",
+    accelerate(state, size) {
+      const out = new Float32Array(state.count * size);
+      for (let index = 0; index < state.count; index += 1) {
+        for (let component = 0; component < size; component += 1) {
+          out[index * size + component] = force[component] ?? 0;
+        }
+      }
+      return out;
+    }
+  };
+}
+function drag(airresist) {
+  return {
+    label: "drag",
+    accelerate(state, size) {
+      const out = new Float32Array(state.count * size);
+      for (let index = 0; index < out.length; index += 1) {
+        out[index] = -state.velocity[index] * airresist;
+      }
+      return out;
+    }
+  };
+}
+function noiseField(options) {
+  const { seed, frequency, amplitude, evolve = 0 } = options;
+  return {
+    label: "noiseField",
+    accelerate(state, size) {
+      const out = new Float32Array(state.count * size);
+      for (let index = 0; index < state.count; index += 1) {
+        const x = state.position[index * size] * frequency;
+        const y = state.position[index * size + 1] * frequency;
+        const heading = valueNoise(seed, x, y, evolve) * Math.PI * 2;
+        out[index * size] = Math.cos(heading) * amplitude;
+        out[index * size + 1] = Math.sin(heading) * amplitude;
+      }
+      return out;
+    }
+  };
+}
+function separation(options) {
+  const { radius, strength } = options;
+  return {
+    label: "separation",
+    accelerate(state, size) {
+      const out = new Float32Array(state.count * size);
+      if (radius <= 0 || strength === 0) return out;
+      const cell = radius;
+      const buckets = /* @__PURE__ */ new Map();
+      const key = (x, y) => `${Math.floor(x / cell)}:${Math.floor(y / cell)}`;
+      for (let index = 0; index < state.count; index += 1) {
+        const k = key(state.position[index * size], state.position[index * size + 1]);
+        const bucket = buckets.get(k);
+        if (bucket) bucket.push(index);
+        else buckets.set(k, [index]);
+      }
+      for (let index = 0; index < state.count; index += 1) {
+        const px = state.position[index * size];
+        const py = state.position[index * size + 1];
+        const cx = Math.floor(px / cell);
+        const cy = Math.floor(py / cell);
+        let ax = 0;
+        let ay = 0;
+        for (let ox = -1; ox <= 1; ox += 1) {
+          for (let oy = -1; oy <= 1; oy += 1) {
+            const bucket = buckets.get(`${cx + ox}:${cy + oy}`);
+            if (!bucket) continue;
+            for (const other of bucket) {
+              if (other === index) continue;
+              const dx = px - state.position[other * size];
+              const dy = py - state.position[other * size + 1];
+              const distanceSquared = dx * dx + dy * dy;
+              if (distanceSquared === 0 || distanceSquared > radius * radius) continue;
+              const distance = Math.sqrt(distanceSquared);
+              const falloff = (1 - distance / radius) / distance;
+              ax += dx * falloff;
+              ay += dy * falloff;
+            }
+          }
+        }
+        out[index * size] = ax * strength;
+        out[index * size + 1] = ay * strength;
+      }
+      return out;
+    }
+  };
+}
+function valueNoise(seed, x, y, z = 0) {
+  const x0 = Math.floor(x);
+  const y0 = Math.floor(y);
+  const z0 = Math.floor(z);
+  const fx = smooth(x - x0);
+  const fy = smooth(y - y0);
+  const fz = smooth(z - z0);
+  let value = 0;
+  for (let dz = 0; dz <= 1; dz += 1) {
+    for (let dy = 0; dy <= 1; dy += 1) {
+      for (let dx = 0; dx <= 1; dx += 1) {
+        const weight = (dx === 0 ? 1 - fx : fx) * (dy === 0 ? 1 - fy : fy) * (dz === 0 ? 1 - fz : fz);
+        value += hash(seed, x0 + dx, y0 + dy, z0 + dz) * weight;
+      }
+    }
+  }
+  return value;
+}
+function smooth(t) {
+  return t * t * (3 - 2 * t);
+}
+function hash(seed, x, y, z) {
+  const n = Math.sin(seed * 12.9898 + x * 78.233 + y * 37.719 + z * 19.371) * 43758.5453;
+  return n - Math.floor(n);
+}
+function attract(options) {
+  const { targets, targetSize, targetCount, amplitude, radius } = options;
+  const cell = radius > 0 ? radius : 0;
+  const buckets = /* @__PURE__ */ new Map();
+  if (cell > 0) {
+    for (let target = 0; target < targetCount; target += 1) {
+      const key = bucketKey(
+        Number(targets[target * targetSize]),
+        Number(targets[target * targetSize + 1]),
+        cell
+      );
+      const bucket = buckets.get(key);
+      if (bucket) bucket.push(target);
+      else buckets.set(key, [target]);
+    }
+  }
+  return {
+    label: "attract",
+    accelerate(state, size) {
+      const out = new Float32Array(state.count * size);
+      if (amplitude === 0 || targetCount === 0) return out;
+      const limit = radius > 0 ? radius * radius : Infinity;
+      for (let index = 0; index < state.count; index += 1) {
+        const px = state.position[index * size];
+        const py = state.position[index * size + 1];
+        let ax = 0;
+        let ay = 0;
+        let pulls = 0;
+        const consider = (target) => {
+          const dx = Number(targets[target * targetSize]) - px;
+          const dy = Number(targets[target * targetSize + 1]) - py;
+          const distanceSquared = dx * dx + dy * dy;
+          if (distanceSquared === 0 || distanceSquared > limit) return;
+          const distance = Math.sqrt(distanceSquared);
+          const falloff = radius > 0 ? (1 - distance / radius) / distance : 1 / distance;
+          ax += dx * falloff;
+          ay += dy * falloff;
+          pulls += 1;
+        };
+        if (cell > 0) {
+          const cx = Math.floor(px / cell);
+          const cy = Math.floor(py / cell);
+          for (let ox = -1; ox <= 1; ox += 1) {
+            for (let oy = -1; oy <= 1; oy += 1) {
+              const bucket = buckets.get(`${cx + ox}:${cy + oy}`);
+              if (!bucket) continue;
+              for (const target of bucket) consider(target);
+            }
+          }
+        } else {
+          for (let target = 0; target < targetCount; target += 1) consider(target);
+        }
+        if (pulls === 0) continue;
+        out[index * size] = ax / pulls * amplitude;
+        out[index * size + 1] = ay / pulls * amplitude;
+      }
+      return out;
+    }
+  };
+}
+function bucketKey(x, y, cell) {
+  return `${Math.floor(x / cell)}:${Math.floor(y / cell)}`;
+}
+function flowField(options) {
+  const {
+    positions,
+    positionSize,
+    directions,
+    levels,
+    count,
+    normal,
+    tangential,
+    radius,
+    level = 0,
+    hold = 0
+  } = options;
+  const cell = radius > 0 ? radius : 1;
+  const buckets = /* @__PURE__ */ new Map();
+  for (let sample = 0; sample < count; sample += 1) {
+    const key = bucketKey(
+      Number(positions[sample * positionSize]),
+      Number(positions[sample * positionSize + 1]),
+      cell
+    );
+    const bucket = buckets.get(key);
+    if (bucket) bucket.push(sample);
+    else buckets.set(key, [sample]);
+  }
+  return {
+    label: "flowField",
+    accelerate(state, size) {
+      const out = new Float32Array(state.count * size);
+      if (count === 0 || normal === 0 && tangential === 0) return out;
+      const limit = radius * radius;
+      for (let index = 0; index < state.count; index += 1) {
+        const px = state.position[index * size];
+        const py = state.position[index * size + 1];
+        const cx = Math.floor(px / cell);
+        const cy = Math.floor(py / cell);
+        let gx = 0;
+        let gy = 0;
+        let levelSum = 0;
+        let weightSum = 0;
+        for (let ox = -1; ox <= 1; ox += 1) {
+          for (let oy = -1; oy <= 1; oy += 1) {
+            const bucket = buckets.get(`${cx + ox}:${cy + oy}`);
+            if (!bucket) continue;
+            for (const sample of bucket) {
+              const dx = Number(positions[sample * positionSize]) - px;
+              const dy = Number(positions[sample * positionSize + 1]) - py;
+              const distanceSquared = dx * dx + dy * dy;
+              if (distanceSquared > limit) continue;
+              const weight = 1 - Math.sqrt(distanceSquared) / radius;
+              if (weight <= 0) continue;
+              gx += Number(directions[sample * 2]) * weight;
+              gy += Number(directions[sample * 2 + 1]) * weight;
+              if (levels) levelSum += Number(levels[sample]) * weight;
+              weightSum += weight;
+            }
+          }
+        }
+        if (weightSum === 0) continue;
+        gx /= weightSum;
+        gy /= weightSum;
+        const climb = levels && hold !== 0 ? normal + (level - levelSum / weightSum) * hold : normal;
+        out[index * size] = gx * climb - gy * tangential;
+        out[index * size + 1] = gy * climb + gx * tangential;
+      }
+      return out;
+    }
+  };
+}
+function accumulateForce(geometry, contribution, size) {
+  const count = geometry.pointCount;
+  if (contribution.length !== count * size)
+    throw new Error(
+      `force contribution has ${contribution.length} values for ${count} particles of size ${size}`
+    );
+  const existing = geometry.point.force;
+  const total = new Float32Array(count * size);
+  if (existing && existing.storage !== "string" && existing.size === size)
+    for (let index = 0; index < total.length; index += 1)
+      total[index] = Number(existing.data[index] ?? 0);
+  for (let index = 0; index < total.length; index += 1)
+    total[index] = total[index] + contribution[index];
+  return {
+    ...geometry,
+    point: {
+      ...geometry.point,
+      force: { storage: "f32", size, data: total }
+    }
+  };
+}
+function forceAttribute(geometry) {
+  const stored = geometry.point.force;
+  const data = stored && stored.storage !== "string" ? stored.data : void 0;
+  const storedSize = stored?.size ?? 0;
+  return {
+    label: "force",
+    accelerate: (state, size) => {
+      const out = new Float32Array(state.count * size);
+      if (!data) return out;
+      const shared = Math.min(size, storedSize);
+      for (let point = 0; point < state.count; point += 1)
+        for (let axis = 0; axis < shared; axis += 1)
+          out[point * size + axis] = Number(data[point * storedSize + axis] ?? 0);
+      return out;
+    }
+  };
+}
+function clearForce(geometry) {
+  if (!geometry.point.force) return geometry;
+  const { force: _dropped, ...rest } = geometry.point;
+  return { ...geometry, point: rest };
+}
+
+// packages/runtime/src/pop/trail.ts
+function trailFrame(geometry) {
+  const position = geometry.point[POSITION_ATTRIBUTE];
+  return {
+    id: Int32Array.from(geometry.point.id?.data ?? new Int32Array(0)),
+    position: Float64Array.from(position.data),
+    size: position.size
+  };
+}
+function buildTrails(history, current, options = {}) {
+  const { result = "polylines", length = 12, increment = 1, velocityscale = 1 } = options;
+  if (result === "preserve") return current;
+  const frames = sampled(history, length, increment);
+  const size = frames[0]?.size ?? 2;
+  const paths = /* @__PURE__ */ new Map();
+  for (const frame of frames) {
+    for (let index = 0; index < frame.id.length; index += 1) {
+      const id = frame.id[index];
+      const path = paths.get(id) ?? [];
+      path.push(
+        frame.position[index * frame.size],
+        frame.position[index * frame.size + 1]
+      );
+      paths.set(id, path);
+    }
+  }
+  if (result === "velocity") {
+    return withDerivedVelocity(current, paths, velocityscale);
+  }
+  const builder = new GeometryBuilder({ positionSize: 2 });
+  const trailIds = [];
+  for (const [id, path] of paths) {
+    if (path.length < 4) continue;
+    const points = [];
+    for (let at = 0; at < path.length; at += 2) {
+      points.push(builder.addPoint(path[at], path[at + 1]));
+    }
+    builder.addPrimitive(points, { closed: false, kind: "poly" });
+    trailIds.push(id);
+  }
+  if (trailIds.length > 0) {
+    builder.setNumericAttribute("primitive", "id", Int32Array.from(trailIds), 1, "i32");
+    const currentColour = current.point.Cd;
+    if (currentColour && currentColour.storage !== "string") {
+      const byId = /* @__PURE__ */ new Map();
+      const ids = current.point.id?.data;
+      if (ids) {
+        for (let index = 0; index < current.pointCount; index += 1) {
+          byId.set(Number(ids[index]), index);
+        }
+      }
+      const source = currentColour.data;
+      const colours = new Float32Array(trailIds.length * 4);
+      colours.fill(1);
+      trailIds.forEach((id, primitive) => {
+        const at = byId.get(id);
+        if (at === void 0) return;
+        for (let channel = 0; channel < 4; channel += 1) {
+          colours[primitive * 4 + channel] = Number(source[at * 4 + channel] ?? 1);
+        }
+      });
+      builder.setNumericAttribute("primitive", "Cd", colours, 4, "f32");
+    }
+  }
+  void size;
+  return builder.build();
+}
+function sampled(history, length, increment) {
+  const step2 = Math.max(1, Math.floor(increment));
+  const window = history.slice(Math.max(0, history.length - length * step2));
+  if (step2 === 1) return window;
+  const picked = [];
+  for (let index = window.length - 1; index >= 0; index -= step2) picked.unshift(window[index]);
+  return picked;
+}
+function withDerivedVelocity(current, paths, velocityscale) {
+  const size = current.point[POSITION_ATTRIBUTE].size;
+  const ids = current.point.id?.data;
+  const velocity = new Float32Array(current.pointCount * size);
+  for (let index = 0; index < current.pointCount; index += 1) {
+    const path = ids ? paths.get(Number(ids[index])) : void 0;
+    if (!path || path.length < 4) continue;
+    const last = path.length;
+    velocity[index * size] = (path[last - 2] - path[last - 4]) * velocityscale;
+    velocity[index * size + 1] = (path[last - 1] - path[last - 3]) * velocityscale;
+  }
+  return {
+    ...current,
+    point: { ...current.point, v: { storage: "f32", size, data: velocity } }
+  };
+}
+
+// packages/runtime/src/builtins/pop/definitions.ts
+var sourceDefinition = {
+  apiVersion: 1,
+  label: "POP Source",
+  description: "Birth particles from a geometry's points.",
+  icon: "Sparkles",
+  runsOn: "portable",
+  inputs: {
+    geometry: { kind: "data", type: "geometry" },
+    particles: { kind: "data", type: "geometry" }
+  },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  props: {
+    impulse: { type: "int", default: 8, min: 0, max: 1e5 },
+    life: { type: "float", default: 3, min: 0, max: 3600, step: 0.1 },
+    lifevar: { type: "float", default: 0.3, min: 0, max: 1, step: 0.01 },
+    velocity: { type: "vec2", default: [0, 0] },
+    seed: { type: "int", default: 7, min: 0, max: 999999 }
+  }
+};
+function hsvToRgb(h, s, v) {
+  const turn = (h % 1 + 1) % 1;
+  const sector = turn * 6;
+  const c = v * s;
+  const x = c * (1 - Math.abs(sector % 2 - 1));
+  const m = v - c;
+  const rgb = sector < 1 ? [c, x, 0] : sector < 2 ? [x, c, 0] : sector < 3 ? [0, c, x] : sector < 4 ? [0, x, c] : sector < 5 ? [x, 0, c] : [c, 0, x];
+  return [rgb[0] + m, rgb[1] + m, rgb[2] + m];
+}
+function birthRandom(seed, sample) {
+  const n = Math.sin(seed * 12.9898 + sample * 78.233) * 43758.5453;
+  return n - Math.floor(n);
+}
+function executeSource(context) {
+  const props = context.props;
+  const incoming = context.inputs.particles;
+  const state = incoming ? ParticleState.fromGeometry(incoming) : ParticleState.fromGeometry(emptyParticleGeometry(2));
+  const from = context.inputs.geometry;
+  const available = from ? from.pointCount : 0;
+  const born = available === 0 ? 0 : Math.min(props.impulse, available);
+  if (born === 0) {
+    context.outputs.geometry.set(state.toGeometry());
+    return;
+  }
+  const size = state.size;
+  const position = new Float64Array(born * size);
+  const velocity = new Float32Array(born * size);
+  const life = new Float32Array(born);
+  const source = from.point.P;
+  for (let index = 0; index < born; index += 1) {
+    const pick = available === born ? index : Math.floor(index / born * available);
+    for (let component = 0; component < size; component += 1) {
+      position[index * size + component] = Number(source.data[pick * source.size + component] ?? 0);
+      velocity[index * size + component] = props.velocity[component] ?? 0;
+    }
+    const jitter = birthRandom(props.seed, state.nextId + index);
+    life[index] = props.life * (1 - props.lifevar * jitter);
+  }
+  context.outputs.geometry.set(state.born({ position, velocity, life }).toGeometry());
+}
+var solverDefinition = {
+  apiVersion: 1,
+  label: "POP Solver",
+  description: "Advance a particle system by one timestep.",
+  icon: "Play",
+  runsOn: "portable",
+  inputs: { particles: { kind: "data", type: "geometry" } },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  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.
+     */
+    timestep_mode: {
+      type: "string",
+      default: "fixed",
+      control: "select",
+      options: [
+        { value: "fixed", label: "Fixed - reproducible from the document" },
+        { value: "fps", label: "Variable - derived from the render rate" }
+      ]
+    },
+    timestep: { type: "float", default: 1 / 24, min: 1 / 240, max: 1, step: 1 / 240 },
+    maxspeed: { type: "float", default: 0, min: 0, max: 1e4, step: 0.5 },
+    force: { type: "vec2", default: [0, 0] },
+    airresist: { type: "float", default: 0, min: 0, max: 20, step: 0.05 }
+  }
+};
+function executeSolver(context) {
+  const props = context.props;
+  const incoming = context.inputs.particles;
+  if (!incoming) {
+    context.outputs.geometry.set(emptyParticleGeometry(2));
+    return;
+  }
+  const state = ParticleState.fromGeometry(incoming);
+  const forces = [];
+  forces.push(forceAttribute(incoming));
+  if (props.force[0] !== 0 || props.force[1] !== 0) forces.push(gravity(props.force));
+  if (props.airresist > 0) forces.push(drag(props.airresist));
+  context.outputs.geometry.set(
+    clearForce(
+      step(state, forces, {
+        timestep: props.timestep,
+        ...props.maxspeed > 0 ? { maxSpeed: props.maxspeed } : {}
+      }).toGeometry()
+    )
+  );
+}
+var noiseForceDefinition = {
+  apiVersion: 1,
+  label: "POP Noise Force",
+  description: "Push particles along a heading read from a noise field.",
+  icon: "Wind",
+  runsOn: "portable",
+  inputs: { particles: { kind: "data", type: "geometry" } },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  props: {
+    amplitude: { type: "float", default: 6, min: 0, max: 500, step: 0.5 },
+    frequency: { type: "float", default: 0.3, min: 1e-3, max: 10, step: 0.01 },
+    evolve: { type: "float", default: 0, min: -1e3, max: 1e3, step: 0.01 },
+    timestep: { type: "float", default: 1 / 24, min: 1 / 240, max: 1, step: 1 / 240 },
+    seed: { type: "int", default: 7, min: 0, max: 999999 }
+  }
+};
+function executeNoiseForce(context) {
+  const incoming = context.inputs.particles;
+  if (!incoming) {
+    context.outputs.geometry.set(emptyParticleGeometry(2));
+    return;
+  }
+  const props = context.props;
+  const state = ParticleState.fromGeometry(incoming);
+  context.outputs.geometry.set(
+    accumulateForce(
+      incoming,
+      noiseField({
+        seed: props.seed,
+        frequency: props.frequency,
+        amplitude: props.amplitude,
+        evolve: props.evolve
+      }).accelerate(state, state.size),
+      state.size
+    )
+  );
+}
+var separateDefinition = {
+  apiVersion: 1,
+  label: "POP Separate",
+  description: "Push neighbours apart within a radius.",
+  icon: "Move3d",
+  runsOn: "portable",
+  inputs: { particles: { kind: "data", type: "geometry" } },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  props: {
+    radius: { type: "float", default: 0.5, min: 0, max: 100, step: 0.01 },
+    strength: { type: "float", default: 4, min: 0, max: 500, step: 0.1 },
+    timestep: { type: "float", default: 1 / 24, min: 1 / 240, max: 1, step: 1 / 240 }
+  }
+};
+function executeSeparate(context) {
+  const incoming = context.inputs.particles;
+  if (!incoming) {
+    context.outputs.geometry.set(emptyParticleGeometry(2));
+    return;
+  }
+  const props = context.props;
+  const state = ParticleState.fromGeometry(incoming);
+  context.outputs.geometry.set(
+    accumulateForce(
+      incoming,
+      separation({ radius: props.radius, strength: props.strength }).accelerate(
+        state,
+        state.size
+      ),
+      state.size
+    )
+  );
+}
+var fieldForceDefinition = {
+  apiVersion: 1,
+  label: "POP Field Force",
+  description: "Pull particles along a field's gradient and around its contours. The calligraphy force.",
+  icon: "Waves",
+  runsOn: "portable",
+  inputs: {
+    particles: { kind: "data", type: "geometry" },
+    /** The field: points carrying `N` (the gradient) and optionally `level`. */
+    field: { kind: "data", type: "geometry" }
+  },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  props: {
+    normal: {
+      type: "float",
+      default: 0,
+      min: -1e5,
+      max: 1e5,
+      label: "Normal",
+      description: "Along N, toward the spine. Negative pushes away."
+    },
+    tangential: {
+      type: "float",
+      default: 2600,
+      min: -1e5,
+      max: 1e5,
+      label: "Tangential",
+      description: "Perpendicular to N, around the outline. Sign picks the direction."
+    },
+    radius: {
+      type: "float",
+      default: 20,
+      min: 0,
+      max: 1e4,
+      label: "Radius",
+      description: "How far a field sample reaches."
+    },
+    level: {
+      type: "float",
+      default: 0.28,
+      min: 0,
+      max: 1,
+      step: 0.01,
+      label: "Level",
+      description: "The contour to hold, rather than climbing to the peak."
+    },
+    hold: {
+      type: "float",
+      default: 5200,
+      min: 0,
+      max: 1e5,
+      label: "Hold",
+      description: "How hard to hold that contour."
+    }
+  }
+};
+function executeFieldForce(context) {
+  const incoming = context.inputs.particles;
+  if (!incoming) {
+    context.outputs.geometry.set(emptyParticleGeometry(2));
+    return;
+  }
+  const flow = context.inputs.field;
+  const props = context.props;
+  if (!flow || flow.pointCount === 0 || props.normal === 0 && props.tangential === 0) {
+    context.outputs.geometry.set(incoming);
+    return;
+  }
+  if (!flow.point.N)
+    throw new Error(
+      `${context.nodeId}.field requires point attribute N when the field contains points`
+    );
+  const state = ParticleState.fromGeometry(incoming);
+  context.outputs.geometry.set(
+    accumulateForce(
+      incoming,
+      flowField({
+        positions: flow.point.P.data,
+        positionSize: flow.point.P.size,
+        directions: flow.point.N.data,
+        ...flow.point.level && flow.point.level.storage !== "string" ? { levels: flow.point.level.data } : {},
+        count: flow.pointCount,
+        normal: props.normal,
+        tangential: props.tangential,
+        radius: props.radius,
+        level: props.level,
+        hold: props.hold
+      }).accelerate(state, state.size),
+      state.size
+    )
+  );
+}
+var trailDefinition = {
+  apiVersion: 1,
+  label: "POP Trail",
+  description: "Build trails from a Feedback container's history.",
+  icon: "Activity",
+  runsOn: "portable",
+  inputs: {
+    /** The container's `history` output: every kept step, oldest first. */
+    history: { kind: "data", type: "array" },
+    /** The current state, for `preserve` and for the newest point of each trail. */
+    particles: { kind: "data", type: "geometry" }
+  },
+  outputs: { geometry: { kind: "data", type: "geometry" } },
+  props: {
+    result: {
+      type: "string",
+      default: "polylines",
+      control: "select",
+      options: [
+        { value: "polylines", label: "Polylines - one line per particle" },
+        { value: "preserve", label: "Preserve - pass the points through" }
+      ],
+      label: "Result"
+    },
+    length: { type: "int", default: 12, min: 1, max: 1e5, label: "Length" },
+    increment: { type: "int", default: 1, min: 1, max: 1e3, label: "Increment" },
+    velocityscale: { type: "float", default: 1, min: 0, max: 100, step: 0.01, label: "Velocity Scale" }
+  }
+};
+function executeTrail(context) {
+  const current = context.inputs.particles;
+  if (!current) {
+    context.outputs.geometry.set(emptyParticleGeometry(2));
+    return;
+  }
+  const history = context.inputs.history ?? [];
+  const frames = [];
+  for (const [index, entry] of history.entries()) {
+    if (typeof entry !== "object" || entry === null || entry.kind !== "geometry")
+      throw new Error(`${context.nodeId}.history[${index}] must be particle geometry`);
+    const violations = checkParticleContract(entry);
+    if (violations.length > 0)
+      throw new Error(
+        `${context.nodeId}.history[${index}] is not particle geometry: ${violations.map((violation) => violation.reason).join("; ")}`
+      );
+    frames.push(trailFrame(entry));
+  }
+  const props = context.props;
+  context.outputs.geometry.set(
+    buildTrails(frames, current, {
+      result: props.result === "preserve" ? "preserve" : "polylines",
+      length: props.length,
+      increment: props.increment,
+      velocityscale: props.velocityscale
+    })
+  );
+}
+var simulateDefinition = {
+  apiVersion: 1,
+  label: "POP Simulate",
+  description: "Re-simulate a particle system from frame zero to this frame.",
+  icon: "Rewind",
+  runsOn: "portable",
+  inputs: {
+    /** Where particles are born. Its points are the birth positions. */
+    geometry: { kind: "data", 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. */
+    frame: { kind: "data", type: "float", 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.
+     */
+    attract: { kind: "data", 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.
+     */
+    field: { kind: "data", type: "geometry" }
+  },
+  outputs: {
+    /** The particles, one point each. */
+    geometry: { kind: "data", 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.
+     */
+    trails: { kind: "data", type: "geometry" }
+  },
+  props: {
+    /** Frames of history in the trails. Houdini's Trail `length`. */
+    trail_length: { type: "int", default: 14, min: 1, max: 500 },
+    /** Use every nth frame. Houdini's `increment`. */
+    trail_increment: { type: "int", default: 1, min: 1, 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.
+     */
+    substeps: { type: "int", default: 1, min: 1, max: 32 },
+    timestep: { type: "float", default: 1 / 24, min: 1 / 240, max: 1, step: 1 / 240 },
+    /** Per frame, as on Source. */
+    impulse: { type: "int", default: 6, min: 0, max: 1e5 },
+    life: { type: "float", default: 4, min: 0, max: 3600, step: 0.1 },
+    lifevar: { type: "float", default: 0.4, min: 0, max: 1, step: 0.01 },
+    force: { type: "vec2", default: [0, 0] },
+    airresist: { type: "float", default: 0.4, min: 0, max: 20, step: 0.05 },
+    noise_amplitude: { type: "float", default: 14, min: 0, max: 500, step: 0.5 },
+    noise_frequency: { type: "float", default: 0.02, min: 1e-3, max: 10, step: 1e-3 },
+    /** Turns per second of field evolution. */
+    noise_evolve: { type: "float", default: 0.08, min: -10, max: 10, step: 0.01 },
+    /** Toward the spine, up the field's gradient. */
+    field_normal: { type: "float", default: 0, min: -2e4, max: 2e4, step: 1 },
+    /** Around the outline, perpendicular to the gradient. Sign picks which way. */
+    field_tangential: { type: "float", default: 0, min: -2e4, max: 2e4, step: 1 },
+    /** Field samples beyond this are ignored, and it is the grid's cell size. */
+    field_radius: { type: "float", default: 24, min: 0.5, max: 2e3, 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.
+     */
+    field_level: { type: "float", default: 0.35, min: 0, max: 1, step: 0.01 },
+    field_hold: { type: "float", default: 0, min: 0, max: 4e4, 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.
+     */
+    birth_area: { type: "vec4", default: [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.
+     */
+    birth_hue: { type: "vec2", default: [0, 0], min: 0, max: 1, step: 0.01 },
+    birth_saturation: { type: "float", default: 0.6, min: 0, max: 1, step: 0.01 },
+    birth_value: { type: "float", default: 1, min: 0, max: 1, step: 0.01 },
+    /** How hard the targets pull. Houdini's POP Attract strength. */
+    attract_amplitude: { type: "float", default: 0, min: 0, max: 2e4, 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. */
+    attract_radius: { type: "float", default: 60, min: 0, max: 5e3, step: 1 },
+    separate_radius: { type: "float", default: 0, min: 0, max: 500, step: 0.5 },
+    separate_strength: { type: "float", default: 12, min: 0, max: 500, step: 0.5 },
+    maxspeed: { type: "float", default: 60, min: 0, max: 1e4, step: 1 },
+    /** `[minX, minY, maxX, maxY]`, or all zero for open space. The original
+     *  piece is toroidal. */
+    wrap: { type: "vec4", default: [0, 0, 0, 0] },
+    seed: { type: "int", default: 7, min: 0, max: 999999 }
+  }
+};
+function simulationFingerprint(props, geometries) {
+  const parts = [];
+  for (const [name, value] of Object.entries(props)) {
+    if (name === "trail_length" || name === "trail_increment") continue;
+    parts.push(`${name}=${JSON.stringify(value)}`);
+  }
+  for (const geometry of geometries) {
+    parts.push(geometry ? geometryFingerprint(geometry) : "none");
+  }
+  return parts.join("|");
+}
+function geometryFingerprint(geometry) {
+  let hash2 = 2166136261;
+  const fold = (value) => {
+    hash2 ^= value | 0;
+    hash2 = Math.imul(hash2, 16777619);
+  };
+  fold(geometry.pointCount);
+  fold(geometry.primitiveCount);
+  for (const [name, attribute] of Object.entries(geometry.point)) {
+    for (let index = 0; index < name.length; index += 1) fold(name.charCodeAt(index));
+    if (attribute.storage === "string") continue;
+    const data = attribute.data;
+    for (let index = 0; index < data.length; index += 1) fold(Math.round(Number(data[index]) * 4096));
+  }
+  return (hash2 >>> 0).toString(36);
+}
+function executeSimulate(context) {
+  const props = context.props;
+  const from = context.inputs.geometry;
+  const frames = Math.max(0, Math.floor(context.inputs.frame));
+  let state = ParticleState.fromGeometry(emptyParticleGeometry(2));
+  const history = [];
+  let startFrame = 1;
+  const available = from ? from.pointCount : 0;
+  const source = from?.point.P;
+  const targets = context.inputs.attract;
+  const flow = context.inputs.field;
+  const scatter = props.birth_area.some((value) => value !== 0) ? props.birth_area : null;
+  const canBirth = scatter !== null || available > 0 && source !== void 0;
+  const wrap = props.wrap.some((value) => value !== 0) ? [props.wrap[0], props.wrap[1], props.wrap[2], props.wrap[3]] : void 0;
+  const fingerprint = simulationFingerprint(props, [from, targets, flow]);
+  const keep = props.trail_length * props.trail_increment;
+  const resumed = checkpointAtOrBefore(
+    context.nodeId,
+    fingerprint,
+    Math.max(0, frames - keep)
+  );
+  if (resumed) {
+    state = resumed.state;
+    startFrame = resumed.frame + 1;
+  }
+  for (let frame = startFrame; frame <= frames; frame += 1) {
+    if (canBirth && props.impulse > 0) {
+      const born = scatter ? props.impulse : Math.min(props.impulse, available);
+      const position = new Float64Array(born * 2);
+      const life = new Float32Array(born);
+      const colours = props.birth_hue[0] !== props.birth_hue[1] || props.birth_saturation !== 0 ? new Float32Array(born * 4) : null;
+      for (let index = 0; index < born; index += 1) {
+        const id = state.nextId + index;
+        if (scatter) {
+          position[index * 2] = scatter[0] + birthRandom(props.seed, id * 2) * (scatter[2] - scatter[0]);
+          position[index * 2 + 1] = scatter[1] + birthRandom(props.seed, id * 2 + 1) * (scatter[3] - scatter[1]);
+        } else {
+          const pick = (frame * born + index) % available;
+          const points = source.data;
+          position[index * 2] = Number(points[pick * source.size] ?? 0);
+          position[index * 2 + 1] = Number(points[pick * source.size + 1] ?? 0);
+        }
+        const jitter = birthRandom(props.seed, id);
+        life[index] = props.life * (1 - props.lifevar * jitter);
+        if (colours) {
+          const hue = props.birth_hue[0] + birthRandom(props.seed, id * 4 + 3) * (props.birth_hue[1] - props.birth_hue[0]);
+          const [r, g, b] = hsvToRgb(hue, props.birth_saturation, props.birth_value);
+          colours[index * 4] = r;
+          colours[index * 4 + 1] = g;
+          colours[index * 4 + 2] = b;
+          colours[index * 4 + 3] = 1;
+        }
+      }
+      state = state.born({ position, life, ...colours ? { colour: colours } : {} });
+    }
+    const forces = [];
+    if (props.force[0] !== 0 || props.force[1] !== 0) forces.push(gravity(props.force));
+    if (props.airresist > 0) forces.push(drag(props.airresist));
+    if (props.noise_amplitude > 0) {
+      forces.push(noiseField({
+        seed: props.seed,
+        frequency: props.noise_frequency,
+        amplitude: props.noise_amplitude,
+        // Derived from the frame the caller stated, not from a clock — which
+        // is what keeps the whole node a pure function of `frame`.
+        evolve: frame * props.timestep * props.noise_evolve
+      }));
+    }
+    if (flow && flow.pointCount > 0 && flow.point.N && (props.field_normal !== 0 || props.field_tangential !== 0)) {
+      forces.push(flowField({
+        positions: flow.point.P.data,
+        positionSize: flow.point.P.size,
+        directions: flow.point.N.data,
+        ...flow.point.level && flow.point.level.storage !== "string" ? { levels: flow.point.level.data } : {},
+        count: flow.pointCount,
+        normal: props.field_normal,
+        tangential: props.field_tangential,
+        radius: props.field_radius,
+        level: props.field_level,
+        hold: props.field_hold
+      }));
+    }
+    if (targets && targets.pointCount > 0 && props.attract_amplitude > 0) {
+      forces.push(attract({
+        targets: targets.point.P.data,
+        targetSize: targets.point.P.size,
+        targetCount: targets.pointCount,
+        amplitude: props.attract_amplitude,
+        radius: props.attract_radius
+      }));
+    }
+    if (props.separate_radius > 0) {
+      forces.push(separation({
+        radius: props.separate_radius,
+        strength: props.separate_strength
+      }));
+    }
+    for (let substep = 0; substep < props.substeps; substep += 1) {
+      state = step(state, forces, {
+        timestep: props.timestep / props.substeps,
+        ...props.maxspeed > 0 ? { maxSpeed: props.maxspeed } : {},
+        ...wrap ? { wrap } : {}
+      });
+    }
+    history.push({
+      id: Int32Array.from(state.id),
+      position: Float64Array.from(state.position),
+      size: state.size
+    });
+    if (history.length > keep) history.splice(0, history.length - keep);
+    offerCheckpoint(context.nodeId, fingerprint, frame, state);
+  }
+  const geometry = state.toGeometry();
+  context.outputs.geometry.set(geometry);
+  context.outputs.trails.set(
+    buildTrails(history, geometry, {
+      result: "polylines",
+      length: props.trail_length,
+      increment: props.trail_increment
+    })
+  );
+}
+var simulateRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.pop.Simulate",
+  definition: simulateDefinition,
+  loadExecute: async () => executeSimulate
+};
+var sourceRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.pop.Source",
+  definition: sourceDefinition,
+  loadExecute: async () => executeSource
+};
+var solverRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.pop.Solver",
+  definition: solverDefinition,
+  loadExecute: async () => executeSolver
+};
+var noiseForceRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.pop.NoiseForce",
+  definition: noiseForceDefinition,
+  loadExecute: async () => executeNoiseForce
+};
+var separateRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.pop.Separate",
+  definition: separateDefinition,
+  loadExecute: async () => executeSeparate
+};
+var fieldForceRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.pop.FieldForce",
+  definition: fieldForceDefinition,
+  loadExecute: async () => executeFieldForce
+};
+var trailRegistration = {
+  kind: "definition-v1",
+  moduleId: "cascade.pop.Trail",
+  definition: trailDefinition,
+  loadExecute: async () => executeTrail
+};
+var popNodeRegistrations = Object.freeze([
+  simulateRegistration,
+  sourceRegistration,
+  solverRegistration,
+  noiseForceRegistration,
+  separateRegistration,
+  fieldForceRegistration,
+  trailRegistration
+]);
+var popNodeDefinitions = Object.freeze([
+  ["cascade.pop.Simulate", simulateDefinition],
+  ["cascade.pop.Source", sourceDefinition],
+  ["cascade.pop.Solver", solverDefinition],
+  ["cascade.pop.NoiseForce", noiseForceDefinition],
+  ["cascade.pop.Separate", separateDefinition],
+  ["cascade.pop.FieldForce", fieldForceDefinition],
+  ["cascade.pop.Trail", trailDefinition]
+]);
+
+export {
+  popNodeRegistrations,
+  popNodeDefinitions
+};
+//# sourceMappingURL=chunk-KH4MUBKF.js.map