react-mnemonic 1.2.1-beta1.0 → 1.4.0

package/dist/index.js

@@ -1,1032 +1,1312 @@
-import { createContext, useMemo, useEffect, useCallback, useContext, useState, useSyncExternalStore, useRef } from 'react';
+import { createContext, useRef, useEffect, useMemo, useCallback, useContext, createElement, useState, useSyncExternalStore } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
 // src/Mnemonic/provider.tsx
 
-// src/Mnemonic/runtime.ts
-function getGlobalProcess() {
-  return globalThis.process;
-}
-function getRuntimeNodeEnv() {
-  const runtimeProcess = getGlobalProcess();
-  if (runtimeProcess?.env?.NODE_ENV !== void 0) {
-    return runtimeProcess.env.NODE_ENV;
+// src/Mnemonic/codecs.ts
+var CodecError = class extends Error {
+  /**
+   * Creates a new CodecError.
+   *
+   * @param message - Human-readable error description
+   * @param cause - Optional underlying error that caused this failure
+   */
+  constructor(message, cause) {
+    super(message);
+    this.name = "CodecError";
+    this.cause = cause;
+    Object.setPrototypeOf(this, new.target.prototype);
   }
-  return void 0;
-}
-function getNativeBrowserStorages() {
-  const globalWindow = globalThis.window;
-  if (!globalWindow) return [];
-  const storages = [];
-  const addStorage = (getter) => {
-    try {
-      storages.push(getter());
-    } catch {
-    }
-  };
-  addStorage(() => globalWindow.localStorage);
-  addStorage(() => globalWindow.sessionStorage);
-  return storages;
+};
+var JSONCodec = {
+  encode: (value) => JSON.stringify(value),
+  decode: (encoded) => JSON.parse(encoded)
+};
+function createCodec(encode, decode) {
+  return { encode, decode };
 }
-var MnemonicContext = createContext(null);
-function useMnemonic() {
-  const context = useContext(MnemonicContext);
-  if (!context) {
-    throw new Error("useMnemonic must be used within a MnemonicProvider");
+
+// src/Mnemonic/json-schema.ts
+function matchesType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    default:
+      return false;
   }
-  return context;
 }
-function defaultBrowserStorage() {
-  const globalWindow = globalThis.window;
-  if (globalWindow === void 0) return void 0;
-  try {
-    return globalWindow.localStorage;
-  } catch {
-    return void 0;
+function jsonDeepEqualArray(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!jsonDeepEqual(a[i], b[i])) return false;
   }
+  return true;
 }
-function detectEnumerableStorage(storage) {
-  if (!storage) return false;
-  try {
-    return typeof storage.length === "number" && typeof storage.key === "function";
-  } catch {
-    return false;
+function jsonDeepEqualObject(a, b) {
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!objectHasOwn(b, key)) return false;
+    if (!jsonDeepEqual(a[key], b[key])) return false;
   }
+  return true;
 }
-function isProductionRuntime() {
-  const env = getRuntimeNodeEnv();
-  if (env === void 0) {
-    return true;
+function jsonDeepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) return false;
+    return jsonDeepEqualArray(a, b);
   }
-  return env === "production";
+  if (typeof a === "object") {
+    if (Array.isArray(b)) return false;
+    return jsonDeepEqualObject(a, b);
+  }
+  return false;
 }
-function weakRefConstructor() {
-  const ctor = globalThis.WeakRef;
-  return typeof ctor === "function" ? ctor : null;
+var compiledCache = /* @__PURE__ */ new WeakMap();
+function compileSchema(schema) {
+  const cached = compiledCache.get(schema);
+  if (cached) return cached;
+  const compiled = buildValidator(schema);
+  compiledCache.set(schema, compiled);
+  return compiled;
 }
-function hasFinalizationRegistry() {
-  return typeof globalThis.FinalizationRegistry === "function";
+function isJsonPrimitive(value) {
+  return value === null || typeof value !== "object";
 }
-function isPromiseLike(value) {
-  if (value == null) return false;
-  if (typeof value !== "object" && typeof value !== "function") return false;
-  return typeof value.then === "function";
+function isJsonObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getCrossTabSyncMode(requestedStorage, activeStorage) {
-  const isExplicitNativeBrowserStorage = activeStorage !== void 0 && requestedStorage !== void 0 && getNativeBrowserStorages().includes(activeStorage);
-  if (requestedStorage === void 0 && activeStorage !== void 0 || isExplicitNativeBrowserStorage) {
-    return "browser-storage-event";
-  }
-  if (typeof activeStorage?.onExternalChange === "function") {
-    return "custom-external-change";
+function objectHasOwn(value, property) {
+  const hasOwn = Object.hasOwn;
+  if (typeof hasOwn === "function") {
+    return hasOwn(value, property);
   }
-  return "none";
-}
-function getDevToolsWindow() {
-  return globalThis.window;
+  return Object.getOwnPropertyDescriptor(value, property) !== void 0;
 }
-function sanitizeDevToolsRoot(root) {
-  const reserved = /* @__PURE__ */ new Set(["providers", "resolve", "list", "capabilities", "__meta"]);
-  for (const key of Object.keys(root)) {
-    if (reserved.has(key)) continue;
-    const descriptor = Object.getOwnPropertyDescriptor(root, key);
-    if (descriptor && !descriptor.configurable) continue;
-    try {
-      delete root[key];
-    } catch {
+function buildValidator(schema) {
+  const typeStep = buildTypeValidationStep(schema);
+  const validationSteps = [
+    buildEnumValidationStep(schema),
+    buildConstValidationStep(schema),
+    buildNumberValidationStep(schema),
+    buildStringValidationStep(schema),
+    buildObjectValidationStep(schema),
+    buildArrayValidationStep(schema)
+  ].filter((step) => step !== null);
+  if (typeStep === null && validationSteps.length === 0) {
+    return (_value, _path) => [];
+  }
+  return (value, path = "") => {
+    const errors = [];
+    if (typeStep && !typeStep(value, path, errors)) {
+      return errors;
     }
+    for (const step of validationSteps) {
+      step(value, path, errors);
+    }
+    return errors;
+  };
+}
+function buildTypeValidationStep(schema) {
+  if (schema.type === void 0) {
+    return null;
   }
+  const resolvedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
+  const typeLabel = JSON.stringify(schema.type);
+  return (value, path, errors) => {
+    if (resolvedTypes.some((type) => matchesType(value, type))) {
+      return true;
+    }
+    errors.push({
+      path,
+      message: `Expected type ${typeLabel}, got ${jsonTypeLabel(value)}`,
+      keyword: "type"
+    });
+    return false;
+  };
 }
-function ensureDevToolsRoot(enableDevTools) {
-  if (!enableDevTools) return null;
-  const globalWindow = getDevToolsWindow();
-  if (!globalWindow) return null;
-  const weakRefSupported = weakRefConstructor() !== null;
-  const finalizationRegistrySupported = hasFinalizationRegistry();
-  const existing = globalWindow.__REACT_MNEMONIC_DEVTOOLS__;
-  const root = existing && typeof existing === "object" ? existing : {};
-  sanitizeDevToolsRoot(root);
-  if (!root.providers || typeof root.providers !== "object") {
-    root.providers = {};
+function buildEnumValidationStep(schema) {
+  if (schema.enum === void 0) {
+    return null;
   }
-  if (!root.capabilities || typeof root.capabilities !== "object") {
-    root.capabilities = {};
+  const enumPrimitiveSet = new Set(schema.enum.filter((member) => isJsonPrimitive(member)));
+  const enumComplexMembers = schema.enum.filter((member) => !isJsonPrimitive(member));
+  return (value, path, errors) => {
+    const primitiveMatch = isJsonPrimitive(value) && enumPrimitiveSet.has(value);
+    const complexMatch = !primitiveMatch && enumComplexMembers.some((entry) => jsonDeepEqual(value, entry));
+    if (primitiveMatch || complexMatch) {
+      return;
+    }
+    errors.push({
+      path,
+      message: `Value does not match any enum member`,
+      keyword: "enum"
+    });
+  };
+}
+function buildConstValidationStep(schema) {
+  if (!("const" in schema)) {
+    return null;
   }
-  const capabilities = root.capabilities;
-  capabilities.weakRef = weakRefSupported;
-  capabilities.finalizationRegistry = finalizationRegistrySupported;
-  if (!root.__meta || typeof root.__meta !== "object") {
-    root.__meta = {
-      version: 0,
-      lastUpdated: Date.now(),
-      lastChange: ""
-    };
+  return (value, path, errors) => {
+    if (jsonDeepEqual(value, schema.const)) {
+      return;
+    }
+    errors.push({
+      path,
+      message: `Value does not match const`,
+      keyword: "const"
+    });
+  };
+}
+function buildNumberValidationStep(schema) {
+  const hasMinimum = schema.minimum !== void 0;
+  const hasMaximum = schema.maximum !== void 0;
+  const hasExMin = schema.exclusiveMinimum !== void 0;
+  const hasExMax = schema.exclusiveMaximum !== void 0;
+  if (!hasMinimum && !hasMaximum && !hasExMin && !hasExMax) {
+    return null;
   }
-  const meta = root.__meta;
-  if (typeof meta.version !== "number" || !Number.isFinite(meta.version)) {
-    meta.version = 0;
+  const minimum = schema.minimum;
+  const maximum = schema.maximum;
+  const exMin = schema.exclusiveMinimum;
+  const exMax = schema.exclusiveMaximum;
+  return (value, path, errors) => {
+    if (typeof value !== "number") {
+      return;
+    }
+    if (hasMinimum && value < minimum) {
+      errors.push({
+        path,
+        message: `Value ${value} is less than minimum ${minimum}`,
+        keyword: "minimum"
+      });
+    }
+    if (hasMaximum && value > maximum) {
+      errors.push({
+        path,
+        message: `Value ${value} is greater than maximum ${maximum}`,
+        keyword: "maximum"
+      });
+    }
+    if (hasExMin && value <= exMin) {
+      errors.push({
+        path,
+        message: `Value ${value} is not greater than exclusiveMinimum ${exMin}`,
+        keyword: "exclusiveMinimum"
+      });
+    }
+    if (hasExMax && value >= exMax) {
+      errors.push({
+        path,
+        message: `Value ${value} is not less than exclusiveMaximum ${exMax}`,
+        keyword: "exclusiveMaximum"
+      });
+    }
+  };
+}
+function buildStringValidationStep(schema) {
+  const hasMinLength = schema.minLength !== void 0;
+  const hasMaxLength = schema.maxLength !== void 0;
+  if (!hasMinLength && !hasMaxLength) {
+    return null;
   }
-  if (typeof meta.lastUpdated !== "number" || !Number.isFinite(meta.lastUpdated)) {
-    meta.lastUpdated = Date.now();
+  const minLength = schema.minLength;
+  const maxLength = schema.maxLength;
+  return (value, path, errors) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    if (hasMinLength && value.length < minLength) {
+      errors.push({
+        path,
+        message: `String length ${value.length} is less than minLength ${minLength}`,
+        keyword: "minLength"
+      });
+    }
+    if (hasMaxLength && value.length > maxLength) {
+      errors.push({
+        path,
+        message: `String length ${value.length} is greater than maxLength ${maxLength}`,
+        keyword: "maxLength"
+      });
+    }
+  };
+}
+function buildObjectValidationStep(schema) {
+  const requiredKeys = schema.required ?? [];
+  const propertyValidators = schema.properties ? Object.entries(schema.properties).map(([name, propertySchema]) => [
+    name,
+    compileSchema(propertySchema)
+  ]) : null;
+  const checkAdditional = schema.additionalProperties !== void 0 && schema.additionalProperties !== true;
+  const additionalIsFalse = schema.additionalProperties === false;
+  const additionalValidator = checkAdditional && !additionalIsFalse ? compileSchema(schema.additionalProperties) : null;
+  const definedPropKeys = checkAdditional ? new Set(Object.keys(schema.properties ?? {})) : null;
+  const objectValidationSteps = [];
+  if (requiredKeys.length > 0) {
+    objectValidationSteps.push(createRequiredPropertyStep(requiredKeys));
   }
-  if (typeof meta.lastChange !== "string") {
-    meta.lastChange = "";
+  if (propertyValidators !== null) {
+    objectValidationSteps.push(createDeclaredPropertyStep(propertyValidators));
   }
-  const providers = root.providers;
-  if (typeof root.resolve !== "function") {
-    root.resolve = (namespace) => {
-      const entry = providers[namespace];
-      if (!entry || typeof entry.weakRef?.deref !== "function") return null;
-      const live = entry.weakRef.deref();
-      if (live) {
-        entry.lastSeenAt = Date.now();
-        entry.staleSince = null;
-        return live;
-      }
-      entry.staleSince ?? (entry.staleSince = Date.now());
-      return null;
-    };
+  if (checkAdditional) {
+    objectValidationSteps.push(
+      createAdditionalPropertyStep({
+        additionalIsFalse,
+        additionalValidator,
+        definedPropKeys: definedPropKeys ?? /* @__PURE__ */ new Set()
+      })
+    );
   }
-  if (typeof root.list !== "function") {
-    root.list = () => Object.entries(providers).map(([namespace, entry]) => {
-      const live = typeof entry.weakRef?.deref === "function" ? entry.weakRef.deref() : void 0;
-      const available = Boolean(live);
-      if (available) {
-        entry.lastSeenAt = Date.now();
-        entry.staleSince = null;
-      } else {
-        entry.staleSince ?? (entry.staleSince = Date.now());
-      }
-      return {
-        namespace,
-        available,
-        registeredAt: entry.registeredAt,
-        lastSeenAt: entry.lastSeenAt,
-        staleSince: entry.staleSince
-      };
-    }).sort((left, right) => left.namespace.localeCompare(right.namespace));
+  if (objectValidationSteps.length === 0) {
+    return null;
   }
-  globalWindow.__REACT_MNEMONIC_DEVTOOLS__ = root;
-  return root;
+  return (value, path, errors) => {
+    if (!isJsonObjectRecord(value)) {
+      return;
+    }
+    for (const step of objectValidationSteps) {
+      step(value, path, errors);
+    }
+  };
 }
-function bumpDevToolsVersion(root, namespace, reason) {
-  if (!root) return;
-  root.__meta.version += 1;
-  root.__meta.lastUpdated = Date.now();
-  root.__meta.lastChange = `${namespace}.${reason}`;
+function createRequiredPropertyStep(requiredKeys) {
+  return (value, path, errors) => {
+    for (const requiredKey of requiredKeys) {
+      if (objectHasOwn(value, requiredKey)) {
+        continue;
+      }
+      errors.push({
+        path,
+        message: `Missing required property "${requiredKey}"`,
+        keyword: "required"
+      });
+    }
+  };
 }
-function decodeDevToolsValue(raw) {
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return raw;
-  }
+function createDeclaredPropertyStep(propertyValidators) {
+  return (value, path, errors) => {
+    for (const [propertyName, validator] of propertyValidators) {
+      if (!objectHasOwn(value, propertyName)) {
+        continue;
+      }
+      errors.push(...validator(value[propertyName], `${path}/${propertyName}`));
+    }
+  };
 }
-function readStorageRaw(storage, storageKey, callbacks) {
-  if (!storage) return null;
-  try {
-    const raw = storage.getItem(storageKey);
-    if (isPromiseLike(raw)) {
-      callbacks.onAsyncViolation("getItem", raw);
-      return null;
+function createAdditionalPropertyStep({
+  additionalIsFalse,
+  additionalValidator,
+  definedPropKeys
+}) {
+  return (value, path, errors) => {
+    for (const objectKey of Object.keys(value)) {
+      if (definedPropKeys.has(objectKey)) {
+        continue;
+      }
+      if (additionalIsFalse) {
+        errors.push({
+          path,
+          message: `Additional property "${objectKey}" is not allowed`,
+          keyword: "additionalProperties"
+        });
+        continue;
+      }
+      errors.push(...additionalValidator(value[objectKey], `${path}/${objectKey}`));
     }
-    callbacks.onAccessSuccess();
-    return raw;
-  } catch (error) {
-    callbacks.onAccessError(error);
-    return null;
-  }
+  };
 }
-function enumerateNamespaceKeys(storage, prefix, callbacks) {
-  if (!storage) {
-    return [];
+function buildArrayValidationStep(schema) {
+  const hasMinItems = schema.minItems !== void 0;
+  const hasMaxItems = schema.maxItems !== void 0;
+  const itemsValidator = schema.items ? compileSchema(schema.items) : null;
+  if (!hasMinItems && !hasMaxItems && itemsValidator === null) {
+    return null;
   }
-  const keys = [];
-  try {
-    const storageLength = storage.length;
-    const getStorageKey = storage.key;
-    if (typeof storageLength !== "number" || typeof getStorageKey !== "function") {
-      return [];
+  const minItems = schema.minItems;
+  const maxItems = schema.maxItems;
+  return (value, path, errors) => {
+    if (!Array.isArray(value)) {
+      return;
     }
-    for (let index = 0; index < storageLength; index++) {
-      const fullKey = getStorageKey.call(storage, index);
-      if (!fullKey?.startsWith(prefix)) continue;
-      keys.push(fullKey.slice(prefix.length));
+    if (hasMinItems && value.length < minItems) {
+      errors.push({
+        path,
+        message: `Array length ${value.length} is less than minItems ${minItems}`,
+        keyword: "minItems"
+      });
     }
-    callbacks.onAccessSuccess();
-  } catch (error) {
-    callbacks.onAccessError(error);
-  }
-  return keys;
+    if (hasMaxItems && value.length > maxItems) {
+      errors.push({
+        path,
+        message: `Array length ${value.length} is greater than maxItems ${maxItems}`,
+        keyword: "maxItems"
+      });
+    }
+    if (itemsValidator === null) {
+      return;
+    }
+    for (const [index, item] of value.entries()) {
+      errors.push(...itemsValidator(item, `${path}/${index}`));
+    }
+  };
 }
-function syncCacheEntryFromStorage({
-  key,
-  storageKey,
-  storage,
-  cache,
-  emit,
-  callbacks
-}) {
-  const fresh = readStorageRaw(storage, storageKey, callbacks);
-  const cached = cache.get(key) ?? null;
-  if (fresh === cached) {
-    return false;
+function validateJsonSchema(value, schema, path = "") {
+  const compiled = compileSchema(schema);
+  return compiled(value, path);
+}
+function jsonTypeLabel(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function inferJsonSchema(sample) {
+  if (sample === null) return { type: "null" };
+  if (Array.isArray(sample)) return { type: "array" };
+  switch (typeof sample) {
+    case "string":
+      return { type: "string" };
+    case "number":
+      return { type: "number" };
+    case "boolean":
+      return { type: "boolean" };
+    case "object":
+      return { type: "object" };
+    default:
+      return {};
   }
-  cache.set(key, fresh);
-  emit(key);
-  return true;
 }
-function reloadNamedKeysFromStorage({
-  changedKeys,
-  prefix,
-  storage,
-  listeners,
-  cache,
-  emit,
-  callbacks
-}) {
-  let changed = false;
-  for (const fullStorageKey of changedKeys) {
-    if (!fullStorageKey.startsWith(prefix)) continue;
-    const key = fullStorageKey.slice(prefix.length);
-    const listenerSet = listeners.get(key);
-    if (listenerSet && listenerSet.size > 0) {
-      changed = syncCacheEntryFromStorage({
-        key,
-        storageKey: fullStorageKey,
-        storage,
-        cache,
-        emit,
-        callbacks
-      }) || changed;
-      continue;
+
+// src/Mnemonic/schema.ts
+var SchemaError = class extends Error {
+  /**
+   * Creates a new SchemaError.
+   *
+   * @param code - Machine-readable failure category
+   * @param message - Human-readable error description
+   * @param cause - Optional underlying error
+   */
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "SchemaError";
+    this.code = code;
+    this.cause = cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/Mnemonic/persistence-shared.ts
+function objectHasOwn2(value, property) {
+  const hasOwn = Object.hasOwn;
+  if (typeof hasOwn === "function") {
+    return hasOwn(value, property);
+  }
+  return Object.getOwnPropertyDescriptor(value, property) !== void 0;
+}
+function serializeEnvelope(version, payload) {
+  return JSON.stringify({
+    version,
+    payload
+  });
+}
+function parseEnvelope(key, rawText) {
+  try {
+    const parsed = JSON.parse(rawText);
+    if (typeof parsed !== "object" || parsed == null || !Number.isInteger(parsed.version) || parsed.version < 0 || !objectHasOwn2(parsed, "payload")) {
+      throw new SchemaError("INVALID_ENVELOPE", `Invalid envelope for key "${key}"`);
     }
-    if (cache.has(key)) {
-      cache.delete(key);
+    return parsed;
+  } catch (error) {
+    if (error instanceof SchemaError) {
+      throw error;
     }
+    throw new SchemaError("INVALID_ENVELOPE", `Invalid envelope for key "${key}"`, error);
   }
-  return changed;
 }
-function reloadSubscribedKeysFromStorage({
-  prefix,
-  storage,
-  listeners,
-  cache,
-  emit,
-  callbacks
+function decodeStringPayload(key, payload, codec) {
+  try {
+    return codec.decode(payload);
+  } catch (error) {
+    throw error instanceof CodecError ? error : new CodecError(`Codec decode failed for key "${key}"`, error);
+  }
+}
+function validateAgainstSchema(key, value, jsonSchema) {
+  const errors = validateJsonSchema(value, jsonSchema);
+  if (errors.length === 0) {
+    return;
+  }
+  const message = errors.map((entry) => `${entry.path || "/"}: ${entry.message}`).join("; ");
+  throw new SchemaError("TYPE_MISMATCH", `Schema validation failed for key "${key}": ${message}`);
+}
+function getLatestSchema(schemaRegistry, key) {
+  return schemaRegistry?.getLatestSchema(key);
+}
+function getSchemaForVersion(schemaRegistry, key, version) {
+  return schemaRegistry?.getSchema(key, version);
+}
+function getMigrationPath(schemaRegistry, key, fromVersion, toVersion) {
+  return schemaRegistry?.getMigrationPath(key, fromVersion, toVersion) ?? null;
+}
+function resolveTargetWriteSchema({
+  key,
+  explicitVersion,
+  schemaMode,
+  schemaRegistry
 }) {
-  let changed = false;
-  for (const [key, listenerSet] of listeners) {
-    if (listenerSet.size === 0) continue;
-    changed = syncCacheEntryFromStorage({
-      key,
-      storageKey: `${prefix}${key}`,
-      storage,
-      cache,
-      emit,
-      callbacks
-    }) || changed;
+  const latestSchema = getLatestSchema(schemaRegistry, key);
+  if (explicitVersion === void 0) {
+    return latestSchema;
   }
-  for (const key of cache.keys()) {
-    const listenerSet = listeners.get(key);
-    if (listenerSet && listenerSet.size > 0) continue;
-    cache.delete(key);
+  const explicitSchema = getSchemaForVersion(schemaRegistry, key, explicitVersion);
+  if (explicitSchema) {
+    return explicitSchema;
   }
-  return changed;
+  return schemaMode === "strict" ? void 0 : latestSchema;
 }
-function createDevToolsProviderApi({
-  store,
-  dump,
-  keys,
-  readThrough,
-  writeRaw,
-  removeRaw
+function encodePersistedValueForWrite({
+  key,
+  nextValue,
+  codec,
+  explicitVersion,
+  schemaMode,
+  schemaRegistry
 }) {
+  const targetSchema = resolveTargetWriteSchema({
+    key,
+    explicitVersion,
+    schemaMode,
+    schemaRegistry
+  });
+  if (!targetSchema) {
+    if (explicitVersion !== void 0 && schemaMode === "strict") {
+      throw new SchemaError("WRITE_SCHEMA_REQUIRED", `Write requires schema for key "${key}" in strict mode`);
+    }
+    return serializeEnvelope(0, codec.encode(nextValue));
+  }
+  let valueToStore = nextValue;
+  const writeMigration = schemaRegistry?.getWriteMigration?.(key, targetSchema.version);
+  if (writeMigration) {
+    try {
+      valueToStore = writeMigration.migrate(valueToStore);
+    } catch (error) {
+      throw error instanceof SchemaError ? error : new SchemaError("MIGRATION_FAILED", `Write-time migration failed for key "${key}"`, error);
+    }
+  }
+  validateAgainstSchema(key, valueToStore, targetSchema.schema);
+  return serializeEnvelope(targetSchema.version, valueToStore);
+}
+
+// src/Mnemonic/optional-bridge-adapter.ts
+function resolveOptionalDefaultValue(defaultValue) {
+  return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+}
+function getSchemaCapabilities(schemaRegistry) {
+  return schemaRegistry !== void 0;
+}
+function buildFallbackResult(options) {
   return {
-    getStore: () => store,
-    dump: () => {
-      const data = dump();
-      console.table(
-        Object.entries(data).map(([key, value]) => ({
-          key,
-          value,
-          decoded: decodeDevToolsValue(value)
-        }))
-      );
-      return data;
-    },
-    get: (key) => {
-      const raw = readThrough(key);
-      if (raw == null) return void 0;
-      return decodeDevToolsValue(raw);
-    },
-    set: (key, value) => {
-      writeRaw(key, JSON.stringify(value));
-    },
-    remove: (key) => removeRaw(key),
-    clear: () => {
-      for (const key of keys()) {
-        removeRaw(key);
-      }
-    },
-    keys
+    value: resolveOptionalDefaultValue(options.defaultValue)
   };
 }
-function createReloadFromStorage({
-  storage,
-  hasAsyncContractViolation,
-  prefix,
-  listeners,
-  cache,
-  emit,
-  callbacks,
-  devToolsRoot,
-  namespace
-}) {
-  return (changedKeys) => {
-    if (!storage || hasAsyncContractViolation()) return;
-    if (changedKeys?.length === 0) return;
-    const isFullReload = changedKeys === void 0;
-    const changed = isFullReload ? reloadSubscribedKeysFromStorage({
-      prefix,
-      storage,
-      listeners,
-      cache,
-      emit,
-      callbacks
-    }) : reloadNamedKeysFromStorage({
-      changedKeys,
-      prefix,
-      storage,
-      listeners,
-      cache,
-      emit,
-      callbacks
-    });
-    if (changed) {
-      bumpDevToolsVersion(devToolsRoot, namespace, isFullReload ? "reload:full" : "reload:granular");
-    }
+function encodeValueForWrite(key, nextValue, options, schemaMode, schemaRegistry) {
+  return encodePersistedValueForWrite({
+    key,
+    nextValue,
+    codec: options.codec ?? JSONCodec,
+    explicitVersion: options.schema?.version,
+    schemaMode,
+    schemaRegistry
+  });
+}
+function decodeCodecManagedEnvelope(key, envelope, options) {
+  if (typeof envelope.payload !== "string") {
+    return {
+      value: envelope.payload
+    };
+  }
+  return {
+    value: decodeStringPayload(key, envelope.payload, options.codec ?? JSONCodec)
   };
 }
-function registerDevToolsProvider({
-  devToolsRoot,
-  namespace,
-  store,
-  dump,
-  keys,
-  readThrough,
-  writeRaw,
-  removeRaw
-}) {
-  let infoMessage = `[Mnemonic DevTools] Namespace "${namespace}" available via window.__REACT_MNEMONIC_DEVTOOLS__.resolve("${namespace}")`;
-  if (!devToolsRoot.capabilities.weakRef) {
-    console.info(
-      `[Mnemonic DevTools] WeakRef is not available; registry provider "${namespace}" was not registered.`
+function decodeAutoschemaEnvelope(key, envelope, options, schemaRegistry) {
+  if (!schemaRegistry?.registerSchema) {
+    throw new SchemaError(
+      "MODE_CONFIGURATION_INVALID",
+      `Autoschema mode requires schema registry registration for key "${key}"`
     );
-    return;
   }
-  const existingLive = devToolsRoot.resolve(namespace);
-  if (existingLive) {
-    const duplicateMessage = `[Mnemonic DevTools] Duplicate provider namespace "${namespace}" detected. Each window must have at most one live MnemonicProvider per namespace.`;
-    if (!isProductionRuntime()) {
-      throw new Error(duplicateMessage);
-    }
-    console.warn(`${duplicateMessage} Keeping the first provider and ignoring the duplicate.`);
-    console.info(
-      `[Mnemonic DevTools] Namespace "${namespace}" already registered. Keeping existing provider reference.`
+  const decoded = typeof envelope.payload === "string" ? decodeStringPayload(key, envelope.payload, options.codec ?? JSONCodec) : envelope.payload;
+  const pendingSchema = {
+    key,
+    version: 1,
+    schema: inferJsonSchema(decoded)
+  };
+  return {
+    value: decoded,
+    rewriteRaw: serializeEnvelope(pendingSchema.version, decoded),
+    pendingSchema
+  };
+}
+function decodeSchemaManagedEnvelope(key, envelope, schemaForVersion, latestSchema, schemaRegistry) {
+  let current = envelope.payload;
+  validateAgainstSchema(key, current, schemaForVersion.schema);
+  if (!latestSchema || envelope.version >= latestSchema.version) {
+    return {
+      value: current
+    };
+  }
+  const path = getMigrationPath(schemaRegistry, key, envelope.version, latestSchema.version);
+  if (!path) {
+    throw new SchemaError(
+      "MIGRATION_PATH_NOT_FOUND",
+      `No migration path for key "${key}" from v${envelope.version} to v${latestSchema.version}`
     );
-    return;
   }
-  const providerApi = createDevToolsProviderApi({
-    store,
-    dump,
-    keys,
-    readThrough,
-    writeRaw,
-    removeRaw
-  });
-  const WeakRefCtor = weakRefConstructor();
-  if (!WeakRefCtor) {
-    console.info(`[Mnemonic DevTools] WeakRef became unavailable while registering "${namespace}".`);
-    return;
+  for (const step of path) {
+    current = step.migrate(current);
   }
-  store.__devToolsProviderApiHold = providerApi;
-  const now = Date.now();
-  devToolsRoot.providers[namespace] = {
-    namespace,
-    weakRef: new WeakRefCtor(providerApi),
-    registeredAt: now,
-    lastSeenAt: now,
-    staleSince: null
+  validateAgainstSchema(key, current, latestSchema.schema);
+  return {
+    value: current,
+    rewriteRaw: serializeEnvelope(latestSchema.version, current)
   };
-  bumpDevToolsVersion(devToolsRoot, namespace, "registry:namespace-registered");
-  console.info(infoMessage);
 }
-function MnemonicProvider({
-  children,
-  namespace,
-  storage,
-  enableDevTools = false,
-  schemaMode = "default",
-  schemaRegistry,
-  ssr
-}) {
-  if (schemaMode === "strict" && !schemaRegistry) {
-    throw new Error("MnemonicProvider strict mode requires schemaRegistry");
+function decodePersistedValue(key, raw, options, api, schemaRegistry) {
+  if (raw == null) {
+    return buildFallbackResult(options);
   }
-  if (schemaMode === "autoschema" && typeof schemaRegistry?.registerSchema !== "function") {
-    throw new Error("MnemonicProvider autoschema mode requires schemaRegistry.registerSchema");
+  const envelope = parseEnvelope(key, raw);
+  const latestSchema = getLatestSchema(schemaRegistry, key);
+  const schemaForVersion = getSchemaForVersion(schemaRegistry, key, envelope.version);
+  if (api.schemaMode === "strict" && !schemaForVersion) {
+    throw new SchemaError("SCHEMA_NOT_FOUND", `No schema for key "${key}" v${envelope.version}`);
   }
-  const store = useMemo(() => {
-    const prefix = `${namespace}.`;
-    const st = storage ?? defaultBrowserStorage();
-    const ssrHydration = ssr?.hydration ?? "immediate";
-    const devToolsRoot = ensureDevToolsRoot(enableDevTools);
-    const canEnumerateKeys = detectEnumerableStorage(st);
-    const crossTabSyncMode = getCrossTabSyncMode(storage, st);
-    const cache = /* @__PURE__ */ new Map();
-    const listeners = /* @__PURE__ */ new Map();
-    let quotaErrorLogged = false;
-    let accessErrorLogged = false;
-    let asyncContractViolationDetected = false;
-    const storageAccessCallbacks = {
-      onAccessError: (err) => logAccessError(err),
-      onAccessSuccess: () => {
-        accessErrorLogged = false;
-      },
-      onAsyncViolation: (method, thenable) => handleAsyncStorageContractViolation(method, thenable)
-    };
-    const fullKey = (key) => prefix + key;
-    const emit = (key) => {
-      const set = listeners.get(key);
-      if (!set) return;
-      for (const fn of set) fn();
-    };
-    const logAccessError = (err) => {
-      if (!accessErrorLogged && err instanceof DOMException && err.name !== "QuotaExceededError") {
-        console.error(
-          `[Mnemonic] Storage access error (${err.name}): ${err.message}. Data is cached in memory but may not persist.`
-        );
-        accessErrorLogged = true;
-      }
-    };
-    const handleAsyncStorageContractViolation = (method, thenable) => {
-      asyncContractViolationDetected = true;
-      void Promise.resolve(thenable).catch(() => void 0);
-      if (accessErrorLogged) return;
-      console.error(
-        `[Mnemonic] StorageLike.${method} returned a Promise. StorageLike must remain synchronous for react-mnemonic v1. Wrap async persistence behind a synchronous cache facade instead.`
-      );
-      accessErrorLogged = true;
-    };
-    const readThrough = (key) => {
-      if (cache.has(key)) return cache.get(key) ?? null;
-      if (!st || asyncContractViolationDetected) {
-        cache.set(key, null);
-        return null;
+  if (api.schemaMode === "autoschema" && !schemaForVersion) {
+    return decodeAutoschemaEnvelope(key, envelope, options, schemaRegistry);
+  }
+  if (!schemaForVersion) {
+    return decodeCodecManagedEnvelope(key, envelope, options);
+  }
+  return decodeSchemaManagedEnvelope(key, envelope, schemaForVersion, latestSchema, schemaRegistry);
+}
+function createMnemonicOptionalBridge({
+  api,
+  schemaRegistry
+}) {
+  return {
+    namespace: api.prefix.endsWith(".") ? api.prefix.slice(0, -1) : api.prefix,
+    capabilities: {
+      persistence: true,
+      schema: getSchemaCapabilities(schemaRegistry)
+    },
+    subscribeRaw: (key, listener) => api.subscribeRaw(key, listener),
+    getRawSnapshot: (key) => api.getRawSnapshot(key),
+    decodeSnapshot: (key, raw, options) => {
+      try {
+        return decodePersistedValue(key, raw, options, api, schemaRegistry);
+      } catch {
+        return buildFallbackResult(options);
       }
-      const raw = readStorageRaw(st, fullKey(key), storageAccessCallbacks);
-      cache.set(key, raw);
-      return raw;
-    };
-    const writeRaw = (key, raw) => {
-      cache.set(key, raw);
-      if (st && !asyncContractViolationDetected) {
-        try {
-          const result = st.setItem(fullKey(key), raw);
-          if (isPromiseLike(result)) {
-            handleAsyncStorageContractViolation("setItem", result);
-          } else {
-            quotaErrorLogged = false;
-            accessErrorLogged = false;
-          }
-        } catch (err) {
-          if (!quotaErrorLogged && err instanceof DOMException && err.name === "QuotaExceededError") {
-            console.error(
-              `[Mnemonic] Storage quota exceeded writing key "${key}". Data is cached in memory but will not persist.`
-            );
-            quotaErrorLogged = true;
-          }
-          logAccessError(err);
+    },
+    setValue: (key, nextValue, options) => {
+      try {
+        api.setRaw(key, encodeValueForWrite(key, nextValue, options, api.schemaMode, schemaRegistry));
+      } catch (error) {
+        if (error instanceof SchemaError) {
+          console.error(`[Mnemonic] Schema error for key "${key}" (${error.code}):`, error.message);
+          return;
         }
+        if (error instanceof CodecError) {
+          console.error(`[Mnemonic] Codec error for key "${key}":`, error.message);
+          return;
+        }
+        throw error;
       }
-      emit(key);
-      bumpDevToolsVersion(devToolsRoot, namespace, `set:${key}`);
-    };
-    const removeRaw = (key) => {
-      cache.set(key, null);
-      if (st && !asyncContractViolationDetected) {
-        try {
-          const result = st.removeItem(fullKey(key));
-          if (isPromiseLike(result)) {
-            handleAsyncStorageContractViolation("removeItem", result);
-          } else {
-            accessErrorLogged = false;
+    },
+    removeValue: (key) => {
+      api.removeRaw(key);
+    },
+    commitSnapshot: (key, raw, snapshot) => {
+      if (snapshot.pendingSchema && schemaRegistry?.registerSchema) {
+        if (!schemaRegistry.getSchema(snapshot.pendingSchema.key, snapshot.pendingSchema.version)) {
+          try {
+            schemaRegistry.registerSchema(snapshot.pendingSchema);
+          } catch {
           }
-        } catch (err) {
-          logAccessError(err);
         }
       }
-      emit(key);
-      bumpDevToolsVersion(devToolsRoot, namespace, `remove:${key}`);
-    };
-    const subscribeRaw = (key, listener) => {
-      let set = listeners.get(key);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        listeners.set(key, set);
+      if (snapshot.rewriteRaw !== void 0 && snapshot.rewriteRaw !== raw) {
+        api.setRaw(key, snapshot.rewriteRaw);
       }
-      set.add(listener);
-      readThrough(key);
-      return () => {
-        const s = listeners.get(key);
-        if (!s) return;
-        s.delete(listener);
-        if (s.size === 0) listeners.delete(key);
-      };
-    };
-    const getRawSnapshot = (key) => readThrough(key);
-    const keys = () => {
-      if (asyncContractViolationDetected) {
-        return Array.from(cache.entries()).filter(([, value]) => value != null).map(([key]) => key);
-      }
-      if (!canEnumerateKeys) return [];
-      return enumerateNamespaceKeys(st, prefix, storageAccessCallbacks);
-    };
-    const dump = () => {
-      const out = {};
-      for (const k of keys()) {
-        const raw = readThrough(k);
-        if (raw != null) out[k] = raw;
-      }
-      return out;
-    };
-    const reloadFromStorage = createReloadFromStorage({
-      storage: st,
-      hasAsyncContractViolation: () => asyncContractViolationDetected,
-      prefix,
-      listeners,
-      cache,
-      emit,
-      callbacks: storageAccessCallbacks,
-      devToolsRoot,
-      namespace
-    });
-    const store2 = {
-      prefix,
-      canEnumerateKeys,
-      subscribeRaw,
-      getRawSnapshot,
-      setRaw: writeRaw,
-      removeRaw,
-      keys,
-      dump,
-      reloadFromStorage,
-      schemaMode,
-      ssrHydration,
-      crossTabSyncMode,
-      ...schemaRegistry ? { schemaRegistry } : {}
-    };
-    if (devToolsRoot) {
-      registerDevToolsProvider({
-        devToolsRoot,
-        namespace,
-        store: store2,
-        dump,
-        keys,
-        readThrough,
-        writeRaw,
-        removeRaw
-      });
     }
-    return store2;
-  }, [namespace, storage, enableDevTools, schemaMode, schemaRegistry, ssr?.hydration]);
-  useEffect(() => {
-    if (!storage?.onExternalChange) return;
-    return storage.onExternalChange((changedKeys) => store.reloadFromStorage(changedKeys));
-  }, [storage, store]);
-  return /* @__PURE__ */ jsx(MnemonicContext.Provider, { value: store, children });
+  };
 }
+var MnemonicOptionalBridgeContext = createContext(null);
 
-// src/Mnemonic/codecs.ts
-var CodecError = class extends Error {
-  /**
-   * Creates a new CodecError.
-   *
-   * @param message - Human-readable error description
-   * @param cause - Optional underlying error that caused this failure
-   */
-  constructor(message, cause) {
-    super(message);
-    this.name = "CodecError";
-    this.cause = cause;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var JSONCodec = {
-  encode: (value) => JSON.stringify(value),
-  decode: (encoded) => JSON.parse(encoded)
-};
-function createCodec(encode, decode) {
-  return { encode, decode };
+// src/Mnemonic/optional-bridge-provider.tsx
+function MnemonicOptionalBridgeProvider({
+  bridge,
+  children
+}) {
+  return createElement(MnemonicOptionalBridgeContext.Provider, { value: bridge }, children);
 }
 
-// src/Mnemonic/schema.ts
-var SchemaError = class extends Error {
-  /**
-   * Creates a new SchemaError.
-   *
-   * @param code - Machine-readable failure category
-   * @param message - Human-readable error description
-   * @param cause - Optional underlying error
-   */
-  constructor(code, message, cause) {
-    super(message);
-    this.name = "SchemaError";
-    this.code = code;
-    this.cause = cause;
-    Object.setPrototypeOf(this, new.target.prototype);
+// src/Mnemonic/runtime.ts
+function getGlobalProcess() {
+  return globalThis.process;
+}
+function getRuntimeNodeEnv() {
+  const runtimeProcess = getGlobalProcess();
+  if (runtimeProcess?.env?.NODE_ENV !== void 0) {
+    return runtimeProcess.env.NODE_ENV;
   }
-};
-
-// src/Mnemonic/json-schema.ts
-function matchesType(value, type) {
-  switch (type) {
-    case "string":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number" && Number.isFinite(value);
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "boolean":
-      return typeof value === "boolean";
-    case "null":
-      return value === null;
-    case "object":
-      return typeof value === "object" && value !== null && !Array.isArray(value);
-    case "array":
-      return Array.isArray(value);
-    default:
-      return false;
+  return void 0;
+}
+function getDefaultBrowserStorage() {
+  const globalWindow = globalThis.window;
+  if (globalWindow === void 0) return void 0;
+  try {
+    return globalWindow.localStorage;
+  } catch {
+    return void 0;
   }
 }
-function jsonDeepEqualArray(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    if (!jsonDeepEqual(a[i], b[i])) return false;
+function getNativeBrowserStorages() {
+  const globalWindow = globalThis.window;
+  if (!globalWindow) return [];
+  const storages = [];
+  const addStorage = (getter) => {
+    try {
+      storages.push(getter());
+    } catch {
+    }
+  };
+  addStorage(() => globalWindow.localStorage);
+  addStorage(() => globalWindow.sessionStorage);
+  return storages;
+}
+var MnemonicContext = createContext(null);
+var warnedNestedProviderStores = /* @__PURE__ */ new WeakSet();
+function useMnemonic() {
+  const context = useMnemonicOptional();
+  if (!context) {
+    throw new Error("useMnemonic must be used within a MnemonicProvider");
   }
-  return true;
+  return context;
 }
-function jsonDeepEqualObject(a, b) {
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
-  for (const key of aKeys) {
-    if (!objectHasOwn(b, key)) return false;
-    if (!jsonDeepEqual(a[key], b[key])) return false;
+function useMnemonicOptional() {
+  return useContext(MnemonicContext);
+}
+function detectEnumerableStorage(storage) {
+  if (!storage) return false;
+  try {
+    return typeof storage.length === "number" && typeof storage.key === "function";
+  } catch {
+    return false;
+  }
+}
+function isProductionRuntime() {
+  const env = getRuntimeNodeEnv();
+  if (env === void 0) {
+    return true;
+  }
+  return env === "production";
+}
+function weakRefConstructor() {
+  const ctor = globalThis.WeakRef;
+  return typeof ctor === "function" ? ctor : null;
+}
+function hasFinalizationRegistry() {
+  return typeof globalThis.FinalizationRegistry === "function";
+}
+function isPromiseLike(value) {
+  if (value == null) return false;
+  if (typeof value !== "object" && typeof value !== "function") return false;
+  return typeof value.then === "function";
+}
+function getCrossTabSyncMode(requestedStorage, activeStorage) {
+  const isExplicitNativeBrowserStorage = activeStorage !== void 0 && requestedStorage !== void 0 && getNativeBrowserStorages().includes(activeStorage);
+  if (requestedStorage === void 0 && activeStorage !== void 0 || isExplicitNativeBrowserStorage) {
+    return "browser-storage-event";
+  }
+  if (typeof activeStorage?.onExternalChange === "function") {
+    return "custom-external-change";
+  }
+  return "none";
+}
+function getDevToolsWindow() {
+  return globalThis.window;
+}
+function sanitizeDevToolsRoot(root) {
+  const reserved = /* @__PURE__ */ new Set(["providers", "resolve", "list", "capabilities", "__meta"]);
+  for (const key of Object.keys(root)) {
+    if (reserved.has(key)) continue;
+    const descriptor = Object.getOwnPropertyDescriptor(root, key);
+    if (descriptor && !descriptor.configurable) continue;
+    try {
+      delete root[key];
+    } catch {
+    }
+  }
+}
+function ensureDevToolsRoot(enableDevTools) {
+  if (!enableDevTools) return null;
+  const globalWindow = getDevToolsWindow();
+  if (!globalWindow) return null;
+  const weakRefSupported = weakRefConstructor() !== null;
+  const finalizationRegistrySupported = hasFinalizationRegistry();
+  const existing = globalWindow.__REACT_MNEMONIC_DEVTOOLS__;
+  const root = existing && typeof existing === "object" ? existing : {};
+  sanitizeDevToolsRoot(root);
+  if (!root.providers || typeof root.providers !== "object") {
+    root.providers = {};
+  }
+  if (!root.capabilities || typeof root.capabilities !== "object") {
+    root.capabilities = {};
+  }
+  const capabilities = root.capabilities;
+  capabilities.weakRef = weakRefSupported;
+  capabilities.finalizationRegistry = finalizationRegistrySupported;
+  if (!root.__meta || typeof root.__meta !== "object") {
+    root.__meta = {
+      version: 0,
+      lastUpdated: Date.now(),
+      lastChange: ""
+    };
+  }
+  const meta = root.__meta;
+  if (typeof meta.version !== "number" || !Number.isFinite(meta.version)) {
+    meta.version = 0;
+  }
+  if (typeof meta.lastUpdated !== "number" || !Number.isFinite(meta.lastUpdated)) {
+    meta.lastUpdated = Date.now();
   }
-  return true;
-}
-function jsonDeepEqual(a, b) {
-  if (a === b) return true;
-  if (a === null || b === null) return false;
-  if (typeof a !== typeof b) return false;
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) return false;
-    return jsonDeepEqualArray(a, b);
+  if (typeof meta.lastChange !== "string") {
+    meta.lastChange = "";
   }
-  if (typeof a === "object") {
-    if (Array.isArray(b)) return false;
-    return jsonDeepEqualObject(a, b);
+  const providers = root.providers;
+  if (typeof root.resolve !== "function") {
+    root.resolve = (namespace) => {
+      const entry = providers[namespace];
+      if (!entry || typeof entry.weakRef?.deref !== "function") return null;
+      const live = entry.weakRef.deref();
+      if (live) {
+        entry.lastSeenAt = Date.now();
+        entry.staleSince = null;
+        return live;
+      }
+      entry.staleSince ?? (entry.staleSince = Date.now());
+      return null;
+    };
   }
-  return false;
-}
-var compiledCache = /* @__PURE__ */ new WeakMap();
-function compileSchema(schema) {
-  const cached = compiledCache.get(schema);
-  if (cached) return cached;
-  const compiled = buildValidator(schema);
-  compiledCache.set(schema, compiled);
-  return compiled;
+  if (typeof root.list !== "function") {
+    root.list = () => Object.entries(providers).map(([namespace, entry]) => {
+      const live = typeof entry.weakRef?.deref === "function" ? entry.weakRef.deref() : void 0;
+      const available = Boolean(live);
+      if (available) {
+        entry.lastSeenAt = Date.now();
+        entry.staleSince = null;
+      } else {
+        entry.staleSince ?? (entry.staleSince = Date.now());
+      }
+      return {
+        namespace,
+        available,
+        registeredAt: entry.registeredAt,
+        lastSeenAt: entry.lastSeenAt,
+        staleSince: entry.staleSince
+      };
+    }).sort((left, right) => left.namespace.localeCompare(right.namespace));
+  }
+  globalWindow.__REACT_MNEMONIC_DEVTOOLS__ = root;
+  return root;
 }
-function isJsonPrimitive(value) {
-  return value === null || typeof value !== "object";
+function bumpDevToolsVersion(root, namespace, reason) {
+  if (!root) return;
+  root.__meta.version += 1;
+  root.__meta.lastUpdated = Date.now();
+  root.__meta.lastChange = `${namespace}.${reason}`;
 }
-function isJsonObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function decodeDevToolsValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
 }
-function objectHasOwn(value, property) {
-  const hasOwn = Object.hasOwn;
-  if (typeof hasOwn === "function") {
-    return hasOwn(value, property);
+function readStorageRaw(storage, storageKey, callbacks) {
+  if (!storage) return null;
+  try {
+    const raw = storage.getItem(storageKey);
+    if (isPromiseLike(raw)) {
+      callbacks.onAsyncViolation("getItem", raw);
+      return null;
+    }
+    callbacks.onAccessSuccess();
+    return raw;
+  } catch (error) {
+    callbacks.onAccessError(error);
+    return null;
   }
-  return Object.getOwnPropertyDescriptor(value, property) !== void 0;
 }
-function buildValidator(schema) {
-  const typeStep = buildTypeValidationStep(schema);
-  const validationSteps = [
-    buildEnumValidationStep(schema),
-    buildConstValidationStep(schema),
-    buildNumberValidationStep(schema),
-    buildStringValidationStep(schema),
-    buildObjectValidationStep(schema),
-    buildArrayValidationStep(schema)
-  ].filter((step) => step !== null);
-  if (typeStep === null && validationSteps.length === 0) {
-    return (_value, _path) => [];
+function enumerateNamespaceKeys(storage, prefix, callbacks) {
+  if (!storage) {
+    return [];
   }
-  return (value, path = "") => {
-    const errors = [];
-    if (typeStep && !typeStep(value, path, errors)) {
-      return errors;
+  const keys = [];
+  try {
+    const storageLength = storage.length;
+    const getStorageKey = storage.key;
+    if (typeof storageLength !== "number" || typeof getStorageKey !== "function") {
+      return [];
     }
-    for (const step of validationSteps) {
-      step(value, path, errors);
+    for (let index = 0; index < storageLength; index++) {
+      const fullKey = getStorageKey.call(storage, index);
+      if (!fullKey?.startsWith(prefix)) continue;
+      keys.push(fullKey.slice(prefix.length));
     }
-    return errors;
-  };
+    callbacks.onAccessSuccess();
+  } catch (error) {
+    callbacks.onAccessError(error);
+  }
+  return keys;
 }
-function buildTypeValidationStep(schema) {
-  if (schema.type === void 0) {
-    return null;
+function syncCacheEntryFromStorage({
+  key,
+  storageKey,
+  storage,
+  cache,
+  emit,
+  callbacks
+}) {
+  const fresh = readStorageRaw(storage, storageKey, callbacks);
+  const cached = cache.get(key) ?? null;
+  if (fresh === cached) {
+    return false;
   }
-  const resolvedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
-  const typeLabel = JSON.stringify(schema.type);
-  return (value, path, errors) => {
-    if (resolvedTypes.some((type) => matchesType(value, type))) {
-      return true;
+  cache.set(key, fresh);
+  emit(key);
+  return true;
+}
+function reloadNamedKeysFromStorage({
+  changedKeys,
+  prefix,
+  storage,
+  listeners,
+  cache,
+  emit,
+  callbacks
+}) {
+  let changed = false;
+  for (const fullStorageKey of changedKeys) {
+    if (!fullStorageKey.startsWith(prefix)) continue;
+    const key = fullStorageKey.slice(prefix.length);
+    const listenerSet = listeners.get(key);
+    if (listenerSet && listenerSet.size > 0) {
+      changed = syncCacheEntryFromStorage({
+        key,
+        storageKey: fullStorageKey,
+        storage,
+        cache,
+        emit,
+        callbacks
+      }) || changed;
+      continue;
     }
-    errors.push({
-      path,
-      message: `Expected type ${typeLabel}, got ${jsonTypeLabel(value)}`,
-      keyword: "type"
-    });
-    return false;
-  };
+    if (cache.has(key)) {
+      cache.delete(key);
+    }
+  }
+  return changed;
 }
-function buildEnumValidationStep(schema) {
-  if (schema.enum === void 0) {
-    return null;
+function reloadSubscribedKeysFromStorage({
+  prefix,
+  storage,
+  listeners,
+  cache,
+  emit,
+  callbacks
+}) {
+  let changed = false;
+  for (const [key, listenerSet] of listeners) {
+    if (listenerSet.size === 0) continue;
+    changed = syncCacheEntryFromStorage({
+      key,
+      storageKey: `${prefix}${key}`,
+      storage,
+      cache,
+      emit,
+      callbacks
+    }) || changed;
   }
-  const enumPrimitiveSet = new Set(schema.enum.filter((member) => isJsonPrimitive(member)));
-  const enumComplexMembers = schema.enum.filter((member) => !isJsonPrimitive(member));
-  return (value, path, errors) => {
-    const primitiveMatch = isJsonPrimitive(value) && enumPrimitiveSet.has(value);
-    const complexMatch = !primitiveMatch && enumComplexMembers.some((entry) => jsonDeepEqual(value, entry));
-    if (primitiveMatch || complexMatch) {
-      return;
-    }
-    errors.push({
-      path,
-      message: `Value does not match any enum member`,
-      keyword: "enum"
-    });
+  for (const key of cache.keys()) {
+    const listenerSet = listeners.get(key);
+    if (listenerSet && listenerSet.size > 0) continue;
+    cache.delete(key);
+  }
+  return changed;
+}
+function createDevToolsProviderApi({
+  store,
+  dump,
+  keys,
+  readThrough,
+  writeRaw,
+  removeRaw
+}) {
+  return {
+    getStore: () => store,
+    dump: () => {
+      const data = dump();
+      console.table(
+        Object.entries(data).map(([key, value]) => ({
+          key,
+          value,
+          decoded: decodeDevToolsValue(value)
+        }))
+      );
+      return data;
+    },
+    get: (key) => {
+      const raw = readThrough(key);
+      if (raw == null) return void 0;
+      return decodeDevToolsValue(raw);
+    },
+    set: (key, value) => {
+      writeRaw(key, JSON.stringify(value));
+    },
+    remove: (key) => removeRaw(key),
+    clear: () => {
+      for (const key of keys()) {
+        removeRaw(key);
+      }
+    },
+    keys
   };
 }
-function buildConstValidationStep(schema) {
-  if (!("const" in schema)) {
-    return null;
-  }
-  return (value, path, errors) => {
-    if (jsonDeepEqual(value, schema.const)) {
-      return;
-    }
-    errors.push({
-      path,
-      message: `Value does not match const`,
-      keyword: "const"
+function createReloadFromStorage({
+  storage,
+  hasAsyncContractViolation,
+  prefix,
+  listeners,
+  cache,
+  emit,
+  callbacks,
+  devToolsRoot,
+  namespace
+}) {
+  return (changedKeys) => {
+    if (!storage || hasAsyncContractViolation()) return;
+    if (changedKeys?.length === 0) return;
+    const isFullReload = changedKeys === void 0;
+    const changed = isFullReload ? reloadSubscribedKeysFromStorage({
+      prefix,
+      storage,
+      listeners,
+      cache,
+      emit,
+      callbacks
+    }) : reloadNamedKeysFromStorage({
+      changedKeys,
+      prefix,
+      storage,
+      listeners,
+      cache,
+      emit,
+      callbacks
     });
-  };
-}
-function buildNumberValidationStep(schema) {
-  const hasMinimum = schema.minimum !== void 0;
-  const hasMaximum = schema.maximum !== void 0;
-  const hasExMin = schema.exclusiveMinimum !== void 0;
-  const hasExMax = schema.exclusiveMaximum !== void 0;
-  if (!hasMinimum && !hasMaximum && !hasExMin && !hasExMax) {
-    return null;
-  }
-  const minimum = schema.minimum;
-  const maximum = schema.maximum;
-  const exMin = schema.exclusiveMinimum;
-  const exMax = schema.exclusiveMaximum;
-  return (value, path, errors) => {
-    if (typeof value !== "number") {
-      return;
-    }
-    if (hasMinimum && value < minimum) {
-      errors.push({
-        path,
-        message: `Value ${value} is less than minimum ${minimum}`,
-        keyword: "minimum"
-      });
-    }
-    if (hasMaximum && value > maximum) {
-      errors.push({
-        path,
-        message: `Value ${value} is greater than maximum ${maximum}`,
-        keyword: "maximum"
-      });
-    }
-    if (hasExMin && value <= exMin) {
-      errors.push({
-        path,
-        message: `Value ${value} is not greater than exclusiveMinimum ${exMin}`,
-        keyword: "exclusiveMinimum"
-      });
-    }
-    if (hasExMax && value >= exMax) {
-      errors.push({
-        path,
-        message: `Value ${value} is not less than exclusiveMaximum ${exMax}`,
-        keyword: "exclusiveMaximum"
-      });
+    if (changed) {
+      bumpDevToolsVersion(devToolsRoot, namespace, isFullReload ? "reload:full" : "reload:granular");
     }
   };
 }
-function buildStringValidationStep(schema) {
-  const hasMinLength = schema.minLength !== void 0;
-  const hasMaxLength = schema.maxLength !== void 0;
-  if (!hasMinLength && !hasMaxLength) {
-    return null;
+function registerDevToolsProvider({
+  devToolsRoot,
+  namespace,
+  store,
+  dump,
+  keys,
+  readThrough,
+  writeRaw,
+  removeRaw
+}) {
+  let infoMessage = `[Mnemonic DevTools] Namespace "${namespace}" available via window.__REACT_MNEMONIC_DEVTOOLS__.resolve("${namespace}")`;
+  if (!devToolsRoot.capabilities.weakRef) {
+    console.info(
+      `[Mnemonic DevTools] WeakRef is not available; registry provider "${namespace}" was not registered.`
+    );
+    return;
   }
-  const minLength = schema.minLength;
-  const maxLength = schema.maxLength;
-  return (value, path, errors) => {
-    if (typeof value !== "string") {
-      return;
-    }
-    if (hasMinLength && value.length < minLength) {
-      errors.push({
-        path,
-        message: `String length ${value.length} is less than minLength ${minLength}`,
-        keyword: "minLength"
-      });
-    }
-    if (hasMaxLength && value.length > maxLength) {
-      errors.push({
-        path,
-        message: `String length ${value.length} is greater than maxLength ${maxLength}`,
-        keyword: "maxLength"
-      });
+  const existingLive = devToolsRoot.resolve(namespace);
+  if (existingLive) {
+    const duplicateMessage = `[Mnemonic DevTools] Duplicate provider namespace "${namespace}" detected. Each window must have at most one live MnemonicProvider per namespace.`;
+    if (!isProductionRuntime()) {
+      throw new Error(duplicateMessage);
     }
+    console.warn(`${duplicateMessage} Keeping the first provider and ignoring the duplicate.`);
+    console.info(
+      `[Mnemonic DevTools] Namespace "${namespace}" already registered. Keeping existing provider reference.`
+    );
+    return;
+  }
+  const providerApi = createDevToolsProviderApi({
+    store,
+    dump,
+    keys,
+    readThrough,
+    writeRaw,
+    removeRaw
+  });
+  const WeakRefCtor = weakRefConstructor();
+  if (!WeakRefCtor) {
+    console.info(`[Mnemonic DevTools] WeakRef became unavailable while registering "${namespace}".`);
+    return;
+  }
+  store.__devToolsProviderApiHold = providerApi;
+  const now = Date.now();
+  devToolsRoot.providers[namespace] = {
+    namespace,
+    weakRef: new WeakRefCtor(providerApi),
+    registeredAt: now,
+    lastSeenAt: now,
+    staleSince: null
   };
+  bumpDevToolsVersion(devToolsRoot, namespace, "registry:namespace-registered");
+  console.info(infoMessage);
 }
-function buildObjectValidationStep(schema) {
-  const requiredKeys = schema.required ?? [];
-  const propertyValidators = schema.properties ? Object.entries(schema.properties).map(([name, propertySchema]) => [
-    name,
-    compileSchema(propertySchema)
-  ]) : null;
-  const checkAdditional = schema.additionalProperties !== void 0 && schema.additionalProperties !== true;
-  const additionalIsFalse = schema.additionalProperties === false;
-  const additionalValidator = checkAdditional && !additionalIsFalse ? compileSchema(schema.additionalProperties) : null;
-  const definedPropKeys = checkAdditional ? new Set(Object.keys(schema.properties ?? {})) : null;
-  const objectValidationSteps = [];
-  if (requiredKeys.length > 0) {
-    objectValidationSteps.push(createRequiredPropertyStep(requiredKeys));
+function MnemonicProvider({
+  children,
+  namespace,
+  storage,
+  enableDevTools = false,
+  schemaMode = "default",
+  schemaRegistry,
+  ssr,
+  bootstrap
+}) {
+  if (schemaMode === "strict" && !schemaRegistry) {
+    throw new Error("MnemonicProvider strict mode requires schemaRegistry");
   }
-  if (propertyValidators !== null) {
-    objectValidationSteps.push(createDeclaredPropertyStep(propertyValidators));
+  if (schemaMode === "autoschema" && typeof schemaRegistry?.registerSchema !== "function") {
+    throw new Error("MnemonicProvider autoschema mode requires schemaRegistry.registerSchema");
   }
-  if (checkAdditional) {
-    objectValidationSteps.push(
-      createAdditionalPropertyStep({
-        additionalIsFalse,
-        additionalValidator,
-        definedPropKeys: definedPropKeys ?? /* @__PURE__ */ new Set()
-      })
+  const prefix = `${namespace}.`;
+  const parentStore = useMnemonicOptional();
+  const bootstrapRawSeed = useRef(bootstrap?.raw).current;
+  useEffect(() => {
+    if (isProductionRuntime()) return;
+    if (parentStore?.prefix !== prefix) return;
+    if (warnedNestedProviderStores.has(parentStore)) return;
+    warnedNestedProviderStores.add(parentStore);
+    console.warn(
+      `[Mnemonic] Nested MnemonicProvider detected for namespace "${namespace}". The nearest provider wins, so the inner provider creates a separate store and cache even though the namespace matches. Prefer a single provider per namespace, or use distinct namespaces for intentionally separate scopes.`
     );
-  }
-  if (objectValidationSteps.length === 0) {
-    return null;
-  }
-  return (value, path, errors) => {
-    if (!isJsonObjectRecord(value)) {
-      return;
-    }
-    for (const step of objectValidationSteps) {
-      step(value, path, errors);
+  }, [namespace, parentStore, prefix]);
+  const store = useMemo(() => {
+    const st = storage ?? getDefaultBrowserStorage();
+    const ssrHydration = ssr?.hydration ?? "immediate";
+    const devToolsRoot = ensureDevToolsRoot(enableDevTools);
+    const canEnumerateKeys = detectEnumerableStorage(st);
+    const crossTabSyncMode = getCrossTabSyncMode(storage, st);
+    const cache = /* @__PURE__ */ new Map();
+    if (bootstrapRawSeed) {
+      for (const [key, raw] of Object.entries(bootstrapRawSeed)) {
+        if (raw != null) {
+          cache.set(key, raw);
+        }
+      }
     }
-  };
-}
-function createRequiredPropertyStep(requiredKeys) {
-  return (value, path, errors) => {
-    for (const requiredKey of requiredKeys) {
-      if (objectHasOwn(value, requiredKey)) {
-        continue;
+    const listeners = /* @__PURE__ */ new Map();
+    let quotaErrorLogged = false;
+    let accessErrorLogged = false;
+    let asyncContractViolationDetected = false;
+    const storageAccessCallbacks = {
+      onAccessError: (err) => logAccessError(err),
+      onAccessSuccess: () => {
+        accessErrorLogged = false;
+      },
+      onAsyncViolation: (method, thenable) => handleAsyncStorageContractViolation(method, thenable)
+    };
+    const fullKey = (key) => prefix + key;
+    const emit = (key) => {
+      const set = listeners.get(key);
+      if (!set) return;
+      for (const fn of set) fn();
+    };
+    const logAccessError = (err) => {
+      if (!accessErrorLogged && err instanceof DOMException && err.name !== "QuotaExceededError") {
+        console.error(
+          `[Mnemonic] Storage access error (${err.name}): ${err.message}. Data is cached in memory but may not persist.`
+        );
+        accessErrorLogged = true;
       }
-      errors.push({
-        path,
-        message: `Missing required property "${requiredKey}"`,
-        keyword: "required"
-      });
-    }
-  };
-}
-function createDeclaredPropertyStep(propertyValidators) {
-  return (value, path, errors) => {
-    for (const [propertyName, validator] of propertyValidators) {
-      if (!objectHasOwn(value, propertyName)) {
-        continue;
+    };
+    const handleAsyncStorageContractViolation = (method, thenable) => {
+      asyncContractViolationDetected = true;
+      void Promise.resolve(thenable).catch(() => void 0);
+      if (accessErrorLogged) return;
+      console.error(
+        `[Mnemonic] StorageLike.${method} returned a Promise. StorageLike must remain synchronous for react-mnemonic v1. Wrap async persistence behind a synchronous cache facade instead.`
+      );
+      accessErrorLogged = true;
+    };
+    const readThrough = (key) => {
+      if (cache.has(key)) return cache.get(key) ?? null;
+      if (!st || asyncContractViolationDetected) {
+        cache.set(key, null);
+        return null;
       }
-      errors.push(...validator(value[propertyName], `${path}/${propertyName}`));
-    }
-  };
-}
-function createAdditionalPropertyStep({
-  additionalIsFalse,
-  additionalValidator,
-  definedPropKeys
-}) {
-  return (value, path, errors) => {
-    for (const objectKey of Object.keys(value)) {
-      if (definedPropKeys.has(objectKey)) {
-        continue;
+      const raw = readStorageRaw(st, fullKey(key), storageAccessCallbacks);
+      cache.set(key, raw);
+      return raw;
+    };
+    const writeRaw = (key, raw) => {
+      cache.set(key, raw);
+      if (st && !asyncContractViolationDetected) {
+        try {
+          const result = st.setItem(fullKey(key), raw);
+          if (isPromiseLike(result)) {
+            handleAsyncStorageContractViolation("setItem", result);
+          } else {
+            quotaErrorLogged = false;
+            accessErrorLogged = false;
+          }
+        } catch (err) {
+          if (!quotaErrorLogged && err instanceof DOMException && err.name === "QuotaExceededError") {
+            console.error(
+              `[Mnemonic] Storage quota exceeded writing key "${key}". Data is cached in memory but will not persist.`
+            );
+            quotaErrorLogged = true;
+          }
+          logAccessError(err);
+        }
       }
-      if (additionalIsFalse) {
-        errors.push({
-          path,
-          message: `Additional property "${objectKey}" is not allowed`,
-          keyword: "additionalProperties"
-        });
-        continue;
+      emit(key);
+      bumpDevToolsVersion(devToolsRoot, namespace, `set:${key}`);
+    };
+    const removeRaw = (key) => {
+      cache.set(key, null);
+      if (st && !asyncContractViolationDetected) {
+        try {
+          const result = st.removeItem(fullKey(key));
+          if (isPromiseLike(result)) {
+            handleAsyncStorageContractViolation("removeItem", result);
+          } else {
+            accessErrorLogged = false;
+          }
+        } catch (err) {
+          logAccessError(err);
+        }
       }
-      errors.push(...additionalValidator(value[objectKey], `${path}/${objectKey}`));
-    }
-  };
-}
-function buildArrayValidationStep(schema) {
-  const hasMinItems = schema.minItems !== void 0;
-  const hasMaxItems = schema.maxItems !== void 0;
-  const itemsValidator = schema.items ? compileSchema(schema.items) : null;
-  if (!hasMinItems && !hasMaxItems && itemsValidator === null) {
-    return null;
-  }
-  const minItems = schema.minItems;
-  const maxItems = schema.maxItems;
-  return (value, path, errors) => {
-    if (!Array.isArray(value)) {
-      return;
-    }
-    if (hasMinItems && value.length < minItems) {
-      errors.push({
-        path,
-        message: `Array length ${value.length} is less than minItems ${minItems}`,
-        keyword: "minItems"
-      });
-    }
-    if (hasMaxItems && value.length > maxItems) {
-      errors.push({
-        path,
-        message: `Array length ${value.length} is greater than maxItems ${maxItems}`,
-        keyword: "maxItems"
+      emit(key);
+      bumpDevToolsVersion(devToolsRoot, namespace, `remove:${key}`);
+    };
+    const subscribeRaw = (key, listener) => {
+      let set = listeners.get(key);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(key, set);
+      }
+      set.add(listener);
+      readThrough(key);
+      return () => {
+        const s = listeners.get(key);
+        if (!s) return;
+        s.delete(listener);
+        if (s.size === 0) listeners.delete(key);
+      };
+    };
+    const getRawSnapshot = (key) => readThrough(key);
+    const keys = () => {
+      if (asyncContractViolationDetected) {
+        return Array.from(cache.entries()).filter(([, value]) => value != null).map(([key]) => key);
+      }
+      if (!canEnumerateKeys) return [];
+      return enumerateNamespaceKeys(st, prefix, storageAccessCallbacks);
+    };
+    const dump = () => {
+      const out = {};
+      for (const k of keys()) {
+        const raw = readThrough(k);
+        if (raw != null) out[k] = raw;
+      }
+      return out;
+    };
+    const reloadFromStorage = createReloadFromStorage({
+      storage: st,
+      hasAsyncContractViolation: () => asyncContractViolationDetected,
+      prefix,
+      listeners,
+      cache,
+      emit,
+      callbacks: storageAccessCallbacks,
+      devToolsRoot,
+      namespace
+    });
+    const store2 = {
+      prefix,
+      canEnumerateKeys,
+      subscribeRaw,
+      getRawSnapshot,
+      setRaw: writeRaw,
+      removeRaw,
+      keys,
+      dump,
+      reloadFromStorage,
+      schemaMode,
+      ssrHydration,
+      crossTabSyncMode,
+      ...schemaRegistry ? { schemaRegistry } : {}
+    };
+    if (devToolsRoot) {
+      registerDevToolsProvider({
+        devToolsRoot,
+        namespace,
+        store: store2,
+        dump,
+        keys,
+        readThrough,
+        writeRaw,
+        removeRaw
       });
     }
-    if (itemsValidator === null) {
-      return;
-    }
-    for (const [index, item] of value.entries()) {
-      errors.push(...itemsValidator(item, `${path}/${index}`));
-    }
-  };
-}
-function validateJsonSchema(value, schema, path = "") {
-  const compiled = compileSchema(schema);
-  return compiled(value, path);
-}
-function jsonTypeLabel(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  return typeof value;
-}
-function inferJsonSchema(sample) {
-  if (sample === null) return { type: "null" };
-  if (Array.isArray(sample)) return { type: "array" };
-  switch (typeof sample) {
-    case "string":
-      return { type: "string" };
-    case "number":
-      return { type: "number" };
-    case "boolean":
-      return { type: "boolean" };
-    case "object":
-      return { type: "object" };
-    default:
-      return {};
-  }
+    return store2;
+  }, [namespace, storage, enableDevTools, schemaMode, schemaRegistry, ssr?.hydration, bootstrapRawSeed]);
+  const optionalBridge = useMemo(
+    () => createMnemonicOptionalBridge({
+      api: store,
+      ...schemaRegistry ? { schemaRegistry } : {}
+    }),
+    [schemaRegistry, store]
+  );
+  useEffect(() => {
+    if (!storage?.onExternalChange) return;
+    return storage.onExternalChange((changedKeys) => store.reloadFromStorage(changedKeys));
+  }, [storage, store]);
+  return /* @__PURE__ */ jsx(MnemonicContext.Provider, { value: store, children: /* @__PURE__ */ jsx(MnemonicOptionalBridgeProvider, { bridge: optionalBridge, children }) });
 }
 var SSR_SNAPSHOT_TOKEN = /* @__PURE__ */ Symbol("mnemonic:ssr-snapshot");
 var diagnosticContractRegistry = /* @__PURE__ */ new WeakMap();
 var diagnosticWarningRegistry = /* @__PURE__ */ new WeakMap();
 var diagnosticObjectIds = /* @__PURE__ */ new WeakMap();
 var nextDiagnosticObjectId = 1;
-function serializeEnvelope(version, payload) {
-  return JSON.stringify({
-    version,
-    payload
-  });
-}
 function withReadMetadata(value, rewriteRaw, extra) {
   const result = { value };
   if (extra !== void 0) {
@@ -1074,13 +1354,6 @@ function stableDiagnosticValue(value) {
 function isObjectLike(value) {
   return value !== null && (typeof value === "object" || typeof value === "function");
 }
-function objectHasOwn2(value, property) {
-  const hasOwn = Object.hasOwn;
-  if (typeof hasOwn === "function") {
-    return hasOwn(value, property);
-  }
-  return Object.getOwnPropertyDescriptor(value, property) !== void 0;
-}
 function getDiagnosticObjectId(value) {
   const existing = diagnosticObjectIds.get(value);
   if (existing !== void 0) return existing;
@@ -1124,11 +1397,10 @@ function resolveMnemonicKeyArgs(keyOrDescriptor, options) {
     options
   };
 }
-function useMnemonicKeyShared(keyOrDescriptor, options, schemaVersion) {
+function useMnemonicKeySharedFromApi(api, keyOrDescriptor, options, schemaVersion) {
   const descriptor = resolveMnemonicKeyArgs(keyOrDescriptor, options);
   const key = descriptor.key;
   const resolvedOptions = descriptor.options;
-  const api = useMnemonic();
   const {
     defaultValue,
     onMount,
@@ -1178,37 +1450,26 @@ function useMnemonicKeyShared(keyOrDescriptor, options, schemaVersion) {
     }
     return typeof serverValue === "function" ? serverValue() : serverValue;
   }, [getFallback, ssrOptions?.serverValue]);
-  const parseEnvelope = useCallback(
+  const parseEnvelope2 = useCallback(
     (rawText) => {
       try {
-        const parsed = JSON.parse(rawText);
-        if (typeof parsed !== "object" || parsed == null || !Number.isInteger(parsed.version) || parsed.version < 0 || !objectHasOwn2(parsed, "payload")) {
-          return {
-            ok: false,
-            error: new SchemaError("INVALID_ENVELOPE", `Invalid envelope for key "${key}"`)
-          };
-        }
-        return { ok: true, envelope: parsed };
-      } catch (err) {
+        return { ok: true, envelope: parseEnvelope(key, rawText) };
+      } catch (error) {
         return {
           ok: false,
-          error: new SchemaError("INVALID_ENVELOPE", `Invalid envelope for key "${key}"`, err)
+          error: error instanceof SchemaError ? error : new SchemaError("INVALID_ENVELOPE", `Invalid envelope for key "${key}"`, error)
         };
       }
     },
     [key]
   );
-  const decodeStringPayload = useCallback(
+  const decodeStringPayload2 = useCallback(
     (payload, activeCodec) => {
-      try {
-        return activeCodec.decode(payload);
-      } catch (err) {
-        throw err instanceof CodecError ? err : new CodecError(`Codec decode failed for key "${key}"`, err);
-      }
+      return decodeStringPayload(key, payload, activeCodec);
     },
     [key]
   );
-  const buildFallbackResult = useCallback(
+  const buildFallbackResult2 = useCallback(
     (error, extra) => {
       return withReadMetadata(getFallback(error), void 0, extra);
     },
@@ -1226,9 +1487,9 @@ function useMnemonicKeyShared(keyOrDescriptor, options, schemaVersion) {
     listenCrossTab,
     getFallback,
     getServerValue,
-    parseEnvelope,
-    decodeStringPayload,
-    buildFallbackResult,
+    parseEnvelope: parseEnvelope2,
+    decodeStringPayload: decodeStringPayload2,
+    buildFallbackResult: buildFallbackResult2,
     developmentRuntime,
     contractFingerprint,
     hasMounted,
@@ -1240,7 +1501,7 @@ function useMnemonicKeyShared(keyOrDescriptor, options, schemaVersion) {
 function useApplyReconcile({
   key,
   reconcile,
-  buildFallbackResult
+  buildFallbackResult: buildFallbackResult2
 }) {
   return useCallback(
     ({
@@ -1277,10 +1538,10 @@ function useApplyReconcile({
         return withReadMetadata(reconciled, nextRewriteRaw, nextExtra);
       } catch (err) {
         const typedErr = err instanceof SchemaError ? err : new SchemaError("RECONCILE_FAILED", `Reconciliation failed for key "${key}"`, err);
-        return buildFallbackResult(typedErr, extra);
+        return buildFallbackResult2(typedErr, extra);
       }
     },
-    [buildFallbackResult, key, reconcile]
+    [buildFallbackResult2, key, reconcile]
   );
 }
 function useMnemonicKeyState(shared, config) {
@@ -1301,7 +1562,7 @@ function useMnemonicKeyState(shared, config) {
     hydrationMode,
     ssrOptions
   } = shared;
-  const { decodeForRead, encodeForWrite, additionalDevWarnings, onDecodedEffect } = config;
+  const { decodeForRead, encodeForWrite, active = true, additionalDevWarnings, onDecodedEffect } = config;
   const getServerRawSnapshot = useCallback(
     () => ssrOptions?.serverValue === void 0 ? null : SSR_SNAPSHOT_TOKEN,
     [ssrOptions?.serverValue]
@@ -1309,16 +1570,19 @@ function useMnemonicKeyState(shared, config) {
   const deferStorageRead = hydrationMode === "client-only" && !hasMounted;
   const subscribe = useCallback(
     (listener) => {
+      if (!active) {
+        return () => void 0;
+      }
       if (deferStorageRead) {
         return () => void 0;
       }
       return api.subscribeRaw(key, listener);
     },
-    [api, deferStorageRead, key]
+    [active, api, deferStorageRead, key]
   );
   const raw = useSyncExternalStore(
     subscribe,
-    () => deferStorageRead ? getServerRawSnapshot() : api.getRawSnapshot(key),
+    () => active && !deferStorageRead ? api.getRawSnapshot(key) : getServerRawSnapshot(),
     getServerRawSnapshot
   );
   const decoded = useMemo(() => {
@@ -1329,6 +1593,7 @@ function useMnemonicKeyState(shared, config) {
   }, [decodeForRead, getServerValue, raw]);
   const value = decoded.value;
   useEffect(() => {
+    if (!active) return;
     if (!developmentRuntime) return;
     const globalWindow = globalThis.window;
     if (listenCrossTab && (api.crossTabSyncMode ?? "none") === "none" && globalWindow !== void 0) {
@@ -1368,6 +1633,7 @@ function useMnemonicKeyState(shared, config) {
       `[Mnemonic] Conflicting useMnemonicKey contracts detected for key "${key}" in namespace "${api.prefix.slice(0, -1)}". Reuse a shared descriptor with defineMnemonicKey(...) or align defaultValue/codec/schema/reconcile options so every consumer describes the same persisted contract.`
     );
   }, [
+    active,
     additionalDevWarnings,
     api,
     key,
@@ -1383,28 +1649,33 @@ function useMnemonicKeyState(shared, config) {
     setHasMounted(true);
   }, [hasMounted, setHasMounted]);
   useEffect(() => {
+    if (!active) return;
     if (decoded.rewriteRaw && decoded.rewriteRaw !== raw) {
       api.setRaw(key, decoded.rewriteRaw);
     }
-  }, [api, decoded.rewriteRaw, key, raw]);
+  }, [active, api, decoded.rewriteRaw, key, raw]);
   useEffect(() => {
+    if (!active) return;
     onDecodedEffect?.(decoded);
-  }, [decoded, onDecodedEffect]);
+  }, [active, decoded, onDecodedEffect]);
   const prevRef = useRef(value);
   const mounted = useRef(false);
   useEffect(() => {
+    if (!active) return;
     if (mounted.current) return;
     mounted.current = true;
     onMount?.(value);
     prevRef.current = value;
-  }, []);
+  }, [active]);
   useEffect(() => {
+    if (!active) return;
     const prev = prevRef.current;
     if (Object.is(prev, value)) return;
     prevRef.current = value;
     onChange?.(value, prev);
-  }, [value, onChange]);
+  }, [active, value, onChange]);
   useEffect(() => {
+    if (!active) return;
     if (!listenCrossTab) return;
     const globalWindow = globalThis.window;
     if (globalWindow === void 0) return;
@@ -1423,8 +1694,11 @@ function useMnemonicKeyState(shared, config) {
     };
     globalWindow.addEventListener("storage", handler);
     return () => globalWindow.removeEventListener("storage", handler);
-  }, [listenCrossTab, api, key]);
+  }, [active, listenCrossTab, api, key]);
   const set = useMemo(() => {
+    if (!active) {
+      return () => void 0;
+    }
     return (next) => {
       const nextVal = typeof next === "function" ? next(decodeForRead(api.getRawSnapshot(key)).value) : next;
       try {
@@ -1442,8 +1716,11 @@ function useMnemonicKeyState(shared, config) {
         console.error(`[Mnemonic] Failed to persist key "${key}":`, err);
       }
     };
-  }, [api, key, decodeForRead, encodeForWrite]);
+  }, [active, api, key, decodeForRead, encodeForWrite]);
   const reset = useMemo(() => {
+    if (!active) {
+      return () => void 0;
+    }
     return () => {
       const v = getFallback();
       try {
@@ -1460,10 +1737,13 @@ function useMnemonicKeyState(shared, config) {
         return;
       }
     };
-  }, [api, key, getFallback, encodeForWrite]);
+  }, [active, api, key, getFallback, encodeForWrite]);
   const remove = useMemo(() => {
+    if (!active) {
+      return () => void 0;
+    }
     return () => api.removeRaw(key);
-  }, [api, key]);
+  }, [active, api, key]);
   return useMemo(
     () => ({
       value,
@@ -1476,12 +1756,12 @@ function useMnemonicKeyState(shared, config) {
 }
 
 // src/Mnemonic/use.ts
-function useSchemaMnemonicKey(descriptor) {
-  const shared = useMnemonicKeyShared(descriptor, void 0, descriptor.options.schema?.version);
-  const { api, key, codec, codecOpt, schema, reconcile, parseEnvelope, decodeStringPayload, buildFallbackResult } = shared;
+function useSchemaMnemonicKeyFromApi(store, descriptor, active = true) {
+  const shared = useMnemonicKeySharedFromApi(store, descriptor, void 0, descriptor.options.schema?.version);
+  const { api, key, codec, codecOpt, schema, reconcile, parseEnvelope: parseEnvelope2, decodeStringPayload: decodeStringPayload2, buildFallbackResult: buildFallbackResult2 } = shared;
   const schemaMode = api.schemaMode;
   const schemaRegistry = api.schemaRegistry;
-  const validateAgainstSchema = useCallback(
+  const validateAgainstSchema2 = useCallback(
     (value, jsonSchema) => {
       const errors = validateJsonSchema(value, jsonSchema);
       if (errors.length > 0) {
@@ -1500,7 +1780,7 @@ function useSchemaMnemonicKey(descriptor) {
       migrationPaths: /* @__PURE__ */ new Map()
     };
   }, [schemaRegistry, schemaMode, key]);
-  const getSchemaForVersion = useCallback(
+  const getSchemaForVersion2 = useCallback(
     (version) => {
       if (!schemaRegistry) return void 0;
       if (!registryCache) return schemaRegistry.getSchema(key, version);
@@ -1542,20 +1822,20 @@ function useSchemaMnemonicKey(descriptor) {
   const applyReconcile = useApplyReconcile({
     key,
     reconcile,
-    buildFallbackResult
+    buildFallbackResult: buildFallbackResult2
   });
-  const resolveTargetWriteSchema = useCallback(() => {
+  const resolveTargetWriteSchema2 = useCallback(() => {
     const explicitVersion = schema?.version;
     const latestSchema = getLatestSchemaForKey();
     if (explicitVersion === void 0) return latestSchema;
-    const explicitSchema = getSchemaForVersion(explicitVersion);
+    const explicitSchema = getSchemaForVersion2(explicitVersion);
     if (explicitSchema) return explicitSchema;
     return schemaMode === "strict" ? void 0 : latestSchema;
-  }, [getLatestSchemaForKey, getSchemaForVersion, schema?.version, schemaMode]);
+  }, [getLatestSchemaForKey, getSchemaForVersion2, schema?.version, schemaMode]);
   const encodeForWrite = useCallback(
     (nextValue) => {
       const explicitVersion = schema?.version;
-      const targetSchema = resolveTargetWriteSchema();
+      const targetSchema = resolveTargetWriteSchema2();
       if (!targetSchema) {
         if (explicitVersion !== void 0 && schemaMode === "strict") {
           throw new SchemaError(
@@ -1574,7 +1854,7 @@ function useSchemaMnemonicKey(descriptor) {
           throw err instanceof SchemaError ? err : new SchemaError("MIGRATION_FAILED", `Write-time migration failed for key "${key}"`, err);
         }
       }
-      validateAgainstSchema(valueToStore, targetSchema.schema);
+      validateAgainstSchema2(valueToStore, targetSchema.schema);
       return buildSchemaManagedResult(targetSchema.version, valueToStore);
     },
     [
@@ -1583,20 +1863,20 @@ function useSchemaMnemonicKey(descriptor) {
       schemaMode,
       codec,
       schemaRegistry,
-      validateAgainstSchema,
-      resolveTargetWriteSchema,
+      validateAgainstSchema2,
+      resolveTargetWriteSchema2,
       buildSchemaManagedResult
     ]
   );
-  const decodeAutoschemaEnvelope = useCallback(
+  const decodeAutoschemaEnvelope2 = useCallback(
     (envelope, latestSchema) => {
       if (latestSchema) {
-        return buildFallbackResult(
+        return buildFallbackResult2(
           new SchemaError("SCHEMA_NOT_FOUND", `No schema for key "${key}" v${envelope.version}`)
         );
       }
       if (!schemaRegistry || typeof schemaRegistry.registerSchema !== "function") {
-        return buildFallbackResult(
+        return buildFallbackResult2(
           new SchemaError(
             "MODE_CONFIGURATION_INVALID",
             `Autoschema mode requires schema registry registration for key "${key}"`
@@ -1604,7 +1884,7 @@ function useSchemaMnemonicKey(descriptor) {
         );
       }
       try {
-        const decoded = typeof envelope.payload === "string" ? decodeStringPayload(envelope.payload, codec) : envelope.payload;
+        const decoded = typeof envelope.payload === "string" ? decodeStringPayload2(envelope.payload, codec) : envelope.payload;
         const inferSchemaForValue = (value) => ({
           key,
           version: 1,
@@ -1623,20 +1903,20 @@ function useSchemaMnemonicKey(descriptor) {
         });
       } catch (err) {
         const typedErr = err instanceof SchemaError || err instanceof CodecError ? err : new SchemaError("TYPE_MISMATCH", `Autoschema inference failed for key "${key}"`, err);
-        return buildFallbackResult(typedErr);
+        return buildFallbackResult2(typedErr);
       }
     },
     [
       applyReconcile,
-      buildFallbackResult,
+      buildFallbackResult2,
       buildSchemaManagedResult,
       codec,
-      decodeStringPayload,
+      decodeStringPayload2,
       key,
       schemaRegistry
     ]
   );
-  const decodeCodecManagedEnvelope = useCallback(
+  const decodeCodecManagedEnvelope2 = useCallback(
     (envelope, latestSchema) => {
       if (typeof envelope.payload !== "string") {
         return applyReconcile({
@@ -1647,7 +1927,7 @@ function useSchemaMnemonicKey(descriptor) {
         });
       }
       try {
-        const decoded = decodeStringPayload(envelope.payload, codec);
+        const decoded = decodeStringPayload2(envelope.payload, codec);
         return applyReconcile({
           value: decoded,
           persistedVersion: envelope.version,
@@ -1655,20 +1935,20 @@ function useSchemaMnemonicKey(descriptor) {
           serializeForPersist: encodeForWrite
         });
       } catch (err) {
-        return buildFallbackResult(err);
+        return buildFallbackResult2(err);
       }
     },
-    [applyReconcile, buildFallbackResult, codec, decodeStringPayload, encodeForWrite]
+    [applyReconcile, buildFallbackResult2, codec, decodeStringPayload2, encodeForWrite]
   );
-  const decodeSchemaManagedEnvelope = useCallback(
+  const decodeSchemaManagedEnvelope2 = useCallback(
     (envelope, schemaForVersion, latestSchema) => {
       let current;
       try {
         current = envelope.payload;
-        validateAgainstSchema(current, schemaForVersion.schema);
+        validateAgainstSchema2(current, schemaForVersion.schema);
       } catch (err) {
         const typedErr = err instanceof SchemaError || err instanceof CodecError ? err : new SchemaError("TYPE_MISMATCH", `Schema decode failed for key "${key}"`, err);
-        return buildFallbackResult(typedErr);
+        return buildFallbackResult2(typedErr);
       }
       if (!latestSchema || envelope.version >= latestSchema.version) {
         return applyReconcile({
@@ -1680,7 +1960,7 @@ function useSchemaMnemonicKey(descriptor) {
       }
       const path = getMigrationPathForKey(envelope.version, latestSchema.version);
       if (!path) {
-        return buildFallbackResult(
+        return buildFallbackResult2(
           new SchemaError(
             "MIGRATION_PATH_NOT_FOUND",
             `No migration path for key "${key}" from v${envelope.version} to v${latestSchema.version}`
@@ -1692,7 +1972,7 @@ function useSchemaMnemonicKey(descriptor) {
         for (const step of path) {
           migrated = step.migrate(migrated);
         }
-        validateAgainstSchema(migrated, latestSchema.schema);
+        validateAgainstSchema2(migrated, latestSchema.schema);
         return applyReconcile({
           value: migrated,
           rewriteRaw: buildSchemaManagedResult(latestSchema.version, migrated),
@@ -1702,48 +1982,48 @@ function useSchemaMnemonicKey(descriptor) {
         });
       } catch (err) {
         const typedErr = err instanceof SchemaError || err instanceof CodecError ? err : new SchemaError("MIGRATION_FAILED", `Migration failed for key "${key}"`, err);
-        return buildFallbackResult(typedErr);
+        return buildFallbackResult2(typedErr);
       }
     },
     [
       applyReconcile,
-      buildFallbackResult,
+      buildFallbackResult2,
       buildSchemaManagedResult,
       encodeForWrite,
       getMigrationPathForKey,
       key,
-      validateAgainstSchema
+      validateAgainstSchema2
     ]
   );
   const decodeForRead = useCallback(
     (rawText) => {
-      if (rawText == null) return buildFallbackResult();
-      const parsed = parseEnvelope(rawText);
-      if (!parsed.ok) return buildFallbackResult(parsed.error);
+      if (rawText == null) return buildFallbackResult2();
+      const parsed = parseEnvelope2(rawText);
+      if (!parsed.ok) return buildFallbackResult2(parsed.error);
       const envelope = parsed.envelope;
-      const schemaForVersion = getSchemaForVersion(envelope.version);
+      const schemaForVersion = getSchemaForVersion2(envelope.version);
       const latestSchema = getLatestSchemaForKey();
       if (schemaMode === "strict" && !schemaForVersion) {
-        return buildFallbackResult(
+        return buildFallbackResult2(
           new SchemaError("SCHEMA_NOT_FOUND", `No schema for key "${key}" v${envelope.version}`)
         );
       }
       if (schemaMode === "autoschema" && !schemaForVersion) {
-        return decodeAutoschemaEnvelope(envelope, latestSchema);
+        return decodeAutoschemaEnvelope2(envelope, latestSchema);
       }
       if (!schemaForVersion) {
-        return decodeCodecManagedEnvelope(envelope, latestSchema);
+        return decodeCodecManagedEnvelope2(envelope, latestSchema);
       }
-      return decodeSchemaManagedEnvelope(envelope, schemaForVersion, latestSchema);
+      return decodeSchemaManagedEnvelope2(envelope, schemaForVersion, latestSchema);
     },
     [
-      buildFallbackResult,
-      decodeAutoschemaEnvelope,
-      decodeCodecManagedEnvelope,
-      decodeSchemaManagedEnvelope,
-      parseEnvelope,
+      buildFallbackResult2,
+      decodeAutoschemaEnvelope2,
+      decodeCodecManagedEnvelope2,
+      decodeSchemaManagedEnvelope2,
+      parseEnvelope2,
       schemaMode,
-      getSchemaForVersion,
+      getSchemaForVersion2,
       getLatestSchemaForKey,
       key
     ]
@@ -1770,12 +2050,16 @@ function useSchemaMnemonicKey(descriptor) {
     [schemaRegistry]
   );
   return useMnemonicKeyState(shared, {
+    active,
     decodeForRead,
     encodeForWrite,
     additionalDevWarnings,
     onDecodedEffect
   });
 }
+function useSchemaMnemonicKey(descriptor) {
+  return useSchemaMnemonicKeyFromApi(useMnemonic(), descriptor);
+}
 function useMnemonicKey(keyOrDescriptor, options) {
   return useSchemaMnemonicKey(resolveMnemonicKeyArgs(keyOrDescriptor, options));
 }
@@ -1797,11 +2081,17 @@ function warnRecoveryOnce(api, id, message) {
   console.warn(message);
 }
 function useMnemonicRecovery(options = {}) {
-  const api = useMnemonic();
+  return useMnemonicRecoveryFromApi(useMnemonic(), options);
+}
+function useMnemonicRecoveryFromApi(api, options = {}, active = true) {
   const { onRecover } = options;
-  const namespace = useMemo(() => api.prefix.endsWith(".") ? api.prefix.slice(0, -1) : api.prefix, [api.prefix]);
+  const namespace = useMemo(() => {
+    if (!active) return "";
+    return api.prefix.endsWith(".") ? api.prefix.slice(0, -1) : api.prefix;
+  }, [active, api.prefix]);
   const emitRecovery = useCallback(
     (action, clearedKeys) => {
+      if (!active) return;
       const event = {
         action,
         namespace,
@@ -1809,11 +2099,12 @@ function useMnemonicRecovery(options = {}) {
       };
       onRecover?.(event);
     },
-    [namespace, onRecover]
+    [active, namespace, onRecover]
   );
-  const listKeys = useCallback(() => api.keys(), [api]);
+  const listKeys = useCallback(() => active ? api.keys() : [], [active, api]);
   const clearResolvedKeys = useCallback(
     (action, keys) => {
+      if (!active) return [];
       const clearedKeys = uniqueKeys(keys);
       for (const key of clearedKeys) {
         api.removeRaw(key);
@@ -1821,13 +2112,14 @@ function useMnemonicRecovery(options = {}) {
       emitRecovery(action, clearedKeys);
       return clearedKeys;
     },
-    [api, emitRecovery]
+    [active, api, emitRecovery]
   );
   const clearKeys = useCallback(
     (keys) => clearResolvedKeys("clear-keys", keys),
     [clearResolvedKeys]
   );
   const clearAll = useCallback(() => {
+    if (!active) return [];
     if (!api.canEnumerateKeys) {
       if (isDevelopmentRuntime2()) {
         warnRecoveryOnce(
@@ -1841,9 +2133,10 @@ function useMnemonicRecovery(options = {}) {
       );
     }
     return clearResolvedKeys("clear-all", api.keys());
-  }, [api, clearResolvedKeys, namespace]);
+  }, [active, api, clearResolvedKeys, namespace]);
   const clearMatching = useCallback(
     (predicate) => {
+      if (!active) return [];
       if (!api.canEnumerateKeys) {
         if (isDevelopmentRuntime2()) {
           warnRecoveryOnce(
@@ -1861,18 +2154,18 @@ function useMnemonicRecovery(options = {}) {
         api.keys().filter((key) => predicate(key))
       );
     },
-    [api, clearResolvedKeys, namespace]
+    [active, api, clearResolvedKeys, namespace]
   );
   return useMemo(
     () => ({
       namespace,
-      canEnumerateKeys: api.canEnumerateKeys,
+      canEnumerateKeys: active ? api.canEnumerateKeys : false,
       listKeys,
       clearAll,
       clearKeys,
       clearMatching
     }),
-    [namespace, api.canEnumerateKeys, listKeys, clearAll, clearKeys, clearMatching]
+    [namespace, active, api.canEnumerateKeys, listKeys, clearAll, clearKeys, clearMatching]
   );
 }