@ikijs/editor 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2233 @@
+// src/document.ts
+import { parseIkiModel } from "@ikijs/format";
+
+// src/mesh-uv.ts
+function remapMeshUvsToRect(baseUvs, rect) {
+  if (baseUvs.length % 2 !== 0) {
+    throw new Error(
+      `remapMeshUvsToRect: baseUvs must have an even length (u,v pairs), got ${baseUvs.length}`
+    );
+  }
+  const out = new Array(baseUvs.length);
+  for (let i = 0; i < baseUvs.length; i += 2) {
+    out[i] = rect.x + baseUvs[i] * rect.width;
+    out[i + 1] = rect.y + baseUvs[i + 1] * rect.height;
+  }
+  return out;
+}
+
+// src/document.ts
+var EditorDocument = class {
+  model;
+  undoStack = [];
+  redoStack = [];
+  /** Editor-only session state, never serialized; keyed by stable part id. The
+   *  unmodified BASE local uvs of every mesh part, captured once at construction
+   *  so atlas remaps always derive from the original (idempotent). */
+  baseMeshUvs = /* @__PURE__ */ new Map();
+  constructor(model) {
+    this.model = structuredClone(model);
+    for (const part of this.model.parts) {
+      if (part.mesh) {
+        this.baseMeshUvs.set(part.id, part.mesh.uvs.slice());
+      }
+    }
+  }
+  /** Live reference to the working model — for READ access. Mutate it only
+   *  through {@link execute}/{@link undo}/{@link redo}. */
+  getModel() {
+    return this.model;
+  }
+  /** Resolve a part by stable id. Throws a plain `Error` (NOT an
+   *  `IkiFormatError`) with a path-qualified message if the id is unknown. */
+  findPart(id) {
+    const part = this.model.parts.find((p) => p.id === id);
+    if (!part) {
+      throw new Error(`parts: no part with id "${id}"`);
+    }
+    return part;
+  }
+  /** Resolve a warp deformer by stable id. Throws a path-qualified plain
+   *  `Error` if no deformer matches the id or the match is not a warp deformer.
+   *  READ/mutate-through accessor, consistent with {@link findPart}. */
+  findWarpDeformer(id) {
+    const deformer = this.model.deformers?.find((d) => d.id === id);
+    if (!deformer || deformer.kind !== "warp") {
+      throw new Error(`deformers: no warp deformer with id "${id}"`);
+    }
+    return deformer;
+  }
+  /** Resolve a matrix deformer by stable id. Throws a path-qualified plain
+   *  `Error` if no deformer matches the id or the match is a warp deformer
+   *  (`kind === "warp"`). A `kind` of `"matrix"` or `undefined` is a matrix
+   *  deformer. READ/mutate-through accessor, consistent with {@link findPart}. */
+  findMatrixDeformer(id) {
+    const deformer = this.model.deformers?.find((d) => d.id === id);
+    if (!deformer || deformer.kind === "warp") {
+      throw new Error(`deformers: no matrix deformer with id "${id}"`);
+    }
+    return deformer;
+  }
+  /** Resolve any deformer (matrix or warp) by stable id. Throws a
+   *  path-qualified plain `Error` if no deformer matches the id.
+   *  READ/mutate-through accessor, consistent with {@link findPart}. */
+  findDeformer(id) {
+    const deformer = this.model.deformers?.find((d) => d.id === id);
+    if (!deformer) {
+      throw new Error(`deformers: no deformer with id "${id}"`);
+    }
+    return deformer;
+  }
+  /** Resolve a physics rig by stable id. Throws a path-qualified plain `Error`
+   *  if no rig matches the id. The `physics` array is optional, so guard it.
+   *  READ/mutate-through accessor, consistent with {@link findDeformer}. */
+  findPhysicsRig(id) {
+    const rig = this.model.physics?.find((r) => r.id === id);
+    if (!rig) {
+      throw new Error(`physics: no physics rig with id "${id}"`);
+    }
+    return rig;
+  }
+  /**
+   * Record the base mesh UVs for a part inserted AFTER construction (e.g. by
+   * {@link AddPart}). Returns the PRIOR entry for that id (or `undefined` if
+   * none existed) so the caller can restore it on undo. No-op for meshless
+   * parts (returns `undefined`). Must be called by any command that pushes a
+   * mesh part into the model so the part joins the constructor-captured base-UV
+   * side state required by {@link applyAtlas}.
+   *
+   * The returned prior value is what {@link restoreBaseMeshUvs} expects on
+   * undo — pass it verbatim. Hazard guarded: DeletePart(X) → AddPart(X′) →
+   * undo(add) → undo(delete); without restore, X's constructor-captured entry
+   * would be permanently gone after undo of the add, causing applyAtlas to
+   * fail when X is restored.
+   */
+  captureBaseMeshUvs(partId) {
+    const prev = this.baseMeshUvs.get(partId);
+    const part = this.model.parts.find((p) => p.id === partId);
+    if (part?.mesh) {
+      this.baseMeshUvs.set(partId, part.mesh.uvs.slice());
+    }
+    return prev;
+  }
+  /**
+   * Restore the base-UV side state to exactly what it was before a
+   * {@link captureBaseMeshUvs} call. Called from {@link AddPart.invert}:
+   * pass the value returned by captureBaseMeshUvs on first apply.
+   * - `prev` is `number[]` → sets the entry (restores a prior mesh's base).
+   * - `prev` is `undefined` → deletes the entry (no entry existed before the
+   *   add, so a later different-mesh part reusing the id must not inherit this
+   *   one's base).
+   * DeletePart does NOT call this — the entry persists across delete/undo so
+   * the restored part still has its base available for applyAtlas.
+   */
+  restoreBaseMeshUvs(partId, prev) {
+    if (prev !== void 0) {
+      this.baseMeshUvs.set(partId, prev);
+    } else {
+      this.baseMeshUvs.delete(partId);
+    }
+  }
+  /** The construction-captured base UVs for a mesh part. Throws a path-qualified
+   *  plain `Error` if absent. SINGLE accessor for both apply branches — never
+   *  read `baseMeshUvs` with a bare `!` elsewhere. */
+  requireBaseUvs(partId) {
+    const base = this.baseMeshUvs.get(partId);
+    if (!base) {
+      throw new Error(`parts: no base mesh uvs captured for part "${partId}"`);
+    }
+    return base;
+  }
+  /**
+   * Replace the atlas table and rewrite every part's texture reference in a
+   * single atomic step. For every part in `partTextureAssignments` set
+   * `texture = { index: 0, uv }`; CLEAR `texture` (delete the key) on every
+   * other part.
+   *
+   * Mesh parts are textured as a MATCHED PAIR: an assigned mesh part also has
+   * its per-vertex `mesh.uvs` remapped (from the construction-captured base)
+   * into the same `uv` rect; an unassigned mesh part has its `mesh.uvs` restored
+   * to that base. Quad parts carry `texture.uv` only and are untouched here.
+   *
+   * Deliberately NON-undoable: it does NOT push to or clear the undo/redo
+   * stacks (texture/atlas state is not undoable in 5b — the unified
+   * editor-state superset is deferred to 5d). `canUndo()`/`canRedo()` are
+   * unchanged after a call.
+   *
+   * Validate-all-then-apply: structural input validation, per-partId
+   * resolution, and a base-UV preflight over every mesh part all run BEFORE any
+   * mutation, so a bad input (wrong shape, duplicate partId, unknown partId, or
+   * a mesh part with no captured base) throws a plain `Error` and leaves the
+   * model exactly as it was — never a partial application.
+   */
+  applyAtlas(input) {
+    const { texture, assignmentsByPart } = this.normalizeAtlasInput(input);
+    const resolved = /* @__PURE__ */ new Map();
+    for (const [partId, uv] of assignmentsByPart) {
+      resolved.set(this.findPart(partId), uv);
+    }
+    for (const part of this.model.parts) {
+      if (part.mesh) {
+        this.requireBaseUvs(part.id);
+      }
+    }
+    this.model.textures = texture === void 0 ? void 0 : [{ source: texture.source }];
+    for (const part of this.model.parts) {
+      const uv = resolved.get(part);
+      if (uv) {
+        part.texture = {
+          index: 0,
+          uv: { x: uv.x, y: uv.y, width: uv.width, height: uv.height }
+        };
+        if (part.mesh) {
+          part.mesh = {
+            ...part.mesh,
+            uvs: remapMeshUvsToRect(this.requireBaseUvs(part.id), uv)
+          };
+        }
+      } else {
+        delete part.texture;
+        if (part.mesh) {
+          part.mesh = {
+            ...part.mesh,
+            uvs: this.requireBaseUvs(part.id).slice()
+          };
+        }
+      }
+    }
+  }
+  /**
+   * Clear a model-committed texture reference from a single part. Deliberately
+   * NON-undoable, matching {@link applyAtlas} — texture/atlas state is not in
+   * the undo model (unified editor-state is deferred). Does NOT push to or
+   * clear the undo/redo stacks. Does NOT touch `mesh.uvs` — atlas-space UVs on
+   * an untextured mesh are inert for color rendering; a later atlas import
+   * remaps from the base UVs anyway.
+   *
+   * This is the single consistent texture/atlas undo boundary: by the time a
+   * part is deletable (no texture), its DeletePart snapshot carries no texture
+   * reference, so no stale index can resurface on undo after a later atlas
+   * repack.
+   *
+   * Throws a path-qualified plain `Error` (NOT `IkiFormatError`) if the part
+   * id is unknown — same contract as {@link findPart}.
+   */
+  clearPartTextureRef(partId) {
+    const part = this.findPart(partId);
+    delete part.texture;
+  }
+  /**
+   * Validate the structural shape of an {@link ApplyAtlasInput} without
+   * touching the model, returning a known-good `{ texture?, assignmentsByPart }`
+   * for {@link applyAtlas} to resolve and apply.
+   */
+  normalizeAtlasInput(input) {
+    if (input.textures.length > 1) {
+      throw new Error(
+        `applyAtlas: textures must be a single atlas page (got ${input.textures.length})`
+      );
+    }
+    if (input.partTextureAssignments.length > 0 && input.textures.length !== 1) {
+      throw new Error(
+        "applyAtlas: partTextureAssignments require exactly one texture"
+      );
+    }
+    const assignmentsByPart = /* @__PURE__ */ new Map();
+    for (const { partId, uv } of input.partTextureAssignments) {
+      if (assignmentsByPart.has(partId)) {
+        throw new Error(
+          `applyAtlas: duplicate partId "${partId}" in partTextureAssignments`
+        );
+      }
+      assignmentsByPart.set(partId, uv);
+    }
+    return { texture: input.textures[0], assignmentsByPart };
+  }
+  /**
+   * Overwrite a part's whole transform with a fresh copy of `transform`.
+   * Replacing the whole object (rather than individual channels) preserves any
+   * optional keys already absent from the incoming value.
+   *
+   * Deliberately NON-undoable — used ONLY for an editor app's transient capture
+   * pose. Does NOT push to or clear undoStack/redoStack (sibling to
+   * {@link applyAtlas}'s non-undoable boundary). The caller is responsible for
+   * restoring the exact prior snapshot when the capture pose ends.
+   *
+   * `IkiTransform` is a flat number map, so a shallow spread is a sufficient
+   * deep copy — no aliasing of the caller's object remains.
+   */
+  setPartTransformEphemeral(partId, transform) {
+    const part = this.findPart(partId);
+    part.transform = { ...transform };
+  }
+  /**
+   * Overwrite a matrix deformer's optional transform with a fresh copy, or
+   * delete it when `transform` is `undefined`.
+   * `undefined` deletes the key, restoring the deformer to the same state as
+   * one that never had a transform (absent-vs-present matters for downstream
+   * renderers).
+   *
+   * Deliberately NON-undoable — used ONLY for an editor app's transient capture
+   * pose. Does NOT push to or clear undoStack/redoStack (sibling to
+   * {@link applyAtlas}'s non-undoable boundary). The caller is responsible for
+   * restoring the exact prior snapshot when the capture pose ends.
+   *
+   * `IkiDeformerTransform` is a flat number map, so a shallow spread is a
+   * sufficient deep copy — no aliasing of the caller's object remains.
+   */
+  setDeformerTransformEphemeral(deformerId, transform) {
+    const deformer = this.findMatrixDeformer(deformerId);
+    if (transform === void 0) {
+      delete deformer.transform;
+    } else {
+      deformer.transform = { ...transform };
+    }
+  }
+  /**
+   * Overwrite a part's whole bindings array with a fresh deep copy, or delete
+   * the key when `bindings` is empty.
+   *
+   * Deliberately NON-undoable — used ONLY for an editor app's transient capture
+   * neutralization (zeroing the row being recaptured so the preview reflects
+   * base-only during posing). Does NOT push to or clear undoStack/redoStack.
+   * The caller is responsible for restoring the original bindings when the
+   * capture session ends.
+   */
+  setPartBindingsEphemeral(partId, bindings) {
+    const part = this.findPart(partId);
+    if (bindings.length > 0) {
+      part.bindings = bindings.map((b) => ({ ...b }));
+    } else {
+      delete part.bindings;
+    }
+  }
+  /**
+   * Overwrite a matrix deformer's whole bindings array with a fresh deep copy,
+   * or delete the key when `bindings` is empty.
+   *
+   * Deliberately NON-undoable — used ONLY for an editor app's transient capture
+   * neutralization (zeroing the row being recaptured so the preview reflects
+   * base-only during posing). Does NOT push to or clear undoStack/redoStack.
+   * The caller is responsible for restoring the original bindings when the
+   * capture session ends.
+   */
+  setDeformerBindingsEphemeral(deformerId, bindings) {
+    const deformer = this.findMatrixDeformer(deformerId);
+    if (bindings.length > 0) {
+      deformer.bindings = bindings.map((b) => ({ ...b }));
+    } else {
+      delete deformer.bindings;
+    }
+  }
+  /** Apply a command and record it as one undo step. Clears the redo stack. */
+  execute(cmd) {
+    cmd.apply(this);
+    this.undoStack.push(cmd);
+    this.redoStack.length = 0;
+  }
+  /** Invert the most recent command and move it onto the redo stack. */
+  undo() {
+    const cmd = this.undoStack.pop();
+    if (!cmd) return;
+    cmd.invert(this);
+    this.redoStack.push(cmd);
+  }
+  /** Re-apply the most recently undone command and move it back onto undo. */
+  redo() {
+    const cmd = this.redoStack.pop();
+    if (!cmd) return;
+    cmd.apply(this);
+    this.undoStack.push(cmd);
+  }
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+  /**
+   * Validate and export the current working model by running it through
+   * {@link parseIkiModel}. Uses `structuredClone` so the validator's
+   * normalized output cannot alias the working model. Propagates
+   * `IkiFormatError` unchanged on failure — callers surface `.message`.
+   */
+  toIkiModel() {
+    return parseIkiModel(structuredClone(this.model));
+  }
+  /**
+   * Pretty-print the validated model as a `.iki` JSON string. Always
+   * validates first — invalid documents never reach a file.
+   */
+  serialize() {
+    return JSON.stringify(this.toIkiModel(), null, 2);
+  }
+};
+
+// src/commands.ts
+import {
+  IKI_FORMAT_VERSION,
+  IkiFormatError,
+  parseIkiModel as parseIkiModel2
+} from "@ikijs/format";
+
+// src/grid-keyform.ts
+function interpolateGridOffsets(keyforms, value) {
+  if (keyforms.length === 0) {
+    throw new Error("interpolateGridOffsets: keyforms must be non-empty");
+  }
+  if (value <= keyforms[0].value) {
+    return [...keyforms[0].offsets];
+  }
+  const last = keyforms[keyforms.length - 1];
+  if (value >= last.value) {
+    return [...last.offsets];
+  }
+  let lo = keyforms[0];
+  let hi = keyforms[1];
+  for (let k = 1; k < keyforms.length - 1; k++) {
+    if (keyforms[k].value <= value) {
+      lo = keyforms[k];
+      hi = keyforms[k + 1];
+    }
+  }
+  const t = (value - lo.value) / (hi.value - lo.value);
+  return lo.offsets.map((loOff, i) => loOff + (hi.offsets[i] - loOff) * t);
+}
+function computeGridOffsets(restPoints, restFrameDraggedPoints) {
+  if (restPoints.length !== restFrameDraggedPoints.length) {
+    throw new Error(
+      `computeGridOffsets: restFrameDraggedPoints length ${restFrameDraggedPoints.length} must equal restPoints length ${restPoints.length}`
+    );
+  }
+  if (restPoints.length % 2 !== 0) {
+    throw new Error(
+      `computeGridOffsets: restPoints length ${restPoints.length} must be even (x,y pairs)`
+    );
+  }
+  return restPoints.map((rest, i) => restFrameDraggedPoints[i] - rest);
+}
+function upsertGridKeyform(keyforms, value, offsets) {
+  const result = keyforms.map((kf) => ({
+    value: kf.value,
+    offsets: [...kf.offsets]
+  }));
+  const existing = result.findIndex((kf) => kf.value === value);
+  if (existing !== -1) {
+    result[existing] = { value, offsets: [...offsets] };
+    return result;
+  }
+  const insertAt = result.findIndex((kf) => kf.value > value);
+  const entry = { value, offsets: [...offsets] };
+  if (insertAt === -1) {
+    result.push(entry);
+  } else {
+    result.splice(insertAt, 0, entry);
+  }
+  return result;
+}
+
+// src/reparent.ts
+function kindOf(d) {
+  return d.kind === "warp" ? "warp" : "matrix";
+}
+function validateDeformerReparent(deformers, deformerId, newParentId) {
+  const target = deformers.find((d) => d.id === deformerId);
+  if (target === void 0) {
+    throw new Error(`deformers: no deformer with id "${deformerId}"`);
+  }
+  if (newParentId === void 0) return;
+  if (newParentId === deformerId) {
+    throw new Error(
+      `deformers."${deformerId}".parent "${newParentId}" is a self-reference`
+    );
+  }
+  const parent = deformers.find((d) => d.id === newParentId);
+  if (parent === void 0) {
+    throw new Error(
+      `deformers."${deformerId}".parent "${newParentId}" is not a declared deformer`
+    );
+  }
+  if (kindOf(parent) === "warp") {
+    throw new Error(
+      `deformers."${deformerId}".parent "${newParentId}" must be a matrix deformer (warp deformers cannot be parents)`
+    );
+  }
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const d of deformers) {
+    if (d.parent !== void 0) parentOf.set(d.id, d.parent);
+  }
+  parentOf.set(deformerId, newParentId);
+  const visited = /* @__PURE__ */ new Set();
+  let cur = deformerId;
+  while (cur !== void 0) {
+    if (visited.has(cur)) {
+      throw new Error(
+        `deformers: reparenting "${deformerId}" under "${newParentId}" would create a cycle`
+      );
+    }
+    visited.add(cur);
+    cur = parentOf.get(cur);
+  }
+}
+function validateDeformerDelete(deformers, parts, physicsChains, deformerId) {
+  const target = deformers.find((d) => d.id === deformerId);
+  if (target === void 0) {
+    throw new Error(`deformers: no deformer with id "${deformerId}"`);
+  }
+  const childDeformer = deformers.find((d) => d.parent === deformerId);
+  if (childDeformer !== void 0) {
+    throw new Error(
+      `deformers."${deformerId}": cannot delete \u2014 deformer "${childDeformer.id}" is parented to it; reparent or detach it first`
+    );
+  }
+  const attachedPart = parts.find((p) => p.deformer === deformerId);
+  if (attachedPart !== void 0) {
+    throw new Error(
+      `deformers."${deformerId}": cannot delete \u2014 part "${attachedPart.id}" is attached to it; detach it first`
+    );
+  }
+  const anchoredChain = physicsChains.find(
+    (c) => c.anchorDeformer === deformerId
+  );
+  if (anchoredChain !== void 0) {
+    throw new Error(
+      `deformers."${deformerId}": cannot delete \u2014 physics chain "${anchoredChain.id}" anchors to it; re-anchor or delete the chain first`
+    );
+  }
+}
+function validatePartAttach(deformers, partId, parts, newDeformerId) {
+  const part = parts.find((p) => p.id === partId);
+  if (part === void 0) {
+    throw new Error(`parts: no part with id "${partId}"`);
+  }
+  if (newDeformerId === void 0) return;
+  const deformer = deformers.find((d) => d.id === newDeformerId);
+  if (deformer === void 0) {
+    throw new Error(
+      `parts."${partId}".deformer "${newDeformerId}" is not a declared deformer`
+    );
+  }
+  if (kindOf(deformer) === "warp" && part.mesh === void 0) {
+    throw new Error(
+      `parts."${partId}".deformer "${newDeformerId}" is a warp deformer and requires a mesh`
+    );
+  }
+}
+
+// src/commands.ts
+function findIdCollision(model, id) {
+  for (const p of model.parts) {
+    if (p.id === id) return "part";
+  }
+  for (const d of model.deformers ?? []) {
+    if (d.id === id) return "deformer";
+  }
+  return void 0;
+}
+var FieldCommand = class {
+  constructor(partId, newValue, label, get, set) {
+    this.partId = partId;
+    this.newValue = newValue;
+    this.get = get;
+    this.set = set;
+    this.label = label;
+  }
+  partId;
+  newValue;
+  get;
+  set;
+  label;
+  captured = false;
+  prevValue;
+  apply(doc) {
+    const part = doc.findPart(this.partId);
+    if (!this.captured) {
+      this.prevValue = this.get(part);
+      this.captured = true;
+    }
+    this.set(part, this.newValue);
+  }
+  invert(doc) {
+    const part = doc.findPart(this.partId);
+    this.set(part, this.prevValue);
+  }
+};
+var SetPartColor = class extends FieldCommand {
+  constructor(partId, rgba) {
+    super(
+      partId,
+      [...rgba],
+      "Set color",
+      (part) => [...part.color],
+      (part, value) => {
+        part.color = [...value];
+      }
+    );
+  }
+};
+var SetPartWidth = class extends FieldCommand {
+  constructor(partId, value) {
+    super(
+      partId,
+      value,
+      "Set width",
+      (part) => part.width,
+      (part, v) => {
+        part.width = v;
+      }
+    );
+  }
+};
+var SetPartHeight = class extends FieldCommand {
+  constructor(partId, value) {
+    super(
+      partId,
+      value,
+      "Set height",
+      (part) => part.height,
+      (part, v) => {
+        part.height = v;
+      }
+    );
+  }
+};
+var SetPartOrder = class extends FieldCommand {
+  constructor(partId, value) {
+    super(
+      partId,
+      value,
+      "Set order",
+      (part) => part.order,
+      (part, v) => {
+        part.order = v;
+      }
+    );
+  }
+};
+var SetPartTransform = class extends FieldCommand {
+  constructor(partId, channel, value) {
+    super(
+      partId,
+      value,
+      "Set transform",
+      (part) => part.transform[channel],
+      (part, v) => {
+        if (v === void 0) {
+          delete part.transform[channel];
+        } else {
+          part.transform[channel] = v;
+        }
+      }
+    );
+  }
+};
+var CaptureGridKeyform = class {
+  constructor(deformerId, value, offsets) {
+    this.deformerId = deformerId;
+    this.value = value;
+    this.offsets = [...offsets];
+  }
+  deformerId;
+  value;
+  label = "Capture grid keyform";
+  offsets;
+  captured = false;
+  prevKeyforms;
+  apply(doc) {
+    const deformer = doc.findWarpDeformer(this.deformerId);
+    const warp = deformer.warps?.[0];
+    if (!warp) {
+      throw new Error(
+        `deformers."${this.deformerId}".warps: no grid warp to capture into`
+      );
+    }
+    if (this.offsets.length !== deformer.grid.points.length) {
+      throw new Error(
+        `deformers."${this.deformerId}".warps[0].keyforms.offsets length ${this.offsets.length} must equal grid.points length ${deformer.grid.points.length}`
+      );
+    }
+    const param = doc.getModel().parameters.find((p) => p.id === warp.parameter);
+    if (!param) {
+      throw new Error(
+        `deformers."${this.deformerId}".warps[0].parameter "${warp.parameter}" is not a declared parameter`
+      );
+    }
+    if (this.value < param.min || this.value > param.max) {
+      throw new Error(
+        `deformers."${this.deformerId}".warps[0].keyforms.value ${this.value} is outside parameter "${warp.parameter}" range [${param.min},${param.max}]`
+      );
+    }
+    if (!this.captured) {
+      this.prevKeyforms = structuredClone(warp.keyforms);
+      this.captured = true;
+    }
+    warp.keyforms = upsertGridKeyform(warp.keyforms, this.value, [
+      ...this.offsets
+    ]);
+  }
+  invert(doc) {
+    const warp = doc.findWarpDeformer(this.deformerId).warps?.[0];
+    if (!warp) {
+      throw new Error(
+        `deformers."${this.deformerId}".warps: no grid warp to restore into`
+      );
+    }
+    warp.keyforms = structuredClone(this.prevKeyforms);
+  }
+};
+var DeformerFieldCommand = class {
+  constructor(deformerId, newValue, label, get, set) {
+    this.deformerId = deformerId;
+    this.newValue = newValue;
+    this.get = get;
+    this.set = set;
+    this.label = label;
+  }
+  deformerId;
+  newValue;
+  get;
+  set;
+  label;
+  captured = false;
+  prevValue;
+  apply(doc) {
+    const deformer = doc.findMatrixDeformer(this.deformerId);
+    if (!this.captured) {
+      this.prevValue = this.get(deformer);
+      this.captured = true;
+    }
+    this.set(deformer, this.newValue);
+  }
+  invert(doc) {
+    const deformer = doc.findMatrixDeformer(this.deformerId);
+    this.set(deformer, this.prevValue);
+  }
+};
+var SetDeformerPivotX = class extends DeformerFieldCommand {
+  constructor(deformerId, value) {
+    super(
+      deformerId,
+      value,
+      "Set pivot x",
+      (d) => d.pivot.x,
+      (d, v) => {
+        d.pivot.x = v;
+      }
+    );
+  }
+};
+var SetDeformerPivotY = class extends DeformerFieldCommand {
+  constructor(deformerId, value) {
+    super(
+      deformerId,
+      value,
+      "Set pivot y",
+      (d) => d.pivot.y,
+      (d, v) => {
+        d.pivot.y = v;
+      }
+    );
+  }
+};
+var SetDeformerPivot = class {
+  constructor(deformerId, pivot) {
+    this.deformerId = deformerId;
+    this.pivot = { x: pivot.x, y: pivot.y };
+  }
+  deformerId;
+  label = "Set pivot";
+  captured = false;
+  prevPivot;
+  pivot;
+  apply(doc) {
+    const deformer = doc.findMatrixDeformer(this.deformerId);
+    if (!this.captured) {
+      this.prevPivot = { x: deformer.pivot.x, y: deformer.pivot.y };
+      this.captured = true;
+    }
+    deformer.pivot = { x: this.pivot.x, y: this.pivot.y };
+  }
+  invert(doc) {
+    const deformer = doc.findMatrixDeformer(this.deformerId);
+    deformer.pivot = { x: this.prevPivot.x, y: this.prevPivot.y };
+  }
+};
+var SetDeformerTransform = class {
+  constructor(deformerId, channel, value) {
+    this.deformerId = deformerId;
+    this.channel = channel;
+    this.value = value;
+  }
+  deformerId;
+  channel;
+  value;
+  label = "Set deformer transform";
+  captured = false;
+  prevTransform;
+  apply(doc) {
+    const deformer = doc.findMatrixDeformer(this.deformerId);
+    if (!this.captured) {
+      this.prevTransform = deformer.transform === void 0 ? void 0 : { ...deformer.transform };
+      this.captured = true;
+    }
+    const next = {
+      ...deformer.transform ?? { x: 0, y: 0 }
+    };
+    next[this.channel] = this.value;
+    deformer.transform = next;
+  }
+  invert(doc) {
+    const deformer = doc.findMatrixDeformer(this.deformerId);
+    if (this.prevTransform === void 0) {
+      delete deformer.transform;
+    } else {
+      deformer.transform = { ...this.prevTransform };
+    }
+  }
+};
+var SetDeformerBindings = class {
+  constructor(deformerId, bindings) {
+    this.deformerId = deformerId;
+    this.bindings = bindings.map((b) => ({ ...b }));
+  }
+  deformerId;
+  label = "Set deformer bindings";
+  bindings;
+  captured = false;
+  prevBindings;
+  apply(doc) {
+    const deformer = doc.findMatrixDeformer(this.deformerId);
+    const candidateDeformer = {
+      kind: "matrix",
+      id: "_d",
+      pivot: { x: 0, y: 0 }
+    };
+    if (this.bindings.length > 0) {
+      candidateDeformer.bindings = this.bindings.map((b) => ({ ...b }));
+    }
+    const candidate = {
+      version: IKI_FORMAT_VERSION,
+      name: "_",
+      canvas: { width: 1, height: 1 },
+      parameters: doc.getModel().parameters,
+      parts: [
+        {
+          id: "_",
+          color: [0, 0, 0, 1],
+          width: 1,
+          height: 1,
+          transform: { x: 0, y: 0 },
+          order: 0
+        }
+      ],
+      deformers: [candidateDeformer]
+    };
+    try {
+      parseIkiModel2(candidate);
+    } catch (e) {
+      if (e instanceof IkiFormatError) {
+        throw new IkiFormatError(
+          e.message.replace(
+            /^deformers\[0\]/,
+            `deformers."${this.deformerId}"`
+          )
+        );
+      }
+      throw e;
+    }
+    if (!this.captured) {
+      this.prevBindings = deformer.bindings === void 0 ? void 0 : deformer.bindings.map((b) => ({ ...b }));
+      this.captured = true;
+    }
+    if (this.bindings.length > 0) {
+      deformer.bindings = this.bindings.map((b) => ({ ...b }));
+    } else {
+      delete deformer.bindings;
+    }
+  }
+  invert(doc) {
+    const deformer = doc.findMatrixDeformer(this.deformerId);
+    if (this.prevBindings === void 0) {
+      delete deformer.bindings;
+    } else {
+      deformer.bindings = this.prevBindings.map((b) => ({ ...b }));
+    }
+  }
+};
+var SetDeformerParent = class {
+  constructor(deformerId, newParentId) {
+    this.deformerId = deformerId;
+    this.newParentId = newParentId;
+  }
+  deformerId;
+  newParentId;
+  label = "Set deformer parent";
+  captured = false;
+  prevParent = void 0;
+  prevHadParent = false;
+  apply(doc) {
+    validateDeformerReparent(
+      doc.getModel().deformers ?? [],
+      this.deformerId,
+      this.newParentId
+    );
+    const deformer = doc.findDeformer(this.deformerId);
+    if (!this.captured) {
+      this.prevHadParent = Object.prototype.hasOwnProperty.call(
+        deformer,
+        "parent"
+      );
+      this.prevParent = deformer.parent;
+      this.captured = true;
+    }
+    if (this.newParentId !== void 0) {
+      deformer.parent = this.newParentId;
+    } else {
+      delete deformer.parent;
+    }
+  }
+  invert(doc) {
+    const deformer = doc.findDeformer(this.deformerId);
+    if (this.prevHadParent) {
+      deformer.parent = this.prevParent;
+    } else {
+      delete deformer.parent;
+    }
+  }
+};
+var AddPart = class {
+  label = "Add part";
+  part;
+  captured = false;
+  prevBaseMeshUvs = void 0;
+  constructor(part) {
+    this.part = structuredClone(part);
+  }
+  apply(doc) {
+    const hit = findIdCollision(doc.getModel(), this.part.id);
+    if (hit === "part") {
+      throw new Error(
+        `parts: id "${this.part.id}" collides with an existing part id`
+      );
+    }
+    if (hit === "deformer") {
+      throw new Error(
+        `parts: id "${this.part.id}" collides with an existing deformer id`
+      );
+    }
+    const candidate = structuredClone(doc.getModel());
+    candidate.parts.push(structuredClone(this.part));
+    parseIkiModel2(candidate);
+    doc.getModel().parts.push(structuredClone(this.part));
+    const prev = doc.captureBaseMeshUvs(this.part.id);
+    if (!this.captured) {
+      this.prevBaseMeshUvs = prev;
+      this.captured = true;
+    }
+  }
+  invert(doc) {
+    const parts = doc.getModel().parts;
+    const i = parts.findIndex((p) => p.id === this.part.id);
+    if (i !== -1) parts.splice(i, 1);
+    doc.restoreBaseMeshUvs(this.part.id, this.prevBaseMeshUvs);
+  }
+};
+var AddDeformer = class {
+  label = "Add deformer";
+  deformer;
+  captured = false;
+  prevDeformersAbsent = false;
+  constructor(deformer) {
+    this.deformer = structuredClone(deformer);
+  }
+  apply(doc) {
+    const model = doc.getModel();
+    const hit = findIdCollision(model, this.deformer.id);
+    if (hit === "deformer") {
+      throw new Error(
+        `deformers: id "${this.deformer.id}" collides with an existing deformer id`
+      );
+    }
+    if (hit === "part") {
+      throw new Error(
+        `deformers: id "${this.deformer.id}" collides with an existing part id`
+      );
+    }
+    const candidate = structuredClone(model);
+    candidate.deformers = [
+      ...candidate.deformers ?? [],
+      structuredClone(this.deformer)
+    ];
+    parseIkiModel2(candidate);
+    if (!this.captured) {
+      this.prevDeformersAbsent = model.deformers === void 0;
+      this.captured = true;
+    }
+    if (model.deformers === void 0) {
+      model.deformers = [];
+    }
+    model.deformers.push(structuredClone(this.deformer));
+  }
+  invert(doc) {
+    const model = doc.getModel();
+    const arr = model.deformers;
+    if (!arr) return;
+    const i = arr.findIndex((d) => d.id === this.deformer.id);
+    if (i !== -1) arr.splice(i, 1);
+    if (this.prevDeformersAbsent && arr.length === 0) {
+      delete model.deformers;
+    }
+  }
+};
+var DeletePart = class {
+  constructor(partId) {
+    this.partId = partId;
+  }
+  partId;
+  label = "Delete part";
+  captured = false;
+  removed;
+  index;
+  apply(doc) {
+    const part = doc.findPart(this.partId);
+    if (part.texture !== void 0) {
+      throw new Error(
+        `parts."${this.partId}": cannot delete \u2014 part has a texture reference; clear its texture first`
+      );
+    }
+    const parts = doc.getModel().parts;
+    const masker = parts.find(
+      (p) => p.id !== this.partId && p.clip?.masks.includes(this.partId)
+    );
+    if (masker) {
+      throw new Error(
+        `parts."${this.partId}": cannot delete \u2014 used as a clip mask by part "${masker.id}"; remove its clip first`
+      );
+    }
+    const i = parts.indexOf(part);
+    if (!this.captured) {
+      this.removed = structuredClone(part);
+      this.index = i;
+      this.captured = true;
+    }
+    parts.splice(i, 1);
+  }
+  invert(doc) {
+    doc.getModel().parts.splice(this.index, 0, structuredClone(this.removed));
+  }
+};
+var DeleteDeformer = class {
+  constructor(deformerId) {
+    this.deformerId = deformerId;
+  }
+  deformerId;
+  label = "Delete deformer";
+  captured = false;
+  removed;
+  index;
+  apply(doc) {
+    const model = doc.getModel();
+    validateDeformerDelete(
+      model.deformers ?? [],
+      model.parts,
+      model.physicsChains ?? [],
+      this.deformerId
+    );
+    const arr = model.deformers;
+    const i = arr.findIndex((d) => d.id === this.deformerId);
+    if (!this.captured) {
+      this.removed = structuredClone(arr[i]);
+      this.index = i;
+      this.captured = true;
+    }
+    arr.splice(i, 1);
+  }
+  invert(doc) {
+    doc.getModel().deformers.splice(this.index, 0, structuredClone(this.removed));
+  }
+};
+var SetPartBindings = class {
+  constructor(partId, bindings) {
+    this.partId = partId;
+    this.bindings = bindings.map((b) => ({ ...b }));
+  }
+  partId;
+  label = "Set part bindings";
+  bindings;
+  captured = false;
+  prevBindings;
+  apply(doc) {
+    const candidatePart = {
+      id: "_",
+      color: [0, 0, 0, 1],
+      width: 1,
+      height: 1,
+      transform: { x: 0, y: 0 },
+      order: 0
+    };
+    if (this.bindings.length > 0) {
+      candidatePart.bindings = this.bindings.map((b) => ({ ...b }));
+    }
+    const candidate = {
+      version: IKI_FORMAT_VERSION,
+      name: "_",
+      canvas: { width: 1, height: 1 },
+      parameters: doc.getModel().parameters,
+      parts: [candidatePart]
+    };
+    try {
+      parseIkiModel2(candidate);
+    } catch (e) {
+      if (e instanceof IkiFormatError) {
+        throw new IkiFormatError(
+          e.message.replace(/^parts\[0\]/, `parts."${this.partId}"`)
+        );
+      }
+      throw e;
+    }
+    const part = doc.findPart(this.partId);
+    if (!this.captured) {
+      this.prevBindings = part.bindings === void 0 ? void 0 : part.bindings.map((b) => ({ ...b }));
+      this.captured = true;
+    }
+    if (this.bindings.length > 0) {
+      part.bindings = this.bindings.map((b) => ({ ...b }));
+    } else {
+      delete part.bindings;
+    }
+  }
+  invert(doc) {
+    const part = doc.findPart(this.partId);
+    if (this.prevBindings === void 0) {
+      delete part.bindings;
+    } else {
+      part.bindings = this.prevBindings.map((b) => ({ ...b }));
+    }
+  }
+};
+var SetPartDeformer = class {
+  constructor(partId, newDeformerId) {
+    this.partId = partId;
+    this.newDeformerId = newDeformerId;
+  }
+  partId;
+  newDeformerId;
+  label = "Set part deformer";
+  captured = false;
+  prevDeformer = void 0;
+  prevHadDeformer = false;
+  apply(doc) {
+    validatePartAttach(
+      doc.getModel().deformers ?? [],
+      this.partId,
+      doc.getModel().parts,
+      this.newDeformerId
+    );
+    const part = doc.findPart(this.partId);
+    if (!this.captured) {
+      this.prevHadDeformer = Object.prototype.hasOwnProperty.call(
+        part,
+        "deformer"
+      );
+      this.prevDeformer = part.deformer;
+      this.captured = true;
+    }
+    if (this.newDeformerId !== void 0) {
+      part.deformer = this.newDeformerId;
+    } else {
+      delete part.deformer;
+    }
+  }
+  invert(doc) {
+    const part = doc.findPart(this.partId);
+    if (this.prevHadDeformer) {
+      part.deformer = this.prevDeformer;
+    } else {
+      delete part.deformer;
+    }
+  }
+};
+function isWarpDeformer(model, deformerId) {
+  const d = (model.deformers ?? []).find((x) => x.id === deformerId);
+  return d?.kind === "warp";
+}
+var SetPartMesh = class {
+  constructor(partId, mesh) {
+    this.partId = partId;
+    this.mesh = mesh === void 0 ? void 0 : structuredClone(mesh);
+  }
+  partId;
+  label = "Set part mesh";
+  mesh;
+  captured = false;
+  prevHadMesh = false;
+  prevMesh;
+  prevBaseMeshUvs;
+  apply(doc) {
+    const part = doc.findPart(this.partId);
+    if (this.mesh !== void 0) {
+      const candidatePart = {
+        id: "_",
+        color: [0, 0, 0, 1],
+        width: 1,
+        height: 1,
+        transform: { x: 0, y: 0 },
+        order: 0,
+        mesh: structuredClone(this.mesh)
+      };
+      const candidate = {
+        version: IKI_FORMAT_VERSION,
+        name: "_",
+        canvas: { width: 1, height: 1 },
+        parameters: doc.getModel().parameters,
+        parts: [candidatePart]
+      };
+      try {
+        parseIkiModel2(candidate);
+      } catch (e) {
+        if (e instanceof IkiFormatError) {
+          throw new IkiFormatError(
+            e.message.replace(/^parts\[0\]/, `parts."${this.partId}"`)
+          );
+        }
+        throw e;
+      }
+    }
+    const attachedToWarp = part.deformer !== void 0 && isWarpDeformer(doc.getModel(), part.deformer);
+    if (this.mesh === void 0) {
+      if (part.warps !== void 0 || attachedToWarp) {
+        throw new IkiFormatError(
+          `parts."${this.partId}": cannot remove mesh \u2014 part has warps or is attached to a warp deformer; remove its warps / detach from the warp deformer first`
+        );
+      }
+      const masker = doc.getModel().parts.find(
+        (p) => p.id !== this.partId && p.clip?.masks.includes(this.partId)
+      );
+      if (masker) {
+        throw new IkiFormatError(
+          `parts."${this.partId}": cannot remove mesh \u2014 used as a clip mask by part "${masker.id}" (masks require a mesh); remove its clip first`
+        );
+      }
+    } else {
+      if ((part.warps?.length ?? 0) > 0) {
+        throw new IkiFormatError(
+          `parts."${this.partId}": cannot regenerate mesh \u2014 part has warps whose offsets are bound to the current rest mesh; remove its warps first`
+        );
+      }
+    }
+    if (!this.captured) {
+      this.prevHadMesh = part.mesh !== void 0;
+      this.prevMesh = part.mesh ? structuredClone(part.mesh) : void 0;
+      this.prevBaseMeshUvs = doc.captureBaseMeshUvs(this.partId);
+      this.captured = true;
+    }
+    if (this.mesh !== void 0) {
+      const storedUvs = part.texture !== void 0 ? remapMeshUvsToRect(this.mesh.uvs, part.texture.uv) : this.mesh.uvs.slice();
+      part.mesh = {
+        vertices: this.mesh.vertices.slice(),
+        uvs: storedUvs,
+        indices: this.mesh.indices.slice()
+      };
+    } else {
+      delete part.mesh;
+    }
+    if (this.mesh !== void 0) {
+      doc.restoreBaseMeshUvs(this.partId, this.mesh.uvs.slice());
+    } else {
+      doc.restoreBaseMeshUvs(this.partId, void 0);
+    }
+  }
+  invert(doc) {
+    const part = doc.findPart(this.partId);
+    if (this.prevHadMesh) {
+      if (this.prevBaseMeshUvs === void 0) {
+        throw new Error(
+          `parts."${this.partId}": cannot invert SetPartMesh \u2014 no base mesh uvs captured for a mesh part (broken side-table invariant)`
+        );
+      }
+      const restored = structuredClone(this.prevMesh);
+      restored.uvs = part.texture !== void 0 ? remapMeshUvsToRect(this.prevBaseMeshUvs, part.texture.uv) : this.prevBaseMeshUvs.slice();
+      part.mesh = restored;
+    } else {
+      delete part.mesh;
+    }
+    doc.restoreBaseMeshUvs(this.partId, this.prevBaseMeshUvs);
+  }
+};
+function validatePhysicsCandidate(doc, candidatePhysics) {
+  const candidatePart = {
+    id: "_",
+    color: [0, 0, 0, 1],
+    width: 1,
+    height: 1,
+    transform: { x: 0, y: 0 },
+    order: 0
+  };
+  const candidate = {
+    version: IKI_FORMAT_VERSION,
+    name: "_",
+    canvas: { width: 1, height: 1 },
+    parameters: doc.getModel().parameters,
+    parts: [candidatePart],
+    deformers: doc.getModel().deformers,
+    physics: candidatePhysics,
+    physicsChains: doc.getModel().physicsChains
+  };
+  try {
+    parseIkiModel2(candidate);
+  } catch (e) {
+    if (e instanceof IkiFormatError) {
+      const m = e.message.match(/^physics\[(\d+)\]/);
+      const rigId = m ? candidatePhysics[Number(m[1])]?.id : void 0;
+      if (rigId !== void 0) {
+        throw new IkiFormatError(
+          e.message.replace(/^physics\[\d+\]/, `physics."${rigId}"`)
+        );
+      }
+    }
+    throw e;
+  }
+}
+var AddPhysicsRig = class {
+  label = "Add physics rig";
+  rig;
+  captured = false;
+  prevPhysicsAbsent = false;
+  constructor(rig) {
+    this.rig = structuredClone(rig);
+  }
+  apply(doc) {
+    const model = doc.getModel();
+    if ((model.physics ?? []).some((r) => r.id === this.rig.id)) {
+      throw new Error(
+        `physics: id "${this.rig.id}" collides with an existing physics rig id`
+      );
+    }
+    validatePhysicsCandidate(doc, [
+      ...model.physics ?? [],
+      structuredClone(this.rig)
+    ]);
+    if (!this.captured) {
+      this.prevPhysicsAbsent = model.physics === void 0;
+      this.captured = true;
+    }
+    if (model.physics === void 0) {
+      model.physics = [];
+    }
+    model.physics.push(structuredClone(this.rig));
+  }
+  invert(doc) {
+    const model = doc.getModel();
+    const arr = model.physics;
+    if (!arr) return;
+    const i = arr.findIndex((r) => r.id === this.rig.id);
+    if (i !== -1) arr.splice(i, 1);
+    if (this.prevPhysicsAbsent && arr.length === 0) {
+      delete model.physics;
+    }
+  }
+};
+var DeletePhysicsRig = class {
+  constructor(rigId) {
+    this.rigId = rigId;
+  }
+  rigId;
+  label = "Delete physics rig";
+  captured = false;
+  removed;
+  index;
+  apply(doc) {
+    const rig = doc.findPhysicsRig(this.rigId);
+    const arr = doc.getModel().physics;
+    const i = arr.indexOf(rig);
+    if (!this.captured) {
+      this.removed = structuredClone(rig);
+      this.index = i;
+      this.captured = true;
+    }
+    arr.splice(i, 1);
+    if (arr.length === 0) {
+      delete doc.getModel().physics;
+    }
+  }
+  invert(doc) {
+    const model = doc.getModel();
+    (model.physics ??= []).splice(this.index, 0, structuredClone(this.removed));
+  }
+};
+var SetPhysicsRig = class {
+  constructor(rigId, rig) {
+    this.rigId = rigId;
+    this.rig = structuredClone(rig);
+  }
+  rigId;
+  label = "Set physics rig";
+  rig;
+  captured = false;
+  prevRig;
+  apply(doc) {
+    if (this.rig.id !== this.rigId) {
+      throw new Error(
+        `physics."${this.rigId}": cannot change rig id to "${this.rig.id}" (rename unsupported)`
+      );
+    }
+    const model = doc.getModel();
+    const i = (model.physics ?? []).findIndex((r) => r.id === this.rigId);
+    if (i === -1) {
+      throw new Error(`physics: no physics rig with id "${this.rigId}"`);
+    }
+    const candidate = model.physics.map(
+      (r, idx) => idx === i ? structuredClone(this.rig) : r
+    );
+    validatePhysicsCandidate(doc, candidate);
+    if (!this.captured) {
+      this.prevRig = structuredClone(model.physics[i]);
+      this.captured = true;
+    }
+    model.physics[i] = structuredClone(this.rig);
+  }
+  invert(doc) {
+    const arr = doc.getModel().physics;
+    if (!arr) return;
+    const i = arr.findIndex((r) => r.id === this.rigId);
+    if (i !== -1) arr[i] = structuredClone(this.prevRig);
+  }
+};
+
+// src/alpha-bbox.ts
+var ALPHA_BBOX_THRESHOLD = 8;
+function detectAlphaBbox(rgba, width, height) {
+  let minX = width;
+  let maxX = -1;
+  let minY = height;
+  let maxY = -1;
+  for (let y3 = 0; y3 < height; y3++) {
+    for (let x3 = 0; x3 < width; x3++) {
+      const alpha = rgba[(y3 * width + x3) * 4 + 3];
+      if (alpha >= ALPHA_BBOX_THRESHOLD) {
+        if (x3 < minX) minX = x3;
+        if (x3 > maxX) maxX = x3;
+        if (y3 < minY) minY = y3;
+        if (y3 > maxY) maxY = y3;
+      }
+    }
+  }
+  if (maxX === -1) return null;
+  const x = Math.max(0, minX - 1);
+  const y = Math.max(0, minY - 1);
+  const x2 = Math.min(width - 1, maxX + 1);
+  const y2 = Math.min(height - 1, maxY + 1);
+  return { x, y, w: x2 - x + 1, h: y2 - y + 1 };
+}
+
+// src/binding-capture.ts
+function captureBindingEndpoint(channel, restValue, posedValue) {
+  if (channel === "opacity") {
+    return restValue === 0 ? 0 : posedValue / restValue;
+  }
+  return posedValue - restValue;
+}
+
+// src/atlas.ts
+var ATLAS_PADDING = 2;
+var UV_INSET_PX = 0.5;
+function packAtlas(sources, padding = ATLAS_PADDING) {
+  for (const src of sources) {
+    if (!isFinite(src.width) || src.width <= 0) {
+      throw new Error(
+        `packAtlas: source "${src.id}" has invalid width ${src.width}`
+      );
+    }
+    if (!isFinite(src.height) || src.height <= 0) {
+      throw new Error(
+        `packAtlas: source "${src.id}" has invalid height ${src.height}`
+      );
+    }
+  }
+  if (sources.length === 0) {
+    return { pageWidth: 0, pageHeight: 0, placements: [], padding };
+  }
+  const sorted = sources.slice().sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const totalArea = sorted.reduce(
+    (sum, s) => sum + (s.width + padding) * (s.height + padding),
+    0
+  );
+  const targetWidth = Math.max(
+    Math.ceil(Math.sqrt(totalArea)),
+    // Ensure at least the widest single source fits.
+    Math.max(...sorted.map((s) => s.width + padding))
+  );
+  const placements = [];
+  let shelfX = 0;
+  let shelfY = 0;
+  let shelfHeight = 0;
+  for (const src of sorted) {
+    const paddedW = src.width + padding;
+    const paddedH = src.height + padding;
+    if (shelfX > 0 && shelfX + paddedW > targetWidth) {
+      shelfY += shelfHeight;
+      shelfX = 0;
+      shelfHeight = 0;
+    }
+    placements.push({
+      id: src.id,
+      x: shelfX,
+      y: shelfY,
+      width: src.width,
+      height: src.height
+    });
+    shelfX += paddedW;
+    if (paddedH > shelfHeight) shelfHeight = paddedH;
+  }
+  let pageWidth = 0;
+  let pageHeight = 0;
+  for (const p of placements) {
+    const right = p.x + p.width + padding;
+    const bottom = p.y + p.height + padding;
+    if (right > pageWidth) pageWidth = right;
+    if (bottom > pageHeight) pageHeight = bottom;
+  }
+  return { pageWidth, pageHeight, placements, padding };
+}
+function uvRectFor(placement, page, insetPx = UV_INSET_PX) {
+  const px = placement.x + insetPx;
+  const py = placement.y + insetPx;
+  const pw = placement.width - insetPx * 2;
+  const ph = placement.height - insetPx * 2;
+  const x = Math.max(0, px / page.width);
+  const y = Math.max(0, py / page.height);
+  const width = Math.min(1 - x, Math.max(0, pw / page.width));
+  const height = Math.min(1 - y, Math.max(0, ph / page.height));
+  return { x, y, width, height };
+}
+
+// src/factories.ts
+function generateUniqueId(model, base) {
+  const used = /* @__PURE__ */ new Set();
+  for (const p of model.parts) {
+    used.add(p.id);
+  }
+  for (const d of model.deformers ?? []) {
+    used.add(d.id);
+  }
+  if (!used.has(base)) return base;
+  let n = 2;
+  while (true) {
+    const candidate = `${base}_${n}`;
+    if (!used.has(candidate)) return candidate;
+    n++;
+  }
+}
+function generateRegularGridPoints(cols, rows, minX, maxX, minY, maxY) {
+  const pts = [];
+  for (let row = 0; row <= rows; row++) {
+    const t = row / rows;
+    const y = maxY - t * (maxY - minY);
+    for (let col = 0; col <= cols; col++) {
+      const s = col / cols;
+      const x = minX + s * (maxX - minX);
+      pts.push(x, y);
+    }
+  }
+  return pts;
+}
+function createDefaultPart(model) {
+  const order = model.parts.length ? Math.max(...model.parts.map((p) => p.order)) + 1 : 0;
+  return {
+    id: generateUniqueId(model, "part"),
+    color: [0.45, 0.6, 0.85, 1],
+    width: 150,
+    height: 150,
+    transform: { x: 0, y: 0 },
+    order
+  };
+}
+function createDefaultMatrixDeformer(model) {
+  return {
+    id: generateUniqueId(model, "deformer"),
+    pivot: { x: 0, y: 0 }
+  };
+}
+function createGridMesh(cols, rows) {
+  if (!Number.isInteger(cols) || cols < 1 || !Number.isInteger(rows) || rows < 1 || (cols + 1) * (rows + 1) > 65536) {
+    throw new Error(
+      "createGridMesh: cols and rows must be integers >= 1 with (cols+1)*(rows+1) <= 65536"
+    );
+  }
+  const colVerts = cols + 1;
+  const rowVerts = rows + 1;
+  const vertices = [];
+  const uvs = [];
+  for (let row = 0; row < rowVerts; row++) {
+    const t = row / rows;
+    const y = 0.5 - t;
+    const v = t;
+    for (let col = 0; col < colVerts; col++) {
+      const s = col / cols;
+      const x = -0.5 + s;
+      const u = s;
+      vertices.push(x, y);
+      uvs.push(u, v);
+    }
+  }
+  const indices = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      const tl = row * colVerts + col;
+      const tr = row * colVerts + col + 1;
+      const bl = (row + 1) * colVerts + col;
+      const br = (row + 1) * colVerts + col + 1;
+      indices.push(bl, br, tl);
+      indices.push(tl, br, tr);
+    }
+  }
+  return { vertices, uvs, indices };
+}
+function createDefaultWarpDeformer(model) {
+  const hx = model.canvas.width / 4;
+  const hy = model.canvas.height / 4;
+  return {
+    kind: "warp",
+    id: generateUniqueId(model, "warp"),
+    grid: {
+      cols: 4,
+      rows: 4,
+      points: generateRegularGridPoints(4, 4, -hx, hx, -hy, hy)
+    }
+  };
+}
+
+// src/auto-rig.ts
+import {
+  IKI_FORMAT_VERSION as IKI_FORMAT_VERSION2,
+  StandardParameter,
+  parseIkiModel as parseIkiModel3
+} from "@ikijs/format";
+var ROLE_TABLE = {
+  // hair_back stays rigid (silhouette behind the face); per-layer front/back
+  // depth parallax is a later slice.
+  hair_back: { deformer: "headDeformer", order: 0, mesh: false },
+  face: { deformer: "faceWarp", order: 10, mesh: true },
+  nose: { deformer: "faceWarp", order: 15, mesh: true },
+  blush_L: { deformer: "faceWarp", order: 20, mesh: true },
+  blush_R: { deformer: "faceWarp", order: 20, mesh: true },
+  mouth: { deformer: "faceWarp", order: 25, mesh: true },
+  eye_L: { deformer: "faceWarp", order: 30, mesh: true, eyeSide: "L" },
+  eye_R: { deformer: "faceWarp", order: 30, mesh: true, eyeSide: "R" },
+  iris_L: { deformer: "faceWarp", order: 31, mesh: true, eyeSide: "L" },
+  iris_R: { deformer: "faceWarp", order: 31, mesh: true, eyeSide: "R" },
+  pupil_L: { deformer: "faceWarp", order: 32, mesh: true, eyeSide: "L" },
+  pupil_R: { deformer: "faceWarp", order: 32, mesh: true, eyeSide: "R" },
+  highlight_L: { deformer: "faceWarp", order: 33, mesh: true, eyeSide: "L" },
+  highlight_R: { deformer: "faceWarp", order: 33, mesh: true, eyeSide: "R" },
+  // Upper lashes: an OPTIONAL separate layer ABOVE the iris that folds down to
+  // the closed-eye seam (the same crease the white folds to), covering the cut
+  // eyeball cleanly. When absent, the white's own fold is the only closed line.
+  lash_L: { deformer: "faceWarp", order: 34, mesh: true, eyeSide: "L" },
+  lash_R: { deformer: "faceWarp", order: 34, mesh: true, eyeSide: "R" },
+  brow_L: { deformer: "faceWarp", order: 40, mesh: true },
+  brow_R: { deformer: "faceWarp", order: 40, mesh: true },
+  // Front hair rides faceWarp (mesh) so it follows the head-turn curvature with
+  // the face instead of detaching as a rigid blob; its bbox joins the faceWarp
+  // grid union so the grid covers it.
+  hair_front: { deformer: "faceWarp", order: 50, mesh: true }
+};
+var REQUIRED_ROLES = ["face", "eye_L", "eye_R", "mouth"];
+var ALIAS_MAP = {
+  eyebrow_L: "brow_L",
+  eyebrow_R: "brow_R",
+  eye_white_L: "eye_L",
+  eye_white_R: "eye_R"
+};
+function normalizeRole(raw) {
+  const noExt = raw.replace(/\.[^.]+$/, "");
+  const collapsed = noExt.toLowerCase().replace(/[-\s]+/g, "_");
+  const sided = collapsed.replace(
+    /_([lr])$/,
+    (_, s) => `_${s.toUpperCase()}`
+  );
+  return ALIAS_MAP[sided] ?? sided;
+}
+function assertRoleSet(roles) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const role of roles) {
+    if (!(role in ROLE_TABLE)) {
+      throw new Error(`auto-rig: unknown role "${role}"`);
+    }
+    if (seen.has(role)) {
+      throw new Error(`auto-rig: duplicate role "${role}"`);
+    }
+    seen.add(role);
+  }
+  for (const required of REQUIRED_ROLES) {
+    if (!seen.has(required)) {
+      throw new Error(`auto-rig: missing required role "${required}"`);
+    }
+  }
+}
+function parseLayerRoles(fileNames) {
+  const pairs = fileNames.map((fileName) => {
+    const role = normalizeRole(fileName);
+    if (!(role in ROLE_TABLE)) {
+      throw new Error(
+        `auto-rig: unknown role "${role}" from file "${fileName}"`
+      );
+    }
+    return { role, fileName };
+  });
+  assertRoleSet(pairs.map((p) => p.role));
+  return pairs;
+}
+function bboxToTransform(bbox, canvasW, canvasH, partLabel) {
+  if (bbox.w <= 0 || bbox.h <= 0) {
+    throw new Error(`auto-rig: empty bbox for ${partLabel ?? "layer"}`);
+  }
+  const x = bbox.x + bbox.w / 2 - canvasW / 2;
+  const y = canvasH / 2 - (bbox.y + bbox.h / 2);
+  return { x, y };
+}
+function validateLayerInputs(layers, canvas) {
+  if (layers.length === 0) {
+    throw new Error("auto-rig: validateLayerInputs: layers must not be empty");
+  }
+  assertRoleSet(layers.map((l) => l.role));
+  for (const layer of layers) {
+    const { role, bbox, cropW, cropH, canvasW, canvasH } = layer;
+    if (bbox.w <= 0) {
+      throw new Error(
+        `auto-rig: validateLayerInputs: role "${role}" has non-positive bbox.w (${bbox.w})`
+      );
+    }
+    if (bbox.h <= 0) {
+      throw new Error(
+        `auto-rig: validateLayerInputs: role "${role}" has non-positive bbox.h (${bbox.h})`
+      );
+    }
+    if (cropW <= 0) {
+      throw new Error(
+        `auto-rig: validateLayerInputs: role "${role}" has non-positive cropW (${cropW})`
+      );
+    }
+    if (cropH <= 0) {
+      throw new Error(
+        `auto-rig: validateLayerInputs: role "${role}" has non-positive cropH (${cropH})`
+      );
+    }
+    if (canvasW !== canvas.width || canvasH !== canvas.height) {
+      throw new Error(
+        `auto-rig: validateLayerInputs: role "${role}" canvas size (${canvasW}\xD7${canvasH}) does not match canvas arg (${canvas.width}\xD7${canvas.height})`
+      );
+    }
+  }
+}
+function generateGridPoints(cols, rows, minX, maxX, minY, maxY) {
+  const pts = [];
+  for (let row = 0; row <= rows; row++) {
+    const t = row / rows;
+    const y = maxY - t * (maxY - minY);
+    for (let col = 0; col <= cols; col++) {
+      const s = col / cols;
+      const x = minX + s * (maxX - minX);
+      pts.push(x, y);
+    }
+  }
+  return pts;
+}
+function createPixelGridMesh(cols, rows, w, h) {
+  const colVerts = cols + 1;
+  const rowVerts = rows + 1;
+  const vertices = [];
+  const uvs = [];
+  for (let row = 0; row < rowVerts; row++) {
+    const t = row / rows;
+    const y = h / 2 - t * h;
+    const v = t;
+    for (let col = 0; col < colVerts; col++) {
+      const s = col / cols;
+      const x = -w / 2 + s * w;
+      const u = s;
+      vertices.push(x, y);
+      uvs.push(u, v);
+    }
+  }
+  const indices = [];
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      const tl = row * colVerts + col;
+      const tr = row * colVerts + col + 1;
+      const bl = (row + 1) * colVerts + col;
+      const br = (row + 1) * colVerts + col + 1;
+      indices.push(bl, br, tl);
+      indices.push(tl, br, tr);
+    }
+  }
+  return { vertices, uvs, indices };
+}
+function bakeHeadTurnGridWarpCentered(grid, parameter, centerX) {
+  const ANGLES = [-30, 0, 30];
+  const halfWidth = (grid.points[grid.cols * 2] - grid.points[0]) / 2;
+  const RADIUS = halfWidth * (0.6 / 0.5);
+  const pointCount = grid.points.length / 2;
+  const DEG_TO_RAD = Math.PI / 180;
+  const keyforms = ANGLES.map((angleDeg) => {
+    const theta = angleDeg * DEG_TO_RAD;
+    const offsets = [];
+    for (let i = 0; i < pointCount; i++) {
+      const x = grid.points[i * 2];
+      const localX = x - centerX;
+      const alpha = Math.asin(Math.max(-1, Math.min(1, localX / RADIUS)));
+      const xPrime = centerX + RADIUS * Math.sin(alpha + theta);
+      const dx = xPrime - x;
+      offsets.push(dx, 0);
+    }
+    return { value: angleDeg, offsets };
+  });
+  return { parameter, keyforms };
+}
+var EYE_STACK_PREFIXES = ["eye_", "iris_", "pupil_", "highlight_"];
+function bindingsForRole(spec, role, cropW, cropH) {
+  const isEyeStack = EYE_STACK_PREFIXES.some((p) => role.startsWith(p));
+  if (isEyeStack && spec.eyeSide !== void 0) {
+    const isGazeRole = role.startsWith("iris_") || role.startsWith("pupil_") || role.startsWith("highlight_");
+    if (!isGazeRole) return [];
+    const gx = Math.min(cropW * 0.18, 22);
+    const gy = Math.min(cropH * 0.18, 16);
+    return [
+      {
+        parameter: StandardParameter.EyeballX,
+        channel: "translateX",
+        from: -gx,
+        to: gx
+      },
+      {
+        parameter: StandardParameter.EyeballY,
+        channel: "translateY",
+        from: -gy,
+        to: gy
+      }
+    ];
+  }
+  if (role === "mouth") {
+    return [
+      // Mouth open: scaleY from 0 (closed, param=0) to 3 (wide open, param=1).
+      {
+        parameter: StandardParameter.MouthOpen,
+        channel: "scaleY",
+        from: 0,
+        to: 3
+      },
+      // Mouth form: scaleX from -0.2 (pursed, param=-1) to 0.4 (wide, param=1).
+      {
+        parameter: StandardParameter.MouthForm,
+        channel: "scaleX",
+        from: -0.2,
+        to: 0.4
+      }
+    ];
+  }
+  if (role === "brow_L" || role === "brow_R") {
+    const ty = Math.min(cropH * 0.8, 18);
+    const deg = 12;
+    if (role === "brow_L") {
+      return [
+        {
+          parameter: StandardParameter.BrowLeftY,
+          channel: "translateY",
+          from: -ty,
+          to: ty
+        },
+        {
+          parameter: StandardParameter.BrowLeftAngle,
+          channel: "rotate",
+          from: -deg,
+          to: deg
+        }
+      ];
+    } else {
+      return [
+        {
+          parameter: StandardParameter.BrowRightY,
+          channel: "translateY",
+          from: -ty,
+          to: ty
+        },
+        {
+          parameter: StandardParameter.BrowRightAngle,
+          channel: "rotate",
+          from: -deg,
+          to: deg
+        }
+      ];
+    }
+  }
+  if (role === "hair_front") {
+    return [
+      {
+        parameter: StandardParameter.HairSwayX,
+        channel: "rotate",
+        from: -8,
+        to: 8
+      },
+      {
+        parameter: StandardParameter.HairSwayX,
+        channel: "translateX",
+        from: -10,
+        to: 10
+      }
+    ];
+  }
+  return [];
+}
+var EYELID_FOLD_CREASE = 0.15;
+var EYELID_FOLD_K = 0.04;
+var LASH_FOLD_K = 0.2;
+function bakeEyelidFoldWarp(mesh, parameter, creaseOffsetY, k) {
+  const closed = [];
+  const zeros = [];
+  for (let i = 0; i < mesh.vertices.length; i += 2) {
+    const vy = mesh.vertices[i + 1];
+    closed.push(0, creaseOffsetY - (1 - k) * vy);
+    zeros.push(0, 0);
+  }
+  return {
+    parameter,
+    keyforms: [
+      { value: 0, offsets: closed },
+      { value: 1, offsets: zeros }
+    ]
+  };
+}
+function generateIkiFromLayerSet(layers, canvas) {
+  validateLayerInputs(layers, canvas);
+  const hasHair = layers.some((l) => l.role === "hair_front");
+  const parameters = [
+    {
+      id: StandardParameter.MouthOpen,
+      name: "Mouth Open",
+      min: 0,
+      max: 1,
+      default: 0
+    },
+    {
+      id: StandardParameter.MouthForm,
+      name: "Mouth Form",
+      min: -1,
+      max: 1,
+      default: 0
+    },
+    {
+      id: StandardParameter.EyeOpenLeft,
+      name: "Eye L",
+      min: 0,
+      max: 1,
+      default: 1
+    },
+    {
+      id: StandardParameter.EyeOpenRight,
+      name: "Eye R",
+      min: 0,
+      max: 1,
+      default: 1
+    },
+    {
+      id: StandardParameter.EyeballX,
+      name: "Gaze X",
+      min: -1,
+      max: 1,
+      default: 0
+    },
+    {
+      id: StandardParameter.EyeballY,
+      name: "Gaze Y",
+      min: -1,
+      max: 1,
+      default: 0
+    },
+    {
+      id: StandardParameter.AngleX,
+      name: "Head Angle",
+      min: -30,
+      max: 30,
+      default: 0
+    },
+    {
+      id: StandardParameter.Breath,
+      name: "Breath",
+      min: 0,
+      max: 1,
+      default: 0
+    },
+    {
+      id: StandardParameter.BrowLeftY,
+      name: "Brow L Y",
+      min: -1,
+      max: 1,
+      default: 0
+    },
+    {
+      id: StandardParameter.BrowRightY,
+      name: "Brow R Y",
+      min: -1,
+      max: 1,
+      default: 0
+    },
+    {
+      id: StandardParameter.BrowLeftAngle,
+      name: "Brow L Angle",
+      min: -1,
+      max: 1,
+      default: 0
+    },
+    {
+      id: StandardParameter.BrowRightAngle,
+      name: "Brow R Angle",
+      min: -1,
+      max: 1,
+      default: 0
+    }
+  ];
+  if (hasHair) {
+    parameters.push({
+      id: StandardParameter.HairSwayX,
+      name: "Hair Sway X",
+      min: -20,
+      max: 20,
+      default: 0
+    });
+  }
+  const faceLayers = layers.filter((l) => l.role === "face");
+  const faceLayer = faceLayers[0];
+  const faceTransform = bboxToTransform(
+    faceLayer.bbox,
+    faceLayer.canvasW,
+    faceLayer.canvasH,
+    "face"
+  );
+  const faceCenterX = faceTransform.x;
+  const faceCropH = faceLayer.cropH;
+  const faceWarpLayers = layers.filter(
+    (l) => ROLE_TABLE[l.role].deformer === "faceWarp"
+  );
+  let unionMinX = -canvas.width / 2;
+  let unionMaxX = canvas.width / 2;
+  let unionMinY = -canvas.height / 2;
+  let unionMaxY = canvas.height / 2;
+  if (faceWarpLayers.length > 0) {
+    const transforms = faceWarpLayers.map(
+      (l) => bboxToTransform(l.bbox, l.canvasW, l.canvasH, l.role)
+    );
+    unionMinX = Math.min(
+      ...transforms.map((t, i) => t.x - faceWarpLayers[i].cropW / 2)
+    );
+    unionMaxX = Math.max(
+      ...transforms.map((t, i) => t.x + faceWarpLayers[i].cropW / 2)
+    );
+    unionMinY = Math.min(
+      ...transforms.map((t, i) => t.y - faceWarpLayers[i].cropH / 2)
+    );
+    unionMaxY = Math.max(
+      ...transforms.map((t, i) => t.y + faceWarpLayers[i].cropH / 2)
+    );
+    const spanX = unionMaxX - unionMinX;
+    const spanY = unionMaxY - unionMinY;
+    const MARGIN = 0.12;
+    unionMinX -= spanX * MARGIN;
+    unionMaxX += spanX * MARGIN;
+    unionMinY -= spanY * MARGIN;
+    unionMaxY += spanY * MARGIN;
+  }
+  const halfW = Math.max(faceCenterX - unionMinX, unionMaxX - faceCenterX);
+  const faceGridMinX = faceCenterX - halfW;
+  const faceGridMaxX = faceCenterX + halfW;
+  const faceGrid = {
+    cols: 4,
+    rows: 4,
+    points: generateGridPoints(
+      4,
+      4,
+      faceGridMinX,
+      faceGridMaxX,
+      unionMinY,
+      unionMaxY
+    )
+  };
+  const faceBottom = faceTransform.y - faceCropH / 2;
+  const neckPivot = {
+    x: faceCenterX,
+    y: faceBottom - faceCropH * 0.15
+    // 15% below face bottom = neck
+  };
+  const faceWarpBake = bakeHeadTurnGridWarpCentered(
+    faceGrid,
+    StandardParameter.AngleX,
+    faceCenterX
+  );
+  const deformers = [
+    // headDeformer: rigid matrix rotating/translating the whole head about the
+    // neck pivot; bindings mirror sample-model.ts exactly.
+    {
+      id: "headDeformer",
+      pivot: neckPivot,
+      bindings: [
+        {
+          parameter: StandardParameter.AngleX,
+          channel: "rotate",
+          from: 6,
+          to: -6
+        },
+        {
+          parameter: StandardParameter.AngleX,
+          channel: "translateX",
+          from: -50,
+          to: 50
+        },
+        {
+          parameter: StandardParameter.Breath,
+          channel: "translateY",
+          from: 0,
+          to: -12
+        }
+      ]
+    },
+    // faceWarp: cylinder-bend warp parented to headDeformer; grid is symmetric
+    // about faceCenterX so the bake's cylinder axis aligns with the face center.
+    {
+      kind: "warp",
+      id: "faceWarp",
+      parent: "headDeformer",
+      grid: faceGrid,
+      warps: [faceWarpBake]
+    }
+  ];
+  const eyeCreaseBySide = {};
+  for (const layer of layers) {
+    const side = ROLE_TABLE[layer.role].eyeSide;
+    if ((layer.role === "eye_L" || layer.role === "eye_R") && side) {
+      const ey = bboxToTransform(
+        layer.bbox,
+        layer.canvasW,
+        layer.canvasH,
+        layer.role
+      ).y;
+      eyeCreaseBySide[side] = ey - EYELID_FOLD_CREASE * layer.cropH;
+    }
+  }
+  const parts = layers.map((layer) => {
+    const { role, bbox, cropW, cropH, canvasW, canvasH } = layer;
+    const spec = ROLE_TABLE[role];
+    const t = bboxToTransform(bbox, canvasW, canvasH, role);
+    const roleBindings = bindingsForRole(spec, role, cropW, cropH);
+    if (spec.mesh) {
+      const mesh = createPixelGridMesh(4, 4, cropW, cropH);
+      const part = {
+        id: role,
+        color: [1, 1, 1, 1],
+        width: 1,
+        height: 1,
+        order: spec.order,
+        transform: t,
+        deformer: spec.deformer,
+        mesh
+      };
+      if (roleBindings.length > 0) {
+        part.bindings = roleBindings;
+      }
+      if (spec.eyeSide !== void 0) {
+        const isLash = role.startsWith("lash_");
+        if (role.startsWith("eye_") || isLash) {
+          const openParam = spec.eyeSide === "L" ? StandardParameter.EyeOpenLeft : StandardParameter.EyeOpenRight;
+          const creaseWorldY = eyeCreaseBySide[spec.eyeSide] ?? t.y - EYELID_FOLD_CREASE * cropH;
+          part.warps = [
+            bakeEyelidFoldWarp(
+              mesh,
+              openParam,
+              creaseWorldY - t.y,
+              isLash ? LASH_FOLD_K : EYELID_FOLD_K
+            )
+          ];
+        } else {
+          part.clip = { masks: [`eye_${spec.eyeSide}`] };
+        }
+      }
+      return part;
+    } else {
+      return {
+        id: role,
+        color: [1, 1, 1, 1],
+        width: cropW,
+        height: cropH,
+        order: spec.order,
+        transform: t,
+        deformer: spec.deformer
+      };
+    }
+  });
+  const model = {
+    version: IKI_FORMAT_VERSION2,
+    name: "Auto-Rigged Model",
+    canvas: { width: canvas.width, height: canvas.height },
+    textures: [],
+    parameters,
+    deformers,
+    parts,
+    // Secondary motion: a spring lags AngleX onto HairSwayX so front hair sways
+    // behind the head turn (same constants as the hand-authored sample). Omitted
+    // when there is no front hair to drive.
+    physics: hasHair ? [
+      {
+        id: "hairSway",
+        input: { parameter: StandardParameter.AngleX, weight: 1 },
+        output: { parameter: StandardParameter.HairSwayX, scale: -10 },
+        mass: 1,
+        stiffness: 80,
+        damping: 10
+      }
+    ] : void 0
+  };
+  return parseIkiModel3(structuredClone(model));
+}
+export {
+  ALPHA_BBOX_THRESHOLD,
+  ATLAS_PADDING,
+  AddDeformer,
+  AddPart,
+  AddPhysicsRig,
+  CaptureGridKeyform,
+  DeleteDeformer,
+  DeletePart,
+  DeletePhysicsRig,
+  EditorDocument,
+  SetDeformerBindings,
+  SetDeformerParent,
+  SetDeformerPivot,
+  SetDeformerPivotX,
+  SetDeformerPivotY,
+  SetDeformerTransform,
+  SetPartBindings,
+  SetPartColor,
+  SetPartDeformer,
+  SetPartHeight,
+  SetPartMesh,
+  SetPartOrder,
+  SetPartTransform,
+  SetPartWidth,
+  SetPhysicsRig,
+  UV_INSET_PX,
+  captureBindingEndpoint,
+  computeGridOffsets,
+  createDefaultMatrixDeformer,
+  createDefaultPart,
+  createDefaultWarpDeformer,
+  createGridMesh,
+  detectAlphaBbox,
+  generateIkiFromLayerSet,
+  interpolateGridOffsets,
+  packAtlas,
+  parseLayerRoles,
+  upsertGridKeyform,
+  uvRectFor,
+  validateDeformerDelete,
+  validateDeformerReparent,
+  validatePartAttach
+};
+//# sourceMappingURL=index.mjs.map