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

package/dist/chunks/useOutsideClick-CW80BJfE.js

@@ -1,22 +0,0 @@
-import { watchPostEffect, toValue } from "vue";
-function useOutsideClick(targets, handler, enabled = true) {
-  const targetList = Array.isArray(targets) ? targets : [targets];
-  watchPostEffect((onCleanup) => {
-    if (!toValue(enabled) || typeof document === "undefined") return;
-    const onPointerDown = (e) => {
-      const target = e.target;
-      if (!target) return;
-      for (const candidate of targetList) {
-        const element = toValue(candidate);
-        if (element && element.contains(target)) return;
-      }
-      handler(e);
-    };
-    document.addEventListener("pointerdown", onPointerDown, true);
-    onCleanup(() => document.removeEventListener("pointerdown", onPointerDown, true));
-  });
-}
-export {
-  useOutsideClick as u
-};
-//# sourceMappingURL=useOutsideClick-CW80BJfE.js.map

package/dist/chunks/useOutsideClick-CW80BJfE.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useOutsideClick-CW80BJfE.js","sources":["../../src/foundation/hooks/useOutsideClick/useOutsideClick.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\n/** One element source — a template ref, a plain element, or a getter that resolves to either. */\nexport type OutsideClickTarget = MaybeRefOrGetter<HTMLElement | null | undefined>;\n\n/**\n * Fire `handler` when the user clicks outside any of the provided targets.\n * Uses `pointerdown` so it fires before focus shifts (avoids losing focus\n * inside an overlay before a click on a trigger registers).\n *\n * Pass a `useTemplateRef` (or an array of them) — each is resolved at event\n * time, so a target that mounts later is still honoured without re-attaching.\n */\nexport function useOutsideClick(\n  targets: OutsideClickTarget | ReadonlyArray<OutsideClickTarget>,\n  handler: (event: PointerEvent) => void,\n  enabled: MaybeRefOrGetter<boolean> = true,\n): void {\n  // `Array.isArray` does not narrow a `ReadonlyArray` union, hence the assertions.\n  const targetList: ReadonlyArray<OutsideClickTarget> = Array.isArray(targets)\n    ? (targets as ReadonlyArray<OutsideClickTarget>)\n    : [targets as OutsideClickTarget];\n\n  watchPostEffect((onCleanup) => {\n    if (!toValue(enabled) || typeof document === 'undefined') return;\n\n    const onPointerDown = (e: PointerEvent): void => {\n      const target = e.target as Node | null;\n      if (!target) return;\n      for (const candidate of targetList) {\n        const element = toValue(candidate);\n        if (element && element.contains(target)) return;\n      }\n      handler(e);\n    };\n\n    document.addEventListener('pointerdown', onPointerDown, true);\n    onCleanup(() => document.removeEventListener('pointerdown', onPointerDown, true));\n  });\n}\n"],"names":[],"mappings":";AAaO,SAAS,gBACd,SACA,SACA,UAAqC,MAC/B;AAEN,QAAM,aAAgD,MAAM,QAAQ,OAAO,IACtE,UACD,CAAC,OAA6B;AAElC,kBAAgB,CAAC,cAAc;AAC7B,QAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,aAAa,YAAa;AAE1D,UAAM,gBAAgB,CAAC,MAA0B;AAC/C,YAAM,SAAS,EAAE;AACjB,UAAI,CAAC,OAAQ;AACb,iBAAW,aAAa,YAAY;AAClC,cAAM,UAAU,QAAQ,SAAS;AACjC,YAAI,WAAW,QAAQ,SAAS,MAAM,EAAG;AAAA,MAC3C;AACA,cAAQ,CAAC;AAAA,IACX;AAEA,aAAS,iBAAiB,eAAe,eAAe,IAAI;AAC5D,cAAU,MAAM,SAAS,oBAAoB,eAAe,eAAe,IAAI,CAAC;AAAA,EAClF,CAAC;AACH;"}

package/dist/chunks/useRecentItems-DFnt5CBy.js

@@ -1,137 +0,0 @@
-import { onScopeDispose, watch, toValue, shallowRef, computed, onMounted } from "vue";
-import { l as localStorageStorageBroker } from "./StorageBroker-COC81ZGB.js";
-function isPrintableKey(event) {
-  if (event.ctrlKey || event.metaKey || event.altKey) return false;
-  return event.key.length === 1;
-}
-function isAllSameChar(buffer) {
-  return buffer.length > 0 && [...buffer].every((c) => c === buffer[0]);
-}
-function useTypeahead(options) {
-  let buffer = "";
-  let timer = null;
-  const isEnabled = () => toValue(options.enabled ?? true);
-  function clearTimer() {
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  }
-  function reset() {
-    buffer = "";
-    clearTimer();
-  }
-  onScopeDispose(clearTimer);
-  function onKeyDown(event) {
-    if (!isEnabled()) return false;
-    if (!isPrintableKey(event)) return false;
-    const isSpace = event.key === " ";
-    const hasBuffer = buffer.length > 0;
-    if (isSpace && !hasBuffer) return false;
-    const list = toValue(options.items);
-    if (list.length === 0) return false;
-    const nextBuffer = buffer + event.key;
-    buffer = nextBuffer;
-    clearTimer();
-    timer = setTimeout(() => {
-      buffer = "";
-      timer = null;
-    }, toValue(options.timeout ?? 500));
-    const labelOf = (item) => options.getLabel(item).toLowerCase();
-    const disabledOf = (item) => options.isDisabled ? options.isDisabled(item) : false;
-    const startFrom = options.getActiveIndex ? options.getActiveIndex() : -1;
-    let matchIndex = -1;
-    if (isAllSameChar(nextBuffer)) {
-      const char = nextBuffer[0].toLowerCase();
-      for (let step = 1; step <= list.length; step += 1) {
-        const idx = (startFrom + step + list.length) % list.length;
-        const item = list[idx];
-        if (!disabledOf(item) && labelOf(item).startsWith(char)) {
-          matchIndex = idx;
-          break;
-        }
-      }
-    } else {
-      const prefix = nextBuffer.toLowerCase();
-      const begin = startFrom < 0 ? 0 : startFrom;
-      for (let step = 0; step < list.length; step += 1) {
-        const idx = (begin + step) % list.length;
-        const item = list[idx];
-        if (!disabledOf(item) && labelOf(item).startsWith(prefix)) {
-          matchIndex = idx;
-          break;
-        }
-      }
-    }
-    if (matchIndex >= 0) {
-      options.onMatch(list[matchIndex], matchIndex);
-      return true;
-    }
-    return true;
-  }
-  watch(isEnabled, (nowEnabled) => {
-    if (!nowEnabled) reset();
-  });
-  return { onKeyDown, reset };
-}
-function canSyncAcrossTabs(broker) {
-  return broker === localStorageStorageBroker && typeof window !== "undefined";
-}
-function usePersistentState(key, initial, options) {
-  const broker = options?.broker ?? localStorageStorageBroker;
-  const state = shallowRef(initial);
-  const setValue = (next) => {
-    const resolved = typeof next === "function" ? next(state.value) : next;
-    broker.write(toValue(key), resolved);
-    state.value = resolved;
-  };
-  const value = computed({
-    get: () => state.value,
-    set: setValue
-  });
-  function hydrate() {
-    const persisted = broker.read(toValue(key));
-    if (persisted !== null) state.value = persisted;
-  }
-  onMounted(hydrate);
-  watch(() => toValue(key), hydrate);
-  let detachStorage = null;
-  onMounted(() => {
-    if (!canSyncAcrossTabs(broker)) return;
-    function onStorage(event) {
-      const currentKey = toValue(key);
-      if (event.key !== currentKey) return;
-      state.value = event.newValue === null ? initial : broker.read(currentKey) ?? initial;
-    }
-    window.addEventListener("storage", onStorage);
-    detachStorage = () => window.removeEventListener("storage", onStorage);
-  });
-  onScopeDispose(() => {
-    detachStorage?.();
-    detachStorage = null;
-  });
-  return { value, setValue };
-}
-const DefaultMax = 24;
-function prependRecent(items, item, identify, max) {
-  const id = identify(item);
-  const withoutDuplicate = items.filter((existing) => identify(existing) !== id);
-  return [item, ...withoutDuplicate].slice(0, Math.max(0, max));
-}
-function useRecentItems(key, options) {
-  const { identify, max = DefaultMax, broker } = options;
-  const state = usePersistentState(key, [], { broker });
-  const recents = computed(() => state.value.value);
-  const push = (item) => {
-    state.setValue((previous) => prependRecent(previous, item, identify, toValue(max)));
-  };
-  const clear = () => state.setValue([]);
-  return { recents, push, clear };
-}
-export {
-  useRecentItems as a,
-  useTypeahead as b,
-  prependRecent as p,
-  usePersistentState as u
-};
-//# sourceMappingURL=useRecentItems-DFnt5CBy.js.map

package/dist/chunks/useRecentItems-DFnt5CBy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useRecentItems-DFnt5CBy.js","sources":["../../src/foundation/hooks/useTypeahead/useTypeahead.ts","../../src/foundation/hooks/usePersistentState/usePersistentState.ts","../../src/foundation/hooks/useRecentItems/useRecentItems.ts"],"sourcesContent":["import { onScopeDispose, toValue, watch, type MaybeRefOrGetter } from 'vue';\n\n/** Resolves the typeahead item pool — a static array, a ref, or a getter read lazily on each keystroke. */\ntype ItemSource<T> = MaybeRefOrGetter<readonly T[]>;\n\n/** Configures {@link useTypeahead}. `T` is the item type the caller stores per option. */\nexport interface UseTypeaheadOptions<T> {\n  /** Supplies the items to match against; a ref or function is re-read on every keystroke (live lists). */\n  items: ItemSource<T>;\n\n  /** Extracts the comparable label from an item. Matching is case-insensitive on this string. */\n  getLabel: (item: T) => string;\n\n  /** Reports whether an item is disabled; disabled items are skipped during matching. */\n  isDisabled?: (item: T) => boolean;\n\n  /** Fires with the matched item and its index in the (live) item array when a keystroke resolves. */\n  onMatch: (item: T, index: number) => void;\n\n  /** Returns the index of the currently-active item — same-letter cycling starts after it. */\n  getActiveIndex?: () => number;\n\n  /** Disables the matcher when `false`; every key falls through unhandled. Defaults to `true`. */\n  enabled?: MaybeRefOrGetter<boolean>;\n\n  /** Idle time (ms) after which the typed buffer resets. Defaults to `500`. */\n  timeout?: MaybeRefOrGetter<number>;\n}\n\n/** The keyboard handler + manual reset returned by {@link useTypeahead}. */\nexport interface UseTypeaheadReturn {\n  /** Feeds a keydown into the matcher. Returns `true` when consumed (caller should stop), else `false`. */\n  onKeyDown: (event: KeyboardEvent) => boolean;\n\n  /** Clears the typed buffer immediately (e.g. on blur / close). */\n  reset: () => void;\n}\n\n/** Reports whether a key event carries a single printable character (and no command modifier). */\nfunction isPrintableKey(event: KeyboardEvent): boolean {\n  if (event.ctrlKey || event.metaKey || event.altKey) return false;\n  // Printable keys surface as a single char in `key`; named keys (Enter, ArrowDown…) are multi-char.\n  return event.key.length === 1;\n}\n\n/** Reports whether every char in the buffer is the same letter — the \"cycle\" case (e.g. \"aaa\"). */\nfunction isAllSameChar(buffer: string): boolean {\n  return buffer.length > 0 && [...buffer].every((c) => c === buffer[0]);\n}\n\n/**\n * APG-correct type-to-select matcher (WAI-ARIA listbox/combobox typeahead). Accumulates printable\n * chars into a buffer (resets after `timeout` ms idle): a repeated single char cycles to the next\n * label starting with it (after `getActiveIndex()`, wrap-around), else prefix-matches the whole\n * buffer case-insensitively; disabled items skipped. On a hit `onMatch(item, index)` fires; consumed\n * keys return `true`, others `false` to fall through. Space is typeable only while buffering (a\n * leading Space reaches the caller). SSR-safe; reset timer cleared when the scope is disposed.\n *\n * `items`, `enabled` and `timeout` may each be a ref or getter and are read per keystroke, so the\n * matcher tracks a live list without the original's options-in-a-ref indirection. The callbacks\n * (`getLabel`, `onMatch`, …) are read off the options object at call time — pass a `reactive`\n * options object if they must be swappable.\n */\nexport function useTypeahead<T>(options: UseTypeaheadOptions<T>): UseTypeaheadReturn {\n  let buffer = '';\n  let timer: ReturnType<typeof setTimeout> | null = null;\n\n  const isEnabled = (): boolean => toValue(options.enabled ?? true);\n\n  function clearTimer(): void {\n    if (timer !== null) {\n      clearTimeout(timer);\n      timer = null;\n    }\n  }\n\n  function reset(): void {\n    buffer = '';\n    clearTimer();\n  }\n\n  /* Clears the pending reset timer on teardown (no stale fire after the scope is gone). */\n  onScopeDispose(clearTimer);\n\n  function onKeyDown(event: KeyboardEvent): boolean {\n    if (!isEnabled()) return false;\n    if (!isPrintableKey(event)) return false;\n\n    const isSpace = event.key === ' ';\n    const hasBuffer = buffer.length > 0;\n    /* Reserve Space: with no active buffer, hand it back so the caller can select; while typing,\n       a Space is a real character (matches labels with spaces) and is consumed. */\n    if (isSpace && !hasBuffer) return false;\n\n    const list = toValue(options.items);\n    if (list.length === 0) return false;\n\n    const nextBuffer = buffer + event.key;\n    buffer = nextBuffer;\n\n    /* Restart the idle window on every accepted keystroke. */\n    clearTimer();\n    timer = setTimeout(() => {\n      buffer = '';\n      timer = null;\n    }, toValue(options.timeout ?? 500));\n\n    const labelOf = (item: T): string => options.getLabel(item).toLowerCase();\n    const disabledOf = (item: T): boolean => (options.isDisabled ? options.isDisabled(item) : false);\n    const startFrom = options.getActiveIndex ? options.getActiveIndex() : -1;\n\n    let matchIndex = -1;\n    if (isAllSameChar(nextBuffer)) {\n      /* Same-letter repeat → cycle to the next label starting with that letter, after the active one. */\n      const char = nextBuffer[0]!.toLowerCase();\n      for (let step = 1; step <= list.length; step += 1) {\n        const idx = (startFrom + step + list.length) % list.length;\n        const item = list[idx]!;\n        if (!disabledOf(item) && labelOf(item).startsWith(char)) {\n          matchIndex = idx;\n          break;\n        }\n      }\n    } else {\n      /* Multi-char buffer → prefix-match the whole buffer; scan from the current item forward so a\n         refining sequence stays put when the active item still matches. */\n      const prefix = nextBuffer.toLowerCase();\n      const begin = startFrom < 0 ? 0 : startFrom;\n      for (let step = 0; step < list.length; step += 1) {\n        const idx = (begin + step) % list.length;\n        const item = list[idx]!;\n        if (!disabledOf(item) && labelOf(item).startsWith(prefix)) {\n          matchIndex = idx;\n          break;\n        }\n      }\n    }\n\n    if (matchIndex >= 0) {\n      options.onMatch(list[matchIndex]!, matchIndex);\n      return true;\n    }\n    /* No label matched, but the char was consumed into the buffer (and Space, once buffering,\n       must not double as select) — report handled so the caller doesn't also act on it. */\n    return true;\n  }\n\n  /* `enabled` toggling off mid-type should not leave a stale buffer/timer armed. */\n  watch(isEnabled, (nowEnabled) => {\n    if (!nowEnabled) reset();\n  });\n\n  return { onKeyDown, reset };\n}\n","import {\n  computed,\n  onMounted,\n  onScopeDispose,\n  shallowRef,\n  toValue,\n  watch,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n  type WritableComputedRef,\n} from 'vue';\n\nimport { localStorageStorageBroker, type StorageBroker } from '../../storage';\n\n/** Defines the options that tune where and how `usePersistentState` persists. */\nexport interface PersistentStateOptions {\n  /** The persistence seam to read and write through; defaults to `localStorageStorageBroker`. */\n  readonly broker?: StorageBroker;\n}\n\n/** A setter that accepts a next value or an updater fn, mirroring the original's `useState` dispatch. */\nexport type SetPersistentState<T> = (next: T | ((previous: T) => T)) => void;\n\n/** The persistent-state handle — a writable value plus the updater-accepting setter it delegates to. */\nexport interface PersistentState<T> {\n  /**\n   * The live value. Writable: `value.value = next` runs the same write-through path as `setValue(next)`.\n   * A writable computed rather than a plain ref, so persistence is driven by the assignment itself —\n   * mutating a nested field in place does not persist, exactly as the original required a setter call.\n   */\n  readonly value: WritableComputedRef<T>;\n\n  /** Sets the next value — or derives it from the previous one — and writes it through the broker. */\n  readonly setValue: SetPersistentState<T>;\n}\n\n/** Resolves whether cross-tab sync is available — the `storage` event only fires for the shared `localStorage`, and only in a browser. */\nfunction canSyncAcrossTabs(broker: StorageBroker): boolean {\n  return broker === localStorageStorageBroker && typeof window !== 'undefined';\n}\n\n/**\n * Manages a piece of state mirrored into a `StorageBroker` under `key`. Hydrates from the broker on\n * mount (SSR-safe: the first render always uses `initial`, then a mount hook adopts any persisted value, so\n * server and client markup match), writes through on every set, and — when backed by `localStorage` —\n * adopts writes from other tabs via the window `storage` event.\n *\n * Returns `{ value, setValue }` rather than a tuple: `value` is writable (`state.value = next`), and\n * `setValue` is kept because it additionally accepts an updater fn. `key` may be a ref or getter — changing\n * it re-hydrates from the new slot.\n */\nexport function usePersistentState<T>(\n  key: MaybeRefOrGetter<string>,\n  initial: T,\n  options?: PersistentStateOptions,\n): PersistentState<T> {\n  const broker = options?.broker ?? localStorageStorageBroker;\n\n  // `initial` is the first-paint value on both server and client; a mount hook reconciles it with storage,\n  // so hydration never diverges. Cast: `shallowRef`'s return type is a conditional over an unresolved `T`.\n  const state = shallowRef(initial) as ShallowRef<T>;\n\n  const setValue: SetPersistentState<T> = (next) => {\n    const resolved =\n      typeof next === 'function' ? (next as (previous: T) => T)(state.value) : (next as T);\n    broker.write(toValue(key), resolved);\n    state.value = resolved;\n  };\n\n  const value = computed<T>({\n    get: () => state.value,\n    set: setValue,\n  });\n\n  /** Adopts the persisted value for the current key — a hit wins over what is held, a miss leaves it alone. */\n  function hydrate(): void {\n    const persisted = broker.read<T>(toValue(key));\n    if (persisted !== null) state.value = persisted;\n  }\n\n  onMounted(hydrate);\n  // A key swap re-reads from the new slot. Adoption assigns `state` directly, never through `setValue`, so\n  // reading a value never writes it back.\n  watch(() => toValue(key), hydrate);\n\n  // Adopt writes made under the same key in another tab. Guarded so a non-localStorage or SSR context attaches\n  // no listener. `event.newValue === null` means the key was removed elsewhere — fall back to `initial`.\n  let detachStorage: (() => void) | null = null;\n\n  onMounted(() => {\n    if (!canSyncAcrossTabs(broker)) return;\n\n    function onStorage(event: StorageEvent): void {\n      const currentKey = toValue(key);\n      if (event.key !== currentKey) return;\n      state.value = event.newValue === null ? initial : (broker.read<T>(currentKey) ?? initial);\n    }\n\n    window.addEventListener('storage', onStorage);\n    detachStorage = () => window.removeEventListener('storage', onStorage);\n  });\n\n  // Registered at setup level — `onScopeDispose` only binds to the component's effect scope while that scope\n  // is current, which it is not inside `onMounted`.\n  onScopeDispose(() => {\n    detachStorage?.();\n    detachStorage = null;\n  });\n\n  return { value, setValue };\n}\n","import { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { type StorageBroker } from '../../storage';\nimport { usePersistentState } from '../usePersistentState';\n\n/** The default cap on retained recents, applied when `max` is omitted. */\nconst DefaultMax = 24;\n\n/** Defines the options that configure a recent-items list — identity, cap, and the persistence seam. */\nexport interface RecentItemsOptions<T> {\n  /** Derives a stable de-duplication key for an item; re-pushing a matching item moves it to the front. */\n  readonly identify: (item: T) => string;\n\n  /** The maximum number of items retained, most-recent-first; defaults to 24. */\n  readonly max?: MaybeRefOrGetter<number>;\n\n  /** The persistence seam to store the list through; defaults to `localStorageStorageBroker` via `usePersistentState`. */\n  readonly broker?: StorageBroker;\n}\n\n/** Represents a most-recently-used list plus the operations that mutate it. */\nexport interface RecentItems<T> {\n  /** The retained items, most-recent-first. */\n  readonly recents: ComputedRef<ReadonlyArray<T>>;\n\n  /** Records `item` as the most recent — de-duplicated by identity and capped at `max`. */\n  readonly push: (item: T) => void;\n\n  /** Empties the list. */\n  readonly clear: () => void;\n}\n\n/**\n * Prepends `item` to `items` as the most recent, de-duplicating by `identify` (an existing match is removed so\n * the item resurfaces at the front) and capping the result to `max`. Pure — the reducer the composable writes\n * through its adapter.\n */\nexport function prependRecent<T>(\n  items: ReadonlyArray<T>,\n  item: T,\n  identify: (item: T) => string,\n  max: number,\n): ReadonlyArray<T> {\n  const id = identify(item);\n  const withoutDuplicate = items.filter((existing) => identify(existing) !== id);\n  return [item, ...withoutDuplicate].slice(0, Math.max(0, max));\n}\n\n/**\n * Manages a persisted most-recently-used list under `key`, layered on `usePersistentState`. `push` records an\n * item at the front, de-duplicated by `identify` and capped at `max` (default 24); `clear` empties it. The list\n * inherits the underlying composable's hydrate-on-mount, write-through, and cross-tab sync.\n *\n * `recents` is a read-only computed — mutate the list through `push` / `clear`, never in place.\n */\nexport function useRecentItems<T>(\n  key: MaybeRefOrGetter<string>,\n  options: RecentItemsOptions<T>,\n): RecentItems<T> {\n  const { identify, max = DefaultMax, broker } = options;\n\n  const state = usePersistentState<ReadonlyArray<T>>(key, [], { broker });\n\n  const recents = computed<ReadonlyArray<T>>(() => state.value.value);\n\n  const push = (item: T): void => {\n    state.setValue((previous) => prependRecent(previous, item, identify, toValue(max)));\n  };\n\n  const clear = (): void => state.setValue([]);\n\n  return { recents, push, clear };\n}\n"],"names":[],"mappings":"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"}

package/dist/chunks/useReducedMotion-B9LqQ3UT.js

@@ -1,8 +0,0 @@
-import { u as useMediaQuery } from "./useMediaQuery-DwVcSgGk.js";
-function useReducedMotion() {
-  return useMediaQuery("(prefers-reduced-motion: reduce)");
-}
-export {
-  useReducedMotion as u
-};
-//# sourceMappingURL=useReducedMotion-B9LqQ3UT.js.map

package/dist/chunks/useReducedMotion-B9LqQ3UT.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useReducedMotion-B9LqQ3UT.js","sources":["../../src/foundation/hooks/useReducedMotion/useReducedMotion.ts"],"sourcesContent":["import type { ShallowRef } from 'vue';\n\nimport { useMediaQuery } from '../useMediaQuery';\n\n/**\n * Returns a ref that is `true` when the user has requested reduced motion via\n * OS settings. Components should short-circuit looping/transitional animations\n * to a static final state when it is `true`.\n */\nexport function useReducedMotion(): Readonly<ShallowRef<boolean>> {\n  return useMediaQuery('(prefers-reduced-motion: reduce)');\n}\n"],"names":[],"mappings":";AASO,SAAS,mBAAkD;AAChE,SAAO,cAAc,kCAAkC;AACzD;"}

package/dist/chunks/useResizeObserver-BUU7lC-n.js

@@ -1,17 +0,0 @@
-import { watchPostEffect, toValue } from "vue";
-function useResizeObserver(target, callback, enabled = true) {
-  watchPostEffect((onCleanup) => {
-    const element = toValue(target);
-    if (!toValue(enabled) || !element || typeof ResizeObserver === "undefined") return;
-    const observer = new ResizeObserver((entries) => {
-      const entry = entries[0];
-      if (entry) callback(entry);
-    });
-    observer.observe(element);
-    onCleanup(() => observer.disconnect());
-  });
-}
-export {
-  useResizeObserver as u
-};
-//# sourceMappingURL=useResizeObserver-BUU7lC-n.js.map

package/dist/chunks/useResizeObserver-BUU7lC-n.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useResizeObserver-BUU7lC-n.js","sources":["../../src/foundation/hooks/useResizeObserver/useResizeObserver.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\n/**\n * Run `callback` whenever the referenced element's size changes. The effect is\n * post-flush, so the element is in the DOM (and laid out) before the observer\n * attaches. Disconnects automatically when the element changes, `enabled`\n * flips, or the scope is disposed.\n *\n * Takes the element as a ref or getter rather than handing one back, so the\n * caller keeps ownership of its `useTemplateRef`.\n */\nexport function useResizeObserver<T extends HTMLElement = HTMLElement>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  callback: (entry: ResizeObserverEntry) => void,\n  enabled: MaybeRefOrGetter<boolean> = true,\n): void {\n  watchPostEffect((onCleanup) => {\n    const element = toValue(target);\n    if (!toValue(enabled) || !element || typeof ResizeObserver === 'undefined') return;\n    const observer = new ResizeObserver((entries) => {\n      const entry = entries[0];\n      if (entry) callback(entry);\n    });\n    observer.observe(element);\n    onCleanup(() => observer.disconnect());\n  });\n}\n"],"names":[],"mappings":";AAWO,SAAS,kBACd,QACA,UACA,UAAqC,MAC/B;AACN,kBAAgB,CAAC,cAAc;AAC7B,UAAM,UAAU,QAAQ,MAAM;AAC9B,QAAI,CAAC,QAAQ,OAAO,KAAK,CAAC,WAAW,OAAO,mBAAmB,YAAa;AAC5E,UAAM,WAAW,IAAI,eAAe,CAAC,YAAY;AAC/C,YAAM,QAAQ,QAAQ,CAAC;AACvB,UAAI,gBAAgB,KAAK;AAAA,IAC3B,CAAC;AACD,aAAS,QAAQ,OAAO;AACxB,cAAU,MAAM,SAAS,YAAY;AAAA,EACvC,CAAC;AACH;"}

package/dist/chunks/useScrollLock-d6YIGUcs.js

@@ -1,37 +0,0 @@
-import { watchPostEffect, toValue } from "vue";
-let lockCount = 0;
-let originalOverflow = null;
-let originalPaddingRight = null;
-function getScrollbarWidth() {
-  return window.innerWidth - document.documentElement.clientWidth;
-}
-function useScrollLock(enabled = true) {
-  watchPostEffect((onCleanup) => {
-    if (!toValue(enabled) || typeof document === "undefined") return;
-    if (lockCount === 0) {
-      const body = document.body;
-      const scrollbarWidth = getScrollbarWidth();
-      originalOverflow = body.style.overflow;
-      originalPaddingRight = body.style.paddingRight;
-      body.style.overflow = "hidden";
-      if (scrollbarWidth > 0) {
-        body.style.paddingRight = `${scrollbarWidth}px`;
-      }
-    }
-    lockCount += 1;
-    onCleanup(() => {
-      lockCount -= 1;
-      if (lockCount === 0) {
-        const body = document.body;
-        body.style.overflow = originalOverflow ?? "";
-        body.style.paddingRight = originalPaddingRight ?? "";
-        originalOverflow = null;
-        originalPaddingRight = null;
-      }
-    });
-  });
-}
-export {
-  useScrollLock as u
-};
-//# sourceMappingURL=useScrollLock-d6YIGUcs.js.map

package/dist/chunks/useScrollLock-d6YIGUcs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useScrollLock-d6YIGUcs.js","sources":["../../src/foundation/hooks/useScrollLock/useScrollLock.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nlet lockCount = 0;\nlet originalOverflow: string | null = null;\nlet originalPaddingRight: string | null = null;\n\nfunction getScrollbarWidth(): number {\n  return window.innerWidth - document.documentElement.clientWidth;\n}\n\n/**\n * Prevent body scroll while at least one consumer has the lock active.\n * Internally counted — multiple overlays may lock; only the last unlock restores.\n * Compensates for scrollbar width to avoid layout shift.\n *\n * `enabled` may be a ref or a getter (`() => props.isEnabled`), so the lock\n * follows a prop without the consumer re-invoking anything. The counter is\n * module-level and shared, exactly as in the original.\n */\nexport function useScrollLock(enabled: MaybeRefOrGetter<boolean> = true): void {\n  watchPostEffect((onCleanup) => {\n    if (!toValue(enabled) || typeof document === 'undefined') return;\n    if (lockCount === 0) {\n      const body = document.body;\n      const scrollbarWidth = getScrollbarWidth();\n      originalOverflow = body.style.overflow;\n      originalPaddingRight = body.style.paddingRight;\n      body.style.overflow = 'hidden';\n      if (scrollbarWidth > 0) {\n        body.style.paddingRight = `${scrollbarWidth}px`;\n      }\n    }\n    lockCount += 1;\n\n    onCleanup(() => {\n      lockCount -= 1;\n      if (lockCount === 0) {\n        const body = document.body;\n        body.style.overflow = originalOverflow ?? '';\n        body.style.paddingRight = originalPaddingRight ?? '';\n        originalOverflow = null;\n        originalPaddingRight = null;\n      }\n    });\n  });\n}\n"],"names":[],"mappings":";AAEA,IAAI,YAAY;AAChB,IAAI,mBAAkC;AACtC,IAAI,uBAAsC;AAE1C,SAAS,oBAA4B;AACnC,SAAO,OAAO,aAAa,SAAS,gBAAgB;AACtD;AAWO,SAAS,cAAc,UAAqC,MAAY;AAC7E,kBAAgB,CAAC,cAAc;AAC7B,QAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,aAAa,YAAa;AAC1D,QAAI,cAAc,GAAG;AACnB,YAAM,OAAO,SAAS;AACtB,YAAM,iBAAiB,kBAAA;AACvB,yBAAmB,KAAK,MAAM;AAC9B,6BAAuB,KAAK,MAAM;AAClC,WAAK,MAAM,WAAW;AACtB,UAAI,iBAAiB,GAAG;AACtB,aAAK,MAAM,eAAe,GAAG,cAAc;AAAA,MAC7C;AAAA,IACF;AACA,iBAAa;AAEb,cAAU,MAAM;AACd,mBAAa;AACb,UAAI,cAAc,GAAG;AACnB,cAAM,OAAO,SAAS;AACtB,aAAK,MAAM,WAAW,oBAAoB;AAC1C,aAAK,MAAM,eAAe,wBAAwB;AAClD,2BAAmB;AACnB,+BAAuB;AAAA,MACzB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;"}

package/dist/flags/FlagsContext.d.ts

@@ -1,32 +0,0 @@
-import { ComputedRef, MaybeRefOrGetter } from 'vue';
-import { FlagClient } from './FlagClient';
-import { FlagValue } from './FlagTypes';
-/**
- * The provider half — used by `FlagsProvider`, and by any component that owns a flag client.
- * Subscribes to the client and re-subscribes if the active client is swapped, disposing the previous
- * subscription through the watcher's `onCleanup`.
- *
- * Pass `client` as a getter (`() => props.client ?? ownClient`) so the active client stays tracked.
- */
-export declare function provideFlags(client: MaybeRefOrGetter<FlagClient>): void;
-/**
- * Reads the flag client. Works without a {@link FlagsProvider} — falls back to an empty one, where
- * every flag returns the caller's default.
- *
- * Returns the plain `FlagClient` rather than a ref, matching the React original: the client is
- * created once and never re-created, so there is nothing to track. Use it for imperative reads and
- * for `setContext`; for a value that must re-evaluate when the evaluation context moves, use
- * {@link useFlag}, whose computed is the reactive path.
- */
-export declare function useFlags(): FlagClient;
-/**
- * Reads one flag's value, re-evaluating whenever the evaluation context changes. The typed path is
- * picked from `defaultValue`, which also types the result — `useFlag('newNav', false)` is
- * `ComputedRef<boolean>`, `useFlag('limits', { max: 10 })` is a computed of that object type.
- *
- * Diverges from the React original, which returned a bare `TValue` re-read on every render: this
- * returns a `ComputedRef<TValue>`, because a bare value could never re-evaluate. `key` and
- * `defaultValue` may each be a ref or getter — changing either re-evaluates the flag, which the
- * React signature could not express at all.
- */
-export declare function useFlag<TValue extends FlagValue>(key: MaybeRefOrGetter<string>, defaultValue: MaybeRefOrGetter<TValue>): ComputedRef<TValue>;

package/dist/flags/FlagsProvider.vue.d.ts

@@ -1,24 +0,0 @@
-import { FlagClient, FlagErrorListener } from './FlagClient';
-import { FlagProvider } from './FlagProvider';
-import { EvaluationContext } from './FlagTypes';
-import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
-/** Defines the props for {@link FlagsProvider}. */
-export interface FlagsProviderProps {
-    /** An existing client to serve — the app-wide instance shared with non-Vue callers. Takes precedence over `provider` / `onError`. */
-    client?: FlagClient;
-    /** The flag source to build a client around, when no `client` is passed. Read once, at setup. */
-    provider?: FlagProvider;
-    /** The evaluation context. Kept in sync on every change — a fresh object literal per render is safe. */
-    context?: EvaluationContext;
-    /** Receives evaluation faults, when no `client` is passed. Read once, at setup. */
-    onError?: FlagErrorListener;
-}
-declare const _default: __VLS_WithSlots< DefineComponent<FlagsProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<FlagsProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
-    default?: (props: {}) => any;
-}>;
-export default _default;
-type __VLS_WithSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};

