@workglow/util 0.2.16 → 0.2.18

package/dist/media-browser.js

@@ -1,16 +1,342 @@
-// src/media/imageTypes.ts
-function parseDataUri(dataUri) {
-  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
-  if (!match) {
-    throw new Error("Invalid base64 data URI");
+// 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;
   }
-  return {
-    mimeType: match[1],
-    base64: match[2]
-  };
+});
+
+// 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 slot = _g2[GLOBAL_CODEC_KEY];
+function registerImageRasterCodec(next) {
+  slot.value = next;
+}
+function getImageRasterCodec() {
+  if (!slot.value) {
+    throw new Error("Image raster codec is not registered. Ensure you import @workglow/tasks from the browser or Node entry (dist/browser.js or dist/node.js), or call registerImageRasterCodec() during startup.");
+  }
+  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;
+}
+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;
+}
+
+class CpuImage {
+  bin;
+  backend = "cpu";
+  _previewScale;
+  constructor(bin, previewScale = 1) {
+    this.bin = bin;
+    this._previewScale = previewScale;
+  }
+  get width() {
+    return this.bin.width;
+  }
+  get height() {
+    return this.bin.height;
+  }
+  get channels() {
+    return this.bin.channels;
+  }
+  get previewScale() {
+    return this._previewScale;
+  }
+  _setPreviewScale(scale) {
+    this._previewScale = scale;
+    return this;
+  }
+  async materialize() {
+    return this.bin;
+  }
+  getBinary() {
+    return this.bin;
+  }
+  async toCanvas(canvas) {
+    if (typeof ImageData === "undefined") {
+      throw new Error("CpuImage.toCanvas requires a browser environment with 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);
+  }
+}
+registerGpuImageFactory("fromImageBinary", CpuImage.fromImageBinary);
+
+// src/media/imageCacheCodec.ts
+registerPortCodec("image", {
+  async serialize(value) {
+    if (typeof value.materialize !== "function") {
+      return value;
+    }
+    const bin = await value.materialize();
+    return {
+      kind: "image-binary",
+      width: bin.width,
+      height: bin.height,
+      channels: bin.channels,
+      data: bin.data
+    };
+  },
+  async deserialize(cached) {
+    if (cached.kind !== "image-binary") {
+      return cached;
+    }
+    return CpuImage.fromImageBinary({
+      data: cached.data,
+      width: cached.width,
+      height: cached.height,
+      channels: cached.channels
+    });
+  }
+});
+
+// src/di/Container.ts
+class Container {
+  services = new Map;
+  factories = new Map;
+  singletons = new Set;
+  resolving = [];
+  register(token, factory2, singleton = true) {
+    this.factories.set(token, factory2);
+    if (singleton) {
+      this.singletons.add(token);
+    }
+  }
+  registerIfAbsent(token, factory2, singleton = true) {
+    if (this.factories.has(token) || this.services.has(token)) {
+      return;
+    }
+    this.register(token, factory2, singleton);
+  }
+  registerInstance(token, instance) {
+    this.services.set(token, instance);
+    this.singletons.add(token);
+  }
+  get(token) {
+    if (this.services.has(token)) {
+      return this.services.get(token);
+    }
+    const factory2 = this.factories.get(token);
+    if (!factory2) {
+      throw new Error(`Service not registered: ${String(token)}`);
+    }
+    if (this.resolving.includes(token)) {
+      const cycle = [...this.resolving.slice(this.resolving.indexOf(token)), token];
+      throw new Error(`Circular dependency detected: ${cycle.join(" -> ")}`);
+    }
+    this.resolving.push(token);
+    try {
+      const instance = factory2();
+      if (this.singletons.has(token)) {
+        this.services.set(token, instance);
+      }
+      return instance;
+    } finally {
+      this.resolving.pop();
+    }
+  }
+  has(token) {
+    return this.services.has(token) || this.factories.has(token);
+  }
+  remove(token) {
+    this.services.delete(token);
+    this.factories.delete(token);
+    this.singletons.delete(token);
+  }
+  async dispose() {
+    const errors = [];
+    try {
+      for (const service of this.services.values()) {
+        if (service == null)
+          continue;
+        try {
+          if (typeof service[Symbol.asyncDispose] === "function") {
+            await service[Symbol.asyncDispose]();
+          } else if (typeof service[Symbol.dispose] === "function") {
+            service[Symbol.dispose]();
+          } else if (typeof service.dispose === "function") {
+            await service.dispose();
+          }
+        } catch (err) {
+          errors.push(err);
+        }
+      }
+    } finally {
+      this.services.clear();
+      this.factories.clear();
+      this.singletons.clear();
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(errors, "One or more services failed to dispose");
+    }
+  }
+  async[Symbol.asyncDispose]() {
+    await this.dispose();
+  }
+  createChildContainer() {
+    const child = new Container;
+    this.factories.forEach((factory2, token) => {
+      child.factories.set(token, factory2);
+      if (this.singletons.has(token)) {
+        child.singletons.add(token);
+      }
+    });
+    this.services.forEach((service, token) => {
+      if (this.singletons.has(token)) {
+        child.services.set(token, service);
+        child.singletons.add(token);
+      }
+    });
+    return child;
+  }
+}
+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 globalContainer = _g3[GLOBAL_CONTAINER_KEY];
+
+// src/di/ServiceRegistry.ts
+function createServiceToken(id) {
+  return { id, _type: null };
+}
+
+class ServiceRegistry {
+  container;
+  constructor(container = globalContainer) {
+    this.container = container;
+  }
+  register(token, factory2, singleton = true) {
+    this.container.register(token.id, factory2, singleton);
+  }
+  registerIfAbsent(token, factory2, singleton = true) {
+    this.container.registerIfAbsent(token.id, factory2, singleton);
+  }
+  registerInstance(token, instance) {
+    this.container.registerInstance(token.id, instance);
+  }
+  get(token) {
+    return this.container.get(token.id);
+  }
+  has(token) {
+    return this.container.has(token.id);
+  }
+  async dispose() {
+    await this.container.dispose();
+  }
+}
+var globalServiceRegistry = new ServiceRegistry(globalContainer);
+
+// src/di/InputResolverRegistry.ts
+var INPUT_RESOLVERS = createServiceToken("task.input.resolvers");
+globalServiceRegistry.registerIfAbsent(INPUT_RESOLVERS, () => new Map, true);
+function getInputResolvers() {
+  return globalServiceRegistry.get(INPUT_RESOLVERS);
+}
+function registerInputResolver(formatPrefix, resolver) {
+  const resolvers = getInputResolvers();
+  resolvers.set(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);
+  }
+  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).`);
+}
+registerInputResolver("image", resolveImageString);
+
 // 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)}`);
