@field/cascade 0.3.1 → 0.5.1

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

@@ -210,6 +210,26 @@ export declare const svgExportDefinition: {
             readonly default: 0;
             readonly label: "Margin";
         };
+        /**
+         * An explicit world rectangle, `[minX, minY, maxX, maxY]`, instead of the
+         * geometry's own bounds. All zero derives them as before.
+         *
+         * A frame sequence needs it: derived bounds give every frame its own
+         * viewBox, so a growing drawing appears to zoom out over the animation.
+         */
+        readonly bounds: {
+            readonly type: "vec4";
+            readonly default: readonly [0, 0, 0, 0];
+            readonly label: "Bounds";
+        };
+        /** A ground behind the drawing. Fully transparent leaves the document
+         *  transparent, which is what plotter work wants. */
+        readonly background: {
+            readonly type: "color";
+            readonly default: readonly [0, 0, 0, 0];
+            readonly label: "Background";
+            readonly description: "A ground behind the drawing. Transparent by default, because a plotter wants paper.";
+        };
         readonly stroke: {
             readonly type: "color";
             readonly default: readonly [0, 0, 0, 1];
@@ -263,6 +283,110 @@ export declare const svgExportDefinition: {
         };
     };
 };
+export declare const renderDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "Render";
+    readonly description: "Draw a scene through a camera, as a raster.";
+    readonly icon: "Camera";
+    readonly runsOn: "portable";
+    readonly capabilities: readonly ["assets"];
+    readonly inputs: {
+        /**
+         * A scene, or a geometry — `geometry` widens to `scene`, so wiring a
+         * geometry straight in still works and arrives through `asScene`.
+         *
+         * Taking a scene rather than a geometry is what makes the viewport and this
+         * node incapable of disagreeing about framing: both read the same object,
+         * so the picture on screen and the picture in the PNG come from one camera
+         * and one list of geometry rather than from two paths that have to be kept
+         * in step by hand.
+         */
+        readonly scene: {
+            readonly kind: "data";
+            readonly type: "scene";
+        };
+        /**
+         * The camera, and required in the sense that matters: it may come from the
+         * scene instead, but it may not be invented. A render with an implicit
+         * camera is a render nobody can reproduce, and `cascade.core.Camera` is one
+         * node away.
+         *
+         * Wired here it **overrides** the scene's own camera, which is what lets one
+         * scene be rendered from several viewpoints without rebuilding it — and is
+         * also why the viewport's navigated camera never reaches this node. A view
+         * you dragged is not a document.
+         */
+        readonly camera: {
+            readonly kind: "data";
+            readonly type: "camera";
+        };
+    };
+    readonly outputs: {
+        readonly image: {
+            readonly kind: "data";
+            readonly type: "image";
+        };
+        readonly asset: {
+            readonly kind: "data";
+            readonly type: "asset";
+        };
+    };
+    readonly props: {
+        /** Pixels. Separate from the camera's own `resolution`, which describes
+         *  the frame the projection assumes — so a preview renders small and frames
+         *  identically to the full-size render. */
+        readonly size: {
+            readonly type: "vec2i";
+            readonly default: readonly [1280, 720];
+            readonly min: 16;
+            readonly max: 8192;
+        };
+        readonly filename: {
+            readonly type: "string";
+            readonly default: "render.png";
+            readonly label: "Filename";
+        };
+        readonly background: {
+            readonly type: "color";
+            readonly default: readonly [0, 0, 0, 0];
+            readonly label: "Background";
+        };
+        /** Fallback for a primitive with no `Cd`, exactly as SvgExport's is. */
+        readonly stroke: {
+            readonly type: "color";
+            readonly default: readonly [0, 0, 0, 1];
+            readonly label: "Stroke";
+        };
+        readonly strokeWidth: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0;
+            readonly max: 200;
+            readonly step: 0.05;
+        };
+        readonly opacity: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        /** Points no primitive claimed. Off by default: a trail system has
+         *  thousands of vertices and a dot on every one buries the strokes. */
+        readonly drawPoints: {
+            readonly type: "bool";
+            readonly default: false;
+            readonly label: "Draw Loose Points";
+        };
+        readonly pointRadius: {
+            readonly type: "float";
+            readonly default: 1.5;
+            readonly min: 0;
+            readonly max: 50;
+            readonly step: 0.1;
+        };
+    };
+};
 export declare const geoNodeDefinitions: readonly [readonly ["cascade.geo.Rectangle", {
     readonly apiVersion: 1;
     readonly label: "Rectangle";
@@ -470,6 +594,26 @@ export declare const geoNodeDefinitions: readonly [readonly ["cascade.geo.Rectan
             readonly default: 0;
             readonly label: "Margin";
         };
+        /**
+         * An explicit world rectangle, `[minX, minY, maxX, maxY]`, instead of the
+         * geometry's own bounds. All zero derives them as before.
+         *
+         * A frame sequence needs it: derived bounds give every frame its own
+         * viewBox, so a growing drawing appears to zoom out over the animation.
+         */
+        readonly bounds: {
+            readonly type: "vec4";
+            readonly default: readonly [0, 0, 0, 0];
+            readonly label: "Bounds";
+        };
+        /** A ground behind the drawing. Fully transparent leaves the document
+         *  transparent, which is what plotter work wants. */
+        readonly background: {
+            readonly type: "color";
+            readonly default: readonly [0, 0, 0, 0];
+            readonly label: "Background";
+            readonly description: "A ground behind the drawing. Transparent by default, because a plotter wants paper.";
+        };
         readonly stroke: {
             readonly type: "color";
             readonly default: readonly [0, 0, 0, 1];
@@ -522,5 +666,108 @@ export declare const geoNodeDefinitions: readonly [readonly ["cascade.geo.Rectan
             readonly description: "Decimal places on emitted coordinates.";
         };
     };
+}], readonly ["cascade.geo.Render", {
+    readonly apiVersion: 1;
+    readonly label: "Render";
+    readonly description: "Draw a scene through a camera, as a raster.";
+    readonly icon: "Camera";
+    readonly runsOn: "portable";
+    readonly capabilities: readonly ["assets"];
+    readonly inputs: {
+        /**
+         * A scene, or a geometry — `geometry` widens to `scene`, so wiring a
+         * geometry straight in still works and arrives through `asScene`.
+         *
+         * Taking a scene rather than a geometry is what makes the viewport and this
+         * node incapable of disagreeing about framing: both read the same object,
+         * so the picture on screen and the picture in the PNG come from one camera
+         * and one list of geometry rather than from two paths that have to be kept
+         * in step by hand.
+         */
+        readonly scene: {
+            readonly kind: "data";
+            readonly type: "scene";
+        };
+        /**
+         * The camera, and required in the sense that matters: it may come from the
+         * scene instead, but it may not be invented. A render with an implicit
+         * camera is a render nobody can reproduce, and `cascade.core.Camera` is one
+         * node away.
+         *
+         * Wired here it **overrides** the scene's own camera, which is what lets one
+         * scene be rendered from several viewpoints without rebuilding it — and is
+         * also why the viewport's navigated camera never reaches this node. A view
+         * you dragged is not a document.
+         */
+        readonly camera: {
+            readonly kind: "data";
+            readonly type: "camera";
+        };
+    };
+    readonly outputs: {
+        readonly image: {
+            readonly kind: "data";
+            readonly type: "image";
+        };
+        readonly asset: {
+            readonly kind: "data";
+            readonly type: "asset";
+        };
+    };
+    readonly props: {
+        /** Pixels. Separate from the camera's own `resolution`, which describes
+         *  the frame the projection assumes — so a preview renders small and frames
+         *  identically to the full-size render. */
+        readonly size: {
+            readonly type: "vec2i";
+            readonly default: readonly [1280, 720];
+            readonly min: 16;
+            readonly max: 8192;
+        };
+        readonly filename: {
+            readonly type: "string";
+            readonly default: "render.png";
+            readonly label: "Filename";
+        };
+        readonly background: {
+            readonly type: "color";
+            readonly default: readonly [0, 0, 0, 0];
+            readonly label: "Background";
+        };
+        /** Fallback for a primitive with no `Cd`, exactly as SvgExport's is. */
+        readonly stroke: {
+            readonly type: "color";
+            readonly default: readonly [0, 0, 0, 1];
+            readonly label: "Stroke";
+        };
+        readonly strokeWidth: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0;
+            readonly max: 200;
+            readonly step: 0.05;
+        };
+        readonly opacity: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+        };
+        /** Points no primitive claimed. Off by default: a trail system has
+         *  thousands of vertices and a dot on every one buries the strokes. */
+        readonly drawPoints: {
+            readonly type: "bool";
+            readonly default: false;
+            readonly label: "Draw Loose Points";
+        };
+        readonly pointRadius: {
+            readonly type: "float";
+            readonly default: 1.5;
+            readonly min: 0;
+            readonly max: 50;
+            readonly step: 0.1;
+        };
+    };
 }]];
 //# sourceMappingURL=definitions.d.ts.map

