@energy8platform/golem 0.5.0 → 0.7.0

package/dist/lib/rig-import-layers.d.ts

@@ -28,5 +28,7 @@ export interface LayerSpec {
     blend?: "normal" | "add" | "multiply" | "screen";
 }
 export declare function pngSize(buf: Buffer): [number, number];
+/** `file`, named by a sidecar inside `dir` (layers.json, a Spine atlas), leaves `dir`: absolute or climbing out. */
+export declare function outsideDir(dir: string, file: string): boolean;
 export declare function importLayers(doc: Doc, dir: string, relPrefix?: string): Promise<Doc>;
 export {};

package/dist/lib/rig-version.d.ts

@@ -0,0 +1,12 @@
+import { type ToolResult } from "./rig-api";
+/** `mtimeMs:size` of the file, or "missing" */
+export declare function rigVersion(abs: string): Promise<string>;
+/**
+ * callTool with the rig's version just before and just after, both read inside the rig's queue, so no other writer in
+ * this process lands between them. `args.path` must be absolute; a call without one reads "missing" twice.
+ */
+export declare function callToolVersioned(name: string, args: Record<string, unknown>): Promise<{
+    result: ToolResult;
+    before: string;
+    after: string;
+}>;

package/dist/lib/runtime.js

@@ -159,7 +159,9 @@ var PathAttachment = z.object({
   /** curve lengths for constant-speed positioning */
   lengths: z.array(z.number()).default([]),
   closed: z.boolean().default(false),
-  constantSpeed: z.boolean().default(true)
+  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({
@@ -223,7 +225,9 @@ var Key = z.object({
   t: z.number().nonnegative(),
   v: KeyValue,
   /** easing INTO the next key */
-  ease: Ease.default("ease_in_out")
+  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", [
@@ -410,6 +414,10 @@ function validate(doc) {
       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;
@@ -493,6 +501,7 @@ function validate(doc) {
       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") {
@@ -657,8 +666,8 @@ function sample(track, t, loop = false) {
   }
   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 u = ease(a.ease)((t - a.t) / (b.t - a.t)), av = a.v, bv = b.v;
-    return av.map((v, k) => v + ((bv[k] ?? v) - v) * u);
+    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;
 }
@@ -746,6 +755,13 @@ function boneWorldOf(bone, s, parent) {
   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();
@@ -778,11 +794,11 @@ var localOf = (doc, pose, b) => {
     shearY: num(pose, pk("bone", id, "shearY"), r.shearY)
   };
 };
-function updateSubtree(skel, root) {
+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 = [root];
+  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);
@@ -816,6 +832,23 @@ function evaluate(doc, pose, modifiers) {
   }
   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;
@@ -1025,7 +1058,8 @@ function applyTransformConstraint(skel, c) {
   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 offsetRotation = c.rotation * DEG2, offsetShearY = c.shearY * DEG2;
+  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) {
@@ -1187,6 +1221,7 @@ function applyPathConstraint(skel, c) {
   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;
@@ -1221,9 +1256,10 @@ function applyPathConstraint(skel, c) {
     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 = { ...st.world };
+    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 };
@@ -1253,7 +1289,11 @@ function applyPathConstraint(skel, c) {
       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 };
     }
-    setEffectiveWorld(skel, b, st, w);
+    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) {
@@ -1282,9 +1322,14 @@ function inheritedParentLinear(bone, parent) {
     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) || 1;
+      const lenX = Math.hypot(parent.a, parent.b);
       const det = parent.a * parent.d - parent.b * parent.c;
-      return { a: lenX, b: 0, c: 0, d: Math.abs(det) / lenX, tx: 0, ty: 0 };
+      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": {
@@ -1310,7 +1355,16 @@ function setEffectiveWorld(skel, bone, st, world) {
   st.scaleY = Math.hypot(lin.c, lin.d);
   st.shearX = 0;
   st.shearY = shortest(Math.atan2(lin.d, lin.c) / DEG2 - st.rotation - 90);
-  updateSubtree(skel, bone.id);
+  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"));
@@ -1709,7 +1763,7 @@ var RigPlayer = class {
     this.clipPoints.clear();
     const skel = this.skel = evaluate(this.doc, pose, this.beforePose);
     pose = skel.pose;
-    const clips = new Set(this.doc.slots.flatMap((s) => s.clip ? [s.clip] : []));
+    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);
@@ -1736,7 +1790,8 @@ var RigPlayer = class {
     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);
-      it.node.mask = s.clip ? this.clipGraphics.get(s.clip) ?? null : null;
+      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;