@field/cascade 0.10.0 → 0.11.0

package/dist/cli/chunk-GFS6W3C5.js

@@ -0,0 +1,308 @@
+// packages/contracts/src/bundle.ts
+function bundleFieldType(definition) {
+  if (!definition) return "any";
+  return typeof definition === "string" ? definition : definition.type;
+}
+function bundleSchemasCompatible(output, input) {
+  return !output || !input || output === input;
+}
+function isBundleValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function selectBundleFields(value, fields) {
+  if (!isBundleValue(value)) return value;
+  const selected = {};
+  for (const field of fields)
+    if (Object.prototype.hasOwnProperty.call(value, field)) selected[field] = value[field];
+  return Object.freeze(selected);
+}
+function suggestName(name, candidates) {
+  let best;
+  let bestDistance = Infinity;
+  const lower = name.toLowerCase();
+  for (const candidate of candidates) {
+    const distance = editDistance(lower, candidate.toLowerCase());
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  if (best === void 0) return void 0;
+  const limit = Math.max(1, Math.floor(Math.max(name.length, best.length) / 3));
+  return bestDistance <= limit ? best : void 0;
+}
+function unknownFieldMessage(field, known, where) {
+  const suggestion = suggestName(field, known);
+  return `${where} reads unknown bundle field "${field}"` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : "") + (known.length ? ` (fields: ${known.join(", ")})` : " (the bundle declares no fields)");
+}
+function bundleValueProblem(value, fields) {
+  if (value === void 0 || value === null) return null;
+  if (!isBundleValue(value)) return "a bundle must be a plain object of fields";
+  if (!fields) return null;
+  const known = Object.keys(fields);
+  for (const key of Object.keys(value))
+    if (!Object.prototype.hasOwnProperty.call(fields, key)) {
+      const suggestion = suggestName(key, known);
+      return `sets undeclared bundle field "${key}"` + (suggestion ? ` \u2014 did you mean "${suggestion}"?` : "") + ` (declared: ${known.join(", ") || "none"})`;
+    }
+  return null;
+}
+function editDistance(a, b) {
+  const previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = previous[0];
+    previous[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = previous[j];
+      previous[j] = Math.min(
+        previous[j] + 1,
+        previous[j - 1] + 1,
+        diagonal + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+      diagonal = above;
+    }
+  }
+  return previous[b.length];
+}
+
+// packages/runtime/src/seed.ts
+var DEFAULT_GRAPH_SEED = 0;
+function graphSeed(document) {
+  const value = document?.seed;
+  return typeof value === "number" && Number.isInteger(value) ? value >>> 0 : DEFAULT_GRAPH_SEED;
+}
+function nodeSeed(seedOfGraph, nodeId) {
+  const text = `${seedOfGraph >>> 0}:${nodeId}`;
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index++) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  hash ^= hash >>> 16;
+  hash = Math.imul(hash, 2246822507);
+  hash ^= hash >>> 13;
+  hash = Math.imul(hash, 3266489909);
+  hash ^= hash >>> 16;
+  return hash >>> 0;
+}
+function seededRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// packages/runtime/src/gpu.ts
+var HOST_SCOPE = "\0host";
+var MISSING_DEVICE = "The gpu capability was used before its device was ready \u2014 the host must await ensure() before a cook.";
+var DISPOSED = "The gpu capability has been disposed.";
+function isGpuHost(value) {
+  return !!value && typeof value.ensure === "function" && typeof value.forNode === "function" && typeof value.dispose === "function";
+}
+function createGpuHost(options) {
+  let active = null;
+  let starting = null;
+  let disposal = null;
+  let disposed = false;
+  const caches = /* @__PURE__ */ new Map();
+  const retiring = /* @__PURE__ */ new Set();
+  const retirementErrors = [];
+  function dropCaches() {
+    const errors = [];
+    const scopes = [...caches.values()];
+    caches.clear();
+    for (const entries of scopes) {
+      for (const entry of entries.values()) {
+        try {
+          entry.destroy?.(entry.value);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+    }
+    return errors;
+  }
+  async function release(acquired, destroyDevice) {
+    if (acquired.released) return [];
+    acquired.released = true;
+    const errors = [];
+    if (destroyDevice) {
+      try {
+        acquired.device.destroy();
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    try {
+      await acquired.release?.();
+    } catch (error) {
+      errors.push(error);
+    }
+    return errors;
+  }
+  function throwCleanupErrors(errors) {
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) {
+      const combined = new Error("GPU host cleanup failed");
+      Object.assign(combined, { errors });
+      throw combined;
+    }
+  }
+  function watchLoss(acquired) {
+    void acquired.device.lost.then(() => {
+      if (disposed || active !== acquired) return;
+      active = null;
+      retirementErrors.push(...dropCaches());
+      const cleanup = release(acquired, false).then((errors) => {
+        retirementErrors.push(...errors);
+      });
+      retiring.add(cleanup);
+      void cleanup.finally(() => retiring.delete(cleanup));
+    }).catch(() => {
+    });
+  }
+  async function start() {
+    const result = await options.acquire();
+    const acquired = {
+      device: result.device,
+      info: {
+        vendor: result.info?.vendor ?? "",
+        architecture: result.info?.architecture ?? "",
+        device: result.info?.device ?? "",
+        description: result.info?.description ?? ""
+      },
+      limits: readGpuLimits(result.limits),
+      release: result.release,
+      released: false
+    };
+    if (disposed) {
+      const errors = await release(acquired, true);
+      throwCleanupErrors(errors);
+      throw new Error(DISPOSED);
+    }
+    active = acquired;
+    watchLoss(acquired);
+  }
+  const host = {
+    get device() {
+      if (!active) throw new Error(MISSING_DEVICE);
+      return active.device;
+    },
+    get adapterInfo() {
+      if (!active) throw new Error(MISSING_DEVICE);
+      return active.info;
+    },
+    get limits() {
+      return active?.limits ?? {};
+    },
+    cache(key, create, destroy) {
+      return host.forNode(HOST_SCOPE).cache(key, create, destroy);
+    },
+    async ensure() {
+      if (disposed) throw new Error(DISPOSED);
+      if (active) return;
+      if (!starting) {
+        const attempt = start();
+        const tracked = attempt.finally(() => {
+          if (starting === tracked) starting = null;
+        });
+        starting = tracked;
+      }
+      await starting;
+    },
+    forNode(nodeId) {
+      return {
+        get device() {
+          if (!active) throw new Error(MISSING_DEVICE);
+          return active.device;
+        },
+        get adapterInfo() {
+          if (!active) throw new Error(MISSING_DEVICE);
+          return active.info;
+        },
+        get limits() {
+          return active?.limits ?? {};
+        },
+        cache(key, create, destroy) {
+          if (!active) throw new Error(MISSING_DEVICE);
+          let entries = caches.get(nodeId);
+          if (!entries) {
+            entries = /* @__PURE__ */ new Map();
+            caches.set(nodeId, entries);
+          }
+          const existing = entries.get(key);
+          if (existing) return existing.value;
+          const value = create(active.device);
+          entries.set(key, {
+            value,
+            destroy
+          });
+          return value;
+        }
+      };
+    },
+    dispose() {
+      disposal ??= performDispose();
+      return disposal;
+    }
+  };
+  async function performDispose() {
+    disposed = true;
+    const errors = dropCaches();
+    const pending = starting;
+    if (pending) {
+      try {
+        await pending;
+      } catch (error) {
+        if (!(error instanceof Error && error.message === DISPOSED))
+          errors.push(error);
+      }
+    }
+    const acquired = active;
+    active = null;
+    if (acquired) errors.push(...await release(acquired, true));
+    await Promise.all([...retiring]);
+    errors.push(...retirementErrors);
+    retirementErrors.length = 0;
+    throwCleanupErrors(errors);
+  }
+  return host;
+}
+function readGpuLimits(source) {
+  if (!source || typeof source !== "object") return {};
+  const names = new Set(Object.keys(source));
+  for (let cursor = Object.getPrototypeOf(source); cursor && cursor !== Object.prototype; cursor = Object.getPrototypeOf(cursor)) {
+    for (const key of Object.getOwnPropertyNames(cursor)) {
+      if (key !== "constructor") names.add(key);
+    }
+  }
+  const limits = {};
+  for (const key of names) {
+    const value = source[key];
+    if (typeof value === "number") limits[key] = value;
+  }
+  return limits;
+}
+
+export {
+  bundleFieldType,
+  bundleSchemasCompatible,
+  isBundleValue,
+  selectBundleFields,
+  suggestName,
+  unknownFieldMessage,
+  bundleValueProblem,
+  isGpuHost,
+  createGpuHost,
+  DEFAULT_GRAPH_SEED,
+  graphSeed,
+  nodeSeed,
+  seededRandom
+};
+//# sourceMappingURL=chunk-GFS6W3C5.js.map

package/dist/cli/chunk-HFHWYL55.js

@@ -0,0 +1,139 @@
+import {
+  ExpressionEvaluator,
+  isEmptyChannel,
+  parseBundleFieldPath,
+  sampleChannel
+} from "./chunk-CO22XHNG.js";
+
+// packages/runtime/src/params/resolve.ts
+function isBoundProp(binding) {
+  if (!binding) return false;
+  return !!binding.expression || !isEmptyChannel(binding.channel);
+}
+function resolvePropBinding(binding, context) {
+  if (!isEmptyChannel(binding.channel)) {
+    const sampled = sampleChannel(binding.channel, context.frame);
+    if (sampled !== void 0) return { value: sampled, source: "channel" };
+  }
+  if (binding.expression && context.evaluateExpression) {
+    const result = context.evaluateExpression(binding.expression);
+    if (result?.error) {
+      return { value: binding.value, source: "value", error: result.error };
+    }
+    if (result) return { value: result.value, source: "expression" };
+  }
+  return { value: binding.value, source: "value" };
+}
+
+// packages/runtime/src/params/animator.ts
+var PropAnimator = class {
+  constructor(topology) {
+    this.topology = topology;
+    this.resolving = /* @__PURE__ */ new Set();
+    this.evaluator = new ExpressionEvaluator(this.scope());
+  }
+  /** True when any parameter in the graph is bound at all — so a host can skip
+   *  the whole pass, and a graph with no animation costs nothing. */
+  get animated() {
+    return this.topology.nodes.some(
+      (node) => Object.values(node.bindings).some((binding) => isBoundProp(binding))
+    );
+  }
+  setFrame(frame) {
+    this.evaluator.setFrame(frame);
+  }
+  setFps(fps) {
+    this.evaluator.setFps(fps);
+  }
+  /** Write every bound parameter's value at the current frame into `props`. */
+  resolveAll() {
+    for (const node of this.topology.nodes)
+      for (const name of Object.keys(node.bindings)) this.resolve(node, name);
+  }
+  /** Re-resolve one node's bound parameters, e.g. once its inputs exist. */
+  resolveNode(node) {
+    for (const name of Object.keys(node.bindings)) this.resolve(node, name);
+  }
+  /**
+   * One parameter, at the current frame.
+   *
+   * Re-entry returns the stored value rather than throwing: a parameter whose
+   * expression refers back to itself is an author's mistake, and the render
+   * that names it is more use than the one that dies.
+   */
+  resolve(node, name) {
+    const binding = node.bindings[name];
+    if (!binding) return node.props[name];
+    const key = `${node.id}.${name}`;
+    if (this.resolving.has(key)) return binding.value;
+    this.resolving.add(key);
+    try {
+      const resolved = resolvePropBinding(binding, {
+        frame: this.evaluator.fframe,
+        evaluateExpression: (expression) => this.evaluator.evaluate(expression, node)
+      });
+      if (resolved.error) this.topology.report?.(node.id, name, resolved.error);
+      node.props[name] = resolved.value;
+      return resolved.value;
+    } finally {
+      this.resolving.delete(key);
+    }
+  }
+  /**
+   * The host binding the expression engine reads through.
+   *
+   * A path names a parameter — `./radius`, `../blur1/amount`,
+   * `/root/blur1/amount` — and the last segment is always the parameter, the
+   * one before it the node. Anything a graph does not have resolves to null,
+   * which the engine turns into 0 / '' / [] per accessor rather than an
+   * exception: one broken reference must not take a render down.
+   */
+  scope() {
+    return {
+      resolveParam: (from, path) => {
+        const segments = split(path);
+        if (!segments.length) return null;
+        const name = segments[segments.length - 1];
+        const owner = this.owner(from, segments.slice(0, -1));
+        if (!owner) return null;
+        if (owner.bindings[name]) return { value: this.resolve(owner, name) };
+        const field = parseBundleFieldPath(name);
+        if (field && this.topology.inputValue) {
+          const bundle = this.topology.inputValue(owner, field.port);
+          if (bundle === null || typeof bundle !== "object") return null;
+          if (!Object.prototype.hasOwnProperty.call(bundle, field.field)) return null;
+          return { value: bundle[field.field] };
+        }
+        if (name in owner.props) return { value: owner.props[name] };
+        if (name in owner.inputs) return { value: owner.inputs[name] };
+        return null;
+      },
+      nodeExists: (from, path) => {
+        const segments = split(path);
+        if (!segments.length) return false;
+        const last = segments[segments.length - 1];
+        if (last === "..") return true;
+        return last === from.id || !!this.topology.node(last);
+      },
+      inputNode: (from, index) => this.topology.inputNode(from, index)
+    };
+  }
+  /** The node a path's leading segments name, or `from` when they name none. */
+  owner(from, segments) {
+    for (let i = segments.length - 1; i >= 0; i--) {
+      if (segments[i] === "..") continue;
+      return this.topology.node(segments[i]);
+    }
+    return from;
+  }
+};
+function split(path) {
+  return String(path ?? "").split("/").filter((segment) => segment.length > 0 && segment !== ".");
+}
+
+export {
+  isBoundProp,
+  resolvePropBinding,
+  PropAnimator
+};
+//# sourceMappingURL=chunk-HFHWYL55.js.map

package/dist/cli/chunk-HSNOBIVT.js

@@ -0,0 +1,263 @@
+import {
+  POSITION_ATTRIBUTE,
+  PRIMITIVE_KINDS,
+  attributeArray,
+  attributeArrayFrom,
+  createGeometry,
+  isStringAttribute
+} from "./chunk-J7VK7MNF.js";
+
+// packages/runtime/src/geometry/attributes.ts
+function geometryError(code, message) {
+  throw new TypeError(`geometry/${code}: ${message}`);
+}
+function attributeSet(geometry, level) {
+  return geometry[level];
+}
+function numericAttribute(attribute, path, sizes) {
+  if (attribute === void 0) return void 0;
+  if (isStringAttribute(attribute))
+    geometryError("attribute-storage", `${path} must be numeric`);
+  if (sizes !== void 0 && !sizes.includes(attribute.size))
+    geometryError(
+      "attribute-size",
+      `${path} has size ${attribute.size}; expected ${sizes.join(" or ")}`
+    );
+  return attribute;
+}
+function readComponent(attribute, index, component = 0) {
+  return attribute.data[index * attribute.size + component];
+}
+function readElement(attribute, index) {
+  const values = new Array(attribute.size);
+  for (let component = 0; component < attribute.size; component += 1)
+    values[component] = attribute.data[index * attribute.size + component];
+  return values;
+}
+function readString(attribute, index) {
+  const slot = attribute.data[index];
+  return slot < 0 ? "" : attribute.table[slot] ?? "";
+}
+function positionSize(geometry) {
+  return geometry.point[POSITION_ATTRIBUTE].size;
+}
+function positionAttribute(geometry) {
+  return geometry.point[POSITION_ATTRIBUTE];
+}
+function getPosition(geometry, index) {
+  return readElement(positionAttribute(geometry), index);
+}
+function createAttribute(count, size, storage = "f64", fill) {
+  const data = attributeArray(storage, size * count);
+  if (fill !== void 0) {
+    const values = typeof fill === "number" ? [fill] : fill;
+    for (let index = 0; index < count; index += 1)
+      for (let component = 0; component < size; component += 1)
+        data[index * size + component] = values[component % Math.max(values.length, 1)] ?? 0;
+  }
+  return { storage, size, data };
+}
+function createStringAttribute(values) {
+  const table = [];
+  const slots = /* @__PURE__ */ new Map();
+  const data = new Int32Array(values.length);
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    let slot = slots.get(value);
+    if (slot === void 0) {
+      slot = table.length;
+      table.push(value);
+      slots.set(value, slot);
+    }
+    data[index] = slot;
+  }
+  return { storage: "string", size: 1, table, data };
+}
+function withAttributeSet(geometry, level, set) {
+  return createGeometry({
+    pointCount: geometry.pointCount,
+    point: level === "point" ? set : geometry.point,
+    vertex: level === "vertex" ? set : geometry.vertex,
+    primitive: level === "primitive" ? set : geometry.primitive,
+    detail: geometry.detail,
+    topology: geometry.topology,
+    pointGroups: geometry.pointGroups,
+    primitiveGroups: geometry.primitiveGroups
+  });
+}
+function setAttribute(geometry, level, name, attribute) {
+  return withAttributeSet(geometry, level, {
+    ...geometry[level],
+    [name]: attribute
+  });
+}
+function copyAttributeArray(attribute) {
+  return attributeArrayFrom(attribute.storage, attribute.data);
+}
+
+// packages/runtime/src/geometry/builder.ts
+var GeometryBuilder = class {
+  constructor(options = {}) {
+    this.positions = [];
+    this.vertexPoints = [];
+    this.offsets = [0];
+    this.kinds = [];
+    this.closed = [];
+    this.attributes = { point: {}, vertex: {}, primitive: {} };
+    this.detail = {};
+    this.pointGroups = /* @__PURE__ */ new Map();
+    this.primitiveGroups = /* @__PURE__ */ new Map();
+    this.size = options.positionSize ?? 2;
+    this.storage = options.positionStorage ?? "f64";
+  }
+  get pointCount() {
+    return this.positions.length / this.size;
+  }
+  get vertexCount() {
+    return this.vertexPoints.length;
+  }
+  get primitiveCount() {
+    return this.offsets.length - 1;
+  }
+  /** Append one point and return its index. */
+  addPoint(x, y, z = 0) {
+    const index = this.pointCount;
+    this.positions.push(x, y);
+    if (this.size === 3) this.positions.push(z);
+    return index;
+  }
+  /** Append points from a flat array of `positionSize`-wide entries. */
+  addPoints(flat) {
+    if (flat.length % this.size !== 0)
+      geometryError(
+        "point-stride",
+        `${flat.length} values is not a multiple of the position size ${this.size}`
+      );
+    const first = this.pointCount;
+    for (let index = 0; index < flat.length; index += 1)
+      this.positions.push(flat[index]);
+    return first;
+  }
+  /**
+   * Append one primitive over existing point indices and return its index. A
+   * closed primitive does not repeat its first point: `closed` is topology, not
+   * a duplicated vertex.
+   */
+  addPrimitive(points, options = {}) {
+    const index = this.primitiveCount;
+    for (const point of points) {
+      if (!Number.isInteger(point) || point < 0 || point >= this.pointCount)
+        geometryError(
+          "vertex-point",
+          `primitive ${index} references point ${point} of ${this.pointCount}`
+        );
+      this.vertexPoints.push(point);
+    }
+    this.offsets.push(this.vertexPoints.length);
+    this.kinds.push(PRIMITIVE_KINDS.indexOf(options.kind ?? "poly"));
+    this.closed.push(options.closed ? 1 : 0);
+    return index;
+  }
+  /** Append points and one primitive over them, the common generator case. */
+  addPolygon(flat, options = {}) {
+    const first = this.addPoints(flat);
+    const points = [];
+    for (let index = first; index < this.pointCount; index += 1)
+      points.push(index);
+    return this.addPrimitive(points, options);
+  }
+  setAttribute(level, name, attribute) {
+    if (level === "point" && name === POSITION_ATTRIBUTE)
+      geometryError(
+        "set-position",
+        "point.P is owned by the builder; use addPoint"
+      );
+    this.attributes[level][name] = attribute;
+    return this;
+  }
+  setNumericAttribute(level, name, values, size = 1, storage = "f64") {
+    return this.setAttribute(level, name, {
+      storage,
+      size,
+      data: attributeArrayFrom(storage, values)
+    });
+  }
+  setStringAttribute(level, name, values) {
+    return this.setAttribute(level, name, createStringAttribute(values));
+  }
+  setDetail(name, value) {
+    this.detail[name] = value;
+    return this;
+  }
+  addToPointGroup(name, index) {
+    const members = this.pointGroups.get(name) ?? /* @__PURE__ */ new Set();
+    members.add(index);
+    this.pointGroups.set(name, members);
+    return this;
+  }
+  addToPrimitiveGroup(name, index) {
+    const members = this.primitiveGroups.get(name) ?? /* @__PURE__ */ new Set();
+    members.add(index);
+    this.primitiveGroups.set(name, members);
+    return this;
+  }
+  build() {
+    const pointCount = this.pointCount;
+    const pointGroups = {};
+    for (const [name, members] of this.pointGroups)
+      pointGroups[name] = mask(members, pointCount);
+    const primitiveGroups = {};
+    for (const [name, members] of this.primitiveGroups)
+      primitiveGroups[name] = mask(members, this.primitiveCount);
+    return createGeometry({
+      pointCount,
+      point: {
+        ...this.attributes.point,
+        [POSITION_ATTRIBUTE]: {
+          storage: this.storage,
+          size: this.size,
+          data: attributeArrayFrom(this.storage, this.positions)
+        }
+      },
+      vertex: this.attributes.vertex,
+      primitive: this.attributes.primitive,
+      detail: this.detail,
+      topology: {
+        vertexPoints: Int32Array.from(this.vertexPoints),
+        offsets: Int32Array.from(this.offsets),
+        kinds: Uint8Array.from(this.kinds),
+        closed: Uint8Array.from(this.closed)
+      },
+      pointGroups,
+      primitiveGroups
+    });
+  }
+};
+function mask(members, count) {
+  const result = new Uint8Array(count);
+  for (const member of members) {
+    if (!Number.isInteger(member) || member < 0 || member >= count)
+      geometryError("group-indices", `group references element ${member}`);
+    result[member] = 1;
+  }
+  return result;
+}
+
+export {
+  geometryError,
+  attributeSet,
+  numericAttribute,
+  readComponent,
+  readElement,
+  readString,
+  positionSize,
+  positionAttribute,
+  getPosition,
+  createAttribute,
+  createStringAttribute,
+  withAttributeSet,
+  setAttribute,
+  copyAttributeArray,
+  GeometryBuilder
+};
+//# sourceMappingURL=chunk-HSNOBIVT.js.map