@pixerate/editor 0.211.0 → 0.213.0

package/dist/{chunk-3T5VCDIV.cjs → chunk-LCCMOWR7.cjs}

@@ -1,6 +1,18 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
+
+
+
+
+var _chunkQAUIZPYIcjs = require('./chunk-QAUIZPYI.cjs');
+
+
+var _chunkGF2RBSDMcjs = require('./chunk-GF2RBSDM.cjs');
+
+
+
+
 var _chunkNM3G4VQTcjs = require('./chunk-NM3G4VQT.cjs');
 
 // src/vector/trace.ts
@@ -1342,6 +1354,412 @@ async function unwoff(view) {
   return o;
 }
 
+// src/vector/pathEdit.ts
+var EPS = 1e-9;
+var unit = (x, y) => {
+  const l = Math.hypot(x, y);
+  return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
+};
+function cubicOf(sp, i) {
+  const s = _chunkQAUIZPYIcjs.subpathSegment.call(void 0, sp, i);
+  if (s.length === 4) return s;
+  const [a, b] = s;
+  return [a, [a[0] + (b[0] - a[0]) / 3, a[1] + (b[1] - a[1]) / 3], [a[0] + 2 * (b[0] - a[0]) / 3, a[1] + 2 * (b[1] - a[1]) / 3], b];
+}
+var isLine = (sp, i) => _chunkQAUIZPYIcjs.subpathSegment.call(void 0, sp, i).length === 2;
+function startTangent(c) {
+  for (let k = 1; k < 4; k++) {
+    const u = unit(c[k][0] - c[0][0], c[k][1] - c[0][1]);
+    if (u) return u;
+  }
+  return [1, 0];
+}
+function endTangent(c) {
+  for (let k = 2; k >= 0; k--) {
+    const u = unit(c[3][0] - c[k][0], c[3][1] - c[k][1]);
+    if (u) return u;
+  }
+  return [1, 0];
+}
+function sample(c, n, out, withStart) {
+  for (let i = withStart ? 0 : 1; i <= n; i++) out.push(_chunkGF2RBSDMcjs.segmentPoint.call(void 0, c, i / n));
+}
+var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
+function tidy(a, keepType = true) {
+  const next = _chunkQAUIZPYIcjs.cloneAnchor.call(void 0, a);
+  if (onAnchor(next, next.in)) delete next.in;
+  if (onAnchor(next, next.out)) delete next.out;
+  const shown = _chunkQAUIZPYIcjs.inferAnchorType.call(void 0, next);
+  const type = keepType && a.type ? a.type === "symmetric" && shown !== "symmetric" ? shown === "corner" ? "corner" : "smooth" : a.type === "smooth" && shown === "corner" ? "corner" : a.type : shown;
+  if (type === "corner") delete next.type;
+  else next.type = type;
+  return next;
+}
+function neighbours(sp, i) {
+  const n = sp.anchors.length;
+  const wrap = sp.closed && n > 1;
+  return [i > 0 ? i - 1 : wrap ? n - 1 : -1, i < n - 1 ? i + 1 : wrap ? 0 : -1];
+}
+function goldenMin(f, a, b) {
+  const R = 0.618033988749895;
+  let x1 = b - R * (b - a);
+  let x2 = a + R * (b - a);
+  let f1 = f(x1);
+  let f2 = f(x2);
+  for (let i = 0; i < 40; i++) {
+    if (f1.error < f2.error || Number.isNaN(f2.error)) {
+      b = x2;
+      x2 = x1;
+      f2 = f1;
+      x1 = b - R * (b - a);
+      f1 = f(x1);
+    } else {
+      a = x1;
+      x1 = x2;
+      f1 = f2;
+      x2 = a + R * (b - a);
+      f2 = f(x2);
+    }
+  }
+  return f1.error <= f2.error ? f1 : f2;
+}
+function fitAcross(pts, N, t0, t1) {
+  const fit = (k) => {
+    const u = [];
+    for (let i = 0; i <= N; i++) u.push(k * i / N);
+    for (let i = 1; i <= N; i++) u.push(k + (1 - k) * i / N);
+    return _chunkNM3G4VQTcjs.fitCubicWithTangents.call(void 0, pts, u, t0, t1);
+  };
+  return goldenMin(fit, 0, 1);
+}
+function removeAnchorKeepingShape(sp, index) {
+  const anchors = sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor);
+  const n = anchors.length;
+  if (index < 0 || index >= n) return { anchors, closed: sp.closed };
+  if ((sp.closed || index > 0 && index < n - 1) && n >= 3) {
+    const pi = (index + n - 1) % n;
+    const ni = (index + 1) % n;
+    if (!(isLine(sp, pi) && isLine(sp, index))) {
+      const left = cubicOf(sp, pi);
+      const right = cubicOf(sp, index);
+      const N = 16;
+      const pts = [];
+      sample(left, N, pts, true);
+      sample(right, N, pts, false);
+      const t0 = startTangent(left);
+      const t1 = endTangent(right);
+      const { curve } = fitAcross(pts, N, t0, t1);
+      if ([curve.p1, curve.p2].every((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]))) {
+        anchors[pi] = tidy({ ...anchors[pi], out: { x: curve.p1[0], y: curve.p1[1] } });
+        anchors[ni] = tidy({ ...anchors[ni], in: { x: curve.p2[0], y: curve.p2[1] } });
+      }
+    }
+  }
+  anchors.splice(index, 1);
+  let closed = sp.closed;
+  if (!closed && anchors.length) {
+    anchors[0] = tidy({ ...anchors[0], in: null });
+    const last = anchors.length - 1;
+    anchors[last] = tidy({ ...anchors[last], out: null });
+  }
+  if (anchors.length < 3) closed = closed && anchors.length === 2 && anchors.some((a) => a.in || a.out);
+  return { anchors, closed };
+}
+function removeAnchorsKeepingShape(sp, indices) {
+  const order = [...new Set(indices)].filter((i) => i >= 0 && i < sp.anchors.length).sort((a, b) => b - a);
+  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor), closed: sp.closed });
+}
+function bendSegment(sp, segment, t, p) {
+  const anchors = sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor);
+  const n = anchors.length;
+  if (segment < 0 || segment >= _chunkQAUIZPYIcjs.subpathSegmentCount.call(void 0, sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
+  const tc = Math.min(0.95, Math.max(0.05, t));
+  const ia = segment;
+  const ib = (segment + 1) % n;
+  const a = anchors[ia];
+  const b = anchors[ib];
+  const k = 3 * tc * (1 - tc);
+  const ox = (p.x - (a.x + (b.x - a.x) * tc)) / k;
+  const oy = (p.y - (a.y + (b.y - a.y) * tc)) / k;
+  const c1 = { x: a.x + (b.x - a.x) / 3 + ox, y: a.y + (b.y - a.y) / 3 + oy };
+  const c2 = { x: b.x + (a.x - b.x) / 3 + ox, y: b.y + (a.y - b.y) / 3 + oy };
+  anchors[ia] = _chunkQAUIZPYIcjs.moveAnchorHandle.call(void 0, a, "out", c1);
+  anchors[ib] = _chunkQAUIZPYIcjs.moveAnchorHandle.call(void 0, b, "in", c2);
+  return { anchors, closed: sp.closed };
+}
+function subpathPointAt(sp, segment, t) {
+  const [x, y] = _chunkGF2RBSDMcjs.segmentPoint.call(void 0, _chunkQAUIZPYIcjs.subpathSegment.call(void 0, sp, segment), t);
+  return { x, y };
+}
+function curvatureMoveAnchor(sp, index, q) {
+  const anchors = sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor);
+  const a = sp.anchors[index];
+  if (!a) return { anchors, closed: sp.closed };
+  const own = [
+    a.in && !onAnchor(a, a.in) ? { x: a.in.x - a.x, y: a.in.y - a.y } : null,
+    a.out && !onAnchor(a, a.out) ? { x: a.out.x - a.x, y: a.out.y - a.y } : null
+  ];
+  const ends = [null, null];
+  neighbours(sp, index).forEach((j, side) => {
+    if (j < 0 || j === index) return;
+    const b = anchors[j];
+    const old = Math.hypot(a.x - b.x, a.y - b.y);
+    const s = old > 1e-9 ? Math.hypot(q.x - b.x, q.y - b.y) / old : 1;
+    const key = side === 0 ? "out" : "in";
+    const h = b[key];
+    if (h) b[key] = { x: b.x + (h.x - b.x) * s, y: b.y + (h.y - b.y) * s };
+    const o = own[side];
+    if (o) own[side] = { x: o.x * s, y: o.y * s };
+    ends[side] = { x: b.x, y: b.y };
+  });
+  const moved = { x: q.x, y: q.y };
+  if (own[0]) moved.in = { x: q.x + own[0].x, y: q.y + own[0].y };
+  if (own[1]) moved.out = { x: q.x + own[1].x, y: q.y + own[1].y };
+  if (a.type) moved.type = a.type;
+  if (a.corner) moved.corner = { ...a.corner };
+  if (a.id) moved.id = a.id;
+  const [prev, next] = ends;
+  if (a.type && a.type !== "corner" && prev && next) {
+    const dx = next.x - prev.x;
+    const dy = next.y - prev.y;
+    const l = Math.hypot(dx, dy);
+    if (l > 1e-9) {
+      const len = (h, to) => h ? Math.hypot(h.x, h.y) : Math.hypot(q.x - to.x, q.y - to.y) / 3;
+      let li = len(own[0], prev);
+      let lo = len(own[1], next);
+      if (a.type === "symmetric") li = lo = (li + lo) / 2;
+      moved.in = { x: q.x - dx * li / l, y: q.y - dy * li / l };
+      moved.out = { x: q.x + dx * lo / l, y: q.y + dy * lo / l };
+    }
+  }
+  anchors[index] = moved;
+  return { anchors, closed: sp.closed };
+}
+function cutSubpathAt(sp, at) {
+  const n = sp.anchors.length;
+  const cuts = [...new Set(at)].filter((i) => Number.isInteger(i) && i >= 0 && i < n && (sp.closed || i > 0 && i < n - 1)).sort((a, b) => a - b);
+  if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor), closed: sp.closed }];
+  const first = cuts[0];
+  const run = sp.closed ? Array.from({ length: n + 1 }, (_, i) => sp.anchors[(first + i) % n]) : sp.anchors;
+  const cutSet = new Set(sp.closed ? [...cuts.map((c) => (c - first + n) % n), n] : cuts);
+  const pieces = [];
+  let cur = [];
+  run.forEach((a, i) => {
+    if (!cutSet.has(i)) {
+      cur.push(_chunkQAUIZPYIcjs.cloneAnchor.call(void 0, a));
+      return;
+    }
+    if (cur.length) {
+      cur.push(tidy({ ...a, out: null }, false));
+      pieces.push({ anchors: cur, closed: false });
+      cur = [];
+    }
+    if (i < n) cur.push(tidy({ ...a, in: null }, false));
+  });
+  if (cur.length > 1) pieces.push({ anchors: cur, closed: false });
+  return pieces;
+}
+function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
+  const n = sp.anchors.length;
+  if (segment < 0 || segment >= _chunkQAUIZPYIcjs.subpathSegmentCount.call(void 0, sp)) return [{ anchors: sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor), closed: sp.closed }];
+  if (t <= endTolerance) return cutSubpathAt(sp, [segment]);
+  if (t >= 1 - endTolerance) return cutSubpathAt(sp, [(segment + 1) % n]);
+  const { subpath, index } = _chunkQAUIZPYIcjs.insertAnchor.call(void 0, sp, segment, t);
+  return cutSubpathAt(subpath, [index]);
+}
+var endOf = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
+var dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function reverse(sp) {
+  return {
+    closed: sp.closed,
+    anchors: sp.anchors.slice().reverse().map((a) => {
+      const next = { x: a.x, y: a.y };
+      if (a.out) next.in = { ...a.out };
+      if (a.in) next.out = { ...a.in };
+      if (a.type) next.type = a.type;
+      if (a.corner) next.corner = { ...a.corner };
+      if (a.id) next.id = a.id;
+      return next;
+    })
+  };
+}
+function joinSubpaths(subpaths, tolerance) {
+  const closed = [];
+  let open = [];
+  for (const sp of subpaths) {
+    const copy = { anchors: sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor), closed: sp.closed };
+    if (sp.closed || sp.anchors.length < 2) {
+      if (sp.anchors.length) closed.push(copy);
+    } else open.push(copy);
+  }
+  if (open.length === 1) {
+    const sp = open[0];
+    const first = sp.anchors[0];
+    const last = sp.anchors[sp.anchors.length - 1];
+    if (sp.anchors.length > 2 && dist(first, last) <= tolerance) {
+      sp.anchors.pop();
+      sp.anchors[0] = tidy({ ...first, in: _nullishCoalesce(last.in, () => ( null)) }, false);
+    } else {
+      sp.anchors[0] = tidy({ ...first, in: null }, false);
+      sp.anchors[sp.anchors.length - 1] = tidy({ ...sp.anchors[sp.anchors.length - 1], out: null }, false);
+    }
+    sp.closed = true;
+    return [...closed, sp];
+  }
+  while (open.length > 1) {
+    let best = { d: Infinity, i: 0, j: 1, ei: true, ej: false };
+    for (let i = 0; i < open.length; i++) {
+      for (let j = i + 1; j < open.length; j++) {
+        for (const ei of [false, true]) {
+          for (const ej of [false, true]) {
+            const d = dist(endOf(open[i], ei), endOf(open[j], ej));
+            if (d < best.d) best = { d, i, j, ei, ej };
+          }
+        }
+      }
+    }
+    let a = open[best.i];
+    let b = open[best.j];
+    open = open.filter((_, k) => k !== best.j);
+    if (!best.ei) a = reverse(a);
+    if (best.ej) b = reverse(b);
+    const anchors = a.anchors;
+    if (best.d <= tolerance) {
+      const [head, ...rest] = b.anchors;
+      const l = anchors[anchors.length - 1];
+      anchors[anchors.length - 1] = tidy({ ...l, out: _nullishCoalesce(head.out, () => ( null)) }, false);
+      anchors.push(...rest);
+    } else {
+      const l = anchors[anchors.length - 1];
+      anchors[anchors.length - 1] = tidy({ ...l, out: null }, false);
+      anchors.push(tidy({ ...b.anchors[0], in: null }, false), ...b.anchors.slice(1));
+    }
+    open[best.i > best.j ? best.i - 1 : best.i] = { anchors, closed: false };
+  }
+  return [...closed, ...open];
+}
+function smoothSubpath(sp, amount = 1, only) {
+  const t = Math.min(1, Math.max(0, amount));
+  const orig = sp.anchors;
+  const n = orig.length;
+  const anchors = orig.map(_chunkQAUIZPYIcjs.cloneAnchor);
+  if (n < 3 || t === 0) return { anchors, closed: sp.closed };
+  for (let i = 0; i < n; i++) {
+    if (!sp.closed && (i === 0 || i === n - 1)) continue;
+    if (only && !only.has(i)) continue;
+    const prev = orig[(i + n - 1) % n];
+    const next = orig[(i + 1) % n];
+    const p = orig[i];
+    const dir = unit(next.x - prev.x, next.y - prev.y);
+    if (!dir) continue;
+    const li = dist(p, prev) / 3;
+    const lo = dist(p, next) / 3;
+    const hin = _nullishCoalesce(p.in, () => ( p));
+    const hout = _nullishCoalesce(p.out, () => ( p));
+    const target = (h, x, y) => ({ x: h.x + (x - h.x) * t, y: h.y + (y - h.y) * t });
+    anchors[i] = tidy(
+      {
+        x: p.x,
+        y: p.y,
+        in: target(hin, p.x - dir[0] * li, p.y - dir[1] * li),
+        out: target(hout, p.x + dir[0] * lo, p.y + dir[1] * lo)
+      },
+      false
+    );
+  }
+  return { anchors, closed: sp.closed };
+}
+function segsOf(sp) {
+  const out = [];
+  for (let i = 0; i < _chunkQAUIZPYIcjs.subpathSegmentCount.call(void 0, sp); i++) {
+    const s = _chunkQAUIZPYIcjs.subpathSegment.call(void 0, sp, i);
+    out.push(s.length === 2 ? { c: s, line: true } : { c: s, line: false });
+  }
+  return out;
+}
+function segsToSubpath(segs, closed, types) {
+  if (!segs.length) return null;
+  const anchors = [];
+  const at = (p) => ({ x: p[0], y: p[1] });
+  anchors.push(at(segs[0].c[0]));
+  for (const s of segs) {
+    const end = s.c[s.c.length - 1];
+    if (!s.line) anchors[anchors.length - 1].out = { x: s.c[1][0], y: s.c[1][1] };
+    const next = at(end);
+    if (!s.line) next.in = { x: s.c[2][0], y: s.c[2][1] };
+    anchors.push(next);
+  }
+  if (closed) {
+    const last = anchors.pop();
+    if (last.in) anchors[0].in = last.in;
+  }
+  const typed = anchors.map((a) => {
+    const type = types.get(`${a.x},${a.y}`);
+    return tidy(type ? { ...a, type } : a, !!type);
+  });
+  return { anchors: typed, closed };
+}
+var isZeroSeg = (s) => s.c.every((p) => Math.abs(p[0] - s.c[0][0]) < 1e-9 && Math.abs(p[1] - s.c[0][1]) < 1e-9);
+function mergePair(a, b, tol) {
+  const a0 = a.c[0];
+  const a3 = a.c[a.c.length - 1];
+  const b3 = b.c[b.c.length - 1];
+  if (a.line && b.line) {
+    const cx = b3[0] - a0[0];
+    const cy = b3[1] - a0[1];
+    const len = Math.hypot(cx, cy);
+    if (len < 1e-12) return null;
+    const mx = a3[0] - a0[0];
+    const my = a3[1] - a0[1];
+    const along = (mx * cx + my * cy) / len;
+    return Math.abs((mx * cy - my * cx) / len) <= tol && along >= 0 && along <= len ? { c: [a0, b3], line: true } : null;
+  }
+  const ca = a.line ? [a0, a0, a3, a3] : a.c;
+  const cb = b.line ? [a3, a3, b3, b3] : b.c;
+  const ta = endTangent(ca);
+  const tb = startTangent(cb);
+  if (ta[0] * tb[0] + ta[1] * tb[1] < 0.99) return null;
+  const pts = [];
+  sample(ca, 16, pts, true);
+  sample(cb, 16, pts, false);
+  const { curve, error } = fitAcross(pts, 16, startTangent(ca), endTangent(cb));
+  return error <= tol ? { c: [curve.p0, curve.p1, curve.p2, curve.p3], line: false } : null;
+}
+function removeRedundantPoints(sp, tolerance) {
+  const tol = Math.max(tolerance, 1e-9);
+  const types = new Map(sp.anchors.filter((a) => a.type).map((a) => [`${a.x},${a.y}`, a.type]));
+  const segs = segsOf(sp).filter((s) => !isZeroSeg(s));
+  if (!segs.length) return { anchors: sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor), closed: sp.closed };
+  const minSegs = sp.closed ? 2 : 1;
+  let changed = true;
+  while (changed && segs.length > minSegs) {
+    changed = false;
+    const n = segs.length;
+    const joints = sp.closed ? n : n - 1;
+    for (let j = 0; j < joints; j++) {
+      const [i0, i1] = sp.closed ? [(j + n - 1) % n, j] : [j, j + 1];
+      const m = mergePair(segs[i0], segs[i1], tol);
+      if (!m) continue;
+      segs[i0] = m;
+      segs.splice(i1, 1);
+      if (sp.closed && i1 === 0) segs.unshift(segs.pop());
+      changed = true;
+      break;
+    }
+  }
+  return _nullishCoalesce(segsToSubpath(segs, sp.closed, types), () => ( { anchors: sp.anchors.map(_chunkQAUIZPYIcjs.cloneAnchor), closed: sp.closed }));
+}
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -1350,4 +1768,4 @@ async function unwoff(view) {
 
 
 
-exports.VECTOR_TRACE_MAX_PIXELS = VECTOR_TRACE_MAX_PIXELS; exports.vectorTraceContours = vectorTraceContours; exports.traceField = traceField; exports.quantizeVectorTraceColors = quantizeVectorTraceColors; exports.traceVectorImage = traceVectorImage; exports.parseOpenTypeFont = parseOpenTypeFont; exports.loadOpenTypeFont = loadOpenTypeFont;
+exports.VECTOR_TRACE_MAX_PIXELS = VECTOR_TRACE_MAX_PIXELS; exports.vectorTraceContours = vectorTraceContours; exports.traceField = traceField; exports.quantizeVectorTraceColors = quantizeVectorTraceColors; exports.traceVectorImage = traceVectorImage; exports.parseOpenTypeFont = parseOpenTypeFont; exports.loadOpenTypeFont = loadOpenTypeFont; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.bendSegment = bendSegment; exports.subpathPointAt = subpathPointAt; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.splitSubpathAt = splitSubpathAt; exports.joinSubpaths = joinSubpaths; exports.smoothSubpath = smoothSubpath; exports.removeRedundantPoints = removeRedundantPoints;

package/dist/image-editor/content-aware-fill-session.d.cts

@@ -5,7 +5,7 @@
  * applies it as one undo step through `contentAwareFillAsync` (the same fill the
  * `content_aware_fill` tool makes, with a sampling area).
  */
-import type { ImageEditorController } from './controller.cjs';
+import type { ContentAwareFillOutput, ImageEditorController } from './controller.cjs';
 import type { CropBox, ImagePoint } from './types.cjs';
 import { type SelectionMask } from './selection/mask.cjs';
 export type ContentAwareFillSampling = 'auto' | 'rectangular' | 'custom';
@@ -32,7 +32,7 @@ export interface ContentAwareFillSettings {
     brushMode: 'add' | 'subtract';
     /** The fill's random seed; another gives another fill to choose from. */
     seed: number;
-    output: 'current' | 'new-layer';
+    output: ContentAwareFillOutput;
     /** Update the preview as the area changes (otherwise with Preview). */
     livePreview: boolean;
 }
@@ -61,11 +61,23 @@ export declare class ContentAwareFillSession {
     get window(): CropBox | null;
     subscribe(listener: () => void): () => void;
     private emit;
+    /** Images up to this many pixels show (and can be sampled) whole in the workspace. */
+    static readonly WHOLE_IMAGE_PIXELS = 4000000;
+    /** Room around the selection the window holds, in px each way. */
+    private margin;
     /**
-     * Reads the layer around the selection and makes the first preview. The window holds the
-     * selection and room around it to sample from (its larger side, at least 64 px, each way).
+     * Reads the layer and makes the first preview. The window is the whole image up to
+     * {@link WHOLE_IMAGE_PIXELS}; on a larger one it holds the selection and room around it (twice
+     * its larger side, at least 256 px, each way), and {@link expandView} widens it.
      */
     open(): Promise<boolean>;
+    /** Whether the window shows the whole image (else {@link expandView} can widen it). */
+    get showsWholeImage(): boolean;
+    /**
+     * Doubles the room around the selection (up to the whole image), keeping what was painted; a
+     * preset fills the new room as it would. Returns false when the whole image already shows.
+     */
+    expandView(): boolean;
     /** Sets the area to a preset: Auto (a band around the selection), Rectangular (the whole window). */
     private applySampling;
     /** Changes settings; a sampling preset replaces the area, and the preview follows when live. */
@@ -104,6 +116,6 @@ export declare class ContentAwareFillSession {
     }): Promise<{
         layerId: string;
         bounds: CropBox;
-        output: 'current' | 'new-layer';
+        output: ContentAwareFillOutput;
     }>;
 }

