@field/cascade 0.4.0 → 0.5.1

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

@@ -0,0 +1,165 @@
+import type { NodeExecutionContext } from "@field/cascade/contracts";
+/**
+ * `cascade.core.Time` — the clock, as a value the graph can carry.
+ *
+ * Built 2026-09-09, from Marcus scrubbing the timeline on `particle-type` and
+ * seeing nothing move: *"when i jump to a different time on the timeline i dont
+ * actually see the pop simulation animating in the viewer."*
+ *
+ * The cause was not the viewer. `cascade.pop.Simulate` takes the frame on an
+ * **input**, its own comment says *"drive it with `$F`"*, and **that was not
+ * possible**: expressions attach to props, and an input port has no expression
+ * field. So the sketch had a constant in there and no graph in the system could
+ * read the clock through a port at all.
+ *
+ * ## Why a node rather than an expression on the input
+ *
+ * Making inputs expression-bearing is the other fix, and it is the wrong one.
+ * An input is a *wire*, and a wire that is sometimes a formula means every
+ * consumer of every input has two ways to get a value — which is the shape that
+ * made props themselves complicated (a value, an expression, a channel, and a
+ * resolution order between them). Doing it again on the input side doubles that
+ * surface for one use.
+ *
+ * The node is also the more honest picture. Time is an input to the graph in
+ * the same way a camera is, and a graph that shows where the clock enters can
+ * be read; one where any of two hundred ports might secretly be `$F` cannot.
+ *
+ * ## Why the props carry the expressions
+ *
+ * `frame` and `time` are props with declared default expressions — `$F` and
+ * `$T` — which is the one mechanism that already reads the clock and updates a
+ * node's time dependency. Nothing here calls a clock: the node is a pure
+ * function of its props, and the props are where the binding lives. That keeps
+ * `execute` deterministic and testable, which a node reading a global clock
+ * would not be.
+ *
+ * They are props rather than fixed values so you can override one: pinning
+ * `frame` to a constant is exactly what a still render wants, and it is a
+ * one-field edit rather than a rewire.
+ */
+export declare const timeDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "Time";
+    readonly description: "The current frame and time, as values the graph can read.";
+    readonly icon: "Clock";
+    readonly runsOn: "portable";
+    readonly inputs: {};
+    readonly outputs: {
+        /**
+         * The whole frame, as an integer — Houdini's `$F`.
+         *
+         * An `int` rather than a `float`, and that is the point of having two
+         * outputs. Anything that **counts** frames needs an integer: a feedback
+         * container's step count, a sequence index, a modulo. Narrowing is never
+         * implicit in Cascade, so a float frame simply could not be wired to a step
+         * count, and the alternative — truncating silently somewhere downstream —
+         * is a simulation running 3 steps when the graph said 3.7.
+         */
+        readonly frame: {
+            readonly kind: "data";
+            readonly type: "int";
+            readonly description: "The whole frame. Houdini's $F.";
+        };
+        /** The fractional frame — Houdini's `$FF`. For anything that moves. */
+        readonly fframe: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly description: "The fractional frame, for sub-frame motion. Houdini's $FF.";
+        };
+        readonly time: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly description: "The playhead in seconds.";
+        };
+    };
+    readonly props: {
+        readonly frame: {
+            readonly type: "int";
+            readonly default: 1;
+            readonly expression: "$F";
+            readonly label: "Frame";
+            readonly description: "Bound to $F. Replace with a number to pin a still, or with any expression.";
+        };
+        readonly fframe: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly expression: "$FF";
+            readonly label: "Fractional Frame";
+            readonly description: "Bound to $FF.";
+        };
+        readonly time: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly expression: "$T";
+            readonly label: "Time";
+            readonly description: "Bound to $T, in seconds.";
+        };
+    };
+};
+export declare function executeTime(context: NodeExecutionContext<typeof timeDefinition>): void;
+export declare const timeRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "Time";
+        readonly description: "The current frame and time, as values the graph can read.";
+        readonly icon: "Clock";
+        readonly runsOn: "portable";
+        readonly inputs: {};
+        readonly outputs: {
+            /**
+             * The whole frame, as an integer — Houdini's `$F`.
+             *
+             * An `int` rather than a `float`, and that is the point of having two
+             * outputs. Anything that **counts** frames needs an integer: a feedback
+             * container's step count, a sequence index, a modulo. Narrowing is never
+             * implicit in Cascade, so a float frame simply could not be wired to a step
+             * count, and the alternative — truncating silently somewhere downstream —
+             * is a simulation running 3 steps when the graph said 3.7.
+             */
+            readonly frame: {
+                readonly kind: "data";
+                readonly type: "int";
+                readonly description: "The whole frame. Houdini's $F.";
+            };
+            /** The fractional frame — Houdini's `$FF`. For anything that moves. */
+            readonly fframe: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly description: "The fractional frame, for sub-frame motion. Houdini's $FF.";
+            };
+            readonly time: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly description: "The playhead in seconds.";
+            };
+        };
+        readonly props: {
+            readonly frame: {
+                readonly type: "int";
+                readonly default: 1;
+                readonly expression: "$F";
+                readonly label: "Frame";
+                readonly description: "Bound to $F. Replace with a number to pin a still, or with any expression.";
+            };
+            readonly fframe: {
+                readonly type: "float";
+                readonly default: 1;
+                readonly expression: "$FF";
+                readonly label: "Fractional Frame";
+                readonly description: "Bound to $FF.";
+            };
+            readonly time: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly expression: "$T";
+                readonly label: "Time";
+                readonly description: "Bound to $T, in seconds.";
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeTime>;
+};
+//# sourceMappingURL=time.d.ts.map

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

