@field/cascade 0.11.0 → 0.13.0

package/dist/cli/chunk-LTXWBXOM.js

@@ -0,0 +1,438 @@
+// packages/runtime/src/builtins/image/definitions.ts
+var contactSheetDefinition = {
+  apiVersion: 1,
+  label: "Contact Sheet",
+  description: "Lay images out as one labelled grid.",
+  icon: "LayoutGrid",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: {
+    images: { kind: "data", type: "image", variadic: true },
+    /** More images after the wired ones: image values or project-relative paths. */
+    list: { kind: "data", type: "array" }
+  },
+  outputs: {
+    image: { kind: "data", type: "image" },
+    asset: { kind: "data", type: "asset" }
+  },
+  props: {
+    columns: { type: "int", default: 0, min: 0, max: 64, description: "0: as square as the count allows." },
+    gap: { type: "int", default: 16, min: 0, max: 512 },
+    background: { type: "color", default: [1, 1, 1, 1], label: "Background" },
+    cellWidth: { type: "int", default: 0, min: 0, max: 8192, description: "0: images at their own size. Otherwise each is scaled to fit this width." },
+    labels: { type: "string", default: "", description: "One label per line, in image order." },
+    labelSize: { type: "int", default: 14, min: 6, max: 128 },
+    labelColor: { type: "color", default: [0.1, 0.1, 0.1, 1], label: "Label Colour" },
+    filename: { type: "string", default: "contact-sheet.png", label: "Filename" }
+  }
+};
+var colorDefinition = {
+  apiVersion: 1,
+  label: "Color",
+  description: "A solid colour.",
+  icon: "Square",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    color: { type: "color", default: [1, 1, 1, 1], label: "Color" },
+    resolution: { type: "vec2i", default: [512, 512], min: 1, max: 4096, label: "Resolution" }
+  }
+};
+var checkersDefinition = {
+  apiVersion: 1,
+  label: "Checkers",
+  description: "A checkerboard.",
+  icon: "Grid",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    color1: { type: "color", default: [1, 1, 1, 1], label: "Color 1" },
+    color2: { type: "color", default: [0, 0, 0, 1], label: "Color 2" },
+    mode: {
+      type: "string",
+      default: "size",
+      label: "Mode",
+      control: "select",
+      options: [{ value: "size", label: "Size" }, { value: "divisions", label: "Divisions" }]
+    },
+    size: { type: "float", default: 32, min: 1, max: 512, step: 0.1, label: "Size", description: "Cell size in pixels (mode Size)." },
+    divisions: { type: "int", default: 16, min: 1, max: 512, step: 1, label: "Divisions", description: "Cells across (mode Divisions)." },
+    centered: { type: "bool", default: false, label: "Centered" },
+    resolution: { type: "vec2i", default: [512, 512], min: 1, max: 4096, label: "Resolution" }
+  }
+};
+var noiseDefinition = {
+  apiVersion: 1,
+  label: "Noise",
+  description: "Fractal simplex noise, grey.",
+  icon: "Cloud",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    seed: { type: "int", default: 0, min: 0, max: 1e4, step: 1, label: "Seed" },
+    scale: { type: "float", default: 0.01, min: 1e-3, max: 1, step: 1e-3, label: "Scale" },
+    iterations: { type: "int", default: 4, min: 1, max: 8, step: 1, label: "Iterations" },
+    resolution: { type: "vec2i", default: [512, 512], min: 1, max: 4096, label: "Resolution" }
+  }
+};
+var rampDefinition = {
+  apiVersion: 1,
+  label: "Ramp",
+  description: "A colour ramp: horizontal, vertical, radial or concentric.",
+  icon: "Gradient",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    type: {
+      type: "string",
+      default: "horizontal",
+      label: "Type",
+      control: "select",
+      options: [
+        { value: "horizontal", label: "Horizontal" },
+        { value: "vertical", label: "Vertical" },
+        { value: "radial", label: "Radial" },
+        { value: "concentric", label: "Concentric" }
+      ]
+    },
+    points: {
+      type: "array",
+      label: "Ramp",
+      description: "{ position, color, interpolation: linear | smooth | constant } stops.",
+      default: [
+        { position: 0, color: { r: 0, g: 0, b: 0 }, interpolation: "linear" },
+        { position: 1, color: { r: 1, g: 1, b: 1 }, interpolation: "linear" }
+      ]
+    },
+    resolution: { type: "vec2i", default: [512, 512], min: 1, max: 4096, label: "Resolution" }
+  }
+};
+var textDefinition = {
+  apiVersion: 1,
+  label: "Text",
+  description: "Text drawn with a CSS font family, or a font file from the project.",
+  icon: "Type",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    text: { type: "string", default: "Hello, World!", label: "Text", control: "textarea" },
+    font: {
+      type: "string",
+      default: "Inter, system-ui, sans-serif",
+      label: "Font",
+      description: "A CSS font family list, or a project font file (.otf, .ttf, .woff, .woff2); a file that is not there falls back to sans-serif."
+    },
+    fontSize: { type: "float", default: 48, min: 1, max: 500, step: 1, label: "Font Size", control: "slider" },
+    fontWeight: {
+      type: "string",
+      default: "normal",
+      label: "Font Weight",
+      control: "select",
+      options: [
+        { value: "normal", label: "Normal" },
+        { value: "bold", label: "Bold" },
+        { value: "100", label: "Thin (100)" },
+        { value: "200", label: "Extra Light (200)" },
+        { value: "300", label: "Light (300)" },
+        { value: "500", label: "Medium (500)" },
+        { value: "600", label: "Semi Bold (600)" },
+        { value: "700", label: "Bold (700)" },
+        { value: "800", label: "Extra Bold (800)" },
+        { value: "900", label: "Black (900)" }
+      ]
+    },
+    fontStyle: {
+      type: "string",
+      default: "normal",
+      label: "Font Style",
+      control: "select",
+      options: [{ value: "normal", label: "Normal" }, { value: "italic", label: "Italic" }, { value: "oblique", label: "Oblique" }]
+    },
+    alignH: {
+      type: "string",
+      default: "center",
+      label: "Horizontal Align",
+      control: "select",
+      options: [{ value: "left", label: "Left" }, { value: "center", label: "Center" }, { value: "right", label: "Right" }]
+    },
+    alignV: {
+      type: "string",
+      default: "middle",
+      label: "Vertical Align",
+      control: "select",
+      options: [{ value: "top", label: "Top" }, { value: "middle", label: "Middle" }, { value: "bottom", label: "Bottom" }]
+    },
+    color: { type: "color", default: [1, 1, 1, 1], label: "Color" },
+    backgroundColor: { type: "color", default: [0, 0, 0, 0], label: "Background" },
+    resolution: { type: "vec2i", default: [512, 512], min: 1, max: 4096, label: "Resolution" },
+    offset: { type: "vec2", default: [0, 0], min: -2048, max: 2048, step: 1, label: "Offset" },
+    rotation: { type: "float", default: 0, min: -180, max: 180, step: 0.1, label: "Rotation", control: "slider" },
+    letterSpacing: { type: "float", default: 0, min: -50, max: 100, step: 0.5, label: "Letter Spacing", control: "slider" },
+    lineHeight: { type: "float", default: 1.2, min: 0.5, max: 3, step: 0.05, label: "Line Height", control: "slider" },
+    opacity: { type: "float", default: 1, min: 0, max: 1, step: 0.01, label: "Opacity", control: "slider" }
+  }
+};
+var imageDefinition = {
+  apiVersion: 1,
+  label: "File",
+  description: "An image file from the project, or an image input, optionally resized.",
+  icon: "FileImage",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: { image: { kind: "data", type: "image", description: "Used instead of the file when wired." } },
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    file: { type: "string", default: "", label: "File", description: "A project-relative image path." },
+    resolutionMode: {
+      type: "string",
+      default: "original",
+      label: "Resolution Mode",
+      control: "select",
+      options: [{ value: "original", label: "Original" }, { value: "max", label: "Max Resolution" }, { value: "fixed", label: "Fixed Resolution" }]
+    },
+    maxResolution: { type: "vec2i", default: [2048, 2048], min: 1, max: 4096, label: "Max Resolution" },
+    fixedResolution: { type: "vec2i", default: [512, 512], min: 1, max: 4096, label: "Fixed Resolution" }
+  }
+};
+var blurDefinition = {
+  apiVersion: 1,
+  label: "Blur",
+  description: "Box (three passes, fast) or true Gaussian blur.",
+  icon: "Droplets",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: { image: { kind: "data", type: "image" } },
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    method: {
+      type: "string",
+      default: "box",
+      label: "Method",
+      control: "select",
+      options: [{ value: "box", label: "Box (Fast)" }, { value: "gaussian", label: "Gaussian (Accurate)" }]
+    },
+    radius: { type: "float", default: 5, min: 0, max: 100, step: 0.1, label: "Radius" },
+    wrapEdges: { type: "bool", default: false, label: "Wrap Edges" }
+  }
+};
+var normalMapDefinition = {
+  apiVersion: 1,
+  label: "Normal Map",
+  description: "A normal map from the red (or grey) channel as height.",
+  icon: "Box",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: { image: { kind: "data", type: "image" } },
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    scale: { type: "float", default: 1, min: 0, max: 10, step: 0.1, label: "Scale" },
+    flipX: { type: "bool", default: false, label: "Flip X" },
+    flipY: { type: "bool", default: false, label: "Flip Y" }
+  }
+};
+var resizeDefinition = {
+  apiVersion: 1,
+  label: "Resize",
+  description: "Scale an image, or resize it to a fixed size, bilinear.",
+  icon: "Maximize2",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: { image: { kind: "data", type: "image" } },
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    mode: {
+      type: "string",
+      default: "scale",
+      label: "Mode",
+      control: "select",
+      options: [{ value: "scale", label: "Scale" }, { value: "fixed", label: "Fixed" }]
+    },
+    scale: { type: "float", default: 1, min: 0.1, max: 10, step: 0.1, label: "Scale" },
+    width: { type: "int", default: 512, min: 1, max: 4096, step: 1, label: "Width" },
+    height: { type: "int", default: 512, min: 1, max: 4096, step: 1, label: "Height" }
+  }
+};
+var transformDefinition = {
+  apiVersion: 1,
+  label: "Transform",
+  description: "Rotate, translate and scale an image about a pivot.",
+  icon: "Move",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: { image: { kind: "data", type: "image" } },
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    translate: { type: "vec2", default: [0, 0], min: -2048, max: 2048, step: 1, label: "Translate" },
+    rotation: { type: "float", default: 0, min: -180, max: 180, step: 0.1, label: "Rotation" },
+    scale: { type: "vec2", default: [1, 1], min: 0.01, max: 10, step: 0.01, label: "Scale" },
+    uniformScale: { type: "bool", default: true, label: "Uniform Scale" },
+    pivot: {
+      type: "string",
+      default: "center",
+      label: "Pivot",
+      control: "select",
+      options: [
+        { value: "center", label: "Center" },
+        { value: "top-left", label: "Top Left" },
+        { value: "top-right", label: "Top Right" },
+        { value: "bottom-left", label: "Bottom Left" },
+        { value: "bottom-right", label: "Bottom Right" },
+        { value: "custom", label: "Custom" }
+      ]
+    },
+    customPivot: { type: "vec2", default: [0.5, 0.5], min: 0, max: 1, step: 0.01, label: "Custom Pivot" },
+    filter: {
+      type: "string",
+      default: "bilinear",
+      label: "Filter",
+      control: "select",
+      options: [{ value: "nearest", label: "Nearest" }, { value: "bilinear", label: "Bilinear" }]
+    },
+    wrap: {
+      type: "string",
+      default: "clamp",
+      label: "Wrap Mode",
+      control: "select",
+      options: [
+        { value: "clamp", label: "Clamp" },
+        { value: "repeat", label: "Repeat" },
+        { value: "mirror", label: "Mirror" },
+        { value: "transparent", label: "Transparent" }
+      ]
+    }
+  }
+};
+var compositeDefinition = {
+  apiVersion: 1,
+  label: "Composite",
+  description: "Blend image2 over image1.",
+  icon: "Layers",
+  runsOn: "portable",
+  capabilities: ["assets"],
+  inputs: {
+    image1: { kind: "data", type: "image" },
+    image2: { kind: "data", type: "image" }
+  },
+  outputs: { image: { kind: "data", type: "image" } },
+  props: {
+    blendMode: {
+      type: "string",
+      default: "multiply",
+      label: "Blend Mode",
+      control: "select",
+      options: [
+        { value: "normal", label: "Normal" },
+        { value: "multiply", label: "Multiply" },
+        { value: "screen", label: "Screen" },
+        { value: "overlay", label: "Overlay" },
+        { value: "darken", label: "Darken" },
+        { value: "lighten", label: "Lighten" },
+        { value: "color-dodge", label: "Color Dodge" },
+        { value: "color-burn", label: "Color Burn" },
+        { value: "hard-light", label: "Hard Light" },
+        { value: "soft-light", label: "Soft Light" },
+        { value: "difference", label: "Difference" },
+        { value: "exclusion", label: "Exclusion" },
+        { value: "add", label: "Add" },
+        { value: "subtract", label: "Subtract" },
+        { value: "divide", label: "Divide" },
+        { value: "pin-light", label: "Pin Light" },
+        { value: "vivid-light", label: "Vivid Light" },
+        { value: "linear-dodge", label: "Linear Dodge" },
+        { value: "linear-burn", label: "Linear Burn" }
+      ]
+    },
+    opacity: { type: "float", default: 1, min: 0, max: 1, step: 0.01, label: "Opacity" },
+    outputResolution: {
+      type: "string",
+      default: "input1",
+      label: "Output Resolution",
+      control: "select",
+      options: [
+        { value: "input1", label: "Use Input 1" },
+        { value: "input2", label: "Use Input 2" },
+        { value: "largest", label: "Largest Input" },
+        { value: "smallest", label: "Smallest Input" },
+        { value: "custom", label: "Custom" }
+      ]
+    },
+    customResolution: { type: "vec2i", default: [512, 512], min: 1, max: 4096, label: "Resolution" },
+    fitMode: {
+      type: "string",
+      default: "fill",
+      label: "Fit Mode",
+      control: "select",
+      options: [
+        { value: "fill", label: "Fill (Crop)" },
+        { value: "fit", label: "Fit (Letterbox)" },
+        { value: "stretch", label: "Stretch" },
+        { value: "native", label: "Native (No Scale)" }
+      ]
+    }
+  }
+};
+
+// packages/runtime/src/builtins/image/index.ts
+function lazy(name, definition, load) {
+  return { kind: "definition-v1", moduleId: `cascade.image.${name}`, definition, loadExecute: load };
+}
+var contactSheetRegistration = lazy("ContactSheet", contactSheetDefinition, async () => (await import("./contactSheet-2PQVRUFW.js")).executeContactSheet);
+var colorRegistration = lazy("Color", colorDefinition, async () => (await import("./generators-YU7GB4MD.js")).executeColor);
+var checkersRegistration = lazy("Checkers", checkersDefinition, async () => (await import("./generators-YU7GB4MD.js")).executeCheckers);
+var noiseRegistration = lazy("Noise", noiseDefinition, async () => (await import("./generators-YU7GB4MD.js")).executeNoise);
+var rampRegistration = lazy("Ramp", rampDefinition, async () => (await import("./generators-YU7GB4MD.js")).executeRamp);
+var textRegistration = lazy("Text", textDefinition, async () => (await import("./text-MB3EKR4H.js")).executeText);
+var imageRegistration = lazy("Image", imageDefinition, async () => (await import("./file-3HTQHPYQ.js")).executeImage);
+var blurRegistration = lazy("Blur", blurDefinition, async () => (await import("./filters-6ODFWYK4.js")).executeBlur);
+var normalMapRegistration = lazy("NormalMap", normalMapDefinition, async () => (await import("./filters-6ODFWYK4.js")).executeNormalMap);
+var resizeRegistration = lazy("Resize", resizeDefinition, async () => (await import("./filters-6ODFWYK4.js")).executeResize);
+var transformRegistration = lazy("Transform", transformDefinition, async () => (await import("./filters-6ODFWYK4.js")).executeTransform);
+var compositeRegistration = lazy("Composite", compositeDefinition, async () => (await import("./filters-6ODFWYK4.js")).executeComposite);
+var imageNodeRegistrations = Object.freeze([
+  colorRegistration,
+  checkersRegistration,
+  noiseRegistration,
+  rampRegistration,
+  textRegistration,
+  imageRegistration,
+  blurRegistration,
+  normalMapRegistration,
+  resizeRegistration,
+  transformRegistration,
+  compositeRegistration,
+  contactSheetRegistration
+]);
+
+export {
+  contactSheetDefinition,
+  colorDefinition,
+  checkersDefinition,
+  noiseDefinition,
+  rampDefinition,
+  textDefinition,
+  imageDefinition,
+  blurDefinition,
+  normalMapDefinition,
+  resizeDefinition,
+  transformDefinition,
+  compositeDefinition,
+  contactSheetRegistration,
+  colorRegistration,
+  checkersRegistration,
+  noiseRegistration,
+  rampRegistration,
+  textRegistration,
+  imageRegistration,
+  blurRegistration,
+  normalMapRegistration,
+  resizeRegistration,
+  transformRegistration,
+  compositeRegistration,
+  imageNodeRegistrations
+};
+//# sourceMappingURL=chunk-LTXWBXOM.js.map

