@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/undo/HistoryCore.d.ts

@@ -1,92 +0,0 @@
-/** Notified after any change to a history — push, undo, redo, or clear. Carries no payload; re-read the store. */
-export type HistoryListener = () => void;
-/** Identifies which direction of travel threw, so an `onError` handler can word its message. */
-export declare const HistoryPhase: {
-    /** The failure came from an entry's `undo` work. */
-    readonly Undo: "undo";
-    /** The failure came from an entry's `do` work, replayed by `redo()`. */
-    readonly Redo: "redo";
-};
-export type HistoryPhase = (typeof HistoryPhase)[keyof typeof HistoryPhase];
-/** Receives an error thrown while travelling the stack, alongside the direction that threw. */
-export type HistoryErrorHandler = (error: unknown, phase: HistoryPhase) => void;
-/** The default coalescing window — roughly one typing burst, so a typed word collapses into one undo step. */
-export declare const DEFAULT_COALESCE_MS = 500;
-/** Tunes a history at creation. Every field is optional; the default is an unbounded, 500 ms-coalescing history. */
-export interface HistoryOptions {
-    /**
-     * Caps how many entries are retained. Exceeding it discards the OLDEST entry, so recent work always survives.
-     * Omitted → unbounded.
-     */
-    readonly limit?: number;
-    /**
-     * How long after an entry a same-keyed push still merges into it, in milliseconds.
-     * Defaults to {@link DEFAULT_COALESCE_MS}. Only pushes carrying a `coalesceKey` are ever candidates.
-     */
-    readonly coalesceMs?: number;
-    /** Where an error thrown by an entry's `do` / `undo` work is reported. Omitted → the failure is swallowed. */
-    readonly onError?: HistoryErrorHandler;
-    /** The clock coalescing measures against. Defaults to `Date.now`; inject one to make the window deterministic. */
-    readonly now?: () => number;
-}
-/** The minimum surface a keybinding, toolbar, or menu needs — satisfied by both history flavors. */
-export interface UndoRedoTarget {
-    /** Reverses the most recent entry. Returns whether anything was undone (`false` at the bottom, or on failure). */
-    readonly undo: () => boolean;
-    /** Re-applies the next entry on the redo branch. Returns whether anything was redone. */
-    readonly redo: () => boolean;
-    /** Whether an entry is available to undo. */
-    readonly canUndo: boolean;
-    /** Whether an entry is available to redo. */
-    readonly canRedo: boolean;
-}
-/** Everything both flavors share — travel, grouping, introspection, and change notification. */
-export interface HistoryStore extends UndoRedoTarget {
-    /**
-     * Groups every push made inside `fn` into ONE reversible entry labelled `label`, and returns `fn`'s result.
-     * Nested calls flatten into the outermost group. A throwing `fn` still commits what it buffered, then rethrows.
-     */
-    readonly transact: <TResult>(label: string | undefined, fn: () => TResult) => TResult;
-    /** Drops every entry (both directions). Any state already applied stays applied — this forgets, it does not revert. */
-    readonly clear: () => void;
-    /** Subscribes to changes; returns an unsubscribe. */
-    readonly subscribe: (listener: HistoryListener) => () => void;
-    /** A monotonic counter bumped on every change — the identity-stable snapshot the composables subscribe to. */
-    readonly version: () => number;
-    /** How many entries are retained across both directions — what a history panel lists. */
-    readonly size: number;
-    /** The label of the entry `undo()` would reverse — the text for an "Undo {label}" menu item. */
-    readonly undoLabel: string | undefined;
-    /** The label of the entry `redo()` would re-apply. */
-    readonly redoLabel: string | undefined;
-}
-/** One entry as handed to the core — the flavor supplies the payload, the core owns everything else. */
-export interface HistoryPushRequest<TPayload> {
-    /** Human label for menus and history panels. */
-    readonly label?: string;
-    /** The flavor-specific work or state this entry carries. */
-    readonly payload: TPayload;
-    /** Merges this push into the previous entry when they share the key and land inside the coalescing window. */
-    readonly coalesceKey?: string;
-}
-/** The core store — a {@link HistoryStore} plus the payload-level `push` each flavor wraps in its own API. */
-export interface HistoryCore<TPayload> extends HistoryStore {
-    /** Records one entry, applying the truncate / evict / coalesce / buffer rules. Never runs the payload. */
-    readonly push: (request: HistoryPushRequest<TPayload>) => void;
-}
-/** How a flavor teaches the core to travel over, and merge, its own payload type. */
-export interface HistoryCoreConfig<TPayload> {
-    /** Moves the world forward over a payload — the redo direction. May throw; the core keeps the cursor put. */
-    readonly applyForward: (payload: TPayload) => void;
-    /** Moves the world backward over a payload — the undo direction. May throw; the core keeps the cursor put. */
-    readonly applyBackward: (payload: TPayload) => void;
-    /** Fuses two adjacent payloads into one that travels like both — used by coalescing and by `transact`. */
-    readonly mergePayloads: (previous: TPayload, next: TPayload) => TPayload;
-    /** The creation-time options, read live on every use so a flavor can pass its caller's object straight through. */
-    readonly options: HistoryOptions | undefined;
-}
-/**
- * Builds the shared engine. Not exported from the slice barrel — consumers take `createUndoHistory` or
- * `createSnapshotHistory`, which are this core plus a payload type.
- */
-export declare function createHistoryCore<TPayload>(config: HistoryCoreConfig<TPayload>): HistoryCore<TPayload>;

package/dist/foundation/undo/UseUndoHistory.d.ts

@@ -1,66 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef, WritableComputedRef } from 'vue';
-import { HistoryOptions, HistoryStore } from './HistoryCore';
-import { SnapshotHistory, SnapshotRecordOptions } from './SnapshotHistory';
-import { UndoHistory } from './UndoHistory';
-/**
- * Subscribes to a history's changes and returns its version counter, updating on every push, undo, redo, and
- * clear. Use it directly when the history is owned outside a component (a module-scope editor store) and read
- * it inside a `computed` to make that computed track the history.
- */
-export declare function useHistoryVersion(store: HistoryStore): Readonly<ShallowRef<number>>;
-/** What {@link useUndoHistory} returns — the history plus the cursor that makes it reactive. */
-export interface UndoHistoryControls {
-    /** The history itself. Stable — pass it down, or to {@link useUndoShortcuts}, unchanged. */
-    readonly history: UndoHistory;
-    /**
-     * The mutation cursor. Its members are getters, so read them inside a `computed` that also touches this —
-     * `computed(() => (version.value, history.canUndo))` — and the computed re-evaluates on every change.
-     */
-    readonly version: Readonly<ShallowRef<number>>;
-    /** Whether an undo is available. The pre-derived form of the `version` idiom above. */
-    readonly canUndo: Readonly<ShallowRef<boolean>>;
-    /** Whether a redo is available. */
-    readonly canRedo: Readonly<ShallowRef<boolean>>;
-}
-/**
- * Owns a command-based {@link UndoHistory} for the scope's lifetime and exposes its reactivity.
- *
- * Returns the history alongside the version cursor and the two flags a toolbar actually renders. The history
- * object never changes identity — pass it down, or to {@link useUndoShortcuts}, without wrapping.
- *
- * @param options History configuration. `limit` / `coalesceMs` are read once; `onError` / `now` stay live.
- */
-export declare function useUndoHistory(options?: MaybeRefOrGetter<HistoryOptions | undefined>): UndoHistoryControls;
-/** Publishes the next state — a value or an updater, plus how this particular change should be recorded. */
-export type UndoableStateSetter<TState> = (next: TState | ((previous: TState) => TState), options?: SnapshotRecordOptions) => void;
-/** What {@link useUndoableState} returns — the value, its setter, and the history behind them. */
-export interface UndoableState<TState> {
-    /**
-     * The current state. Writable, so it drops straight into `v-model`; a `v-model` write records with no options,
-     * and `setState` is the way to pass `{ label, coalesceKey }`.
-     */
-    readonly state: WritableComputedRef<TState>;
-    /** Records the next state — a value or an updater — with optional per-call record options. */
-    readonly setState: UndoableStateSetter<TState>;
-    /** The full {@link SnapshotHistory}: `undo` / `redo` / `canUndo` / `transact`, and the target for shortcuts. */
-    readonly history: SnapshotHistory<TState>;
-    /** The mutation cursor, for deriving anything the two flags below do not cover. */
-    readonly version: Readonly<ShallowRef<number>>;
-    /** Whether an undo is available. */
-    readonly canUndo: Readonly<ShallowRef<boolean>>;
-    /** Whether a redo is available. */
-    readonly canRedo: Readonly<ShallowRef<boolean>>;
-}
-/**
- * A `ref` with a history behind it — the snapshot flavor as a drop-in for small, immutable state.
- *
- * ```ts
- * const { state, setState, history } = useUndoableState('');
- * setState((prev) => prev + 'a', { label: 'Typing', coalesceKey: 'text' });
- * useUndoShortcuts(history);
- * ```
- *
- * `state` is a writable computed over the history's `present`, so travel is visible immediately and a `v-model`
- * write records an entry. An updater is the only way to store a function-typed state.
- */
-export declare function useUndoableState<TState>(initial: TState, options?: MaybeRefOrGetter<HistoryOptions | undefined>): UndoableState<TState>;

