@field/cascade 0.11.0 → 0.12.0

package/dist/cli/webBuild-WPPMGGW7.js

@@ -0,0 +1,44 @@
+import {
+  buildPlayer,
+  canonicalFuturePath,
+  exists,
+  inside,
+  installRoot,
+  playerFile,
+  staticRuntimePlugin
+} from "./chunk-OM6BEME6.js";
+import "./chunk-MP653A5O.js";
+import "./chunk-MI5JLQYA.js";
+import "./chunk-GRIN2DDP.js";
+import "./chunk-X4WKAOQP.js";
+import "./chunk-DEQSEFFH.js";
+import "./chunk-RXDIMXN5.js";
+import "./chunk-QQPA2ZHH.js";
+import "./chunk-KH4MUBKF.js";
+import "./chunk-HSNOBIVT.js";
+import "./chunk-L6B6FUQP.js";
+import "./chunk-HFHWYL55.js";
+import "./chunk-KBGUO27Q.js";
+import "./chunk-ICH7N5PN.js";
+import "./chunk-CO22XHNG.js";
+import "./chunk-LTXWBXOM.js";
+import "./chunk-BZ63XQ3I.js";
+import "./chunk-YH637PDL.js";
+import "./chunk-X566FWBV.js";
+import "./chunk-WD62JIP6.js";
+import "./chunk-5ORUQ6ES.js";
+import "./chunk-2JEU3MGB.js";
+import "./chunk-NJFMDXHR.js";
+import "./chunk-J7VK7MNF.js";
+import "./chunk-FWMSGKEH.js";
+import "./chunk-JVOCK5W4.js";
+export {
+  buildPlayer,
+  canonicalFuturePath,
+  exists,
+  inside,
+  installRoot,
+  playerFile,
+  staticRuntimePlugin
+};
+//# sourceMappingURL=webBuild-WPPMGGW7.js.map

package/dist/contracts/capabilities.d.ts

@@ -1,4 +1,4 @@
-import type { AssetRef, ImageRef, JsonValue } from "./values.js";
+import type { AssetRef, ImagePixels, ImageRef, JsonValue } from "./values.js";
 export interface CascadeAbortSignal {
     readonly aborted: boolean;
     readonly reason?: unknown;
@@ -46,6 +46,23 @@ export interface AssetCapability {
         signal: CascadeAbortSignal;
     }): Promise<AssetRef>;
     resolveUrl?(ref: AssetRef | ImageRef): Promise<ResourceLease<string>>;
