@field/cascade 0.3.0 → 0.4.0

package/dist/contracts/values.d.ts

@@ -1,6 +1,7 @@
+import type { Camera } from "./camera.js";
 import type { Color } from "./color.js";
 import type { Geometry, GeometryFileRef, GeometryJson, GeometrySerialized } from "./geometry.js";
-export declare const CORE_TYPES: readonly ["float", "int", "bool", "string", "vec2", "vec3", "vec4", "vec2i", "vec3i", "vec4i", "mat2", "mat3", "mat4", "image", "texture", "geometry", "points", "lines", "polyline", "mesh", "rects", "color", "asset", "array", "object", "any"];
+export declare const CORE_TYPES: readonly ["float", "int", "bool", "string", "vec2", "vec3", "vec4", "vec2i", "vec3i", "vec4i", "mat2", "mat3", "mat4", "image", "texture", "geometry", "points", "lines", "polyline", "mesh", "rects", "color", "camera", "asset", "array", "object", "any"];
 export type CoreType = (typeof CORE_TYPES)[number];
 export type NamespacedType = `${string}.${string}`;
 export type CascadeType = CoreType | NamespacedType;
@@ -94,7 +95,7 @@ export interface AssetRef {
     readonly mediaType?: string;
 }
 export type SerializableValue = JsonValue | AssetRef | ImageRef | GeometryJson | GeometryFileRef;
-export type ValueForType<T extends CascadeType> = T extends "float" | "int" ? number : T extends "bool" ? boolean : T extends "string" ? string : T extends "vec2" ? Vec2 : T extends "vec3" ? Vec3 : T extends "vec4" ? Vec4 : T extends "vec2i" ? Vec2i : T extends "vec3i" ? Vec3i : T extends "vec4i" ? Vec4i : T extends "mat2" ? Mat2 : T extends "mat3" ? Mat3 : T extends "mat4" ? Mat4 : T extends "color" ? Color : T extends "image" ? ImageRef : T extends "texture" ? TextureHandle : T extends "geometry" ? Geometry : T extends "points" ? PointSet : T extends "lines" ? LineSegments : T extends "polyline" ? Polyline : T extends "mesh" ? Mesh : T extends "rects" ? Rects : T extends "asset" ? AssetRef : T extends "array" ? readonly unknown[] : T extends "object" ? Readonly<Record<string, unknown>> : unknown;
+export type ValueForType<T extends CascadeType> = T extends "float" | "int" ? number : T extends "bool" ? boolean : T extends "string" ? string : T extends "vec2" ? Vec2 : T extends "vec3" ? Vec3 : T extends "vec4" ? Vec4 : T extends "vec2i" ? Vec2i : T extends "vec3i" ? Vec3i : T extends "vec4i" ? Vec4i : T extends "mat2" ? Mat2 : T extends "mat3" ? Mat3 : T extends "mat4" ? Mat4 : T extends "color" ? Color : T extends "camera" ? Camera : T extends "image" ? ImageRef : T extends "texture" ? TextureHandle : T extends "geometry" ? Geometry : T extends "points" ? PointSet : T extends "lines" ? LineSegments : T extends "polyline" ? Polyline : T extends "mesh" ? Mesh : T extends "rects" ? Rects : T extends "asset" ? AssetRef : T extends "array" ? readonly unknown[] : T extends "object" ? Readonly<Record<string, unknown>> : unknown;
 export type SerializableValueForType<T extends CascadeType> = T extends "texture" ? never : T extends "geometry" ? GeometrySerialized : T extends "array" ? readonly JsonValue[] : T extends "object" ? Readonly<Record<string, JsonValue>> : T extends "any" | NamespacedType ? JsonValue : ValueForType<T>;
 export {};
 //# sourceMappingURL=values.d.ts.map

package/dist/contracts/values.js

