@field/cascade 0.2.22 → 0.3.1

package/dist/gpu.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `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;
+};

package/dist/gpu.js

@@ -0,0 +1,53 @@
+// 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
+};
+export {
+  BufferUsage,
+  ColorWrite,
+  MapMode,
+  ShaderStage,
+  TextureUsage
+};
+//# sourceMappingURL=gpu.js.map

package/dist/graphs/default.cascade

@@ -9,7 +9,7 @@
   "nodes": [
     {
       "id": "Color1",
-      "module": "cascade.lens.Color",
+      "module": "cascade.image.Color",
       "position": [0, 0],
       "source": "stdlib",
       "props": {

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-BXYXSdgh.js"></script>
-  <link rel="modulepreload" crossorigin href="/assets/legacy-DIu3XRwl.js">
-  <link rel="modulepreload" crossorigin href="/assets/index-client-DN_FvjN8.js">
-  <link rel="modulepreload" crossorigin href="/assets/nodeTypeUtils-CweA3NHd.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-CrNke7SW.css">
+  <script type="module" crossorigin src="/assets/index-CMcH8AgP.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">
 </head>
 <body>
   <div id="app"></div>

package/dist/io.d.ts

@@ -0,0 +1,196 @@
+/**
+ * `cascade/io` — the runtime a BROWSER-side node imports.
+ *
+ * The interop rests on one rule: an image port carries a project-relative PATH,
+ * never pixels. A Python node writes a file and emits its path; a WebGL node
+ * reads that path as a texture, renders, writes its result back, and emits a
+ * path of the same kind. Neither knows or cares which side produced its input,
+ * which is what makes the two interchangeable — and it lets the heavy stages
+ * stay in Python while the interactive ones run in the page.
+ *
+ * The counterpart on the server side is the project's own exec bridge
+ * (`runStage`), which is per-project because the stages are.
+ *
+ * This file is compiled into any node module that imports 'cascade/io'; it is
+ * not published to npm and has no dependencies.
+ */
+export interface MediaOptions {
+    /** Ask for a resized copy. Never upscales past the file's own resolution. */
+    width?: number;
+    /** 'webp' | 'png' | 'jpeg' | 'avif'. Defaults to WebP, which is what you want
+     *  for anything being looked at rather than processed. */
+    format?: string;
+    /** The original bytes, unresized and unconverted. Use this when the pixels
+     *  matter — reading a render back for further processing, not previewing it. */
+    raw?: boolean;
+    quality?: number;
+}
+/** Build the URL that serves a project file to the page. */
+export declare function mediaUrl(path: string, options?: MediaOptions): string;
+/**
+ * The transport a host installs so `cascade/io` can reach project files.
+ *
+ * Same shape of decision as `cascade/stage`: the page posts to the server,
+ * because that is the only door a browser has, and a headless host installs a
+ * local transport before it runs the graph. Without one, every read here is a
+ * `fetch('/api/media/...')` against a relative URL with no origin to resolve it
+ * — which is exactly how a Canvas 2D node came to render in Studio and fail
+ * under `cascade run`.
+ *
+ * Paths stay project-relative on both sides. The bridge, not the node, decides
+ * what that resolves to.
+ */
+export interface IoBridge {
+    /** Read a project file's bytes. */
+    read(path: string, options?: MediaOptions): Promise<Uint8Array>;
+    /** Write bytes into the project cache. Returns the stored project-relative path. */
+    write(path: string, data: Uint8Array): Promise<string>;
+}
+/** Install the local transport. Returns a disposer, so a test can take it down. */
+export declare function installIoBridge(bridge: IoBridge | null): () => void;
+/**
+ * A project file's bytes, over whichever transport this host has. Every read in
+ * this module goes through here so the two hosts differ in one place only.
+ */
+export declare function loadBytes(path: string, options?: MediaOptions): Promise<ArrayBuffer>;
+/**
+ * Load a project image as an <img>. Defaults to `raw` — a node is processing
+ * these pixels, not showing them, so a re-encoded copy would be the wrong thing
+ * 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>;
+/** Same, as an ImageBitmap — the right input for `texImage2D`. */
+export declare function loadBitmap(path: string, options?: MediaOptions): Promise<ImageBitmap>;
+/**
+ * A .npy field (a mask, a signal, a height or density field) rendered to
+ * greyscale, ready to upload as a texture. The numeric array itself stays on
+ * the server side for now; this is the visual form of it.
+ */
+export declare function loadFieldBitmap(path: string, options?: MediaOptions): Promise<ImageBitmap>;
+export interface SaveOptions {
+    /** 'png' (default), 'webp' or 'jpeg'. PNG is the default because the usual
+     *  consumer of a node's output is another node, and a lossy intermediate
+     *  compounds down a pipeline. Choose webp when the output is a preview. */
+    format?: 'png' | 'webp' | 'jpeg';
+    quality?: number;
+}
+/**
+ * Anything that can produce encoded pixels. The two browser canvases are the
+ * usual case; a headless host's canvas offers Skia's own encoder instead, and
+ * `saveImage` takes whichever it is handed rather than making a node care.
+ */
+export interface ImageSource {
+    convertToBlob?(options?: {
+        type?: string;
+        quality?: number;
+    }): Promise<Blob>;
+    encode?(format: string, quality?: number): Promise<Uint8Array>;
+    toBuffer?(mime: string): Uint8Array;
+}
+/**
+ * Write pixels into the project and get back the path to hand downstream.
+ * Confined to the cache directory, like every other node output.
+ *
+ *   const out = await saveImage(canvas, cachePath(node.id, '.png'));
+ *   node.out('path').setValue(out);
+ */
+export declare function saveImage(source: HTMLCanvasElement | OffscreenCanvas | Blob | ImageSource, path: string, options?: SaveOptions): Promise<string>;
+/** Write any bytes into the project cache and return the path. */
+export declare function saveBytes(data: Blob | ArrayBuffer | Uint8Array, path: string): Promise<string>;
+/**
+ * The output path convention, shared with the Python side: scoped by node id so
+ * one node's scratch file never lands on a sibling's. The server puts the cache
+ * key into the filename when it writes, so different inputs keep separate files.
+ */
+export declare function cachePath(nodeId: string, suffix: string): string;
+/**
+ * Float pixel data, shared between Python and JavaScript with no conversion.
+ *
+ * This works because a `.npy` file holding little-endian float32 in C order IS
+ * a Float32Array with a header in front of it. numpy pads that header so the
+ * data begins on a 64-byte boundary — measured on this project's own files, it
+ * starts at byte 128 every time — which means a typed array can be constructed
+ * as a VIEW onto the fetched buffer rather than a copy of it. A 10 MB density
+ * field costs one fetch and no marshalling.
+ *
+ * From there it goes straight where you need it: into `texImage2D` as an R32F
+ * or RGBA32F texture, into a compute pass, or through `toImageData` for
+ * Canvas2D. And `saveFloats` writes the same layout back, so `np.load` on the
+ * Python side reads it as an ordinary array.
+ */
+export interface FloatImage {
+    data: Float32Array;
+    /** [width, height] */
+    size: [number, number];
+    /** 1 for a mask or signal, 3 for RGB, 4 for RGBA. */
+    channels: number;
+}
+/**
+ * Read a float image as a zero-copy Float32Array view. Non-float and
+ * non-native-endian arrays are converted rather than refused, so a uint8 mask
+ * still loads — it just costs a pass.
+ */
+export declare function loadFloats(path: string): Promise<FloatImage>;
+/** Write float pixels back into the project. Python reads the result with a
+ *  plain `np.load`. Returns the stored path. */
+export declare function saveFloats(image: FloatImage, path: string): Promise<string>;
+/**
+ * Float pixels -> ImageData for Canvas2D. Values are assumed to be 0..1 unless
+ * a range is given; pass the field's actual range to see it the way the viewer
+ * does rather than clipped.
+ */
+export declare function toImageData(image: FloatImage, range?: [number, number]): ImageData;
+/**
+ * Upload float pixels as a GPU texture, no conversion on the way. Needs the
+ * EXT_color_buffer_float extension to render INTO one; sampling works without.
+ */
+export declare function uploadFloatTexture(gl: WebGL2RenderingContext, image: FloatImage): WebGLTexture;
+/**
+ * A live GPU texture, passed between browser nodes.
+ *
+ * Separate from `image` on purpose, and the distinction is about cost rather
+ * than taste. An `image` is file-backed: durable, portable, readable by Python,
+ * and it costs a write and a read every time it is handed on. A `texture` never
+ * leaves the page — a chain of WebGL nodes passes one along with no round trip
+ * at all, which is what makes an interactive shader chain feel immediate.
+ *
+ * Because it is session-bound it cannot be cached, cannot be inspected after a
+ * reload, and cannot be read by a Python stage. So the conversions are explicit:
+ * `toImage` is a GPU readback and a file write, and it should be visible in the
+ * graph rather than happening silently on a connection.
+ */
+export interface TextureRef {
+    gl: WebGL2RenderingContext;
+    texture: WebGLTexture;
+    /** [width, height] */
+    size: [number, number];
+    channels: number;
+    /** True when the texture holds float data rather than 8-bit. */
+    float: boolean;
+}
+/** Upload an image file to the GPU. The integer path for `uploadFloatTexture`. */
+export declare function textureFromImage(gl: WebGL2RenderingContext, image: string | {
+    path: string;
+}, options?: MediaOptions): Promise<TextureRef>;
+/** Allocate an empty texture to render into. */
+export declare function createTexture(gl: WebGL2RenderingContext, size: [number, number], options?: {
+    float?: boolean;
+    channels?: number;
+}): TextureRef;
+/**
+ * Read a texture back off the GPU and write it into the project as an image.
+ * The one place a texture becomes durable — deliberately a named step, because
+ * a readback stalls the pipeline and a write costs a file.
+ */
+export declare function textureToImage(ref: TextureRef, path: string, options?: {
+    format?: 'png' | 'webp';
+    space?: 'srgb' | 'linear';
+}): Promise<ImageRef>;
+/** The value on an `image` port. Mirrors Cascade's core ImageRef. */
+export interface ImageRef {
+    path: string;
+    size: [number, number];
+    channels: 'r' | 'a' | 'rg' | 'rgb' | 'rgba';
+    depth: 'u8' | 'u16' | 'f16' | 'f32';
+    space: 'srgb' | 'linear';
+}

package/dist/io.js

@@ -0,0 +1,303 @@
+// server/src/runtime/io.ts
+function mediaUrl(path, options = {}) {
+  if (/^(https?:|data:|blob:)/.test(path)) return path;
+  const clean = path.replace(/^\.?\//, "");
+  const encoded = clean.split("/").map(encodeURIComponent).join("/");
+  const params = new URLSearchParams();
+  if (options.raw) params.set("raw", "1");
+  else {
+    if (options.width) params.set("w", String(options.width));
+    if (options.format) params.set("fmt", options.format);
+    if (options.quality) params.set("q", String(options.quality));
+  }
+  const query = params.toString();
+  return `/api/media/${encoded}${query ? `?${query}` : ""}`;
+}
+var IO_BRIDGE_KEY = "__cascadeIoBridge";
+function installIoBridge(bridge) {
+  const globals = globalThis;
+  const previous = globals[IO_BRIDGE_KEY];
+  globals[IO_BRIDGE_KEY] = bridge ?? void 0;
+  return () => {
+    globals[IO_BRIDGE_KEY] = previous;
+  };
+}
+function localIo() {
+  const bridge = globalThis[IO_BRIDGE_KEY];
+  return bridge && typeof bridge.read === "function" && typeof bridge.write === "function" ? bridge : null;
+}
+async function loadBytes(path, options = { raw: true }) {
+  const bridge = localIo();
+  if (bridge) {
+    const bytes = await bridge.read(path, options);
+    const exact = bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes.buffer : bytes.slice().buffer;
+    return exact;
+  }
+  const response = await fetch(mediaUrl(path, options));
+  if (!response.ok) throw new Error(`cascade/io: cannot load ${path} (${response.status})`);
+  return await response.arrayBuffer();
+}
+async function loadImage(path, options = { raw: true }) {
+  const image = new Image();
+  const bridge = localIo();
+  if (bridge) {
+    image.src = new Uint8Array(await loadBytes(path, options));
+  } else {
+    image.crossOrigin = "anonymous";
+    image.src = mediaUrl(path, options);
+  }
+  await image.decode();
+  return image;
+}
+async function loadBitmap(path, options = { raw: true }) {
+  if (localIo()) return createImageBitmap(new Blob([await loadBytes(path, options)]));
+  const response = await fetch(mediaUrl(path, options));
+  if (!response.ok) throw new Error(`cascade/io: cannot load ${path} (${response.status})`);
+  return createImageBitmap(await response.blob());
+}
+async function loadFieldBitmap(path, options = {}) {
+  return loadBitmap(path, { ...options, raw: false });
+}
+async function saveImage(source, path, options = {}) {
+  const format = options.format ?? "png";
+  const type = `image/${format}`;
+  let blob;
+  if (source instanceof Blob) {
+    blob = source;
+  } else if (typeof source.convertToBlob === "function") {
+    blob = await source.convertToBlob({ type, quality: options.quality });
+  } else if (typeof source.encode === "function") {
+    blob = new Blob([await source.encode(format, options.quality)], { type });
+  } else if (typeof source.toBuffer === "function") {
+    blob = new Blob([source.toBuffer(type)], { type });
+  } else {
+    blob = await new Promise((resolve, reject) => {
+      source.toBlob(
+        (result) => result ? resolve(result) : reject(new Error("cascade/io: canvas produced no data")),
+        type,
+        options.quality
+      );
+    });
+  }
+  return saveBytes(blob, path);
+}
+async function saveBytes(data, path) {
+  const clean = path.replace(/^\.?\//, "");
+  const bridge = localIo();
+  if (bridge) {
+    const bytes = data instanceof Uint8Array ? data : new Uint8Array(data instanceof Blob ? await data.arrayBuffer() : data);
+    return await bridge.write(clean, bytes);
+  }
+  const response = await fetch(`/api/media/${clean.split("/").map(encodeURIComponent).join("/")}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/octet-stream" },
+    body: data
+  });
+  if (!response.ok) {
+    throw new Error(`cascade/io: cannot write ${path} \u2014 ${await response.text()}`);
+  }
+  const result = await response.json();
+  return result.path;
+}
+function cachePath(nodeId, suffix) {
+  const safe = nodeId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `.cascade-cache/${safe}${suffix}`;
+}
+function parseNpyHeader(buffer) {
+  const bytes = new Uint8Array(buffer);
+  const magic = String.fromCharCode(...bytes.subarray(0, 6));
+  if (magic !== "\x93NUMPY") throw new Error("cascade/io: not a .npy file");
+  const view = new DataView(buffer);
+  const major = bytes[6];
+  const headerLength = major >= 2 ? view.getUint32(8, true) : view.getUint16(8, true);
+  const headerStart = major >= 2 ? 12 : 10;
+  const header = String.fromCharCode(...bytes.subarray(headerStart, headerStart + headerLength));
+  const dtype = header.match(/'descr':\s*'([^']+)'/)?.[1];
+  if (!dtype) throw new Error("cascade/io: .npy header has no dtype");
+  const shape = (header.match(/'shape':\s*\(([^)]*)\)/)?.[1] ?? "").split(",").map((part) => part.trim()).filter(Boolean).map(Number);
+  return {
+    dtype,
+    shape,
+    dataOffset: headerStart + headerLength,
+    fortran: /'fortran_order':\s*True/.test(header)
+  };
+}
+async function loadFloats(path) {
+  const buffer = await loadBytes(path, { raw: true });
+  const header = parseNpyHeader(buffer);
+  if (header.fortran) throw new Error("cascade/io: Fortran-ordered .npy is not supported");
+  if (header.shape.length < 2) throw new Error(`cascade/io: expected an image-shaped array, got ${header.shape.length}D`);
+  const [height, width] = header.shape;
+  const channels = header.shape.length > 2 ? header.shape.slice(2).reduce((a, b) => a * b, 1) : 1;
+  const count = width * height * channels;
+  let data;
+  if (header.dtype === "<f4" || header.dtype === "=f4") {
+    data = new Float32Array(buffer, header.dataOffset, count);
+  } else {
+    const source = readAs(buffer, header.dataOffset, header.dtype, count);
+    data = source instanceof Float32Array ? source : Float32Array.from(source);
+  }
+  return { data, size: [width, height], channels };
+}
+function readAs(buffer, offset, dtype, count) {
+  switch (dtype) {
+    case "<f8":
+    case "=f8":
+      return new Float64Array(buffer, offset, count);
+    case "|u1":
+    case "<u1":
+    case "=u1":
+    case "|b1":
+      return new Uint8Array(buffer, offset, count);
+    case "|i1":
+      return new Int8Array(buffer, offset, count);
+    case "<i2":
+      return new Int16Array(buffer, offset, count);
+    case "<u2":
+      return new Uint16Array(buffer, offset, count);
+    case "<i4":
+      return new Int32Array(buffer, offset, count);
+    case "<u4":
+      return new Uint32Array(buffer, offset, count);
+    default:
+      throw new Error(`cascade/io: .npy dtype ${dtype} is not supported`);
+  }
+}
+function encodeNpy(data, shape) {
+  const dict = `{'descr': '<f4', 'fortran_order': False, 'shape': (${shape.join(", ")}${shape.length === 1 ? "," : ""}), }`;
+  const unpadded = 10 + dict.length + 1;
+  const padding = (64 - unpadded % 64) % 64;
+  const header = dict + " ".repeat(padding) + "\n";
+  const out = new Uint8Array(10 + header.length + data.byteLength);
+  const view = new DataView(out.buffer);
+  out.set([147, 78, 85, 77, 80, 89, 1, 0], 0);
+  view.setUint16(8, header.length, true);
+  for (let i = 0; i < header.length; i++) out[10 + i] = header.charCodeAt(i);
+  out.set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength), 10 + header.length);
+  return out;
+}
+async function saveFloats(image, path) {
+  const [width, height] = image.size;
+  const shape = image.channels > 1 ? [height, width, image.channels] : [height, width];
+  return saveBytes(encodeNpy(image.data, shape), path);
+}
+function toImageData(image, range = [0, 1]) {
+  const [width, height] = image.size;
+  const [low, high] = range;
+  const span = high - low || 1;
+  const out = new Uint8ClampedArray(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    const base = i * image.channels;
+    const r = (image.data[base] - low) / span * 255;
+    const g = image.channels > 1 ? (image.data[base + 1] - low) / span * 255 : r;
+    const b = image.channels > 2 ? (image.data[base + 2] - low) / span * 255 : r;
+    const a = image.channels > 3 ? image.data[base + 3] * 255 : 255;
+    out[i * 4] = r;
+    out[i * 4 + 1] = g;
+    out[i * 4 + 2] = b;
+    out[i * 4 + 3] = a;
+  }
+  return new ImageData(out, width, height);
+}
+function uploadFloatTexture(gl, image) {
+  const [width, height] = image.size;
+  const formats = {
+    1: [gl.R32F, gl.RED],
+    2: [gl.RG32F, gl.RG],
+    3: [gl.RGB32F, gl.RGB],
+    4: [gl.RGBA32F, gl.RGBA]
+  };
+  const pair = formats[image.channels];
+  if (!pair) throw new Error(`cascade/io: ${image.channels} channels has no texture format`);
+  const [internalFormat, format] = pair;
+  const texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+  gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, width, height, 0, format, gl.FLOAT, image.data);
+  return texture;
+}
+async function textureFromImage(gl, image, options = { raw: true }) {
+  const path = typeof image === "string" ? image : image.path;
+  if (path.endsWith(".npy")) {
+    const floats = await loadFloats(path);
+    return {
+      gl,
+      texture: uploadFloatTexture(gl, floats),
+      size: floats.size,
+      channels: floats.channels,
+      float: true
+    };
+  }
+  const bitmap = await loadBitmap(path, options);
+  const texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
+  const size = [bitmap.width, bitmap.height];
+  bitmap.close();
+  return { gl, texture, size, channels: 4, float: false };
+}
+function createTexture(gl, size, options = {}) {
+  const [width, height] = size;
+  const float = options.float ?? false;
+  const channels = options.channels ?? 4;
+  const texture = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+  gl.texStorage2D(gl.TEXTURE_2D, 1, float ? gl.RGBA32F : gl.RGBA8, width, height);
+  return { gl, texture, size, channels, float };
+}
+async function textureToImage(ref, path, options = {}) {
+  const { gl, size } = ref;
+  const [width, height] = size;
+  const framebuffer = gl.createFramebuffer();
+  gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
+  gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, ref.texture, 0);
+  try {
+    if (ref.float) {
+      const pixels2 = new Float32Array(width * height * 4);
+      gl.readPixels(0, 0, width, height, gl.RGBA, gl.FLOAT, pixels2);
+      const stored2 = await saveFloats({ data: pixels2, size, channels: 4 }, path.replace(/\.[^.]+$/, "") + ".npy");
+      return { path: stored2, size, channels: "rgba", depth: "f32", space: options.space ?? "linear" };
+    }
+    const pixels = new Uint8ClampedArray(width * height * 4);
+    gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+    const canvas = new OffscreenCanvas(width, height);
+    canvas.getContext("2d").putImageData(new ImageData(pixels, width, height), 0, 0);
+    const format = options.format ?? "png";
+    const stored = await saveImage(canvas, path, { format });
+    return { path: stored, size, channels: "rgba", depth: "u8", space: options.space ?? "srgb" };
+  } finally {
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.deleteFramebuffer(framebuffer);
+  }
+}
+export {
+  cachePath,
+  createTexture,
+  installIoBridge,
+  loadBitmap,
+  loadBytes,
+  loadFieldBitmap,
+  loadFloats,
+  loadImage,
+  mediaUrl,
+  saveBytes,
+  saveFloats,
+  saveImage,
+  textureFromImage,
+  textureToImage,
+  toImageData,
+  uploadFloatTexture
+};
+//# sourceMappingURL=io.js.map

