@pixerate/editor 0.22.0 → 0.24.0

package/dist/persistence/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/persistence/index.cjs","../../src/persistence/recoveryPolicy.ts","../../src/persistence/storage.ts","../../src/persistence/autosave.ts","../../src/persistence/revisions.ts"],"names":[],"mappings":"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AA;AACU,YAAA;AACD,YAAA;AAElB,UAAA;AACA,UAAA;AACA,UAAA;AACF,QAAA;AACE,UAAA;AACF,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACE,UAAA;AACA,UAAA;AACF,QAAA;AACE,UAAA;AACF,QAAA;AACA,QAAA;AACC,MAAA;AACL,IAAA;AACE,MAAA;AACA,MAAA;AACE,QAAA;AACA,QAAA;AACA,QAAA;AACE,UAAA;AACA,UAAA;AACF,QAAA;AACE,UAAA;AACF,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AAEE,UAAA;AACA,UAAA;AACF,QAAA;AACE,UAAA;AACF,QAAA;AACA,QAAA;AACC,MAAA;AACL,IAAA;AACE,MAAA;AACA,MAAA;AACE,QAAA;AAGF,MAAA;AACF,IAAA;AACE,MAAA;AACF,IAAA;AACE,MAAA;AACF,IAAA;AACF,EAAA;AAES,EAAA;AACH,IAAA;AACE,IAAA;AACA,IAAA;AACA,IAAA;AACD,IAAA;AACC,MAAA;AACJ,MAAA;AACF,IAAA;AACM,IAAA;AACN,IAAA;AACI,IAAA;AACF,MAAA;AACA,MAAA;AACI,MAAA;AACF,QAAA;AACA,QAAA;AACA,QAAA;AACF,MAAA;AACF,IAAA;AACI,IAAA;AACN,EAAA;AAEM,EAAA;AACG,IAAA;AACT,EAAA;AAEO,EAAA;AACL,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACE,QAAA;AACF,MAAA;AACF,IAAA;AACA,IAAA;AACM,MAAA;AACJ,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACI,MAAA;AACF,QAAA;AACF,MAAA;AACK,MAAA;AAEL,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACA,IAAA;AACM,MAAA;AACJ,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACI,IAAA;AACF,MAAA;AACF,IAAA;AACM,IAAA;AACA,MAAA;AACJ,MAAA;AACA,MAAA;AACA,MAAA;AACK,MAAA;AACL,MAAA;AACF,IAAA;AACM,IAAA;AACA,MAAA;AACJ,MAAA;AACA,MAAA;AACK,MAAA;AACL,MAAA;AACF,IAAA;AACM,IAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACF,QAAA;AACA,QAAA;AACA,QAAA;AACF,MAAA;AACE,QAAA;AACF,MAAA;AACK,MAAA;AACL,MAAA;AACI,MAAA;AACA,MAAA;AACF,QAAA;AACF,MAAA;AACE,QAAA;AACF,MAAA;AACF,IAAA;AACM,IAAA;AACA,MAAA;AACJ,MAAA;AACA,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACF,EAAA;AACF;AHkKW;AACA;AIjiBK;AACV,EAAA;AACA,EAAA;AACE,EAAA;AACA,EAAA;AAEE,IAAA;AACF,MAAA;AACF,IAAA;AACE,MAAA;AACF,IAAA;AACD,EAAA;AACG,EAAA;AAEA,IAAA;AACN,EAAA;AAEM,EAAA;AACF,EAAA;AACF,IAAA;AACE,MAAA;AACE,QAAA;AACA,QAAA;AACD,MAAA;AACH,IAAA;AACF,EAAA;AACI,EAAA;AACE,IAAA;AACJ,IAAA;AACE,MAAA;AACE,QAAA;AACE,UAAA;AAEA,UAAA;AACA,UAAA;AACF,QAAA;AACA,QAAA;AACA,QAAA;AACA,QAAA;AACD,MAAA;AACH,IAAA;AACF,EAAA;AAEO,EAAA;AACL,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACF,IAAA;AACO,IAAA;AACL,MAAA;AACK,MAAA;AACP,IAAA;AACA,IAAA;AACE,MAAA;AACK,MAAA;AACP,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACE,QAAA;AACF,MAAA;AACF,IAAA;AACA,IAAA;AACE,MAAA;AACA,MAAA;AACA,MAAA;AACF,IAAA;AACF,EAAA;AACF;AJ8hBW;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/editor/editor/packages/core/dist/persistence/index.cjs","sourcesContent":[null,"// Portions ported from filmcraft-main/apps/filmcraft-web/src/recovery_policy.rs (MIT OR Apache-2.0,\n// © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.\n\n/**\n * What the caller should do now (see `RecoveryPolicy.tick`).\n *\n * - `writeSnapshot`: write the snapshot and a dirty meta for `revision`, then report with `written`.\n * - `writeClean`: write a clean meta (retire the snapshot), then report with `cleaned`.\n * - `wakeAfter`: nothing now; tick again after `delay` (same unit as `now`).\n */\nexport type RecoveryAction =\n  | { type: \"nothing\" }\n  | { type: \"writeSnapshot\"; revision: number }\n  | { type: \"writeClean\" }\n  | { type: \"wakeAfter\"; delay: number };\n\nexport interface RecoveryPolicyOptions {\n  /**\n   * Minimum time between snapshots of a changing document, in the unit of `now`\n   * (default 5000, i.e. milliseconds).\n   */\n  interval?: number;\n  /**\n   * Wait before retrying after the `failures`-th consecutive failed write\n   * (default: `interval`, as in FilmCraft). Use `exponentialBackoff` for doubling delays.\n   */\n  retryDelay?: (failures: number) => number;\n}\n\nexport interface RecoveryTickOptions {\n  /** Ignore the interval and any retry wait (e.g. on `pagehide`). */\n  force?: boolean;\n}\n\nexport interface RecoveryPolicy {\n  /** Called whenever something may have changed, with the revisions and the current time. */\n  tick(\n    now: number,\n    revision: number,\n    savedRevision: number,\n    options?: RecoveryTickOptions,\n  ): RecoveryAction;\n  /** The snapshot write for `revision` finished. */\n  written(revision: number, ok: boolean, now: number): void;\n  /** The clean-meta write finished. */\n  cleaned(ok: boolean, now: number): void;\n  /** Whether this session wrote a dirty snapshot that is not retired yet. */\n  readonly ownsSnapshot: boolean;\n  /** Consecutive failed writes (reset by a successful one). */\n  readonly failures: number;\n}\n\n/**\n * Exponential backoff: `base`, `2·base`, `4·base`, … capped at `max`.\n * `failures` is 1 for the first failure.\n */\nexport function exponentialBackoff(\n  failures: number,\n  base = 1000,\n  max = 30000,\n): number {\n  const exp = Math.min(Math.max(failures - 1, 0), 16);\n  return Math.min(base * 2 ** exp, max);\n}\n\n/**\n * Pure state machine deciding when a crash-recovery snapshot is written or\n * retired. Deterministic: time is always passed in.\n *\n * - A dirty document is snapshotted at most every `interval`, once per revision.\n *   A write that fails is retried after `retryDelay`, without waiting for another edit.\n * - The snapshot is marked clean only if this session wrote it. A snapshot left by an\n *   earlier session (that was not restored) stays dirty, so it can still be recovered.\n * - An edit made while the clean write is in flight keeps the snapshot owned.\n */\nexport function createRecoveryPolicy(\n  options: RecoveryPolicyOptions = {},\n): RecoveryPolicy {\n  const interval = options.interval ?? 5000;\n  const retryDelay = options.retryDelay ?? (() => interval);\n  const minWake = interval * 0.01;\n\n  /** Revision whose snapshot was last written or is being written. */\n  let lastRevision: number | null = null;\n  let lastTime: number | null = null;\n  /** Required gap after `lastTime`: the interval, or the retry delay after a failure. */\n  let gap = interval;\n  /** This session wrote a dirty meta that is not yet retired. */\n  let ownsDirtyMeta = false;\n  /** A clean-meta write is in flight. */\n  let cleaning = false;\n  /** Snapshot writes started so far, and how many had started when the clean write did. */\n  let snapshots = 0;\n  let snapshotsAtClean = 0;\n  let failures = 0;\n\n  const fail = (now: number) => {\n    failures++;\n    lastRevision = null;\n    lastTime = now;\n    gap = retryDelay(failures);\n  };\n\n  return {\n    tick(now, revision, savedRevision, tickOptions) {\n      const force = tickOptions?.force === true;\n      const since = force || lastTime === null ? Infinity : now - lastTime;\n      if (revision !== savedRevision) {\n        if (lastRevision === revision) return { type: \"nothing\" };\n        if (since >= gap) {\n          lastRevision = revision;\n          lastTime = now;\n          ownsDirtyMeta = true;\n          snapshots++;\n          return { type: \"writeSnapshot\", revision };\n        }\n        return { type: \"wakeAfter\", delay: Math.max(gap - since, minWake) };\n      }\n      if (ownsDirtyMeta && !cleaning) {\n        if (lastRevision !== null || since >= gap) {\n          cleaning = true;\n          snapshotsAtClean = snapshots;\n          return { type: \"writeClean\" };\n        }\n        return { type: \"wakeAfter\", delay: Math.max(gap - since, minWake) };\n      }\n      return { type: \"nothing\" };\n    },\n    written(revision, ok, now) {\n      if (ok) {\n        if (lastRevision === revision) {\n          failures = 0;\n          gap = interval;\n        }\n      } else if (lastRevision === revision) {\n        // retry after the delay, even if nothing else changes\n        fail(now);\n      }\n    },\n    cleaned(ok, now) {\n      cleaning = false;\n      if (ok) {\n        ownsDirtyMeta = snapshots !== snapshotsAtClean;\n        failures = 0;\n        gap = interval;\n      } else {\n        fail(now);\n      }\n    },\n    get ownsSnapshot() {\n      return ownsDirtyMeta;\n    },\n    get failures() {\n      return failures;\n    },\n  };\n}\n","/**\n * Key/value storage adapters for autosave and crash recovery. Every adapter is\n * async, stores strings, feature-detects its backend (an unavailable backend\n * rejects every call with `StorageUnavailableError` instead of throwing at\n * construction, so SSR and old browsers are safe) and accepts an injectable\n * failure mode for tests.\n */\n\nexport type StorageOperation = \"get\" | \"set\" | \"remove\";\n\n/**\n * Injected failure: return `true` (or an `Error`) to make that operation fail.\n * Example: `failure: (op) => op === \"set\"` simulates a full disk.\n */\nexport type StorageFailureMode = (\n  operation: StorageOperation,\n  key: string,\n) => boolean | Error | undefined | void;\n\nexport interface StorageAdapter {\n  /** Short backend name, e.g. `\"memory\"`, `\"localStorage\"`, `\"indexedDB\"`, `\"opfs\"`. */\n  readonly kind: string;\n  /** Whether the backend was found. When `false`, every call rejects. */\n  readonly available: boolean;\n  get(key: string): Promise<string | null>;\n  set(key: string, value: string): Promise<void>;\n  remove(key: string): Promise<void>;\n}\n\nexport interface StorageAdapterOptions {\n  failure?: StorageFailureMode;\n}\n\nexport class StorageUnavailableError extends Error {\n  constructor(kind: string) {\n    super(`${kind} storage is not available in this environment`);\n    this.name = \"StorageUnavailableError\";\n  }\n}\n\nexport class InjectedStorageError extends Error {\n  constructor(operation: StorageOperation, key: string) {\n    super(`injected ${operation} failure for \"${key}\"`);\n    this.name = \"InjectedStorageError\";\n  }\n}\n\nfunction checkFailure(\n  failure: StorageFailureMode | undefined,\n  operation: StorageOperation,\n  key: string,\n): void {\n  if (!failure) return;\n  const result = failure(operation, key);\n  if (result instanceof Error) throw result;\n  if (result) throw new InjectedStorageError(operation, key);\n}\n\n/** Wraps an adapter so `failure` can make any of its operations fail. */\nexport function withStorageFailures(\n  inner: StorageAdapter,\n  failure: StorageFailureMode,\n): StorageAdapter {\n  return {\n    kind: inner.kind,\n    get available() {\n      return inner.available;\n    },\n    async get(key) {\n      checkFailure(failure, \"get\", key);\n      return inner.get(key);\n    },\n    async set(key, value) {\n      checkFailure(failure, \"set\", key);\n      return inner.set(key, value);\n    },\n    async remove(key) {\n      checkFailure(failure, \"remove\", key);\n      return inner.remove(key);\n    },\n  };\n}\n\nfunction guarded(\n  kind: string,\n  isAvailable: () => boolean,\n  failure: StorageFailureMode | undefined,\n  impl: Omit<StorageAdapter, \"kind\" | \"available\">,\n): StorageAdapter {\n  const check = (operation: StorageOperation, key: string) => {\n    if (!isAvailable()) throw new StorageUnavailableError(kind);\n    checkFailure(failure, operation, key);\n  };\n  return {\n    kind,\n    get available() {\n      return isAvailable();\n    },\n    async get(key) {\n      check(\"get\", key);\n      return impl.get(key);\n    },\n    async set(key, value) {\n      check(\"set\", key);\n      return impl.set(key, value);\n    },\n    async remove(key) {\n      check(\"remove\", key);\n      return impl.remove(key);\n    },\n  };\n}\n\n// ---------------------------------------------------------------- memory\n\nexport interface MemoryStorage extends StorageAdapter {\n  /** The underlying map (inspect it in tests). */\n  readonly entries: Map<string, string>;\n}\n\n/** In-memory storage (tests, SSR, or a session-only fallback). */\nexport function createMemoryStorage(\n  options: StorageAdapterOptions & { initial?: Record<string, string> } = {},\n): MemoryStorage {\n  const entries = new Map<string, string>(Object.entries(options.initial ?? {}));\n  const adapter = guarded(\"memory\", () => true, options.failure, {\n    async get(key) {\n      return entries.has(key) ? (entries.get(key) as string) : null;\n    },\n    async set(key, value) {\n      entries.set(key, value);\n    },\n    async remove(key) {\n      entries.delete(key);\n    },\n  });\n  return Object.assign(adapter, { entries });\n}\n\n// ---------------------------------------------------------------- localStorage\n\n/** Minimal `Storage` surface used by the localStorage adapter. */\nexport interface WebStorageLike {\n  getItem(key: string): string | null;\n  setItem(key: string, value: string): void;\n  removeItem(key: string): void;\n}\n\nexport interface LocalStorageAdapterOptions extends StorageAdapterOptions {\n  /** Storage to use (default `globalThis.localStorage`, e.g. pass `sessionStorage`). */\n  storage?: WebStorageLike;\n}\n\nfunction detectLocalStorage(): WebStorageLike | undefined {\n  try {\n    const storage = (globalThis as { localStorage?: WebStorageLike }).localStorage;\n    return storage && typeof storage.getItem === \"function\" ? storage : undefined;\n  } catch {\n    // Accessing localStorage throws when site data is blocked.\n    return undefined;\n  }\n}\n\n/** Whether `localStorage` can be used (it throws when site data is blocked). */\nexport function isLocalStorageAvailable(): boolean {\n  return detectLocalStorage() !== undefined;\n}\n\n/**\n * `localStorage` adapter; every key is prefixed with `prefix`. Writes are\n * synchronous under the hood, so they complete even inside `pagehide`.\n * A full quota rejects the `set` (`QuotaExceededError`).\n */\nexport function createLocalStorageAdapter(\n  prefix = \"\",\n  options: LocalStorageAdapterOptions = {},\n): StorageAdapter {\n  const storage = options.storage ?? detectLocalStorage();\n  return guarded(\"localStorage\", () => storage !== undefined, options.failure, {\n    async get(key) {\n      return storage!.getItem(prefix + key);\n    },\n    async set(key, value) {\n      storage!.setItem(prefix + key, value);\n    },\n    async remove(key) {\n      storage!.removeItem(prefix + key);\n    },\n  });\n}\n\n// ---------------------------------------------------------------- IndexedDB\n\n/** Minimal `IDBFactory` surface (the real `indexedDB`, or a fake in tests). */\nexport interface IdbFactoryLike {\n  open(name: string, version?: number): any;\n}\n\nexport interface IndexedDbAdapterOptions extends StorageAdapterOptions {\n  /** Object store name (default `\"kv\"`). */\n  store?: string;\n  /** Factory to use (default `globalThis.indexedDB`). */\n  indexedDB?: IdbFactoryLike;\n}\n\nfunction detectIndexedDb(): IdbFactoryLike | undefined {\n  try {\n    const factory = (globalThis as { indexedDB?: IdbFactoryLike }).indexedDB;\n    return factory && typeof factory.open === \"function\" ? factory : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Whether `indexedDB` exists in this environment. */\nexport function isIndexedDbAvailable(): boolean {\n  return detectIndexedDb() !== undefined;\n}\n\nconst requestToPromise = <T>(request: any): Promise<T> =>\n  new Promise((resolve, reject) => {\n    request.onsuccess = () => resolve(request.result as T);\n    request.onerror = () => reject(request.error ?? new Error(\"IndexedDB request failed\"));\n  });\n\n/**\n * IndexedDB adapter: one database `name` with a single key/value object store.\n * A `set` resolves when its transaction completes (not merely when the request\n * succeeds), so a resolved write is durable.\n */\nexport function createIndexedDbAdapter(\n  name = \"pixerate-editor\",\n  options: IndexedDbAdapterOptions = {},\n): StorageAdapter {\n  const factory = options.indexedDB ?? detectIndexedDb();\n  const storeName = options.store ?? \"kv\";\n  let dbPromise: Promise<any> | null = null;\n\n  const open = (): Promise<any> => {\n    dbPromise ??= new Promise((resolve, reject) => {\n      const request = factory!.open(name, 1);\n      request.onupgradeneeded = () => {\n        const db = request.result;\n        if (!db.objectStoreNames.contains(storeName)) db.createObjectStore(storeName);\n      };\n      request.onsuccess = () => resolve(request.result);\n      request.onerror = () => {\n        dbPromise = null;\n        reject(request.error ?? new Error(\"IndexedDB open failed\"));\n      };\n    });\n    return dbPromise;\n  };\n\n  const write = async (fn: (store: any) => void): Promise<void> => {\n    const db = await open();\n    await new Promise<void>((resolve, reject) => {\n      const tx = db.transaction(storeName, \"readwrite\");\n      tx.oncomplete = () => resolve();\n      tx.onerror = () => reject(tx.error ?? new Error(\"IndexedDB transaction failed\"));\n      tx.onabort = () => reject(tx.error ?? new Error(\"IndexedDB transaction aborted\"));\n      fn(tx.objectStore(storeName));\n    });\n  };\n\n  return guarded(\"indexedDB\", () => factory !== undefined, options.failure, {\n    async get(key) {\n      const db = await open();\n      const tx = db.transaction(storeName, \"readonly\");\n      const value = await requestToPromise<unknown>(tx.objectStore(storeName).get(key));\n      return typeof value === \"string\" ? value : null;\n    },\n    set: (key, value) => write((store) => store.put(value, key)),\n    remove: (key) => write((store) => store.delete(key)),\n  });\n}\n\n// ---------------------------------------------------------------- OPFS\n\n/** Minimal `FileSystemDirectoryHandle` surface used by the OPFS adapter. */\nexport interface OpfsDirectoryLike {\n  getDirectoryHandle(name: string, options?: { create?: boolean }): Promise<OpfsDirectoryLike>;\n  getFileHandle(name: string, options?: { create?: boolean }): Promise<OpfsFileLike>;\n  removeEntry(name: string): Promise<void>;\n}\n\nexport interface OpfsFileLike {\n  getFile(): Promise<{ text(): Promise<string> }>;\n  createWritable?(): Promise<{ write(data: string): Promise<void>; close(): Promise<void> }>;\n  /** Rename in place (Chromium, Safari). Used for temp-file + rename writes. */\n  move?(name: string): Promise<void>;\n}\n\nexport interface OpfsAdapterOptions extends StorageAdapterOptions {\n  /** Root directory (default `navigator.storage.getDirectory()`). */\n  root?: () => Promise<OpfsDirectoryLike>;\n  /** Force the write-then-pointer-swap strategy even when `move` exists. */\n  disableRename?: boolean;\n}\n\nfunction detectOpfsRoot(): (() => Promise<OpfsDirectoryLike>) | undefined {\n  try {\n    const storage = (globalThis as any).navigator?.storage;\n    if (storage && typeof storage.getDirectory === \"function\") {\n      return () => storage.getDirectory();\n    }\n  } catch {\n    // ignore\n  }\n  return undefined;\n}\n\n/** Whether the Origin Private File System exists (`navigator.storage.getDirectory`). */\nexport function isOpfsAvailable(): boolean {\n  return detectOpfsRoot() !== undefined;\n}\n\nconst isNotFound = (error: unknown) =>\n  !!error && typeof error === \"object\" && (error as { name?: string }).name === \"NotFoundError\";\n\n/**\n * Origin Private File System adapter. Values are files in `dir` (created on\n * demand), named after the URI-encoded key.\n *\n * Writes never leave a half-written value behind: where file handles support\n * `move`, the value is written to `<file>.tmp` and renamed over `<file>`;\n * otherwise it alternates between two slots (`<file>.a` / `<file>.b`) and then\n * swaps a pointer file (`<file>.ptr`), so a crash mid-write keeps the previous\n * value. Main-thread writes need `createWritable` (missing in some Safari\n * versions); without it, `set` rejects with `StorageUnavailableError`.\n */\nexport function createOpfsAdapter(\n  dir = \"pixerate-editor\",\n  options: OpfsAdapterOptions = {},\n): StorageAdapter {\n  const getRoot = options.root ?? detectOpfsRoot();\n  let dirPromise: Promise<OpfsDirectoryLike> | null = null;\n  const directory = () => {\n    dirPromise ??= getRoot!().then((root) => root.getDirectoryHandle(dir, { create: true }));\n    dirPromise.catch(() => {\n      dirPromise = null;\n    });\n    return dirPromise;\n  };\n  const fileName = (key: string) => encodeURIComponent(key) || \"_\";\n\n  const readFile = async (d: OpfsDirectoryLike, name: string): Promise<string | null> => {\n    try {\n      const handle = await d.getFileHandle(name);\n      return await (await handle.getFile()).text();\n    } catch (error) {\n      if (isNotFound(error)) return null;\n      throw error;\n    }\n  };\n\n  const writeFile = async (d: OpfsDirectoryLike, name: string, value: string) => {\n    const handle = await d.getFileHandle(name, { create: true });\n    if (typeof handle.createWritable !== \"function\") {\n      throw new StorageUnavailableError(\"opfs (createWritable)\");\n    }\n    const writable = await handle.createWritable();\n    await writable.write(value);\n    await writable.close();\n    return handle;\n  };\n\n  const removeFile = async (d: OpfsDirectoryLike, name: string) => {\n    try {\n      await d.removeEntry(name);\n    } catch (error) {\n      if (!isNotFound(error)) throw error;\n    }\n  };\n\n  return guarded(\"opfs\", () => getRoot !== undefined, options.failure, {\n    async get(key) {\n      const d = await directory();\n      const base = fileName(key);\n      const pointer = await readFile(d, `${base}.ptr`);\n      if (pointer === \"a\" || pointer === \"b\") return readFile(d, `${base}.${pointer}`);\n      return readFile(d, base);\n    },\n    async set(key, value) {\n      const d = await directory();\n      const base = fileName(key);\n      const pointer = await readFile(d, `${base}.ptr`);\n      if (!options.disableRename && pointer === null) {\n        const tmp = await writeFile(d, `${base}.tmp`, value);\n        if (typeof tmp.move === \"function\") {\n          await tmp.move(base);\n          return;\n        }\n        await removeFile(d, `${base}.tmp`);\n      }\n      // Write-then-pointer swap: the pointer only moves once the new slot is complete.\n      const next = pointer === \"a\" ? \"b\" : \"a\";\n      await writeFile(d, `${base}.${next}`, value);\n      await writeFile(d, `${base}.ptr`, next);\n    },\n    async remove(key) {\n      const d = await directory();\n      const base = fileName(key);\n      for (const name of [`${base}.ptr`, base, `${base}.a`, `${base}.b`, `${base}.tmp`]) {\n        await removeFile(d, name);\n      }\n    },\n  });\n}\n","// Portions ported from filmcraft-main/apps/filmcraft-web/src/recovery.rs and\n// craft-libs-main/crates/settings/src/store.rs (MIT OR Apache-2.0, © ArtCraft Team and\n// contributors). See THIRD_PARTY_NOTICES.md.\n\nimport {\n  createRecoveryPolicy,\n  exponentialBackoff,\n  type RecoveryAction,\n  type RecoveryPolicy,\n} from \"./recoveryPolicy\";\nimport type { StorageAdapter } from \"./storage\";\n\nexport type AutosaveStatus = \"idle\" | \"dirty\" | \"saving\" | \"saved\" | \"error\";\n\nexport interface AutosaveStatusInfo {\n  status: AutosaveStatus;\n  /** Last write error (while `status` is `\"error\"`). */\n  error: unknown;\n  /** Consecutive failed writes. */\n  failures: number;\n  /** When the next attempt is due (`now()` units), while waiting. */\n  nextAttemptAt: number | null;\n  /** When the last snapshot was written (`now()` units). */\n  lastSavedAt: number | null;\n  /** Whether `ready()` was called. */\n  ready: boolean;\n}\n\n/** Stored next to the snapshot (`<key>:meta`). */\nexport interface RecoveryMeta {\n  dirty: boolean;\n  revision?: number;\n  /** `Date.now()` of the write. */\n  time?: number;\n  /** Document name, for the \"Restore unsaved changes from …?\" prompt. */\n  name?: string;\n}\n\nexport interface AutosaveRecovery<T = unknown> {\n  /** The parsed snapshot (`undefined` when `deserialize` threw; see `error`). */\n  snapshot: T | undefined;\n  /** The stored text. */\n  text: string;\n  meta: RecoveryMeta & { dirty: true };\n  error?: unknown;\n}\n\nexport interface AutosaveControllerOptions<T> {\n  storage: StorageAdapter;\n  /** Snapshot key; the meta lives at `<key>:meta`. */\n  key: string;\n  /** Reads the current document. */\n  getSnapshot: () => T;\n  /** Default `JSON.stringify`. */\n  serialize?: (snapshot: T) => string;\n  /** Default `JSON.parse` (used by `checkRecovery`). */\n  deserialize?: (text: string) => T;\n  /** Current document revision; must change on every edit. */\n  revision: () => number;\n  /** Revision of the last explicit save (equal to `revision()` when clean). */\n  savedRevision: () => number;\n  /** Document name stored in the meta. */\n  name?: string | (() => string | undefined);\n  onStatus?: (info: AutosaveStatusInfo) => void;\n  /** Minimum time between snapshots while edits keep coming (default 5000 ms). */\n  interval?: number;\n  /** Quiet time after the last edit before a snapshot is written (default 1000 ms). */\n  debounceMs?: number;\n  /** First retry delay after a failed write; doubles per failure (default 1000 ms). */\n  retryBaseMs?: number;\n  /** Retry delay cap (default 30000 ms). */\n  retryMaxMs?: number;\n  /** Clock for scheduling (default `Date.now`). */\n  now?: () => number;\n  /** Wall clock stored in the meta (default `Date.now`). */\n  wallClock?: () => number;\n  setTimeout?: (fn: () => void, ms: number) => unknown;\n  clearTimeout?: (handle: any) => void;\n  /** Start hydrated, i.e. as if `ready()` was already called (default `false`). */\n  ready?: boolean;\n}\n\nexport interface AutosaveController<T = unknown> {\n  /** Current status. */\n  getStatus(): AutosaveStatusInfo;\n  /** Listener is called on every status change (not immediately). */\n  subscribe(listener: (info: AutosaveStatusInfo) => void): () => void;\n  /** Call after every change (edit, undo, save). Cheap; the write is scheduled. */\n  notify(): void;\n  /** Lifts the hydration gate: no snapshot is written before this. */\n  ready(): void;\n  readonly isReady: boolean;\n  /**\n   * Writes a snapshot of unsaved changes right away, skipping the debounce, the\n   * interval and retry waits. Use on `pagehide` / `visibilitychange`. Resolves\n   * once the write settled.\n   */\n  flushNow(): Promise<void>;\n  /**\n   * Call after the document was saved (`savedRevision()` now equals\n   * `revision()`): retires the snapshot only if this session wrote it.\n   */\n  markClean(): Promise<void>;\n  /**\n   * A dirty snapshot left by an earlier session, or `null`. Returns `null` once\n   * this session has written its own snapshot.\n   */\n  checkRecovery(): Promise<AutosaveRecovery<T> | null>;\n  /** Deletes an earlier session's snapshot. No-op once this session wrote its own. */\n  discardRecovery(): Promise<boolean>;\n  /** Runs one scheduling step now (normally driven by `notify` and timers). */\n  tick(): void;\n  /** Resolves when no write is in flight. */\n  whenIdle(): Promise<void>;\n  /** Stops all timers. Pending changes are not written; call `flushNow` first. */\n  destroy(): void;\n}\n\nexport const recoveryMetaKey = (key: string) => `${key}:meta`;\n\n/**\n * Text for a recovery prompt: \"Restore unsaved changes from <time>?\" (the\n * React and Svelte `RecoveryPrompt` components use it).\n */\nexport function formatRecoveryMessage(\n  meta: Pick<RecoveryMeta, \"time\">,\n  formatTime: (time: number) => string = (time) => new Date(time).toLocaleString(),\n): string {\n  return typeof meta.time === \"number\" && Number.isFinite(meta.time)\n    ? `Restore unsaved changes from ${formatTime(meta.time)}?`\n    : \"Restore unsaved changes?\";\n}\n\n/**\n * Debounced autosave of crash-recovery snapshots.\n *\n * - Hydration gate: nothing is written until `ready()`, so loading a document\n *   (or deciding about a recovered one) never overwrites the previous session's snapshot.\n * - A snapshot is written `debounceMs` after the last edit, and at least every\n *   `interval` while edits keep coming; never twice for one revision.\n * - Failed writes are retried with exponential backoff (`retryBaseMs` doubling up to\n *   `retryMaxMs`) without waiting for another edit.\n * - The snapshot is written before its dirty meta, so the meta never points at a\n *   missing snapshot. Once saved, the meta is marked clean only if this session\n *   wrote the snapshot (`createRecoveryPolicy`).\n */\nexport function createAutosaveController<T>(\n  options: AutosaveControllerOptions<T>,\n): AutosaveController<T> {\n  const {\n    storage,\n    key,\n    getSnapshot,\n    revision,\n    savedRevision,\n    interval = 5000,\n    debounceMs = 1000,\n    retryBaseMs = 1000,\n    retryMaxMs = 30000,\n  } = options;\n  const serialize = options.serialize ?? ((value: T) => JSON.stringify(value));\n  const deserialize = options.deserialize ?? ((text: string) => JSON.parse(text) as T);\n  const now = options.now ?? (() => Date.now());\n  const wallClock = options.wallClock ?? (() => Date.now());\n  const setTimer =\n    options.setTimeout ?? ((fn: () => void, ms: number) => globalThis.setTimeout(fn, ms));\n  const clearTimer = options.clearTimeout ?? ((handle: any) => globalThis.clearTimeout(handle));\n  const metaKey = recoveryMetaKey(key);\n\n  const policy: RecoveryPolicy = createRecoveryPolicy({\n    interval,\n    retryDelay: (failures) => exponentialBackoff(failures, retryBaseMs, retryMaxMs),\n  });\n\n  let hydrated = options.ready === true;\n  let destroyed = false;\n  let timer: unknown = null;\n  let timerDue = Infinity;\n  let inflight: Promise<void> | null = null;\n  let observedRevision = revision();\n  let lastChangeAt: number | null = null;\n  let pendingSince: number | null = null;\n  let forceNext = false;\n  let info: AutosaveStatusInfo = {\n    status: \"idle\",\n    error: null,\n    failures: 0,\n    nextAttemptAt: null,\n    lastSavedAt: null,\n    ready: hydrated,\n  };\n  const listeners = new Set<(info: AutosaveStatusInfo) => void>();\n\n  const setInfo = (patch: Partial<AutosaveStatusInfo>) => {\n    const next = { ...info, ...patch, failures: policy.failures, ready: hydrated };\n    if (\n      next.status === info.status &&\n      next.error === info.error &&\n      next.failures === info.failures &&\n      next.nextAttemptAt === info.nextAttemptAt &&\n      next.lastSavedAt === info.lastSavedAt &&\n      next.ready === info.ready\n    ) {\n      return;\n    }\n    info = next;\n    options.onStatus?.(info);\n    listeners.forEach((listener) => {\n      try {\n        listener(info);\n      } catch (error) {\n        console.error(\"[autosave] Error in status listener:\", error);\n      }\n    });\n  };\n\n  const cancelTimer = () => {\n    if (timer !== null) clearTimer(timer);\n    timer = null;\n    timerDue = Infinity;\n  };\n\n  const schedule = (delay: number) => {\n    if (destroyed) return;\n    const due = now() + Math.max(0, delay);\n    if (timer !== null && timerDue <= due) return;\n    cancelTimer();\n    timerDue = due;\n    timer = setTimer(() => {\n      timer = null;\n      timerDue = Infinity;\n      tick();\n    }, Math.max(0, delay));\n  };\n\n  const observe = (t: number) => {\n    const rev = revision();\n    if (rev !== observedRevision) {\n      observedRevision = rev;\n      lastChangeAt = t;\n      pendingSince ??= t;\n    }\n    return rev;\n  };\n\n  const docName = () =>\n    typeof options.name === \"function\" ? options.name() : options.name;\n\n  const run = (action: RecoveryAction, rev: number) => {\n    if (action.type === \"writeSnapshot\") {\n      setInfo({ status: \"saving\", nextAttemptAt: null });\n      inflight = (async () => {\n        let ok = false;\n        let error: unknown = null;\n        try {\n          const text = serialize(getSnapshot());\n          await storage.set(key, text);\n          const meta: RecoveryMeta = {\n            dirty: true,\n            revision: action.revision,\n            time: wallClock(),\n            name: docName(),\n          };\n          await storage.set(metaKey, JSON.stringify(meta));\n          ok = true;\n        } catch (e) {\n          error = e;\n        }\n        const t = now();\n        policy.written(action.revision, ok, t);\n        inflight = null;\n        if (ok) {\n          if (observedRevision === action.revision) pendingSince = null;\n          setInfo({ status: \"saved\", error: null, lastSavedAt: t });\n        } else {\n          setInfo({ status: \"error\", error });\n        }\n        tick();\n      })();\n    } else if (action.type === \"writeClean\") {\n      setInfo({ status: \"saving\", nextAttemptAt: null });\n      inflight = (async () => {\n        let ok = false;\n        let error: unknown = null;\n        try {\n          await storage.set(metaKey, JSON.stringify({ dirty: false } satisfies RecoveryMeta));\n          ok = true;\n        } catch (e) {\n          error = e;\n        }\n        policy.cleaned(ok, now());\n        inflight = null;\n        if (ok) {\n          // Best effort: the clean meta already retired the snapshot.\n          if (!policy.ownsSnapshot) await storage.remove(key).catch(() => undefined);\n          setInfo({ status: \"saved\", error: null });\n        } else {\n          setInfo({ status: \"error\", error });\n        }\n        tick();\n      })();\n    } else if (action.type === \"wakeAfter\") {\n      schedule(action.delay);\n      setInfo(\n        info.status === \"error\"\n          ? { nextAttemptAt: now() + action.delay }\n          : { status: rev !== savedRevision() ? \"dirty\" : info.status, nextAttemptAt: now() + action.delay },\n      );\n    } else if (rev === savedRevision() && info.status === \"dirty\") {\n      setInfo({ status: policy.ownsSnapshot ? \"dirty\" : \"idle\", nextAttemptAt: null });\n    } else if (rev !== savedRevision() && info.status !== \"saved\" && info.status !== \"error\") {\n      setInfo({ status: \"dirty\" });\n    }\n  };\n\n  function tick(): void {\n    if (destroyed || inflight) return;\n    const t = now();\n    const rev = observe(t);\n    const saved = savedRevision();\n    if (!hydrated) {\n      if (rev !== saved) setInfo({ status: \"dirty\" });\n      return;\n    }\n    const force = forceNext;\n    forceNext = false;\n    if (rev !== saved && !force && info.status !== \"error\") {\n      const changed = lastChangeAt ?? t;\n      const due = Math.min(changed + debounceMs, (pendingSince ?? changed) + interval);\n      if (t < due) {\n        setInfo({ status: \"dirty\", nextAttemptAt: due });\n        schedule(due - t);\n        return;\n      }\n    }\n    run(policy.tick(t, rev, saved, { force }), rev);\n  }\n\n  const whenIdle = async () => {\n    while (inflight) await inflight;\n  };\n\n  return {\n    getStatus: () => info,\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    notify() {\n      if (destroyed) return;\n      const t = now();\n      const before = observedRevision;\n      const rev = observe(t);\n      const dirty = rev !== savedRevision();\n      if (dirty && rev !== before && info.status !== \"error\" && !inflight) {\n        setInfo({ status: \"dirty\" });\n      }\n      if (!hydrated) return;\n      // Never synchronous: listeners that update `savedRevision` may run after us.\n      const changed = lastChangeAt ?? t;\n      const due = Math.min(changed + debounceMs, (pendingSince ?? changed) + interval);\n      schedule(dirty ? due - t : 0);\n    },\n    ready() {\n      if (hydrated || destroyed) return;\n      hydrated = true;\n      setInfo({});\n      schedule(0);\n    },\n    get isReady() {\n      return hydrated;\n    },\n    async flushNow() {\n      if (destroyed || !hydrated) return;\n      await whenIdle();\n      cancelTimer();\n      forceNext = true;\n      tick();\n      await whenIdle();\n    },\n    async markClean() {\n      if (destroyed) return;\n      await whenIdle();\n      cancelTimer();\n      tick();\n      await whenIdle();\n    },\n    async checkRecovery() {\n      if (policy.ownsSnapshot) return null;\n      let meta: RecoveryMeta;\n      try {\n        const metaText = await storage.get(metaKey);\n        if (!metaText) return null;\n        meta = JSON.parse(metaText) as RecoveryMeta;\n      } catch {\n        return null;\n      }\n      if (!meta || meta.dirty !== true) return null;\n      const text = await storage.get(key).catch(() => null);\n      if (text === null) return null;\n      try {\n        return { snapshot: deserialize(text), text, meta: meta as RecoveryMeta & { dirty: true } };\n      } catch (error) {\n        return { snapshot: undefined, text, meta: meta as RecoveryMeta & { dirty: true }, error };\n      }\n    },\n    async discardRecovery() {\n      if (policy.ownsSnapshot) return false;\n      await whenIdle();\n      await storage.remove(metaKey);\n      await storage.remove(key);\n      return true;\n    },\n    tick,\n    whenIdle,\n    destroy() {\n      destroyed = true;\n      cancelTimer();\n      listeners.clear();\n    },\n  };\n}\n","/** Anything that notifies on every document change (`HistoryManager` satisfies it). */\nexport interface RevisionChangeSource {\n  subscribe(listener: (...args: any[]) => void): () => void;\n}\n\n/** Anything with a dirty flag (`DirtyTracker` and `HistoryDirtyBinding` satisfy it). */\nexport interface DirtyFlagSource {\n  readonly dirty: boolean;\n  subscribe(listener: (dirty: boolean) => void): () => void;\n}\n\nexport interface RevisionTrackerOptions {\n  /** Change notifications (e.g. a `HistoryManager`). Every notification is a new revision. */\n  history?: RevisionChangeSource;\n  /**\n   * Saved-vs-current flag (e.g. `bindDirtyToHistory(...)` or a `DirtyTracker`).\n   * Whenever it reads clean, the current revision counts as saved, so undoing\n   * back to the saved state needs no snapshot. Without it, call `markSaved()`.\n   */\n  dirty?: DirtyFlagSource;\n}\n\nexport interface RevisionTracker {\n  /** Bumped on every change. */\n  revision(): number;\n  /** Revision of the last save; equals `revision()` while clean. */\n  savedRevision(): number;\n  /** Records a change made outside `history`. */\n  bump(): void;\n  /** Marks the current revision saved. */\n  markSaved(): void;\n  /** Called after every change, save or dirty flip. */\n  subscribe(listener: () => void): () => void;\n  destroy(): void;\n}\n\n/**\n * Derives the `revision` / `savedRevision` pair an autosave controller needs\n * from a history and a dirty flag (`bindDirtyToHistory` or `DirtyTracker`).\n * Structural types only, so this entry stays dependency-free.\n */\nexport function createRevisionTracker(options: RevisionTrackerOptions = {}): RevisionTracker {\n  let revision = 0;\n  let saved = 0;\n  const listeners = new Set<() => void>();\n  const emit = () =>\n    listeners.forEach((listener) => {\n      try {\n        listener();\n      } catch (error) {\n        console.error(\"[autosave] Error in revision listener:\", error);\n      }\n    });\n  const syncSaved = () => {\n    // Read lazily: the dirty binding may update after our history listener ran.\n    if (options.dirty && !options.dirty.dirty) saved = revision;\n  };\n\n  const unsubscribers: (() => void)[] = [];\n  if (options.history) {\n    unsubscribers.push(\n      options.history.subscribe(() => {\n        revision++;\n        emit();\n      }),\n    );\n  }\n  if (options.dirty) {\n    let first = true;\n    unsubscribers.push(\n      options.dirty.subscribe((dirty) => {\n        if (first) {\n          first = false;\n          // DirtyTracker calls back immediately with the current value.\n          if (dirty && revision === saved) revision++;\n          return;\n        }\n        if (dirty && revision === saved) revision++;\n        if (!dirty) saved = revision;\n        emit();\n      }),\n    );\n  }\n\n  return {\n    revision: () => revision,\n    savedRevision: () => {\n      syncSaved();\n      return saved;\n    },\n    bump() {\n      revision++;\n      emit();\n    },\n    markSaved() {\n      saved = revision;\n      emit();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    destroy() {\n      unsubscribers.forEach((fn) => fn());\n      unsubscribers.length = 0;\n      listeners.clear();\n    },\n  };\n}\n"]}

