@field/cascade 0.7.1 → 0.10.0

package/dist/player/editorEngine.js

@@ -0,0 +1,477 @@
+// src/player/editorEngine.ts
+import { createBrowserRuntimeHost as createBrowserRuntimeHost2 } from "@field/cascade/runtime/browser";
+import { createRuntime as createRuntime2, PREFLIGHT_WARNING_CODES as PREFLIGHT_WARNING_CODES2 } from "@field/cascade/runtime";
+import { installIoBridge as installIoBridge2 } from "@field/cascade/io";
+
+// src/browser/gpu.ts
+import {
+  createGpuHost
+} from "@field/cascade/runtime";
+function createBrowserGpuHost() {
+  const gpu = globalThis.navigator?.gpu;
+  if (!gpu) return void 0;
+  return createGpuHost({
+    async acquire() {
+      const adapter = await gpu.requestAdapter();
+      if (!adapter) {
+        throw new Error(
+          "No WebGPU adapter is available \u2014 the browser reports WebGPU but the system offers no GPU to render on."
+        );
+      }
+      const device = await adapter.requestDevice();
+      const info = adapter.info;
+      return {
+        device,
+        info: {
+          vendor: info?.vendor ?? "",
+          architecture: info?.architecture ?? "",
+          device: info?.device ?? "",
+          description: info?.description ?? ""
+        },
+        limits: device.limits ?? adapter.limits
+      };
+    }
+  });
+}
+
+// src/player/app.ts
+import {
+  CAMERA_DEFAULTS,
+  isScene,
+  sceneFromGeometry
+} from "@field/cascade/contracts";
+import { createBrowserRuntimeHost } from "@field/cascade/runtime/browser";
+import { renderScene } from "@field/cascade/runtime/render";
+import { createRuntime, PREFLIGHT_WARNING_CODES } from "@field/cascade/runtime";
+import { sceneBounds } from "@field/cascade/runtime/scene";
+import { installIoBridge } from "@field/cascade/io";
+
+// src/player/assets.ts
+var DEFAULT_MAX_BYTES = 256 * 1024 * 1024;
+var DEFAULT_MAX_ENTRIES = 4096;
+var GENERATED_ROOT = ".cascade-player/generated";
+var PlayerAssetStore = class {
+  constructor(assets, options = {}) {
+    this.authored = /* @__PURE__ */ new Map();
+    this.generated = /* @__PURE__ */ new Map();
+    this.generatedByUrl = /* @__PURE__ */ new Map();
+    this.generatedBytes = 0;
+    this.sequence = 0;
+    this.disposed = false;
+    this.maxGeneratedBytes = finiteLimit(
+      options.maxGeneratedBytes,
+      DEFAULT_MAX_BYTES,
+      "maxGeneratedBytes"
+    );
+    this.maxGeneratedEntries = finiteLimit(
+      options.maxGeneratedEntries,
+      DEFAULT_MAX_ENTRIES,
+      "maxGeneratedEntries"
+    );
+    for (const [path, url] of Object.entries(assets)) {
+      const clean = cleanPath(path);
+      if (typeof url !== "string" || url.length === 0)
+        throw new TypeError(`Player asset ${clean} has no deployment URL`);
+      this.authored.set(clean, url);
+    }
+  }
+  async read(ref, options = {}) {
+    this.assertActive();
+    const path = cleanPath(typeof ref === "string" ? ref : ref.path);
+    if (typeof ref === "string") assertIdentityMediaOptions(path, options);
+    const signal = "signal" in options ? options.signal : void 0;
+    if (signal?.aborted) throw abortError(signal.reason);
+    const generated = this.generated.get(path);
+    if (generated) return generated.bytes.slice();
+    const url = this.authored.get(path);
+    if (!url) throw new Error(`Player asset not found: ${path}`);
+    const relay = signal ? relayAbort(signal) : void 0;
+    try {
+      const response = await fetch(url, {
+        ...relay ? { signal: relay.signal } : {}
+      });
+      if (!response.ok)
+        throw new Error(`Could not read player asset ${path} (${response.status})`);
+      return new Uint8Array(await response.arrayBuffer());
+    } finally {
+      relay?.dispose();
+    }
+  }
+  async write(first, second, third) {
+    this.assertActive();
+    const fromIo = typeof first === "string";
+    const data = fromIo ? second : first;
+    if (!(data instanceof Uint8Array))
+      throw new TypeError("Player asset writes require Uint8Array bytes");
+    const metadata = fromIo ? { suggestedName: first, mediaType: mediaTypeForName(first) } : second;
+    if (third?.signal.aborted) throw abortError(third.signal.reason);
+    const name = safeName(metadata.suggestedName);
+    const path = `${GENERATED_ROOT}/${String(++this.sequence).padStart(8, "0")}-${name}`;
+    const nextBytes = this.generatedBytes + data.byteLength;
+    const nextEntries = this.generated.size + 1;
+    if (nextBytes > this.maxGeneratedBytes) {
+      throw new Error(
+        `Player asset ${path} would use ${nextBytes} bytes; limit is ${this.maxGeneratedBytes} bytes`
+      );
+    }
+    if (nextEntries > this.maxGeneratedEntries) {
+      throw new Error(
+        `Player asset ${path} would use ${nextEntries} entries; limit is ${this.maxGeneratedEntries} entries`
+      );
+    }
+    const stored = data.slice();
+    this.generated.set(path, {
+      bytes: stored,
+      ...metadata.mediaType ? { mediaType: metadata.mediaType } : {},
+      leases: 0
+    });
+    this.generatedBytes = nextBytes;
+    return fromIo ? path : { path, ...metadata.mediaType ? { mediaType: metadata.mediaType } : {} };
+  }
+  url(path, options = {}) {
+    this.assertActive();
+    assertIdentityMediaOptions(path, options);
+    const clean = cleanPath(path);
+    const authored = this.authored.get(clean);
+    if (authored) return authored;
+    const generated = this.generated.get(clean);
+    if (!generated) throw new Error(`Player asset not found: ${clean}`);
+    if (!generated.objectUrl) {
+      generated.objectUrl = URL.createObjectURL(blobFor(generated));
+      this.generatedByUrl.set(generated.objectUrl, clean);
+    }
+    return generated.objectUrl;
+  }
+  async resolveUrl(ref) {
+    this.assertActive();
+    const path = cleanPath(ref.path);
+    const generated = this.generated.get(path);
+    if (!generated) {
+      const authored = this.authored.get(path);
+      if (!authored) throw new Error(`Player asset not found: ${path}`);
+      return { value: authored, release: () => {
+      } };
+    }
+    generated.leases += 1;
+    let value;
+    try {
+      value = this.url(path, { raw: true });
+    } catch (error) {
+      generated.leases -= 1;
+      throw error;
+    }
+    let released = false;
+    return {
+      value,
+      release: () => {
+        if (released) return;
+        released = true;
+        generated.leases = Math.max(0, generated.leases - 1);
+      }
+    };
+  }
+  /** Remove generated entries that no settled graph value or display lease owns. */
+  collect(roots) {
+    if (this.disposed) return;
+    const reachable = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    for (const root of roots)
+      visitPaths(root, reachable, seen, this.generated, this.generatedByUrl);
+    const errors = [];
+    for (const [path, entry] of this.generated) {
+      if (reachable.has(path) || entry.leases > 0) continue;
+      try {
+        this.drop(path, entry);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    throwCollectedErrors(errors, "Player asset collection failed");
+  }
+  stats() {
+    return {
+      generatedBytes: this.generatedBytes,
+      generatedEntries: this.generated.size,
+      objectUrls: this.generatedByUrl.size
+    };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    const errors = [];
+    for (const [path, entry] of this.generated) {
+      try {
+        this.drop(path, entry);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    throwCollectedErrors(errors, "Player asset disposal failed");
+  }
+  drop(path, entry) {
+    try {
+      if (entry.objectUrl) URL.revokeObjectURL(entry.objectUrl);
+    } finally {
+      if (entry.objectUrl) this.generatedByUrl.delete(entry.objectUrl);
+      this.generated.delete(path);
+      this.generatedBytes -= entry.bytes.byteLength;
+    }
+  }
+  assertActive() {
+    if (this.disposed) throw new Error("Player asset store is disposed");
+  }
+};
+function finiteLimit(value, fallback, name) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved < 0)
+    throw new TypeError(`${name} must be a non-negative safe integer`);
+  return resolved;
+}
+function cleanPath(path) {
+  const clean = path.replace(/^\.\//, "").replace(/\\/g, "/");
+  if (!clean || clean.startsWith("/") || clean.split("/").some((part) => part === ".."))
+    throw new Error(`Invalid player asset path: ${path}`);
+  return clean;
+}
+function safeName(value) {
+  const source = (value?.trim() || "asset.bin").replace(/\\/g, "/").split("/").pop();
+  const safe = source.replace(/[^A-Za-z0-9._-]/g, "-").replace(/^\.+/, "");
+  return safe || "asset.bin";
+}
+function assertIdentityMediaOptions(path, options) {
+  if (options.width !== void 0 || options.format !== void 0 || options.quality !== void 0)
+    throw new Error(`Player asset transforms are unsupported for ${path}; request the raw asset`);
+}
+function blobFor(entry) {
+  return new Blob([entry.bytes.slice().buffer], {
+    type: entry.mediaType ?? "application/octet-stream"
+  });
+}
+function visitPaths(value, reachable, seen, generated, generatedByUrl) {
+  if (typeof value === "string") {
+    const path = value.replace(/^\.\//, "");
+    if (generated.has(path)) reachable.add(path);
+    else {
+      const generatedPath = generatedByUrl.get(value);
+      if (generatedPath) reachable.add(generatedPath);
+    }
+    return;
+  }
+  if (typeof value !== "object" || value === null) return;
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  if ("path" in value && typeof value.path === "string") {
+    const path = value.path.replace(/^\.\//, "");
+    if (generated.has(path)) reachable.add(path);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      visitPaths(item, reachable, seen, generated, generatedByUrl);
+    return;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return;
+  for (const item of Object.values(value))
+    visitPaths(item, reachable, seen, generated, generatedByUrl);
+}
+function relayAbort(signal) {
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal.reason);
+  signal.addEventListener("abort", abort, { once: true });
+  if (signal.aborted) abort();
+  return {
+    signal: controller.signal,
+    dispose: () => signal.removeEventListener("abort", abort)
+  };
+}
+function abortError(reason) {
+  return reason instanceof Error ? reason : new Error(reason === void 0 ? "Aborted" : String(reason));
+}
+function mediaTypeForName(name) {
+  if (/\.png$/i.test(name)) return "image/png";
+  if (/\.svg$/i.test(name)) return "image/svg+xml";
+  if (/\.jpe?g$/i.test(name)) return "image/jpeg";
+  if (/\.webp$/i.test(name)) return "image/webp";
+  return void 0;
+}
+function throwCollectedErrors(errors, message) {
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1) {
+    const combined = new Error(message);
+    Object.assign(combined, { errors });
+    throw combined;
+  }
+}
+
+// src/player/app.ts
+async function cleanupAll(actions) {
+  const errors = [];
+  for (const action of actions) {
+    try {
+      await action();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throwCollectedErrors(errors, "Cascade player cleanup failed");
+}
+
+// src/player/editorEngine.ts
+var never = { aborted: false, reason: void 0, addEventListener() {
+}, removeEventListener() {
+} };
+var LocalEngine = class _LocalEngine {
+  constructor(graph, store, release) {
+    this.graph = graph;
+    this.store = store;
+    this.release = release;
+  }
+  static async create(options) {
+    const store = new PlayerAssetStore(options.assets);
+    const disposeIo = installIoBridge2(store);
+    const gpu = createBrowserGpuHost();
+    const registrations = new Map(options.registrations.map((item) => [item.moduleId, item]));
+    const runtime = createRuntime2({
+      host: createBrowserRuntimeHost2({
+        modules: { resolve: async (moduleId) => registrations.get(moduleId) ?? null },
+        assets: store,
+        ...gpu ? { gpu } : {}
+      }),
+      nodes: options.registrations
+    });
+    const release = () => cleanupAll([() => runtime.dispose(), () => gpu?.dispose(), () => disposeIo(), () => store.dispose()]);
+    try {
+      const graph = await runtime.load(options.document);
+      const blocking = graph.preflight().find((item) => !PREFLIGHT_WARNING_CODES2.has(item.code));
+      if (blocking) throw new Error(blocking.message);
+      return new _LocalEngine(graph, store, async () => {
+        await graph.dispose();
+        await release();
+      });
+    } catch (error) {
+      await release().catch(() => {
+      });
+      throw error;
+    }
+  }
+  async nodes() {
+    return this.graph.inspect().nodes.map((node) => ({
+      id: node.id,
+      moduleId: node.moduleId,
+      ...node.parent ? { parent: node.parent } : {},
+      props: Object.fromEntries(Object.entries(node.props).map(([name, prop]) => [name, { type: prop.type, value: prop.value }]))
+    }));
+  }
+  async setProps(writes) {
+    for (const [node, prop, value] of writes) await this.graph.setProp(node, prop, value);
+  }
+  async run(options = {}) {
+    const result = await this.graph.run(options);
+    this.collect();
+    return { status: result.status, messages: result.diagnostics.map((item) => item.message) };
+  }
+  async output(node, port) {
+    return this.graph.getOutput(node, port);
+  }
+  async outputs() {
+    return new Map(this.graph.inspect().nodes.map((node) => [node.id, new Map(this.graph.getOutputs(node.id))]));
+  }
+  writeAsset(bytes, metadata) {
+    return this.store.write(bytes, metadata, { signal: never });
+  }
+  readAsset(ref) {
+    return this.store.read(ref, { signal: never });
+  }
+  dispose() {
+    return this.release();
+  }
+  /** Drop generated assets nothing reaches any more: not a prop, not an output. */
+  collect() {
+    const roots = [];
+    for (const node of this.graph.inspect().nodes) {
+      roots.push(...Object.values(node.props).map((prop) => prop.value));
+      roots.push(...this.graph.getOutputs(node.id).values());
+    }
+    try {
+      this.store.collect(roots);
+    } catch {
+    }
+  }
+};
+function serveEditorEngine(registrations) {
+  const scope = globalThis;
+  let engine;
+  scope.onmessage = async (event) => {
+    const { id, method, args } = event.data;
+    try {
+      if (method === "init") {
+        const [document, assets] = args;
+        engine = LocalEngine.create({ document, registrations, assets });
+        await engine;
+        scope.postMessage({ id, ok: true });
+        return;
+      }
+      if (!engine) throw new Error("Editor engine is not initialised");
+      const target = await engine;
+      const value = await target[method].apply(target, [...args]);
+      const transfer = value instanceof Uint8Array ? [value.buffer] : [];
+      try {
+        scope.postMessage({ id, ok: true, value }, transfer);
+      } catch (error) {
+        scope.postMessage({ id, ok: true, value: describeUncloneable(value, error) });
+      }
+    } catch (error) {
+      scope.postMessage({ id, ok: false, error: error instanceof Error ? error.message : String(error) });
+    }
+  };
+}
+async function createWorkerEngine(url, options) {
+  const worker = new Worker(url, { type: "module", name: "cascade-editor-engine" });
+  let sequence = 0;
+  const pending = /* @__PURE__ */ new Map();
+  worker.onmessage = (event) => {
+    const entry = pending.get(event.data.id);
+    if (!entry) return;
+    pending.delete(event.data.id);
+    if (event.data.ok) entry.resolve(event.data.value);
+    else entry.reject(new Error(event.data.error));
+  };
+  worker.onerror = (event) => {
+    const error = new Error(event.message || "Editor engine worker failed");
+    for (const entry of pending.values()) entry.reject(error);
+    pending.clear();
+  };
+  const call = (method, ...args) => new Promise((resolve, reject) => {
+    const id = ++sequence;
+    pending.set(id, { resolve, reject });
+    worker.postMessage({ id, method, args });
+  });
+  const assets = Object.fromEntries(Object.entries(options.assets).map(([name, href]) => [name, new URL(href, location.href).href]));
+  await call("init", options.document, assets);
+  return {
+    nodes: () => call("nodes"),
+    setProps: (writes) => call("setProps", writes),
+    run: (runOptions = {}) => call("run", runOptions),
+    output: (node, port) => call("output", node, port),
+    outputs: () => call("outputs"),
+    writeAsset: (bytes, metadata) => call("writeAsset", bytes, metadata),
+    readAsset: (ref) => call("readAsset", ref),
+    async dispose() {
+      try {
+        await call("dispose");
+      } finally {
+        worker.terminate();
+      }
+    }
+  };
+}
+function describeUncloneable(value, error) {
+  const kind = value === null ? "null" : typeof value === "object" ? value.constructor?.name ?? "object" : typeof value;
+  return `(${kind} cannot be shown here: ${error instanceof Error ? error.message : String(error)})`;
+}
+export {
+  LocalEngine,
+  createWorkerEngine,
+  serveEditorEngine
+};

package/dist/runtime/builtins/core/bundle.d.ts

@@ -0,0 +1,70 @@
+import type { DefinitionNodeRegistration } from "../../types.js";
+/**
+ * Pick and Pack: the two adapters between bundles and single-value ports.
+ *
+ * A node that wants one number takes it from a bundle through Pick; a handful
+ * of loose values become a bundle through Pack. Pick is cheap to re-cook and
+ * its output only changes when the picked field does, so with early cutoff a
+ * Pick is also the way to depend on one field of a bundle whose consumer
+ * cannot declare its fields.
+ */
+declare const pickDefinition: {
+    readonly apiVersion: 1;
+    readonly runsOn: "portable";
+    readonly label: "Pick";
+    readonly description: "Reads one field of a bundle";
+    readonly icon: "ListFilter";
+    readonly inputs: {
+        readonly bundle: {
+            readonly kind: "data";
+            readonly type: "bundle";
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {
+        readonly field: {
+            readonly type: "string";
+            readonly default: "";
+            readonly label: "Field";
+        };
+    };
+};
+declare const packDefinition: {
+    readonly apiVersion: 1;
+    readonly runsOn: "portable";
+    readonly label: "Pack";
+    readonly description: "Collects inputs into a bundle, one named field each";
+    readonly icon: "Package";
+    readonly inputs: {
+        readonly inputs: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly variadic: true;
+        };
+    };
+    readonly outputs: {
+        readonly bundle: {
+            readonly kind: "data";
+            readonly type: "bundle";
+        };
+    };
+    readonly props: {
+        readonly names: {
+            readonly type: "string";
+            readonly default: "";
+            readonly label: "Field names";
+            readonly description: "Comma-separated, one per input in order; an unnamed input becomes field_<n>";
+        };
+    };
+};
+/** The field names Pack gives its inputs. */
+export declare function packFieldNames(names: string, count: number): string[];
+export declare const pickRegistration: DefinitionNodeRegistration<typeof pickDefinition>;
+export declare const packRegistration: DefinitionNodeRegistration<typeof packDefinition>;
+export {};
+//# sourceMappingURL=bundle.d.ts.map

package/dist/runtime/builtins/core/bundle.js

@@ -0,0 +1,81 @@
+/**
+ * Pick and Pack: the two adapters between bundles and single-value ports.
+ *
+ * A node that wants one number takes it from a bundle through Pick; a handful
+ * of loose values become a bundle through Pack. Pick is cheap to re-cook and
+ * its output only changes when the picked field does, so with early cutoff a
+ * Pick is also the way to depend on one field of a bundle whose consumer
+ * cannot declare its fields.
+ */
+const pickDefinition = {
+    apiVersion: 1,
+    runsOn: "portable",
+    label: "Pick",
+    description: "Reads one field of a bundle",
+    icon: "ListFilter",
+    inputs: {
+        bundle: { kind: "data", type: "bundle" },
+    },
+    outputs: {
+        value: { kind: "data", type: "any" },
+    },
+    props: {
+        field: { type: "string", default: "", label: "Field" },
+    },
+};
+const packDefinition = {
+    apiVersion: 1,
+    runsOn: "portable",
+    label: "Pack",
+    description: "Collects inputs into a bundle, one named field each",
+    icon: "Package",
+    inputs: {
+        inputs: { kind: "data", type: "any", variadic: true },
+    },
+    outputs: {
+        bundle: { kind: "data", type: "bundle" },
+    },
+    props: {
+        names: {
+            type: "string",
+            default: "",
+            label: "Field names",
+            description: "Comma-separated, one per input in order; an unnamed input becomes field_<n>",
+        },
+    },
+};
+/** The field names Pack gives its inputs. */
+export function packFieldNames(names, count) {
+    const declared = String(names ?? "")
+        .split(",")
+        .map((name) => name.trim());
+    return Array.from({ length: count }, (_, index) => declared[index] || `field_${index}`);
+}
+export const pickRegistration = {
+    kind: "definition-v1",
+    moduleId: "cascade.core.Pick",
+    definition: pickDefinition,
+    loadExecute: async () => ({ inputs, outputs, props }) => {
+        const bundle = inputs.bundle;
+        const field = props.field.trim();
+        outputs.value.set(bundle && field && Object.prototype.hasOwnProperty.call(bundle, field)
+            ? bundle[field]
+            : null);
+    },
+};
+export const packRegistration = {
+    kind: "definition-v1",
+    moduleId: "cascade.core.Pack",
+    definition: packDefinition,
+    loadExecute: async () => ({ inputs, outputs, props }) => {
+        const values = inputs.inputs;
+        const names = packFieldNames(props.names, values.length);
+        const bundle = {};
+        names.forEach((name, index) => {
+            if (values[index] !== undefined)
+                bundle[name] = values[index];
+        });
+        outputs.bundle.set(bundle);
+    },
+};
+//# sourceMappingURL=bundle.js.map

package/dist/runtime/builtins/core/index.d.ts

@@ -1,11 +1,12 @@
 import type { DefinitionNodeRegistration } from "../../types.js";
+import { packRegistration, pickRegistration } from "./bundle.js";
 import { cameraRegistration } from "./camera.js";
 import { randomRegistration } from "./random.js";
 import { remapRegistration } from "./remap.js";
-import { mergeRegistration, nullRegistration, selectRegistration, switchRegistration } from "./routing.js";
+import { frozenRegistration, mergeRegistration, nullRegistration, selectRegistration, switchRegistration } from "./routing.js";
 import { feedbackRegistration, inputRegistration, outputRegistration, previousRegistration, subnetRegistration } from "./structural.js";
 import { timeRegistration } from "./time.js";
-export { cameraRegistration, feedbackRegistration, previousRegistration, inputRegistration, mergeRegistration, nullRegistration, outputRegistration, randomRegistration, remapRegistration, selectRegistration, subnetRegistration, switchRegistration, timeRegistration, };
+export { cameraRegistration, feedbackRegistration, frozenRegistration, previousRegistration, inputRegistration, mergeRegistration, nullRegistration, outputRegistration, packRegistration, pickRegistration, randomRegistration, remapRegistration, selectRegistration, subnetRegistration, switchRegistration, timeRegistration, };
 export declare const coreNodeRegistrations: readonly DefinitionNodeRegistration[];
 export declare function coreNodeRegistration(moduleId: string): DefinitionNodeRegistration | undefined;
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/builtins/core/index.js

@@ -1,10 +1,11 @@
+import { packRegistration, pickRegistration } from "./bundle.js";
 import { cameraRegistration } from "./camera.js";
 import { randomRegistration } from "./random.js";
 import { remapRegistration } from "./remap.js";
-import { mergeRegistration, nullRegistration, selectRegistration, switchRegistration } from "./routing.js";
+import { frozenRegistration, mergeRegistration, nullRegistration, selectRegistration, switchRegistration } from "./routing.js";
 import { feedbackRegistration, inputRegistration, outputRegistration, previousRegistration, subnetRegistration, } from "./structural.js";
 import { timeRegistration } from "./time.js";
-export { cameraRegistration, feedbackRegistration, previousRegistration, inputRegistration, mergeRegistration, nullRegistration, outputRegistration, randomRegistration, remapRegistration, selectRegistration, subnetRegistration, switchRegistration, timeRegistration, };
+export { cameraRegistration, feedbackRegistration, frozenRegistration, previousRegistration, inputRegistration, mergeRegistration, nullRegistration, outputRegistration, packRegistration, pickRegistration, randomRegistration, remapRegistration, selectRegistration, subnetRegistration, switchRegistration, timeRegistration, };
 export const coreNodeRegistrations = Object.freeze([
     subnetRegistration,
     inputRegistration,
@@ -13,12 +14,15 @@ export const coreNodeRegistrations = Object.freeze([
     mergeRegistration,
     nullRegistration,
     selectRegistration,
+    pickRegistration,
+    packRegistration,
     randomRegistration,
     remapRegistration,
     cameraRegistration,
     timeRegistration,
     feedbackRegistration,
     previousRegistration,
+    frozenRegistration,
 ]);
 const registrationsById = new Map(coreNodeRegistrations.map((registration) => [registration.moduleId, registration]));
 export function coreNodeRegistration(moduleId) {