package/dist/net.d.ts

@@ -0,0 +1 @@
+export declare function authorizedFetch(credential: string, url: string, init?: RequestInit): Promise<Response>;

package/dist/net.js

@@ -0,0 +1,28 @@
+// server/src/runtime/net.ts
+var capability = null;
+async function authorizedFetch(credential, url, init = {}) {
+  capability ??= fetch("/api/net/capability").then(async (response2) => {
+    if (!response2.ok) throw new Error(`Authorized fetch capability failed: HTTP ${response2.status}`);
+    return (await response2.json()).capability;
+  });
+  const headers = Object.fromEntries(new Headers(init.headers).entries());
+  const response = await fetch("/api/net", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "X-Cascade-Net-Capability": await capability },
+    body: JSON.stringify({
+      credential,
+      url,
+      method: init.method ?? "GET",
+      headers,
+      ...typeof init.body === "string" ? { body: init.body } : {}
+    }),
+    signal: init.signal
+  });
+  const result = await response.json();
+  if (!response.ok || !result.ok) throw new Error(result.error ?? `Authorized fetch failed: HTTP ${response.status}`);
+  return new Response(result.body, { status: result.status, statusText: result.statusText, headers: result.headers });
+}
+export {
+  authorizedFetch
+};
+//# sourceMappingURL=net.js.map