package/dist/cli/chunk-MI5JLQYA.js

@@ -0,0 +1,220 @@
+import {
+  LIGHT_DEFAULTS,
+  geoNodeRegistrations,
+  isLight,
+  isScene
+} from "./chunk-GRIN2DDP.js";
+import {
+  coreNodeRegistrations,
+  isCamera
+} from "./chunk-X4WKAOQP.js";
+import {
+  mathNodeRegistrations
+} from "./chunk-QQPA2ZHH.js";
+import {
+  popNodeRegistrations
+} from "./chunk-KH4MUBKF.js";
+import {
+  imageNodeRegistrations
+} from "./chunk-LTXWBXOM.js";
+import {
+  assertNodeRegistrations
+} from "./chunk-JVOCK5W4.js";
+
+// packages/runtime/src/builtins/scene/definitions.ts
+var SCENE_NAMESPACE = "cascade.scene";
+function sceneModuleId(name) {
+  return `${SCENE_NAMESPACE}.${name}`;
+}
+var sceneDefinition = {
+  apiVersion: 1,
+  label: "Scene",
+  description: "Geometry, a camera and lights, assembled into a scene. Attach anything to the input.",
+  icon: "Box",
+  runsOn: "portable",
+  inputs: {
+    inputs: {
+      kind: "data",
+      type: "any",
+      variadic: true,
+      description: "Geometry, one camera, and lights, in any order. Scenes are flattened."
+    }
+  },
+  outputs: {
+    scene: { kind: "data", type: "scene" }
+  },
+  props: {}
+};
+function executeScene(context) {
+  const geometry = [];
+  const lights = [];
+  let camera = null;
+  let cameraFrom = -1;
+  context.inputs.inputs.forEach((value, index) => {
+    if (value === void 0 || value === null) return;
+    if (isScene(value)) {
+      geometry.push(...value.geometry);
+      lights.push(...value.lights);
+      if (value.camera !== null) {
+        if (camera !== null)
+          throw new Error(
+            `cascade.scene.Scene has two cameras, on inputs ${cameraFrom} and ${index}. A scene has one viewpoint; remove one or use a Switch to choose between them.`
+          );
+        camera = value.camera;
+        cameraFrom = index;
+      }
+      return;
+    }
+    if (isCamera(value)) {
+      if (camera !== null)
+        throw new Error(
+          `cascade.scene.Scene has two cameras, on inputs ${cameraFrom} and ${index}. A scene has one viewpoint; remove one or use a Switch to choose between them.`
+        );
+      camera = value;
+      cameraFrom = index;
+      return;
+    }
+    if (isLight(value)) {
+      lights.push(value);
+      return;
+    }
+    if (typeof value === "object" && value.kind === "geometry") {
+      geometry.push(value);
+      return;
+    }
+    throw new Error(
+      `cascade.scene.Scene input ${index} is not geometry, a camera, a light or a scene (received ${describe(value)}). A scene can only hold those.`
+    );
+  });
+  context.outputs.scene.set({ geometry, camera, lights });
+}
+function describe(value) {
+  if (Array.isArray(value)) return `an array of ${value.length}`;
+  if (typeof value === "object" && value !== null) {
+    const kind = value.kind;
+    return typeof kind === "string" ? `an object of kind "${kind}"` : "an object";
+  }
+  return `a ${typeof value}`;
+}
+var lightDefinition = {
+  apiVersion: 1,
+  label: "Light",
+  description: "A light, following Houdini's /obj/hlight. Nothing shades with lights yet \u2014 the viewport draws wireframe and points.",
+  icon: "Lightbulb",
+  runsOn: "portable",
+  inputs: {
+    translate: {
+      kind: "data",
+      type: "vec3",
+      default: [0, 0, 5],
+      description: "World position. Ignored for a distant or ambient light."
+    },
+    direction: {
+      kind: "data",
+      type: "vec3",
+      default: [0, 0, -1],
+      description: "Direction the light points. Used by distant and spot."
+    },
+    color: {
+      kind: "data",
+      type: "color",
+      default: [1, 1, 1, 1],
+      description: "Houdini light_color."
+    },
+    intensity: {
+      kind: "data",
+      type: "float",
+      default: 1,
+      min: 0,
+      description: "Houdini light_intensity."
+    }
+  },
+  outputs: {
+    light: { kind: "data", type: "light" }
+  },
+  props: {
+    type: {
+      type: "string",
+      default: "point",
+      label: "Light Type",
+      control: "select",
+      options: [
+        { value: "point", label: "Point" },
+        { value: "distant", label: "Distant - directional" },
+        { value: "ambient", label: "Ambient" },
+        { value: "spot", label: "Spot" }
+      ],
+      description: "Houdini light_type. Distant is what other renderers call directional."
+    },
+    coneangle: {
+      type: "float",
+      default: 45,
+      min: 0,
+      max: 180,
+      label: "Cone Angle",
+      description: "Degrees. Spot only."
+    }
+  }
+};
+function executeLight(context) {
+  const type = context.props.type;
+  context.outputs.light.set({
+    type: type === "distant" || type === "ambient" || type === "spot" ? type : LIGHT_DEFAULTS.type,
+    translate: context.inputs.translate ?? LIGHT_DEFAULTS.translate,
+    direction: context.inputs.direction ?? LIGHT_DEFAULTS.direction,
+    color: context.inputs.color ?? LIGHT_DEFAULTS.color,
+    intensity: context.inputs.intensity ?? LIGHT_DEFAULTS.intensity,
+    coneangle: context.props.coneangle
+  });
+}
+var sceneRegistration = {
+  kind: "definition-v1",
+  moduleId: sceneModuleId("Scene"),
+  definition: sceneDefinition,
+  loadExecute: async () => executeScene
+};
+var lightRegistration = {
+  kind: "definition-v1",
+  moduleId: sceneModuleId("Light"),
+  definition: lightDefinition,
+  loadExecute: async () => executeLight
+};
+var sceneNodeRegistrations = Object.freeze([sceneRegistration, lightRegistration]);
+var sceneNodeDefinitions = Object.freeze([
+  [sceneModuleId("Scene"), sceneDefinition],
+  [sceneModuleId("Light"), lightDefinition]
+]);
+
+// packages/runtime/src/builtins/index.ts
+var builtinNodeRegistrations = Object.freeze([
+  ...coreNodeRegistrations,
+  ...geoNodeRegistrations,
+  ...mathNodeRegistrations,
+  ...popNodeRegistrations,
+  ...sceneNodeRegistrations,
+  ...imageNodeRegistrations,
+  ...assertNodeRegistrations
+]);
+var registrationsById = new Map(
+  builtinNodeRegistrations.map((registration) => [
+    registration.moduleId,
+    registration
+  ])
+);
+function builtinNodeRegistration(moduleId) {
+  return registrationsById.get(moduleId);
+}
+
+// src/cli/headlessBuiltins.ts
+var headlessBuiltinRegistrations = builtinNodeRegistrations;
+function headlessBuiltin(moduleId) {
+  return builtinNodeRegistration(moduleId);
+}
+
+export {
+  builtinNodeRegistrations,
+  builtinNodeRegistration,
+  headlessBuiltinRegistrations,
+  headlessBuiltin
+};
+//# sourceMappingURL=chunk-MI5JLQYA.js.map