@workglow/util 0.2.19 → 0.2.21

package/dist/media-browser.js

@@ -1,39 +1,13 @@
 // src/media/imageCacheCodec.ts
 import { registerPortCodec } from "@workglow/util";
 
-// src/media/gpuImage.ts
-var GLOBAL_FACTORY_KEY = Symbol.for("@workglow/util/media/gpuImageFactory");
-var _g = globalThis;
-if (!_g[GLOBAL_FACTORY_KEY]) {
-  _g[GLOBAL_FACTORY_KEY] = {};
-}
-var factory = _g[GLOBAL_FACTORY_KEY];
-function registerGpuImageFactory(key, fn) {
-  factory[key] = fn;
-}
-function getGpuImageFactory(key) {
-  const fn = factory[key];
-  return typeof fn === "function" ? fn : undefined;
-}
-var GpuImage = new Proxy({}, {
-  get(_t, prop) {
-    if (typeof prop !== "string" || prop === "then")
-      return;
-    const fn = factory[prop];
-    if (typeof fn !== "function") {
-      throw new Error(`GpuImage.${prop} is not registered. Import the platform entry point.`);
-    }
-    return fn;
-  }
-});
-
 // src/media/imageRasterCodecRegistry.ts
 var GLOBAL_CODEC_KEY = Symbol.for("@workglow/util/media/imageRasterCodec");
