@ikijs/editor 0.30.1 → 0.32.0

package/dist/index.js

@@ -26,7 +26,9 @@ __export(index_exports, {
   AddDeformer: () => AddDeformer,
   AddPart: () => AddPart,
   AddPhysicsRig: () => AddPhysicsRig,
+  BakeError: () => BakeError,
   CaptureGridKeyform: () => CaptureGridKeyform,
+  CustomPartError: () => CustomPartError,
   DEFAULT_TURN_TARGETS: () => DEFAULT_TURN_TARGETS,
   DeleteDeformer: () => DeleteDeformer,
   DeletePart: () => DeletePart,
@@ -82,6 +84,7 @@ __export(index_exports, {
   packAtlas: () => packAtlas,
   parseLayerRoles: () => parseLayerRoles,
   partIdsOfRole: () => partIdsOfRole,
+  rigidResidual: () => rigidResidual,
   styleRemovedMessage: () => styleRemovedMessage,
   upsertGridKeyform: () => upsertGridKeyform,
   uvRectFor: () => uvRectFor,
@@ -1112,6 +1115,14 @@ var DeletePart = class {
         `parts."${this.partId}": cannot delete \u2014 used as a clip mask by part "${masker.id}"; remove its clip first`
       );
     }
+    const occluded = parts.find(
+      (p) => p.id !== this.partId && p.occlusion?.by.includes(this.partId)
+    );
+    if (occluded) {
+      throw new Error(
+        `parts."${this.partId}": cannot delete \u2014 used as an occluder by part "${occluded.id}"; remove its occlusion first`
+      );
+    }
     const i = parts.indexOf(part);
     if (!this.captured) {
       this.removed = structuredClone(part);
@@ -1316,6 +1327,14 @@ var SetPartMesh = class {
           `parts."${this.partId}": cannot remove mesh \u2014 used as a clip mask by part "${masker.id}" (masks require a mesh); remove its clip first`
         );
       }
+      const occluded = doc.getModel().parts.find(
+        (p) => p.id !== this.partId && p.occlusion?.by.includes(this.partId)
+      );
+      if (occluded) {
+        throw new import_format2.IkiFormatError(
+          `parts."${this.partId}": cannot remove mesh \u2014 used as an occluder by part "${occluded.id}" (occluders require a mesh); remove its occlusion first`
+        );
+      }
     } else {
       if ((part.warps?.length ?? 0) > 0) {
         throw new import_format2.IkiFormatError(
@@ -1395,6 +1414,14 @@ function validatePhysicsCandidate(doc, candidatePhysics) {
     }
     throw e;
   }
+  for (const rig of candidatePhysics) {
+    const part = doc.getModel().parts.find((p) => p.occlusion?.parameter === rig.output.parameter);
+    if (part !== void 0) {
+      throw new import_format2.IkiFormatError(
+        `physics."${rig.id}".output.parameter "${rig.output.parameter}" keys parts."${part.id}".occlusion; an occlusion amount cannot be keyed on a physics output`
+      );
+    }
+  }
 }
 var AddPhysicsRig = class {
   label = "Add physics rig";
@@ -2203,6 +2230,18 @@ var PatchError = class extends Error {
     this.name = "PatchError";
   }
 };
+var CustomPartError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CustomPartError";
+  }
+};
+var BakeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BakeError";
+  }
+};
 
 // src/auto-rig/layout.ts
 function boxOfLayer(layer) {
@@ -2607,10 +2646,10 @@ function checkSidesHaveFront(roles) {
 function checkMouth(roles) {
   const has = new Set(roles);
   const present = LIP_ROLES.filter((r) => has.has(r));
-  const inside = LIP_INSIDE_ROLES.filter((r) => has.has(r));
-  if (inside.length > 0 && present.length === 0) {
+  const inside2 = LIP_INSIDE_ROLES.filter((r) => has.has(r));
+  if (inside2.length > 0 && present.length === 0) {
     throw new Error(
-      `auto-rig: ${inside[0]} needs the lip set ${LIP_ROLES.join(", ")} (it is cut from the interior and clipped to it)`
+      `auto-rig: ${inside2[0]} needs the lip set ${LIP_ROLES.join(", ")} (it is cut from the interior and clipped to it)`
     );
   }
   if (present.length === 0) {
@@ -2830,10 +2869,10 @@ function mouthFold(role, opening) {
   const stackThin = (c, y) => y > c.Tu ? c.Tu + UPPER_THIN * (y - c.Tu) : y;
   return (col, y, v) => {
     const k = 1 - v;
-    const inside = col >= x0 && col <= x1;
+    const inside2 = col >= x0 && col <= x1;
     switch (role) {
       case "lip_lower": {
-        if (!inside) return [0, 0];
+        if (!inside2) return [0, 0];
         const c = opening.at(col);
         return [0, (c.seam + c.overlap - c.Bl) * k];
       }
@@ -2857,9 +2896,9 @@ function mouthFold(role, opening) {
           line = opening.line(c += col < x0 ? 1 : -1);
         const thin = line.bottom + UPPER_THIN * (y - line.bottom);
         const mid = line.bottom + UPPER_THIN * (line.top - line.bottom) / 2;
-        const travel = inside ? opening.at(col).seam - line.bottom : 0;
+        const travel = inside2 ? opening.at(col).seam - line.bottom : 0;
         const shut = mid + line.squash * (thin - mid) + travel;
-        const pull = inside ? 0 : (1 - FLICK_PULL) * ((col < x0 ? x0 : x1 + 1) - col);
+        const pull = inside2 ? 0 : (1 - FLICK_PULL) * ((col < x0 ? x0 : x1 + 1) - col);
         return [pull * k, thin - y + (shut - thin) * k];
       }
     }
@@ -4192,14 +4231,14 @@ function cuesAt(ctx, land2, ax) {
   const l0 = land2(L.role, L.lo, L.y, ax);
   const l1 = land2(L.role, L.hi, L.y, ax);
   const r0 = land2(R.role, R.lo, R.y, ax);
-  const r1 = land2(R.role, R.hi, R.y, ax);
+  const r12 = land2(R.role, R.hi, R.y, ax);
   const wl = l1 - l0;
-  const wr = r1 - r0;
+  const wr = r12 - r0;
   const wl0 = L.hi - L.lo;
   const wr0 = R.hi - R.lo;
   const ratio = ax < 0 ? wl / wr / (wl0 / wr0) : wr / wl / (wr0 / wl0);
   const pc0 = (L.lo + L.hi + R.lo + R.hi) / 4;
-  const pc = (l0 + l1 + r0 + r1) / 4;
+  const pc = (l0 + l1 + r0 + r12) / 4;
   const y = ctx.frame.eyeY;
   const hl0 = Math.min(...ctx.candidates.left.map((c) => c.x));
   const hr0 = Math.max(...ctx.candidates.right.map((c) => c.x));
@@ -4833,7 +4872,7 @@ function blendStops(values, offsets, v) {
   const t = (x - values[i]) / (values[i + 1] - values[i]);
   return offsets[i].map((o, k) => o + (offsets[i + 1][k] - o) * t);
 }
-function land(l, offsets, x, y) {
+function bindToRest(l, x, y) {
   const { cols, rows, points } = l;
   const stride = cols + 1;
   let col = cols - 1;
@@ -4854,8 +4893,17 @@ function land(l, offsets, x, y) {
   const x1 = points[(col + 1) * 2];
   const yT = points[row * stride * 2 + 1];
   const yB = points[(row + 1) * stride * 2 + 1];
-  const s = clamp((x - x0) / (x1 - x0), 0, 1);
-  const t = clamp((yT - y) / (yT - yB), 0, 1);
+  return {
+    row,
+    col,
+    s: clamp((x - x0) / (x1 - x0), 0, 1),
+    t: clamp((yT - y) / (yT - yB), 0, 1)
+  };
+}
+function land(l, offsets, x, y) {
+  const { cols, points } = l;
+  const stride = cols + 1;
+  const { row, col, s, t } = bindToRest(l, x, y);
   const at = (r, c) => {
     const k = (r * stride + c) * 2;
     return [points[k] + offsets[k], points[k + 1] + offsets[k + 1]];
@@ -5195,7 +5243,7 @@ function armGeometry(layer, bodyAxisX) {
     b.x1 - elbow.x,
     b.y1 - elbow.y
   );
-  const inside = (x, y) => {
+  const inside2 = (x, y) => {
     const k = Math.floor(y) - bbox.y;
     if (k < 0 || k >= bbox.h) return false;
     const [rs, re] = span3(k);
@@ -5204,7 +5252,7 @@ function armGeometry(layer, bodyAxisX) {
   const capRays = Array.from({ length: CAP_SEGMENTS + 1 }, (_, i) => {
     const a = Math.PI * i / CAP_SEGMENTS;
     let t = 1;
-    while (t <= capRadius + CAP_INSET && inside(
+    while (t <= capRadius + CAP_INSET && inside2(
       elbow.x + canvasW / 2 + t * Math.cos(a),
       canvasH / 2 - elbow.y - t * Math.sin(a)
     )) {
@@ -5404,6 +5452,675 @@ function forearmPoseDeformer(role, arm) {
   };
 }
 
+// src/auto-rig/chain.ts
+function multiply(a, b) {
+  return [
+    a[0] * b[0] + a[2] * b[1],
+    a[1] * b[0] + a[3] * b[1],
+    a[0] * b[2] + a[2] * b[3],
+    a[1] * b[2] + a[3] * b[3],
+    a[0] * b[4] + a[2] * b[5] + a[4],
+    a[1] * b[4] + a[3] * b[5] + a[5]
+  ];
+}
+function valueOf(parameters, values, id) {
+  const p = parameters.find((q) => q.id === id);
+  if (p === void 0) return 0;
+  const v = values[id] ?? p.default;
+  return Math.min(p.max, Math.max(p.min, v));
+}
+function ownMatrix(d, parameters, values) {
+  let x = d.transform?.x ?? 0;
+  let y = d.transform?.y ?? 0;
+  let rotation = d.transform?.rotation ?? 0;
+  let sx = d.transform?.scaleX ?? 1;
+  let sy = d.transform?.scaleY ?? 1;
+  for (const b of d.bindings ?? []) {
+    const p = parameters.find((q) => q.id === b.parameter);
+    const t = p === void 0 || p.max === p.min ? 0 : (valueOf(parameters, values, b.parameter) - p.min) / (p.max - p.min);
+    const v = b.from + (b.to - b.from) * t;
+    if (b.channel === "translateX") x += v;
+    else if (b.channel === "translateY") y += v;
+    else if (b.channel === "rotate") rotation += v;
+    else if (b.channel === "scaleX") sx += v;
+    else if (b.channel === "scaleY") sy += v;
+  }
+  const r = rotation * Math.PI / 180;
+  const c = Math.cos(r);
+  const s = Math.sin(r);
+  const trs = [c * sx, s * sx, -s * sy, c * sy, x, y];
+  return multiply(multiply([1, 0, 0, 1, d.pivot.x, d.pivot.y], trs), [
+    1,
+    0,
+    0,
+    1,
+    -d.pivot.x,
+    -d.pivot.y
+  ]);
+}
+function localGrid(w, parameters, values) {
+  const points = [...w.grid.points];
+  for (const warp of w.warps ?? []) {
+    const offsets = blendStops(
+      warp.keyforms.map((k) => k.value),
+      warp.keyforms.map((k) => k.offsets),
+      valueOf(parameters, values, warp.parameter)
+    );
+    for (let i = 0; i < points.length; i++) points[i] += offsets[i];
+  }
+  return points;
+}
+function riddenFrame(pivot, w, q) {
+  const { cols, points: rest } = w.grid;
+  const stride = cols + 1;
+  const { row, col, s, t } = bindToRest(w.grid, pivot.x, pivot.y);
+  const xl = rest[col * 2];
+  const xr = rest[(col + 1) * 2];
+  const yt = rest[row * stride * 2 + 1];
+  const yb = rest[(row + 1) * stride * 2 + 1];
+  const i00 = (row * stride + col) * 2;
+  const i10 = (row * stride + col + 1) * 2;
+  const i01 = ((row + 1) * stride + col) * 2;
+  const i11 = ((row + 1) * stride + col + 1) * 2;
+  const lerp = (a, b, k) => a + (b - a) * k;
+  const topX = lerp(q[i00], q[i10], s);
+  const topY = lerp(q[i00 + 1], q[i10 + 1], s);
+  const botX = lerp(q[i01], q[i11], s);
+  const botY = lerp(q[i01 + 1], q[i11 + 1], s);
+  const px = lerp(topX, botX, t);
+  const py = lerp(topY, botY, t);
+  const width = xr - xl;
+  const height = yt - yb;
+  const exX = lerp(q[i10] - q[i00], q[i11] - q[i01], t) / width;
+  const exY = lerp(q[i10 + 1] - q[i00 + 1], q[i11 + 1] - q[i01 + 1], t) / width;
+  const eyX = -lerp(q[i01] - q[i00], q[i11] - q[i10], s) / height;
+  const eyY = -lerp(q[i01 + 1] - q[i00 + 1], q[i11 + 1] - q[i10 + 1], s) / height;
+  const theta = Math.atan2(exY - eyX, exX + eyY);
+  const c = Math.cos(theta);
+  const sn = Math.sin(theta);
+  return [
+    c,
+    sn,
+    -sn,
+    c,
+    px - (c * pivot.x - sn * pivot.y),
+    py - (sn * pivot.x + c * pivot.y)
+  ];
+}
+function matrixWorldAt(deformers2, parameters, id, values = {}) {
+  for (const key of Object.keys(values)) {
+    if (!parameters.some((q) => q.id === key)) {
+      throw new Error(`chain: unknown parameter "${key}"`);
+    }
+  }
+  const d = deformers2.find((x) => x.id === id);
+  if (d === void 0) throw new Error(`chain: no deformer "${id}"`);
+  if (d.kind === "warp") {
+    throw new Error(`chain: "${id}" is a warp deformer, not a matrix`);
+  }
+  const own = ownMatrix(d, parameters, values);
+  if (d.parent === void 0) return own;
+  const parent = deformers2.find((x) => x.id === d.parent);
+  if (parent === void 0) {
+    throw new Error(`chain: "${id}" has an unknown parent "${d.parent}"`);
+  }
+  if (parent.kind !== "warp") {
+    throw new Error(
+      `chain: "${id}" hangs from the matrix deformer "${parent.id}"; only a root warp is supported`
+    );
+  }
+  if (parent.parent !== void 0) {
+    throw new Error(
+      `chain: "${id}" hangs from warp "${parent.id}", which has a parent "${parent.parent}"; only a root warp is supported`
+    );
+  }
+  if (parent.warp2d !== void 0) {
+    throw new Error(
+      `chain: "${id}" hangs from warp "${parent.id}", which carries a warp2d; only 1D warps are supported`
+    );
+  }
+  return multiply(
+    riddenFrame(d.pivot, parent, localGrid(parent, parameters, values)),
+    own
+  );
+}
+
+// src/auto-rig/bakes.ts
+var TARGET_KEYS = [
+  "id",
+  "param",
+  "parts",
+  "box",
+  "grid",
+  "stops",
+  "mirror",
+  "why"
+];
+var BOX_KEYS = ["x", "y", "w", "h"];
+var MAX_VERTICES = 65536;
+var CELL_PX = [4, 400];
+var MAX_MESH_COLS = 64;
+var MAX_MESH_ROWS = 400;
+var DEFAULT_BOX_MARGIN = 2;
+var SAME_STOP = 1e-9;
+var PLAIN_DECIMAL = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var show = (v) => typeof v === "number" ? String(v) : JSON.stringify(v) ?? String(v);
+function mirrorLattice(lattice2, cols, rows) {
+  const out = new Array(lattice2.length);
+  for (let r = 0; r <= rows; r++) {
+    for (let c = 0; c <= cols; c++) {
+      const [dx, dy] = lattice2[r * (cols + 1) + (cols - c)];
+      out[r * (cols + 1) + c] = [-dx, dy];
+    }
+  }
+  return out;
+}
+var r1 = (v) => Math.round(v * 10) / 10;
+var findStop = (stops, v) => [...stops.keys()].find((k) => Math.abs(k - v) <= SAME_STOP);
+function checkGrid(at, grid) {
+  if (!isObject(grid)) {
+    throw new BakeError(`${at}.grid must be { cols, rows }, got ${show(grid)}`);
+  }
+  checkedKeys(`${at}.grid`, grid, ["cols", "rows"], BakeError);
+  const out = { cols: 0, rows: 0 };
+  for (const key of ["cols", "rows"]) {
+    const v = checkedNumber(
+      `${at}.grid.${key}`,
+      grid[key],
+      1,
+      32,
+      false,
+      BakeError
+    );
+    if (!Number.isInteger(v)) {
+      throw new BakeError(`${at}.grid.${key} must be an integer, got ${v}`);
+    }
+    out[key] = v;
+  }
+  return out;
+}
+function checkBox(at, box, partBoxes) {
+  if (box === void 0) {
+    const x0 = Math.min(...partBoxes.map((b) => b.x)) - DEFAULT_BOX_MARGIN;
+    const y0 = Math.min(...partBoxes.map((b) => b.y)) - DEFAULT_BOX_MARGIN;
+    const x1 = Math.max(...partBoxes.map((b) => b.x + b.w)) + DEFAULT_BOX_MARGIN;
+    const y1 = Math.max(...partBoxes.map((b) => b.y + b.h)) + DEFAULT_BOX_MARGIN;
+    return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+  }
+  if (!isObject(box)) {
+    throw new BakeError(`${at}.box must be { x, y, w, h }, got ${show(box)}`);
+  }
+  checkedKeys(`${at}.box`, box, BOX_KEYS, BakeError);
+  const [x, y] = ["x", "y"].map(
+    (k) => checkedNumber(
+      `${at}.box.${k}`,
+      box[k],
+      -Infinity,
+      Infinity,
+      false,
+      BakeError
+    )
+  );
+  const [w, h] = ["w", "h"].map(
+    (k) => checkedNumber(`${at}.box.${k}`, box[k], 0, Infinity, true, BakeError)
+  );
+  return { x, y, w, h };
+}
+function checkStops(at, t, info, rest, cols, rows) {
+  if (!isObject(t.stops)) {
+    throw new BakeError(
+      `${at}.stops must be an object keyed by a ${info.id} value, got ${show(t.stops)}`
+    );
+  }
+  const n = (cols + 1) * (rows + 1);
+  const stops = /* @__PURE__ */ new Map();
+  for (const [key, list] of Object.entries(t.stops)) {
+    const sat = `${at}.stops["${key}"]`;
+    if (!PLAIN_DECIMAL.test(key)) {
+      throw new BakeError(`${sat} must be keyed by a plain decimal number`);
+    }
+    const v = Number(key);
+    if (!Number.isFinite(v) || v < info.min || v > info.max) {
+      throw new BakeError(
+        `${sat} is outside ${info.id}'s range ${info.min} to ${info.max}`
+      );
+    }
+    if (Math.abs(v - rest) <= SAME_STOP) {
+      throw new BakeError(
+        `${sat} is ${info.id}'s rest value ${rest}: rest is implicit, leave it out`
+      );
+    }
+    if (findStop(stops, v) !== void 0) {
+      throw new BakeError(`${sat} repeats an earlier stop`);
+    }
+    if (!Array.isArray(list) || list.length !== n) {
+      throw new BakeError(
+        `${sat} must be ${n} points [dx, dy] (${cols + 1} x ${rows + 1}), got ${Array.isArray(list) ? `${list.length} points` : show(list)}`
+      );
+    }
+    list.forEach((pt, k) => {
+      if (!Array.isArray(pt) || pt.length !== 2) {
+        throw new BakeError(`${sat}[${k}] must be [dx, dy], got ${show(pt)}`);
+      }
+      pt.forEach((c, j) => {
+        if (!finite(c)) {
+          throw new BakeError(
+            `${sat}[${k}][${j}] must be a finite number, got ${String(c)}`
+          );
+        }
+      });
+    });
+    stops.set(v, list);
+  }
+  if (stops.size === 0) {
+    throw new BakeError(`${at}.stops must have at least one stop`);
+  }
+  if (t.mirror === true) {
+    for (const [v, lattice2] of [...stops]) {
+      const m = 2 * rest - v;
+      if (m < info.min - SAME_STOP || m > info.max + SAME_STOP) continue;
+      if (Math.abs(m - rest) <= SAME_STOP || findStop(stops, m) !== void 0) {
+        continue;
+      }
+      stops.set(
+        Math.min(info.max, Math.max(info.min, m)),
+        mirrorLattice(lattice2, cols, rows)
+      );
+    }
+  }
+  return stops;
+}
+function checkTarget(t, i, customParts, paramById) {
+  const at = `bakes.targets[${i}]`;
+  if (!isObject(t)) {
+    throw new BakeError(`${at} must be a plain object, got ${show(t)}`);
+  }
+  checkedKeys(at, t, TARGET_KEYS, BakeError);
+  if (t.id !== void 0 && typeof t.id !== "string") {
+    throw new BakeError(`${at}.id must be a string, got ${show(t.id)}`);
+  }
+  if (t.why !== void 0 && typeof t.why !== "string") {
+    throw new BakeError(`${at}.why must be a string, got ${show(t.why)}`);
+  }
+  const info = typeof t.param === "string" ? paramById.get(t.param) : void 0;
+  if (info === void 0) {
+    throw new BakeError(
+      `${at}.param must be a parameter the model declares, got ${show(t.param)}`
+    );
+  }
+  const rest = Math.min(info.max, Math.max(info.min, info.default));
+  const customIds = customParts.map((c) => c.id);
+  if (!Array.isArray(t.parts) || t.parts.length === 0) {
+    throw new BakeError(
+      `${at}.parts must be a non-empty array of part ids, got ${show(t.parts)}`
+    );
+  }
+  const parts = t.parts;
+  parts.forEach((id, k) => {
+    if (typeof id !== "string" || !customIds.includes(id)) {
+      throw new BakeError(
+        `${at}.parts[${k}] must be a custom part id (${customIds.join(", ")}): a bake moves custom parts only, got ${show(id)}`
+      );
+    }
+    if (parts.indexOf(id) !== k) {
+      throw new BakeError(`${at}.parts[${k}] repeats "${id}"`);
+    }
+  });
+  const { cols, rows } = checkGrid(at, t.grid);
+  const partBoxes = parts.map(
+    (id) => customParts.find((c) => c.id === id).layer.bbox
+  );
+  const box = checkBox(at, t.box, partBoxes);
+  if (t.mirror !== void 0 && typeof t.mirror !== "boolean") {
+    throw new BakeError(
+      `${at}.mirror must be true or false, got ${show(t.mirror)}`
+    );
+  }
+  const stops = checkStops(at, t, info, rest, cols, rows);
+  return {
+    id: typeof t.id === "string" ? t.id : `target${i}`,
+    param: info.id,
+    rest,
+    parts,
+    box,
+    cols,
+    rows,
+    stops
+  };
+}
+function checkMesh(at, choice, box) {
+  if (!isObject(choice)) {
+    throw new BakeError(
+      `${at} must be { rows, cols } or { cellPx }, got ${show(choice)}`
+    );
+  }
+  checkedKeys(at, choice, ["rows", "cols", "cellPx"], BakeError);
+  if (choice.cellPx !== void 0) {
+    if (choice.rows !== void 0 || choice.cols !== void 0) {
+      throw new BakeError(`${at} takes { cellPx } or { rows, cols }, not both`);
+    }
+    const cell = checkedNumber(
+      `${at}.cellPx`,
+      choice.cellPx,
+      CELL_PX[0],
+      CELL_PX[1],
+      false,
+      BakeError
+    );
+    const count = (Math.max(1, Math.round(box.w / cell)) + 1) * (Math.max(1, Math.round(box.h / cell)) + 1);
+    if (count > MAX_VERTICES) {
+      throw new BakeError(
+        `${at}.cellPx ${cell} makes ${count} vertices, over the format's ${MAX_VERTICES} limit`
+      );
+    }
+    return { cellPx: cell };
+  }
+  const cols = checkedNumber(
+    `${at}.cols`,
+    choice.cols,
+    1,
+    MAX_MESH_COLS,
+    false,
+    BakeError
+  );
+  if (!Number.isInteger(cols)) {
+    throw new BakeError(`${at}.cols must be an integer, got ${cols}`);
+  }
+  const ys = choice.rows;
+  if (!Array.isArray(ys) || ys.length < 2 || ys.length > MAX_MESH_ROWS) {
+    throw new BakeError(
+      `${at}.rows must be an array of 2 to ${MAX_MESH_ROWS} canvas-px y values, got ${Array.isArray(ys) ? `${ys.length} values` : show(ys)}`
+    );
+  }
+  ys.forEach((y, k) => {
+    if (!finite(y)) {
+      throw new BakeError(
+        `${at}.rows[${k}] must be a finite number, got ${String(y)}`
+      );
+    }
+    if (k > 0 && !(y > ys[k - 1])) {
+      throw new BakeError(
+        `${at}.rows[${k}] must be below the row before it (rows are strictly increasing), got ${y} after ${String(ys[k - 1])}`
+      );
+    }
+  });
+  const last = ys.length - 1;
+  if (Math.abs(ys[0] - box.y) > 0.5) {
+    throw new BakeError(
+      `${at}.rows[0] must be the part's box top ${r1(box.y)} (within 0.5 px), got ${String(ys[0])}`
+    );
+  }
+  if (Math.abs(ys[last] - (box.y + box.h)) > 0.5) {
+    throw new BakeError(
+      `${at}.rows[${last}] must be the part's box bottom ${r1(box.y + box.h)} (within 0.5 px), got ${String(ys[last])}`
+    );
+  }
+  return { rows: ys, cols };
+}
+function parseBakes(bakes, customParts, parameters) {
+  if (customParts === void 0 || customParts.length === 0) {
+    throw new BakeError(
+      "bakes needs customParts: a bake moves custom parts only, and none were given"
+    );
+  }
+  if (!isObject(bakes)) {
+    throw new BakeError(`bakes must be a plain object, got ${show(bakes)}`);
+  }
+  checkedKeys("bakes", bakes, ["targets", "meshes"], BakeError);
+  const { targets, meshes } = bakes;
+  if (!Array.isArray(targets) || targets.length === 0) {
+    throw new BakeError("bakes.targets must be a non-empty array");
+  }
+  const paramById = new Map(parameters.map((p) => [p.id, p]));
+  const parsedTargets = targets.map(
+    (t, i) => checkTarget(t, i, customParts, paramById)
+  );
+  const parsedMeshes = /* @__PURE__ */ new Map();
+  if (meshes !== void 0) {
+    if (!isObject(meshes)) {
+      throw new BakeError(
+        `bakes.meshes must be an object keyed by part id, got ${show(meshes)}`
+      );
+    }
+    for (const [id, choice] of Object.entries(meshes)) {
+      const at = `bakes.meshes.${id}`;
+      const part = customParts.find((c) => c.id === id);
+      if (part === void 0) {
+        throw new BakeError(
+          `${at}: "${id}" is not a custom part (${customParts.map((c) => c.id).join(", ")}): only a custom part is re-meshed`
+        );
+      }
+      parsedMeshes.set(id, checkMesh(at, choice, part.layer.bbox));
+    }
+  }
+  return { targets: parsedTargets, meshes: parsedMeshes };
+}
+var OFFSET_STEP = 1e-6;
+var RIGID_BEND = 25e-4;
+function rigidResidual(rest, moved) {
+  const n = rest.length;
+  if (moved.length !== n) {
+    throw new Error(
+      `rigidResidual: ${n} rest points but ${moved.length} moved points`
+    );
+  }
+  if (n === 0) return 0;
+  let pcx = 0;
+  let pcy = 0;
+  let qcx = 0;
+  let qcy = 0;
+  for (let i = 0; i < n; i++) {
+    pcx += rest[i][0];
+    pcy += rest[i][1];
+    qcx += moved[i][0];
+    qcy += moved[i][1];
+  }
+  pcx /= n;
+  pcy /= n;
+  qcx /= n;
+  qcy /= n;
+  let dot = 0;
+  let cross = 0;
+  for (let i = 0; i < n; i++) {
+    const px = rest[i][0] - pcx;
+    const py = rest[i][1] - pcy;
+    const qx = moved[i][0] - qcx;
+    const qy = moved[i][1] - qcy;
+    dot += px * qx + py * qy;
+    cross += px * qy - py * qx;
+  }
+  const theta = Math.atan2(cross, dot);
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  let worst = 0;
+  for (let i = 0; i < n; i++) {
+    const px = rest[i][0] - pcx;
+    const py = rest[i][1] - pcy;
+    const ex = qcx + c * px - s * py - moved[i][0];
+    const ey = qcy + s * px + c * py - moved[i][1];
+    worst = Math.max(worst, Math.hypot(ex, ey));
+  }
+  return worst;
+}
+function latticeAt(t, lattice2, x, y) {
+  const { cols, rows, box } = t;
+  const u = clamp((x - box.x) / box.w, 0, 1) * cols;
+  const v = clamp((y - box.y) / box.h, 0, 1) * rows;
+  const c = Math.min(Math.floor(u), cols - 1);
+  const r = Math.min(Math.floor(v), rows - 1);
+  const fx = u - c;
+  const fy = v - r;
+  const at = (rr, cc) => lattice2[rr * (cols + 1) + cc];
+  const mix = (k) => {
+    const top = at(r, c)[k] + (at(r, c + 1)[k] - at(r, c)[k]) * fx;
+    const bot = at(r + 1, c)[k] + (at(r + 1, c + 1)[k] - at(r + 1, c)[k]) * fx;
+    return top + (bot - top) * fy;
+  };
+  return [mix(0), mix(1)];
+}
+function targetField(t, v) {
+  const side = Math.sign(v - t.rest);
+  const knots = [...t.stops.keys()].filter((k) => Math.sign(k - t.rest) === side).sort((a2, b) => Math.abs(a2 - t.rest) - Math.abs(b - t.rest));
+  const a = Math.abs(v - t.rest);
+  return (x, y) => {
+    if (knots.length === 0) return [0, 0];
+    const at = (k) => latticeAt(t, t.stops.get(k), x, y);
+    let lo = 0;
+    let loVal = [0, 0];
+    for (const k of knots) {
+      const hi = Math.abs(k - t.rest);
+      const hiVal = at(k);
+      if (a <= hi + SAME_STOP) {
+        const f = hi - lo > 0 ? Math.min(1, (a - lo) / (hi - lo)) : 1;
+        return [
+          loVal[0] + (hiVal[0] - loVal[0]) * f,
+          loVal[1] + (hiVal[1] - loVal[1]) * f
+        ];
+      }
+      lo = hi;
+      loVal = hiVal;
+    }
+    return loVal;
+  };
+}
+var apply = (m, x, y) => [
+  m[0] * x + m[2] * y + m[4],
+  m[1] * x + m[3] * y + m[5]
+];
+function invert(m) {
+  const det = m[0] * m[3] - m[1] * m[2];
+  const a = m[3] / det;
+  const b = -m[1] / det;
+  const c = -m[2] / det;
+  const d = m[0] / det;
+  return [a, b, c, d, -(a * m[4] + c * m[5]), -(b * m[4] + d * m[5])];
+}
+function remesh(part, entry, choice, canvas) {
+  const b = boxOfPixels(entry.layer.bbox, canvas.width, canvas.height);
+  if ("cellPx" in choice) {
+    part.mesh = gridMesh(
+      Math.max(1, Math.round(bw(b) / choice.cellPx)),
+      Math.max(1, Math.round(bh(b) / choice.cellPx))
+    );
+    return;
+  }
+  const xs = Array.from(
+    { length: choice.cols + 1 },
+    (_, c) => b.x0 + bw(b) * c / choice.cols
+  );
+  part.mesh = columnMesh(b, {
+    xs,
+    ys: choice.rows.map((y) => canvas.height / 2 - y)
+  });
+}
+function applyBakes(parsed, parts, entries, ctx) {
+  const { canvas, deformers: deformers2, parameters, faceWidth } = ctx;
+  const partOf = (id) => parts.find((p) => p.id === id);
+  const entryOf = (id) => entries.find((e) => e.id === id);
+  for (const [id, choice] of parsed.meshes) {
+    remesh(partOf(id), entryOf(id), choice, canvas);
+  }
+  const ids = [...new Set(parsed.targets.flatMap((t) => t.parts))];
+  const reports = [];
+  for (const id of ids) {
+    const part = partOf(id);
+    const n = part.mesh.vertices.length / 2;
+    const own = parsed.targets.filter((t) => t.parts.includes(id));
+    const w0 = matrixWorldAt(deformers2, parameters, part.deformer);
+    const local = [];
+    const restModel = [];
+    const restCanvas = [];
+    for (let i = 0; i < n; i++) {
+      const p = [
+        part.transform.x + part.mesh.vertices[i * 2] * part.width,
+        part.transform.y + part.mesh.vertices[i * 2 + 1] * part.height
+      ];
+      const r = apply(w0, p[0], p[1]);
+      local.push(p);
+      restModel.push(r);
+      restCanvas.push([r[0] + canvas.width / 2, canvas.height / 2 - r[1]]);
+    }
+    for (const param of [...new Set(own.map((t) => t.param))]) {
+      const targets = own.filter((t) => t.param === param);
+      const rest = targets[0].rest;
+      const stops = [];
+      for (const v of targets.flatMap((t) => [...t.stops.keys()]).sort((a, b) => a - b)) {
+        if (stops.length === 0 || v - stops[stops.length - 1] > SAME_STOP) {
+          stops.push(v);
+        }
+      }
+      const range = parameters.find((p) => p.id === param);
+      const ends = [];
+      for (const [outer, end] of [
+        [stops.filter((v) => v < rest).shift(), range.min],
+        [stops.filter((v) => v > rest).pop(), range.max]
+      ]) {
+        if (outer !== void 0 && Math.abs(end - outer) > SAME_STOP) {
+          ends.push(end);
+        }
+      }
+      const keyforms = [{ value: rest, offsets: new Array(2 * n).fill(0) }];
+      const wanted = [];
+      const endWanted = [];
+      for (const v of [...stops, ...ends]) {
+        const disp = new Array(2 * n).fill(0);
+        const fields2 = targets.map((t) => targetField(t, v));
+        for (let i = 0; i < n; i++) {
+          for (const field of fields2) {
+            const [dx, dy] = field(restCanvas[i][0], restCanvas[i][1]);
+            disp[i * 2] += dx;
+            disp[i * 2 + 1] += dy;
+          }
+        }
+        (ends.includes(v) ? endWanted : wanted).push(disp);
+        if (entryOf(id).rigid === true) {
+          const moved = restCanvas.map(
+            (p, i) => [p[0] + disp[i * 2], p[1] + disp[i * 2 + 1]]
+          );
+          const bend = rigidResidual(restCanvas, moved);
+          if (bend > RIGID_BEND * faceWidth) {
+            const names = targets.map(
+              (t) => `bakes.targets[${parsed.targets.indexOf(t)}] ("${t.id}")`
+            ).join(", ");
+            throw new BakeError(
+              `${names}: "${id}" is rigid, but at ${param} ${v} these targets together bend it by ${bend.toFixed(2)} px, over the ${(RIGID_BEND * faceWidth).toFixed(2)} px a rigid part may bend (${RIGID_BEND} face widths): give every control point one displacement, or a rotation`
+            );
+          }
+        }
+        const inv = invert(
+          matrixWorldAt(deformers2, parameters, part.deformer, { [param]: v })
+        );
+        const offsets = [];
+        for (let i = 0; i < n; i++) {
+          const [px, py] = apply(
+            inv,
+            restModel[i][0] + disp[i * 2],
+            restModel[i][1] - disp[i * 2 + 1]
+          );
+          offsets.push(
+            roundTo((px - local[i][0]) / part.width, OFFSET_STEP),
+            roundTo((py - local[i][1]) / part.height, OFFSET_STEP)
+          );
+        }
+        keyforms.push({ value: v, offsets });
+      }
+      keyforms.sort((a, b) => a.value - b.value);
+      part.warps = [...part.warps ?? [], { parameter: param, keyforms }];
+      reports.push({
+        part: id,
+        param,
+        stops,
+        vertexCount: n,
+        wanted,
+        ends: ends.map((value, i) => ({ value, wanted: endWanted[i] }))
+      });
+    }
+  }
+  return reports;
+}
+
 // src/auto-rig/generate.ts
 var import_format12 = require("@ikijs/format");
 
@@ -5606,8 +6323,8 @@ function defaultMotions(declared) {
 }
 
 // src/auto-rig/checks.ts
-var finite = (v) => typeof v === "number" && Number.isFinite(v);
-var isObject = (v) => typeof v === "object" && v !== null;
+var finite2 = (v) => typeof v === "number" && Number.isFinite(v);
+var isObject2 = (v) => typeof v === "object" && v !== null;
 var MIN_FACE_PX = 24;
 function checkLayers(layers, canvas) {
   if (!Array.isArray(layers) || layers.length === 0) {
@@ -5615,10 +6332,10 @@ function checkLayers(layers, canvas) {
       "auto-rig: generateIkiFromLayerSet: layers must be a non-empty array"
     );
   }
-  if (!(finite(canvas?.width) && canvas.width > 0)) {
+  if (!(finite2(canvas?.width) && canvas.width > 0)) {
     throw new Error("auto-rig: canvas.width must be a positive number");
   }
-  if (!(finite(canvas?.height) && canvas.height > 0)) {
+  if (!(finite2(canvas?.height) && canvas.height > 0)) {
     throw new Error("auto-rig: canvas.height must be a positive number");
   }
   const seen = /* @__PURE__ */ new Set();
@@ -5630,7 +6347,7 @@ function checkLayers(layers, canvas) {
     seen.add(l.role);
     const at = `auto-rig: layer "${l.fileName}"`;
     const { x, y, w, h } = l.bbox ?? {};
-    if (![x, y, w, h].every(finite) || w <= 0 || h <= 0 || x < 0 || y < 0 || x + w > canvas.width || y + h > canvas.height) {
+    if (![x, y, w, h].every(finite2) || w <= 0 || h <= 0 || x < 0 || y < 0 || x + w > canvas.width || y + h > canvas.height) {
       throw new Error(
         `${at} has a bbox outside its ${canvas.width}x${canvas.height} canvas`
       );
@@ -5658,7 +6375,7 @@ function checkLayers(layers, canvas) {
         );
       }
       rows.forEach((v, i) => {
-        if (!finite(v) || v < 0 || v > w / 2 + 0.5) {
+        if (!finite2(v) || v < 0 || v > w / 2 + 0.5) {
           throw new Error(
             `${at}: rowHalfWidths[${i}] ${v} is not a half-width inside its crop`
           );
@@ -5699,7 +6416,7 @@ function checkLayers(layers, canvas) {
     }
     if (l.denseCore !== void 0) {
       const c = l.denseCore;
-      if (![c.x, c.y, c.w, c.h].every(finite) || c.w <= 0 || c.h <= 0 || c.x < x - 1 || c.y < y - 1 || c.x + c.w > x + w + 1 || c.y + c.h > y + h + 1) {
+      if (![c.x, c.y, c.w, c.h].every(finite2) || c.w <= 0 || c.h <= 0 || c.x < x - 1 || c.y < y - 1 || c.x + c.w > x + w + 1 || c.y + c.h > y + h + 1) {
         throw new Error(`${at}: denseCore is not a box inside its crop`);
       }
     }
@@ -5722,7 +6439,7 @@ function checkLayers(layers, canvas) {
 }
 function checkHeadEdges(edges, byRole) {
   if (edges === void 0) return;
-  if (!isObject(edges))
+  if (!isObject2(edges))
     throw new TurnTargetError("headEdges must be an object");
   for (const side of ["left", "right"]) {
     const list = edges[side];
@@ -5730,12 +6447,12 @@ function checkHeadEdges(edges, byRole) {
       throw new TurnTargetError(`headEdges.${side} must be an array`);
     }
     list.forEach((e, i) => {
-      if (!isObject(e) || typeof e.role !== "string" || !byRole.has(e.role)) {
+      if (!isObject2(e) || typeof e.role !== "string" || !byRole.has(e.role)) {
         throw new TurnTargetError(
           `headEdges.${side}[${i}].role is not a layer in this set`
         );
       }
-      if (!finite(e.x)) {
+      if (!finite2(e.x)) {
         throw new TurnTargetError(
           `headEdges.${side}[${i}].x must be a finite number`
         );
@@ -5755,25 +6472,25 @@ function checkHeadEdges(edges, byRole) {
 }
 function checkStrandEdges(strand, irises, hair) {
   if (strand === void 0) return;
-  if (!isObject(strand)) {
+  if (!isObject2(strand)) {
     throw new TurnTargetError("strandEdges must be an object");
   }
   for (const side of ["left", "right"]) {
     const s = strand[side];
     if (s === void 0) continue;
     const at = `strandEdges.${side}`;
-    if (!isObject(s)) throw new TurnTargetError(`${at} must be an object`);
+    if (!isObject2(s)) throw new TurnTargetError(`${at} must be an object`);
     if (hair === void 0) {
       throw new TurnTargetError(
         `${at} names a bangs' run, but this layer set has no hair_front`
       );
     }
     for (const k of ["y", "irisOuter", "irisInner", "runOuter"]) {
-      if (!finite(s[k])) {
+      if (!finite2(s[k])) {
         throw new TurnTargetError(`${at}.${k} must be a finite number`);
       }
     }
-    if (s.runFace !== null && !finite(s.runFace)) {
+    if (s.runFace !== null && !finite2(s.runFace)) {
       throw new TurnTargetError(
         `${at}.runFace must be a finite number or null`
       );
@@ -6242,9 +6959,9 @@ function replay(op, i, ctx, sums) {
   const x = span2(`${name}.region.x`, region.x);
   const y = span2(`${name}.region.y`, region.y);
   const by = fields(`${name}.by`, o.by, BY_KEYS);
-  const dx = finite2(`${name}.by.dx`, by.dx);
-  const dy = finite2(`${name}.by.dy`, by.dy);
-  const falloff = o.falloff === void 0 ? 0 : finite2(`${name}.falloff`, o.falloff, 0);
+  const dx = finite3(`${name}.by.dx`, by.dx);
+  const dy = finite3(`${name}.by.dy`, by.dy);
+  const falloff = o.falloff === void 0 ? 0 : finite3(`${name}.falloff`, o.falloff, 0);
   if (o.why !== void 0) text(`${name}.why`, o.why);
   const box = ctx.boxOf(role);
   if (box === void 0) {
@@ -6412,10 +7129,10 @@ function fields(name, v, known) {
 function numbers(name, v) {
   const o = fields(name, v, Object.keys(v ?? {}));
   return Object.fromEntries(
-    Object.entries(o).map(([k, n]) => [k, finite2(`${name}.${k}`, n)])
+    Object.entries(o).map(([k, n]) => [k, finite3(`${name}.${k}`, n)])
   );
 }
-var finite2 = (name, v, lo = -Infinity) => asPatch(() => checkedNumber(name, v, lo, Infinity));
+var finite3 = (name, v, lo = -Infinity) => asPatch(() => checkedNumber(name, v, lo, Infinity));
 function text(name, v) {
   if (typeof v !== "string") {
     throw new PatchError(`${name} must be a string, got ${String(v)}`);
@@ -6428,8 +7145,8 @@ function span2(name, v) {
       `${name} must be [from, to], got ${JSON.stringify(v)}`
     );
   }
-  const lo = finite2(`${name}[0]`, v[0]);
-  const hi = finite2(`${name}[1]`, v[1]);
+  const lo = finite3(`${name}[0]`, v[0]);
+  const hi = finite3(`${name}[1]`, v[1]);
   if (lo > hi) {
     throw new PatchError(
       `${name} [${lo}, ${hi}] runs backwards: ${name}[0] must not exceed ${name}[1]`
@@ -6438,6 +7155,224 @@ function span2(name, v) {
   return [lo, hi];
 }
 
+// src/auto-rig/custom-parts.ts
+var KEYS = [
+  "id",
+  "layer",
+  "anchor",
+  "tie",
+  "after",
+  "deformer",
+  "rigid",
+  "occlusion"
+];
+var OCCLUSION_KEYS = ["by", "parameter", "stops"];
+var STOP_KEYS = ["value", "amount"];
+var LAYER_KEYS = ["fileName", "bbox"];
+var finite4 = (v) => typeof v === "number" && Number.isFinite(v);
+var isObject3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var inside = (b, [x, y]) => x >= b.x && x < b.x + b.w && y >= b.y && y < b.y + b.h;
+var RESERVED = new Set(
+  ROLE_TABLE.flatMap((r) => [r.role, ...partIdsOfRole(r.role)])
+);
+function checkCustomParts(customParts, byRole, canvas, parameters, physicsOutputs) {
+  if (!Array.isArray(customParts)) {
+    throw new CustomPartError(
+      `customParts must be an array, got ${customParts === null ? "null" : typeof customParts}`
+    );
+  }
+  const present = [...byRole.keys()];
+  const roleField = (at, v) => {
+    const layer = typeof v === "string" ? byRole.get(v) : void 0;
+    if (layer === void 0) {
+      throw new CustomPartError(
+        `${at} must be a role of the set, one of ${present.join(", ")}; got ${JSON.stringify(v)}`
+      );
+    }
+    return layer;
+  };
+  const ids = /* @__PURE__ */ new Set();
+  customParts.forEach((entry, i) => {
+    const at = `customParts[${i}]`;
+    if (!isObject3(entry)) {
+      throw new CustomPartError(`${at} must be a plain object`);
+    }
+    checkedKeys(at, entry, KEYS, CustomPartError);
+    const { id, layer, anchor, tie, after, deformer, rigid, occlusion } = entry;
+    if (typeof id !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(id)) {
+      throw new CustomPartError(
+        `${at}.id must be a plain identifier (letters, digits, underscore; not starting with a digit), got ${JSON.stringify(id)}`
+      );
+    }
+    if (RESERVED.has(id)) {
+      throw new CustomPartError(
+        `${at}.id "${id}" is a role's name or a part id a role yields: those are reserved, also for roles added later, so pick a name no role would take`
+      );
+    }
+    if (ids.has(id)) {
+      throw new CustomPartError(
+        `${at}.id "${id}" repeats an earlier entry's id`
+      );
+    }
+    ids.add(id);
+    if (!isObject3(layer)) {
+      throw new CustomPartError(`${at}.layer must be a plain object`);
+    }
+    checkedKeys(`${at}.layer`, layer, LAYER_KEYS, CustomPartError);
+    if (typeof layer.fileName !== "string" || layer.fileName === "") {
+      throw new CustomPartError(
+        `${at}.layer.fileName must be a non-empty string`
+      );
+    }
+    const b = isObject3(layer.bbox) ? layer.bbox : {};
+    const { x, y, w, h } = b;
+    if (!(finite4(x) && finite4(y) && finite4(w) && finite4(h)) || w <= 0 || h <= 0 || x < 0 || y < 0 || x + w > canvas.width || y + h > canvas.height) {
+      throw new CustomPartError(
+        `${at}.layer.bbox must be a finite, non-empty box inside the ${canvas.width}x${canvas.height} canvas, got ${JSON.stringify(layer.bbox)}`
+      );
+    }
+    const box = { x, y, w, h };
+    const anchorLayer = roleField(`${at}.anchor`, anchor);
+    roleField(`${at}.after`, after);
+    if (!Array.isArray(tie) || tie.length !== 2 || !tie.every(finite4) || !inside(box, tie) || !inside(anchorLayer.bbox, tie)) {
+      throw new CustomPartError(
+        `${at}.tie must be [x, y], two finite canvas px inside both the part's layer box and the anchor "${String(anchor)}" layer box, got ${JSON.stringify(tie)}`
+      );
+    }
+    if (deformer !== void 0 && deformer !== "headDeformer") {
+      throw new CustomPartError(
+        `${at}.deformer "${String(deformer)}" is not accepted: headDeformer is the only deformer a custom part hangs on`
+      );
+    }
+    if (rigid !== void 0 && typeof rigid !== "boolean") {
+      throw new CustomPartError(
+        `${at}.rigid must be true or false, got ${JSON.stringify(rigid)}`
+      );
+    }
+    if (occlusion !== void 0) {
+      checkOcclusion(
+        `${at}.occlusion`,
+        occlusion,
+        present,
+        parameters,
+        physicsOutputs
+      );
+    }
+  });
+  return customParts;
+}
+function checkOcclusion(at, occlusion, present, parameters, physicsOutputs) {
+  if (!isObject3(occlusion)) {
+    throw new CustomPartError(`${at} must be a plain object`);
+  }
+  checkedKeys(at, occlusion, OCCLUSION_KEYS, CustomPartError);
+  const { by, parameter, stops } = occlusion;
+  if (!Array.isArray(by) || by.length === 0) {
+    throw new CustomPartError(
+      `${at}.by must be a non-empty array of roles of the set, one of ${present.join(", ")}`
+    );
+  }
+  by.forEach((role, j) => {
+    if (typeof role !== "string" || !present.includes(role)) {
+      throw new CustomPartError(
+        `${at}.by[${j}] must be a role of the set, one of ${present.join(", ")}; got ${JSON.stringify(role)}`
+      );
+    }
+    if (by.indexOf(role) !== j) {
+      throw new CustomPartError(
+        `${at}.by[${j}] "${role}" repeats an earlier role`
+      );
+    }
+  });
+  const descriptor = parameters.find((p) => p.id === parameter);
+  if (typeof parameter !== "string" || descriptor === void 0) {
+    throw new CustomPartError(
+      `${at}.parameter must be a parameter the rig declares, got ${JSON.stringify(parameter)}`
+    );
+  }
+  if (physicsOutputs.has(parameter)) {
+    throw new CustomPartError(
+      `${at}.parameter "${parameter}" is a physics output; an occlusion amount cannot be keyed on one`
+    );
+  }
+  if (!Array.isArray(stops) || stops.length === 0) {
+    throw new CustomPartError(`${at}.stops must be a non-empty array`);
+  }
+  const { min, max } = descriptor;
+  let previous = -Infinity;
+  stops.forEach((stop, k) => {
+    const s = `${at}.stops[${k}]`;
+    if (!isObject3(stop))
+      throw new CustomPartError(`${s} must be a plain object`);
+    checkedKeys(s, stop, STOP_KEYS, CustomPartError);
+    const { value, amount } = stop;
+    if (!finite4(value)) {
+      throw new CustomPartError(
+        `${s}.value must be a finite number, got ${JSON.stringify(value)}`
+      );
+    }
+    if (value < min || value > max) {
+      throw new CustomPartError(
+        `${s}.value ${value} is outside parameter "${parameter}" range [${min},${max}]`
+      );
+    }
+    if (value <= previous) {
+      throw new CustomPartError(`${s}.value must be strictly ascending`);
+    }
+    previous = value;
+    if (!finite4(amount) || amount < 0 || amount > 1) {
+      throw new CustomPartError(
+        `${s}.amount must be a number in 0..1, got ${JSON.stringify(amount)}`
+      );
+    }
+  });
+}
+var CELL_PX2 = 20;
+function buildCustomParts(customParts, canvas) {
+  return customParts.map(({ id, layer }) => {
+    const b = boxOfPixels(layer.bbox, canvas.width, canvas.height);
+    return {
+      id,
+      color: [1, 1, 1, 1],
+      width: bw(b),
+      height: bh(b),
+      transform: { x: cx(b), y: cy(b) },
+      order: 0,
+      deformer: "headDeformer",
+      mesh: gridMesh(
+        Math.max(1, Math.round(bw(b) / CELL_PX2)),
+        Math.max(1, Math.round(bh(b) / CELL_PX2))
+      )
+    };
+  });
+}
+function writeOcclusion(customParts, built, parts) {
+  const byId = new Map(parts.map((p) => [p.id, p]));
+  customParts.forEach((entry, i) => {
+    if (entry.occlusion === void 0) return;
+    const { by, parameter, stops } = entry.occlusion;
+    const ids = [];
+    by.forEach((role, j) => {
+      for (const id of partIdsOfRole(role)) {
+        const part = byId.get(id);
+        if (part === void 0) continue;
+        const fault = part.clip !== void 0 ? { is: "is clipped", kind: "a clipped part" } : part.mesh === void 0 ? { is: "has no mesh", kind: "a part without a mesh" } : void 0;
+        if (fault !== void 0) {
+          throw new CustomPartError(
+            `customParts[${i}].occlusion.by[${j}] "${role}" yields part "${id}", which ${fault.is}; ${fault.kind} cannot occlude`
+          );
+        }
+        ids.push(id);
+      }
+    });
+    built[i].occlusion = {
+      by: ids,
+      parameter,
+      stops: stops.map((s) => ({ value: s.value, amount: s.amount }))
+    };
+  });
+}
+
 // src/auto-rig/generate.ts
 var MESH_CELLS = {
   face: { px: 28, min: 4, max: 24 },
@@ -6479,6 +7414,16 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
   const hasNose = has("nose");
   const plateHalf = byRole.get("face").cropW / 2;
   checkHeadEdges(options.headEdges, byRole);
+  const physics = has("hair_front") ? hairPhysics(has("hair_back")) : void 0;
+  const parameters = declareParameters(new Set(byRole.keys()));
+  const entries = options.customParts !== void 0 && !(Array.isArray(options.customParts) && options.customParts.length === 0) ? checkCustomParts(
+    options.customParts,
+    byRole,
+    canvas,
+    parameters,
+    new Set((physics ?? []).map((r) => r.output.parameter))
+  ) : [];
+  const bakes = options.bakes === void 0 ? void 0 : parseBakes(options.bakes, entries, parameters);
   checkStrandEdges(
     options.strandEdges,
     sideIrises(byRole),
@@ -6628,7 +7573,6 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
       ...part.warps ?? []
     ];
   }
-  const parameters = declareParameters(new Set(byRole.keys()));
   const reports = options.patches === void 0 ? void 0 : applyPatches(options.patches, {
     grids: new Map(
       [...grids].map(([family, g]) => [WARP_ID[family], g])
@@ -6638,19 +7582,51 @@ function generateIkiFromLayerSet(layers, canvas, options = {}) {
     faceWidth: byRole.get("face").cropW,
     parameters
   });
+  const deformerList = deformers(
+    frame,
+    grids,
+    bodyWarp?.deformer,
+    arms,
+    byRole
+  );
+  let bakeReports;
+  if (entries.length > 0) {
+    const built = buildCustomParts(entries, canvas);
+    entries.forEach((entry, i) => {
+      const group = new Set(partIdsOfRole(entry.after));
+      for (let j = 0; j < i; j++) {
+        if (entries[j].after === entry.after) group.add(entries[j].id);
+      }
+      const last = parts.map((p) => group.has(p.id)).lastIndexOf(true);
+      parts.splice(last + 1, 0, built[i]);
+    });
+    parts.forEach((p, i) => {
+      p.order = i;
+    });
+    writeOcclusion(entries, built, parts);
+    if (bakes !== void 0) {
+      bakeReports = applyBakes(bakes, built, entries, {
+        canvas,
+        deformers: deformerList,
+        parameters,
+        faceWidth: byRole.get("face").cropW
+      });
+    }
+  }
   const model = {
     version: import_format12.IKI_FORMAT_VERSION,
     name: "auto-rigged",
     canvas: { width: canvas.width, height: canvas.height },
     parameters,
     parts,
-    deformers: deformers(frame, grids, bodyWarp?.deformer, arms, byRole),
-    ...has("hair_front") ? { physics: hairPhysics(has("hair_back")) } : {},
+    deformers: deformerList,
+    ...physics !== void 0 ? { physics } : {},
     expressions: defaultExpressions(new Set(parameters.map((p) => p.id))),
     motions: defaultMotions(new Set(parameters.map((p) => p.id)))
   };
   const valid = (0, import_format12.parseIkiModel)(model);
   if (reports !== void 0) options.onPatchesApplied?.(reports);
+  if (bakeReports !== void 0) options.onBakesApplied?.(bakeReports);
   options.onRigPlanResolved?.(
     rigPlanReport(options.rigPlan ?? {}, plan, targets, fit)
   );
@@ -7133,7 +8109,9 @@ function declareParameters(roles) {
   AddDeformer,
   AddPart,
   AddPhysicsRig,
+  BakeError,
   CaptureGridKeyform,
+  CustomPartError,
   DEFAULT_TURN_TARGETS,
   DeleteDeformer,
   DeletePart,
@@ -7189,6 +8167,7 @@ function declareParameters(roles) {
   packAtlas,
   parseLayerRoles,
   partIdsOfRole,
+  rigidResidual,
   styleRemovedMessage,
   upsertGridKeyform,
   uvRectFor,