@energy8platform/golem 0.6.0 → 0.7.0

package/dist/lib/e8-runtime.js

@@ -0,0 +1,2024 @@
+// src/e8/runtime.ts
+import { extensions } from "pixi.js";
+
+// src/e8/node.ts
+import { Assets, Container as Container2, ExtensionType, Ticker } from "pixi.js";
+import Schema from "schemastery";
+
+// src/rig-runtime.ts
+import { Container, Sprite, Mesh, MeshGeometry, MeshPlane, Texture, Matrix, Rectangle, Graphics } from "pixi.js";
+
+// src/rig-format.ts
+import { z } from "zod";
+
+// src/rig-deform.ts
+var DEFORM_BOUNDS = { bulge: 0.9, bend: 1, sway: 1, squash: 0.9 };
+var T = [0, 0.5, 1];
+var basis = (t) => [(1 - t) * (1 - 2 * t), 4 * t * (1 - t), t * (2 * t - 1)];
+function controlOffsets(params, w, h, pivot, out = new Float64Array(18)) {
+  out.fill(0);
+  const bulge = params.bulge ?? 0, bend = params.bend ?? 0, sway = params.sway ?? 0, squash = params.squash ?? 0;
+  for (let r = 0; r < 3; r++) for (let c = 0; c < 3; c++) {
+    const i = (r * 3 + c) * 2, u = T[c], v = T[r], mid = r === 1 ? 1 : 0;
+    out[i] = mid * (bulge * w * (u - 0.5) + bend * w) + sway * w * (v - pivot.y) + squash * w * (u - pivot.x) * 0.5 + 0;
+    out[i + 1] = -squash * h * (v - pivot.y) + 0;
+  }
+  for (const k in params) {
+    if (k.length !== 4 || k[0] !== "p") continue;
+    const r = +k[1], c = +k[2];
+    if (!(r >= 0 && r < 3 && c >= 0 && c < 3) || k[3] !== "x" && k[3] !== "y") continue;
+    out[(r * 3 + c) * 2 + (k[3] === "y" ? 1 : 0)] += params[k];
+  }
+  return out;
+}
+function evalPatch(offsets, u, v) {
+  const bu = basis(u), bv = basis(v);
+  let x = 0, y = 0;
+  for (let r = 0; r < 3; r++) for (let c = 0; c < 3; c++) {
+    const wgt = bv[r] * bu[c], i = (r * 3 + c) * 2;
+    x += wgt * offsets[i];
+    y += wgt * offsets[i + 1];
+  }
+  return [x, y];
+}
+function gridPositions(offsets, w, h, pivot, n, out = new Float32Array(2 * n * n)) {
+  const px = pivot.x * w, py = pivot.y * h;
+  for (let j = 0; j < n; j++) for (let i = 0; i < n; i++) {
+    const u = i / (n - 1), v = j / (n - 1), [ox, oy] = evalPatch(offsets, u, v), k = (j * n + i) * 2;
+    out[k] = u * w - px + ox;
+    out[k + 1] = v * h - py + oy;
+  }
+  return out;
+}
+
+// src/rig-format.ts
+var ID_RE = /^[a-z][a-z0-9_]*$/;
+var Id = z.string().regex(ID_RE, "snake_case id");
+var Ease = z.union([
+  z.enum(["linear", "step", "ease_in", "ease_out", "ease_in_out", "minimum_jerk", "back_out", "elastic_out"]),
+  // cubic-bezier control points, same semantics as CSS
+  z.object({ bezier: z.tuple([z.number(), z.number(), z.number(), z.number()]) })
+]);
+var Transform = z.object({
+  x: z.number().default(0),
+  y: z.number().default(0),
+  rotation: z.number().default(0),
+  scaleX: z.number().default(1),
+  scaleY: z.number().default(1),
+  shearX: z.number().default(0),
+  shearY: z.number().default(0)
+});
+var Color = z.string().regex(/^#[0-9a-fA-F]{8}$/, "color must be #rrggbbaa");
+var Blend = z.enum(["normal", "add", "multiply", "screen"]);
+var Inherit = z.enum(["normal", "onlyTranslation", "noRotationOrReflection", "noScale", "noScaleOrReflection"]);
+var Asset = z.object({
+  id: Id,
+  /** relative path inside the rig package, e.g. "layers/arm_l.png" */
+  src: z.string(),
+  /** original (untrimmed, unrotated) image size — the space attachments and uvs refer to */
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  /** packed region [x, y, w, h] inside `src` when `src` is an atlas (w/h as packed: trimmed, rotated) */
+  frame: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional(),
+  /** the packed region is stored rotated 90° clockwise */
+  rotate: z.union([z.literal(0), z.literal(90)]).default(0),
+  /** offset [x, y] of the packed (trimmed) region inside the original image */
+  trim: z.tuple([z.number(), z.number()]).optional(),
+  /** where this layer came from — provenance for agents */
+  origin: z.object({
+    sourceImage: z.string().optional(),
+    bboxSpace: z.enum(["source", "document"]).optional(),
+    /** bbox in source image: [x, y, w, h] */
+    bbox: z.tuple([z.number(), z.number(), z.number(), z.number()]).optional(),
+    inpainted: z.boolean().default(false),
+    prompt: z.string().optional()
+  }).optional()
+});
+var Bone = z.object({
+  id: Id,
+  parent: Id.optional(),
+  /** visual length for the editor gizmo and for chains (ik/path), no effect on child transforms */
+  length: z.number().nonnegative().default(0),
+  transform: Transform.default({}),
+  /** which parts of the parent's world transform this bone inherits */
+  inherit: Inherit.default("normal"),
+  /** semantic hint: "head", "arm_l", "torso"… drives auto-rig & presets */
+  role: z.string().optional(),
+  /** editor colour, no runtime effect */
+  color: z.string().optional()
+});
+var Slot = z.object({
+  id: Id,
+  bone: Id,
+  /** Closed path attachment used as a moving clipping mask. */
+  clip: Id.optional(),
+  /** active attachment id; undefined = hidden */
+  attachment: Id.optional(),
+  alpha: z.number().min(0).max(1).default(1),
+  /** draw order, higher = on top */
+  z: z.number().int().default(0),
+  /** blend mode: `add` for glows/fire on black, `multiply` for shadows */
+  blend: Blend.default("normal"),
+  /** tint, #rrggbbaa */
+  color: Color.default("#ffffffff")
+});
+var Influence = z.object({ bone: Id, x: z.number(), y: z.number(), w: z.number() });
+var VertexData = {
+  /** unweighted: [x, y, …] in the slot bone's local space */
+  vertices: z.array(z.number()).optional(),
+  /** weighted: one influence list per vertex */
+  weights: z.array(z.array(Influence).min(1)).optional()
+};
+var RegionAttachment = z.object({
+  id: Id,
+  slot: Id,
+  type: z.literal("region"),
+  asset: Id,
+  /** placement of the image centre in the slot bone's local space */
+  x: z.number().default(0),
+  y: z.number().default(0),
+  rotation: z.number().default(0),
+  scaleX: z.number().default(1),
+  scaleY: z.number().default(1),
+  /** drawn size; default: the asset size */
+  width: z.number().positive().optional(),
+  height: z.number().positive().optional()
+});
+var MeshAttachment = z.object({
+  id: Id,
+  slot: Id,
+  type: z.literal("mesh"),
+  asset: Id,
+  /** texture coordinates 0..1 in the asset's original image, 2 per vertex */
+  uvs: z.array(z.number()),
+  triangles: z.array(z.number().int().nonnegative()),
+  ...VertexData,
+  /** number of hull vertices (the outline is uvs[0..hull)) */
+  hull: z.number().int().nonnegative().default(0),
+  width: z.number().positive().optional(),
+  height: z.number().positive().optional()
+});
+var PathAttachment = z.object({
+  id: Id,
+  slot: Id,
+  type: z.literal("path"),
+  ...VertexData,
+  /** curve lengths for constant-speed positioning */
+  lengths: z.array(z.number()).default([]),
+  closed: z.boolean().default(false),
+  constantSpeed: z.boolean().default(true),
+  /** Spine-style active clipping span in the posed draw order; end slot is inclusive. */
+  clipping: z.object({ end: Id.optional() }).optional()
+});
+var Attachment = z.discriminatedUnion("type", [RegionAttachment, MeshAttachment, PathAttachment]);
+var IkConstraint = z.object({
+  id: Id,
+  order: z.number().int().default(0),
+  bones: z.array(Id).min(1),
+  target: Id,
+  iterations: z.number().int().min(1).max(1e3).optional(),
+  tolerance: z.number().positive().optional(),
+  mix: z.number().default(1),
+  softness: z.number().default(0),
+  bendPositive: z.boolean().default(true),
+  compress: z.boolean().default(false),
+  stretch: z.boolean().default(false),
+  uniform: z.boolean().default(false)
+});
+var TransformConstraint = z.object({
+  id: Id,
+  order: z.number().int().default(0),
+  bones: z.array(Id).min(1),
+  target: Id,
+  local: z.boolean().default(false),
+  relative: z.boolean().default(false),
+  rotation: z.number().default(0),
+  x: z.number().default(0),
+  y: z.number().default(0),
+  scaleX: z.number().default(0),
+  scaleY: z.number().default(0),
+  shearY: z.number().default(0),
+  mixRotate: z.number().default(1),
+  mixX: z.number().default(1),
+  mixY: z.number().default(1),
+  mixScaleX: z.number().default(1),
+  mixScaleY: z.number().default(1),
+  mixShearY: z.number().default(1)
+});
+var PathConstraint = z.object({
+  id: Id,
+  order: z.number().int().default(0),
+  bones: z.array(Id).min(1),
+  /** slot whose active attachment is a path */
+  target: Id,
+  positionMode: z.enum(["fixed", "percent"]).default("percent"),
+  spacingMode: z.enum(["length", "fixed", "percent", "proportional"]).default("length"),
+  rotateMode: z.enum(["tangent", "chain", "chainScale"]).default("tangent"),
+  rotation: z.number().default(0),
+  position: z.number().default(0),
+  spacing: z.number().default(0),
+  mixRotate: z.number().default(1),
+  mixX: z.number().default(1),
+  mixY: z.number().default(1)
+});
+var BoneProp = z.enum(["x", "y", "rotation", "scaleX", "scaleY", "shearX", "shearY"]);
+var SlotProp = z.enum(["alpha", "attachment", "z", "color"]);
+var DeformProp = z.string().regex(/^(bulge|bend|sway|squash|p[0-2][0-2][xy]|vertices)$/, "deform prop must be bulge|bend|sway|squash|p<row><col>x|y|vertices");
+var IkProp = z.enum(["mix", "softness", "bendPositive", "compress", "stretch"]);
+var TransformProp = z.enum(["mixRotate", "mixX", "mixY", "mixScaleX", "mixScaleY", "mixShearY", "x", "y", "rotation", "scaleX", "scaleY", "shearY"]);
+var PathProp = z.enum(["position", "spacing", "mixRotate", "mixX", "mixY"]);
+var KeyValue = z.union([z.number(), z.string(), z.null(), z.array(z.number()), z.array(z.string())]);
+var Key = z.object({
+  t: z.number().nonnegative(),
+  v: KeyValue,
+  /** easing INTO the next key */
+  ease: Ease.default("ease_in_out"),
+  /** Optional independent easing for numeric-array components (for example Spine RGBA curves). */
+  componentEase: z.array(Ease).min(1).optional()
+});
+var Interpolation = { interpolation: z.enum(["segment", "pchip"]).optional() };
+var Track = z.discriminatedUnion("target", [
+  z.object({ target: z.literal("control"), id: Id, prop: z.literal("value"), ...Interpolation, keys: z.array(Key).min(1) }),
+  z.object({ target: z.literal("bone"), id: Id, prop: BoneProp, ...Interpolation, keys: z.array(Key).min(1) }),
+  z.object({ target: z.literal("slot"), id: Id, prop: SlotProp, ...Interpolation, keys: z.array(Key).min(1) }),
+  z.object({ target: z.literal("deform"), id: Id, prop: DeformProp, ...Interpolation, keys: z.array(Key).min(1) }),
+  z.object({ target: z.literal("ik"), id: Id, prop: IkProp, ...Interpolation, keys: z.array(Key).min(1) }),
+  z.object({ target: z.literal("transform"), id: Id, prop: TransformProp, ...Interpolation, keys: z.array(Key).min(1) }),
+  z.object({ target: z.literal("path"), id: Id, prop: PathProp, ...Interpolation, keys: z.array(Key).min(1) }),
+  z.object({ target: z.literal("drawOrder"), id: Id.default("order"), prop: z.literal("order").default("order"), ...Interpolation, keys: z.array(Key).min(1) })
+]);
+var Event = z.object({
+  t: z.number().nonnegative(),
+  name: z.string(),
+  payload: z.record(z.unknown()).optional()
+});
+var Animation = z.object({
+  id: Id,
+  duration: z.number().positive(),
+  loop: z.boolean().default(false),
+  tracks: z.array(Track).default([]),
+  events: z.array(Event).default([]),
+  /** if generated from a preset — keep params so the agent can re-tune instead of re-keying */
+  preset: z.object({ name: z.string(), params: z.record(z.unknown()) }).optional()
+});
+var RigControl = z.object({
+  id: Id,
+  label: z.string().optional(),
+  min: z.number().finite(),
+  max: z.number().finite(),
+  default: z.number().finite()
+}).strict();
+var ControlValues = z.array(z.union([z.number().finite(), z.array(z.number().finite()).min(1)])).min(2);
+var ControlChannel = z.discriminatedUnion("target", [
+  z.object({ target: z.literal("bone"), id: Id, prop: BoneProp, values: ControlValues }).strict(),
+  z.object({ target: z.literal("slot"), id: Id, prop: z.literal("alpha"), values: ControlValues }).strict(),
+  z.object({ target: z.literal("deform"), id: Id, prop: z.literal("vertices"), values: ControlValues }).strict()
+]);
+var ControlBinding = z.object({
+  id: Id,
+  axes: z.array(z.object({ control: Id, keys: z.array(z.number().finite()).min(2).max(32) }).strict()).min(1).max(2),
+  /** Flattened grid, first axis varies fastest. Linear / bilinear interpolation. */
+  channels: z.array(ControlChannel).min(1)
+}).strict();
+var Reference = z.object({
+  src: z.string(),
+  opacity: z.number().min(0).max(1).default(0.5),
+  x: z.number().default(0),
+  y: z.number().default(0),
+  scale: z.number().positive().default(1)
+});
+var RigSchema = z.object({
+  format: z.literal("energy8.rig"),
+  version: z.literal(2),
+  meta: z.object({
+    name: z.string(),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    /** free-form notes for agents & humans: what this rig is, what's intentionally missing */
+    notes: z.string().optional(),
+    reference: Reference.optional()
+  }),
+  assets: z.array(Asset),
+  bones: z.array(Bone).min(1),
+  slots: z.array(Slot),
+  attachments: z.array(Attachment).default([]),
+  ik: z.array(IkConstraint).default([]),
+  transform: z.array(TransformConstraint).default([]),
+  path: z.array(PathConstraint).default([]),
+  animations: z.array(Animation),
+  controls: z.array(RigControl).optional(),
+  controlBindings: z.array(ControlBinding).optional()
+});
+var RigDocument = z.preprocess((input) => {
+  const v = input?.version;
+  return v === 0 || v === 1 ? migrateV1(input) : input;
+}, RigSchema);
+var DEG = Math.PI / 180;
+function migrateV1(input) {
+  const doc = input;
+  const assets = doc.assets ?? [], slots = doc.slots ?? [], anims = doc.animations ?? [];
+  const assetById = new Map(assets.map((a) => [a.id, a]));
+  const shows = /* @__PURE__ */ new Map();
+  const add = (slot, asset) => (shows.get(slot) ?? shows.set(slot, /* @__PURE__ */ new Set()).get(slot)).add(asset);
+  for (const s of slots) if (s.attachment) add(s.id, s.attachment);
+  for (const a of anims) for (const t of a.tracks ?? [])
+    if (t.target === "slot" && t.prop === "attachment") {
+      for (const k of t.keys ?? []) if (typeof k.v === "string") add(t.id, k.v);
+    }
+  const usage = /* @__PURE__ */ new Map();
+  for (const set of shows.values()) for (const asset of set) usage.set(asset, (usage.get(asset) ?? 0) + 1);
+  const attachmentId = (slot, asset) => (usage.get(asset) ?? 0) > 1 ? `${slot}_${asset}` : asset;
+  const attachments = [];
+  for (const s of slots) {
+    const pivot = s.pivot ?? { x: 0.5, y: 0.5 }, o = { x: 0, y: 0, rotation: 0, scaleX: 1, scaleY: 1, ...s.offset ?? {} };
+    for (const asset of shows.get(s.id) ?? []) {
+      const a = assetById.get(asset);
+      if (!a) continue;
+      const cx = (0.5 - pivot.x) * a.width, cy = (0.5 - pivot.y) * a.height;
+      const r = o.rotation * DEG, cos = Math.cos(r), sin = Math.sin(r);
+      const x = o.x + cos * o.scaleX * cx - sin * o.scaleY * cy, y = o.y + sin * o.scaleX * cx + cos * o.scaleY * cy;
+      attachments.push({ id: attachmentId(s.id, asset), slot: s.id, type: "region", asset, x: round(x), y: round(y), rotation: o.rotation, scaleX: o.scaleX, scaleY: o.scaleY });
+    }
+  }
+  const restAttachment = (slot) => {
+    const s = slots.find((x) => x.id === slot);
+    const first = s?.attachment ?? [...shows.get(slot) ?? []][0];
+    return first ? attachmentId(slot, first) : void 0;
+  };
+  const newSlots = slots.map((s) => {
+    const { pivot, offset, attachment, ...rest } = s;
+    return { ...rest, ...attachment ? { attachment: attachmentId(s.id, attachment) } : {} };
+  });
+  const newAnims = anims.map((a) => ({
+    ...a,
+    tracks: (a.tracks ?? []).flatMap((t) => {
+      if (t.target === "slot" && t.prop === "attachment")
+        return [{ ...t, keys: t.keys.map((k) => ({ ...k, v: typeof k.v === "string" ? attachmentId(t.id, k.v) : k.v })) }];
+      if (t.target === "deform") {
+        const id = restAttachment(t.id);
+        return id ? [{ ...t, id }] : [];
+      }
+      return [t];
+    })
+  }));
+  return { ...doc, version: 2, slots: newSlots, attachments: [...doc.attachments ?? [], ...attachments], animations: newAnims };
+}
+var round = (v) => Math.round(v * 1e6) / 1e6 + 0;
+var trackId = (t) => `${t.target}.${t.id}.${t.prop}`;
+function validate(doc) {
+  const errs = [];
+  const dup = (xs, kind) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (const x of xs) {
+      if (seen.has(x.id)) errs.push(`${kind}: duplicate id "${x.id}"`);
+      seen.add(x.id);
+    }
+  };
+  dup(doc.assets, "asset");
+  dup(doc.bones, "bone");
+  dup(doc.slots, "slot");
+  dup(doc.attachments, "attachment");
+  dup(doc.animations, "animation");
+  dup(doc.ik, "ik");
+  dup(doc.transform, "transform");
+  dup(doc.path, "path");
+  dup(doc.controls ?? [], "control");
+  dup(doc.controlBindings ?? [], "control binding");
+  const bones = new Set(doc.bones.map((b) => b.id));
+  const assets = new Map(doc.assets.map((a) => [a.id, a]));
+  const slots = new Set(doc.slots.map((s) => s.id));
+  const attachments = new Map(doc.attachments.map((a) => [a.id, a]));
+  const iks = new Set(doc.ik.map((c) => c.id)), transforms = new Set(doc.transform.map((c) => c.id)), paths = new Set(doc.path.map((c) => c.id));
+  for (const b of doc.bones) {
+    if (b.parent && !bones.has(b.parent)) errs.push(`bone "${b.id}": unknown parent "${b.parent}"`);
+  }
+  for (const b of doc.bones) {
+    const seen = /* @__PURE__ */ new Set();
+    let cur = b;
+    while (cur?.parent) {
+      if (seen.has(cur.id)) {
+        errs.push(`bone "${b.id}": parent cycle`);
+        break;
+      }
+      seen.add(cur.id);
+      cur = doc.bones.find((x) => x.id === cur.parent);
+    }
+  }
+  if (!doc.bones.some((b) => !b.parent)) errs.push("no root bone");
+  for (const a of doc.assets) {
+    if (a.frame && (a.frame[2] <= 0 || a.frame[3] <= 0)) errs.push(`asset "${a.id}": frame must have positive size`);
+    if (a.frame && !a.trim && !a.rotate && (a.frame[2] !== a.width || a.frame[3] !== a.height)) errs.push(`asset "${a.id}": frame size must equal width\xD7height (or declare trim/rotate)`);
+  }
+  for (const s of doc.slots) {
+    if (s.clip) {
+      const mask = attachments.get(s.clip);
+      if (mask?.type !== "path" || !mask.closed) errs.push(`slot "${s.id}": clip must name a closed path attachment`);
+    }
+    if (!bones.has(s.bone)) errs.push(`slot "${s.id}": unknown bone "${s.bone}"`);
+    if (s.attachment) {
+      const a = attachments.get(s.attachment);
+      if (!a) errs.push(`slot "${s.id}": unknown attachment "${s.attachment}"`);
+      else if (a.slot !== s.id) errs.push(`slot "${s.id}": attachment "${s.attachment}" belongs to slot "${a.slot}"`);
+    }
+  }
+  for (const a of doc.attachments) if (a.type === "path" && a.clipping) {
+    if (!a.closed) errs.push(`attachment "${a.id}": clipping path must be closed`);
+    if (a.clipping.end && !slots.has(a.clipping.end)) errs.push(`attachment "${a.id}": unknown clipping end slot "${a.clipping.end}"`);
+  }
+  const vertexCount = (a) => {
+    if (a.type === "region") return 4;
+    if (a.type === "mesh") return a.uvs.length / 2;
+    return a.vertices ? a.vertices.length / 2 : a.weights?.length ?? 0;
+  };
+  for (const a of doc.attachments) {
+    if (!slots.has(a.slot)) errs.push(`attachment "${a.id}": unknown slot "${a.slot}"`);
+    if (a.type !== "path" && !assets.has(a.asset)) errs.push(`attachment "${a.id}": unknown asset "${a.asset}"`);
+    if (a.type === "mesh" || a.type === "path") {
+      const n = a.type === "mesh" ? a.uvs.length / 2 : vertexCount(a);
+      if (a.type === "mesh") {
+        if (a.uvs.length % 2 || n < 3) errs.push(`attachment "${a.id}": uvs must have 2 numbers per vertex, at least 3 vertices`);
+        if (a.triangles.length % 3) errs.push(`attachment "${a.id}": triangles must have 3 indices each`);
+        for (const i of a.triangles) if (i >= n) errs.push(`attachment "${a.id}": triangle index ${i} out of range (${n} vertices)`);
+      }
+      if ((a.vertices ? 1 : 0) + (a.weights ? 1 : 0) !== 1) errs.push(`attachment "${a.id}": exactly one of vertices / weights`);
+      if (a.vertices && a.vertices.length !== 2 * n) errs.push(`attachment "${a.id}": vertices must have 2 numbers per vertex (${2 * n}, got ${a.vertices.length})`);
+      if (a.weights) {
+        if (a.weights.length !== n) errs.push(`attachment "${a.id}": weights must have one influence list per vertex (${n}, got ${a.weights.length})`);
+        for (const list of a.weights) for (const inf of list) if (!bones.has(inf.bone)) errs.push(`attachment "${a.id}": weights reference unknown bone "${inf.bone}"`);
+      }
+    }
+  }
+  for (const c of doc.ik) {
+    for (let i = 1; i < c.bones.length; i++) if (doc.bones.find((b) => b.id === c.bones[i])?.parent !== c.bones[i - 1])
+      errs.push(`ik "${c.id}": bones must form a contiguous parent-to-child chain`);
+    for (const b of c.bones) if (!bones.has(b)) errs.push(`ik "${c.id}": unknown bone "${b}"`);
+    if (!bones.has(c.target)) errs.push(`ik "${c.id}": unknown target bone "${c.target}"`);
+  }
+  for (const c of doc.transform) {
+    for (const b of c.bones) if (!bones.has(b)) errs.push(`transform "${c.id}": unknown bone "${b}"`);
+    if (!bones.has(c.target)) errs.push(`transform "${c.id}": unknown target bone "${c.target}"`);
+  }
+  for (const c of doc.path) {
+    for (const b of c.bones) if (!bones.has(b)) errs.push(`path "${c.id}": unknown bone "${b}"`);
+    if (!slots.has(c.target)) errs.push(`path "${c.id}": unknown target slot "${c.target}"`);
+  }
+  const controls = new Map((doc.controls ?? []).map((c) => [c.id, c]));
+  const driven = /* @__PURE__ */ new Set();
+  for (const c of controls.values()) if (!(c.min < c.max && c.default >= c.min && c.default <= c.max))
+    errs.push(`control "${c.id}": require min < max and default within range`);
+  for (const b of doc.controlBindings ?? []) {
+    const prefix = `control binding "${b.id}"`;
+    if (new Set(b.axes.map((a) => a.control)).size !== b.axes.length) errs.push(`${prefix}: axes must use different controls`);
+    for (const axis of b.axes) {
+      const c = controls.get(axis.control);
+      if (!c) errs.push(`${prefix}: unknown control "${axis.control}"`);
+      else if (axis.keys[0] !== c.min || axis.keys.at(-1) !== c.max) errs.push(`${prefix}: keys must span the control's full range`);
+      if (axis.keys.some((v, i) => i > 0 && v <= axis.keys[i - 1])) errs.push(`${prefix}: keys must be strictly increasing`);
+    }
+    const count = b.axes.reduce((n, a) => n * a.keys.length, 1);
+    for (const ch of b.channels) {
+      const key = `${ch.target}.${ch.id}.${ch.prop}`;
+      if (driven.has(key)) errs.push(`${prefix}: channel ${key} already owned by a binding`);
+      driven.add(key);
+      if (ch.values.length !== count) errs.push(`${prefix}: ${key} needs ${count} grid values`);
+      if (ch.target === "deform") {
+        const att = attachments.get(ch.id);
+        if (!att || att.type === "region") errs.push(`${prefix}: vertices need a mesh or path attachment`);
+        else {
+          const n = att.weights ? att.weights.reduce((s, a) => s + a.length * 2, 0) : att.vertices.length;
+          if (ch.values.some((v) => !Array.isArray(v) || v.length !== n)) errs.push(`${prefix}: ${key} needs arrays of ${n} offsets`);
+        }
+      } else {
+        if (!(ch.target === "bone" ? bones : slots).has(ch.id)) errs.push(`${prefix}: unknown ${ch.target} "${ch.id}"`);
+        if (ch.values.some((v) => typeof v !== "number")) errs.push(`${prefix}: ${key} needs numeric values`);
+        if (ch.target === "slot" && ch.values.some((v) => typeof v === "number" && (v < 0 || v > 1))) errs.push(`${prefix}: alpha must be in 0..1`);
+      }
+    }
+  }
+  for (const a of doc.animations) {
+    const tracks = /* @__PURE__ */ new Set();
+    for (const t of a.tracks) {
+      const tid = trackId(t);
+      if (tracks.has(tid)) errs.push(`animation "${a.id}": duplicate track ${tid}`);
+      tracks.add(tid);
+      if (driven.has(tid)) errs.push(`animation "${a.id}": ${tid} is controlled by a binding; animate its control instead`);
+      const known = t.target === "bone" ? bones.has(t.id) : t.target === "slot" ? slots.has(t.id) : t.target === "deform" ? attachments.has(t.id) : t.target === "ik" ? iks.has(t.id) : t.target === "transform" ? transforms.has(t.id) : t.target === "path" ? paths.has(t.id) : t.target === "control" ? controls.has(t.id) : true;
+      if (!known) errs.push(`animation "${a.id}": unknown ${t.target} "${t.id}"`);
+      const bound = t.target === "deform" ? DEFORM_BOUNDS[t.prop] : void 0;
+      const att = t.target === "deform" ? attachments.get(t.id) : void 0;
+      let prev = -1;
+      for (const k of t.keys) {
+        if (k.componentEase && (!Array.isArray(k.v) || !k.v.every((v) => typeof v === "number") || k.componentEase.length !== k.v.length)) errs.push(`animation "${a.id}" ${tid}: componentEase must match the numeric-array value length`);
+        if (k.t <= prev && prev >= 0) errs.push(`animation "${a.id}" ${tid}: keys not strictly increasing`);
+        if (k.t > a.duration) errs.push(`animation "${a.id}" ${tid}: key at ${k.t}s exceeds duration`);
+        if (t.target === "control") {
+          const c = controls.get(t.id);
+          if (typeof k.v !== "number" || !Number.isFinite(k.v) || c && (k.v < c.min || k.v > c.max)) errs.push(`animation "${a.id}" ${tid}: control key outside its finite range`);
+        }
+        if (t.target === "slot" && t.prop === "attachment") {
+          if (k.v !== null && typeof k.v !== "string") errs.push(`animation "${a.id}" ${tid}: attachment key must be an attachment id or null`);
+          else if (typeof k.v === "string") {
+            const target = attachments.get(k.v);
+            if (!target) errs.push(`animation "${a.id}": unknown attachment "${k.v}"`);
+            else if (target.slot !== t.id) errs.push(`animation "${a.id}" ${tid}: attachment "${k.v}" belongs to slot "${target.slot}"`);
+          }
+        } else if (t.target === "slot" && t.prop === "color") {
+          const ok = Array.isArray(k.v) && k.v.length === 4 && k.v.every((c) => typeof c === "number" && c >= 0 && c <= 1);
+          if (!ok) errs.push(`animation "${a.id}" ${tid}: color key must be [r, g, b, a] in 0..1`);
+        } else if (t.target === "drawOrder") {
+          const order = Array.isArray(k.v) ? k.v : [];
+          const ok = order.length === doc.slots.length && new Set(order).size === order.length && order.every((s) => typeof s === "string" && slots.has(s));
+          if (!ok) errs.push(`animation "${a.id}" drawOrder key at ${k.t}s must list every slot exactly once`);
+        } else if (t.target === "deform" && t.prop === "vertices") {
+          if (!Array.isArray(k.v) || !k.v.every((v) => typeof v === "number")) errs.push(`animation "${a.id}" ${tid}: vertices key must be a number array`);
+          else if (att && att.type !== "region") {
+            const expected = att.weights ? 2 * att.weights.reduce((s, list) => s + list.length, 0) : 2 * vertexCount(att);
+            if (k.v.length !== expected) errs.push(`animation "${a.id}" ${tid}: vertices key needs ${expected} numbers, got ${k.v.length}`);
+          } else if (att) errs.push(`animation "${a.id}" ${tid}: vertices deform needs a mesh or path attachment`);
+        } else if (typeof k.v !== "number") errs.push(`animation "${a.id}" ${tid}: key must be a number`);
+        else if (bound !== void 0 && Math.abs(k.v) > bound) errs.push(`animation "${a.id}" ${tid}: value ${k.v} out of range [-${bound}, ${bound}]`);
+        prev = k.t;
+      }
+    }
+    for (const e of a.events) {
+      if (e.t > a.duration) errs.push(`animation "${a.id}": event "${e.name}" exceeds duration`);
+    }
+  }
+  return errs;
+}
+function parse(input) {
+  const doc = RigDocument.parse(input);
+  const errs = validate(doc);
+  if (errs.length) throw new Error("rig validation failed:\n" + errs.join("\n"));
+  return doc;
+}
+
+// src/rig-controls.ts
+function controlPose(doc, values) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [id, value] of Object.entries(values)) {
+    const c = doc.controls?.find((c2) => c2.id === id);
+    if (!c) throw new Error(`unknown control "${id}"`);
+    if (!Number.isFinite(value)) throw new Error(`control "${id}" must be finite`);
+    out.set(`control:${id}:value`, Math.max(c.min, Math.min(c.max, value)));
+  }
+  return out;
+}
+function bracket(keys, value) {
+  let i = 0;
+  while (i < keys.length - 2 && value > keys[i + 1]) i++;
+  return [i, Math.max(0, Math.min(1, (value - keys[i]) / (keys[i + 1] - keys[i])))];
+}
+function sampleBinding(binding, values) {
+  const [x, u] = bracket(binding.axes[0].keys, values[0]);
+  const [y, v] = binding.axes[1] ? bracket(binding.axes[1].keys, values[1]) : [0, 0];
+  const width = binding.axes[0].keys.length, a = y * width + x;
+  const mix = (a2, b, u2) => a2 + (b - a2) * u2;
+  return binding.channels.map((ch) => {
+    const read = (i, j) => j === void 0 ? ch.values[i] : ch.values[i][j];
+    const at = (j) => {
+      const top = mix(read(a, j), read(a + 1, j), u);
+      return binding.axes[1] ? mix(top, mix(read(a + width, j), read(a + width + 1, j), u), v) : top;
+    };
+    return Array.isArray(ch.values[0]) ? ch.values[0].map((_, j) => at(j)) : at();
+  });
+}
+function resolveControls(doc, input) {
+  if (!doc.controlBindings?.length) return input;
+  const out = new Map(input), controls = new Map(doc.controls?.map((c) => [c.id, c]));
+  for (const b of doc.controlBindings) {
+    const values = b.axes.map((axis) => {
+      const c = controls.get(axis.control);
+      const value = input.get(`control:${c.id}:value`) ?? c.default;
+      if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`control "${c.id}" must be finite`);
+      return Math.max(c.min, Math.min(c.max, value));
+    });
+    const sampled = sampleBinding(b, values);
+    b.channels.forEach((ch, i) => out.set(`${ch.target}:${ch.id}:${ch.prop}`, sampled[i]));
+  }
+  return out;
+}
+
+// src/rig-anim.ts
+var DEG2 = Math.PI / 180;
+var named = {
+  linear: (t) => t,
+  step: () => 0,
+  ease_in: (t) => t * t,
+  ease_out: (t) => 1 - (1 - t) * (1 - t),
+  ease_in_out: (t) => t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2,
+  minimum_jerk: (t) => t * t * t * (10 + t * (-15 + 6 * t)),
+  back_out: (t) => 1 + 2.70158 * (t - 1) ** 3 + 1.70158 * (t - 1) ** 2,
+  elastic_out: (t) => t === 0 ? 0 : t === 1 ? 1 : 2 ** (-10 * t) * Math.sin((t * 10 - 0.75) * (2 * Math.PI / 3)) + 1
+};
+var BEZIER_SEGMENTS = 10;
+function bezier(x1, y1, x2, y2) {
+  const px = [0], py = [0];
+  for (let i = 1; i <= BEZIER_SEGMENTS; i++) {
+    const t = i / BEZIER_SEGMENTS, u = 1 - t;
+    px.push(3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t);
+    py.push(3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t);
+  }
+  return (x) => {
+    if (x <= 0) return 0;
+    for (let i = 1; i <= BEZIER_SEGMENTS; i++) {
+      if (px[i] >= x) {
+        const span = px[i] - px[i - 1];
+        return py[i - 1] + (span > 0 ? (x - px[i - 1]) / span * (py[i] - py[i - 1]) : 0);
+      }
+    }
+    return 1;
+  };
+}
+var easeCache = /* @__PURE__ */ new Map();
+function ease(spec) {
+  if (typeof spec === "string") return named[spec];
+  const key = spec.bezier.join(",");
+  let f = easeCache.get(key);
+  if (!f) easeCache.set(key, f = bezier(...spec.bezier));
+  return f;
+}
+var pk = (target, id, prop) => `${target}:${id}:${prop}`;
+function smoothValue(track, i, t, component, loop) {
+  const k = track.keys, n = k.length;
+  const v = (j) => component === void 0 ? k[j].v : k[j].v[component];
+  const h = (j) => k[j + 1].t - k[j].t;
+  const d = (j) => (v(j + 1) - v(j)) / h(j);
+  const harmonic = (a, b, h0, h1) => a * b <= 0 ? 0 : 3 * (h0 + h1) / ((2 * h1 + h0) / a + (h1 + 2 * h0) / b);
+  const tangent = (j) => {
+    if (j === 0 || j === n - 1) {
+      if (loop && n > 2 && v(0) === v(n - 1) && k[0].ease !== "step" && k[n - 2].ease !== "step")
+        return harmonic(d(n - 2), d(0), h(n - 2), h(0));
+      return 0;
+    }
+    if (k[j - 1].ease === "step" || k[j].ease === "step") return 0;
+    return harmonic(d(j - 1), d(j), h(j - 1), h(j));
+  };
+  const u = (t - k[i].t) / h(i), u2 = u * u, u3 = u2 * u;
+  return (2 * u3 - 3 * u2 + 1) * v(i) + (u3 - 2 * u2 + u) * h(i) * tangent(i) + (-2 * u3 + 3 * u2) * v(i + 1) + (u3 - u2) * h(i) * tangent(i + 1);
+}
+function sample(track, t, loop = false) {
+  const keys = track.keys;
+  if (t <= keys[0].t) return keys[0].v;
+  const last = keys[keys.length - 1];
+  if (t >= last.t) return last.v;
+  let i = 0;
+  while (keys[i + 1].t <= t) i++;
+  const a = keys[i], b = keys[i + 1];
+  if (a.ease === "step") return a.v;
+  if (typeof a.v === "number" && typeof b.v === "number") {
+    if (track.interpolation === "pchip") return smoothValue(track, i, t, void 0, loop);
+    const u = ease(a.ease)((t - a.t) / (b.t - a.t));
+    return a.v + (b.v - a.v) * u;
+  }
+  if (Array.isArray(a.v) && Array.isArray(b.v) && typeof a.v[0] === "number") {
+    if (track.interpolation === "pchip") return a.v.map((_, j) => smoothValue(track, i, t, j, loop));
+    const phase = (t - a.t) / (b.t - a.t), av = a.v, bv = b.v;
+    return av.map((v, k) => v + ((bv[k] ?? v) - v) * ease(a.componentEase?.[k] ?? a.ease)(phase));
+  }
+  return a.v;
+}
+function poseOf(anim, t, out = /* @__PURE__ */ new Map()) {
+  for (const tr of anim.tracks) out.set(pk(tr.target, tr.id, tr.prop), sample(tr, t, anim.loop && tr.keys[0].t === 0 && tr.keys.at(-1).t === anim.duration));
+  return out;
+}
+function blendPoses(from, to, w, restOf) {
+  if (w >= 1) return new Map(to);
+  const out = /* @__PURE__ */ new Map();
+  for (const k of /* @__PURE__ */ new Set([...from.keys(), ...to.keys()])) {
+    const f = from.has(k) ? from.get(k) : restOf(k);
+    const cur = to.has(k) ? to.get(k) : restOf(k);
+    if (typeof f === "number" && !Array.isArray(cur)) {
+      const target = typeof cur === "number" ? cur : restOf(k);
+      out.set(k, f + (target - f) * w);
+    } else if (Array.isArray(f) && typeof f[0] === "number") {
+      const fv = f, tv = Array.isArray(cur) && typeof cur[0] === "number" ? cur : fv.map(() => 0);
+      out.set(k, fv.map((v, i) => v + ((tv[i] ?? 0) - v) * w));
+    } else if (Array.isArray(cur) && typeof cur[0] === "number" && typeof f !== "string") {
+      out.set(k, cur.map((v) => v * w));
+    } else out.set(k, f ?? null);
+  }
+  return out;
+}
+function restValue(doc, key) {
+  const [target, id, prop] = key.split(":");
+  if (target === "control") return doc.controls?.find((c) => c.id === id)?.default ?? 0;
+  if (target === "bone") return doc.bones.find((b) => b.id === id).transform[prop];
+  if (target === "slot") {
+    const s = doc.slots.find((s2) => s2.id === id);
+    if (prop === "color") return colorToArray(s.color);
+    return s[prop];
+  }
+  if (target === "ik" || target === "transform" || target === "path") {
+    const c = doc[target].find((c2) => c2.id === id);
+    const v = c?.[prop];
+    return typeof v === "boolean" ? v ? 1 : 0 : v ?? 0;
+  }
+  if (target === "drawOrder") return doc.slots.map((s) => s.id);
+  return 0;
+}
+var colorToArray = (c) => [0, 2, 4, 6].map((k) => parseInt(c.slice(1 + k, 3 + k), 16) / 255);
+function deformParams(pose, attachmentId) {
+  let out;
+  const prefix = `deform:${attachmentId}:`;
+  for (const [k, v] of pose)
+    if (k.startsWith(prefix) && typeof v === "number") (out ??= {})[k.slice(prefix.length)] = v;
+  return out;
+}
+function affineOf(x, y, rotationDeg, sx, sy, shearX = 0, shearY = 0) {
+  const rx = (rotationDeg + shearX) * DEG2, ry = (rotationDeg + 90 + shearY) * DEG2;
+  return { a: Math.cos(rx) * sx, b: Math.sin(rx) * sx, c: Math.cos(ry) * sy, d: Math.sin(ry) * sy, tx: x, ty: y };
+}
+function mul(p, l) {
+  return {
+    a: p.a * l.a + p.c * l.b,
+    b: p.b * l.a + p.d * l.b,
+    c: p.a * l.c + p.c * l.d,
+    d: p.b * l.c + p.d * l.d,
+    tx: p.a * l.tx + p.c * l.ty + p.tx,
+    ty: p.b * l.tx + p.d * l.ty + p.ty
+  };
+}
+var apply = (m, x, y) => [m.a * x + m.c * y + m.tx, m.b * x + m.d * y + m.ty];
+function invert(m) {
+  const det = m.a * m.d - m.b * m.c || 1e-12;
+  const a = m.d / det, b = -m.b / det, c = -m.c / det, d = m.a / det;
+  return { a, b, c, d, tx: -(a * m.tx + c * m.ty), ty: -(b * m.tx + d * m.ty) };
+}
+var num = (pose, key, rest) => {
+  const v = pose.get(key);
+  return typeof v === "number" ? v : rest;
+};
+var boneIndex = /* @__PURE__ */ new WeakMap();
+function boneOf(doc, id) {
+  let idx = boneIndex.get(doc);
+  if (!idx) boneIndex.set(doc, idx = new Map(doc.bones.map((b2) => [b2.id, b2])));
+  const b = idx.get(id);
+  if (!b) throw new Error(`unknown bone "${id}"`);
+  return b;
+}
+function boneWorldOf(bone, s, parent) {
+  const local = affineOf(s.x, s.y, s.rotation, s.scaleX, s.scaleY, s.shearX, s.shearY);
+  if (!parent) return local;
+  if (bone.inherit === "normal") return mul(parent, local);
+  const [tx, ty] = apply(parent, s.x, s.y);
+  if (bone.inherit === "noScale" || bone.inherit === "noScaleOrReflection") {
+    const r = s.rotation * DEG2, x = parent.a * Math.cos(r) + parent.c * Math.sin(r), y = parent.b * Math.cos(r) + parent.d * Math.sin(r);
+    const length = Math.hypot(x, y), a = length > 1e-5 ? x / length : x, b = length > 1e-5 ? y / length : y;
+    const sign = bone.inherit === "noScale" && parent.a * parent.d - parent.b * parent.c < 0 ? -1 : 1;
+    const basis2 = { a, b, c: -b * sign, d: a * sign, tx: 0, ty: 0 };
+    return { ...mul(basis2, affineOf(0, 0, 0, s.scaleX, s.scaleY, s.shearX, s.shearY)), tx, ty };
+  }
+  return { ...mul(inheritedParentLinear(bone, parent), { ...local, tx: 0, ty: 0 }), tx, ty };
+}
+var orderCache = /* @__PURE__ */ new WeakMap();
+function boneOrder(doc) {
+  let order = orderCache.get(doc);
+  if (order) return order;
+  order = [];
+  const emitted = /* @__PURE__ */ new Set();
+  while (order.length < doc.bones.length) {
+    let progressed = false;
+    for (const b of doc.bones) if (!emitted.has(b.id) && (!b.parent || emitted.has(b.parent))) {
+      emitted.add(b.id);
+      order.push(b);
+      progressed = true;
+    }
+    if (!progressed) throw new Error("bone hierarchy has a cycle");
+  }
+  orderCache.set(doc, order);
+  return order;
+}
+var localOf = (doc, pose, b) => {
+  const r = b.transform, id = b.id;
+  return {
+    x: num(pose, pk("bone", id, "x"), r.x),
+    y: num(pose, pk("bone", id, "y"), r.y),
+    rotation: num(pose, pk("bone", id, "rotation"), r.rotation),
+    scaleX: num(pose, pk("bone", id, "scaleX"), r.scaleX),
+    scaleY: num(pose, pk("bone", id, "scaleY"), r.scaleY),
+    shearX: num(pose, pk("bone", id, "shearX"), r.shearX),
+    shearY: num(pose, pk("bone", id, "shearY"), r.shearY)
+  };
+};
+function updateSubtree(skel, root, includeRoot = true) {
+  const doc = skel.doc;
+  const kids = /* @__PURE__ */ new Map();
+  for (const b of doc.bones) if (b.parent) (kids.get(b.parent) ?? kids.set(b.parent, []).get(b.parent)).push(b);
+  const stack = includeRoot ? [root] : (kids.get(root) ?? []).map((b) => b.id);
+  while (stack.length) {
+    const id = stack.pop(), b = boneOf(doc, id), st = skel.bones.get(id);
+    st.world = boneWorldOf(b, st, b.parent ? skel.bones.get(b.parent).world : void 0);
+    for (const k of kids.get(id) ?? []) stack.push(k.id);
+  }
+}
+function evaluate(doc, pose, modifiers) {
+  pose = resolveControls(doc, pose);
+  if (modifiers) for (const modify of modifiers) pose = modify(new Map(pose));
+  const skel = { doc, pose, bones: /* @__PURE__ */ new Map(), attachment: /* @__PURE__ */ new Map() };
+  for (const b of boneOrder(doc)) {
+    const s = localOf(doc, pose, b);
+    const world = boneWorldOf(b, s, b.parent ? skel.bones.get(b.parent).world : void 0);
+    skel.bones.set(b.id, { ...s, world });
+  }
+  const attachments = new Map(doc.attachments.map((a) => [a.id, a]));
+  for (const s of doc.slots) {
+    const v = pose.get(pk("slot", s.id, "attachment"));
+    const id = v === void 0 ? s.attachment : v;
+    skel.attachment.set(s.id, id ? attachments.get(id) ?? null : null);
+  }
+  const all = [
+    ...doc.ik.map((c) => ({ order: c.order, kind: "ik", c })),
+    ...doc.transform.map((c) => ({ order: c.order, kind: "transform", c })),
+    ...doc.path.map((c) => ({ order: c.order, kind: "path", c }))
+  ].sort((a, b) => a.order - b.order);
+  for (const { kind, c } of all) {
+    if (kind === "ik") applyIk(skel, c);
+    else if (kind === "transform") applyTransformConstraint(skel, c);
+    else applyPathConstraint(skel, c);
+  }
+  return skel;
+}
+function slotClips(skel) {
+  const keyed = skel.pose.get(pk("drawOrder", "order", "order"));
+  const order = Array.isArray(keyed) ? keyed : [...skel.doc.slots].sort((a, b) => a.z - b.z).map((s) => s.id);
+  const masks = /* @__PURE__ */ new Map();
+  let active;
+  for (const id of order) {
+    const att = skel.attachment.get(id);
+    if (!active && att?.type === "path" && att.clipping) {
+      active = att;
+      continue;
+    }
+    if (active) masks.set(id, active.id);
+    if (active?.clipping?.end === id) active = void 0;
+  }
+  for (const s of skel.doc.slots) if (s.clip) masks.set(s.id, s.clip);
+  return masks;
+}
+var cnum = (skel, kind, id, prop, rest) => num(skel.pose, pk(kind, id, prop), typeof rest === "boolean" ? rest ? 1 : 0 : rest);
+var IDENTITY = { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+var wrapRad = (r) => r > Math.PI ? r - 2 * Math.PI : r < -Math.PI ? r + 2 * Math.PI : r;
+function aimAt(skel, boneId, tx, ty, mix, compress = false, stretch = false, uniform = false) {
+  const b = boneOf(skel.doc, boneId), st = skel.bones.get(boneId);
+  const parent = b.parent ? skel.bones.get(b.parent).world : void 0;
+  let dx, dy;
+  if (parent && b.inherit === "onlyTranslation") {
+    dx = tx - st.world.tx;
+    dy = ty - st.world.ty;
+  } else {
+    const [px, py] = parent ? apply(invert(parent), tx, ty) : [tx, ty];
+    dx = px - st.x;
+    dy = py - st.y;
+  }
+  let r = Math.atan2(dy, dx) / DEG2 - st.shearX - st.rotation;
+  if (st.scaleX < 0) r += 180;
+  r = shortest(r);
+  let sx = st.scaleX, sy = st.scaleY;
+  if (compress || stretch) {
+    const len = b.length * sx;
+    if (len > 1e-4) {
+      const dd = dx * dx + dy * dy;
+      if (compress && dd < len * len || stretch && dd > len * len) {
+        const f = (Math.sqrt(dd) / len - 1) * mix + 1;
+        sx *= f;
+        if (uniform) sy *= f;
+      }
+    }
+  }
+  st.rotation += r * mix;
+  st.scaleX = sx;
+  st.scaleY = sy;
+  updateSubtree(skel, boneId);
+}
+var shortest = (deg) => ((deg + 180) % 360 + 360) % 360 - 180;
+function applyLongIk(skel, c, tx, ty, mix) {
+  const initial = c.bones.map((id) => ({ ...skel.bones.get(id) }));
+  const last = c.bones.at(-1), len = boneOf(skel.doc, last).length;
+  const end = () => apply(skel.bones.get(last).world, len, 0);
+  const tolerance = c.tolerance ?? 0.05;
+  const root = skel.bones.get(c.bones[0]).world, tip = end();
+  if (Math.abs((tip[0] - root.tx) * (ty - root.ty) - (tip[1] - root.ty) * (tx - root.tx)) < 1e-7 && Math.hypot(tx - root.tx, ty - root.ty) < Math.hypot(tip[0] - root.tx, tip[1] - root.ty) - tolerance) {
+    skel.bones.get(last).rotation += cnum(skel, "ik", c.id, "bendPositive", c.bendPositive) > 0.5 ? 5 : -5;
+    updateSubtree(skel, last);
+  }
+  for (let iter = 0; iter < (c.iterations ?? 100); iter++) {
+    const e = end();
+    if (Math.hypot(e[0] - tx, e[1] - ty) <= tolerance) break;
+    for (let i = c.bones.length - 1; i >= 0; i--) {
+      const id = c.bones[i], b = boneOf(skel.doc, id), st = skel.bones.get(id), w = st.world, e2 = end();
+      const angle = wrapRad(Math.atan2(ty - w.ty, tx - w.tx) - Math.atan2(e2[1] - w.ty, e2[0] - w.tx));
+      const cos = Math.cos(angle), sin = Math.sin(angle);
+      setEffectiveWorld(skel, b, st, { ...w, a: cos * w.a - sin * w.b, b: sin * w.a + cos * w.b, c: cos * w.c - sin * w.d, d: sin * w.c + cos * w.d });
+    }
+  }
+  if (mix < 1) {
+    c.bones.forEach((id, i) => {
+      const st = skel.bones.get(id), from = initial[i];
+      for (const p of ["rotation", "shearX", "shearY"]) st[p] = from[p] + shortest(st[p] - from[p]) * mix;
+      for (const p of ["x", "y", "scaleX", "scaleY"]) st[p] = from[p] + (st[p] - from[p]) * mix;
+    });
+    updateSubtree(skel, c.bones[0]);
+  }
+}
+function applyIk(skel, c) {
+  const mix = cnum(skel, "ik", c.id, "mix", c.mix);
+  if (mix <= 0) return;
+  const target = skel.bones.get(c.target).world;
+  if (c.bones.length > 2) {
+    applyLongIk(skel, c, target.tx, target.ty, mix);
+    return;
+  }
+  const bendDir = cnum(skel, "ik", c.id, "bendPositive", c.bendPositive) > 0.5 ? 1 : -1;
+  const compress = cnum(skel, "ik", c.id, "compress", c.compress) > 0.5, stretch = cnum(skel, "ik", c.id, "stretch", c.stretch) > 0.5;
+  let softness = cnum(skel, "ik", c.id, "softness", c.softness);
+  if (c.bones.length === 1) {
+    aimAt(skel, c.bones[0], target.tx, target.ty, mix, compress, stretch, c.uniform);
+    return;
+  }
+  const [pId, cId] = c.bones;
+  const parentBone = boneOf(skel.doc, pId), childBone = boneOf(skel.doc, cId);
+  const p = skel.bones.get(pId), ch = skel.bones.get(cId);
+  const px = p.x, py = p.y;
+  let psx = p.scaleX, psy = p.scaleY, csx = ch.scaleX, sx = psx, sy = psy;
+  let os1 = 0, os2 = 0, s2 = 1;
+  if (psx < 0) {
+    psx = -psx;
+    os1 = 180;
+    s2 = -1;
+  }
+  if (psy < 0) {
+    psy = -psy;
+    s2 = -s2;
+  }
+  if (csx < 0) {
+    csx = -csx;
+    os2 = 180;
+  }
+  const uniform = Math.abs(psx - psy) <= 1e-4;
+  const cx = ch.x, cy = !uniform || stretch ? 0 : ch.y;
+  const [cwx, cwy] = apply(p.world, cx, cy);
+  const ppInv = invert(parentBone.parent ? skel.bones.get(parentBone.parent).world : IDENTITY);
+  const [clx, cly] = apply(ppInv, cwx, cwy);
+  const dx = clx - px, dy = cly - py, l1 = Math.hypot(dx, dy);
+  let l2 = childBone.length * csx;
+  if (l1 < 1e-4) {
+    aimAt(skel, pId, target.tx, target.ty, mix, false, stretch, false);
+    ch.x = cx;
+    ch.y = cy;
+    ch.rotation = 0;
+    updateSubtree(skel, pId);
+    return;
+  }
+  const [tlx, tly] = apply(ppInv, target.tx, target.ty);
+  let tx = tlx - px, ty = tly - py, dd = tx * tx + ty * ty;
+  if (softness !== 0) {
+    softness *= psx * (csx + 1) * 0.5;
+    const td = Math.sqrt(dd), sd = td - l1 - l2 * psx + softness;
+    if (sd > 0) {
+      let q = Math.min(1, sd / (softness * 2)) - 1;
+      q = (sd - softness * (1 - q * q)) / td;
+      tx -= q * tx;
+      ty -= q * ty;
+      dd = tx * tx + ty * ty;
+    }
+  }
+  let a1, a2;
+  if (uniform) {
+    l2 *= psx;
+    let cos = (dd - l1 * l1 - l2 * l2) / (2 * l1 * l2);
+    if (cos < -1) {
+      cos = -1;
+      a2 = Math.PI * bendDir;
+    } else if (cos > 1) {
+      cos = 1;
+      a2 = 0;
+      if (stretch) {
+        const f = (Math.sqrt(dd) / (l1 + l2) - 1) * mix + 1;
+        sx *= f;
+        if (c.uniform) sy *= f;
+      }
+    } else a2 = Math.acos(cos) * bendDir;
+    const a = l1 + l2 * cos, b = l2 * Math.sin(a2);
+    a1 = Math.atan2(ty * a - tx * b, tx * a + ty * b);
+  } else {
+    const a = psx * l2, b = psy * l2, aa = a * a, bb = b * b, ta = Math.atan2(ty, tx);
+    const c0 = bb * l1 * l1 + aa * dd - aa * bb, c1 = -2 * bb * l1, c2 = bb - aa;
+    const disc = c1 * c1 - 4 * c2 * c0;
+    let solved = false;
+    a1 = a2 = 0;
+    if (disc >= 0) {
+      let q = Math.sqrt(disc);
+      if (c1 < 0) q = -q;
+      q = -(c1 + q) * 0.5;
+      const r0 = q / c2, r1 = c0 / q, r = Math.abs(r0) < Math.abs(r1) ? r0 : r1, yy = dd - r * r;
+      if (yy >= 0) {
+        const y = Math.sqrt(yy) * bendDir;
+        a1 = ta - Math.atan2(y, r);
+        a2 = Math.atan2(y / psy, (r - l1) / psx);
+        solved = true;
+      }
+    }
+    if (!solved) {
+      let minAngle = Math.PI, minX = l1 - a, minDist = minX * minX, minY = 0, maxAngle = 0, maxX = l1 + a, maxDist = maxX * maxX, maxY = 0;
+      const k = -a * l1 / (aa - bb);
+      if (k >= -1 && k <= 1) {
+        const ang = Math.acos(k), x = a * Math.cos(ang) + l1, y = b * Math.sin(ang), dist = x * x + y * y;
+        if (dist < minDist) {
+          minAngle = ang;
+          minDist = dist;
+          minX = x;
+          minY = y;
+        }
+        if (dist > maxDist) {
+          maxAngle = ang;
+          maxDist = dist;
+          maxX = x;
+          maxY = y;
+        }
+      }
+      if (dd <= (minDist + maxDist) * 0.5) {
+        a1 = ta - Math.atan2(minY * bendDir, minX);
+        a2 = minAngle * bendDir;
+      } else {
+        a1 = ta - Math.atan2(maxY * bendDir, maxX);
+        a2 = maxAngle * bendDir;
+      }
+    }
+  }
+  const os = Math.atan2(cy, cx) * s2;
+  const d1 = shortest((a1 - os) / DEG2 + os1 - p.rotation);
+  const d2 = shortest(((a2 + os) / DEG2 - ch.shearX) * s2 + os2 - ch.rotation);
+  p.rotation += d1 * mix;
+  p.scaleX = sx;
+  p.scaleY = sy;
+  p.shearX = 0;
+  p.shearY = 0;
+  ch.x = cx;
+  ch.y = cy;
+  ch.rotation += d2 * mix;
+  updateSubtree(skel, pId);
+}
+function applyTransformConstraint(skel, c) {
+  const mixRotate = cnum(skel, "transform", c.id, "mixRotate", c.mixRotate), mixX = cnum(skel, "transform", c.id, "mixX", c.mixX), mixY = cnum(skel, "transform", c.id, "mixY", c.mixY);
+  const mixScaleX = cnum(skel, "transform", c.id, "mixScaleX", c.mixScaleX), mixScaleY = cnum(skel, "transform", c.id, "mixScaleY", c.mixScaleY), mixShearY = cnum(skel, "transform", c.id, "mixShearY", c.mixShearY);
+  if (!mixRotate && !mixX && !mixY && !mixScaleX && !mixScaleY && !mixShearY) return;
+  c = { ...c, ...Object.fromEntries(["x", "y", "rotation", "scaleX", "scaleY", "shearY"].map((p) => [p, cnum(skel, "transform", c.id, p, c[p])])) };
+  const target = skel.bones.get(c.target), tw = target.world;
+  const handedness = tw.a * tw.d - tw.b * tw.c < 0 ? -1 : 1;
+  const offsetRotation = c.rotation * DEG2 * (c.local ? 1 : handedness), offsetShearY = c.shearY * DEG2 * (c.local ? 1 : handedness);
+  for (const id of c.bones) {
+    const b = boneOf(skel.doc, id), st = skel.bones.get(id);
+    if (c.local) {
+      if (c.relative) {
+        st.rotation += (target.rotation + c.rotation) * mixRotate;
+        st.x += (target.x + c.x) * mixX;
+        st.y += (target.y + c.y) * mixY;
+        st.scaleX *= (target.scaleX - 1 + c.scaleX) * mixScaleX + 1;
+        st.scaleY *= (target.scaleY - 1 + c.scaleY) * mixScaleY + 1;
+        st.shearY += (target.shearY + c.shearY) * mixShearY;
+      } else {
+        st.rotation += (target.rotation - st.rotation + c.rotation) * mixRotate;
+        st.x += (target.x - st.x + c.x) * mixX;
+        st.y += (target.y - st.y + c.y) * mixY;
+        if (st.scaleX !== 0) st.scaleX += (target.scaleX - st.scaleX + c.scaleX) * mixScaleX;
+        if (st.scaleY !== 0) st.scaleY += (target.scaleY - st.scaleY + c.scaleY) * mixScaleY;
+        st.shearY += (target.shearY - st.shearY + c.shearY) * mixShearY;
+      }
+      updateSubtree(skel, id);
+      continue;
+    }
+    let w = { ...st.world };
+    const targetRot = Math.atan2(tw.b, tw.a), rotate = (m, r) => {
+      const cos = Math.cos(r), sin = Math.sin(r);
+      return { a: cos * m.a - sin * m.b, b: sin * m.a + cos * m.b, c: cos * m.c - sin * m.d, d: sin * m.c + cos * m.d, tx: m.tx, ty: m.ty };
+    };
+    if (mixRotate !== 0) {
+      const r = wrapRad(c.relative ? targetRot + offsetRotation : targetRot - Math.atan2(w.b, w.a) + offsetRotation);
+      w = rotate(w, r * mixRotate);
+    }
+    if (mixX !== 0 || mixY !== 0) {
+      const [ox, oy] = apply(tw, c.x, c.y);
+      if (c.relative) {
+        w.tx += ox * mixX;
+        w.ty += oy * mixY;
+      } else {
+        w.tx += (ox - w.tx) * mixX;
+        w.ty += (oy - w.ty) * mixY;
+      }
+    }
+    if (mixScaleX !== 0) {
+      const ts = Math.hypot(tw.a, tw.b);
+      let f;
+      if (c.relative) f = (ts - 1 + c.scaleX) * mixScaleX + 1;
+      else {
+        const s0 = Math.hypot(w.a, w.b);
+        f = s0 === 0 ? 1 : (s0 + (ts - s0 + c.scaleX) * mixScaleX) / s0;
+      }
+      w.a *= f;
+      w.b *= f;
+    }
+    if (mixScaleY !== 0) {
+      const ts = Math.hypot(tw.c, tw.d);
+      let f;
+      if (c.relative) f = (ts - 1 + c.scaleY) * mixScaleY + 1;
+      else {
+        const s0 = Math.hypot(w.c, w.d);
+        f = s0 === 0 ? 1 : (s0 + (ts - s0 + c.scaleY) * mixScaleY) / s0;
+      }
+      w.c *= f;
+      w.d *= f;
+    }
+    if (mixShearY > 0) {
+      const by = Math.atan2(w.d, w.c), targetShear = Math.atan2(tw.d, tw.c) - targetRot;
+      const r = c.relative ? by + (wrapRad(targetShear) - Math.PI / 2 + offsetShearY) * mixShearY : by + (wrapRad(targetShear - (by - Math.atan2(w.b, w.a))) + offsetShearY) * mixShearY;
+      const len = Math.hypot(w.c, w.d);
+      w.c = Math.cos(r) * len;
+      w.d = Math.sin(r) * len;
+    }
+    setEffectiveWorld(skel, b, st, w);
+  }
+}
+function pathWorldVertices(skel, slotId, att) {
+  return attachmentWorldVertices(skel, slotId, att);
+}
+function pathLength(vertexCount, closed, lengths) {
+  const curveCount = closed ? vertexCount / 3 : vertexCount / 3 - 1;
+  return curveCount >= 1 && lengths.length >= curveCount ? lengths[curveCount - 1] : lengths[lengths.length - 1] ?? 1;
+}
+function samplePath(points, closed, lengths, constantSpeed, positions, percent) {
+  const n = points.length / 2;
+  const curveCount = closed ? n / 3 : n / 3 - 1;
+  if (curveCount < 1) return positions.map(() => ({ x: points[2] ?? 0, y: points[3] ?? 0, angle: 0 }));
+  const curve = (i) => {
+    const a = (i * 3 + 1) % n * 2, c1 = (i * 3 + 2) % n * 2, c2 = (i * 3 + 3) % n * 2, b = (i * 3 + 4) % n * 2;
+    return [points[a], points[a + 1], points[c1], points[c1 + 1], points[c2], points[c2 + 1], points[b], points[b + 1]];
+  };
+  const pointAt = (i, t) => {
+    const [x0, y0, x1, y1, x2, y2, x3, y3] = curve(i), u = 1 - t;
+    return { x: u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3, y: u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3 };
+  };
+  const angleAt = (i, t) => {
+    const [x0, y0, x1, y1, x2, y2, x3, y3] = curve(i), u = 1 - t;
+    const dx = 3 * u * u * (x1 - x0) + 6 * u * t * (x2 - x1) + 3 * t * t * (x3 - x2);
+    const dy = 3 * u * u * (y1 - y0) + 6 * u * t * (y2 - y1) + 3 * t * t * (y3 - y2);
+    return Math.atan2(dy, dx) / DEG2;
+  };
+  const chords = (i, count) => {
+    const acc = [];
+    let sum = 0, prev = pointAt(i, 0);
+    for (let k = 1; k <= count; k++) {
+      const q = pointAt(i, k / count);
+      sum += Math.hypot(q.x - prev.x, q.y - prev.y);
+      acc.push(sum);
+      prev = q;
+    }
+    return acc;
+  };
+  const cum = [];
+  if (constantSpeed) {
+    let acc = 0;
+    for (let i = 0; i < curveCount; i++) {
+      acc += chords(i, 4)[3];
+      cum.push(acc);
+    }
+  } else for (let i = 0; i < curveCount; i++) cum.push(lengths[i] ?? (i ? cum[i - 1] : 0));
+  const total = cum[curveCount - 1];
+  const out = [];
+  for (let pos of positions) {
+    if (percent) pos *= total;
+    if (closed) {
+      if (total > 0) {
+        pos %= total;
+        if (pos < 0) pos += total;
+      } else pos = 0;
+    } else if (pos < 0) {
+      const r = Math.atan2(points[5] - points[3], points[4] - points[2]);
+      out.push({ x: points[2] + pos * Math.cos(r), y: points[3] + pos * Math.sin(r), angle: r / DEG2 });
+      continue;
+    } else if (pos > total) {
+      const a = (curveCount * 3 + 1) * 2, c = curveCount * 3 * 2, e = pos - total;
+      const r = Math.atan2(points[a + 1] - points[c + 1], points[a] - points[c]);
+      out.push({ x: points[a] + e * Math.cos(r), y: points[a + 1] + e * Math.sin(r), angle: r / DEG2 });
+      continue;
+    }
+    let i = 0;
+    while (i < curveCount - 1 && pos > cum[i]) i++;
+    const prev = i ? cum[i - 1] : 0, span = cum[i] - prev;
+    const f = span > 0 ? (pos - prev) / span : 0;
+    let t = f;
+    if (constantSpeed) {
+      const seg = chords(i, 10), target = f * seg[9];
+      let k = 0;
+      while (k < 9 && target > seg[k]) k++;
+      const sPrev = k ? seg[k - 1] : 0, sSpan = seg[k] - sPrev;
+      t = (k + (sSpan > 0 ? (target - sPrev) / sSpan : 0)) / 10;
+    }
+    out.push({ ...pointAt(i, t), angle: angleAt(i, t) });
+  }
+  return out;
+}
+var PATH_EPSILON = 1e-5;
+function applyPathConstraint(skel, c) {
+  const mixRotate = cnum(skel, "path", c.id, "mixRotate", c.mixRotate), mixX = cnum(skel, "path", c.id, "mixX", c.mixX), mixY = cnum(skel, "path", c.id, "mixY", c.mixY);
+  if (!mixRotate && !mixX && !mixY) return;
+  const att = skel.attachment.get(c.target);
+  if (!att || att.type !== "path") return;
+  const points = pathWorldVertices(skel, c.target, att);
+  const position = cnum(skel, "path", c.id, "position", c.position), spacing = cnum(skel, "path", c.id, "spacing", c.spacing);
+  const tangents = c.rotateMode === "tangent", scale = c.rotateMode === "chainScale";
+  const bones = c.bones.map((id) => ({ b: boneOf(skel.doc, id), st: skel.bones.get(id) }));
+  const inputWorlds = bones.map(({ st }) => ({ ...st.world }));
+  const spacesCount = tangents ? bones.length : bones.length + 1;
+  const spaces = new Array(spacesCount).fill(0), worldLengths = [];
+  let sum = 0;
+  for (let i = 0; i < spacesCount - 1; i++) {
+    const { b, st } = bones[i], setupLength = b.length;
+    const len = setupLength < PATH_EPSILON ? 0 : setupLength * Math.hypot(st.world.a, st.world.b);
+    worldLengths.push(len);
+    if (c.spacingMode === "percent") spaces[i + 1] = spacing;
+    else if (setupLength < PATH_EPSILON) spaces[i + 1] = spacing;
+    else if (c.spacingMode === "proportional") {
+      spaces[i + 1] = len;
+      sum += len;
+    } else spaces[i + 1] = (c.spacingMode === "length" ? setupLength + spacing : spacing) * len / setupLength;
+  }
+  if (c.spacingMode === "proportional" && sum > 0) {
+    const f = spacesCount / sum * spacing;
+    for (let i = 1; i < spacesCount; i++) spaces[i] *= f;
+  }
+  const total = measuredPathLength(points, att.closed, att.lengths, att.constantSpeed);
+  const multiplier = c.spacingMode === "percent" ? total : c.spacingMode === "proportional" ? total / spacesCount : 1;
+  let p = c.positionMode === "percent" ? position * total : position;
+  const positions = [];
+  for (let i = 0; i < spacesCount; i++) {
+    p += spaces[i] * multiplier;
+    positions.push(p);
+  }
+  const samples = samplePath(points, att.closed, att.lengths, att.constantSpeed, positions, false);
+  const tip = c.rotation === 0 && c.rotateMode === "chain";
+  let offsetRotation = c.rotation * DEG2;
+  if (c.rotation !== 0) {
+    const slot = skel.doc.slots.find((sl) => sl.id === c.target), tw = skel.bones.get(slot.bone).world;
+    if (tw.a * tw.d - tw.b * tw.c < 0) offsetRotation = -offsetRotation;
+  }
+  let boneX = samples[0].x, boneY = samples[0].y;
+  const solvedWorlds = /* @__PURE__ */ new Map();
+  for (let i = 0; i < bones.length; i++) {
+    const { b, st } = bones[i];
+    let w = { ...inputWorlds[i] };
+    w.tx += (boneX - w.tx) * mixX;
+    w.ty += (boneY - w.ty) * mixY;
+    const next = samples[i + 1] ?? { x: 0, y: 0, angle: 0 };
+    const dx = next.x - boneX, dy = next.y - boneY;
+    if (scale) {
+      const len = worldLengths[i];
+      if (len !== 0) {
+        const f = (Math.hypot(dx, dy) / len - 1) * mixRotate + 1;
+        w.a *= f;
+        w.b *= f;
+      }
+    }
+    boneX = next.x;
+    boneY = next.y;
+    if (mixRotate > 0) {
+      const { a, b: bb, c: cc, d } = w;
+      let r = (tangents ? samples[i].angle : spaces[i + 1] === 0 ? next.angle : Math.atan2(dy, dx) / DEG2) * DEG2;
+      r -= Math.atan2(bb, a);
+      if (tip) {
+        const cos2 = Math.cos(r), sin2 = Math.sin(r), length = b.length;
+        boneX += (length * (cos2 * a - sin2 * bb) - dx) * mixRotate;
+        boneY += (length * (sin2 * a + cos2 * bb) - dy) * mixRotate;
+      } else r += offsetRotation;
+      if (r > Math.PI) r -= 2 * Math.PI;
+      else if (r < -Math.PI) r += 2 * Math.PI;
+      r *= mixRotate;
+      const cos = Math.cos(r), sin = Math.sin(r);
+      w = { a: cos * a - sin * bb, b: sin * a + cos * bb, c: cos * cc - sin * d, d: sin * cc + cos * d, tx: w.tx, ty: w.ty };
+    }
+    solvedWorlds.set(b.id, w);
+  }
+  for (const b of boneOrder(skel.doc)) {
+    const world = solvedWorlds.get(b.id);
+    if (world) setEffectiveWorld(skel, b, skel.bones.get(b.id), world);
+  }
+}
+function measuredPathLength(points, closed, lengths, constantSpeed) {
+  const n = points.length / 2, curveCount = closed ? n / 3 : n / 3 - 1;
+  if (curveCount < 1) return 0;
+  if (!constantSpeed) return pathLength(n, closed, lengths);
+  let total = 0;
+  for (let i = 0; i < curveCount; i++) {
+    const a = (i * 3 + 1) % n * 2, c1 = (i * 3 + 2) % n * 2, c2 = (i * 3 + 3) % n * 2, b = (i * 3 + 4) % n * 2;
+    let px = points[a], py = points[a + 1];
+    for (let k = 1; k <= 4; k++) {
+      const t = k / 4, u = 1 - t;
+      const x = u * u * u * points[a] + 3 * u * u * t * points[c1] + 3 * u * t * t * points[c2] + t * t * t * points[b];
+      const y = u * u * u * points[a + 1] + 3 * u * u * t * points[c1 + 1] + 3 * u * t * t * points[c2 + 1] + t * t * t * points[b + 1];
+      total += Math.hypot(x - px, y - py);
+      px = x;
+      py = y;
+    }
+  }
+  return total;
+}
+function inheritedParentLinear(bone, parent) {
+  switch (bone.inherit) {
+    case "normal":
+      return { ...parent, tx: 0, ty: 0 };
+    case "onlyTranslation":
+      return { a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 };
+    case "noRotationOrReflection": {
+      const lenX = Math.hypot(parent.a, parent.b);
+      const det = parent.a * parent.d - parent.b * parent.c;
+      if (lenX * lenX <= 1e-4) {
+        const lenY = Math.hypot(parent.c, parent.d), ux2 = lenY ? parent.c / lenY : 0, uy2 = lenY ? parent.d / lenY : 0;
+        return { a: lenY * ux2 * ux2, b: lenY * ux2 * uy2, c: lenY * ux2 * uy2, d: lenY * uy2 * uy2, tx: 0, ty: 0 };
+      }
+      const ux = parent.a / lenX, uy = parent.b / lenX, sy = Math.abs(det) / lenX;
+      return { a: lenX * ux * ux + sy * uy * uy, b: (lenX - sy) * ux * uy, c: (lenX - sy) * ux * uy, d: lenX * uy * uy + sy * ux * ux, tx: 0, ty: 0 };
+    }
+    case "noScale":
+    case "noScaleOrReflection": {
+      const lenX = Math.hypot(parent.a, parent.b) || 1;
+      const ua = parent.a / lenX, ub = parent.b / lenX;
+      const det = parent.a * parent.d - parent.b * parent.c;
+      const reflect = det < 0 && bone.inherit === "noScale" ? -1 : 1;
+      return { a: ua, b: ub, c: -ub * reflect, d: ua * reflect, tx: 0, ty: 0 };
+    }
+  }
+}
+function setEffectiveWorld(skel, bone, st, world) {
+  const parent = bone.parent ? skel.bones.get(bone.parent).world : void 0;
+  let lin = world, tx = world.tx, ty = world.ty;
+  if (parent) {
+    [tx, ty] = apply(invert(parent), world.tx, world.ty);
+    lin = mul(invert(inheritedParentLinear(bone, parent)), { ...world, tx: 0, ty: 0 });
+  }
+  st.x = tx;
+  st.y = ty;
+  st.rotation = Math.atan2(lin.b, lin.a) / DEG2;
+  st.scaleX = Math.hypot(lin.a, lin.b);
+  st.scaleY = Math.hypot(lin.c, lin.d);
+  st.shearX = 0;
+  st.shearY = shortest(Math.atan2(lin.d, lin.c) / DEG2 - st.rotation - 90);
+  if (parent && (bone.inherit === "noScale" || bone.inherit === "noScaleOrReflection")) {
+    const direction = mul(invert({ ...parent, tx: 0, ty: 0 }), { ...world, tx: 0, ty: 0 });
+    st.rotation = Math.atan2(direction.b, direction.a) / DEG2;
+    st.scaleX = Math.hypot(world.a, world.b);
+    st.scaleY = Math.hypot(world.c, world.d);
+    const sign = bone.inherit === "noScale" && parent.a * parent.d - parent.b * parent.c < 0 ? -1 : 1;
+    st.shearY = shortest((Math.atan2(world.d, world.c) - Math.atan2(world.b, world.a)) / DEG2 * sign - 90);
+  }
+  st.world = world;
+  updateSubtree(skel, bone.id, false);
+}
+function attachmentWorldVertices(skel, slotId, att) {
+  const deform = skel.pose.get(pk("deform", att.id, "vertices"));
+  const off = Array.isArray(deform) && typeof deform[0] === "number" ? deform : void 0;
+  const out = [];
+  if (att.weights) {
+    let k = 0;
+    for (const list of att.weights) {
+      let x = 0, y = 0;
+      for (const inf of list) {
+        const w = skel.bones.get(inf.bone).world;
+        const vx = inf.x + (off ? off[k] : 0), vy = inf.y + (off ? off[k + 1] : 0);
+        k += 2;
+        x += (w.a * vx + w.c * vy + w.tx) * inf.w;
+        y += (w.b * vx + w.d * vy + w.ty) * inf.w;
+      }
+      out.push(x, y);
+    }
+  } else {
+    const slot = skel.doc.slots.find((s) => s.id === slotId), w = skel.bones.get(slot.bone).world, v = att.vertices;
+    for (let i = 0; i < v.length; i += 2) {
+      const vx = v[i] + (off ? off[i] : 0), vy = v[i + 1] + (off ? off[i + 1] : 0);
+      out.push(w.a * vx + w.c * vy + w.tx, w.b * vx + w.d * vy + w.ty);
+    }
+  }
+  return out;
+}
+function regionMatrix(skel, slotId, att) {
+  const slot = skel.doc.slots.find((s) => s.id === slotId);
+  return mul(skel.bones.get(slot.bone).world, affineOf(att.x, att.y, att.rotation, att.scaleX, att.scaleY));
+}
+function regionSize(doc, att) {
+  const asset = doc.assets.find((a) => a.id === att.asset);
+  return [att.width ?? asset.width, att.height ?? asset.height];
+}
+
+// src/rig-state.ts
+var AnimationState = class {
+  constructor(sink, opts = {}) {
+    this.sink = sink;
+    this.opts = opts;
+    this.defaultMix = opts.mix ?? 0;
+  }
+  onEvent;
+  base;
+  main;
+  queue = [];
+  overlays = /* @__PURE__ */ new Map();
+  /** last composed pose without overlays — mix snapshots start here */
+  pose = /* @__PURE__ */ new Map();
+  from;
+  mixLeft = 0;
+  mixTotal = 0;
+  /** a mix begun in this update shows weight 0 for the frame it starts on */
+  mixFresh = false;
+  defaultMix;
+  /** id of the animation currently shown (main, else base) */
+  get current() {
+    return (this.main ?? this.base)?.anim.id;
+  }
+  get baseId() {
+    return this.base?.anim.id;
+  }
+  channel(id, loop, priority = 0) {
+    const anim = this.sink.doc.animations.find((a) => a.id === id);
+    if (!anim) {
+      const message = `unknown animation "${id}"; available: ${this.sink.doc.animations.map((a) => a.id).join(", ")}`;
+      if (this.opts.missingAnimation === "throw") throw new Error(message);
+      (this.opts.onWarning ?? console.warn)(message);
+      return void 0;
+    }
+    return { anim, time: 0, loop: loop ?? anim.loop, done: false, priority, fresh: true };
+  }
+  setBase(id, opts = {}) {
+    const next = id === void 0 ? void 0 : this.channel(id);
+    if (id !== void 0 && !next) return;
+    this.base = next;
+    if (!this.main || this.main.done) {
+      this.main = void 0;
+      this.beginMix(opts.mix);
+      this.update(0);
+    }
+  }
+  play(id, opts = {}) {
+    const ch = this.channel(id, opts.loop, opts.priority ?? 0);
+    if (!ch) {
+      this.main?.settle?.("interrupted");
+      for (const queued of this.queue) queued.settle?.("dropped");
+      this.main = void 0;
+      this.queue = [];
+      this.beginMix(opts.mix);
+      this.update(0);
+      opts.onComplete?.("dropped");
+      return Promise.resolve("dropped");
+    }
+    const promise = new Promise((resolve) => {
+      ch.settle = (r) => {
+        ch.settle = void 0;
+        opts.onComplete?.(r);
+        resolve(r);
+      };
+    });
+    const cur = this.main, busy = cur !== void 0 && !cur.done, mode = opts.ifBusy ?? "queue";
+    if (!busy || mode === "interrupt" || ch.priority >= cur.priority) {
+      if (busy) cur.settle?.("interrupted");
+      this.main = ch;
+      this.beginMix(opts.mix);
+      this.update(0);
+    } else if (mode === "drop") ch.settle("dropped");
+    else this.queue.push(ch);
+    return promise;
+  }
+  /** Independent loop on top of the shown pose; `undefined` removes it. */
+  setOverlay(name2, id) {
+    if (id === void 0) this.overlays.delete(name2);
+    else {
+      const ch = this.channel(id);
+      if (ch) this.overlays.set(name2, ch);
+    }
+  }
+  /** Clear everything and show the setup pose. Pending plays resolve as "stopped". */
+  stop() {
+    this.main?.settle?.("stopped");
+    for (const ch of this.queue) ch.settle?.("stopped");
+    this.main = this.base = void 0;
+    this.queue = [];
+    this.overlays.clear();
+    this.from = void 0;
+    this.mixLeft = this.mixTotal = 0;
+    this.mixFresh = false;
+    this.pose = /* @__PURE__ */ new Map();
+    this.sink.setPose(/* @__PURE__ */ new Map());
+  }
+  update(dt) {
+    if (this.base) this.advance(this.base, dt, this.main === void 0);
+    if (this.main) {
+      const wasDone = this.main.done;
+      this.advance(this.main, dt, true);
+      if (this.main.done && !wasDone) {
+        this.main.settle?.("completed");
+        const next = this.queue.shift();
+        if (next || this.base) {
+          this.main = next;
+          this.beginMix();
+        }
+      }
+    }
+    const shown = this.main ?? this.base;
+    let pose = shown ? poseOf(shown.anim, shown.time) : /* @__PURE__ */ new Map();
+    if (this.from) {
+      if (!this.mixFresh) this.mixLeft = Math.max(0, this.mixLeft - dt);
+      this.mixFresh = false;
+      const w = this.mixTotal > 0 ? 1 - this.mixLeft / this.mixTotal : 1;
+      pose = blendPoses(this.from, pose, w, (k) => restValue(this.sink.doc, k));
+      if (this.mixLeft === 0) this.from = void 0;
+    }
+    this.pose = pose;
+    if (this.overlays.size) {
+      pose = new Map(pose);
+      for (const [name2, ov] of this.overlays) {
+        this.advance(ov, dt, false);
+        poseOf(ov.anim, ov.time, pose);
+        if (ov.done) this.overlays.delete(name2);
+      }
+    }
+    this.sink.setPose(pose);
+  }
+  beginMix(mix = this.defaultMix) {
+    if (mix > 0) {
+      this.from = new Map(this.pose);
+      this.mixLeft = this.mixTotal = mix;
+      this.mixFresh = true;
+    } else {
+      this.from = void 0;
+      this.mixLeft = this.mixTotal = 0;
+      this.mixFresh = false;
+    }
+  }
+  advance(ch, dt, emit) {
+    if (ch.done) return;
+    const prev = ch.fresh ? -1 : ch.time, d = ch.anim.duration;
+    ch.fresh = false;
+    ch.time += dt;
+    if (emit) {
+      for (const e of ch.anim.events) if (hit(e.t, prev, ch.time, d, ch.loop)) this.onEvent?.(e.name, e.payload);
+    }
+    if (ch.time >= d) {
+      if (ch.loop) ch.time %= d;
+      else {
+        ch.time = d;
+        ch.done = true;
+      }
+    }
+  }
+};
+function hit(t, prev, cur, d, loop) {
+  if (cur < d || !loop) return t > prev && t <= cur;
+  return t > prev && t <= d || t <= cur % d;
+}
+
+// src/rig-runtime.ts
+var DEG3 = Math.PI / 180;
+var MESH_GRID = 9;
+var GHOST_ALPHA = 0.5;
+async function createTextures(doc, loadSource) {
+  const bySrc = /* @__PURE__ */ new Map(), out = /* @__PURE__ */ new Map();
+  for (const a of doc.assets) {
+    let base = bySrc.get(a.src);
+    if (!base) bySrc.set(a.src, base = await loadSource(a.src));
+    if (!a.frame) {
+      out.set(a.id, base);
+      continue;
+    }
+    const [fx, fy, w, h] = a.frame;
+    const trimmed = !!a.trim || w !== a.width || h !== a.height;
+    const [ox, oy] = a.trim ?? [0, 0];
+    out.set(a.id, new Texture({
+      source: base.source,
+      frame: new Rectangle(fx, fy, a.rotate ? h : w, a.rotate ? w : h),
+      orig: new Rectangle(0, 0, a.width, a.height),
+      // packer offsets: x from the left, y from the BOTTOM: top-left of the trimmed image in the original
+      trim: trimmed ? new Rectangle(ox, a.height - oy - h, w, h) : void 0,
+      rotate: a.rotate ? 2 : 0
+    }));
+  }
+  return out;
+}
+function atlasUV(asset, u, v, sourceW, sourceH) {
+  if (!asset.frame) return [u, v];
+  const [fx, fy, w, h] = asset.frame, [ox, oy] = asset.trim ?? [0, 0], W = asset.width, H = asset.height;
+  let ax, ay;
+  if (asset.rotate) {
+    ax = fx - (H - oy - h) + v * H;
+    ay = fy - (W - ox - w) + (1 - u) * W;
+  } else {
+    ax = fx - ox + u * W;
+    ay = fy - (H - oy - h) + v * H;
+  }
+  return [ax / sourceW, ay / sourceH];
+}
+var rgbOf = (c) => Math.round(c[0] * 255) << 16 | Math.round(c[1] * 255) << 8 | Math.round(c[2] * 255);
+var sameNumbers = (a, b) => a === b || a.length === b.length && a.every((v, i) => v === b[i]);
+var RigPlayer = class {
+  /** Default crossfade is 0.18 seconds; explicit mix: 0 requests a hard cut. */
+  constructor(doc, textures, opts = {}) {
+    this.doc = doc;
+    parse(doc);
+    this.textures = textures;
+    this.view.sortableChildren = true;
+    const latticed = /* @__PURE__ */ new Set();
+    for (const a of doc.animations) for (const t of a.tracks) if (t.target === "deform" && t.prop !== "vertices") latticed.add(t.id);
+    const slots = new Map(doc.slots.map((s) => [s.id, s]));
+    for (const att of doc.attachments) {
+      const slot = slots.get(att.slot);
+      if (!slot || att.type === "path") continue;
+      let item;
+      if (att.type === "mesh") {
+        const asset = doc.assets.find((a) => a.id === att.asset);
+        const tex = this.textures.get(att.asset) ?? Texture.EMPTY;
+        const page = this.pageTexture(tex);
+        const n = att.uvs.length / 2, uvs = new Float32Array(n * 2), positions = new Float32Array(n * 2);
+        for (let i = 0; i < n; i++) {
+          const [u, v] = atlasUV(asset, att.uvs[i * 2], att.uvs[i * 2 + 1], page.width, page.height);
+          uvs[i * 2] = u;
+          uvs[i * 2 + 1] = v;
+        }
+        const geometry = new MeshGeometry({ positions, uvs, indices: new Uint32Array(att.triangles) });
+        const mesh = new Mesh({ geometry, texture: page });
+        item = { att, slot, node: mesh, skinned: { mesh, positions } };
+      } else if (latticed.has(att.id)) {
+        const plane = new MeshPlane({ texture: this.textures.get(att.asset) ?? Texture.EMPTY, verticesX: MESH_GRID, verticesY: MESH_GRID });
+        plane.autoResize = false;
+        item = { att, slot, node: plane, lattice: { plane, offsets: new Float64Array(18), applied: new Float64Array(18).fill(NaN) } };
+      } else {
+        const sp = new Sprite(this.textures.get(att.asset) ?? Texture.EMPTY);
+        sp.anchor.set(0.5, 0.5);
+        item = { att, slot, node: sp };
+      }
+      item.node.blendMode = slot.blend;
+      this.items.push(item);
+      this.view.addChild(item.node);
+    }
+    this.state = new AnimationState(this, { ...opts, mix: opts.mix ?? 0.18 });
+    this.setPose(/* @__PURE__ */ new Map());
+  }
+  inputPose = /* @__PURE__ */ new Map();
+  controlOverrides = /* @__PURE__ */ new Map();
+  /** Manual inputs override animated controls until resetControls; values are clamped to declared ranges. */
+  setControls(values) {
+    this.controlOverrides = controlPose(this.doc, values);
+    this.setPose(this.inputPose);
+  }
+  resetControls() {
+    this.controlOverrides.clear();
+    this.setPose(this.inputPose);
+  }
+  view = new Container();
+  state;
+  items = [];
+  beforePose = /* @__PURE__ */ new Set();
+  afterPose = /* @__PURE__ */ new Set();
+  clipPoints = /* @__PURE__ */ new Map();
+  skel;
+  textures;
+  pages = /* @__PURE__ */ new Map();
+  /** slots the editor hides; honoured by setPose */
+  hidden = /* @__PURE__ */ new Set();
+  /** slots the editor has selected; setPose draws them at GHOST_ALPHA at least */
+  ghosts = /* @__PURE__ */ new Set();
+  clipGraphics = /* @__PURE__ */ new Map();
+  /** Read-only render handles for in-page tools. Nodes remain owned by the player. */
+  get renderItems() {
+    return this.items;
+  }
+  /** Current document-space clipping polygons, keyed by path attachment id. */
+  get clipPolygons() {
+    return this.clipPoints;
+  }
+  /**
+   * Modify resolved control outputs before skeleton evaluation, constraints and skinning.
+   * Callbacks run in registration order, each with its own map. Change control inputs via setControls.
+   */
+  onBeforePose(callback) {
+    this.beforePose.add(callback);
+    return () => {
+      this.beforePose.delete(callback);
+    };
+  }
+  /** Subscribe after the base pose has been rebuilt. Return value removes the callback. */
+  onAfterPose(callback) {
+    this.afterPose.add(callback);
+    return () => {
+      this.afterPose.delete(callback);
+    };
+  }
+  /** Rebuild the current pose without advancing playback; useful for reversible overlays. */
+  refreshPose() {
+    this.setPose(this.inputPose);
+  }
+  /** whole atlas page as a plain texture (identity uv mapping) for skinned meshes */
+  pageTexture(tex) {
+    let page = this.pages.get(tex.source);
+    if (!page) this.pages.set(tex.source, page = tex.frame.x === 0 && tex.frame.y === 0 && tex.frame.width === tex.source.width && tex.frame.height === tex.source.height && !tex.rotate ? tex : new Texture({ source: tex.source }));
+    return page;
+  }
+  /** Replace whatever is playing (no queueing). Resolves when the animation completes or is replaced. */
+  play(animId, opts = {}) {
+    this.state.onEvent = opts.onEvent;
+    return this.state.play(animId, {
+      loop: opts.loop,
+      mix: opts.mix,
+      ifBusy: "interrupt",
+      onComplete: (r) => {
+        if (r === "completed") opts.onComplete?.();
+      }
+    });
+  }
+  /**
+   * Swap the document for pose evaluation without rebuilding display objects — valid only when slots/attachments
+   * keep their ids and types (the editor uses it during drags). Throws otherwise: rebuild the player.
+   */
+  updateDoc(doc) {
+    const atts = new Map(doc.attachments.map((a) => [a.id, a])), slots = new Map(doc.slots.map((s) => [s.id, s]));
+    for (const it of this.items) {
+      const a = atts.get(it.att.id), s = slots.get(it.slot.id);
+      if (!a || !s || a.type !== it.att.type) throw new Error("updateDoc: structure changed \u2014 rebuild the player");
+      if (a.type === "mesh" && it.att.type === "mesh" && (!sameNumbers(a.uvs, it.att.uvs) || !sameNumbers(a.triangles, it.att.triangles)))
+        throw new Error("updateDoc: structure changed \u2014 rebuild the player");
+      it.att = a;
+      it.slot = s;
+      it.node.blendMode = s.blend;
+    }
+    this.doc = doc;
+  }
+  /** Editor-only: hide a slot's display object regardless of the pose (restored by passing `true`). */
+  setSlotVisible(slotId, visible) {
+    if (visible) this.hidden.delete(slotId);
+    else this.hidden.add(slotId);
+  }
+  /** Editor-only: draw these slots at GHOST_ALPHA at least, whatever the pose says (an empty list clears it). */
+  setGhostSlots(slotIds) {
+    this.ghosts = new Set(slotIds);
+  }
+  /** Stop playback and immediately restore the complete setup pose. */
+  stop() {
+    this.state.stop();
+  }
+  /** dt in seconds */
+  tick(dt) {
+    this.state.update(dt);
+  }
+  /** Apply a pose (rest where silent) to the display objects. */
+  setPose(pose) {
+    this.inputPose = new Map(pose);
+    if (this.controlOverrides.size) pose = new Map([...pose, ...this.controlOverrides]);
+    this.clipPoints.clear();
+    const skel = this.skel = evaluate(this.doc, pose, this.beforePose);
+    pose = skel.pose;
+    const masks = slotClips(skel), clips = new Set(masks.values());
+    for (const [id, g] of this.clipGraphics) if (!clips.has(id)) {
+      g.destroy();
+      this.clipGraphics.delete(id);
+    }
+    for (const id of clips) {
+      const att = this.doc.attachments.find((a) => a.id === id);
+      if (att?.type !== "path" || !att.closed) continue;
+      let g = this.clipGraphics.get(id);
+      if (!g) {
+        g = new Graphics();
+        this.clipGraphics.set(id, g);
+        this.view.addChild(g);
+      }
+      const vertices = attachmentWorldVertices(skel, att.slot, att);
+      const n = Math.max(32, vertices.length * 4);
+      const points = samplePath(vertices, true, att.lengths, true, Array.from({ length: n }, (_, i) => i / n), true);
+      const polygon = points.flatMap((p) => [p.x, p.y]);
+      this.clipPoints.set(id, polygon);
+      g.clear().poly(polygon, true).fill(16777215);
+    }
+    const m = new Matrix();
+    const orderV = pose.get(pk("drawOrder", "order", "order"));
+    const order = /* @__PURE__ */ new Map();
+    if (Array.isArray(orderV)) orderV.forEach((id, i) => order.set(id, i));
+    for (const it of this.items) {
+      const s = it.slot, shown = skel.attachment.get(s.id);
+      const mask = masks.get(s.id);
+      it.node.mask = mask ? this.clipGraphics.get(mask) ?? null : null;
+      if (shown !== it.att || this.hidden.has(s.id)) {
+        it.node.visible = false;
+        continue;
+      }
+      it.node.visible = true;
+      const colorV = pose.get(pk("slot", s.id, "color"));
+      const color = Array.isArray(colorV) && typeof colorV[0] === "number" ? colorV : colorToArray(s.color);
+      const alpha = numOf(pose, pk("slot", s.id, "alpha"), s.alpha) * color[3];
+      it.node.alpha = this.ghosts.has(s.id) ? Math.max(alpha, GHOST_ALPHA) : alpha;
+      it.node.tint = rgbOf(color);
+      it.node.zIndex = order.size ? order.get(s.id) ?? 0 : numOf(pose, pk("slot", s.id, "z"), s.z);
+      if (it.skinned) {
+        it.node.setFromMatrix(m.identity());
+        const v = attachmentWorldVertices(skel, s.id, it.att);
+        const buf = it.skinned.mesh.geometry.getBuffer("aPosition");
+        buf.data.set(v);
+        buf.update();
+        continue;
+      }
+      const att = it.att;
+      const [w, h] = regionSize(this.doc, att);
+      if (it.lattice) {
+        const off = controlOffsets(deformParams(pose, att.id) ?? {}, w, h, { x: 0.5, y: 0.5 }, it.lattice.offsets);
+        if (!same(off, it.lattice.applied)) {
+          const buf = it.lattice.plane.geometry.getBuffer("aPosition");
+          gridPositions(off, w, h, { x: 0.5, y: 0.5 }, MESH_GRID, buf.data);
+          buf.update();
+          it.lattice.applied.set(off);
+        }
+      } else {
+        const sp = it.node, tex = this.textures.get(att.asset);
+        if (tex && sp.texture !== tex) sp.texture = tex;
+        if (tex && (att.width || att.height)) {
+          sp.width = w;
+          sp.height = h;
+        }
+      }
+      const a = regionMatrix(skel, s.id, att);
+      m.set(a.a, a.b, a.c, a.d, a.tx, a.ty);
+      it.node.setFromMatrix(m);
+      if (!it.lattice && (att.width || att.height)) {
+        it.node.scale.x *= w / (this.textures.get(att.asset)?.width ?? w);
+        it.node.scale.y *= h / (this.textures.get(att.asset)?.height ?? h);
+      }
+    }
+    for (const callback of this.afterPose) callback(this);
+  }
+  /** World-space bone positions — used by editor gizmos and renderPreview overlays */
+  bonePositions() {
+    const out = {};
+    for (const [id, st] of this.skel.bones) out[id] = { x: st.world.tx, y: st.world.ty, rotation: Math.atan2(st.world.b, st.world.a) / DEG3 };
+    return out;
+  }
+  /** current world transforms (for tests and tools) */
+  get world() {
+    return new Map([...this.skel.bones].map(([id, s]) => [id, s.world]));
+  }
+};
+var numOf = (pose, key, rest) => {
+  const v = pose.get(key);
+  return typeof v === "number" ? v : rest;
+};
+var same = (a, b) => {
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+};
+
+// src/e8/node.ts
+var isLoadedRig = (v) => !!v && typeof v === "object" && "doc" in v && v.textures instanceof Map;
+var plain = (p) => {
+  try {
+    return decodeURIComponent(p);
+  } catch {
+    return p;
+  }
+};
+var BASE = "http://golem.invalid/";
+function resolveSrc(rigUrl, src) {
+  const href = new URL(src, new URL(rigUrl, BASE)).href;
+  return href.startsWith(BASE) ? `/${href.slice(BASE.length)}` : href;
+}
+var rigPrivate = (url, rig) => `${url}${url.includes("?") ? "&" : "?"}golem=${encodeURIComponent(rig)}`;
+function createRigLoader(io = {
+  load: (url) => Assets.load(url),
+  unload: (urls) => Assets.unload(urls)
+}) {
+  return {
+    extension: { type: ExtensionType.LoadParser, name: "golemRigLoader" },
+    name: "golemRigLoader",
+    async testParse(asset) {
+      return !!asset && typeof asset === "object" && asset.format === "energy8.rig";
+    },
+    async parse(asset, resolved) {
+      const doc = parse(asset);
+      const sources = [];
+      const textures = await createTextures(doc, (src) => {
+        const url = rigPrivate(resolveSrc(resolved?.src ?? "", src), resolved?.src ?? "");
+        sources.push(url);
+        return io.load(url);
+      });
+      return { doc, textures, sources };
+    },
+    async unload(rig) {
+      if (isLoadedRig(rig) && rig.sources.length) await io.unload(rig.sources);
+    }
+  };
+}
+var rigLoader = createRigLoader();
+var SCHEMA = Schema.object({
+  rig: Schema.string().required().extra("asset", ["json"]).description("rig.json, project-relative"),
+  animation: Schema.string().description("animation id (empty: the rig's first)"),
+  loop: Schema.boolean().default(true),
+  speed: Schema.number().default(1).description("playback speed multiplier"),
+  controls: Schema.dict(Schema.number()).description("expression controls by id; a set one overrides that control's animated track")
+});
+function createGolemNode(ticker) {
+  const live = /* @__PURE__ */ new WeakMap();
+  const drop = (view) => {
+    const s = live.get(view);
+    if (!s) return;
+    live.delete(view);
+    ticker.remove(s.tick);
+    s.player.stop();
+    s.player.view.destroy({ children: true });
+  };
+  const animationOf = (doc, wanted) => wanted && doc.animations.some((a) => a.id === wanted) ? wanted : doc.animations[0]?.id;
+  const node = {
+    type: "golem",
+    schema: SCHEMA,
+    accept: { extensions: ["rig.json"], prop: "rig" },
+    assetProps: ["rig"],
+    assets: (p) => p.rig ? [p.rig] : [],
+    dependsOn(props, ctx) {
+      const got = props.rig ? ctx.reflect.get("assetLoader", false)?.get(props.rig) : void 0;
+      if (!isLoadedRig(got)) return [];
+      const files = got.doc.assets.map((a) => resolveSrc(`/${props.rig}`, a.src.replace(/[?#].*$/, ""))).filter((u) => u.startsWith("/")).map((u) => plain(u.slice(1)));
+      return [...new Set(files)];
+    },
+    mount(props, ctx) {
+      const view = new Container2();
+      node.update(view, props, ctx);
+      return view;
+    },
+    update(view, props, ctx) {
+      const loader = ctx.reflect.get("assetLoader", false);
+      const got = props.rig ? loader?.get(props.rig) : void 0;
+      if (live.has(view) && live.get(view).rig !== got) drop(view);
+      if (got === void 0 || got === null) return;
+      if (!isLoadedRig(got)) throw new Error(`not a golem rig: ${props.rig} (a rig.json has "format": "energy8.rig")`);
+      let s = live.get(view);
+      if (!s) {
+        const player = new RigPlayer(got.doc, got.textures);
+        player.view.position.set(-got.doc.meta.width / 2, -got.doc.meta.height / 2);
+        view.addChild(player.view);
+        const state = { rig: got, player, speed: 1, controls: "{}", tick: (t) => player.tick(t.deltaMS / 1e3 * state.speed) };
+        ticker.add(state.tick);
+        live.set(view, s = state);
+      }
+      s.speed = props.speed ?? 1;
+      const animation = animationOf(got.doc, props.animation), loop = props.loop ?? true;
+      if (animation !== s.animation || loop !== s.loop) {
+        s.animation = animation;
+        s.loop = loop;
+        if (animation) void s.player.play(animation, { loop });
+        else s.player.stop();
+      }
+      const controls = JSON.stringify(props.controls ?? {});
+      if (controls !== s.controls) {
+        s.controls = controls;
+        if (Object.keys(props.controls ?? {}).length) s.player.setControls(props.controls);
+        else s.player.resetControls();
+      }
+    },
+    once(view, props) {
+      const s = live.get(view);
+      const animation = s && animationOf(s.rig.doc, props.animation);
+      if (!s || !animation) return Promise.resolve();
+      s.animation = animation;
+      s.loop = false;
+      return new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          view.off("destroyed", done);
+          resolve();
+        };
+        view.once("destroyed", done);
+        void s.player.play(animation, { loop: false }).then(done);
+      });
+    },
+    // not one of the runtime's own types: it does not destroy the view; textures belong to the Assets cache
+    unmount(view) {
+      drop(view);
+      view.destroy({ children: true });
+    }
+  };
+  return node;
+}
+var golemNode = createGolemNode(Ticker.shared);
+
+// src/e8/runtime.ts
+var name = "golem";
+var inject = ["nodeTypes"];
+function apply2(ctx) {
+  ctx.effect(() => {
+    extensions.add(rigLoader);
+    return () => extensions.remove(rigLoader);
+  }, "golem:loader");
+  ctx.effect(() => ctx.nodeTypes.register(golemNode), "golem:node");
+}
+export {
+  apply2 as apply,
+  createGolemNode,
+  createRigLoader,
+  golemNode,
+  inject,
+  isLoadedRig,
+  name,
+  resolveSrc,
+  rigLoader
+};
+//# sourceMappingURL=e8-runtime.js.map