@@ -21,6 +21,7 @@ export const CORE_TYPES = [
     "mesh",
     "rects",
     "color",
+    "camera",
     "asset",
     "array",
     "object",

package/dist/gpu.d.ts

@@ -0,0 +1,88 @@
+/**
+ * `cascade/gpu` — WebGPU's flag namespaces as plain values.
+ *
+ * Small, and it was load-bearing. TypeScript's DOM library declares the WebGPU
+ * *interfaces* but not the constant objects, so the only way to reach
+ * `GPUTextureUsage.RENDER_ATTACHMENT` was off `globalThis` — which
+ * `architecture/ambient-state` correctly forbids inside a node module, because
+ * an ambient read makes a node's inputs invisible to the static reader that
+ * lets `cascade check` say anything without cooking.
+ *
+ * So a sketch had to choose between a rule and a working shader, and it chose
+ * a project library file to hide the read in. Both stay honest now: the rule
+ * keeps its teeth and a node imports these instead. That is the whole reason
+ * this file exists, and it is why it had to land with the capability rather
+ * than after it — a rule whose only workaround is removed at the same moment
+ * is a rule; one enforced a release earlier is a nuisance.
+ *
+ * The values are fixed by the WebGPU specification, not by an implementation,
+ * which is what makes writing them down safe rather than a guess. They are
+ * checked against a real browser's own globals in `tests/gpu-usage-flags.test.ts`
+ * — the numbers below were verified against Chrome rather than recalled.
+ */
+/** `GPUBufferUsage`. */
+export declare const BufferUsage: {
+    readonly MAP_READ: 1;
+    readonly MAP_WRITE: 2;
+    readonly COPY_SRC: 4;
+    readonly COPY_DST: 8;
+    readonly INDEX: 16;
+    readonly VERTEX: 32;
+    readonly UNIFORM: 64;
+    readonly STORAGE: 128;
+    readonly INDIRECT: 256;
+    readonly QUERY_RESOLVE: 512;
+};
+/** `GPUTextureUsage`. */
+export declare const TextureUsage: {
+    readonly COPY_SRC: 1;
+    readonly COPY_DST: 2;
+    readonly TEXTURE_BINDING: 4;
+    readonly STORAGE_BINDING: 8;
+    readonly RENDER_ATTACHMENT: 16;
+    /**
+     * Chrome 147 has this and it is newer than the rest — verified present
+     * 2026-09-08 alongside the others, but do not assume every implementation
+     * carries it. Included rather than omitted deliberately: leaving it out
+     * would send a node that wants it back to `globalThis`, which is the exact
+     * ambient read this file exists to remove, so an honest constant with a
+     * caveat beats an omission that forces a rule violation.
+     */
+    readonly TRANSIENT_ATTACHMENT: 32;
+};
+/** `GPUShaderStage`, for a bind group layout entry's `visibility`. */
+export declare const ShaderStage: {
+    readonly VERTEX: 1;
+    readonly FRAGMENT: 2;
+    readonly COMPUTE: 4;
+};
+/** `GPUMapMode`, for `buffer.mapAsync`. */
+export declare const MapMode: {
+    readonly READ: 1;
+    readonly WRITE: 2;
+};
+/** `GPUColorWrite`, for a colour target's `writeMask`. */
+export declare const ColorWrite: {
+    readonly RED: 1;
+    readonly GREEN: 2;
+    readonly BLUE: 4;
+    readonly ALPHA: 8;
+    readonly ALL: 15;
+};
+/** Read one single-sample rgba8unorm 2D texture into owned, tightly packed
+ * top-left RGBA bytes. No colour conversion, PNG encoding or graph transport.
+ * The caller owns the source texture and must give it COPY_SRC usage.
+ */
+export declare function readTexture(device: GPUDevice, texture: GPUTexture, options?: {
+    signal?: {
+        readonly aborted: boolean;
+        addEventListener(type: 'abort', listener: () => void, options?: {
+            once?: boolean;
+        }): void;
+        removeEventListener(type: 'abort', listener: () => void): void;
+    };
+}): Promise<{
+    data: Uint8Array<ArrayBuffer>;
+    width: number;
+    height: number;
+}>;

package/dist/gpu.js

@@ -0,0 +1,113 @@
+// server/src/runtime/gpu.ts
+var BufferUsage = {
+  MAP_READ: 1,
+  MAP_WRITE: 2,
+  COPY_SRC: 4,
+  COPY_DST: 8,
+  INDEX: 16,
+  VERTEX: 32,
+  UNIFORM: 64,
+  STORAGE: 128,
+  INDIRECT: 256,
+  QUERY_RESOLVE: 512
+};
+var TextureUsage = {
+  COPY_SRC: 1,
+  COPY_DST: 2,
+  TEXTURE_BINDING: 4,
+  STORAGE_BINDING: 8,
+  RENDER_ATTACHMENT: 16,
+  /**
+   * Chrome 147 has this and it is newer than the rest — verified present
+   * 2026-09-08 alongside the others, but do not assume every implementation
+   * carries it. Included rather than omitted deliberately: leaving it out
+   * would send a node that wants it back to `globalThis`, which is the exact
+   * ambient read this file exists to remove, so an honest constant with a
+   * caveat beats an omission that forces a rule violation.
+   */
+  TRANSIENT_ATTACHMENT: 32
+};
+var ShaderStage = {
+  VERTEX: 1,
+  FRAGMENT: 2,
+  COMPUTE: 4
+};
+var MapMode = {
+  READ: 1,
+  WRITE: 2
+};
+var ColorWrite = {
+  RED: 1,
+  GREEN: 2,
+  BLUE: 4,
+  ALPHA: 8,
+  ALL: 15
+};
+async function readTexture(device, texture, options = {}) {
+  const { signal } = options;
+  if (signal?.aborted) throw new Error("GPU readback aborted");
+  if (texture.format !== "rgba8unorm" || texture.dimension !== "2d" || texture.depthOrArrayLayers !== 1 || texture.sampleCount !== 1 || !(texture.usage & TextureUsage.COPY_SRC)) {
+    throw new Error("GPU readback requires a single-sample rgba8unorm 2D texture with COPY_SRC usage");
+  }
+  const { width, height } = texture;
+  const rowBytes = width * 4;
+  const bytesPerRow = Math.ceil(rowBytes / 256) * 256;
+  let buffer;
+  let mapped = false;
+  let abort;
+  let errorScopeOpen = false;
+  try {
+    device.pushErrorScope("validation");
+    errorScopeOpen = true;
+    buffer = device.createBuffer({
+      label: "Cascade RGBA readback",
+      size: bytesPerRow * height,
+      usage: BufferUsage.COPY_DST | BufferUsage.MAP_READ
+    });
+    const encoder = device.createCommandEncoder();
+    encoder.copyTextureToBuffer({ texture }, { buffer, bytesPerRow }, [width, height]);
+    device.queue.submit([encoder.finish()]);
+    const validation = device.popErrorScope();
+    errorScopeOpen = false;
+    const completion = Promise.allSettled([buffer.mapAsync(MapMode.READ), validation]);
+    let completed;
+    if (signal) {
+      completed = await Promise.race([completion, new Promise((_, reject) => {
+        abort = () => reject(new Error("GPU readback aborted"));
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted) abort();
+      })]);
+    } else completed = await completion;
+    const mappingResult = completed[0];
+    const validationResult = completed[1];
+    if (validationResult.status === "rejected") throw validationResult.reason;
+    const validationError = validationResult.value;
+    if (validationError) throw new Error(`GPU readback validation failed: ${validationError.message}`);
+    if (mappingResult.status === "rejected") throw mappingResult.reason;
+    mapped = true;
+    if (signal?.aborted) throw new Error("GPU readback aborted");
+    const source = new Uint8Array(buffer.getMappedRange());
+    const data = new Uint8Array(rowBytes * height);
+    for (let y = 0; y < height; y++) data.set(source.subarray(y * bytesPerRow, y * bytesPerRow + rowBytes), y * rowBytes);
+    return { data, width, height };
+  } finally {
+    if (abort) signal?.removeEventListener("abort", abort);
+    if (errorScopeOpen) {
+      try {
+        await device.popErrorScope();
+      } catch {
+      }
+    }
+    if (mapped) buffer?.unmap();
+    buffer?.destroy();
+  }
+}
+export {
+  BufferUsage,
+  ColorWrite,
+  MapMode,
+  ShaderStage,
+  TextureUsage,
+  readTexture
+};
+//# sourceMappingURL=gpu.js.map