@@ -81,9 +407,29 @@ function isColorObject(value) {
 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")
-    return parseHexColor(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)}`);
   }
@@ -94,16 +440,101 @@ function resolveColor(value) {
     a: value.a ?? 255
   };
 }
-// src/media/imageRasterCodecRegistry.ts
-var codec = null;
-function registerImageRasterCodec(next) {
-  codec = next;
+// src/media/encode.ts
+async function encodeImageBinaryBytes(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;
 }
-function getImageRasterCodec() {
-  if (!codec) {
-    throw new Error("Image raster codec is not registered. Ensure you import @workglow/tasks from the browser or Node entry (dist/browser.js or dist/node.js), or call registerImageRasterCodec() during startup.");
+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") {
+  return getImageRasterCodec().encodeDataUri(bin, mimeType);
+}
+async function imageBinaryToBlob(bin, mimeType = "image/png") {
+  const bytes = await encodeImageBinaryBytes(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 codec;
+  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/gpuImageSchema.ts
+function GpuImageSchema(annotations = {}) {
+  return {
+    type: ["string", "object"],
+    properties: {},
+    title: "Image",
+    description: "Image (hydrated to GpuImage by the runner)",
+    ...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 {
@@ -124,430 +555,445 @@ function isMediaRawImageShape(value) {
   const v = value;
   return v.data instanceof Uint8ClampedArray && typeof v.width === "number" && typeof v.height === "number" && typeof v.channels === "number";
 }
-// src/media/Image.ts
-var IMAGE_BRAND = Symbol.for("@workglow/util/media/Image");
-function parseDataUriMimeType(dataUri) {
-  const match = dataUri.match(/^data:([^;,]+)/);
-  const raw = match?.[1]?.trim();
-  return raw ? raw.toLowerCase() : "image/png";
+// 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 dataUriToBlob(dataUri) {
-  const { mimeType, base64 } = parseDataUri(dataUri);
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0;i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return new Blob([bytes], { type: mimeType });
+function registerPreviewResizeFn(fn) {
+  _g5[GLOBAL_RESIZE_KEY] = fn;
+}
+function getPreviewResizeFn() {
+  return _g5[GLOBAL_RESIZE_KEY];
+}
+function getPreviewBudget() {
+  return _g5[GLOBAL_BUDGET_KEY];
 }
-function toImageBinary(value) {
-  const ch = value.channels;
-  if (ch !== 1 && ch !== 3 && ch !== 4) {
-    throw new Error(`Image: unsupported channel count ${ch}`);
+function setPreviewBudget(px) {
+  if (!Number.isFinite(px) || px <= 0) {
+    throw new Error(`setPreviewBudget: invalid value ${px}; expected a positive finite number`);
   }
-  const data = coerceToUint8ClampedArray(value.data);
+  _g5[GLOBAL_BUDGET_KEY] = Math.floor(px);
+}
+function previewSource(image) {
+  if (image.backend !== "webgpu")
+    return 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 result = resize(image, Math.round(image.width * ratio), Math.round(image.height * ratio));
+  const composed = image.previewScale * ratio;
+  return result._setPreviewScale(composed);
+}
+// 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 {
-    data,
-    width: value.width,
-    height: value.height,
-    channels: ch,
-    rawChannels: value.rawChannels
+    get(source) {
+      let mod = map.get(source);
+      if (!mod) {
+        mod = device.createShaderModule({ code: source });
+        map.set(source, mod);
+      }
+      return mod;
+    }
   };
 }
-function coerceToUint8ClampedArray(data) {
-  if (data instanceof Uint8ClampedArray) {
-    return data;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength);
+var singleton = null;
+function getShaderCache(device) {
+  if (!singleton || singleton.device !== device) {
+    singleton = { device, cache: createShaderCache(device) };
   }
-  if (Array.isArray(data)) {
-    return Uint8ClampedArray.from(data);
-  }
-  if (data && typeof data === "object") {
-    const obj = data;
-    const keys = Object.keys(obj);
-    if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
-      const arr = new Uint8ClampedArray(keys.length);
-      for (let i = 0;i < keys.length; i++) {
-        arr[i] = Number(obj[String(i)]);
+  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}`;
+  return {
+    acquire(width, height, format) {
+      const k = sizeClassKey(width, height, format);
+      const bucket = buckets.get(k);
+      if (bucket && bucket.length > 0) {
+        const reused = bucket.pop();
+        reused.inPool = false;
+        return reused.texture;
+      }
+      const texture = device.createTexture({
+        size: [width, height, 1],
+        format,
+        usage: TEXTURE_USAGE
+      });
+      const entry = { texture, width, height, format, inPool: false };
+      owners.set(texture, entry);
+      return texture;
+    },
+    release(texture) {
+      const entry = owners.get(texture);
+      if (!entry)
+        return;
+      if (entry.inPool)
+        return;
+      const k = sizeClassKey(entry.width, entry.height, entry.format);
+      let bucket = buckets.get(k);
+      if (!bucket) {
+        bucket = [];
+        buckets.set(k, bucket);
+      }
+      if (bucket.length >= capacity) {
+        owners.delete(texture);
+        texture.destroy();
+        return;
       }
-      return arr;
+      entry.inPool = true;
+      bucket.push(entry);
+    },
+    drain() {
+      for (const bucket of buckets.values()) {
+        for (const entry of bucket) {
+          owners.delete(entry.texture);
+          entry.texture.destroy();
+        }
+      }
+      buckets.clear();
     }
-  }
-  throw new Error("Image: pixel data is not array-like");
+  };
 }