@@ -0,0 +1,110 @@
+/**
+ * `cascade.core.Time` — the clock, as a value the graph can carry.
+ *
+ * Built 2026-09-09, from Marcus scrubbing the timeline on `particle-type` and
+ * seeing nothing move: *"when i jump to a different time on the timeline i dont
+ * actually see the pop simulation animating in the viewer."*
+ *
+ * The cause was not the viewer. `cascade.pop.Simulate` takes the frame on an
+ * **input**, its own comment says *"drive it with `$F`"*, and **that was not
+ * possible**: expressions attach to props, and an input port has no expression
+ * field. So the sketch had a constant in there and no graph in the system could
+ * read the clock through a port at all.
+ *
+ * ## Why a node rather than an expression on the input
+ *
+ * Making inputs expression-bearing is the other fix, and it is the wrong one.
+ * An input is a *wire*, and a wire that is sometimes a formula means every
+ * consumer of every input has two ways to get a value — which is the shape that
+ * made props themselves complicated (a value, an expression, a channel, and a
+ * resolution order between them). Doing it again on the input side doubles that
+ * surface for one use.
+ *
+ * The node is also the more honest picture. Time is an input to the graph in
+ * the same way a camera is, and a graph that shows where the clock enters can
+ * be read; one where any of two hundred ports might secretly be `$F` cannot.
+ *
+ * ## Why the props carry the expressions
+ *
+ * `frame` and `time` are props with declared default expressions — `$F` and
+ * `$T` — which is the one mechanism that already reads the clock and updates a
+ * node's time dependency. Nothing here calls a clock: the node is a pure
+ * function of its props, and the props are where the binding lives. That keeps
+ * `execute` deterministic and testable, which a node reading a global clock
+ * would not be.
+ *
+ * They are props rather than fixed values so you can override one: pinning
+ * `frame` to a constant is exactly what a still render wants, and it is a
+ * one-field edit rather than a rewire.
+ */
+export const timeDefinition = {
+    apiVersion: 1,
+    label: "Time",
+    description: "The current frame and time, as values the graph can read.",
+    icon: "Clock",
+    runsOn: "portable",
+    inputs: {},
+    outputs: {
+        /**
+         * The whole frame, as an integer — Houdini's `$F`.
+         *
+         * An `int` rather than a `float`, and that is the point of having two
+         * outputs. Anything that **counts** frames needs an integer: a feedback
+         * container's step count, a sequence index, a modulo. Narrowing is never
+         * implicit in Cascade, so a float frame simply could not be wired to a step
+         * count, and the alternative — truncating silently somewhere downstream —
+         * is a simulation running 3 steps when the graph said 3.7.
+         */
+        frame: {
+            kind: "data",
+            type: "int",
+            description: "The whole frame. Houdini's $F.",
+        },
+        /** The fractional frame — Houdini's `$FF`. For anything that moves. */
+        fframe: {
+            kind: "data",
+            type: "float",
+            description: "The fractional frame, for sub-frame motion. Houdini's $FF.",
+        },
+        time: {
+            kind: "data",
+            type: "float",
+            description: "The playhead in seconds.",
+        },
+    },
+    props: {
+        frame: {
+            type: "int",
+            default: 1,
+            expression: "$F",
+            label: "Frame",
+            description: "Bound to $F. Replace with a number to pin a still, or with any expression.",
+        },
+        fframe: {
+            type: "float",
+            default: 1,
+            expression: "$FF",
+            label: "Fractional Frame",
+            description: "Bound to $FF.",
+        },
+        time: {
+            type: "float",
+            default: 0,
+            expression: "$T",
+            label: "Time",
+            description: "Bound to $T, in seconds.",
+        },
+    },
+};
+export function executeTime(context) {
+    context.outputs.frame.set(context.props.frame);
+    context.outputs.fframe.set(context.props.fframe);
+    context.outputs.time.set(context.props.time);
+}
+export const timeRegistration = {
+    kind: "definition-v1",
+    moduleId: "cascade.core.Time",
+    definition: timeDefinition,
+    loadExecute: async () => executeTime,
+};
+//# sourceMappingURL=time.js.map

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) => [