@energy8platform/golem 0.1.0

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

@@ -0,0 +1,1053 @@
+import { type Pose, type Skeleton } from "../rig-anim";
+import { type Reference, type RigDocument, type Track } from "../rig-format";
+import type { AnimationTemplate } from "../rig-templates";
+import { type FileEntry } from "./api";
+import { type Mask, type Rect } from "./atlas-detect";
+export type Selection = {
+    kind: "bone" | "slot" | "attachment" | "vertex" | "constraint";
+    id: string;
+    index?: number;
+};
+export type TrackRef = {
+    target: Track["target"];
+    id: string;
+    prop: string;
+};
+/** rig path relative to the server root */
+export declare const rigPath: string;
+/** the rig file's directory, "" at the root — asset `src` values are relative to it */
+export declare const rigDir: string;
+export declare const doc: import("@preact/signals-core").Signal<{
+    path: {
+        rotation: number;
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        mixRotate: number;
+        mixX: number;
+        mixY: number;
+        positionMode: "fixed" | "percent";
+        spacingMode: "length" | "fixed" | "percent" | "proportional";
+        rotateMode: "tangent" | "chain" | "chainScale";
+        position: number;
+        spacing: number;
+    }[];
+    transform: {
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        shearY: number;
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        local: boolean;
+        relative: boolean;
+        mixRotate: number;
+        mixX: number;
+        mixY: number;
+        mixScaleX: number;
+        mixScaleY: number;
+        mixShearY: number;
+    }[];
+    bones: {
+        length: number;
+        id: string;
+        transform: {
+            x: number;
+            y: number;
+            rotation: number;
+            scaleX: number;
+            scaleY: number;
+            shearX: number;
+            shearY: number;
+        };
+        inherit: "normal" | "onlyTranslation" | "noRotationOrReflection" | "noScale" | "noScaleOrReflection";
+        parent?: string | undefined;
+        role?: string | undefined;
+        color?: string | undefined;
+    }[];
+    ik: {
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        mix: number;
+        softness: number;
+        bendPositive: boolean;
+        compress: boolean;
+        stretch: boolean;
+        uniform: boolean;
+    }[];
+    format: "energy8.rig";
+    version: 2;
+    meta: {
+        width: number;
+        height: number;
+        name: string;
+        notes?: string | undefined;
+        reference?: {
+            x: number;
+            y: number;
+            src: string;
+            opacity: number;
+            scale: number;
+        } | undefined;
+    };
+    assets: {
+        id: string;
+        src: string;
+        width: number;
+        height: number;
+        rotate: 0 | 90;
+        frame?: [number, number, number, number] | undefined;
+        trim?: [number, number] | undefined;
+        origin?: {
+            inpainted: boolean;
+            sourceImage?: string | undefined;
+            bbox?: [number, number, number, number] | undefined;
+            prompt?: string | undefined;
+        } | undefined;
+    }[];
+    slots: {
+        id: string;
+        color: string;
+        bone: string;
+        alpha: number;
+        z: number;
+        blend: "normal" | "add" | "multiply" | "screen";
+        attachment?: string | undefined;
+    }[];
+    attachments: ({
+        x: number;
+        y: number;
+        type: "region";
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        id: string;
+        slot: string;
+        asset: string;
+        width?: number | undefined;
+        height?: number | undefined;
+    } | {
+        type: "mesh";
+        id: string;
+        slot: string;
+        asset: string;
+        uvs: number[];
+        triangles: number[];
+        hull: number;
+        width?: number | undefined;
+        height?: number | undefined;
+        vertices?: number[] | undefined;
+        weights?: {
+            x: number;
+            y: number;
+            bone: string;
+            w: number;
+        }[][] | undefined;
+    } | {
+        type: "path";
+        id: string;
+        slot: string;
+        lengths: number[];
+        closed: boolean;
+        constantSpeed: boolean;
+        vertices?: number[] | undefined;
+        weights?: {
+            x: number;
+            y: number;
+            bone: string;
+            w: number;
+        }[][] | undefined;
+    })[];
+    animations: {
+        id: string;
+        duration: number;
+        loop: boolean;
+        tracks: ({
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "bone";
+            prop: "x" | "y" | "rotation" | "scaleX" | "scaleY" | "shearX" | "shearY";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "slot";
+            prop: "color" | "attachment" | "alpha" | "z";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "deform";
+            prop: string;
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "ik";
+            prop: "mix" | "softness" | "bendPositive" | "compress" | "stretch";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "transform";
+            prop: "mixRotate" | "mixX" | "mixY" | "mixScaleX" | "mixScaleY" | "mixShearY";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "path";
+            prop: "mixRotate" | "mixX" | "mixY" | "position" | "spacing";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "drawOrder";
+            prop: "order";
+        })[];
+        events: {
+            t: number;
+            name: string;
+            payload?: Record<string, unknown> | undefined;
+        }[];
+        preset?: {
+            params: Record<string, unknown>;
+            name: string;
+        } | undefined;
+    }[];
+} | undefined>;
+export declare const draft: import("@preact/signals-core").Signal<{
+    path: {
+        rotation: number;
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        mixRotate: number;
+        mixX: number;
+        mixY: number;
+        positionMode: "fixed" | "percent";
+        spacingMode: "length" | "fixed" | "percent" | "proportional";
+        rotateMode: "tangent" | "chain" | "chainScale";
+        position: number;
+        spacing: number;
+    }[];
+    transform: {
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        shearY: number;
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        local: boolean;
+        relative: boolean;
+        mixRotate: number;
+        mixX: number;
+        mixY: number;
+        mixScaleX: number;
+        mixScaleY: number;
+        mixShearY: number;
+    }[];
+    bones: {
+        length: number;
+        id: string;
+        transform: {
+            x: number;
+            y: number;
+            rotation: number;
+            scaleX: number;
+            scaleY: number;
+            shearX: number;
+            shearY: number;
+        };
+        inherit: "normal" | "onlyTranslation" | "noRotationOrReflection" | "noScale" | "noScaleOrReflection";
+        parent?: string | undefined;
+        role?: string | undefined;
+        color?: string | undefined;
+    }[];
+    ik: {
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        mix: number;
+        softness: number;
+        bendPositive: boolean;
+        compress: boolean;
+        stretch: boolean;
+        uniform: boolean;
+    }[];
+    format: "energy8.rig";
+    version: 2;
+    meta: {
+        width: number;
+        height: number;
+        name: string;
+        notes?: string | undefined;
+        reference?: {
+            x: number;
+            y: number;
+            src: string;
+            opacity: number;
+            scale: number;
+        } | undefined;
+    };
+    assets: {
+        id: string;
+        src: string;
+        width: number;
+        height: number;
+        rotate: 0 | 90;
+        frame?: [number, number, number, number] | undefined;
+        trim?: [number, number] | undefined;
+        origin?: {
+            inpainted: boolean;
+            sourceImage?: string | undefined;
+            bbox?: [number, number, number, number] | undefined;
+            prompt?: string | undefined;
+        } | undefined;
+    }[];
+    slots: {
+        id: string;
+        color: string;
+        bone: string;
+        alpha: number;
+        z: number;
+        blend: "normal" | "add" | "multiply" | "screen";
+        attachment?: string | undefined;
+    }[];
+    attachments: ({
+        x: number;
+        y: number;
+        type: "region";
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        id: string;
+        slot: string;
+        asset: string;
+        width?: number | undefined;
+        height?: number | undefined;
+    } | {
+        type: "mesh";
+        id: string;
+        slot: string;
+        asset: string;
+        uvs: number[];
+        triangles: number[];
+        hull: number;
+        width?: number | undefined;
+        height?: number | undefined;
+        vertices?: number[] | undefined;
+        weights?: {
+            x: number;
+            y: number;
+            bone: string;
+            w: number;
+        }[][] | undefined;
+    } | {
+        type: "path";
+        id: string;
+        slot: string;
+        lengths: number[];
+        closed: boolean;
+        constantSpeed: boolean;
+        vertices?: number[] | undefined;
+        weights?: {
+            x: number;
+            y: number;
+            bone: string;
+            w: number;
+        }[][] | undefined;
+    })[];
+    animations: {
+        id: string;
+        duration: number;
+        loop: boolean;
+        tracks: ({
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "bone";
+            prop: "x" | "y" | "rotation" | "scaleX" | "scaleY" | "shearX" | "shearY";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "slot";
+            prop: "color" | "attachment" | "alpha" | "z";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "deform";
+            prop: string;
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "ik";
+            prop: "mix" | "softness" | "bendPositive" | "compress" | "stretch";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "transform";
+            prop: "mixRotate" | "mixX" | "mixY" | "mixScaleX" | "mixScaleY" | "mixShearY";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "path";
+            prop: "mixRotate" | "mixX" | "mixY" | "position" | "spacing";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "drawOrder";
+            prop: "order";
+        })[];
+        events: {
+            t: number;
+            name: string;
+            payload?: Record<string, unknown> | undefined;
+        }[];
+        preset?: {
+            params: Record<string, unknown>;
+            name: string;
+        } | undefined;
+    }[];
+} | undefined>;
+export declare const shown: import("@preact/signals-core").ReadonlySignal<{
+    path: {
+        rotation: number;
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        mixRotate: number;
+        mixX: number;
+        mixY: number;
+        positionMode: "fixed" | "percent";
+        spacingMode: "length" | "fixed" | "percent" | "proportional";
+        rotateMode: "tangent" | "chain" | "chainScale";
+        position: number;
+        spacing: number;
+    }[];
+    transform: {
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        shearY: number;
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        local: boolean;
+        relative: boolean;
+        mixRotate: number;
+        mixX: number;
+        mixY: number;
+        mixScaleX: number;
+        mixScaleY: number;
+        mixShearY: number;
+    }[];
+    bones: {
+        length: number;
+        id: string;
+        transform: {
+            x: number;
+            y: number;
+            rotation: number;
+            scaleX: number;
+            scaleY: number;
+            shearX: number;
+            shearY: number;
+        };
+        inherit: "normal" | "onlyTranslation" | "noRotationOrReflection" | "noScale" | "noScaleOrReflection";
+        parent?: string | undefined;
+        role?: string | undefined;
+        color?: string | undefined;
+    }[];
+    ik: {
+        id: string;
+        order: number;
+        bones: string[];
+        target: string;
+        mix: number;
+        softness: number;
+        bendPositive: boolean;
+        compress: boolean;
+        stretch: boolean;
+        uniform: boolean;
+    }[];
+    format: "energy8.rig";
+    version: 2;
+    meta: {
+        width: number;
+        height: number;
+        name: string;
+        notes?: string | undefined;
+        reference?: {
+            x: number;
+            y: number;
+            src: string;
+            opacity: number;
+            scale: number;
+        } | undefined;
+    };
+    assets: {
+        id: string;
+        src: string;
+        width: number;
+        height: number;
+        rotate: 0 | 90;
+        frame?: [number, number, number, number] | undefined;
+        trim?: [number, number] | undefined;
+        origin?: {
+            inpainted: boolean;
+            sourceImage?: string | undefined;
+            bbox?: [number, number, number, number] | undefined;
+            prompt?: string | undefined;
+        } | undefined;
+    }[];
+    slots: {
+        id: string;
+        color: string;
+        bone: string;
+        alpha: number;
+        z: number;
+        blend: "normal" | "add" | "multiply" | "screen";
+        attachment?: string | undefined;
+    }[];
+    attachments: ({
+        x: number;
+        y: number;
+        type: "region";
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        id: string;
+        slot: string;
+        asset: string;
+        width?: number | undefined;
+        height?: number | undefined;
+    } | {
+        type: "mesh";
+        id: string;
+        slot: string;
+        asset: string;
+        uvs: number[];
+        triangles: number[];
+        hull: number;
+        width?: number | undefined;
+        height?: number | undefined;
+        vertices?: number[] | undefined;
+        weights?: {
+            x: number;
+            y: number;
+            bone: string;
+            w: number;
+        }[][] | undefined;
+    } | {
+        type: "path";
+        id: string;
+        slot: string;
+        lengths: number[];
+        closed: boolean;
+        constantSpeed: boolean;
+        vertices?: number[] | undefined;
+        weights?: {
+            x: number;
+            y: number;
+            bone: string;
+            w: number;
+        }[][] | undefined;
+    })[];
+    animations: {
+        id: string;
+        duration: number;
+        loop: boolean;
+        tracks: ({
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "bone";
+            prop: "x" | "y" | "rotation" | "scaleX" | "scaleY" | "shearX" | "shearY";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "slot";
+            prop: "color" | "attachment" | "alpha" | "z";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "deform";
+            prop: string;
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "ik";
+            prop: "mix" | "softness" | "bendPositive" | "compress" | "stretch";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "transform";
+            prop: "mixRotate" | "mixX" | "mixY" | "mixScaleX" | "mixScaleY" | "mixShearY";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "path";
+            prop: "mixRotate" | "mixX" | "mixY" | "position" | "spacing";
+        } | {
+            keys: {
+                t: number;
+                v: string | number | number[] | string[] | null;
+                ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                    bezier: [number, number, number, number];
+                };
+            }[];
+            id: string;
+            target: "drawOrder";
+            prop: "order";
+        })[];
+        events: {
+            t: number;
+            name: string;
+            payload?: Record<string, unknown> | undefined;
+        }[];
+        preset?: {
+            params: Record<string, unknown>;
+            name: string;
+        } | undefined;
+    }[];
+} | undefined>;
+export declare const version: import("@preact/signals-core").Signal<string>;
+export declare const mode: import("@preact/signals-core").Signal<"setup" | "atlas" | "animate">;
+export declare const animId: import("@preact/signals-core").Signal<string | undefined>;
+export declare const time: import("@preact/signals-core").Signal<number>;
+export declare const playing: import("@preact/signals-core").Signal<boolean>;
+export declare const loop: import("@preact/signals-core").Signal<boolean>;
+export declare const overlays: import("@preact/signals-core").Signal<string[]>;
+export declare const selection: import("@preact/signals-core").Signal<Selection | undefined>;
+export declare const selectedTrack: import("@preact/signals-core").Signal<TrackRef | undefined>;
+export declare const selectedKeys: import("@preact/signals-core").Signal<number[]>;
+/**
+ * Every selected vertex of the mesh being edited, in click order — the last one is `selection.index`, so this
+ * always contains the primary vertex while `selection.kind === "vertex"` and is empty otherwise.
+ */
+export declare const selectedVertices: import("@preact/signals-core").Signal<number[]>;
+/** draw every triangle edge of the selected mesh, whatever the zoom */
+export declare const wireframe: import("@preact/signals-core").Signal<boolean>;
+/** paint skinning weights on the selected mesh instead of moving things: heatmap overlay, brush, weights panel */
+export declare const weightsMode: import("@preact/signals-core").Signal<boolean>;
+/** the weight brush — panel state, never part of the document; `radius` is document px, `strength` per stroke step */
+export declare const brush: import("@preact/signals-core").Signal<{
+    bone: string;
+    radius: number;
+    strength: number;
+    maxInfluences: number;
+}>;
+/** the bones `auto weights` in the weights panel offers as candidates (`defaultWeightBones` of the slot by default) */
+export declare const weightCandidates: import("@preact/signals-core").Signal<string[]>;
+export declare const hiddenSlots: import("@preact/signals-core").Signal<Set<string>>;
+export declare const status: import("@preact/signals-core").Signal<{
+    text: string;
+    level: "info" | "warn" | "error";
+}>;
+export declare const online: import("@preact/signals-core").Signal<boolean>;
+/** the rig file was not there at the last load — like offline until the watcher says it is back */
+export declare const blocked: import("@preact/signals-core").Signal<boolean>;
+/** the document on screen arrived from someone else's write → the status bar offers `rig_diff` */
+export declare const externalChange: import("@preact/signals-core").Signal<boolean>;
+/** the pointer in document px, undefined when it is off the scene (the Stage writes it once per frame) */
+export declare const cursor: import("@preact/signals-core").Signal<{
+    x: number;
+    y: number;
+} | undefined>;
+/** the Stage camera's scale, mirrored here for the status bar */
+export declare const zoom: import("@preact/signals-core").Signal<number>;
+/** asset `src` values whose texture failed to load (the Stage fills this, the tree marks them) */
+export declare const missingAssets: import("@preact/signals-core").Signal<Set<string>>;
+/** what the bin needs from the Stage to drop onto it: its canvas and the screen → document conversion */
+export declare const stageApi: import("@preact/signals-core").Signal<{
+    canvas: HTMLCanvasElement;
+    toDoc(sx: number, sy: number): [number, number];
+} | undefined>;
+/** the file is reachable and writable: no commit and no gizmo drag outside this */
+export declare const editable: import("@preact/signals-core").ReadonlySignal<boolean>;
+/** a pointer gesture is in progress → defer external reloads */
+export declare const gesture: import("@preact/signals-core").Signal<boolean>;
+/** version announced while a gesture ran */
+export declare const pendingExternal: import("@preact/signals-core").Signal<string | undefined>;
+/**
+ * A `changed` version from the watcher. Ours is ignored; one that arrives while a commit is in flight is parked
+ * until that commit's response says which version it wrote; anything else reloads (deferred while a gesture runs,
+ * so a drag is never yanked out from under the cursor).
+ */
+export declare function noteChanged(v: string): void;
+export declare const currentAnim: import("@preact/signals-core").ReadonlySignal<{
+    id: string;
+    duration: number;
+    loop: boolean;
+    tracks: ({
+        keys: {
+            t: number;
+            v: string | number | number[] | string[] | null;
+            ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                bezier: [number, number, number, number];
+            };
+        }[];
+        id: string;
+        target: "bone";
+        prop: "x" | "y" | "rotation" | "scaleX" | "scaleY" | "shearX" | "shearY";
+    } | {
+        keys: {
+            t: number;
+            v: string | number | number[] | string[] | null;
+            ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                bezier: [number, number, number, number];
+            };
+        }[];
+        id: string;
+        target: "slot";
+        prop: "color" | "attachment" | "alpha" | "z";
+    } | {
+        keys: {
+            t: number;
+            v: string | number | number[] | string[] | null;
+            ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                bezier: [number, number, number, number];
+            };
+        }[];
+        id: string;
+        target: "deform";
+        prop: string;
+    } | {
+        keys: {
+            t: number;
+            v: string | number | number[] | string[] | null;
+            ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                bezier: [number, number, number, number];
+            };
+        }[];
+        id: string;
+        target: "ik";
+        prop: "mix" | "softness" | "bendPositive" | "compress" | "stretch";
+    } | {
+        keys: {
+            t: number;
+            v: string | number | number[] | string[] | null;
+            ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                bezier: [number, number, number, number];
+            };
+        }[];
+        id: string;
+        target: "transform";
+        prop: "mixRotate" | "mixX" | "mixY" | "mixScaleX" | "mixScaleY" | "mixShearY";
+    } | {
+        keys: {
+            t: number;
+            v: string | number | number[] | string[] | null;
+            ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                bezier: [number, number, number, number];
+            };
+        }[];
+        id: string;
+        target: "path";
+        prop: "mixRotate" | "mixX" | "mixY" | "position" | "spacing";
+    } | {
+        keys: {
+            t: number;
+            v: string | number | number[] | string[] | null;
+            ease: "linear" | "step" | "ease_in" | "ease_out" | "ease_in_out" | "back_out" | "elastic_out" | {
+                bezier: [number, number, number, number];
+            };
+        }[];
+        id: string;
+        target: "drawOrder";
+        prop: "order";
+    })[];
+    events: {
+        t: number;
+        name: string;
+        payload?: Record<string, unknown> | undefined;
+    }[];
+    preset?: {
+        params: Record<string, unknown>;
+        name: string;
+    } | undefined;
+} | undefined>;
+/** pose shown when not playing: poseOf(currentAnim, time) in animate mode, rest otherwise */
+export declare const pose: import("@preact/signals-core").ReadonlySignal<Pose>;
+/**
+ * The evaluated skeleton of what is on screen — posed bone locals and world matrices, constraints applied.
+ * A `computed` memoizes on (shown, pose), so the Stage's gizmos and hit-tests, the properties panel and anything
+ * else all share one evaluation per frame instead of reaching into the Stage for it.
+ */
+export declare const skeleton: import("@preact/signals-core").ReadonlySignal<Skeleton | undefined>;
+/**
+ * Bone id → the constraints that WRITE that bone, in the order the solver applies them (so the last id in a list
+ * is the one whose value survives). The Stage reads it to refuse — or redirect — a drag the solver would overwrite.
+ */
+export declare const drivenBy: import("@preact/signals-core").ReadonlySignal<Map<string, string[]>>;
+/**
+ * Slot ids front-most first — the Stage's draw key: the drawOrder key at the playhead in animate, else z; ties
+ * break by the shown attachment's position in `d.attachments`, exactly like `Stage.drawOrder` (and the runtime,
+ * which sorts attachments the same way) — they never compare slots directly, so breaking ties by SLOT document
+ * order instead would let this list and the canvas disagree whenever two slots share a z, which the z field
+ * makes easy to produce. A slot showing nothing has no attachment to rank by and never draws, so its position
+ * among other empty/hidden slots is cosmetic: it falls back to its own slot index.
+ */
+export declare const drawOrderFront: import("@preact/signals-core").ReadonlySignal<string[]>;
+export declare function setStatus(text: string, level?: "info" | "warn" | "error"): void;
+/**
+ * End a pointer gesture (Stage handles, timeline drags): the flag drops first, then a file change that arrived
+ * while the gesture ran is taken — as an *external* reload, so the status bar says so and offers the diff.
+ */
+export declare function finishGesture(): Promise<void>;
+/**
+ * Point the vertex selection at `indices` of one mesh (in click order) and return the selection the caller should
+ * store: the LAST index is the primary one, and an empty list falls back to the mesh itself. Written before
+ * `selection` so the effect below recognises it as the same mesh and keeps the list.
+ */
+export declare function selectVertices(id: string, indices: number[]): Selection;
+/** the mesh the selection is working on — the attachment itself, or the mesh one of whose vertices is selected */
+export declare const selectedMesh: import("@preact/signals-core").ReadonlySignal<{
+    type: "mesh";
+    id: string;
+    slot: string;
+    asset: string;
+    uvs: number[];
+    triangles: number[];
+    hull: number;
+    width?: number | undefined;
+    height?: number | undefined;
+    vertices?: number[] | undefined;
+    weights?: {
+        x: number;
+        y: number;
+        bone: string;
+        w: number;
+    }[][] | undefined;
+} | undefined>;
+/**
+ * Enter or leave weights mode. Only a mesh selection can be painted, so turning it on anywhere else is refused
+ * (with a reason, since the key and the button are the same gesture); entering aims the brush at the mesh's own
+ * slot bone while it has no usable one — a bone the user picked by hand survives the next mesh — and fills the
+ * candidate list from the mesh's default bones whenever the mesh it was filled for is not this one.
+ *
+ * Weights mode is a SETUP tool: influences hold the vertex in each bone's local space, so painting against a
+ * posed skeleton would bake the pose into the file. Entering from animate switches to setup rather than refusing
+ * — the user asked to paint, and the rest pose is the only place that means anything.
+ */
+export declare function setWeightsMode(on: boolean): void;
+/** library templates fetched by name (`rig_get_preset`), so the panel can preview param changes locally */
+export declare const templates: import("@preact/signals-core").Signal<Map<string, AnimationTemplate>>;
+/**
+ * The library template named `name`, from the cache or from the server (read-only: `rig_get_preset` does not
+ * write, so it goes through `callTool` rather than `commit`). `undefined` for a built-in preset or an unknown name.
+ */
+export declare function ensureTemplate(name: string): Promise<AnimationTemplate | undefined>;
+/** the editing frame rate — the playhead snaps to this grid when stepped */
+export declare const FPS = 30;
+/** step the playhead by n frames, snapped to the frame grid and clamped to [0, duration]; stops playback */
+export declare function stepFrames(n: number): void;
+/** play/pause the current animation; with nothing to play it only warns (the Stage stops playback outside animate mode) */
+export declare function togglePlay(): void;
+/**
+ * POST a tool call; on success replaces doc/version, drops the preview it was made from, reports the tool's
+ * "changed:" lines. Only THAT preview is dropped: a drag started while the call was in flight owns `draft` now,
+ * and wiping it would snap the view back under the user's cursor.
+ * The call carries the version it was made against, so a write another process has moved on from is refused (409)
+ * instead of clobbering it — `false` comes back, with that other writer's document already on screen.
+ */
+export declare function commit(tool: string, args: Record<string, unknown>): Promise<boolean>;
+/**
+ * GET the document (at start and after an external change); keeps selection / animId / time when still valid.
+ * `external` marks a reload caused by someone else's write: it is reported, and the status bar offers the diff.
+ */
+export declare function reload(external?: boolean): Promise<void>;
+/** the bone a placed part goes on: the selected bone, else the selection's slot bone, else the root */
+export declare function boneForPlacement(): string | undefined;
+/** `rig_place_asset` at a document point; placement is a setup property, so animate refuses with a reason */
+export declare function placeAsset(asset: string, x: number, y: number, bone?: string | undefined): Promise<void>;
+/** the bone tool: a press is the joint, a drag the direction and length; a selected part re-binds onto the new bone */
+export declare const boneTool: import("@preact/signals-core").Signal<boolean>;
+export declare function setBoneTool(on: boolean): void;
+/**
+ * The bone a drag from `from` to `to` (document points) describes, committed: under the selected bone, or the
+ * selected part's bone (which then re-binds onto the new one), or the root. The id is asked for, like the tree's
+ * "add child bone".
+ */
+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>;
+/** collapsed panel sections by id */
+export declare const sections: import("@preact/signals-core").Signal<Record<string, boolean>>;
+export declare function toggleSection(id: string): void;
+/** the PNGs beside the rig (`/api/files`); refreshed after an upload and on every reload */
+export declare const files: import("@preact/signals-core").Signal<FileEntry[]>;
+export declare function refreshFiles(): Promise<void>;
+/** a prompted id, or undefined when the user cancelled or typed something the format would reject */
+export declare function askId(what: string, suggestion?: string): string | undefined;
+/** `Sheet-01.png` → `sheet_01`; an id the format accepts, from a file name */
+export declare const idFromFile: (name: string) => string;
+/** a reference underlay fitted inside the canvas and centred: `{src, opacity 0.5, x, y, scale}` */
+export declare function fitReference(d: RigDocument, f: FileEntry): Reference;
+export declare const atlasSrc: import("@preact/signals-core").Signal<string | undefined>;
+/** the alpha of the open sheet — the AtlasView fills it once the image is decoded */
+export declare const atlasMask: import("@preact/signals-core").Signal<Mask | undefined>;
+/** the open sheet could not be decoded (the AtlasView says why) — so an empty `atlasMask` is not "still loading" */
+export declare const atlasFailed: import("@preact/signals-core").Signal<boolean>;
+/** rectangles detected or drawn but not yet named — editor memory, per sheet, for this page's lifetime */
+export declare const proposed: import("@preact/signals-core").Signal<{
+    key: string;
+    rect: Rect;
+}[]>;
+/** keys: an asset id, or a proposed `p<n>` */
+export declare const atlasSelected: import("@preact/signals-core").Signal<string[]>;
+/** drawn and resized rectangles shrink to the opaque pixels inside them */
+export declare const snap: import("@preact/signals-core").Signal<boolean>;
+export declare const detectGap: import("@preact/signals-core").Signal<number>;
+export declare const detectMinArea: import("@preact/signals-core").Signal<number>;
+export type AtlasRect = {
+    key: string;
+    id?: string;
+    rect: Rect;
+};
+/** named rectangles are the document's framed assets of this sheet; proposed ones follow */
+export declare const atlasRects: import("@preact/signals-core").ReadonlySignal<AtlasRect[]>;
+/** show `src` in atlas mode; another sheet's proposals are parked under its name and come back with it */
+export declare function openAtlas(src: string): void;
+export declare function addProposed(rect: Rect): string;
+/** islands of the open sheet → the proposal list (named rectangles stay; islands inside one are not proposed) */
+export declare function runDetect(): void;
+/** `snap`: shrink to the opaque pixels inside; undefined = nothing opaque there */
+export declare function snapped(rect: Rect): Rect | undefined;
+export declare function setRect(key: string, rect: Rect): Promise<void>;
+/** a proposed rectangle becomes an asset of the sheet (and leaves the proposals); a named one is renamed */
+export declare function nameRect(key: string, id: string): Promise<void>;
+export declare function removeRect(key: string): Promise<void>;
+/** Delete: every selected rectangle, one commit at a time so each write builds on the last */
+export declare function removeSelectedRects(): Promise<void>;
+/** the selected rectangles become their union — the first named one keeps its name, the others go */
+export declare function mergeSelected(): Promise<void>;