-
-class Image {
-  [IMAGE_BRAND] = true;
-  source;
-  pixelsCache;
-  dataUriCache = new Map;
-  blobCache = new Map;
-  constructor(source) {
-    this.source = source;
-  }
-  static fromDataUri(dataUri) {
-    if (!dataUri.startsWith("data:")) {
-      throw new Error("Image.fromDataUri: input must start with 'data:'");
-    }
-    return new Image({ kind: "dataUri", dataUri, mimeType: parseDataUriMimeType(dataUri) });
-  }
-  static fromPixels(pixels) {
-    return new Image({ kind: "pixels", pixels });
+var singleton2 = null;
+function getTexturePool(device) {
+  if (!singleton2 || singleton2.device !== device) {
+    singleton2?.pool.drain();
+    singleton2 = { device, pool: createTexturePool(device) };
   }
-  static fromBlob(blob) {
-    return new Image({ kind: "blob", blob });
-  }
-  static from(value) {
-    if (Image.is(value)) {
-      return value;
-    }
-    if (typeof value === "string" && value.startsWith("data:")) {
-      return Image.fromDataUri(value);
-    }
-    if (typeof Blob !== "undefined" && value instanceof Blob) {
-      return Image.fromBlob(value);
-    }
-    if (typeof ImageBitmap !== "undefined" && value instanceof ImageBitmap) {
-      return new Image({ kind: "bitmap", bitmap: value });
-    }
-    if (typeof VideoFrame !== "undefined" && value instanceof VideoFrame) {
-      return new Image({ kind: "videoFrame", frame: value });
-    }
-    if (typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas) {
-      return new Image({ kind: "offscreenCanvas", canvas: value });
+  return singleton2.pool;
+}
+function resetTexturePoolForTests() {
+  singleton2?.pool.drain();
+  singleton2 = null;
+}
+// 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;
     }
-    if (value && typeof value === "object" && "data" in value && "width" in value && "height" in value && "channels" in value) {
-      return Image.fromPixels(toImageBinary(value));
+  } 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;
     }
-    throw new Error(`Image.from: unsupported image value of type ${typeof value}`);
-  }
-  static is(value) {
-    return typeof value === "object" && value !== null && value[IMAGE_BRAND] === true;
   }
-  static fromJSON(value) {
-    if (Image.is(value)) {
-      return value;
-    }
-    if (typeof value === "string" && value.startsWith("data:")) {
-      return Image.fromDataUri(value);
-    }
-    if (value && typeof value === "object" && value.unsynced === true) {
-      const kind = value.kind;
-      throw new Error(`Image.fromJSON: cannot reconstruct image from "unsynced" sentinel (kind=${String(kind)}); pixels were not materialized before serialization. Call await image.getPixels() before JSON.stringify.`);
-    }
-    if (value && typeof value === "object" && "data" in value && typeof value.width === "number" && typeof value.height === "number" && typeof value.channels === "number") {
-      const v = value;
-      return Image.fromPixels(toImageBinary({
-        data: v.data,
-        width: v.width,
-        height: v.height,
-        channels: v.channels
-      }));
+  return out;
+}
+function align(n, m) {
+  return Math.ceil(n / m) * m;
+}
+
+class WebGpuImage {
+  device;
+  texture;
+  width;
+  height;
+  backend = "webgpu";
+  channels = 4;
+  refcount = 1;
+  _previewScale;
+  constructor(device, texture, width, height, previewScale = 1) {
+    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);
     }
-    throw new Error("Image.fromJSON: value does not match any known Image shape");
   }
-  get kind() {
-    return this.source.kind;
-  }
-  get mimeType() {
-    if (this.source.kind === "dataUri")
-      return this.source.mimeType;
-    if (this.source.kind === "blob")
-      return this.source.blob.type || undefined;
-    return;
-  }
-  get width() {
-    if (this.source.kind === "pixels")
-      return this.source.pixels.width;
-    if (this.source.kind === "bitmap")
-      return this.source.bitmap.width;
-    if (this.source.kind === "offscreenCanvas")
-      return this.source.canvas.width;
-    if (this.source.kind === "videoFrame")
-      return this.source.frame.displayWidth;
-    return this.pixelsCache?.width;
-  }
-  get height() {
-    if (this.source.kind === "pixels")
-      return this.source.pixels.height;
-    if (this.source.kind === "bitmap")
-      return this.source.bitmap.height;
-    if (this.source.kind === "offscreenCanvas")
-      return this.source.canvas.height;
-    if (this.source.kind === "videoFrame")
-      return this.source.frame.displayHeight;
-    return this.pixelsCache?.height;
-  }
-  get channels() {
-    if (this.source.kind === "pixels")
-      return this.source.pixels.channels;
-    return this.pixelsCache?.channels;
-  }
-  async getPixels() {
-    if (this.pixelsCache)
-      return this.pixelsCache;
-    if (this.source.kind === "pixels") {
-      this.pixelsCache = this.source.pixels;
-      return this.pixelsCache;
+  get previewScale() {
+    return this._previewScale;
+  }
+  _setPreviewScale(scale) {
+    this._previewScale = scale;
+    return this;
+  }
+  static async fromImageBinary(bin) {
+    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);
+  }
+  apply(params) {
+    if (!this.texture)
+      throw new Error("WebGpuImage.apply called on a released 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);
+    const shaderModule = getShaderCache(this.device).get(params.shader);
+    const pipeline = this.device.createRenderPipeline({
+      layout: "auto",
+      vertex: { module: shaderModule, entryPoint: "vs" },
+      fragment: { module: shaderModule, entryPoint: "fs", targets: [{ format: TEX_FORMAT }] },
+      primitive: { topology: "triangle-list" }
+    });
+    const sampler = this.device.createSampler({ magFilter: "linear", minFilter: "linear" });
+    const bindEntries = [
+      { binding: 0, resource: this.texture.createView() },
+      { binding: 1, resource: sampler }
+    ];
+    if (params.uniforms) {
+      const ubo = this.device.createBuffer({
+        size: params.uniforms.byteLength,
+        usage: 64 | 8
+      });
+      this.device.queue.writeBuffer(ubo, 0, params.uniforms);
+      bindEntries.push({ binding: 2, resource: { buffer: ubo } });
     }
-    if (this.source.kind === "dataUri") {
-      this.pixelsCache = await getImageRasterCodec().decodeDataUri(this.source.dataUri);
-      return this.pixelsCache;
-    }
-    if (this.source.kind === "blob") {
-      const dataUri = await blobToDataUri(this.source.blob);
-      this.pixelsCache = await getImageRasterCodec().decodeDataUri(dataUri);
-      return this.pixelsCache;
-    }
-    throw new Error(`Image.getPixels: browser-only source '${this.source.kind}' requires Image.browser augmentation`);
-  }
-  async getDataUri(mimeType = "image/png") {
-    if (this.source.kind === "dataUri") {
-      if (mimeType === this.source.mimeType) {
-        return this.source.dataUri;
+    const bindGroup = this.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: bindEntries
+    });
+    const enc = this.device.createCommandEncoder();
+    const pass = enc.beginRenderPass({
+      colorAttachments: [{
+        view: out.createView(),
+        loadOp: "clear",
+        storeOp: "store",
+        clearValue: [0, 0, 0, 0]
+      }]
+    });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bindGroup);
+    pass.draw(3);
+    pass.end();
+    this.device.queue.submit([enc.finish()]);
+    return new WebGpuImage(this.device, out, outW, outH, this._previewScale);
+  }
+  async materialize() {
+    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);
       }
     }