-var _g2 = globalThis;
-if (!_g2[GLOBAL_CODEC_KEY]) {
-  _g2[GLOBAL_CODEC_KEY] = { value: null };
+var _g = globalThis;
+if (!_g[GLOBAL_CODEC_KEY]) {
+  _g[GLOBAL_CODEC_KEY] = { value: null };
 }
-var slot = _g2[GLOBAL_CODEC_KEY];
+var slot = _g[GLOBAL_CODEC_KEY];
 function registerImageRasterCodec(next) {
   slot.value = next;
 }
@@ -44,130 +18,170 @@ function getImageRasterCodec() {
   return slot.value;
 }
 
-// src/media/cpuImage.ts
-var FORMAT_TO_MIME = {
-  png: "image/png",
-  jpeg: "image/jpeg",
-  webp: "image/webp"
-};
-function dataUriToBytes(dataUri) {
-  const comma = dataUri.indexOf(",");
-  const b64 = dataUri.slice(comma + 1);
-  const bin = atob(b64);
-  const bytes = new Uint8Array(bin.length);
-  for (let i = 0;i < bin.length; i++)
-    bytes[i] = bin.charCodeAt(i);
-  return bytes;
+// src/media/imageValue.ts
+function imageValueFromBitmap(bitmap, width, height, previewScale = 1) {
+  return { bitmap, width, height, previewScale };
 }
-function expandToRgba(bin) {
-  if (bin.channels === 4)
-    return bin.data;
-  const px = bin.width * bin.height;
-  const out = new Uint8ClampedArray(px * 4);
-  if (bin.channels === 3) {
-    for (let i = 0;i < px; i++) {
-      out[i * 4 + 0] = bin.data[i * 3 + 0] ?? 0;
-      out[i * 4 + 1] = bin.data[i * 3 + 1] ?? 0;
-      out[i * 4 + 2] = bin.data[i * 3 + 2] ?? 0;
-      out[i * 4 + 3] = 255;
-    }
-  } else if (bin.channels === 1) {
-    for (let i = 0;i < px; i++) {
-      const g = bin.data[i] ?? 0;
-      out[i * 4 + 0] = g;
-      out[i * 4 + 1] = g;
-      out[i * 4 + 2] = g;
-      out[i * 4 + 3] = 255;
-    }
-  }
-  return out;
+function imageValueFromBuffer(buffer, format, width, height, previewScale = 1) {
+  return { buffer, format, width, height, previewScale };
 }
-
-class CpuImage {
-  bin;
-  backend = "cpu";
-  _previewScale;
-  constructor(bin, previewScale = 1) {
-    this.bin = bin;
-    this._previewScale = previewScale;
+function isImageValue(v) {
+  return isBrowserImageValue(v) || isNodeImageValue(v);
+}
+function isBrowserImageValue(v) {
+  if (v === null || typeof v !== "object")
+    return false;
+  const o = v;
+  return typeof o.width === "number" && typeof o.height === "number" && typeof o.previewScale === "number" && typeof ImageBitmap !== "undefined" && o.bitmap instanceof ImageBitmap;
+}
+function isNodeImageValue(v) {
+  if (v === null || typeof v !== "object")
+    return false;
+  const o = v;
+  return typeof o.width === "number" && typeof o.height === "number" && typeof o.previewScale === "number" && typeof Buffer !== "undefined" && Buffer.isBuffer(o.buffer) && (o.format === "png" || o.format === "jpeg" || o.format === "raw-rgba");
+}
+async function normalizeToImageValue(value) {
+  if (value === null || value === undefined)
+    return;
+  if (isImageValue(value))
+    return value;
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    if (typeof createImageBitmap === "function") {
+      const bitmap = await createImageBitmap(value);
+      return imageValueFromBitmap(bitmap, bitmap.width, bitmap.height);
+    }
+    return;
   }
-  get width() {
-    return this.bin.width;
+  if (typeof ImageBitmap !== "undefined" && value instanceof ImageBitmap) {
+    return imageValueFromBitmap(value, value.width, value.height);
   }
-  get height() {
-    return this.bin.height;
+  if (typeof value === "string" && value.startsWith("data:")) {
+    if (typeof createImageBitmap === "function" && typeof fetch === "function") {
+      const blob = await (await fetch(value)).blob();
+      const bitmap = await createImageBitmap(blob);
+      return imageValueFromBitmap(bitmap, bitmap.width, bitmap.height);
+    }
+    if (typeof Buffer !== "undefined") {
+      return decodeDataUriToNodeImageValue(value);
+    }
+    return;
   }
-  get channels() {
-    return this.bin.channels;
+  return;
+}
+async function decodeDataUriToNodeImageValue(dataUri) {
+  const match = /^data:([^;,]+);base64,(.+)$/.exec(dataUri);
+  if (!match)
+    return;
+  const mime = match[1] ?? "image/png";
+  const base64 = match[2] ?? "";
+  const buffer = Buffer.from(base64, "base64");
+  const format = /jpe?g/i.test(mime) ? "jpeg" : "png";
+  try {
+    const decoded = await getImageRasterCodec().decodeDataUri(dataUri);
+    return imageValueFromBuffer(buffer, format, decoded.width, decoded.height);
+  } catch (err) {
+    throw new Error("normalizeToImageValue: failed to probe data URI dimensions", {
+      cause: err
+    });
   }
-  get previewScale() {
-    return this._previewScale;
+}
+
+// src/media/imageCacheCodec.ts
+function isImageValueWire(v) {
+  if (v === null || typeof v !== "object")
+    return false;
+  const o = v;
+  return o.__imageValueWire === 1 && typeof o.base64 === "string" && (o.format === "png" || o.format === "jpeg" || o.format === "raw-rgba") && typeof o.width === "number" && typeof o.height === "number" && typeof o.previewScale === "number";
+}
+function bytesToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
   }
-  _setPreviewScale(scale) {
-    this._previewScale = scale;
-    return this;
+  let bin = "";
+  for (let i = 0;i < bytes.length; i++)
+    bin += String.fromCharCode(bytes[i] ?? 0);
+  return btoa(bin);
+}
+function base64ToBytes(b64) {
+  if (typeof Buffer !== "undefined") {
+    const buf = Buffer.from(b64, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
   }
-  async materialize() {
-    return this.bin;
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0;i < bin.length; i++)
+    out[i] = bin.charCodeAt(i);
+  return out;
+}
+async function browserToPngBase64(value) {
+  if (typeof OffscreenCanvas === "undefined") {
+    throw new Error("imageCacheCodec.serialize: BrowserImageValue requires OffscreenCanvas");
   }
-  getBinary() {
-    return this.bin;
+  const off = new OffscreenCanvas(value.width, value.height);
+  const ctx = off.getContext("2d");
+  if (!ctx)
+    throw new Error("imageCacheCodec.serialize: could not acquire 2D context");
+  ctx.drawImage(value.bitmap, 0, 0);
+  const blob = await off.convertToBlob({ type: "image/png" });
+  const bytes = new Uint8Array(await blob.arrayBuffer());
+  return bytesToBase64(bytes);
+}
+async function wireToBrowserImageValue(wire) {
+  if (typeof createImageBitmap !== "function") {
+    throw new Error("imageCacheCodec.deserialize: browser path requires createImageBitmap");
   }
-  async toCanvas(canvas) {
+  const bytes = base64ToBytes(wire.base64);
+  if (wire.format === "raw-rgba") {
     if (typeof ImageData === "undefined") {
-      throw new Error("CpuImage.toCanvas requires a browser environment with ImageData");
+      throw new Error("imageCacheCodec.deserialize: raw-rgba decode requires ImageData");
     }
-    const rgba = expandToRgba(this.bin);
-    const id = new ImageData(new Uint8ClampedArray(rgba.buffer, rgba.byteOffset, rgba.byteLength), this.bin.width, this.bin.height);
-    if (canvas.width !== this.bin.width)
-      canvas.width = this.bin.width;
-    if (canvas.height !== this.bin.height)
-      canvas.height = this.bin.height;
-    const ctx = canvas.getContext("2d");
-    if (!ctx)
-      throw new Error("CpuImage.toCanvas could not acquire a 2D context");
-    ctx.putImageData(id, 0, 0);
-  }
-  async encode(format, _quality) {
-    const codec = getImageRasterCodec();
-    const dataUri = await codec.encodeDataUri(this.bin, FORMAT_TO_MIME[format]);
-    return dataUriToBytes(dataUri);
-  }
-  retain(_n = 1) {
-    return this;
-  }
-  release() {}
-  static fromImageBinary(bin, previewScale = 1) {
-    return new CpuImage(bin, previewScale);
+    const data = new Uint8ClampedArray(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const imageData = new ImageData(data, wire.width, wire.height);
+    const bitmap2 = await createImageBitmap(imageData);
+    return { bitmap: bitmap2, width: wire.width, height: wire.height, previewScale: wire.previewScale };
   }
+  const mime = wire.format === "jpeg" ? "image/jpeg" : "image/png";
+  const blob = new Blob([bytes.buffer], { type: mime });
+  const bitmap = await createImageBitmap(blob);
+  return { bitmap, width: wire.width, height: wire.height, previewScale: wire.previewScale };
 }
-registerGpuImageFactory("fromImageBinary", CpuImage.fromImageBinary);
-
-// src/media/imageCacheCodec.ts
 registerPortCodec("image", {
   async serialize(value) {
-    if (typeof value.materialize !== "function") {
+    if (typeof value === "string")
       return value;
+    if (isNodeImageValue(value)) {
+      return {
+        __imageValueWire: 1,
+        format: value.format,
+        base64: value.buffer.toString("base64"),
+        width: value.width,
+        height: value.height,
+        previewScale: value.previewScale
+      };
     }
-    const bin = await value.materialize();
-    return {
-      kind: "image-binary",
-      width: bin.width,
-      height: bin.height,
-      channels: bin.channels,
-      data: bin.data
-    };
+    if (isBrowserImageValue(value)) {
+      const base64 = await browserToPngBase64(value);
+      return {
+        __imageValueWire: 1,
+        format: "png",
+        base64,
+        width: value.width,
+        height: value.height,
+        previewScale: value.previewScale
+      };
+    }
+    throw new Error("imageCacheCodec.serialize: value is not an ImageValue or string");
   },
-  async deserialize(cached) {
-    if (cached.kind !== "image-binary") {
-      return cached;
+  async deserialize(wire) {
+    if (typeof wire === "string")
+      return wire;
+    if (!isImageValueWire(wire)) {
+      throw new Error("imageCacheCodec.deserialize: input is not an ImageValueWire or string");
     }
-    return CpuImage.fromImageBinary({
-      data: cached.data,
-      width: cached.width,
-      height: cached.height,
-      channels: cached.channels
-    });
+    if (typeof Buffer !== "undefined") {
+      return imageValueFromBuffer(Buffer.from(wire.base64, "base64"), wire.format, wire.width, wire.height, wire.previewScale);
+    }
+    return wireToBrowserImageValue(wire);
   }
 });
 
@@ -177,17 +191,17 @@ class Container {
   factories = new Map;
   singletons = new Set;
   resolving = [];
-  register(token, factory2, singleton = true) {
-    this.factories.set(token, factory2);
+  register(token, factory, singleton = true) {
+    this.factories.set(token, factory);
     if (singleton) {
       this.singletons.add(token);
     }
   }
-  registerIfAbsent(token, factory2, singleton = true) {
+  registerIfAbsent(token, factory, singleton = true) {
     if (this.factories.has(token) || this.services.has(token)) {
       return;
     }
-    this.register(token, factory2, singleton);
+    this.register(token, factory, singleton);
   }
   registerInstance(token, instance) {
     this.services.set(token, instance);
@@ -197,8 +211,8 @@ class Container {
     if (this.services.has(token)) {
       return this.services.get(token);
     }
-    const factory2 = this.factories.get(token);
-    if (!factory2) {
+    const factory = this.factories.get(token);
+    if (!factory) {
       throw new Error(`Service not registered: ${String(token)}`);
     }
     if (this.resolving.includes(token)) {
@@ -207,7 +221,7 @@ class Container {
     }
     this.resolving.push(token);
     try {
-      const instance = factory2();
+      const instance = factory();
       if (this.singletons.has(token)) {
         this.services.set(token, instance);
       }
@@ -256,8 +270,8 @@ class Container {
   }
   createChildContainer() {
     const child = new Container;
-    this.factories.forEach((factory2, token) => {
-      child.factories.set(token, factory2);
+    this.factories.forEach((factory, token) => {
+      child.factories.set(token, factory);
       if (this.singletons.has(token)) {
         child.singletons.add(token);
       }
@@ -272,11 +286,11 @@ class Container {
   }
 }
 var GLOBAL_CONTAINER_KEY = Symbol.for("@workglow/util/di/globalContainer");
-var _g3 = globalThis;
-if (!_g3[GLOBAL_CONTAINER_KEY]) {
-  _g3[GLOBAL_CONTAINER_KEY] = new Container;
+var _g2 = globalThis;
+if (!_g2[GLOBAL_CONTAINER_KEY]) {
+  _g2[GLOBAL_CONTAINER_KEY] = new Container;
 }
-var globalContainer = _g3[GLOBAL_CONTAINER_KEY];
+var globalContainer = _g2[GLOBAL_CONTAINER_KEY];
 
 // src/di/ServiceRegistry.ts
 function createServiceToken(id) {
@@ -288,11 +302,11 @@ class ServiceRegistry {
   constructor(container = globalContainer) {
     this.container = container;
   }
-  register(token, factory2, singleton = true) {
-    this.container.register(token.id, factory2, singleton);
+  register(token, factory, singleton = true) {
+    this.container.register(token.id, factory, singleton);
   }
-  registerIfAbsent(token, factory2, singleton = true) {
-    this.container.registerIfAbsent(token.id, factory2, singleton);
+  registerIfAbsent(token, factory, singleton = true) {
+    this.container.registerIfAbsent(token.id, factory, singleton);
   }
   registerInstance(token, instance) {
     this.container.registerInstance(token.id, instance);
@@ -321,16 +335,17 @@ function registerInputResolver(formatPrefix, resolver) {
 }
 
 // src/media/imageHydrationResolver.ts
-async function resolveImageString(id, _format, _registry) {
-  if (typeof id !== "string")
-    return id;
-  if (id.startsWith("data:")) {
-    return GpuImage.fromDataUri(id);
+async function resolveImage(id, _format, _registry) {
+  const normalized = await normalizeToImageValue(id);
+  if (normalized !== undefined)
+    return normalized;
+  if (typeof id === "string") {
+    const preview = id.length > 32 ? `${id.slice(0, 32)}...` : id;
+    throw new Error(`format:"image" resolver received an unsupported string "${preview}". ` + `Only data: URIs are handled. Register a sub-resolver for other schemes.`);
   }
-  const preview = id.length > 32 ? `${id.slice(0, 32)}...` : id;
-  throw new Error(`format:"image" resolver received an unsupported string "${preview}". ` + `Only data: URIs are handled. For other schemes register a sub-resolver, ` + `e.g. registerInputResolver("image:http", fn).`);
+  return id;
 }
-registerInputResolver("image", resolveImageString);
+registerInputResolver("image", resolveImage);
 
 // src/media/color.ts
 var HEX_PATTERN = /^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
@@ -440,8 +455,153 @@ function resolveColor(value) {
     a: value.a ?? 255
   };
 }
+// src/media/cpuImage.ts
+var FORMAT_TO_MIME = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp"
+};
+
+class CpuImage {
+  bin;
+  backend = "cpu";
+  constructor(bin) {
+    this.bin = bin;
+  }
+  get width() {
+    if (!this.bin)
+      throw new Error("CpuImage.width on a disposed image");
+    return this.bin.width;
+  }
+  get height() {
+    if (!this.bin)
+      throw new Error("CpuImage.height on a disposed image");
+    return this.bin.height;
+  }
+  get channels() {
+    if (!this.bin)
+      throw new Error("CpuImage.channels on a disposed image");
+    return this.bin.channels;
+  }
+  getBinary() {
+    if (!this.bin)
+      throw new Error("CpuImage.getBinary on a disposed image");
+    return this.bin;
+  }
+  static async from(value) {
+    if (isBrowserImageValue(value)) {
+      if (typeof OffscreenCanvas === "undefined") {
+        throw new Error("CpuImage.from(BrowserImageValue) requires OffscreenCanvas");
+      }
+      const off = new OffscreenCanvas(value.width, value.height);
+      const ctx = off.getContext("2d");
+      if (!ctx)
+        throw new Error("CpuImage.from: could not acquire 2D context");
+      ctx.drawImage(value.bitmap, 0, 0);
+      const id = ctx.getImageData(0, 0, value.width, value.height);
+      return new CpuImage({ data: id.data, width: value.width, height: value.height, channels: 4 });
+    }
+    if (isNodeImageValue(value)) {
+      const bin = await decodeNodeImageValue(value);
+      return new CpuImage(bin);
+    }
+    throw new Error("CpuImage.from: unrecognized ImageValue shape");
+  }
+  static fromRaw(bin) {
+    return new CpuImage(bin);
+  }
+  async toImageValue(previewScale) {
+    if (!this.bin)
+      throw new Error("CpuImage.toImageValue on a disposed image");
+    if (typeof OffscreenCanvas !== "undefined" && typeof createImageBitmap === "function") {
+      const off = new OffscreenCanvas(this.bin.width, this.bin.height);
+      const ctx = off.getContext("2d");
+      if (!ctx)
+        throw new Error("CpuImage.toImageValue could not acquire a 2D context");
+      const rgba2 = expandToRgba(this.bin);
+      ctx.putImageData(new ImageData(new Uint8ClampedArray(rgba2.buffer, rgba2.byteOffset, rgba2.byteLength), this.bin.width, this.bin.height), 0, 0);
+      const bitmap = await createImageBitmap(off);
+      const out2 = {
+        bitmap,
+        width: this.bin.width,
+        height: this.bin.height,
+        previewScale
+      };
+      this.bin = null;
+      return out2;
+    }
+    const rgba = expandToRgba(this.bin);
+    const buffer = Buffer.from(rgba.buffer, rgba.byteOffset, rgba.byteLength);
+    const out = {
+      buffer,
+      format: "raw-rgba",
+      width: this.bin.width,
+      height: this.bin.height,
+      previewScale
+    };
+    this.bin = null;
+    return out;
+  }
+  async encode(format, _quality) {
+    if (!this.bin)
+      throw new Error("CpuImage.encode on a disposed image");
+    const codec = getImageRasterCodec();
+    const dataUri = await codec.encodeDataUri(this.bin, FORMAT_TO_MIME[format]);
+    return dataUriToBytes(dataUri);
+  }
+  dispose() {
+    this.bin = null;
+  }
+}
+function expandToRgba(bin) {
+  if (bin.channels === 4)
+    return bin.data;
+  const px = bin.width * bin.height;
+  const out = new Uint8ClampedArray(px * 4);
+  if (bin.channels === 3) {
+    for (let i = 0;i < px; i++) {
+      out[i * 4 + 0] = bin.data[i * 3 + 0] ?? 0;
+      out[i * 4 + 1] = bin.data[i * 3 + 1] ?? 0;
+      out[i * 4 + 2] = bin.data[i * 3 + 2] ?? 0;
+      out[i * 4 + 3] = 255;
+    }
+  } else if (bin.channels === 1) {
+    for (let i = 0;i < px; i++) {
+      const g = bin.data[i] ?? 0;
+      out[i * 4 + 0] = g;
+      out[i * 4 + 1] = g;
+      out[i * 4 + 2] = g;
+      out[i * 4 + 3] = 255;
+    }
+  }
+  return out;
+}
+function dataUriToBytes(dataUri) {
+  const comma = dataUri.indexOf(",");
+  const b64 = dataUri.slice(comma + 1);
+  const bin = atob(b64);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0;i < bin.length; i++)
+    bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+async function decodeNodeImageValue(value) {
+  if (value.format === "raw-rgba") {
+    const data = new Uint8ClampedArray(value.buffer.buffer, value.buffer.byteOffset, value.buffer.byteLength);
+    return { data, width: value.width, height: value.height, channels: 4 };
+  }
+  const codec = getImageRasterCodec();
+  const dataUri = `data:image/${value.format};base64,${value.buffer.toString("base64")}`;
+  const decoded = await codec.decodeDataUri(dataUri);
+  return {
+    data: decoded.data,
+    width: decoded.width,
+    height: decoded.height,
+    channels: decoded.channels
+  };
+}
 // src/media/encode.ts
-async function encodeImageBinaryBytes(bin, mimeType) {
+async function rawPixelBufferToBytes(bin, mimeType) {
   const dataUri = await getImageRasterCodec().encodeDataUri(bin, mimeType);
   const b64 = dataUri.slice(dataUri.indexOf(",") + 1);
   const decoded = atob(b64);
@@ -450,28 +610,21 @@ async function encodeImageBinaryBytes(bin, mimeType) {
     bytes[i] = decoded.charCodeAt(i);
   return bytes;
 }
-async function encodeImageBinaryToPng(bin) {
-  return encodeImageBinaryBytes(bin, "image/png");
-}
-async function imageBinaryToBase64Png(bin) {
-  const dataUri = await getImageRasterCodec().encodeDataUri(bin, "image/png");
-  return dataUri.slice(dataUri.indexOf(",") + 1);
-}
-async function imageBinaryToDataUri(bin, mimeType = "image/png") {
+async function rawPixelBufferToDataUri(bin, mimeType = "image/png") {
   return getImageRasterCodec().encodeDataUri(bin, mimeType);
 }
-async function imageBinaryToBlob(bin, mimeType = "image/png") {
-  const bytes = await encodeImageBinaryBytes(bin, mimeType);
+async function rawPixelBufferToBlob(bin, mimeType = "image/png") {
+  const bytes = await rawPixelBufferToBytes(bin, mimeType);
   return new Blob([bytes.buffer], { type: mimeType });
 }
 // src/media/filterRegistry.ts
 var GLOBAL_REGISTRY_KEY = Symbol.for("@workglow/util/media/filterRegistry");
-var _g4 = globalThis;
+var _g3 = globalThis;
 function getRegistry() {
-  let reg = _g4[GLOBAL_REGISTRY_KEY];
+  let reg = _g3[GLOBAL_REGISTRY_KEY];
   if (!reg) {
     reg = new Map;
-    _g4[GLOBAL_REGISTRY_KEY] = reg;
+    _g3[GLOBAL_REGISTRY_KEY] = reg;
   }
   return reg;
 }
@@ -514,28 +667,42 @@ async function getGpuDevice() {
 function resetGpuDeviceForTests() {
   cached = null;
 }
-// src/media/gpuImageSchema.ts
-function GpuImageSchema(annotations = {}) {
+// src/media/gpuImage.ts
+var GLOBAL_FACTORY_KEY = Symbol.for("@workglow/util/media/gpuImageFactory");
+var _g4 = globalThis;
+if (!_g4[GLOBAL_FACTORY_KEY]) {
+  _g4[GLOBAL_FACTORY_KEY] = {};
+}
+var factory = _g4[GLOBAL_FACTORY_KEY];
+function registerGpuImageFactory(key2, fn) {
+  factory[key2] = fn;
+}
+function getGpuImageFactory(key2) {
+  const fn = factory[key2];
+  return typeof fn === "function" ? fn : undefined;
+}
+var GpuImage = new Proxy({}, {
+  get(_t, prop) {
+    if (typeof prop !== "string" || prop === "then")
+      return;
+    const fn = factory[prop];
+    if (typeof fn !== "function") {
+      throw new Error(`GpuImage.${prop} is not registered. Import the platform entry point.`);
+    }
+    return fn;
+  }
+});
+// src/media/imageValueSchema.ts
+function ImageValueSchema(annotations = {}) {
   return {
     type: ["string", "object"],
     properties: {},
     title: "Image",
-    description: "Image (hydrated to GpuImage by the runner)",
+    description: "Image (hydrated to ImageValue at task entry)",
     ...annotations,
     format: "image"
   };
 }
-// src/media/imageTypes.ts
-function parseDataUri(dataUri) {
-  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
-  if (!match) {
-    throw new Error("Invalid base64 data URI");
-  }
-  return {
-    mimeType: match[1],
-    base64: match[2]
-  };
-}
 // src/media/MediaRawImage.ts
 class MediaRawImage {
   data;
@@ -578,9 +745,7 @@ function setPreviewBudget(px) {
   }
   _g5[GLOBAL_BUDGET_KEY] = Math.floor(px);
 }
-function previewSource(image) {
-  if (image.backend !== "webgpu")
-    return image;
+async function previewSource(image) {
   const budget = getPreviewBudget();
   const long = Math.max(image.width, image.height);
   if (long <= budget)
@@ -589,9 +754,14 @@ function previewSource(image) {
   const resize = getPreviewResizeFn();
   if (!resize)
     return image;
-  const result = resize(image, Math.round(image.width * ratio), Math.round(image.height * ratio));
-  const composed = image.previewScale * ratio;
-  return result._setPreviewScale(composed);
+  const targetW = Math.max(1, Math.round(image.width * ratio));
+  const targetH = Math.max(1, Math.round(image.height * ratio));
+  const result = await resize(image, targetW, targetH);
+  const composedScale = image.previewScale * ratio;
+  return {
+    ...result,
+    previewScale: composedScale
+  };
 }
 // src/media/shaderRegistry.browser.ts
 var VERTEX_PRELUDE = `
@@ -708,37 +878,6 @@ function resetTexturePoolForTests() {
 }
 // src/media/webGpuImage.browser.ts
 var TEX_FORMAT = "rgba8unorm";
-var finalizers = typeof FinalizationRegistry !== "undefined" ? new FinalizationRegistry((fn) => {
-  try {
-    fn();
-  } catch {}
-}) : undefined;
-function expandToRgba2(bin) {
-  if (bin.channels === 4)
-    return bin.data;
-  const px = bin.width * bin.height;
-  const out = new Uint8ClampedArray(px * 4);
-  if (bin.channels === 3) {
-    for (let i = 0;i < px; i++) {
-      out[i * 4 + 0] = bin.data[i * 3 + 0] ?? 0;
-      out[i * 4 + 1] = bin.data[i * 3 + 1] ?? 0;
-      out[i * 4 + 2] = bin.data[i * 3 + 2] ?? 0;
-      out[i * 4 + 3] = 255;
-    }
-  } else if (bin.channels === 1) {
-    for (let i = 0;i < px; i++) {
-      const g = bin.data[i] ?? 0;
-      out[i * 4 + 0] = g;
-      out[i * 4 + 1] = g;
-      out[i * 4 + 2] = g;
-      out[i * 4 + 3] = 255;
-    }
-  }
-  return out;
-}
-function align(n, m) {
-  return Math.ceil(n / m) * m;
-}
 
 class WebGpuImage {
   device;
@@ -747,43 +886,29 @@ class WebGpuImage {
   height;
   backend = "webgpu";
   channels = 4;
-  refcount = 1;
-  _previewScale;
-  constructor(device, texture, width, height, previewScale = 1) {
+  constructor(device, texture, width, height) {
     this.device = device;
     this.texture = texture;
     this.width = width;
     this.height = height;
-    this._previewScale = previewScale;
-    if (finalizers && texture) {
-      const dev = device;
-      const tex = texture;
-      finalizers.register(this, () => {
-        try {
-          getTexturePool(dev).release(tex);
-        } catch {}
-      }, this);
-    }
-  }
-  get previewScale() {
-    return this._previewScale;
   }
-  _setPreviewScale(scale) {
-    this._previewScale = scale;
-    return this;
-  }
-  static async fromImageBinary(bin) {
+  static async from(value) {
     const dev = await getGpuDevice();
     if (!dev)
-      throw new Error("WebGPU device unavailable; use CpuImage.fromImageBinary instead");
-    const tex = getTexturePool(dev).acquire(bin.width, bin.height, TEX_FORMAT);
-    const rgba = bin.channels === 4 ? bin.data : expandToRgba2(bin);
-    dev.queue.writeTexture({ texture: tex }, rgba, { bytesPerRow: bin.width * 4, rowsPerImage: bin.height }, [bin.width, bin.height, 1]);
-    return new WebGpuImage(dev, tex, bin.width, bin.height);
+      throw new Error("WebGpuImage.from: WebGPU device unavailable");
+    if (isNodeImageValue(value)) {
+      throw new Error("WebGpuImage.from: NodeImageValue not supported in browser runtime");
+    }
+    if (!isBrowserImageValue(value)) {
+      throw new Error("WebGpuImage.from: unrecognized ImageValue shape");
+    }
+    const tex = getTexturePool(dev).acquire(value.width, value.height, TEX_FORMAT);
+    dev.queue.copyExternalImageToTexture({ source: value.bitmap }, { texture: tex }, [value.width, value.height, 1]);
+    return new WebGpuImage(dev, tex, value.width, value.height);
   }
   apply(params) {
     if (!this.texture)
-      throw new Error("WebGpuImage.apply called on a released image");
+      throw new Error("WebGpuImage.apply called on a disposed image");
     const outW = params.outSize?.width ?? this.width;
     const outH = params.outSize?.height ?? this.height;
     const out = getTexturePool(this.device).acquire(outW, outH, TEX_FORMAT);
@@ -825,44 +950,18 @@ class WebGpuImage {
     pass.draw(3);
     pass.end();
     this.device.queue.submit([enc.finish()]);
-    return new WebGpuImage(this.device, out, outW, outH, this._previewScale);
+    return new WebGpuImage(this.device, out, outW, outH);
   }
-  async materialize() {
+  async transferToImageBitmap() {
     if (!this.texture)
-      throw new Error("WebGpuImage.materialize called on a released image");
-    const bytesPerRow = align(this.width * 4, 256);
-    const buffer = this.device.createBuffer({
-      size: bytesPerRow * this.height,
-      usage: 1 | 8
-    });
-    const enc = this.device.createCommandEncoder();
-    enc.copyTextureToBuffer({ texture: this.texture }, { buffer, bytesPerRow, rowsPerImage: this.height }, [this.width, this.height, 1]);
-    this.device.queue.submit([enc.finish()]);
-    await buffer.mapAsync(1);
-    const mapped = new Uint8Array(buffer.getMappedRange());
-    const tightStride = this.width * 4;
-    const tight = new Uint8ClampedArray(this.width * this.height * 4);
-    if (bytesPerRow === tightStride) {
-      tight.set(mapped);
-    } else {
-      for (let y = 0;y < this.height; y++) {
-        tight.set(mapped.subarray(y * bytesPerRow, y * bytesPerRow + tightStride), y * tightStride);
-      }
+      throw new Error("WebGpuImage.transferToImageBitmap on a disposed image");
+    if (typeof OffscreenCanvas === "undefined") {
+      throw new Error("WebGpuImage.transferToImageBitmap requires OffscreenCanvas");
     }
-    buffer.unmap();
-    buffer.destroy();
-    return { data: tight, width: this.width, height: this.height, channels: 4 };
-  }
-  async toCanvas(canvas) {
-    if (!this.texture)
-      throw new Error("WebGpuImage.toCanvas called on a released image");
-    if (canvas.width !== this.width)
-      canvas.width = this.width;
-    if (canvas.height !== this.height)
-      canvas.height = this.height;
-    const ctx = canvas.getContext("webgpu");
+    const off = new OffscreenCanvas(this.width, this.height);
+    const ctx = off.getContext("webgpu");
     if (!ctx)
-      throw new Error("WebGpuImage.toCanvas requires a webgpu context");
+      throw new Error("WebGpuImage.transferToImageBitmap: no webgpu context");
     const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
     ctx.configure({ device: this.device, format: presentationFormat, alphaMode: "premultiplied" });
     const view = ctx.getCurrentTexture().createView();
@@ -890,72 +989,54 @@ class WebGpuImage {
     pass.draw(3);
     pass.end();
     this.device.queue.submit([enc.finish()]);
+    try {
+      return await createImageBitmap(off);
+    } finally {
+      this.dispose();
+    }
+  }
+  async toImageValue(previewScale) {
+    const bitmap = await this.transferToImageBitmap();
+    return imageValueFromBitmap(bitmap, this.width, this.height, previewScale);
   }
   async encode(format, quality) {
-    const bin = await this.materialize();
-    if (typeof OffscreenCanvas === "undefined") {
-      throw new Error("WebGpuImage.encode requires an OffscreenCanvas environment");
-    }
+    if (!this.texture)
+      throw new Error("WebGpuImage.encode on a disposed image");
     const off = new OffscreenCanvas(this.width, this.height);
     const ctx = off.getContext("2d");
     if (!ctx)
       throw new Error("WebGpuImage.encode could not acquire a 2D context");
-    ctx.putImageData(new ImageData(bin.data, this.width, this.height), 0, 0);
+    const bitmap = await this.transferToImageBitmap();
+    ctx.drawImage(bitmap, 0, 0);
     const blob = await off.convertToBlob({ type: `image/${format}`, quality });
     return new Uint8Array(await blob.arrayBuffer());
   }
-  retain(n = 1) {
-    if (this.refcount <= 0) {
-      throw new Error("WebGpuImage.retain called on a released image");
-    }
-    this.refcount += n;
-    return this;
-  }
-  release() {
-    if (this.refcount <= 0) {
-      throw new Error("WebGpuImage.release called on a released image");
-    }
-    this.refcount -= 1;
-    if (this.refcount > 0)
+  dispose() {
+    if (!this.texture)
       return;
-    if (this.texture) {
-      const tex = this.texture;
-      this.texture = null;
-      if (finalizers)
-        finalizers.unregister(this);
+    const tex = this.texture;
+    this.texture = null;
+    try {
       getTexturePool(this.device).release(tex);
-    }
+    } catch {}
   }
 }
+registerGpuImageFactory("from", WebGpuImage.from.bind(WebGpuImage));
 // src/media-browser.ts
-async function _preferGpu(bin) {
+async function probeImageDimensions() {
+  throw new Error("probeImageDimensions: not available in browser runtime");
+}
+async function decodeBufferToRaw() {
+  throw new Error("decodeBufferToRaw: not available in browser runtime");
+}
+async function encodeRawPixels() {
+  throw new Error("encodeRawPixels: not available in browser runtime");
+}
+async function _preferGpu(value) {
   const dev = await getGpuDevice();
-  return dev ? WebGpuImage.fromImageBinary(bin) : CpuImage.fromImageBinary(bin);
+  return dev ? WebGpuImage.from(value) : CpuImage.from(value);
 }
-registerGpuImageFactory("fromImageBinaryAsync", _preferGpu);
-registerGpuImageFactory("fromDataUri", async (dataUri) => {
-  const bin = await getImageRasterCodec().decodeDataUri(dataUri);
-  return _preferGpu(bin);
-});
-registerGpuImageFactory("fromBlob", async (blob) => {
-  const bitmap = await createImageBitmap(blob);
-  const off = new OffscreenCanvas(bitmap.width, bitmap.height);
-  const ctx = off.getContext("2d");
-  if (!ctx)
-    throw new Error("fromBlob: could not acquire 2D context");
-  ctx.drawImage(bitmap, 0, 0);
-  const id = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
-  return _preferGpu({ data: id.data, width: bitmap.width, height: bitmap.height, channels: 4 });
-});
-registerGpuImageFactory("fromImageBitmap", async (bitmap) => {
-  const off = new OffscreenCanvas(bitmap.width, bitmap.height);
-  const ctx = off.getContext("2d");
-  if (!ctx)
-    throw new Error("fromImageBitmap: could not acquire 2D context");
-  ctx.drawImage(bitmap, 0, 0);
-  const id = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
-  return _preferGpu({ data: id.data, width: bitmap.width, height: bitmap.height, channels: 4 });
-});
+registerGpuImageFactory("from", _preferGpu);
 export {
   toHexColor,
   setPreviewBudget,
@@ -966,15 +1047,20 @@ export {
   registerImageRasterCodec,
   registerGpuImageFactory,
   registerFilterOp,
+  rawPixelBufferToDataUri,
+  rawPixelBufferToBlob,
+  probeImageDimensions,
   previewSource,
   parseHexColor,
-  parseDataUri,
+  normalizeToImageValue,
+  isNodeImageValue,
   isMediaRawImageShape,
+  isImageValue,
   isHexColor,
   isColorObject,
-  imageBinaryToDataUri,
-  imageBinaryToBlob,
-  imageBinaryToBase64Png,
+  isBrowserImageValue,
+  imageValueFromBuffer,
+  imageValueFromBitmap,
   hasFilterOp,
   getTexturePool,
   getShaderCache,
@@ -982,7 +1068,8 @@ export {
   getImageRasterCodec,
   getGpuImageFactory,
   getGpuDevice,
-  encodeImageBinaryToPng,
+  encodeRawPixels,
+  decodeBufferToRaw,
   createTexturePool,
   createShaderCache,
   applyFilter,
@@ -991,9 +1078,9 @@ export {
   VERTEX_PRELUDE,
   PASSTHROUGH_SHADER_SRC,
   MediaRawImage,
-  GpuImageSchema,
+  ImageValueSchema,
   GpuImage as GpuImageFactory,
   CpuImage
 };
 
-//# debugId=006D8DBD8329F1E964756E2164756E21
+//# debugId=4003D4BA5EB9040764756E2164756E21