package/dist/runtime/builtins/geo/definitions.js

@@ -118,6 +118,22 @@ export const svgExportDefinition = {
         },
         height: { type: "float", default: 0, min: 0, label: "Height" },
         margin: { type: "float", default: 0, label: "Margin" },
+        /**
+         * An explicit world rectangle, `[minX, minY, maxX, maxY]`, instead of the
+         * geometry's own bounds. All zero derives them as before.
+         *
+         * A frame sequence needs it: derived bounds give every frame its own
+         * viewBox, so a growing drawing appears to zoom out over the animation.
+         */
+        bounds: { type: "vec4", default: [0, 0, 0, 0], label: "Bounds" },
+        /** A ground behind the drawing. Fully transparent leaves the document
+         *  transparent, which is what plotter work wants. */
+        background: {
+            type: "color",
+            default: [0, 0, 0, 0],
+            label: "Background",
+            description: "A ground behind the drawing. Transparent by default, because a plotter wants paper.",
+        },
         stroke: {
             type: "color",
             default: [0, 0, 0, 1],
@@ -171,6 +187,59 @@ export const svgExportDefinition = {
         },
     },
 };
+export const renderDefinition = {
+    apiVersion: 1,
+    label: "Render",
+    description: "Draw a scene through a camera, as a raster.",
+    icon: "Camera",
+    runsOn: "portable",
+    capabilities: ["assets"],
+    inputs: {
+        /**
+         * A scene, or a geometry — `geometry` widens to `scene`, so wiring a
+         * geometry straight in still works and arrives through `asScene`.
+         *
+         * Taking a scene rather than a geometry is what makes the viewport and this
+         * node incapable of disagreeing about framing: both read the same object,
+         * so the picture on screen and the picture in the PNG come from one camera
+         * and one list of geometry rather than from two paths that have to be kept
+         * in step by hand.
+         */
+        scene: { kind: "data", type: "scene" },
+        /**
+         * The camera, and required in the sense that matters: it may come from the
+         * scene instead, but it may not be invented. A render with an implicit
+         * camera is a render nobody can reproduce, and `cascade.core.Camera` is one
+         * node away.
+         *
+         * Wired here it **overrides** the scene's own camera, which is what lets one
+         * scene be rendered from several viewpoints without rebuilding it — and is
+         * also why the viewport's navigated camera never reaches this node. A view
+         * you dragged is not a document.
+         */
+        camera: { kind: "data", type: "camera" },
+    },
+    outputs: {
+        image: { kind: "data", type: "image" },
+        asset: { kind: "data", type: "asset" },
+    },
+    props: {
+        /** Pixels. Separate from the camera's own `resolution`, which describes
+         *  the frame the projection assumes — so a preview renders small and frames
+         *  identically to the full-size render. */
+        size: { type: "vec2i", default: [1280, 720], min: 16, max: 8192 },
+        filename: { type: "string", default: "render.png", label: "Filename" },
+        background: { type: "color", default: [0, 0, 0, 0], label: "Background" },
+        /** Fallback for a primitive with no `Cd`, exactly as SvgExport's is. */
+        stroke: { type: "color", default: [0, 0, 0, 1], label: "Stroke" },
+        strokeWidth: { type: "float", default: 1, min: 0, max: 200, step: 0.05 },
+        opacity: { type: "float", default: 1, min: 0, max: 1, step: 0.01 },
+        /** Points no primitive claimed. Off by default: a trail system has
+         *  thousands of vertices and a dot on every one buries the strokes. */
+        drawPoints: { type: "bool", default: false, label: "Draw Loose Points" },
+        pointRadius: { type: "float", default: 1.5, min: 0, max: 50, step: 0.1 },
+    },
+};
 export const geoNodeDefinitions = Object.freeze([
     ["cascade.geo.Rectangle", rectangleDefinition],
     ["cascade.geo.Circle", circleDefinition],
@@ -178,5 +247,6 @@ export const geoNodeDefinitions = Object.freeze([
     ["cascade.geo.Merge", mergeDefinition],
     ["cascade.geo.CopyToPoints", copyToPointsDefinition],
     ["cascade.geo.SvgExport", svgExportDefinition],
+    ["cascade.geo.Render", renderDefinition],
 ]);
 //# sourceMappingURL=definitions.js.map

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

@@ -2,6 +2,7 @@ import type { DefinitionNodeRegistration } from "../../types.js";
 import { copyToPointsRegistration } from "./copyToPoints.js";
 import { circleRegistration, rectangleRegistration } from "./generators.js";
 import { mergeRegistration } from "./merge.js";
+import { renderRegistration } from "./render.js";
 import { svgExportRegistration } from "./svgExport.js";
 import { transformRegistration } from "./transform.js";
 /**
@@ -16,7 +17,7 @@ import { transformRegistration } from "./transform.js";
  *
  * The namespace lives in `namespace.ts`, once.
  */
-export { circleRegistration, copyToPointsRegistration, mergeRegistration, rectangleRegistration, svgExportRegistration, transformRegistration, };
+export { circleRegistration, copyToPointsRegistration, mergeRegistration, rectangleRegistration, renderRegistration, svgExportRegistration, transformRegistration, };
 export { GEO_NAMESPACE, geoModuleId } from "./namespace.js";
 export declare const geoNodeRegistrations: readonly DefinitionNodeRegistration[];
 export declare function geoNodeRegistration(moduleId: string): DefinitionNodeRegistration | undefined;

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

@@ -1,6 +1,7 @@
 import { copyToPointsRegistration } from "./copyToPoints.js";
 import { circleRegistration, rectangleRegistration } from "./generators.js";
 import { mergeRegistration } from "./merge.js";
+import { renderRegistration } from "./render.js";
 import { svgExportRegistration } from "./svgExport.js";
 import { transformRegistration } from "./transform.js";
 /**
@@ -15,7 +16,7 @@ import { transformRegistration } from "./transform.js";
  *
  * The namespace lives in `namespace.ts`, once.
  */
-export { circleRegistration, copyToPointsRegistration, mergeRegistration, rectangleRegistration, svgExportRegistration, transformRegistration, };
+export { circleRegistration, copyToPointsRegistration, mergeRegistration, rectangleRegistration, renderRegistration, svgExportRegistration, transformRegistration, };
 export { GEO_NAMESPACE, geoModuleId } from "./namespace.js";
 export const geoNodeRegistrations = Object.freeze([
     rectangleRegistration,
@@ -23,6 +24,7 @@ export const geoNodeRegistrations = Object.freeze([
     transformRegistration,
     mergeRegistration,
     copyToPointsRegistration,
+    renderRegistration,
     svgExportRegistration,
 ]);
 const registrationsById = new Map(geoNodeRegistrations.map((registration) => [

package/dist/runtime/builtins/geo/render.d.ts

@@ -0,0 +1,87 @@
+import type { NodeExecutionContext } from "@field/cascade/contracts";
+import { renderDefinition } from "./definitions.js";
+export declare function executeRender(context: NodeExecutionContext<typeof renderDefinition>): Promise<void>;
+export declare const renderRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "Render";
+        readonly description: "Draw a scene through a camera, as a raster.";
+        readonly icon: "Camera";
+        readonly runsOn: "portable";
+        readonly capabilities: readonly ["assets"];
+        readonly inputs: {
+            readonly scene: {
+                readonly kind: "data";
+                readonly type: "scene";
+            };
+            readonly camera: {
+                readonly kind: "data";
+                readonly type: "camera";
+            };
+        };
+        readonly outputs: {
+            readonly image: {
+                readonly kind: "data";
+                readonly type: "image";
+            };
+            readonly asset: {
+                readonly kind: "data";
+                readonly type: "asset";
+            };
+        };
+        readonly props: {
+            readonly size: {
+                readonly type: "vec2i";
+                readonly default: readonly [1280, 720];
+                readonly min: 16;
+                readonly max: 8192;
+            };
+            readonly filename: {
+                readonly type: "string";
+                readonly default: "render.png";
+                readonly label: "Filename";
+            };
+            readonly background: {
+                readonly type: "color";
+                readonly default: readonly [0, 0, 0, 0];
+                readonly label: "Background";
+            };
+            readonly stroke: {
+                readonly type: "color";
+                readonly default: readonly [0, 0, 0, 1];
+                readonly label: "Stroke";
+            };
+            readonly strokeWidth: {
+                readonly type: "float";
+                readonly default: 1;
+                readonly min: 0;
+                readonly max: 200;
+                readonly step: 0.05;
+            };
+            readonly opacity: {
+                readonly type: "float";
+                readonly default: 1;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+            };
+            readonly drawPoints: {
+                readonly type: "bool";
+                readonly default: false;
+                readonly label: "Draw Loose Points";
+            };
+            readonly pointRadius: {
+                readonly type: "float";
+                readonly default: 1.5;
+                readonly min: 0;
+                readonly max: 50;
+                readonly step: 0.1;
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeRender>;
+};
+export { renderDefinition } from "./definitions.js";
+//# sourceMappingURL=render.d.ts.map

package/dist/runtime/builtins/geo/render.js

@@ -0,0 +1,87 @@
+import { asScene } from "@field/cascade/contracts";
+import { renderScene, renderToPng, } from "../../geometry/render.js";
+import { renderDefinition } from "./definitions.js";
+import { geoModuleId } from "./namespace.js";
+/**
+ * `cascade.geo.Render` — the 3D-to-2D half of `PLAN viewport.md`.
+ *
+ * Beside `SvgExport` rather than in a namespace of its own, and the naming
+ * argument is in the plan: `cascade.geo.Render` puts it next to the node it
+ * shares a style vocabulary with, while `cascade.render.Scene` would start a
+ * namespace holding one node — a promise rather than a structure.
+ *
+ * **It is a node and not a viewport button** because a render is part of the
+ * document: it has a resolution, it is what a series renders per instance, and
+ * `cascade run --frames` has to produce it without a browser. A button produces
+ * a file; a node produces a value other nodes consume, and the second is the
+ * whole point of the graph.
+ *
+ * `portable` with only `assets`, like `SvgExport`: both hosts supply
+ * `OffscreenCanvas`, so nothing here needs a GPU. The plan argues for the CPU
+ * path first on the grounds that this vault's work is lines and a node that
+ * runs in every host — including CI — is worth more than one that is faster in
+ * one.
+ */
+/**
+ * The one host assumption, and it lives here rather than in the renderer.
+ *
+ * Both hosts supply `OffscreenCanvas` — the browser natively, the headless host
+ * through @napi-rs/canvas — so a `portable` node can draw. `packages/runtime`
+ * itself compiles without a DOM lib and must not reach for a global, which is
+ * why the renderer takes a factory and this is where it comes from.
+ */
+function hostSurface(width, height) {
+    const factory = globalThis
+        .OffscreenCanvas;
+    if (!factory) {
+        throw new Error("cascade.geo.Render needs OffscreenCanvas, which this host does not provide");
+    }
+    return new factory(width, height);
+}
+export async function executeRender(context) {
+    const { props } = context;
+    const scene = asScene(context.inputs.scene);
+    /**
+     * The camera input wins over the scene's own, so one scene can be rendered
+     * from several viewpoints without being rebuilt.
+     *
+     * And a render still refuses to invent one. The viewport may fall back to
+     * whatever camera you have navigated to, because a view is a way of looking;
+     * a render is a document, and a document with an implicit camera is one
+     * nobody can reproduce — including `cascade run --frames`, which has no
+     * viewport to borrow from.
+     */
+    const camera = context.inputs.camera ?? scene.camera;
+    if (!camera) {
+        throw new Error("cascade.geo.Render has no camera — wire a cascade.core.Camera to its camera input, or into the scene");
+    }
+    const surface = renderScene(scene.geometry, {
+        camera,
+        size: [props.size[0], props.size[1]],
+        ...(props.background[3] > 0 ? { background: props.background } : {}),
+        stroke: props.stroke,
+        strokeWidth: props.strokeWidth,
+        opacity: props.opacity,
+        pointRadius: props.pointRadius,
+        drawPoints: props.drawPoints,
+        surface: hostSurface,
+    });
+    const bytes = await renderToPng(surface);
+    const asset = await context.capabilities.assets.write(bytes, { mediaType: "image/png", suggestedName: props.filename }, { signal: context.signal });
+    context.outputs.asset.set(asset);
+    context.outputs.image.set({
+        path: asset.path ?? props.filename,
+        size: [surface.width, surface.height],
+        channels: "rgba",
+        depth: "u8",
+        space: "srgb",
+    });
+}
+export const renderRegistration = {
+    kind: "definition-v1",
+    moduleId: geoModuleId("Render"),
+    definition: renderDefinition,
+    loadExecute: async () => executeRender,
+};
+export { renderDefinition } from "./definitions.js";
+//# sourceMappingURL=render.js.map

package/dist/runtime/builtins/geo/svgExport.d.ts

@@ -71,6 +71,17 @@ export declare const svgExportRegistration: {
                 readonly default: 0;
                 readonly label: "Margin";
             };
+            readonly bounds: {
+                readonly type: "vec4";
+                readonly default: readonly [0, 0, 0, 0];
+                readonly label: "Bounds";
+            };
+            readonly background: {
+                readonly type: "color";
+                readonly default: readonly [0, 0, 0, 0];
+                readonly label: "Background";
+                readonly description: "A ground behind the drawing. Transparent by default, because a plotter wants paper.";
+            };
             readonly stroke: {
                 readonly type: "color";
                 readonly default: readonly [0, 0, 0, 1];

package/dist/runtime/builtins/geo/svgExport.js

@@ -28,6 +28,16 @@ export async function executeSvgExport(context) {
         width: props.width,
         height: props.height,
         margin: props.margin,
+        // All-zero means "derive", because a zero-area rectangle is not a frame
+        // anyone would ask for and a separate boolean for it would be a second
+        // way to say the same thing.
+        ...(props.bounds.some((value) => value !== 0)
+            ? { bounds: [props.bounds[0], props.bounds[1], props.bounds[2], props.bounds[3]] }
+            : {}),
+        // Only when it would show: a fully transparent ground and no ground at all
+        // are the same document, and emitting a rect for it would put a shape in
+        // the file that a plotter would try to draw.
+        ...(props.background[3] > 0 ? { background: props.background } : {}),
         stroke: props.stroke,
         strokeWidth: props.strokeWidth,
         opacity: props.opacity,

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

@@ -1,8 +1,11 @@
 import type { DefinitionNodeRegistration } from "../types.js";
 /**
  * Every reserved built-in, in one list, so that a caller does not have to know
- * how many namespaces there are. `cascade.core.*` is structural and routing;
- * `cascade.geo.*` is the geometry set.
+ * how many namespaces there are. `cascade.core.*` is structural and routing,
+ * `cascade.geo.*` is the geometry set, and `cascade.pop.*` is the particle
+ * set — which speaks the same `geometry` type as `geo`, so any of its outputs
+ * fits any geometry node's input. `cascade.scene.*` is the assembly: geometry
+ * plus a viewpoint plus lights, which is what the Viewer's 3D mode renders.
  */
 export declare const builtinNodeRegistrations: readonly DefinitionNodeRegistration[];
 export declare function builtinNodeRegistration(moduleId: string): DefinitionNodeRegistration | undefined;

package/dist/runtime/builtins/index.js

@@ -1,11 +1,21 @@
 import { coreNodeRegistrations } from "./core/index.js";
 import { geoNodeRegistrations } from "./geo/index.js";
+import { popNodeRegistrations } from "./pop/index.js";
+import { sceneNodeRegistrations } from "./scene/index.js";
 /**
  * Every reserved built-in, in one list, so that a caller does not have to know
- * how many namespaces there are. `cascade.core.*` is structural and routing;
- * `cascade.geo.*` is the geometry set.
+ * how many namespaces there are. `cascade.core.*` is structural and routing,
+ * `cascade.geo.*` is the geometry set, and `cascade.pop.*` is the particle
+ * set — which speaks the same `geometry` type as `geo`, so any of its outputs
+ * fits any geometry node's input. `cascade.scene.*` is the assembly: geometry
+ * plus a viewpoint plus lights, which is what the Viewer's 3D mode renders.
  */
-export const builtinNodeRegistrations = Object.freeze([...coreNodeRegistrations, ...geoNodeRegistrations]);
+export const builtinNodeRegistrations = Object.freeze([
+    ...coreNodeRegistrations,
+    ...geoNodeRegistrations,
+    ...popNodeRegistrations,
+    ...sceneNodeRegistrations,
+]);
 const registrationsById = new Map(builtinNodeRegistrations.map((registration) => [
     registration.moduleId,
     registration,