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

package/dist/foundation/storage/hooks/UsePersistentState.d.ts

@@ -0,0 +1,31 @@
+import { MaybeRefOrGetter, WritableComputedRef } from 'vue';
+import { StorageBroker } from '../StorageBroker';
+/** Defines the options that tune where and how `usePersistentState` persists. */
+export interface PersistentStateOptions {
+    /** The persistence seam to read and write through; defaults to `localStorageStorageBroker`. */
+    readonly broker?: StorageBroker;
+}
+/** A setter that accepts a next value or an updater fn, mirroring the original's `useState` dispatch. */
+export type SetPersistentState<T> = (next: T | ((previous: T) => T)) => void;
+/** The persistent-state handle — a writable value plus the updater-accepting setter it delegates to. */
+export interface PersistentState<T> {
+    /**
+     * The live value. Writable: `value.value = next` runs the same write-through path as `setValue(next)`.
+     * A writable computed rather than a plain ref, so persistence is driven by the assignment itself —
+     * mutating a nested field in place does not persist, exactly as the original required a setter call.
+     */
+    readonly value: WritableComputedRef<T>;
+    /** Sets the next value — or derives it from the previous one — and writes it through the broker. */
+    readonly setValue: SetPersistentState<T>;
+}
+/**
+ * Manages a piece of state mirrored into a `StorageBroker` under `key`. Hydrates from the broker on
+ * mount (SSR-safe: the first render always uses `initial`, then a mount hook adopts any persisted value, so
+ * server and client markup match), writes through on every set, and — when backed by `localStorage` —
+ * adopts writes from other tabs via the window `storage` event.
+ *
+ * Returns `{ value, setValue }` rather than a tuple: `value` is writable (`state.value = next`), and
+ * `setValue` is kept because it additionally accepts an updater fn. `key` may be a ref or getter — changing
+ * it re-hydrates from the new slot.
+ */
+export declare function usePersistentState<T>(key: MaybeRefOrGetter<string>, initial: T, options?: PersistentStateOptions): PersistentState<T>;

package/dist/foundation/storage/hooks/UseRecentItems.d.ts

@@ -0,0 +1,34 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+import { StorageBroker } from '../StorageBroker';
+/** Defines the options that configure a recent-items list — identity, cap, and the persistence seam. */
+export interface RecentItemsOptions<T> {
+    /** Derives a stable de-duplication key for an item; re-pushing a matching item moves it to the front. */
+    readonly identify: (item: T) => string;
+    /** The maximum number of items retained, most-recent-first; defaults to 24. */
+    readonly max?: MaybeRefOrGetter<number>;
+    /** The persistence seam the list stores through. Defaults to `localStorageStorageBroker` via `usePersistentState`. */
+    readonly broker?: StorageBroker;
+}
+/** Represents a most-recently-used list plus the operations that mutate it. */
+export interface RecentItems<T> {
+    /** The retained items, most-recent-first. */
+    readonly recents: ComputedRef<ReadonlyArray<T>>;
+    /** Records `item` as the most recent — de-duplicated by identity and capped at `max`. */
+    readonly push: (item: T) => void;
+    /** Empties the list. */
+    readonly clear: () => void;
+}
+/**
+ * Prepends `item` to `items` as the most recent, de-duplicating by `identify` (an existing match is removed so
+ * the item resurfaces at the front) and capping the result to `max`. Pure — the reducer the composable writes
+ * through its adapter.
+ */
+export declare function prependRecent<T>(items: ReadonlyArray<T>, item: T, identify: (item: T) => string, max: number): ReadonlyArray<T>;
+/**
+ * Manages a persisted most-recently-used list under `key`, layered on `usePersistentState`. `push` records an
+ * item at the front, de-duplicated by `identify` and capped at `max` (default 24); `clear` empties it. The list
+ * inherits the underlying composable's hydrate-on-mount, write-through, and cross-tab sync.
+ *
+ * `recents` is a read-only computed — mutate the list through `push` / `clear`, never in place.
+ */
+export declare function useRecentItems<T>(key: MaybeRefOrGetter<string>, options: RecentItemsOptions<T>): RecentItems<T>;

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

@@ -1,3 +1,6 @@
-export { type StorageBroker, localStorageStorageBroker, memoryStorageBroker, } from './StorageBroker';
+export { type StorageBroker, localStorageStorageBroker, memoryStorageBroker } from './StorageBroker';
 export { namespacedBroker } from './NamespacedBroker';
 export { type Migration, type MigrationMap, type VersionedStore, type VersionedStoreOptions, createVersionedStore, } from './VersionedStore';
+export * from './hooks/UseAutosave';
+export * from './hooks/UsePersistentState';
+export * from './hooks/UseRecentItems';

package/dist/foundation/storage/index.js

@@ -1,8 +1,10 @@
 import { l as localStorageStorageBroker } from "../../chunks/StorageBroker-COC81ZGB.js";
 import { m } from "../../chunks/StorageBroker-COC81ZGB.js";
