@oh-just-another/state 0.57.0

package/dist/actions/registry.js

@@ -0,0 +1,300 @@
+import { isMac } from "../platform.js";
+import { SEQUENCE_HOTKEY_WINDOW_MS } from "../constants.js";
+import { historyActions } from "./actionHistory.js";
+import { selectionActions } from "./actionSelection.js";
+import { clipboardActions } from "./actionClipboard.js";
+import { zOrderActions } from "./actionZOrder.js";
+import { groupingActions } from "./actionGrouping.js";
+import { zoomActions } from "./actionZoom.js";
+import { modeActions } from "./actionMode.js";
+import { keyboardActions } from "./actionKeyboard.js";
+import { layoutActions } from "./actionLayout.js";
+import { viewActions } from "./actionView.js";
+/**
+ * Registry of actions. Hosts construct one (or use the shared
+ * `defaultActionRegistry` populated by `registerBuiltinActions`),
+ * register custom actions on top, and pass it to the hotkey listener
+ * + context menu builder. Order of registration is preserved so
+ * `dispatchHotkey` returns the first match.
+ */
+export class ActionRegistry {
+    entries = new Map();
+    /** Registered keys for ordered iteration on dispatch. */
+    order = [];
+    /**
+     * Rolling buffer of recent plain keypresses (key + event timestamp) for
+     * matching multi-key `sequence` actions like `g d`. Pruned to the
+     * `SEQUENCE_HOTKEY_WINDOW_MS` window on each feed; cleared on a match or
+     * when a modifier combo interrupts the chain.
+     */
+    seqBuffer = [];
+    register(action) {
+        if (this.entries.has(action.id)) {
+            throw new Error(`Action already registered: ${action.id}`);
+        }
+        this.entries.set(action.id, action);
+        this.order.push(action.id);
+    }
+    /** Re-registering the same id overwrites it in place. */
+    replace(action) {
+        if (this.entries.has(action.id)) {
+            this.entries.set(action.id, action);
+            return;
+        }
+        this.register(action);
+    }
+    unregister(id) {
+        if (!this.entries.delete(id))
+            return;
+        const idx = this.order.indexOf(id);
+        if (idx !== -1)
+            this.order.splice(idx, 1);
+    }
+    get(id) {
+        return this.entries.get(id);
+    }
+    getAll() {
+        return this.order
+            .map((id) => this.entries.get(id))
+            .filter((a) => a !== undefined);
+    }
+    /**
+     * Dispatch by id. Returns `true` if an action ran (predicate passed
+     * AND perform was called), `false` otherwise.
+     */
+    dispatch(id, ctx) {
+        const action = this.entries.get(id);
+        if (!action)
+            return false;
+        if (action.predicate && !action.predicate(ctx))
+            return false;
+        action.perform(ctx);
+        return true;
+    }
+    /**
+     * Match the keyboard event against every registered action's
+     * `hotkey` matcher(s) and dispatch the first whose predicate
+     * passes. Returns `true` on hit (caller should `preventDefault`),
+     * `false` when no action matched.
+     *
+     * Honours platform convention for `meta`: on macOS the
+     * platform's Cmd key (event.metaKey) qualifies; elsewhere it's
+     * Ctrl (event.ctrlKey).
+     */
+    dispatchHotkey(event, ctx) {
+        const fullCtx = { ...ctx, event };
+        // 1. Multi-key sequences (g d, …) — checked first so the final key
+        //    can't also fire a single-key action bound to the same letter.
+        if (this.trySequence(event, fullCtx))
+            return true;
+        for (const id of this.order) {
+            const action = this.entries.get(id);
+            if (!action)
+                continue;
+            // 2. Custom keyTest escape hatch (before declarative matchers).
+            if (action.keyTest?.(event, fullCtx)) {
+                if (action.predicate && !action.predicate(fullCtx))
+                    continue;
+                action.perform(fullCtx);
+                return true;
+            }
+            // 3. Declarative single-key matchers.
+            if (!action.hotkey)
+                continue;
+            const matchers = Array.isArray(action.hotkey)
+                ? action.hotkey
+                : [action.hotkey];
+            for (const m of matchers) {
+                if (!matchesHotkey(event, m))
+                    continue;
+                if (action.predicate && !action.predicate(fullCtx))
+                    continue;
+                action.perform(fullCtx);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Feed the event into the sequence buffer and dispatch the first action
+     * whose `sequence` the buffer's tail now completes (within the time
+     * window). Only plain keypresses (single char, no Meta/Ctrl/Alt) chain;
+     * any modifier combo clears the buffer so `g`-then-`Cmd+d` can't match.
+     */
+    trySequence(event, ctx) {
+        const plain = event.key.length === 1 && !event.metaKey && !event.ctrlKey && !event.altKey;
+        if (!plain) {
+            this.seqBuffer = [];
+            return false;
+        }
+        const t = event.timeStamp;
+        this.seqBuffer = this.seqBuffer.filter((e) => t - e.t <= SEQUENCE_HOTKEY_WINDOW_MS);
+        // Keep key AND code so the match is layout-independent (a Cyrillic
+        // layout's physical G/D still complete a "g d" sequence via `code`).
+        this.seqBuffer.push({ key: event.key, code: event.code, t });
+        for (const id of this.order) {
+            const action = this.entries.get(id);
+            if (!action?.sequence || action.sequence.length === 0)
+                continue;
+            const seq = action.sequence;
+            const tail = this.seqBuffer.slice(-seq.length);
+            if (tail.length !== seq.length)
+                continue;
+            if (!tail.every((e, i) => matchKeyOrCodeRaw(e.key, e.code, seq[i] ?? "")))
+                continue;
+            if (action.predicate && !action.predicate(ctx))
+                continue;
+            this.seqBuffer = [];
+            action.perform(ctx);
+            return true;
+        }
+        return false;
+    }
+}
+const matchesHotkey = (event, m) => {
+    if (m.key !== undefined && !matchKeyOrCode(event, m.key))
+        return false;
+    if (m.code !== undefined && event.code !== m.code)
+        return false;
+    const want = (flag) => flag === true;
+    // Cross-platform meta: macOS uses metaKey, others use ctrlKey.
+    const metaPressed = isMac ? event.metaKey : event.ctrlKey;
+    if (want(m.meta) !== metaPressed)
+        return false;
+    if (want(m.shift) !== event.shiftKey)
+        return false;
+    if (want(m.alt) !== event.altKey)
+        return false;
+    if (m.ctrl !== undefined && want(m.ctrl) !== event.ctrlKey)
+        return false;
+    return true;
+};
+/**
+ * Hotkey-key match that survives non-Latin keyboard layouts.
+ *
+ *   1. First try direct `event.key.toLowerCase()` comparison.
+ *      Latin-letter layouts (US, UK, German, French, Czech, Turkish,
+ *      Pinyin IME, …) provide the matcher's expected letter through
+ *      `event.key` even when the underlying physical key is somewhere
+ *      else, so this is the right comparison for them.
+ *
+ *   2. If `event.key` IS itself a Latin letter (a-z) and didn't
+ *      match — bail. The user pressed a *different* Latin letter
+ *      from the one the matcher wants — e.g. Czech layout swaps
+ *      physical Y / Z, so pressing Y yields `key:'y'` even though
+ *      `code:'KeyZ'`; we must NOT silently rewrite that to the Z
+ *      hotkey.
+ *
+ *   3. Otherwise (`event.key` is Cyrillic, Greek, Hebrew, Arabic,
+ *      a CJK glyph, etc) fall back to `event.code` — the
+ *      physical-key identifier that is layout-invariant. `KeyZ` is
+ *      always the key in the Latin-Z position no matter what label
+ *      the OS prints on it.
+ *
+ * Special keys (Escape, ArrowLeft, Enter, F1, …) match through
+ * step 1 because their `event.key` is stable across layouts.
+ *
+ * Pinyin / Cangjie / Japanese IMEs: Cmd-modified key presses
+ * usually deliver the underlying Latin letter through `event.key`
+ * (because the IME is bypassed), so they hit step 1. The few that
+ * deliver an IME glyph instead are caught by step 3.
+ */
+const matchKeyOrCode = (event, want) => matchKeyOrCodeRaw(event.key, event.code, want);
+/**
+ * Layout-independent key match on raw (`key`, `code`) — the core of
+ * {@link matchKeyOrCode}, also used by sequence matching where we only kept
+ * the key/code, not the whole event. Same rules: prefer `key`, bail on a
+ * mismatching Latin letter, else fall back to the physical `code` (so a
+ * Cyrillic/Greek/etc layout still triggers a Latin-letter shortcut).
+ */
+const matchKeyOrCodeRaw = (key, code, want) => {
+    if (key.toLowerCase() === want.toLowerCase())
+        return true;
+    // Bail when the user pressed a *different* Latin letter — we'd
+    // otherwise hijack layouts that swap physical key positions
+    // (Czech Y/Z, French QWERTY-AZERTY, etc).
+    if (isLatinChar(key))
+        return false;
+    const expectedCode = codeForKey(want);
+    return expectedCode !== null && code === expectedCode;
+};
+const isLatinChar = (s) => /^[a-z]$/i.test(s);
+/**
+ * Map a host-declared `key` literal to the `event.code` we'd see
+ * when the same physical key is pressed on any layout. Returns
+ * `null` for keys whose `code` we don't (or shouldn't) try to
+ * derive — those are matched through `event.key` only.
+ */
+const codeForKey = (key) => {
+    if (key.length !== 1)
+        return null;
+    const c = key.toLowerCase();
+    if (c >= "a" && c <= "z")
+        return `Key${c.toUpperCase()}`;
+    if (c >= "0" && c <= "9")
+        return `Digit${c}`;
+    // Punctuation that commonly carries a host-declared hotkey
+    // (Cmd+[, Cmd+], Cmd+/, Cmd+., Cmd+, Cmd+- Cmd+= Cmd+;).
+    switch (c) {
+        case "[":
+            return "BracketLeft";
+        case "]":
+            return "BracketRight";
+        case ",":
+            return "Comma";
+        case ".":
+            return "Period";
+        case "/":
+            return "Slash";
+        case ";":
+            return "Semicolon";
+        case "'":
+            return "Quote";
+        case "`":
+            return "Backquote";
+        case "-":
+            return "Minus";
+        case "=":
+            return "Equal";
+        case "\\":
+            return "Backslash";
+        default:
+            return null;
+    }
+};
+/**
+ * Register the kernel's built-in actions on the given registry.
+ * Pure side-effect — call once at host bootstrap (or use
+ * `defaultActionRegistry` which has them pre-registered).
+ *
+ * Covers: undo / redo, clipboard (copy / cut / paste), selection
+ * (all / clear / duplicate / delete), z-order (front / back),
+ * grouping (group / ungroup), zoom (in / out / reset / fit),
+ * mode switching (select / hand / draw-rect / draw-ellipse /
+ * draw-edge / brush), tool-lock toggle, cancel. Anything host-
+ * specific (Save / Load / Export) is registered by the host on top.
+ */
+export const registerBuiltinActions = (registry) => {
+    const allBuiltins = [
+        ...historyActions,
+        ...selectionActions,
+        ...clipboardActions,
+        ...zOrderActions,
+        ...groupingActions,
+        ...zoomActions,
+        ...modeActions,
+        ...keyboardActions,
+        ...layoutActions,
+        ...viewActions,
+    ];
+    for (const action of allBuiltins) {
+        registry.register(action);
+    }
+};
+/**
+ * Shared registry with built-in actions pre-registered. Hosts can add
+ * more on top via `register` or replace existing ones via `replace`.
+ */
+export const defaultActionRegistry = new ActionRegistry();
+registerBuiltinActions(defaultActionRegistry);
+//# sourceMappingURL=registry.js.map

package/dist/actions/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/actions/registry.ts"],"names":[],"mappings":"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"}

package/dist/actions/types.d.ts

@@ -0,0 +1,103 @@
+import type { Editor } from "../editor.js";
+/**
+ * Action architecture. Every host-facing imperative command (undo, copy,
+ * switch-mode, group, …) is wrapped as an `Action` and registered in an
+ * `ActionRegistry`. Hotkeys, context menu, and toolbar all dispatch through
+ * the same registry, so a host extension that registers a new action gets the
+ * keyboard + menu wiring for free if it provides the right metadata.
+ */
+export interface ActionContext {
+    /** The live editor — every action operates against it. */
+    readonly editor: Editor;
+    /**
+     * The originating event when the action was dispatched via
+     * `dispatchHotkey`. Hosts can read modifier state from it; absent
+     * when the action was triggered from UI (button / menu).
+     */
+    readonly event?: KeyboardEvent | undefined;
+}
+/**
+ * Keyboard descriptor — matched against a `KeyboardEvent` in
+ * `dispatchHotkey`. `key` is case-insensitive against `event.key`;
+ * `code` uses `event.code` (layout-independent — handy for non-latin
+ * keyboards). At least one of `key` / `code` must be set.
+ *
+ * `meta` defaults to `false` when omitted. Use the same modifier
+ * idiom on macOS and Linux/Windows — `meta: true` matches Cmd on
+ * macOS and Ctrl on the others. To target Ctrl specifically (e.g.
+ * for the Linux-only convention) set `ctrl: true` and `meta: false`.
+ */
+export interface HotkeyMatcher {
+    readonly key?: string;
+    readonly code?: string;
+    /** Cmd on macOS, Ctrl on Linux/Windows. */
+    readonly meta?: boolean;
+    readonly shift?: boolean;
+    readonly alt?: boolean;
+    readonly ctrl?: boolean;
+}
+/**
+ * Category groups Actions in the help dialog / menus.
+ */
+export type ActionCategory = "history" | "selection" | "clipboard" | "z-order" | "grouping" | "zoom" | "mode" | "layout" | "edit" | "other";
+export interface Action {
+    /** Stable identifier — used by context menu / hotkey routing. */
+    readonly id: string;
+    /** Display label for menus / tooltips. */
+    readonly label?: string;
+    /** Category for grouping in help dialog / menus. */
+    readonly category?: ActionCategory;
+    /** Hotkey trigger; multiple matchers allowed (e.g. ⌘Z and Ctrl+Z). */
+    readonly hotkey?: HotkeyMatcher | readonly HotkeyMatcher[];
+    /**
+     * Multi-key SEQUENCE trigger — the keys (plain, no modifiers) must be
+     * pressed in order within `SEQUENCE_HOTKEY_WINDOW_MS` (e.g.
+     * `["g", "d"]` to toggle the debug panel, vim/Gmail style). Matched
+     * case-insensitively against `event.key`. Sequences are checked before
+     * single-key `hotkey` / `keyTest` so the final key can't double-fire.
+     */
+    readonly sequence?: readonly string[];
+    /**
+     * Escape hatch for hotkeys the declarative `hotkey` / `sequence` can't
+     * express (modifier combos with custom logic, contextual triggers).
+     * Returns `true` to claim the event. Checked after `sequence` and
+     * before the declarative `hotkey` matchers.
+     */
+    readonly keyTest?: (event: KeyboardEvent, ctx: ActionContext) => boolean;
+    /**
+     * `true` when the action makes sense in the current state — used
+     * by menus to gate visibility AND by `dispatch` to short-circuit
+     * a no-op trigger. Defaults to "always true" when omitted.
+     */
+    readonly predicate?: (ctx: ActionContext) => boolean;
+    /**
+     * Toggle state for `uiKind: "toggle"` actions (e.g. is the debug panel
+     * open, is snap on). Read by the UI to render the pressed/checked state.
+     * Pure read of editor / host state.
+     */
+    readonly checked?: (ctx: ActionContext) => boolean;
+    /**
+     * Serializable UI metadata so `react-ui` can render the action without
+     * the kernel importing React. `iconId` keys an icon registry on the UI
+     * side; `uiKind` picks the control shape.
+     */
+    readonly iconId?: string;
+    readonly uiKind?: "button" | "toggle" | "menu-item";
+    /**
+     * When `true`, the action stays available in read-only / view mode.
+     * Default (absent) → hidden in view mode.
+     */
+    readonly viewMode?: boolean;
+    /** The actual work — receives the editor and (optionally) the event. */
+    readonly perform: (ctx: ActionContext) => void;
+}
+/** Shared predicate — "element selection is non-empty". */
+export declare const hasSelection: (ctx: ActionContext) => boolean;
+/**
+ * Predicate — "anything deletable is selected": elements OR one-or-more
+ * links. Links live in a parallel selection set (`editor.selectedLinks`), so
+ * a link-only (incl. multi-link) selection must still enable Delete/Backspace.
+ * `deleteSelected()` removes every selected link; this just opens the gate.
+ */
+export declare const hasSelectionOrLink: (ctx: ActionContext) => boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/actions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/actions/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CAC5C;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,SAAS,GACT,WAAW,GACX,WAAW,GACX,SAAS,GACT,UAAU,GACV,MAAM,GACN,MAAM,GACN,QAAQ,GACR,MAAM,GACN,OAAO,CAAC;AAEZ,MAAM,WAAW,MAAM;IACrB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IACnC,sEAAsE;IACtE,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,SAAS,aAAa,EAAE,CAAC;IAC3D;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC;IACzE;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC;IACrD;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC;IACnD;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAC;IACpD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,IAAI,CAAC;CAChD;AAED,2DAA2D;AAC3D,eAAO,MAAM,YAAY,GAAI,KAAK,aAAa,KAAG,OAAwC,CAAC;AAE3F;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,aAAa,KAAG,OACY,CAAC"}

package/dist/actions/types.js

@@ -0,0 +1,10 @@
+/** Shared predicate — "element selection is non-empty". */
+export const hasSelection = (ctx) => ctx.editor.selection.size > 0;
+/**
+ * Predicate — "anything deletable is selected": elements OR one-or-more
+ * links. Links live in a parallel selection set (`editor.selectedLinks`), so
+ * a link-only (incl. multi-link) selection must still enable Delete/Backspace.
+ * `deleteSelected()` removes every selected link; this just opens the gate.
+ */
+export const hasSelectionOrLink = (ctx) => ctx.editor.selection.size > 0 || ctx.editor.selectedLinks.size > 0;
+//# sourceMappingURL=types.js.map

package/dist/actions/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/actions/types.ts"],"names":[],"mappings":"AA4GA,2DAA2D;AAC3D,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,GAAkB,EAAW,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,CAAC;AAE3F;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,GAAkB,EAAW,EAAE,CAChE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,CAAC"}

package/dist/animation-tick.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Tiny requestAnimationFrame loop manager. Used by the editor for
+ * animated content (GIFs) that needs a re-render every frame even when
+ * the scene reference hasn't changed.
+ *
+ * Self-terminating: each tick consults `isAnimated()`; when it
+ * returns false the loop stops and `start()` is a no-op until
+ * called again. SSR-safe — no-op when `requestAnimationFrame` is
+ * not on `globalThis`.
+ */
+export declare class AnimationTick {
+    private frameId;
+    private readonly isAnimated;
+    private readonly onTick;
+    constructor(opts: {
+        readonly isAnimated: () => boolean;
+        readonly onTick: () => void;
+    });
+    /** Begin the rAF loop. No-op when already running or when
+     *  `requestAnimationFrame` is unavailable (Node).
+     */
+    start(): void;
+    /** Cancel any pending frame. Safe to call from dispose paths. */
+    stop(): void;
+    /** True while the loop is actively scheduled. */
+    get running(): boolean;
+}
+//# sourceMappingURL=animation-tick.d.ts.map

package/dist/animation-tick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-tick.d.ts","sourceRoot":"","sources":["../src/animation-tick.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;gBAExB,IAAI,EAAE;QAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAA;KAAE;IAKrF;;OAEG;IACH,KAAK,IAAI,IAAI;IAcb,iEAAiE;IACjE,IAAI,IAAI,IAAI;IAMZ,iDAAiD;IACjD,IAAI,OAAO,IAAI,OAAO,CAErB;CACF"}

package/dist/animation-tick.js

@@ -0,0 +1,50 @@
+/**
+ * Tiny requestAnimationFrame loop manager. Used by the editor for
+ * animated content (GIFs) that needs a re-render every frame even when
+ * the scene reference hasn't changed.
+ *
+ * Self-terminating: each tick consults `isAnimated()`; when it
+ * returns false the loop stops and `start()` is a no-op until
+ * called again. SSR-safe — no-op when `requestAnimationFrame` is
+ * not on `globalThis`.
+ */
+export class AnimationTick {
+    frameId = null;
+    isAnimated;
+    onTick;
+    constructor(opts) {
+        this.isAnimated = opts.isAnimated;
+        this.onTick = opts.onTick;
+    }
+    /** Begin the rAF loop. No-op when already running or when
+     *  `requestAnimationFrame` is unavailable (Node).
+     */
+    start() {
+        if (this.frameId !== null)
+            return;
+        if (typeof requestAnimationFrame === "undefined")
+            return;
+        const loop = () => {
+            if (!this.isAnimated()) {
+                this.frameId = null;
+                return;
+            }
+            this.onTick();
+            this.frameId = requestAnimationFrame(loop);
+        };
+        this.frameId = requestAnimationFrame(loop);
+    }
+    /** Cancel any pending frame. Safe to call from dispose paths. */
+    stop() {
+        if (this.frameId === null)
+            return;
+        if (typeof cancelAnimationFrame !== "undefined")
+            cancelAnimationFrame(this.frameId);
+        this.frameId = null;
+    }
+    /** True while the loop is actively scheduled. */
+    get running() {
+        return this.frameId !== null;
+    }
+}
+//# sourceMappingURL=animation-tick.js.map

package/dist/animation-tick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-tick.js","sourceRoot":"","sources":["../src/animation-tick.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,OAAO,aAAa;IAChB,OAAO,GAAkB,IAAI,CAAC;IACrB,UAAU,CAAgB;IAC1B,MAAM,CAAa;IAEpC,YAAY,IAAyE;QACnF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QAClC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI;YAAE,OAAO;QAClC,IAAI,OAAO,qBAAqB,KAAK,WAAW;YAAE,OAAO;QACzD,MAAM,IAAI,GAAG,GAAS,EAAE;YACtB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;gBACvB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;gBACpB,OAAO;YACT,CAAC;YACD,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,IAAI,CAAC,OAAO,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;QAC7C,CAAC,CAAC;QACF,IAAI,CAAC,OAAO,GAAG,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED,iEAAiE;IACjE,IAAI;QACF,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI;YAAE,OAAO;QAClC,IAAI,OAAO,oBAAoB,KAAK,WAAW;YAAE,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpF,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,iDAAiD;IACjD,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,OAAO,KAAK,IAAI,CAAC;IAC/B,CAAC;CACF"}

package/dist/auto-compact.d.ts

@@ -0,0 +1,27 @@
+import type { LayerId } from "@oh-just-another/types";
+import type { Scene } from "@oh-just-another/scene";
+/**
+ * Microtask-scheduled rebalancer for fractional `order` keys. When any
+ * shape or edge's order string grows past AUTO_COMPACT_THRESHOLD, a
+ * single compaction pass is scheduled per mutation burst so users never
+ * see the long-key state.
+ *
+ * The scheduler keeps a `pending` flag to coalesce bursts into one
+ * microtask; `runCheck()` is what the microtask invokes (and what tests
+ * call directly when they want determinism).
+ */
+export declare class AutoCompactScheduler {
+    private pending;
+    private readonly getScene;
+    private readonly compact;
+    constructor(opts: {
+        readonly getScene: () => Scene;
+        /** Caller-supplied compaction action — usually `editor.compactLayerZOrder(layerId, {recordHistory:false})`. */
+        readonly compact: (layerId: LayerId) => void;
+    });
+    /** Queue a check for the next microtask. Coalesces bursts. */
+    schedule(): void;
+    /** Run the actual check + compact immediately. Used by tests. */
+    runCheck(): void;
+}
+//# sourceMappingURL=auto-compact.d.ts.map

package/dist/auto-compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-compact.d.ts","sourceRoot":"","sources":["../src/auto-compact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAGpD;;;;;;;;;GASG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;gBAEzC,IAAI,EAAE;QAChB,QAAQ,CAAC,QAAQ,EAAE,MAAM,KAAK,CAAC;QAC/B,+GAA+G;QAC/G,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;KAC9C;IAKD,8DAA8D;IAC9D,QAAQ,IAAI,IAAI;IAShB,iEAAiE;IACjE,QAAQ,IAAI,IAAI;CAWjB"}

package/dist/auto-compact.js

@@ -0,0 +1,46 @@
+import { AUTO_COMPACT_THRESHOLD } from "./constants.js";
+/**
+ * Microtask-scheduled rebalancer for fractional `order` keys. When any
+ * shape or edge's order string grows past AUTO_COMPACT_THRESHOLD, a
+ * single compaction pass is scheduled per mutation burst so users never
+ * see the long-key state.
+ *
+ * The scheduler keeps a `pending` flag to coalesce bursts into one
+ * microtask; `runCheck()` is what the microtask invokes (and what tests
+ * call directly when they want determinism).
+ */
+export class AutoCompactScheduler {
+    pending = false;
+    getScene;
+    compact;
+    constructor(opts) {
+        this.getScene = opts.getScene;
+        this.compact = opts.compact;
+    }
+    /** Queue a check for the next microtask. Coalesces bursts. */
+    schedule() {
+        if (this.pending)
+            return;
+        this.pending = true;
+        queueMicrotask(() => {
+            this.pending = false;
+            this.runCheck();
+        });
+    }
+    /** Run the actual check + compact immediately. Used by tests. */
+    runCheck() {
+        const scene = this.getScene();
+        const layersToCompact = new Set();
+        for (const s of scene.elements.values()) {
+            if (s.order.length > AUTO_COMPACT_THRESHOLD)
+                layersToCompact.add(s.layerId);
+        }
+        for (const e of scene.links.values()) {
+            if (e.order.length > AUTO_COMPACT_THRESHOLD)
+                layersToCompact.add(e.layerId);
+        }
+        for (const lid of layersToCompact)
+            this.compact(lid);
+    }
+}
+//# sourceMappingURL=auto-compact.js.map

package/dist/auto-compact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-compact.js","sourceRoot":"","sources":["../src/auto-compact.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;;;;;GASG;AACH,MAAM,OAAO,oBAAoB;IACvB,OAAO,GAAG,KAAK,CAAC;IACP,QAAQ,CAAc;IACtB,OAAO,CAA6B;IAErD,YAAY,IAIX;QACC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC9B,CAAC;IAED,8DAA8D;IAC9D,QAAQ;QACN,IAAI,IAAI,CAAC,OAAO;YAAE,OAAO;QACzB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,cAAc,CAAC,GAAG,EAAE;YAClB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iEAAiE;IACjE,QAAQ;QACN,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,MAAM,eAAe,GAAG,IAAI,GAAG,EAAW,CAAC;QAC3C,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YACxC,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,sBAAsB;gBAAE,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QAC9E,CAAC;QACD,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;YACrC,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,sBAAsB;gBAAE,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QAC9E,CAAC;QACD,KAAK,MAAM,GAAG,IAAI,eAAe;YAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACvD,CAAC;CACF"}

package/dist/auto-layout-scheduler.d.ts

@@ -0,0 +1,50 @@
+import type { ElementId } from "@oh-just-another/types";
+import { apply, type Patch, type Scene } from "@oh-just-another/scene";
+/**
+ * Microtask-coalesced re-runner for shapes carrying
+ * `metadata.autoLayout`. The editor calls `schedule()` from `notify()`;
+ * the check walks every auto-layout parent, compares its children-set
+ * fingerprint against the previous run, and re-runs the layout when the
+ * set changed.
+ *
+ * Pure position edits inside an existing children set are ignored
+ * (fingerprint is sorted-ids only), so a manual nudge of a child
+ * isn't snapped back. Add / remove / reparent does trigger.
+ */
+export declare class AutoLayoutScheduler {
+    private readonly opts;
+    private pending;
+    private readonly signatures;
+    constructor(opts: AutoLayoutSchedulerOptions);
+    /** Queue a check for the next microtask. Coalesces bursts. */
+    schedule(): void;
+    /**
+     * Recompute and store the signature for a parent, used after the
+     * editor's public `runLayout(parentId)` to prevent the next
+     * scheduled check from firing a redundant second run.
+     */
+    resetSignature(parentId: ElementId): void;
+    /** Run the actual check + relayout immediately. Used by tests. */
+    runCheck(): void;
+    private signatureFor;
+}
+export interface AutoLayoutSchedulerOptions {
+    readonly getScene: () => Scene;
+    /**
+     * Apply the layout patch — implementation knows whether to join
+     * a running gesture transaction or push straight to history.
+     */
+    readonly applyPatch: (patch: Patch) => void;
+    /** Editor-side hook to grow the container after the relayout. */
+    readonly growContainer: (parentId: ElementId, childId: ElementId) => void;
+    /**
+     * Called once at the end of a check that produced at least one
+     * mutation — editor renders + fires listeners (intentionally NOT
+     * `notify()` because that would re-schedule the check and risk
+     * a microtask loop).
+     */
+    readonly onMutated: () => void;
+}
+export type { Patch, Scene };
+export { apply };
+//# sourceMappingURL=auto-layout-scheduler.d.ts.map