react-mnemonic 0.1.1-alpha.0 → 1.0.0-beta.0

package/dist/index.d.ts

@@ -149,6 +149,8 @@ declare function createCodec<T>(encode: (value: T) => string, decode: (encoded:
  * | `WRITE_SCHEMA_REQUIRED`         | Strict mode requires a schema to write, but none was found.     |
  * | `MIGRATION_PATH_NOT_FOUND`      | No contiguous migration path between the stored and latest version. |
  * | `MIGRATION_FAILED`              | A migration step threw during execution.                        |
+ * | `MIGRATION_GRAPH_INVALID`       | The schema registry helper received an ambiguous or cyclic migration graph. |
+ * | `RECONCILE_FAILED`             | A read-time reconciliation hook threw or returned an unpersistable value. |
  * | `SCHEMA_REGISTRATION_CONFLICT`  | `registerSchema` was called with a conflicting definition.      |
  * | `TYPE_MISMATCH`                 | The decoded value failed JSON Schema validation.                |
  * | `MODE_CONFIGURATION_INVALID`    | The schema mode requires a capability the registry doesn't provide. |
@@ -170,7 +172,7 @@ declare class SchemaError extends Error {
     /**
      * Machine-readable code identifying the category of schema failure.
      */
-    readonly code: "INVALID_ENVELOPE" | "SCHEMA_NOT_FOUND" | "WRITE_SCHEMA_REQUIRED" | "MIGRATION_PATH_NOT_FOUND" | "MIGRATION_FAILED" | "SCHEMA_REGISTRATION_CONFLICT" | "TYPE_MISMATCH" | "MODE_CONFIGURATION_INVALID";
+    readonly code: "INVALID_ENVELOPE" | "SCHEMA_NOT_FOUND" | "WRITE_SCHEMA_REQUIRED" | "MIGRATION_PATH_NOT_FOUND" | "MIGRATION_FAILED" | "MIGRATION_GRAPH_INVALID" | "RECONCILE_FAILED" | "SCHEMA_REGISTRATION_CONFLICT" | "TYPE_MISMATCH" | "MODE_CONFIGURATION_INVALID";
     /**
      * The underlying error that caused this failure, if any.
      */
@@ -407,8 +409,13 @@ interface MnemonicProviderOptions {
     /**
      * Enable DevTools debugging interface.
      *
-     * When enabled, exposes the store on `window.__REACT_MNEMONIC_DEVTOOLS__[namespace]`
-     * with methods to inspect, modify, and dump storage state from the console.
+     * When enabled, registers this provider in the global
+     * `window.__REACT_MNEMONIC_DEVTOOLS__` registry.
+     *
+     * The registry stores providers as weak references and exposes:
+     * - `resolve(namespace)` to strengthen a provider reference and access
+     *   inspection methods.
+     * - `list()` to enumerate provider availability.
      *
      * @default false
      *
@@ -418,9 +425,10 @@ interface MnemonicProviderOptions {
      * enableDevTools: process.env.NODE_ENV === 'development'
      *
      * // Then in browser console:
-     * window.__REACT_MNEMONIC_DEVTOOLS__.myApp.dump()
-     * window.__REACT_MNEMONIC_DEVTOOLS__.myApp.get('user')
-     * window.__REACT_MNEMONIC_DEVTOOLS__.myApp.set('user', { name: 'Test' })
+     * const provider = window.__REACT_MNEMONIC_DEVTOOLS__.resolve('myApp')
+     * provider?.dump()
+     * provider?.get('user')
+     * provider?.set('user', { name: 'Test' })
      * ```
      */
     enableDevTools?: boolean;
@@ -491,6 +499,112 @@ interface MnemonicProviderOptions {
  * @see {@link KeySchema} - Individual schema definition
  */
 type SchemaMode = "strict" | "default" | "autoschema";
+/**
+ * Weak-reference shape used by the devtools registry.
+ *
+ * Matches the standard `WeakRef` API while keeping the public type surface
+ * compatible with ES2020 TypeScript lib targets.
+ */
+interface MnemonicDevToolsWeakRef<T extends object> {
+    /**
+     * Attempts to strengthen the weak reference.
+     *
+     * @returns The live object, or undefined if it was garbage-collected.
+     */
+    deref: () => T | undefined;
+}
+/**
+ * Provider inspection API exposed through devtools registry resolution.
+ *
+ * Resolve a provider from the registry, then invoke these methods for manual
+ * inspection/mutation from the browser console.
+ */
+interface MnemonicDevToolsProviderApi {
+    /** Access the underlying store instance. */
+    getStore: () => Mnemonic;
+    /** Dump all raw key-value pairs for the provider namespace. */
+    dump: () => Record<string, string>;
+    /** Read decoded value for an unprefixed key. */
+    get: (key: string) => unknown;
+    /** Write value for an unprefixed key (JSON-encoded). */
+    set: (key: string, value: unknown) => void;
+    /** Remove a single unprefixed key. */
+    remove: (key: string) => void;
+    /** Remove all keys in this provider namespace. */
+    clear: () => void;
+    /** List all unprefixed keys in this provider namespace. */
+    keys: () => string[];
+}
+/**
+ * Registry entry for a single provider namespace.
+ */
+interface MnemonicDevToolsProviderEntry {
+    /** Namespace key for this provider entry. */
+    namespace: string;
+    /** Weak reference to the provider inspection API. */
+    weakRef: MnemonicDevToolsWeakRef<MnemonicDevToolsProviderApi>;
+    /** Timestamp when this namespace was registered. */
+    registeredAt: number;
+    /** Timestamp when provider was last confirmed live. */
+    lastSeenAt: number;
+    /** Timestamp when provider was first observed unavailable, or null when live. */
+    staleSince: number | null;
+}
+/**
+ * Lightweight provider status returned by `list()`.
+ */
+interface MnemonicDevToolsProviderDescriptor {
+    /** Namespace registered by the provider. */
+    namespace: string;
+    /** Whether the provider can currently be resolved to a live API instance. */
+    available: boolean;
+    /** Timestamp when the provider namespace was first registered. */
+    registeredAt: number;
+    /** Timestamp when the provider was last observed as live. */
+    lastSeenAt: number;
+    /** Timestamp when the provider first became unavailable, or `null` when live. */
+    staleSince: number | null;
+}
+/**
+ * Environment capabilities reported by devtools registry.
+ */
+interface MnemonicDevToolsCapabilities {
+    /** Whether the runtime supports `WeakRef`. */
+    weakRef: boolean;
+    /** Whether the runtime supports `FinalizationRegistry`. */
+    finalizationRegistry: boolean;
+}
+/**
+ * Polling metadata for extension synchronization.
+ */
+interface MnemonicDevToolsMeta {
+    /** Monotonic registry version incremented on register and mutation events. */
+    version: number;
+    /** Timestamp of the most recent registry update. */
+    lastUpdated: number;
+    /** Short label describing the most recent registry change. */
+    lastChange: string;
+}
+/**
+ * Global devtools registry contract available on window.
+ *
+ * This is an advanced public API used by the browser console integration and
+ * extension tooling. Direct namespace access
+ * (`window.__REACT_MNEMONIC_DEVTOOLS__.myNamespace`) is not part of the
+ * public API.
+ */
+interface MnemonicDevToolsRegistry {
+    /** Provider entries keyed by namespace. */
+    providers: Record<string, MnemonicDevToolsProviderEntry>;
+    /** Resolve a namespace to a live provider API when one is available. */
+    resolve: (namespace: string) => MnemonicDevToolsProviderApi | null;
+    /** List provider availability without strengthening weak references manually. */
+    list: () => MnemonicDevToolsProviderDescriptor[];
+    /** Runtime capabilities relevant to the registry implementation. */
+    capabilities: MnemonicDevToolsCapabilities;
+    /** Versioning metadata used by polling devtools integrations. */
+    __meta: MnemonicDevToolsMeta;
+}
 /**
  * Schema definition for a single key at a specific version.
  *
@@ -624,6 +738,31 @@ type MigrationRule = {
  * @see {@link SchemaRegistry.getMigrationPath} - Resolves a path between versions
  */
 type MigrationPath = MigrationRule[];
+/**
+ * Input options for {@link createSchemaRegistry}.
+ *
+ * Use this helper when your registry contents are known up front and do not
+ * need runtime mutation. The returned registry is immutable and optimized for
+ * the common `"default"` / `"strict"` setup.
+ */
+interface CreateSchemaRegistryOptions {
+    /**
+     * Versioned schemas to index by key and version.
+     *
+     * Duplicate `key + version` pairs are rejected up front with
+     * `SchemaError("SCHEMA_REGISTRATION_CONFLICT")`.
+     */
+    schemas?: readonly KeySchema[];
+    /**
+     * Migration rules to index by key and version edge.
+     *
+     * Write-time normalizers (`fromVersion === toVersion`) are indexed
+     * separately from read-time migration edges. Ambiguous outgoing edges,
+     * backward migrations, and duplicate write normalizers are rejected up
+     * front with `SchemaError("MIGRATION_GRAPH_INVALID")`.
+     */
+    migrations?: readonly MigrationRule[];
+}
 /**
  * Lookup and registration API for key schemas and migration paths.
  *
@@ -824,6 +963,215 @@ type StorageLike = {
      */
     onExternalChange?: (callback: (changedKeys?: string[]) => void) => () => void;
 };
+/**
+ * Function type for unsubscribing from event listeners.
+ *
+ * Call this function to remove a subscription and stop receiving updates.
+ *
+ * @example
+ * ```typescript
+ * const unsubscribe = store.subscribeRaw('user', () => console.log('Updated!'));
+ * // Later...
+ * unsubscribe(); // Stop listening
+ * ```
+ */
+type Unsubscribe = () => void;
+/**
+ * Callback function invoked when a subscribed value changes.
+ *
+ * Used by the external store contract to notify React when state updates.
+ */
+type Listener = () => void;
+/**
+ * Low-level Mnemonic store API provided via React Context.
+ *
+ * This interface powers `MnemonicProvider` internally and is also exposed to
+ * advanced consumers through `MnemonicDevToolsProviderApi.getStore()`. Typical
+ * application code should still prefer `useMnemonicKey`.
+ *
+ * All keys passed to these methods should be **unprefixed**. The store
+ * automatically applies the namespace prefix internally.
+ *
+ * @remarks
+ * This implements the React `useSyncExternalStore` contract for efficient,
+ * tearing-free state synchronization. Most application code should still
+ * prefer `useMnemonicKey`; this type mainly appears in the DevTools API via
+ * `MnemonicDevToolsProviderApi.getStore()`.
+ */
+type Mnemonic = {
+    /**
+     * The namespace prefix applied to all keys in storage.
+     *
+     * Keys are stored as `${prefix}${key}` in the underlying storage backend.
+     */
+    prefix: string;
+    /**
+     * Whether the active storage backend can enumerate keys in this namespace.
+     *
+     * This is `true` for `localStorage`-like backends that implement both
+     * `length` and `key(index)`. Namespace-wide recovery helpers rely on this
+     * capability unless the caller supplies an explicit key list.
+     */
+    canEnumerateKeys: boolean;
+    /**
+     * Subscribe to changes for a specific key.
+     *
+     * Follows the React external store subscription contract. The listener
+     * will be called whenever the value for this key changes.
+     *
+     * @param key - The unprefixed storage key to subscribe to
+     * @param listener - Callback invoked when the value changes
+     * @returns Unsubscribe function to stop listening
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = store.subscribeRaw('user', () => {
+     *   console.log('User changed:', store.getRawSnapshot('user'));
+     * });
+     * ```
+     */
+    subscribeRaw: (key: string, listener: Listener) => Unsubscribe;
+    /**
+     * Get the current raw string value for a key.
+     *
+     * This is part of the external store snapshot contract. Values are
+     * cached in memory for stable snapshots.
+     *
+     * @param key - The unprefixed storage key
+     * @returns The raw string value, or null if not present
+     */
+    getRawSnapshot: (key: string) => string | null;
+    /**
+     * Write a raw string value to storage.
+     *
+     * Updates both the in-memory cache and the underlying storage backend,
+     * then notifies all subscribers for this key.
+     *
+     * @param key - The unprefixed storage key
+     * @param raw - The raw string value to store
+     */
+    setRaw: (key: string, raw: string) => void;
+    /**
+     * Remove a key from storage.
+     *
+     * Clears the value from both the cache and the underlying storage,
+     * then notifies all subscribers.
+     *
+     * @param key - The unprefixed storage key to remove
+     */
+    removeRaw: (key: string) => void;
+    /**
+     * Enumerate all keys in this namespace.
+     *
+     * Returns unprefixed keys that belong to this store's namespace.
+     *
+     * @returns Array of unprefixed key names
+     */
+    keys: () => string[];
+    /**
+     * Dump all key-value pairs in this namespace.
+     *
+     * Useful for debugging and DevTools integration.
+     *
+     * @returns Object mapping unprefixed keys to raw string values
+     */
+    dump: () => Record<string, string>;
+    /**
+     * The active schema enforcement mode for this provider.
+     *
+     * Propagated from the `schemaMode` provider option. Hooks read this
+     * to determine how to handle versioned envelopes.
+     *
+     * @see {@link SchemaMode}
+     */
+    schemaMode: SchemaMode;
+    /**
+     * The schema registry for this provider, if one was supplied.
+     *
+     * Hooks use this to look up schemas, resolve migration paths, and
+     * (in autoschema mode) register inferred schemas.
+     *
+     * @see {@link SchemaRegistry}
+     */
+    schemaRegistry?: SchemaRegistry;
+};
+/**
+ * Recovery action names emitted by {@link useMnemonicRecovery}.
+ */
+type MnemonicRecoveryAction = "clear-all" | "clear-keys" | "clear-matching";
+/**
+ * Recovery event payload emitted after a namespace recovery action completes.
+ */
+interface MnemonicRecoveryEvent {
+    /**
+     * Recovery action that just ran.
+     */
+    action: MnemonicRecoveryAction;
+    /**
+     * Namespace where the recovery action ran.
+     */
+    namespace: string;
+    /**
+     * Unprefixed keys cleared by the action.
+     */
+    clearedKeys: string[];
+}
+/**
+ * Options for {@link useMnemonicRecovery}.
+ */
+interface UseMnemonicRecoveryOptions {
+    /**
+     * Optional callback invoked after a recovery action completes.
+     *
+     * Useful for analytics, audit trails, support diagnostics, or user-facing
+     * confirmation toasts.
+     */
+    onRecover?: (event: MnemonicRecoveryEvent) => void;
+}
+/**
+ * Namespace-scoped recovery helpers returned by {@link useMnemonicRecovery}.
+ *
+ * These helpers operate on the current provider namespace and are intended for
+ * user-facing recovery UX such as "reset app data" or "clear stale filters".
+ */
+interface MnemonicRecoveryHook {
+    /**
+     * Current provider namespace without the trailing storage prefix dot.
+     */
+    namespace: string;
+    /**
+     * Whether namespace keys can be enumerated automatically.
+     *
+     * `clearAll()` and `clearMatching()` require this to be `true`. If it is
+     * `false`, prefer `clearKeys([...])` with an explicit durable-key list.
+     */
+    canEnumerateKeys: boolean;
+    /**
+     * Lists all unprefixed keys currently visible in this namespace.
+     *
+     * Returns an empty array when no keys exist or when the storage backend
+     * cannot enumerate keys.
+     */
+    listKeys: () => string[];
+    /**
+     * Clears every key in the current namespace.
+     *
+     * @throws {Error} When the storage backend cannot enumerate namespace keys
+     */
+    clearAll: () => string[];
+    /**
+     * Clears a specific set of unprefixed keys in the current namespace.
+     *
+     * Duplicate keys are ignored.
+     */
+    clearKeys: (keys: readonly string[]) => string[];
+    /**
+     * Clears namespace keys whose names match the supplied predicate.
+     *
+     * @throws {Error} When the storage backend cannot enumerate namespace keys
+     */
+    clearMatching: (predicate: (key: string) => boolean) => string[];
+}
 /**
  * Configuration options for the useMnemonicKey hook.
  *
@@ -921,6 +1269,39 @@ type UseMnemonicKeyOptions<T> = {
      * ```
      */
     codec?: Codec<T>;
+    /**
+     * Optional read-time reconciliation hook for persisted values.
+     *
+     * Runs after a stored value has been decoded and any read-time migrations
+     * have completed, but before the hook exposes the value to React. This is
+     * useful for selectively enforcing newly shipped defaults or normalizing
+     * legacy persisted values without discarding the whole key.
+     *
+     * If the reconciled value would persist differently from the pre-reconcile
+     * value, the hook rewrites storage once using the normal write path.
+     *
+     * @remarks
+     * Prefer schema migrations for structural changes that must always happen
+     * between explicit versions. Use `reconcile` for conditional, field-level
+     * adjustments that depend on application policy rather than a strict schema
+     * upgrade step.
+     *
+     * If `reconcile` throws a `SchemaError`, that error is preserved and passed
+     * to `defaultValue`. Any other thrown error is wrapped as
+     * `SchemaError("RECONCILE_FAILED")`.
+     *
+     * @param value - The decoded persisted value
+     * @param context - Metadata about the stored and latest schema versions
+     *
+     * @example
+     * ```typescript
+     * reconcile: (value, { persistedVersion }) => ({
+     *   ...value,
+     *   theme: persistedVersion < 2 ? "dark" : value.theme,
+     * })
+     * ```
+     */
+    reconcile?: (value: T, context: ReconcileContext) => T;
     /**
      * Callback invoked once when the hook is first mounted.
      *
@@ -1011,6 +1392,23 @@ type UseMnemonicKeyOptions<T> = {
         version?: number;
     };
 };
+/**
+ * Metadata passed to `UseMnemonicKeyOptions.reconcile`.
+ */
+type ReconcileContext = {
+    /**
+     * The unprefixed storage key being reconciled.
+     */
+    key: string;
+    /**
+     * The version found in the persisted envelope that was read.
+     */
+    persistedVersion: number;
+    /**
+     * The latest registered schema version for the key, when available.
+     */
+    latestVersion?: number;
+};
 
 /**
  * Props for the MnemonicProvider component.
@@ -1086,9 +1484,10 @@ interface MnemonicProviderProps extends MnemonicProviderOptions {
  * }
  *
  * // Then in browser console:
- * window.__REACT_MNEMONIC_DEVTOOLS__.myApp.dump()
- * window.__REACT_MNEMONIC_DEVTOOLS__.myApp.get('user')
- * window.__REACT_MNEMONIC_DEVTOOLS__.myApp.set('theme', 'dark')
+ * const dt = window.__REACT_MNEMONIC_DEVTOOLS__.resolve('myApp')
+ * dt?.dump()
+ * dt?.get('user')
+ * dt?.set('theme', 'dark')
  * ```
  *
  * @example
@@ -1148,4 +1547,173 @@ declare function useMnemonicKey<T>(key: string, options: UseMnemonicKeyOptions<T
     remove: () => void;
 };
 
-export { type Codec, CodecError, type CompiledValidator, JSONCodec, type JsonSchema, type JsonSchemaType, type JsonSchemaValidationError, type KeySchema, type MigrationPath, type MigrationRule, MnemonicProvider, type MnemonicProviderOptions, type MnemonicProviderProps, SchemaError, type SchemaMode, type SchemaRegistry, type StorageLike, type UseMnemonicKeyOptions, compileSchema, createCodec, useMnemonicKey, validateJsonSchema };
+/**
+ * Hook for namespace-scoped recovery actions such as hard reset and selective clear.
+ *
+ * Applications can use this to offer self-service recovery UX for corrupt or
+ * legacy persisted state. The hook operates on the current provider namespace.
+ *
+ * @param options - Optional recovery callback for telemetry/auditing
+ * @returns Namespace recovery helpers
+ *
+ * @throws {Error} If used outside of a MnemonicProvider
+ */
+declare function useMnemonicRecovery(options?: UseMnemonicRecoveryOptions): MnemonicRecoveryHook;
+
+/**
+ * Create an immutable schema registry for common default/strict-mode setups.
+ *
+ * The helper indexes schemas and migrations up front, validates duplicate and
+ * ambiguous definitions, and returns a {@link SchemaRegistry} ready to pass to
+ * `MnemonicProvider`.
+ *
+ * @param options - Initial schema and migration definitions
+ * @returns An indexed immutable schema registry
+ *
+ * @throws {SchemaError} With `SCHEMA_REGISTRATION_CONFLICT` for duplicate
+ *   schemas, or `MIGRATION_GRAPH_INVALID` for invalid migration graphs
+ */
+declare function createSchemaRegistry(options?: CreateSchemaRegistryOptions): SchemaRegistry;
+
+/**
+ * Adapter functions for structural migration helpers.
+ *
+ * These helpers assume tree-like data, but not a specific node shape. Supply a
+ * `StructuralTreeHelpers<T>` when your nodes use custom field names. When your
+ * nodes already look like `{ id, children }`, the exported helpers work without
+ * any adapter configuration.
+ *
+ * @template T - Tree node type
+ */
+interface StructuralTreeHelpers<T> {
+    /**
+     * Returns the stable identifier for a node.
+     */
+    getId: (node: T) => string;
+    /**
+     * Returns the node's child list, or `undefined` when it has no children.
+     */
+    getChildren: (node: T) => readonly T[] | undefined;
+    /**
+     * Returns a copy of the node with a new child list.
+     */
+    withChildren: (node: T, children: T[]) => T;
+    /**
+     * Returns a copy of the node with a new identifier.
+     */
+    withId: (node: T, id: string) => T;
+}
+/**
+ * Default tree node shape supported by the structural migration helpers.
+ *
+ * If your nodes already use `id` and `children`, you can call the helpers
+ * directly without supplying `StructuralTreeHelpers`.
+ *
+ * @template T - Tree node type
+ */
+interface StructuralNode<T> {
+    /**
+     * Stable node identifier used for lookup and rename operations.
+     */
+    id: string;
+    /**
+     * Optional child nodes.
+     */
+    children?: readonly T[];
+}
+/**
+ * Finds the first node with the requested id using depth-first traversal.
+ *
+ * @template T - Tree node type (must extend `{ id: string; children?: readonly T[] }` when `helpers` is omitted)
+ * @param root - Root node to search
+ * @param id - Target node id
+ * @returns The matching node, or `undefined`
+ */
+declare function findNodeById<T extends StructuralNode<T>>(root: T, id: string): T | undefined;
+/**
+ * Finds the first node with the requested id using depth-first traversal.
+ *
+ * @template T - Tree node type
+ * @param root - Root node to search
+ * @param id - Target node id
+ * @param helpers - Adapter for custom node shapes
+ * @returns The matching node, or `undefined`
+ */
+declare function findNodeById<T>(root: T, id: string, helpers: StructuralTreeHelpers<T>): T | undefined;
+/**
+ * Inserts a child under the target parent when none of that parent's existing
+ * direct children share the same id. Returns the original tree when the parent
+ * is missing or the child is already present as a direct child.
+ *
+ * @template T - Tree node type (must extend `{ id: string; children?: readonly T[] }` when `helpers` is omitted)
+ * @param root - Root node to update
+ * @param parentId - Parent node that should receive the child
+ * @param child - Child node to append
+ * @returns Updated tree with the child inserted once
+ */
+declare function insertChildIfMissing<T extends StructuralNode<T>>(root: T, parentId: string, child: T): T;
+/**
+ * Inserts a child under the target parent when no existing child shares the
+ * same id. Returns the original tree when the parent is missing or the child is
+ * already present.
+ *
+ * @template T - Tree node type
+ * @param root - Root node to update
+ * @param parentId - Parent node that should receive the child
+ * @param child - Child node to append
+ * @param helpers - Adapter for custom node shapes
+ * @returns Updated tree with the child inserted once
+ */
+declare function insertChildIfMissing<T>(root: T, parentId: string, child: T, helpers: StructuralTreeHelpers<T>): T;
+/**
+ * Renames every node with the source id while preserving tree structure.
+ * Returns the original tree when the source id is missing or the target id
+ * already exists elsewhere.
+ *
+ * @template T - Tree node type (must extend `{ id: string; children?: readonly T[] }` when `helpers` is omitted)
+ * @param root - Root node to update
+ * @param currentId - Existing id to rename
+ * @param nextId - Replacement id
+ * @returns Updated tree with matching node ids renamed
+ */
+declare function renameNode<T extends StructuralNode<T>>(root: T, currentId: string, nextId: string): T;
+/**
+ * Renames every node with the source id while preserving tree structure.
+ * Returns the original tree when the source id is missing or the target id
+ * already exists elsewhere.
+ *
+ * @template T - Tree node type
+ * @param root - Root node to update
+ * @param currentId - Existing id to rename
+ * @param nextId - Replacement id
+ * @param helpers - Adapter for custom node shapes
+ * @returns Updated tree with matching node ids renamed
+ */
+declare function renameNode<T>(root: T, currentId: string, nextId: string, helpers: StructuralTreeHelpers<T>): T;
+/**
+ * Deduplicates each node's immediate children while preserving the first child
+ * encountered for each key. The helper traverses the full tree and returns the
+ * original root when no duplicates are removed.
+ *
+ * @template T - Tree node type (must extend `{ id: string; children?: readonly T[] }` when `helpers` is omitted)
+ * @template K - Deduplication key type
+ * @param root - Root node to normalize
+ * @param getKey - Function that computes a dedupe key for each child
+ * @returns Updated tree with duplicate siblings removed
+ */
+declare function dedupeChildrenBy<T extends StructuralNode<T>, K>(root: T, getKey: (node: T) => K): T;
+/**
+ * Deduplicates each node's immediate children while preserving the first child
+ * encountered for each key. The helper traverses the full tree and returns the
+ * original root when no duplicates are removed.
+ *
+ * @template T - Tree node type
+ * @template K - Deduplication key type
+ * @param root - Root node to normalize
+ * @param getKey - Function that computes a dedupe key for each child
+ * @param helpers - Adapter for custom node shapes
+ * @returns Updated tree with duplicate siblings removed
+ */
+declare function dedupeChildrenBy<T, K>(root: T, getKey: (node: T) => K, helpers: StructuralTreeHelpers<T>): T;
+
+export { type Codec, CodecError, type CompiledValidator, type CreateSchemaRegistryOptions, JSONCodec, type JsonSchema, type JsonSchemaType, type JsonSchemaValidationError, type KeySchema, type Listener, type MigrationPath, type MigrationRule, type Mnemonic, type MnemonicDevToolsCapabilities, type MnemonicDevToolsMeta, type MnemonicDevToolsProviderApi, type MnemonicDevToolsProviderDescriptor, type MnemonicDevToolsProviderEntry, type MnemonicDevToolsRegistry, type MnemonicDevToolsWeakRef, MnemonicProvider, type MnemonicProviderOptions, type MnemonicProviderProps, type MnemonicRecoveryAction, type MnemonicRecoveryEvent, type MnemonicRecoveryHook, type ReconcileContext, SchemaError, type SchemaMode, type SchemaRegistry, type StorageLike, type StructuralNode, type StructuralTreeHelpers, type Unsubscribe, type UseMnemonicKeyOptions, type UseMnemonicRecoveryOptions, compileSchema, createCodec, createSchemaRegistry, dedupeChildrenBy, findNodeById, insertChildIfMissing, renameNode, useMnemonicKey, useMnemonicRecovery, validateJsonSchema };