package/dist/index.html

@@ -4,11 +4,11 @@
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Cascade</title>
-  <script type="module" crossorigin src="/assets/index-HTCN44kj.js"></script>
+  <script type="module" crossorigin src="/assets/index-CC6YQw2n.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/legacy-CAj2_7QE.js">
   <link rel="modulepreload" crossorigin href="/assets/index-client-BoJgsN9M.js">
   <link rel="modulepreload" crossorigin href="/assets/nodeTypeUtils-BBA1JqHx.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-BDV5xGBZ.css">
+  <link rel="stylesheet" crossorigin href="/assets/index-Y2ock1cw.css">
 </head>
 <body>
   <div id="app"></div>

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

@@ -0,0 +1,252 @@
+import { type NodeExecutionContext } from "@field/cascade/contracts";
+/**
+ * `cascade.core.Camera` — Houdini's `/obj/cam`, as a node.
+ *
+ * Marcus, 2026-09-08: *"I think it just requires a camera. camera should be a
+ * core node."* So a renderer takes a camera on a port rather than carrying its
+ * own copy of the same eight parameters, which is what `volume-render` was
+ * doing.
+ *
+ * The split between inputs and props is the usual one and it matters here:
+ * **what a camera move animates is an input** — position, orientation, the
+ * look-at target, the lens — and **what defines the frame is a prop**, because
+ * clipping planes, resolution and projection are set once and left. `focal` is
+ * an input for exactly this reason: a focus pull is a camera move.
+ */
+export declare const cameraDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "Camera";
+    readonly description: "A camera, following Houdini's /obj/cam.";
+    readonly icon: "Video";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly translate: {
+            readonly kind: "data";
+            readonly type: "vec3";
+            readonly default: readonly [0, 0, 5];
+            readonly description: "World position.";
+        };
+        readonly rotate: {
+            readonly kind: "data";
+            readonly type: "vec3";
+            readonly default: readonly [0, 0, 0];
+            readonly description: "Degrees, XYZ order. The camera looks down its own -Z.";
+        };
+        readonly focal: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 50;
+            readonly min: 1;
+            readonly max: 300;
+            readonly description: "Focal length in millimetres.";
+        };
+        readonly lookat: {
+            readonly kind: "data";
+            readonly type: "vec3";
+            readonly default: readonly [0, 0, 0];
+            readonly description: "Point to aim at. Used only when Look At is on, and it replaces Rotate.";
+        };
+        readonly up: {
+            readonly kind: "data";
+            readonly type: "vec3";
+            readonly default: readonly [0, 1, 0];
+            readonly description: "Up vector for Look At.";
+        };
+        readonly spin: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 0;
+            readonly description: "Degrees added to the Y rotation, after Look At. For turntables.";
+        };
+    };
+    readonly outputs: {
+        readonly camera: {
+            readonly kind: "data";
+            readonly type: "camera";
+        };
+    };
+    readonly props: {
+        readonly lookAt: {
+            readonly type: "bool";
+            readonly default: false;
+            readonly label: "Look At";
+            readonly description: "Aim at the Look At point instead of using Rotate.";
+        };
+        readonly aperture: {
+            readonly type: "float";
+            readonly default: 41.4214;
+            readonly min: 1;
+            readonly max: 200;
+            readonly label: "Aperture";
+            readonly description: "Horizontal aperture in millimetres. With the default focal length this is a 45 degree view.";
+        };
+        readonly resolution: {
+            readonly type: "vec2i";
+            readonly default: readonly [1280, 720];
+            readonly label: "Resolution";
+            readonly description: "Frame size in pixels. The vertical field of view is derived from this.";
+        };
+        readonly aspect: {
+            readonly type: "float";
+            readonly default: 1;
+            readonly min: 0.1;
+            readonly max: 10;
+            readonly label: "Pixel Aspect";
+            readonly description: "The aspect of one pixel, not of the frame.";
+        };
+        readonly projection: {
+            readonly type: "string";
+            readonly default: "perspective";
+            readonly label: "Projection";
+            readonly control: "select";
+            readonly options: readonly [{
+                readonly value: "perspective";
+                readonly label: "Perspective";
+            }, {
+                readonly value: "orthographic";
+                readonly label: "Orthographic";
+            }];
+        };
+        readonly orthowidth: {
+            readonly type: "float";
+            readonly default: 2;
+            readonly min: 0.01;
+            readonly label: "Ortho Width";
+            readonly description: "Width of the orthographic frame in world units.";
+        };
+        readonly near: {
+            readonly type: "float";
+            readonly default: 0.001;
+            readonly min: 0;
+            readonly label: "Near Clip";
+        };
+        readonly far: {
+            readonly type: "float";
+            readonly default: 10000;
+            readonly min: 0;
+            readonly label: "Far Clip";
+        };
+    };
+};
+export declare function executeCamera(context: NodeExecutionContext<typeof cameraDefinition>): void;
+export declare const cameraRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "Camera";
+        readonly description: "A camera, following Houdini's /obj/cam.";
+        readonly icon: "Video";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly translate: {
+                readonly kind: "data";
+                readonly type: "vec3";
+                readonly default: readonly [0, 0, 5];
+                readonly description: "World position.";
+            };
+            readonly rotate: {
+                readonly kind: "data";
+                readonly type: "vec3";
+                readonly default: readonly [0, 0, 0];
+                readonly description: "Degrees, XYZ order. The camera looks down its own -Z.";
+            };
+            readonly focal: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 50;
+                readonly min: 1;
+                readonly max: 300;
+                readonly description: "Focal length in millimetres.";
+            };
+            readonly lookat: {
+                readonly kind: "data";
+                readonly type: "vec3";
+                readonly default: readonly [0, 0, 0];
+                readonly description: "Point to aim at. Used only when Look At is on, and it replaces Rotate.";
+            };
+            readonly up: {
+                readonly kind: "data";
+                readonly type: "vec3";
+                readonly default: readonly [0, 1, 0];
+                readonly description: "Up vector for Look At.";
+            };
+            readonly spin: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 0;
+                readonly description: "Degrees added to the Y rotation, after Look At. For turntables.";
+            };
+        };
+        readonly outputs: {
+            readonly camera: {
+                readonly kind: "data";
+                readonly type: "camera";
+            };
+        };
+        readonly props: {
+            readonly lookAt: {
+                readonly type: "bool";
+                readonly default: false;
+                readonly label: "Look At";
+                readonly description: "Aim at the Look At point instead of using Rotate.";
+            };
+            readonly aperture: {
+                readonly type: "float";
+                readonly default: 41.4214;
+                readonly min: 1;
+                readonly max: 200;
+                readonly label: "Aperture";
+                readonly description: "Horizontal aperture in millimetres. With the default focal length this is a 45 degree view.";
+            };
+            readonly resolution: {
+                readonly type: "vec2i";
+                readonly default: readonly [1280, 720];
+                readonly label: "Resolution";
+                readonly description: "Frame size in pixels. The vertical field of view is derived from this.";
+            };
+            readonly aspect: {
+                readonly type: "float";
+                readonly default: 1;
+                readonly min: 0.1;
+                readonly max: 10;
+                readonly label: "Pixel Aspect";
+                readonly description: "The aspect of one pixel, not of the frame.";
+            };
+            readonly projection: {
+                readonly type: "string";
+                readonly default: "perspective";
+                readonly label: "Projection";
+                readonly control: "select";
+                readonly options: readonly [{
+                    readonly value: "perspective";
+                    readonly label: "Perspective";
+                }, {
+                    readonly value: "orthographic";
+                    readonly label: "Orthographic";
+                }];
+            };
+            readonly orthowidth: {
+                readonly type: "float";
+                readonly default: 2;
+                readonly min: 0.01;
+                readonly label: "Ortho Width";
+                readonly description: "Width of the orthographic frame in world units.";
+            };
+            readonly near: {
+                readonly type: "float";
+                readonly default: 0.001;
+                readonly min: 0;
+                readonly label: "Near Clip";
+            };
+            readonly far: {
+                readonly type: "float";
+                readonly default: 10000;
+                readonly min: 0;
+                readonly label: "Far Clip";
+            };
+        };
+    };
+    loadExecute: () => Promise<typeof executeCamera>;
+};
+//# sourceMappingURL=camera.d.ts.map

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