-const NAMESPACE_SEPARATOR = ":";
+import { shallowRef, watch, toValue, onScopeDispose } from "vue";
+import { p, u, a } from "../../chunks/UseRecentItems-Bgj28t5Y.js";
+const NamespaceSeparator = ":";
 function namespacedBroker(inner, namespace) {
-  const scope = (key) => `${namespace}${NAMESPACE_SEPARATOR}${key}`;
+  const scope = (key) => `${namespace}${NamespaceSeparator}${key}`;
   return {
     read(key) {
       return inner.read(scope(key));
@@ -56,10 +58,123 @@ function createVersionedStore(options) {
     }
   };
 }
+function useAutosave(value, save, options = {}) {
+  const { delayMs = 800, enabled = true, onError } = options;
+  const status = shallowRef("idle");
+  const error = shallowRef(null);
+  const lastSavedAt = shallowRef(null);
+  let timer = null;
+  let isDisposed = false;
+  let isRunning = false;
+  let pending = false;
+  let ready = false;
+  let revision = 0;
+  const isEnabled = () => toValue(enabled);
+  function clearTimer() {
+    if (timer === null) return;
+    clearTimeout(timer);
+    timer = null;
+  }
+  function reportError(failure) {
+    if (!onError) return;
+    const reportObserverFailure = (observerError) => {
+      console.error("Autosave onError callback failed", observerError);
+    };
+    try {
+      void Promise.resolve(onError(failure)).catch(reportObserverFailure);
+    } catch (observerError) {
+      reportObserverFailure(observerError);
+    }
+  }
+  async function execute(currentRevision) {
+    let failed = false;
+    let failure;
+    try {
+      const outcome = await save(toValue(value));
+      if (outcome && !outcome.ok) {
+        failed = true;
+        failure = outcome.failure;
+      }
+    } catch (caught) {
+      failed = true;
+      failure = caught;
+    }
+    isRunning = false;
+    if (!isDisposed && isEnabled() && currentRevision === revision) {
+      status.value = failed ? "error" : "saved";
+      error.value = failed ? failure : null;
+      if (failed) reportError(failure);
+      else lastSavedAt.value = Date.now();
+    }
+    drain();
+  }
+  function drain() {
+    if (isDisposed || !isEnabled() || isRunning || !pending || !ready) return;
+    clearTimer();
+    pending = false;
+    ready = false;
+    isRunning = true;
+    status.value = "saving";
+    void execute(revision);
+  }
+  function flush() {
+    if (isDisposed || !isEnabled() || !pending) return;
+    clearTimer();
+    ready = true;
+    drain();
+  }
+  function cancel() {
+    clearTimer();
+    pending = false;
+    ready = false;
+    revision += 1;
+    if (isDisposed) return;
+    status.value = "idle";
+    error.value = null;
+  }
+  watch(
+    [() => toValue(value), isEnabled],
+    () => {
+      if (isDisposed) return;
+      if (!isEnabled()) {
+        cancel();
+        return;
+      }
+      revision += 1;
+      clearTimer();
+      pending = true;
+      ready = false;
+      status.value = "pending";
+      error.value = null;
+      const delay = toValue(delayMs);
+      timer = setTimeout(
+        () => {
+          timer = null;
+          ready = true;
+          drain();
+        },
+        Number.isFinite(delay) ? Math.max(0, delay) : 800
+      );
+    },
+    // Invalidate a completion immediately on edit; a queued watcher could otherwise report obsolete success.
+    { deep: true, flush: "sync" }
+  );
+  onScopeDispose(() => {
+    isDisposed = true;
+    cancel();
+    status.value = "idle";
+    error.value = null;
+  });
+  return { status, error, lastSavedAt, flush, cancel };
+}
 export {
   createVersionedStore,
   localStorageStorageBroker,
   m as memoryStorageBroker,
-  namespacedBroker
+  namespacedBroker,
+  p as prependRecent,
+  useAutosave,
+  u as usePersistentState,
+  a as useRecentItems
 };
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/storage/NamespacedBroker.ts","../../../src/foundation/storage/VersionedStore.ts"],"sourcesContent":["// A `StorageBroker` decorator that prefixes every key with a namespace. Wrapping a shared broker (one\n// `localStorage`) in a namespace keeps unrelated features — or two tenants in the same app — from colliding on\n// a bare key like `\"draft\"`, without any hook change: the persistence hooks still see a plain `StorageBroker`.\n// Composes with any broker (production, memory, or another namespace) since it only rewrites keys.\n\nimport type { StorageBroker } from './StorageBroker';\n\n/** The separator between a namespace and the caller's key. */\nconst NAMESPACE_SEPARATOR = ':';\n\n/**\n * Wraps `inner` so every key is transparently prefixed with `namespace` (joined by `:`). Reads, writes, and\n * removes all address the namespaced key, so two brokers with distinct namespaces over the same backing store\n * never observe each other's values. Delegates JSON handling and failure-tolerance to `inner` unchanged.\n */\nexport function namespacedBroker(inner: StorageBroker, namespace: string): StorageBroker {\n  const scope = (key: string): string => `${namespace}${NAMESPACE_SEPARATOR}${key}`;\n\n  return {\n    read<T>(key: string): T | null {\n      return inner.read<T>(scope(key));\n    },\n\n    write<T>(key: string, value: T): void {\n      inner.write(scope(key), value);\n    },\n\n    remove(key: string): void {\n      inner.remove(scope(key));\n    },\n  };\n}\n","// A versioned wrapper over a `StorageBroker`. Persisted client state outlives the code that wrote it: a user\n// carries last month's `localStorage` into today's deploy. A `VersionedStore` stamps each value with a schema\n// `version` and, on read, walks a migration chain from the stored version up to the current one — so an old\n// shape is upgraded in place instead of silently mis-parsed. It inherits the broker's failure-tolerance: any\n// unrecoverable state (missing migration, a future version, a broken read) degrades to `initial`, never a throw.\n\nimport { localStorageStorageBroker, type StorageBroker } from './StorageBroker';\n\n/** Upgrades a value from one schema version to the next. Receives the prior shape as `unknown`; returns the next. */\nexport type Migration = (previous: unknown) => unknown;\n\n/** A map from *source* version to the migration that upgrades it to the following version (`n` upgrades `n`→`n+1`). */\nexport type MigrationMap = Readonly<Record<number, Migration>>;\n\n/** Configures a versioned store. */\nexport interface VersionedStoreOptions<T> {\n  /** The storage key the envelope is persisted under. */\n  readonly key: string;\n\n  /** The current schema version (a positive integer). A stored value below this is migrated up on read. */\n  readonly version: number;\n\n  /** The value returned when nothing is stored or the stored value cannot be recovered. */\n  readonly initial: T;\n\n  /** Migrations keyed by source version; `migrations[n]` upgrades a v`n` value to v`n+1`. */\n  readonly migrations?: MigrationMap;\n\n  /** The backing persistence seam; defaults to `localStorageStorageBroker`. */\n  readonly broker?: StorageBroker;\n}\n\n/** A versioned view over a storage key — hydrate-with-migration on read, envelope-stamp on write. */\nexport interface VersionedStore<T> {\n  /** The storage key this store owns. */\n  readonly key: string;\n\n  /** The current schema version. */\n  readonly version: number;\n\n  /** Reads and, if needed, migrates the stored value; returns `initial` on absence or any unrecoverable state. */\n  read(): T;\n\n  /** Writes `value` stamped with the current version. */\n  write(value: T): void;\n\n  /** Removes the stored value. */\n  clear(): void;\n}\n\n/** The persisted shape: the schema version alongside the caller's data. */\ninterface Envelope {\n  readonly v: number;\n  readonly data: unknown;\n}\n\n/** Recognises a value as a version envelope (vs a legacy bare value written before versioning). */\nfunction isEnvelope(value: unknown): value is Envelope {\n  return typeof value === 'object' && value !== null && 'v' in value && 'data' in value && typeof (value as Envelope).v === 'number';\n}\n\n/**\n * Builds a {@link VersionedStore} over `key`. On `read`, a stored value is interpreted as:\n * - **current version** → returned as-is;\n * - **older version** → each `migrations[n]` is applied in turn from the stored version up to `version`, the\n *   upgraded value is written back, and returned. A gap in the chain (a missing `migrations[n]`) yields `initial`;\n * - **newer version** (a rollback to older code) → `initial`, leaving the forward-written value untouched;\n * - **legacy bare value** (no envelope) → treated as version `0` and migrated the same way.\n *\n * Any thrown error inside migration or the broker degrades to `initial`, mirroring the broker's never-throw contract.\n */\nexport function createVersionedStore<T>(options: VersionedStoreOptions<T>): VersionedStore<T> {\n  const { key, version, initial, migrations = {} } = options;\n  const broker = options.broker ?? localStorageStorageBroker;\n\n  /** Runs the migration chain from `fromVersion` to the current `version`; null when a step is missing. */\n  function migrate(fromVersion: number, data: unknown): { data: unknown } | null {\n    let current = data;\n    for (let from = fromVersion; from < version; from++) {\n      const step = migrations[from];\n      if (step === undefined) return null; // chain gap — cannot safely interpret the old shape\n      current = step(current);\n    }\n    return { data: current };\n  }\n\n  return {\n    key,\n    version,\n\n    read(): T {\n      try {\n        const stored = broker.read<unknown>(key);\n        if (stored === null) return initial;\n\n        const { v, data } = isEnvelope(stored) ? stored : { v: 0, data: stored };\n\n        if (v === version) return data as T;\n        if (v > version) return initial; // forward-written by newer code — don't guess\n\n        const migrated = migrate(v, data);\n        if (migrated === null) return initial;\n\n        // Persist the upgrade so the next read is a fast, migration-free hit.\n        broker.write<Envelope>(key, { v: version, data: migrated.data });\n        return migrated.data as T;\n      } catch {\n        return initial;\n      }\n    },\n\n    write(value: T): void {\n      broker.write<Envelope>(key, { v: version, data: value });\n    },\n\n    clear(): void {\n      broker.remove(key);\n    },\n  };\n}\n"],"names":[],"mappings":";;AAQA,MAAM,sBAAsB;AAOrB,SAAS,iBAAiB,OAAsB,WAAkC;AACvF,QAAM,QAAQ,CAAC,QAAwB,GAAG,SAAS,GAAG,mBAAmB,GAAG,GAAG;AAE/E,SAAO;AAAA,IACL,KAAQ,KAAuB;AAC7B,aAAO,MAAM,KAAQ,MAAM,GAAG,CAAC;AAAA,IACjC;AAAA,IAEA,MAAS,KAAa,OAAgB;AACpC,YAAM,MAAM,MAAM,GAAG,GAAG,KAAK;AAAA,IAC/B;AAAA,IAEA,OAAO,KAAmB;AACxB,YAAM,OAAO,MAAM,GAAG,CAAC;AAAA,IACzB;AAAA,EAAA;AAEJ;AC0BA,SAAS,WAAW,OAAmC;AACrD,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,OAAO,SAAS,UAAU,SAAS,OAAQ,MAAmB,MAAM;AAC5H;AAYO,SAAS,qBAAwB,SAAsD;AAC5F,QAAM,EAAE,KAAK,SAAS,SAAS,aAAa,CAAA,MAAO;AACnD,QAAM,SAAS,QAAQ,UAAU;AAGjC,WAAS,QAAQ,aAAqB,MAAyC;AAC7E,QAAI,UAAU;AACd,aAAS,OAAO,aAAa,OAAO,SAAS,QAAQ;AACnD,YAAM,OAAO,WAAW,IAAI;AAC5B,UAAI,SAAS,OAAW,QAAO;AAC/B,gBAAU,KAAK,OAAO;AAAA,IACxB;AACA,WAAO,EAAE,MAAM,QAAA;AAAA,EACjB;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IAEA,OAAU;AACR,UAAI;AACF,cAAM,SAAS,OAAO,KAAc,GAAG;AACvC,YAAI,WAAW,KAAM,QAAO;AAE5B,cAAM,EAAE,GAAG,KAAA,IAAS,WAAW,MAAM,IAAI,SAAS,EAAE,GAAG,GAAG,MAAM,OAAA;AAEhE,YAAI,MAAM,QAAS,QAAO;AAC1B,YAAI,IAAI,QAAS,QAAO;AAExB,cAAM,WAAW,QAAQ,GAAG,IAAI;AAChC,YAAI,aAAa,KAAM,QAAO;AAG9B,eAAO,MAAgB,KAAK,EAAE,GAAG,SAAS,MAAM,SAAS,MAAM;AAC/D,eAAO,SAAS;AAAA,MAClB,QAAQ;AACN,eAAO;AAAA,MACT;AAAA,IACF;AAAA,IAEA,MAAM,OAAgB;AACpB,aAAO,MAAgB,KAAK,EAAE,GAAG,SAAS,MAAM,OAAO;AAAA,IACzD;AAAA,IAEA,QAAc;AACZ,aAAO,OAAO,GAAG;AAAA,IACnB;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/storage/NamespacedBroker.ts","../../../src/foundation/storage/VersionedStore.ts","../../../src/foundation/storage/hooks/UseAutosave.ts"],"sourcesContent":["// A `StorageBroker` decorator that prefixes every key with a namespace. Wrapping a shared broker (one\n// `localStorage`) in a namespace keeps unrelated features — or two tenants in the same app — from colliding on\n// a bare key like `\"draft\"`, without any hook change: the persistence hooks still see a plain `StorageBroker`.\n// Composes with any broker (production, memory, or another namespace) since it only rewrites keys.\n\nimport type { StorageBroker } from './StorageBroker';\n\n/** The separator between a namespace and the caller's key. */\nconst NamespaceSeparator = ':';\n\n/**\n * Wraps `inner` so every key is transparently prefixed with `namespace` (joined by `:`). Reads, writes, and\n * removes all address the namespaced key, so two brokers with distinct namespaces over the same backing store\n * never observe each other's values. Delegates JSON handling and failure-tolerance to `inner` unchanged.\n */\nexport function namespacedBroker(inner: StorageBroker, namespace: string): StorageBroker {\n  const scope = (key: string): string => `${namespace}${NamespaceSeparator}${key}`;\n\n  return {\n    read<T>(key: string): T | null {\n      return inner.read<T>(scope(key));\n    },\n\n    write<T>(key: string, value: T): void {\n      inner.write(scope(key), value);\n    },\n\n    remove(key: string): void {\n      inner.remove(scope(key));\n    },\n  };\n}\n","// A versioned wrapper over a `StorageBroker`. Persisted client state outlives the code that wrote it: a user\n// carries last month's `localStorage` into today's deploy. A `VersionedStore` stamps each value with a schema\n// `version` and, on read, walks a migration chain from the stored version up to the current one — so an old\n// shape is upgraded in place instead of silently mis-parsed. It inherits the broker's failure-tolerance: any\n// unrecoverable state (missing migration, a future version, a broken read) degrades to `initial`, never a throw.\n\nimport { localStorageStorageBroker, type StorageBroker } from './StorageBroker';\n\n/** Upgrades a value from one schema version to the next. Receives the prior shape as `unknown`; returns the next. */\nexport type Migration = (previous: unknown) => unknown;\n\n/** A map from *source* version to the migration that upgrades it to the following version (`n` upgrades `n`→`n+1`). */\nexport type MigrationMap = Readonly<Record<number, Migration>>;\n\n/** Configures a versioned store. */\nexport interface VersionedStoreOptions<T> {\n  /** The storage key the envelope is persisted under. */\n  readonly key: string;\n\n  /** The current schema version (a positive integer). A stored value below this is migrated up on read. */\n  readonly version: number;\n\n  /** The value returned when nothing is stored or the stored value cannot be recovered. */\n  readonly initial: T;\n\n  /** Migrations keyed by source version; `migrations[n]` upgrades a v`n` value to v`n+1`. */\n  readonly migrations?: MigrationMap;\n\n  /** The backing persistence seam; defaults to `localStorageStorageBroker`. */\n  readonly broker?: StorageBroker;\n}\n\n/** A versioned view over a storage key — hydrate-with-migration on read, envelope-stamp on write. */\nexport interface VersionedStore<T> {\n  /** The storage key this store owns. */\n  readonly key: string;\n\n  /** The current schema version. */\n  readonly version: number;\n\n  /** Reads and, if needed, migrates the stored value; returns `initial` on absence or any unrecoverable state. */\n  read(): T;\n\n  /** Writes `value` stamped with the current version. */\n  write(value: T): void;\n\n  /** Removes the stored value. */\n  clear(): void;\n}\n\n/** The persisted shape: the schema version alongside the caller's data. */\ninterface Envelope {\n  readonly v: number;\n  readonly data: unknown;\n}\n\n/** Recognises a value as a version envelope (vs a legacy bare value written before versioning). */\nfunction isEnvelope(value: unknown): value is Envelope {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'v' in value &&\n    'data' in value &&\n    typeof (value as Envelope).v === 'number'\n  );\n}\n\n/**\n * Builds a {@link VersionedStore} over `key`. On `read`, a stored value is interpreted as:\n * - **current version** → returned as-is;\n * - **older version** → each `migrations[n]` is applied in turn from the stored version up to `version`, the\n *   upgraded value is written back, and returned. A gap in the chain (a missing `migrations[n]`) yields `initial`;\n * - **newer version** (a rollback to older code) → `initial`, leaving the forward-written value untouched;\n * - **legacy bare value** (no envelope) → treated as version `0` and migrated the same way.\n *\n * Any thrown error inside migration or the broker degrades to `initial`, mirroring the broker's never-throw contract.\n */\nexport function createVersionedStore<T>(options: VersionedStoreOptions<T>): VersionedStore<T> {\n  const { key, version, initial, migrations = {} } = options;\n  const broker = options.broker ?? localStorageStorageBroker;\n\n  /** Runs the migration chain from `fromVersion` to the current `version`; null when a step is missing. */\n  function migrate(fromVersion: number, data: unknown): { data: unknown } | null {\n    let current = data;\n    for (let from = fromVersion; from < version; from++) {\n      const step = migrations[from];\n      if (step === undefined) return null; // chain gap — cannot safely interpret the old shape\n      current = step(current);\n    }\n    return { data: current };\n  }\n\n  return {\n    key,\n    version,\n\n    read(): T {\n      try {\n        const stored = broker.read<unknown>(key);\n        if (stored === null) return initial;\n\n        const { v, data } = isEnvelope(stored) ? stored : { v: 0, data: stored };\n\n        if (v === version) return data as T;\n        if (v > version) return initial; // forward-written by newer code — don't guess\n\n        const migrated = migrate(v, data);\n        if (migrated === null) return initial;\n\n        // Persist the upgrade so the next read is a fast, migration-free hit.\n        broker.write<Envelope>(key, { v: version, data: migrated.data });\n        return migrated.data as T;\n      } catch {\n        return initial;\n      }\n    },\n\n    write(value: T): void {\n      broker.write<Envelope>(key, { v: version, data: value });\n    },\n\n    clear(): void {\n      broker.remove(key);\n    },\n  };\n}\n","import { onScopeDispose, shallowRef, toValue, watch, type MaybeRefOrGetter, type ShallowRef } from 'vue';\nimport type { AppError, Result } from '../../results';\n\n/** The lifecycle of the latest autosave intent, including a queued trailing write. */\nexport type AutosaveStatus = 'idle' | 'pending' | 'saving' | 'saved' | 'error';\n\n/** Tunes autosave timing, gating and failure reporting. */\nexport interface UseAutosaveOptions {\n  /** The quiet period in milliseconds. Defaults to 800; read when an edit is scheduled. */\n  readonly delayMs?: MaybeRefOrGetter<number>;\n  /** Disabling drops pending work and invalidates completion state; reenabling schedules the current value. */\n  readonly enabled?: MaybeRefOrGetter<boolean>;\n  /** Reports a current write's explicit failure or exception while the scope remains enabled and live. */\n  readonly onError?: (error: unknown) => void | PromiseLike<void>;\n}\n\n/** The current autosave intent and explicit queue controls. */\nexport interface AutosaveControls {\n  readonly status: Readonly<ShallowRef<AutosaveStatus>>;\n  /** The latest current-intent failure or exception; cleared by a new edit or cancellation. */\n  readonly error: Readonly<ShallowRef<unknown | null>>;\n  /** Date.now() when a still-current write last succeeded; obsolete completions do not advance it. */\n  readonly lastSavedAt: Readonly<ShallowRef<number | null>>;\n  /**\n   * Makes pending work ready immediately, still waiting for any active sink. Without pending work this is a no-op.\n   */\n  flush(): void;\n  /** Drops queued work and invalidates active completion state. An already-started sink cannot be undone. */\n  cancel(): void;\n}\n\n/**\n * Watches edits deeply and serializes saves, retaining only the latest pending value behind an active write.\n * A new edit immediately supersedes the old completion status, even while its debounce is still pending.\n * The sink receives the latest value when its turn starts. For mutable drafts, a sink that needs an immutable\n * payload must snapshot before its first await; autosave does not impose a cloning policy on domain values.\n *\n * A void sink acknowledges completion by returning normally, preserving synchronous storage adapters.\n * A Result sink acknowledges success explicitly or supplies an AppError. Neither means durable persistence\n * beyond the sink's own contract. Thrown/rejected exceptions remain the original error in the handle/onError;\n * they are not converted into an expected Result failure. Error-observer failures are reported diagnostically.\n *\n * The initial value is not saved. Disable/cancel discard queued writes and invalidate late completion state.\n * Disposal cancels scheduling and starts no new writes; the rejection of an already-started sink is observed\n * without updating disposed state or invoking onError. Flush readies queued work but does not await durability;\n * disposal still cancels a write queued behind an active sink.\n */\nexport function useAutosave<T>(\n  value: MaybeRefOrGetter<T>,\n  save: (value: T) => void | Result<void, AppError> | PromiseLike<void | Result<void, AppError>>,\n  options: UseAutosaveOptions = {},\n): AutosaveControls {\n  const { delayMs = 800, enabled = true, onError } = options;\n  const status = shallowRef<AutosaveStatus>('idle');\n  const error = shallowRef<unknown | null>(null);\n  const lastSavedAt = shallowRef<number | null>(null);\n  let timer: ReturnType<typeof setTimeout> | null = null;\n  let isDisposed = false;\n  let isRunning = false;\n  let pending = false;\n  let ready = false;\n  let revision = 0;\n  const isEnabled = (): boolean => toValue(enabled);\n\n  function clearTimer(): void {\n    if (timer === null) return;\n    clearTimeout(timer);\n    timer = null;\n  }\n\n  /** Error observers are not allowed to create an unobserved rejection in the scheduler. */\n  function reportError(failure: unknown): void {\n    if (!onError) return;\n    const reportObserverFailure = (observerError: unknown): void => {\n      console.error('Autosave onError callback failed', observerError);\n    };\n    try {\n      void Promise.resolve(onError(failure)).catch(reportObserverFailure);\n    } catch (observerError) {\n      reportObserverFailure(observerError);\n    }\n  }\n\n  async function execute(currentRevision: number): Promise<void> {\n    let failed = false;\n    let failure: unknown;\n    try {\n      const outcome = await save(toValue(value));\n      if (outcome && !outcome.ok) {\n        failed = true;\n        failure = outcome.failure;\n      }\n    } catch (caught) {\n      failed = true;\n      failure = caught;\n    }\n    isRunning = false;\n    if (!isDisposed && isEnabled() && currentRevision === revision) {\n      status.value = failed ? 'error' : 'saved';\n      error.value = failed ? failure : null;\n      if (failed) reportError(failure);\n      else lastSavedAt.value = Date.now();\n    }\n    drain();\n  }\n\n  function drain(): void {\n    if (isDisposed || !isEnabled() || isRunning || !pending || !ready) return;\n    clearTimer();\n    pending = false;\n    ready = false;\n    isRunning = true;\n    status.value = 'saving';\n    void execute(revision);\n  }\n\n  function flush(): void {\n    if (isDisposed || !isEnabled() || !pending) return;\n    clearTimer();\n    ready = true;\n    drain();\n  }\n\n  function cancel(): void {\n    clearTimer();\n    pending = false;\n    ready = false;\n    revision += 1;\n    if (isDisposed) return;\n    status.value = 'idle';\n    error.value = null;\n  }\n\n  watch(\n    [() => toValue(value), isEnabled],\n    () => {\n      if (isDisposed) return;\n      if (!isEnabled()) {\n        cancel();\n        return;\n      }\n      revision += 1;\n      clearTimer();\n      pending = true;\n      ready = false;\n      status.value = 'pending';\n      error.value = null;\n      const delay = toValue(delayMs);\n      timer = setTimeout(\n        () => {\n          timer = null;\n          ready = true;\n          drain();\n        },\n        Number.isFinite(delay) ? Math.max(0, delay) : 800,\n      );\n    },\n    // Invalidate a completion immediately on edit; a queued watcher could otherwise report obsolete success.\n    { deep: true, flush: 'sync' },\n  );\n\n  onScopeDispose(() => {\n    isDisposed = true;\n    cancel();\n    status.value = 'idle';\n    error.value = null;\n  });\n  return { status, error, lastSavedAt, flush, cancel };\n}\n"],"names":[],"mappings":"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"}

package/dist/foundation/styles/SurfaceStyles.d.ts

@@ -0,0 +1,191 @@
+import { VariantProps } from './Tv';
+import { Tone } from './enums/StyleTokens';
+/** Defines the visual-recipe axis of a surface (solid · soft · surface · outline · glass · etc.). */
+export declare const SurfaceVariant: {
+    /** Refers to an opaque fill, no border, light shadow. */
+    readonly Solid: "solid";
+    /** Refers to a muted/tinted fill, no border, light shadow. */
+    readonly Soft: "soft";
+    /** Refers to an opaque fill + visible border + medium shadow. */
+    readonly Surface: "surface";
+    /** Refers to a transparent fill + visible border. */
+    readonly Outline: "outline";
+    /** Refers to a translucent + blur fill, no border, medium shadow. */
+    readonly Glass: "glass";
+    /** Refers to a translucent + blur fill + subtle border. */
+    readonly GlassOutline: "glass-outline";
+    /** Refers to an opaque fill, no border, heavy shadow. */
+    readonly Elevated: "elevated";
+    /** Refers to an opaque fill, no border, no shadow. */
+    readonly Flat: "flat";
+    /** Refers to a low-alpha tinted fill + neutral border, no shadow. */
+    readonly Subtle: "subtle";
+};
+export type SurfaceVariant = (typeof SurfaceVariant)[keyof typeof SurfaceVariant];
+/** Provides the tailwind-variants config for every "block with a visual treatment" surface. */
+export declare const surfaceVariants: import('tailwind-variants').TVReturnType<{
+    variant: {
+        solid: "shadow-sm";
+        soft: "shadow-sm";
+        surface: "border shadow-md";
+        outline: "border bg-transparent";
+        glass: "backdrop-blur-md shadow-md";
+        'glass-outline': "border backdrop-blur-md shadow-md";
+        elevated: "shadow-xl";
+        flat: "";
+        subtle: "border";
+    };
+    tone: {
+        neutral: "";
+        primary: "";
+        danger: "";
+        success: "";
+        warning: "";
+        info: "";
+    };
+    radius: {
+        none: "rounded-none";
+        sm: "rounded-sm";
+        md: "rounded-md";
+        lg: "rounded-lg";
+        xl: "rounded-xl";
+        '2xl': "rounded-2xl";
+        full: "rounded-full";
+    };
+    padding: {
+        none: "p-0";
+        xs: "p-1";
+        sm: "p-2";
+        md: "p-3";
+        lg: "p-4";
+        xl: "p-6";
+        '2xl': "p-8";
+    };
+    elevation: {
+        0: "shadow-none";
+        1: "shadow-sm";
+        2: "shadow-md";
+        3: "shadow-lg";
+        4: "shadow-xl";
+        5: "shadow-2xl";
+    };
+    ambient: {
+        none: "";
+        sheen: "surface-sheen";
+        glow: "surface-glow";
+    };
+}, undefined, "outline-hidden transition-colors", {
+    variant: {
+        solid: "shadow-sm";
+        soft: "shadow-sm";
+        surface: "border shadow-md";
+        outline: "border bg-transparent";
+        glass: "backdrop-blur-md shadow-md";
+        'glass-outline': "border backdrop-blur-md shadow-md";
+        elevated: "shadow-xl";
+        flat: "";
+        subtle: "border";
+    };
+    tone: {
+        neutral: "";
+        primary: "";
+        danger: "";
+        success: "";
+        warning: "";
+        info: "";
+    };
+    radius: {
+        none: "rounded-none";
+        sm: "rounded-sm";
+        md: "rounded-md";
+        lg: "rounded-lg";
+        xl: "rounded-xl";
+        '2xl': "rounded-2xl";
+        full: "rounded-full";
+    };
+    padding: {
+        none: "p-0";
+        xs: "p-1";
+        sm: "p-2";
+        md: "p-3";
+        lg: "p-4";
+        xl: "p-6";
+        '2xl': "p-8";
+    };
+    elevation: {
+        0: "shadow-none";
+        1: "shadow-sm";
+        2: "shadow-md";
+        3: "shadow-lg";
+        4: "shadow-xl";
+        5: "shadow-2xl";
+    };
+    ambient: {
+        none: "";
+        sheen: "surface-sheen";
+        glow: "surface-glow";
+    };
+}, undefined, import('tailwind-variants').TVReturnTypeLike<{
+    variant: {
+        solid: "shadow-sm";
+        soft: "shadow-sm";
+        surface: "border shadow-md";
+        outline: "border bg-transparent";
+        glass: "backdrop-blur-md shadow-md";
+        'glass-outline': "border backdrop-blur-md shadow-md";
+        elevated: "shadow-xl";
+        flat: "";
+        subtle: "border";
+    };
+    tone: {
+        neutral: "";
+        primary: "";
+        danger: "";
+        success: "";
+        warning: "";
+        info: "";
+    };
+    radius: {
+        none: "rounded-none";
+        sm: "rounded-sm";
+        md: "rounded-md";
+        lg: "rounded-lg";
+        xl: "rounded-xl";
+        '2xl': "rounded-2xl";
+        full: "rounded-full";
+    };
+    padding: {
+        none: "p-0";
+        xs: "p-1";
+        sm: "p-2";
+        md: "p-3";
+        lg: "p-4";
+        xl: "p-6";
+        '2xl': "p-8";
+    };
+    elevation: {
+        0: "shadow-none";
+        1: "shadow-sm";
+        2: "shadow-md";
+        3: "shadow-lg";
+        4: "shadow-xl";
+        5: "shadow-2xl";
+    };
+    ambient: {
+        none: "";
+        sheen: "surface-sheen";
+        glow: "surface-glow";
+    };
+}, undefined>>;
+/** Represents the union of every surface variant prop. */
+export type SurfaceVariants = VariantProps<typeof surfaceVariants>;
+/** Represents the semantic colour axis — the shared `Tone` (neutral · primary · danger · success · warning · info). */
+export type SurfaceTone = Tone;
+/** Represents the corner-roundness axis (none · sm · md · lg · xl · 2xl · full). */
+export type SurfaceRadius = NonNullable<SurfaceVariants['radius']>;
+/** Represents the interior-padding axis (none · xs · sm · md · lg · xl · 2xl). */
+export type SurfacePadding = NonNullable<SurfaceVariants['padding']>;
+/** Represents the shadow-depth override (0–5); omitted means the variant decides. */
+export type SurfaceElevation = NonNullable<SurfaceVariants['elevation']>;
+/** Represents the optional ambient gradient overlay (none · sheen · glow); omitted = none. */
+export type SurfaceAmbient = NonNullable<SurfaceVariants['ambient']>;

package/dist/foundation/styles/constants/Layers.d.ts

@@ -0,0 +1,35 @@
+/** Contains the semantic z-index tiers; matching `z-{name}` utilities ship via @theme. */
+export declare const Layer: {
+    /** Slips under the base layer; visually hidden. */
+    readonly Hide: -1;
+    /** Sits in the default DOM flow with no z-index applied. */
+    readonly Base: 0;
+    /** Slightly elevates over siblings — badges, sticky list items, in-grid overlays. */
+    readonly Raised: 10;
+    /** Pins widgets inside a section — panels, inline overlays. */
+    readonly Docked: 20;
+    /** Anchors a page-level sticky header or footer. */
+    readonly Sticky: 30;
+    /** Hosts system banners — cookie notice, status banner, persistent Fab. */
+    readonly Banner: 40;
+    /** Hosts dropdowns, popovers, comboboxes, menus, hover-cards anchored to a trigger. */
+    readonly Dropdown: 50;
+    /** Dims the page behind a modal — backdrop / scrim layer. */
+    readonly Overlay: 60;
+    /** Hosts modal / dialog / drawer / sheet content above its backdrop. */
+    readonly Modal: 70;
+    /** Hosts popovers / menus opened FROM inside a modal — must beat Modal. */
+    readonly Popover: 80;
+    /** Hosts toasts, snackbars, undo bars — survives above modals. */
+    readonly Toast: 90;
+    /** Hosts tooltips and live-cursors — highest functional layer. */
+    readonly Tooltip: 100;
+    /** Hosts DevTools / design-system inspector overlays — always wins. */
+    readonly Debug: 9999;
+};
+/** Represents the name of a semantic z-index tier. */
+export type LayerName = keyof typeof Layer;
+/** Provides an inline `style` object for programmatic z-index assignment. */
+export declare function layerStyle(layer: LayerName): {
+    zIndex: number;
+};

package/dist/foundation/styles/constants/Tones.d.ts

@@ -0,0 +1,21 @@
+import { Tone } from '../enums/StyleTokens';
+/** Defines a tone-family — the variant group that picks the same bg/border/text palette. */
+export declare const ToneFamily: {
+    /** Refers to an opaque tone bg + foreground. */
+    readonly Solid: "solid";
+    /** Refers to a muted/tinted bg + tone-readable foreground. */
+    readonly Soft: "soft";
+    /** Refers to a popover bg + tone-accent border. */
+    readonly Surface: "surface";
+    /** Refers to a transparent bg, tone border + tone text. */
+    readonly Outline: "outline";
+    /** Refers to a translucent tone bg + blur. */
+    readonly Glass: "glass";
+    /** Refers to a glass fill + tone-accent border at 50% alpha. */
+    readonly GlassOutline: "glassOutline";
+    /** Refers to a low-alpha tinted fill + neutral border, no shadow. */
+    readonly Subtle: "subtle";
+};
+export type ToneFamily = (typeof ToneFamily)[keyof typeof ToneFamily];
+/** Contains the cross-engine palette: bg / text (+ border where applicable) per tone-family × tone. */
+export declare const Tones: Record<ToneFamily, Record<Tone, string>>;

package/dist/foundation/styles/extensions/ColorExtensions.d.ts

@@ -0,0 +1,51 @@
+import { CSSProperties } from 'vue';
+/** Defines the tone vocabulary shared by tone-aware components (Button, Checkbox, ToggleButton, Tag, Alert, etc.). */
+export declare const ColorTone: {
+    /** Refers to the primary brand palette. */
+    readonly Primary: "primary";
+    /** Refers to the neutral / default grey palette. */
+    readonly Neutral: "neutral";
+    /** Refers to the destructive / error palette. */
+    readonly Danger: "danger";
+    /** Refers to the positive / confirmation palette. */
+    readonly Success: "success";
+    /** Refers to the caution palette. */
+    readonly Warning: "warning";
+};
+export type ColorTone = (typeof ColorTone)[keyof typeof ColorTone];
+export interface ColorOverride {
+    bg?: string;
+    text?: string;
+    soft?: string;
+    softText?: string;
+    ring?: string;
+}
+export type ColorProp = string | ColorOverride;
+/**
+ * Convert a `color` / `colors` prop into a CSS-variable override style for
+ * the active tone's slot set. Returned style overrides the component's theme
+ * tokens locally — every Tailwind utility (`bg-{tone}`, `hover:bg-{tone}/X`,
+ * `text-{tone}-foreground`, etc.) that references the var picks it up
+ * automatically. No variant config refactor required.
+ *
+ * Single-seed mode (`input` is a string):
+ * - `bg` ← seed
+ * - `text` ← white (default contrast; override via `colors.text`)
+ * - `soft` ← seed mixed 12% over white via `color-mix(in oklch, ...)`
+ * - `softText` ← seed
+ * - `ring` ← seed
+ *
+ * Object mode (`input` is a `ColorOverride`):
+ * - Each slot independently overridable; unset slots retain the theme default.
+ */
+declare function toneColorOverride(input: ColorProp | undefined, tone: ColorTone | undefined): CSSProperties | undefined;
+export declare const ColorExtensions: {
+    readonly toneColorOverride: typeof toneColorOverride;
+    readonly ToneTokenMap: Record<ColorTone, {
+        main: string;
+        fg: string;
+        soft: string;
+        softFg: string;
+    }>;
+};
+export {};