@field/cascade 0.11.0 → 0.13.0

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

@@ -1,9 +1,44 @@
-import { contactSheetRegistration } from "./contactSheet.js";
+import { blurDefinition, checkersDefinition, colorDefinition, compositeDefinition, contactSheetDefinition, imageDefinition, noiseDefinition, normalMapDefinition, rampDefinition, resizeDefinition, textDefinition, transformDefinition, } from "./definitions.js";
 /**
- * The definition-v1 image nodes. One so far: the contact sheet a ladder of
- * variants is judged on. Studio's `cascade.image.*` library (src/nodes/image)
- * is the compatibility engine's and is not listed here.
+ * `cascade.image.*`: the image library, in every host.
+ *
+ * Eleven nodes were Studio classes over `ImageNodeBase` until 2026-11-07, when
+ * Marcus decided to port them (round 1 decision 4); the twelfth, the contact
+ * sheet, was the first definition-v1 node here. The declarations are literal
+ * and small, because this list sits in Studio's first-paint bundle with every
+ * other built-in; each body loads behind a dynamic import the first time a node
+ * of that kind cooks, so Studio pays for a node's pixel loop only when a graph
+ * uses it. (`cascade ladder` imports the contact sheet's layout and drawing
+ * from `contactSheet.ts` directly, for the same reason.)
  */
-export { composeContactSheet, contactSheetDefinition, contactSheetLayout, contactSheetRegistration, executeContactSheet, } from "./contactSheet.js";
-export const imageNodeRegistrations = Object.freeze([contactSheetRegistration]);
+export * from "./definitions.js";
+function lazy(name, definition, load) {
+    return { kind: "definition-v1", moduleId: `cascade.image.${name}`, definition, loadExecute: load };
+}
+export const contactSheetRegistration = lazy("ContactSheet", contactSheetDefinition, async () => (await import("./contactSheet.js")).executeContactSheet);
+export const colorRegistration = lazy("Color", colorDefinition, async () => (await import("./generators.js")).executeColor);
+export const checkersRegistration = lazy("Checkers", checkersDefinition, async () => (await import("./generators.js")).executeCheckers);
+export const noiseRegistration = lazy("Noise", noiseDefinition, async () => (await import("./generators.js")).executeNoise);
+export const rampRegistration = lazy("Ramp", rampDefinition, async () => (await import("./generators.js")).executeRamp);
+export const textRegistration = lazy("Text", textDefinition, async () => (await import("./text.js")).executeText);
+export const imageRegistration = lazy("Image", imageDefinition, async () => (await import("./file.js")).executeImage);
+export const blurRegistration = lazy("Blur", blurDefinition, async () => (await import("./filters.js")).executeBlur);
+export const normalMapRegistration = lazy("NormalMap", normalMapDefinition, async () => (await import("./filters.js")).executeNormalMap);
+export const resizeRegistration = lazy("Resize", resizeDefinition, async () => (await import("./filters.js")).executeResize);
+export const transformRegistration = lazy("Transform", transformDefinition, async () => (await import("./filters.js")).executeTransform);
+export const compositeRegistration = lazy("Composite", compositeDefinition, async () => (await import("./filters.js")).executeComposite);
+export const imageNodeRegistrations = Object.freeze([
+    colorRegistration,
+    checkersRegistration,
+    noiseRegistration,
+    rampRegistration,
+    textRegistration,
+    imageRegistration,
+    blurRegistration,
+    normalMapRegistration,
+    resizeRegistration,
+    transformRegistration,
+    compositeRegistration,
+    contactSheetRegistration,
+]);
 //# sourceMappingURL=index.js.map

package/dist/runtime/builtins/image/io.d.ts

