@workglow/util 0.2.23 → 0.2.24

package/dist/media-browser.js

@@ -1,6 +1,3 @@
-// src/media/imageCacheCodec.ts
-import { registerPortCodec } from "@workglow/util";
-
 // src/media/imageRasterCodecRegistry.ts
 var GLOBAL_CODEC_KEY = Symbol.for("@workglow/util/media/imageRasterCodec");
 var _g = globalThis;
@@ -86,7 +83,203 @@ async function decodeDataUriToNodeImageValue(dataUri) {
   }
 }
 
+// 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/gpuDevice.browser.ts
+var cached = null;
+async function getGpuDevice() {
+  if (cached)
+    return cached;
+  cached = (async () => {
+    if (typeof navigator === "undefined" || !("gpu" in navigator))
+      return null;
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter)
+      return null;
+    const device = await adapter.requestDevice();
+    device.lost.then(() => {
+      cached = null;
+    });
+    return device;
+  })();
+  return cached;
+}
+function resetGpuDeviceForTests() {
+  cached = null;
+}
+
+// src/media/gpuImage.ts
+var GLOBAL_FACTORY_KEY = Symbol.for("@workglow/util/media/gpuImageFactory");
+var _g2 = globalThis;
+if (!_g2[GLOBAL_FACTORY_KEY]) {
+  _g2[GLOBAL_FACTORY_KEY] = {};
+}
+var factory = _g2[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/imageCacheCodec.ts
+import { registerPortCodec } from "@workglow/util";
 function isImageValueWire(v) {
   if (v === null || typeof v !== "object")
     return false;
@@ -191,17 +384,17 @@ class Container {
   factories = new Map;
   singletons = new Set;
   resolving = [];
-  register(token, factory, singleton = true) {
-    this.factories.set(token, factory);
+  register(token, factory2, singleton = true) {
+    this.factories.set(token, factory2);
     if (singleton) {
       this.singletons.add(token);
     }
   }
-  registerIfAbsent(token, factory, singleton = true) {
+  registerIfAbsent(token, factory2, singleton = true) {
     if (this.factories.has(token) || this.services.has(token)) {
       return;
     }
-    this.register(token, factory, singleton);
+    this.register(token, factory2, singleton);
   }
   registerInstance(token, instance) {
     this.services.set(token, instance);
@@ -211,8 +404,8 @@ class Container {
     if (this.services.has(token)) {
       return this.services.get(token);
     }
-    const factory = this.factories.get(token);
-    if (!factory) {
+    const factory2 = this.factories.get(token);
+    if (!factory2) {
       throw new Error(`Service not registered: ${String(token)}`);
     }
     if (this.resolving.includes(token)) {
@@ -221,7 +414,7 @@ class Container {
     }
     this.resolving.push(token);
     try {
-      const instance = factory();
+      const instance = factory2();
       if (this.singletons.has(token)) {
         this.services.set(token, instance);
       }
@@ -270,8 +463,8 @@ class Container {
   }
   createChildContainer() {
     const child = new Container;
-    this.factories.forEach((factory, token) => {
-      child.factories.set(token, factory);
+    this.factories.forEach((factory2, token) => {
+      child.factories.set(token, factory2);
       if (this.singletons.has(token)) {
         child.singletons.add(token);
       }
@@ -286,11 +479,11 @@ class Container {
   }
 }
 var GLOBAL_CONTAINER_KEY = Symbol.for("@workglow/util/di/globalContainer");
-var _g2 = globalThis;
-if (!_g2[GLOBAL_CONTAINER_KEY]) {
-  _g2[GLOBAL_CONTAINER_KEY] = new Container;
+var _g3 = globalThis;
+if (!_g3[GLOBAL_CONTAINER_KEY]) {
+  _g3[GLOBAL_CONTAINER_KEY] = new Container;
 }
-var globalContainer = _g2[GLOBAL_CONTAINER_KEY];
+var globalContainer = _g3[GLOBAL_CONTAINER_KEY];
 
 // src/di/ServiceRegistry.ts
 function createServiceToken(id) {
@@ -302,11 +495,11 @@ class ServiceRegistry {
   constructor(container = globalContainer) {
     this.container = container;
   }
-  register(token, factory, singleton = true) {
-    this.container.register(token.id, factory, singleton);
+  register(token, factory2, singleton = true) {
+    this.container.register(token.id, factory2, singleton);
   }
-  registerIfAbsent(token, factory, singleton = true) {
-    this.container.registerIfAbsent(token.id, factory, singleton);
+  registerIfAbsent(token, factory2, singleton = true) {
+    this.container.registerIfAbsent(token.id, factory2, singleton);
   }
   registerInstance(token, instance) {
     this.container.registerInstance(token.id, instance);
@@ -347,474 +540,14 @@ async function resolveImage(id, _format, _registry) {
 }
 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})$/;
-var CSS_RGB_CHANNEL = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
-var CSS_RGB_ALPHA = "(?:0(?:\\.\\d+)?|1(?:\\.0+)?)";
-var CSS_RGB_PATTERN = new RegExp(`^rgba?\\(\\s*(${CSS_RGB_CHANNEL})\\s*,\\s*(${CSS_RGB_CHANNEL})\\s*,\\s*(${CSS_RGB_CHANNEL})\\s*(?:,\\s*(${CSS_RGB_ALPHA}))?\\s*\\)$`);
-function parseHexColor(hex) {
-  if (typeof hex !== "string" || !HEX_PATTERN.test(hex)) {
-    throw new Error(`Invalid hex color: ${String(hex)}`);
-  }
-  const body = hex.slice(1);
-  const double = (nibble) => parseInt(nibble + nibble, 16);
-  if (body.length === 3) {
-    return { r: double(body[0]), g: double(body[1]), b: double(body[2]), a: 255 };
-  }
-  if (body.length === 4) {
-    return {
-      r: double(body[0]),
-      g: double(body[1]),
-      b: double(body[2]),
-      a: double(body[3])
-    };
-  }
-  if (body.length === 6) {
-    return {
-      r: parseInt(body.slice(0, 2), 16),
-      g: parseInt(body.slice(2, 4), 16),
-      b: parseInt(body.slice(4, 6), 16),
-      a: 255
-    };
-  }
-  return {
-    r: parseInt(body.slice(0, 2), 16),
-    g: parseInt(body.slice(2, 4), 16),
-    b: parseInt(body.slice(4, 6), 16),
-    a: parseInt(body.slice(6, 8), 16)
-  };
-}
-var CHANNEL_MIN = 0;
-var CHANNEL_MAX = 255;
-function assertChannel(name, value) {
-  if (!Number.isInteger(value) || value < CHANNEL_MIN || value > CHANNEL_MAX) {
-    throw new Error(`Color channel ${name} out of range (0-255 integer): ${value}`);
-  }
-}
-function byteToHex(value) {
-  return value.toString(16).padStart(2, "0");
-}
-function toHexColor(c) {
-  assertChannel("r", c.r);
-  assertChannel("g", c.g);
-  assertChannel("b", c.b);
-  assertChannel("a", c.a);
-  const head = `#${byteToHex(c.r)}${byteToHex(c.g)}${byteToHex(c.b)}`;
-  return c.a === 255 ? head : `${head}${byteToHex(c.a)}`;
-}
-function isInRangeByte(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 255;
-}
-function isColorObject(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const candidate = value;
-  if (!isInRangeByte(candidate.r))
-    return false;
-  if (!isInRangeByte(candidate.g))
-    return false;
-  if (!isInRangeByte(candidate.b))
-    return false;
-  if (candidate.a !== undefined && !isInRangeByte(candidate.a))
-    return false;
-  return true;
-}
-function isHexColor(value) {
-  return typeof value === "string" && HEX_PATTERN.test(value);
-}
-function parseCssRgbColor(value) {
-  const match = CSS_RGB_PATTERN.exec(value);
-  if (!match) {
-    throw new Error(`Invalid CSS rgb color: ${String(value)}`);
-  }
-  const r = Number.parseInt(match[1] ?? "", 10);
-  const g = Number.parseInt(match[2] ?? "", 10);
-  const b = Number.parseInt(match[3] ?? "", 10);
-  const alpha = match[4] === undefined ? 1 : Number.parseFloat(match[4]);
-  assertChannel("r", r);
-  assertChannel("g", g);
-  assertChannel("b", b);
-  if (!Number.isFinite(alpha) || alpha < 0 || alpha > 1) {
-    throw new Error(`Color alpha out of range (0-1 number): ${match[4]}`);
-  }
-  return { r, g, b, a: Math.round(alpha * 255) };
-}
-function resolveColor(value) {
-  if (typeof value === "string") {
-    if (isHexColor(value))
-      return parseHexColor(value);
-    return parseCssRgbColor(value);
-  }
-  if (!isColorObject(value)) {
-    throw new Error(`Invalid color value: ${JSON.stringify(value)}`);
-  }
-  return {
-    r: value.r,
-    g: value.g,
-    b: value.b,
-    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 rawPixelBufferToBytes(bin, mimeType) {
-  const dataUri = await getImageRasterCodec().encodeDataUri(bin, mimeType);
-  const b64 = dataUri.slice(dataUri.indexOf(",") + 1);
-  const decoded = atob(b64);
-  const bytes = new Uint8Array(decoded.length);
-  for (let i = 0;i < decoded.length; i++)
-    bytes[i] = decoded.charCodeAt(i);
-  return bytes;
-}
-async function rawPixelBufferToDataUri(bin, mimeType = "image/png") {
-  return getImageRasterCodec().encodeDataUri(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 _g3 = globalThis;
-function getRegistry() {
-  let reg = _g3[GLOBAL_REGISTRY_KEY];
-  if (!reg) {
-    reg = new Map;
-    _g3[GLOBAL_REGISTRY_KEY] = reg;
-  }
-  return reg;
-}
-var key = (backend, filter) => `${backend}:${filter}`;
-function registerFilterOp(backend, filter, fn) {
-  getRegistry().set(key(backend, filter), fn);
-}
-function applyFilter(image, filter, params) {
-  const fn = getRegistry().get(key(image.backend, filter));
-  if (!fn) {
-    throw new Error(`applyFilter("${filter}") on backend "${image.backend}": no implementation registered. ` + `Task-layer fallback should have routed this to "cpu" first; this means even the cpu arm is missing. ` + `Ensure @workglow/tasks has been imported so its filter-arm side effects run.`);
-  }
-  return fn(image, params);
-}
-function hasFilterOp(backend, filter) {
-  return getRegistry().has(key(backend, filter));
-}
-function _resetFilterRegistryForTests() {
-  getRegistry().clear();
-}
-// src/media/gpuDevice.browser.ts
-var cached = null;
-async function getGpuDevice() {
-  if (cached)
-    return cached;
-  cached = (async () => {
-    if (typeof navigator === "undefined" || !("gpu" in navigator))
-      return null;
-    const adapter = await navigator.gpu.requestAdapter();
-    if (!adapter)
-      return null;
-    const device = await adapter.requestDevice();
-    device.lost.then(() => {
-      cached = null;
-    });
-    return device;
-  })();
-  return cached;
-}
-function resetGpuDeviceForTests() {
-  cached = null;
-}
-// 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 ImageValue at task entry)",
-    ...annotations,
-    format: "image"
-  };
-}
-// src/media/MediaRawImage.ts
-class MediaRawImage {
-  data;
-  width;
-  height;
-  channels;
-  constructor(data, width, height, channels) {
-    this.data = data;
-    this.width = width;
-    this.height = height;
-    this.channels = channels;
-  }
-}
-function isMediaRawImageShape(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  const v = value;
-  return v.data instanceof Uint8ClampedArray && typeof v.width === "number" && typeof v.height === "number" && typeof v.channels === "number";
-}
-// src/media/previewBudget.ts
-var GLOBAL_RESIZE_KEY = Symbol.for("@workglow/util/media/previewResizeFn");
-var GLOBAL_BUDGET_KEY = Symbol.for("@workglow/util/media/previewBudget");
-var _g5 = globalThis;
-var DEFAULT_BUDGET = 512;
-if (typeof _g5[GLOBAL_BUDGET_KEY] !== "number") {
-  _g5[GLOBAL_BUDGET_KEY] = DEFAULT_BUDGET;
-}
-function registerPreviewResizeFn(fn) {
-  _g5[GLOBAL_RESIZE_KEY] = fn;
-}
-function getPreviewResizeFn() {
-  return _g5[GLOBAL_RESIZE_KEY];
-}
-function getPreviewBudget() {
-  return _g5[GLOBAL_BUDGET_KEY];
-}
-function setPreviewBudget(px) {
-  if (!Number.isFinite(px) || px <= 0) {
-    throw new Error(`setPreviewBudget: invalid value ${px}; expected a positive finite number`);
-  }
-  _g5[GLOBAL_BUDGET_KEY] = Math.floor(px);
-}
-async function previewSource(image) {
-  const budget = getPreviewBudget();
-  const long = Math.max(image.width, image.height);
-  if (long <= budget)
-    return image;
-  const ratio = budget / long;
-  const resize = getPreviewResizeFn();
-  if (!resize)
-    return image;
-  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 = `
-@group(0) @binding(0) var src: texture_2d<f32>;
-@group(0) @binding(1) var src_sampler: sampler;
-
-struct VsOut {
-  @builtin(position) pos: vec4f,
-  @location(0) uv: vec2f,
-};
-
-@vertex
-fn vs(@builtin(vertex_index) vid: u32) -> VsOut {
-  let xy = vec2f(f32((vid << 1u) & 2u), f32(vid & 2u));
-  var out: VsOut;
-  out.pos = vec4f(xy * 2.0 - 1.0, 0.0, 1.0);
-  out.uv  = vec2f(xy.x, 1.0 - xy.y);
-  return out;
-}`;
-var PASSTHROUGH_SHADER_SRC = `${VERTEX_PRELUDE}
-@fragment
-fn fs(in: VsOut) -> @location(0) vec4f {
-  return textureSample(src, src_sampler, in.uv);
-}
-`;
-function createShaderCache(device) {
-  const map = new Map;
-  return {
-    get(source) {
-      let mod = map.get(source);
-      if (!mod) {
-        mod = device.createShaderModule({ code: source });
-        map.set(source, mod);
-      }
-      return mod;
-    }
-  };
-}
-var singleton = null;
-function getShaderCache(device) {
-  if (!singleton || singleton.device !== device) {
-    singleton = { device, cache: createShaderCache(device) };
-  }
-  return singleton.cache;
-}
-// src/media/texturePool.browser.ts
-var DEFAULT_CAPACITY_PER_SIZE = 8;
-var TEXTURE_USAGE = 4 | 16 | 1 | 2;
-function createTexturePool(device, opts = {}) {
-  const capacity = opts.capacityPerSize ?? DEFAULT_CAPACITY_PER_SIZE;
-  const buckets = new Map;
-  const owners = new WeakMap;
-  const sizeClassKey = (w, h, f) => `${w}x${h}:${f}`;
+// src/media/texturePool.browser.ts
+var DEFAULT_CAPACITY_PER_SIZE = 8;
+var TEXTURE_USAGE = 4 | 16 | 1 | 2;
+function createTexturePool(device, opts = {}) {
+  const capacity = opts.capacityPerSize ?? DEFAULT_CAPACITY_PER_SIZE;
+  const buckets = new Map;
+  const owners = new WeakMap;
+  const sizeClassKey = (w, h, f) => `${w}x${h}:${f}`;
   return {
     acquire(width, height, format) {
       const k = sizeClassKey(width, height, format);
@@ -860,22 +593,68 @@ function createTexturePool(device, opts = {}) {
           entry.texture.destroy();
         }
       }
-      buckets.clear();
+      buckets.clear();
+    }
+  };
+}
+var singleton = null;
+function getTexturePool(device) {
+  if (!singleton || singleton.device !== device) {
+    singleton?.pool.drain();
+    singleton = { device, pool: createTexturePool(device) };
+  }
+  return singleton.pool;
+}
+function resetTexturePoolForTests() {
+  singleton?.pool.drain();
+  singleton = null;
+}
+
+// src/media/shaderRegistry.browser.ts
+var VERTEX_PRELUDE = `
+@group(0) @binding(0) var src: texture_2d<f32>;
+@group(0) @binding(1) var src_sampler: sampler;
+
+struct VsOut {
+  @builtin(position) pos: vec4f,
+  @location(0) uv: vec2f,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vid: u32) -> VsOut {
+  let xy = vec2f(f32((vid << 1u) & 2u), f32(vid & 2u));
+  var out: VsOut;
+  out.pos = vec4f(xy * 2.0 - 1.0, 0.0, 1.0);
+  out.uv  = vec2f(xy.x, 1.0 - xy.y);
+  return out;
+}`;
+var PASSTHROUGH_SHADER_SRC = `${VERTEX_PRELUDE}
+@fragment
+fn fs(in: VsOut) -> @location(0) vec4f {
+  return textureSample(src, src_sampler, in.uv);
+}
+`;
+function createShaderCache(device) {
+  const map = new Map;
+  return {
+    get(source) {
+      let mod = map.get(source);
+      if (!mod) {
+        mod = device.createShaderModule({ code: source });
+        map.set(source, mod);
+      }
+      return mod;
     }
   };
 }
 var singleton2 = null;
-function getTexturePool(device) {
+function getShaderCache(device) {
   if (!singleton2 || singleton2.device !== device) {
-    singleton2?.pool.drain();
-    singleton2 = { device, pool: createTexturePool(device) };
+    singleton2 = { device, cache: createShaderCache(device) };
   }
-  return singleton2.pool;
-}
-function resetTexturePoolForTests() {
-  singleton2?.pool.drain();
-  singleton2 = null;
+  return singleton2.cache;
 }
+
 // src/media/webGpuImage.browser.ts
 var TEX_FORMAT = "rgba8unorm";
 
@@ -1032,14 +811,240 @@ class WebGpuImage {
   }
 }
 registerGpuImageFactory("from", WebGpuImage.from.bind(WebGpuImage));
+
+// src/media/color.ts
+var HEX_PATTERN = /^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var CSS_RGB_CHANNEL = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
+var CSS_RGB_ALPHA = "(?:0(?:\\.\\d+)?|1(?:\\.0+)?)";
+var CSS_RGB_PATTERN = new RegExp(`^rgba?\\(\\s*(${CSS_RGB_CHANNEL})\\s*,\\s*(${CSS_RGB_CHANNEL})\\s*,\\s*(${CSS_RGB_CHANNEL})\\s*(?:,\\s*(${CSS_RGB_ALPHA}))?\\s*\\)$`);
+function parseHexColor(hex) {
+  if (typeof hex !== "string" || !HEX_PATTERN.test(hex)) {
+    throw new Error(`Invalid hex color: ${String(hex)}`);
+  }
+  const body = hex.slice(1);
+  const double = (nibble) => parseInt(nibble + nibble, 16);
+  if (body.length === 3) {
+    return { r: double(body[0]), g: double(body[1]), b: double(body[2]), a: 255 };
+  }
+  if (body.length === 4) {
+    return {
+      r: double(body[0]),
+      g: double(body[1]),
+      b: double(body[2]),
+      a: double(body[3])
+    };
+  }
+  if (body.length === 6) {
+    return {
+      r: parseInt(body.slice(0, 2), 16),
+      g: parseInt(body.slice(2, 4), 16),
+      b: parseInt(body.slice(4, 6), 16),
+      a: 255
+    };
+  }
+  return {
+    r: parseInt(body.slice(0, 2), 16),
+    g: parseInt(body.slice(2, 4), 16),
+    b: parseInt(body.slice(4, 6), 16),
+    a: parseInt(body.slice(6, 8), 16)
+  };
+}
+var CHANNEL_MIN = 0;
+var CHANNEL_MAX = 255;
+function assertChannel(name, value) {
+  if (!Number.isInteger(value) || value < CHANNEL_MIN || value > CHANNEL_MAX) {
+    throw new Error(`Color channel ${name} out of range (0-255 integer): ${value}`);
+  }
+}
+function byteToHex(value) {
+  return value.toString(16).padStart(2, "0");
+}
+function toHexColor(c) {
+  assertChannel("r", c.r);
+  assertChannel("g", c.g);
+  assertChannel("b", c.b);
+  assertChannel("a", c.a);
+  const head = `#${byteToHex(c.r)}${byteToHex(c.g)}${byteToHex(c.b)}`;
+  return c.a === 255 ? head : `${head}${byteToHex(c.a)}`;
+}
+function isInRangeByte(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 255;
+}
+function isColorObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const candidate = value;
+  if (!isInRangeByte(candidate.r))
+    return false;
+  if (!isInRangeByte(candidate.g))
+    return false;
+  if (!isInRangeByte(candidate.b))
+    return false;
+  if (candidate.a !== undefined && !isInRangeByte(candidate.a))
+    return false;
+  return true;
+}
+function isHexColor(value) {
+  return typeof value === "string" && HEX_PATTERN.test(value);
+}
+function parseCssRgbColor(value) {
+  const match = CSS_RGB_PATTERN.exec(value);
+  if (!match) {
+    throw new Error(`Invalid CSS rgb color: ${String(value)}`);
+  }
+  const r = Number.parseInt(match[1] ?? "", 10);
+  const g = Number.parseInt(match[2] ?? "", 10);
+  const b = Number.parseInt(match[3] ?? "", 10);
+  const alpha = match[4] === undefined ? 1 : Number.parseFloat(match[4]);
+  assertChannel("r", r);
+  assertChannel("g", g);
+  assertChannel("b", b);
+  if (!Number.isFinite(alpha) || alpha < 0 || alpha > 1) {
+    throw new Error(`Color alpha out of range (0-1 number): ${match[4]}`);
+  }
+  return { r, g, b, a: Math.round(alpha * 255) };
+}
+function resolveColor(value) {
+  if (typeof value === "string") {
+    if (isHexColor(value))
+      return parseHexColor(value);
+    return parseCssRgbColor(value);
+  }
+  if (!isColorObject(value)) {
+    throw new Error(`Invalid color value: ${JSON.stringify(value)}`);
+  }
+  return {
+    r: value.r,
+    g: value.g,
+    b: value.b,
+    a: value.a ?? 255
+  };
+}
+// src/media/encode.ts
+async function rawPixelBufferToBytes(bin, mimeType) {
+  const dataUri = await getImageRasterCodec().encodeDataUri(bin, mimeType);
+  const b64 = dataUri.slice(dataUri.indexOf(",") + 1);
+  const decoded = atob(b64);
+  const bytes = new Uint8Array(decoded.length);
+  for (let i = 0;i < decoded.length; i++)
+    bytes[i] = decoded.charCodeAt(i);
+  return bytes;
+}
+async function rawPixelBufferToDataUri(bin, mimeType = "image/png") {
+  return getImageRasterCodec().encodeDataUri(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;
+function getRegistry() {
+  let reg = _g4[GLOBAL_REGISTRY_KEY];
+  if (!reg) {
+    reg = new Map;
+    _g4[GLOBAL_REGISTRY_KEY] = reg;
+  }
+  return reg;
+}
+var key = (backend, filter) => `${backend}:${filter}`;
+function registerFilterOp(backend, filter, fn) {
+  getRegistry().set(key(backend, filter), fn);
+}
+function applyFilter(image, filter, params) {
+  const fn = getRegistry().get(key(image.backend, filter));
+  if (!fn) {
+    throw new Error(`applyFilter("${filter}") on backend "${image.backend}": no implementation registered. ` + `Task-layer fallback should have routed this to "cpu" first; this means even the cpu arm is missing. ` + `Ensure @workglow/tasks has been imported so its filter-arm side effects run.`);
+  }
+  return fn(image, params);
+}
+function hasFilterOp(backend, filter) {
+  return getRegistry().has(key(backend, filter));
+}
+function _resetFilterRegistryForTests() {
+  getRegistry().clear();
+}
+// src/media/imageValueSchema.ts
+function ImageValueSchema(annotations = {}) {
+  return {
+    type: ["string", "object"],
+    properties: {},
+    title: "Image",
+    description: "Image (hydrated to ImageValue at task entry)",
+    ...annotations,
+    format: "image"
+  };
+}
+// src/media/MediaRawImage.ts
+class MediaRawImage {
+  data;
+  width;
+  height;
+  channels;
+  constructor(data, width, height, channels) {
+    this.data = data;
+    this.width = width;
+    this.height = height;
+    this.channels = channels;
+  }
+}
+function isMediaRawImageShape(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  return v.data instanceof Uint8ClampedArray && typeof v.width === "number" && typeof v.height === "number" && typeof v.channels === "number";
+}
+// src/media/previewBudget.ts
+var GLOBAL_RESIZE_KEY = Symbol.for("@workglow/util/media/previewResizeFn");
+var GLOBAL_BUDGET_KEY = Symbol.for("@workglow/util/media/previewBudget");
+var _g5 = globalThis;
+var DEFAULT_BUDGET = 512;
+if (typeof _g5[GLOBAL_BUDGET_KEY] !== "number") {
+  _g5[GLOBAL_BUDGET_KEY] = DEFAULT_BUDGET;
+}
+function registerPreviewResizeFn(fn) {
+  _g5[GLOBAL_RESIZE_KEY] = fn;
+}
+function getPreviewResizeFn() {
+  return _g5[GLOBAL_RESIZE_KEY];
+}
+function getPreviewBudget() {
+  return _g5[GLOBAL_BUDGET_KEY];
+}
+function setPreviewBudget(px) {
+  if (!Number.isFinite(px) || px <= 0) {
+    throw new Error(`setPreviewBudget: invalid value ${px}; expected a positive finite number`);
+  }
+  _g5[GLOBAL_BUDGET_KEY] = Math.floor(px);
+}
+async function previewSource(image) {
+  const budget = getPreviewBudget();
+  const long = Math.max(image.width, image.height);
+  if (long <= budget)
+    return image;
+  const ratio = budget / long;
+  const resize = getPreviewResizeFn();
+  if (!resize)
+    return image;
+  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-browser.ts
-async function probeImageDimensions() {
+async function probeImageDimensions(_) {
   throw new Error("probeImageDimensions: not available in browser runtime");
 }
-async function decodeBufferToRaw() {
+async function decodeBufferToRaw(_) {
   throw new Error("decodeBufferToRaw: not available in browser runtime");
 }
-async function encodeRawPixels() {
+async function encodeRawPixels(_, _options) {
   throw new Error("encodeRawPixels: not available in browser runtime");
 }
 async function _preferGpu(value) {
@@ -1093,4 +1098,4 @@ export {
   CpuImage
 };
 
-//# debugId=ECB4E78593EFEFAB64756E2164756E21
+//# debugId=DBD4B12E61C4A72264756E2164756E21