package/dist/foundation/undo/UseUndoShortcuts.d.ts

@@ -1,20 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { HotkeyOptions } from '../shortcuts';
-import { UndoRedoTarget } from './HistoryCore';
-/** Tunes {@link useUndoShortcuts}; every {@link HotkeyOptions} field (`enabled`, `target`, …) applies as usual. */
-export interface UndoShortcutOptions extends HotkeyOptions {
-    /** Chord(s) that trigger `undo()`. Defaults to `'mod+z'`. */
-    readonly undoChords?: MaybeRefOrGetter<string | readonly string[]>;
-    /** Chord(s) that trigger `redo()`. Defaults to `['mod+shift+z', 'mod+y']`. */
-    readonly redoChords?: MaybeRefOrGetter<string | readonly string[]>;
-}
-/**
- * Binds the conventional undo / redo chords to a history. Opt-in — nothing is bound unless a surface calls this.
- *
- * ```ts
- * const { history } = useUndoHistory();
- * useUndoShortcuts(history);                            // ⌘Z · ⌘⇧Z · ⌘Y
- * useUndoShortcuts(history, { enabled: () => !isModalOpen.value }); // suspended while a dialog owns the keyboard
- * ```
- */
-export declare function useUndoShortcuts(target: UndoRedoTarget, options?: UndoShortcutOptions): void;

package/dist/foundation/undo/index.d.ts

@@ -1,5 +0,0 @@
-export { DEFAULT_COALESCE_MS, HistoryPhase, type HistoryErrorHandler, type HistoryListener, type HistoryOptions, type HistoryStore, type UndoRedoTarget, } from './HistoryCore';
-export { createUndoHistory, type UndoableAction, type UndoHistory } from './UndoHistory';
-export { createSnapshotHistory, type SnapshotHistory, type SnapshotRecordOptions, } from './SnapshotHistory';
-export { useHistoryVersion, useUndoableState, useUndoHistory, type UndoHistoryControls, type UndoableState, type UndoableStateSetter, } from './UseUndoHistory';
-export { useUndoShortcuts, type UndoShortcutOptions } from './UseUndoShortcuts';

package/dist/foundation/undo/index.js

