@pixerate/editor 0.246.0 → 0.248.0

package/dist/{chunk-A23PSOBB.js → chunk-XNRBMYNB.js}

@@ -18,7 +18,7 @@ import {
   unionBounds,
   vectorGradientPoints,
   widthProfileAt
-} from "./chunk-N6WUB3Y5.js";
+} from "./chunk-Q2HA52V4.js";
 import {
   segmentLength,
   segmentParamAtLength,

package/dist/{chunk-CEPKXLBS.cjs → chunk-XWTRATIM.cjs}

@@ -5,7 +5,7 @@
 
 
 
-var _chunkFK5LTDOOcjs = require('./chunk-FK5LTDOO.cjs');
+var _chunkL6REDLNBcjs = require('./chunk-L6REDLNB.cjs');
 
 
 var _chunkGF2RBSDMcjs = require('./chunk-GF2RBSDM.cjs');
@@ -1361,12 +1361,12 @@ var unit = (x, y) => {
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
 };
 function cubicOf(sp, i) {
-  const s = _chunkFK5LTDOOcjs.subpathSegment.call(void 0, sp, i);
+  const s = _chunkL6REDLNBcjs.subpathSegment.call(void 0, sp, i);
   if (s.length === 4) return s;
   const [a, b] = s;
   return [a, [a[0] + (b[0] - a[0]) / 3, a[1] + (b[1] - a[1]) / 3], [a[0] + 2 * (b[0] - a[0]) / 3, a[1] + 2 * (b[1] - a[1]) / 3], b];
 }
-var isLine = (sp, i) => _chunkFK5LTDOOcjs.subpathSegment.call(void 0, sp, i).length === 2;
+var isLine = (sp, i) => _chunkL6REDLNBcjs.subpathSegment.call(void 0, sp, i).length === 2;
 function startTangent(c) {
   for (let k = 1; k < 4; k++) {
     const u = unit(c[k][0] - c[0][0], c[k][1] - c[0][1]);
@@ -1386,10 +1386,10 @@ function sample(c, n, out, withStart) {
 }
 var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
 function tidy(a, keepType = true) {
-  const next = _chunkFK5LTDOOcjs.cloneAnchor.call(void 0, a);
+  const next = _chunkL6REDLNBcjs.cloneAnchor.call(void 0, a);
   if (onAnchor(next, next.in)) delete next.in;
   if (onAnchor(next, next.out)) delete next.out;
-  const shown = _chunkFK5LTDOOcjs.inferAnchorType.call(void 0, next);
+  const shown = _chunkL6REDLNBcjs.inferAnchorType.call(void 0, next);
   const type = keepType && a.type ? a.type === "symmetric" && shown !== "symmetric" ? shown === "corner" ? "corner" : "smooth" : a.type === "smooth" && shown === "corner" ? "corner" : a.type : shown;
   if (type === "corner") delete next.type;
   else next.type = type;
@@ -1433,7 +1433,7 @@ function fitAcross(pts, N, t0, t1) {
   return goldenMin(fit, 0, 1);
 }
 function removeAnchorKeepingShape(sp, index) {
-  const anchors = sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor);
   const n = anchors.length;
   if (index < 0 || index >= n) return { anchors, closed: sp.closed };
   if ((sp.closed || index > 0 && index < n - 1) && n >= 3) {
@@ -1467,12 +1467,12 @@ function removeAnchorKeepingShape(sp, index) {
 }
 function removeAnchorsKeepingShape(sp, indices) {
   const order = [...new Set(indices)].filter((i) => i >= 0 && i < sp.anchors.length).sort((a, b) => b - a);
-  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor), closed: sp.closed });
+  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor), closed: sp.closed });
 }
 function bendSegment(sp, segment, t, p) {
-  const anchors = sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor);
   const n = anchors.length;
