@workglow/util 0.2.20 → 0.2.22

package/dist/media-node.js

@@ -4,39 +4,13 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // 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;
 }
@@ -47,130 +21,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);
   }
 });
 
@@ -180,17 +194,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);
@@ -200,8 +214,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)) {
@@ -210,7 +224,7 @@ class Container {
     }
     this.resolving.push(token);
     try {
-      const instance = factory2();
+      const instance = factory();
       if (this.singletons.has(token)) {
         this.services.set(token, instance);
       }
@@ -259,8 +273,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);
       }
@@ -275,11 +289,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) {
@@ -291,11 +305,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);
@@ -324,16 +338,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})$/;
@@ -443,8 +458,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);
@@ -453,28 +613,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;
 }
@@ -495,28 +648,42 @@ function hasFilterOp(backend, filter) {
 function _resetFilterRegistryForTests() {
   getRegistry().clear();
 }
-// 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;
@@ -559,9 +726,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)
@@ -570,9 +735,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 = `
@@ -687,12 +857,17 @@ function resetTexturePoolForTests() {
   singleton2?.pool.drain();
   singleton2 = null;
 }
-// src/media/sharpImage.node.ts
+// src/media/sharpImage.server.ts
 var cachedSharp = null;
 async function loadSharp() {
   if (cachedSharp)
     return cachedSharp;
-  const mod = await import("sharp");
+  let mod;
+  try {
+    mod = await import("sharp");
+  } catch {
+    throw new Error("Server-side image processing requires the optional 'sharp' package. Install it with: npm install sharp  (or bun add sharp)");
+  }
   cachedSharp = mod.default ?? mod;
   return cachedSharp;
 }
@@ -703,61 +878,69 @@ class SharpImage {
   height;
   channels;
   backend = "sharp";
-  _previewScale;
-  constructor(pipeline, width, height, channels, previewScale = 1) {
+  constructor(pipeline, width, height, channels) {
     this.pipeline = pipeline;
     this.width = width;
     this.height = height;
     this.channels = channels;
-    this._previewScale = previewScale;
   }
-  get previewScale() {
-    return this._previewScale;
-  }
-  _setPreviewScale(scale) {
-    this._previewScale = scale;
-    return this;
-  }
-  static async fromImageBinary(bin, previewScale = 1) {
-    const sharp = await loadSharp();
-    const buf = Buffer.from(bin.data.buffer, bin.data.byteOffset, bin.data.byteLength);
-    const pipeline = sharp(buf, {
-      raw: { width: bin.width, height: bin.height, channels: bin.channels }
-    });
-    return new SharpImage(pipeline, bin.width, bin.height, bin.channels, previewScale);
-  }
-  static async fromBuffer(buf) {
+  static async from(value) {
+    if (isBrowserImageValue(value)) {
+      throw new Error("SharpImage.from: BrowserImageValue not supported in node runtime");
+    }
+    if (!isNodeImageValue(value)) {
+      throw new Error("SharpImage.from: unrecognized ImageValue shape");
+    }
     const sharp = await loadSharp();
-    const pipeline = sharp(buf);
-    const meta = await pipeline.clone().metadata();
-    if (typeof meta.width !== "number" || typeof meta.height !== "number") {
-      throw new Error("SharpImage.fromBuffer: input has no width/height metadata");
+    if (value.format === "raw-rgba") {
+      const pipeline2 = sharp(value.buffer, {
+        raw: { width: value.width, height: value.height, channels: 4 }
+      });
+      return new SharpImage(pipeline2, value.width, value.height, 4);
     }
-    return new SharpImage(pipeline, meta.width, meta.height, meta.channels ?? 4);
+    const pipeline = sharp(value.buffer);
+    const meta = await pipeline.clone().metadata();
+    const channels = meta.channels ?? 4;
+    return new SharpImage(pipeline, value.width, value.height, channels);
   }
   apply(op, outSize) {
+    if (!this.pipeline)
+      throw new Error("SharpImage.apply on a disposed image");
     const next = op(this.pipeline.clone());
-    return new SharpImage(next, outSize?.width ?? this.width, outSize?.height ?? this.height, outSize?.channels ?? this.channels, this._previewScale);
+    return new SharpImage(next, outSize?.width ?? this.width, outSize?.height ?? this.height, outSize?.channels ?? this.channels);
   }
-  async materialize() {
-    const result = await this.pipeline.clone().raw().toBuffer({ resolveWithObject: true });
-    if (!isObjectResult(result)) {
-      throw new Error("SharpImage.materialize: expected resolveWithObject result");
+  async toBuffer(format) {
+    if (!this.pipeline)
+      throw new Error("SharpImage.toBuffer on a disposed image");
+    const p = this.pipeline.clone();
+    if (format === "raw-rgba") {
+      const result = await p.raw().toBuffer({ resolveWithObject: true });
+      if (!isObjectResult(result))
+        throw new Error("SharpImage.toBuffer: expected resolveWithObject result");
+      return result.data;
     }
-    const { data, info } = result;
-    const out = new Uint8ClampedArray(data.length);
-    out.set(data);
-    return {
-      data: out,
-      width: info.width,
-      height: info.height,
-      channels: info.channels
-    };
+    if (format === "png")
+      return await p.png().toBuffer();
+    return await p.jpeg().toBuffer();
   }
-  async toCanvas(_canvas) {
-    throw new Error("SharpImage.toCanvas is not supported in node/bun environments");
+  async toImageValue(previewScale) {
+    try {
+      const buffer = await this.toBuffer("png");
+      const out = {
+        buffer,
+        format: "png",
+        width: this.width,
+        height: this.height,
+        previewScale
+      };
+      return out;
+    } finally {
+      this.dispose();
+    }
   }
   async encode(format, quality) {
+    if (!this.pipeline)
+      throw new Error("SharpImage.encode on a disposed image");
     const p = this.pipeline.clone();
     let result;
     if (format === "png")
@@ -769,28 +952,64 @@ class SharpImage {
     const buf = result;
     return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
   }
-  retain(_n = 1) {
-    return this;
+  dispose() {
+    this.pipeline = null;
   }
-  release() {}
 }
 function isObjectResult(r) {
   return !!r && typeof r === "object" && "data" in r && "info" in r;
 }
+async function probeImageDimensions(buffer) {
+  const sharp = await loadSharp();
+  const meta = await sharp(buffer).metadata();
+  if (typeof meta.width !== "number" || typeof meta.height !== "number") {
+    throw new Error("probeImageDimensions: sharp could not read image dimensions");
+  }
+  return { width: meta.width, height: meta.height, channels: meta.channels };
+}
+async function decodeBufferToRaw(buffer, options) {
+  const sharp = await loadSharp();
+  const sharpOpts = {};
+  if (options?.limitInputPixels !== undefined)
+    sharpOpts.limitInputPixels = options.limitInputPixels;
+  if (options?.sequentialRead !== undefined)
+    sharpOpts.sequentialRead = options.sequentialRead;
+  let pipeline = sharp(buffer, sharpOpts);
+  if (options?.ensureAlpha)
+    pipeline = pipeline.ensureAlpha();
+  const result = await pipeline.raw().toBuffer({ resolveWithObject: true });
+  if (!isObjectResult(result))
+    throw new Error("decodeBufferToRaw: expected resolveWithObject result");
+  return {
+    data: result.data,
+    width: result.info.width,
+    height: result.info.height,
+    channels: result.info.channels
+  };
+}
+async function encodeRawPixels(raw, options) {
+  const sharp = await loadSharp();
+  const inputBuffer = raw.data instanceof Uint8ClampedArray ? Buffer.from(raw.data.buffer, raw.data.byteOffset, raw.data.byteLength) : raw.data;
+  const pipeline = sharp(inputBuffer, {
+    raw: { width: raw.width, height: raw.height, channels: raw.channels }
+  });
+  let encoded;
+  if (options.format === "png") {
+    encoded = await pipeline.png({ compressionLevel: options.compressionLevel }).toBuffer();
+  } else if (options.format === "jpeg") {
+    encoded = await pipeline.jpeg({ quality: options.quality, mozjpeg: options.mozjpeg }).toBuffer();
+  } else {
+    encoded = await pipeline.webp({ quality: options.quality }).toBuffer();
+  }
+  return encoded;
+}
+registerGpuImageFactory("from", SharpImage.from.bind(SharpImage));
 // src/media-node.ts
 async function getGpuDevice() {
   return null;
 }
 function resetGpuDeviceForTests() {}
-registerGpuImageFactory("fromImageBinaryAsync", (bin) => SharpImage.fromImageBinary(bin));
-registerGpuImageFactory("fromDataUri", async (dataUri) => {
-  const bin = await getImageRasterCodec().decodeDataUri(dataUri);
-  return SharpImage.fromImageBinary(bin);
-});
-registerGpuImageFactory("fromBlob", async (blob) => {
-  const buf = Buffer.from(await blob.arrayBuffer());
-  return SharpImage.fromBuffer(buf);
-});
+registerGpuImageFactory("from", (value) => SharpImage.from(value));
 export {
   toHexColor,
   setPreviewBudget,
@@ -801,15 +1020,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,
@@ -817,7 +1041,8 @@ export {
   getImageRasterCodec,
   getGpuImageFactory,
   getGpuDevice,
-  encodeImageBinaryToPng,
+  encodeRawPixels,
+  decodeBufferToRaw,
   createTexturePool,
   createShaderCache,
   applyFilter,
@@ -826,9 +1051,9 @@ export {
   SharpImage,
   PASSTHROUGH_SHADER_SRC,
   MediaRawImage,
-  GpuImageSchema,
+  ImageValueSchema,
   GpuImage as GpuImageFactory,
   CpuImage
 };
 
-//# debugId=2970EA408E9A184364756E2164756E21
+//# debugId=49C9406160EA2AA164756E2164756E21