package/dist/image-editor/content-aware-fill-session.d.ts

@@ -5,7 +5,7 @@
  * applies it as one undo step through `contentAwareFillAsync` (the same fill the
  * `content_aware_fill` tool makes, with a sampling area).
  */
-import type { ImageEditorController } from './controller.js';
+import type { ContentAwareFillOutput, ImageEditorController } from './controller.js';
 import type { CropBox, ImagePoint } from './types.js';
 import { type SelectionMask } from './selection/mask.js';
 export type ContentAwareFillSampling = 'auto' | 'rectangular' | 'custom';
@@ -32,7 +32,7 @@ export interface ContentAwareFillSettings {
     brushMode: 'add' | 'subtract';
     /** The fill's random seed; another gives another fill to choose from. */
     seed: number;
-    output: 'current' | 'new-layer';
+    output: ContentAwareFillOutput;
     /** Update the preview as the area changes (otherwise with Preview). */
     livePreview: boolean;
 }
@@ -61,11 +61,23 @@ export declare class ContentAwareFillSession {
     get window(): CropBox | null;
     subscribe(listener: () => void): () => void;
     private emit;
+    /** Images up to this many pixels show (and can be sampled) whole in the workspace. */
+    static readonly WHOLE_IMAGE_PIXELS = 4000000;
+    /** Room around the selection the window holds, in px each way. */
+    private margin;
     /**
-     * Reads the layer around the selection and makes the first preview. The window holds the
-     * selection and room around it to sample from (its larger side, at least 64 px, each way).
+     * Reads the layer and makes the first preview. The window is the whole image up to
+     * {@link WHOLE_IMAGE_PIXELS}; on a larger one it holds the selection and room around it (twice
+     * its larger side, at least 256 px, each way), and {@link expandView} widens it.
      */
     open(): Promise<boolean>;
+    /** Whether the window shows the whole image (else {@link expandView} can widen it). */
+    get showsWholeImage(): boolean;
+    /**
+     * Doubles the room around the selection (up to the whole image), keeping what was painted; a
+     * preset fills the new room as it would. Returns false when the whole image already shows.
+     */
+    expandView(): boolean;
     /** Sets the area to a preset: Auto (a band around the selection), Rectangular (the whole window). */
     private applySampling;
     /** Changes settings; a sampling preset replaces the area, and the preview follows when live. */
@@ -104,6 +116,6 @@ export declare class ContentAwareFillSession {
     }): Promise<{
         layerId: string;
         bounds: CropBox;
-        output: 'current' | 'new-layer';
+        output: ContentAwareFillOutput;
     }>;
 }

