react-mnemonic 0.1.1-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,1151 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * @fileoverview Codec implementations for encoding and decoding values to/from storage.
+ *
+ * This module provides the built-in JSON codec and a factory for creating custom
+ * codecs. Codecs handle the bidirectional transformation between typed JavaScript
+ * values and their string representations for storage.
+ *
+ * Codecs are a low-level mechanism for keys that opt out of the JSON Schema
+ * validation system. When a schema is registered for a key, the schema's
+ * JSON Schema is used for validation and the payload is stored as a JSON value
+ * directly (no codec encoding needed).
+ */
+
+/**
+ * Custom error class for codec encoding and decoding failures.
+ *
+ * Thrown when a codec cannot successfully encode a value to a string or
+ * decode a string back to its typed representation. This allows callers
+ * to distinguish codec errors from other types of errors.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const value = JSONCodec.decode('not-valid-json');
+ * } catch (error) {
+ *   if (error instanceof CodecError) {
+ *     console.error('Failed to decode:', error.message);
+ *   }
+ * }
+ * ```
+ */
+declare class CodecError extends Error {
+    /**
+     * The underlying error that caused the codec failure, if any.
+     *
+     * Useful for debugging when wrapping errors from JSON.parse or
+     * other parsing operations.
+     */
+    readonly cause?: unknown;
+    /**
+     * Creates a new CodecError.
+     *
+     * @param message - Human-readable error description
+     * @param cause - Optional underlying error that caused this failure
+     */
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * JSON codec for encoding and decoding JSON-serializable values.
+ *
+ * This is the default codec used by `useMnemonicKey` when no codec is specified.
+ * It uses `JSON.stringify` for encoding and `JSON.parse` for decoding, making it
+ * suitable for objects, arrays, and primitive values.
+ *
+ * @remarks
+ * - Supports any JSON-serializable type: objects, arrays, strings, numbers, booleans, null
+ * - Does not preserve JavaScript-specific types like Date, Map, Set, or undefined
+ * - Throws standard JSON parsing errors for malformed JSON strings
+ *
+ * @example
+ * ```typescript
+ * // Used automatically as the default
+ * const { value, set } = useMnemonicKey('userProfile', {
+ *   defaultValue: { name: 'Guest', preferences: { theme: 'dark' } }
+ *   // codec: JSONCodec is implicit
+ * });
+ *
+ * // Can be specified explicitly
+ * const { value, set } = useMnemonicKey('settings', {
+ *   defaultValue: { notifications: true },
+ *   codec: JSONCodec
+ * });
+ * ```
+ *
+ * @see {@link createCodec} - For custom encoding schemes
+ */
+declare const JSONCodec: Codec<any>;
+/**
+ * Factory function for creating custom codecs.
+ *
+ * Creates a `Codec<T>` from separate encode and decode functions. This is
+ * useful for implementing custom serialization strategies for types that
+ * aren't supported by JSONCodec. Using a custom codec on a key opts out
+ * of JSON Schema validation for that key.
+ *
+ * @template T - The TypeScript type of values to encode/decode
+ *
+ * @param encode - Function that converts a typed value to a string
+ * @param decode - Function that converts a string back to a typed value
+ * @returns A `Codec<T>` object compatible with useMnemonicKey
+ *
+ * @example
+ * ```typescript
+ * // Codec for Date objects
+ * const DateCodec = createCodec<Date>(
+ *   (date) => date.toISOString(),
+ *   (str) => new Date(str)
+ * );
+ *
+ * const { value, set } = useMnemonicKey('lastLogin', {
+ *   defaultValue: new Date(),
+ *   codec: DateCodec
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Codec for Set<string>
+ * const StringSetCodec = createCodec<Set<string>>(
+ *   (set) => JSON.stringify(Array.from(set)),
+ *   (str) => new Set(JSON.parse(str))
+ * );
+ *
+ * const { value, set } = useMnemonicKey('tags', {
+ *   defaultValue: new Set<string>(),
+ *   codec: StringSetCodec
+ * });
+ * ```
+ *
+ * @see {@link Codec} - The codec interface
+ * @see {@link CodecError} - Error to throw when encoding/decoding fails
+ * @see {@link JSONCodec} - Built-in codec for JSON values
+ */
+declare function createCodec<T>(encode: (value: T) => string, decode: (encoded: string) => T): Codec<T>;
+
+/**
+ * @fileoverview Schema versioning primitives for Mnemonic.
+ *
+ * This module defines the envelope format used to wrap every persisted value
+ * and the error class thrown when schema-related operations fail.
+ */
+/**
+ * Error thrown for schema registry, versioning, and migration failures.
+ *
+ * Each instance carries a machine-readable {@link code} that categorises
+ * the failure. When a `defaultValue` factory is provided to
+ * `useMnemonicKey`, the `SchemaError` is passed as the `error` argument
+ * so the factory can inspect the failure reason.
+ *
+ * Error codes:
+ *
+ * | Code                            | Meaning                                                         |
+ * | ------------------------------- | --------------------------------------------------------------- |
+ * | `INVALID_ENVELOPE`              | The raw stored value is not a valid `MnemonicEnvelope`.         |
+ * | `SCHEMA_NOT_FOUND`              | No schema registered for the stored key + version.              |
+ * | `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.                        |
+ * | `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. |
+ *
+ * @example
+ * ```typescript
+ * defaultValue: (error) => {
+ *   if (error instanceof SchemaError) {
+ *     console.warn(`Schema issue [${error.code}]:`, error.message);
+ *   }
+ *   return { name: "Guest" };
+ * }
+ * ```
+ *
+ * @see {@link SchemaMode} - How the provider uses schemas
+ * @see {@link SchemaRegistry} - Where schemas and migrations are registered
+ */
+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";
+    /**
+     * The underlying error that caused this failure, if any.
+     */
+    readonly cause?: unknown;
+    /**
+     * Creates a new SchemaError.
+     *
+     * @param code - Machine-readable failure category
+     * @param message - Human-readable error description
+     * @param cause - Optional underlying error
+     */
+    constructor(code: SchemaError["code"], message: string, cause?: unknown);
+}
+
+/**
+ * @fileoverview JSON Schema subset validator for Mnemonic.
+ *
+ * This module implements a minimal JSON Schema validator sufficient for
+ * validating localStorage state. Only a subset of JSON Schema keywords
+ * are supported; see {@link JsonSchema} for the full list.
+ *
+ * JSON Schema documents are plain JSON objects (inherently serializable),
+ * making them suitable for storage alongside the data they describe.
+ */
+/**
+ * Supported JSON Schema type keywords.
+ *
+ * `"integer"` is a JSON Schema keyword meaning "a number that is a whole number."
+ */
+type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "null" | "object" | "array";
+/**
+ * A subset of JSON Schema sufficient for localStorage state management.
+ *
+ * Supported keywords:
+ *   type, enum, const,
+ *   minimum, maximum, exclusiveMinimum, exclusiveMaximum,
+ *   minLength, maxLength,
+ *   properties, required, additionalProperties,
+ *   items, minItems, maxItems
+ *
+ * Deliberately omitted: $ref, $id, $schema, $defs, allOf, anyOf,
+ * oneOf, not, pattern, format, patternProperties, if/then/else,
+ * dependencies, uniqueItems, multipleOf, propertyNames.
+ *
+ * An empty schema `{}` accepts any value.
+ */
+interface JsonSchema {
+    /** The expected JSON type(s). An array form like `["string", "null"]` accepts either type. */
+    type?: JsonSchemaType | JsonSchemaType[];
+    /** The value must be deeply equal to one of these entries. */
+    enum?: readonly unknown[];
+    /** The value must be deeply equal to this exact value. */
+    const?: unknown;
+    /** Inclusive lower bound for numbers. */
+    minimum?: number;
+    /** Inclusive upper bound for numbers. */
+    maximum?: number;
+    /** Exclusive lower bound for numbers. */
+    exclusiveMinimum?: number;
+    /** Exclusive upper bound for numbers. */
+    exclusiveMaximum?: number;
+    /** Minimum string length (inclusive). */
+    minLength?: number;
+    /** Maximum string length (inclusive). */
+    maxLength?: number;
+    /** Property name to sub-schema mapping for objects. */
+    properties?: Record<string, JsonSchema>;
+    /** Properties that must be present on the object. */
+    required?: readonly string[];
+    /**
+     * Controls extra properties not listed in `properties`.
+     * `false` disallows them. A schema validates their values.
+     * `true` (or omitted) allows anything.
+     */
+    additionalProperties?: boolean | JsonSchema;
+    /** Schema applied to every element of an array. */
+    items?: JsonSchema;
+    /** Minimum array length (inclusive). */
+    minItems?: number;
+    /** Maximum array length (inclusive). */
+    maxItems?: number;
+}
+/**
+ * A single validation error produced by {@link validateJsonSchema}.
+ */
+type JsonSchemaValidationError = {
+    /** JSON Pointer path to the failing value (e.g., "/foo/bar/0"). Empty string for root. */
+    path: string;
+    /** Human-readable error description. */
+    message: string;
+    /** The JSON Schema keyword that failed. */
+    keyword: string;
+};
+/**
+ * A pre-compiled validation function generated by {@link compileSchema}.
+ *
+ * Accepts a value and an optional JSON Pointer path for error reporting.
+ * Returns an array of validation errors (empty = valid).
+ */
+type CompiledValidator = (value: unknown, path?: string) => JsonSchemaValidationError[];
+/**
+ * Pre-compiles a {@link JsonSchema} into a reusable validation function.
+ *
+ * Inspects the schema once and builds a specialized closure that
+ * eliminates runtime branching for unused keywords, pre-converts
+ * `required` arrays to `Set`s, recursively pre-compiles nested property
+ * and item schemas, and pre-builds primitive `Set`s for O(1) enum
+ * lookups when possible.
+ *
+ * Results are cached by schema object identity in a `WeakMap`, so
+ * calling `compileSchema` with the same schema reference is free
+ * after the first call.
+ *
+ * @param schema - The JSON Schema to compile
+ * @returns A compiled validation function
+ */
+declare function compileSchema(schema: JsonSchema): CompiledValidator;
+/**
+ * Validates a value against a {@link JsonSchema}.
+ *
+ * Returns an empty array when the value is valid.
+ * Returns one or more {@link JsonSchemaValidationError} entries on failure.
+ * Short-circuits on type mismatch (does not report downstream keyword errors).
+ *
+ * @param value - The value to validate
+ * @param schema - The JSON Schema to validate against
+ * @param path - Internal: JSON Pointer path for error reporting (default: `""`)
+ * @returns Array of validation errors (empty = valid)
+ */
+declare function validateJsonSchema(value: unknown, schema: JsonSchema, path?: string): JsonSchemaValidationError[];
+
+/**
+ * @fileoverview Type definitions for the Mnemonic library.
+ *
+ * This module defines the core types and interfaces used throughout the Mnemonic
+ * library for type-safe, persistent state management in React applications.
+ */
+
+/**
+ * Codec for encoding and decoding values to and from storage.
+ *
+ * Codecs provide bidirectional transformations between typed values and their
+ * string representations suitable for storage in localStorage or similar backends.
+ *
+ * Using a codec on a key opts out of JSON Schema validation. Schema-managed
+ * keys store JSON values directly and are validated against their JSON Schema.
+ *
+ * @template T - The TypeScript type of the value to encode/decode
+ *
+ * @example
+ * ```typescript
+ * const DateCodec: Codec<Date> = {
+ *   encode: (date) => date.toISOString(),
+ *   decode: (str) => new Date(str)
+ * };
+ * ```
+ *
+ * @see {@link JSONCodec} - Default codec for JSON-serializable values
+ * @see {@link createCodec} - Helper function to create custom codecs
+ */
+interface Codec<T> {
+    /**
+     * Transforms a typed value into a string suitable for storage.
+     *
+     * @param value - The typed value to encode
+     * @returns A string representation of the value
+     * @throws {CodecError} If the value cannot be encoded
+     */
+    encode: (value: T) => string;
+    /**
+     * Transforms a stored string back into a typed value.
+     *
+     * @param encoded - The string representation from storage
+     * @returns The decoded typed value
+     * @throws {CodecError} If the string cannot be decoded
+     */
+    decode: (encoded: string) => T;
+}
+/**
+ * Configuration options for MnemonicProvider.
+ *
+ * These options configure the behavior of the storage provider, including
+ * namespace isolation, storage backend selection, cross-tab synchronization,
+ * and developer tools integration.
+ *
+ * @example
+ * ```tsx
+ * <MnemonicProvider
+ *   namespace="myApp"
+ *   storage={localStorage}
+ *   enableDevTools={process.env.NODE_ENV === 'development'}
+ * >
+ *   <App />
+ * </MnemonicProvider>
+ * ```
+ */
+interface MnemonicProviderOptions {
+    /**
+     * Namespace prefix for all storage keys.
+     *
+     * All keys stored by this provider will be prefixed with `${namespace}.`
+     * to avoid collisions between different parts of your application or
+     * different applications sharing the same storage backend.
+     *
+     * @example
+     * ```typescript
+     * // With namespace="myApp", a key "user" becomes "myApp.user" in storage
+     * namespace: "myApp"
+     * ```
+     */
+    namespace: string;
+    /**
+     * Storage backend to use for persistence.
+     *
+     * Defaults to `window.localStorage` in browser environments. You can provide
+     * a custom implementation (e.g., sessionStorage, AsyncStorage, or a mock for testing).
+     *
+     * @default window.localStorage
+     *
+     * @example
+     * ```typescript
+     * // Use sessionStorage instead of localStorage
+     * storage: window.sessionStorage
+     *
+     * // Use a custom storage implementation
+     * storage: {
+     *   getItem: (key) => myCustomStore.get(key),
+     *   setItem: (key, value) => myCustomStore.set(key, value),
+     *   removeItem: (key) => myCustomStore.delete(key)
+     * }
+     * ```
+     */
+    storage?: StorageLike;
+    /**
+     * 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.
+     *
+     * @default false
+     *
+     * @example
+     * ```typescript
+     * // Enable in development only
+     * 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' })
+     * ```
+     */
+    enableDevTools?: boolean;
+    /**
+     * Versioning and schema enforcement mode.
+     *
+     * Controls whether stored values require a registered schema, and how
+     * missing schemas are handled. See {@link SchemaMode} for the behaviour
+     * of each mode.
+     *
+     * @default "default"
+     *
+     * @see {@link SchemaMode} - Detailed description of each mode
+     * @see {@link SchemaRegistry} - Registry supplied via `schemaRegistry`
+     */
+    schemaMode?: SchemaMode;
+    /**
+     * Schema registry used for version lookup and migration resolution.
+     *
+     * When provided, the library uses the registry to find the correct
+     * JSON Schema for each stored version, and to resolve migration paths
+     * when upgrading old data to the latest schema.
+     *
+     * Required when `schemaMode` is `"strict"` or `"autoschema"`.
+     * Optional (but recommended) in `"default"` mode.
+     *
+     * @remarks
+     * In `"default"` and `"strict"` modes, the registry is treated as
+     * immutable after the provider initializes. Updates should be shipped
+     * as part of a new app version and applied by remounting the provider.
+     * `"autoschema"` remains mutable so inferred schemas can be registered
+     * at runtime.
+     *
+     * @see {@link SchemaRegistry} - Interface the registry must implement
+     * @see {@link KeySchema} - Schema definition stored in the registry
+     */
+    schemaRegistry?: SchemaRegistry;
+}
+/**
+ * Controls how the provider enforces versioned schemas on stored values.
+ *
+ * - `"default"` — Schemas are optional. When a schema exists for the stored
+ *   version it is used for validation; otherwise the hook's `codec` option is
+ *   used directly with no validation. This is the recommended starting mode.
+ *
+ * - `"strict"` — Every read and write **must** have a registered schema for
+ *   the stored version. If no matching schema is found the value falls back
+ *   to `defaultValue` with a `SchemaError` (`SCHEMA_NOT_FOUND` on reads,
+ *   `WRITE_SCHEMA_REQUIRED` on writes).
+ *   When no schemas are registered and no explicit schema is provided, writes
+ *   fall back to a codec-encoded (v0) envelope.
+ *
+ * - `"autoschema"` — Like `"default"`, but when a key has **no** schema
+ *   registered at all, the library infers a JSON Schema at version 1 from the
+ *   first successfully decoded value and registers it via
+ *   `SchemaRegistry.registerSchema`. Subsequent reads/writes for that key
+ *   then behave as if the schema had been registered manually.
+ *
+ * @remarks
+ * In `"default"` and `"strict"` modes, registry lookups are cached under the
+ * assumption that the schema registry is immutable for the lifetime of the
+ * provider. If you need to update schemas, publish a new app version and
+ * remount the provider. `"autoschema"` does not assume immutability.
+ *
+ * @default "default"
+ *
+ * @see {@link SchemaRegistry} - Registry that stores schemas and migrations
+ * @see {@link KeySchema} - Individual schema definition
+ */
+type SchemaMode = "strict" | "default" | "autoschema";
+/**
+ * Schema definition for a single key at a specific version.
+ *
+ * Each registered schema binds a storage key + version number to a
+ * JSON Schema that validates the payload. Schemas are fully serializable
+ * (no functions).
+ *
+ * When the provider reads a value whose envelope version matches a
+ * registered schema, the payload is validated against the schema's
+ * JSON Schema definition.
+ *
+ * @example
+ * ```typescript
+ * const userSchemaV1: KeySchema = {
+ *   key: "user",
+ *   version: 1,
+ *   schema: {
+ *     type: "object",
+ *     properties: {
+ *       name: { type: "string" },
+ *     },
+ *     required: ["name"],
+ *   },
+ * };
+ * ```
+ *
+ * @see {@link SchemaRegistry} - Where schemas are registered and looked up
+ * @see {@link MigrationRule} - How values migrate between schema versions
+ * @see {@link JsonSchema} - The JSON Schema subset used for validation
+ */
+type KeySchema = {
+    /**
+     * The unprefixed storage key this schema applies to.
+     */
+    key: string;
+    /**
+     * The version number for this schema.
+     *
+     * Must be a non-negative integer. Any version (including `0`) is valid.
+     */
+    version: number;
+    /**
+     * JSON Schema that validates the payload at this version.
+     *
+     * Only the subset of JSON Schema keywords defined in {@link JsonSchema}
+     * are supported. An empty schema `{}` accepts any value.
+     */
+    schema: JsonSchema;
+};
+/**
+ * A single migration step that transforms data from one schema version to
+ * another, or normalizes data at the same version.
+ *
+ * Migration rules are composed into a {@link MigrationPath} by the
+ * {@link SchemaRegistry} to upgrade stored data across multiple versions in
+ * sequence (e.g. v1 -> v2 -> v3).
+ *
+ * When `fromVersion === toVersion`, the rule is a **write-time normalizer**
+ * that runs on every write to that version. This is useful for data
+ * normalization (trimming strings, clamping values, injecting defaults).
+ *
+ * @example
+ * ```typescript
+ * // Version upgrade migration
+ * const userV1ToV2: MigrationRule = {
+ *   key: "user",
+ *   fromVersion: 1,
+ *   toVersion: 2,
+ *   migrate: (v1) => {
+ *     const old = v1 as { name: string };
+ *     return { firstName: old.name, lastName: "" };
+ *   },
+ * };
+ *
+ * // Write-time normalizer (same version)
+ * const trimUserV2: MigrationRule = {
+ *   key: "user",
+ *   fromVersion: 2,
+ *   toVersion: 2,
+ *   migrate: (v) => {
+ *     const user = v as { firstName: string; lastName: string };
+ *     return { firstName: user.firstName.trim(), lastName: user.lastName.trim() };
+ *   },
+ * };
+ * ```
+ *
+ * @see {@link MigrationPath} - Ordered list of rules applied in sequence
+ * @see {@link SchemaRegistry.getMigrationPath} - How the path is resolved
+ * @see {@link SchemaRegistry.getWriteMigration} - How write-time normalizers are resolved
+ */
+type MigrationRule = {
+    /**
+     * The unprefixed storage key this rule applies to.
+     */
+    key: string;
+    /**
+     * The version the stored data is migrating **from**.
+     *
+     * Version `0` is allowed, enabling migrations from unversioned data.
+     */
+    fromVersion: number;
+    /**
+     * The version the stored data is migrating **to**.
+     *
+     * When equal to `fromVersion`, this rule is a write-time normalizer
+     * that runs on every write to that version.
+     */
+    toVersion: number;
+    /**
+     * Transformation function that converts data from `fromVersion`
+     * to `toVersion`.
+     *
+     * Receives the decoded value at `fromVersion` and must return
+     * the value in the shape expected by `toVersion`.
+     *
+     * @param value - The decoded value at `fromVersion`
+     * @returns The transformed value for `toVersion`
+     */
+    migrate: (value: unknown) => unknown;
+};
+/**
+ * An ordered sequence of {@link MigrationRule} steps that upgrades stored
+ * data from an older schema version to a newer one.
+ *
+ * The rules are applied in array order. Each step's output becomes the
+ * next step's input. After the final step the result is validated against
+ * the target schema and persisted back to storage so the migration only
+ * runs once per key.
+ *
+ * @see {@link MigrationRule} - Individual migration step
+ * @see {@link SchemaRegistry.getMigrationPath} - Resolves a path between versions
+ */
+type MigrationPath = MigrationRule[];
+/**
+ * Lookup and registration API for key schemas and migration paths.
+ *
+ * Implementations of this interface are passed to `MnemonicProvider` via the
+ * `schemaRegistry` option. The provider calls these methods at read and write
+ * time to resolve the correct JSON Schema and migration chain for each
+ * stored value.
+ *
+ * In `"default"` and `"strict"` modes, callers should treat registry contents
+ * as immutable after provider initialization. The hook caches lookups to keep
+ * read/write hot paths fast. `"autoschema"` remains mutable to support
+ * inferred schema registration.
+ *
+ * @example
+ * ```typescript
+ * const registry: SchemaRegistry = {
+ *   getSchema: (key, version) => schemas.get(`${key}@${version}`),
+ *   getLatestSchema: (key) => latestByKey.get(key),
+ *   getMigrationPath: (key, from, to) => buildPath(key, from, to),
+ *   getWriteMigration: (key, version) => normalizers.get(`${key}@${version}`),
+ *   registerSchema: (schema) => { schemas.set(`${schema.key}@${schema.version}`, schema); },
+ * };
+ *
+ * <MnemonicProvider namespace="app" schemaRegistry={registry} schemaMode="strict">
+ *   <App />
+ * </MnemonicProvider>
+ * ```
+ *
+ * @see {@link KeySchema} - Schema definition
+ * @see {@link MigrationPath} - Migration chain returned by `getMigrationPath`
+ * @see {@link SchemaMode} - How the provider uses the registry
+ */
+interface SchemaRegistry {
+    /**
+     * Look up the schema registered for a specific key and version.
+     *
+     * @param key - The unprefixed storage key
+     * @param version - The version number to look up
+     * @returns The matching schema, or `undefined` if none is registered
+     */
+    getSchema(key: string, version: number): KeySchema | undefined;
+    /**
+     * Look up the highest-version schema registered for a key.
+     *
+     * Used by the write path to determine which version to stamp on new
+     * values, and by the read path to detect when a migration is needed.
+     *
+     * @param key - The unprefixed storage key
+     * @returns The latest schema, or `undefined` if none is registered
+     */
+    getLatestSchema(key: string): KeySchema | undefined;
+    /**
+     * Resolve an ordered migration path between two versions of a key.
+     *
+     * Returns `null` when no contiguous path exists. The returned rules
+     * are applied in order to transform data from `fromVersion` to
+     * `toVersion`.
+     *
+     * @param key - The unprefixed storage key
+     * @param fromVersion - The stored data's current version
+     * @param toVersion - The target version to migrate to
+     * @returns An ordered array of migration rules, or `null`
+     */
+    getMigrationPath(key: string, fromVersion: number, toVersion: number): MigrationPath | null;
+    /**
+     * Look up a write-time normalizer for a specific key and version.
+     *
+     * A write-time normalizer is a {@link MigrationRule} where
+     * `fromVersion === toVersion`. It runs on every write to that version,
+     * transforming the value before storage. The normalized value is
+     * re-validated against the schema after transformation.
+     *
+     * Optional. When not implemented or returns `undefined`, no write-time
+     * normalization is applied.
+     *
+     * @param key - The unprefixed storage key
+     * @param version - The target schema version
+     * @returns The normalizer rule, or `undefined` if none is registered
+     */
+    getWriteMigration?(key: string, version: number): MigrationRule | undefined;
+    /**
+     * Register a new schema.
+     *
+     * Optional. Required when `schemaMode` is `"autoschema"` so the
+     * library can persist inferred schemas. Implementations should throw
+     * if a schema already exists for the same key + version with a
+     * conflicting definition.
+     *
+     * @param schema - The schema to register
+     */
+    registerSchema?(schema: KeySchema): void;
+}
+/**
+ * Storage interface compatible with localStorage and custom storage implementations.
+ *
+ * Defines the minimum contract required for a storage backend. Compatible with
+ * browser Storage API (localStorage, sessionStorage) and custom implementations
+ * for testing or alternative storage solutions.
+ *
+ * @remarks
+ * **Error handling contract**
+ *
+ * The library wraps every storage call in a try/catch. Errors are handled as
+ * follows:
+ *
+ * - **`DOMException` with `name === "QuotaExceededError"`** — Logged once via
+ *   `console.error` with the prefix `[Mnemonic] Storage quota exceeded`.
+ *   Squelched until a write succeeds, then the flag resets.
+ *
+ * - **Other `DOMException` errors (including `SecurityError`)** — Logged once
+ *   via `console.error` with the prefix `[Mnemonic] Storage access error`.
+ *   Squelched until any storage operation succeeds, then the flag resets.
+ *
+ * - **All other error types** — Silently suppressed.
+ *
+ * Custom `StorageLike` implementations are encouraged to throw `DOMException`
+ * for storage access failures so the library can surface diagnostics. Throwing
+ * non-`DOMException` errors is safe but results in silent suppression.
+ *
+ * In all error cases the library falls back to its in-memory cache, so
+ * components continue to function when the storage backend is unavailable.
+ *
+ * @example
+ * ```typescript
+ * // In-memory storage for testing
+ * const mockStorage: StorageLike = {
+ *   items: new Map<string, string>(),
+ *   getItem(key) { return this.items.get(key) ?? null; },
+ *   setItem(key, value) { this.items.set(key, value); },
+ *   removeItem(key) { this.items.delete(key); },
+ *   get length() { return this.items.size; },
+ *   key(index) {
+ *     return Array.from(this.items.keys())[index] ?? null;
+ *   }
+ * };
+ * ```
+ */
+type StorageLike = {
+    /**
+     * Retrieves the value associated with a key.
+     *
+     * @param key - The storage key to retrieve
+     * @returns The stored value as a string, or null if not found
+     */
+    getItem(key: string): string | null;
+    /**
+     * Stores a key-value pair.
+     *
+     * @param key - The storage key
+     * @param value - The string value to store
+     */
+    setItem(key: string, value: string): void;
+    /**
+     * Removes a key-value pair from storage.
+     *
+     * @param key - The storage key to remove
+     */
+    removeItem(key: string): void;
+    /**
+     * Returns the key at the specified index in storage.
+     *
+     * Optional method for enumeration support.
+     *
+     * @param index - The numeric index
+     * @returns The key at the given index, or null if out of bounds
+     */
+    key?(index: number): string | null;
+    /**
+     * The number of items currently stored.
+     *
+     * Optional property for enumeration support.
+     */
+    readonly length?: number;
+    /**
+     * Subscribe to notifications when data changes externally.
+     *
+     * localStorage has built-in cross-tab notification via the browser's
+     * native `storage` event (used by the `listenCrossTab` hook option).
+     * Non-localStorage backends (IndexedDB, custom stores, etc.) lack this
+     * built-in mechanism. Implementing `onExternalChange` allows those
+     * adapters to provide equivalent cross-tab synchronization through
+     * their own transport (e.g., BroadcastChannel).
+     *
+     * The callback accepts an optional `changedKeys` parameter:
+     * - `callback()` or `callback(undefined)` triggers a blanket reload
+     *   of all actively subscribed keys.
+     * - `callback(["ns.key1", "ns.key2"])` reloads only the specified
+     *   fully-qualified keys, which is more efficient when the adapter
+     *   knows exactly which keys changed.
+     * - `callback([])` is a no-op.
+     *
+     * On a blanket reload the provider re-reads all actively subscribed
+     * keys from the storage backend and emits change notifications for
+     * any whose values differ from the cache.
+     *
+     * @param callback - Invoked when external data changes
+     * @returns An unsubscribe function that removes the callback
+     */
+    onExternalChange?: (callback: (changedKeys?: string[]) => void) => () => void;
+};
+/**
+ * Configuration options for the useMnemonicKey hook.
+ *
+ * These options control how a value is persisted, decoded, and
+ * synchronized across the application.
+ *
+ * @template T - The TypeScript type of the stored value
+ *
+ * @example
+ * ```typescript
+ * const { value, set } = useMnemonicKey<User>('currentUser', {
+ *   defaultValue: { name: 'Guest', id: null },
+ *   onMount: (user) => console.log('Loaded user:', user),
+ *   onChange: (current, previous) => {
+ *     console.log('User changed from', previous, 'to', current);
+ *   },
+ *   listenCrossTab: true
+ * });
+ * ```
+ */
+type UseMnemonicKeyOptions<T> = {
+    /**
+     * Default value to use when no stored value exists, or when decoding/validation fails.
+     *
+     * Can be a literal value or a factory function that returns the default.
+     * Factory functions receive an optional error argument describing why the
+     * fallback is being used:
+     *
+     * - `undefined` — Nominal path: no value exists in storage for this key.
+     * - `CodecError` — The stored value could not be decoded by the codec.
+     * - `SchemaError` — A schema, migration, or validation issue occurred
+     *   (e.g. missing schema, failed migration, JSON Schema validation failure).
+     *
+     * Static (non-function) default values ignore the error entirely.
+     *
+     * @remarks
+     * If a factory function is defined inline, it creates a new reference on
+     * every render, which forces internal memoization to recompute. For best
+     * performance, define the factory at module level or wrap it in `useCallback`:
+     *
+     * ```typescript
+     * // Module-level (stable reference, preferred)
+     * const getDefault = (error?: CodecError | SchemaError) => {
+     *     if (error) console.warn('Fallback:', error.message);
+     *     return { count: 0 };
+     * };
+     *
+     * // Or with useCallback inside a component
+     * const getDefault = useCallback(
+     *     (error?: CodecError | SchemaError) => ({ count: 0 }),
+     *     [],
+     * );
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Static default
+     * defaultValue: { count: 0 }
+     *
+     * // Factory with no error handling
+     * defaultValue: () => ({ timestamp: Date.now() })
+     *
+     * // Error-aware factory
+     * defaultValue: (error) => {
+     *     if (error instanceof CodecError) {
+     *         console.error('Corrupt data:', error.message);
+     *     }
+     *     if (error instanceof SchemaError) {
+     *         console.warn('Schema issue:', error.code, error.message);
+     *     }
+     *     return { count: 0 };
+     * }
+     * ```
+     */
+    defaultValue: T | ((error?: CodecError | SchemaError) => T);
+    /**
+     * Codec for encoding and decoding values to/from storage.
+     *
+     * Determines how the typed value is serialized to a string and
+     * deserialized back. Defaults to JSONCodec if not specified.
+     *
+     * Using a codec is a low-level option that bypasses JSON Schema
+     * validation. Schema-managed keys store JSON values directly and
+     * are validated against their registered JSON Schema.
+     *
+     * @default JSONCodec
+     *
+     * @example
+     * ```typescript
+     * // Custom codec for dates
+     * codec: createCodec(
+     *   (date) => date.toISOString(),
+     *   (str) => new Date(str)
+     * )
+     * ```
+     */
+    codec?: Codec<T>;
+    /**
+     * Callback invoked once when the hook is first mounted.
+     *
+     * Receives the initial value (either from storage or the default).
+     * Useful for triggering side effects based on the loaded state.
+     *
+     * @param value - The initial value loaded on mount
+     *
+     * @example
+     * ```typescript
+     * onMount: (theme) => {
+     *   document.body.className = theme;
+     *   console.log('Theme loaded:', theme);
+     * }
+     * ```
+     */
+    onMount?: (value: T) => void;
+    /**
+     * Callback invoked whenever the value changes.
+     *
+     * Receives both the new value and the previous value. This is called
+     * for all changes, including those triggered by other components or tabs.
+     *
+     * @param value - The new current value
+     * @param prev - The previous value
+     *
+     * @example
+     * ```typescript
+     * onChange: (newTheme, oldTheme) => {
+     *   document.body.classList.remove(oldTheme);
+     *   document.body.classList.add(newTheme);
+     *   console.log(`Theme changed: ${oldTheme} -> ${newTheme}`);
+     * }
+     * ```
+     */
+    onChange?: (value: T, prev: T) => void;
+    /**
+     * Enable listening for changes from other browser tabs.
+     *
+     * When true, uses the browser's `storage` event to detect changes
+     * made to localStorage in other tabs and synchronizes them to this component.
+     *
+     * Only effective when using localStorage as the storage backend.
+     *
+     * @default false
+     *
+     * @example
+     * ```typescript
+     * // Enable cross-tab sync for shared state
+     * listenCrossTab: true
+     * ```
+     *
+     * @remarks
+     * The `storage` event only fires for changes made in *other* tabs,
+     * not the current tab. Changes within the same tab are synchronized
+     * automatically via React's state management.
+     */
+    listenCrossTab?: boolean;
+    /**
+     * Optional schema controls for this key.
+     *
+     * Allows overriding the version written by the `set` function. When
+     * omitted, the library writes using the highest registered schema for
+     * this key, or version `0` when no schemas are registered.
+     *
+     * @example
+     * ```typescript
+     * // Pin writes to schema version 2 even if version 3 exists
+     * const { value, set } = useMnemonicKey("user", {
+     *   defaultValue: { name: "" },
+     *   schema: { version: 2 },
+     * });
+     * ```
+     */
+    schema?: {
+        /**
+         * Explicit schema version to use when writing values.
+         *
+         * When set, the `set` and `reset` functions encode using the
+         * schema registered at this version instead of the latest. Useful
+         * during gradual rollouts where not all consumers have been
+         * updated yet.
+         *
+         * Must reference a version that exists in the `SchemaRegistry`.
+         * If not found the write falls back to the latest schema (default
+         * mode) or fails with a `SchemaError` (strict mode).
+         */
+        version?: number;
+    };
+};
+
+/**
+ * Props for the MnemonicProvider component.
+ *
+ * Extends MnemonicProviderOptions with required children prop.
+ *
+ * @see {@link MnemonicProviderOptions} - Configuration options
+ * @see {@link MnemonicProvider} - Provider component
+ */
+interface MnemonicProviderProps extends MnemonicProviderOptions {
+    /**
+     * React children to render within the provider.
+     */
+    children: ReactNode;
+}
+/**
+ * React Context provider for namespace-isolated persistent state.
+ *
+ * Creates a scoped storage environment where all keys are automatically prefixed
+ * with the namespace to prevent collisions. Implements an in-memory cache with
+ * read-through behavior to the underlying storage backend (localStorage by default).
+ *
+ * This provider must wrap any components that use `useMnemonicKey`. Multiple
+ * providers with different namespaces can coexist in the same application.
+ *
+ * @param props - Provider configuration and children
+ * @param props.children - React children to render within the provider
+ * @param props.namespace - Unique namespace for isolating storage keys
+ * @param props.storage - Optional custom storage backend (defaults to localStorage)
+ * @param props.enableDevTools - Enable DevTools debugging interface (defaults to false)
+ * @param props.schemaMode - Schema enforcement mode (default: "default")
+ * @param props.schemaRegistry - Optional schema registry for storing schemas and migrations
+ *
+ * @example
+ * ```tsx
+ * // Basic usage with default settings
+ * function App() {
+ *   return (
+ *     <MnemonicProvider namespace="myApp">
+ *       <MyComponents />
+ *     </MnemonicProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom storage backend
+ * function App() {
+ *   return (
+ *     <MnemonicProvider
+ *       namespace="myApp"
+ *       storage={window.sessionStorage}
+ *     >
+ *       <MyComponents />
+ *     </MnemonicProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With DevTools enabled (development only)
+ * function App() {
+ *   return (
+ *     <MnemonicProvider
+ *       namespace="myApp"
+ *       enableDevTools={process.env.NODE_ENV === 'development'}
+ *     >
+ *       <MyComponents />
+ *     </MnemonicProvider>
+ *   );
+ * }
+ *
+ * // 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')
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Multiple providers with different namespaces
+ * function App() {
+ *   return (
+ *     <MnemonicProvider namespace="user-prefs">
+ *       <UserSettings />
+ *       <MnemonicProvider namespace="app-state">
+ *         <Dashboard />
+ *       </MnemonicProvider>
+ *     </MnemonicProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @remarks
+ * - Creates a stable store instance that only recreates when namespace, storage, or enableDevTools change
+ * - All storage operations are cached in memory for fast reads
+ * - Storage failures are handled gracefully (logged but not thrown)
+ * - In SSR environments, the provider works but no storage persistence occurs
+ * - The store implements React's useSyncExternalStore contract for efficient updates
+ *
+ * @see {@link useMnemonicKey} - Hook for using persistent state
+ * @see {@link MnemonicProviderOptions} - Configuration options
+ */
+declare function MnemonicProvider({ children, namespace, storage, enableDevTools, schemaMode, schemaRegistry, }: MnemonicProviderProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * React hook for persistent, type-safe state management.
+ *
+ * Creates a stateful value that persists to storage and synchronizes across
+ * components. Works like `useState` but with persistent storage, automatic
+ * encoding/decoding, JSON Schema validation, and optional cross-tab synchronization.
+ *
+ * Must be used within a `MnemonicProvider`. Uses React's `useSyncExternalStore`
+ * internally for efficient, tearing-free state synchronization.
+ *
+ * @template T - The TypeScript type of the stored value
+ *
+ * @param key - The storage key (unprefixed, namespace is applied automatically)
+ * @param options - Configuration options controlling persistence, encoding, and behavior
+ *
+ * @returns Object with the current value and methods to update it
+ *
+ * @throws {Error} If used outside of a MnemonicProvider
+ */
+declare function useMnemonicKey<T>(key: string, options: UseMnemonicKeyOptions<T>): {
+    /** Current decoded value, or the default when the key is absent or invalid. */
+    value: T;
+    /** Persist a new value (direct or updater function). */
+    set: (next: T | ((cur: T) => T)) => void;
+    /** Reset to `defaultValue` and persist it. */
+    reset: () => void;
+    /** Delete the key from storage entirely. */
+    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 };