@pixerate/editor 0.123.0 → 0.124.0

package/dist/image-editor/index.js

@@ -51,6 +51,7 @@ import {
   VIBRANCE_GREY,
   XYZ_D50_TO_SRGB,
   activeAdjustmentLayers,
+  activeEffectSmartFilters,
   activeSmartFilters,
   addLayerEffect,
   addLayerFilter,
@@ -180,6 +181,7 @@ import {
   isRenderedLayer,
   isSelectionEmpty,
   isSelectionMode,
+  isSmartSurfaceIncomplete,
   isSpatialFilter,
   isTransformAnchor,
   isValidWarp,
@@ -197,7 +199,7 @@ import {
   legacyView,
   levelsValue,
   linearSrgbToXy,
-  linearToSrgb,
+  linearToSrgb as linearToSrgb2,
   liveComponent,
   liveShapeSubpaths,
   mapCropHandle,
@@ -360,13 +362,24 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-6ZBR4J62.js";
+} from "../chunk-WATAQ2Z2.js";
 import {
   parseCssColor
 } from "../chunk-CTTF4KYV.js";
 import {
   loadDocument
 } from "../chunk-U5HZSFCS.js";
+import {
+  createEffectToolProvider
+} from "../chunk-VFAKN46Z.js";
+import {
+  EffectUnsupportedError,
+  EffectsSlot,
+  createEffectPixels,
+  linearToSrgb,
+  resolveEffectValues
+} from "../chunk-TGKT5QAB.js";
+import "../chunk-4FX5ACVG.js";
 import {
   createCaptureTool
 } from "../chunk-REOJJIY3.js";
@@ -475,7 +488,7 @@ import {
   pathStrokeCoverage,
   pathStrokeDabs,
   renderBrushstroke
-} from "../chunk-TVXFHE4T.js";
+} from "../chunk-64PYNEHJ.js";
 import {
   BODY_SCATTER,
   DEFAULT_FLOW,
@@ -2772,6 +2785,182 @@ function refineSelection(pixels, mask, params = {}) {
   return createSelectionMask(mask.width, mask.height, out);
 }
 
+// src/image-editor/effects.ts
+var IMAGE_EFFECT_PLACES = {
+  /** A smart filter: the effect changes the pixels below it. */
+  filter: ["filter"],
+  /** An effect layer: drawn at the document's size. */
+  layer: ["generator", "overlay", "title"]
+};
+function checkImageEffectPlace(d, place) {
+  const allowed = IMAGE_EFFECT_PLACES[place];
+  if (d.kind === "motion" || !d.uses.some((u) => allowed.includes(u))) {
+    const instead = place === "filter" && d.uses.some((u) => IMAGE_EFFECT_PLACES.layer.includes(u)) ? "; add it as an effect layer with add_effect_layer instead" : place === "layer" && d.uses.includes("filter") ? "; apply it to a layer as a smart filter with apply_effect instead" : "";
+    throw new EffectUnsupportedError(
+      `"${d.id}" (${d.name}) is a ${d.uses.join(" / ")} effect, and ${place === "filter" ? "a smart filter takes filter effects" : "an effect layer takes generator, overlay or title effects"}${instead}.`,
+      d.id
+    );
+  }
+}
+function over(base, top) {
+  const out = new Uint8ClampedArray(base.length);
+  for (let i = 0; i < out.length; i += 4) {
+    const ta = top[i + 3] / 255;
+    const ba = base[i + 3] / 255;
+    const a = ta + ba * (1 - ta);
+    out[i + 3] = Math.round(a * 255);
+    if (a > 0) for (let c = 0; c < 3; c++) out[i + c] = (top[i + c] * ta + base[i + c] * ba * (1 - ta)) / a;
+  }
+  return out;
+}
+function effectPixelsToSurface(p, depth) {
+  if (depth === 8 || !p.float) return surfaceFromPixels({ width: p.width, height: p.height, data: p.data }, 4);
+  if (depth === 32) return surfaceFromDeepPixels({ width: p.width, height: p.height, data: p.float }, 4);
+  const f = p.float;
+  const d = new Uint16Array(f.length);
+  const code = (v) => v > 0 ? v < 1 ? Math.round(v * 65535) : 65535 : 0;
+  for (let i = 0; i < f.length; i += 4) {
+    d[i] = code(linearToSrgb(f[i]));
+    d[i + 1] = code(linearToSrgb(f[i + 1]));
+    d[i + 2] = code(linearToSrgb(f[i + 2]));
+    d[i + 3] = code(f[i + 3]);
+  }
+  return surfaceFromDeepPixels({ width: p.width, height: p.height, data: d }, 4);
+}
+var ImageEffectsEngine = class {
+  slot;
+  cache = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  failures = /* @__PURE__ */ new Map();
+  renderers = /* @__PURE__ */ new Map();
+  descriptions = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  maxEntries;
+  generation = 0;
+  detach;
+  constructor(options = {}) {
+    this.slot = options.slot ?? new EffectsSlot();
+    this.maxEntries = options.maxEntries ?? 24;
+    this.detach = this.slot.subscribe(() => {
+      this.reset();
+      this.notify();
+    });
+  }
+  get provider() {
+    return this.slot.provider;
+  }
+  /** See `SmartEffectResolver.token`: bumped when the provider changes. */
+  get token() {
+    return this.generation;
+  }
+  /** True while a render is under way. */
+  get busy() {
+    return this.pending.size > 0;
+  }
+  /** See `SmartEffectResolver`. */
+  resolve(filter, input, width, height, key) {
+    const hit = this.cache.get(key);
+    if (hit) {
+      this.cache.delete(key);
+      this.cache.set(key, hit);
+      return { result: hit, pending: false };
+    }
+    if (this.pending.has(key)) return { result: null, pending: true };
+    const provider = this.slot.provider;
+    if (!provider || this.failures.has(key)) return { result: null, pending: false };
+    const generation = this.generation;
+    const source = { width, height, data: new Uint8ClampedArray(input) };
+    const run = this.filter(provider, filter.effect, filter.values, source).then((out) => {
+      if (generation !== this.generation) return;
+      this.cache.set(key, out);
+      while (this.cache.size > this.maxEntries) this.cache.delete(this.cache.keys().next().value);
+    }).catch((error) => {
+      if (generation === this.generation) this.failures.set(key, error instanceof Error ? error : new Error(String(error)));
+    }).finally(() => {
+      if (this.pending.get(key) === run) this.pending.delete(key);
+      if (generation === this.generation) this.notify();
+    });
+    this.pending.set(key, run);
+    return { result: null, pending: true };
+  }
+  /** A filter effect over `source`: its result, or (for an overlay) the effect drawn over it. */
+  async filter(provider, effect, values, source) {
+    const d = await this.describe(provider, effect);
+    const takesSource = d.inputs.some((i) => i.name === "source");
+    const out = await this.render(provider, effect, source.width, source.height, 8, { time: 0, values, ...takesSource ? { inputs: { source } } : {} });
+    return takesSource ? out.data : over(source.data, out.data);
+  }
+  /**
+   * Renders a generator or overlay effect at a size and depth (an effect layer's pixels). Rejects
+   * with the provider's error, or without a provider.
+   */
+  async renderLayer(effect, values, size) {
+    const provider = this.slot.require();
+    const depth = size.depth ?? 8;
+    const out = await this.render(provider, effect, size.width, size.height, depth, { time: size.time ?? 0, values });
+    return out.width === size.width && out.height === size.height ? out : createEffectPixels(size.width, size.height);
+  }
+  /** Why the result for `key` failed, if it did. */
+  failure(key) {
+    return this.failures.get(key);
+  }
+  /** Every failure so far. */
+  failuresList() {
+    return [...this.failures].map(([key, error]) => ({ key, error }));
+  }
+  /** Resolves when nothing is rendering. */
+  async idle() {
+    while (this.pending.size) await Promise.all([...this.pending.values()]);
+  }
+  /** The provider's description of an effect, fetched once per provider. */
+  describe(provider, id) {
+    let d = this.descriptions.get(id);
+    if (!d) {
+      d = Promise.resolve().then(() => provider.describe(id));
+      d.catch(() => this.descriptions.delete(id));
+      this.descriptions.set(id, d);
+    }
+    return d;
+  }
+  render(provider, id, width, height, depth, request) {
+    const k = `${id}@${width}x${height}x${depth}`;
+    let r = this.renderers.get(k);
+    if (!r) {
+      const renderer = Promise.resolve().then(() => provider.createRenderer(id, { width, height, depth }));
+      renderer.catch(() => this.renderers.delete(k));
+      r = { renderer, queue: Promise.resolve() };
+      this.renderers.set(k, r);
+    }
+    const entry = r;
+    const next = entry.queue.then(() => entry.renderer).then((renderer) => renderer.render(request));
+    entry.queue = next.catch(() => void 0);
+    return next;
+  }
+  /** Forgets every result and failure and disposes the renderers. */
+  reset() {
+    this.generation++;
+    this.cache.clear();
+    this.pending.clear();
+    this.failures.clear();
+    this.descriptions.clear();
+    for (const r of this.renderers.values()) r.renderer.then((x) => x.dispose(), () => {
+    });
+    this.renderers.clear();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify() {
+    for (const l of [...this.listeners]) l();
+  }
+  destroy() {
+    this.reset();
+    this.detach();
+    this.listeners.clear();
+  }
+};
+
 // src/image-editor/free-transform.ts
 var FREE_TRANSFORM_CONTENTS = ["auto", "layer", "selection", "selection-copy", "selection-outline"];
 var fail = (message) => {
@@ -3885,7 +4074,15 @@ var ImageEditorController = class {
   viewKey = [];
   /** For `compositePixels` and mask evaluation (the renderer keeps its own for the viewport). */
   compositor = new LayerCompositor();
+  /** The effects provider slot (see `setEffectsProvider`). */
+  effects = new EffectsSlot();
+  /** Renders provider effects: effect smart filter results and effect layers. */
+  effectsEngine = new ImageEffectsEngine({ slot: this.effects });
+  effectRefresh = "none";
   constructor(options = {}) {
+    this.effects.subscribe(() => this.queueEffectRefresh("all"));
+    this.effectsEngine.subscribe(() => this.queueEffectRefresh("incomplete"));
+    if (options.effects) this.effects.set(options.effects);
     this.maxHistoryDepth = options.maxHistoryDepth ?? 50;
     if (options.textShaper !== void 0) this.textShaperValue = options.textShaper;
     this.maxHistoryBytes = options.maxHistoryBytes ?? 512 * 1024 * 1024;
@@ -4019,6 +4216,206 @@ var ImageEditorController = class {
     const currentState = { ...this.state };
     this.onStateChange?.(currentState);
     this.listeners.forEach((l) => l(currentState));
+    if (this.effects.provider) this.queueEffectRefresh("incomplete");
+  }
+  // --- Provider effects ---
+  queueEffectRefresh(kind) {
+    const queued = this.effectRefresh !== "none";
+    if (kind === "all" || this.effectRefresh === "none") this.effectRefresh = kind;
+    if (queued) return;
+    queueMicrotask(() => {
+      const all = this.effectRefresh === "all";
+      this.effectRefresh = "none";
+      this.refreshEffectSurfaces(all);
+    });
+  }
+  /**
+   * Renders smart objects with effect filters again: every one (`all`, after the provider changed)
+   * or those drawn while a result was rendering, once it is in. A cache refresh: no undo step.
+   */
+  refreshEffectSurfaces(all) {
+    let changed = false;
+    const canvas = this.canvasSize;
+    const walk = (layers) => {
+      let out = null;
+      layers.forEach((l, i) => {
+        let next2 = l;
+        if (l.type === "group") {
+          const children = walk(l.children);
+          if (children !== l.children) next2 = { ...l, children };
+        } else if (l.type === "smart" && l.smartFilters?.filters.some((f) => f.kind === "effect") && (all || isSmartSurfaceIncomplete(l.surface))) {
+          try {
+            const r = rerender(l, canvas);
+            if (all || !isSmartSurfaceIncomplete(r.surface)) next2 = r;
+          } catch {
+          }
+        }
+        if (next2 !== l) {
+          out ??= [...layers];
+          out[i] = next2;
+          changed = true;
+        }
+      });
+      return out ?? layers;
+    };
+    const next = walk(this.state.layers);
+    if (!changed) return;
+    this.state.layers = next;
+    this.notify();
+  }
+  /** The registered effects provider, or `null`. */
+  get effectsProvider() {
+    return this.effects.provider;
+  }
+  /** Registers (or with `null` removes) the effects provider. Not an edit: no undo step. */
+  setEffectsProvider(provider) {
+    this.effects.set(provider);
+  }
+  /** Registers `provider` and returns a function that removes it again (if it is still the one set). */
+  useEffects(provider) {
+    return this.effects.use(provider);
+  }
+  /** The provider's description of an effect, checked for `place` (rejects without a provider or for an unknown id). */
+  async describeEffect(effect, place) {
+    const provider = this.effects.require();
+    const d = await this.effectsEngine.describe(provider, effect);
+    if (place) checkImageEffectPlace(d, place);
+    return d;
+  }
+  /** Resolves when every effect render has landed and the surfaces waiting for them are drawn. */
+  async effectsIdle() {
+    const tick = () => new Promise((r) => queueMicrotask(r));
+    for (let round6 = 0; round6 < 32; round6++) {
+      await this.effectsEngine.idle();
+      await tick();
+      await tick();
+      if (!this.effectsEngine.busy && this.effectRefresh === "none") return;
+    }
+  }
+  /**
+   * Applies a provider filter effect as a smart filter (at `index`, default the top), one undo
+   * step. A pixel, shape or type layer (or a group) is first converted to a smart object in the
+   * same step (Filter › Convert for Smart Filters), keeping its id when it is one layer. `values`
+   * are checked against the effect's controls and stored over its defaults.
+   */
+  async applyEffectFilter(layerId, effect, options = {}) {
+    const d = await this.describeEffect(effect, "filter");
+    const values = resolveEffectValues(d, options.values);
+    const found = findLayer(this.state.layers, layerId);
+    if (!found) throw new LayerOperationError(`There is no layer "${layerId}"; call list_layers for the layer ids.`);
+    let layers = this.state.layers;
+    let id = layerId;
+    let converted = false;
+    if (found.layer.type !== "smart") {
+      if (found.layer.type === "adjustment" || found.layer.type === "annotation") throw new LayerOperationError(`Layer "${found.layer.name || layerId}" is ${found.layer.type === "adjustment" ? "an adjustment layer" : "an annotation"}, which has no pixels to filter; apply the effect to a pixel layer or smart object.`);
+      const res2 = convertToSmartObject(layers, [layerId], this.canvasSize, { surfaceOf: (l) => this.surfaceOf(l) });
+      layers = res2.layers;
+      id = res2.layer.id;
+      converted = true;
+    }
+    const filter = normalizeSmartFilter({ kind: "effect", effect: d.id, provider: this.effects.require().id, name: d.name, values, enabled: options.enabled !== false, blend: options.blend, opacity: options.opacity });
+    const res = addSmartFilter(layers, id, filter, this.canvasSize, options.index);
+    this.commitLayers(res.layers);
+    return { layerId: id, filter: res.filter, converted };
+  }
+  /**
+   * Changes an effect smart filter: `values` merged over its own (`null` resets a control to the
+   * effect's default), `enabled`, `blend`, `opacity` or its place in the stack (`index`). Values
+   * are checked against the provider's controls. One undo step (none with `commitToHistory`
+   * false, during a drag).
+   */
+  async updateEffectFilter(layerId, filterId, changes, commitToHistory = true) {
+    const layer = requireSmartObject(this.state.layers, layerId);
+    const was = layer.smartFilters?.filters.find((f) => f.id === filterId);
+    if (!was || was.kind !== "effect") throw new LayerOperationError(`Smart object "${layer.name || layerId}" has no effect filter "${filterId}"; its filters are ${(layer.smartFilters?.filters ?? []).map((f) => `${f.id} (${f.kind === "effect" ? f.name ?? f.effect : f.kind})`).join(", ") || "none"}.`);
+    const update = {};
+    if (changes.values) {
+      const d = await this.describeEffect(was.effect);
+      const given = {};
+      const base = { ...was.values };
+      for (const [k, v] of Object.entries(changes.values)) {
+        if (v !== null) given[k] = v;
+        else if (k in d.controls.properties) base[k] = d.defaults[k];
+        else throw new LayerOperationError(`"${k}" is not a control of "${d.id}"; its controls are ${Object.keys(d.controls.properties).join(", ")}.`);
+      }
+      update.values = { ...base, ...resolveEffectValues({ ...d, defaults: base }, given) };
+    }
+    for (const k of ["enabled", "blend", "opacity"]) if (changes[k] !== void 0) update[k] = changes[k];
+    let res = updateSmartFilter(this.state.layers, layerId, filterId, update, this.canvasSize);
+    if (changes.index !== void 0) res = { ...res, layers: moveSmartFilter(res.layers, layerId, filterId, changes.index, this.canvasSize).layers };
+    this.commitLayers(res.layers, void 0, commitToHistory);
+    return requireSmartObject(this.state.layers, layerId).smartFilters.filters.find((f) => f.id === filterId);
+  }
+  /**
+   * Adds an effect layer: a pixel layer drawn by a provider generator, overlay or title effect at
+   * the document's size and bit depth (at `time` ms, default 0), placed like `addPixelLayer`. One
+   * undo step. Masks, blend and opacity apply as to any layer. Returns its id.
+   */
+  async addEffectLayer(effect, options = {}) {
+    const d = await this.describeEffect(effect, "layer");
+    const values = resolveEffectValues(d, options.values);
+    const { width, height } = this.naturalSize;
+    const pixels = await this.effectsEngine.renderLayer(d.id, values, { width, height, depth: this.bitDepth, time: options.time });
+    const blend = parseBlend(options.blend);
+    if (options.opacity !== void 0 && !(options.opacity >= 0 && options.opacity <= 1)) throw new LayerOperationError("opacity must be from 0 to 1.");
+    const ids = new Set(flattenLayers(this.state.layers).map((l) => l.id));
+    const layer = {
+      type: "pixel",
+      id: options.id && !ids.has(options.id) ? options.id : newLayerId(),
+      name: options.name?.trim() || d.name,
+      visible: true,
+      opacity: options.opacity ?? 1,
+      blend: blend ?? "normal",
+      surface: effectPixelsToSurface(pixels, this.bitDepth),
+      offset: { x: 0, y: 0 },
+      generator: { effect: d.id, provider: this.effects.require().id, name: d.name, values, ...options.time ? { time: options.time } : {} }
+    };
+    const next = placeLayer(this.state.layers, layer, this.newLayerPlacement(options));
+    this.commitLayers(next, () => {
+      this.state.activeLayerId = layer.id;
+      this.state.activeTarget = "pixels";
+    });
+    return layer.id;
+  }
+  /**
+   * Draws an effect layer again with new `values` (merged over its own; `null` resets a control)
+   * or `time`, at the document's size and depth, replacing its pixels (painting on it is lost).
+   * One undo step (none with `commitToHistory` false). Returns its effect settings.
+   */
+  async updateEffectLayer(layerId, changes, commitToHistory = true) {
+    const found = findLayer(this.state.layers, layerId);
+    const layer = found?.layer;
+    if (!layer || layer.type !== "pixel" || !layer.generator) throw new LayerOperationError(`"${layerId}" is not an effect layer; add one with add_effect_layer.`);
+    requireUnlocked(layer, "pixels", "draw its effect again");
+    const g = layer.generator;
+    const d = await this.describeEffect(g.effect);
+    const base = { ...g.values };
+    const given = {};
+    for (const [k, v] of Object.entries(changes.values ?? {})) {
+      if (v !== null) given[k] = v;
+      else if (k in d.controls.properties) base[k] = d.defaults[k];
+      else throw new LayerOperationError(`"${k}" is not a control of "${d.id}"; its controls are ${Object.keys(d.controls.properties).join(", ")}.`);
+    }
+    const values = { ...base, ...resolveEffectValues({ ...d, defaults: base }, given) };
+    const time = changes.time ?? g.time ?? 0;
+    const { width, height } = this.naturalSize;
+    const pixels = await this.effectsEngine.renderLayer(d.id, values, { width, height, depth: this.bitDepth, time });
+    const generator = { ...g, values, provider: this.effects.require().id, ...time ? { time } : {} };
+    if (!time) delete generator.time;
+    const next = mapLayer(this.state.layers, layerId, (l) => ({ ...l, surface: effectPixelsToSurface(pixels, this.bitDepth), offset: { x: 0, y: 0 }, generator }));
+    this.commitLayers(next, void 0, commitToHistory);
+    return generator;
+  }
+  /** Turns an effect layer into a plain pixel layer keeping its pixels (one undo step). */
+  rasterizeEffectLayer(layerId) {
+    const found = findLayer(this.state.layers, layerId);
+    if (!found || found.layer.type !== "pixel" || !found.layer.generator) throw new LayerOperationError(`"${layerId}" is not an effect layer.`);
+    this.commitLayers(
+      mapLayer(this.state.layers, layerId, (l) => {
+        const { generator: _g, ...rest } = l;
+        return rest;
+      })
+    );
   }
   displayFor = null;
   /** Keeps the renderer's display transform in step with the document profile, mode and Proof Setup. */
@@ -4918,7 +5315,7 @@ var ImageEditorController = class {
   }
   // --- Smart objects ---
   get canvasSize() {
-    return this.naturalSize;
+    return { ...this.naturalSize, effects: this.effectsEngine };
   }
   /**
    * Layer › Smart Objects › Convert to Smart Object (one undo step): sibling layers (default the
@@ -13440,7 +13837,7 @@ function smartFilterRows(layer) {
     filter: f,
     index,
     drawn: f.kind !== "psd",
-    label: f.kind === "psd" ? f.name.replace(/&/g, "").replace(/\.\.\.$/, "") : f.kind === "blur" ? `Blur (${f.radius} px)` : "Develop"
+    label: f.kind === "psd" ? f.name.replace(/&/g, "").replace(/\.\.\.$/, "") : f.kind === "effect" ? f.name ?? f.effect : f.kind === "blur" ? `Blur (${f.radius} px)` : "Develop"
   }));
   return rows.reverse();
 }
@@ -14295,6 +14692,103 @@ var FreeTransformTool = class {
     return false;
   }
 };
+
+// src/image-editor/provider-effect-tools.ts
+function imageLayerAppliedEffects(layer) {
+  const out = [];
+  const ref = (r) => ({ effect: r.effect, ...r.name ? { name: r.name } : {}, ...r.provider ? { provider: r.provider } : {} });
+  if (layer.type === "pixel" && layer.generator) out.push({ id: "generator", ...ref(layer.generator), role: "effect layer", enabled: true, values: layer.generator.values, ...layer.generator.time ? { time: layer.generator.time } : {} });
+  if (layer.type === "smart")
+    (layer.smartFilters?.filters ?? []).forEach((f, index) => {
+      if (f.kind === "effect") out.push({ id: f.id, ...ref(f), role: "smart filter", enabled: f.enabled && layer.smartFilters.enabled, opacity: f.opacity, blend: f.blend, values: f.values, index });
+    });
+  return out;
+}
+function createImageEffectsToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const ro = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    return ro ? typeof ro === "string" ? ro : "The image is read-only." : null;
+  };
+  const layerOf = (id) => {
+    const found = findLayer(controller.getState().layers, id);
+    if (!found) {
+      const ids = flattenLayers(controller.getState().layers).map((l) => `"${l.id}"`);
+      throw new Error(`There is no layer "${id}"; the layers are ${ids.join(", ") || "none"} (list_layers lists them).`);
+    }
+    return found.layer;
+  };
+  const result = (target, instance, extra = {}) => {
+    const effects = imageLayerAppliedEffects(layerOf(target));
+    return { target, effect: effects.find((e) => e.id === instance) ?? effects[effects.length - 1], effects, ...extra };
+  };
+  const plainValues = (v) => v;
+  return createEffectToolProvider({
+    id: options.id ?? "image-effects",
+    namespace: options.namespace,
+    target: { noun: "layer", id: "A layer id from list_layers." },
+    applyUses: ["filter"],
+    applyDetails: "The effect becomes a smart filter: it runs on the layer's pixels after the smart filters below it, with its own blend and opacity, under the smart filter mask, and can be changed or removed later. A pixel, shape or type layer (or a group) is converted to a smart object first, in the same undo step (one layer keeps its id; the result says converted). Generators and overlays go on their own layer through add_effect_layer.",
+    provider: () => controller.effectsProvider,
+    readOnlyReason,
+    list: (target) => {
+      const layers = target ? [layerOf(target)] : flattenLayers(controller.getState().layers);
+      return layers.map((l) => ({ target: l.id, ...l.name ? { name: l.name } : {}, effects: imageLayerAppliedEffects(l) })).filter((t) => target || t.effects.length);
+    },
+    apply: async (target, effect, args) => {
+      const r = await controller.applyEffectFilter(target, effect, { values: plainValues(args.values), index: args.index, enabled: args.enabled, opacity: args.opacity });
+      return result(r.layerId, r.filter.id, { converted: r.converted });
+    },
+    update: async (target, instance, changes) => {
+      const layer = layerOf(target);
+      if (instance === "generator") {
+        const extra = ["enabled", "opacity", "index"].filter((k) => changes[k] !== void 0);
+        if (extra.length) throw new Error(`An effect layer's own effect only takes values; change the layer's ${extra.join(", ")} with update_layer.`);
+        if (layer.type !== "pixel" || !layer.generator) throw new Error(`"${target}" is not an effect layer.`);
+        await controller.updateEffectLayer(target, { values: changes.values });
+        return result(target, "generator");
+      }
+      await controller.updateEffectFilter(target, instance, { values: changes.values, enabled: changes.enabled, opacity: changes.opacity, index: changes.index });
+      return result(target, instance);
+    },
+    remove: async (target, instance) => {
+      const layer = layerOf(target);
+      const was = imageLayerAppliedEffects(layer).find((e) => e.id === instance);
+      if (!was) throw new Error(`Layer "${layer.name || target}" has no provider effect "${instance}"; its effects are ${imageLayerAppliedEffects(layer).map((e) => `"${e.id}"`).join(", ") || "none"} (list_applied_effects).`);
+      if (instance === "generator") controller.rasterizeEffectLayer(target);
+      else controller.removeSmartFilter(target, instance);
+      return { target, effect: was, effects: imageLayerAppliedEffects(layerOf(target)) };
+    },
+    subscribe: (notify) => controller.subscribe(() => notify()),
+    extraTools: (ctx) => [
+      {
+        name: "add_effect_layer",
+        title: "Add an effect layer",
+        description: `Adds a layer drawn by a provider generator, overlay or title effect (search_effects with use generator, overlay or title) at the document's size and bit depth, above the active layer unless placed. Masks, blend mode, opacity and layer styles apply as to any layer; transparent effects show the layers beneath. update_effect with effect "generator" draws it again with new values; remove_effect "generator" keeps its pixels as a plain layer. One undo step. Returns the new layer id and its effect.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            effect: ctx.effectIdSchema(["generator", "overlay", "title"]),
+            values: ctx.valuesSchema("Control values over the effect's defaults"),
+            time: { type: "number", minimum: 0, description: "Which moment of an animated effect to draw, in ms (default 0)." },
+            name: { type: "string", minLength: 1, description: "The layer name (default: the effect's name)." },
+            aboveId: { type: "string", minLength: 1, description: "Put it directly above this layer (default: above the active layer, else on top)." },
+            belowId: { type: "string", minLength: 1, description: "Put it directly below this layer." },
+            opacity: { type: "number", minimum: 0, maximum: 1, description: "Layer opacity 0\u20131 (default 1)." },
+            blend: { type: "string", enum: BLEND_MODES.map((m) => m.id).filter((b) => b !== "pigment"), description: "Layer blend mode (default normal); screen or add for light effects, multiply for textures." }
+          },
+          required: ["effect"],
+          additionalProperties: false
+        },
+        annotations: { title: "Add an effect layer", ...ctx.annotations.write },
+        handler: async (args) => {
+          ctx.requireProvider();
+          const id = await controller.addEffectLayer(args.effect, { values: plainValues(args.values), time: args.time, name: args.name, aboveId: args.aboveId, belowId: args.belowId, opacity: args.opacity, blend: args.blend });
+          return { layerId: id, effects: imageLayerAppliedEffects(layerOf(id)) };
+        }
+      }
+    ]
+  });
+}
 export {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -14372,12 +14866,14 @@ export {
   IMAGE_CROP_PRESETS,
   IMAGE_EDITOR_SCHEMA_VERSION,
   IMAGE_EDITOR_STATE_VERSION,
+  IMAGE_EFFECT_PLACES,
   IMAGE_FILTER_PRESETS,
   INTENTS,
   INTENT_OPTIONS,
   INTERPOLATIONS,
   ImageEditorController,
   ImageEditorRenderer,
+  ImageEffectsEngine,
   LATEST_PROCESS_VERSION,
   LAYERED_SCHEMA_VERSION,
   LAYER_EFFECT_KINDS,
@@ -14522,6 +15018,7 @@ export {
   XYZ_D50_TO_SRGB,
   ZlibError,
   activeAdjustmentLayers,
+  activeEffectSmartFilters,
   activeSmartFilters,
   addLayerEffect,
   addLayerFilter,
@@ -14599,6 +15096,7 @@ export {
   canvasToImagePoint,
   caretAt,
   changedTiles,
+  checkImageEffectPlace,
   clampControlValue,
   clampCropToImage,
   cleanMixer,
@@ -14638,6 +15136,7 @@ export {
   createImageEditTools,
   createImageEditorToolProvider,
   createImageEffectTools,
+  createImageEffectsToolProvider,
   createImageLayerTools,
   createImagePaintTools,
   createImagePsdTools,
@@ -14716,6 +15215,7 @@ export {
   edgeWidth,
   effectColorHex,
   effectControlChange,
+  effectPixelsToSurface,
   effectReach,
   effectiveProof,
   effectsFingerprint,
@@ -14797,6 +15297,7 @@ export {
   identityTransform,
   identityWarpMesh,
   imageEditorStateMigrations,
+  imageLayerAppliedEffects,
   imageToCanvasPoint,
   importPsd,
   inflate,
@@ -14831,6 +15332,7 @@ export {
   isSelectionEmpty,
   isSelectionMode,
   isSeparableBlendMode,
+  isSmartSurfaceIncomplete,
   isSpatialFilter,
   isSrgb,
   isTransformAnchor,
@@ -14866,7 +15368,7 @@ export {
   lerpPigmentInto,
   levelsValue,
   linearSrgbToXy,
-  linearToSrgb,
+  linearToSrgb2 as linearToSrgb,
   linearToSrgb8,
   liveComponent,
   liveShapeForDrag,