+    /**
+     * Store an intermediate image from its pixels. Optional; a host without it
+     * gets encoded bytes through `write`. The host chooses how: the headless
+     * host holds the pixels in memory and writes a fast lossless PNG behind
+     * (zlib level 1), or encodes that PNG at once when the run does not keep
+     * pixels. The returned path is content-addressed like `write`'s and is a
+     * whole file before anything reads it from disk. Finals are not encoded
+     * here: a run's saved outputs are encoded at full compression when copied.
+     */
+    keepImage?(pixels: ImagePixels, metadata: {
+        suggestedName?: string;
+    }, options: {
+        signal: CascadeAbortSignal;
+    }): Promise<AssetRef>;
+    /** The pixels behind a stored image while the host still holds them in
+     *  memory, so a reader skips the read and the decode. */
+    imagePixels?(ref: AssetRef | ImageRef): ImagePixels | undefined;
 }
 export interface MediaCapability {
     decodeImage(ref: ImageRef | AssetRef, options: {

package/dist/contracts/color.d.ts

@@ -57,6 +57,14 @@ export declare const Color: Readonly<{
     alpha(color: Color): number;
     /** The same colour at full alpha. */
     opaque(color: Color): Color;
+    /**
+     * A colour saved in an older shape, as the one colour: `{ r, g, b, a? }`
+     * (the class-based image nodes stored that until 2026-11-07) or three
+     * components, with alpha 1. Components above 1 are read as 0–255, the way
+     * those nodes read them. Anything else comes back unchanged, so a reader can
+     * apply this to every stored `color` value and validate the result.
+     */
+    upgrade(value: unknown): unknown;
     /**
      * Four unit components from anything indexable, clamping and defaulting a
      * missing alpha to 1. The reader for a `Cd` attribute's flat array, and the

package/dist/contracts/color.js

@@ -70,6 +70,29 @@ export const Color = Object.freeze({
     opaque(color) {
         return [clamp(color[0]), clamp(color[1]), clamp(color[2]), 1];
     },
+    /**
+     * A colour saved in an older shape, as the one colour: `{ r, g, b, a? }`
+     * (the class-based image nodes stored that until 2026-11-07) or three
+     * components, with alpha 1. Components above 1 are read as 0–255, the way
+     * those nodes read them. Anything else comes back unchanged, so a reader can
+     * apply this to every stored `color` value and validate the result.
+     */
+    upgrade(value) {
+        const legacy = value !== null && typeof value === "object" && !Array.isArray(value) && "r" in value && "g" in value && "b" in value
+            ? value
+            : Array.isArray(value) && value.length === 3
+                ? { r: value[0], g: value[1], b: value[2] }
+                : null;
+        if (!legacy)
+            return value;
+        const parts = [legacy.r, legacy.g, legacy.b, legacy.a ?? 1];
+        if (!parts.every((part) => typeof part === "number" && Number.isFinite(part)))
+            return value;
+        const numbers = parts;
+        const unit = numbers.slice(0, 3).every((part) => part <= 1);
+        const read = (part) => (unit ? part : part / 255);
+        return [read(numbers[0]), read(numbers[1]), read(numbers[2]), legacy.a === undefined ? 1 : read(numbers[3])];
+    },
     /**
      * Four unit components from anything indexable, clamping and defaulting a
      * missing alpha to 1. The reader for a `Cd` attribute's flat array, and the

package/dist/contracts/definition.d.ts

@@ -190,6 +190,16 @@ export interface NodeDefinitionForEnvironment<E extends RuntimeEnvironment> {
      */
     readonly container?: "subnet" | "feedback";
     readonly capabilities?: readonly CapabilityForEnvironment<E>[];
+    /**
+     * GPU limits this node cannot run without, by WebGPU name, for a node that
+     * declares `gpu`: `{ maxStorageBufferBindingSize: 512 * 2 ** 20 }`. The host
+     * already asks for everything the adapter allows; this makes a GPU that
+     * allows less fail before the cook, naming the limit, instead of with a
+     * validation error from inside it. `max*` limits are minimums to reach,
+     * `min*Alignment` ones maximums. Read `context.capabilities.gpu.limits` for
+     * what the device actually gives.
+     */
+    readonly gpuLimits?: Readonly<Record<string, number>>;
     /**
      * `live` marks a node that reads data from outside the graph — an archive,
      * a CLI, a cache, body data, the filesystem or a network. `cascade export`

package/dist/contracts/schema.d.ts

@@ -1,6 +1,6 @@
 export declare const nodeDefinitionSchema: {
-    readonly allOf: readonly [Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>];
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
     readonly $id: "https://cascade.dev/schema/node-definition-v1.json";
+    readonly allOf: readonly [Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>, Readonly<Record<string, unknown>>];
 };
 //# sourceMappingURL=schema.d.ts.map

package/dist/contracts/schema.js

@@ -88,6 +88,7 @@ export const nodeDefinitionSchema = {
             items: { type: "string" },
             uniqueItems: true,
         },
+        gpuLimits: record({ type: "number", minimum: 0 }),
         label: description,
         description,
         icon: description,

package/dist/contracts/validate.js

@@ -19,7 +19,7 @@ export const CAPABILITIES_BY_ENVIRONMENT = {
 };
 const ALLOWED = CAPABILITIES_BY_ENVIRONMENT;
 const fields = (names) => new Set(names.split(" "));
-const TOP_FIELDS = fields("apiVersion runsOn container capabilities source label description icon inputs outputs props");
+const TOP_FIELDS = fields("apiVersion runsOn container capabilities gpuLimits source label description icon inputs outputs props");
 const DATA_FIELDS = fields("kind type default description variadic min max step accept control options schema fields");
 const OUTPUT_FIELDS = fields("kind type description schema fields");
 const PROP_FIELDS = fields("type default label description min max step accept control options expression action");
@@ -111,6 +111,16 @@ export function validateNodeDefinition(value) {
             add("duplicate-capability", `${String(capability)} is duplicated`, path);
         seen.add(capability);
     }
+    if (value.gpuLimits !== undefined) {
+        if (!seen.has("gpu"))
+            add("gpu-limits-without-gpu", "gpuLimits needs the gpu capability", "gpuLimits");
+        if (!isRecord(value.gpuLimits))
+            add("invalid-gpu-limits", "gpuLimits must be an object of WebGPU limit names to numbers", "gpuLimits");
+        else
+            for (const [name, limit] of Object.entries(value.gpuLimits))
+                if (typeof limit !== "number" || !Number.isFinite(limit) || limit < 0)
+                    add("invalid-gpu-limits", `gpuLimits.${name} must be a non-negative number`, `gpuLimits.${name}`);
+    }
     // Two namespaces, not one. An output is addressed in the other direction from
     // an input, so `geometry` in and `geometry` out is not ambiguous anywhere: the
     // document format names the two endpoints of a connection separately, the

package/dist/contracts/values.d.ts

@@ -51,6 +51,18 @@ export type Mat4 = readonly [
     number,
     number
 ];
+/**
+ * The value on an `image` port: a path naming stored pixels, plus what they
+ * are. The port carries the reference, never the pixels, so a value stays
+ * small to snapshot, hash, trace and send to a Python stage.
+ *
+ * The path is always readable as a file by whoever needs a file. A host may
+ * still hold the pixels in memory and write the file behind (see
+ * {@link ImagePixels} and `AssetCapability.keepImage`): a reader in the same
+ * process gets the pixels without a decode, and the host makes the file whole
+ * before anything reads it from disk (a final copy, a Python stage, the end of
+ * a run).
+ */
 export interface ImageRef {
     readonly path: string;
     readonly size: Vec2i;
@@ -58,6 +70,18 @@ export interface ImageRef {
     readonly depth: "u8" | "u16" | "f16" | "f32";
     readonly space: "srgb" | "linear";
 }
+/**
+ * An image's pixels in memory: 8-bit RGBA, sRGB, unpremultiplied, row-major
+ * with the top row first. This is the layout of `ImageData` and of a PNG's
+ * decoded rows, so handing pixels on in memory and handing them on through a
+ * PNG give the next node the same numbers.
+ */
+export interface ImagePixels {
+    readonly width: number;
+    readonly height: number;
+    /** `width * height * 4` bytes. Owned by the host once kept: never mutate. */
+    readonly data: Uint8ClampedArray;
+}
 declare const textureHandleBrand: unique symbol;
 export interface TextureHandle {
     readonly [textureHandleBrand]: true;

package/dist/image.d.ts

@@ -43,6 +43,8 @@
  * `cascade/io`'s bridge, because the node's copy of this module and the CLI's
  * copy are not always the same module instance.
  */
+import { type ImagePixels } from './io.js';
+export type { ImagePixels } from './io.js';
 /** An image port value. Mirrors Cascade's core `ImageRef`. */
 export interface ImageRef {
     path: string;
@@ -71,6 +73,19 @@ export interface ImageAssets {
         path: string;
         mediaType?: string;
     }>;
+    /** Optional: store an intermediate from its pixels (see core `AssetCapability.keepImage`). */
+    keepImage?(pixels: ImagePixels, metadata: {
+        suggestedName?: string;
+    }, options: {
+        signal: unknown;
+    }): Promise<{
+        path: string;
+        mediaType?: string;
+    }>;
+    /** Optional: the pixels behind a stored image while the host holds them in memory. */
+    imagePixels?(ref: {
+        path: string;
+    }): ImagePixels | undefined;
 }
 /**
  * The slice of a definition-v1 `NodeExecutionContext` these helpers need, so

package/dist/image.js

@@ -1,3 +1,29 @@
+// server/src/runtime/io.ts
+function pixelsBitmap(pixels) {
+  const Canvas = globalThis.OffscreenCanvas;
+  if (!Canvas) throw new Error("cascade/io: this host has no OffscreenCanvas to hold the image");
+  const canvas = new Canvas(pixels.width, pixels.height);
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("cascade/io: the canvas has no 2D context");
+  const data = new ImageData(pixels.data, pixels.width, pixels.height);
+  context.putImageData(data, 0, 0);
+  const drawable = canvas;
+  drawable.close = () => {
+  };
+  drawable.naturalWidth = pixels.width;
+  drawable.naturalHeight = pixels.height;
+  return canvas;
+}
+function canvasPixels(source) {
+  const canvas = source;
+  if (typeof canvas?.getContext !== "function" || typeof canvas.width !== "number" || typeof canvas.height !== "number") return null;
+  if (!canvas.width || !canvas.height) return null;
+  const context = canvas.getContext("2d");
+  if (!context || typeof context.getImageData !== "function") return null;
+  const image = context.getImageData(0, 0, canvas.width, canvas.height);
+  return { width: image.width, height: image.height, data: image.data };
+}
+
 // server/src/runtime/image.ts
 var HOST_KEY = "__cascadeImageHost";
 var 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).';
@@ -97,12 +123,20 @@ async function readBytes(context, ref) {
   return assetsOf(context).read(refOf(ref), { signal: context.signal ?? NEVER });
 }
 async function readImage(context, ref) {
+  const pixels = assetsOf(context).imagePixels?.(refOf(ref));
+  if (pixels) return pixelsBitmap(pixels);
   return decodeImage(await readBytes(context, ref));
 }
 async function writeImage(context, canvas, name, options = {}) {
   const type = options.type ?? "image/png";
-  const bytes = await encodeImage(canvas, { type, ...options.quality === void 0 ? {} : { quality: options.quality } });
-  const stored = await assetsOf(context).write(bytes, { mediaType: type, suggestedName: name }, { signal: context.signal ?? NEVER });
+  const assets = assetsOf(context);
+  const signal = context.signal ?? NEVER;
+  const pixels = type === "image/png" && assets.keepImage ? canvasPixels(canvas) : null;
+  const stored = pixels && assets.keepImage ? await assets.keepImage(pixels, { suggestedName: name }, { signal }) : await assets.write(
+    await encodeImage(canvas, { type, ...options.quality === void 0 ? {} : { quality: options.quality } }),
+    { mediaType: type, suggestedName: name },
+    { signal }
+  );
   return {
     path: stored.path,
     size: [canvas.width, canvas.height],

package/dist/index.html

@@ -6,11 +6,17 @@
   <!-- Pinterest browser extension: no Save buttons over canvases and previews -->
   <meta name="pinterest" content="nopin">
   <title>Cascade</title>
-  <script type="module" crossorigin src="/assets/index-5ZtDAuy2.js"></script>
+  <script type="module" crossorigin src="/assets/index-BWnrmIB9.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/legacy-CTEeXeqF.js">
   <link rel="modulepreload" crossorigin href="/assets/index-client-DqYmKstU.js">
   <link rel="modulepreload" crossorigin href="/assets/nodeTypeUtils-BDJsc2Ks.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-7vae6YFC.css">
+  <link rel="modulepreload" crossorigin href="/assets/coreTypes-DtnDATZ7.js">
+  <link rel="modulepreload" crossorigin href="/assets/expressions-X-Z-GrgW.js">
+  <link rel="modulepreload" crossorigin href="/assets/DefinitionNode-CaRTXQ_b.js">
+  <link rel="modulepreload" crossorigin href="/assets/builder-BmBKcDix.js">
+  <link rel="modulepreload" crossorigin href="/assets/preload-helper-Czpn1I53.js">
+  <link rel="modulepreload" crossorigin href="/assets/studioImages-CAyH-0Pl.js">
+  <link rel="stylesheet" crossorigin href="/assets/index-DIaxEONI.css">
 </head>
 <body>
   <div id="app"></div>

package/dist/io.d.ts

@@ -33,6 +33,24 @@ export interface IoBridge {
     write(path: string, data: Uint8Array): Promise<string>;
     /** Host-owned display URL, valid until the host releases its stored asset. */
     url?(path: string, options?: MediaOptions): string;
+    /**
+     * Store an intermediate image from its pixels and return the stored path,
+     * as `write` would. Optional. The headless host has it: it writes a fast
+     * lossless PNG, and in a run that keeps pixels it holds them in memory and
+     * writes behind (`pixels` below). Without it `saveImage` encodes and writes.
+     */
+    keep?(path: string, pixels: ImagePixels): Promise<string>;
+    /** The pixels behind a path `keep` returned, while the host holds them. */
+    pixels?(path: string): ImagePixels | undefined;
+}
+/**
+ * An image's pixels in memory. Mirrors Cascade's core `ImagePixels`: 8-bit
+ * RGBA, sRGB, unpremultiplied, top row first — `ImageData`'s layout.
+ */
+export interface ImagePixels {
+    readonly width: number;
+    readonly height: number;
+    readonly data: Uint8ClampedArray;
 }
 /** Install the local transport. Returns a disposer, so a test can take it down. */
 export declare function installIoBridge(bridge: IoBridge | null): () => void;
@@ -47,6 +65,11 @@ export declare function loadBytes(path: string, options?: MediaOptions): Promise
  * to hand it. Pass a width explicitly to work at a smaller size on purpose.
  */
 export declare function loadImage(path: string, options?: MediaOptions): Promise<HTMLImageElement>;
+/**
+ * `ImagePixels` as a drawable: a canvas holding them, with an `ImageBitmap`'s
+ * `width`, `height` and `close()` (and an image's `naturalWidth`/`naturalHeight`).
+ */
+export declare function pixelsBitmap(pixels: ImagePixels): ImageBitmap;
 /** Same, as an ImageBitmap — the right input for `texImage2D`. */
 export declare function loadBitmap(path: string, options?: MediaOptions): Promise<ImageBitmap>;
 /**
@@ -83,6 +106,12 @@ export interface ImageSource {
  *   node.out('path').setValue(out);
  */
 export declare function saveImage(source: HTMLCanvasElement | OffscreenCanvas | Blob | ImageSource, path: string, options?: SaveOptions): Promise<string>;
+/**
+ * A canvas's pixels as `ImagePixels`, or null for anything that is not a 2D
+ * canvas (a Blob, an encoder-only source, a WebGL canvas, whose `getContext('2d')`
+ * is null).
+ */
+export declare function canvasPixels(source: unknown): ImagePixels | null;
 /** Write any bytes into the project cache and return the path. */
 export declare function saveBytes(data: Blob | ArrayBuffer | Uint8Array, path: string): Promise<string>;
 /**

package/dist/io.js

@@ -40,6 +40,8 @@ async function loadBytes(path, options = { raw: true }) {
   return await response.arrayBuffer();
 }
 async function loadImage(path, options = { raw: true }) {
+  const held = heldBitmap(path);
+  if (held) return held;
   const image = new Image();
   const bridge = localIo();
   let temporaryUrl;
@@ -65,7 +67,29 @@ async function loadImage(path, options = { raw: true }) {
     if (temporaryUrl) URL.revokeObjectURL(temporaryUrl);
   }
 }
+function heldBitmap(path) {
+  if (/^(https?:|data:|blob:)/.test(path)) return null;
+  const pixels = localIo()?.pixels?.(path.replace(/^\.?\//, ""));
+  return pixels ? pixelsBitmap(pixels) : null;
+}
+function pixelsBitmap(pixels) {
+  const Canvas = globalThis.OffscreenCanvas;
+  if (!Canvas) throw new Error("cascade/io: this host has no OffscreenCanvas to hold the image");
+  const canvas = new Canvas(pixels.width, pixels.height);
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("cascade/io: the canvas has no 2D context");
+  const data = new ImageData(pixels.data, pixels.width, pixels.height);
+  context.putImageData(data, 0, 0);
+  const drawable = canvas;
+  drawable.close = () => {
+  };
+  drawable.naturalWidth = pixels.width;
+  drawable.naturalHeight = pixels.height;
+  return canvas;
+}
 async function loadBitmap(path, options = { raw: true }) {
+  const held = heldBitmap(path);
+  if (held) return held;
   const bridge = localIo();
   if (bridge?.url) return createImageBitmap(await loadImage(path, options));
   if (bridge) return createImageBitmap(new Blob([await loadBytes(path, options)]));
@@ -80,6 +104,11 @@ async function saveImage(source, path, options = {}) {
   const format = options.format ?? "png";
   const type = `image/${format}`;
   let blob;
+  const bridge = localIo();
+  if (format === "png" && bridge?.keep) {
+    const pixels = canvasPixels(source);
+    if (pixels) return bridge.keep(path.replace(/^\.?\//, ""), pixels);
+  }
   if (source instanceof Blob) {
     blob = source;
   } else if (typeof source.convertToBlob === "function") {
@@ -99,6 +128,15 @@ async function saveImage(source, path, options = {}) {
   }
   return saveBytes(blob, path);
 }
+function canvasPixels(source) {
+  const canvas = source;
+  if (typeof canvas?.getContext !== "function" || typeof canvas.width !== "number" || typeof canvas.height !== "number") return null;
+  if (!canvas.width || !canvas.height) return null;
+  const context = canvas.getContext("2d");
+  if (!context || typeof context.getImageData !== "function") return null;
+  const image = context.getImageData(0, 0, canvas.width, canvas.height);
+  return { width: image.width, height: image.height, data: image.data };
+}
 async function saveBytes(data, path) {
   const clean = path.replace(/^\.?\//, "");
   const bridge = localIo();
@@ -302,6 +340,7 @@ async function textureToImage(ref, path, options = {}) {
 }
 export {
   cachePath,
+  canvasPixels,
   createTexture,
   installIoBridge,
   loadBitmap,
@@ -310,6 +349,7 @@ export {
   loadFloats,
   loadImage,
   mediaUrl,
+  pixelsBitmap,
   saveBytes,
   saveFloats,
   saveImage,

package/dist/player/app.js

@@ -12,7 +12,8 @@ import { installIoBridge } from "@field/cascade/io";
 
 // src/browser/gpu.ts
 import {
-  createGpuHost
+  createGpuHost,
+  requestDeviceWithAdapterLimits
 } from "@field/cascade/runtime";
 function createBrowserGpuHost() {
   const gpu = globalThis.navigator?.gpu;
@@ -25,7 +26,7 @@ function createBrowserGpuHost() {
           "No WebGPU adapter is available \u2014 the browser reports WebGPU but the system offers no GPU to render on."
         );
       }
-      const device = await adapter.requestDevice();
+      const device = await requestDeviceWithAdapterLimits(adapter);
       const info = adapter.info;
       return {
         device,

package/dist/player/editor.js

@@ -28,7 +28,8 @@ import { installIoBridge } from "@field/cascade/io";
 
 // src/browser/gpu.ts
 import {
-  createGpuHost
+  createGpuHost,
+  requestDeviceWithAdapterLimits
 } from "@field/cascade/runtime";
 function createBrowserGpuHost() {
   const gpu = globalThis.navigator?.gpu;
@@ -41,7 +42,7 @@ function createBrowserGpuHost() {
           "No WebGPU adapter is available \u2014 the browser reports WebGPU but the system offers no GPU to render on."
         );
       }
-      const device = await adapter.requestDevice();
+      const device = await requestDeviceWithAdapterLimits(adapter);
       const info = adapter.info;
       return {
         device,

package/dist/player/editorEngine.js

@@ -5,7 +5,8 @@ import { installIoBridge as installIoBridge2 } from "@field/cascade/io";
 
 // src/browser/gpu.ts
 import {
-  createGpuHost
+  createGpuHost,
+  requestDeviceWithAdapterLimits
 } from "@field/cascade/runtime";
 function createBrowserGpuHost() {
   const gpu = globalThis.navigator?.gpu;
@@ -18,7 +19,7 @@ function createBrowserGpuHost() {
           "No WebGPU adapter is available \u2014 the browser reports WebGPU but the system offers no GPU to render on."
         );
       }
-      const device = await adapter.requestDevice();
+      const device = await requestDeviceWithAdapterLimits(adapter);
       const info = adapter.info;
       return {
         device,

package/dist/runtime/builtins/assert/checks.d.ts

@@ -0,0 +1,18 @@
+import type { NodeExecutionContext } from "@field/cascade/contracts";
+import type { equalsDefinition, notBlankDefinition, rangeDefinition, trueDefinition } from "./definitions.js";
+export declare function executeRange({ nodeId, inputs, props, outputs }: NodeExecutionContext<typeof rangeDefinition>): void;
+export declare function executeEquals({ nodeId, inputs, props, outputs }: NodeExecutionContext<typeof equalsDefinition>): void;
+export declare function executeTrue({ nodeId, inputs, props, outputs }: NodeExecutionContext<typeof trueDefinition>): void;
+export declare function executeNotBlank({ nodeId, inputs, props, outputs, capabilities, signal }: NodeExecutionContext<typeof notBlankDefinition>): Promise<void>;
+export interface Pixels {
+    readonly width: number;
+    readonly height: number;
+    /** Channels per pixel: 1 grey, 2 grey+alpha, 3 RGB, 4 RGBA. */
+    readonly channels: number;
+    readonly data: ArrayLike<number>;
+}
+/** 'one flat colour', 'fully transparent', or null when the image has content. */
+export declare function blankness(pixels: Pixels, tolerance?: number): string | null;
+/** 8-bit non-interlaced PNG (grey, grey+alpha, RGB, RGBA) or binary PPM/PGM. */
+export declare function decodeImage(bytes: Uint8Array): Promise<Pixels | null>;
+//# sourceMappingURL=checks.d.ts.map