@workglow/util 0.2.17 → 0.2.19

package/dist/media-node.js

@@ -1,16 +1,345 @@
-// src/media/imageTypes.ts
-function parseDataUri(dataUri) {
-  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
-  if (!match) {
-    throw new Error("Invalid base64 data URI");
+import { createRequire } from "node:module";
+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;
   }
-  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 +410,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 +443,79 @@ 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 fn(image, params);
+}
+function hasFilterOp(backend, filter) {
+  return getRegistry().has(key(backend, filter));
+}
+function _resetFilterRegistryForTests() {
+  getRegistry().clear();
+}
+// 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 codec;
+  return {
+    mimeType: match[1],
+    base64: match[2]
+  };
 }
 // src/media/MediaRawImage.ts
 class MediaRawImage {
@@ -124,328 +536,299 @@ 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 toImageBinary(value) {
-  const ch = value.channels;
-  if (ch !== 1 && ch !== 3 && ch !== 4) {
-    throw new Error(`Image: unsupported channel count ${ch}`);
-  }
-  const data = coerceToUint8ClampedArray(value.data);
-  return {
-    data,
-    width: value.width,
-    height: value.height,
-    channels: ch,
-    rawChannels: value.rawChannels
-  };
+function getPreviewResizeFn() {
+  return _g5[GLOBAL_RESIZE_KEY];
 }
-function coerceToUint8ClampedArray(data) {
-  if (data instanceof Uint8ClampedArray) {
-    return data;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength);
-  }
-  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 arr;
-    }
+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`);
   }
-  throw new Error("Image: pixel data is not array-like");
+  _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;
 
-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 });
-  }
-  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 });
-    }
-    if (value && typeof value === "object" && "data" in value && "width" in value && "height" in value && "channels" in value) {
-      return Image.fromPixels(toImageBinary(value));
-    }
-    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
-      }));
-    }
-    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;
-    }
-    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;
+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;
     }
-    throw new Error(`Image.getPixels: browser-only source '${this.source.kind}' requires Image.browser augmentation`);
+  };
+}
+var singleton = null;
+function getShaderCache(device) {
+  if (!singleton || singleton.device !== device) {
+    singleton = { device, cache: createShaderCache(device) };
   }
-  async getDataUri(mimeType = "image/png") {
-    if (this.source.kind === "dataUri") {
-      if (mimeType === this.source.mimeType) {
-        return this.source.dataUri;
+  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 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();
-    }
-    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;
+      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;
+      }
+      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();
         }
-        case "Sharp":
-          continue;
       }
+      buckets.clear();
     }
-    throw new Error(`Image.toFirstSupported: none of [${supports.join(", ")}] can be produced on this platform`);
+  };
+}
+var singleton2 = null;
+function getTexturePool(device) {
+  if (!singleton2 || singleton2.device !== device) {
+    singleton2?.pool.drain();
+    singleton2 = { device, pool: createTexturePool(device) };
   }
-  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
-      };
-    }
-    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";
+  return singleton2.pool;
+}
+function resetTexturePoolForTests() {
+  singleton2?.pool.drain();
+  singleton2 = null;
+}
+// src/media/sharpImage.node.ts
+var cachedSharp = null;
+async function loadSharp() {
+  if (cachedSharp)
+    return cachedSharp;
+  const mod = await import("sharp");
+  cachedSharp = mod.default ?? mod;
+  return cachedSharp;
+}
+
+class SharpImage {
+  pipeline;
+  width;
+  height;
+  channels;
+  backend = "sharp";
+  _previewScale;
+  constructor(pipeline, width, height, channels, previewScale = 1) {
+    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) {
+    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");
     }
+    return new SharpImage(pipeline, meta.width, meta.height, meta.channels ?? 4);
+  }
+  apply(op, outSize) {
+    const next = op(this.pipeline.clone());
+    return new SharpImage(next, outSize?.width ?? this.width, outSize?.height ?? this.height, outSize?.channels ?? this.channels, this._previewScale);
   }
-  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;
+  async materialize() {
+    const result = await this.pipeline.clone().raw().toBuffer({ resolveWithObject: true });
+    if (!isObjectResult(result)) {
+      throw new Error("SharpImage.materialize: expected resolveWithObject result");
     }
+    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
+    };
   }
+  async toCanvas(_canvas) {
+    throw new Error("SharpImage.toCanvas is not supported in node/bun environments");
+  }
+  async encode(format, quality) {
+    const p = this.pipeline.clone();
+    let result;
+    if (format === "png")
+      result = await p.png({ quality }).toBuffer();
+    else if (format === "jpeg")
+      result = await p.jpeg({ quality }).toBuffer();
+    else
+      result = await p.webp({ quality }).toBuffer();
+    const buf = result;
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  retain(_n = 1) {
+    return this;
+  }
+  release() {}
 }
-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)}`;
+function isObjectResult(r) {
+  return !!r && typeof r === "object" && "data" in r && "info" in r;
+}
+// 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);
+});
 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,
+  VERTEX_PRELUDE,
+  SharpImage,
+  PASSTHROUGH_SHADER_SRC,
   MediaRawImage,
-  Image
+  GpuImageSchema,
+  GpuImage as GpuImageFactory,
+  CpuImage
 };
 
-//# debugId=DC7CC1D941A4FA1F64756E2164756E21
+//# debugId=2970EA408E9A184364756E2164756E21