@energy8platform/golem 0.6.0 → 0.8.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-symbol.d.ts

@@ -2,7 +2,8 @@
  * rig-symbol — a rig as a slot symbol view for @energy8platform/game-engine (SymbolView, engine ≥ 0.43: square or rectangular cells).
  *
  * The interface is copied structurally (playIdle / playWin / showStatic / resize) so this package does not
- * depend on the engine. Centred at the origin and scaled so the rig canvas fits the cell, like AnimatedSymbol.
+ * depend on the engine. Centred at the origin and scaled so the rig's parts at rest fit the cell, like a static sprite
+ * symbol: the canvas margin left for the motion does not shrink it (a rig with nothing visible at rest fits its canvas).
  * `setDim(on)` is an extra for non-winning symbols. Updated through a ticker (Ticker.shared by default).
  */
 import { Container, type Texture } from "pixi.js";
@@ -22,7 +23,7 @@ export type SymbolSize = number | {
     height: number;
 };
 export interface RigSymbolOptions {
-    /** cell size in px: a number scales the larger canvas side to it, a rectangle fits the canvas inside it */
+    /** cell size in px: a number scales the larger side of the parts at rest to it, a rectangle fits them inside it */
     size: SymbolSize;
     /** animation ids to use; missing ones are skipped gracefully */
     animations?: {
@@ -47,6 +48,8 @@ export declare class RigSymbol extends Container implements SymbolViewLike {
     private readonly names;
     private readonly ticker;
     private readonly onTick;
+    /** the parts at rest in the player's own space, measured before anything plays */
+    private readonly rest;
     constructor(doc: RigDocument, textures: Map<string, Texture>, opts: RigSymbolOptions);
     private has;
     resize(size: SymbolSize): void;

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

@@ -258,7 +258,8 @@ export declare function setKeys(doc: Doc, animId: string, track: Omit<Track, "ke
 }): Doc;
 /**
  * Re-tune one existing track without retyping keys: `amplitude` scales deviations from the rest value
- * (scale props as ratios), `offset` adds a constant, `timeScale` stretches key times (duration grows to fit).
+ * (scale props as ratios), `offset` adds a constant, `timeScale` stretches key times (duration grows to fit);
+ * `track.interpolation`, when given, replaces the track's.
  */
 export declare function adjustTrack(doc: Doc, animId: string, track: Omit<Track, "keys">, adj: {
     amplitude?: number;

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

@@ -229,7 +229,7 @@ var Key = z.object({
   /** 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 Interpolation = { interpolation: z.enum(["segment", "pchip", "spline"]).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) }),
@@ -650,6 +650,57 @@ function smoothValue(track, i, t, component, loop) {
   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 tridiagonal(a, b, c, r) {
+  const n = b.length, cp = [], x = [];
+  let beta = b[0];
+  x[0] = r[0] / beta;
+  for (let i = 1; i < n; i++) {
+    cp[i] = c[i - 1] / beta;
+    beta = b[i] - a[i] * cp[i];
+    x[i] = (r[i] - a[i] * x[i - 1]) / beta;
+  }
+  for (let i = n - 2; i >= 0; i--) x[i] -= cp[i + 1] * x[i + 1];
+  return x;
+}
+function splineMoments(t, v, periodic) {
+  const n = t.length, h = (j) => t[j + 1] - t[j], d = (j) => (v[j + 1] - v[j]) / h(j);
+  if (!periodic) {
+    const a2 = [], b2 = [], c2 = [], r2 = [];
+    for (let i = 0; i < n; i++) {
+      const hp = i > 0 ? h(i - 1) : 0, hn = i < n - 1 ? h(i) : 0;
+      a2.push(hp);
+      b2.push(2 * (hp + hn));
+      c2.push(hn);
+      r2.push(6 * ((i < n - 1 ? d(i) : 0) - (i > 0 ? d(i - 1) : 0)));
+    }
+    return tridiagonal(a2, b2, c2, r2);
+  }
+  const m = n - 1, a = [], b = [], c = [], r = [];
+  for (let i = 0; i < m; i++) {
+    const p = (i + m - 1) % m;
+    a.push(h(p));
+    b.push(2 * (h(p) + h(i)));
+    c.push(h(i));
+    r.push(6 * (d(i) - d(p)));
+  }
+  const top = a[0], bottom = c[m - 1], gamma = -b[0];
+  const bb = [...b];
+  bb[0] -= gamma;
+  bb[m - 1] -= bottom * top / gamma;
+  const x = tridiagonal(a, bb, c, r), u = new Array(m).fill(0);
+  u[0] = gamma;
+  u[m - 1] = bottom;
+  const z2 = tridiagonal(a, bb, c, u);
+  const f = (x[0] + top * x[m - 1] / gamma) / (1 + z2[0] + top * z2[m - 1] / gamma);
+  const M = x.map((xi, i) => xi - f * z2[i]);
+  return [...M, M[0]];
+}
+function splineValue(track, i, t, component, loop) {
+  const k = track.keys, ts = k.map((x) => x.t), vs = k.map((x) => component === void 0 ? x.v : x.v[component]);
+  const M = splineMoments(ts, vs, loop && k.length > 3 && vs[0] === vs[k.length - 1]);
+  const H = ts[i + 1] - ts[i], A = (ts[i + 1] - t) / H, B = (t - ts[i]) / H;
+  return A * vs[i] + B * vs[i + 1] + ((A ** 3 - A) * M[i] + (B ** 3 - B) * M[i + 1]) * H * H / 6;
+}
 function sample(track, t, loop = false) {
   const keys = track.keys;
   if (t <= keys[0].t) return keys[0].v;
@@ -661,11 +712,13 @@ function sample(track, t, loop = false) {
   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);
+    if (track.interpolation === "spline") return splineValue(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));
+    if (track.interpolation === "spline") return a.v.map((_, j) => splineValue(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));
   }
@@ -1869,6 +1922,8 @@ var RigSymbol = class extends Container2 {
     this.names = { idle: "idle", win: "win", dim: "dim", ...opts.animations };
     this.ticker = opts.ticker ?? Ticker.shared;
     this.addChild(this.player.view);
+    const r = this.player.view.getLocalBounds();
+    this.rest = r.width > 0 && r.height > 0 ? { x: r.x, y: r.y, width: r.width, height: r.height } : { x: 0, y: 0, ...doc.meta };
     this.resize(opts.size);
     this.ticker.add(this.onTick);
   }
@@ -1876,14 +1931,16 @@ var RigSymbol = class extends Container2 {
   names;
   ticker;
   onTick = (t) => this.player.tick(t.deltaMS / 1e3);
+  /** the parts at rest in the player's own space, measured before anything plays */
+  rest;
   has(id) {
     return this.doc.animations.some((a) => a.id === id);
   }
   resize(size) {
-    const { width, height } = this.doc.meta;
+    const { x, y, width, height } = this.rest;
     const s = typeof size === "number" ? size / Math.max(width, height) : Math.min(size.width / width, size.height / height);
     this.player.view.scale.set(s);
-    this.player.view.position.set(-width * s / 2, -height * s / 2);
+    this.player.view.position.set(-(x + width / 2) * s, -(y + height / 2) * s);
   }
   playIdle() {
     if (this.has(this.names.idle)) this.player.state.setBase(this.names.idle);