@field/cascade 0.4.0 → 0.5.2

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,