-    const cached = this.dataUriCache.get(mimeType);
-    if (cached)
-      return cached;
-    const pixels = await this.getPixels();
-    const dataUri = await getImageRasterCodec().encodeDataUri(pixels, mimeType);
-    this.dataUriCache.set(mimeType, dataUri);
-    return dataUri;
-  }
-  async getBlob(mimeType = "image/png") {
-    if (this.source.kind === "blob" && (!mimeType || this.source.blob.type === mimeType)) {
-      return this.source.blob;
-    }
-    const cached = this.blobCache.get(mimeType);
-    if (cached)
-      return cached;
-    if (this.source.kind === "dataUri" && this.source.mimeType === mimeType) {
-      const blob2 = dataUriToBlob(this.source.dataUri);
-      this.blobCache.set(mimeType, blob2);
-      return blob2;
-    }
-    const dataUri = await this.getDataUri(mimeType);
-    const blob = dataUriToBlob(dataUri);
-    this.blobCache.set(mimeType, blob);
-    return blob;
-  }
-  async toFirstSupported(supports) {
-    const canonical = this.canonicalSupport();
-    if (canonical && supports.includes(canonical)) {
-      return this.currentSourceValue();
+    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");
+    if (!ctx)
+      throw new Error("WebGpuImage.toCanvas requires a webgpu context");
+    const presentationFormat = navigator.gpu.getPreferredCanvasFormat();
+    ctx.configure({ device: this.device, format: presentationFormat, alphaMode: "premultiplied" });
+    const view = ctx.getCurrentTexture().createView();
+    const shaderModule = getShaderCache(this.device).get(PASSTHROUGH_SHADER_SRC);
+    const pipeline = this.device.createRenderPipeline({
+      layout: "auto",
+      vertex: { module: shaderModule, entryPoint: "vs" },
+      fragment: { module: shaderModule, entryPoint: "fs", targets: [{ format: presentationFormat }] },
+      primitive: { topology: "triangle-list" }
+    });
+    const sampler = this.device.createSampler({ magFilter: "linear", minFilter: "linear" });
+    const bindGroup = this.device.createBindGroup({
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: this.texture.createView() },
+        { binding: 1, resource: sampler }
+      ]
+    });
+    const enc = this.device.createCommandEncoder();
+    const pass = enc.beginRenderPass({
+      colorAttachments: [{ view, loadOp: "clear", storeOp: "store", clearValue: [0, 0, 0, 0] }]
+    });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bindGroup);
+    pass.draw(3);
+    pass.end();
+    this.device.queue.submit([enc.finish()]);
+  }
+  async encode(format, quality) {
+    const bin = await this.materialize();
+    if (typeof OffscreenCanvas === "undefined") {
+      throw new Error("WebGpuImage.encode requires an OffscreenCanvas environment");
     }
-    for (const want of supports) {
-      switch (want) {
-        case "ImageBinary":
-          return this.getPixels();
-        case "Blob":
-          return this.getBlob();
-        case "DataUri":
-          return this.getDataUri();
-        case "RawImage": {
-          const p = await this.getPixels();
-          return new MediaRawImage(p.data, p.width, p.height, p.channels);
-        }
-        case "ImageBitmap":
-        case "VideoFrame":
-        case "OffscreenCanvas": {
-          const asBrowser = this;
-          if (asBrowser.toFirstSupportedBrowser) {
-            const produced = await asBrowser.toFirstSupportedBrowser(want);
-            if (produced !== undefined)
-              return produced;
-          }
-          continue;
-        }
-        case "Sharp":
-          continue;
-      }
+    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 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");
     }
-    throw new Error(`Image.toFirstSupported: none of [${supports.join(", ")}] can be produced on this platform`);
+    this.refcount += n;
+    return this;
   }