@@ -0,0 +1,100 @@
+import type { AssetCapability, CascadeAbortSignal, ImagePixels, ImageRef } from "@field/cascade/contracts";
+import { Planar, type RGBA } from "./planar.js";
+/**
+ * How a `cascade.image.*` node reads and writes an image: the in-memory image
+ * contract ("How an image travels between nodes" in doc/PROJECT_AUTHORING.md),
+ * for built-ins that cannot import `cascade/image` (the runtime depends on
+ * contracts alone).
+ *
+ * In: the host's pixels when it still holds them (`assets.imagePixels`), else
+ * the stored bytes decoded with the realm's `createImageBitmap` and read back
+ * off an `OffscreenCanvas`. Out: the pixels to `assets.keepImage` when the
+ * host keeps images in memory (`cascade run`/`render`, Studio), else a PNG
+ * through `assets.write` (an exported editor, the web player).
+ */
+export interface ImageNodeContext {
+    readonly nodeId: string;
+    readonly capabilities: {
+        readonly assets?: AssetCapability;
+    };
+    readonly signal: CascadeAbortSignal;
+}
+interface Bitmap {
+    readonly width: number;
+    readonly height: number;
+    close?(): void;
+}
+export interface Context2D {
+    fillStyle: unknown;
+    font: string;
+    textAlign: string;
+    globalAlpha: number;
+    fillRect(x: number, y: number, width: number, height: number): void;
+    clearRect(x: number, y: number, width: number, height: number): void;
+    save(): void;
+    restore(): void;
+    translate(x: number, y: number): void;
+    rotate(angle: number): void;
+    fillText(text: string, x: number, y: number): void;
+    measureText(text: string): {
+        width: number;
+    };
+    drawImage(image: Bitmap, x: number, y: number): void;
+    getImageData(x: number, y: number, width: number, height: number): {
+        data: Uint8ClampedArray;
+    };
+    putImageData(data: unknown, x: number, y: number): void;
+}
+interface Surface {
+    readonly width: number;
+    readonly height: number;
+    getContext(kind: "2d", options?: {
+        willReadFrequently?: boolean;
+    }): Context2D | null;
+    convertToBlob(options?: {
+        type?: string;
+    }): Promise<{
+        arrayBuffer(): Promise<ArrayBuffer>;
+    }>;
+}
+/**
+ * A CPU-backed 2D surface. `willReadFrequently` keeps a browser on the
+ * software rasteriser the headless host also uses, as `cascade/image` does.
+ */
+export declare function surface(width: number, height: number): {
+    canvas: Surface;
+    context: Context2D;
+};
+/** An image input, an asset or a project path, as the reference to read. */
+export declare function imageReference(value: unknown): {
+    path: string;
+} | null;
+/** Decode stored bytes to 8-bit RGBA through the realm's canvas. */
+export declare function decodePixels(bytes: Uint8Array): Promise<ImagePixels>;
+/** A whole canvas's pixels. */
+export declare function readPixelsFromCanvas(canvas: Surface): ImagePixels;
+export declare function readPixels(context: ImageNodeContext, ref: {
+    path: string;
+}): Promise<ImagePixels>;
+/** An image input as a `Planar`, or null when nothing is wired. */
+export declare function readPlanar(context: ImageNodeContext, value: unknown): Promise<Planar | null>;
+/** Store pixels as this node's image output and return the value to set. */
+export declare function writePixels(context: ImageNodeContext, pixels: ImagePixels): Promise<ImageRef>;
+/** Set a node's `image` output from a `Planar`. */
+export declare function output(context: ImageNodeContext & {
+    readonly outputs: {
+        readonly image: {
+            set(value: ImageRef): void;
+        };
+    };
+}, image: Planar): Promise<void>;
+/**
+ * A colour in any of the shapes the class library accepted: `[r, g, b, a]`
+ * (Cascade's one colour), the older `{ r, g, b, a }`, 0–255 components, or a
+ * CSS `rgb()` / hex string. Saved graphs hold all of them.
+ */
+export declare function normalizeColor(input: unknown): Required<RGBA>;
+/** `rgb(r,g,b)`, or `rgba(r,g,b,a)` below full alpha, for `fillStyle`. */
+export declare function colorToCss(color: RGBA): string;
+export {};
+//# sourceMappingURL=io.d.ts.map

package/dist/runtime/builtins/image/io.js