-  if (segment < 0 || segment >= _chunkFK5LTDOOcjs.subpathSegmentCount.call(void 0, sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
+  if (segment < 0 || segment >= _chunkL6REDLNBcjs.subpathSegmentCount.call(void 0, sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
   const tc = Math.min(0.95, Math.max(0.05, t));
   const ia = segment;
   const ib = (segment + 1) % n;
@@ -1483,16 +1483,16 @@ function bendSegment(sp, segment, t, p) {
   const oy = (p.y - (a.y + (b.y - a.y) * tc)) / k;
   const c1 = { x: a.x + (b.x - a.x) / 3 + ox, y: a.y + (b.y - a.y) / 3 + oy };
   const c2 = { x: b.x + (a.x - b.x) / 3 + ox, y: b.y + (a.y - b.y) / 3 + oy };
-  anchors[ia] = _chunkFK5LTDOOcjs.moveAnchorHandle.call(void 0, a, "out", c1);
-  anchors[ib] = _chunkFK5LTDOOcjs.moveAnchorHandle.call(void 0, b, "in", c2);
+  anchors[ia] = _chunkL6REDLNBcjs.moveAnchorHandle.call(void 0, a, "out", c1);
+  anchors[ib] = _chunkL6REDLNBcjs.moveAnchorHandle.call(void 0, b, "in", c2);
   return { anchors, closed: sp.closed };
 }
 function subpathPointAt(sp, segment, t) {
-  const [x, y] = _chunkGF2RBSDMcjs.segmentPoint.call(void 0, _chunkFK5LTDOOcjs.subpathSegment.call(void 0, sp, segment), t);
+  const [x, y] = _chunkGF2RBSDMcjs.segmentPoint.call(void 0, _chunkL6REDLNBcjs.subpathSegment.call(void 0, sp, segment), t);
   return { x, y };
 }
 function curvatureMoveAnchor(sp, index, q) {
-  const anchors = sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor);
   const a = sp.anchors[index];
   if (!a) return { anchors, closed: sp.closed };
   const own = [
@@ -1538,7 +1538,7 @@ function curvatureMoveAnchor(sp, index, q) {
 function cutSubpathAt(sp, at) {
   const n = sp.anchors.length;
   const cuts = [...new Set(at)].filter((i) => Number.isInteger(i) && i >= 0 && i < n && (sp.closed || i > 0 && i < n - 1)).sort((a, b) => a - b);
-  if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor), closed: sp.closed }];
+  if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor), closed: sp.closed }];
   const first = cuts[0];
   const run = sp.closed ? Array.from({ length: n + 1 }, (_, i) => sp.anchors[(first + i) % n]) : sp.anchors;
   const cutSet = new Set(sp.closed ? [...cuts.map((c) => (c - first + n) % n), n] : cuts);
@@ -1546,7 +1546,7 @@ function cutSubpathAt(sp, at) {
   let cur = [];
   run.forEach((a, i) => {
     if (!cutSet.has(i)) {
-      cur.push(_chunkFK5LTDOOcjs.cloneAnchor.call(void 0, a));
+      cur.push(_chunkL6REDLNBcjs.cloneAnchor.call(void 0, a));
       return;
     }
     if (cur.length) {
@@ -1561,10 +1561,10 @@ function cutSubpathAt(sp, at) {
 }
 function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
   const n = sp.anchors.length;
-  if (segment < 0 || segment >= _chunkFK5LTDOOcjs.subpathSegmentCount.call(void 0, sp)) return [{ anchors: sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor), closed: sp.closed }];
+  if (segment < 0 || segment >= _chunkL6REDLNBcjs.subpathSegmentCount.call(void 0, sp)) return [{ anchors: sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor), closed: sp.closed }];
   if (t <= endTolerance) return cutSubpathAt(sp, [segment]);
   if (t >= 1 - endTolerance) return cutSubpathAt(sp, [(segment + 1) % n]);
-  const { subpath, index } = _chunkFK5LTDOOcjs.insertAnchor.call(void 0, sp, segment, t);
+  const { subpath, index } = _chunkL6REDLNBcjs.insertAnchor.call(void 0, sp, segment, t);
   return cutSubpathAt(subpath, [index]);
 }
 var endOf = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
@@ -1587,7 +1587,7 @@ function joinSubpaths(subpaths, tolerance) {
   const closed = [];
   let open = [];
   for (const sp of subpaths) {
-    const copy = { anchors: sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor), closed: sp.closed };
+    const copy = { anchors: sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor), closed: sp.closed };
     if (sp.closed || sp.anchors.length < 2) {
       if (sp.anchors.length) closed.push(copy);
     } else open.push(copy);
@@ -1642,7 +1642,7 @@ function smoothSubpath(sp, amount = 1, only) {
   const t = Math.min(1, Math.max(0, amount));
   const orig = sp.anchors;
   const n = orig.length;
-  const anchors = orig.map(_chunkFK5LTDOOcjs.cloneAnchor);
+  const anchors = orig.map(_chunkL6REDLNBcjs.cloneAnchor);
   if (n < 3 || t === 0) return { anchors, closed: sp.closed };
   for (let i = 0; i < n; i++) {
     if (!sp.closed && (i === 0 || i === n - 1)) continue;
@@ -1671,8 +1671,8 @@ function smoothSubpath(sp, amount = 1, only) {
 }
 function segsOf(sp) {
   const out = [];
-  for (let i = 0; i < _chunkFK5LTDOOcjs.subpathSegmentCount.call(void 0, sp); i++) {
-    const s = _chunkFK5LTDOOcjs.subpathSegment.call(void 0, sp, i);
+  for (let i = 0; i < _chunkL6REDLNBcjs.subpathSegmentCount.call(void 0, sp); i++) {
+    const s = _chunkL6REDLNBcjs.subpathSegment.call(void 0, sp, i);
     out.push(s.length === 2 ? { c: s, line: true } : { c: s, line: false });
   }
   return out;
@@ -1729,7 +1729,7 @@ function removeRedundantPoints(sp, tolerance) {
   const tol = Math.max(tolerance, 1e-9);
   const types = new Map(sp.anchors.filter((a) => a.type).map((a) => [`${a.x},${a.y}`, a.type]));
   const segs = segsOf(sp).filter((s) => !isZeroSeg(s));
-  if (!segs.length) return { anchors: sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor), closed: sp.closed };
+  if (!segs.length) return { anchors: sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor), closed: sp.closed };
   const minSegs = sp.closed ? 2 : 1;
   let changed = true;
   while (changed && segs.length > minSegs) {
@@ -1747,7 +1747,7 @@ function removeRedundantPoints(sp, tolerance) {
       break;
     }
   }
-  return _nullishCoalesce(segsToSubpath(segs, sp.closed, types), () => ( { anchors: sp.anchors.map(_chunkFK5LTDOOcjs.cloneAnchor), closed: sp.closed }));
+  return _nullishCoalesce(segsToSubpath(segs, sp.closed, types), () => ( { anchors: sp.anchors.map(_chunkL6REDLNBcjs.cloneAnchor), closed: sp.closed }));
 }
 
 

package/dist/{chunk-4PMCMWQS.js → chunk-ZFSLEOSQ.js}

@@ -22,6 +22,7 @@ import {
   TransformTooLargeError,
   blendTile,
   builtinPattern,
+  builtinPatternIds,
   curveLut,
   defaultLayerEffect,
   effectColorHex,
@@ -35,6 +36,7 @@ import {
   isInterpolation,
   isLayerEffectKind,
   isLayerLocked,
+  layerEffectLabel,
   mapLayer,
   mergeLayerEffect,
   newEffectId,
@@ -104,7 +106,7 @@ import {
   transformTextRect,
   translateMatrix,
   warpPresetMesh
-} from "./chunk-N6WUB3Y5.js";
+} from "./chunk-Q2HA52V4.js";
 import {
   bezierPathBounds,
   outlineStroke,
@@ -114,6 +116,7 @@ import {
   transformBezierPath
 } from "./chunk-WEIK3UYB.js";
 import {
+  BLEND_MODES,
   base64ToBytes,
   blendRgb,
   bytesToBase64,
@@ -11723,6 +11726,355 @@ function exportPsd(input) {
   return { bytes, psb, records: records.length, warnings };
 }
 
+// src/image-editor/effect-tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var EFFECT_ID = { type: "string", description: "Effect id from list_layer_effects or add_layer_effect." };
+var BLEND_IDS = BLEND_MODES.map((m) => m.id).filter((id) => id !== "pigment");
+var DEFS = {
+  color: { type: "string", pattern: "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$", description: "Colour as #rrggbb." },
+  contour: {
+    type: "object",
+    description: "A transfer curve over the effect coverage: points { input, output } from 0 to 1 (at least 2), sorted by input. Linear is [{0,0},{1,1}].",
+    properties: {
+      name: { type: "string", description: 'Display name (e.g. "Cone", "Gaussian").' },
+      points: {
+        type: "array",
+        minItems: 2,
+        description: "Curve points.",
+        items: {
+          type: "object",
+          properties: {
+            input: { type: "number", minimum: 0, maximum: 1, description: "Coverage in (0..1)." },
+            output: { type: "number", minimum: 0, maximum: 1, description: "Coverage out (0..1)." },
+            corner: { type: "boolean", description: "Sharp corner instead of a smooth point (default false)." }
+          },
+          required: ["input", "output"],
+          additionalProperties: false
+        }
+      }
+    },
+    required: ["name", "points"],
+    additionalProperties: false
+  },
+  gradient: {
+    type: "object",
+    description: "A gradient: colour stops, optional opacity stops and its layout.",
+    properties: {
+      stops: {
+        type: "array",
+        minItems: 1,
+        description: "Colour stops { position 0..1, color #rrggbb }.",
+        items: {
+          type: "object",
+          properties: { position: { type: "number", minimum: 0, maximum: 1, description: "0..1 along the gradient." }, color: { $ref: "#/$defs/color" } },
+          required: ["position", "color"],
+          additionalProperties: false
+        }
+      },
+      opacityStops: {
+        type: "array",
+        description: "Opacity stops { position 0..1, opacity 0..1 } (default opaque).",
+        items: {
+          type: "object",
+          properties: {
+            position: { type: "number", minimum: 0, maximum: 1, description: "0..1 along the gradient." },
+            opacity: { type: "number", minimum: 0, maximum: 1, description: "0..1." }
+          },
+          required: ["position", "opacity"],
+          additionalProperties: false
+        }
+      },
+      style: { type: "string", enum: ["linear", "radial", "angle", "reflected", "diamond"], description: "Geometry." },
+      angle: { type: "number", minimum: -360, maximum: 360, description: "Degrees, 90 = bottom to top." },
+      scale: { type: "number", minimum: 0.1, maximum: 1.5, description: "1 = 100 %." },
+      reverse: { type: "boolean", description: "Swap the ends." },
+      align: { type: "boolean", description: "Lay out over the layer bounds (true) or the canvas." },
+      offset: {
+        type: "object",
+        description: "Centre offset as fractions of the bounds.",
+        properties: { x: { type: "number", minimum: -1, maximum: 1, description: "Fraction of the width." }, y: { type: "number", minimum: -1, maximum: 1, description: "Fraction of the height." } },
+        required: ["x", "y"],
+        additionalProperties: false
+      }
+    },
+    required: ["stops", "style", "angle", "scale", "reverse", "align", "offset"],
+    additionalProperties: false
+  },
+  phase: {
+    type: "object",
+    description: "Pattern origin offset in px.",
+    properties: { x: { type: "number", description: "px." }, y: { type: "number", description: "px." } },
+    required: ["x", "y"],
+    additionalProperties: false
+  },
+  fill: {
+    description: "What a stroke or glow paints with. Glows take color or gradient only.",
+    anyOf: [
+      {
+        type: "object",
+        properties: { type: { const: "color", description: "Solid colour." }, color: { $ref: "#/$defs/color" } },
+        required: ["type", "color"],
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        properties: { type: { const: "gradient", description: "Gradient." }, gradient: { $ref: "#/$defs/gradient" } },
+        required: ["type", "gradient"],
+        additionalProperties: false
+      },
+      {
+        type: "object",
+        properties: {
+          type: { const: "pattern", description: "Pattern (strokes only)." },
+          patternId: { type: "string", description: "Pattern id from list_layer_effects.patterns." },
+          name: { type: "string", description: "Display name." },
+          scale: { type: "number", minimum: 0.01, maximum: 10, description: "1 = 100 %." },
+          angle: { type: "number", minimum: -360, maximum: 360, description: "Rotation in degrees (default 0)." },
+          link: { type: "boolean", description: "Tile from the layer (default true) or the canvas origin." },
+          phase: { $ref: "#/$defs/phase" }
+        },
+        required: ["type", "patternId", "scale"],
+        additionalProperties: false
+      }
+    ]
+  }
+};
+var nullable = (schema, description) => ({ anyOf: [schema, { type: "null" }], description });
+function settingsSchema(forUpdate) {
+  const opt = (schema, description) => forUpdate ? nullable(schema, `${description} null removes it.`) : { ...schema, description };
+  return {
+    type: "object",
+    description: forUpdate ? "Settings to change (only these; nested objects are replaced whole). Which settings a kind takes: see add_layer_effect." : "Settings to change from Photoshop's defaults (all optional). Unknown settings for the kind are refused with the list of its settings.",
+    properties: {
+      enabled: { type: "boolean", description: "All kinds: false keeps the effect but hides it (default true)." },
+      blend: { type: "string", enum: BLEND_IDS, description: "All but bevel-emboss: blend mode (shadows multiply, glows screen, others normal)." },
+      opacity: { type: "number", minimum: 0, maximum: 1, description: "All but bevel-emboss: 0..1 (shadows / glows 0.75, satin 0.5, others 1)." },
+      color: { $ref: "#/$defs/color", description: "drop-shadow, inner-shadow, satin, color-overlay: #rrggbb." },
+      angle: { type: "number", minimum: -360, maximum: 360, description: "Shadows, satin, bevel-emboss: light direction in degrees, counter-clockwise from 3 o'clock (default 120; satin 19)." },
+      useGlobalLight: { type: "boolean", description: "Shadows, bevel-emboss: follow the document global light instead of angle (default true)." },
+      distance: { type: "number", minimum: 0, maximum: 3e4, description: "Shadows, satin: offset in px (default 5; satin 11)." },
+      spread: { type: "number", minimum: 0, maximum: 1, description: "drop-shadow, outer-glow: 0..1 of the size made solid (default 0)." },
+      choke: { type: "number", minimum: 0, maximum: 1, description: "inner-shadow, inner-glow: 0..1 of the size made solid (default 0)." },
+      size: { type: "number", minimum: 0, maximum: 250, description: "Shadows, glows, satin, bevel-emboss: blur / size in px (default 5; satin 14); stroke: width in px (default 3)." },
+      contour: opt({ $ref: "#/$defs/contour" }, "Shadows, glows, satin: coverage contour (default linear)."),
+      antiAlias: { type: "boolean", description: "Shadows, glows, satin: smooth the contour (default false; satin true)." },
+      noise: { type: "number", minimum: 0, maximum: 1, description: "Shadows, glows: speckle 0..1 (default 0)." },
+      knocksOut: { type: "boolean", description: "drop-shadow: the layer hides the shadow beneath its see-through fill (default true)." },
+      fill: { $ref: "#/$defs/fill", description: "outer-glow, inner-glow (color or gradient), stroke (color, gradient or pattern)." },
+      technique: { type: "string", enum: ["softer", "precise", "smooth", "chisel-hard", "chisel-soft"], description: "Glows: softer | precise (default softer); bevel-emboss: smooth | chisel-hard | chisel-soft (default smooth)." },
+      range: { type: "number", minimum: 0.01, maximum: 1, description: "Glows: the part of the glow the contour spans (default 0.5)." },
+      jitter: { type: "number", minimum: 0, maximum: 1, description: "Glows: gradient jitter 0..1 (stored, not rendered; default 0)." },
+      source: { type: "string", enum: ["edge", "center"], description: "inner-glow: glow from the edge (default) or the centre." },
+      style: { type: "string", enum: ["inner-bevel", "outer-bevel", "emboss", "pillow-emboss", "stroke-emboss"], description: "bevel-emboss: style (default inner-bevel)." },
+      depth: { type: "number", minimum: 0, maximum: 10, description: "bevel-emboss: depth, 1 = 100 % (default 1)." },
+      direction: { type: "string", enum: ["up", "down"], description: "bevel-emboss: raised (up, default) or sunk (down)." },
+      soften: { type: "number", minimum: 0, maximum: 16, description: "bevel-emboss: blur of the height in px (default 0)." },
+      altitude: { type: "number", minimum: 0, maximum: 90, description: "bevel-emboss: light altitude in degrees (default 30)." },
+      glossContour: opt({ $ref: "#/$defs/contour" }, "bevel-emboss: gloss contour over the shading (default linear)."),
+      highlightColor: { $ref: "#/$defs/color", description: "bevel-emboss: highlight colour (default #ffffff)." },
+      highlightBlend: { type: "string", enum: BLEND_IDS, description: "bevel-emboss: highlight mode (default screen)." },
+      highlightOpacity: { type: "number", minimum: 0, maximum: 1, description: "bevel-emboss: highlight opacity (default 0.75)." },
+      shadowColor: { $ref: "#/$defs/color", description: "bevel-emboss: shadow colour (default #000000)." },
+      shadowBlend: { type: "string", enum: BLEND_IDS, description: "bevel-emboss: shadow mode (default multiply)." },
+      shadowOpacity: { type: "number", minimum: 0, maximum: 1, description: "bevel-emboss: shadow opacity (default 0.75)." },
+      contourElement: opt(
+        {
+          type: "object",
+          properties: {
+            contour: { $ref: "#/$defs/contour" },
+            range: { type: "number", minimum: 0, maximum: 1, description: "Stored range (default 0.5)." },
+            antiAlias: { type: "boolean", description: "Smooth the contour." }
+          },
+          required: ["contour", "range", "antiAlias"],
+          additionalProperties: false
+        },
+        "bevel-emboss: the Contour element, shaping the bevel's height profile (default off)."
+      ),
+      texture: opt(
+        {
+          type: "object",
+          properties: {
+            patternId: { type: "string", description: "Pattern id from list_layer_effects.patterns." },
+            name: { type: "string", description: "Display name." },
+            scale: { type: "number", minimum: 0.01, maximum: 10, description: "1 = 100 %." },
+            depth: { type: "number", minimum: -10, maximum: 10, description: "1 = +100 %; negative carves the pattern in." },
+            invert: { type: "boolean", description: "Invert the pattern." },
+            link: { type: "boolean", description: "Tile from the layer (default true)." },
+            phase: { $ref: "#/$defs/phase" }
+          },
+          required: ["patternId", "scale", "depth", "invert"],
+          additionalProperties: false
+        },
+        "bevel-emboss: the Texture element, a pattern's luminance as extra height (default off)."
+      ),
+      invert: { type: "boolean", description: "satin: invert (default true)." },
+      gradient: { $ref: "#/$defs/gradient", description: "gradient-overlay: the gradient (default black to white, 90\xB0)." },
+      dither: { type: "boolean", description: "gradient-overlay: dither (stored; default false)." },
+      patternId: { type: "string", description: "pattern-overlay: pattern id from list_layer_effects.patterns (default checker)." },
+      name: { type: "string", description: "pattern-overlay: pattern display name." },
+      scale: { type: "number", minimum: 0.01, maximum: 10, description: "pattern-overlay: 1 = 100 % (default 1)." },
+      link: { type: "boolean", description: "pattern-overlay: tile from the layer (default true) or the canvas origin." },
+      phase: { $ref: "#/$defs/phase", description: "pattern-overlay: origin offset in px (default 0, 0)." },
+      position: { type: "string", enum: ["outside", "inside", "center"], description: "stroke: where the stroke sits on the edge (default outside)." }
+    },
+    additionalProperties: false
+  };
+}
+function patternList(documentPatterns) {
+  const doc = documentPatterns.map((p) => ({ id: p.id, name: p.name, width: p.width, height: p.height, builtin: false }));
+  const builtins = builtinPatternIds().map((id) => {
+    const p = builtinPattern(id);
+    return { id, name: p.name, width: p.width, height: p.height, builtin: true };
+  });
+  return [...doc, ...builtins];
+}
+function describeLayerEffects(effects) {
+  return {
+    enabled: effects.enabled,
+    scale: effects.scale ?? 1,
+    margin: effectsMargin(effects),
+    fromPsd: Boolean(effects.psd),
+    effects: effects.items.map((e) => ({ ...JSON.parse(JSON.stringify(e)), label: layerEffectLabel(e.kind) }))
+  };
+}
+function createImageEffectTools(controller) {
+  return createLayerEffectTools(
+    {
+      requireLayer: (id) => void requireLayer(controller.getLayers(), id),
+      getLayerEffects: (id) => controller.getLayerEffects(id),
+      addLayerEffect: (id, kind, settings, index) => controller.addLayerEffect(id, kind, settings, index),
+      updateLayerEffect: (id, effectId, changes) => controller.updateLayerEffect(id, effectId, changes),
+      removeLayerEffect: (id, effectId) => controller.removeLayerEffect(id, effectId),
+      setLayerEffectsEnabled: (id, enabled, scale) => controller.setLayerEffectsEnabled(id, enabled, scale),
+      getGlobalLight: () => controller.getGlobalLight(),
+      setGlobalLight: (light) => controller.setGlobalLight(light),
+      getDocumentPatterns: () => controller.getDocumentPatterns()
+    },
+    { layers: "a pixel, shape, type, smart object, annotation or group layer" }
+  );
+}
+function createLayerEffectTools(host, options) {
+  const error = options.error ?? ((m) => new LayerOperationError(m));
+  const LAYER_ID = { type: "string", description: `Layer id from list_layers (${options.layers}).` };
+  const layerArg = (id) => {
+    if (typeof id !== "string" || !id) throw error("layerId is required (a layer id from list_layers).");
+    host.requireLayer(id);
+    return id;
+  };
+  const result = (layerId, extra = {}) => ({ layerId, ...extra, ...describeLayerEffects(host.getLayerEffects(layerId)) });
+  const globalLight = () => host.getGlobalLight?.() ?? { ...DEFAULT_GLOBAL_LIGHT };
+  const list2 = {
+    name: "list_layer_effects",
+    title: "List layer effects",
+    description: "Returns a layer's effects: the master switch (enabled), Scale Effects (scale, 1 = 100 %), margin (px the effects reach beyond the shape), whether they came from a PSD, and every effect with its id, kind, label and all settings. Also returns the document global light and the pattern ids pattern effects can use.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "List layer effects", ...READ },
+    handler: ({ layerId }) => result(layerArg(layerId), { globalLight: globalLight(), patterns: patternList(host.getDocumentPatterns?.() ?? []), kinds: [...LAYER_EFFECT_KINDS] })
+  };
+  const add = {
+    name: "add_layer_effect",
+    title: "Add a layer effect",
+    description: `Adds a live effect to ${options.layers} with Photoshop's defaults, changed by settings: drop-shadow, inner-shadow, outer-glow, inner-glow, bevel-emboss, satin, color-overlay, gradient-overlay, pattern-overlay or stroke. Several of one kind are allowed (the first listed is on top). The effect is drawn from the layer's pixels, so it follows later changes. One undo step. Returns the new effect's id and the layer's effects.`,
+    inputSchema: {
+      type: "object",
+      $defs: DEFS,
+      properties: {
+        layerId: LAYER_ID,
+        kind: { type: "string", enum: [...LAYER_EFFECT_KINDS], description: "Effect kind." },
+        settings: settingsSchema(false),
+        index: { type: "integer", minimum: 0, description: "Position in the layer's effect list (default the end)." }
+      },
+      required: ["layerId", "kind"],
+      additionalProperties: false
+    },
+    annotations: { title: "Add a layer effect", ...WRITE },
+    handler: ({ layerId, kind, settings, index }) => {
+      const id = layerArg(layerId);
+      if (!isLayerEffectKind(kind)) throw error(`kind must be one of ${LAYER_EFFECT_KINDS.join(", ")}.`);
+      const { effect } = host.addLayerEffect(id, kind, settings ?? {}, index);
+      return result(id, { effectId: effect.id });
+    }
+  };
+  const update = {
+    name: "update_layer_effect",
+    title: "Change a layer effect",
+    description: "Changes settings of one effect (only the given ones; fill, gradient, contour and texture objects are replaced whole, null removes an optional contour or texture). The kind cannot change. Validates everything before changing anything. One undo step. Returns the layer's effects.",
+    inputSchema: {
+      type: "object",
+      $defs: DEFS,
+      properties: { layerId: LAYER_ID, effectId: EFFECT_ID, settings: settingsSchema(true) },
+      required: ["layerId", "effectId", "settings"],
+      additionalProperties: false
+    },
+    annotations: { title: "Change a layer effect", ...WRITE_IDEMPOTENT },
+    handler: ({ layerId, effectId, settings }) => {
+      const id = layerArg(layerId);
+      const changes = settings ?? {};
+      if (!Object.keys(changes).length) throw error("Give at least one setting to change.");
+      host.updateLayerEffect(id, effectId, changes);
+      return result(id);
+    }
+  };
+  const remove = {
+    name: "remove_layer_effect",
+    title: "Remove a layer effect",
+    description: "Removes one effect from a layer (to hide it but keep its settings, set enabled false with update_layer_effect instead). One undo step. Returns the layer's remaining effects.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID, effectId: EFFECT_ID }, required: ["layerId", "effectId"], additionalProperties: false },
+    annotations: { title: "Remove a layer effect", ...DESTRUCTIVE },
+    handler: ({ layerId, effectId }) => {
+      const id = layerArg(layerId);
+      host.removeLayerEffect(id, effectId);
+      return result(id);
+    }
+  };
+  const setEnabled = {
+    name: "set_layer_effects_enabled",
+    title: "Switch layer effects on or off",
+    description: "Turns all of a layer's effects on or off at once (the master switch; each effect keeps its own enabled flag) and optionally sets Scale Effects, which multiplies every size, distance and pattern scale. One undo step. Returns the layer's effects.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID,
+        enabled: { type: "boolean", description: "true renders the enabled effects; false hides them all." },
+        scale: { type: "number", minimum: 0.01, maximum: 10, description: "Scale Effects, 1 = 100 % (unchanged when left out)." }
+      },
+      required: ["layerId", "enabled"],
+      additionalProperties: false
+    },
+    annotations: { title: "Switch layer effects on or off", ...WRITE_IDEMPOTENT },
+    handler: ({ layerId, enabled, scale }) => {
+      const id = layerArg(layerId);
+      host.setLayerEffectsEnabled(id, enabled, scale);
+      return result(id);
+    }
+  };
+  const light = {
+    name: "set_global_light",
+    title: "Set the global light",
+    description: "Sets the document global light that shadows and bevels with useGlobalLight follow (Photoshop default: angle 120\xB0, altitude 30\xB0). One undo step. Returns the light.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        angle: { type: "number", minimum: -360, maximum: 360, description: "Degrees, counter-clockwise from 3 o'clock: where the light comes from (unchanged when left out)." },
+        altitude: { type: "number", minimum: 0, maximum: 90, description: "Degrees above the canvas, for bevels (unchanged when left out)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Set the global light", ...WRITE_IDEMPOTENT },
+    handler: ({ angle, altitude }) => {
+      if (angle === void 0 && altitude === void 0) throw error("Give angle, altitude or both.");
+      const next = {};
+      if (angle !== void 0) next.angle = angle;
+      if (altitude !== void 0) next.altitude = altitude;
+      return { globalLight: host.setGlobalLight(next) };
+    }
+  };
+  return host.setGlobalLight ? [list2, add, update, remove, setEnabled, light] : [list2, add, update, remove, setEnabled];
+}
+
 export {
   LEGACY_PROCESS_VERSION,
   LATEST_PROCESS_VERSION,
@@ -12084,5 +12436,8 @@ export {
   psdToLayers,
   importPsd,
   smartContentsFile,
-  exportPsd
+  exportPsd,
+  describeLayerEffects,
+  createImageEffectTools,
+  createLayerEffectTools
 };

package/dist/image-editor/effect-tools.d.cts

@@ -1,11 +1,44 @@
 import type { AgentTool } from '../tools/registry.cjs';
 import type { ImageEditorController } from './controller.cjs';
-import { type LayerEffects } from '../raster/effects/model.cjs';
+import { type LayerEffectKind, type GlobalLight, type LayerEffects } from '../raster/effects/model.cjs';
+import { type EffectPattern } from '../raster/effects/patterns.cjs';
 /** A layer's effects for agents: the master switch, scale, reach and every effect with its settings. */
 export declare function describeLayerEffects(effects: LayerEffects): Record<string, unknown>;
 /**
- * Agent tools for layer effects: `list_layer_effects`, `add_layer_effect`, `update_layer_effect`,
- * `remove_layer_effect`, `set_layer_effects_enabled` and `set_global_light`. Each write validates
- * every setting first, is one undo step and returns the layer's effects after the change.
+ * What the layer effect tools need of an editor. The image and paint editors both provide it, so
+ * both get the same tools, schemas and defaults (`../raster/effects/model`).
  */
+export interface LayerEffectsHost {
+    /** Throws a helpful error when `id` is not a layer that can take effects. */
+    requireLayer(id: string): void;
+    getLayerEffects(id: string): LayerEffects;
+    addLayerEffect(id: string, kind: LayerEffectKind, settings: Record<string, unknown>, index?: number): {
+        effect: {
+            id: string;
+        };
+    };
+    updateLayerEffect(id: string, effectId: string, changes: Record<string, unknown>): unknown;
+    removeLayerEffect(id: string, effectId: string): unknown;
+    setLayerEffectsEnabled(id: string, enabled: boolean, scale?: number): unknown;
+    /** The light shadows and bevels with useGlobalLight follow; without it, the default 120° / 30°. */
+    getGlobalLight?(): GlobalLight;
+    /** With it, the `set_global_light` tool is offered. */
+    setGlobalLight?(light: Partial<GlobalLight>): GlobalLight;
+    /** Document patterns beside the built-in ones (from a PSD). */
+    getDocumentPatterns?(): readonly EffectPattern[];
+}
+export interface LayerEffectToolsOptions {
+    /** What a layerId may name, for its description (e.g. "a pixel, shape, smart object, annotation or group layer"). */
+    layers: string;
+    /** Turns a refusal into the host's error type (default LayerOperationError). */
+    error?: (message: string) => Error;
+}
+/** The image editor's layer effect tools (see `createLayerEffectTools`). */
 export declare function createImageEffectTools(controller: ImageEditorController): AgentTool[];
+/**
+ * Agent tools for layer effects: `list_layer_effects`, `add_layer_effect`, `update_layer_effect`,
+ * `remove_layer_effect`, `set_layer_effects_enabled` and, when the host has a global light to set,
+ * `set_global_light`. Each write validates every setting first, is one undo step and returns the
+ * layer's effects after the change.
+ */
+export declare function createLayerEffectTools(host: LayerEffectsHost, options: LayerEffectToolsOptions): AgentTool[];