-  toJSON() {
-    if (this.source.kind === "dataUri") {
-      return this.source.dataUri;
-    }
-    const pixels = this.source.kind === "pixels" ? this.source.pixels : this.pixelsCache;
-    if (pixels) {
-      return {
-        data: Array.from(pixels.data),
-        width: pixels.width,
-        height: pixels.height,
-        channels: pixels.channels
-      };
+  release() {
+    if (this.refcount <= 0) {
+      throw new Error("WebGpuImage.release called on a released image");
     }
-    return { unsynced: true, kind: this.source.kind };
-  }
-  canonicalSupport() {
-    switch (this.source.kind) {
-      case "dataUri":
-        return "DataUri";
-      case "pixels":
-        return "ImageBinary";
-      case "blob":
-        return "Blob";
-      case "bitmap":
-        return "ImageBitmap";
-      case "videoFrame":
-        return "VideoFrame";
-      case "offscreenCanvas":
-        return "OffscreenCanvas";
-    }
-  }
-  getSource() {
-    return this.source;
-  }
-  setPixelsCache(pixels) {
-    this.pixelsCache = pixels;
-  }
-  currentSourceValue() {
-    switch (this.source.kind) {
-      case "dataUri":
-        return this.source.dataUri;
-      case "pixels":
-        return this.source.pixels;
-      case "blob":
-        return this.source.blob;
-      case "bitmap":
-        return this.source.bitmap;
-      case "videoFrame":
-        return this.source.frame;
-      case "offscreenCanvas":
-        return this.source.canvas;
+    this.refcount -= 1;
+    if (this.refcount > 0)
+      return;
+    if (this.texture) {
+      const tex = this.texture;
+      this.texture = null;
+      if (finalizers)
+        finalizers.unregister(this);
+      getTexturePool(this.device).release(tex);
     }
   }
 }
-async function blobToDataUri(blob) {
-  const buffer = await blob.arrayBuffer();
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  const CHUNK = 8192;
-  for (let i = 0;i < bytes.byteLength; i += CHUNK) {
-    binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
-  }
-  const mime = blob.type || "image/png";
-  return `data:${mime};base64,${btoa(binary)}`;
-}
-// src/media/Image.browser.ts
-Image.fromBitmap = function fromBitmap(bitmap) {
-  return Image.from(bitmap);
-};
-Image.fromVideoFrame = function fromVideoFrame(frame) {
-  return Image.from(frame);
-};
-Image.fromOffscreenCanvas = function fromOffscreenCanvas(canvas) {
-  return Image.from(canvas);
-};
-function rasterToImageData(image) {
-  const { width, height, channels, data } = image;
-  const id = new ImageData(width, height);
-  if (channels === 4) {
-    id.data.set(data);
-    return id;
-  }
-  if (channels === 3) {
-    for (let i = 0;i < width * height; i++) {
-      id.data[i * 4] = data[i * 3];
-      id.data[i * 4 + 1] = data[i * 3 + 1];
-      id.data[i * 4 + 2] = data[i * 3 + 2];
-      id.data[i * 4 + 3] = 255;
-    }
-    return id;
-  }
-  if (channels === 1) {
-    for (let i = 0;i < width * height; i++) {
-      const v = data[i];
-      id.data[i * 4] = v;
-      id.data[i * 4 + 1] = v;
-      id.data[i * 4 + 2] = v;
-      id.data[i * 4 + 3] = 255;
-    }
-    return id;
-  }
-  throw new Error(`Image.getImageData: unsupported channel count ${channels}`);
+// src/media-browser.ts
+async function _preferGpu(bin) {
+  const dev = await getGpuDevice();
+  return dev ? WebGpuImage.fromImageBinary(bin) : CpuImage.fromImageBinary(bin);
 }
-async function blobToOffscreenCanvas(blob) {
+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);
-  try {
-    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
-    const ctx = canvas.getContext("2d");
-    if (!ctx)
-      throw new Error("Image: failed to get 2D context on OffscreenCanvas");
-    ctx.drawImage(bitmap, 0, 0);
-    return canvas;
-  } finally {
-    bitmap.close();
-  }
-}
-Image.prototype.getImageData = async function getImageData() {
-  const pixels = await this.getPixels();
-  return rasterToImageData(pixels);
-};
-Image.prototype.getImageBitmap = async function getImageBitmap() {
-  const source = this.getSource();
-  if (source.kind === "bitmap")
-    return source.bitmap;
-  if (source.kind === "blob")
-    return createImageBitmap(source.blob);
-  if (source.kind === "offscreenCanvas") {
-    return source.canvas.transferToImageBitmap();
-  }
-  if (source.kind === "dataUri") {
-    return createImageBitmap(dataUriToBlob(source.dataUri));
-  }
-  const id = await this.getImageData();
-  return createImageBitmap(id);
-};
-Image.prototype.getVideoFrame = async function getVideoFrame() {
-  const source = this.getSource();
-  if (source.kind === "videoFrame")
-    return source.frame;
-  const bitmap = await this.getImageBitmap();
-  return new VideoFrame(bitmap, { timestamp: 0 });
-};
-Image.prototype.getOffscreenCanvas = async function getOffscreenCanvas() {
-  const source = this.getSource();
-  if (source.kind === "offscreenCanvas")
-    return source.canvas;
-  if (source.kind === "blob")
-    return blobToOffscreenCanvas(source.blob);
-  if (source.kind === "dataUri")
-    return blobToOffscreenCanvas(dataUriToBlob(source.dataUri));
-  const id = await this.getImageData();
-  const canvas = new OffscreenCanvas(id.width, id.height);
-  const ctx = canvas.getContext("2d");
+  const off = new OffscreenCanvas(bitmap.width, bitmap.height);
+  const ctx = off.getContext("2d");
   if (!ctx)
-    throw new Error("Image.getOffscreenCanvas: failed to get 2D context");
-  ctx.putImageData(id, 0, 0);
-  return canvas;
-};
-Image.prototype.toFirstSupportedBrowser = async function toFirstSupportedBrowser(want) {
-  if (want === "ImageBitmap")
-    return this.getImageBitmap();
-  if (want === "VideoFrame")
-    return this.getVideoFrame();
-  if (want === "OffscreenCanvas")
-    return this.getOffscreenCanvas();
-  return;
-};
+    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 });
+});
 export {
   toHexColor,
+  setPreviewBudget,
   resolveColor,
+  resetTexturePoolForTests,
+  resetGpuDeviceForTests,
+  registerPreviewResizeFn,
   registerImageRasterCodec,
+  registerGpuImageFactory,
+  registerFilterOp,
+  previewSource,
   parseHexColor,
   parseDataUri,
   isMediaRawImageShape,
   isHexColor,
   isColorObject,
+  imageBinaryToDataUri,
+  imageBinaryToBlob,
+  imageBinaryToBase64Png,
+  hasFilterOp,
+  getTexturePool,
+  getShaderCache,
+  getPreviewBudget,
   getImageRasterCodec,
-  dataUriToBlob,
+  getGpuImageFactory,
+  getGpuDevice,
+  encodeImageBinaryToPng,
+  createTexturePool,
+  createShaderCache,
+  applyFilter,
+  _resetFilterRegistryForTests,
+  WebGpuImage,
+  VERTEX_PRELUDE,
+  PASSTHROUGH_SHADER_SRC,
   MediaRawImage,
-  Image
+  GpuImageSchema,
+  GpuImage as GpuImageFactory,
+  CpuImage
 };
 
-//# debugId=9670F06EEC7694A064756E2164756E21
+//# debugId=006D8DBD8329F1E964756E2164756E21