@@ -1,361 +0,0 @@
-import { shallowRef, onMounted, onScopeDispose, computed, toValue } from "vue";
-import { u as useHotkeyMap } from "../../chunks/UseHotkeys-CKIYK5Mq.js";
-const HistoryPhase = {
-  /** The failure came from an entry's `undo` work. */
-  Undo: "undo",
-  /** The failure came from an entry's `do` work, replayed by `redo()`. */
-  Redo: "redo"
-};
-const DEFAULT_COALESCE_MS = 500;
-function createHistoryCore(config) {
-  const { applyForward, applyBackward, mergePayloads, options } = config;
-  const listeners = /* @__PURE__ */ new Set();
-  const entries = [];
-  let cursor = 0;
-  let revision = 0;
-  let depth = 0;
-  let buffer = [];
-  let bufferLabel;
-  let anchorKey;
-  let anchorAt = 0;
-  function now() {
-    return options?.now?.() ?? Date.now();
-  }
-  function notify() {
-    revision += 1;
-    for (const listener of [...listeners]) listener();
-  }
-  function dropAnchor() {
-    anchorKey = void 0;
-  }
-  function evict() {
-    const limit = options?.limit;
-    if (limit === void 0 || !Number.isFinite(limit)) return;
-    const max = Math.max(0, limit);
-    while (entries.length > max) {
-      entries.shift();
-      cursor = Math.max(0, cursor - 1);
-    }
-  }
-  function commit(entry) {
-    const at = now();
-    const previous = cursor > 0 ? entries.at(cursor - 1) : void 0;
-    const canCoalesce = entry.coalesceKey !== void 0 && entry.coalesceKey === anchorKey && previous !== void 0 && // Nothing may sit on the redo branch: the anchor must still be the top of the stack.
-    cursor === entries.length && at - anchorAt <= (options?.coalesceMs ?? DEFAULT_COALESCE_MS);
-    if (canCoalesce && previous !== void 0) {
-      entries[cursor - 1] = {
-        // The first label of a run wins — "Typing" should not be relabelled by its eighth keystroke.
-        label: previous.label ?? entry.label,
-        payload: mergePayloads(previous.payload, entry.payload),
-        coalesceKey: entry.coalesceKey
-      };
-      anchorAt = at;
-      notify();
-      return;
-    }
-    entries.length = cursor;
-    entries.push(entry);
-    cursor = entries.length;
-    anchorKey = entry.coalesceKey;
-    anchorAt = at;
-    evict();
-    notify();
-  }
-  function flush() {
-    const grouped = buffer;
-    buffer = [];
-    const first = grouped.at(0);
-    if (first === void 0) return;
-    const payload = grouped.slice(1).reduce((merged, entry) => mergePayloads(merged, entry.payload), first.payload);
-    commit({ label: bufferLabel ?? first.label, payload, coalesceKey: void 0 });
-  }
-  return {
-    push(request) {
-      const entry = {
-        label: request.label,
-        payload: request.payload,
-        coalesceKey: request.coalesceKey
-      };
-      if (depth > 0) {
-        buffer.push(entry);
-        return;
-      }
-      commit(entry);
-    },
-    transact(label, fn) {
-      if (depth === 0) bufferLabel = label;
-      depth += 1;
-      try {
-        return fn();
-      } finally {
-        depth -= 1;
-        if (depth === 0) {
-          flush();
-          bufferLabel = void 0;
-        }
-      }
-    },
-    undo() {
-      if (cursor === 0) return false;
-      const entry = entries.at(cursor - 1);
-      if (entry === void 0) return false;
-      try {
-        applyBackward(entry.payload);
-      } catch (error) {
-        options?.onError?.(error, HistoryPhase.Undo);
-        return false;
-      }
-      cursor -= 1;
-      dropAnchor();
-      notify();
-      return true;
-    },
-    redo() {
-      const entry = entries.at(cursor);
-      if (cursor >= entries.length || entry === void 0) return false;
-      try {
-        applyForward(entry.payload);
-      } catch (error) {
-        options?.onError?.(error, HistoryPhase.Redo);
-        return false;
-      }
-      cursor += 1;
-      dropAnchor();
-      notify();
-      return true;
-    },
-    clear() {
-      entries.length = 0;
-      cursor = 0;
-      dropAnchor();
-      notify();
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    version() {
-      return revision;
-    },
-    get canUndo() {
-      return cursor > 0;
-    },
-    get canRedo() {
-      return cursor < entries.length;
-    },
-    get size() {
-      return entries.length;
-    },
-    get undoLabel() {
-      return cursor > 0 ? entries.at(cursor - 1)?.label : void 0;
-    },
-    get redoLabel() {
-      return entries.at(cursor)?.label;
-    }
-  };
-}
-function createUndoHistory(options) {
-  const core = createHistoryCore({
-    applyForward: (payload) => payload.do(),
-    applyBackward: (payload) => payload.undo(),
-    mergePayloads: (previous, next) => ({
-      do: () => {
-        previous.do();
-        next.do();
-      },
-      undo: () => {
-        next.undo();
-        previous.undo();
-      }
-    }),
-    options
-  });
-  function push(action) {
-    core.push({
-      label: action.label,
-      coalesceKey: action.coalesceKey,
-      payload: { do: action.do, undo: action.undo }
-    });
-  }
-  return {
-    push,
-    execute(action) {
-      action.do();
-      push(action);
-    },
-    transact: core.transact,
-    undo: core.undo,
-    redo: core.redo,
-    clear: core.clear,
-    subscribe: core.subscribe,
-    version: core.version,
-    get canUndo() {
-      return core.canUndo;
-    },
-    get canRedo() {
-      return core.canRedo;
-    },
-    get size() {
-      return core.size;
-    },
-    get undoLabel() {
-      return core.undoLabel;
-    },
-    get redoLabel() {
-      return core.redoLabel;
-    }
-  };
-}
-function createSnapshotHistory(initial, options) {
-  let present = initial;
-  const core = createHistoryCore({
-    applyForward: (payload) => {
-      present = payload.after;
-    },
-    applyBackward: (payload) => {
-      present = payload.before;
-    },
-    mergePayloads: (previous, next) => ({ before: previous.before, after: next.after }),
-    options
-  });
-  return {
-    record(state, recordOptions) {
-      if (Object.is(state, present)) return;
-      const before = present;
-      present = state;
-      core.push({
-        label: recordOptions?.label,
-        coalesceKey: recordOptions?.coalesceKey,
-        payload: { before, after: state }
-      });
-    },
-    transact: core.transact,
-    undo: core.undo,
-    redo: core.redo,
-    clear: core.clear,
-    subscribe: core.subscribe,
-    version: core.version,
-    get present() {
-      return present;
-    },
-    get canUndo() {
-      return core.canUndo;
-    },
-    get canRedo() {
-      return core.canRedo;
-    },
-    get size() {
-      return core.size;
-    },
-    get undoLabel() {
-      return core.undoLabel;
-    },
-    get redoLabel() {
-      return core.redoLabel;
-    }
-  };
-}
-function useHistoryVersion(store) {
-  const version = shallowRef(store.version());
-  let unsubscribe;
-  onMounted(() => {
-    version.value = store.version();
-    unsubscribe = store.subscribe(() => {
-      version.value = store.version();
-    });
-  });
-  onScopeDispose(() => {
-    unsubscribe?.();
-    unsubscribe = void 0;
-  });
-  return version;
-}
-function scopeOptions(options) {
-  const initial = toValue(options);
-  return {
-    limit: initial?.limit,
-    coalesceMs: initial?.coalesceMs,
-    onError: (error, phase) => toValue(options)?.onError?.(error, phase),
-    now: () => (toValue(options)?.now ?? Date.now)()
-  };
-}
-function useUndoHistory(options) {
-  const history = createUndoHistory(scopeOptions(options));
-  const version = useHistoryVersion(history);
-  return {
-    history,
-    version,
-    canUndo: computed(() => {
-      void version.value;
-      return history.canUndo;
-    }),
-    canRedo: computed(() => {
-      void version.value;
-      return history.canRedo;
-    })
-  };
-}
-function useUndoableState(initial, options) {
-  const history = createSnapshotHistory(initial, scopeOptions(options));
-  const version = useHistoryVersion(history);
-  const setState = (next, recordOptions) => {
-    const value = typeof next === "function" ? next(history.present) : next;
-    history.record(value, recordOptions);
-  };
-  const state = computed({
-    get: () => {
-      void version.value;
-      return history.present;
-    },
-    set: (next) => setState(next)
-  });
-  return {
-    state,
-    setState,
-    history,
-    version,
-    canUndo: computed(() => {
-      void version.value;
-      return history.canUndo;
-    }),
-    canRedo: computed(() => {
-      void version.value;
-      return history.canRedo;
-    })
-  };
-}
-const DEFAULT_UNDO_CHORDS = ["mod+z"];
-const DEFAULT_REDO_CHORDS = ["mod+shift+z", "mod+y"];
-function toChordList(chords) {
-  return typeof chords === "string" ? [chords] : chords;
-}
-function useUndoShortcuts(target, options) {
-  const { undoChords, redoChords, ...hotkeyOptions } = options ?? {};
-  useHotkeyMap(() => {
-    const map = {};
-    for (const chord of toChordList(toValue(undoChords) ?? DEFAULT_UNDO_CHORDS)) {
-      map[chord] = () => {
-        target.undo();
-      };
-    }
-    for (const chord of toChordList(toValue(redoChords) ?? DEFAULT_REDO_CHORDS)) {
-      map[chord] = () => {
-        target.redo();
-      };
-    }
-    return map;
-  }, hotkeyOptions);
-}
-export {
-  DEFAULT_COALESCE_MS,
-  HistoryPhase,
-  createSnapshotHistory,
-  createUndoHistory,
-  useHistoryVersion,
-  useUndoHistory,
-  useUndoShortcuts,
-  useUndoableState
-};
-//# sourceMappingURL=index.js.map

package/dist/foundation/undo/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/undo/HistoryCore.ts","../../../src/foundation/undo/UndoHistory.ts","../../../src/foundation/undo/SnapshotHistory.ts","../../../src/foundation/undo/UseUndoHistory.ts","../../../src/foundation/undo/UseUndoShortcuts.ts"],"sourcesContent":["// The engine both history flavors run on — one linear entry list plus one pointer, and every branch rule\n// (truncate · evict · coalesce · group) implemented exactly once. The command flavor and the snapshot flavor\n// differ only in what an entry's payload is and how two payloads merge; they must never differ in when the\n// redo branch dies, so that decision lives here and nowhere else.\n//\n// The model is an array + an `index` cursor, not a past/future pair of stacks. `entries.slice(0, index)` is\n// applied, `entries.slice(index)` is redoable. One array means truncation is `entries.length = index` — the\n// single most important rule in an undo stack, expressed as one line that cannot drift between flavors.\n//\n// Non-obvious decisions:\n// - The store is exposed through GETTERS (`canUndo`, `size`, `undoLabel`), not snapshot values. A history is a\n//   long-lived mutable object a toolbar re-reads after every notification; a frozen boolean would be stale the\n//   moment anything pushed. This is also why a facade must delegate getter-by-getter — a spread would evaluate\n//   each one once and bake the answer in.\n// - `version()` sits alongside `subscribe()` for the same reason `CommandRegistry` has one: a subscribing\n//   composable re-reads after every notification, and a value with fresh identity per call would look changed\n//   every time. The monotonic revision is the identity-stable cursor a composable subscribes to.\n// - Coalescing anchors on the LAST PUSH, and any undo / redo / clear drops the anchor. Merging a fresh keystroke\n//   into an entry the user just travelled back through would rewrite history they are currently inspecting.\n// - A failed `undo` / `redo` leaves the cursor exactly where it was and reports through `onError`. A half-moved\n//   pointer is worse than a failed undo: every later entry would then revert against a state that never existed.\n// - `transact` flattens by depth counter rather than by nesting entries. A nested group is a caller's structural\n//   detail; the user pressing ⌘Z wants the OUTERMOST intent reversed in one step, so inner labels are dropped.\n// - A transaction whose body throws still commits what it buffered. The mutations already landed in the world —\n//   discarding them would leave the stack unable to reverse work that actually happened.\n\n/** Notified after any change to a history — push, undo, redo, or clear. Carries no payload; re-read the store. */\nexport type HistoryListener = () => void;\n\n/** Identifies which direction of travel threw, so an `onError` handler can word its message. */\nexport const HistoryPhase = {\n  /** The failure came from an entry's `undo` work. */\n  Undo: 'undo',\n  /** The failure came from an entry's `do` work, replayed by `redo()`. */\n  Redo: 'redo',\n} as const;\n\nexport type HistoryPhase = (typeof HistoryPhase)[keyof typeof HistoryPhase];\n\n/** Receives an error thrown while travelling the stack, alongside the direction that threw. */\nexport type HistoryErrorHandler = (error: unknown, phase: HistoryPhase) => void;\n\n/** The default coalescing window — roughly one typing burst, so a typed word collapses into one undo step. */\nexport const DEFAULT_COALESCE_MS = 500;\n\n/** Tunes a history at creation. Every field is optional; the default is an unbounded, 500 ms-coalescing history. */\nexport interface HistoryOptions {\n  /**\n   * Caps how many entries are retained. Exceeding it discards the OLDEST entry, so recent work always survives.\n   * Omitted → unbounded.\n   */\n  readonly limit?: number;\n\n  /**\n   * How long after an entry a same-keyed push still merges into it, in milliseconds.\n   * Defaults to {@link DEFAULT_COALESCE_MS}. Only pushes carrying a `coalesceKey` are ever candidates.\n   */\n  readonly coalesceMs?: number;\n\n  /** Where an error thrown by an entry's `do` / `undo` work is reported. Omitted → the failure is swallowed. */\n  readonly onError?: HistoryErrorHandler;\n\n  /** The clock coalescing measures against. Defaults to `Date.now`; inject one to make the window deterministic. */\n  readonly now?: () => number;\n}\n\n/** The minimum surface a keybinding, toolbar, or menu needs — satisfied by both history flavors. */\nexport interface UndoRedoTarget {\n  /** Reverses the most recent entry. Returns whether anything was undone (`false` at the bottom, or on failure). */\n  readonly undo: () => boolean;\n\n  /** Re-applies the next entry on the redo branch. Returns whether anything was redone. */\n  readonly redo: () => boolean;\n\n  /** Whether an entry is available to undo. */\n  readonly canUndo: boolean;\n\n  /** Whether an entry is available to redo. */\n  readonly canRedo: boolean;\n}\n\n/** Everything both flavors share — travel, grouping, introspection, and change notification. */\nexport interface HistoryStore extends UndoRedoTarget {\n  /**\n   * Groups every push made inside `fn` into ONE reversible entry labelled `label`, and returns `fn`'s result.\n   * Nested calls flatten into the outermost group. A throwing `fn` still commits what it buffered, then rethrows.\n   */\n  readonly transact: <TResult>(label: string | undefined, fn: () => TResult) => TResult;\n\n  /** Drops every entry (both directions). Any state already applied stays applied — this forgets, it does not revert. */\n  readonly clear: () => void;\n\n  /** Subscribes to changes; returns an unsubscribe. */\n  readonly subscribe: (listener: HistoryListener) => () => void;\n\n  /** A monotonic counter bumped on every change — the identity-stable snapshot the composables subscribe to. */\n  readonly version: () => number;\n\n  /** How many entries are retained across both directions — what a history panel lists. */\n  readonly size: number;\n\n  /** The label of the entry `undo()` would reverse — the text for an \"Undo {label}\" menu item. */\n  readonly undoLabel: string | undefined;\n\n  /** The label of the entry `redo()` would re-apply. */\n  readonly redoLabel: string | undefined;\n}\n\n/** One entry as handed to the core — the flavor supplies the payload, the core owns everything else. */\nexport interface HistoryPushRequest<TPayload> {\n  /** Human label for menus and history panels. */\n  readonly label?: string;\n\n  /** The flavor-specific work or state this entry carries. */\n  readonly payload: TPayload;\n\n  /** Merges this push into the previous entry when they share the key and land inside the coalescing window. */\n  readonly coalesceKey?: string;\n}\n\n/** The core store — a {@link HistoryStore} plus the payload-level `push` each flavor wraps in its own API. */\nexport interface HistoryCore<TPayload> extends HistoryStore {\n  /** Records one entry, applying the truncate / evict / coalesce / buffer rules. Never runs the payload. */\n  readonly push: (request: HistoryPushRequest<TPayload>) => void;\n}\n\n/** How a flavor teaches the core to travel over, and merge, its own payload type. */\nexport interface HistoryCoreConfig<TPayload> {\n  /** Moves the world forward over a payload — the redo direction. May throw; the core keeps the cursor put. */\n  readonly applyForward: (payload: TPayload) => void;\n\n  /** Moves the world backward over a payload — the undo direction. May throw; the core keeps the cursor put. */\n  readonly applyBackward: (payload: TPayload) => void;\n\n  /** Fuses two adjacent payloads into one that travels like both — used by coalescing and by `transact`. */\n  readonly mergePayloads: (previous: TPayload, next: TPayload) => TPayload;\n\n  /** The creation-time options, read live on every use so a flavor can pass its caller's object straight through. */\n  readonly options: HistoryOptions | undefined;\n}\n\n/** One retained entry. Mutable because coalescing replaces the payload of the entry already on the stack. */\ninterface CoreEntry<TPayload> {\n  label: string | undefined;\n  payload: TPayload;\n  coalesceKey: string | undefined;\n}\n\n/**\n * Builds the shared engine. Not exported from the slice barrel — consumers take `createUndoHistory` or\n * `createSnapshotHistory`, which are this core plus a payload type.\n */\nexport function createHistoryCore<TPayload>(config: HistoryCoreConfig<TPayload>): HistoryCore<TPayload> {\n  const { applyForward, applyBackward, mergePayloads, options } = config;\n\n  const listeners = new Set<HistoryListener>();\n  const entries: CoreEntry<TPayload>[] = [];\n\n  /** How many entries are applied — the cursor. Everything at or after it is the redo branch. */\n  let cursor = 0;\n  let revision = 0;\n\n  /** Transaction nesting depth; pushes buffer instead of committing while it is above zero. */\n  let depth = 0;\n  let buffer: CoreEntry<TPayload>[] = [];\n  let bufferLabel: string | undefined;\n\n  /** The coalescing anchor — the key of the last committed push and when it landed. */\n  let anchorKey: string | undefined;\n  let anchorAt = 0;\n\n  /** Reads the injected clock, falling back to wall time. */\n  function now(): number {\n    return options?.now?.() ?? Date.now();\n  }\n\n  /** Bumps the revision then fans out over a copy, so a listener may unsubscribe while being notified. */\n  function notify(): void {\n    revision += 1;\n    for (const listener of [...listeners]) listener();\n  }\n\n  /** Ends the run of consecutive pushes — travel or a reset must not leave a merge target behind. */\n  function dropAnchor(): void {\n    anchorKey = undefined;\n  }\n\n  /** Enforces `limit` by discarding from the front; the cursor follows so it keeps pointing at the same entry. */\n  function evict(): void {\n    const limit = options?.limit;\n    if (limit === undefined || !Number.isFinite(limit)) return;\n    const max = Math.max(0, limit);\n    while (entries.length > max) {\n      entries.shift();\n      cursor = Math.max(0, cursor - 1);\n    }\n  }\n\n  /** Places an entry on the stack — the only place the redo branch is truncated. */\n  function commit(entry: CoreEntry<TPayload>): void {\n    const at = now();\n    const previous = cursor > 0 ? entries.at(cursor - 1) : undefined;\n    const canCoalesce =\n      entry.coalesceKey !== undefined &&\n      entry.coalesceKey === anchorKey &&\n      previous !== undefined &&\n      // Nothing may sit on the redo branch: the anchor must still be the top of the stack.\n      cursor === entries.length &&\n      at - anchorAt <= (options?.coalesceMs ?? DEFAULT_COALESCE_MS);\n\n    if (canCoalesce && previous !== undefined) {\n      entries[cursor - 1] = {\n        // The first label of a run wins — \"Typing\" should not be relabelled by its eighth keystroke.\n        label: previous.label ?? entry.label,\n        payload: mergePayloads(previous.payload, entry.payload),\n        coalesceKey: entry.coalesceKey,\n      };\n      anchorAt = at;\n      notify();\n      return;\n    }\n\n    // The rule everything else defers to: recording after an undo kills whatever was ahead of the cursor.\n    entries.length = cursor;\n    entries.push(entry);\n    cursor = entries.length;\n    anchorKey = entry.coalesceKey;\n    anchorAt = at;\n    evict();\n    notify();\n  }\n\n  /** Collapses a transaction's buffer into one entry and commits it. A group never coalesces — it IS the grouping. */\n  function flush(): void {\n    const grouped = buffer;\n    buffer = [];\n    const first = grouped.at(0);\n    if (first === undefined) return;\n\n    const payload = grouped\n      .slice(1)\n      .reduce((merged, entry) => mergePayloads(merged, entry.payload), first.payload);\n\n    commit({ label: bufferLabel ?? first.label, payload, coalesceKey: undefined });\n  }\n\n  return {\n    push(request: HistoryPushRequest<TPayload>): void {\n      const entry: CoreEntry<TPayload> = {\n        label: request.label,\n        payload: request.payload,\n        coalesceKey: request.coalesceKey,\n      };\n      // Inside a transaction nothing reaches the stack until the outermost body returns.\n      if (depth > 0) {\n        buffer.push(entry);\n        return;\n      }\n      commit(entry);\n    },\n\n    transact<TResult>(label: string | undefined, fn: () => TResult): TResult {\n      // Only the outermost call owns the buffer and the label — that is the whole of the flattening rule.\n      if (depth === 0) bufferLabel = label;\n      depth += 1;\n      try {\n        return fn();\n      } finally {\n        depth -= 1;\n        if (depth === 0) {\n          // In `finally` on purpose: a throwing body still leaves real mutations that must stay reversible.\n          flush();\n          bufferLabel = undefined;\n        }\n      }\n    },\n\n    undo(): boolean {\n      if (cursor === 0) return false;\n      const entry = entries.at(cursor - 1);\n      if (entry === undefined) return false;\n      try {\n        applyBackward(entry.payload);\n      } catch (error) {\n        // Cursor untouched — the entry stays undoable so a caller can fix the cause and retry.\n        options?.onError?.(error, HistoryPhase.Undo);\n        return false;\n      }\n      cursor -= 1;\n      dropAnchor();\n      notify();\n      return true;\n    },\n\n    redo(): boolean {\n      const entry = entries.at(cursor);\n      if (cursor >= entries.length || entry === undefined) return false;\n      try {\n        applyForward(entry.payload);\n      } catch (error) {\n        options?.onError?.(error, HistoryPhase.Redo);\n        return false;\n      }\n      cursor += 1;\n      dropAnchor();\n      notify();\n      return true;\n    },\n\n    clear(): void {\n      entries.length = 0;\n      cursor = 0;\n      dropAnchor();\n      notify();\n    },\n\n    subscribe(listener: HistoryListener): () => void {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n\n    version(): number {\n      return revision;\n    },\n\n    get canUndo(): boolean {\n      return cursor > 0;\n    },\n\n    get canRedo(): boolean {\n      return cursor < entries.length;\n    },\n\n    get size(): number {\n      return entries.length;\n    },\n\n    get undoLabel(): string | undefined {\n      return cursor > 0 ? entries.at(cursor - 1)?.label : undefined;\n    },\n\n    get redoLabel(): string | undefined {\n      return entries.at(cursor)?.label;\n    },\n  };\n}\n","// The command-based flavor — a history of REVERSIBLE ACTIONS. Each entry pairs the work that applies a change\n// with the work that reverses it, so the stack stores intent (`do` / `undo`) rather than data.\n//\n// Choose this flavor when the state being edited is large, shared, or lives outside Vue — a canvas document,\n// a graph, a server-backed list. Reversing a cell edit costs one closure regardless of how big the document is,\n// and the change can reach anywhere (a ref, a DOM node, a store) because nothing here inspects state at all.\n// The price is that correctness is the caller's: an `undo` that does not exactly reverse its `do` silently\n// desynchronises the app from its history, and nothing in this file can detect that. `SnapshotHistory` makes\n// the opposite trade — see the barrel header for the side-by-side.\n//\n// Non-obvious decisions:\n// - `push` does NOT run `do`. The overwhelmingly common shape is \"the change already happened, record how to\n//   take it back\", so `do` exists purely to replay on redo. `execute` is the other half for callers that want\n//   the history to drive the change instead.\n// - Merged actions replay forward in push order and unwind in REVERSE order. Any other pairing fails as soon as\n//   two coalesced edits touch the same field: undoing the first before the second restores a stale value.\n\nimport {\n  createHistoryCore,\n  type HistoryOptions,\n  type HistoryStore,\n} from './HistoryCore';\n\n/** One reversible unit of work — what a command-based history stores and travels over. */\nexport interface UndoableAction {\n  /** Human label for menus and history panels (`'Delete row'`). Surfaces as `undoLabel` / `redoLabel`. */\n  readonly label?: string;\n\n  /**\n   * Applies the change. Called by `redo()` and by `execute()` — never by `push()`, which assumes the change\n   * has already been made.\n   */\n  readonly do: () => void;\n\n  /** Reverses the change. Must undo exactly what `do` applies, or the app and its history drift apart. */\n  readonly undo: () => void;\n\n  /**\n   * Merges this action into the previous one when they share the key and land inside the coalescing window —\n   * the mechanism that makes a typed word one undo step instead of eight.\n   */\n  readonly coalesceKey?: string;\n}\n\n/** The travel work one entry carries, once the core has taken ownership of the label and coalescing key. */\ninterface ActionPayload {\n  readonly do: () => void;\n  readonly undo: () => void;\n}\n\n/** A history of reversible actions — {@link createUndoHistory}'s product. */\nexport interface UndoHistory extends HistoryStore {\n  /**\n   * Records an already-applied action. Truncates the redo branch, evicts past `limit`, and merges into the\n   * previous entry when `coalesceKey` matches inside the window.\n   */\n  readonly push: (action: UndoableAction) => void;\n\n  /**\n   * Runs the action's `do`, then records it — for callers that route every mutation through the history.\n   * A throwing `do` propagates and records nothing, so a failed action never enters the stack.\n   */\n  readonly execute: (action: UndoableAction) => void;\n}\n\n/**\n * Creates a command-based history.\n *\n * ```ts\n * const history = createUndoHistory({ limit: 100 });\n * rows.splice(index, 1);\n * history.push({ label: 'Delete row', do: () => rows.splice(index, 1), undo: () => rows.splice(index, 0, row) });\n * ```\n */\nexport function createUndoHistory(options?: HistoryOptions): UndoHistory {\n  const core = createHistoryCore<ActionPayload>({\n    applyForward: (payload) => payload.do(),\n    applyBackward: (payload) => payload.undo(),\n    mergePayloads: (previous, next) => ({\n      do: () => {\n        previous.do();\n        next.do();\n      },\n      undo: () => {\n        // Reverse order — the later edit must be taken back before the one it was layered on.\n        next.undo();\n        previous.undo();\n      },\n    }),\n    options,\n  });\n\n  /** Records an action without running it. */\n  function push(action: UndoableAction): void {\n    core.push({\n      label: action.label,\n      coalesceKey: action.coalesceKey,\n      payload: { do: action.do, undo: action.undo },\n    });\n  }\n\n  // Delegated member by member rather than spread: `canUndo` and friends are live getters on the core, and a\n  // spread would call each one once and freeze that answer into the facade.\n  return {\n    push,\n\n    execute(action: UndoableAction): void {\n      action.do();\n      push(action);\n    },\n\n    transact: core.transact,\n    undo: core.undo,\n    redo: core.redo,\n    clear: core.clear,\n    subscribe: core.subscribe,\n    version: core.version,\n\n    get canUndo(): boolean {\n      return core.canUndo;\n    },\n\n    get canRedo(): boolean {\n      return core.canRedo;\n    },\n\n    get size(): number {\n      return core.size;\n    },\n\n    get undoLabel(): string | undefined {\n      return core.undoLabel;\n    },\n\n    get redoLabel(): string | undefined {\n      return core.redoLabel;\n    },\n  };\n}\n","// The snapshot-based flavor — a history of STATES rather than of work. Each entry keeps the value before a\n// change and the value after it, so travelling is an assignment and there is no way for undo to disagree with do.\n//\n// Choose this flavor when the edited state is small and immutable — a form's values, a filter set, a colour\n// picker, a small drawing model. It cannot desynchronise the way the command flavor can, and a caller writes no\n// reversal logic at all. The price is memory and identity: every entry pins a whole state object, and undoing\n// hands back the previous REFERENCE, so anything holding the old value keeps working while anything that mutated\n// it in place has already corrupted both ends of the entry. Keep the state immutable and this flavor is the\n// simpler one by a wide margin.\n//\n// Non-obvious decisions:\n// - `record` publishes `present` immediately, then hands the before/after pair to the core. The caller has\n//   already decided the new state is current; the history is a witness, not a gatekeeper.\n// - Merging two adjacent snapshots keeps the OUTER pair (`previous.before` → `next.after`) and discards the\n//   intermediate value. That is precisely what coalescing means for states: one undo jumps the whole run.\n// - Recording the identical reference is a no-op. A setter that returns its own input is a common shape and must not\n//   deposit an entry that undoes to the value it already holds.\n\nimport {\n  createHistoryCore,\n  type HistoryOptions,\n  type HistoryStore,\n} from './HistoryCore';\n\n/** The state pair one entry carries — travelling is assigning one of these two ends to `present`. */\ninterface SnapshotPayload<TState> {\n  readonly before: TState;\n  readonly after: TState;\n}\n\n/** Per-call tuning for {@link SnapshotHistory.record}. */\nexport interface SnapshotRecordOptions {\n  /** Human label for menus and history panels (`'Rename'`). Surfaces as `undoLabel` / `redoLabel`. */\n  readonly label?: string;\n\n  /**\n   * Merges this state into the previous entry when they share the key and land inside the coalescing window —\n   * so a slider drag or a typed word collapses to a single undo step.\n   */\n  readonly coalesceKey?: string;\n}\n\n/** A history of states — {@link createSnapshotHistory}'s product. */\nexport interface SnapshotHistory<TState> extends HistoryStore {\n  /** The current state. A live getter: re-read it after every notification. */\n  readonly present: TState;\n\n  /**\n   * Publishes `state` as the present and records the step from the previous one. Truncates the redo branch,\n   * evicts past `limit`, and merges into the previous entry when `coalesceKey` matches inside the window.\n   * Recording the state already held is a no-op.\n   */\n  readonly record: (state: TState, options?: SnapshotRecordOptions) => void;\n}\n\n/**\n * Creates a snapshot-based history seeded with `initial`.\n *\n * ```ts\n * const history = createSnapshotHistory({ title: '' }, { limit: 50 });\n * history.record({ title: 'Hel' }, { coalesceKey: 'title' });\n * history.record({ title: 'Hello' }, { coalesceKey: 'title' }); // same undo step\n * history.undo(); // present → { title: '' }\n * ```\n */\nexport function createSnapshotHistory<TState>(\n  initial: TState,\n  options?: HistoryOptions,\n): SnapshotHistory<TState> {\n  let present = initial;\n\n  const core = createHistoryCore<SnapshotPayload<TState>>({\n    applyForward: (payload) => {\n      present = payload.after;\n    },\n    applyBackward: (payload) => {\n      present = payload.before;\n    },\n    mergePayloads: (previous, next) => ({ before: previous.before, after: next.after }),\n    options,\n  });\n\n  // Delegated member by member rather than spread — `present`, `canUndo` and friends are live getters, and a\n  // spread would call each one once and freeze that answer into the facade.\n  return {\n    record(state: TState, recordOptions?: SnapshotRecordOptions): void {\n      if (Object.is(state, present)) return;\n      const before = present;\n      present = state;\n      core.push({\n        label: recordOptions?.label,\n        coalesceKey: recordOptions?.coalesceKey,\n        payload: { before, after: state },\n      });\n    },\n\n    transact: core.transact,\n    undo: core.undo,\n    redo: core.redo,\n    clear: core.clear,\n    subscribe: core.subscribe,\n    version: core.version,\n\n    get present(): TState {\n      return present;\n    },\n\n    get canUndo(): boolean {\n      return core.canUndo;\n    },\n\n    get canRedo(): boolean {\n      return core.canRedo;\n    },\n\n    get size(): number {\n      return core.size;\n    },\n\n    get undoLabel(): string | undefined {\n      return core.undoLabel;\n    },\n\n    get redoLabel(): string | undefined {\n      return core.redoLabel;\n    },\n  };\n}\n","// The Vue seam over the two history flavors — ownership and reactivity, no history logic.\n//\n// A history is a long-lived mutable object whose interesting members are getters, so a component cannot simply\n// hold it and expect its template to update: nothing about `canUndo` flipping is visible to Vue.\n// `useHistoryVersion` closes that gap by subscribing to the store and mirroring its monotonic revision into a\n// `shallowRef` — identity-stable between changes, which a derived value like `size` or a fresh array would not\n// be. Every composable here calls it, so the returned history object is the same object throughout while the\n// values read off it stay fresh: read them inside a `computed` that touches the version.\n//\n// Non-obvious decisions:\n// - Options are captured at SETUP, because the history is created once. `limit` and `coalesceMs` are\n//   configuration and effectively constant; `onError` and `now` are routed through `toValue` instead, since\n//   those two are routinely fresh closures and a stale one would swallow real errors.\n// - `useUndoableState` is deliberately uncontrolled-only. A controlled seam (`value` / `onChange`) would let a\n//   parent change the value out of band, and the history's `present` — the anchor every entry's `before` was\n//   captured against — would silently stop matching the rendered state. Travel would then restore states the\n//   parent never agreed to. A caller who must own the value should own a `createSnapshotHistory` too and drive\n//   `record` from its own reducer.\n// - The setter takes per-call record options, because `coalesceKey` is a property of the interaction (a drag, a\n//   typing burst), not of the composable. A component types with one key and drags a slider with another.\n// - Nothing here touches a platform global, so the subscription could run at setup — it is still attached in\n//   `onMounted` and dropped in `onScopeDispose`, matching every other subscription in the port.\n\nimport {\n  computed,\n  onMounted,\n  onScopeDispose,\n  shallowRef,\n  toValue,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n  type WritableComputedRef,\n} from 'vue';\n\nimport type { HistoryOptions, HistoryStore } from './HistoryCore';\nimport { createSnapshotHistory, type SnapshotHistory, type SnapshotRecordOptions } from './SnapshotHistory';\nimport { createUndoHistory, type UndoHistory } from './UndoHistory';\n\n/**\n * Subscribes to a history's changes and returns its version counter, updating on every push, undo, redo, and\n * clear. Use it directly when the history is owned outside a component (a module-scope editor store) and read\n * it inside a `computed` to make that computed track the history.\n */\nexport function useHistoryVersion(store: HistoryStore): Readonly<ShallowRef<number>> {\n  const version = shallowRef(store.version());\n\n  let unsubscribe: (() => void) | undefined;\n\n  onMounted(() => {\n    // Re-read first: a change between setup and mount would otherwise be missed entirely.\n    version.value = store.version();\n    unsubscribe = store.subscribe(() => {\n      version.value = store.version();\n    });\n  });\n\n  onScopeDispose(() => {\n    unsubscribe?.();\n    unsubscribe = undefined;\n  });\n\n  return version;\n}\n\n/** Builds the options a scope-owned history is created with, routing the two closure-shaped fields live. */\nfunction scopeOptions(options: MaybeRefOrGetter<HistoryOptions | undefined>): HistoryOptions {\n  const initial = toValue(options);\n  return {\n    limit: initial?.limit,\n    coalesceMs: initial?.coalesceMs,\n    onError: (error, phase) => toValue(options)?.onError?.(error, phase),\n    now: () => (toValue(options)?.now ?? Date.now)(),\n  };\n}\n\n/** What {@link useUndoHistory} returns — the history plus the cursor that makes it reactive. */\nexport interface UndoHistoryControls {\n  /** The history itself. Stable — pass it down, or to {@link useUndoShortcuts}, unchanged. */\n  readonly history: UndoHistory;\n\n  /**\n   * The mutation cursor. Its members are getters, so read them inside a `computed` that also touches this —\n   * `computed(() => (version.value, history.canUndo))` — and the computed re-evaluates on every change.\n   */\n  readonly version: Readonly<ShallowRef<number>>;\n\n  /** Whether an undo is available. The pre-derived form of the `version` idiom above. */\n  readonly canUndo: Readonly<ShallowRef<boolean>>;\n\n  /** Whether a redo is available. */\n  readonly canRedo: Readonly<ShallowRef<boolean>>;\n}\n\n/**\n * Owns a command-based {@link UndoHistory} for the scope's lifetime and exposes its reactivity.\n *\n * Returns the history alongside the version cursor and the two flags a toolbar actually renders. The history\n * object never changes identity — pass it down, or to {@link useUndoShortcuts}, without wrapping.\n *\n * @param options History configuration. `limit` / `coalesceMs` are read once; `onError` / `now` stay live.\n */\nexport function useUndoHistory(\n  options?: MaybeRefOrGetter<HistoryOptions | undefined>,\n): UndoHistoryControls {\n  const history = createUndoHistory(scopeOptions(options));\n  const version = useHistoryVersion(history);\n\n  return {\n    history,\n    version,\n    canUndo: computed(() => {\n      void version.value;\n      return history.canUndo;\n    }),\n    canRedo: computed(() => {\n      void version.value;\n      return history.canRedo;\n    }),\n  };\n}\n\n/** Publishes the next state — a value or an updater, plus how this particular change should be recorded. */\nexport type UndoableStateSetter<TState> = (\n  next: TState | ((previous: TState) => TState),\n  options?: SnapshotRecordOptions,\n) => void;\n\n/** What {@link useUndoableState} returns — the value, its setter, and the history behind them. */\nexport interface UndoableState<TState> {\n  /**\n   * The current state. Writable, so it drops straight into `v-model`; a `v-model` write records with no options,\n   * and `setState` is the way to pass `{ label, coalesceKey }`.\n   */\n  readonly state: WritableComputedRef<TState>;\n\n  /** Records the next state — a value or an updater — with optional per-call record options. */\n  readonly setState: UndoableStateSetter<TState>;\n\n  /** The full {@link SnapshotHistory}: `undo` / `redo` / `canUndo` / `transact`, and the target for shortcuts. */\n  readonly history: SnapshotHistory<TState>;\n\n  /** The mutation cursor, for deriving anything the two flags below do not cover. */\n  readonly version: Readonly<ShallowRef<number>>;\n\n  /** Whether an undo is available. */\n  readonly canUndo: Readonly<ShallowRef<boolean>>;\n\n  /** Whether a redo is available. */\n  readonly canRedo: Readonly<ShallowRef<boolean>>;\n}\n\n/**\n * A `ref` with a history behind it — the snapshot flavor as a drop-in for small, immutable state.\n *\n * ```ts\n * const { state, setState, history } = useUndoableState('');\n * setState((prev) => prev + 'a', { label: 'Typing', coalesceKey: 'text' });\n * useUndoShortcuts(history);\n * ```\n *\n * `state` is a writable computed over the history's `present`, so travel is visible immediately and a `v-model`\n * write records an entry. An updater is the only way to store a function-typed state.\n */\nexport function useUndoableState<TState>(\n  initial: TState,\n  options?: MaybeRefOrGetter<HistoryOptions | undefined>,\n): UndoableState<TState> {\n  const history = createSnapshotHistory(initial, scopeOptions(options));\n  const version = useHistoryVersion(history);\n\n  const setState: UndoableStateSetter<TState> = (next, recordOptions) => {\n    // Resolved against the history's live `present`, not a captured value, so two setters in one tick compose.\n    const value = typeof next === 'function' ? (next as (previous: TState) => TState)(history.present) : next;\n    history.record(value, recordOptions);\n  };\n\n  const state = computed<TState>({\n    get: () => {\n      void version.value;\n      return history.present;\n    },\n    set: (next) => setState(next),\n  });\n\n  return {\n    state,\n    setState,\n    history,\n    version,\n    canUndo: computed(() => {\n      void version.value;\n      return history.canUndo;\n    }),\n    canRedo: computed(() => {\n      void version.value;\n      return history.canRedo;\n    }),\n  };\n}\n","// The keyboard binding — opt-in, and separate from the history on purpose.\n//\n// ⌘Z is conventional, not universal: a history driving a background job queue, a wizard's step stack, or a\n// second nested editor must not silently steal the window's undo key. So `createUndoHistory` binds nothing, and\n// a surface that wants the convention calls this composable. Chords route through `foundation/shortcuts`'\n// parser, so `mod` resolves to ⌘ on Apple and Ctrl elsewhere and the app never hard-codes a platform.\n//\n// Non-obvious decisions:\n// - Redo binds BOTH `mod+shift+z` and `mod+y`. The first is the Apple/Linux convention, the second the Windows\n//   one, and users carry the muscle memory of whichever they learned. Binding one and not the other reads as a\n//   broken redo to half the audience.\n// - The target is typed as `UndoRedoTarget`, the four-member subset both flavors satisfy — this composable works\n//   with a command history, a snapshot history, or an app's own object that merely behaves like one.\n// - `useHotkeyMap` lets a Ctrl/⌘ combo through even while a text field has focus (a bare key is suppressed, a\n//   mod combo is not), so ⌘Z fires while the user is typing. That is right for an app-owned document and WRONG\n//   where the field's own native undo should win — `preventDefault` defaults to true and will suppress it.\n//   Scope with `target` or gate with `enabled` on surfaces where the browser should keep the key.\n// - The handler map is built as a getter rather than a fixed object: `useHotkeyMap` accepts a\n//   `MaybeRefOrGetter` and keys its attachment off the parsed chord set, so a reactive `undoChords` re-binds\n//   and an unchanged one costs nothing.\n\nimport { toValue, type MaybeRefOrGetter } from 'vue';\n\nimport { useHotkeyMap, type HotkeyOptions } from '../shortcuts';\n\nimport type { UndoRedoTarget } from './HistoryCore';\n\n/** The conventional undo chord — ⌘Z on Apple, Ctrl+Z elsewhere. */\nconst DEFAULT_UNDO_CHORDS: readonly string[] = ['mod+z'];\n\n/** The conventional redo chords — the Apple/Linux `⌘⇧Z` and the Windows `Ctrl+Y`, both bound. */\nconst DEFAULT_REDO_CHORDS: readonly string[] = ['mod+shift+z', 'mod+y'];\n\n/** Tunes {@link useUndoShortcuts}; every {@link HotkeyOptions} field (`enabled`, `target`, …) applies as usual. */\nexport interface UndoShortcutOptions extends HotkeyOptions {\n  /** Chord(s) that trigger `undo()`. Defaults to `'mod+z'`. */\n  readonly undoChords?: MaybeRefOrGetter<string | readonly string[]>;\n\n  /** Chord(s) that trigger `redo()`. Defaults to `['mod+shift+z', 'mod+y']`. */\n  readonly redoChords?: MaybeRefOrGetter<string | readonly string[]>;\n}\n\n/** Normalises the one-or-many chord option into a list. */\nfunction toChordList(chords: string | readonly string[]): readonly string[] {\n  return typeof chords === 'string' ? [chords] : chords;\n}\n\n/**\n * Binds the conventional undo / redo chords to a history. Opt-in — nothing is bound unless a surface calls this.\n *\n * ```ts\n * const { history } = useUndoHistory();\n * useUndoShortcuts(history);                            // ⌘Z · ⌘⇧Z · ⌘Y\n * useUndoShortcuts(history, { enabled: () => !isModalOpen.value }); // suspended while a dialog owns the keyboard\n * ```\n */\nexport function useUndoShortcuts(target: UndoRedoTarget, options?: UndoShortcutOptions): void {\n  const { undoChords, redoChords, ...hotkeyOptions } = options ?? {};\n\n  useHotkeyMap(() => {\n    const map: Record<string, (event: KeyboardEvent) => void> = {};\n    for (const chord of toChordList(toValue(undoChords) ?? DEFAULT_UNDO_CHORDS)) {\n      map[chord] = () => {\n        target.undo();\n      };\n    }\n    for (const chord of toChordList(toValue(redoChords) ?? DEFAULT_REDO_CHORDS)) {\n      map[chord] = () => {\n        target.redo();\n      };\n    }\n    return map;\n  }, hotkeyOptions);\n}\n"],"names":[],"mappings":";;AA8BO,MAAM,eAAe;AAAA;AAAA,EAE1B,MAAM;AAAA;AAAA,EAEN,MAAM;AACR;AAQO,MAAM,sBAAsB;AA6G5B,SAAS,kBAA4B,QAA4D;AACtG,QAAM,EAAE,cAAc,eAAe,eAAe,YAAY;AAEhE,QAAM,gCAAgB,IAAA;AACtB,QAAM,UAAiC,CAAA;AAGvC,MAAI,SAAS;AACb,MAAI,WAAW;AAGf,MAAI,QAAQ;AACZ,MAAI,SAAgC,CAAA;AACpC,MAAI;AAGJ,MAAI;AACJ,MAAI,WAAW;AAGf,WAAS,MAAc;AACrB,WAAO,SAAS,WAAW,KAAK,IAAA;AAAA,EAClC;AAGA,WAAS,SAAe;AACtB,gBAAY;AACZ,eAAW,YAAY,CAAC,GAAG,SAAS,EAAG,UAAA;AAAA,EACzC;AAGA,WAAS,aAAmB;AAC1B,gBAAY;AAAA,EACd;AAGA,WAAS,QAAc;AACrB,UAAM,QAAQ,SAAS;AACvB,QAAI,UAAU,UAAa,CAAC,OAAO,SAAS,KAAK,EAAG;AACpD,UAAM,MAAM,KAAK,IAAI,GAAG,KAAK;AAC7B,WAAO,QAAQ,SAAS,KAAK;AAC3B,cAAQ,MAAA;AACR,eAAS,KAAK,IAAI,GAAG,SAAS,CAAC;AAAA,IACjC;AAAA,EACF;AAGA,WAAS,OAAO,OAAkC;AAChD,UAAM,KAAK,IAAA;AACX,UAAM,WAAW,SAAS,IAAI,QAAQ,GAAG,SAAS,CAAC,IAAI;AACvD,UAAM,cACJ,MAAM,gBAAgB,UACtB,MAAM,gBAAgB,aACtB,aAAa;AAAA,IAEb,WAAW,QAAQ,UACnB,KAAK,aAAa,SAAS,cAAc;AAE3C,QAAI,eAAe,aAAa,QAAW;AACzC,cAAQ,SAAS,CAAC,IAAI;AAAA;AAAA,QAEpB,OAAO,SAAS,SAAS,MAAM;AAAA,QAC/B,SAAS,cAAc,SAAS,SAAS,MAAM,OAAO;AAAA,QACtD,aAAa,MAAM;AAAA,MAAA;AAErB,iBAAW;AACX,aAAA;AACA;AAAA,IACF;AAGA,YAAQ,SAAS;AACjB,YAAQ,KAAK,KAAK;AAClB,aAAS,QAAQ;AACjB,gBAAY,MAAM;AAClB,eAAW;AACX,UAAA;AACA,WAAA;AAAA,EACF;AAGA,WAAS,QAAc;AACrB,UAAM,UAAU;AAChB,aAAS,CAAA;AACT,UAAM,QAAQ,QAAQ,GAAG,CAAC;AAC1B,QAAI,UAAU,OAAW;AAEzB,UAAM,UAAU,QACb,MAAM,CAAC,EACP,OAAO,CAAC,QAAQ,UAAU,cAAc,QAAQ,MAAM,OAAO,GAAG,MAAM,OAAO;AAEhF,WAAO,EAAE,OAAO,eAAe,MAAM,OAAO,SAAS,aAAa,QAAW;AAAA,EAC/E;AAEA,SAAO;AAAA,IACL,KAAK,SAA6C;AAChD,YAAM,QAA6B;AAAA,QACjC,OAAO,QAAQ;AAAA,QACf,SAAS,QAAQ;AAAA,QACjB,aAAa,QAAQ;AAAA,MAAA;AAGvB,UAAI,QAAQ,GAAG;AACb,eAAO,KAAK,KAAK;AACjB;AAAA,MACF;AACA,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,SAAkB,OAA2B,IAA4B;AAEvE,UAAI,UAAU,EAAG,eAAc;AAC/B,eAAS;AACT,UAAI;AACF,eAAO,GAAA;AAAA,MACT,UAAA;AACE,iBAAS;AACT,YAAI,UAAU,GAAG;AAEf,gBAAA;AACA,wBAAc;AAAA,QAChB;AAAA,MACF;AAAA,IACF;AAAA,IAEA,OAAgB;AACd,UAAI,WAAW,EAAG,QAAO;AACzB,YAAM,QAAQ,QAAQ,GAAG,SAAS,CAAC;AACnC,UAAI,UAAU,OAAW,QAAO;AAChC,UAAI;AACF,sBAAc,MAAM,OAAO;AAAA,MAC7B,SAAS,OAAO;AAEd,iBAAS,UAAU,OAAO,aAAa,IAAI;AAC3C,eAAO;AAAA,MACT;AACA,gBAAU;AACV,iBAAA;AACA,aAAA;AACA,aAAO;AAAA,IACT;AAAA,IAEA,OAAgB;AACd,YAAM,QAAQ,QAAQ,GAAG,MAAM;AAC/B,UAAI,UAAU,QAAQ,UAAU,UAAU,OAAW,QAAO;AAC5D,UAAI;AACF,qBAAa,MAAM,OAAO;AAAA,MAC5B,SAAS,OAAO;AACd,iBAAS,UAAU,OAAO,aAAa,IAAI;AAC3C,eAAO;AAAA,MACT;AACA,gBAAU;AACV,iBAAA;AACA,aAAA;AACA,aAAO;AAAA,IACT;AAAA,IAEA,QAAc;AACZ,cAAQ,SAAS;AACjB,eAAS;AACT,iBAAA;AACA,aAAA;AAAA,IACF;AAAA,IAEA,UAAU,UAAuC;AAC/C,gBAAU,IAAI,QAAQ;AACtB,aAAO,MAAM;AACX,kBAAU,OAAO,QAAQ;AAAA,MAC3B;AAAA,IACF;AAAA,IAEA,UAAkB;AAChB,aAAO;AAAA,IACT;AAAA,IAEA,IAAI,UAAmB;AACrB,aAAO,SAAS;AAAA,IAClB;AAAA,IAEA,IAAI,UAAmB;AACrB,aAAO,SAAS,QAAQ;AAAA,IAC1B;AAAA,IAEA,IAAI,OAAe;AACjB,aAAO,QAAQ;AAAA,IACjB;AAAA,IAEA,IAAI,YAAgC;AAClC,aAAO,SAAS,IAAI,QAAQ,GAAG,SAAS,CAAC,GAAG,QAAQ;AAAA,IACtD;AAAA,IAEA,IAAI,YAAgC;AAClC,aAAO,QAAQ,GAAG,MAAM,GAAG;AAAA,IAC7B;AAAA,EAAA;AAEJ;ACjRO,SAAS,kBAAkB,SAAuC;AACvE,QAAM,OAAO,kBAAiC;AAAA,IAC5C,cAAc,CAAC,YAAY,QAAQ,GAAA;AAAA,IACnC,eAAe,CAAC,YAAY,QAAQ,KAAA;AAAA,IACpC,eAAe,CAAC,UAAU,UAAU;AAAA,MAClC,IAAI,MAAM;AACR,iBAAS,GAAA;AACT,aAAK,GAAA;AAAA,MACP;AAAA,MACA,MAAM,MAAM;AAEV,aAAK,KAAA;AACL,iBAAS,KAAA;AAAA,MACX;AAAA,IAAA;AAAA,IAEF;AAAA,EAAA,CACD;AAGD,WAAS,KAAK,QAA8B;AAC1C,SAAK,KAAK;AAAA,MACR,OAAO,OAAO;AAAA,MACd,aAAa,OAAO;AAAA,MACpB,SAAS,EAAE,IAAI,OAAO,IAAI,MAAM,OAAO,KAAA;AAAA,IAAK,CAC7C;AAAA,EACH;AAIA,SAAO;AAAA,IACL;AAAA,IAEA,QAAQ,QAA8B;AACpC,aAAO,GAAA;AACP,WAAK,MAAM;AAAA,IACb;AAAA,IAEA,UAAU,KAAK;AAAA,IACf,MAAM,KAAK;AAAA,IACX,MAAM,KAAK;AAAA,IACX,OAAO,KAAK;AAAA,IACZ,WAAW,KAAK;AAAA,IAChB,SAAS,KAAK;AAAA,IAEd,IAAI,UAAmB;AACrB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,UAAmB;AACrB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,OAAe;AACjB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,YAAgC;AAClC,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,YAAgC;AAClC,aAAO,KAAK;AAAA,IACd;AAAA,EAAA;AAEJ;ACzEO,SAAS,sBACd,SACA,SACyB;AACzB,MAAI,UAAU;AAEd,QAAM,OAAO,kBAA2C;AAAA,IACtD,cAAc,CAAC,YAAY;AACzB,gBAAU,QAAQ;AAAA,IACpB;AAAA,IACA,eAAe,CAAC,YAAY;AAC1B,gBAAU,QAAQ;AAAA,IACpB;AAAA,IACA,eAAe,CAAC,UAAU,UAAU,EAAE,QAAQ,SAAS,QAAQ,OAAO,KAAK;IAC3E;AAAA,EAAA,CACD;AAID,SAAO;AAAA,IACL,OAAO,OAAe,eAA6C;AACjE,UAAI,OAAO,GAAG,OAAO,OAAO,EAAG;AAC/B,YAAM,SAAS;AACf,gBAAU;AACV,WAAK,KAAK;AAAA,QACR,OAAO,eAAe;AAAA,QACtB,aAAa,eAAe;AAAA,QAC5B,SAAS,EAAE,QAAQ,OAAO,MAAA;AAAA,MAAM,CACjC;AAAA,IACH;AAAA,IAEA,UAAU,KAAK;AAAA,IACf,MAAM,KAAK;AAAA,IACX,MAAM,KAAK;AAAA,IACX,OAAO,KAAK;AAAA,IACZ,WAAW,KAAK;AAAA,IAChB,SAAS,KAAK;AAAA,IAEd,IAAI,UAAkB;AACpB,aAAO;AAAA,IACT;AAAA,IAEA,IAAI,UAAmB;AACrB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,UAAmB;AACrB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,OAAe;AACjB,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,YAAgC;AAClC,aAAO,KAAK;AAAA,IACd;AAAA,IAEA,IAAI,YAAgC;AAClC,aAAO,KAAK;AAAA,IACd;AAAA,EAAA;AAEJ;ACpFO,SAAS,kBAAkB,OAAmD;AACnF,QAAM,UAAU,WAAW,MAAM,QAAA,CAAS;AAE1C,MAAI;AAEJ,YAAU,MAAM;AAEd,YAAQ,QAAQ,MAAM,QAAA;AACtB,kBAAc,MAAM,UAAU,MAAM;AAClC,cAAQ,QAAQ,MAAM,QAAA;AAAA,IACxB,CAAC;AAAA,EACH,CAAC;AAED,iBAAe,MAAM;AACnB,kBAAA;AACA,kBAAc;AAAA,EAChB,CAAC;AAED,SAAO;AACT;AAGA,SAAS,aAAa,SAAuE;AAC3F,QAAM,UAAU,QAAQ,OAAO;AAC/B,SAAO;AAAA,IACL,OAAO,SAAS;AAAA,IAChB,YAAY,SAAS;AAAA,IACrB,SAAS,CAAC,OAAO,UAAU,QAAQ,OAAO,GAAG,UAAU,OAAO,KAAK;AAAA,IACnE,KAAK,OAAO,QAAQ,OAAO,GAAG,OAAO,KAAK,KAAA;AAAA,EAAK;AAEnD;AA4BO,SAAS,eACd,SACqB;AACrB,QAAM,UAAU,kBAAkB,aAAa,OAAO,CAAC;AACvD,QAAM,UAAU,kBAAkB,OAAO;AAEzC,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS,SAAS,MAAM;AACtB,WAAK,QAAQ;AACb,aAAO,QAAQ;AAAA,IACjB,CAAC;AAAA,IACD,SAAS,SAAS,MAAM;AACtB,WAAK,QAAQ;AACb,aAAO,QAAQ;AAAA,IACjB,CAAC;AAAA,EAAA;AAEL;AA4CO,SAAS,iBACd,SACA,SACuB;AACvB,QAAM,UAAU,sBAAsB,SAAS,aAAa,OAAO,CAAC;AACpE,QAAM,UAAU,kBAAkB,OAAO;AAEzC,QAAM,WAAwC,CAAC,MAAM,kBAAkB;AAErE,UAAM,QAAQ,OAAO,SAAS,aAAc,KAAsC,QAAQ,OAAO,IAAI;AACrG,YAAQ,OAAO,OAAO,aAAa;AAAA,EACrC;AAEA,QAAM,QAAQ,SAAiB;AAAA,IAC7B,KAAK,MAAM;AACT,WAAK,QAAQ;AACb,aAAO,QAAQ;AAAA,IACjB;AAAA,IACA,KAAK,CAAC,SAAS,SAAS,IAAI;AAAA,EAAA,CAC7B;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,SAAS,MAAM;AACtB,WAAK,QAAQ;AACb,aAAO,QAAQ;AAAA,IACjB,CAAC;AAAA,IACD,SAAS,SAAS,MAAM;AACtB,WAAK,QAAQ;AACb,aAAO,QAAQ;AAAA,IACjB,CAAC;AAAA,EAAA;AAEL;AC1KA,MAAM,sBAAyC,CAAC,OAAO;AAGvD,MAAM,sBAAyC,CAAC,eAAe,OAAO;AAYtE,SAAS,YAAY,QAAuD;AAC1E,SAAO,OAAO,WAAW,WAAW,CAAC,MAAM,IAAI;AACjD;AAWO,SAAS,iBAAiB,QAAwB,SAAqC;AAC5F,QAAM,EAAE,YAAY,YAAY,GAAG,cAAA,IAAkB,WAAW,CAAA;AAEhE,eAAa,MAAM;AACjB,UAAM,MAAsD,CAAA;AAC5D,eAAW,SAAS,YAAY,QAAQ,UAAU,KAAK,mBAAmB,GAAG;AAC3E,UAAI,KAAK,IAAI,MAAM;AACjB,eAAO,KAAA;AAAA,MACT;AAAA,IACF;AACA,eAAW,SAAS,YAAY,QAAQ,UAAU,KAAK,mBAAmB,GAAG;AAC3E,UAAI,KAAK,IAAI,MAAM;AACjB,eAAO,KAAA;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,GAAG,aAAa;AAClB;"}

package/dist/foundation/utils/Align/index.d.ts

@@ -1 +0,0 @@
-export * from './Align';