@pixerate/editor 0.89.0 → 0.90.0

package/dist/image-editor/index.js

@@ -271,8 +271,8 @@ function whiteBalanceFromSample(rgb) {
   if (lin[0] + lin[1] + lin[2] <= 1e-6) return { temperature: 0, tint: 0 };
   const src = linearSrgbToXy(applyMatrix3(AS_SHOT_WB_INV, lin));
   const { kelvin, tint } = xyToTempTint(src);
-  const clamp2 = (v) => Math.max(-100, Math.min(100, v));
-  return { temperature: clamp2(kelvinToTemperature(kelvin)), tint: clamp2(tint) };
+  const clamp3 = (v) => Math.max(-100, Math.min(100, v));
+  return { temperature: clamp3(kelvinToTemperature(kelvin)), tint: clamp3(tint) };
 }
 var TONE_LUT_SIZE = 4096;
 var GREY = 0.18;
@@ -1001,20 +1001,20 @@ function distanceTransform(inside, width, height) {
   for (let y = 0; y < height; y++) {
     const row = y * width;
     let count = 0;
-    for (let q = 0; q < width; q++) {
-      const dq = vertical[row + q];
+    for (let q2 = 0; q2 < width; q2++) {
+      const dq = vertical[row + q2];
       if (dq === NONE) continue;
       const fq = dq * dq;
       let start = -Infinity;
       while (count > 0) {
         const p = sites[count - 1];
         const dp = vertical[row + p];
-        start = (fq - dp * dp) / (2 * (q - p)) + (q + p) * 0.5;
+        start = (fq - dp * dp) / (2 * (q2 - p)) + (q2 + p) * 0.5;
         if (start > starts[count - 1]) break;
         count--;
       }
       if (count === 0) start = -Infinity;
-      sites[count] = q;
+      sites[count] = q2;
       starts[count] = start;
       count++;
     }
@@ -1551,9 +1551,9 @@ function levelsValue(ch, v, quantum) {
   const range = Math.max(1e-6, ch.inWhite - ch.inBlack);
   let u;
   if (quantum !== void 0 && Number.isFinite(quantum) && quantum >= 1) {
-    const q = quantum;
-    const vq = Math.round(v * q) / q;
-    u = Math.floor(clamp01((vq - ch.inBlack) / range) * q + 0.5 + 1e-3) / q;
+    const q2 = quantum;
+    const vq = Math.round(v * q2) / q2;
+    u = Math.floor(clamp01((vq - ch.inBlack) / range) * q2 + 0.5 + 1e-3) / q2;
   } else {
     u = clamp01((v - ch.inBlack) / range);
   }
@@ -1587,13 +1587,13 @@ function rgbToHsl(c) {
 }
 function hslToRgb(h, s, l) {
   if (s <= 0) return [l, l, l];
-  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-  const p = 2 * l - q;
+  const q2 = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q2;
   const f = (t) => {
     t = remEuclid(t, 1);
-    if (t < 1 / 6) return p + (q - p) * 6 * t;
-    if (t < 0.5) return q;
-    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+    if (t < 1 / 6) return p + (q2 - p) * 6 * t;
+    if (t < 0.5) return q2;
+    if (t < 2 / 3) return p + (q2 - p) * (2 / 3 - t) * 6;
     return p;
   };
   return [f(h + 1 / 3), f(h), f(h - 1 / 3)];
@@ -1671,10 +1671,10 @@ function vibranceLinear(c, v) {
     t2 = t * (1 - a / 4) * (1 - a + a * t * (1 + t) / 2);
     v2 = mx - a * shape;
   } else {
-    const [c0, c1, p, q, r0, ra, rt] = VIBRANCE_BOOST;
+    const [c0, c1, p, q2, r0, ra, rt] = VIBRANCE_BOOST;
     const w = vibranceSkin(hsvHue(c, mx, mn));
     const a = v * (1 - w) + 0.64 * Math.pow(v, 1.6) * w;
-    const boost = (c0 * a + c1 * a * a) * Math.pow(t, p) * Math.pow(1 - t, q) * Math.exp((r0 + ra * a + rt * (1 - t)) * Math.max(0, 1 - mx));
+    const boost = (c0 * a + c1 * a * a) * Math.pow(t, p) * Math.pow(1 - t, q2) * Math.exp((r0 + ra * a + rt * (1 - t)) * Math.max(0, 1 - mx));
     t2 = Math.min(1, t * (1 + boost));
     v2 = mx + v / 4 * shape;
   }
@@ -3961,7 +3961,7 @@ function polygonCoverage(points, width, height, antiAlias = true) {
     if (a.y < b.y) edges.push({ top: a.y, bottom: b.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
     else if (b.y < a.y) edges.push({ top: b.y, bottom: a.y, ax: a.x, ay: a.y, bx: b.x, by: b.y });
   }
-  edges.sort((p, q) => p.top - q.top);
+  edges.sort((p, q2) => p.top - q2.top);
   let next = 0;
   let active = [];
   const xs = [];
@@ -4425,13 +4425,13 @@ function refineCoverage(guide, m, w, h, params = {}) {
     if (any) {
       const dist = distanceTransform(boundary, w, h);
       const r = gfRadius(p);
-      const q = guidedFilterColor(guide, m, w, h, r);
+      const q2 = guidedFilterColor(guide, m, w, h, r);
       const widths = p.smartRadius ? edgeWidth(guide, w, h, r) : null;
       for (let i = 0; i < n; i++) {
         const reff = widths ? Math.min(Math.max(p.radius, 1.5), Math.max(1.5, widths[i])) : p.radius;
         const wgt = Math.min(1, Math.max(0, reff + 1 - dist[i]));
         if (wgt > 0) {
-          const qi = Math.min(1, Math.max(0, q[i]));
+          const qi = Math.min(1, Math.max(0, q2[i]));
           a[i] = m[i] + (qi - m[i]) * wgt;
         }
       }
@@ -4583,6 +4583,53 @@ function serializeLayers(layers) {
   };
   return { layers: layers.map((l) => serializeLayer(l, ctx)), 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 { 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.");
@@ -4976,6 +5023,2070 @@ function unionRect(a, b) {
   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/psd/binary.ts
+var PsdError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PsdError";
+  }
+};
+var PsdReader = class _PsdReader {
+  constructor(data, start = 0, end = data.length) {
+    this.data = data;
+    this.start = start;
+    this.end = end;
+    this.pos = start;
+  }
+  data;
+  start;
+  end;
+  pos;
+  get remaining() {
+    return this.end - this.pos;
+  }
+  get offset() {
+    return this.pos - this.start;
+  }
+  need(n, what) {
+    if (n < 0 || this.pos + n > this.end) throw new PsdError(`Unexpected end of data reading ${what} at byte ${this.pos}.`);
+  }
+  u8() {
+    this.need(1, "a byte");
+    return this.data[this.pos++];
+  }
+  i8() {
+    const v = this.u8();
+    return v > 127 ? v - 256 : v;
+  }
+  u16() {
+    this.need(2, "a 16-bit value");
+    const v = this.data[this.pos] << 8 | this.data[this.pos + 1];
+    this.pos += 2;
+    return v;
+  }
+  i16() {
+    const v = this.u16();
+    return v > 32767 ? v - 65536 : v;
+  }
+  u32() {
+    this.need(4, "a 32-bit value");
+    const d = this.data;
+    const p = this.pos;
+    this.pos += 4;
+    return (d[p] << 24 | d[p + 1] << 16 | d[p + 2] << 8 | d[p + 3]) >>> 0;
+  }
+  i32() {
+    return this.u32() | 0;
+  }
+  u64() {
+    const hi = this.u32();
+    const lo = this.u32();
+    const v = hi * 2 ** 32 + lo;
+    if (!Number.isSafeInteger(v)) throw new PsdError("A 64-bit length is too large.");
+    return v;
+  }
+  i64() {
+    const hi = this.i32();
+    const lo = this.u32();
+    return hi * 2 ** 32 + lo;
+  }
+  f32() {
+    this.need(4, "a float");
+    const v = new DataView(this.data.buffer, this.data.byteOffset + this.pos, 4).getFloat32(0, false);
+    this.pos += 4;
+    return v;
+  }
+  f64() {
+    this.need(8, "a double");
+    const v = new DataView(this.data.buffer, this.data.byteOffset + this.pos, 8).getFloat64(0, false);
+    this.pos += 8;
+    return v;
+  }
+  /** A length field: 8 bytes in PSB where the format says so, else 4. */
+  len(long2) {
+    return long2 ? this.u64() : this.u32();
+  }
+  bytes(n) {
+    this.need(n, `${n} bytes`);
+    const out = this.data.subarray(this.pos, this.pos + n);
+    this.pos += n;
+    return out;
+  }
+  ascii(n) {
+    return String.fromCharCode(...this.bytes(n));
+  }
+  skip(n) {
+    this.need(n, `${n} bytes`);
+    this.pos += n;
+  }
+  /** A reader over the next `n` bytes (and skips them here). */
+  sub(n) {
+    this.need(n, `a ${n}-byte section`);
+    const r = new _PsdReader(this.data, this.pos, this.pos + n);
+    this.pos += n;
+    return r;
+  }
+  peek(n) {
+    return this.data.subarray(this.pos, Math.min(this.end, this.pos + n));
+  }
+  rest() {
+    const out = this.data.subarray(this.pos, this.end);
+    this.pos = this.end;
+    return out;
+  }
+  /** Refuses counts that could not fit in what is left (each item at least `size` bytes). */
+  checkCount(n, size, what) {
+    if (n * size > this.remaining) throw new PsdError(`${what}: count ${n} does not fit in the remaining ${this.remaining} bytes.`);
+  }
+  /** Pascal string padded to a multiple of `align` (length byte included). */
+  pascal(align) {
+    const n = this.u8();
+    const s = this.bytes(n);
+    const pad = (align - (1 + n) % align) % align;
+    this.skip(Math.min(pad, this.remaining));
+    return s;
+  }
+  /** Photoshop Unicode string: u32 code-unit count, UTF-16BE units (trailing NULs dropped). */
+  unicode() {
+    const n = this.u32();
+    this.checkCount(n, 2, "Unicode string");
+    let s = "";
+    for (let i = 0; i < n; i++) s += String.fromCharCode(this.u16());
+    return s.replace(/\u0000+$/, "");
+  }
+};
+var PsdWriter = class {
+  buf = new Uint8Array(1 << 16);
+  length = 0;
+  ensure(n) {
+    if (this.length + n <= this.buf.length) return;
+    let size = this.buf.length * 2;
+    while (size < this.length + n) size *= 2;
+    const next = new Uint8Array(size);
+    next.set(this.buf.subarray(0, this.length));
+    this.buf = next;
+  }
+  u8(v) {
+    this.ensure(1);
+    this.buf[this.length++] = v & 255;
+  }
+  u16(v) {
+    this.ensure(2);
+    this.buf[this.length++] = v >>> 8 & 255;
+    this.buf[this.length++] = v & 255;
+  }
+  i16(v) {
+    this.u16(v < 0 ? v + 65536 : v);
+  }
+  u32(v) {
+    this.ensure(4);
+    this.buf[this.length++] = v >>> 24 & 255;
+    this.buf[this.length++] = v >>> 16 & 255;
+    this.buf[this.length++] = v >>> 8 & 255;
+    this.buf[this.length++] = v & 255;
+  }
+  i32(v) {
+    this.u32(v >>> 0);
+  }
+  u64(v) {
+    this.u32(Math.floor(v / 2 ** 32));
+    this.u32(v >>> 0);
+  }
+  f64(v) {
+    this.ensure(8);
+    new DataView(this.buf.buffer, this.length, 8).setFloat64(0, v, false);
+    this.length += 8;
+  }
+  bytes(b) {
+    this.ensure(b.length);
+    this.buf.set(b, this.length);
+    this.length += b.length;
+  }
+  ascii(s) {
+    for (let i = 0; i < s.length; i++) this.u8(s.charCodeAt(i));
+  }
+  zeros(n) {
+    this.ensure(n);
+    this.buf.fill(0, this.length, this.length + n);
+    this.length += n;
+  }
+  /** Reserves a length field; `endLen` fills it with the bytes written since. */
+  beginLen(long2) {
+    const at = this.length;
+    if (long2) this.u64(0);
+    else this.u32(0);
+    return { at, long: long2 };
+  }
+  endLen(mark) {
+    const n = this.length - mark.at - (mark.long ? 8 : 4);
+    const save = this.length;
+    this.length = mark.at;
+    if (mark.long) this.u64(n);
+    else this.u32(n);
+    this.length = save;
+    return n;
+  }
+  /** Pascal string padded to a multiple of `align`. */
+  pascal(s, align) {
+    const n = Math.min(255, s.length);
+    this.u8(n);
+    this.bytes(s.subarray(0, n));
+    this.zeros((align - (1 + n) % align) % align);
+  }
+  unicode(s, nul = false) {
+    const n = s.length + (nul ? 1 : 0);
+    this.u32(n);
+    for (let i = 0; i < s.length; i++) this.u16(s.charCodeAt(i));
+    if (nul) this.u16(0);
+  }
+  result() {
+    return this.buf.slice(0, this.length);
+  }
+};
+function decodeLegacyName(b) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(b);
+  } catch {
+    return String.fromCharCode(...b);
+  }
+}
+function encodeLegacyName(s) {
+  const out = [];
+  for (const ch of s) {
+    const c = ch.codePointAt(0);
+    out.push(c >= 32 && c < 127 ? c : 63);
+    if (out.length >= 255) break;
+  }
+  return Uint8Array.from(out);
+}
+
+// src/image-editor/psd/descriptor.ts
+var MAX_DEPTH = 64;
+var STRING_IDS = /* @__PURE__ */ new Set(["warp", "list", "time"]);
+function descriptor(classId, items = []) {
+  return { name: "", classId, items };
+}
+function descGet(d, key) {
+  return d.items.find(([k]) => k === key)?.[1];
+}
+function descNumber(d, key) {
+  const v = descGet(d, key);
+  if (!v) return void 0;
+  if (v.type === "long" || v.type === "doub" || v.type === "UntF" || v.type === "comp") return v.value;
+  return void 0;
+}
+function descBool(d, key) {
+  const v = descGet(d, key);
+  return v?.type === "bool" ? v.value : void 0;
+}
+function descObject(d, key) {
+  const v = descGet(d, key);
+  return v && (v.type === "Objc" || v.type === "GlbO") ? v.value : void 0;
+}
+function readId(r) {
+  const n = r.u32();
+  return n === 0 ? r.ascii(4) : r.ascii(n);
+}
+function writeId(w, id) {
+  if (id.length === 4 && !STRING_IDS.has(id)) {
+    w.u32(0);
+    w.ascii(id);
+  } else {
+    w.u32(id.length);
+    w.ascii(id);
+  }
+}
+function readClass(r) {
+  return { name: r.unicode(), classId: readId(r) };
+}
+function writeClass(w, c) {
+  w.unicode(c.name);
+  writeId(w, c.classId);
+}
+function readReferenceItem(r) {
+  const type = r.ascii(4);
+  switch (type) {
+    case "prop":
+      return { type, class: readClass(r), key: readId(r) };
+    case "Clss":
+      return { type, class: readClass(r) };
+    case "Enmr":
+      return { type, class: readClass(r), typeId: readId(r), value: readId(r) };
+    case "rele":
+      return { type, class: readClass(r), offset: r.i32() };
+    case "Idnt":
+      return { type, class: readClass(r), id: r.u32() };
+    case "indx":
+      return { type, class: readClass(r), index: r.u32() };
+    case "name":
+      return { type, class: readClass(r), name: r.unicode() };
+    default:
+      throw new PsdError(`Unsupported descriptor reference item "${type}".`);
+  }
+}
+function writeReferenceItem(w, it) {
+  w.ascii(it.type);
+  writeClass(w, it.class);
+  switch (it.type) {
+    case "prop":
+      writeId(w, it.key);
+      break;
+    case "Enmr":
+      writeId(w, it.typeId);
+      writeId(w, it.value);
+      break;
+    case "rele":
+      w.i32(it.offset);
+      break;
+    case "Idnt":
+      w.u32(it.id);
+      break;
+    case "indx":
+      w.u32(it.index);
+      break;
+    case "name":
+      w.unicode(it.name);
+      break;
+  }
+}
+function readValue(r, depth) {
+  if (depth > MAX_DEPTH) throw new PsdError("Descriptor nesting is too deep.");
+  const type = r.ascii(4);
+  switch (type) {
+    case "obj ": {
+      const n = r.u32();
+      r.checkCount(n, 8, "Descriptor reference");
+      const items = [];
+      for (let i = 0; i < n; i++) items.push(readReferenceItem(r));
+      return { type, items };
+    }
+    case "Objc":
+    case "GlbO":
+      return { type, value: readDescriptorBody(r, depth + 1) };
+    case "VlLs": {
+      const n = r.u32();
+      r.checkCount(n, 4, "Descriptor list");
+      const items = [];
+      for (let i = 0; i < n; i++) items.push(readValue(r, depth + 1));
+      return { type, items };
+    }
+    case "doub":
+      return { type, value: r.f64() };
+    case "UntF":
+      return { type, unit: r.ascii(4), value: r.f64() };
+    case "UnFl": {
+      const unit = r.ascii(4);
+      const n = r.u32();
+      r.checkCount(n, 8, "Unit float list");
+      const values = [];
+      for (let i = 0; i < n; i++) values.push(r.f64());
+      return { type, unit, values };
+    }
+    case "TEXT":
+      return { type, value: r.unicode() };
+    case "enum":
+      return { type, typeId: readId(r), value: readId(r) };
+    case "long":
+      return { type, value: r.i32() };
+    case "comp":
+      return { type, value: r.i64() };
+    case "bool":
+      return { type, value: r.u8() !== 0 };
+    case "type":
+    case "GlbC":
+      return { type, class: readClass(r) };
+    case "alis":
+    case "Pth ":
+    case "tdta":
+      return { type, data: r.bytes(r.u32()) };
+    case "ObAr":
+      return { type, prefix: r.u32(), body: readDescriptorBody(r, depth + 1) };
+    default:
+      throw new PsdError(`Unsupported descriptor value type "${type}".`);
+  }
+}
+function writeValue(w, v) {
+  w.ascii(v.type);
+  switch (v.type) {
+    case "obj ":
+      w.u32(v.items.length);
+      for (const it of v.items) writeReferenceItem(w, it);
+      break;
+    case "Objc":
+    case "GlbO":
+      writeDescriptorBody(w, v.value);
+      break;
+    case "VlLs":
+      w.u32(v.items.length);
+      for (const it of v.items) writeValue(w, it);
+      break;
+    case "doub":
+      w.f64(v.value);
+      break;
+    case "UntF":
+      w.ascii(v.unit);
+      w.f64(v.value);
+      break;
+    case "UnFl":
+      w.ascii(v.unit);
+      w.u32(v.values.length);
+      for (const x of v.values) w.f64(x);
+      break;
+    case "TEXT":
+      w.unicode(v.value, true);
+      break;
+    case "enum":
+      writeId(w, v.typeId);
+      writeId(w, v.value);
+      break;
+    case "long":
+      w.i32(v.value);
+      break;
+    case "comp":
+      w.u32(Math.floor(v.value / 2 ** 32) >>> 0);
+      w.u32(v.value >>> 0);
+      break;
+    case "bool":
+      w.u8(v.value ? 1 : 0);
+      break;
+    case "type":
+    case "GlbC":
+      writeClass(w, v.class);
+      break;
+    case "alis":
+    case "Pth ":
+    case "tdta":
+      w.u32(v.data.length);
+      w.bytes(v.data);
+      break;
+    case "ObAr":
+      w.u32(v.prefix);
+      writeDescriptorBody(w, v.body);
+      break;
+  }
+}
+function readDescriptorBody(r, depth) {
+  if (depth > MAX_DEPTH) throw new PsdError("Descriptor nesting is too deep.");
+  const name = r.unicode();
+  const classId = readId(r);
+  const n = r.u32();
+  r.checkCount(n, 10, "Descriptor items");
+  const items = [];
+  for (let i = 0; i < n; i++) {
+    const key = readId(r);
+    items.push([key, readValue(r, depth + 1)]);
+  }
+  return { name, classId, items };
+}
+function writeDescriptorBody(w, d) {
+  w.unicode(d.name, true);
+  writeId(w, d.classId);
+  w.u32(d.items.length);
+  for (const [k, v] of d.items) {
+    writeId(w, k);
+    writeValue(w, v);
+  }
+}
+function readVersionedDescriptor(r) {
+  const version = r.u32();
+  if (version !== 16) throw new PsdError(`Descriptor version ${version}, expected 16.`);
+  return readDescriptorBody(r, 0);
+}
+function writeVersionedDescriptor(w, d) {
+  w.u32(16);
+  writeDescriptorBody(w, d);
+}
+function parseVersionedDescriptor(bytes) {
+  return readVersionedDescriptor(new PsdReader(bytes));
+}
+function versionedDescriptorBytes(d) {
+  const w = new PsdWriter();
+  writeVersionedDescriptor(w, d);
+  return w.result();
+}
+
+// src/image-editor/psd/adjust.ts
+var ADJUSTMENT_KEYS = ["levl", "curv", "hue2", "brit", "nvrt", "thrs", "post", "expA", "vibA", "blnc", "mixr", "grdm", "phfl", "selc", "blwh", "clrL"];
+var SUPPORTED_ADJUSTMENT_KEYS = {
+  levl: "levels",
+  curv: "curves",
+  hue2: "hueSaturation",
+  vibA: "vibrance",
+  blnc: "colorBalance",
+  blwh: "blackWhite",
+  nvrt: "invert",
+  post: "posterize",
+  thrs: "threshold",
+  phfl: "photoFilter"
+};
+var LABELS = {
+  levl: "Levels",
+  curv: "Curves",
+  hue2: "Hue/Saturation",
+  brit: "Brightness/Contrast",
+  nvrt: "Invert",
+  thrs: "Threshold",
+  post: "Posterize",
+  expA: "Exposure",
+  vibA: "Vibrance",
+  blnc: "Color Balance",
+  mixr: "Channel Mixer",
+  grdm: "Gradient Map",
+  phfl: "Photo Filter",
+  selc: "Selective Color",
+  blwh: "Black & White",
+  clrL: "Color Lookup"
+};
+function adjustmentLabel(key) {
+  return LABELS[key] ?? "adjustment";
+}
+var clamp2 = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var toHex = (rgb) => "#" + rgb.map((v) => Math.round(clamp2(v, 0, 1) * 255).toString(16).padStart(2, "0")).join("");
+function canonicalBounds(b) {
+  if (b.some((v) => !Number.isFinite(v))) return [-45, -15, 15, 45];
+  const rem = (v) => (v % 360 + 360) % 360;
+  const out = [b[0], b[0], b[0], b[0]];
+  for (let k = 1; k < 4; k++) out[k] = Math.min(out[k - 1] + rem(b[k] - out[k - 1]), out[0] + 359);
+  const centre = (out[1] + out[2]) / 2;
+  const shift = rem(centre + 30) - 30 - centre;
+  return out.map((v) => v + shift);
+}
+function levelsRecord(r) {
+  const inBlack = r.u16();
+  const inWhite = r.u16();
+  const outBlack = r.u16();
+  const outWhite = r.u16();
+  const gamma = r.u16() / 100;
+  return {
+    inBlack: clamp2(inBlack, 0, 255),
+    inWhite: clamp2(inWhite, 0, 255),
+    gamma: clamp2(gamma || 1, 0.1, 9.99),
+    outBlack: clamp2(outBlack, 0, 255),
+    outWhite: clamp2(outWhite, 0, 255)
+  };
+}
+function curveFromMap(map) {
+  const pts = [];
+  for (let i = 0; i <= 255; i += 15) pts.push({ input: i, output: map[i] });
+  return pts;
+}
+function parseCurves(d) {
+  const r = new PsdReader(d);
+  const pencil = r.u8() !== 0;
+  const version = r.u16();
+  if (version !== 1 && version !== 4) return null;
+  const bits = r.u32();
+  const params = defaultAdjustmentParams("curves");
+  const order = ["master", "red", "green", "blue"];
+  for (let bit = 0; bit < 32; bit++) {
+    if (!(bits & 1 << bit)) continue;
+    let pts;
+    if (pencil) {
+      pts = curveFromMap(r.bytes(256));
+    } else {
+      const n = r.u16();
+      r.checkCount(n, 4, "Curve points");
+      pts = [];
+      for (let i = 0; i < n; i++) {
+        const output = r.u16();
+        const input = r.u16();
+        pts.push({ input: clamp2(input, 0, 255), output: clamp2(output, 0, 255) });
+      }
+      pts.sort((a, b) => a.input - b.input);
+    }
+    if (bit < 4 && pts.length >= 2) params[order[bit]] = pts;
+  }
+  return { kind: "curves", params, approximated: pencil ? "its pencil curve is approximated by points" : void 0 };
+}
+function parseHueSaturation(d) {
+  const r = new PsdReader(d);
+  r.u16();
+  const colorize = r.u8() !== 0;
+  r.u8();
+  const triple = () => [r.i16(), r.i16(), r.i16()];
+  const col = triple();
+  const master = triple();
+  const ranges = [];
+  for (let i = 0; i < 6; i++) {
+    if (r.remaining < 14) {
+      ranges.push(neutralHueRange(i));
+      continue;
+    }
+    const b = [r.u16(), r.u16(), r.u16(), r.u16()];
+    const [hue2, saturation2, lightness2] = triple();
+    ranges.push({ hue: hue2, saturation: saturation2, lightness: lightness2, bounds: canonicalBounds(b) });
+  }
+  const [hue, saturation, lightness] = colorize ? col : master;
+  return { kind: "hueSaturation", params: { hue, saturation, lightness, colorize, ranges } };
+}
+var BW_KEYS = [
+  ["reds", "Rd  "],
+  ["yellows", "Yllw"],
+  ["greens", "Grn "],
+  ["cyans", "Cyn "],
+  ["blues", "Bl  "],
+  ["magentas", "Mgnt"]
+];
+var BW_TINT = [225 / 255, 211 / 255, 179 / 255];
+function descRgb(d) {
+  if (!d) return null;
+  if (descNumber(d, "redFloat") !== void 0) {
+    return [descNumber(d, "redFloat"), descNumber(d, "greenFloat") ?? 0, descNumber(d, "blueFloat") ?? 0].map((v) => clamp2(v, 0, 1));
+  }
+  const r = descNumber(d, "Rd  ");
+  const g = descNumber(d, "Grn ");
+  const b = descNumber(d, "Bl  ");
+  if (r === void 0 || g === void 0 || b === void 0) return null;
+  return [r, g, b].map((v) => clamp2(v / 255, 0, 1));
+}
+function parseBlackWhite(d) {
+  const desc = parseVersionedDescriptor(d);
+  const params = defaultAdjustmentParams("blackWhite");
+  for (const [field, key] of BW_KEYS) {
+    const v = descNumber(desc, key);
+    if (v !== void 0) params[field] = clamp2(v, -200, 300);
+  }
+  params.tint = descBool(desc, "useTint") ? toHex(descRgb(descObject(desc, "tintColor")) ?? BW_TINT) : null;
+  return { kind: "blackWhite", params };
+}
+function labToRgb(l, a, b) {
+  const fy = (l + 16) / 116;
+  const fx = fy + a / 500;
+  const fz = fy - b / 200;
+  const f = (t) => t > 6 / 29 ? t ** 3 : 3 * (6 / 29) ** 2 * (t - 4 / 29);
+  const xyz = [f(fx) * D50[0], f(fy) * D50[1], f(fz) * D50[2]];
+  return XYZ_D50_TO_SRGB.map((row) => linearToSrgb(clamp2(row[0] * xyz[0] + row[1] * xyz[1] + row[2] * xyz[2], 0, 1)));
+}
+function decodePsdColor(space, c) {
+  const n = (v) => v / 65535;
+  switch (space) {
+    case 0:
+      return [n(c[0]), n(c[1]), n(c[2])];
+    case 1: {
+      const h = n(c[0]) * 360;
+      const s = n(c[1]);
+      const v = n(c[2]);
+      const k = (m) => (m + h / 60) % 6;
+      const f = (m) => v - v * s * Math.max(0, Math.min(k(m), 4 - k(m), 1));
+      return [f(5), f(3), f(1)];
+    }
+    case 2: {
+      const [cy, m, y, k] = c.map(n);
+      return [cy * k, m * k, y * k];
+    }
+    case 7: {
+      const signed = (v) => v << 16 >> 16;
+      return labToRgb(Math.min(c[0], 1e4) / 100, signed(c[1]) / 100, signed(c[2]) / 100);
+    }
+    case 8: {
+      const v = 1 - Math.min(c[0], 1e4) / 1e4;
+      return [v, v, v];
+    }
+    default:
+      return null;
+  }
+}
+function parsePhotoFilter(d) {
+  const r = new PsdReader(d);
+  const version = r.u16();
+  let rgb;
+  if (version === 2) {
+    const space = r.u16();
+    const c = [r.u16(), r.u16(), r.u16(), r.u16()];
+    rgb = [0, 2, 7, 8].includes(space) ? decodePsdColor(space, c) : null;
+  } else if (version === 3) {
+    const rel = [r.u32(), r.u32(), r.u32()].map((v) => v / 32768);
+    if (rel.some((v) => v > 2)) return null;
+    const xyz = [rel[0] * D50[0], rel[1], rel[2] * D50[2]];
+    rgb = XYZ_D50_TO_SRGB.map((row) => linearToSrgb(clamp2(row[0] * xyz[0] + row[1] * xyz[1] + row[2] * xyz[2], 0, 1)));
+  } else {
+    return null;
+  }
+  if (!rgb) return null;
+  const density = clamp2(r.u32(), 0, 100);
+  const preserveLuminosity = r.u8() !== 0;
+  return { kind: "photoFilter", params: { color: toHex(rgb), density, preserveLuminosity } };
+}
+function parseAdjustmentBlock(key, data) {
+  try {
+    const r = new PsdReader(data);
+    switch (key) {
+      case "nvrt":
+        return { kind: "invert", params: {} };
+      case "thrs":
+        return { kind: "threshold", params: { level: clamp2(r.u16(), 1, 255) } };
+      case "post":
+        return { kind: "posterize", params: { levels: clamp2(r.u16(), 2, 255) } };
+      case "levl": {
+        r.u16();
+        const master = levelsRecord(r);
+        const red = levelsRecord(r);
+        const green = levelsRecord(r);
+        const blue = levelsRecord(r);
+        return { kind: "levels", params: { master, red, green, blue } };
+      }
+      case "curv":
+        return parseCurves(data);
+      case "hue2":
+        return parseHueSaturation(data);
+      case "vibA": {
+        const desc = parseVersionedDescriptor(data);
+        const get = (k) => clamp2(descNumber(desc, k) ?? 0, -100, 100);
+        return { kind: "vibrance", params: { vibrance: get("vibrance"), saturation: get("Strt") } };
+      }
+      case "blnc": {
+        const tone2 = () => [r.i16(), r.i16(), r.i16()].map((v) => clamp2(v, -100, 100));
+        const shadows = tone2();
+        const midtones = tone2();
+        const highlights = tone2();
+        return { kind: "colorBalance", params: { shadows, midtones, highlights, preserveLuminosity: r.u8() !== 0 } };
+      }
+      case "blwh":
+        return parseBlackWhite(data);
+      case "phfl":
+        return parsePhotoFilter(data);
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+var q = (v) => Math.round(clamp2(v, 0, 255));
+var i16 = (v) => Math.round(clamp2(v, -32768, 32767));
+function writeLevels(w, c) {
+  w.u16(q(c.inBlack));
+  w.u16(q(c.inWhite));
+  w.u16(q(c.outBlack));
+  w.u16(q(c.outWhite));
+  w.u16(Math.round(clamp2(c.gamma * 100, 1, 999)));
+}
+var long = (value) => ({ type: "long", value: i16(value) });
+function writeAdjustmentBlock(kind, params) {
+  const w = new PsdWriter();
+  switch (kind) {
+    case "invert":
+      return { key: "nvrt", data: new Uint8Array(0) };
+    case "threshold": {
+      const p = params;
+      w.u16(Math.max(1, q(p.level)));
+      w.u16(0);
+      return { key: "thrs", data: w.result() };
+    }
+    case "posterize": {
+      const p = params;
+      w.u16(Math.round(clamp2(p.levels, 2, 255)));
+      w.u16(0);
+      return { key: "post", data: w.result() };
+    }
+    case "levels": {
+      const p = params;
+      w.u16(2);
+      for (const c of [p.master, p.red, p.green, p.blue]) writeLevels(w, c);
+      const ident = { inBlack: 0, inWhite: 255, gamma: 1, outBlack: 0, outWhite: 255 };
+      for (let i = 4; i < 29; i++) writeLevels(w, ident);
+      return { key: "levl", data: w.result() };
+    }
+    case "curves": {
+      const p = params;
+      w.u8(0);
+      w.u16(1);
+      w.u32(15);
+      for (const c of [p.master, p.red, p.green, p.blue]) {
+        const pts = c.slice(0, 19);
+        w.u16(pts.length);
+        for (const pt of pts) {
+          w.u16(q(pt.output));
+          w.u16(q(pt.input));
+        }
+      }
+      return { key: "curv", data: w.result() };
+    }
+    case "hueSaturation": {
+      const p = params;
+      w.u16(2);
+      w.u8(p.colorize ? 1 : 0);
+      w.u8(0);
+      for (let k = 0; k < 2; k++) for (const x of [p.hue, p.saturation, p.lightness]) w.i16(i16(x));
+      for (let i = 0; i < 6; i++) {
+        const r = p.ranges[i] ?? neutralHueRange(i);
+        for (const b of r.bounds) w.u16(Math.round((b % 360 + 360) % 360) % 360);
+        for (const x of [r.hue, r.saturation, r.lightness]) w.i16(i16(x));
+      }
+      return { key: "hue2", data: w.result() };
+    }
+    case "vibrance": {
+      const p = params;
+      const d = descriptor("null", [
+        ["vibrance", long(clamp2(p.vibrance, -100, 100))],
+        ["Strt", long(clamp2(p.saturation, -100, 100))]
+      ]);
+      return { key: "vibA", data: versionedDescriptorBytes(d) };
+    }
+    case "colorBalance": {
+      const p = params;
+      for (const x of [...p.shadows, ...p.midtones, ...p.highlights]) w.i16(i16(clamp2(x, -100, 100)));
+      w.u8(p.preserveLuminosity ? 1 : 0);
+      w.u8(0);
+      return { key: "blnc", data: w.result() };
+    }
+    case "blackWhite": {
+      const p = params;
+      const tint = p.tint ? hexToRgb(p.tint) : BW_TINT;
+      const dbl = (v) => ({ type: "doub", value: clamp2(v, 0, 1) * 255 });
+      const items = BW_KEYS.map(([field, key]) => [key, long(clamp2(p[field], -200, 300))]);
+      items.push(
+        ["useTint", { type: "bool", value: p.tint !== null }],
+        ["tintColor", { type: "Objc", value: descriptor("RGBC", [["Rd  ", dbl(tint[0])], ["Grn ", dbl(tint[1])], ["Bl  ", dbl(tint[2])]]) }],
+        ["bwPresetKind", { type: "long", value: 1 }],
+        ["blackAndWhitePresetFileName", { type: "TEXT", value: "" }]
+      );
+      return { key: "blwh", data: versionedDescriptorBytes(descriptor("null", items)) };
+    }
+    case "photoFilter": {
+      const p = params;
+      const rgb = hexToRgb(p.color);
+      w.u16(2);
+      w.u16(0);
+      for (const x of rgb) w.u16(Math.round(clamp2(x, 0, 1) * 65535));
+      w.u16(0);
+      w.u32(Math.round(clamp2(p.density, 0, 100)));
+      w.u8(p.preserveLuminosity ? 1 : 0);
+      w.zeros(3);
+      return { key: "phfl", data: w.result() };
+    }
+  }
+  throw new Error(`Unknown adjustment kind "${kind}".`);
+}
+
+// src/image-editor/psd/compression.ts
+var MAX_DECODED_BYTES = 2 ** 31;
+function rowBytes(width, depth) {
+  return depth === 1 ? Math.ceil(width / 8) : width * Math.max(1, depth >> 3);
+}
+function decodedLength(l) {
+  const total = l.planes * l.height * rowBytes(l.width, l.depth);
+  if (total > MAX_DECODED_BYTES) throw new PsdError(`Decoded channel data of ${total} bytes is larger than the ${MAX_DECODED_BYTES}-byte limit.`);
+  return total;
+}
+function packbitsBound(n) {
+  return n + Math.ceil(n / 128);
+}
+function packbitsEncode(src, out, at) {
+  const n = src.length;
+  let i = 0;
+  while (i < n) {
+    let run = 1;
+    while (i + run < n && run < 128 && src[i + run] === src[i]) run++;
+    if (run >= 2) {
+      out[at++] = 257 - run & 255;
+      out[at++] = src[i];
+      i += run;
+      continue;
+    }
+    const start = i;
+    let len = 0;
+    while (i < n && len < 128) {
+      if (i + 2 < n && src[i] === src[i + 1] && src[i] === src[i + 2]) break;
+      i++;
+      len++;
+    }
+    out[at++] = len - 1;
+    out.set(src.subarray(start, start + len), at);
+    at += len;
+  }
+  return at;
+}
+function packbitsDecodeInto(src, expected, out, at) {
+  const target = at + expected;
+  let i = 0;
+  while (at < target) {
+    if (i >= src.length) throw new PsdError("PackBits row ended early.");
+    const h = src[i++];
+    if (h < 128) {
+      const len = h + 1;
+      if (i + len > src.length) throw new PsdError("PackBits literal is truncated.");
+      if (at + len > target) throw new PsdError("PackBits literal overflows its row.");
+      out.set(src.subarray(i, i + len), at);
+      at += len;
+      i += len;
+    } else if (h !== 128) {
+      const len = 257 - h;
+      if (i >= src.length) throw new PsdError("PackBits run is truncated.");
+      const b = src[i++];
+      if (at + len > target) throw new PsdError("PackBits run overflows its row.");
+      out.fill(b, at, at + len);
+      at += len;
+    }
+  }
+  return at;
+}
+function inflateChecked(data, expected) {
+  let out;
+  try {
+    out = inflate(data, { maxOutput: expected + (1 << 20), sizeHint: expected, verify: false });
+  } catch (e) {
+    throw new PsdError(`ZIP channel data: ${e instanceof ZlibError || e instanceof Error ? e.message : String(e)}`);
+  }
+  if (out.length < expected) throw new PsdError(`ZIP stream produced ${out.length} of ${expected} bytes.`);
+  return out.length === expected ? out : out.subarray(0, expected);
+}
+function unpredict(buf, l) {
+  const rb = rowBytes(l.width, l.depth);
+  if (rb === 0) return;
+  const w = l.width;
+  const scratch = l.depth === 32 ? new Uint8Array(rb) : null;
+  for (let o = 0; o + rb <= buf.length; o += rb) {
+    if (l.depth === 1 || l.depth === 8) {
+      for (let i = 1; i < rb; i++) buf[o + i] = buf[o + i] + buf[o + i - 1] & 255;
+    } else if (l.depth === 16) {
+      for (let i = 1; i < w; i++) {
+        const a = buf[o + 2 * i] << 8 | buf[o + 2 * i + 1];
+        const b = buf[o + 2 * i - 2] << 8 | buf[o + 2 * i - 1];
+        const v = a + b & 65535;
+        buf[o + 2 * i] = v >> 8;
+        buf[o + 2 * i + 1] = v & 255;
+      }
+    } else if (l.depth === 32) {
+      for (let i = 1; i < rb; i++) buf[o + i] = buf[o + i] + buf[o + i - 1] & 255;
+      scratch.set(buf.subarray(o, o + rb));
+      for (let i = 0; i < w; i++) for (let k = 0; k < 4; k++) buf[o + 4 * i + k] = scratch[k * w + i];
+    } else {
+      throw new PsdError(`ZIP prediction is not defined for depth ${l.depth}.`);
+    }
+  }
+}
+function decodeRle(r, l, total) {
+  const rows = l.planes * l.height;
+  const rb = rowBytes(l.width, l.depth);
+  r.checkCount(rows, l.psb ? 4 : 2, "RLE row counts");
+  const counts = new Array(rows);
+  for (let i = 0; i < rows; i++) counts[i] = l.psb ? r.u32() : r.u16();
+  if (total > r.remaining * 130) throw new PsdError("RLE data is too short for its declared size.");
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const c of counts) at = packbitsDecodeInto(r.bytes(c), rb, out, at);
+  return out;
+}
+function decodePlanes(compression, data, l) {
+  const total = decodedLength(l);
+  switch (compression) {
+    case 0:
+      if (data.length < total) throw new PsdError(`Raw channel data has ${data.length} of ${total} bytes.`);
+      return data.slice(0, total);
+    case 1:
+      return decodeRle(new PsdReader(data), l, total);
+    case 2:
+      return inflateChecked(data, total).slice();
+    case 3: {
+      const v = inflateChecked(data, total).slice();
+      unpredict(v, l);
+      return v;
+    }
+    default:
+      throw new PsdError(`Unsupported compression method ${compression}.`);
+  }
+}
+function encodeRle(decoded2, l) {
+  const rows = l.planes * l.height;
+  const rb = rowBytes(l.width, l.depth);
+  const cs = l.psb ? 4 : 2;
+  const packed = new Uint8Array(rows * packbitsBound(rb));
+  let at = 0;
+  const counts = new Uint8Array(rows * cs);
+  for (let row = 0; row < rows; row++) {
+    const start = at;
+    at = packbitsEncode(decoded2.subarray(row * rb, (row + 1) * rb), packed, at);
+    const n = at - start;
+    if (cs === 2) {
+      if (n > 65535) throw new PsdError("An RLE row is longer than 65535 bytes; write a PSB instead.");
+      counts[row * 2] = n >> 8;
+      counts[row * 2 + 1] = n & 255;
+    } else {
+      counts[row * 4] = n >>> 24;
+      counts[row * 4 + 1] = n >>> 16 & 255;
+      counts[row * 4 + 2] = n >>> 8 & 255;
+      counts[row * 4 + 3] = n & 255;
+    }
+  }
+  const out = new Uint8Array(counts.length + at);
+  out.set(counts);
+  out.set(packed.subarray(0, at), counts.length);
+  return out;
+}
+
+// src/image-editor/psd/file.ts
+var PSD_MAX_DIMENSION = 3e4;
+var PSB_MAX_DIMENSION = 3e5;
+var MAX_CHANNELS = 56;
+var MAX_LAYER_CHANNELS = 64;
+var COLOR_MODES = {
+  0: "bitmap",
+  1: "grayscale",
+  2: "indexed",
+  3: "rgb",
+  4: "cmyk",
+  7: "multichannel",
+  8: "duotone",
+  9: "lab"
+};
+var PSB_LONG_KEYS = /* @__PURE__ */ new Set([
+  "LMsk",
+  "Lr16",
+  "Lr32",
+  "Layr",
+  "Mt16",
+  "Mt32",
+  "Mtrn",
+  "Alph",
+  "FMsk",
+  "lnk2",
+  "FEid",
+  "FXid",
+  "PxSD",
+  "lnk3",
+  "lnkE",
+  "pths",
+  "extd",
+  "extn",
+  "FELS",
+  "cinf",
+  "artd"
+]);
+var CHANNEL_ALPHA = -1;
+var CHANNEL_USER_MASK = -2;
+var CHANNEL_REAL_USER_MASK = -3;
+var LAYER_FLAG_TRANSPARENCY_PROTECTED = 1;
+var LAYER_FLAG_HIDDEN = 2;
+var MASK_FLAG_DISABLED = 2;
+var MASK_FLAG_PARAMETERS = 16;
+var SECTION_OTHER = 0;
+var SECTION_OPEN = 1;
+var SECTION_CLOSED = 2;
+var SECTION_DIVIDER = 3;
+function readRect(r) {
+  return { top: r.i32(), left: r.i32(), bottom: r.i32(), right: r.i32() };
+}
+function rectSize(rect) {
+  const width = rect.right - rect.left;
+  const height = rect.bottom - rect.top;
+  if (width < 0 || height < 0) throw new PsdError("A layer rectangle has a negative size.");
+  if (width > PSB_MAX_DIMENSION || height > PSB_MAX_DIMENSION) throw new PsdError("A layer is larger than 300000 pixels.");
+  return { width, height };
+}
+function readHeader(r) {
+  if (r.ascii(4) !== "8BPS") throw new PsdError('Not a PSD file: the signature is not "8BPS".');
+  const version = r.u16();
+  if (version !== 1 && version !== 2) throw new PsdError(`Unsupported PSD version ${version} (1 is PSD, 2 is PSB).`);
+  r.skip(6);
+  const h = { psb: version === 2, channels: r.u16(), height: r.u32(), width: r.u32(), depth: r.u16(), colorMode: r.u16() };
+  if (h.channels < 1 || h.channels > MAX_CHANNELS) throw new PsdError(`Channel count ${h.channels} is outside 1 to ${MAX_CHANNELS}.`);
+  if (h.width < 1 || h.height < 1) throw new PsdError(`Image size ${h.width} \xD7 ${h.height} must be at least 1 \xD7 1.`);
+  const max = h.psb ? PSB_MAX_DIMENSION : PSD_MAX_DIMENSION;
+  if (h.width > max || h.height > max) throw new PsdError(`Image size ${h.width} \xD7 ${h.height} exceeds ${max} pixels.`);
+  if (![1, 8, 16, 32].includes(h.depth)) throw new PsdError(`Unsupported bit depth ${h.depth}.`);
+  return h;
+}
+function readResources(r) {
+  const s = r.sub(r.u32());
+  const out = [];
+  while (s.remaining >= 12) {
+    s.ascii(4);
+    const id = s.u16();
+    const name = decodeLegacyName(s.pascal(2));
+    const len = s.u32();
+    const data = s.bytes(len);
+    if (len % 2 && s.remaining) s.skip(1);
+    out.push({ id, name, data });
+  }
+  return out;
+}
+var isSig = (r, at = 0) => {
+  const b = r.data.subarray(r.pos + at, r.pos + at + 4);
+  if (b.length < 4) return false;
+  const s = String.fromCharCode(b[0], b[1], b[2], b[3]);
+  return s === "8BIM" || s === "8B64";
+};
+function readBlocks(r, psb, alignment) {
+  const out = [];
+  while (r.remaining >= 12 && isSig(r)) {
+    r.skip(4);
+    const key = r.ascii(4);
+    const len = r.len(psb && PSB_LONG_KEYS.has(key));
+    const data = r.bytes(len);
+    let pad = -1;
+    for (let k = 0; k <= 3; k++) {
+      if (k === r.remaining || k < r.remaining && isSig(r, k)) {
+        pad = k;
+        break;
+      }
+    }
+    if (pad < 0) {
+      const def = (alignment - len % alignment) % alignment;
+      pad = r.peek(def).every((b) => b === 0) && r.remaining >= def ? def : 0;
+    }
+    r.skip(pad);
+    out.push({ key, data });
+  }
+  return out;
+}
+function maskParameterBytes(pf) {
+  return (pf & 1 ? 1 : 0) + (pf & 2 ? 8 : 0) + (pf & 4 ? 1 : 0) + (pf & 8 ? 8 : 0);
+}
+function realBeforeParameters(d) {
+  const fits = (at) => {
+    if (at >= d.length) return false;
+    const end = at + 1 + maskParameterBytes(d[at]);
+    return d.length >= end && d.length <= end + 3;
+  };
+  if (fits(18)) return false;
+  if (!fits(36)) return false;
+  const known = (pf) => (pf & 240) === 0;
+  const bgOk = (at) => at + 1 < d.length && (d[at + 1] === 0 || d[at + 1] === 255);
+  const photoshop = bgOk(18) && known(d[36]);
+  const realAt = 19 + maskParameterBytes(d[18]);
+  const spec = known(d[18]) && d.length >= realAt + 18 && d.length <= realAt + 21 && bgOk(realAt);
+  return photoshop || !spec;
+}
+function parseMask(d) {
+  try {
+    const r = new PsdReader(d);
+    const m = { rect: readRect(r), defaultColor: r.u8(), flags: r.u8() };
+    const readReal = () => r.remaining >= 18 ? { flags: r.u8(), background: r.u8(), rect: readRect(r) } : void 0;
+    const params = (m.flags & MASK_FLAG_PARAMETERS) !== 0;
+    const realFirst = params && realBeforeParameters(d);
+    if (realFirst) m.real = readReal();
+    if (params) {
+      const pf = r.u8();
+      if (pf & 1) m.userDensity = r.u8();
+      if (pf & 2) m.userFeather = r.f64();
+      if (pf & 4) m.vectorDensity = r.u8();
+      if (pf & 8) m.vectorFeather = r.f64();
+    }
+    if (!realFirst) m.real = readReal();
+    return m;
+  } catch {
+    return void 0;
+  }
+}
+function readLayerRecord(r, psb) {
+  const rect = readRect(r);
+  const n = r.u16();
+  if (n > MAX_LAYER_CHANNELS) throw new PsdError(`A layer has ${n} channels (at most ${MAX_LAYER_CHANNELS}).`);
+  const channels = [];
+  const lengths = [];
+  for (let i = 0; i < n; i++) {
+    channels.push({ id: r.i16(), compression: null, data: new Uint8Array(0) });
+    lengths.push(r.len(psb));
+  }
+  if (r.ascii(4) !== "8BIM") throw new PsdError('A layer record has no "8BIM" blend-mode signature.');
+  const blendKey = r.ascii(4);
+  const opacity = r.u8();
+  const clipping = r.u8();
+  const flags = r.u8();
+  r.u8();
+  const x = r.sub(r.u32());
+  const maskBytes = x.bytes(x.u32());
+  const mask = maskBytes.length ? parseMask(maskBytes) : void 0;
+  x.skip(x.u32());
+  const legacyName = decodeLegacyName(x.pascal(4));
+  const blocks = readBlocks(x, psb, 2);
+  return { record: { rect, channels, blendKey, opacity, clipping, flags, mask, legacyName, blocks }, lengths };
+}
+function readLayerInfo(data, psb) {
+  const r = new PsdReader(data);
+  const count = r.i16();
+  const n = Math.abs(count);
+  r.checkCount(n, 34, "Layer records");
+  const read = [];
+  for (let i = 0; i < n; i++) read.push(readLayerRecord(r, psb));
+  for (const { record, lengths } of read) {
+    record.channels.forEach((ch, i) => {
+      const len = lengths[i];
+      if (len === 0) return;
+      if (len === 1) throw new PsdError("A channel has a data length of 1.");
+      ch.compression = r.u16();
+      ch.data = r.bytes(len - 2);
+    });
+  }
+  return { layers: read.map((x) => x.record), mergedAlpha: count < 0 };
+}
+function readPsd(bytes) {
+  const r = new PsdReader(bytes);
+  const header = readHeader(r);
+  const { psb } = header;
+  const colorModeData = r.bytes(r.u32());
+  const resources = readResources(r);
+  const s = r.sub(r.len(psb));
+  let layers = [];
+  let mergedAlpha = false;
+  let globalBlocks = [];
+  if (s.remaining) {
+    const liLen = s.len(psb);
+    if (liLen > 0) ({ layers, mergedAlpha } = readLayerInfo(s.bytes(liLen), psb));
+    if (s.remaining >= 4) {
+      s.skip(s.u32());
+      globalBlocks = readBlocks(s, psb, 4);
+      const key = header.depth === 16 ? "Lr16" : header.depth === 32 ? "Lr32" : null;
+      const block = globalBlocks.find((b) => key ? b.key === key : !layers.length && ["Layr", "Lr16", "Lr32"].includes(b.key));
+      if (block) {
+        ({ layers, mergedAlpha } = readLayerInfo(block.data, psb));
+        globalBlocks = globalBlocks.filter((b) => b !== block);
+      }
+    }
+  }
+  const imageCompression = r.remaining >= 2 ? r.u16() : 0;
+  return { header, colorModeData, resources, layers, mergedAlpha, globalBlocks, imageCompression, imageData: r.rest() };
+}
+function layerBlock(rec, key) {
+  return rec.blocks.find((b) => b.key === key)?.data;
+}
+function layerName(rec) {
+  const luni = layerBlock(rec, "luni");
+  if (luni) {
+    try {
+      return new PsdReader(luni).unicode();
+    } catch {
+    }
+  }
+  return rec.legacyName;
+}
+function sectionDivider(rec) {
+  const d = layerBlock(rec, "lsct") ?? layerBlock(rec, "lsdk");
+  if (!d || d.length < 4) return void 0;
+  const r = new PsdReader(d);
+  const kind = r.u32();
+  if (r.remaining >= 8 && r.ascii(4) === "8BIM") return { kind, blendKey: r.ascii(4) };
+  return { kind };
+}
+function u32Block(rec, key) {
+  const d = layerBlock(rec, key);
+  return d && d.length >= 4 ? new PsdReader(d).u32() : void 0;
+}
+function u8Block(rec, key) {
+  const d = layerBlock(rec, key);
+  return d && d.length >= 1 ? d[0] : void 0;
+}
+function layerTree(file) {
+  const stack = [[]];
+  file.layers.forEach((rec, index) => {
+    const kind = sectionDivider(rec)?.kind ?? SECTION_OTHER;
+    if (kind === SECTION_DIVIDER) {
+      stack.push([]);
+    } else if (kind === SECTION_OPEN || kind === SECTION_CLOSED) {
+      const children = stack.length > 1 ? stack.pop() : [];
+      stack[stack.length - 1].push({ index, children });
+    } else {
+      stack[stack.length - 1].push({ index });
+    }
+  });
+  while (stack.length > 1) {
+    const children = stack.pop();
+    stack[stack.length - 1].push(...children);
+  }
+  return stack[0];
+}
+function channelRect(rec, id) {
+  if (id === CHANNEL_USER_MASK && rec.mask) return rec.mask.rect;
+  if (id === CHANNEL_REAL_USER_MASK && rec.mask) return rec.mask.real?.rect ?? rec.mask.rect;
+  return rec.rect;
+}
+function decodeLayerChannel(file, rec, id) {
+  const ch = rec.channels.find((c) => c.id === id);
+  if (!ch) return void 0;
+  const { width, height } = rectSize(channelRect(rec, id));
+  if (ch.compression === null) {
+    if (width * height === 0) return new Uint8Array(0);
+    throw new PsdError(`Channel ${id} of layer "${layerName(rec)}" has no data.`);
+  }
+  return decodePlanes(ch.compression, ch.data, { planes: 1, width, height, depth: file.header.depth, psb: file.header.psb });
+}
+function decodeMergedImage(file) {
+  const { channels, width, height, depth, psb } = file.header;
+  return decodePlanes(file.imageCompression, file.imageData, { planes: channels, width, height, depth, psb });
+}
+function resource(file, id) {
+  return file.resources.find((r) => r.id === id)?.data;
+}
+function resolution(file) {
+  const d = resource(file, 1005);
+  if (!d || d.length < 4) return void 0;
+  return new PsdReader(d).u32() / 65536;
+}
+function writeRect(w, r) {
+  w.i32(r.top);
+  w.i32(r.left);
+  w.i32(r.bottom);
+  w.i32(r.right);
+}
+function writeBlocks(w, blocks, psb, alignment) {
+  for (const b of blocks) {
+    const long2 = psb && PSB_LONG_KEYS.has(b.key);
+    w.ascii(long2 ? "8B64" : "8BIM");
+    w.ascii(b.key);
+    const pad = (alignment - b.data.length % alignment) % alignment;
+    if (long2) w.u64(b.data.length + pad);
+    else w.u32(b.data.length + pad);
+    w.bytes(b.data);
+    w.zeros(pad);
+  }
+}
+function writeMask(w, m) {
+  writeRect(w, m.rect);
+  w.u8(m.defaultColor);
+  const pf = (m.userDensity !== void 0 ? 1 : 0) | (m.userFeather !== void 0 ? 2 : 0);
+  w.u8(pf ? m.flags | MASK_FLAG_PARAMETERS : m.flags & ~MASK_FLAG_PARAMETERS);
+  if (pf) {
+    w.u8(pf);
+    if (m.userDensity !== void 0) w.u8(m.userDensity);
+    if (m.userFeather !== void 0) w.f64(m.userFeather);
+  }
+  const len = 18 + (pf ? 1 + maskParameterBytes(pf) : 0);
+  w.zeros(Math.max(0, 20 - len) + (4 - Math.max(20, len) % 4) % 4);
+}
+function writeLayerRecord(w, rec, psb, nameBytes) {
+  writeRect(w, rec.rect);
+  w.u16(rec.channels.length);
+  for (const c of rec.channels) {
+    w.i16(c.id);
+    const len = c.compression === null ? 0 : 2 + c.data.length;
+    if (psb) w.u64(len);
+    else w.u32(len);
+  }
+  if (rec.blendKey.length !== 4) throw new PsdError(`Blend key "${rec.blendKey}" must be 4 characters.`);
+  w.ascii("8BIM");
+  w.ascii(rec.blendKey);
+  w.u8(rec.opacity);
+  w.u8(rec.clipping);
+  w.u8(rec.flags);
+  w.u8(0);
+  const extra = w.beginLen(false);
+  const mask = w.beginLen(false);
+  if (rec.mask) writeMask(w, rec.mask);
+  w.endLen(mask);
+  w.u32(40);
+  for (let i = 0; i < 5; i++) w.bytes([0, 0, 255, 255, 0, 0, 255, 255]);
+  w.pascal(nameBytes, 4);
+  writeBlocks(w, rec.blocks, psb, 2);
+  w.endLen(extra);
+}
+function writePsd(file, encodeName) {
+  const { header } = file;
+  const { psb } = header;
+  const w = new PsdWriter();
+  w.ascii("8BPS");
+  w.u16(psb ? 2 : 1);
+  w.zeros(6);
+  w.u16(header.channels);
+  w.u32(header.height);
+  w.u32(header.width);
+  w.u16(header.depth);
+  w.u16(header.colorMode);
+  w.u32(file.colorModeData.length);
+  w.bytes(file.colorModeData);
+  const res = w.beginLen(false);
+  for (const r of file.resources) {
+    w.ascii("8BIM");
+    w.u16(r.id);
+    w.pascal(encodeName(r.name), 2);
+    w.u32(r.data.length);
+    w.bytes(r.data);
+    if (r.data.length % 2) w.u8(0);
+  }
+  w.endLen(res);
+  const lm = w.beginLen(psb);
+  if (file.layers.length || file.globalBlocks.length) {
+    const li = w.beginLen(psb);
+    if (file.layers.length) {
+      const start = w.length;
+      w.i16(file.mergedAlpha ? -file.layers.length : file.layers.length);
+      for (const rec of file.layers) writeLayerRecord(w, rec, psb, encodeName(rec.legacyName));
+      for (const rec of file.layers) {
+        for (const c of rec.channels) {
+          if (c.compression === null) continue;
+          w.u16(c.compression);
+          w.bytes(c.data);
+        }
+      }
+      if ((w.length - start) % 2) w.u8(0);
+    }
+    w.endLen(li);
+    w.u32(0);
+    writeBlocks(w, file.globalBlocks, psb, 4);
+  }
+  w.endLen(lm);
+  w.u16(file.imageCompression);
+  w.bytes(file.imageData);
+  return w.result();
+}
+
+// src/image-editor/psd/pixels.ts
+var MODE_INDEXED = 2;
+var MODE_RGB = 3;
+var MODE_CMYK = 4;
+var MODE_MULTICHANNEL = 7;
+var MODE_LAB = 9;
+function colorChannelCount(mode, headerChannels) {
+  switch (mode) {
+    case MODE_RGB:
+    case MODE_LAB:
+      return 3;
+    case MODE_CMYK:
+      return 4;
+    case MODE_MULTICHANNEL:
+      return Math.min(3, headerChannels);
+    default:
+      return 1;
+  }
+}
+var clamp012 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function sampler(plane, depth, width, encode, fill) {
+  if (!plane) return () => fill;
+  switch (depth) {
+    case 8:
+      return (i) => plane[i] / 255;
+    case 16:
+      return (i) => (plane[2 * i] << 8 | plane[2 * i + 1]) / 65535;
+    case 32: {
+      const view = new DataView(plane.buffer, plane.byteOffset, plane.byteLength);
+      return (i) => {
+        const v = clamp012(view.getFloat32(4 * i, false) || 0);
+        return encode ? linearToSrgb(v) : v;
+      };
+    }
+    case 1: {
+      const rb = Math.ceil(width / 8);
+      return (i) => {
+        const x = i % width;
+        const y = (i - x) / width;
+        return plane[y * rb + (x >> 3)] >> 7 - (x & 7) & 1 ? 0 : 1;
+      };
+    }
+    default:
+      throw new PsdError(`Unsupported bit depth ${depth}.`);
+  }
+}
+function labToSrgb(l, a, b) {
+  const fy = (l + 16) / 116;
+  const f = (t) => t > 6 / 29 ? t ** 3 : 3 * (6 / 29) ** 2 * (t - 4 / 29);
+  const x = f(fy + a / 500) * D50[0];
+  const y = f(fy) * D50[1];
+  const z = f(fy - b / 200) * D50[2];
+  const m = XYZ_D50_TO_SRGB;
+  return [
+    linearToSrgb(clamp012(m[0][0] * x + m[0][1] * y + m[0][2] * z)),
+    linearToSrgb(clamp012(m[1][0] * x + m[1][1] * y + m[1][2] * z)),
+    linearToSrgb(clamp012(m[2][0] * x + m[2][1] * y + m[2][2] * z))
+  ];
+}
+function toRgba8(set) {
+  const { width, height, depth, mode } = set;
+  const n = width * height;
+  const out = new Uint8ClampedArray(n * 4);
+  const linear = depth === 32;
+  const isLab = mode === MODE_LAB;
+  const cmyk = mode === MODE_CMYK;
+  const planes = set.color.map((p) => sampler(p, depth, width, linear && !isLab && !cmyk, cmyk ? 1 : 0));
+  const alpha = sampler(set.alpha, depth, width, false, 1);
+  const fast8 = depth === 8 && mode === MODE_RGB && set.color.every(Boolean);
+  if (fast8) {
+    const [r, g, b] = set.color;
+    const a = set.alpha;
+    for (let i = 0, o = 0; i < n; i++, o += 4) {
+      out[o] = r[i];
+      out[o + 1] = g[i];
+      out[o + 2] = b[i];
+      out[o + 3] = a ? a[i] : 255;
+    }
+    return out;
+  }
+  const palette = set.palette;
+  for (let i = 0, o = 0; i < n; i++, o += 4) {
+    let r;
+    let g;
+    let b;
+    switch (mode) {
+      case MODE_RGB:
+      case MODE_MULTICHANNEL:
+        r = planes[0](i);
+        g = planes[1] ? planes[1](i) : r;
+        b = planes[2] ? planes[2](i) : r;
+        break;
+      case MODE_CMYK: {
+        const k = planes[3] ? planes[3](i) : 1;
+        r = planes[0](i) * k;
+        g = planes[1](i) * k;
+        b = planes[2](i) * k;
+        break;
+      }
+      case MODE_LAB:
+        [r, g, b] = labToSrgb(planes[0](i) * 100, planes[1](i) * 255 - 128, planes[2](i) * 255 - 128);
+        break;
+      case MODE_INDEXED: {
+        const idx = Math.round(planes[0](i) * 255);
+        if (palette && palette.length >= 768) {
+          out[o] = palette[idx];
+          out[o + 1] = palette[256 + idx];
+          out[o + 2] = palette[512 + idx];
+          out[o + 3] = Math.round(alpha(i) * 255);
+          continue;
+        }
+        r = g = b = idx / 255;
+        break;
+      }
+      default:
+        r = g = b = planes[0](i);
+    }
+    out[o] = Math.round(r * 255);
+    out[o + 1] = Math.round(g * 255);
+    out[o + 2] = Math.round(b * 255);
+    out[o + 3] = Math.round(alpha(i) * 255);
+  }
+  return out;
+}
+function toMask8(plane, width, height, depth) {
+  if (depth === 8) return new Uint8ClampedArray(plane.buffer, plane.byteOffset, width * height);
+  const s = sampler(plane, depth, width, false, 0);
+  const out = new Uint8ClampedArray(width * height);
+  for (let i = 0; i < out.length; i++) out[i] = Math.round(s(i) * 255);
+  return out;
+}
+function rgbaToPlanes(data, n) {
+  const planes = [new Uint8Array(n), new Uint8Array(n), new Uint8Array(n), new Uint8Array(n)];
+  for (let i = 0, o = 0; i < n; i++, o += 4) {
+    planes[0][i] = data[o];
+    planes[1][i] = data[o + 1];
+    planes[2][i] = data[o + 2];
+    planes[3][i] = data[o + 3];
+  }
+  return planes;
+}
+function unmatteWhite(data) {
+  for (let i = 0; i < data.length; i += 4) {
+    const a = data[i + 3];
+    if (a === 255 || a === 0) continue;
+    const k = 255 - a;
+    for (let c = 0; c < 3; c++) data[i + c] = Math.round((data[i + c] - k) * 255 / a);
+  }
+}
+function matteWhite(data) {
+  const out = Uint8ClampedArray.from(data);
+  for (let i = 0; i < out.length; i += 4) {
+    const a = out[i + 3];
+    if (a === 255) continue;
+    for (let c = 0; c < 3; c++) out[i + c] = Math.round((out[i + c] * a + 255 * (255 - a)) / 255);
+  }
+  return out;
+}
+
+// src/image-editor/psd/import.ts
+var PSD_BLEND_KEYS = {
+  pass: "pass-through",
+  norm: "normal",
+  dark: "darken",
+  "mul ": "multiply",
+  idiv: "color-burn",
+  lbrn: "linear-burn",
+  dkCl: "darker-color",
+  lite: "lighten",
+  scrn: "screen",
+  "div ": "color-dodge",
+  lddg: "linear-dodge",
+  lgCl: "lighter-color",
+  over: "overlay",
+  sLit: "soft-light",
+  hLit: "hard-light",
+  vLit: "vivid-light",
+  lLit: "linear-light",
+  pLit: "pin-light",
+  hMix: "hard-mix",
+  diff: "difference",
+  smud: "exclusion",
+  fsub: "subtract",
+  fdiv: "divide",
+  "hue ": "hue",
+  "sat ": "saturation",
+  colr: "color",
+  "lum ": "luminosity"
+};
+var BLEND_TO_PSD = Object.fromEntries(
+  Object.entries(PSD_BLEND_KEYS).map(([k, v]) => [v, k])
+);
+var FILL_KEYS = ["SoCo", "GdFl", "PtFl"];
+var TYPE_KEYS = ["TySh", "tySh"];
+var SMART_KEYS = ["SoLd", "SoLE", "PlLd"];
+var VECTOR_KEYS = ["vmsk", "vsms"];
+var EFFECT_KEYS = ["lfx2", "lfxs", "lmfx"];
+var percent = (v) => Math.round(v / 255 * 100) / 100;
+var Warnings = class {
+  groups = /* @__PURE__ */ new Map();
+  extra = [];
+  add(message, layer) {
+    const list = this.groups.get(message) ?? [];
+    if (!list.includes(layer)) list.push(layer);
+    this.groups.set(message, list);
+  }
+  list() {
+    const out = [...this.extra];
+    for (const [message, layers] of this.groups) {
+      const names = layers.map((n) => `"${n}"`);
+      const shown = names.length > 6 ? `${names.slice(0, 6).join(", ")} and ${names.length - 6} more` : names.join(", ");
+      out.push(`${message} (${layers.length === 1 ? "layer" : "layers"} ${shown}).`);
+    }
+    return out;
+  }
+};
+function psdKind(rec) {
+  if (rec.blocks.some((b) => TYPE_KEYS.includes(b.key))) return "type";
+  if (rec.blocks.some((b) => SMART_KEYS.includes(b.key))) return "smart-object";
+  const fill = rec.blocks.some((b) => FILL_KEYS.includes(b.key));
+  const vector = rec.blocks.some((b) => VECTOR_KEYS.includes(b.key) || b.key === "vstk");
+  if (fill && vector) return "shape";
+  if (fill) return "fill";
+  const adj = rec.blocks.find((b) => ADJUSTMENT_KEYS.includes(b.key));
+  if (adj) return adjustmentLabel(adj.key);
+  return "pixel";
+}
+function locksOf(rec) {
+  const v = u32Block(rec, "lspf");
+  if (!v) return void 0;
+  const locks = {};
+  if (v & 2147483648) locks.all = true;
+  if (v & 1) locks.transparency = true;
+  if (v & 2) locks.pixels = true;
+  if (v & 4) locks.position = true;
+  return Object.keys(locks).length ? locks : void 0;
+}
+function decodeOr(ctx, rec, id, name) {
+  try {
+    return decodeLayerChannel(ctx.file, rec, id);
+  } catch (e) {
+    ctx.warn.add(`A channel could not be decoded (${e instanceof Error ? e.message : String(e)}) and the layer is treated as empty`, name);
+    return void 0;
+  }
+}
+function safeSize(ctx, rect, name) {
+  try {
+    return rectSize(rect);
+  } catch (e) {
+    ctx.warn.add(`A malformed rectangle (${e instanceof Error ? e.message : String(e)}) left the layer or its mask empty`, name);
+    return { width: 0, height: 0 };
+  }
+}
+function recordPixels(ctx, rec, name) {
+  const { width, height } = safeSize(ctx, rec.rect, name);
+  if (!width || !height || ctx.skipPixels) return emptySurface(4);
+  const ids = [...Array.from({ length: ctx.colorCount }, (_, i) => i), CHANNEL_ALPHA];
+  const planes = ids.map((id) => rec.channels.some((c) => c.id === id) ? decodeOr(ctx, rec, id, name) ?? null : void 0);
+  if (planes.some((p) => p === null)) return emptySurface(4);
+  if (planes.every((p) => p === void 0)) return emptySurface(4);
+  const data = toRgba8({
+    width,
+    height,
+    depth: ctx.file.header.depth,
+    mode: ctx.file.header.colorMode,
+    color: planes.slice(0, ctx.colorCount),
+    alpha: planes[ctx.colorCount],
+    palette: ctx.palette
+  });
+  return surfaceFromPixels({ width, height, data }, 4, rec.rect.left, rec.rect.top);
+}
+function recordMask(ctx, rec, name) {
+  const m = rec.mask;
+  if (!m) return void 0;
+  const useReal = rec.channels.some((c) => c.id === CHANNEL_REAL_USER_MASK) && m.real;
+  const id = useReal ? CHANNEL_REAL_USER_MASK : CHANNEL_USER_MASK;
+  if (!rec.channels.some((c) => c.id === id)) return void 0;
+  const rect = useReal ? m.real.rect : m.rect;
+  const def = (useReal ? m.real.background : m.defaultColor) >= 128 ? 255 : 0;
+  const flags = useReal ? m.real.flags : m.flags;
+  let surface = emptySurface(1, def);
+  const { width, height } = safeSize(ctx, rect, name);
+  if (width && height && !ctx.skipPixels) {
+    const plane = decodeOr(ctx, rec, id, name);
+    if (plane) surface = surfaceFromPixels({ width, height, data: toMask8(plane, width, height, ctx.file.header.depth) }, 1, rect.left, rect.top, def);
+  }
+  const mask = { surface, defaultValue: def };
+  if (m.userDensity !== void 0 && m.userDensity < 255) mask.density = percent(m.userDensity);
+  if (m.userFeather !== void 0 && m.userFeather > 0) mask.feather = Math.min(1e3, m.userFeather);
+  if (flags & MASK_FLAG_DISABLED) mask.enabled = false;
+  return mask;
+}
+function baseProps(ctx, rec, name, notes) {
+  let blend = PSD_BLEND_KEYS[rec.blendKey];
+  if (rec.blendKey === "diss") {
+    ctx.warn.add("Dissolve is not supported and became Normal", name);
+    notes.push("Dissolve became Normal");
+  } else if (!blend) {
+    ctx.warn.add(`An unknown blend mode became Normal`, name);
+    notes.push(`unknown blend mode "${rec.blendKey}"`);
+  }
+  if (!blend || blend === "pass-through") blend = "normal";
+  const props = {
+    name,
+    visible: (rec.flags & LAYER_FLAG_HIDDEN) === 0,
+    opacity: percent(rec.opacity),
+    blend
+  };
+  if (rec.clipping) props.clipped = true;
+  const locks = locksOf(rec);
+  if (locks) props.locks = locks;
+  if (rec.blocks.some((b) => EFFECT_KEYS.includes(b.key))) {
+    ctx.warn.add("Layer effects (lfx2) are not rendered", name);
+    notes.push("layer effects are not rendered");
+  }
+  if (rec.blocks.some((b) => b.key === "artb" || b.key === "artd" || b.key === "abdd")) {
+    ctx.warn.add("Artboards are not supported; they came in as plain groups, without their background colour and clipping", name);
+    notes.push("artboard imported as a group");
+  }
+  if (rec.blocks.some((b) => VECTOR_KEYS.includes(b.key)) && psdKind(rec) === "pixel") {
+    ctx.warn.add("Vector masks are not supported and were ignored", name);
+    notes.push("vector mask ignored");
+  }
+  return props;
+}
+function importNode(ctx, node, depth) {
+  const rec = ctx.file.layers[node.index];
+  const name = layerName(rec);
+  const notes = [];
+  const kind = psdKind(rec);
+  const entry = { name, type: null, status: "mapped", psdKind: node.children ? "group" : kind, notes, depth };
+  ctx.summary.push(entry);
+  if (node.children) {
+    const props2 = baseProps(ctx, rec, name, notes);
+    const divider = sectionDivider(rec);
+    const key = divider?.blendKey ?? rec.blendKey;
+    const groupBlend = key === "pass" ? "pass-through" : PSD_BLEND_KEYS[key] ?? "normal";
+    const children = [];
+    for (const child of node.children) {
+      const layer2 = importNode(ctx, child, depth + 1);
+      if (layer2) children.push(layer2);
+    }
+    const group = { type: "group", id: ctx.newId(name), ...props2, blend: groupBlend, children };
+    if (divider?.kind === SECTION_CLOSED) group.collapsed = true;
+    const mask2 = recordMask(ctx, rec, name);
+    if (mask2) group.mask = mask2;
+    entry.type = "group";
+    entry.id = group.id;
+    entry.status = notes.length ? "approximated" : "mapped";
+    return group;
+  }
+  const adjBlock = rec.blocks.find((b) => ADJUSTMENT_KEYS.includes(b.key));
+  if (adjBlock) {
+    const parsed = parseAdjustmentBlock(adjBlock.key, adjBlock.data);
+    if (!parsed) {
+      const label = adjustmentLabel(adjBlock.key);
+      ctx.warn.add(`${label} adjustment layers are not supported and were left out`, name);
+      notes.push(`${label} is not supported`);
+      entry.status = "dropped";
+      return null;
+    }
+    const props2 = baseProps(ctx, rec, name, notes);
+    if (parsed.approximated) {
+      ctx.warn.add(`A ${adjustmentLabel(adjBlock.key)} layer was approximated: ${parsed.approximated}`, name);
+      notes.push(parsed.approximated);
+    }
+    const layer2 = { type: "adjustment", id: ctx.newId(name), ...props2, kind: parsed.kind, params: parsed.params };
+    const mask2 = recordMask(ctx, rec, name);
+    if (mask2) layer2.mask = mask2;
+    entry.type = "adjustment";
+    entry.id = layer2.id;
+    entry.status = notes.length ? "approximated" : "mapped";
+    return layer2;
+  }
+  const props = baseProps(ctx, rec, name, notes);
+  if (kind !== "pixel") {
+    const what = kind === "smart-object" ? "Smart objects" : kind === "type" ? "Type layers" : kind === "shape" ? "Shape layers" : "Fill layers";
+    ctx.warn.add(`${what} came in as pixel layers (their stored pixels)`, name);
+    notes.push(`${kind} layer imported as pixels`);
+  }
+  const layer = { type: "pixel", id: ctx.newId(name), ...props, surface: recordPixels(ctx, rec, name), offset: { x: 0, y: 0 } };
+  const fill = u8Block(rec, "iOpa");
+  if (fill !== void 0 && fill < 255) layer.fillOpacity = percent(fill);
+  const mask = recordMask(ctx, rec, name);
+  if (mask) layer.mask = mask;
+  entry.type = "pixel";
+  entry.id = layer.id;
+  entry.status = notes.length ? "approximated" : "mapped";
+  return layer;
+}
+function mergedLayer(ctx) {
+  const { header } = ctx.file;
+  const { width, height } = header;
+  let planes;
+  try {
+    planes = decodeMergedImage(ctx.file);
+  } catch (e) {
+    ctx.warn.extra.push(`The merged image could not be decoded (${e instanceof Error ? e.message : String(e)}).`);
+    return null;
+  }
+  const size = rowBytes(width, header.depth) * height;
+  const plane = (i) => i < header.channels ? planes.subarray(i * size, (i + 1) * size) : void 0;
+  const cc = ctx.colorCount;
+  const hasAlpha = header.channels > cc && (ctx.file.layers.length === 0 || ctx.file.mergedAlpha);
+  const data = toRgba8({
+    width,
+    height,
+    depth: header.depth,
+    mode: header.colorMode,
+    color: Array.from({ length: cc }, (_, i) => plane(i)),
+    alpha: hasAlpha ? plane(cc) : void 0,
+    palette: ctx.palette
+  });
+  if (hasAlpha) unmatteWhite(data);
+  return {
+    type: "pixel",
+    id: ctx.newId("Background"),
+    name: "Background",
+    visible: true,
+    opacity: 1,
+    blend: "normal",
+    surface: surfaceFromPixels({ width, height, data }, 4),
+    offset: { x: 0, y: 0 }
+  };
+}
+function psdToLayers(file, options = {}) {
+  const { header } = file;
+  const warn = new Warnings();
+  let n = 0;
+  const ctx = {
+    file,
+    warn,
+    newId: options.newId ?? (() => `psd-${++n}`),
+    skipPixels: options.skipPixels ?? false,
+    summary: [],
+    colorCount: colorChannelCount(header.colorMode, header.channels),
+    palette: header.colorMode === MODE_INDEXED ? file.colorModeData : void 0
+  };
+  const mode = COLOR_MODES[header.colorMode] ?? `mode ${header.colorMode}`;
+  if (mode !== "rgb" || header.depth !== 8) {
+    warn.extra.push(`The file is ${header.depth}-bit ${mode}; it was converted to 8-bit RGB.`);
+  }
+  if (resource(file, 1039)) warn.extra.push("The embedded ICC profile is ignored; colours are read as sRGB.");
+  let layers = [];
+  if (file.layers.length) {
+    const tree = layerTree(file);
+    const built = [];
+    for (const node of tree) {
+      const layer = importNode(ctx, node, 0);
+      if (layer) built.push(layer);
+    }
+    layers = built;
+    if (!layers.length && !ctx.skipPixels) {
+      const bg = mergedLayer(ctx);
+      if (bg) {
+        layers = [bg];
+        warn.extra.push("No layer could be imported, so the merged image was opened as the Background.");
+      }
+    }
+  } else if (!ctx.skipPixels) {
+    const bg = mergedLayer(ctx);
+    if (bg) layers = [bg];
+  }
+  return {
+    width: header.width,
+    height: header.height,
+    layers,
+    warnings: warn.list(),
+    summary: ctx.summary,
+    resolution: resolution(file),
+    info: { psb: header.psb, depth: header.depth, colorMode: mode, channels: header.channels }
+  };
+}
+function importPsd(bytes, options = {}) {
+  if (bytes.length < 26) throw new PsdError("Not a PSD file: it is shorter than a PSD header.");
+  return psdToLayers(readPsd(bytes), options);
+}
+
+// src/image-editor/psd/export.ts
+var FLAG_PIXELS_IRRELEVANT = 8 | 16;
+var EMPTY_RECT = { top: 0, left: 0, bottom: 0, right: 0 };
+function unicodeBlock(s) {
+  const w = new PsdWriter();
+  w.unicode(s);
+  return w.result();
+}
+function u32Bytes(v) {
+  const w = new PsdWriter();
+  w.u32(v);
+  return w.result();
+}
+function sectionBlock(kind, blendKey) {
+  const w = new PsdWriter();
+  w.u32(kind);
+  if (blendKey) {
+    w.ascii("8BIM");
+    w.ascii(blendKey);
+  }
+  return w.result();
+}
+var toRect = (r) => ({ top: r.y, left: r.x, bottom: r.y + r.height, right: r.x + r.width });
+function rleChannel(id, plane, width, height, psb) {
+  return { id, compression: 1, data: encodeRle(plane, { planes: 1, width, height, depth: 8, psb }) };
+}
+var emptyChannel = (id) => ({ id, compression: 0, data: new Uint8Array(0) });
+function maskChannel(mask, ox, oy, psb) {
+  if (mask.source) throw new PsdError("A parametric mask must be baked before export.");
+  const bounds = contentBounds(mask.surface);
+  const def = mask.defaultValue;
+  const m = { rect: EMPTY_RECT, defaultColor: def, flags: mask.enabled === false ? MASK_FLAG_DISABLED : 0 };
+  if ((mask.density ?? 1) < 1) m.userDensity = Math.round(Math.max(0, mask.density ?? 1) * 255);
+  if ((mask.feather ?? 0) > 0) m.userFeather = mask.feather;
+  if (!bounds) return { channel: emptyChannel(CHANNEL_USER_MASK), mask: m };
+  const plane = readRegion(mask.surface, bounds);
+  m.rect = toRect({ ...bounds, x: bounds.x + ox, y: bounds.y + oy });
+  return { channel: rleChannel(CHANNEL_USER_MASK, new Uint8Array(plane.buffer, plane.byteOffset, plane.length), bounds.width, bounds.height, psb), mask: m };
+}
+function lockBits(layer) {
+  const l = layer.locks;
+  if (!l) return 0;
+  return (l.all ? 2147483648 : 0) | (l.transparency ? 1 : 0) | (l.pixels ? 2 : 0) | (l.position ? 4 : 0);
+}
+function exportPsd(input) {
+  const { width, height } = input;
+  if (width < 1 || height < 1) throw new PsdError("The document is empty.");
+  const psb = width > PSD_MAX_DIMENSION || height > PSD_MAX_DIMENSION;
+  const records = [];
+  let nextId = 0;
+  const common = (layer, extra = []) => {
+    const name = layer.name || (layer.type === "adjustment" ? adjustmentKindLabel(layer.kind) : "");
+    const blocks = [{ key: "luni", data: unicodeBlock(name) }, { key: "lyid", data: u32Bytes(++nextId) }, ...extra];
+    const locks = lockBits(layer);
+    if (locks) blocks.push({ key: "lspf", data: u32Bytes(locks >>> 0) });
+    return {
+      opacity: Math.round(Math.min(1, Math.max(0, layer.opacity)) * 255),
+      clipping: layer.clipped ? 1 : 0,
+      flags: (layer.visible ? 0 : LAYER_FLAG_HIDDEN) | (layer.locks?.transparency ? LAYER_FLAG_TRANSPARENCY_PROTECTED : 0),
+      legacyName: name,
+      blocks
+    };
+  };
+  const write = (layer) => {
+    switch (layer.type) {
+      case "group": {
+        records.push({
+          rect: EMPTY_RECT,
+          channels: [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel),
+          blendKey: "norm",
+          opacity: 255,
+          clipping: 0,
+          flags: FLAG_PIXELS_IRRELEVANT | (layer.visible ? 0 : LAYER_FLAG_HIDDEN),
+          legacyName: "</Layer group>",
+          blocks: [
+            { key: "luni", data: unicodeBlock("</Layer group>") },
+            { key: "lsct", data: sectionBlock(SECTION_DIVIDER) }
+          ]
+        });
+        for (const child of layer.children) write(child);
+        const blendKey = BLEND_TO_PSD[layer.blend] ?? "norm";
+        const base = common(layer, [{ key: "lsct", data: sectionBlock(layer.collapsed ? SECTION_CLOSED : SECTION_OPEN, blendKey) }]);
+        const rec = {
+          ...base,
+          rect: EMPTY_RECT,
+          channels: [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel),
+          blendKey,
+          flags: base.flags | FLAG_PIXELS_IRRELEVANT
+        };
+        if (layer.mask) {
+          const m = maskChannel(layer.mask, 0, 0, psb);
+          rec.channels.push(m.channel);
+          rec.mask = m.mask;
+        }
+        records.push(rec);
+        return;
+      }
+      case "adjustment": {
+        const block = writeAdjustmentBlock(layer.kind, layer.params);
+        const rec = {
+          ...common(layer, [{ key: block.key, data: block.data }]),
+          rect: EMPTY_RECT,
+          channels: [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel),
+          blendKey: BLEND_TO_PSD[layer.blend] ?? "norm"
+        };
+        if (layer.mask) {
+          const m = maskChannel(layer.mask, 0, 0, psb);
+          rec.channels.push(m.channel);
+          rec.mask = m.mask;
+        }
+        records.push(rec);
+        return;
+      }
+      case "pixel": {
+        if (layer.source === "document") throw new PsdError(`Layer "${layer.name}" reads the document image; resolve its pixels before export.`);
+        if (layer.filters?.some(isActiveFilter)) throw new PsdError(`Layer "${layer.name}" has live filters; bake them before export.`);
+        const extra = [];
+        if (layer.fillOpacity !== void 0 && layer.fillOpacity < 1) {
+          extra.push({ key: "iOpa", data: Uint8Array.from([Math.round(Math.max(0, layer.fillOpacity) * 255), 0, 0, 0]) });
+        }
+        const rec = { ...common(layer, extra), rect: EMPTY_RECT, channels: [], blendKey: BLEND_TO_PSD[layer.blend] ?? "norm" };
+        const bounds = contentBounds(layer.surface);
+        if (bounds) {
+          const n2 = bounds.width * bounds.height;
+          const [r2, g2, b2, a2] = rgbaToPlanes(readRegion(layer.surface, bounds), n2);
+          rec.rect = toRect({ ...bounds, x: bounds.x + layer.offset.x, y: bounds.y + layer.offset.y });
+          rec.channels = [
+            rleChannel(CHANNEL_ALPHA, a2, bounds.width, bounds.height, psb),
+            rleChannel(0, r2, bounds.width, bounds.height, psb),
+            rleChannel(1, g2, bounds.width, bounds.height, psb),
+            rleChannel(2, b2, bounds.width, bounds.height, psb)
+          ];
+        } else {
+          rec.channels = [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel);
+        }
+        if (layer.mask) {
+          const m = maskChannel(layer.mask, layer.offset.x, layer.offset.y, psb);
+          rec.channels.push(m.channel);
+          rec.mask = m.mask;
+        }
+        records.push(rec);
+        return;
+      }
+      case "annotation":
+        throw new PsdError(`Annotation layer "${layer.name}" must be rasterized before export.`);
+    }
+  };
+  for (const layer of input.layers) write(layer);
+  if (records.length > 32767) throw new PsdError("A PSD holds at most 32767 layer records.");
+  const n = width * height;
+  if (input.merged.length < n * 4) throw new PsdError(`The merged image has ${input.merged.length} bytes, expected ${n * 4}.`);
+  const [r, g, b, a] = rgbaToPlanes(matteWhite(input.merged), n);
+  const transparent = a.some((v) => v !== 255);
+  const planes = transparent ? [r, g, b, a] : [r, g, b];
+  const merged = new Uint8Array(n * planes.length);
+  planes.forEach((p, i) => merged.set(p, i * n));
+  const res = Math.max(1, input.resolution ?? 72);
+  const rw = new PsdWriter();
+  for (let k = 0; k < 2; k++) {
+    rw.u32(Math.round(res * 65536));
+    rw.u16(1);
+    rw.u16(1);
+  }
+  const version = new PsdWriter();
+  version.u32(1);
+  version.u8(1);
+  version.unicode("Pixerate Editor");
+  version.unicode("Pixerate Editor");
+  version.u32(1);
+  const resources = [
+    { id: 1005, name: "", data: rw.result() },
+    { id: 1057, name: "", data: version.result() }
+  ];
+  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
+  );
+  return { bytes, psb, records: records.length };
+}
+
 // src/image-editor/controller.ts
 var IMAGE_EDITOR_SCHEMA_VERSION = LAYERED_SCHEMA_VERSION;
 function paintCoverageInto(base, coverage, apply, rects) {
@@ -6137,8 +8248,8 @@ var ImageEditorController = class {
     const cur = this.state.paint;
     const next = {
       brush: options.brush ? normalizeBrush({ ...cur.brush, ...options.brush }) : cur.brush,
-      foreground: options.foreground !== void 0 ? toHex(parseColor(options.foreground)) : cur.foreground,
-      background: options.background !== void 0 ? toHex(parseColor(options.background)) : cur.background
+      foreground: options.foreground !== void 0 ? toHex2(parseColor(options.foreground)) : cur.foreground,
+      background: options.background !== void 0 ? toHex2(parseColor(options.background)) : cur.background
     };
     this.state.paint = next;
     this.notify();
@@ -6652,9 +8763,18 @@ var ImageEditorController = class {
       if (!this.samplePixelsOverride && !options.pixels) this.samplePixels = null;
       return null;
     }
-    if (!options.sampleMerged) return base;
+    const legacy = legacyView(this.stack(), width, height, null).exact;
+    if (options.sample === "active-layer") {
+      const layer = this.getActiveLayer();
+      if (!layer || layer.type !== "pixel") {
+        throw new LayerOperationError("Sampling the active layer needs an active pixel layer; select one, or sample the composite.");
+      }
+      const surface = layer.source === "document" && options.pixels ? surfaceFromPixels(options.pixels, 4) : this.surfaceOf(layer);
+      return { width, height, data: readRegion(surface, { x: -layer.offset.x, y: -layer.offset.y, width, height }) };
+    }
+    if (legacy && !options.sampleMerged) return base;
     this.syncViews();
-    if (legacyView(this.stack(), width, height, null).exact) {
+    if (legacy && !options.pixels) {
       const copy = { width: base.width, height: base.height, data: new Uint8ClampedArray(base.data) };
       applyAdjustments(copy, legacyView(this.stack(), width, height, null).adjustments);
       return copy;
@@ -6666,7 +8786,9 @@ var ImageEditorController = class {
       surfaceOf: (l) => l.source === "document" && pixels ? surfaceFromPixels(pixels, 4) : this.surfaceOf(l),
       version: pixels ? "pixels" : this.sourceVersion()
     };
-    const data = new LayerCompositor().composite(withoutAnnotations(this.state.layers), { x: 0, y: 0, width, height }, sources);
+    const stack = withoutAnnotations(this.state.layers);
+    const layers = options.sampleMerged ? stack : pixelsOnly(stack);
+    const data = new LayerCompositor().composite(layers, { x: 0, y: 0, width, height }, sources);
     return { width, height, data };
   }
   async requirePixels(options) {
@@ -6914,8 +9036,24 @@ var ImageEditorController = class {
     this.notify();
   }
   // --- Rendering & Export ---
-  async render(targetCanvas, options) {
+  blankSource = null;
+  /**
+   * What the renderer draws from: the source image, or, for a document without one (an opened
+   * PSD, a v3 document loaded on its own), a transparent canvas of the document size, since every
+   * pixel then comes from the layers. `null` when there is nothing to draw.
+   */
+  drawSource() {
     const source = this.imageElement || this.state.sourceUrl;
+    if (source) return source;
+    if (!this.isSourceless()) return null;
+    const { width, height } = this.naturalSize;
+    if (!this.blankSource || this.blankSource.width !== width || this.blankSource.height !== height) {
+      this.blankSource = this.renderer.createCanvas(width, height);
+    }
+    return this.blankSource;
+  }
+  async render(targetCanvas, options) {
+    const source = this.drawSource();
     if (!source) return;
     this.syncViews();
     const dirty = this.pendingDirty;
@@ -6930,7 +9068,7 @@ var ImageEditorController = class {
     }
   }
   async renderExport(options) {
-    const source = this.imageElement || this.state.sourceUrl;
+    const source = this.drawSource();
     if (!source) {
       return this.renderer.createCanvas(1, 1);
     }
@@ -6949,7 +9087,7 @@ var ImageEditorController = class {
    * Returns `null` when no image is loaded.
    */
   async renderSourceView(options = {}) {
-    const source = this.imageElement || this.state.sourceUrl;
+    const source = this.drawSource();
     if (!source) return null;
     this.syncViews();
     const { width, height } = this.state.imageDimensions;
@@ -7021,23 +9159,270 @@ var ImageEditorController = class {
     ctx.drawImage(img, 0, 0, width, height);
     return canvas;
   }
+  /**
+   * The image an AI hook should edit: the source (`toSourceDataURL`) when results replace the
+   * Background, or the composite of the layers without annotations, in the source frame, when
+   * they go to a new layer or mask (see `applyInpaintedImage`).
+   */
+  async toAIInputDataURL(options = {}) {
+    const target = options.target ?? this.defaultAITarget();
+    if (target === "replace") return this.toSourceDataURL();
+    const canvas = await this.renderSourceView({ includeAnnotations: false });
+    return canvas ? canvas.toDataURL("image/png") : this.toSourceDataURL();
+  }
   async toSourceDataURL(options = {}) {
     const canvas = await this.renderSource();
     return canvas.toDataURL(options.format || "image/png", options.quality ?? 0.92);
   }
   /**
-   * Replaces the source image with an inpainted result (natural image space, see
-   * `toSourceDataURL`) and clears the mask annotations, as ONE undoable step.
+   * Whether AI results go to layers: the document has more than one pixel layer or group (adjustment
+   * and annotation layers are edits of the image, not images of their own).
+   */
+  /** `new-layer` in multi-layer documents and documents without a source image, else `replace`. */
+  defaultAITarget() {
+    return this.isMultiLayer || this.isSourceless() ? "new-layer" : "replace";
+  }
+  /** No source image, and no layer reading one (an opened PSD): the layers are the whole document. */
+  isSourceless() {
+    if (this.imageElement || this.state.sourceUrl || !this.state.layers.length) return false;
+    return !flattenLayers(this.state.layers).some((l) => l.type === "pixel" && l.source === "document");
+  }
+  get isMultiLayer() {
+    return flattenLayers(this.state.layers).filter((l) => l.type === "pixel" || l.type === "group").length > 1;
+  }
+  /**
+   * Applies an inpainted result (natural image space, see `toSourceDataURL`) as ONE undoable step.
+   * In a document with several layers (see `isMultiLayer`), or with `target: 'new-layer'`, the
+   * result goes to a new pixel layer above the active layer, limited to the selection. Otherwise
+   * (`target: 'replace'`, the single-layer default) it replaces the Background's pixels and clears
+   * the mask annotations, as before. Resolves to the new layer's id in new-layer mode.
+   */
+  async applyInpaintedImage(newDataUrl, options = {}) {
+    if ((options.target ?? this.defaultAITarget()) === "replace") {
+      await this.replaceSource(newDataUrl, true);
+      return;
+    }
+    const { width, height } = this.naturalSize;
+    let px = await this.decodeImage(newDataUrl);
+    if (px.width !== width || px.height !== height) px = resizePixels(px, width, height);
+    const data = new Uint8ClampedArray(px.data);
+    const sel = this.state.selection?.bounds ? this.state.selection : null;
+    if (sel) for (let p = 0, i = 3; p < width * height; p++, i += 4) data[i] = Math.round(data[i] * sel.data[p] / 255);
+    return this.addPixelLayer({ name: "Inpaint", pixels: { width, height, data } });
+  }
+  /**
+   * Applies a background-removed result as ONE undoable step. In a document with several layers
+   * (or with `target: 'new-layer'`) the result's alpha becomes the mask of the active pixel layer
+   * (or the Background), replacing its mask. Otherwise (`target: 'replace'`, the single-layer
+   * default) it replaces the Background's pixels; crop and annotations are kept (rescaled if the
+   * new image has different dimensions). Resolves to the masked layer's id in mask mode.
+   */
+  async applyBackgroundRemovedImage(newDataUrl, options = {}) {
+    if ((options.target ?? this.defaultAITarget()) === "replace") {
+      await this.replaceSource(newDataUrl, false);
+      return;
+    }
+    const target = this.developLayer();
+    if (!target) throw new LayerOperationError("There is no pixel layer to mask.");
+    requireUnlocked(target, "all", "mask it");
+    const { width, height } = this.naturalSize;
+    let px = await this.decodeImage(newDataUrl);
+    if (px.width !== width || px.height !== height) px = resizePixels(px, width, height);
+    const alpha = new Uint8ClampedArray(width * height);
+    for (let p = 0; p < alpha.length; p++) alpha[p] = px.data[p * 4 + 3];
+    let surface = surfaceFromPixels({ width, height, data: alpha }, 1, 0, 0, 0);
+    if (target.offset.x || target.offset.y) surface = translateSurface(surface, -target.offset.x, -target.offset.y);
+    this.commitLayers(setLayerMask(this.state.layers, target.id, { surface, defaultValue: 0 }));
+    return target.id;
+  }
+  /**
+   * Rasterize Layer: an annotation layer becomes a pixel layer with the same id, name and
+   * properties (needs a canvas), and a pixel layer's filters are baked into its pixels. One undo
+   * step. Returns the layer id.
+   */
+  async rasterizeLayer(id) {
+    const layer = requireLayer(this.state.layers, id).layer;
+    requireUnlocked(layer, "all", "rasterize it");
+    const { width, height } = this.naturalSize;
+    const canvas = { x: 0, y: 0, width, height };
+    let next;
+    if (layer.type === "annotation") {
+      const blend = layer.blend === "normal" && layer.annotation.blend ? layer.annotation.blend : layer.blend;
+      const content = { ...layer, visible: true, opacity: 1, blend: "normal", annotation: { ...layer.annotation, blend: void 0 } };
+      delete content.mask;
+      delete content.clipped;
+      const surface = await this.compositeToSurface([content], this.paintBounds(layer));
+      next = { type: "pixel", id: layer.id, name: layer.name, visible: layer.visible, opacity: layer.opacity, blend, surface, offset: { x: 0, y: 0 } };
+      if (layer.clipped) next.clipped = true;
+      if (layer.mask) next.mask = layer.mask;
+      if (layer.locks) next.locks = layer.locks;
+      if (this.state.selectedAnnotationId === layer.annotation.id) this.state.selectedAnnotationId = null;
+    } else if (layer.type === "pixel") {
+      if (!layer.filters?.length) throw new LayerOperationError(`Layer "${layer.name || id}" is already pixels with no filters to bake.`);
+      requireUnlocked(layer, "pixels", "rasterize it");
+      const spatial = layer.filters.some((f) => f.enabled && f.kind === "blur");
+      const content = { ...layer, visible: true, opacity: 1, blend: "normal" };
+      delete content.mask;
+      delete content.clipped;
+      delete content.fillOpacity;
+      const rect = spatial ? canvas : this.getLayerBounds(id) ?? canvas;
+      const surface = await this.compositeToSurface([content], rect);
+      next = { ...layer, surface, offset: { x: 0, y: 0 } };
+      delete next.filters;
+      delete next.source;
+      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 {
+      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.`);
+    }
+    this.commitLayers(mapLayer(this.state.layers, id, () => next));
+    return id;
+  }
+  // --- PSD ---
+  /** Pixels per inch of the last opened PSD (written back by `toPsd`). */
+  psdResolution;
+  /**
+   * Opens PSD / PSB bytes as the document (one undo step): the layers replace the stack and the
+   * document has no source image afterwards (every pixel comes from the layers). What the model
+   * cannot hold is approximated or left out; `warnings` says what, naming the layers.
+   * Throws `PsdError` for files that cannot be read at all.
    */
-  async applyInpaintedImage(newDataUrl) {
-    await this.replaceSource(newDataUrl, true);
+  loadPsd(bytes) {
+    const result = importPsd(bytes, { newId: () => newLayerId() });
+    this.recordHistory();
+    const s = this.state;
+    this.imageElement = null;
+    s.sourceUrl = null;
+    s.imageDimensions = { width: result.width, height: result.height };
+    if (!this.samplePixelsOverride) this.samplePixels = null;
+    s.layers = result.layers;
+    s.crop = null;
+    s.transform = { ...DEFAULT_TRANSFORM_VALUES };
+    s.outputOpacity = 1;
+    delete s.legacyOutputBlur;
+    s.selection = null;
+    s.selectedAnnotationId = null;
+    const pixels = flattenLayers(result.layers).filter((l) => l.type === "pixel");
+    s.activeLayerId = pixels.length ? pixels[pixels.length - 1].id : null;
+    s.activeTarget = "pixels";
+    this.psdResolution = result.resolution;
+    this.lastLoadProblems = result.warnings;
+    this.notify();
+    return {
+      layerIds: flattenLayers(result.layers).map((l) => l.id),
+      warnings: result.warnings,
+      width: result.width,
+      height: result.height,
+      summary: result.summary
+    };
   }
   /**
-   * Replaces the source image with a background-removed result as ONE undoable step.
-   * Crop and annotations are kept (rescaled if the new image has different dimensions).
+   * The document as an 8-bit RGB PSD (PSB above 30 000 px) with real layers, groups, adjustment
+   * layers and masks, in the source frame. Layer filters and parametric (depth) masks are baked
+   * into pixels and masks, annotation layers are rasterized (in a browser; elsewhere they are left
+   * out), and the merged image is our composite. `warnings` lists every such change.
    */
-  async applyBackgroundRemovedImage(newDataUrl) {
-    await this.replaceSource(newDataUrl, false);
+  async toPsd() {
+    const { width, height } = this.naturalSize;
+    const canvas = { x: 0, y: 0, width, height };
+    const warnings = [];
+    const note = /* @__PURE__ */ new Map();
+    const add = (msg, name) => note.set(msg, [...note.get(msg) ?? [], name]);
+    const canRasterize = this.renderer.canRasterize();
+    await this.renderer.prepareLayerAssets(this.state.layers, width, height);
+    const sources = this.renderer.compositorSources(width, height);
+    const compositor = new LayerCompositor();
+    const bakeMask = (layer) => {
+      const mask = layer.mask;
+      if (!mask?.source) return mask;
+      add("Parametric (depth) masks were baked into pixel masks", layer.name);
+      const plain3 = { ...layer, mask: { ...mask, density: 1, feather: 0, enabled: true } };
+      const ox = layer.type === "pixel" ? layer.offset.x : 0;
+      const oy = layer.type === "pixel" ? layer.offset.y : 0;
+      const coverage = compositor.maskCoverage(plain3, canvas, sources);
+      const bytes = new Uint8ClampedArray(width * height);
+      if (coverage) for (let i = 0; i < bytes.length; i++) bytes[i] = Math.round(coverage[i] * 255);
+      else bytes.fill(255);
+      const baked = { surface: surfaceFromPixels({ width, height, data: bytes }, 1, -ox, -oy), defaultValue: 0 };
+      if (mask.density !== void 0 && mask.density < 1) baked.density = mask.density;
+      if (mask.feather) baked.feather = mask.feather;
+      if (mask.enabled === false) baked.enabled = false;
+      return baked;
+    };
+    const prepare = async (layer) => {
+      if (layer.type === "group") {
+        const children = [];
+        for (const c of layer.children) {
+          const p = await prepare(c);
+          if (p) children.push(p);
+        }
+        return { ...layer, children, mask: bakeMask(layer) };
+      }
+      if (layer.type === "adjustment") return { ...layer, mask: bakeMask(layer) };
+      if (layer.type === "annotation") {
+        if (!canRasterize) {
+          add("Annotation layers need a canvas (a browser) to rasterize and were left out", layer.name);
+          return null;
+        }
+        add("Annotation layers were written as pixel layers", layer.name);
+        const blend = layer.blend === "normal" && layer.annotation.blend ? layer.annotation.blend : layer.blend;
+        const content = { ...layer, visible: true, opacity: 1, blend: "normal", annotation: { ...layer.annotation, blend: void 0 } };
+        delete content.mask;
+        delete content.clipped;
+        const data = compositor.composite([content], canvas, sources);
+        const out2 = {
+          type: "pixel",
+          id: layer.id,
+          name: layer.name,
+          visible: layer.visible,
+          opacity: layer.opacity,
+          blend,
+          surface: surfaceFromPixels({ width, height, data }, 4),
+          offset: { x: 0, y: 0 }
+        };
+        if (layer.clipped) out2.clipped = true;
+        if (layer.locks) out2.locks = layer.locks;
+        const mask2 = bakeMask(layer);
+        if (mask2) out2.mask = mask2;
+        return out2;
+      }
+      let out = { ...layer };
+      if (layer.source === "document") {
+        out.surface = this.surfaceOf(layer);
+        delete out.source;
+      }
+      const active = layer.filters?.filter(isActiveFilter) ?? [];
+      if (active.length) {
+        add("Layer filters (develop, blur) were baked into the pixels", layer.name);
+        const content = { ...out, visible: true, opacity: 1, blend: "normal" };
+        delete content.mask;
+        delete content.clipped;
+        delete content.fillOpacity;
+        const data = compositor.composite([content], canvas, sources);
+        out = { ...out, surface: surfaceFromPixels({ width, height, data }, 4, -layer.offset.x, -layer.offset.y) };
+      }
+      if (layer.filters?.some((f) => !f.enabled)) add("Disabled layer filters were left out", layer.name);
+      delete out.filters;
+      const mask = bakeMask(layer);
+      if (mask) out.mask = mask;
+      else delete out.mask;
+      return out;
+    };
+    const prepared = [];
+    for (const l of this.state.layers) {
+      const p = await prepare(l);
+      if (p) prepared.push(p);
+    }
+    const s = this.state;
+    if (s.crop) warnings.push("The crop is not applied; the PSD is the uncropped document.");
+    if (s.transform.rotate || s.transform.flipH || s.transform.flipV) warnings.push("Rotation and flips are not applied; the PSD is in the source orientation.");
+    if (s.outputOpacity < 1) warnings.push("The document opacity is not written; layers keep their own opacity.");
+    if (s.legacyOutputBlur) warnings.push("The document-level blur of an old document is not written.");
+    for (const [msg, names] of note) warnings.push(`${msg} (${names.length === 1 ? "layer" : "layers"} ${names.map((n) => `"${n}"`).join(", ")}).`);
+    const merged = compositor.composite(prepared, canvas, { ...sources, version: `psd:${Date.now()}` });
+    const result = exportPsd({ width, height, layers: prepared, merged, resolution: this.psdResolution });
+    return { bytes: result.bytes, warnings, psb: result.psb, width, height };
   }
   async replaceSource(src, clearAnnotations) {
     const next = await this.resolveSource(src);
@@ -7084,17 +9469,26 @@ var ImageEditorController = class {
     this.state.layers = layers;
     this.notify();
   }
-  // --- Serialization ---
-  /**
-   * The serializable state. A document whose layers still have the v1 / v2 shape (the
-   * Background with its sliders and depth mask, adjustment layers, annotations) is written as
-   * v1 / v2 exactly as before; anything else is written as v3 with the layer pixels as PNG
-   * assets. `selection` is included (run-length encoded) only when something is selected.
-   */
-  toJSON() {
+  toJSON(options) {
     const out = this.serializeState();
     if (this.state.selection?.bounds) out.selection = serializeSelection(this.state.selection);
-    return out;
+    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 }));
+  }
+  /**
+   * Loads a stored state whose v3 assets may live in an asset store (references other than data
+   * URLs are fetched with `store.get`), as one undo step. Assets that cannot be fetched are left
+   * out and listed in `lastLoadProblems`.
+   */
+  async loadJSONAsync(data, options = {}) {
+    if (data.version !== LAYERED_SCHEMA_VERSION || !data.assets) {
+      this.loadJSON(data);
+      return;
+    }
+    const problems = [];
+    const assets = await resolveExternalAssets(data.assets, options.store, problems);
+    this.loadJSON({ ...data, assets });
+    this.lastLoadProblems = [...problems, ...this.lastLoadProblems];
   }
   /** Loads a stored state of any version (one undo step). */
   loadJSON(data) {
@@ -7309,6 +9703,43 @@ function collectStateTiles(layers, into) {
     if (l.mask && !l.mask.source) collectTiles(l.mask.surface, into);
   }
 }
+function pixelsOnly(layers) {
+  const out = [];
+  for (const l of layers) {
+    if (l.type === "adjustment") continue;
+    if (l.type === "group") out.push({ ...l, children: pixelsOnly(l.children) });
+    else if (l.type === "pixel" && l.filters?.length) {
+      const p = { ...l };
+      delete p.filters;
+      out.push(p);
+    } else out.push(l);
+  }
+  return out;
+}
+function resizePixels(px, width, height) {
+  const src = px.data;
+  const out = new Uint8ClampedArray(width * height * 4);
+  const kx = px.width / width;
+  const ky = px.height / height;
+  for (let y = 0; y < height; y++) {
+    const fy = Math.min(px.height - 1, Math.max(0, (y + 0.5) * ky - 0.5));
+    const y0 = Math.floor(fy);
+    const y1 = Math.min(px.height - 1, y0 + 1);
+    const ty = fy - y0;
+    for (let x = 0; x < width; x++) {
+      const fx = Math.min(px.width - 1, Math.max(0, (x + 0.5) * kx - 0.5));
+      const x0 = Math.floor(fx);
+      const x1 = Math.min(px.width - 1, x0 + 1);
+      const tx = fx - x0;
+      for (let c = 0; c < 4; c++) {
+        const a = src[(y0 * px.width + x0) * 4 + c] * (1 - tx) + src[(y0 * px.width + x1) * 4 + c] * tx;
+        const b = src[(y1 * px.width + x0) * 4 + c] * (1 - tx) + src[(y1 * px.width + x1) * 4 + c] * tx;
+        out[(y * width + x) * 4 + c] = a * (1 - ty) + b * ty;
+      }
+    }
+  }
+  return { width, height, data: out };
+}
 function withoutAnnotations(layers) {
   const out = [];
   for (const l of layers) {
@@ -7331,7 +9762,7 @@ function parseColor(value) {
   const n = (i) => parseInt(hex.slice(i, i + 2), 16);
   return [n(0), n(2), n(4), hex.length === 8 ? n(6) : 255];
 }
-function toHex(c) {
+function toHex2(c) {
   return "#" + [c[0], c[1], c[2]].map((v) => Math.round(v).toString(16).padStart(2, "0")).join("");
 }
 function normalizeSelection(mask) {
@@ -7622,7 +10053,7 @@ var tone = (prefix, label) => [
   decimals: 0,
   track: { kind: "gradient", from, to }
 }));
-var levelsRecord = (ch, label) => [
+var levelsRecord2 = (ch, label) => [
   { id: `${ch}.inBlack`, label: `${label} input black`, section: "layer", min: 0, max: 253, step: 1, default: 0, decimals: 0, track: plain },
   { id: `${ch}.gamma`, label: `${label} gamma`, section: "layer", min: 0.1, max: 9.99, step: 0.01, default: 1, decimals: 2, track: plain },
   { id: `${ch}.inWhite`, label: `${label} input white`, section: "layer", min: 2, max: 255, step: 1, default: 255, decimals: 0, track: plain },
@@ -7633,10 +10064,10 @@ var RANGE_NAMES = ["Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas"];
 var ADJUSTMENT_LAYER_CONTROLS = {
   curves: [],
   levels: [
-    ...levelsRecord("master", "RGB"),
-    ...levelsRecord("red", "Red"),
-    ...levelsRecord("green", "Green"),
-    ...levelsRecord("blue", "Blue")
+    ...levelsRecord2("master", "RGB"),
+    ...levelsRecord2("red", "Red"),
+    ...levelsRecord2("green", "Green"),
+    ...levelsRecord2("blue", "Blue")
   ],
   hueSaturation: [
     { id: "hue", label: "Hue", section: "layer", min: -180, max: 180, step: 1, default: 0, decimals: 0, track: { kind: "rainbow" }, unit: "\xB0" },
@@ -7899,13 +10330,22 @@ function createImageSelectionTools(controller) {
         contiguous: { type: "boolean", description: "Only the connected region around (x, y) (default true)." },
         fuzziness: { type: "number", minimum: 0, maximum: 200, description: "Color Range fuzziness (default 40)." },
         sampleMerged: { type: "boolean", description: "Sample the adjusted image rather than the source." },
+        sample: {
+          type: "string",
+          enum: ["composite", "active-layer"],
+          description: "composite (default): the whole image; active-layer: only the active pixel layer (see set_active_layer)."
+        },
         mode: modeSchema
       },
       additionalProperties: false
     },
     annotations: writeAnnotations("Select by colour", true),
-    handler: async ({ x, y, color, tolerance, contiguous, fuzziness, sampleMerged, mode }) => {
-      const common = { mode: parseSelectionMode(mode), sampleMerged: sampleMerged === true };
+    handler: async ({ x, y, color, tolerance, contiguous, fuzziness, sampleMerged, sample, mode }) => {
+      const common = {
+        mode: parseSelectionMode(mode),
+        sampleMerged: sampleMerged === true,
+        sample: sample ?? "composite"
+      };
       if (typeof color === "string") {
         await controller.selectColorRange([{ color }], { ...common, fuzziness: num2(fuzziness, 40) });
       } else if (typeof x === "number" && typeof y === "number") {
@@ -8762,6 +11202,14 @@ function createImageLayerTools(controller) {
       return { layer: describe(controller.layerViaCopy({ layerId, cut: cut === true, name })) };
     }
   };
+  const rasterize = {
+    name: "rasterize_layer",
+    title: "Rasterize a layer",
+    description: "Rasterize Layer: turns an annotation layer into a pixel layer (same id, name, opacity, blend and mask; needs a browser) or bakes a pixel layer's filters (develop, blur) into its pixels. One undo step. Returns the layer.",
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID2 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Rasterize a layer", ...DESTRUCTIVE },
+    handler: async ({ layerId }) => ({ layer: describe(await controller.rasterizeLayer(exists(layerId))) })
+  };
   const filterArgs = {
     enabled: { type: "boolean", description: "false keeps the filter but skips it." },
     radius: { type: "number", minimum: 0, maximum: 50, description: "blur: box radius in px (default 2)." },
@@ -8848,6 +11296,7 @@ function createImageLayerTools(controller) {
     removeMask,
     maskProps,
     viaCopy,
+    rasterize,
     addFilter,
     updateFilter,
     removeFilter
@@ -8966,6 +11415,82 @@ function createImagePaintTools(controller) {
   return [paintStroke, fill, clear];
 }
 
+// src/image-editor/psd-tools.ts
+var READ3 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var DATA = {
+  type: "string",
+  minLength: 1,
+  description: "The PSD or PSB file as base64 (a `data:` URL prefix is accepted)."
+};
+function psdBytesFromBase64(data) {
+  if (typeof data !== "string" || !data.trim()) throw new PsdError("data is required: the PSD file as base64.");
+  const body = data.trim().replace(/^data:[^,]*;base64,/i, "");
+  if (!/^[A-Za-z0-9+/=_\s-]+$/.test(body)) throw new PsdError("data is not base64; send the PSD file bytes base64-encoded.");
+  const bytes = base64ToBytes(body);
+  if (bytes.length < 26) throw new PsdError(`data decodes to ${bytes.length} bytes, too short for a PSD (at least 26).`);
+  return bytes;
+}
+function createImagePsdTools(controller) {
+  const inspect = {
+    name: "inspect_psd",
+    title: "Inspect a PSD",
+    description: "Reads a PSD / PSB without opening it: size, bit depth, colour mode, resolution, and every layer (bottom first, a group before its children) with its PSD kind, the layer type it would become and its status (mapped, approximated or dropped, with notes), plus the import warnings. Changes nothing. Call before import_psd to see what would be lost.",
+    inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
+    annotations: { title: "Inspect a PSD", ...READ3 },
+    handler: ({ data }) => {
+      const res = importPsd(psdBytesFromBase64(data), { skipPixels: true });
+      return {
+        width: res.width,
+        height: res.height,
+        ...res.info,
+        resolution: res.resolution ?? null,
+        layers: res.summary.map(({ id: _id, ...s }) => s),
+        warnings: res.warnings
+      };
+    }
+  };
+  const open = {
+    name: "import_psd",
+    title: "Open a PSD as the document",
+    description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility and locks map directly; type, smart-object, fill and shape layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
+    inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
+    annotations: { title: "Open a PSD as the document", ...DESTRUCTIVE3 },
+    handler: ({ data }) => {
+      const res = controller.loadPsd(psdBytesFromBase64(data));
+      const s = controller.getState();
+      return {
+        width: res.width,
+        height: res.height,
+        layerIds: res.layerIds,
+        layers: s.layers.map((l) => describeLayer(l, s.activeLayerId, (x) => controller.getLayerBounds(x.id))),
+        activeLayerId: s.activeLayerId,
+        warnings: res.warnings
+      };
+    }
+  };
+  const save = {
+    name: "export_psd",
+    title: "Export the document as a PSD",
+    description: "Writes the document as an 8-bit RGB PSD (a PSB above 30000 px) with real layers, groups, adjustment layers and masks, in the source frame (crop and rotation are not applied). Layer filters and depth masks are baked, annotation layers are rasterized (in a browser; elsewhere left out), and the merged image is the editor's composite. Changes nothing. Returns the file as base64, its size in bytes, whether it is a PSB, and warnings for everything that was changed or left out.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Export the document as a PSD", ...READ3 },
+    handler: async () => {
+      const res = await controller.toPsd();
+      return {
+        data: bytesToBase64(res.bytes),
+        mimeType: "image/vnd.adobe.photoshop",
+        size: res.bytes.length,
+        psb: res.psb,
+        width: res.width,
+        height: res.height,
+        warnings: res.warnings
+      };
+    }
+  };
+  return [inspect, open, save];
+}
+
 // src/image-editor/tools.ts
 var LAYER_PATH = /^layers\.([^.]+)\.(.+)$/;
 function adjustmentsSummary(adjustments) {
@@ -9203,7 +11728,8 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageSelectionTools(controller),
       ...createImageEditTools(controller),
       ...createImageLayerTools(controller),
-      ...createImagePaintTools(controller)
+      ...createImagePaintTools(controller),
+      ...createImagePsdTools(controller)
     ]
   };
 }
@@ -9242,14 +11768,14 @@ function hitTestCurvePoint(points, x, y, width, height, radius = 8) {
 }
 function insertCurvePoint(points, p) {
   const point = { input: clampLevel(p.input), output: clampLevel(p.output) };
-  const out = points.filter((q) => q.input !== point.input).map((q) => ({ ...q }));
-  let index = out.findIndex((q) => q.input > point.input);
+  const out = points.filter((q2) => q2.input !== point.input).map((q2) => ({ ...q2 }));
+  let index = out.findIndex((q2) => q2.input > point.input);
   if (index === -1) index = out.length;
   out.splice(index, 0, point);
   return { points: out, index };
 }
 function moveCurvePoint(points, index, p) {
-  const out = points.map((q) => ({ ...q }));
+  const out = points.map((q2) => ({ ...q2 }));
   if (index < 0 || index >= out.length) return out;
   const lo = index > 0 ? out[index - 1].input + 1 : 0;
   const hi = index < out.length - 1 ? out[index + 1].input - 1 : 255;
@@ -9257,8 +11783,8 @@ function moveCurvePoint(points, index, p) {
   return out;
 }
 function removeCurvePoint(points, index) {
-  if (points.length <= 2 || index < 0 || index >= points.length) return points.map((q) => ({ ...q }));
-  return points.filter((_, i) => i !== index).map((q) => ({ ...q }));
+  if (points.length <= 2 || index < 0 || index >= points.length) return points.map((q2) => ({ ...q2 }));
+  return points.filter((_, i) => i !== index).map((q2) => ({ ...q2 }));
 }
 var round22 = (v) => Math.round(v * 100) / 100;
 
@@ -9313,6 +11839,7 @@ var SelectionGesture = class {
           antiAlias: options.antiAlias,
           distance: options.distance,
           sampleMerged: options.sampleMerged,
+          sample: options.sample,
           mode: selectionModeFromModifiers(modifiers, options.mode)
         });
       } catch (err) {
@@ -9575,6 +12102,7 @@ function layerMenu(controller) {
     { action: "apply-mask", label: "Apply Layer Mask", enabled: isPixel && Boolean(active?.mask) },
     { 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: "rasterize", label: "Rasterize Layer", enabled: active?.type === "annotation" || isPixel && Boolean(active?.type === "pixel" && active.filters?.length) },
     { action: "toggle-clip", label: active?.clipped ? "Release Clipping Mask" : "Create Clipping Mask", enabled: Boolean(loc && loc.index > 0) }
   ];
 }
@@ -9629,6 +12157,9 @@ async function runLayerMenuAction(controller, action) {
       case "toggle-mask":
         if (id && active?.mask) controller.setLayerMaskProps(id, { enabled: active.mask.enabled === false });
         break;
+      case "rasterize":
+        if (id) await controller.rasterizeLayer(id);
+        break;
       case "toggle-clip":
         if (id) controller.setLayerProperties(id, { clipped: !active?.clipped });
         break;
@@ -9777,7 +12308,41 @@ var PaintGesture = class {
     this.move = null;
   }
 };
+
+// src/image-editor/psd/ui.ts
+var PSD_FILE_ACCEPT = ".psd,.psb,image/vnd.adobe.photoshop,application/x-photoshop";
+function blobBytes(file) {
+  if (typeof file.arrayBuffer === "function") return file.arrayBuffer().then((b) => new Uint8Array(b));
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(new Uint8Array(reader.result));
+    reader.onerror = () => reject(reader.error ?? new Error("The file could not be read."));
+    reader.readAsArrayBuffer(file);
+  });
+}
+async function openPsdFile(controller, file) {
+  return controller.loadPsd(await blobBytes(file)).warnings;
+}
+function psdFileName(name, psb) {
+  const base = name.replace(/\.[a-z0-9]{2,4}$/i, "") || "image";
+  return `${base}.${psb ? "psb" : "psd"}`;
+}
+async function downloadPsd(controller, name = "image") {
+  const res = await controller.toPsd();
+  const fileName = psdFileName(name, res.psb);
+  if (typeof document !== "undefined" && typeof URL !== "undefined" && URL.createObjectURL) {
+    const blob = new Blob([res.bytes], { type: "image/vnd.adobe.photoshop" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = fileName;
+    a.click();
+    setTimeout(() => URL.revokeObjectURL(url), 0);
+  }
+  return { fileName, warnings: res.warnings };
+}
 export {
+  ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
   ADJUSTMENT_LAYER_CONTROLS,
   ADJUSTMENT_LAYER_OPACITY_CONTROL,
@@ -9789,6 +12354,7 @@ export {
   BLUR_FILTER_ID,
   BRUSH_OPTION_CONTROLS,
   CoverageMap,
+  D50,
   D65,
   DEFAULT_ADJUSTMENTS,
   DEFAULT_BRUSH,
@@ -9820,13 +12386,17 @@ export {
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
   PAINT_TOOLS,
+  PSD_BLEND_KEYS,
+  PSD_FILE_ACCEPT,
   PaintGesture,
   PaintStrokeSession,
+  PsdError,
   REFINE_EDGE_CONTROLS,
   SELECTION_MODES,
   SELECTION_MODE_LABELS,
   SELECTION_MODIFY_OPS,
   SELECTION_TOOLS,
+  SUPPORTED_ADJUSTMENT_KEYS,
   SelectionGesture,
   StrokeCoverage,
   SurfaceDraft,
@@ -9837,6 +12407,7 @@ export {
   TONE_RANGE_PRESETS,
   TiledSurface,
   VIBRANCE_GREY,
+  XYZ_D50_TO_SRGB,
   ZlibError,
   activeAdjustmentLayers,
   addLayerFilter,
@@ -9904,6 +12475,7 @@ export {
   createImageEditorToolProvider,
   createImageLayerTools,
   createImagePaintTools,
+  createImagePsdTools,
   createImageSelectionTools,
   createSelectionMask,
   curveLut,
@@ -9912,7 +12484,10 @@ export {
   curveSvgPath,
   dabCoverage,
   dabRect,
+  decodeLayerChannel,
   decodeLayerMask,
+  decodeMergedImage,
+  decodePlanes,
   decodePng,
   decodePngDataUrl,
   decodeSelectionRle,
@@ -9930,6 +12505,7 @@ export {
   developFromAdjustments,
   developTarget,
   distanceTransform,
+  downloadPsd,
   dropPlacement,
   dropZone,
   duplicateLayer,
@@ -9939,10 +12515,12 @@ export {
   emptyHistogram,
   emptySurface,
   encodePng,
+  encodeRle,
   encodeSelectionRle,
   encodeSurface,
   evaluateAdjustmentLayers,
   expandCoverage,
+  exportPsd,
   featherCoverage,
   fillRect,
   findAdjustmentControl,
@@ -9981,6 +12559,7 @@ export {
   identityLevels,
   imageEditorStateMigrations,
   imageToCanvasPoint,
+  importPsd,
   inflate,
   inflateRaw,
   insertCurvePoint,
@@ -10008,7 +12587,9 @@ export {
   layerMaskFromSelection,
   layerMaskKey,
   layerMenu,
+  layerName,
   layerPanelRows,
+  layerTree,
   layerTypeLabel,
   layersFromLegacy,
   legacyAdjustmentLayer,
@@ -10043,11 +12624,14 @@ export {
   normalizeRefineEdgeParams,
   normalizeStoredAdjustments,
   offsetLayer,
+  openPsdFile,
   packRgba,
+  parseAdjustmentBlock,
   parseBlend,
   parseColor,
   parseDataUrl,
   parseSelectionMode,
+  parseVersionedDescriptor,
   photoFilterMatrix,
   pixelLayerBounds,
   pixelLayers,
@@ -10061,12 +12645,16 @@ export {
   projectImageRect,
   projectMaskCoverage,
   projectQuarterTurn,
+  psdBytesFromBase64,
+  psdFileName,
+  psdToLayers,
   quickMaskPixels,
   rangeLightness,
   rasterMaskFromLegacy,
   rasterizeDab,
   readAdjustmentControls,
   readPixel,
+  readPsd,
   readRegion,
   rectSelection,
   refineCoverage,
@@ -10079,7 +12667,9 @@ export {
   renderLayeredBase,
   requireLayer,
   requireUnlocked,
+  resizePixels,
   resizeSelection,
+  resolveExternalAssets,
   resolveMosaicRegionBounds,
   rgbToGray,
   rgbToHsl,
@@ -10096,6 +12686,7 @@ export {
   selectionValueAt,
   serializeLayer,
   serializeLayers,
+  serializeLayersExternal,
   serializeSelection,
   setControlPath,
   setLayerMask,
@@ -10121,7 +12712,7 @@ export {
   tipFalloff,
   tipReach,
   tipShape,
-  toHex,
+  toHex2 as toHex,
   toneCurve,
   toneLuts,
   toneRange,
@@ -10133,6 +12724,7 @@ export {
   updateLayerFilter,
   updateLayerMaskProps,
   uvToXy,
+  versionedDescriptorBytes,
   vibranceLinear,
   vibrancePixel,
   walkDabs,
@@ -10140,6 +12732,8 @@ export {
   whiteBalanceFromSample,
   whiteBalanceMatrix,
   withNewIds,
+  writeAdjustmentBlock,
+  writePsd,
   writeRegion,
   xyToTempTint,
   xyToUv