package/dist/image-editor/controller.d.cts

@@ -2,7 +2,7 @@ import { AdjustmentKind, AdjustmentLayer, AdjustmentParamsMap, Annotation, Creat
 import { type PathToSelectionOptions, type SelectionToPathOptions } from './selection/path.cjs';
 import { type MagneticEdgeOptions } from './selection/magnetic.cjs';
 import type { ObjectTarget } from './selection/segment/grabcut.cjs';
-import { type DocumentPath } from './paths.cjs';
+import { type DocumentPath, type PathEditTarget } from './paths.cjs';
 import { type SelectionJob, type SelectionJobResult, type SelectionWorkerFactory } from './selection/worker.cjs';
 import type { SelectionProgress } from './selection/segment/work.cjs';
 import type { FocusAreaOptions } from './selection/segment/focus.cjs';
@@ -20,7 +20,7 @@ import { type RefineEdit } from './selection/refine-edits.cjs';
 import { type LayerMaskProps } from './selection/layer-mask.cjs';
 import { type AlphaChannel } from './selection/channels.cjs';
 import type { AdjustmentLayerMask } from './types.cjs';
-import { type LayerBlendMode, type ImageLayer, type LayerFilter, type LayerTarget, type PixelLayer, type RasterMask, type SmartContents, type SmartFilter, type SmartPlacement, type LiveShape, type ShapeFillRule, type VectorMask, type ShapeOperation, type ShapePaint, type ShapeStroke, type ParagraphStyle, type TextStyle, type TextOrientation, type TypeLayer, type ImageEffectAnimation } from './layers/model.cjs';
+import { type LayerBlendMode, type ImageLayer, type LayerFilter, type LayerTarget, type PixelLayer, type RasterMask, type SmartContents, type SmartFilter, type SmartPlacement, type LiveShape, type ShapeComponent, type ShapeFillRule, type VectorMask, type ShapeOperation, type ShapePaint, type ShapeStroke, type ParagraphStyle, type TextStyle, type TextOrientation, type TypeLayer, type ImageEffectAnimation } from './layers/model.cjs';
 import { type TextLayout, type TextShaper } from './layers/text.cjs';
 import type { VectorSubpath } from '../vector/types.cjs';
 import { EffectsSlot } from '../effects/helpers.cjs';
@@ -479,12 +479,17 @@ export interface StrokeSelectionOptions extends Omit<FillOptions, 'useSelection'
     /** Where the band lies against the selection edge (default `outside`). */
     location?: 'inside' | 'center' | 'outside';
 }