@@ -0,0 +1,142 @@
+import { Planar } from "./planar.js";
+const NO_CANVAS = "cascade.image: this host has no canvas. In a browser this needs OffscreenCanvas; headless, Cascade installs " +
+    '@napi-rs/canvas before a run (install it with "npm install @napi-rs/canvas" if it is missing).';
+/** The host's canvas, read here and nowhere else (see `cascade.geo.Render`). */
+function canvasGlobals() {
+    return globalThis;
+}
+/**
+ * A CPU-backed 2D surface. `willReadFrequently` keeps a browser on the
+ * software rasteriser the headless host also uses, as `cascade/image` does.
+ */
+export function surface(width, height) {
+    const Canvas = canvasGlobals().OffscreenCanvas;
+    if (!Canvas)
+        throw new Error(NO_CANVAS);
+    const canvas = new Canvas(width, height);
+    const context = canvas.getContext("2d", { willReadFrequently: true });
+    if (!context)
+        throw new Error("cascade.image: the canvas has no 2D context");
+    return { canvas, context };
+}
+function assetsOf(context) {
+    const assets = context.capabilities.assets;
+    if (!assets)
+        throw new Error(`${context.nodeId}: this host gives cascade.image nodes no assets capability`);
+    return assets;
+}
+/** An image input, an asset or a project path, as the reference to read. */
+export function imageReference(value) {
+    if (typeof value === "string")
+        return value ? { path: value } : null;
+    const path = value?.path;
+    return typeof path === "string" && path ? { path } : null;
+}
+/** Decode stored bytes to 8-bit RGBA through the realm's canvas. */
+export async function decodePixels(bytes) {
+    const globals = canvasGlobals();
+    if (!globals.createImageBitmap || !globals.Blob)
+        throw new Error(NO_CANVAS);
+    const bitmap = await globals.createImageBitmap(new globals.Blob([bytes]));
+    try {
+        const { width, height } = bitmap;
+        if (!width || !height)
+            throw new Error("cascade.image: could not decode the image data");
+        const { context } = surface(width, height);
+        context.drawImage(bitmap, 0, 0);
+        return { width, height, data: context.getImageData(0, 0, width, height).data };
+    }
+    finally {
+        bitmap.close?.();
+    }
+}
+/** A whole canvas's pixels. */
+export function readPixelsFromCanvas(canvas) {
+    const context = canvas.getContext("2d", { willReadFrequently: true });
+    if (!context)
+        throw new Error("cascade.image: the canvas has no 2D context");
+    return { width: canvas.width, height: canvas.height, data: context.getImageData(0, 0, canvas.width, canvas.height).data };
+}
+export async function readPixels(context, ref) {
+    const assets = assetsOf(context);
+    const kept = assets.imagePixels?.(ref);
+    if (kept)
+        return kept;
+    return decodePixels(await assets.read(ref, { signal: context.signal }));
+}
+/** An image input as a `Planar`, or null when nothing is wired. */
+export async function readPlanar(context, value) {
+    const ref = imageReference(value);
+    return ref ? Planar.fromPixels(await readPixels(context, ref)) : null;
+}
+async function encodePng(pixels) {
+    const globals = canvasGlobals();
+    if (!globals.ImageData)
+        throw new Error(NO_CANVAS);
+    const { canvas, context } = surface(pixels.width, pixels.height);
+    context.putImageData(new globals.ImageData(pixels.data, pixels.width, pixels.height), 0, 0);
+    const blob = await canvas.convertToBlob({ type: "image/png" });
+    return new Uint8Array(await blob.arrayBuffer());
+}
+/** Store pixels as this node's image output and return the value to set. */
+export async function writePixels(context, pixels) {
+    const assets = assetsOf(context);
+    const name = `${context.nodeId}.png`;
+    const options = { signal: context.signal };
+    const stored = assets.keepImage
+        ? await assets.keepImage(pixels, { suggestedName: name }, options)
+        : await assets.write(await encodePng(pixels), { mediaType: "image/png", suggestedName: name }, options);
+    return { path: stored.path, size: [pixels.width, pixels.height], channels: "rgba", depth: "u8", space: "srgb" };
+}
+/** Set a node's `image` output from a `Planar`. */
+export async function output(context, image) {
+    context.outputs.image.set(await writePixels(context, image.toPixels()));
+}
+/**
+ * A colour in any of the shapes the class library accepted: `[r, g, b, a]`
+ * (Cascade's one colour), the older `{ r, g, b, a }`, 0–255 components, or a
+ * CSS `rgb()` / hex string. Saved graphs hold all of them.
+ */
+export function normalizeColor(input) {
+    if (input && typeof input === "object" && !Array.isArray(input) && "r" in input && "g" in input && "b" in input) {
+        const color = input;
+        const unit = color.r <= 1 && color.g <= 1 && color.b <= 1;
+        return {
+            r: unit ? color.r : color.r / 255,
+            g: unit ? color.g : color.g / 255,
+            b: unit ? color.b : color.b / 255,
+            a: color.a !== undefined ? (unit ? color.a : color.a / 255) : 1,
+        };
+    }
+    if (Array.isArray(input)) {
+        const unit = input.every((value) => value <= 1);
+        return {
+            r: unit ? input[0] : input[0] / 255,
+            g: unit ? input[1] : input[1] / 255,
+            b: unit ? input[2] : input[2] / 255,
+            a: input[3] !== undefined ? (unit ? input[3] : input[3] / 255) : 1,
+        };
+    }
+    if (typeof input === "string") {
+        const rgb = input.match(/rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/);
+        if (rgb)
+            return { r: parseInt(rgb[1], 10) / 255, g: parseInt(rgb[2], 10) / 255, b: parseInt(rgb[3], 10) / 255, a: 1 };
+        const hex = input.replace("#", "");
+        if (hex.length === 3 || hex.length === 6) {
+            const expanded = hex.length === 3 ? hex.split("").map((digit) => digit + digit).join("") : hex;
+            const parts = /^([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(expanded);
+            if (parts)
+                return { r: parseInt(parts[1], 16) / 255, g: parseInt(parts[2], 16) / 255, b: parseInt(parts[3], 16) / 255, a: 1 };
+        }
+    }
+    return { r: 0, g: 0, b: 0, a: 1 };
+}
+/** `rgb(r,g,b)`, or `rgba(r,g,b,a)` below full alpha, for `fillStyle`. */
+export function colorToCss(color) {
+    const r = Math.round(color.r * 255);
+    const g = Math.round(color.g * 255);
+    const b = Math.round(color.b * 255);
+    const a = color.a !== undefined ? color.a : 1;
+    return a < 1 ? `rgba(${r},${g},${b},${a})` : `rgb(${r},${g},${b})`;
+}
+//# sourceMappingURL=io.js.map

package/dist/runtime/builtins/image/planar.d.ts

@@ -0,0 +1,55 @@
+import type { ImagePixels } from "@field/cascade/contracts";
+/**
+ * The working image of the `cascade.image.*` nodes: one Float32Array per
+ * channel, 0..1, one, three or four channels.
+ *
+ * Ported from the class library's `ImageBuffer` with the canvas half left out.
+ * The arithmetic is kept exactly — the same Float32 stores, the same 1/255
+ * conversion in and the same round-and-clamp out — because the port is held to
+ * the class nodes' golden images pixel for pixel
+ * (`tests/fixtures/image-golden`). Between nodes an image travels as 8-bit
+ * RGBA (`ImagePixels`, see "How an image travels between nodes"), so a value
+ * becomes a `Planar` when a node reads it and 8-bit again when it writes.
+ */
+export declare class Planar {
+    readonly width: number;
+    readonly height: number;
+    readonly channels: Float32Array[];
+    constructor(width: number, height: number, channels: Float32Array[]);
+    static grayscale(width: number, height: number): Planar;
+    static rgba(width: number, height: number): Planar;
+    /** From 8-bit RGBA, unpremultiplied. */
+    static fromPixels(pixels: ImagePixels): Planar;
+    static solid(width: number, height: number, color: RGBA): Planar;
+    get channelCount(): number;
+    get pixelCount(): number;
+    fill(channel: number, value: number): void;
+    clone(): Planar;
+    emptyClone(): Planar;
+    toRGBA(): Planar;
+    /** To 8-bit RGBA: a grey image fills red, green and blue, and no alpha is opaque. */
+    toPixels(): ImagePixels;
+    /** Bilinear, clamped at the edges (or wrapped). */
+    sample(x: number, y: number, channel?: number, wrap?: boolean): number;
+}
+export interface RGBA {
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a?: number;
+}
+/** A plain resample to a new size, every channel, opaque when there was no alpha. */
+export declare function resample(source: Planar, width: number, height: number): Planar;
+export type ResolutionMode = "input" | "input1" | "input2" | "largest" | "smallest" | "custom";
+export type FitMode = "fill" | "fit" | "stretch" | "native";
+/** Which input decides the output size. */
+export declare function resolveOutputSize(mode: ResolutionMode, inputs: readonly (Planar | null)[], customSize?: readonly [number, number]): {
+    width: number;
+    height: number;
+};
+/**
+ * Fit an image to a size: `fill` crops, `fit` letterboxes, `stretch` distorts,
+ * `native` centres it at 1:1.
+ */
+export declare function resizeToFit(source: Planar, targetWidth: number, targetHeight: number, fitMode?: FitMode): Planar;
+//# sourceMappingURL=planar.d.ts.map

package/dist/runtime/builtins/image/planar.js

@@ -0,0 +1,274 @@
+/**
+ * The working image of the `cascade.image.*` nodes: one Float32Array per
+ * channel, 0..1, one, three or four channels.
+ *
+ * Ported from the class library's `ImageBuffer` with the canvas half left out.
+ * The arithmetic is kept exactly — the same Float32 stores, the same 1/255
+ * conversion in and the same round-and-clamp out — because the port is held to
+ * the class nodes' golden images pixel for pixel
+ * (`tests/fixtures/image-golden`). Between nodes an image travels as 8-bit
+ * RGBA (`ImagePixels`, see "How an image travels between nodes"), so a value
+ * becomes a `Planar` when a node reads it and 8-bit again when it writes.
+ */
+export class Planar {
+    width;
+    height;
+    channels;
+    constructor(width, height, channels) {
+        pixelCount(width, height);
+        this.width = width;
+        this.height = height;
+        this.channels = channels;
+    }
+    static grayscale(width, height) {
+        return new Planar(width, height, [new Float32Array(pixelCount(width, height))]);
+    }
+    static rgba(width, height) {
+        const size = pixelCount(width, height);
+        return new Planar(width, height, [
+            new Float32Array(size),
+            new Float32Array(size),
+            new Float32Array(size),
+            new Float32Array(size),
+        ]);
+    }
+    /** From 8-bit RGBA, unpremultiplied. */
+    static fromPixels(pixels) {
+        const { width, height, data } = pixels;
+        const size = width * height;
+        const r = new Float32Array(size);
+        const g = new Float32Array(size);
+        const b = new Float32Array(size);
+        const a = new Float32Array(size);
+        const inv255 = 1 / 255;
+        for (let i = 0; i < size; i++) {
+            const idx = i * 4;
+            r[i] = data[idx] * inv255;
+            g[i] = data[idx + 1] * inv255;
+            b[i] = data[idx + 2] * inv255;
+            a[i] = data[idx + 3] * inv255;
+        }
+        return new Planar(width, height, [r, g, b, a]);
+    }
+    static solid(width, height, color) {
+        const buffer = Planar.rgba(width, height);
+        buffer.fill(0, color.r);
+        buffer.fill(1, color.g);
+        buffer.fill(2, color.b);
+        buffer.fill(3, color.a ?? 1);
+        return buffer;
+    }
+    get channelCount() {
+        return this.channels.length;
+    }
+    get pixelCount() {
+        return this.width * this.height;
+    }
+    fill(channel, value) {
+        this.channels[channel].fill(value);
+    }
+    clone() {
+        return new Planar(this.width, this.height, this.channels.map((channel) => new Float32Array(channel)));
+    }
+    emptyClone() {
+        return new Planar(this.width, this.height, this.channels.map(() => new Float32Array(this.pixelCount)));
+    }
+    toRGBA() {
+        if (this.channels.length >= 4)
+            return this.clone();
+        const result = Planar.rgba(this.width, this.height);
+        const [r, g = r, b = r] = this.channels.length === 1 ? [this.channels[0]] : this.channels;
+        result.channels[0].set(r);
+        result.channels[1].set(g);
+        result.channels[2].set(b);
+        result.channels[3].fill(1);
+        return result;
+    }
+    /** To 8-bit RGBA: a grey image fills red, green and blue, and no alpha is opaque. */
+    toPixels() {
+        const size = this.pixelCount;
+        const data = new Uint8ClampedArray(size * 4);
+        const r = this.channels[0];
+        const g = this.channels.length > 1 ? this.channels[1] : r;
+        const b = this.channels.length > 2 ? this.channels[2] : r;
+        const a = this.channels.length > 3 ? this.channels[3] : null;
+        for (let i = 0; i < size; i++) {
+            const idx = i << 2;
+            let v = (r[i] * 255 + 0.5) | 0;
+            data[idx] = v < 0 ? 0 : v > 255 ? 255 : v;
+            v = (g[i] * 255 + 0.5) | 0;
+            data[idx + 1] = v < 0 ? 0 : v > 255 ? 255 : v;
+            v = (b[i] * 255 + 0.5) | 0;
+            data[idx + 2] = v < 0 ? 0 : v > 255 ? 255 : v;
+            if (a) {
+                v = (a[i] * 255 + 0.5) | 0;
+                data[idx + 3] = v < 0 ? 0 : v > 255 ? 255 : v;
+            }
+            else {
+                data[idx + 3] = 255;
+            }
+        }
+        return { width: this.width, height: this.height, data };
+    }
+    /** Bilinear, clamped at the edges (or wrapped). */
+    sample(x, y, channel = 0, wrap = false) {
+        const x0 = Math.floor(x);
+        const y0 = Math.floor(y);
+        const fx = x - x0;
+        const fy = y - y0;
+        const ch = this.channels[channel];
+        const w = this.width;
+        const h = this.height;
+        const px0 = edge(x0, w, wrap);
+        const px1 = edge(x0 + 1, w, wrap);
+        const py0 = edge(y0, h, wrap);
+        const py1 = edge(y0 + 1, h, wrap);
+        const v0 = ch[py0 * w + px0] * (1 - fx) + ch[py0 * w + px1] * fx;
+        const v1 = ch[py1 * w + px0] * (1 - fx) + ch[py1 * w + px1] * fx;
+        return v0 * (1 - fy) + v1 * fy;
+    }
+}
+function edge(coord, max, wrap) {
+    return wrap ? ((coord % max) + max) % max : Math.max(0, Math.min(max - 1, coord));
+}
+function pixelCount(width, height) {
+    const count = width * height;
+    if (!Number.isSafeInteger(width) ||
+        !Number.isSafeInteger(height) ||
+        width < 1 ||
+        height < 1 ||
+        !Number.isSafeInteger(count)) {
+        throw new RangeError(`Image dimensions must be positive safe integers; received ${width}×${height}`);
+    }
+    return count;
+}
+/** A plain resample to a new size, every channel, opaque when there was no alpha. */
+export function resample(source, width, height) {
+    const result = Planar.rgba(width, height);
+    const scaleX = source.width / width;
+    const scaleY = source.height / height;
+    for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
+        const dst = result.channels[c];
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                dst[y * width + x] = source.sample(x * scaleX, y * scaleY, c);
+            }
+        }
+    }
+    if (source.channelCount < 4)
+        result.fill(3, 1);
+    return result;
+}
+/** Which input decides the output size. */
+export function resolveOutputSize(mode, inputs, customSize) {
+    const valid = inputs.filter((buffer) => buffer !== null);
+    const area = (buffer) => buffer.width * buffer.height;
+    switch (mode) {
+        case "input":
+        case "input1":
+            if (valid[0])
+                return { width: valid[0].width, height: valid[0].height };
+            break;
+        case "input2": {
+            const chosen = valid[1] ?? valid[0];
+            if (chosen)
+                return { width: chosen.width, height: chosen.height };
+            break;
+        }
+        case "largest":
+        case "smallest":
+            if (valid.length > 0) {
+                let best = valid[0];
+                let bestArea = mode === "largest" ? 0 : Infinity;
+                for (const buffer of valid) {
+                    if (mode === "largest" ? area(buffer) > bestArea : area(buffer) < bestArea) {
+                        bestArea = area(buffer);
+                        best = buffer;
+                    }
+                }
+                return { width: best.width, height: best.height };
+            }
+            break;
+        case "custom":
+            if (customSize)
+                return { width: customSize[0], height: customSize[1] };
+            break;
+    }
+    if (valid[0])
+        return { width: valid[0].width, height: valid[0].height };
+    return { width: 512, height: 512 };
+}
+/**
+ * Fit an image to a size: `fill` crops, `fit` letterboxes, `stretch` distorts,
+ * `native` centres it at 1:1.
+ */
+export function resizeToFit(source, targetWidth, targetHeight, fitMode = "fill") {
+    if (source.width === targetWidth && source.height === targetHeight)
+        return source;
+    const result = Planar.rgba(targetWidth, targetHeight);
+    const srcAspect = source.width / source.height;
+    const dstAspect = targetWidth / targetHeight;
+    let srcX = 0, srcY = 0, srcW = source.width, srcH = source.height;
+    let dstX = 0, dstY = 0, dstW = targetWidth, dstH = targetHeight;
+    const black = () => {
+        result.fill(0, 0);
+        result.fill(1, 0);
+        result.fill(2, 0);
+        result.fill(3, 1);
+    };
+    switch (fitMode) {
+        case "fill":
+            if (srcAspect > dstAspect) {
+                srcW = Math.round(source.height * dstAspect);
+                srcX = Math.round((source.width - srcW) / 2);
+            }
+            else {
+                srcH = Math.round(source.width / dstAspect);
+                srcY = Math.round((source.height - srcH) / 2);
+            }
+            break;
+        case "fit":
+            if (srcAspect > dstAspect) {
+                dstH = Math.round(targetWidth / srcAspect);
+                dstY = Math.round((targetHeight - dstH) / 2);
+            }
+            else {
+                dstW = Math.round(targetHeight * srcAspect);
+                dstX = Math.round((targetWidth - dstW) / 2);
+            }
+            black();
+            break;
+        case "stretch":
+            break;
+        case "native":
+            dstW = Math.min(source.width, targetWidth);
+            dstH = Math.min(source.height, targetHeight);
+            srcW = dstW;
+            srcH = dstH;
+            dstX = Math.round((targetWidth - dstW) / 2);
+            dstY = Math.round((targetHeight - dstH) / 2);
+            srcX = Math.round((source.width - srcW) / 2);
+            srcY = Math.round((source.height - srcH) / 2);
+            black();
+            break;
+    }
+    const scaleX = srcW / dstW;
+    const scaleY = srcH / dstH;
+    for (let c = 0; c < Math.min(source.channelCount, 4); c++) {
+        const dst = result.channels[c];
+        for (let y = 0; y < dstH; y++) {
+            for (let x = 0; x < dstW; x++) {
+                dst[(dstY + y) * targetWidth + (dstX + x)] = source.sample(srcX + x * scaleX, srcY + y * scaleY, c);
+            }
+        }
+    }
+    if (source.channelCount < 4 && fitMode !== "fit" && fitMode !== "native") {
+        const alpha = result.channels[3];
+        for (let y = 0; y < dstH; y++) {
+            for (let x = 0; x < dstW; x++)
+                alpha[(dstY + y) * targetWidth + (dstX + x)] = 1;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=planar.js.map

package/dist/runtime/builtins/image/simplex.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 2D simplex noise: `createNoise2D` and `buildPermutationTable` from
+ * simplex-noise 4.0.3 by Jonas Wagner (MIT), copied rather than depended on.
+ *
+ * The class `Noise` node loaded simplex-noise@latest from esm.sh at cook time,
+ * so it needed a network and could not run headless. The runtime depends on
+ * contracts alone, so the two functions it used live here, unchanged, and a
+ * seeded noise image is the same pixels it always was.
+ *
+ * Copyright (c) 2024 Jonas Wagner. Permission is hereby granted, free of
+ * charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions: The above copyright notice and this permission
+ * notice shall be included in all copies or substantial portions of the
+ * Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
+ */
+export type NoiseFunction2D = (x: number, y: number) => number;
+export declare function createNoise2D(random: () => number): NoiseFunction2D;
+//# sourceMappingURL=simplex.d.ts.map