package/dist/forms-engine/AppForm.d.ts

@@ -1,258 +0,0 @@
-import { MaybeRefOrGetter, PublicProps, Ref, VNode } from 'vue';
-import { ApiError } from '../foundation/http';
-import { ValidationMessageCatalogue } from '../foundation/validation';
-import { StandardSchemaV1 } from './StandardSchema';
-import { SubmitErrorMap } from './SubmitErrors';
-/** Defines the options every engine adapter accepts. */
-export interface AppFormOptions<TValues extends object> {
-    /** The initial values. Async prefill (edit screens) stays on `/query` — render the form once loaded, or `reset(data)`. */
-    readonly defaultValues: TValues;
-    /** The whole-form validator — any Standard Schema (zod / valibot / arktype). Sync or async. */
-    readonly schema?: StandardSchemaV1<TValues>;
-    /** When client validation runs. `'submit'` (default) re-validates touched fields on change after the first attempt. */
-    readonly validateOn?: 'change' | 'blur' | 'submit';
-    /**
-     * Validate once on mount — seeds `isValid` / field errors before any interaction (edit-screen
-     * validity indicators, wizard step-entry gating). Fields stay untouched (`isTouched` false), so
-     * the initial pass populates state without asserting the user has interacted. Default `false`.
-     */
-    readonly validateOnMount?: boolean;
-    /**
-     * How a failed client validation gates the submit. `false` (default) blocks `onSubmit` on errors
-     * (the client is the gate); `true` validates (errors still populate + render, advisory) but runs
-     * `onSubmit` regardless — the **backend is the source of truth**. Belongs here, on the
-     * validation-config surface, because it is a validation→submit *gate policy*, not a submit callback.
-     * The verdict (`handleSubmit` / `isSubmitSuccessful`) then reflects `onSubmit`'s outcome, not the
-     * bypassed client gate.
-     */
-    readonly submitInvalid?: boolean;
-    /** Performs the submit with valid values — usually a `useAppMutation` / `useOptimisticMutation` `mutateAsync`. */
-    readonly onSubmit: (values: TValues) => Promise<unknown>;
-    /**
-     * What triggers a submit. `'manual'` (default) = only `handleSubmit` / the `<form @submit>` path.
-     * `'change'` = any field change schedules a submit (settings / live-save); `'blur'` = submit when a
-     * field blurs (save-on-blur). Auto-submits route through the SAME internal submit path as
-     * `handleSubmit`, so validation, the `submitInvalid` gate, server-error mapping, the verdict, and
-     * the concurrent-submit guard all apply identically. `reset()` / `reset(data)` / prefill never
-     * auto-submit — only user-origin writes do. Named `'manual'` (not `'submit'`) so it never reads as
-     * a `validateOn` value.
-     */
-    readonly submitOn?: 'change' | 'blur' | 'manual';
-    /** Debounce (ms, trailing) for `submitOn: 'change'` — coalesces a change burst into one submit. Default `0`. Ignored for `'blur'` / `'manual'`. */
-    readonly submitDebounceMs?: number;
-    /**
-     * Disables the whole form — ORs into every `form.Field`'s control-disabled flag (on top of any
-     * per-field `isDisabled`) and makes `handleSubmit` / auto-submit inert. For read-only / role-locked
-     * screens or a while-related-data-loads freeze. Read on every access from the latest options
-     * ({@link AppFormOptionsSource}). Default `false`.
-     */
-    readonly isDisabled?: boolean;
-    /**
-     * Maps a thrown submit error to `path → failures`. Default: `fieldIssues` (ProblemDetails, both .NET
-     * shapes), which keeps each failure's rule code for `messages`. A mapper returning plain strings is
-     * still valid — those render as-is.
-     */
-    readonly mapSubmitError?: (error: unknown) => SubmitErrorMap;
-    /** Rewrites a server error path onto a form path. Default: camelCase per segment (`Rules[0].Destination` → `rules[0].destination`). */
-    readonly mapFieldPath?: (serverPath: string) => string;
-    /**
-     * The message used when a submit failure is neither an `ApiError`, an `Error`, nor a
-     * string (e.g. a thrown plain object) — the last SDK-authored English literal on the
-     * submit path. Override for i18n. Default: `'Unknown error'`.
-     */
-    readonly fallbackErrorMessage?: string;
-    /**
-     * Overrides the wording of individual rule codes, merged over `defaultValidationMessages`.
-     *
-     * The point is ONE voice per rule: a failure the client caught and the same failure the server caught
-     * render from the same entry, instead of "Name is required" from one side and "'Name' must not be
-     * empty." from the other. Server codes are normalized onto the shared vocabulary on read
-     * (`foundation/http` `fieldIssues`), so both sides reach the same key.
-     *
-     * Applies to server failures always, and to client failures when the schema is a
-     * `foundation/validation` validator — a third-party spec schema's codes are erased by the spec, so its
-     * messages render as the schema authored them. An unknown code falls back to the source's own message,
-     * which is why wiring this can never render a form worse than not wiring it.
-     *
-     * i18n: swap the whole table per locale off `foundation/i18n`'s `LocaleContext`.
-     */
-    readonly messages?: ValidationMessageCatalogue;
-    /**
-     * Display labels per field path, prefixed to a catalogue-rendered message (`rules[].destination` also
-     * matches every row). Omitted, messages render as bare fragments — correct under a labelled control,
-     * which is why this is opt-in rather than required.
-     */
-    readonly labels?: Readonly<Record<string, string>>;
-}
-/**
- * How `useAppForm` receives its options. React re-read `options` on every render (latest-ref);
- * Vue's `setup()` runs once, so the reactive source has to be named: pass a getter (or a ref, or a
- * `reactive()` object) when an option must stay live — a swapped `schema`, a role-driven
- * `isDisabled`, a `messages` table that follows the locale. A plain object literal is read once,
- * which is the right default for `defaultValues` + a closure `onSubmit`.
- */
-export type AppFormOptionsSource<TValues extends object> = MaybeRefOrGetter<AppFormOptions<TValues>>;
-/** The per-field API a `<form.Field>` slot receives. Every member is a LIVE getter — destructuring takes a snapshot, bind to the object. */
-export interface AppFieldApi<TValue> {
-    /**
-     * The field's value. Writable — assigning runs the same path as {@link setValue}, so a control
-     * binds with `v-model="field.value"` and needs no `@update` handler. (React exposed a read-only
-     * `value` plus `setValue`; both spellings are kept, per the port's keep-React's-name rule.)
-     */
-    value: TValue;
-    readonly setValue: (value: TValue) => void;
-    /** Marks the field touched — the Field glue also wires it onto the control's blur. */
-    readonly onBlur: () => void;
-    /** Client + server messages merged (client first); server messages clear on the next change to the field. */
-    readonly errors: readonly string[];
-    readonly isDirty: boolean;
-    readonly isTouched: boolean;
-}
-/**
- * The reactive form state. Read a member and you are subscribed — `form.state.isSubmitting` in a
- * template re-renders that template alone when it flips. Every member is a LIVE getter, so
- * destructuring takes a snapshot; bind to the object (`form.state`), or reach for
- * {@link AppForm.useFormState} when a `Ref` is what's wanted.
- */
-export interface AppFormState<TValues> {
-    readonly values: TValues;
-    readonly isDirty: boolean;
-    readonly isValid: boolean;
-    readonly isSubmitting: boolean;
-    readonly isValidating: boolean;
-    /** The submit failure whose mapped paths matched no field — feed the form-level `Alert`. */
-    readonly submitError: ApiError | null;
-    /**
-     * The last completed submit's verdict as a reactive slice — `true` when validation passed
-     * AND `onSubmit` resolved, `false` when validation failed or `onSubmit` threw, `null` before
-     * the first completed attempt and after `reset()`. Mirrors `handleSubmit`'s resolved value,
-     * so the imperative return and this slice never disagree (success banners read here).
-     */
-    readonly isSubmitSuccessful: boolean | null;
-}
-/**
- * Resolves the field value type for a path: top-level keys infer `TValues[name]`;
- * deeper dot/index paths stay `unknown` — loose string paths are the documented
- * contract (typed values, untyped paths), deep typed paths are the tanstack
- * adapter's escape-hatch territory.
- */
-export type AppFieldValue<TValues, TPath extends string> = TPath extends keyof TValues ? TValues[TPath] : unknown;
-/**
- * The path a field binds — a key of `TValues`, or any other string (`rules[0].destination`).
- *
- * The `(string & {})` half is load-bearing, not decoration. Constrain the type parameter to a
- * plain `string` and `vue-tsc` widens the literal in `name="title"` to `string` when it resolves
- * the tag, so {@link AppFieldValue} falls through to `unknown` and EVERY slot payload silently
- * loses its type — a plain `.ts` call site infers it correctly, which is what makes the
- * regression invisible without a template test. A constraint that contains literal types
- * suppresses that widening. It also earns the editor's completion list for the known keys.
- */
-export type AppFieldPath<TValues> = (keyof TValues & string) | (string & {});
-/** The props `<form.Field>` accepts — the per-mode control flags (R12); the control renders in its default slot. */
-export interface AppFieldProps<TPath extends string = string> {
-    /** The field path — a top-level key or a dot/index path (`rules[0].destination`). */
-    readonly name: TPath;
-    /** The per-mode disabled flag, exposed to the control via `FormControlContext`. */
-    readonly isDisabled?: boolean;
-    /** The per-mode required flag, exposed to the control via `FormControlContext`. */
-    readonly isRequired?: boolean;
-    /** The per-mode read-only flag, exposed to the control via `FormControlContext`. */
-    readonly isReadOnly?: boolean;
-}
-/**
- * Field wrapper — always provides `FormControlContext` (id / labelId / errorId / isInvalid /
- * `errors` / isDisabled / isRequired) so the control + chrome auto-wire aria. Label / helper
- * chrome stays with the presentation `Field` composed inside the slot — it ADOPTS this
- * provider (same ids, inherited flags) and renders the context `errors` without
- * `:error="f.errors[0]"` hand-wiring.
- *
- * ```vue
- * <form.Field name="url" v-slot="f">
- *   <Field label="Destination">
- *     <UrlInput v-model="f.value" @blur="f.onBlur" />
- *   </Field>
- * </form.Field>
- * ```
- *
- * Typed as a constructor so `TPath` is inferred per usage and the slot payload narrows with it —
- * the same shape `@tanstack/vue-form` types its own `Field` with, and what `vue-tsc` reads a
- * component's props/slots off.
- */
-export interface AppFieldComponent<TValues extends object> {
-    new <TPath extends AppFieldPath<TValues>>(props: AppFieldProps<TPath>): {
-        $props: AppFieldProps<TPath> & PublicProps;
-        $slots: {
-            default?: (field: AppFieldApi<AppFieldValue<TValues, TPath>>) => VNode[];
-        };
-    };
-}
-/** Array helpers at a path — `push` / `insert` / `remove` / `swap` / `move` (R8). Indices are assumed in range. */
-export interface AppArrayApi {
-    readonly push: (value: unknown) => void;
-    readonly insert: (index: number, value: unknown) => void;
-    readonly remove: (index: number) => void;
-    readonly swap: (indexA: number, indexB: number) => void;
-    readonly move: (fromIndex: number, toIndex: number) => void;
-}
-/** What `useAppForm` returns — identical across engines; `TEngine` types the escape hatch. */
-export interface AppForm<TValues extends object, TEngine = unknown> {
-    /** Field wrapper — always provides `FormControlContext` (id / labelId / errorId / isInvalid / `errors` /
-     *  isDisabled / isRequired); the presentation `Field` composed inside the slot adopts it, so
-     *  label/helper/error chrome renders from one provider with zero hand-wiring. */
-    readonly Field: AppFieldComponent<TValues>;
-    /**
-     * The reactive form state — the read path. `form.state.isSubmitting` inside a template or a
-     * `computed` subscribes to that member alone; no selector, no render prop, no nesting to read
-     * four fields. Live getters: bind to `form.state`, never destructure it.
-     */
-    readonly state: AppFormState<TValues>;
-    /** The current values — the shorthand for `form.state.values`, and the same subscription (`form.values.style`). */
-    readonly values: TValues;
-    /**
-     * A state slice as a `Ref` — for a `watch` source, and for the one case reactivity alone cannot
-     * express: a COMPOSITE selection with a custom `isEqual`. `computed` always compares with
-     * `Object.is`, so `() => ({ a, b })` invalidates every downstream effect on any store commit;
-     * pass `isEqual` (a shallow-equal) and the previous slice is kept, so nothing downstream re-runs.
-     * Plain single-member reads want `form.state` instead — this is the `Subscribe` replacement, not
-     * the everyday read path.
-     */
-    readonly useFormState: <TSlice>(selector: (state: AppFormState<TValues>) => TSlice, isEqual?: (a: TSlice, b: TSlice) => boolean) => Readonly<Ref<TSlice>>;
-    /**
-     * Validates, runs `onSubmit`, applies mapped server errors to fields, leaves the remainder
-     * in `submitError`. Resolves the verdict — `true` iff validation passed AND `onSubmit`
-     * resolved; `false` on validation failure or an `onSubmit` throw. Never rejects, so a
-     * `<form @submit="form.handleSubmit">` handler ignores the return while an imperative caller
-     * (a wizard-step gate) branches on it. The reactive mirror is `state.isSubmitSuccessful`.
-     */
-    readonly handleSubmit: (event?: Event) => Promise<boolean>;
-    /**
-     * Validates the current values WITHOUT submitting — runs the whole-form schema, populates
-     * `field.errors`, and marks fields touched so the errors display (the "validate now" gate), then
-     * resolves the client validity. `onSubmit` never runs. The clean single-form multi-step gate
-     * (`const ok = await form.validate()` before advancing a wizard step) and the imperative
-     * "is it valid now" check. Never rejects. Mirrors RHF `trigger` / TanStack `validateAllFields`.
-     */
-    readonly validate: () => Promise<boolean>;
-    /**
-     * Writes a value at a path outside a `<form.Field>` slot — cross-field / derived
-     * writes (name → slug) and sibling-group writes. Top-level keys are typed to their value;
-     * deeper dot/index paths accept `unknown` (the typed-values / untyped-paths contract rule,
-     * mirroring {@link AppFieldValue}). Clears that field's server error like an in-field edit
-     * and runs change-time validation under the active `validateOn`.
-     */
-    readonly setValue: <TPath extends AppFieldPath<TValues>>(path: TPath, value: AppFieldValue<TValues, TPath>) => void;
-    /** Array helpers at a path — `push` / `insert` / `remove` / `swap` / `move` (R8). */
-    readonly array: (path: string) => AppArrayApi;
-    /** Resets to `defaultValues`, or re-seeds with `next` (edit-mode prefill — kills smart-qr's 13-setter effect). */
-    readonly reset: (next?: TValues) => void;
-    /** Applies server field errors outside the submit pipeline (e.g. a deferred backend check). Replaces the current server-error overlay. */
-    readonly setFieldErrors: (errors: Record<string, string[]>) => void;
-    /** Clears the form-level `submitError` (a dismissible error banner's reset) — leaves field errors untouched. */
-    readonly clearSubmitError: () => void;
-    /** ESCAPE HATCH — the native engine form instance. See the 90/10 rule in docs/analysis/forms-engine.md §4. */
-    readonly engine: TEngine;
-}
-/** The module contract every adapter satisfies — enforced by the conformance suite, swapped by import path. */
-export interface FormEngine {
-    useAppForm<TValues extends object>(options: AppFormOptionsSource<TValues>): AppForm<TValues>;
-}

