react-mnemonic 1.3.0 → 1.4.0

package/dist/bootstrap.cjs

@@ -0,0 +1,864 @@
+'use strict';
+
+// 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/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;
+  }
+}
+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 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 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 a === "object") {
+    if (Array.isArray(b)) return false;
+    return jsonDeepEqualObject(a, b);
+  }
+  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;
+}
+function isJsonPrimitive(value) {
+  return value === null || typeof value !== "object";
+}
+function isJsonObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function objectHasOwn(value, property) {
+  const hasOwn = Object.hasOwn;
+  if (typeof hasOwn === "function") {
+    return hasOwn(value, property);
+  }
+  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) => [];
+  }
+  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 buildEnumValidationStep(schema) {
+  if (schema.enum === void 0) {
+    return null;
+  }
+  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;
+  }
+  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 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;
+  }
+  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 (propertyValidators !== null) {
+    objectValidationSteps.push(createDeclaredPropertyStep(propertyValidators));
+  }
+  if (checkAdditional) {
+    objectValidationSteps.push(
+      createAdditionalPropertyStep({
+        additionalIsFalse,
+        additionalValidator,
+        definedPropKeys: definedPropKeys ?? /* @__PURE__ */ new Set()
+      })
+    );
+  }
+  if (objectValidationSteps.length === 0) {
+    return null;
+  }
+  return (value, path, errors) => {
+    if (!isJsonObjectRecord(value)) {
+      return;
+    }
+    for (const step of objectValidationSteps) {
+      step(value, path, errors);
+    }
+  };
+}
+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 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 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}`));
+    }
+  };
+}
+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"
+      });
+    }
+    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 {};
+  }
+}
+
+// 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}"`);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof SchemaError) {
+      throw error;
+    }
+    throw new SchemaError("INVALID_ENVELOPE", `Invalid envelope for key "${key}"`, error);
+  }
+}
+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
+}) {
+  const latestSchema = getLatestSchema(schemaRegistry, key);
+  if (explicitVersion === void 0) {
+    return latestSchema;
+  }
+  const explicitSchema = getSchemaForVersion(schemaRegistry, key, explicitVersion);
+  if (explicitSchema) {
+    return explicitSchema;
+  }
+  return schemaMode === "strict" ? void 0 : latestSchema;
+}
+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/runtime.ts
+function getDefaultBrowserStorage() {
+  const globalWindow = globalThis.window;
+  if (globalWindow === void 0) return void 0;
+  try {
+    return globalWindow.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/Mnemonic/bootstrap.ts
+function isPromiseLike(value) {
+  if (value == null) return false;
+  if (typeof value !== "object" && typeof value !== "function") return false;
+  return typeof value.then === "function";
+}
+function resolveBootstrapInput(input) {
+  if ("options" in input) {
+    return input;
+  }
+  const { key, ...options } = input;
+  return {
+    key,
+    options
+  };
+}
+function resolveFallback(defaultValue, error) {
+  return typeof defaultValue === "function" ? defaultValue(error) : defaultValue;
+}
+function encodeForWrite(key, nextValue, options, schemaMode, schemaRegistry) {
+  return encodePersistedValueForWrite({
+    key,
+    nextValue,
+    codec: options.codec ?? JSONCodec,
+    explicitVersion: options.schema?.version,
+    schemaMode,
+    schemaRegistry
+  });
+}
+function applyReconcile({
+  key,
+  value,
+  options,
+  persistedVersion,
+  latestVersion,
+  rewriteRaw,
+  schemaMode,
+  schemaRegistry,
+  serializeForPersist
+}) {
+  const reconcile = options.reconcile;
+  if (!reconcile) {
+    return { value, ...rewriteRaw === void 0 ? {} : { rewriteRaw } };
+  }
+  const persist = serializeForPersist ?? ((nextValue) => encodeForWrite(key, nextValue, options, schemaMode, schemaRegistry));
+  const baselineSerialized = (() => {
+    try {
+      return persist(value);
+    } catch {
+      return rewriteRaw;
+    }
+  })();
+  try {
+    const reconciled = reconcile(value, {
+      key,
+      persistedVersion,
+      ...latestVersion === void 0 ? {} : { latestVersion }
+    });
+    const nextSerialized = persist(reconciled);
+    const nextRewriteRaw = baselineSerialized === void 0 || nextSerialized !== baselineSerialized ? nextSerialized : rewriteRaw;
+    return {
+      value: reconciled,
+      ...nextRewriteRaw === void 0 ? {} : { rewriteRaw: nextRewriteRaw }
+    };
+  } catch (error) {
+    const typedError = error instanceof SchemaError ? error : new SchemaError("RECONCILE_FAILED", `Reconciliation failed for key "${key}"`, error);
+    return {
+      value: resolveFallback(options.defaultValue, typedError)
+    };
+  }
+}
+function buildFallbackResult(options, error) {
+  return {
+    value: resolveFallback(options.defaultValue, error)
+  };
+}
+function decodeCodecManagedEnvelope({
+  key,
+  envelope,
+  options,
+  latestSchema,
+  schemaMode,
+  schemaRegistry
+}) {
+  if (typeof envelope.payload !== "string") {
+    return applyReconcile({
+      key,
+      value: envelope.payload,
+      options,
+      persistedVersion: envelope.version,
+      ...latestSchema ? { latestVersion: latestSchema.version } : {},
+      schemaMode,
+      schemaRegistry
+    });
+  }
+  try {
+    const decoded = decodeStringPayload(key, envelope.payload, options.codec ?? JSONCodec);
+    return applyReconcile({
+      key,
+      value: decoded,
+      options,
+      persistedVersion: envelope.version,
+      ...latestSchema ? { latestVersion: latestSchema.version } : {},
+      schemaMode,
+      schemaRegistry
+    });
+  } catch (error) {
+    return buildFallbackResult(options, error);
+  }
+}
+function decodeAutoschemaEnvelope({
+  key,
+  envelope,
+  options,
+  latestSchema,
+  schemaRegistry,
+  schemaMode
+}) {
+  if (latestSchema) {
+    return buildFallbackResult(
+      options,
+      new SchemaError("SCHEMA_NOT_FOUND", `No schema for key "${key}" v${envelope.version}`)
+    );
+  }
+  if (!schemaRegistry?.registerSchema) {
+    return buildFallbackResult(
+      options,
+      new SchemaError(
+        "MODE_CONFIGURATION_INVALID",
+        `Autoschema mode requires schema registry registration for key "${key}"`
+      )
+    );
+  }
+  try {
+    const decoded = typeof envelope.payload === "string" ? decodeStringPayload(key, envelope.payload, options.codec ?? JSONCodec) : envelope.payload;
+    const inferredVersion = 1;
+    inferJsonSchema(decoded);
+    return applyReconcile({
+      key,
+      value: decoded,
+      options,
+      persistedVersion: envelope.version,
+      rewriteRaw: serializeEnvelope(inferredVersion, decoded),
+      schemaMode,
+      schemaRegistry,
+      serializeForPersist: (value) => serializeEnvelope(inferredVersion, value)
+    });
+  } catch (error) {
+    const typedError = error instanceof SchemaError || error instanceof CodecError ? error : new SchemaError("TYPE_MISMATCH", `Autoschema inference failed for key "${key}"`, error);
+    return buildFallbackResult(options, typedError);
+  }
+}
+function decodeSchemaManagedEnvelope({
+  key,
+  envelope,
+  options,
+  schemaForVersion,
+  latestSchema,
+  schemaMode,
+  schemaRegistry
+}) {
+  let current;
+  try {
+    current = envelope.payload;
+    validateAgainstSchema(key, current, schemaForVersion.schema);
+  } catch (error) {
+    const typedError = error instanceof SchemaError || error instanceof CodecError ? error : new SchemaError("TYPE_MISMATCH", `Schema decode failed for key "${key}"`, error);
+    return buildFallbackResult(options, typedError);
+  }
+  if (!latestSchema || envelope.version >= latestSchema.version) {
+    return applyReconcile({
+      key,
+      value: current,
+      options,
+      persistedVersion: envelope.version,
+      ...latestSchema ? { latestVersion: latestSchema.version } : {},
+      schemaMode,
+      schemaRegistry
+    });
+  }
+  const path = getMigrationPath(schemaRegistry, key, envelope.version, latestSchema.version);
+  if (!path) {
+    return buildFallbackResult(
+      options,
+      new SchemaError(
+        "MIGRATION_PATH_NOT_FOUND",
+        `No migration path for key "${key}" from v${envelope.version} to v${latestSchema.version}`
+      )
+    );
+  }
+  try {
+    let migrated = current;
+    for (const step of path) {
+      migrated = step.migrate(migrated);
+    }
+    validateAgainstSchema(key, migrated, latestSchema.schema);
+    return applyReconcile({
+      key,
+      value: migrated,
+      options,
+      persistedVersion: envelope.version,
+      latestVersion: latestSchema.version,
+      rewriteRaw: serializeEnvelope(latestSchema.version, migrated),
+      schemaMode,
+      schemaRegistry
+    });
+  } catch (error) {
+    const typedError = error instanceof SchemaError || error instanceof CodecError ? error : new SchemaError("MIGRATION_FAILED", `Migration failed for key "${key}"`, error);
+    return buildFallbackResult(options, typedError);
+  }
+}
+function decodeForRead({
+  key,
+  raw,
+  options,
+  schemaMode,
+  schemaRegistry
+}) {
+  if (raw == null) {
+    return buildFallbackResult(options);
+  }
+  try {
+    const envelope = parseEnvelope(key, raw);
+    const latestSchema = getLatestSchema(schemaRegistry, key);
+    const schemaForVersion = getSchemaForVersion(schemaRegistry, key, envelope.version);
+    if (schemaMode === "strict" && !schemaForVersion) {
+      return buildFallbackResult(
+        options,
+        new SchemaError("SCHEMA_NOT_FOUND", `No schema for key "${key}" v${envelope.version}`)
+      );
+    }
+    if (schemaMode === "autoschema" && !schemaForVersion) {
+      return decodeAutoschemaEnvelope({
+        key,
+        envelope,
+        options,
+        latestSchema,
+        schemaRegistry,
+        schemaMode
+      });
+    }
+    if (!schemaForVersion) {
+      return decodeCodecManagedEnvelope({
+        key,
+        envelope,
+        options,
+        latestSchema,
+        schemaMode,
+        schemaRegistry
+      });
+    }
+    return decodeSchemaManagedEnvelope({
+      key,
+      envelope,
+      options,
+      schemaForVersion,
+      latestSchema,
+      schemaMode,
+      schemaRegistry
+    });
+  } catch (error) {
+    return buildFallbackResult(options, error);
+  }
+}
+function readStorageRaw(storage, storageKey) {
+  if (!storage) {
+    return {
+      readable: false,
+      raw: null
+    };
+  }
+  try {
+    const raw = storage.getItem(storageKey);
+    if (isPromiseLike(raw)) {
+      void Promise.resolve(raw).catch(() => void 0);
+      return {
+        readable: false,
+        raw: null
+      };
+    }
+    return {
+      readable: true,
+      raw: typeof raw === "string" ? raw : null
+    };
+  } catch {
+    return {
+      readable: false,
+      raw: null
+    };
+  }
+}
+function assertRecallSchemaConfiguration(schemaMode, schemaRegistry) {
+  if (schemaMode === "strict" && !schemaRegistry) {
+    throw new Error("recallMnemonic strict mode requires schemaRegistry");
+  }
+  if (schemaMode === "autoschema" && typeof schemaRegistry?.registerSchema !== "function") {
+    throw new Error("recallMnemonic autoschema mode requires schemaRegistry.registerSchema");
+  }
+}
+function recallMnemonic(options) {
+  const storage = options.storage ?? getDefaultBrowserStorage();
+  const schemaMode = options.schemaMode ?? "default";
+  assertRecallSchemaConfiguration(schemaMode, options.schemaRegistry);
+  const prefix = `${options.namespace}.`;
+  const values = {};
+  const raw = {};
+  for (const entry of options.keys) {
+    const resolved = resolveBootstrapInput(entry);
+    const snapshot = readStorageRaw(storage, `${prefix}${resolved.key}`);
+    if (snapshot.readable) {
+      raw[resolved.key] = snapshot.raw;
+    }
+    values[resolved.key] = decodeForRead({
+      key: resolved.key,
+      raw: snapshot.raw,
+      options: resolved.options,
+      schemaMode,
+      schemaRegistry: options.schemaRegistry
+    }).value;
+  }
+  return {
+    raw,
+    values
+  };
+}
+function applyMnemonicBootstrap({
+  snapshot,
+  apply
+}) {
+  apply(snapshot.values);
+  return snapshot.values;
+}
+
+exports.CodecError = CodecError;
+exports.JSONCodec = JSONCodec;
+exports.SchemaError = SchemaError;
+exports.applyMnemonicBootstrap = applyMnemonicBootstrap;
+exports.createCodec = createCodec;
+exports.recallMnemonic = recallMnemonic;
+//# sourceMappingURL=bootstrap.cjs.map
+//# sourceMappingURL=bootstrap.cjs.map