@pixerate/editor 0.101.0 → 0.102.0

package/dist/image-editor/index.js

@@ -68,7 +68,7 @@ import {
   validateLayerEffect,
   validateLayerEffects,
   warpSurface
-} from "../chunk-WIR377F6.js";
+} from "../chunk-67FRIOPZ.js";
 import {
   affineFromHomography,
   applyHomography,
@@ -166,6 +166,7 @@ import {
   identityWarpMesh,
   invertMatrix,
   isValidWarpMesh,
+  mapWarpMeshPoints,
   matrixAbout,
   multiplyMatrices,
   pullWarpMesh,
@@ -2429,7 +2430,13 @@ function pixelLayerBounds(layer, surface = layer.surface) {
   return { x: b.x + layer.offset.x, y: b.y + layer.offset.y, width: b.width, height: b.height };
 }
 function layerTypeLabel(type) {
-  return type === "pixel" ? "Pixel layer" : type === "adjustment" ? "Adjustment layer" : type === "group" ? "Group" : "Annotation";
+  return type === "pixel" ? "Pixel layer" : type === "adjustment" ? "Adjustment layer" : type === "group" ? "Group" : type === "smart" ? "Smart object" : "Annotation";
+}
+function hasSurface(layer) {
+  return layer.type === "pixel" || layer.type === "smart";
+}
+function smartObjectLayers(layers) {
+  return flattenLayers(layers).filter((l) => l.type === "smart");
 }
 
 // src/image-editor/layers/compositor.ts
@@ -2485,6 +2492,13 @@ function depthMaskAlpha(depth, options) {
   v += lo;
   return v < 0 ? 0 : v > 255 ? 255 : v;
 }
+function runLayerFilters(data, width, height, filters) {
+  for (const f of filters) {
+    if (!isActiveFilter(f)) continue;
+    if (f.kind === "develop") applyPixelFilters(data, [f]);
+    else if (f.kind === "blur") applyBoxBlur({ width, height, data }, Math.min(Math.round(f.radius), 40));
+  }
+}
 var filterSpecCache = /* @__PURE__ */ new WeakMap();
 function pixelFilterSpec(layer) {
   const list2 = layer.filters;
@@ -2497,12 +2511,7 @@ function pixelFilterSpec(layer) {
     spec = {
       key: JSON.stringify(filters),
       spatial,
-      apply: (data, width, height) => {
-        for (const f of filters) {
-          if (f.kind === "develop") applyPixelFilters(data, [f]);
-          else if (f.kind === "blur") applyBoxBlur({ width, height, data }, Math.min(Math.round(f.radius), 40));
-        }
-      }
+      apply: (data, width, height) => runLayerFilters(data, width, height, filters)
     };
   }
   filterSpecCache.set(list2, spec);
@@ -2519,6 +2528,8 @@ var PHOTO_PROFILE = {
   contentBlend: (l) => l.type === "annotation" && l.blend === "normal" && l.annotation.blend ? l.annotation.blend : l.blend,
   layerKey: (l) => l.type === "pixel" ? [l.filters ?? null, l.source ?? null] : l.type === "adjustment" ? [l.kind, l.params] : l.type === "annotation" ? l.annotation : void 0,
   pixelFilters: (l) => l.type === "pixel" ? pixelFilterSpec(l) : null,
+  /** A smart object draws its rendered pixels (contents → placement → smart filters) like a pixel layer. */
+  isPixelLike: (l) => l.type === "smart",
   maskSourcePlane: (source, W, H, sources) => {
     const opts = source;
     const depth = sources.depthMap?.(opts) ?? null;
@@ -4607,330 +4618,162 @@ function refineSelection(pixels, mask, params = {}) {
   return createSelectionMask(mask.width, mask.height, out);
 }
 
-// src/image-editor/layers/serialize.ts
-var LAYERED_SCHEMA_VERSION = 3;
-function serializePatterns(patterns) {
-  return patterns.map((p) => ({ id: p.id, name: p.name, png: pngDataUrl(p.width, p.height, p.data) }));
+// src/image-editor/transform.ts
+var FREE_TRANSFORM_MODES = ["scale", "rotate", "skew", "distort", "perspective", "warp"];
+var TRANSFORM_ANCHORS = ["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"];
+var ANCHOR_FRACTION = {
+  "top-left": [0, 0],
+  top: [0.5, 0],
+  "top-right": [1, 0],
+  left: [0, 0.5],
+  center: [0.5, 0.5],
+  right: [1, 0.5],
+  "bottom-left": [0, 1],
+  bottom: [0.5, 1],
+  "bottom-right": [1, 1]
+};
+function isTransformAnchor(value) {
+  return typeof value === "string" && value in ANCHOR_FRACTION;
 }
-function deserializePatterns(raw, problems = []) {
-  if (!Array.isArray(raw)) return [];
-  const out = [];
-  for (const p of raw) {
-    if (!p || typeof p !== "object" || typeof p.id !== "string" || typeof p.png !== "string") continue;
-    try {
-      const png = decodePngDataUrl(p.png, 4);
-      out.push({ id: p.id, name: typeof p.name === "string" ? p.name : p.id, width: png.width, height: png.height, data: png.data });
-    } catch (e) {
-      problems.push(`Pattern "${p.name ?? p.id}" could not be decoded (${e instanceof Error ? e.message : String(e)}).`);
-    }
-  }
-  return out;
+function identityTransform(box) {
+  return { box: { ...box }, corners: boxQuad(box) };
 }
-var encodedCache = /* @__PURE__ */ new WeakMap();
-function encodeSurface(surface) {
-  if (encodedCache.has(surface)) return encodedCache.get(surface);
-  const b = contentBounds(surface);
-  let out = null;
-  if (b) {
-    const data = readRegion(surface, b);
-    out = { url: pngDataUrl(b.width, b.height, data, surface.channels), x: b.x, y: b.y };
-  }
-  encodedCache.set(surface, out);
-  return out;
+function cornersFromMatrix(box, m) {
+  const q2 = boxQuad(box);
+  return [applyMatrix(m, q2[0]), applyMatrix(m, q2[1]), applyMatrix(m, q2[2]), applyMatrix(m, q2[3])];
 }
-function baseFields(layer, ctx) {
-  const out = {
-    id: layer.id,
-    name: layer.name,
-    visible: layer.visible,
-    opacity: layer.opacity,
-    blend: layer.blend
-  };
-  if (layer.clipped) out.clipped = true;
-  if (layer.mask) out.mask = serializeMask(layer.mask, `${layer.id}-mask`, ctx);
-  if (layer.locks && Object.values(layer.locks).some(Boolean)) out.locks = { ...layer.locks };
-  if (layer.effects) out.effects = serializeEffects(layer.effects);
-  return out;
+function matrixFromCorners(box, corners, eps = 1e-6) {
+  const [tl, tr, br, bl] = corners;
+  const size = 1 + Math.max(box.width, box.height);
+  if (Math.abs(tl.x + br.x - tr.x - bl.x) > eps * size || Math.abs(tl.y + br.y - tr.y - bl.y) > eps * size) return null;
+  const h = rectToQuad(box, corners);
+  return h ? affineFromHomography(h, 1e-9) : null;
 }
-function serializeEffects(effects) {
-  const out = { enabled: effects.enabled, items: JSON.parse(JSON.stringify(effects.items)) };
-  if (effects.scale !== void 0 && effects.scale !== 1) out.scale = effects.scale;
-  if (effects.psd) out.psd = { key: effects.psd.key, data: bytesToBase64(effects.psd.data) };
-  return out;
+function transformHomography(geometry) {
+  const h = rectToQuad(geometry.box, geometry.corners);
+  if (!h) return null;
+  return homographyKeepsQuad(h, boxQuad(geometry.box)) ? h : null;
 }
-function deserializeEffects(raw) {
-  if (!raw || typeof raw !== "object") return void 0;
-  const r = raw;
-  let psd;
-  const p = r.psd;
-  if (p && typeof p.key === "string" && typeof p.data === "string") {
-    try {
-      psd = { key: p.key, data: base64ToBytes(p.data) };
-    } catch {
-      psd = void 0;
-    }
-  }
-  return normalizeLayerEffects({ ...r, psd });
+function hasWarp(geometry) {
+  const w = geometry.warp;
+  if (!w) return false;
+  const id = identityWarpMesh(geometry.box, w.us.length - 1, w.vs.length - 1);
+  if (id.points.length !== w.points.length || id.us.some((u, i) => Math.abs(u - w.us[i]) > 1e-12) || id.vs.some((v, i) => Math.abs(v - w.vs[i]) > 1e-12)) return true;
+  return w.points.some((p, i) => Math.abs(p.x - id.points[i].x) > 1e-6 || Math.abs(p.y - id.points[i].y) > 1e-6);
 }
-function serializeMask(mask, hint, ctx) {
-  const out = { defaultValue: mask.defaultValue };
-  if (!mask.source) {
-    const enc = encodeSurface(mask.surface);
-    if (enc) {
-      out.asset = ctx.addAsset(enc.url, hint);
-      out.x = enc.x;
-      out.y = enc.y;
-    }
-  } else {
-    out.source = { ...mask.source, depthRange: [...mask.source.depthRange] };
-  }
-  if (mask.density !== void 0 && mask.density !== 1) out.density = mask.density;
-  if (mask.feather) out.feather = mask.feather;
-  if (mask.enabled === false) out.enabled = false;
-  if (mask.linked === false) out.linked = false;
-  return out;
+function isIdentityTransform(geometry) {
+  if (hasWarp(geometry)) return false;
+  const q2 = boxQuad(geometry.box);
+  return geometry.corners.every((c, i) => Math.abs(c.x - q2[i].x) < 1e-6 && Math.abs(c.y - q2[i].y) < 1e-6);
 }
-function serializeLayer(layer, ctx) {
-  const base = baseFields(layer, ctx);
-  switch (layer.type) {
-    case "pixel": {
-      const out = { ...base, type: "pixel", offset: { ...layer.offset } };
-      if (layer.source === "document") out.source = "document";
-      else {
-        const enc = encodeSurface(layer.surface);
-        if (enc) {
-          out.asset = ctx.addAsset(enc.url, layer.id);
-          out.x = enc.x;
-          out.y = enc.y;
-        }
-      }
-      if (layer.fillOpacity !== void 0 && layer.fillOpacity !== 1) out.fillOpacity = layer.fillOpacity;
-      if (layer.filters?.length) out.filters = JSON.parse(JSON.stringify(layer.filters));
-      return out;
-    }
-    case "adjustment":
-      return { ...base, type: "adjustment", kind: layer.kind, params: JSON.parse(JSON.stringify(layer.params)) };
-    case "group": {
-      const out = { ...base, type: "group", children: layer.children.map((c) => serializeLayer(c, ctx)) };
-      if (layer.collapsed) out.collapsed = true;
-      return out;
-    }
-    case "annotation":
-      return { ...base, type: "annotation", annotation: JSON.parse(JSON.stringify(layer.annotation)) };
-  }
+function transformMap(geometry) {
+  const h = transformHomography(geometry);
+  if (!h) return null;
+  const { box } = geometry;
+  const warp = hasWarp(geometry) ? geometry.warp : null;
+  if (!warp) return (p) => applyHomography(h, p);
+  return (p) => applyHomography(h, evalWarpMesh(warp, (p.x - box.x) / box.width, (p.y - box.y) / box.height));
 }
-function serializeLayers(layers) {
-  const assets = {};
-  const ctx = {
-    addAsset(url, hint) {
-      let id = hint;
-      for (let n = 2; id in assets && assets[id] !== url; n++) id = `${hint}-${n}`;
-      assets[id] = url;
-      return id;
-    }
-  };
-  return { layers: layers.map((l) => serializeLayer(l, ctx)), assets };
+function transformedPoint(geometry, fx, fy) {
+  const f = transformMap(geometry);
+  const { box } = geometry;
+  return f ? f({ x: box.x + fx * box.width, y: box.y + fy * box.height }) : null;
 }
-var externalRefs = /* @__PURE__ */ new WeakMap();
-async function serializeLayersExternal(layers, store) {
-  const inline = serializeLayers(layers);
-  let refs = externalRefs.get(store);
-  if (!refs) {
-    refs = /* @__PURE__ */ new Map();
-    externalRefs.set(store, refs);
-  }
-  const assets = {};
-  for (const [id, url] of Object.entries(inline.assets)) {
-    let ref = refs.get(url);
-    if (!ref) {
-      const parsed = parseDataUrl(url);
-      const png = decodePngHeader(parsed.bytes);
-      ref = await store.put(new Blob([parsed.bytes], { type: "image/png" }), { id, width: png.width, height: png.height });
-      if (typeof ref !== "string" || !ref) throw new Error(`The asset store returned no reference for "${id}".`);
-      refs.set(url, ref);
+function anchorPoint(geometry, anchor) {
+  const [fx, fy] = ANCHOR_FRACTION[anchor];
+  const h = rectToQuad(geometry.box, geometry.corners);
+  const p = { x: geometry.box.x + fx * geometry.box.width, y: geometry.box.y + fy * geometry.box.height };
+  return (h && applyHomography(h, p)) ?? p;
+}
+function transformedBox(geometry) {
+  const f = transformMap(geometry);
+  if (!f) return null;
+  const { box } = geometry;
+  const pts = [];
+  const n = hasWarp(geometry) ? 16 : 1;
+  for (let i = 0; i <= n; i++) {
+    const t = i / n;
+    for (const [fx, fy] of [[t, 0], [1, t], [1 - t, 1], [0, 1 - t]]) {
+      const p = f({ x: box.x + fx * box.width, y: box.y + fy * box.height });
+      if (!p) return null;
+      pts.push(p);
     }
-    assets[id] = ref;
   }
-  return { layers: inline.layers, assets };
+  const xs = pts.map((p) => p.x);
+  const ys = pts.map((p) => p.y);
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
 }
-function decodePngHeader(bytes) {
-  const u32 = (o) => (bytes[o] << 24 | bytes[o + 1] << 16 | bytes[o + 2] << 8 | bytes[o + 3]) >>> 0;
-  return { width: u32(16), height: u32(20) };
+function referencePoint(box, reference) {
+  if (reference && typeof reference === "object") return { x: reference.x, y: reference.y };
+  const [fx, fy] = ANCHOR_FRACTION[reference ?? "center"];
+  return { x: box.x + fx * box.width, y: box.y + fy * box.height };
 }
-async function resolveExternalAssets(assets, store, problems) {
-  const out = {};
-  for (const [id, ref] of Object.entries(assets)) {
-    if (ref.startsWith("data:")) {
-      out[id] = ref;
-      continue;
-    }
-    if (!store) {
-      problems.push(`Asset "${id}" is external (${ref}) and no asset store was given.`);
-      continue;
-    }
-    try {
-      const blob = await store.get(ref);
-      const bytes = new Uint8Array(await blob.arrayBuffer());
-      out[id] = `data:image/png;base64,${bytesToBase64(bytes)}`;
-    } catch (err) {
-      problems.push(`Asset "${id}" (${ref}) could not be fetched: ${err.message}`);
-    }
-  }
-  return out;
+function matrixFromParams(box, params) {
+  const sx = (params.scaleX ?? 100) / 100;
+  const sy = (params.scaleY ?? 100) / 100;
+  const tx = Math.tan((params.skewX ?? 0) * Math.PI / 180);
+  const ty = Math.tan((params.skewY ?? 0) * Math.PI / 180);
+  const ref = referencePoint(box, params.reference);
+  const linear = multiplyMatrices(multiplyMatrices([1, ty, tx, 1, 0, 0], [sx, 0, 0, sy, 0, 0]), rotateMatrix(params.rotate ?? 0));
+  return multiplyMatrices(matrixAbout(linear, ref), translateMatrix(params.dx ?? 0, params.dy ?? 0));
 }
-function decodePngDataUrl(url, channels) {
-  const parsed = parseDataUrl(url);
-  if (!parsed) throw new Error("Asset is not a data URL.");
-  const png = decodePng(parsed.bytes, { keepGray: channels === 1 });
-  if (png.channels === channels) return png;
-  if (channels === 1) {
-    const out2 = new Uint8ClampedArray(png.width * png.height);
-    for (let i = 0, p = 0; p < out2.length; i += 4, p++) {
-      out2[p] = Math.round((0.299 * png.data[i] + 0.587 * png.data[i + 1] + 0.114 * png.data[i + 2]) * png.data[i + 3] / 255);
-    }
-    return { width: png.width, height: png.height, data: out2 };
-  }
-  const out = new Uint8ClampedArray(png.width * png.height * 4);
-  for (let p = 0; p < png.width * png.height; p++) {
-    out[p * 4] = out[p * 4 + 1] = out[p * 4 + 2] = png.data[p];
-    out[p * 4 + 3] = 255;
+function describeTransform(geometry, reference = "center") {
+  const m = hasWarp(geometry) ? null : matrixFromCorners(geometry.box, geometry.corners);
+  const ref = referencePoint(geometry.box, reference);
+  const bounds = transformedBox(geometry);
+  if (!m) {
+    const h = rectToQuad(geometry.box, geometry.corners);
+    const at2 = (h && applyHomography(h, ref)) ?? ref;
+    return { affine: false, scaleX: 100, scaleY: 100, rotate: 0, skewX: 0, x: at2.x, y: at2.y, bounds, corners: geometry.corners };
   }
-  return { width: png.width, height: png.height, data: out };
+  const [a, b, c, d] = m;
+  const sxAbs = Math.hypot(a, b);
+  const rot = Math.atan2(b, a) * 180 / Math.PI;
+  const shear = sxAbs ? (a * c + b * d) / sxAbs : 0;
+  const sy = sxAbs ? (a * d - b * c) / sxAbs : 0;
+  const skew = sxAbs ? Math.atan(shear / sxAbs) * 180 / Math.PI : 0;
+  const at = applyMatrix(m, ref);
+  const clean = (v) => Math.abs(v) < 1e-9 ? 0 : v;
+  return {
+    affine: true,
+    scaleX: clean(sxAbs * 100),
+    scaleY: clean(sy * 100),
+    rotate: clean(rot === -180 ? 180 : rot),
+    skewX: clean(skew),
+    x: at.x,
+    y: at.y,
+    bounds,
+    corners: geometry.corners
+  };
 }
-var num = (v, lo, hi, fallback) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : fallback;
-function readSurface(ref, x, y, channels, defaultValue, ctx, what) {
-  if (typeof ref !== "string" || !ref) return emptySurface(channels, defaultValue);
-  const url = ctx.assets[ref];
-  if (typeof url !== "string") {
-    ctx.problems.push(`${what}: asset "${ref}" is missing`);
-    return emptySurface(channels, defaultValue);
-  }
-  try {
-    const px2 = (ctx.decodeAsset ?? decodePngDataUrl)(url, channels);
-    return surfaceFromPixels(px2, channels, Math.round(num(x, -1e7, 1e7, 0)), Math.round(num(y, -1e7, 1e7, 0)), defaultValue);
-  } catch (err) {
-    ctx.problems.push(`${what}: asset "${ref}" could not be decoded (${err.message})`);
-    return emptySurface(channels, defaultValue);
-  }
+function applyParams(geometry, params) {
+  const ref = params.reference && typeof params.reference === "object" ? params.reference : anchorPoint(geometry, params.reference ?? "center");
+  const m = matrixFromParams({ x: ref.x, y: ref.y, width: 0, height: 0 }, { ...params, reference: ref });
+  const c = geometry.corners;
+  return [applyMatrix(m, c[0]), applyMatrix(m, c[1]), applyMatrix(m, c[2]), applyMatrix(m, c[3])];
 }
-function readMask(raw, ctx, what) {
-  if (!raw || typeof raw !== "object") return void 0;
-  const r = raw;
-  const defaultValue = r.defaultValue === 255 ? 255 : 0;
-  const mask = {
-    surface: r.source ? emptySurface(1, 255) : readSurface(r.asset, r.x, r.y, 1, defaultValue, ctx, `${what} mask`),
-    defaultValue: r.source ? 255 : defaultValue
-  };
-  if (typeof r.density === "number" && r.density !== 1) mask.density = num(r.density, 0, 1, 1);
-  if (typeof r.feather === "number" && r.feather > 0) mask.feather = num(r.feather, 0, 1e3, 0);
-  if (r.enabled === false) mask.enabled = false;
-  if (r.linked === false) mask.linked = false;
-  if (r.source && typeof r.source === "object") {
-    const s = { ...DEFAULT_DEPTH_MASK_VALUES, ...r.source };
-    mask.source = { ...s, depthRange: [...s.depthRange] };
-  }
-  return mask;
+function flipCorners(geometry, axis) {
+  const c = anchorPoint(geometry, "center");
+  const m = axis === "horizontal" ? [-1, 0, 0, 1, 2 * c.x, 0] : [1, 0, 0, -1, 0, 2 * c.y];
+  const q2 = geometry.corners;
+  return [applyMatrix(m, q2[0]), applyMatrix(m, q2[1]), applyMatrix(m, q2[2]), applyMatrix(m, q2[3])];
 }
-function readFilters(raw) {
-  if (!Array.isArray(raw)) return void 0;
-  const out = [];
-  for (const f of raw) {
-    if (!f || typeof f !== "object") continue;
-    const r = f;
-    const id = typeof r.id === "string" && r.id ? r.id : newLayerId("flt");
-    const enabled = r.enabled !== false;
-    if (r.kind === "blur") out.push({ id, kind: "blur", enabled, radius: num(r.radius, 0, 50, 0) });
-    else if (r.kind === "develop") {
-      out.push({
-        id,
-        kind: "develop",
-        enabled,
-        brightness: num(r.brightness, -100, 100, 0),
-        contrast: num(r.contrast, -100, 100, 0),
-        saturation: num(r.saturation, -100, 100, 0),
-        exposure: num(r.exposure, -100, 100, 0),
-        temperature: num(r.temperature, -100, 100, 0),
-        tint: num(r.tint, -100, 100, 0),
-        process: normalizeProcessVersion(r.process)
-      });
-    }
-  }
-  return out.length ? out : void 0;
+function boxPointOf(geometry, p) {
+  const m = matrixFromCorners(geometry.box, geometry.corners);
+  if (m) return applyMatrix(invertMatrix(m), p);
+  return null;
 }
-function deserializeLayer(raw, ctx) {
-  if (!raw || typeof raw !== "object") return null;
-  const r = raw;
-  const id = typeof r.id === "string" && r.id ? r.id : newLayerId();
-  const base = {
-    id,
-    name: typeof r.name === "string" ? r.name : "",
-    visible: r.visible !== false,
-    opacity: num(r.opacity, 0, 1, 1),
-    blend: normalizeBlendMode(r.blend)
-  };
-  if (r.clipped === true) base.clipped = true;
-  const mask = readMask(r.mask, ctx, `Layer "${base.name || id}"`);
-  if (mask) base.mask = mask;
-  if (r.locks && typeof r.locks === "object") {
-    const locks = {};
-    for (const k of ["pixels", "transparency", "position", "all"]) if (r.locks[k] === true) locks[k] = true;
-    if (Object.keys(locks).length) base.locks = locks;
-  }
-  const effects = deserializeEffects(r.effects);
-  if (effects && r.type !== "adjustment") base.effects = effects;
-  switch (r.type) {
-    case "pixel": {
-      const layer = {
-        ...base,
-        type: "pixel",
-        surface: r.source === "document" ? emptySurface(4) : readSurface(r.asset, r.x, r.y, 4, 0, ctx, `Layer "${base.name || id}"`),
-        offset: { x: Math.round(num(r.offset?.x, -1e7, 1e7, 0)), y: Math.round(num(r.offset?.y, -1e7, 1e7, 0)) }
-      };
-      if (r.source === "document") layer.source = "document";
-      if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num(r.fillOpacity, 0, 1, 1);
-      const filters = readFilters(r.filters);
-      if (filters) layer.filters = filters;
-      return layer;
-    }
-    case "adjustment": {
-      const norm = normalizeAdjustmentLayer({ id, kind: r.kind, params: r.params });
-      if (!norm) {
-        ctx.problems.push(`Layer "${base.name || id}": unknown adjustment kind "${r.kind}"`);
-        return null;
-      }
-      return { ...base, type: "adjustment", kind: norm.kind, params: norm.params };
-    }
-    case "group": {
-      const children = Array.isArray(r.children) ? r.children.map((c) => deserializeLayer(c, ctx)).filter(Boolean) : [];
-      const blend = r.blend === "pass-through" ? "pass-through" : isBlendMode(r.blend) ? r.blend : "pass-through";
-      const group = { ...base, type: "group", blend, children };
-      if (r.collapsed === true) group.collapsed = true;
-      return group;
-    }
-    case "annotation": {
-      const a = r.annotation;
-      if (!a || typeof a !== "object" || typeof a.type !== "string") {
-        ctx.problems.push(`Layer "${base.name || id}": annotation is missing`);
-        return null;
-      }
-      return { ...base, type: "annotation", annotation: JSON.parse(JSON.stringify({ ...a, id: typeof a.id === "string" ? a.id : id })) };
-    }
-    default:
-      ctx.problems.push(`Layer "${base.name || id}": unknown layer type "${r.type}"`);
-      return null;
-  }
+function presetWarp(box, preset) {
+  return warpPresetMesh(preset, box);
 }
-function deserializeLayers(raw, ctx) {
-  if (!Array.isArray(raw)) return [];
-  const seen = /* @__PURE__ */ new Set();
-  const dedupe = (list2) => list2.map((l) => {
-    let next = l;
-    if (seen.has(l.id)) next = { ...l, id: newLayerId() };
-    seen.add(next.id);
-    if (next.type === "group") next = { ...next, children: dedupe(next.children) };
-    return next;
-  });
-  return dedupe(raw.map((l) => deserializeLayer(l, ctx)).filter(Boolean));
+function isValidWarp(mesh) {
+  return isValidWarpMesh(mesh);
+}
+function geometryHomography(geometry) {
+  const m = matrixFromCorners(geometry.box, geometry.corners);
+  return m ? homographyFromAffine(m) : transformHomography(geometry);
 }
 
 // src/image-editor/layers/ops.ts
@@ -4991,6 +4834,10 @@ function withNewIds(layer) {
   const next = { ...layer, id: newLayerId(layer.type === "adjustment" ? "adj" : layer.type) };
   if (next.type === "group") next.children = next.children.map(withNewIds);
   if (next.type === "annotation") next.annotation = { ...next.annotation, id: next.id };
+  if (next.type === "smart" && next.psd?.placed) {
+    next.psd = { ...next.psd };
+    delete next.psd.placed;
+  }
   return next;
 }
 function duplicateLayer(layers, id, name) {
@@ -5016,7 +4863,7 @@ function setLayerProperties(layers, id, props) {
     next.opacity = props.opacity;
   }
   if (props.fillOpacity !== void 0) {
-    if (layer.type !== "pixel") fail(`fillOpacity applies to pixel layers; "${id}" is a ${layer.type} layer.`);
+    if (layer.type !== "pixel" && layer.type !== "smart") fail(`fillOpacity applies to pixel layers and smart objects; "${id}" is a ${layer.type} layer.`);
     if (!(typeof props.fillOpacity === "number" && props.fillOpacity >= 0 && props.fillOpacity <= 1)) fail("fillOpacity must be a number from 0 to 1.");
     const p = next;
     if (props.fillOpacity === 1) delete p.fillOpacity;
@@ -5165,89 +5012,1198 @@ function removeLayerFilter(layers, id, filterId) {
   else delete next.filters;
   return mapLayer(layers, id, () => next);
 }
-function requireEffectLayer(layers, id, action) {
-  const layer = requireLayer(layers, id).layer;
-  if (layer.type === "adjustment") fail(`Layer "${layer.name || id}" is an adjustment layer; effects go on pixel, annotation and group layers.`);
-  requireUnlocked(layer, "all", action);
-  return layer;
+function requireEffectLayer(layers, id, action) {
+  const layer = requireLayer(layers, id).layer;
+  if (layer.type === "adjustment") fail(`Layer "${layer.name || id}" is an adjustment layer; effects go on pixel, annotation and group layers.`);
+  requireUnlocked(layer, "all", action);
+  return layer;
+}
+function layerEffectsOf(layer) {
+  return layer.effects ?? { enabled: true, items: [] };
+}
+function guard(fn) {
+  try {
+    return fn();
+  } catch (e) {
+    if (e instanceof LayerEffectError) fail(e.message);
+    throw e;
+  }
+}
+function setLayerEffects(layers, id, effects) {
+  const layer = requireEffectLayer(layers, id, "change its effects");
+  const next = { ...layer };
+  if (effects && (effects.items.length || effects.psd || effects.scale !== void 0 || !effects.enabled)) {
+    guard(() => validateLayerEffects(effects));
+    next.effects = effects;
+  } else delete next.effects;
+  return mapLayer(layers, id, () => next);
+}
+function addLayerEffect(layers, id, kind, params = {}, index) {
+  if (!isLayerEffectKind(kind)) fail(`Unknown effect kind "${String(kind)}". Kinds: ${LAYER_EFFECT_KINDS.join(", ")}.`);
+  const layer = requireEffectLayer(layers, id, "add effects");
+  const current = layerEffectsOf(layer);
+  const ids = new Set(current.items.map((e) => e.id));
+  let effectId = newEffectId();
+  while (ids.has(effectId)) effectId = newEffectId();
+  const { id: _ignored, kind: _kind, ...rest } = params;
+  const effect = guard(() => mergeLayerEffect(defaultLayerEffect(kind, effectId), rest));
+  const items = [...current.items];
+  const at = index === void 0 ? items.length : Math.max(0, Math.min(items.length, Math.floor(index)));
+  items.splice(at, 0, effect);
+  return { layers: setLayerEffects(layers, id, { ...current, items }), effect };
+}
+function requireEffect(layer, effectId) {
+  const items = layer.effects?.items ?? [];
+  const i = items.findIndex((e) => e.id === effectId);
+  if (i === -1) fail(`Layer "${layer.name || layer.id}" has no effect "${effectId}". Effects: ${items.map((e) => `${e.id} (${e.kind})`).join(", ") || "none"}; call list_layer_effects.`);
+  return i;
+}
+function updateLayerEffect(layers, id, effectId, changes) {
+  const layer = requireEffectLayer(layers, id, "change its effects");
+  const i = requireEffect(layer, effectId);
+  const current = layer.effects;
+  const items = [...current.items];
+  items[i] = guard(() => mergeLayerEffect(items[i], changes));
+  return setLayerEffects(layers, id, { ...current, items });
+}
+function removeLayerEffect(layers, id, effectId) {
+  const layer = requireEffectLayer(layers, id, "change its effects");
+  requireEffect(layer, effectId);
+  const current = layer.effects;
+  return setLayerEffects(layers, id, { ...current, items: current.items.filter((e) => e.id !== effectId) });
+}
+function setLayerEffectsEnabled(layers, id, enabled, scale) {
+  const layer = requireEffectLayer(layers, id, "change its effects");
+  if (scale !== void 0 && !(Number.isFinite(scale) && scale >= 0.01 && scale <= 10)) fail(`scale must be from 0.01 to 10 (1 = 100 %), got ${scale}.`);
+  const current = layerEffectsOf(layer);
+  const next = { ...current, enabled };
+  if (scale !== void 0) {
+    if (scale === 1) delete next.scale;
+    else next.scale = scale;
+  }
+  return setLayerEffects(layers, id, next);
+}
+function parseBlend(value, allowPassThrough = false) {
+  if (value === void 0) return void 0;
+  if (value === "pass-through" && allowPassThrough) return value;
+  if (!isBlendMode(value)) fail(`Unknown blend mode "${String(value)}".`);
+  return value;
+}
+function unionRect(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+
+// src/image-editor/layers/smart.ts
+var fail2 = (message) => {
+  throw new LayerOperationError(message);
+};
+var SMART_RENDER_MARGIN = MAX_EFFECT_REACH;
+function newContentsId() {
+  return newLayerId("so");
+}
+function contentsBox(contents) {
+  return { x: 0, y: 0, width: contents.width, height: contents.height };
+}
+function placementGeometry(layer) {
+  return { box: contentsBox(layer.contents), corners: layer.placement.corners, warp: layer.placement.warp ?? null };
+}
+function placementAt(contents, x, y) {
+  return { corners: boxQuad({ x, y, width: contents.width, height: contents.height }) };
+}
+function isContentsDecoded(contents) {
+  return contents.kind === "raster" ? Boolean(contents.raster) : Boolean(contents.document);
+}
+function requireDecoded(layer, action) {
+  if (isContentsDecoded(layer.contents)) return;
+  const what = layer.contents.file?.type ? `a ${layer.contents.file.type.toUpperCase()} file` : "a file";
+  fail2(
+    `The contents of smart object "${layer.name || layer.id}" are ${what} that could not be decoded here, so it cannot ${action}. Run prepareSmartObjects() in a browser first, or rasterize it.`
+  );
+}
+function requireSmartObject(layers, id) {
+  const layer = requireLayer(layers, id).layer;
+  if (layer.type !== "smart") fail2(`Layer "${layer.name || id}" is a ${layer.type} layer, not a smart object; convert it with convert_to_smart_object.`);
+  return layer;
+}
+var contentsPixels = /* @__PURE__ */ new WeakMap();
+function contentsSurface(contents) {
+  let s = contentsPixels.get(contents);
+  if (s) return s;
+  if (contents.kind === "raster") {
+    s = contents.raster ?? emptySurface(4);
+  } else {
+    const doc = contents.document;
+    if (!doc) return emptySurface(4);
+    const W = contents.width;
+    const H = contents.height;
+    const data = new LayerCompositor().composite(doc.layers, { x: 0, y: 0, width: W, height: H }, {
+      width: W,
+      height: H,
+      globalLight: doc.globalLight,
+      pattern: (id) => doc.patterns?.find((p) => p.id === id) ?? null
+    });
+    s = surfaceFromPixels({ width: W, height: H, data }, 4, 0, 0);
+  }
+  contentsPixels.set(contents, s);
+  return s;
+}
+function rasterContents(pixels, name, id = newContentsId()) {
+  if (!(pixels.width > 0 && pixels.height > 0) || pixels.data.length < pixels.width * pixels.height * 4) fail2("Contents pixels must be RGBA with width \xD7 height \xD7 4 bytes.");
+  return { id, name, width: pixels.width, height: pixels.height, kind: "raster", raster: surfaceFromPixels(pixels, 4, 0, 0) };
+}
+function documentContents(document2, width, height, name, id = newContentsId()) {
+  if (!(Number.isInteger(width) && Number.isInteger(height) && width > 0 && height > 0)) fail2("Contents width and height must be positive whole numbers.");
+  return { id, name, width, height, kind: "document", document: document2 };
+}
+var placedCache = /* @__PURE__ */ new WeakMap();
+var filteredCache = /* @__PURE__ */ new WeakMap();
+function placementKey(p, canvas) {
+  return JSON.stringify([p.corners, p.warp ?? null, p.interpolation ?? "bicubic", canvas.width, canvas.height]);
+}
+function integerMove(layer) {
+  const g = placementGeometry(layer);
+  if (hasWarp(g)) return null;
+  const q2 = boxQuad(g.box);
+  const dx = g.corners[0].x - q2[0].x;
+  const dy = g.corners[0].y - q2[0].y;
+  if (Math.abs(dx - Math.round(dx)) > 1e-9 || Math.abs(dy - Math.round(dy)) > 1e-9) return null;
+  const same = g.corners.every((c, i) => Math.abs(c.x - q2[i].x - dx) < 1e-9 && Math.abs(c.y - q2[i].y - dy) < 1e-9);
+  return same ? { x: Math.round(dx), y: Math.round(dy) } : null;
+}
+function placeContents(layer, canvas, options = {}) {
+  const { contents, placement } = layer;
+  const preview = Boolean(options.step && options.step > 1) || Boolean(options.clip);
+  const key = placementKey(placement, canvas);
+  if (!preview) {
+    const hit = placedCache.get(contents)?.get(key);
+    if (hit) return hit;
+  }
+  const src = contentsSurface(contents);
+  const m = SMART_RENDER_MARGIN;
+  const area = { x: -m, y: -m, width: canvas.width + 2 * m, height: canvas.height + 2 * m };
+  let clip = area;
+  if (options.clip) {
+    const c = options.clip;
+    const x0 = Math.max(area.x, Math.floor(c.x));
+    const y0 = Math.max(area.y, Math.floor(c.y));
+    const x1 = Math.min(area.x + area.width, Math.ceil(c.x + c.width));
+    const y1 = Math.min(area.y + area.height, Math.ceil(c.y + c.height));
+    clip = { x: x0, y: y0, width: Math.max(0, x1 - x0), height: Math.max(0, y1 - y0) };
+  }
+  let out;
+  const move = integerMove(layer);
+  if (move && !options.clip) {
+    out = translateSurface(src, move.x, move.y);
+  } else {
+    const g = placementGeometry(layer);
+    const interpolation = preview ? placement.interpolation === "nearest" ? "nearest" : "bilinear" : placement.interpolation ?? "bicubic";
+    const step = options.step && options.step > 1 ? options.step : 1;
+    let source = src;
+    let k = 1;
+    if (step > 1) {
+      k = step;
+      let r = options.reduced?.get(k);
+      if (!r) {
+        r = reduceSurface(src, k);
+        options.reduced?.set(k, r);
+      }
+      source = r;
+    }
+    const box = { x: 0, y: 0, width: Math.ceil(contents.width / k), height: Math.ceil(contents.height / k) };
+    try {
+      if (hasWarp(g)) {
+        const f = transformMap(g);
+        if (!f) fail2("The placement folds the contents over itself or through the horizon; keep the corners a convex quad.");
+        out = warpSurface(source, (p) => f({ x: p.x * k, y: p.y * k }), { interpolation, source: box, clip, step: step > 1 ? step : void 0 });
+      } else {
+        const h = transformHomography(g);
+        if (!h) fail2("The placement folds the contents over itself or through the horizon; keep the corners a convex quad.");
+        const hk = multiplyHomographies([k, 0, 0, 0, k, 0, 0, 0, 1], h);
+        out = transformSurface(source, hk, { interpolation, source: box, clip, step: step > 1 ? step : void 0 });
+      }
+    } catch (e) {
+      if (e instanceof TransformTooLargeError) fail2(e.message);
+      throw e;
+    }
+  }
+  if (!preview) {
+    let byKey = placedCache.get(contents);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      placedCache.set(contents, byKey);
+    }
+    byKey.set(key, out);
+    while (byKey.size > 4) byKey.delete(byKey.keys().next().value);
+  }
+  return out;
+}
+function activeSmartFilters(stack) {
+  if (!stack?.enabled) return [];
+  return stack.filters.filter((f) => f.kind !== "psd" && isActiveFilter(f) && f.opacity > 0);
+}
+function filterMaskCoverage(mask, canvas) {
+  if (!mask || mask.enabled === false || mask.source) return null;
+  const W = canvas.width;
+  const H = canvas.height;
+  const bytes = readRegion(mask.surface, { x: 0, y: 0, width: W, height: H });
+  let v = new Float32Array(W * H);
+  let all = true;
+  for (let i = 0; i < v.length; i++) {
+    v[i] = bytes[i] / 255;
+    if (bytes[i] !== 255) all = false;
+  }
+  const feather = mask.feather ?? 0;
+  if (all && !(feather > 0)) return null;
+  if (feather > 0) v = gaussianBlur(v, W, H, feather, "clamp");
+  const density = mask.density ?? 1;
+  if (density !== 1) for (let i = 0; i < v.length; i++) v[i] = 1 - density * (1 - v[i]);
+  return v;
+}
+function applySmartFilters(placed, stack, canvas) {
+  const active = activeSmartFilters(stack);
+  if (!active.length || !(canvas.width > 0 && canvas.height > 0)) return placed;
+  const W = canvas.width;
+  const H = canvas.height;
+  const key = JSON.stringify([W, H, active.map((f) => ({ ...f, id: void 0 }))]);
+  let entry = filteredCache.get(placed);
+  if (!entry || entry.key !== key) {
+    const base = readRegion(placed, { x: 0, y: 0, width: W, height: H });
+    let acc = new Uint8ClampedArray(base);
+    for (const f of active) {
+      const out = new Uint8ClampedArray(acc);
+      runLayerFilters(out, W, H, [f]);
+      if (f.blend === "normal") {
+        if (f.opacity >= 1) acc = out;
+        else lerpInto(acc, out, f.opacity, null);
+      } else {
+        blendTile(acc, out, f.blend, f.opacity, null);
+      }
+    }
+    entry = { key, base, filtered: acc };
+    filteredCache.set(placed, entry);
+  }
+  const cov = filterMaskCoverage(stack.mask, canvas);
+  let result = entry.filtered;
+  if (cov) {
+    result = new Uint8ClampedArray(entry.base);
+    lerpInto(result, entry.filtered, 1, cov);
+  }
+  return surfaceFromPixels({ width: W, height: H, data: result }, 4, 0, 0);
+}
+function lerpInto(dst, src, k, coverage) {
+  for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
+    const t = coverage ? k * coverage[p] : k;
+    if (t <= 0) continue;
+    if (t >= 1) {
+      dst[i] = src[i];
+      dst[i + 1] = src[i + 1];
+      dst[i + 2] = src[i + 2];
+      dst[i + 3] = src[i + 3];
+      continue;
+    }
+    for (let c = 0; c < 4; c++) dst[i + c] = Math.round(dst[i + c] + (src[i + c] - dst[i + c]) * t);
+  }
+}
+function renderSmartObject(layer, canvas, options = {}) {
+  const placed = placeContents(layer, canvas, options);
+  return options.skipFilters ? placed : applySmartFilters(placed, layer.smartFilters, canvas);
+}
+function rerender(layer, canvas, action = "change") {
+  requireDecoded(layer, action);
+  return { ...layer, surface: renderSmartObject(layer, canvas) };
+}
+function normalizePlacement(raw, contents) {
+  const c = raw?.corners;
+  if (!Array.isArray(c) || c.length !== 4 || !c.every((p) => p && Number.isFinite(p.x) && Number.isFinite(p.y))) {
+    fail2("corners must be four finite points [top-left, top-right, bottom-right, bottom-left] in document pixels.");
+  }
+  const out = { corners: c.map((p) => ({ x: p.x, y: p.y })) };
+  if (raw.warp) {
+    if (!isValidWarpMesh(raw.warp)) fail2("warp must be a mesh with us and vs (knots from 0 to 1, increasing) and (3\xB7columns + 1) \xD7 (3\xB7rows + 1) finite points in contents pixels.");
+    out.warp = { us: [...raw.warp.us], vs: [...raw.warp.vs], points: raw.warp.points.map((p) => ({ x: p.x, y: p.y })) };
+  }
+  if (raw.interpolation !== void 0) {
+    if (!isInterpolation(raw.interpolation)) fail2(`Unknown interpolation "${String(raw.interpolation)}"; use nearest, bilinear or bicubic.`);
+    if (raw.interpolation !== "bicubic") out.interpolation = raw.interpolation;
+  }
+  const g = { box: { x: 0, y: 0, width: contents.width, height: contents.height }, corners: out.corners, warp: out.warp ?? null };
+  if (!transformHomography(g)) fail2("These corners fold the contents over themselves or through the horizon; keep the quad convex.");
+  if (out.warp && !hasWarp(g)) delete out.warp;
+  return out;
+}
+function placementHomography(layer) {
+  const g = placementGeometry(layer);
+  return hasWarp(g) ? null : transformHomography(g);
+}
+function followMask(mask, before, after) {
+  if (!mask || mask.linked === false || mask.source) return mask;
+  const h0 = placementHomography(before);
+  const h1 = placementHomography(after);
+  if (!h0 || !h1) return mask;
+  const inv = invertHomography(h0);
+  if (!inv) return mask;
+  const delta = multiplyHomographies(inv, h1);
+  const surface = transformSurface(mask.surface, delta, { interpolation: "bilinear" });
+  return { ...mask, surface };
+}
+function setSmartPlacement(layers, id, placement, canvas) {
+  const layer = requireSmartObject(layers, id);
+  requireUnlocked(layer, "position", "transform it");
+  requireDecoded(layer, "be transformed");
+  const clean = normalizePlacement(placement, layer.contents);
+  let next = { ...layer, placement: clean };
+  let masksMoved = false;
+  if (layer.mask) {
+    const m = followMask(layer.mask, layer, next);
+    masksMoved ||= m !== layer.mask;
+    next.mask = m;
+  }
+  if (next.smartFilters?.mask) {
+    const m = followMask(next.smartFilters.mask, layer, next);
+    masksMoved ||= m !== next.smartFilters.mask;
+    next.smartFilters = { ...next.smartFilters, mask: m };
+  }
+  next = rerender(next, canvas, "be transformed");
+  return { layers: mapLayer(layers, id, () => next), layer: next, masksMoved };
+}
+function offsetSmartObject(layers, id, dx, dy, canvas) {
+  const layer = requireSmartObject(layers, id);
+  requireUnlocked(layer, "position", "move it");
+  const mx = Math.round(dx);
+  const my = Math.round(dy);
+  if (!mx && !my) return layers;
+  const corners = layer.placement.corners.map((p) => ({ x: p.x + mx, y: p.y + my }));
+  let next = { ...layer, placement: { ...layer.placement, corners } };
+  const moveMask = (m2) => m2 && m2.linked !== false && !m2.source ? { ...m2, surface: translateSurface(m2.surface, mx, my) } : m2;
+  if (layer.mask) next.mask = moveMask(layer.mask);
+  if (layer.smartFilters?.mask) next.smartFilters = { ...layer.smartFilters, mask: moveMask(layer.smartFilters.mask) };
+  const spatial = activeSmartFilters(layer.smartFilters).some((f) => f.kind === "blur");
+  const b = contentBounds(layer.surface);
+  const m = SMART_RENDER_MARGIN;
+  const cut = b && (b.x <= -m || b.y <= -m || b.x + b.width >= canvas.width + m || b.y + b.height >= canvas.height + m);
+  if (!spatial && !cut && !(next.smartFilters?.mask && activeSmartFilters(next.smartFilters).length && next.smartFilters.mask.linked === false)) {
+    next = { ...next, surface: translateSurface(layer.surface, mx, my) };
+  } else {
+    next = rerender(next, canvas, "move");
+  }
+  return mapLayer(layers, id, () => next);
+}
+function translateLayer(layer, dx, dy) {
+  if (!dx && !dy) return layer;
+  const moveMask = (m) => {
+    if (!m) return m;
+    if (m.source) fail2(`Layer "${layer.name || layer.id}" has a depth mask, which cannot move into a smart object; bake or remove it first.`);
+    return { ...m, surface: translateSurface(m.surface, dx, dy) };
+  };
+  switch (layer.type) {
+    case "pixel":
+      return { ...layer, offset: { x: layer.offset.x + dx, y: layer.offset.y + dy } };
+    case "smart": {
+      const next = {
+        ...layer,
+        placement: { ...layer.placement, corners: layer.placement.corners.map((p) => ({ x: p.x + dx, y: p.y + dy })) },
+        surface: translateSurface(layer.surface, dx, dy),
+        mask: moveMask(layer.mask)
+      };
+      if (!next.mask) delete next.mask;
+      if (layer.smartFilters?.mask) next.smartFilters = { ...layer.smartFilters, mask: moveMask(layer.smartFilters.mask) };
+      return next;
+    }
+    case "group": {
+      const next = { ...layer, children: layer.children.map((c) => translateLayer(c, dx, dy)), mask: moveMask(layer.mask) };
+      if (!next.mask) delete next.mask;
+      return next;
+    }
+    case "adjustment": {
+      const next = { ...layer, mask: moveMask(layer.mask) };
+      if (!next.mask) delete next.mask;
+      return next;
+    }
+    case "annotation":
+      return fail2(`Annotation layer "${layer.name || layer.id}" cannot go into a smart object; rasterize it first.`);
+  }
+}
+function layerExtent(layer, surfaceOf, canvas) {
+  const full = { x: 0, y: 0, width: canvas.width, height: canvas.height };
+  let b = null;
+  if (layer.type === "pixel" || layer.type === "smart") {
+    const s = layer.type === "pixel" ? surfaceOf(layer) : layer.surface;
+    if (s.defaultValue !== 0) b = full;
+    else {
+      const c = contentBounds(s);
+      b = c ? { x: c.x + layer.offset.x, y: c.y + layer.offset.y, width: c.width, height: c.height } : null;
+    }
+  } else if (layer.type === "group") {
+    for (const c of layer.children) b = union(b, layerExtent(c, surfaceOf, canvas));
+  } else {
+    b = full;
+  }
+  const m = effectsMargin(layer.effects);
+  if (b && m > 0) b = { x: b.x - Math.ceil(m), y: b.y - Math.ceil(m), width: b.width + 2 * Math.ceil(m), height: b.height + 2 * Math.ceil(m) };
+  return b;
+}
+function union(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+}
+function asSmartFilters(filters) {
+  if (!filters?.length) return void 0;
+  return { enabled: true, filters: filters.map((f) => ({ ...f, blend: "normal", opacity: 1 })) };
+}
+function convertToSmartObject(layers, ids, canvas, options) {
+  if (!ids.length) fail2("Give at least one layer id to convert.");
+  const locs = [...new Set(ids)].map((id) => requireLayer(layers, id));
+  const parent = locs[0].parent?.id ?? null;
+  if (locs.some((l) => (l.parent?.id ?? null) !== parent)) fail2("Layers to convert must share one parent; move them next to each other first.");
+  for (const l of locs) requireUnlocked(l.layer, "all", "convert it");
+  const ordered = locs.sort((a, b) => a.index - b.index);
+  const top = ordered[ordered.length - 1];
+  let smart;
+  const single = ordered.length === 1 ? ordered[0].layer : null;
+  if (single && single.type === "pixel") {
+    const surface = options.surfaceOf(single);
+    if (surface.defaultValue !== 0) fail2(`Layer "${single.name || single.id}" has no transparent area to crop to; it cannot be converted.`);
+    const b = contentBounds(surface);
+    if (!b) fail2(`Layer "${single.name || single.id}" has no pixels to convert; paint something first.`);
+    const contents = {
+      id: newContentsId(),
+      name: `${single.name || "Layer"}.png`,
+      width: b.width,
+      height: b.height,
+      kind: "raster",
+      raster: translateSurface(surface, -b.x, -b.y)
+    };
+    smart = {
+      type: "smart",
+      id: single.id,
+      name: single.name,
+      visible: single.visible,
+      opacity: single.opacity,
+      blend: single.blend,
+      contents,
+      placement: placementAt(contents, b.x + single.offset.x, b.y + single.offset.y),
+      surface: emptySurface(4),
+      offset: { x: 0, y: 0 }
+    };
+    if (single.clipped) smart.clipped = true;
+    if (single.fillOpacity !== void 0) smart.fillOpacity = single.fillOpacity;
+    if (single.effects) smart.effects = single.effects;
+    if (single.mask) {
+      smart.mask = single.mask.source ? single.mask : { ...single.mask, surface: translateSurface(single.mask.surface, single.offset.x, single.offset.y) };
+    }
+    const filters = asSmartFilters(single.filters);
+    if (filters) smart.smartFilters = filters;
+  } else {
+    let b = null;
+    for (const l of ordered) b = union(b, layerExtent(l.layer, options.surfaceOf, canvas));
+    if (!b || !(b.width > 0 && b.height > 0)) fail2("The layers have no pixels to convert; paint something first.");
+    const nested = ordered.map((l) => {
+      let layer = l.layer;
+      if (layer.type === "pixel" && layer.source === "document") {
+        const resolved = { ...layer, surface: options.surfaceOf(layer) };
+        delete resolved.source;
+        layer = resolved;
+      }
+      if (flattenLayers([layer]).some((x) => x.type === "pixel" && x.source === "document")) fail2(`Layer "${layer.name || layer.id}" holds the document image inside a group; convert the Background on its own.`);
+      return translateLayer(layer, -b.x, -b.y);
+    });
+    if (nested[0].clipped) {
+      const first = { ...nested[0] };
+      delete first.clipped;
+      nested[0] = first;
+    }
+    const name = options.name?.trim() || top.layer.name || "Smart Object";
+    const contents = documentContents({ layers: nested }, b.width, b.height, `${name}.psb`);
+    smart = {
+      type: "smart",
+      id: ordered.length === 1 ? ordered[0].layer.id : newLayerId("smart"),
+      name,
+      visible: true,
+      opacity: 1,
+      blend: "normal",
+      contents,
+      placement: placementAt(contents, b.x, b.y),
+      surface: emptySurface(4),
+      offset: { x: 0, y: 0 }
+    };
+  }
+  if (options.name?.trim()) smart.name = options.name.trim();
+  smart = { ...smart, surface: renderSmartObject(smart, canvas) };
+  const below = ordered.filter((l) => l.index < top.index).length;
+  let out = layers;
+  for (const l of ordered) out = mapLayer(out, l.layer.id, () => null);
+  return { layers: insertLayer(out, smart, parent, top.index - below), layer: smart };
+}
+function rasterizeSmartObject(layers, id) {
+  const layer = requireSmartObject(layers, id);
+  requireUnlocked(layer, "all", "rasterize it");
+  const out = {
+    type: "pixel",
+    id: layer.id,
+    name: layer.name,
+    visible: layer.visible,
+    opacity: layer.opacity,
+    blend: layer.blend,
+    surface: layer.surface,
+    offset: { x: 0, y: 0 }
+  };
+  if (layer.clipped) out.clipped = true;
+  if (layer.mask) out.mask = layer.mask;
+  if (layer.locks) out.locks = layer.locks;
+  if (layer.effects) out.effects = layer.effects;
+  if (layer.fillOpacity !== void 0) out.fillOpacity = layer.fillOpacity;
+  return { layers: mapLayer(layers, id, () => out), layer: out };
+}
+function copySmartObject(layers, id, linked, name) {
+  const loc = requireLayer(layers, id);
+  const layer = requireSmartObject(layers, id);
+  const copy = { ...layer, id: newLayerId("smart"), name: name?.trim() || `${layer.name || "Smart Object"} copy` };
+  delete copy.locks;
+  delete copy.psd;
+  if (!linked) copy.contents = { ...layer.contents, id: newContentsId() };
+  if (copy.smartFilters) copy.smartFilters = { ...copy.smartFilters, filters: copy.smartFilters.filters.map((f) => ({ ...f, id: newLayerId("flt") })) };
+  return { layers: insertLayer(layers, copy, loc.parent?.id ?? null, loc.index + 1), layer: copy };
+}
+function instancesOf(layers, contentsId) {
+  return flattenLayers(layers).filter((l) => l.type === "smart" && l.contents.id === contentsId).map((l) => l.id);
+}
+function replaceContents(layers, contentsId, contents, canvas) {
+  const ids = instancesOf(layers, contentsId);
+  if (!ids.length) fail2(`No smart object uses contents "${contentsId}".`);
+  for (const id of ids) requireUnlocked(findLayer(layers, id).layer, "all", "replace its contents");
+  const next = { ...contents, id: contentsId };
+  let out = layers;
+  for (const id of ids) {
+    out = mapLayer(out, id, (l) => {
+      const layer = l;
+      return rerender({ ...layer, contents: next, placement: refitPlacement(layer, next) }, canvas, "take the new contents");
+    });
+  }
+  return { layers: out, ids };
+}
+function refitPlacement(layer, contents) {
+  const W0 = layer.contents.width;
+  const H0 = layer.contents.height;
+  const W1 = contents.width;
+  const H1 = contents.height;
+  if (W0 === W1 && H0 === H1) return layer.placement;
+  const g = placementGeometry(layer);
+  const h = transformHomography(g);
+  if (!h) return placementAt(contents, 0, 0);
+  const shift = [1, 0, (W0 - W1) / 2, 0, 1, (H0 - H1) / 2, 0, 0, 1];
+  const hn = multiplyHomographies(shift, h);
+  const pts = boxQuad({ x: 0, y: 0, width: W1, height: H1 }).map((p) => {
+    const w = hn[6] * p.x + hn[7] * p.y + hn[8];
+    return { x: (hn[0] * p.x + hn[1] * p.y + hn[2]) / w, y: (hn[3] * p.x + hn[4] * p.y + hn[5]) / w };
+  });
+  const out = { corners: pts };
+  if (layer.placement.interpolation) out.interpolation = layer.placement.interpolation;
+  if (layer.placement.warp) out.warp = mapWarpMeshPoints(layer.placement.warp, (p) => ({ x: p.x * W1 / W0, y: p.y * H1 / H0 }));
+  return out;
+}
+function normalizeSmartFilter(raw, id = newLayerId("flt")) {
+  if (raw.kind === "psd") fail2("Photoshop filters can only come from a PSD; add develop or blur.");
+  const base = normalizeFilter(raw, id);
+  const blend = raw.blend ?? "normal";
+  if (!isBlendMode(blend) || blend === "pigment") fail2(`Unknown blend mode "${String(blend)}" for a smart filter.`);
+  const opacity = raw.opacity ?? 1;
+  if (!(typeof opacity === "number" && opacity >= 0 && opacity <= 1)) fail2("opacity must be a number from 0 to 1.");
+  return { ...base, blend, opacity };
+}
+function withStack(layer, stack, canvas) {
+  const next = { ...layer };
+  if (stack && (stack.filters.length || stack.mask || !stack.enabled)) next.smartFilters = stack;
+  else delete next.smartFilters;
+  return rerender(next, canvas, "change its smart filters");
+}
+function stackOf(layer) {
+  return layer.smartFilters ?? { enabled: true, filters: [] };
+}
+function requireFilter(layer, filterId) {
+  const list2 = layer.smartFilters?.filters ?? [];
+  const i = list2.findIndex((f) => f.id === filterId);
+  if (i === -1) fail2(`Smart object "${layer.name || layer.id}" has no smart filter "${filterId}". Filters: ${list2.map((f) => `${f.id} (${f.kind})`).join(", ") || "none"}; call get_smart_object.`);
+  return i;
+}
+function editableSmart(layers, id) {
+  const layer = requireSmartObject(layers, id);
+  requireUnlocked(layer, "all", "change its smart filters");
+  return layer;
+}
+function addSmartFilter(layers, id, filter, canvas, index) {
+  const layer = editableSmart(layers, id);
+  const stack = stackOf(layer);
+  const filters = [...stack.filters];
+  const at = index === void 0 ? filters.length : Math.max(0, Math.min(filters.length, Math.floor(index)));
+  filters.splice(at, 0, filter);
+  const next = withStack(layer, { ...stack, filters }, canvas);
+  return { layers: mapLayer(layers, id, () => next), layer: next, filter };
+}
+function updateSmartFilter(layers, id, filterId, changes, canvas) {
+  const layer = editableSmart(layers, id);
+  const i = requireFilter(layer, filterId);
+  const current = layer.smartFilters.filters[i];
+  if ("kind" in changes && changes.kind !== current.kind) fail2("A smart filter kind cannot change; remove it and add another.");
+  let merged;
+  if (current.kind === "psd") {
+    const extra = Object.keys(changes).filter((k) => !["enabled", "blend", "opacity", "kind"].includes(k));
+    if (extra.length) fail2(`"${current.name}" is a Photoshop filter we keep but do not model; only enabled, blend and opacity change. Unknown: ${extra.join(", ")}.`);
+    const blend = changes.blend ?? current.blend;
+    if (!isBlendMode(blend) || blend === "pigment") fail2(`Unknown blend mode "${String(blend)}" for a smart filter.`);
+    const opacity = changes.opacity ?? current.opacity;
+    if (!(typeof opacity === "number" && opacity >= 0 && opacity <= 1)) fail2("opacity must be a number from 0 to 1.");
+    merged = { ...current, enabled: changes.enabled === void 0 ? current.enabled : Boolean(changes.enabled), blend, opacity };
+  } else {
+    merged = normalizeSmartFilter({ ...current, ...changes, kind: current.kind }, current.id);
+  }
+  const filters = [...layer.smartFilters.filters];
+  filters[i] = merged;
+  const next = withStack(layer, { ...layer.smartFilters, filters }, canvas);
+  return { layers: mapLayer(layers, id, () => next), layer: next, filter: merged };
+}
+function removeSmartFilter(layers, id, filterId, canvas) {
+  const layer = editableSmart(layers, id);
+  requireFilter(layer, filterId);
+  const stack = layer.smartFilters;
+  const filters = stack.filters.filter((f) => f.id !== filterId);
+  const next = withStack(layer, filters.length ? { ...stack, filters } : stack.enabled ? void 0 : { enabled: false, filters }, canvas);
+  return { layers: mapLayer(layers, id, () => next), layer: next };
+}
+function moveSmartFilter(layers, id, filterId, index, canvas) {
+  const layer = editableSmart(layers, id);
+  const i = requireFilter(layer, filterId);
+  const list2 = layer.smartFilters.filters;
+  if (!Number.isInteger(index) || index < 0 || index >= list2.length) fail2(`index must be a whole number from 0 to ${list2.length - 1}.`);
+  const filters = [...list2];
+  const [f] = filters.splice(i, 1);
+  filters.splice(index, 0, f);
+  const next = withStack(layer, { ...layer.smartFilters, filters }, canvas);
+  return { layers: mapLayer(layers, id, () => next), layer: next };
+}
+function setSmartFiltersEnabled(layers, id, enabled, canvas) {
+  const layer = editableSmart(layers, id);
+  const next = withStack(layer, { ...stackOf(layer), enabled: Boolean(enabled) }, canvas);
+  return { layers: mapLayer(layers, id, () => next), layer: next };
+}
+function setSmartFilterMask(layers, id, mask, canvas) {
+  const layer = editableSmart(layers, id);
+  if (mask?.source) fail2("A smart filter mask is painted, not generated; use a raster mask.");
+  const stack = { ...stackOf(layer) };
+  if (mask) stack.mask = mask;
+  else delete stack.mask;
+  const next = withStack(layer, stack, canvas);
+  return { layers: mapLayer(layers, id, () => next), layer: next };
+}
+function withFilterMaskSurface(layer, surface, canvas) {
+  const stack = stackOf(layer);
+  if (!stack.mask) fail2(`Smart object "${layer.name || layer.id}" has no filter mask; add one with set_smart_filter_mask.`);
+  return withStack(layer, { ...stack, mask: { ...stack.mask, surface } }, canvas);
+}
+function placementBounds(layer) {
+  return transformedBox(placementGeometry(layer));
+}
+
+// src/image-editor/layers/serialize.ts
+var LAYERED_SCHEMA_VERSION = 3;
+function serializePatterns(patterns) {
+  return patterns.map((p) => ({ id: p.id, name: p.name, png: pngDataUrl(p.width, p.height, p.data) }));
+}
+function deserializePatterns(raw, problems = []) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const p of raw) {
+    if (!p || typeof p !== "object" || typeof p.id !== "string" || typeof p.png !== "string") continue;
+    try {
+      const png = decodePngDataUrl(p.png, 4);
+      out.push({ id: p.id, name: typeof p.name === "string" ? p.name : p.id, width: png.width, height: png.height, data: png.data });
+    } catch (e) {
+      problems.push(`Pattern "${p.name ?? p.id}" could not be decoded (${e instanceof Error ? e.message : String(e)}).`);
+    }
+  }
+  return out;
+}
+var encodedCache = /* @__PURE__ */ new WeakMap();
+function encodeSurface(surface) {
+  if (encodedCache.has(surface)) return encodedCache.get(surface);
+  const b = contentBounds(surface);
+  let out = null;
+  if (b) {
+    const data = readRegion(surface, b);
+    out = { url: pngDataUrl(b.width, b.height, data, surface.channels), x: b.x, y: b.y };
+  }
+  encodedCache.set(surface, out);
+  return out;
+}
+function baseFields(layer, ctx) {
+  const out = {
+    id: layer.id,
+    name: layer.name,
+    visible: layer.visible,
+    opacity: layer.opacity,
+    blend: layer.blend
+  };
+  if (layer.clipped) out.clipped = true;
+  if (layer.mask) out.mask = serializeMask(layer.mask, `${layer.id}-mask`, ctx);
+  if (layer.locks && Object.values(layer.locks).some(Boolean)) out.locks = { ...layer.locks };
+  if (layer.effects) out.effects = serializeEffects(layer.effects);
+  return out;
+}
+function serializeEffects(effects) {
+  const out = { enabled: effects.enabled, items: JSON.parse(JSON.stringify(effects.items)) };
+  if (effects.scale !== void 0 && effects.scale !== 1) out.scale = effects.scale;
+  if (effects.psd) out.psd = { key: effects.psd.key, data: bytesToBase64(effects.psd.data) };
+  return out;
+}
+function deserializeEffects(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  let psd;
+  const p = r.psd;
+  if (p && typeof p.key === "string" && typeof p.data === "string") {
+    try {
+      psd = { key: p.key, data: base64ToBytes(p.data) };
+    } catch {
+      psd = void 0;
+    }
+  }
+  return normalizeLayerEffects({ ...r, psd });
+}
+function serializeMask(mask, hint, ctx) {
+  const out = { defaultValue: mask.defaultValue };
+  if (!mask.source) {
+    const enc = encodeSurface(mask.surface);
+    if (enc) {
+      out.asset = ctx.addAsset(enc.url, hint);
+      out.x = enc.x;
+      out.y = enc.y;
+    }
+  } else {
+    out.source = { ...mask.source, depthRange: [...mask.source.depthRange] };
+  }
+  if (mask.density !== void 0 && mask.density !== 1) out.density = mask.density;
+  if (mask.feather) out.feather = mask.feather;
+  if (mask.enabled === false) out.enabled = false;
+  if (mask.linked === false) out.linked = false;
+  return out;
+}
+function serializeLayer(layer, ctx) {
+  const base = baseFields(layer, ctx);
+  switch (layer.type) {
+    case "pixel": {
+      const out = { ...base, type: "pixel", offset: { ...layer.offset } };
+      if (layer.source === "document") out.source = "document";
+      else {
+        const enc = encodeSurface(layer.surface);
+        if (enc) {
+          out.asset = ctx.addAsset(enc.url, layer.id);
+          out.x = enc.x;
+          out.y = enc.y;
+        }
+      }
+      if (layer.fillOpacity !== void 0 && layer.fillOpacity !== 1) out.fillOpacity = layer.fillOpacity;
+      if (layer.filters?.length) out.filters = JSON.parse(JSON.stringify(layer.filters));
+      return out;
+    }
+    case "adjustment":
+      return { ...base, type: "adjustment", kind: layer.kind, params: JSON.parse(JSON.stringify(layer.params)) };
+    case "group": {
+      const out = { ...base, type: "group", children: layer.children.map((c) => serializeLayer(c, ctx)) };
+      if (layer.collapsed) out.collapsed = true;
+      return out;
+    }
+    case "annotation":
+      return { ...base, type: "annotation", annotation: JSON.parse(JSON.stringify(layer.annotation)) };
+    case "smart":
+      return serializeSmartObject(layer, base, ctx);
+  }
+}
+function serializeSmartFilters(stack, layerId, ctx) {
+  const out = {
+    enabled: stack.enabled,
+    filters: stack.filters.map((f) => f.kind === "psd" ? { ...f, data: bytesToBase64(f.data) } : JSON.parse(JSON.stringify(f)))
+  };
+  if (stack.mask) out.mask = serializeMask(stack.mask, `${layerId}-filter-mask`, ctx);
+  return out;
+}
+function serializeSmartObject(layer, base, ctx) {
+  if (!ctx.addContents) throw new Error("Smart objects need a contents table to be written.");
+  ctx.addContents(layer.contents);
+  const p = layer.placement;
+  const out = {
+    ...base,
+    type: "smart",
+    contents: layer.contents.id,
+    placement: { corners: p.corners.map((c) => ({ x: c.x, y: c.y })) }
+  };
+  if (p.warp) out.placement.warp = JSON.parse(JSON.stringify(p.warp));
+  if (p.interpolation && p.interpolation !== "bicubic") out.placement.interpolation = p.interpolation;
+  if (layer.smartFilters) out.smartFilters = serializeSmartFilters(layer.smartFilters, layer.id, ctx);
+  const enc = encodeSurface(layer.surface);
+  if (enc) {
+    out.asset = ctx.addAsset(enc.url, layer.id);
+    out.x = enc.x;
+    out.y = enc.y;
+  }
+  if (layer.fillOpacity !== void 0 && layer.fillOpacity !== 1) out.fillOpacity = layer.fillOpacity;
+  if (layer.psd) {
+    out.psd = { key: layer.psd.key, data: bytesToBase64(layer.psd.data) };
+    if (layer.psd.placed) out.psd.placed = layer.psd.placed;
+  }
+  return out;
+}
+function serializeContents(c, ctx) {
+  const out = { id: c.id, name: c.name, width: c.width, height: c.height, kind: c.kind };
+  if (c.kind === "raster" && c.raster) {
+    const enc = encodeSurface(c.raster);
+    if (enc) {
+      if (enc.x !== 0 || enc.y !== 0) {
+        const data = readRegion(c.raster, { x: 0, y: 0, width: c.width, height: c.height });
+        out.asset = ctx.addAsset(pngDataUrl(c.width, c.height, data, 4), `contents-${c.id}`);
+      } else out.asset = ctx.addAsset(enc.url, `contents-${c.id}`);
+    }
+  }
+  if (c.kind === "document" && c.document) {
+    out.layers = c.document.layers.map((l) => serializeLayer(l, ctx));
+    if (c.document.globalLight) out.globalLight = { ...c.document.globalLight };
+    if (c.document.patterns?.length) out.patterns = serializePatterns(c.document.patterns);
+  }
+  if (c.file) out.file = { type: c.file.type, data: bytesToBase64(c.file.bytes) };
+  if (c.linked) out.linked = { path: c.linked.path };
+  return out;
+}
+function serializeLayers(layers) {
+  const assets = {};
+  const contents = /* @__PURE__ */ new Map();
+  const ctx = {
+    addAsset(url, hint) {
+      let id = hint;
+      for (let n = 2; id in assets && assets[id] !== url; n++) id = `${hint}-${n}`;
+      assets[id] = url;
+      return id;
+    },
+    addContents(c) {
+      if (contents.has(c.id)) return;
+      contents.set(c.id, null);
+      contents.set(c.id, serializeContents(c, ctx));
+    }
+  };
+  const out = layers.map((l) => serializeLayer(l, ctx));
+  const list2 = [...contents.values()].filter(Boolean);
+  return list2.length ? { layers: out, assets, smartContents: list2 } : { layers: out, assets };
+}
+var externalRefs = /* @__PURE__ */ new WeakMap();
+async function serializeLayersExternal(layers, store) {
+  const inline = serializeLayers(layers);
+  let refs = externalRefs.get(store);
+  if (!refs) {
+    refs = /* @__PURE__ */ new Map();
+    externalRefs.set(store, refs);
+  }
+  const assets = {};
+  for (const [id, url] of Object.entries(inline.assets)) {
+    let ref = refs.get(url);
+    if (!ref) {
+      const parsed = parseDataUrl(url);
+      const png = decodePngHeader(parsed.bytes);
+      ref = await store.put(new Blob([parsed.bytes], { type: "image/png" }), { id, width: png.width, height: png.height });
+      if (typeof ref !== "string" || !ref) throw new Error(`The asset store returned no reference for "${id}".`);
+      refs.set(url, ref);
+    }
+    assets[id] = ref;
+  }
+  return inline.smartContents ? { layers: inline.layers, assets, smartContents: inline.smartContents } : { layers: inline.layers, assets };
+}
+function decodePngHeader(bytes) {
+  const u32 = (o) => (bytes[o] << 24 | bytes[o + 1] << 16 | bytes[o + 2] << 8 | bytes[o + 3]) >>> 0;
+  return { width: u32(16), height: u32(20) };
+}
+async function resolveExternalAssets(assets, store, problems) {
+  const out = {};
+  for (const [id, ref] of Object.entries(assets)) {
+    if (ref.startsWith("data:")) {
+      out[id] = ref;
+      continue;
+    }
+    if (!store) {
+      problems.push(`Asset "${id}" is external (${ref}) and no asset store was given.`);
+      continue;
+    }
+    try {
+      const blob = await store.get(ref);
+      const bytes = new Uint8Array(await blob.arrayBuffer());
+      out[id] = `data:image/png;base64,${bytesToBase64(bytes)}`;
+    } catch (err) {
+      problems.push(`Asset "${id}" (${ref}) could not be fetched: ${err.message}`);
+    }
+  }
+  return out;
+}
+function decodePngDataUrl(url, channels) {
+  const parsed = parseDataUrl(url);
+  if (!parsed) throw new Error("Asset is not a data URL.");
+  const png = decodePng(parsed.bytes, { keepGray: channels === 1 });
+  if (png.channels === channels) return png;
+  if (channels === 1) {
+    const out2 = new Uint8ClampedArray(png.width * png.height);
+    for (let i = 0, p = 0; p < out2.length; i += 4, p++) {
+      out2[p] = Math.round((0.299 * png.data[i] + 0.587 * png.data[i + 1] + 0.114 * png.data[i + 2]) * png.data[i + 3] / 255);
+    }
+    return { width: png.width, height: png.height, data: out2 };
+  }
+  const out = new Uint8ClampedArray(png.width * png.height * 4);
+  for (let p = 0; p < png.width * png.height; p++) {
+    out[p * 4] = out[p * 4 + 1] = out[p * 4 + 2] = png.data[p];
+    out[p * 4 + 3] = 255;
+  }
+  return { width: png.width, height: png.height, data: out };
+}
+var num = (v, lo, hi, fallback) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : fallback;
+function readSurface(ref, x, y, channels, defaultValue, ctx, what) {
+  if (typeof ref !== "string" || !ref) return emptySurface(channels, defaultValue);
+  const url = ctx.assets[ref];
+  if (typeof url !== "string") {
+    ctx.problems.push(`${what}: asset "${ref}" is missing`);
+    return emptySurface(channels, defaultValue);
+  }
+  try {
+    const px2 = (ctx.decodeAsset ?? decodePngDataUrl)(url, channels);
+    return surfaceFromPixels(px2, channels, Math.round(num(x, -1e7, 1e7, 0)), Math.round(num(y, -1e7, 1e7, 0)), defaultValue);
+  } catch (err) {
+    ctx.problems.push(`${what}: asset "${ref}" could not be decoded (${err.message})`);
+    return emptySurface(channels, defaultValue);
+  }
+}
+function readMask(raw, ctx, what) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const defaultValue = r.defaultValue === 255 ? 255 : 0;
+  const mask = {
+    surface: r.source ? emptySurface(1, 255) : readSurface(r.asset, r.x, r.y, 1, defaultValue, ctx, `${what} mask`),
+    defaultValue: r.source ? 255 : defaultValue
+  };
+  if (typeof r.density === "number" && r.density !== 1) mask.density = num(r.density, 0, 1, 1);
+  if (typeof r.feather === "number" && r.feather > 0) mask.feather = num(r.feather, 0, 1e3, 0);
+  if (r.enabled === false) mask.enabled = false;
+  if (r.linked === false) mask.linked = false;
+  if (r.source && typeof r.source === "object") {
+    const s = { ...DEFAULT_DEPTH_MASK_VALUES, ...r.source };
+    mask.source = { ...s, depthRange: [...s.depthRange] };
+  }
+  return mask;
+}
+function readFilters(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const f of raw) {
+    if (!f || typeof f !== "object") continue;
+    const r = f;
+    const id = typeof r.id === "string" && r.id ? r.id : newLayerId("flt");
+    const enabled = r.enabled !== false;
+    if (r.kind === "blur") out.push({ id, kind: "blur", enabled, radius: num(r.radius, 0, 50, 0) });
+    else if (r.kind === "develop") {
+      out.push({
+        id,
+        kind: "develop",
+        enabled,
+        brightness: num(r.brightness, -100, 100, 0),
+        contrast: num(r.contrast, -100, 100, 0),
+        saturation: num(r.saturation, -100, 100, 0),
+        exposure: num(r.exposure, -100, 100, 0),
+        temperature: num(r.temperature, -100, 100, 0),
+        tint: num(r.tint, -100, 100, 0),
+        process: normalizeProcessVersion(r.process)
+      });
+    }
+  }
+  return out.length ? out : void 0;
+}
+function deserializeLayer(raw, ctx) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const id = typeof r.id === "string" && r.id ? r.id : newLayerId();
+  const base = {
+    id,
+    name: typeof r.name === "string" ? r.name : "",
+    visible: r.visible !== false,
+    opacity: num(r.opacity, 0, 1, 1),
+    blend: normalizeBlendMode(r.blend)
+  };
+  if (r.clipped === true) base.clipped = true;
+  const mask = readMask(r.mask, ctx, `Layer "${base.name || id}"`);
+  if (mask) base.mask = mask;
+  if (r.locks && typeof r.locks === "object") {
+    const locks = {};
+    for (const k of ["pixels", "transparency", "position", "all"]) if (r.locks[k] === true) locks[k] = true;
+    if (Object.keys(locks).length) base.locks = locks;
+  }
+  const effects = deserializeEffects(r.effects);
+  if (effects && r.type !== "adjustment") base.effects = effects;
+  switch (r.type) {
+    case "pixel": {
+      const layer = {
+        ...base,
+        type: "pixel",
+        surface: r.source === "document" ? emptySurface(4) : readSurface(r.asset, r.x, r.y, 4, 0, ctx, `Layer "${base.name || id}"`),
+        offset: { x: Math.round(num(r.offset?.x, -1e7, 1e7, 0)), y: Math.round(num(r.offset?.y, -1e7, 1e7, 0)) }
+      };
+      if (r.source === "document") layer.source = "document";
+      if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num(r.fillOpacity, 0, 1, 1);
+      const filters = readFilters(r.filters);
+      if (filters) layer.filters = filters;
+      return layer;
+    }
+    case "adjustment": {
+      const norm = normalizeAdjustmentLayer({ id, kind: r.kind, params: r.params });
+      if (!norm) {
+        ctx.problems.push(`Layer "${base.name || id}": unknown adjustment kind "${r.kind}"`);
+        return null;
+      }
+      return { ...base, type: "adjustment", kind: norm.kind, params: norm.params };
+    }
+    case "group": {
+      const children = Array.isArray(r.children) ? r.children.map((c) => deserializeLayer(c, ctx)).filter(Boolean) : [];
+      const blend = r.blend === "pass-through" ? "pass-through" : isBlendMode(r.blend) ? r.blend : "pass-through";
+      const group = { ...base, type: "group", blend, children };
+      if (r.collapsed === true) group.collapsed = true;
+      return group;
+    }
+    case "annotation": {
+      const a = r.annotation;
+      if (!a || typeof a !== "object" || typeof a.type !== "string") {
+        ctx.problems.push(`Layer "${base.name || id}": annotation is missing`);
+        return null;
+      }
+      return { ...base, type: "annotation", annotation: JSON.parse(JSON.stringify({ ...a, id: typeof a.id === "string" ? a.id : id })) };
+    }
+    case "smart":
+      return readSmartObject(r, base, ctx);
+    default:
+      ctx.problems.push(`Layer "${base.name || id}": unknown layer type "${r.type}"`);
+      return null;
+  }
+}
+function readContents(id, ctx) {
+  const memo = ctx.contentsMemo ??= /* @__PURE__ */ new Map();
+  if (memo.has(id)) {
+    const c2 = memo.get(id);
+    if (c2 === null) ctx.problems.push(`Smart object contents "${id}" contain themselves; the inner instance was dropped`);
+    return c2 ?? null;
+  }
+  const raw = (ctx.smartContents ?? []).find((c2) => c2 && typeof c2 === "object" && c2.id === id);
+  if (!raw) {
+    ctx.problems.push(`Smart object contents "${id}" are missing`);
+    return null;
+  }
+  const width = Math.round(num(raw.width, 0, 3e5, 0));
+  const height = Math.round(num(raw.height, 0, 3e5, 0));
+  if (!(width > 0 && height > 0)) {
+    ctx.problems.push(`Smart object contents "${id}" have no size`);
+    return null;
+  }
+  memo.set(id, null);
+  const c = { id, name: typeof raw.name === "string" ? raw.name : "Contents", width, height, kind: raw.kind === "document" ? "document" : "raster" };
+  if (raw.file && typeof raw.file.type === "string" && typeof raw.file.data === "string") {
+    try {
+      c.file = { type: raw.file.type, bytes: base64ToBytes(raw.file.data) };
+    } catch {
+      ctx.problems.push(`Smart object contents "${c.name}": the embedded file could not be read`);
+    }
+  }
+  if (raw.linked && typeof raw.linked.path === "string") c.linked = { path: raw.linked.path };
+  if (c.kind === "raster") {
+    if (typeof raw.asset === "string") c.raster = readSurface(raw.asset, 0, 0, 4, 0, ctx, `Smart object contents "${c.name}"`);
+    else if (!c.file) c.raster = emptySurface(4);
+  } else {
+    const outer = ctx.canvas;
+    ctx.canvas = { width, height };
+    const layers = deserializeLayers(raw.layers, ctx);
+    ctx.canvas = outer;
+    c.document = { layers };
+    if (raw.globalLight && typeof raw.globalLight === "object") c.document.globalLight = { angle: num(raw.globalLight.angle, -360, 360, 120), altitude: num(raw.globalLight.altitude, 0, 90, 30) };
+    const patterns = deserializePatterns(raw.patterns, ctx.problems);
+    if (patterns.length) c.document.patterns = patterns;
+  }
+  memo.set(id, c);
+  return c;
 }
-function layerEffectsOf(layer) {
-  return layer.effects ?? { enabled: true, items: [] };
+function readSmartFilters(raw, ctx, what) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const r = raw;
+  const filters = [];
+  const list2 = Array.isArray(r.filters) ? r.filters : [];
+  const plain3 = readFilters(list2.filter((f) => f && f.kind !== "psd")) ?? [];
+  let k = 0;
+  for (const f of list2) {
+    if (!f || typeof f !== "object") continue;
+    const blend = isBlendMode(f.blend) && f.blend !== "pigment" ? f.blend : "normal";
+    const opacity = num(f.opacity, 0, 1, 1);
+    if (f.kind === "psd") {
+      try {
+        filters.push({ id: typeof f.id === "string" ? f.id : newLayerId("flt"), kind: "psd", enabled: f.enabled !== false, name: typeof f.name === "string" ? f.name : "Filter", data: base64ToBytes(String(f.data ?? "")), blend, opacity });
+      } catch {
+        ctx.problems.push(`${what}: a Photoshop smart filter could not be read`);
+      }
+    } else if (f.kind === "develop" || f.kind === "blur") {
+      const base = plain3[k++];
+      if (base) filters.push({ ...base, blend, opacity });
+    }
+  }
+  const stack = { enabled: r.enabled !== false, filters };
+  const mask = readMask(r.mask, ctx, `${what} filter`);
+  if (mask) stack.mask = mask;
+  return stack;
 }
-function guard(fn) {
+function readSmartObject(r, base, ctx) {
+  const what = `Layer "${base.name || base.id}"`;
+  const contents = typeof r.contents === "string" ? readContents(r.contents, ctx) : null;
+  if (!contents) {
+    ctx.problems.push(`${what}: its smart object contents are missing; the layer was dropped`);
+    return null;
+  }
+  const p = r.placement ?? {};
+  let placement;
   try {
-    return fn();
+    const raw = { corners: p.corners };
+    if (p.warp && isValidWarpMesh(p.warp)) raw.warp = p.warp;
+    if (isInterpolation(p.interpolation)) raw.interpolation = p.interpolation;
+    placement = normalizePlacement(raw, contents);
   } catch (e) {
-    if (e instanceof LayerEffectError) fail(e.message);
-    throw e;
-  }
-}
-function setLayerEffects(layers, id, effects) {
-  const layer = requireEffectLayer(layers, id, "change its effects");
-  const next = { ...layer };
-  if (effects && (effects.items.length || effects.psd || effects.scale !== void 0 || !effects.enabled)) {
-    guard(() => validateLayerEffects(effects));
-    next.effects = effects;
-  } else delete next.effects;
-  return mapLayer(layers, id, () => next);
-}
-function addLayerEffect(layers, id, kind, params = {}, index) {
-  if (!isLayerEffectKind(kind)) fail(`Unknown effect kind "${String(kind)}". Kinds: ${LAYER_EFFECT_KINDS.join(", ")}.`);
-  const layer = requireEffectLayer(layers, id, "add effects");
-  const current = layerEffectsOf(layer);
-  const ids = new Set(current.items.map((e) => e.id));
-  let effectId = newEffectId();
-  while (ids.has(effectId)) effectId = newEffectId();
-  const { id: _ignored, kind: _kind, ...rest } = params;
-  const effect = guard(() => mergeLayerEffect(defaultLayerEffect(kind, effectId), rest));
-  const items = [...current.items];
-  const at = index === void 0 ? items.length : Math.max(0, Math.min(items.length, Math.floor(index)));
-  items.splice(at, 0, effect);
-  return { layers: setLayerEffects(layers, id, { ...current, items }), effect };
-}
-function requireEffect(layer, effectId) {
-  const items = layer.effects?.items ?? [];
-  const i = items.findIndex((e) => e.id === effectId);
-  if (i === -1) fail(`Layer "${layer.name || layer.id}" has no effect "${effectId}". Effects: ${items.map((e) => `${e.id} (${e.kind})`).join(", ") || "none"}; call list_layer_effects.`);
-  return i;
-}
-function updateLayerEffect(layers, id, effectId, changes) {
-  const layer = requireEffectLayer(layers, id, "change its effects");
-  const i = requireEffect(layer, effectId);
-  const current = layer.effects;
-  const items = [...current.items];
-  items[i] = guard(() => mergeLayerEffect(items[i], changes));
-  return setLayerEffects(layers, id, { ...current, items });
-}
-function removeLayerEffect(layers, id, effectId) {
-  const layer = requireEffectLayer(layers, id, "change its effects");
-  requireEffect(layer, effectId);
-  const current = layer.effects;
-  return setLayerEffects(layers, id, { ...current, items: current.items.filter((e) => e.id !== effectId) });
-}
-function setLayerEffectsEnabled(layers, id, enabled, scale) {
-  const layer = requireEffectLayer(layers, id, "change its effects");
-  if (scale !== void 0 && !(Number.isFinite(scale) && scale >= 0.01 && scale <= 10)) fail(`scale must be from 0.01 to 10 (1 = 100 %), got ${scale}.`);
-  const current = layerEffectsOf(layer);
-  const next = { ...current, enabled };
-  if (scale !== void 0) {
-    if (scale === 1) delete next.scale;
-    else next.scale = scale;
+    ctx.problems.push(`${what}: its placement is invalid (${e instanceof Error ? e.message : String(e)}); it was placed at the top left`);
+    placement = { corners: [{ x: 0, y: 0 }, { x: contents.width, y: 0 }, { x: contents.width, y: contents.height }, { x: 0, y: contents.height }] };
+  }
+  const layer = { ...base, type: "smart", contents, placement, surface: emptySurface(4), offset: { x: 0, y: 0 } };
+  const filters = readSmartFilters(r.smartFilters, ctx, what);
+  if (filters) layer.smartFilters = filters;
+  if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num(r.fillOpacity, 0, 1, 1);
+  if (r.psd && typeof r.psd.key === "string" && typeof r.psd.data === "string") {
+    try {
+      layer.psd = { key: r.psd.key, data: base64ToBytes(r.psd.data) };
+      if (typeof r.psd.placed === "string") layer.psd.placed = r.psd.placed;
+    } catch {
+    }
   }
-  return setLayerEffects(layers, id, next);
-}
-function parseBlend(value, allowPassThrough = false) {
-  if (value === void 0) return void 0;
-  if (value === "pass-through" && allowPassThrough) return value;
-  if (!isBlendMode(value)) fail(`Unknown blend mode "${String(value)}".`);
-  return value;
+  if (typeof r.asset === "string") layer.surface = readSurface(r.asset, r.x, r.y, 4, 0, ctx, what);
+  else if (contents.raster || contents.document) layer.surface = renderSmartObject(layer, ctx.canvas ?? { width: 1, height: 1 });
+  return layer;
 }
-function unionRect(a, b) {
-  if (!a) return b;
-  if (!b) return a;
-  const x = Math.min(a.x, b.x);
-  const y = Math.min(a.y, b.y);
-  return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
+function deserializeLayers(raw, ctx) {
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const dedupe = (list2) => list2.map((l) => {
+    let next = l;
+    if (seen.has(l.id)) next = { ...l, id: newLayerId() };
+    seen.add(next.id);
+    if (next.type === "group") next = { ...next, children: dedupe(next.children) };
+    return next;
+  });
+  return dedupe(raw.map((l) => deserializeLayer(l, ctx)).filter(Boolean));
 }
 
 // src/image-editor/psd/binary.ts
@@ -8165,202 +9121,44 @@ function exportPsd(input) {
     { id: 1057, name: "", data: version.result() }
   ];
   if (input.globalLight) {
-    const i32 = (v) => {
-      const w = new PsdWriter();
-      w.i32(Math.round(v));
-      return w.result();
-    };
-    resources.push({ id: 1037, name: "", data: i32(input.globalLight.angle) }, { id: 1049, name: "", data: i32(input.globalLight.altitude) });
-  }
-  const globalBlocks = [];
-  if (patternIds2.size) {
-    const byId = new Map((input.patterns ?? []).map((p) => [p.id, p]));
-    const embed = [];
-    for (const id of patternIds2) {
-      const p = byId.get(id) ?? builtinPattern(id);
-      if (p) embed.push(p);
-      else note(`Pattern "${id}" is not in the document and was not embedded`, id);
-    }
-    if (embed.length) globalBlocks.push({ key: "Patt", data: writePatternBlock(embed) });
-  }
-  const bytes = writePsd(
-    {
-      header: { psb, channels: planes.length, width, height, depth: 8, colorMode: 3 },
-      colorModeData: new Uint8Array(0),
-      resources,
-      layers: records,
-      mergedAlpha: transparent && records.length > 0,
-      globalBlocks,
-      imageCompression: 1,
-      imageData: encodeRle(merged, { planes: planes.length, width, height, depth: 8, psb })
-    },
-    encodeLegacyName
-  );
-  const warnings = [...notes].map(([msg, names]) => `${msg} (${names.map((n2) => `"${n2}"`).join(", ")}).`);
-  return { bytes, psb, records: records.length, warnings };
-}
-
-// src/image-editor/transform.ts
-var FREE_TRANSFORM_MODES = ["scale", "rotate", "skew", "distort", "perspective", "warp"];
-var TRANSFORM_ANCHORS = ["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"];
-var ANCHOR_FRACTION = {
-  "top-left": [0, 0],
-  top: [0.5, 0],
-  "top-right": [1, 0],
-  left: [0, 0.5],
-  center: [0.5, 0.5],
-  right: [1, 0.5],
-  "bottom-left": [0, 1],
-  bottom: [0.5, 1],
-  "bottom-right": [1, 1]
-};
-function isTransformAnchor(value) {
-  return typeof value === "string" && value in ANCHOR_FRACTION;
-}
-function identityTransform(box) {
-  return { box: { ...box }, corners: boxQuad(box) };
-}
-function cornersFromMatrix(box, m) {
-  const q2 = boxQuad(box);
-  return [applyMatrix(m, q2[0]), applyMatrix(m, q2[1]), applyMatrix(m, q2[2]), applyMatrix(m, q2[3])];
-}
-function matrixFromCorners(box, corners, eps = 1e-6) {
-  const [tl, tr, br, bl] = corners;
-  const size = 1 + Math.max(box.width, box.height);
-  if (Math.abs(tl.x + br.x - tr.x - bl.x) > eps * size || Math.abs(tl.y + br.y - tr.y - bl.y) > eps * size) return null;
-  const h = rectToQuad(box, corners);
-  return h ? affineFromHomography(h, 1e-9) : null;
-}
-function transformHomography(geometry) {
-  const h = rectToQuad(geometry.box, geometry.corners);
-  if (!h) return null;
-  return homographyKeepsQuad(h, boxQuad(geometry.box)) ? h : null;
-}
-function hasWarp(geometry) {
-  const w = geometry.warp;
-  if (!w) return false;
-  const id = identityWarpMesh(geometry.box, w.us.length - 1, w.vs.length - 1);
-  if (id.points.length !== w.points.length || id.us.some((u, i) => Math.abs(u - w.us[i]) > 1e-12) || id.vs.some((v, i) => Math.abs(v - w.vs[i]) > 1e-12)) return true;
-  return w.points.some((p, i) => Math.abs(p.x - id.points[i].x) > 1e-6 || Math.abs(p.y - id.points[i].y) > 1e-6);
-}
-function isIdentityTransform(geometry) {
-  if (hasWarp(geometry)) return false;
-  const q2 = boxQuad(geometry.box);
-  return geometry.corners.every((c, i) => Math.abs(c.x - q2[i].x) < 1e-6 && Math.abs(c.y - q2[i].y) < 1e-6);
-}
-function transformMap(geometry) {
-  const h = transformHomography(geometry);
-  if (!h) return null;
-  const { box } = geometry;
-  const warp = hasWarp(geometry) ? geometry.warp : null;
-  if (!warp) return (p) => applyHomography(h, p);
-  return (p) => applyHomography(h, evalWarpMesh(warp, (p.x - box.x) / box.width, (p.y - box.y) / box.height));
-}
-function transformedPoint(geometry, fx, fy) {
-  const f = transformMap(geometry);
-  const { box } = geometry;
-  return f ? f({ x: box.x + fx * box.width, y: box.y + fy * box.height }) : null;
-}
-function anchorPoint(geometry, anchor) {
-  const [fx, fy] = ANCHOR_FRACTION[anchor];
-  const h = rectToQuad(geometry.box, geometry.corners);
-  const p = { x: geometry.box.x + fx * geometry.box.width, y: geometry.box.y + fy * geometry.box.height };
-  return (h && applyHomography(h, p)) ?? p;
-}
-function transformedBox(geometry) {
-  const f = transformMap(geometry);
-  if (!f) return null;
-  const { box } = geometry;
-  const pts = [];
-  const n = hasWarp(geometry) ? 16 : 1;
-  for (let i = 0; i <= n; i++) {
-    const t = i / n;
-    for (const [fx, fy] of [[t, 0], [1, t], [1 - t, 1], [0, 1 - t]]) {
-      const p = f({ x: box.x + fx * box.width, y: box.y + fy * box.height });
-      if (!p) return null;
-      pts.push(p);
-    }
+    const i32 = (v) => {
+      const w = new PsdWriter();
+      w.i32(Math.round(v));
+      return w.result();
+    };
+    resources.push({ id: 1037, name: "", data: i32(input.globalLight.angle) }, { id: 1049, name: "", data: i32(input.globalLight.altitude) });
   }
-  const xs = pts.map((p) => p.x);
-  const ys = pts.map((p) => p.y);
-  const x = Math.min(...xs);
-  const y = Math.min(...ys);
-  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
-}
-function referencePoint(box, reference) {
-  if (reference && typeof reference === "object") return { x: reference.x, y: reference.y };
-  const [fx, fy] = ANCHOR_FRACTION[reference ?? "center"];
-  return { x: box.x + fx * box.width, y: box.y + fy * box.height };
-}
-function matrixFromParams(box, params) {
-  const sx = (params.scaleX ?? 100) / 100;
-  const sy = (params.scaleY ?? 100) / 100;
-  const tx = Math.tan((params.skewX ?? 0) * Math.PI / 180);
-  const ty = Math.tan((params.skewY ?? 0) * Math.PI / 180);
-  const ref = referencePoint(box, params.reference);
-  const linear = multiplyMatrices(multiplyMatrices([1, ty, tx, 1, 0, 0], [sx, 0, 0, sy, 0, 0]), rotateMatrix(params.rotate ?? 0));
-  return multiplyMatrices(matrixAbout(linear, ref), translateMatrix(params.dx ?? 0, params.dy ?? 0));
-}
-function describeTransform(geometry, reference = "center") {
-  const m = hasWarp(geometry) ? null : matrixFromCorners(geometry.box, geometry.corners);
-  const ref = referencePoint(geometry.box, reference);
-  const bounds = transformedBox(geometry);
-  if (!m) {
-    const h = rectToQuad(geometry.box, geometry.corners);
-    const at2 = (h && applyHomography(h, ref)) ?? ref;
-    return { affine: false, scaleX: 100, scaleY: 100, rotate: 0, skewX: 0, x: at2.x, y: at2.y, bounds, corners: geometry.corners };
+  const globalBlocks = [];
+  if (patternIds2.size) {
+    const byId = new Map((input.patterns ?? []).map((p) => [p.id, p]));
+    const embed = [];
+    for (const id of patternIds2) {
+      const p = byId.get(id) ?? builtinPattern(id);
+      if (p) embed.push(p);
+      else note(`Pattern "${id}" is not in the document and was not embedded`, id);
+    }
+    if (embed.length) globalBlocks.push({ key: "Patt", data: writePatternBlock(embed) });
   }
-  const [a, b, c, d] = m;
-  const sxAbs = Math.hypot(a, b);
-  const rot = Math.atan2(b, a) * 180 / Math.PI;
-  const shear = sxAbs ? (a * c + b * d) / sxAbs : 0;
-  const sy = sxAbs ? (a * d - b * c) / sxAbs : 0;
-  const skew = sxAbs ? Math.atan(shear / sxAbs) * 180 / Math.PI : 0;
-  const at = applyMatrix(m, ref);
-  const clean = (v) => Math.abs(v) < 1e-9 ? 0 : v;
-  return {
-    affine: true,
-    scaleX: clean(sxAbs * 100),
-    scaleY: clean(sy * 100),
-    rotate: clean(rot === -180 ? 180 : rot),
-    skewX: clean(skew),
-    x: at.x,
-    y: at.y,
-    bounds,
-    corners: geometry.corners
-  };
-}
-function applyParams(geometry, params) {
-  const ref = params.reference && typeof params.reference === "object" ? params.reference : anchorPoint(geometry, params.reference ?? "center");
-  const m = matrixFromParams({ x: ref.x, y: ref.y, width: 0, height: 0 }, { ...params, reference: ref });
-  const c = geometry.corners;
-  return [applyMatrix(m, c[0]), applyMatrix(m, c[1]), applyMatrix(m, c[2]), applyMatrix(m, c[3])];
-}
-function flipCorners(geometry, axis) {
-  const c = anchorPoint(geometry, "center");
-  const m = axis === "horizontal" ? [-1, 0, 0, 1, 2 * c.x, 0] : [1, 0, 0, -1, 0, 2 * c.y];
-  const q2 = geometry.corners;
-  return [applyMatrix(m, q2[0]), applyMatrix(m, q2[1]), applyMatrix(m, q2[2]), applyMatrix(m, q2[3])];
-}
-function boxPointOf(geometry, p) {
-  const m = matrixFromCorners(geometry.box, geometry.corners);
-  if (m) return applyMatrix(invertMatrix(m), p);
-  return null;
-}
-function presetWarp(box, preset) {
-  return warpPresetMesh(preset, box);
-}
-function isValidWarp(mesh) {
-  return isValidWarpMesh(mesh);
-}
-function geometryHomography(geometry) {
-  const m = matrixFromCorners(geometry.box, geometry.corners);
-  return m ? homographyFromAffine(m) : transformHomography(geometry);
+  const bytes = writePsd(
+    {
+      header: { psb, channels: planes.length, width, height, depth: 8, colorMode: 3 },
+      colorModeData: new Uint8Array(0),
+      resources,
+      layers: records,
+      mergedAlpha: transparent && records.length > 0,
+      globalBlocks,
+      imageCompression: 1,
+      imageData: encodeRle(merged, { planes: planes.length, width, height, depth: 8, psb })
+    },
+    encodeLegacyName
+  );
+  const warnings = [...notes].map(([msg, names]) => `${msg} (${names.map((n2) => `"${n2}"`).join(", ")}).`);
+  return { bytes, psb, records: records.length, warnings };
 }
 
 // src/image-editor/free-transform.ts
 var FREE_TRANSFORM_CONTENTS = ["auto", "layer", "selection", "selection-copy", "selection-outline"];
-var fail2 = (message) => {
+var fail3 = (message) => {
   throw new LayerOperationError(message);
 };
 var T = (x, y) => [1, 0, x, 0, 1, y, 0, 0, 1];
@@ -8419,17 +9217,20 @@ function liftMask(mask, sel, o) {
 var FreeTransformSession = class {
   constructor(host, init = {}) {
     this.host = host;
-    if (init.interpolation !== void 0 && !isInterpolation(init.interpolation)) fail2(`Unknown interpolation "${String(init.interpolation)}"; use nearest, bilinear or bicubic.`);
+    if (init.interpolation !== void 0 && !isInterpolation(init.interpolation)) fail3(`Unknown interpolation "${String(init.interpolation)}"; use nearest, bilinear or bicubic.`);
     this.interp = init.interpolation ?? "bicubic";
     const sel = host.selection();
     const selected = Boolean(sel?.bounds);
     let content = init.content ?? "auto";
     if (!["auto", "layer", "selection", "selection-copy", "selection-outline"].includes(content)) {
-      fail2(`Unknown content "${String(content)}"; use auto, layer, selection, selection-copy or selection-outline.`);
+      fail3(`Unknown content "${String(content)}"; use auto, layer, selection, selection-copy or selection-outline.`);
     }
-    if (content === "auto") content = selected ? "selection" : "layer";
+    const targetId = init.layerId ?? host.activeLayerId();
+    const target = targetId && content !== "selection-outline" ? findLayer(host.layers(), targetId)?.layer : void 0;
+    const smartTarget = target?.type === "smart" && (init.channel ?? (target.id === host.activeLayerId() ? host.activeTarget() : "pixels")) !== "mask";
+    if (content === "auto") content = selected && !smartTarget ? "selection" : "layer";
     this.content = content;
-    if (content !== "layer" && !selected) fail2(`Nothing is selected; ${content} needs a selection. Select first, or use content layer.`);
+    if (content !== "layer" && !selected) fail3(`Nothing is selected; ${content} needs a selection. Select first, or use content layer.`);
     const layers = host.layers();
     this.startLayers = layers;
     this.startSelection = sel;
@@ -8444,25 +9245,39 @@ var FreeTransformSession = class {
       box = { ...sel.bounds };
     } else {
       const id = init.layerId ?? host.activeLayerId();
-      if (!id) fail2("No layer given and none is active; pass layerId (see list_layers).");
+      if (!id) fail3("No layer given and none is active; pass layerId (see list_layers).");
       const layer = requireLayer(layers, id).layer;
       this.layerId = layer.id;
       const mask = layer.mask && !layer.mask.source ? layer.mask : void 0;
       const channel = init.channel ?? (layer.id === host.activeLayerId() ? host.activeTarget() : "pixels");
-      if (channel !== "pixels" && channel !== "mask") fail2(`Unknown channel "${String(channel)}"; use pixels or mask.`);
+      if (channel !== "pixels" && channel !== "mask") fail3(`Unknown channel "${String(channel)}"; use pixels or mask.`);
       const linked = mask?.linked !== false;
       const maskAlone = channel === "mask" && (!linked || layer.type !== "pixel");
-      if (channel === "mask" && !mask) fail2(layer.mask?.source ? `Layer "${layer.name || id}" has a depth mask, which is generated, not transformed.` : `Layer "${layer.name || id}" has no mask to transform; add one with add_layer_mask, or transform its pixels.`);
-      if (!maskAlone && layer.type !== "pixel") fail2(`Layer "${layer.name || id}" is a ${layer.type} layer; Free Transform works on pixel layers, layer masks (channel mask) and selections.`);
-      if (!layer.visible && content !== "selection-copy") fail2(`Layer "${layer.name || id}" is hidden; show it before you transform it.`);
+      if (channel === "mask" && !mask) fail3(layer.mask?.source ? `Layer "${layer.name || id}" has a depth mask, which is generated, not transformed.` : `Layer "${layer.name || id}" has no mask to transform; add one with add_layer_mask, or transform its pixels.`);
+      if (!maskAlone && layer.type !== "pixel" && layer.type !== "smart") fail3(`Layer "${layer.name || id}" is a ${layer.type} layer; Free Transform works on pixel layers, smart objects, layer masks (channel mask) and selections.`);
+      if (!layer.visible && content !== "selection-copy") fail3(`Layer "${layer.name || id}" is hidden; show it before you transform it.`);
       if (content !== "selection-copy") {
         requireUnlocked(layer, "position", "transform it");
         if (!maskAlone) requireUnlocked(layer, "pixels", "transform it");
       }
       const o = layer.type === "pixel" ? layer.offset : { x: 0, y: 0 };
       const pixels = layer.type === "pixel" ? host.pixelsOf(layer) : null;
+      if (layer.type === "smart" && !maskAlone) {
+        if (content !== "layer") fail3(`Layer "${layer.name || id}" is a smart object, which transforms as a whole; use content layer (or rasterize it to transform part of it).`);
+        if (!isContentsDecoded(layer.contents)) fail3(`The contents of "${layer.name || id}" are not decoded here, so it cannot be transformed; run prepareSmartObjects() first.`);
+        this.smart = layer;
+        this.smartObject = true;
+        this.startGeometry = placementGeometry(layer);
+        if (init.interpolation === void 0 && layer.placement.interpolation) this.interp = layer.placement.interpolation;
+        this.startInterp = this.interp;
+        this.box = contentsBox(layer.contents);
+        this.moves = mask && linked ? ["pixels", "mask"] : ["pixels"];
+        this.geometryValue = this.startGeometry;
+        this.shown = this.startLayers;
+        return;
+      }
       if (maskAlone) {
-        if (content === "selection-copy") fail2("Layer via Copy copies pixels; transform a mask with content layer or selection.");
+        if (content === "selection-copy") fail3("Layer via Copy copies pixels; transform a mask with content layer or selection.");
         if (content === "selection") {
           const { lifted, rest } = liftMask(mask.surface, sel, o);
           this.parts.push({ what: "mask", offset: o, moving: lifted, base: rest, reduced: /* @__PURE__ */ new Map() });
@@ -8517,11 +9332,13 @@ var FreeTransformSession = class {
         moves.push("selection");
       }
     }
-    if (!box && moves[0] === "mask") fail2("The mask holds nothing but its default value, so there is nothing to transform; paint it first, or transform the pixels (channel pixels).");
-    if (!box) fail2(content === "layer" ? "The layer has no pixels to transform." : "The selection holds no pixels of this layer; select some, or transform the outline (content selection-outline).");
+    if (!box && moves[0] === "mask") fail3("The mask holds nothing but its default value, so there is nothing to transform; paint it first, or transform the pixels (channel pixels).");
+    if (!box) fail3(content === "layer" ? "The layer has no pixels to transform." : "The selection holds no pixels of this layer; select some, or transform the outline (content selection-outline).");
     this.box = box;
     this.moves = moves;
-    this.geometryValue = identityTransform(box);
+    this.startGeometry = identityTransform(box);
+    this.startInterp = this.interp;
+    this.geometryValue = this.startGeometry;
     this.shown = this.startLayers;
     if (this.copyId) host.show(this.startLayers, sel, this.copyId);
     this.shown = host.layers();
@@ -8536,7 +9353,19 @@ var FreeTransformSession = class {
   box;
   /** What moves. */
   moves;
+  /**
+   * The geometry the transform starts from: the identity over `box`, or for a smart object its
+   * placement (`box` is then the contents' rectangle in contents pixels, and the transform edits
+   * the placement without resampling anything twice).
+   */
+  startGeometry;
+  /** True when the layer is a smart object (the transform sets its placement). */
+  smartObject = false;
   geometryValue;
+  smart = null;
+  smartReduced = /* @__PURE__ */ new Map();
+  startInterp;
+  smartMasksMoved = false;
   interp;
   parts = [];
   before;
@@ -8557,10 +9386,10 @@ var FreeTransformSession = class {
     return !this.closed;
   }
   check() {
-    if (this.closed) fail2("This transform has already been committed or cancelled; begin a new one.");
+    if (this.closed) fail3("This transform has already been committed or cancelled; begin a new one.");
     if (this.host.layers() !== this.shown) {
       this.closed = true;
-      fail2("The document changed while the transform was open, so it was abandoned; begin a new one.");
+      fail3("The document changed while the transform was open, so it was abandoned; begin a new one.");
     }
   }
   /**
@@ -8570,7 +9399,7 @@ var FreeTransformSession = class {
   update(changes, preview = {}) {
     this.check();
     if (changes.interpolation !== void 0) {
-      if (!isInterpolation(changes.interpolation)) fail2(`Unknown interpolation "${String(changes.interpolation)}"; use nearest, bilinear or bicubic.`);
+      if (!isInterpolation(changes.interpolation)) fail3(`Unknown interpolation "${String(changes.interpolation)}"; use nearest, bilinear or bicubic.`);
       this.interp = changes.interpolation;
     }
     const next = {
@@ -8578,14 +9407,15 @@ var FreeTransformSession = class {
       corners: (changes.corners ?? this.geometryValue.corners).map((p) => ({ x: p.x, y: p.y })),
       warp: changes.warp === void 0 ? this.geometryValue.warp ?? null : changes.warp
     };
-    if (next.corners.length !== 4 || !next.corners.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) fail2("corners must be four finite points: top-left, top-right, bottom-right, bottom-left.");
-    if (!transformMap(next)) fail2("These corners fold the frame over itself or through the horizon; keep the quad convex.");
+    if (next.corners.length !== 4 || !next.corners.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) fail3("corners must be four finite points: top-left, top-right, bottom-right, bottom-left.");
+    if (!transformMap(next)) fail3("These corners fold the frame over itself or through the horizon; keep the quad convex.");
     this.geometryValue = next;
     if (preview !== false) this.render(preview);
     return next;
   }
   /** Resamples every part for the current geometry and shows it (or returns it, for commit). */
   resample(final, preview = {}) {
+    if (this.smart) return { layers: this.resampleSmart(final, preview), selection: this.startSelection };
     const g = this.geometryValue;
     const identity = isIdentityTransform(g);
     const warp = hasWarp(g);
@@ -8625,7 +9455,7 @@ var FreeTransformSession = class {
             moved = transformSurface(src, hl, opts);
           }
         } catch (e) {
-          if (e instanceof TransformTooLargeError) fail2(e.message);
+          if (e instanceof TransformTooLargeError) fail3(e.message);
           throw e;
         }
       }
@@ -8647,6 +9477,35 @@ var FreeTransformSession = class {
     }
     return { layers, selection };
   }
+  /** A smart object re-rendered from its contents for the current geometry (previews leave the smart filters out). */
+  resampleSmart(final, preview) {
+    const layer = this.smart;
+    const g = this.geometryValue;
+    const placement = { corners: g.corners, warp: g.warp ?? null, interpolation: this.interp };
+    const canvas = this.host.canvas();
+    try {
+      if (final) {
+        const res = setSmartPlacement(this.startLayers, layer.id, placement, canvas);
+        this.smartMasksMoved = res.masksMoved;
+        return res.layers;
+      }
+      const step = previewStep(preview.scale);
+      const surface = renderSmartObject({ ...layer, placement }, canvas, { step, clip: preview.clip, skipFilters: true, reduced: this.smartReduced });
+      return mapLayer(this.startLayers, layer.id, (l) => ({ ...l, placement, surface }));
+    } catch (e) {
+      if (e instanceof TransformTooLargeError) fail3(e.message);
+      throw e;
+    }
+  }
+  /** Whether the geometry (or the interpolation of a smart object) differs from where it started. */
+  isChanged() {
+    const g = this.geometryValue;
+    if (!this.smart) return !isIdentityTransform(g);
+    const a = this.startGeometry;
+    const same = g.corners.every((c, i) => Math.abs(c.x - a.corners[i].x) < 1e-9 && Math.abs(c.y - a.corners[i].y) < 1e-9);
+    const warp = (w, box) => w && hasWarp({ box, corners: a.corners, warp: w }) ? JSON.stringify(w) : "";
+    return !same || warp(g.warp, g.box) !== warp(a.warp, a.box) || this.interp !== this.startInterp;
+  }
   render(preview) {
     const { layers, selection } = this.resample(false, preview);
     this.host.show(layers, selection, this.copyId ?? this.startActive);
@@ -8655,8 +9514,7 @@ var FreeTransformSession = class {
   /** Finishes the transform with full-quality resampling, as one undo step. */
   commit() {
     this.check();
-    const g = this.geometryValue;
-    const changed = !isIdentityTransform(g) || Boolean(this.copyId);
+    const changed = this.isChanged() || Boolean(this.copyId);
     if (!changed) {
       this.closed = true;
       this.host.restore(this.before);
@@ -8679,12 +9537,13 @@ var FreeTransformSession = class {
     const id = this.copyId ?? this.layerId;
     const layer = id ? findLayer(layers, id)?.layer : void 0;
     if (this.moves.includes("pixels") && layer?.type === "pixel") bounds = toDoc(contentBounds(this.host.pixelsOf(layer)), layer.offset);
+    else if (this.moves.includes("pixels") && layer?.type === "smart") bounds = contentBounds(layer.surface);
     else if (this.moves.includes("mask") && layer?.mask) bounds = toDoc(contentBounds(layer.mask.surface), layer.type === "pixel" ? layer.offset : { x: 0, y: 0 });
     else if (this.moves.includes("selection")) bounds = selection?.bounds ? { ...selection.bounds } : null;
     return {
       layerId: this.copyId ?? this.layerId,
       content: this.content,
-      moved: [...this.moves],
+      moved: this.smart ? this.moves.filter((m) => m !== "mask" || this.smartMasksMoved) : [...this.moves],
       box: { ...this.box },
       corners: this.geometryValue.corners,
       bounds,
@@ -8694,6 +9553,39 @@ var FreeTransformSession = class {
 };
 
 // src/image-editor/controller.ts
+function prepareNestedForPsd(layers) {
+  const out = [];
+  for (const l of layers) {
+    if (l.type === "annotation") continue;
+    let next = l;
+    if (l.type === "group") next = { ...l, children: prepareNestedForPsd(l.children) };
+    else if (l.type === "smart") next = rasterizeSmartObject([l], l.id).layer;
+    else if (l.type === "pixel" && l.filters?.length) {
+      const p = { ...l };
+      if (l.filters.some(isActiveFilter)) {
+        const b = l.surface.bounds;
+        if (b) {
+          const r = { x: b.x + l.offset.x - 64, y: b.y + l.offset.y - 64, width: b.width + 128, height: b.height + 128 };
+          const plain3 = { ...l, visible: true, opacity: 1, blend: "normal" };
+          delete plain3.mask;
+          delete plain3.clipped;
+          delete plain3.effects;
+          delete plain3.fillOpacity;
+          const data = new LayerCompositor().composite([plain3], r, { width: r.x + r.width, height: r.y + r.height });
+          p.surface = surfaceFromPixels({ width: r.width, height: r.height, data }, 4, r.x - l.offset.x, r.y - l.offset.y);
+        }
+      }
+      delete p.filters;
+      next = p;
+    }
+    if (next.mask?.source) {
+      next = { ...next };
+      delete next.mask;
+    }
+    out.push(next);
+  }
+  return out;
+}
 var IMAGE_EDITOR_SCHEMA_VERSION = LAYERED_SCHEMA_VERSION;
 function paintCoverageInto(base, coverage, apply, rects) {
   const tiles = new Map(base.tiles);
@@ -8994,6 +9886,7 @@ var ImageEditorController = class {
    * for undoable source replacement.
    */
   async loadImage(src) {
+    this.abandonContents();
     if (typeof src === "string") this.state.sourceUrl = src;
     const source = await this.resolveSource(src);
     const prev = this.state.imageDimensions;
@@ -9283,7 +10176,7 @@ var ImageEditorController = class {
   setActiveLayer(id, target = "pixels") {
     if (id !== null && !this.getLayer(id)) return false;
     const layer = id ? this.getLayer(id) : void 0;
-    const t = target === "mask" && layer?.mask ? "mask" : "pixels";
+    const t = target === "mask" && layer?.mask ? "mask" : target === "filter-mask" && layer?.type === "smart" && layer.smartFilters?.mask ? "filter-mask" : "pixels";
     if (this.state.activeLayerId === id && this.state.activeTarget === t) return true;
     this.state.activeLayerId = id;
     this.state.activeTarget = t;
@@ -9296,7 +10189,7 @@ var ImageEditorController = class {
    */
   getLayerPixels(id) {
     const layer = this.getLayer(id);
-    if (!layer || layer.type !== "pixel") return null;
+    if (!layer || layer.type !== "pixel" && layer.type !== "smart") return null;
     const surface = this.surfaceOf(layer);
     const b = contentBounds(surface);
     if (!b) return null;
@@ -9309,7 +10202,7 @@ var ImageEditorController = class {
    */
   getLayerBounds(id) {
     const layer = this.getLayer(id);
-    if (!layer || layer.type !== "pixel") return null;
+    if (!layer || layer.type !== "pixel" && layer.type !== "smart") return null;
     const surface = this.surfaceOf(layer);
     let b = this.boundsCache.get(surface);
     if (b === void 0) {
@@ -9358,9 +10251,9 @@ var ImageEditorController = class {
     }
     return String(id);
   }
-  /** The pixels a pixel layer composites (the decoded source for the Background). */
+  /** The pixels a pixel layer or smart object composites (the decoded source for the Background). */
   surfaceOf(layer) {
-    if (layer.source !== "document") return layer.surface;
+    if (layer.type === "smart" || layer.source !== "document") return layer.surface;
     return this.sourceSurface() ?? layer.surface;
   }
   /**
@@ -9604,6 +10497,15 @@ var ImageEditorController = class {
    */
   offsetLayer(id, move, commitToHistory = true) {
     const layer = requireLayer(this.state.layers, id).layer;
+    if (layer.type === "smart") {
+      const tl = layer.placement.corners[0];
+      const dx = move.x !== void 0 ? move.x - tl.x : move.dx ?? 0;
+      const dy = move.y !== void 0 ? move.y - tl.y : move.dy ?? 0;
+      if (!Number.isFinite(dx) || !Number.isFinite(dy)) throw new LayerOperationError("x and y must be numbers.");
+      this.commitLayers(offsetSmartObject(this.state.layers, id, dx, dy, this.canvasSize), void 0, commitToHistory);
+      const moved = findLayer(this.state.layers, id).layer;
+      return { offset: { x: Math.round(moved.placement.corners[0].x), y: Math.round(moved.placement.corners[0].y) }, bounds: this.getLayerBounds(id) };
+    }
     const current = layer.type === "pixel" ? layer.offset : { x: 0, y: 0 };
     const x = move.x ?? current.x + (move.dx ?? 0);
     const y = move.y ?? current.y + (move.dy ?? 0);
@@ -9810,78 +10712,476 @@ var ImageEditorController = class {
       const [a, b, c, d] = spec.matrix;
       if (Math.abs(a * d - b * c) < 1e-9) throw new LayerOperationError("matrix is singular (it collapses the layer to a line); its determinant a\xB7d \u2212 b\xB7c must not be 0.");
     }
-    const session = this.beginFreeTransform(spec);
-    try {
-      const g = identityTransform(session.box);
-      const corners = spec.matrix ? cornersFromMatrix(session.box, spec.matrix) : spec.corners ? spec.corners : spec.params ? applyParams(g, spec.params) : g.corners;
-      let warp = null;
-      if (spec.warp) {
-        if ("style" in spec.warp) {
-          if (!WARP_STYLES.includes(spec.warp.style)) throw new LayerOperationError(`Unknown warp style "${String(spec.warp.style)}". Styles: ${WARP_STYLES.join(", ")}.`);
-          warp = presetWarp(session.box, spec.warp);
-        } else {
-          if (!isValidWarp(spec.warp)) throw new LayerOperationError("mesh must have us and vs (knots from 0 to 1, increasing) and (3\xB7columns + 1) \xD7 (3\xB7rows + 1) finite points, row by row.");
-          warp = spec.warp;
-        }
+    const session = this.beginFreeTransform(spec);
+    try {
+      const g = session.startGeometry;
+      const corners = spec.matrix ? g.corners.map((p) => applyMatrix(spec.matrix, p)) : spec.corners ? spec.corners : spec.params ? applyParams(g, spec.params) : g.corners;
+      let warp = spec.warp === void 0 ? g.warp ?? null : null;
+      if (spec.warp) {
+        if ("style" in spec.warp) {
+          if (!WARP_STYLES.includes(spec.warp.style)) throw new LayerOperationError(`Unknown warp style "${String(spec.warp.style)}". Styles: ${WARP_STYLES.join(", ")}.`);
+          warp = presetWarp(session.box, spec.warp);
+        } else {
+          if (!isValidWarp(spec.warp)) throw new LayerOperationError("mesh must have us and vs (knots from 0 to 1, increasing) and (3\xB7columns + 1) \xD7 (3\xB7rows + 1) finite points, row by row.");
+          warp = spec.warp;
+        }
+      }
+      session.update({ corners, warp }, false);
+      return session.commit();
+    } catch (e) {
+      session.cancel();
+      throw e;
+    }
+  }
+  /** Flips the layer (or its selected pixels, or the outline) about the frame's centre, exactly (one undo step). */
+  flipLayer(axis, init = {}) {
+    if (axis !== "horizontal" && axis !== "vertical") throw new LayerOperationError(`axis must be horizontal or vertical, got "${String(axis)}".`);
+    const session = this.beginFreeTransform({ interpolation: "nearest", ...init });
+    try {
+      session.update({ corners: flipCorners(session.startGeometry, axis) }, false);
+      return session.commit();
+    } catch (e) {
+      session.cancel();
+      throw e;
+    }
+  }
+  /**
+   * Rotates by a quarter turn (90 clockwise, −90 counter-clockwise) or 180 about the frame's
+   * centre, snapped so pixels land on whole pixels: exact, no resampling (one undo step).
+   */
+  rotateLayer90(turn, init = {}) {
+    if (turn !== 90 && turn !== -90 && turn !== 180) throw new LayerOperationError(`turn must be 90, -90 or 180, got ${String(turn)}.`);
+    const session = this.beginFreeTransform({ interpolation: "nearest", ...init });
+    try {
+      const b = session.smartObject ? transformedBox(session.startGeometry) ?? session.box : session.box;
+      const cx = b.x + b.width / 2;
+      const cy = b.y + b.height / 2;
+      const ox = turn === 180 ? 0 : Math.round(cx - b.height / 2) - (cx - b.height / 2);
+      const oy = turn === 180 ? 0 : Math.round(cy - b.width / 2) - (cy - b.width / 2);
+      const m = turn === 90 ? [0, 1, -1, 0, cx + cy + ox, cy - cx + oy] : turn === -90 ? [0, -1, 1, 0, cx - cy + ox, cy + cx + oy] : [-1, 0, 0, -1, 2 * cx, 2 * cy];
+      session.update({ corners: session.startGeometry.corners.map((p) => applyMatrix(m, p)) }, false);
+      return session.commit();
+    } catch (e) {
+      session.cancel();
+      throw e;
+    }
+  }
+  /** Adds a `develop` or `blur` filter to a pixel layer (one undo step). Returns the layer's filters. */
+  addLayerFilter(id, filter) {
+    const f = normalizeFilter(filter);
+    const next = addLayerFilter(this.state.layers, id, f);
+    this.commitLayers(next);
+    return findLayer(next, id).layer.filters ?? [];
+  }
+  /** Changes one filter (one undo step, or none with `commitToHistory = false` during a drag). Returns the filters. */
+  updateLayerFilter(id, filterId, changes, commitToHistory = true) {
+    const next = updateLayerFilter(this.state.layers, id, filterId, changes);
+    this.commitLayers(next, void 0, commitToHistory);
+    return findLayer(next, id).layer.filters ?? [];
+  }
+  /** Removes one filter (one undo step). Returns the remaining filters. */
+  removeLayerFilter(id, filterId) {
+    const next = removeLayerFilter(this.state.layers, id, filterId);
+    this.commitLayers(next);
+    return findLayer(next, id).layer.filters ?? [];
+  }
+  // --- Smart objects ---
+  get canvasSize() {
+    return this.naturalSize;
+  }
+  /**
+   * Layer › Smart Objects › Convert to Smart Object (one undo step): sibling layers (default the
+   * active one) become one smart object at the topmost one's position. A single pixel layer keeps
+   * its id and properties and its filters become smart filters (it renders exactly as before);
+   * anything else nests as a layer document. Returns the smart object's id.
+   */
+  convertToSmartObject(ids, options = {}) {
+    const list2 = ids?.length ? ids : this.state.activeLayerId ? [this.state.activeLayerId] : [];
+    if (!list2.length) throw new LayerOperationError("No layers given and none is active; pass layerIds (see list_layers).");
+    const res = convertToSmartObject(this.state.layers, list2, this.canvasSize, { surfaceOf: (l) => this.surfaceOf(l), name: options.name });
+    this.commitLayers(res.layers, () => {
+      this.state.activeLayerId = res.layer.id;
+      this.state.activeTarget = "pixels";
+    });
+    return res.layer.id;
+  }
+  /** Layer › Smart Objects › Rasterize (one undo step): the smart object becomes a pixel layer holding what it renders. */
+  rasterizeSmartObject(id) {
+    const res = rasterizeSmartObject(this.state.layers, id);
+    this.commitLayers(res.layers, () => {
+      if (this.state.activeLayerId === id && this.state.activeTarget === "filter-mask") this.state.activeTarget = "pixels";
+    });
+    return id;
+  }
+  /** A smart object's contents, placement and smart filters as plain data (see `SmartObjectInfo`). */
+  getSmartObject(id) {
+    const layer = requireSmartObject(this.state.layers, id);
+    const c = layer.contents;
+    const g = placementGeometry(layer);
+    const readout = describeTransform(g);
+    const stack = layer.smartFilters;
+    return {
+      layerId: layer.id,
+      contents: {
+        id: c.id,
+        name: c.name,
+        kind: c.kind,
+        width: c.width,
+        height: c.height,
+        decoded: isContentsDecoded(c),
+        fileType: c.file?.type ?? null,
+        linkedPath: c.linked?.path ?? null,
+        instances: instancesOf(this.state.layers, c.id),
+        layerCount: c.document ? flattenLayers(c.document.layers).length : 0
+      },
+      placement: {
+        corners: g.corners.map((p) => ({ x: p.x, y: p.y })),
+        warp: layer.placement.warp ?? null,
+        interpolation: layer.placement.interpolation ?? "bicubic",
+        affine: readout.affine,
+        scaleX: readout.scaleX,
+        scaleY: readout.scaleY,
+        rotate: readout.rotate,
+        skewX: readout.skewX,
+        center: anchorPoint(g, "center"),
+        bounds: transformedBox(g)
+      },
+      smartFilters: {
+        enabled: stack?.enabled ?? true,
+        filters: (stack?.filters ?? []).map((f) => f.kind === "psd" ? { id: f.id, kind: "psd", name: f.name, enabled: f.enabled, blend: f.blend, opacity: f.opacity } : { ...f }),
+        mask: stack?.mask ? { enabled: stack.mask.enabled !== false, linked: stack.mask.linked !== false, density: stack.mask.density ?? 1, feather: stack.mask.feather ?? 0, bounds: contentBounds(stack.mask.surface), defaultValue: stack.mask.defaultValue } : null
+      },
+      bounds: this.getLayerBounds(id)
+    };
+  }
+  /**
+   * Sets a smart object's placement (one undo step, or none with `commitToHistory = false` during a
+   * drag): where the contents' corners land, an optional warp in contents pixels and the
+   * interpolation. The contents render again from the source; a linked mask follows a warp-free
+   * change. Returns the new placement summary.
+   */
+  setSmartObjectPlacement(id, placement, commitToHistory = true) {
+    const res = setSmartPlacement(this.state.layers, id, placement, this.canvasSize);
+    this.commitLayers(res.layers, void 0, commitToHistory);
+    return { ...this.getSmartObject(id).placement, masksMoved: res.masksMoved };
+  }
+  /**
+   * Sets a smart object's transform absolutely (one undo step): exactly one of `corners` (where the
+   * contents' corners land), `matrix` (contents pixels → document) or the numbers (`scaleX`,
+   * `scaleY` in percent of the contents' own size, `rotate`, `skewX`, `skewY`, and `x`, `y` where
+   * the contents' centre goes, default where it is now); plus, optionally, a warp (a preset, a mesh
+   * in contents pixels, or `null` to remove it) and the interpolation. Unlike `transformLayer`,
+   * nothing is relative to the current transform.
+   */
+  setSmartObjectTransform(id, spec) {
+    const layer = requireSmartObject(this.state.layers, id);
+    const g = placementGeometry(layer);
+    const numeric = ["scaleX", "scaleY", "rotate", "skewX", "skewY", "x", "y"].filter((k) => spec[k] !== void 0);
+    const ways = [spec.corners !== void 0, spec.matrix !== void 0, numeric.length > 0].filter(Boolean).length;
+    if (ways > 1) throw new LayerOperationError("Give the transform only one way: corners, matrix, or the numbers (scaleX, scaleY, rotate, skewX, skewY, x, y).");
+    let corners = g.corners;
+    if (spec.corners) corners = spec.corners;
+    else if (spec.matrix) {
+      if (!(Array.isArray(spec.matrix) && spec.matrix.length === 6 && spec.matrix.every(Number.isFinite))) throw new LayerOperationError("matrix must be six finite numbers [a, b, c, d, e, f] (x' = a\xB7x + c\xB7y + e, y' = b\xB7x + d\xB7y + f).");
+      const [a, b, c, d] = spec.matrix;
+      if (Math.abs(a * d - b * c) < 1e-9) throw new LayerOperationError("matrix is singular (it collapses the contents to a line); a\xB7d \u2212 b\xB7c must not be 0.");
+      corners = cornersFromMatrix(g.box, spec.matrix);
+    } else if (numeric.length) {
+      if (spec.scaleX === 0 || spec.scaleY === 0) throw new LayerOperationError("scaleX and scaleY must not be 0 (that collapses the contents to a line).");
+      for (const k of numeric) if (!Number.isFinite(spec[k])) throw new LayerOperationError(`${k} must be a finite number.`);
+      const now = describeTransform(g);
+      const centre = anchorPoint(g, "center");
+      const params = {
+        scaleX: spec.scaleX ?? (now.affine ? now.scaleX : 100),
+        scaleY: spec.scaleY ?? (now.affine ? now.scaleY : 100),
+        rotate: spec.rotate ?? (now.affine ? now.rotate : 0),
+        skewX: spec.skewX ?? (now.affine ? now.skewX : 0),
+        skewY: spec.skewY ?? 0
+      };
+      const m = matrixFromParams(g.box, { ...params, reference: "center" });
+      const cx = g.box.width / 2;
+      const cy = g.box.height / 2;
+      const to = { x: spec.x ?? centre.x, y: spec.y ?? centre.y };
+      corners = cornersFromMatrix(g.box, multiplyMatrices(m, translateMatrix(to.x - cx, to.y - cy)));
+    }
+    let warp = layer.placement.warp ?? null;
+    if (spec.warp === null) warp = null;
+    else if (spec.warp) {
+      if ("style" in spec.warp) {
+        if (!WARP_STYLES.includes(spec.warp.style)) throw new LayerOperationError(`Unknown warp style "${String(spec.warp.style)}". Styles: ${WARP_STYLES.join(", ")}.`);
+        warp = presetWarp(g.box, spec.warp);
+      } else {
+        if (!isValidWarp(spec.warp)) throw new LayerOperationError("mesh must have us and vs (knots from 0 to 1, increasing) and (3\xB7columns + 1) \xD7 (3\xB7rows + 1) finite points in contents pixels, row by row.");
+        warp = spec.warp;
+      }
+    }
+    const next = { corners, warp, interpolation: spec.interpolation ?? layer.placement.interpolation };
+    return this.setSmartObjectPlacement(id, next);
+  }
+  /**
+   * Layer › Smart Objects › Replace Contents (one undo step): new contents for the smart object and
+   * every instance linked to it, from RGBA pixels, PSD bytes (a layer document) or contents. Each
+   * instance keeps its scale and rotation about the contents' centre. Returns the contents id and
+   * the layers that changed.
+   */
+  replaceSmartObjectContents(id, source) {
+    const layer = requireSmartObject(this.state.layers, id);
+    let contents;
+    if ("contents" in source) contents = source.contents;
+    else if ("pixels" in source) contents = rasterContents(source.pixels, source.name ?? layer.contents.name.replace(/\.\w+$/, ".png"));
+    else {
+      const psd = importPsd(source.psd, { newId: () => newLayerId() });
+      contents = documentContents({ layers: psd.layers, globalLight: psd.globalLight, patterns: psd.patterns.length ? psd.patterns : void 0 }, psd.width, psd.height, source.name ?? `${layer.name || "Contents"}.psb`);
+      contents.file = { bytes: source.psd.slice(), type: psd.info.psb ? "psb" : "psd" };
+    }
+    const res = replaceContents(this.state.layers, layer.contents.id, contents, this.canvasSize);
+    this.commitLayers(res.layers);
+    return { contentsId: layer.contents.id, width: contents.width, height: contents.height, layerIds: res.ids };
+  }
+  /** `replaceSmartObjectContents` from an image (PNG data URL or base64 decodes anywhere; other formats need a browser). */
+  async replaceSmartObjectContentsFromImage(id, image, name) {
+    const pixels = await this.decodeImage(image);
+    return this.replaceSmartObjectContents(id, { pixels, name });
+  }
+  /**
+   * Layer › Smart Objects › Export Contents: the file the contents came from while unedited, else a
+   * PNG (raster contents) or a PSD / PSB of the nested document. Returns the file name, MIME type
+   * and bytes.
+   */
+  exportSmartObjectContents(id) {
+    const layer = requireSmartObject(this.state.layers, id);
+    const c = layer.contents;
+    const base = c.name.replace(/\.\w+$/, "") || "Contents";
+    if (c.file) {
+      const mime = { psd: "image/vnd.adobe.photoshop", psb: "image/vnd.adobe.photoshop", png: "image/png", jpg: "image/jpeg", jpeg: "image/jpeg", tif: "image/tiff", tiff: "image/tiff", gif: "image/gif" };
+      const ext = c.file.type.toLowerCase();
+      return { name: /\.\w+$/.test(c.name) ? c.name : `${base}.${ext}`, mimeType: mime[ext] ?? "application/octet-stream", bytes: c.file.bytes };
+    }
+    if (!isContentsDecoded(c)) throw new LayerOperationError(`The contents of "${layer.name || id}" are not available here.`);
+    if (c.kind === "raster") {
+      const data = readRegion(contentsSurface(c), { x: 0, y: 0, width: c.width, height: c.height });
+      return { name: `${base}.png`, mimeType: "image/png", bytes: encodePng(c.width, c.height, data) };
+    }
+    const doc = c.document;
+    const merged = readRegion(contentsSurface(c), { x: 0, y: 0, width: c.width, height: c.height });
+    const prepared = prepareNestedForPsd(doc.layers);
+    const res = exportPsd({ width: c.width, height: c.height, layers: prepared, merged, patterns: doc.patterns, globalLight: doc.globalLight });
+    return { name: `${base}.${res.psb ? "psb" : "psd"}`, mimeType: "image/vnd.adobe.photoshop", bytes: res.bytes };
+  }
+  /**
+   * Layer › Smart Objects › New Smart Object via Copy (`linked: false`: independent contents) or a
+   * linked duplicate (`linked: true`: edits to the contents show in both), directly above, as one
+   * undo step. Returns the copy's id.
+   */
+  copySmartObject(id, linked = false, name) {
+    const res = copySmartObject(this.state.layers, id, linked, name);
+    this.commitLayers(res.layers, () => {
+      this.state.activeLayerId = res.layer.id;
+      this.state.activeTarget = "pixels";
+    });
+    return res.layer.id;
+  }
+  /** Adds a smart filter (`develop` or `blur`, with `blend` and `opacity`) at `index` (default the top), as one undo step. */
+  addSmartFilter(id, filter, index) {
+    const res = addSmartFilter(this.state.layers, id, normalizeSmartFilter(filter), this.canvasSize, index);
+    this.commitLayers(res.layers);
+    return res.filter;
+  }
+  /** Changes one smart filter (one undo step, or none with `commitToHistory = false` during a drag). */
+  updateSmartFilter(id, filterId, changes, commitToHistory = true) {
+    const res = updateSmartFilter(this.state.layers, id, filterId, changes, this.canvasSize);
+    this.commitLayers(res.layers, void 0, commitToHistory);
+    return res.filter;
+  }
+  /** Removes one smart filter (one undo step). Returns the remaining filters. */
+  removeSmartFilter(id, filterId) {
+    const res = removeSmartFilter(this.state.layers, id, filterId, this.canvasSize);
+    this.commitLayers(res.layers);
+    return res.layer.smartFilters?.filters ?? [];
+  }
+  /** Moves one smart filter to `index` (0 = bottom, applied first), as one undo step. Returns the filters. */
+  moveSmartFilter(id, filterId, index) {
+    const res = moveSmartFilter(this.state.layers, id, filterId, index, this.canvasSize);
+    this.commitLayers(res.layers);
+    return res.layer.smartFilters?.filters ?? [];
+  }
+  /** Turns a smart object's whole filter stack on or off (one undo step). */
+  setSmartFiltersEnabled(id, enabled) {
+    const res = setSmartFiltersEnabled(this.state.layers, id, enabled, this.canvasSize);
+    this.commitLayers(res.layers);
+    return res.layer.smartFilters?.enabled ?? true;
+  }
+  /**
+   * Sets the smart filter mask (one undo step): `reveal-all`, `hide-all`, `selection` (the
+   * selection's coverage), or `none` to remove it; `props` sets density, feather, enabled and linked.
+   * Painting it targets channel `filter-mask`. Returns the mask, or `null` when removed.
+   */
+  setSmartFilterMask(id, from, props = {}, commitToHistory = true) {
+    const layer = requireSmartObject(this.state.layers, id);
+    let mask;
+    if (from === "none") mask = null;
+    else if (from === "keep") {
+      if (!layer.smartFilters?.mask) throw new LayerOperationError(`Smart object "${layer.name || id}" has no filter mask; add one with from reveal-all, hide-all or selection.`);
+      mask = withMaskProps(layer.smartFilters.mask, props);
+    } else if (from === "selection") {
+      const sel = this.state.selection;
+      if (!sel?.bounds) throw new LayerOperationError("Nothing is selected; select first, or use reveal-all / hide-all.");
+      mask = this.maskFromSelection(sel, props);
+    } else {
+      const v = from === "reveal-all" ? 255 : 0;
+      mask = withMaskProps({ surface: emptySurface(1, v), defaultValue: v }, props);
+    }
+    const res = setSmartFilterMask(this.state.layers, id, mask, this.canvasSize);
+    this.commitLayers(res.layers, () => {
+      if (this.state.activeLayerId !== id) return;
+      if (mask && from !== "keep") this.state.activeTarget = "filter-mask";
+      else if (!mask && this.state.activeTarget === "filter-mask") this.state.activeTarget = "pixels";
+    }, commitToHistory);
+    return res.layer.smartFilters?.mask ?? null;
+  }
+  /**
+   * Decodes smart object contents that came as files the synchronous decoders cannot read (a JPEG
+   * or TIFF embedded in a PSD), through the browser's image decoder. No undo step: the pixels on
+   * screen do not change. Returns the contents ids still undecoded.
+   */
+  async prepareSmartObjects() {
+    const pending = /* @__PURE__ */ new Map();
+    for (const l of flattenLayers(this.state.layers)) if (l.type === "smart" && !isContentsDecoded(l.contents) && l.contents.file) pending.set(l.contents.id, l.contents);
+    const left = [];
+    for (const [cid, c] of pending) {
+      try {
+        const url = `data:${c.file.type === "png" ? "image/png" : c.file.type === "gif" ? "image/gif" : c.file.type === "tif" || c.file.type === "tiff" ? "image/tiff" : "image/jpeg"};base64,${bytesToBase64(c.file.bytes)}`;
+        const px2 = await this.decodeImage(url);
+        const decoded2 = { ...c, kind: "raster", raster: rasterContents(px2, c.name, cid).raster, width: px2.width, height: px2.height };
+        const swap = (layers) => {
+          let out = layers;
+          for (const l of flattenLayers(layers)) if (l.type === "smart" && l.contents.id === cid) out = mapLayer(out, l.id, (x) => ({ ...x, contents: decoded2 }));
+          return out;
+        };
+        this.state.layers = swap(this.state.layers);
+        for (const e of [...this.undoStack, ...this.redoStack]) e.layers = swap(e.layers);
+      } catch {
+        left.push(cid);
       }
-      session.update({ corners, warp }, false);
-      return session.commit();
-    } catch (e) {
-      session.cancel();
-      throw e;
     }
+    if (pending.size) this.notify();
+    return left;
   }
-  /** Flips the layer (or its selected pixels, or the outline) about the frame's centre, exactly (one undo step). */
-  flipLayer(axis, init = {}) {
-    if (axis !== "horizontal" && axis !== "vertical") throw new LayerOperationError(`axis must be horizontal or vertical, got "${String(axis)}".`);
-    const session = this.beginFreeTransform({ interpolation: "nearest", ...init });
-    try {
-      session.update({ corners: flipCorners(identityTransform(session.box), axis) }, false);
-      return session.commit();
-    } catch (e) {
-      session.cancel();
-      throw e;
-    }
+  // --- Smart object contents (Edit Contents) ---
+  contentsStack = [];
+  /** The smart objects whose contents are open (outermost first); empty when the document itself is shown. */
+  getEditingContents() {
+    return this.contentsStack.map((e) => ({ layerId: e.layerId, name: e.name }));
   }
   /**
-   * Rotates by a quarter turn (90 clockwise, −90 counter-clockwise) or 180 about the frame's
-   * centre, snapped so pixels land on whole pixels: exact, no resampling (one undo step).
+   * Layer › Smart Objects › Edit Contents: shows the smart object's contents as a document of their
+   * own (a layer document, or raster contents as one pixel layer), with their own undo history.
+   * Every editor operation and tool then works on the contents until `closeSmartObjectContents`.
+   * Contents can nest. Returns the contents' size and layer ids.
    */
-  rotateLayer90(turn, init = {}) {
-    if (turn !== 90 && turn !== -90 && turn !== 180) throw new LayerOperationError(`turn must be 90, -90 or 180, got ${String(turn)}.`);
-    const session = this.beginFreeTransform({ interpolation: "nearest", ...init });
-    try {
-      const b = session.box;
-      const cx = b.x + b.width / 2;
-      const cy = b.y + b.height / 2;
-      const ox = turn === 180 ? 0 : Math.round(cx - b.height / 2) - (cx - b.height / 2);
-      const oy = turn === 180 ? 0 : Math.round(cy - b.width / 2) - (cy - b.width / 2);
-      const m = turn === 90 ? [0, 1, -1, 0, cx + cy + ox, cy - cx + oy] : turn === -90 ? [0, -1, 1, 0, cx - cy + ox, cy + cx + oy] : [-1, 0, 0, -1, 2 * cx, 2 * cy];
-      session.update({ corners: cornersFromMatrix(b, m) }, false);
-      return session.commit();
-    } catch (e) {
-      session.cancel();
-      throw e;
-    }
+  editSmartObjectContents(id) {
+    if (this.getFreeTransform()) throw new LayerOperationError("A Free Transform is open; commit or cancel it first.");
+    const layer = requireSmartObject(this.state.layers, id);
+    const c = layer.contents;
+    if (!isContentsDecoded(c)) throw new LayerOperationError(`The contents of "${layer.name || id}" are a ${c.file?.type ?? "file"} that could not be decoded here; run prepareSmartObjects() in a browser first.`);
+    const saved = {
+      state: { ...this.state },
+      undo: this.undoStack,
+      redo: this.redoStack,
+      initial: this.initialSnapshot,
+      element: this.imageElement,
+      samplePixels: this.samplePixels,
+      samplePixelsOverride: this.samplePixelsOverride,
+      psdResolution: this.psdResolution
+    };
+    const layers = c.kind === "document" ? c.document.layers : [{ type: "pixel", id: newLayerId(), name: "Layer 0", visible: true, opacity: 1, blend: "normal", surface: c.raster, offset: { x: 0, y: 0 } }];
+    this.contentsStack.push({ layerId: layer.id, contentsId: c.id, name: layer.name || c.name, saved });
+    const s = this.state;
+    this.state = {
+      ...s,
+      sourceUrl: null,
+      imageDimensions: { width: c.width, height: c.height },
+      crop: null,
+      transform: { ...DEFAULT_TRANSFORM_VALUES },
+      layers,
+      activeLayerId: layers.length ? layers[layers.length - 1].id : null,
+      activeTarget: "pixels",
+      selection: null,
+      selectedAnnotationId: null,
+      outputOpacity: 1,
+      zoom: 1,
+      pan: { x: 0, y: 0 },
+      editingContents: this.getEditingContents()
+    };
+    delete this.state.legacyOutputBlur;
+    if (c.document?.globalLight) this.state.globalLight = c.document.globalLight;
+    else delete this.state.globalLight;
+    if (c.document?.patterns?.length) this.state.patterns = c.document.patterns;
+    else delete this.state.patterns;
+    this.imageElement = null;
+    this.samplePixels = null;
+    this.samplePixelsOverride = false;
+    this.undoStack = [];
+    this.redoStack = [];
+    this.viewKey = [];
+    this.initialSnapshot = this.captureHistoryEntry();
+    this.notify();
+    return { layerId: layer.id, depth: this.contentsStack.length, width: c.width, height: c.height, layerIds: flattenLayers(layers).map((l) => l.id) };
   }
-  /** Adds a `develop` or `blur` filter to a pixel layer (one undo step). Returns the layer's filters. */
-  addLayerFilter(id, filter) {
-    const f = normalizeFilter(filter);
-    const next = addLayerFilter(this.state.layers, id, f);
-    this.commitLayers(next);
-    return findLayer(next, id).layer.filters ?? [];
+  /**
+   * Closes the innermost open contents: with `save` (default) the edited layers become the smart
+   * object's contents, and it and every linked instance render again (one undo step in the
+   * document); without, the edits are dropped. Returns the smart object and the layers that changed.
+   */
+  closeSmartObjectContents(save = true) {
+    const top = this.contentsStack.pop();
+    if (!top) throw new LayerOperationError("No smart object contents are open; open them with edit_smart_object_contents.");
+    if (this.openTransform?.isOpen) this.openTransform.cancel();
+    this.openTransform = null;
+    const edited = this.state;
+    const changed = save && this.undoStack.length > 0;
+    let next = null;
+    if (changed) {
+      const layer = findLayer(top.saved.state.layers, top.layerId)?.layer;
+      const old = layer?.contents;
+      const { width, height } = edited.imageDimensions;
+      const only = edited.layers.length === 1 ? edited.layers[0] : null;
+      const plain3 = only?.type === "pixel" && only.visible && only.opacity === 1 && only.blend === "normal" && !only.mask && !only.effects && !only.filters?.length && !only.clipped && (only.fillOpacity ?? 1) === 1 && only.source !== "document";
+      if (old?.kind === "raster" && plain3) {
+        const px2 = readRegion(only.surface, { x: -only.offset.x, y: -only.offset.y, width, height });
+        next = rasterContents({ width, height, data: px2 }, old.name, old.id);
+      } else {
+        const doc = { layers: edited.layers, globalLight: edited.globalLight, patterns: edited.patterns };
+        next = documentContents(doc, width, height, old?.kind === "document" ? old.name : `${(old?.name ?? "Contents").replace(/\.\w+$/, "")}.psb`, top.contentsId);
+      }
+    }
+    const saved = top.saved;
+    this.state = saved.state;
+    this.undoStack = saved.undo;
+    this.redoStack = saved.redo;
+    this.initialSnapshot = saved.initial;
+    this.imageElement = saved.element;
+    this.samplePixels = saved.samplePixels;
+    this.samplePixelsOverride = saved.samplePixelsOverride;
+    this.psdResolution = saved.psdResolution;
+    this.viewKey = [];
+    if (this.contentsStack.length) this.state.editingContents = this.getEditingContents();
+    else delete this.state.editingContents;
+    if (!next) {
+      this.notify();
+      return { layerId: top.layerId, changed: false, layerIds: [] };
+    }
+    const res = replaceContents(this.state.layers, top.contentsId, next, this.canvasSize);
+    this.commitLayers(res.layers);
+    return { layerId: top.layerId, changed: true, layerIds: res.ids };
   }
-  /** Changes one filter (one undo step, or none with `commitToHistory = false` during a drag). Returns the filters. */
-  updateLayerFilter(id, filterId, changes, commitToHistory = true) {
-    const next = updateLayerFilter(this.state.layers, id, filterId, changes);
-    this.commitLayers(next, void 0, commitToHistory);
-    return findLayer(next, id).layer.filters ?? [];
+  /** The document's own layers (not the contents open for editing). */
+  rootLayers() {
+    return this.contentsStack[0]?.saved.state.layers ?? this.state.layers;
   }
-  /** Removes one filter (one undo step). Returns the remaining filters. */
-  removeLayerFilter(id, filterId) {
-    const next = removeLayerFilter(this.state.layers, id, filterId);
-    this.commitLayers(next);
-    return findLayer(next, id).layer.filters ?? [];
+  /** Drops every open contents edit (loading another document). */
+  abandonContents() {
+    while (this.contentsStack.length) this.closeSmartObjectContents(false);
   }
   // --- Layer effects ---
   /** A layer's effects (an empty, enabled list when it has none). */
@@ -10073,7 +11373,7 @@ var ImageEditorController = class {
     const k = Math.min(1, side / Math.max(width, height));
     const tw = Math.max(1, Math.round(width * k));
     const th = Math.max(1, Math.round(height * k));
-    const surface = options.mask ? layer.mask && !layer.mask.source ? layer.mask.surface : null : layer.type === "pixel" ? this.surfaceOf(layer) : null;
+    const surface = options.mask ? layer.mask && !layer.mask.source ? layer.mask.surface : null : layer.type === "pixel" || layer.type === "smart" ? this.surfaceOf(layer) : null;
     if (!surface) return null;
     const ox = layer.type === "pixel" ? layer.offset.x : 0;
     const oy = layer.type === "pixel" ? layer.offset.y : 0;
@@ -10160,19 +11460,27 @@ var ImageEditorController = class {
       if (!layer.mask) throw new LayerOperationError(`Layer "${layer.name || id}" has no mask to ${action}; add one with add_layer_mask, or target pixels.`);
       if (layer.mask.source) throw new LayerOperationError(`Layer "${layer.name || id}" has a depth mask, which is generated, not painted.`);
       requireUnlocked(layer, "all", action);
+    } else if (ch === "filter-mask") {
+      if (layer.type !== "smart" || !layer.smartFilters?.mask) {
+        throw new LayerOperationError(`Layer "${layer.name || id}" has no smart filter mask to ${action}; add one with set_smart_filter_mask, or target pixels or mask.`);
+      }
+      if (!isContentsDecoded(layer.contents)) throw new LayerOperationError(`The contents of "${layer.name || id}" are not decoded here, so its filter mask cannot be painted; run prepareSmartObjects() first.`);
+      requireUnlocked(layer, "all", action);
     } else {
+      if (layer.type === "smart") throw new LayerOperationError(`Layer "${layer.name || id}" is a smart object; its pixels come from its contents. Rasterize it (rasterize_smart_object), edit its contents (edit_smart_object_contents), or ${action} on its mask or filter mask.`);
       if (layer.type !== "pixel") throw new LayerOperationError(`Layer "${layer.name || id}" is a ${layer.type} layer; ${action} on a pixel layer, or on this layer's mask (channel mask).`);
       requireUnlocked(layer, "pixels", action);
     }
     if (!layer.visible) throw new LayerOperationError(`Layer "${layer.name || id}" is hidden; show it before you ${action}.`);
     const offset = layer.type === "pixel" ? layer.offset : { x: 0, y: 0 };
-    const surface = ch === "mask" ? layer.mask.surface : this.surfaceOf(layer);
+    const surface = ch === "mask" ? layer.mask.surface : ch === "filter-mask" ? layer.smartFilters.mask.surface : this.surfaceOf(layer);
     const lockTransparency = ch === "pixels" && Boolean(layer.locks?.transparency);
     return { id, layer, channel: ch, offset, surface, lockTransparency };
   }
   /** The layer with its pixels (or mask) replaced by `surface`. */
   withSurface(layer, channel, surface) {
     if (channel === "mask") return { ...layer, mask: { ...layer.mask, surface } };
+    if (channel === "filter-mask") return withFilterMaskSurface(layer, surface, this.canvasSize);
     const next = { ...layer, surface };
     delete next.source;
     return next;
@@ -10187,7 +11495,7 @@ var ImageEditorController = class {
     const tool = init.tool ?? "brush";
     if (tool !== "brush" && tool !== "eraser" && tool !== "mixer") throw new LayerOperationError(`Unknown paint tool "${String(tool)}"; use brush, eraser or mixer.`);
     const target = this.paintTarget(init.layerId, init.channel, tool === "eraser" ? "erase" : "paint");
-    if (tool === "mixer" && target.channel === "mask") {
+    if (tool === "mixer" && target.channel !== "pixels") {
       throw new LayerOperationError("The Mixer Brush paints colour on pixels, not on masks; target pixels (channel pixels), or paint the mask with the brush.");
     }
     const brush = normalizeBrush({ ...this.state.paint.brush, ...init.brush ?? {} });
@@ -10199,10 +11507,10 @@ var ImageEditorController = class {
     };
     const apply = {
       mode: tool === "eraser" ? "erase" : "paint",
-      color: target.channel === "mask" ? toMaskGrey(color) : color,
-      background: target.channel === "mask" ? toMaskGrey(background) : background,
+      color: target.channel !== "pixels" ? toMaskGrey(color) : color,
+      background: target.channel !== "pixels" ? toMaskGrey(background) : background,
       opacity: brush.opacity,
-      blend: target.channel === "mask" ? "normal" : brush.blend,
+      blend: target.channel !== "pixels" ? "normal" : brush.blend,
       lockTransparency: target.lockTransparency,
       selection: this.state.selection?.bounds ? this.state.selection : null,
       offset: target.offset
@@ -10230,7 +11538,7 @@ var ImageEditorController = class {
   /** @internal Shows a stroke's live surface (no history). */
   _strokeUpdate(layerId, channel, surface, rects) {
     this.state.layers = mapLayer(this.state.layers, layerId, (l) => this.withSurface(l, channel, surface));
-    this.notify(rects);
+    this.notify(channel === "filter-mask" ? void 0 : rects);
   }
   /** @internal Commits a finished stroke as one undo step (`before` is the pre-stroke state). */
   _strokeCommit(before, layerId, channel, surface) {
@@ -10302,10 +11610,10 @@ var ImageEditorController = class {
     };
     const apply = {
       mode,
-      color: target.channel === "mask" ? grey(color) : color,
-      background: target.channel === "mask" ? grey(background) : background,
+      color: target.channel !== "pixels" ? grey(color) : color,
+      background: target.channel !== "pixels" ? grey(background) : background,
       opacity,
-      blend: target.channel === "mask" ? "normal" : blend,
+      blend: target.channel !== "pixels" ? "normal" : blend,
       lockTransparency: target.lockTransparency,
       selection: null,
       offset: target.offset
@@ -10691,7 +11999,7 @@ var ImageEditorController = class {
     const sources = {
       width,
       height,
-      surfaceOf: (l) => l.source === "document" && pixels ? surfaceFromPixels(pixels, 4) : this.surfaceOf(l),
+      surfaceOf: (l) => l.type === "pixel" && l.source === "document" && pixels ? surfaceFromPixels(pixels, 4) : this.surfaceOf(l),
       version: pixels ? "pixels" : this.sourceVersion()
     };
     const stack = withoutAnnotations(this.state.layers);
@@ -11181,8 +12489,10 @@ var ImageEditorController = class {
       if (layer.mask && (layer.offset.x || layer.offset.y)) {
         next.mask = { ...layer.mask, surface: translateSurface(layer.mask.surface, layer.offset.x, layer.offset.y) };
       }
+    } else if (layer.type === "smart") {
+      return this.rasterizeSmartObject(id);
     } else {
-      throw new LayerOperationError(`Only annotation layers and pixel layers with filters rasterize; "${layer.name || id}" is a ${layer.type} layer. Merge it down or flatten instead.`);
+      throw new LayerOperationError(`Only annotation layers, smart objects and pixel layers with filters rasterize; "${layer.name || id}" is a ${layer.type} layer. Merge it down or flatten instead.`);
     }
     this.commitLayers(mapLayer(this.state.layers, id, () => next));
     return id;
@@ -11198,6 +12508,7 @@ var ImageEditorController = class {
    */
   loadPsd(bytes) {
     const result = importPsd(bytes, { newId: () => newLayerId() });
+    this.abandonContents();
     this.recordHistory();
     const s = this.state;
     this.imageElement = null;
@@ -11306,6 +12617,13 @@ var ImageEditorController = class {
         if (mask2) out2.mask = mask2;
         return out2;
       }
+      if (layer.type === "smart") {
+        add2("Smart objects were written as pixel layers (their rendered pixels)", layer.name);
+        const px2 = rasterizeSmartObject([layer], layer.id).layer;
+        const mask2 = bakeMask(px2);
+        if (mask2) px2.mask = mask2;
+        return px2;
+      }
       let out = { ...layer };
       if (layer.source === "document") {
         out.surface = this.surfaceOf(layer);
@@ -11391,10 +12709,27 @@ var ImageEditorController = class {
     this.notify();
   }
   toJSON(options) {
-    const out = this.serializeState();
-    if (this.state.selection?.bounds) out.selection = serializeSelection(this.state.selection);
+    const root = this.contentsStack[0]?.saved;
+    const current = this.state;
+    const element = this.imageElement;
+    if (root) {
+      this.state = root.state;
+      this.imageElement = root.element;
+      this.viewKey = [];
+    }
+    let out;
+    try {
+      out = this.serializeState();
+      if (this.state.selection?.bounds) out.selection = serializeSelection(this.state.selection);
+    } finally {
+      if (root) {
+        this.state = current;
+        this.imageElement = element;
+        this.viewKey = [];
+      }
+    }
     if (!options || out.version !== LAYERED_SCHEMA_VERSION) return options ? Promise.resolve(out) : out;
-    return serializeLayersExternal(this.state.layers, options.store).then(({ layers, assets }) => ({ ...out, layers, assets }));
+    return serializeLayersExternal(this.rootLayers(), options.store).then(({ layers, assets, smartContents }) => smartContents ? { ...out, layers, assets, smartContents } : { ...out, layers, assets });
   }
   /**
    * Loads a stored state whose v3 assets may live in an asset store (references other than data
@@ -11413,6 +12748,7 @@ var ImageEditorController = class {
   }
   /** Loads a stored state of any version (one undo step). */
   loadJSON(data) {
+    this.abandonContents();
     this.recordHistory();
     this.applyStored(data);
     let selection = null;
@@ -11435,7 +12771,8 @@ var ImageEditorController = class {
     this.lastLoadProblems = [];
     if (isLayered(data)) {
       const problems = [];
-      s.layers = deserializeLayers(data.layers, { assets: data.assets ?? {}, problems });
+      const canvas = typeof data.width === "number" && data.width > 0 && typeof data.height === "number" && data.height > 0 ? { width: data.width, height: data.height } : this.naturalSize;
+      s.layers = deserializeLayers(data.layers, { assets: data.assets ?? {}, problems, smartContents: Array.isArray(data.smartContents) ? data.smartContents : [], canvas });
       this.lastLoadProblems = problems;
       s.crop = data.crop ? { ...data.crop } : null;
       s.transform = { ...data.transform };
@@ -11487,7 +12824,7 @@ var ImageEditorController = class {
         annotations: JSON.parse(JSON.stringify(view.annotations))
       };
     }
-    const { layers, assets } = serializeLayers(this.state.layers);
+    const { layers, assets, smartContents } = serializeLayers(this.state.layers);
     const out = {
       version: LAYERED_SCHEMA_VERSION,
       width,
@@ -11502,6 +12839,7 @@ var ImageEditorController = class {
     if (this.state.legacyOutputBlur !== void 0) out.legacyOutputBlur = this.state.legacyOutputBlur;
     if (this.state.globalLight) out.globalLight = { ...this.state.globalLight };
     if (this.state.patterns?.length) out.patterns = serializePatterns(this.state.patterns);
+    if (smartContents) out.smartContents = smartContents;
     return out;
   }
 };
@@ -11636,6 +12974,12 @@ function collectStateTiles(layers, into) {
   for (const l of flattenLayers(layers)) {
     if (l.type === "pixel" && l.source !== "document") collectTiles(l.surface, into);
     if (l.mask && !l.mask.source) collectTiles(l.mask.surface, into);
+    if (l.type === "smart") {
+      collectTiles(l.surface, into);
+      if (l.smartFilters?.mask) collectTiles(l.smartFilters.mask.surface, into);
+      if (l.contents.raster) collectTiles(l.contents.raster, into);
+      if (l.contents.document) collectStateTiles(l.contents.document.layers, into);
+    }
   }
 }
 function pixelsOnly(layers) {
@@ -11868,7 +13212,7 @@ function loadImageEditorDocument(input) {
   if (state.selection === void 0) delete state.selection;
   return { state, report: result.report, unknown: result.unknown };
 }
-var LAYER_TYPES = /* @__PURE__ */ new Set(["pixel", "adjustment", "group", "annotation"]);
+var LAYER_TYPES = /* @__PURE__ */ new Set(["pixel", "adjustment", "group", "annotation", "smart"]);
 function cleanLayers(value, dropped) {
   const out = [];
   for (const raw of value) {
@@ -11934,6 +13278,13 @@ function loadLayeredDocument(doc) {
           return { width: mask.width, height: mask.height, rle: v.rle };
         },
         defaults: void 0
+      },
+      smartContents: {
+        parse: (value) => {
+          if (!Array.isArray(value)) throw new Error("smartContents must be an array");
+          return value.filter((c) => isObject(c) && typeof c.id === "string").map((c) => JSON.parse(JSON.stringify(c)));
+        },
+        defaults: void 0
       }
     },
     { currentVersion: 3, steps: {} }
@@ -11947,6 +13298,7 @@ function loadLayeredDocument(doc) {
   const state = { version: 3, ...result.value };
   if (state.selection === void 0) delete state.selection;
   if (state.legacyOutputBlur === void 0) delete state.legacyOutputBlur;
+  if (state.smartContents === void 0) delete state.smartContents;
   return { state, report: result.report, unknown: result.unknown };
 }
 
@@ -12766,6 +14118,13 @@ function describeLayer(layer, activeId, boundsOf) {
       out.collapsed = Boolean(layer.collapsed);
       out.children = layer.children.map((c) => describeLayer(c, activeId, boundsOf));
       break;
+    case "smart":
+      out.bounds = boundsOf(layer);
+      out.fillOpacity = round3(layer.fillOpacity ?? 1);
+      out.contents = { id: layer.contents.id, name: layer.contents.name, kind: layer.contents.kind, width: layer.contents.width, height: layer.contents.height };
+      out.smartFilters = (layer.smartFilters?.filters ?? []).map((f) => ({ id: f.id, kind: f.kind, enabled: f.enabled }));
+      out.filterMask = maskSummary(layer.smartFilters?.mask);
+      break;
   }
   return out;
 }
@@ -13735,7 +15094,11 @@ var WRITE4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: fals
 var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var TARGET = {
   layerId: { type: "string", description: "Layer to paint (default the active layer; see list_layers)." },
-  channel: { type: "string", enum: ["pixels", "mask"], description: "pixels (default for a pixel layer) or the layer's mask: black hides, white reveals." }
+  channel: {
+    type: "string",
+    enum: ["pixels", "mask", "filter-mask"],
+    description: "pixels (default for a pixel layer), the layer's mask, or a smart object's smart filter mask (filter-mask): black hides, white reveals."
+  }
 };
 var BRUSH = {
   type: "object",
@@ -14072,7 +15435,7 @@ function createImageTransformTools(controller) {
   const getFrame = {
     name: "get_transform_frame",
     title: "Get the Free Transform frame",
-    description: "Returns what a transform would move and its frame: content (layer, selection, selection-copy or selection-outline), moved (pixels, mask, selection), the frame (document bounds of the content), its corners [top-left, top-right, bottom-right, bottom-left] and centre. Pass meshColumns / meshRows to also get the identity warp mesh over the frame to edit for warp_layer. Changes nothing.",
+    description: "Returns what a transform would move and its frame: content (layer, selection, selection-copy or selection-outline), moved (pixels, mask, selection), the frame (document bounds of the content), its corners [top-left, top-right, bottom-right, bottom-left] and centre. For a smart object (smartObject true) the frame is the contents\u2019 rectangle in contents pixels and the corners are where they land now. Pass meshColumns / meshRows to also get the identity warp mesh over the frame to edit for warp_layer. Changes nothing.",
     inputSchema: {
       type: "object",
       properties: {
@@ -14094,9 +15457,10 @@ function createImageTransformTools(controller) {
         content: args.content === "selection-copy" ? "selection-copy" : s.content,
         moved: [...s.moves],
         frame: { ...s.box },
-        corners: identityTransform(s.box).corners.map(roundPoint),
-        center: roundPoint({ x: s.box.x + s.box.width / 2, y: s.box.y + s.box.height / 2 })
+        corners: s.startGeometry.corners.map(roundPoint),
+        center: roundPoint(anchorPoint(s.startGeometry, "center"))
       };
+      if (s.smartObject) out.smartObject = true;
       s.cancel();
       if (args.meshColumns !== void 0) {
         const cols = args.meshColumns;
@@ -14225,6 +15589,366 @@ function createImageTransformTools(controller) {
   return [getFrame, transformLayer, warpLayer, transformSelection, flipLayer, rotate90];
 }
 
+// src/image-editor/smart-tools.ts
+var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE5 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var round5 = (n, digits = 3) => Math.round(n * 10 ** digits) / 10 ** digits;
+var roundPoint2 = (p) => ({ x: round5(p.x), y: round5(p.y) });
+var LAYER_ID4 = { type: "string", description: "Smart object layer id from list_layers (type smart)." };
+var FILTER_ID = { type: "string", description: "Smart filter id from get_smart_object or add_smart_filter." };
+var POINT2 = {
+  type: "object",
+  properties: { x: { type: "number", description: "Document pixels from the left." }, y: { type: "number", description: "Document pixels from the top." } },
+  required: ["x", "y"],
+  additionalProperties: false
+};
+var FILTER_BLENDS = BLEND_MODES.map((m) => m.id).filter((m) => m !== "pigment");
+var FILTER_SETTINGS = {
+  enabled: { type: "boolean", description: "false keeps the filter but skips it (the eye in the Layers panel; default true)." },
+  blend: { type: "string", enum: FILTER_BLENDS, description: "How the filter\u2019s result blends with the result below it (Blending Options; default normal)." },
+  opacity: { type: "number", minimum: 0, maximum: 1, description: "Strength of the filter\u2019s result over the result below it, 0..1 (default 1)." },
+  radius: { type: "number", minimum: 0, maximum: 50, description: "blur: box radius in px (default 2)." },
+  brightness: { type: "number", minimum: -100, maximum: 100, description: "develop: -100..100 (default 0)." },
+  contrast: { type: "number", minimum: -100, maximum: 100, description: "develop: -100..100 (default 0)." },
+  saturation: { type: "number", minimum: -100, maximum: 100, description: "develop: -100..100 (default 0)." },
+  exposure: { type: "number", minimum: -100, maximum: 100, description: "develop: -100..100 (default 0)." },
+  temperature: { type: "number", minimum: -100, maximum: 100, description: "develop: -100..100 blue to yellow (default 0)." },
+  tint: { type: "number", minimum: -100, maximum: 100, description: "develop: -100..100 green to magenta (default 0)." }
+};
+function settingsFrom(args) {
+  const out = {};
+  for (const k of Object.keys(FILTER_SETTINGS)) if (args[k] !== void 0) out[k] = args[k];
+  return out;
+}
+function imageArg(image) {
+  if (typeof image !== "string" || !image.trim()) throw new LayerOperationError("image is required: a PNG as a data URL or base64 (other formats need a browser).");
+  return image.trim();
+}
+function createImageSmartObjectTools(controller) {
+  const smartId = (id) => {
+    if (typeof id !== "string" || !id) throw new LayerOperationError("layerId is required (a smart object id from list_layers).");
+    requireSmartObject(controller.getLayers(), id);
+    return id;
+  };
+  const info = (id) => {
+    const i = controller.getSmartObject(id);
+    return {
+      ...i,
+      placement: { ...i.placement, corners: i.placement.corners.map(roundPoint2), center: roundPoint2(i.placement.center), scaleX: round5(i.placement.scaleX), scaleY: round5(i.placement.scaleY), rotate: round5(i.placement.rotate), skewX: round5(i.placement.skewX) }
+    };
+  };
+  const layerSummary = (id) => {
+    const s = controller.getState();
+    const loc = findLayer(s.layers, id);
+    return loc ? { ...describeLayer(loc.layer, s.activeLayerId, (x) => controller.getLayerBounds(x.id)), parentId: loc.parent?.id ?? null, index: loc.index } : null;
+  };
+  const getSmart = {
+    name: "get_smart_object",
+    title: "Read a smart object",
+    description: "Returns a smart object\u2019s contents (id shared by linked instances, name, kind raster or document, pixel size, the file type it came from, the instances placed from it), its placement (corners in document pixels, warp mesh in contents pixels, interpolation, and scale / rotate / skew in percent and degrees of the contents\u2019 own size when affine), its smart filters bottom to top (ids, kind, settings, enabled, blend, opacity; kind psd marks a Photoshop filter kept but not drawn) with the filter mask, and the rendered bounds. Changes nothing.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Read a smart object", ...READ7 },
+    handler: ({ layerId }) => info(smartId(layerId))
+  };
+  const convert = {
+    name: "convert_to_smart_object",
+    title: "Convert to Smart Object",
+    description: "Layer \u203A Smart Objects \u203A Convert to Smart Object: sibling layers become one smart object at the topmost one\u2019s position, so later transforms and filters are non-destructive. One pixel layer keeps its id, name, opacity, blend, fill, mask and effects, and its filters become smart filters (it looks exactly the same); several layers, a group or an adjustment become a nested layer document (edit it with edit_smart_object_contents). One undo step. Returns the new layer and its contents.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerIds: { type: "array", items: { type: "string" }, minItems: 1, description: "Sibling layer ids from list_layers (default the active layer)." },
+        name: { type: "string", description: "Name of the smart object (default the top layer\u2019s name)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Convert to Smart Object", ...WRITE6 },
+    handler: ({ layerIds, name }) => {
+      for (const id2 of layerIds ?? []) requireLayer(controller.getLayers(), id2);
+      const id = controller.convertToSmartObject(layerIds, { name });
+      return { layer: layerSummary(id), smartObject: info(id) };
+    }
+  };
+  const rasterize = {
+    name: "rasterize_smart_object",
+    title: "Rasterize a smart object",
+    description: "Layer \u203A Smart Objects \u203A Rasterize: the smart object becomes a pixel layer holding what it shows now (smart filters baked; same id, mask, effects, opacity, blend and fill). The contents, placement and filters are gone, so later transforms resample the pixels. One undo step. Returns the layer.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Rasterize a smart object", ...DESTRUCTIVE5 },
+    handler: ({ layerId }) => ({ layer: layerSummary(controller.rasterizeSmartObject(smartId(layerId))) })
+  };
+  const setTransform = {
+    name: "set_smart_object_transform",
+    title: "Set a smart object\u2019s transform",
+    description: "Sets where a smart object\u2019s contents land, absolutely (not relative to the current transform), and renders it again from the contents, so nothing degrades however often it is transformed. Give at most one of: corners (Distort / Perspective), matrix (contents pixels \u2192 document), or the numbers scaleX / scaleY (percent of the contents\u2019 own size), rotate, skewX, skewY and x, y (where the contents\u2019 centre goes; unset numbers keep their current values). warp sets a preset or a mesh in contents pixels (null removes it); with nothing else given the corners stay. A linked mask follows a warp-free change. For a relative nudge use transform_layer. One undo step. Returns the placement and bounds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID4,
+        corners: { type: "array", items: POINT2, minItems: 4, maxItems: 4, description: "Where the contents\u2019 corners land: [top-left, top-right, bottom-right, bottom-left] in document pixels. The quad must stay convex." },
+        matrix: { type: "array", items: { type: "number" }, minItems: 6, maxItems: 6, description: "Affine map from contents pixels to document pixels [a, b, c, d, e, f] (x' = a\xB7x + c\xB7y + e, y' = b\xB7x + d\xB7y + f)." },
+        scaleX: { type: "number", description: "Width in percent of the contents\u2019 own width (negative flips)." },
+        scaleY: { type: "number", description: "Height in percent of the contents\u2019 own height (negative flips)." },
+        rotate: { type: "number", description: "Rotation in degrees, clockwise." },
+        skewX: { type: "number", minimum: -89, maximum: 89, description: "Horizontal skew in degrees." },
+        skewY: { type: "number", minimum: -89, maximum: 89, description: "Vertical skew in degrees." },
+        x: { type: "number", description: "Document x of the contents\u2019 centre (default where it is now)." },
+        y: { type: "number", description: "Document y of the contents\u2019 centre (default where it is now)." },
+        warp: {
+          description: "A warp over the contents: a preset {style, bend, horizontal, vertical, orientation}, a mesh {columns, rows, points} in contents pixels, or null to remove the warp. Omit to keep the current warp.",
+          anyOf: [
+            { type: "null" },
+            {
+              type: "object",
+              properties: {
+                style: { type: "string", enum: WARP_STYLES, description: "Preset (Photoshop\u2019s menu)." },
+                bend: { type: "number", minimum: -100, maximum: 100, description: "Bend in percent (default 50)." },
+                horizontal: { type: "number", minimum: -100, maximum: 100, description: "Horizontal distortion in percent (default 0)." },
+                vertical: { type: "number", minimum: -100, maximum: 100, description: "Vertical distortion in percent (default 0)." },
+                orientation: { type: "string", enum: ["horizontal", "vertical"], description: "Bend axis (default horizontal)." }
+              },
+              required: ["style"],
+              additionalProperties: false
+            },
+            {
+              type: "object",
+              properties: {
+                columns: { type: "integer", minimum: 1, maximum: 16, description: "Patch columns." },
+                rows: { type: "integer", minimum: 1, maximum: 16, description: "Patch rows." },
+                points: { type: "array", items: POINT2, minItems: 16, description: "The (3\xB7columns + 1) \xD7 (3\xB7rows + 1) control points row by row, in contents pixels (0..width \xD7 0..height is no warp)." }
+              },
+              required: ["columns", "rows", "points"],
+              additionalProperties: false
+            }
+          ]
+        },
+        interpolation: { type: "string", enum: INTERPOLATIONS, description: "Resampling: nearest, bilinear or bicubic (default: as before, bicubic for new smart objects)." }
+      },
+      required: ["layerId"],
+      additionalProperties: false
+    },
+    annotations: { title: "Set a smart object\u2019s transform", ...WRITE_IDEMPOTENT4 },
+    handler: (args) => {
+      const id = smartId(args.layerId);
+      let warp;
+      const w = args.warp;
+      if (w === null) warp = null;
+      else if (w && "style" in w) warp = { style: w.style, bend: w.bend ?? 50, horizontal: w.horizontal, vertical: w.vertical, orientation: w.orientation };
+      else if (w) {
+        const m = w;
+        const want = (3 * m.columns + 1) * (3 * m.rows + 1);
+        if (m.points.length !== want) throw new LayerOperationError(`A ${m.columns} \xD7 ${m.rows} mesh needs (3\xB7${m.columns} + 1) \xD7 (3\xB7${m.rows} + 1) = ${want} points, got ${m.points.length}.`);
+        const knots = (n) => Array.from({ length: n + 1 }, (_, i) => i / n);
+        warp = { us: knots(m.columns), vs: knots(m.rows), points: m.points.map((p) => ({ x: p.x, y: p.y })) };
+      }
+      const keys = ["corners", "matrix", "scaleX", "scaleY", "rotate", "skewX", "skewY", "x", "y", "warp", "interpolation"];
+      if (!keys.some((k) => args[k] !== void 0)) throw new LayerOperationError(`Give something to set: ${keys.join(", ")}.`);
+      const res = controller.setSmartObjectTransform(id, {
+        corners: args.corners,
+        matrix: args.matrix,
+        scaleX: args.scaleX,
+        scaleY: args.scaleY,
+        rotate: args.rotate,
+        skewX: args.skewX,
+        skewY: args.skewY,
+        x: args.x,
+        y: args.y,
+        warp,
+        interpolation: args.interpolation
+      });
+      return { layerId: id, placement: info(id).placement, masksMoved: res.masksMoved, bounds: controller.getLayerBounds(id) };
+    }
+  };
+  const replace = {
+    name: "replace_smart_object_contents",
+    title: "Replace a smart object\u2019s contents",
+    description: "Layer \u203A Smart Objects \u203A Replace Contents: new raster contents from an image for the smart object and every linked instance (same contents id). Each instance keeps its scale and rotation about the contents\u2019 centre and its smart filters, and renders again. One undo step. Returns the contents id, the new size and the layers that changed.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID4,
+        image: { type: "string", description: "The new contents: a PNG as a data URL or base64 (other formats and URLs need a browser)." },
+        name: { type: "string", description: "File name of the contents (default the old name with .png)." }
+      },
+      required: ["layerId", "image"],
+      additionalProperties: false
+    },
+    annotations: { title: "Replace a smart object\u2019s contents", ...DESTRUCTIVE5 },
+    handler: async ({ layerId, image, name }) => controller.replaceSmartObjectContentsFromImage(smartId(layerId), imageArg(image), name)
+  };
+  const exportContents = {
+    name: "export_smart_object_contents",
+    title: "Export a smart object\u2019s contents",
+    description: "Layer \u203A Smart Objects \u203A Export Contents: the contents as a file, base64: the file they came from while unedited (a PSB, PNG, JPEG\u2026), else a PNG for raster contents or a PSD / PSB of a nested document. Returns name, mimeType, byteLength and base64. Changes nothing.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Export a smart object\u2019s contents", ...READ7 },
+    handler: ({ layerId }) => {
+      const f = controller.exportSmartObjectContents(smartId(layerId));
+      return { name: f.name, mimeType: f.mimeType, byteLength: f.bytes.length, base64: bytesToBase64(f.bytes) };
+    }
+  };
+  const copy = {
+    name: "copy_smart_object",
+    title: "Copy a smart object",
+    description: "Duplicates a smart object directly above it. linked true (Duplicate Layer) shares the contents, so editing or replacing them changes both; linked false (Layer \u203A Smart Objects \u203A New Smart Object via Copy) gives the copy its own contents. Placement, filters, mask and effects are copied either way. One undo step. Returns the copy.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID4,
+        linked: { type: "boolean", description: "true shares the contents with the original; false (default) makes independent contents." },
+        name: { type: "string", description: 'Name of the copy (default "<name> copy").' }
+      },
+      required: ["layerId"],
+      additionalProperties: false
+    },
+    annotations: { title: "Copy a smart object", ...WRITE6 },
+    handler: ({ layerId, linked, name }) => {
+      const id = controller.copySmartObject(smartId(layerId), linked === true, name);
+      return { layer: layerSummary(id), contentsId: controller.getSmartObject(id).contents.id };
+    }
+  };
+  const editContents = {
+    name: "edit_smart_object_contents",
+    title: "Edit a smart object\u2019s contents",
+    description: 'Layer \u203A Smart Objects \u203A Edit Contents: opens the contents as a document of their own (a layer document, or raster contents as one pixel layer "Layer 0") with their own undo history. Every other tool (list_layers, paint, adjustments\u2026) then works inside the contents until close_smart_object_contents saves them back. Contents can nest. Returns the contents\u2019 size and layers.',
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Edit a smart object\u2019s contents", ...WRITE6 },
+    handler: ({ layerId }) => {
+      const res = controller.editSmartObjectContents(smartId(layerId));
+      const s = controller.getState();
+      return { ...res, editing: controller.getEditingContents(), layers: s.layers.map((l) => describeLayer(l, s.activeLayerId, (x) => controller.getLayerBounds(x.id))) };
+    }
+  };
+  const closeContents = {
+    name: "close_smart_object_contents",
+    title: "Close a smart object\u2019s contents",
+    description: "Closes the contents opened with edit_smart_object_contents. save true (default) writes the edits back: the smart object and every linked instance render again, as one undo step in the document; save false drops them. Returns the smart object, whether it changed, the layers that changed and what is still open.",
+    inputSchema: {
+      type: "object",
+      properties: { save: { type: "boolean", description: "true (default) saves the edits into the smart object; false discards them." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Close a smart object\u2019s contents", ...WRITE6 },
+    handler: ({ save }) => ({ ...controller.closeSmartObjectContents(save !== false), editing: controller.getEditingContents() })
+  };
+  const addFilter = {
+    name: "add_smart_filter",
+    title: "Add a smart filter",
+    description: "Adds a smart filter to a smart object: develop (brightness, contrast, saturation, exposure, temperature, tint) or blur (radius px), with its own blend mode and opacity over the result below it. Filters run bottom to top on the placed contents, then the filter mask mixes in the unfiltered contents. Unlike layer filters, a kind can repeat. One undo step. Returns the filter (with its id) and the stack.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID4,
+        kind: { type: "string", enum: ["develop", "blur"], description: "Filter kind." },
+        index: { type: "integer", minimum: 0, description: "Position in the stack, 0 = bottom, applied first (default the top)." },
+        ...FILTER_SETTINGS
+      },
+      required: ["layerId", "kind"],
+      additionalProperties: false
+    },
+    annotations: { title: "Add a smart filter", ...WRITE6 },
+    handler: (args) => {
+      const id = smartId(args.layerId);
+      const filter = controller.addSmartFilter(id, { kind: args.kind, ...settingsFrom(args) }, args.index);
+      return { layerId: id, filter, smartFilters: info(id).smartFilters };
+    }
+  };
+  const updateFilter = {
+    name: "update_smart_filter",
+    title: "Change a smart filter",
+    description: "Changes one smart filter: its settings, enabled, blend or opacity (only the given values; the kind cannot change). A Photoshop filter kept from a PSD (kind psd) only takes enabled, blend and opacity. One undo step. Returns the filter and the stack.",
+    inputSchema: {
+      type: "object",
+      properties: { layerId: LAYER_ID4, filterId: FILTER_ID, ...FILTER_SETTINGS },
+      required: ["layerId", "filterId"],
+      additionalProperties: false
+    },
+    annotations: { title: "Change a smart filter", ...WRITE_IDEMPOTENT4 },
+    handler: (args) => {
+      const id = smartId(args.layerId);
+      const changes = settingsFrom(args);
+      if (!Object.keys(changes).length) throw new LayerOperationError("Give at least one value to change.");
+      const filter = controller.updateSmartFilter(id, args.filterId, changes);
+      return { layerId: id, filter, smartFilters: info(id).smartFilters };
+    }
+  };
+  const removeFilter = {
+    name: "remove_smart_filter",
+    title: "Remove a smart filter",
+    description: "Removes one smart filter (the filter mask goes with the last one). One undo step. Returns the remaining stack.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID4, filterId: FILTER_ID }, required: ["layerId", "filterId"], additionalProperties: false },
+    annotations: { title: "Remove a smart filter", ...DESTRUCTIVE5 },
+    handler: ({ layerId, filterId }) => {
+      const id = smartId(layerId);
+      controller.removeSmartFilter(id, filterId);
+      return { layerId: id, smartFilters: info(id).smartFilters };
+    }
+  };
+  const moveFilter = {
+    name: "move_smart_filter",
+    title: "Reorder a smart filter",
+    description: "Moves one smart filter to a position in the stack (0 = bottom, applied first), as dragging it in the Layers panel. One undo step. Returns the stack in its new order.",
+    inputSchema: {
+      type: "object",
+      properties: { layerId: LAYER_ID4, filterId: FILTER_ID, index: { type: "integer", minimum: 0, description: "New position, 0 = bottom (applied first)." } },
+      required: ["layerId", "filterId", "index"],
+      additionalProperties: false
+    },
+    annotations: { title: "Reorder a smart filter", ...WRITE_IDEMPOTENT4 },
+    handler: ({ layerId, filterId, index }) => {
+      const id = smartId(layerId);
+      controller.moveSmartFilter(id, filterId, index);
+      return { layerId: id, smartFilters: info(id).smartFilters };
+    }
+  };
+  const setEnabled = {
+    name: "set_smart_filters_enabled",
+    title: "Turn smart filters on or off",
+    description: "Layer \u203A Smart Filter \u203A Disable / Enable Smart Filters: switches the whole stack; each filter keeps its own enabled flag. One undo step. Returns the stack.",
+    inputSchema: {
+      type: "object",
+      properties: { layerId: LAYER_ID4, enabled: { type: "boolean", description: "false hides every smart filter; true shows them again." } },
+      required: ["layerId", "enabled"],
+      additionalProperties: false
+    },
+    annotations: { title: "Turn smart filters on or off", ...WRITE_IDEMPOTENT4 },
+    handler: ({ layerId, enabled }) => {
+      const id = smartId(layerId);
+      controller.setSmartFiltersEnabled(id, enabled === true);
+      return { layerId: id, smartFilters: info(id).smartFilters };
+    }
+  };
+  const setMask = {
+    name: "set_smart_filter_mask",
+    title: "Set the smart filter mask",
+    description: "Sets the one filter mask of a smart object\u2019s smart filters, which says where the filtered result shows over the unfiltered contents: from reveal-all (white), hide-all (black), selection (the selection\u2019s coverage) or none (remove it); keep changes only its properties. Paint it with paint_stroke channel filter-mask. One undo step. Returns the mask summary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: LAYER_ID4,
+        from: { type: "string", enum: ["reveal-all", "hide-all", "selection", "none", "keep"], description: "What the mask starts from; none removes it; keep only changes the properties below." },
+        density: { type: "number", minimum: 0, maximum: 1, description: "How much hidden areas hide, 0..1 (default 1)." },
+        feather: { type: "number", minimum: 0, maximum: 1e3, description: "Gaussian softening in px (default 0)." },
+        enabled: { type: "boolean", description: "false keeps the mask but ignores it." },
+        linked: { type: "boolean", description: "false keeps the mask in place when the smart object is transformed or moved (default linked)." }
+      },
+      required: ["layerId", "from"],
+      additionalProperties: false
+    },
+    annotations: { title: "Set the smart filter mask", ...WRITE6 },
+    handler: (args) => {
+      const id = smartId(args.layerId);
+      const props = {};
+      for (const k of ["density", "feather", "enabled", "linked"]) if (args[k] !== void 0) props[k] = args[k];
+      const mask = controller.setSmartFilterMask(id, args.from, props);
+      return { layerId: id, filterMask: maskSummary(mask ?? void 0) };
+    }
+  };
+  return [getSmart, convert, rasterize, setTransform, replace, exportContents, copy, editContents, closeContents, addFilter, updateFilter, removeFilter, moveFilter, setEnabled, setMask];
+}
+
 // src/image-editor/tools.ts
 var LAYER_PATH = /^layers\.([^.]+)\.(.+)$/;
 function adjustmentsSummary(adjustments) {
@@ -14463,6 +16187,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageEditTools(controller),
       ...createImageLayerTools(controller),
       ...createImageTransformTools(controller),
+      ...createImageSmartObjectTools(controller),
       ...createImageEffectTools(controller),
       ...createImagePaintTools(controller),
       ...createPigmentTools(),
@@ -14801,6 +16526,8 @@ function layerBadge(layer) {
       return "grp";
     case "annotation":
       return layer.annotation.type === "text" ? "T" : "ann";
+    case "smart":
+      return "so";
   }
 }
 function dropZone(fraction, isGroup) {
@@ -14840,7 +16567,11 @@ function layerMenu(controller) {
     { action: "delete-mask", label: "Delete Layer Mask", enabled: Boolean(active?.mask) },
     { action: "toggle-mask", label: active?.mask?.enabled === false ? "Enable Layer Mask" : "Disable Layer Mask", enabled: Boolean(active?.mask) },
     { action: "toggle-mask-link", label: active?.mask?.linked === false ? "Link Layer Mask" : "Unlink Layer Mask", enabled: Boolean(active?.mask && !active.mask.source) },
-    { action: "rasterize", label: "Rasterize Layer", enabled: active?.type === "annotation" || isPixel && Boolean(active?.type === "pixel" && active.filters?.length) },
+    { action: "rasterize", label: "Rasterize Layer", enabled: active?.type === "annotation" || active?.type === "smart" || isPixel && Boolean(active?.type === "pixel" && active.filters?.length) },
+    { action: "convert-smart", label: "Convert to Smart Object", enabled: Boolean(active && active.type !== "annotation") },
+    { action: "edit-contents", label: "Edit Contents", enabled: active?.type === "smart" },
+    { action: "smart-via-copy", label: "New Smart Object via Copy", enabled: active?.type === "smart" },
+    { action: "add-filter-mask", label: "Add Smart Filter Mask", enabled: active?.type === "smart" && !active.smartFilters?.mask },
     { action: "toggle-clip", label: active?.clipped ? "Release Clipping Mask" : "Create Clipping Mask", enabled: Boolean(loc && loc.index > 0) }
   ];
 }
@@ -14901,6 +16632,18 @@ async function runLayerMenuAction(controller, action) {
       case "rasterize":
         if (id) await controller.rasterizeLayer(id);
         break;
+      case "convert-smart":
+        if (id) controller.convertToSmartObject([id]);
+        break;
+      case "edit-contents":
+        if (id) controller.editSmartObjectContents(id);
+        break;
+      case "smart-via-copy":
+        if (id) controller.copySmartObject(id, false);
+        break;
+      case "add-filter-mask":
+        if (id) controller.setSmartFilterMask(id, "reveal-all");
+        break;
       case "toggle-clip":
         if (id) controller.setLayerProperties(id, { clipped: !active?.clipped });
         break;
@@ -14910,6 +16653,17 @@ async function runLayerMenuAction(controller, action) {
     return err instanceof Error ? err.message : String(err);
   }
 }
+function smartFilterRows(layer) {
+  if (layer.type !== "smart") return [];
+  const list2 = layer.smartFilters?.filters ?? [];
+  const rows = list2.map((f, index) => ({
+    filter: f,
+    index,
+    drawn: f.kind !== "psd",
+    label: f.kind === "psd" ? f.name.replace(/&/g, "").replace(/\.\.\.$/, "") : f.kind === "blur" ? `Blur (${f.radius} px)` : "Develop"
+  }));
+  return rows.reverse();
+}
 
 // src/image-editor/layers/effects-ui.ts
 function layerEffectsPanel(layer) {
@@ -15267,7 +17021,7 @@ var FreeTransformTool = class {
       this.corners = s.geometry.corners;
       this.refBox = { x: s.box.x + s.box.width / 2, y: s.box.y + s.box.height / 2 };
       this.modeValue = "scale";
-      this.mesh = null;
+      this.mesh = s.geometry.warp ?? null;
       this.warpSettings = { style: "custom", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", columns: 1, rows: 1 };
       this.typed = {};
       this.error = null;
@@ -15770,6 +17524,7 @@ export {
   SELECTION_MODE_LABELS,
   SELECTION_MODIFY_OPS,
   SELECTION_TOOLS,
+  SMART_RENDER_MARGIN,
   SUPPORTED_ADJUSTMENT_KEYS,
   SelectionGesture,
   StrokeCoverage,
@@ -15790,8 +17545,10 @@ export {
   XYZ_D50_TO_SRGB,
   ZlibError,
   activeAdjustmentLayers,
+  activeSmartFilters,
   addLayerEffect,
   addLayerFilter,
+  addSmartFilter,
   addToHistogram,
   adjustmentKindLabel,
   adjustmentLayersKey,
@@ -15814,6 +17571,7 @@ export {
   applyProcess2Adjustments,
   applyRegionBlur,
   applyRegionMosaic,
+  applySmartFilters,
   applyStrokeToTile,
   backgroundLayer,
   base64ToBytes,
@@ -15853,9 +17611,13 @@ export {
   computeHistogram,
   computeSelectionBounds,
   contentBounds,
+  contentsBox,
+  contentsSurface,
   contractCoverage,
   controlPosition,
   controlTrackBackground,
+  convertToSmartObject,
+  copySmartObject,
   cornersFromMatrix,
   coverageTileCoord,
   coverageToByte,
@@ -15869,6 +17631,7 @@ export {
   createImagePaintTools,
   createImagePsdTools,
   createImageSelectionTools,
+  createImageSmartObjectTools,
   createImageTransformTools,
   createPigment,
   createPigmentTools,
@@ -15906,6 +17669,7 @@ export {
   developFromAdjustments,
   developTarget,
   distanceTransform,
+  documentContents,
   downloadPsd,
   dragWarpMeshPoint,
   dropPlacement,
@@ -15932,6 +17696,7 @@ export {
   exportPsd,
   featherCoverage,
   fillRect,
+  filterMaskCoverage,
   findAdjustmentControl,
   findLayer,
   findLayerControl,
@@ -15956,6 +17721,7 @@ export {
   handlePaintShortcut,
   hasActiveEffects,
   hasResampledLegacyMask,
+  hasSurface,
   hasWarp,
   hashMaskContent,
   hashNoise,
@@ -15982,12 +17748,14 @@ export {
   inflateRaw,
   insertCurvePoint,
   insertLayer,
+  instancesOf,
   invertHomography,
   invertMatrix3,
   invertSelection,
   isActiveFilter,
   isAdjustmentKind,
   isBlendMode,
+  isContentsDecoded,
   isDefaultDepthMask,
   isIdentityTransform,
   isInterpolation,
@@ -16049,9 +17817,11 @@ export {
   modifySelection,
   moveCurvePoint,
   moveLayer,
+  moveSmartFilter,
   mulMatrix3,
   needsLegacyBase,
   neutralHueRange,
+  newContentsId,
   newEffectId,
   newLayerId,
   normalizeAdjustmentLayer,
@@ -16063,11 +17833,14 @@ export {
   normalizeLayerEffects,
   normalizeLayerMask,
   normalizeMixer,
+  normalizePlacement,
   normalizeProcessVersion,
   normalizeRect,
   normalizeRefineEdgeParams,
+  normalizeSmartFilter,
   normalizeStoredAdjustments,
   offsetLayer,
+  offsetSmartObject,
   openPsdFile,
   packRgba,
   parseAdjustmentBlock,
@@ -16083,7 +17856,11 @@ export {
   photoFilterMatrix,
   pixelLayerBounds,
   pixelLayers,
+  placeContents,
   placeLayer,
+  placementAt,
+  placementBounds,
+  placementGeometry,
   pngDataUrl,
   pointerPressure,
   polygonCoverage,
@@ -16102,8 +17879,10 @@ export {
   pullWarpMesh,
   quickMaskPixels,
   rangeLightness,
+  rasterContents,
   rasterMaskFromLegacy,
   rasterizeDab,
+  rasterizeSmartObject,
   readAdjustmentControls,
   readPixel,
   readPsd,
@@ -16121,10 +17900,15 @@ export {
   removeLayer,
   removeLayerEffect,
   removeLayerFilter,
+  removeSmartFilter,
   renderLayerEffects,
   renderLayeredBase,
+  renderSmartObject,
+  replaceContents,
   requireLayer,
+  requireSmartObject,
   requireUnlocked,
+  rerender,
   resizePixels,
   resizeSelection,
   resizeWarpMesh,
@@ -16134,6 +17918,7 @@ export {
   rgbToHsl,
   rgbToReflectance,
   rgbUnitToHex,
+  runLayerFilters,
   runLayerMenuAction,
   sampleLut,
   sampleToneLut,
@@ -16146,6 +17931,7 @@ export {
   selectionToCoverage,
   selectionToPixels,
   selectionValueAt,
+  serializeContents,
   serializeEffects,
   serializeLayer,
   serializeLayers,
@@ -16159,7 +17945,12 @@ export {
   setLayerProperties,
   setLum,
   setPigmentColor,
+  setSmartFilterMask,
+  setSmartFiltersEnabled,
+  setSmartPlacement,
   shiftCoverage,
+  smartFilterRows,
+  smartObjectLayers,
   smoothCoverage,
   smoothPoints,
   solidSurface,
@@ -16197,6 +17988,7 @@ export {
   updateLayerEffect,
   updateLayerFilter,
   updateLayerMaskProps,
+  updateSmartFilter,
   uvToXy,
   validateEffectGradient,
   validateLayerEffect,
@@ -16213,6 +18005,7 @@ export {
   wbMatrix,
   whiteBalanceFromSample,
   whiteBalanceMatrix,
+  withFilterMaskSurface,
   withNewIds,
   writeAdjustmentBlock,
   writeLfx2,