@@ -0,0 +1,149 @@
+import { CAMERA_DEFAULTS } from "@field/cascade/contracts";
+import { lookAtRotation } from "../../camera/index.js";
+/**
+ * `cascade.core.Camera` — Houdini's `/obj/cam`, as a node.
+ *
+ * Marcus, 2026-09-08: *"I think it just requires a camera. camera should be a
+ * core node."* So a renderer takes a camera on a port rather than carrying its
+ * own copy of the same eight parameters, which is what `volume-render` was
+ * doing.
+ *
+ * The split between inputs and props is the usual one and it matters here:
+ * **what a camera move animates is an input** — position, orientation, the
+ * look-at target, the lens — and **what defines the frame is a prop**, because
+ * clipping planes, resolution and projection are set once and left. `focal` is
+ * an input for exactly this reason: a focus pull is a camera move.
+ */
+export const cameraDefinition = {
+    apiVersion: 1,
+    label: "Camera",
+    description: "A camera, following Houdini's /obj/cam.",
+    icon: "Video",
+    runsOn: "portable",
+    inputs: {
+        translate: {
+            kind: "data",
+            type: "vec3",
+            default: [0, 0, 5],
+            description: "World position.",
+        },
+        rotate: {
+            kind: "data",
+            type: "vec3",
+            default: [0, 0, 0],
+            description: "Degrees, XYZ order. The camera looks down its own -Z.",
+        },
+        focal: {
+            kind: "data",
+            type: "float",
+            default: 50,
+            min: 1,
+            max: 300,
+            description: "Focal length in millimetres.",
+        },
+        lookat: {
+            kind: "data",
+            type: "vec3",
+            default: [0, 0, 0],
+            description: "Point to aim at. Used only when Look At is on, and it replaces Rotate.",
+        },
+        up: {
+            kind: "data",
+            type: "vec3",
+            default: [0, 1, 0],
+            description: "Up vector for Look At.",
+        },
+        spin: {
+            kind: "data",
+            type: "float",
+            default: 0,
+            description: "Degrees added to the Y rotation, after Look At. For turntables.",
+        },
+    },
+    outputs: {
+        camera: { kind: "data", type: "camera" },
+    },
+    props: {
+        lookAt: {
+            type: "bool",
+            default: false,
+            label: "Look At",
+            description: "Aim at the Look At point instead of using Rotate.",
+        },
+        aperture: {
+            type: "float",
+            default: 41.4214,
+            min: 1,
+            max: 200,
+            label: "Aperture",
+            description: "Horizontal aperture in millimetres. With the default focal length this is a 45 degree view.",
+        },
+        resolution: {
+            type: "vec2i",
+            default: [1280, 720],
+            label: "Resolution",
+            description: "Frame size in pixels. The vertical field of view is derived from this.",
+        },
+        aspect: {
+            type: "float",
+            default: 1,
+            min: 0.1,
+            max: 10,
+            label: "Pixel Aspect",
+            description: "The aspect of one pixel, not of the frame.",
+        },
+        projection: {
+            type: "string",
+            default: "perspective",
+            label: "Projection",
+            control: "select",
+            options: [
+                { value: "perspective", label: "Perspective" },
+                { value: "orthographic", label: "Orthographic" },
+            ],
+        },
+        orthowidth: {
+            type: "float",
+            default: 2,
+            min: 0.01,
+            label: "Ortho Width",
+            description: "Width of the orthographic frame in world units.",
+        },
+        near: { type: "float", default: 0.001, min: 0, label: "Near Clip" },
+        far: { type: "float", default: 10000, min: 0, label: "Far Clip" },
+    },
+};
+export function executeCamera(context) {
+    const { translate, rotate, focal, lookat, up, spin } = context.inputs;
+    const props = context.props;
+    const aimed = props.lookAt
+        ? lookAtRotation(translate, lookat, up)
+        : rotate;
+    // Spin is applied after look-at rather than folded into it, so a turntable
+    // keeps pointing at its subject while it goes round. Degrees, because
+    // `rotate` is degrees and adding a different unit to it would be a trap.
+    const oriented = spin === 0
+        ? aimed
+        : [aimed[0], aimed[1] + spin, aimed[2]];
+    const camera = {
+        ...CAMERA_DEFAULTS,
+        translate: translate,
+        rotate: oriented,
+        focal,
+        aperture: props.aperture,
+        resolution: props.resolution,
+        aspect: props.aspect,
+        projection: props.projection === "orthographic" ? "orthographic" : "perspective",
+        orthowidth: props.orthowidth,
+        near: props.near,
+        far: props.far,
+    };
+    context.outputs.camera.set(camera);
+}
+export const cameraRegistration = {
+    kind: "definition-v1",
+    moduleId: "cascade.core.Camera",
+    definition: cameraDefinition,
+    loadExecute: async () => executeCamera,
+};
+//# sourceMappingURL=camera.js.map

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

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

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

@@ -1,8 +1,9 @@
+import { cameraRegistration } from "./camera.js";
 import { randomRegistration } from "./random.js";
 import { remapRegistration } from "./remap.js";
 import { mergeRegistration, nullRegistration, selectRegistration, switchRegistration } from "./routing.js";
 import { inputRegistration, outputRegistration, subnetRegistration } from "./structural.js";
-export { inputRegistration, mergeRegistration, nullRegistration, outputRegistration, randomRegistration, remapRegistration, selectRegistration, subnetRegistration, switchRegistration, };
+export { cameraRegistration, inputRegistration, mergeRegistration, nullRegistration, outputRegistration, randomRegistration, remapRegistration, selectRegistration, subnetRegistration, switchRegistration, };
 export const coreNodeRegistrations = Object.freeze([
     subnetRegistration,
     inputRegistration,
@@ -13,6 +14,7 @@ export const coreNodeRegistrations = Object.freeze([
     selectRegistration,
     randomRegistration,
     remapRegistration,
+    cameraRegistration,
 ]);
 const registrationsById = new Map(coreNodeRegistrations.map((registration) => [registration.moduleId, registration]));
 export function coreNodeRegistration(moduleId) {