+/** Where Content-Aware Fill puts its result. */
+export type ContentAwareFillOutput = 'current' | 'new-layer' | 'duplicate-layer';
 /** Edit › Content-Aware Fill (see `contentAwareFill`). */
 export interface ContentAwareFillOptions {
     /** The pixel layer to sample and fill (default the active layer). */
     layerId?: string;
-    /** `current` (default) paints into the layer; `new-layer` puts the fill on a new layer above it. */
-    output?: 'current' | 'new-layer';
+    /**
+     * `current` (default) paints into the layer; `new-layer` puts the fill on a new layer above it;
+     * `duplicate-layer` paints it into a copy of the layer, above it.
+     */
+    output?: ContentAwareFillOutput;
     /** How far around the selection to sample, in pixels (default its larger side, at least 32). */
     sampleRadius?: number;
     /** Random seed: the same seed gives the same fill (default 0). */
@@ -1106,6 +1111,26 @@ export declare class ImageEditorController {
     }): DocumentPath;
     /** Replaces a path's geometry (its name is kept). One undo step. */
     setPathGeometry(id: string, input: VectorMaskPathInput): DocumentPath;
+    /**
+     * What the path tools (Path Selection, Direct Selection, Pen) edit: the active path in the Paths
+     * panel, else the active layer when it is a shape, else the active layer's vector mask; null
+     * when there is none of these (the Pen then starts a new Work Path).
+     */
+    pathEditTarget(): PathEditTarget | null;
+    /** The components a path tool target holds (document pixels). Throws for a target that is gone. */
+    getPathEditComponents(target: PathEditTarget): ShapeComponent[];
+    /**
+     * Replaces a path tool target's components: one undo step, or none with `commitToHistory` false
+     * (the later moves of a drag whose first move recorded one). A component that still has its
+     * `live` shape is kept as given (drop `live` from one whose anchors changed); a shape layer keeps
+     * at least one component.
+     */
+    setPathEditComponents(target: PathEditTarget, components: readonly ShapeComponent[], commitToHistory?: boolean): void;
+    /**
+     * The Pen with no path to add to: a new Work Path from `components` (replacing the last one,
+     * unless it was saved), made the active path. One undo step. Returns the path.
+     */
+    startWorkPath(components: readonly ShapeComponent[]): DocumentPath;
     /** Renames a path; renaming the Work Path saves it (Photoshop's Save Path). One undo step. */
     renamePath(id: string, name: string): DocumentPath;
     /** Duplicates a path as a saved path. One undo step. */
@@ -1528,7 +1553,7 @@ export declare class ImageEditorController {
     contentAwareFill(options?: ContentAwareFillOptions): {
         layerId: string;
         bounds: CropBox;
-        output: 'current' | 'new-layer';
+        output: ContentAwareFillOutput;
     };
     /**
      * `contentAwareFill` with the synthesis in the selection worker when there is one, with
@@ -1540,7 +1565,7 @@ export declare class ImageEditorController {
     }): Promise<{
         layerId: string;
         bounds: CropBox;
-        output: 'current' | 'new-layer';
+        output: ContentAwareFillOutput;
     }>;
     /**
      * The fill without changing anything: the window, its pixels before and after (RGBA, the fill