package/dist/persistence/index.d.cts

@@ -0,0 +1,347 @@
+export { J as JsonObject, L as LoadDocumentOptions, a as LoadDocumentResult, b as LoadReport, c as LoadSectionsOptions, d as LoadSectionsResult, M as MigrateOptions, e as MigrateResult, f as MigrationStep, R as ReadOnlyReason, S as SectionProblem, g as SectionSpec, h as SectionSpecs, i as createLoadReport, j as hasLoadProblems, l as loadDocument, k as loadSections, m as migrateDocument } from '../migrate-iTlm3a8h.cjs';
+
+/**
+ * What the caller should do now (see `RecoveryPolicy.tick`).
+ *
+ * - `writeSnapshot`: write the snapshot and a dirty meta for `revision`, then report with `written`.
+ * - `writeClean`: write a clean meta (retire the snapshot), then report with `cleaned`.
+ * - `wakeAfter`: nothing now; tick again after `delay` (same unit as `now`).
+ */
+type RecoveryAction = {
+    type: "nothing";
+} | {
+    type: "writeSnapshot";
+    revision: number;
+} | {
+    type: "writeClean";
+} | {
+    type: "wakeAfter";
+    delay: number;
+};
+interface RecoveryPolicyOptions {
+    /**
+     * Minimum time between snapshots of a changing document, in the unit of `now`
+     * (default 5000, i.e. milliseconds).
+     */
+    interval?: number;
+    /**
+     * Wait before retrying after the `failures`-th consecutive failed write
+     * (default: `interval`, as in FilmCraft). Use `exponentialBackoff` for doubling delays.
+     */
+    retryDelay?: (failures: number) => number;
+}
+interface RecoveryTickOptions {
+    /** Ignore the interval and any retry wait (e.g. on `pagehide`). */
+    force?: boolean;
+}
+interface RecoveryPolicy {
+    /** Called whenever something may have changed, with the revisions and the current time. */
+    tick(now: number, revision: number, savedRevision: number, options?: RecoveryTickOptions): RecoveryAction;
+    /** The snapshot write for `revision` finished. */
+    written(revision: number, ok: boolean, now: number): void;
+    /** The clean-meta write finished. */
+    cleaned(ok: boolean, now: number): void;
+    /** Whether this session wrote a dirty snapshot that is not retired yet. */
+    readonly ownsSnapshot: boolean;
+    /** Consecutive failed writes (reset by a successful one). */
+    readonly failures: number;
+}
+/**
+ * Exponential backoff: `base`, `2·base`, `4·base`, … capped at `max`.
+ * `failures` is 1 for the first failure.
+ */
+declare function exponentialBackoff(failures: number, base?: number, max?: number): number;
+/**
+ * Pure state machine deciding when a crash-recovery snapshot is written or
+ * retired. Deterministic: time is always passed in.
+ *
+ * - A dirty document is snapshotted at most every `interval`, once per revision.
+ *   A write that fails is retried after `retryDelay`, without waiting for another edit.
+ * - The snapshot is marked clean only if this session wrote it. A snapshot left by an
+ *   earlier session (that was not restored) stays dirty, so it can still be recovered.
+ * - An edit made while the clean write is in flight keeps the snapshot owned.
+ */
+declare function createRecoveryPolicy(options?: RecoveryPolicyOptions): RecoveryPolicy;
+
+/**
+ * Key/value storage adapters for autosave and crash recovery. Every adapter is
+ * async, stores strings, feature-detects its backend (an unavailable backend
+ * rejects every call with `StorageUnavailableError` instead of throwing at
+ * construction, so SSR and old browsers are safe) and accepts an injectable
+ * failure mode for tests.
+ */
+type StorageOperation = "get" | "set" | "remove";
+/**
+ * Injected failure: return `true` (or an `Error`) to make that operation fail.
+ * Example: `failure: (op) => op === "set"` simulates a full disk.
+ */
+type StorageFailureMode = (operation: StorageOperation, key: string) => boolean | Error | undefined | void;
+interface StorageAdapter {
+    /** Short backend name, e.g. `"memory"`, `"localStorage"`, `"indexedDB"`, `"opfs"`. */
+    readonly kind: string;
+    /** Whether the backend was found. When `false`, every call rejects. */
+    readonly available: boolean;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    remove(key: string): Promise<void>;
+}
+interface StorageAdapterOptions {
+    failure?: StorageFailureMode;
+}
+declare class StorageUnavailableError extends Error {
+    constructor(kind: string);
+}
+declare class InjectedStorageError extends Error {
+    constructor(operation: StorageOperation, key: string);
+}
+/** Wraps an adapter so `failure` can make any of its operations fail. */
+declare function withStorageFailures(inner: StorageAdapter, failure: StorageFailureMode): StorageAdapter;
+interface MemoryStorage extends StorageAdapter {
+    /** The underlying map (inspect it in tests). */
+    readonly entries: Map<string, string>;
+}
+/** In-memory storage (tests, SSR, or a session-only fallback). */
+declare function createMemoryStorage(options?: StorageAdapterOptions & {
+    initial?: Record<string, string>;
+}): MemoryStorage;
+/** Minimal `Storage` surface used by the localStorage adapter. */
+interface WebStorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+interface LocalStorageAdapterOptions extends StorageAdapterOptions {
+    /** Storage to use (default `globalThis.localStorage`, e.g. pass `sessionStorage`). */
+    storage?: WebStorageLike;
+}
+/** Whether `localStorage` can be used (it throws when site data is blocked). */
+declare function isLocalStorageAvailable(): boolean;
+/**
+ * `localStorage` adapter; every key is prefixed with `prefix`. Writes are
+ * synchronous under the hood, so they complete even inside `pagehide`.
+ * A full quota rejects the `set` (`QuotaExceededError`).
+ */
+declare function createLocalStorageAdapter(prefix?: string, options?: LocalStorageAdapterOptions): StorageAdapter;
+/** Minimal `IDBFactory` surface (the real `indexedDB`, or a fake in tests). */
+interface IdbFactoryLike {
+    open(name: string, version?: number): any;
+}
+interface IndexedDbAdapterOptions extends StorageAdapterOptions {
+    /** Object store name (default `"kv"`). */
+    store?: string;
+    /** Factory to use (default `globalThis.indexedDB`). */
+    indexedDB?: IdbFactoryLike;
+}
+/** Whether `indexedDB` exists in this environment. */
+declare function isIndexedDbAvailable(): boolean;
+/**
+ * IndexedDB adapter: one database `name` with a single key/value object store.
+ * A `set` resolves when its transaction completes (not merely when the request
+ * succeeds), so a resolved write is durable.
+ */
+declare function createIndexedDbAdapter(name?: string, options?: IndexedDbAdapterOptions): StorageAdapter;
+/** Minimal `FileSystemDirectoryHandle` surface used by the OPFS adapter. */
+interface OpfsDirectoryLike {
+    getDirectoryHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<OpfsDirectoryLike>;
+    getFileHandle(name: string, options?: {
+        create?: boolean;
+    }): Promise<OpfsFileLike>;
+    removeEntry(name: string): Promise<void>;
+}
+interface OpfsFileLike {
+    getFile(): Promise<{
+        text(): Promise<string>;
+    }>;
+    createWritable?(): Promise<{
+        write(data: string): Promise<void>;
+        close(): Promise<void>;
+    }>;
+    /** Rename in place (Chromium, Safari). Used for temp-file + rename writes. */
+    move?(name: string): Promise<void>;
+}
+interface OpfsAdapterOptions extends StorageAdapterOptions {
+    /** Root directory (default `navigator.storage.getDirectory()`). */
+    root?: () => Promise<OpfsDirectoryLike>;
+    /** Force the write-then-pointer-swap strategy even when `move` exists. */
+    disableRename?: boolean;
+}
+/** Whether the Origin Private File System exists (`navigator.storage.getDirectory`). */
+declare function isOpfsAvailable(): boolean;
+/**
+ * Origin Private File System adapter. Values are files in `dir` (created on
+ * demand), named after the URI-encoded key.
+ *
+ * Writes never leave a half-written value behind: where file handles support
+ * `move`, the value is written to `<file>.tmp` and renamed over `<file>`;
+ * otherwise it alternates between two slots (`<file>.a` / `<file>.b`) and then
+ * swaps a pointer file (`<file>.ptr`), so a crash mid-write keeps the previous
+ * value. Main-thread writes need `createWritable` (missing in some Safari
+ * versions); without it, `set` rejects with `StorageUnavailableError`.
+ */
+declare function createOpfsAdapter(dir?: string, options?: OpfsAdapterOptions): StorageAdapter;
+
+type AutosaveStatus = "idle" | "dirty" | "saving" | "saved" | "error";
+interface AutosaveStatusInfo {
+    status: AutosaveStatus;
+    /** Last write error (while `status` is `"error"`). */
+    error: unknown;
+    /** Consecutive failed writes. */
+    failures: number;
+    /** When the next attempt is due (`now()` units), while waiting. */
+    nextAttemptAt: number | null;
+    /** When the last snapshot was written (`now()` units). */
+    lastSavedAt: number | null;
+    /** Whether `ready()` was called. */
+    ready: boolean;
+}
+/** Stored next to the snapshot (`<key>:meta`). */
+interface RecoveryMeta {
+    dirty: boolean;
+    revision?: number;
+    /** `Date.now()` of the write. */
+    time?: number;
+    /** Document name, for the "Restore unsaved changes from …?" prompt. */
+    name?: string;
+}
+interface AutosaveRecovery<T = unknown> {
+    /** The parsed snapshot (`undefined` when `deserialize` threw; see `error`). */
+    snapshot: T | undefined;
+    /** The stored text. */
+    text: string;
+    meta: RecoveryMeta & {
+        dirty: true;
+    };
+    error?: unknown;
+}
+interface AutosaveControllerOptions<T> {
+    storage: StorageAdapter;
+    /** Snapshot key; the meta lives at `<key>:meta`. */
+    key: string;
+    /** Reads the current document. */
+    getSnapshot: () => T;
+    /** Default `JSON.stringify`. */
+    serialize?: (snapshot: T) => string;
+    /** Default `JSON.parse` (used by `checkRecovery`). */
+    deserialize?: (text: string) => T;
+    /** Current document revision; must change on every edit. */
+    revision: () => number;
+    /** Revision of the last explicit save (equal to `revision()` when clean). */
+    savedRevision: () => number;
+    /** Document name stored in the meta. */
+    name?: string | (() => string | undefined);
+    onStatus?: (info: AutosaveStatusInfo) => void;
+    /** Minimum time between snapshots while edits keep coming (default 5000 ms). */
+    interval?: number;
+    /** Quiet time after the last edit before a snapshot is written (default 1000 ms). */
+    debounceMs?: number;
+    /** First retry delay after a failed write; doubles per failure (default 1000 ms). */
+    retryBaseMs?: number;
+    /** Retry delay cap (default 30000 ms). */
+    retryMaxMs?: number;
+    /** Clock for scheduling (default `Date.now`). */
+    now?: () => number;
+    /** Wall clock stored in the meta (default `Date.now`). */
+    wallClock?: () => number;
+    setTimeout?: (fn: () => void, ms: number) => unknown;
+    clearTimeout?: (handle: any) => void;
+    /** Start hydrated, i.e. as if `ready()` was already called (default `false`). */
+    ready?: boolean;
+}
+interface AutosaveController<T = unknown> {
+    /** Current status. */
+    getStatus(): AutosaveStatusInfo;
+    /** Listener is called on every status change (not immediately). */
+    subscribe(listener: (info: AutosaveStatusInfo) => void): () => void;
+    /** Call after every change (edit, undo, save). Cheap; the write is scheduled. */
+    notify(): void;
+    /** Lifts the hydration gate: no snapshot is written before this. */
+    ready(): void;
+    readonly isReady: boolean;
+    /**
+     * Writes a snapshot of unsaved changes right away, skipping the debounce, the
+     * interval and retry waits. Use on `pagehide` / `visibilitychange`. Resolves
+     * once the write settled.
+     */
+    flushNow(): Promise<void>;
+    /**
+     * Call after the document was saved (`savedRevision()` now equals
+     * `revision()`): retires the snapshot only if this session wrote it.
+     */
+    markClean(): Promise<void>;
+    /**
+     * A dirty snapshot left by an earlier session, or `null`. Returns `null` once
+     * this session has written its own snapshot.
+     */
+    checkRecovery(): Promise<AutosaveRecovery<T> | null>;
+    /** Deletes an earlier session's snapshot. No-op once this session wrote its own. */
+    discardRecovery(): Promise<boolean>;
+    /** Runs one scheduling step now (normally driven by `notify` and timers). */
+    tick(): void;
+    /** Resolves when no write is in flight. */
+    whenIdle(): Promise<void>;
+    /** Stops all timers. Pending changes are not written; call `flushNow` first. */
+    destroy(): void;
+}
+declare const recoveryMetaKey: (key: string) => string;
+/**
+ * Text for a recovery prompt: "Restore unsaved changes from <time>?" (the
+ * React and Svelte `RecoveryPrompt` components use it).
+ */
+declare function formatRecoveryMessage(meta: Pick<RecoveryMeta, "time">, formatTime?: (time: number) => string): string;
+/**
+ * Debounced autosave of crash-recovery snapshots.
+ *
+ * - Hydration gate: nothing is written until `ready()`, so loading a document
+ *   (or deciding about a recovered one) never overwrites the previous session's snapshot.
+ * - A snapshot is written `debounceMs` after the last edit, and at least every
+ *   `interval` while edits keep coming; never twice for one revision.
+ * - Failed writes are retried with exponential backoff (`retryBaseMs` doubling up to
+ *   `retryMaxMs`) without waiting for another edit.
+ * - The snapshot is written before its dirty meta, so the meta never points at a
+ *   missing snapshot. Once saved, the meta is marked clean only if this session
+ *   wrote the snapshot (`createRecoveryPolicy`).
+ */
+declare function createAutosaveController<T>(options: AutosaveControllerOptions<T>): AutosaveController<T>;
+
+/** Anything that notifies on every document change (`HistoryManager` satisfies it). */
+interface RevisionChangeSource {
+    subscribe(listener: (...args: any[]) => void): () => void;
+}
+/** Anything with a dirty flag (`DirtyTracker` and `HistoryDirtyBinding` satisfy it). */
+interface DirtyFlagSource {
+    readonly dirty: boolean;
+    subscribe(listener: (dirty: boolean) => void): () => void;
+}
+interface RevisionTrackerOptions {
+    /** Change notifications (e.g. a `HistoryManager`). Every notification is a new revision. */
+    history?: RevisionChangeSource;
+    /**
+     * Saved-vs-current flag (e.g. `bindDirtyToHistory(...)` or a `DirtyTracker`).
+     * Whenever it reads clean, the current revision counts as saved, so undoing
+     * back to the saved state needs no snapshot. Without it, call `markSaved()`.
+     */
+    dirty?: DirtyFlagSource;
+}
+interface RevisionTracker {
+    /** Bumped on every change. */
+    revision(): number;
+    /** Revision of the last save; equals `revision()` while clean. */
+    savedRevision(): number;
+    /** Records a change made outside `history`. */
+    bump(): void;
+    /** Marks the current revision saved. */
+    markSaved(): void;
+    /** Called after every change, save or dirty flip. */
+    subscribe(listener: () => void): () => void;
+    destroy(): void;
+}
+/**
+ * Derives the `revision` / `savedRevision` pair an autosave controller needs
+ * from a history and a dirty flag (`bindDirtyToHistory` or `DirtyTracker`).
+ * Structural types only, so this entry stays dependency-free.
+ */
+declare function createRevisionTracker(options?: RevisionTrackerOptions): RevisionTracker;
+
+export { type AutosaveController, type AutosaveControllerOptions, type AutosaveRecovery, type AutosaveStatus, type AutosaveStatusInfo, type DirtyFlagSource, type IdbFactoryLike, type IndexedDbAdapterOptions, InjectedStorageError, type LocalStorageAdapterOptions, type MemoryStorage, type OpfsAdapterOptions, type OpfsDirectoryLike, type OpfsFileLike, type RecoveryAction, type RecoveryMeta, type RecoveryPolicy, type RecoveryPolicyOptions, type RecoveryTickOptions, type RevisionChangeSource, type RevisionTracker, type RevisionTrackerOptions, type StorageAdapter, type StorageAdapterOptions, type StorageFailureMode, type StorageOperation, StorageUnavailableError, type WebStorageLike, createAutosaveController, createIndexedDbAdapter, createLocalStorageAdapter, createMemoryStorage, createOpfsAdapter, createRecoveryPolicy, createRevisionTracker, exponentialBackoff, formatRecoveryMessage, isIndexedDbAvailable, isLocalStorageAvailable, isOpfsAvailable, recoveryMetaKey, withStorageFailures };