package/dist/forms-engine/DeepEqual.d.ts

@@ -1,8 +0,0 @@
-/**
- * Structural equality over form-value shapes — primitives, plain objects, arrays,
- * `Date`, and `File` / `Blob` (upload fields). Powers dirty tracking (values vs the
- * reset baseline), so it only needs to cover what form values hold; exotic types fall
- * back to `Object.is`. (`foundation/utils` `Equality` is shallow-only, hence the local
- * deep variant.)
- */
-export declare function deepEqual(a: unknown, b: unknown): boolean;

package/dist/forms-engine/FocusFirstInvalid.d.ts

@@ -1,15 +0,0 @@
-/**
- * Focuses the first invalid, focusable control inside `root` and returns it (`null` when
- * nothing qualifies — the form is valid, or every invalid control is disabled/hidden).
- *
- * Call it after `handleSubmit` settles; capture the form element BEFORE awaiting — the DOM
- * nulls `event.currentTarget` once dispatch ends, so reading it after an `await` yields `null`:
- *
- * ```vue
- * <form @submit="(event) => {
- *   const root = event.currentTarget as ParentNode;
- *   void form.handleSubmit(event).then(() => focusFirstInvalid(root));
- * }">
- * ```
- */
-export declare function focusFirstInvalid(root: ParentNode | null | undefined): HTMLElement | null;