@energy8platform/golem 0.1.1 → 0.2.1

package/dist/lib/editor/stage.d.ts

@@ -49,6 +49,12 @@ export declare class Stage {
     private applyDraft;
     /** push the shown pose (and slot visibility) into the player, then redraw the overlay */
     private applyPose;
+    /**
+     * The slots the selection is about — a slot, the one an attachment (or a vertex of it) hangs in, or every slot on
+     * a selected bone. The player draws them half-visible at least, so a part faded out at rest (runes that only light
+     * up in `win`) is not an invisible box of grips. Not while playing: the animation's own fade is what is watched.
+     */
+    private selectedSlots;
     private reference?;
     private referenceSrc?;
     /** the underlay is on screen — a texture loaded and the sprite visible (tests read it) */
@@ -57,6 +63,17 @@ export declare class Stage {
     private applyReference;
     private startPlayback;
     private tick;
+    /** one export at a time: two runs would interleave their seeks into the same player and produce a mixed file */
+    private exporting;
+    /**
+     * The current animation as GIF bytes — the top bar hands them to a download link, and the tests read them.
+     *
+     * Each frame is the DOCUMENT rectangle rendered on its own: `extract` REPLACES the target's transform with the
+     * frame's, so the file ignores the camera's zoom and pan and comes out at `meta.width` × `meta.height` whatever
+     * is on screen. The overlay (bones, labels, gizmos) is switched off for the duration, so nothing of the editor
+     * ends up in it; the paper stays, which is what makes every pixel opaque — GIF has no partial transparency.
+     */
+    exportGif(fps?: number): Promise<Uint8Array<ArrayBuffer> | undefined>;
     /** doc px → screen px (canvas client coords); the camera never rotates, so this is exact without a render */
     toScreen(x: number, y: number): [number, number];
     toDoc(sx: number, sy: number): [number, number];

package/dist/lib/editor/store.d.ts

@@ -1001,6 +1001,8 @@ export declare function setBoneTool(on: boolean): void;
 export declare function placeBone(from: [number, number], to: [number, number]): Promise<void>;
 /** clicks on images select their slot's bone instead — the images are "locked", as Spine puts it */
 export declare const lockImages: import("@preact/signals-core").Signal<boolean>;
+/** draw the bone overlay — lines, joints and labels. Off is for looking at the art alone; the GIF export forces it off anyway */
+export declare const showBones: import("@preact/signals-core").Signal<boolean>;
 /** collapsed panel sections by id */
 export declare const sections: import("@preact/signals-core").Signal<Record<string, boolean>>;
 export declare function toggleSection(id: string): void;

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

@@ -14,6 +14,8 @@ import { type Pose, type Affine } from "./rig-anim";
 import { AnimationState, type PlayResult } from "./rig-state";
 /** vertices per axis of a lattice-deformed region's render mesh (8 segments) */
 export declare const MESH_GRID = 9;
+/** the least alpha an editor-selected slot is drawn with, so a part faded out at rest can still be seen */
+export declare const GHOST_ALPHA = 0.5;
 export interface PlayOptions {
     loop?: boolean;
     /** crossfade seconds from current pose */
@@ -38,6 +40,8 @@ export declare class RigPlayer {
     private pages;
     /** slots the editor hides; honoured by setPose */
     private hidden;
+    /** slots the editor has selected; setPose draws them at GHOST_ALPHA at least */
+    private ghosts;
     /** `mix`: default crossfade seconds for state transitions (setBase, completion → base); play() passes its own */
     constructor(doc: RigDocument, textures: Map<string, Texture>, opts?: {
         mix?: number;
@@ -53,6 +57,8 @@ export declare class RigPlayer {
     updateDoc(doc: RigDocument): void;
     /** Editor-only: hide a slot's display object regardless of the pose (restored by passing `true`). */
     setSlotVisible(slotId: string, visible: boolean): void;
+    /** Editor-only: draw these slots at GHOST_ALPHA at least, whatever the pose says (an empty list clears it). */
+    setGhostSlots(slotIds: Iterable<string>): void;
     /** Stop playback and immediately restore the complete setup pose. */
     stop(): void;
     /** dt in seconds */

package/dist/lib/runtime.js

@@ -1311,6 +1311,7 @@ function hit(t, prev, cur, d, loop) {
 // 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) {
@@ -1400,6 +1401,8 @@ var RigPlayer = class {
   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();
   /** whole atlas page as a plain texture (identity uv mapping) for skinned meshes */
   pageTexture(tex) {
     let page = this.pages.get(tex.source);
@@ -1440,6 +1443,10 @@ var RigPlayer = class {
     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();
@@ -1464,7 +1471,8 @@ var RigPlayer = class {
       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);
-      it.node.alpha = numOf(pose, pk("slot", s.id, "alpha"), s.alpha) * color[3];
+      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) {