@bendyline/docblocks 2.6.2 → 2.7.0

package/dist/{chunk-YM7O3PWO.js → chunk-HKOOHM67.js}

@@ -1,3 +1,7 @@
+import {
+  RawIndexedDBFileSystemStore,
+  indexedDBWorkspaceDatabaseName
+} from "./chunk-DAPFSEKY.js";
 import {
   withFileCommitLock
 } from "./chunk-DZB666V7.js";
@@ -11,9 +15,11 @@ import {
   bytesEqual,
   compareSnapshotsByName,
   compareText,
-  copyBytes,
+  copyBytes
+} from "./chunk-HABG2JM3.js";
+import {
   parseFileSystemVersion
-} from "./chunk-M62ZGJ5I.js";
+} from "./chunk-LPIJ6HKL.js";
 import {
   decodeUtf8Text
 } from "./chunk-M5ZNQGR5.js";
@@ -26,10 +32,6 @@ import {
   workspacePathContains,
   workspacePathDirname
 } from "./chunk-AYWKIZLD.js";
-import {
-  RawIndexedDBFileSystemStore,
-  indexedDBWorkspaceDatabaseName
-} from "./chunk-OQCPBOQA.js";
 
 // src/filesystem/indexeddb-provider-v2.ts
 var ENTRY_SCHEMA_VERSION = 1;
@@ -132,13 +134,10 @@ var IndexedDBFileSystemProviderV2 = class {
           "Expected a directory but found a file."
         );
       }
-      const paths = await listEntryPaths(tx);
       const children = [];
-      for (const candidate of paths) {
-        if (candidate && workspacePathDirname(candidate) === canonical) {
-          const entry = await readRequiredEntry(tx, candidate);
-          children.push(toEntrySnapshot(entry));
-        }
+      for (const candidate of await listChildPaths(tx, canonical)) {
+        const entry = await readRequiredEntry(tx, candidate);
+        children.push(toEntrySnapshot(entry));
       }
       children.sort(compareSnapshotsByName);
       return Object.freeze(children);
@@ -960,6 +959,15 @@ function entryPathsFromKeys(keys) {
 async function listEntryPaths(tx) {
   return entryPathsFromKeys(await tx.keys());
 }
+async function listChildPaths(tx, directory) {
+  if (!tx.childKeys) {
+    return (await listEntryPaths(tx)).filter(
+      (candidate) => candidate !== "" && workspacePathDirname(candidate) === directory
+    );
+  }
+  const prefix = directory ? `${entryKey(directory)}/` : ENTRY_PREFIX;
+  return entryPathsFromKeys(await tx.childKeys(prefix));
+}
 async function readEntry(tx, path) {
   const raw = await tx.get(entryKey(path));
   return raw === null ? null : validateEntry(raw, path);

package/dist/chunk-IDYE73TU.js

@@ -0,0 +1,77 @@
+import {
+  HostFileSystemProviderV2
+} from "./chunk-L6PRMR7T.js";
+import {
+  ELECTRON_FILE_SYSTEM_V2_CAPABILITIES,
+  maybeGetDocBlocksHost
+} from "./chunk-YNUQG4GF.js";
+
+// src/filesystem/electron-provider-v2.ts
+var ElectronFileSystemProviderV2 = class extends HostFileSystemProviderV2 {
+  constructor(id, label, rootPath) {
+    super(id, label, rootPath, { capabilities: ELECTRON_FILE_SYSTEM_V2_CAPABILITIES });
+  }
+};
+
+// src/filesystem/electron-provider.ts
+function getHostFs() {
+  const host = maybeGetDocBlocksHost();
+  if (!host?.fs) {
+    throw new Error("ElectronFileSystemProvider: the host does not expose the legacy fs bridge.");
+  }
+  return host.fs;
+}
+var ElectronFileSystemProvider = class {
+  constructor(id, label, rootPath) {
+    this.id = id;
+    this.label = label;
+    this.rootPath = rootPath;
+    this.v2 = new ElectronFileSystemProviderV2(id, label, rootPath);
+  }
+  /** Absolute path this provider is rooted at. */
+  getRootPath() {
+    return this.rootPath;
+  }
+  readFile(path) {
+    return getHostFs().readFile(this.id, path);
+  }
+  writeFile(path, content) {
+    return getHostFs().writeFile(this.id, path, content);
+  }
+  commitFile(path, content, expectedContent) {
+    return getHostFs().commitFile(this.id, path, content, expectedContent);
+  }
+  delete(path) {
+    return getHostFs().delete(this.id, path);
+  }
+  rename(oldPath, newPath) {
+    return getHostFs().rename(this.id, oldPath, newPath);
+  }
+  readDirectory(path) {
+    return getHostFs().readDirectory(this.id, path);
+  }
+  exists(path) {
+    return getHostFs().exists(this.id, path);
+  }
+  createDirectory(path) {
+    return getHostFs().createDirectory(this.id, path);
+  }
+  stat(path) {
+    return getHostFs().stat(this.id, path);
+  }
+  readBinary(path) {
+    return getHostFs().readBinary(this.id, path);
+  }
+  writeBinary(path, data) {
+    return getHostFs().writeBinary(this.id, path, data);
+  }
+  /** Subscribe to external change notifications under this root. */
+  watch(onChange) {
+    return getHostFs().watch(this.id, onChange);
+  }
+};
+
+export {
+  ElectronFileSystemProviderV2,
+  ElectronFileSystemProvider
+};

package/dist/{chunk-KLQKU74Q.js → chunk-IGB2VSRE.js}

@@ -1,6 +1,6 @@
 import {
-  isFileSystemMoveStateError
-} from "./chunk-QI6YKTQV.js";
+  getFileSystemProviderV2
+} from "./chunk-XAMILHQP.js";
 import {
   decodeUtf8Text
 } from "./chunk-M5ZNQGR5.js";
@@ -8,9 +8,100 @@ import {
   FsError,
   parseWorkspacePath
 } from "./chunk-AYWKIZLD.js";
-import {
-  getFileSystemProviderV2
-} from "./chunk-XAMILHQP.js";
+
+// src/filesystem/move-error.ts
+function locationFromPresence(source, destination) {
+  if (source === "unknown" || destination === "unknown") return "unknown";
+  if (source === "present" && destination === "present") return "both";
+  if (source === "present") return "source";
+  if (destination === "present") return "destination";
+  return "neither";
+}
+var FileSystemMoveRecoveryError = class extends Error {
+  constructor(sourcePath, destinationPath, state, moveError) {
+    super(
+      `The move did not restore one authoritative path. Entry location: ${locationFromPresence(
+        state.source,
+        state.destination
+      )}.`
+    );
+    this.sourcePath = sourcePath;
+    this.destinationPath = destinationPath;
+    this.state = state;
+    this.moveError = moveError;
+    this.code = "partial-move";
+    this.name = "FileSystemMoveRecoveryError";
+  }
+  get location() {
+    return locationFromPresence(this.state.source, this.state.destination);
+  }
+  /** Alias used by DocumentSession's document-retarget recovery protocol. */
+  get documentLocation() {
+    return this.location;
+  }
+};
+var FileSystemPartialMoveError = class extends Error {
+  constructor(sourcePath, destinationPath, companionSourcePath, companionDestinationPath, state, moveError, rollbackError) {
+    super(
+      `The document move could not be rolled back. Document location: ${locationFromPresence(
+        state.source,
+        state.destination
+      )}; companion location: ${locationFromPresence(
+        state.companionSource,
+        state.companionDestination
+      )}.`
+    );
+    this.sourcePath = sourcePath;
+    this.destinationPath = destinationPath;
+    this.companionSourcePath = companionSourcePath;
+    this.companionDestinationPath = companionDestinationPath;
+    this.state = state;
+    this.moveError = moveError;
+    this.rollbackError = rollbackError;
+    this.code = "partial-move";
+    this.name = "FileSystemPartialMoveError";
+  }
+  get documentLocation() {
+    return locationFromPresence(this.state.source, this.state.destination);
+  }
+  get companionLocation() {
+    return locationFromPresence(this.state.companionSource, this.state.companionDestination);
+  }
+};
+function isFileSystemPartialMoveError(error) {
+  return error instanceof FileSystemPartialMoveError;
+}
+function isFileSystemMoveRecoveryError(error) {
+  return error instanceof FileSystemMoveRecoveryError;
+}
+function isFileSystemMoveStateError(error) {
+  return isFileSystemMoveRecoveryError(error) || isFileSystemPartialMoveError(error);
+}
+async function probePath(provider, path) {
+  try {
+    const providerV2 = getFileSystemProviderV2(provider);
+    const present = providerV2 ? await providerV2.stat(parseWorkspacePath(path)) !== null : await provider.exists(path);
+    return present ? "present" : "missing";
+  } catch {
+    return "unknown";
+  }
+}
+async function describePartialMove(provider, sourcePath, destinationPath, companionSourcePath, companionDestinationPath) {
+  const [source, destination, companionSource, companionDestination] = await Promise.all([
+    probePath(provider, sourcePath),
+    probePath(provider, destinationPath),
+    probePath(provider, companionSourcePath),
+    probePath(provider, companionDestinationPath)
+  ]);
+  return { source, destination, companionSource, companionDestination };
+}
+async function describeEntryMove(provider, sourcePath, destinationPath) {
+  const [source, destination] = await Promise.all([
+    probePath(provider, sourcePath),
+    probePath(provider, destinationPath)
+  ]);
+  return { source, destination };
+}
 
 // src/document/document-session.ts
 var DEFAULT_AUTO_SAVE_RETRY_DELAYS_MS = [1e3, 3e3, 1e4];
@@ -31,6 +122,7 @@ var DocumentSessionConflictError = class extends Error {
 };
 var DocumentSession = class {
   constructor(options = {}) {
+    this.recoveredRecords = [];
     this.listeners = /* @__PURE__ */ new Set();
     this.target = null;
     this.content = "";
@@ -60,7 +152,7 @@ var DocumentSession = class {
     this.autoSaveRetryDelaysMs = normalizeRetryDelays(
       options.autoSaveRetryDelaysMs ?? DEFAULT_AUTO_SAVE_RETRY_DELAYS_MS
     );
-    this.recoveryJournal = options.recoveryJournal ?? null;
+    this.recoveryJournal = options.recoveryJournal?.forOwner(crypto.randomUUID()) ?? null;
     this.snapshot = this.createSnapshot();
   }
   /** Enable or disable automatic persistence without weakening explicit or lifecycle flushes. */
@@ -281,6 +373,7 @@ var DocumentSession = class {
       this.clearAutoSaveTimer();
       this.haltDrain = true;
       this.conflict = {
+        ...this.conflict,
         targetKey: change.targetKey,
         localContent: this.content,
         localRevision: this.revision,
@@ -541,6 +634,7 @@ var DocumentSession = class {
         generation,
         persistedRevision: this.persistedRevision
       });
+      this.acknowledgeRecoveredRecords();
       this.emit();
     }
   }
@@ -558,15 +652,16 @@ var DocumentSession = class {
    * baseline becomes an explicit conflict and is never auto-overwritten.
    */
   restoreRecoverySnapshot() {
+    this.recoveredRecords = [];
     if (!this.target || !this.recoveryJournal) return "none";
-    const recovered = this.recoveryJournal.lookup(this.target.key);
+    const records = this.recoveryJournal.list(this.target.key);
+    const recovered = records[0];
     if (!recovered) return "none";
+    this.recoveredRecords = records.filter(
+      (record) => record.content === recovered.content && record.persistedContent === recovered.persistedContent
+    );
     if (recovered.content === this.content) {
-      this.recoveryJournal.acknowledge({
-        targetKey: recovered.targetKey,
-        generation: recovered.generation,
-        persistedRevision: recovered.revision
-      });
+      this.acknowledgeRecoveredRecords();
       return "none";
     }
     const externalContent = this.content;
@@ -580,6 +675,10 @@ var DocumentSession = class {
     this.persistedContent = recovered.persistedContent;
     this.haltDrain = true;
     this.conflict = {
+      recoveredDraft: true,
+      recoveredDraftCapturedAt: Math.min(
+        ...this.recoveredRecords.map((record) => record.updatedAt)
+      ),
       targetKey: this.target.key,
       localContent: recovered.content,
       localRevision: this.revision,
@@ -603,6 +702,11 @@ var DocumentSession = class {
   discardRecoverySnapshot() {
     if (!this.target) return;
     this.recoveryJournal?.discard(this.target.key);
+    this.acknowledgeRecoveredRecords();
+  }
+  acknowledgeRecoveredRecords() {
+    for (const record of this.recoveredRecords) this.recoveryJournal?.acknowledgeRecord(record);
+    this.recoveredRecords = [];
   }
   detach() {
     this.clearAutoSaveTimer();
@@ -758,326 +862,16 @@ function createFileSystemDocumentTarget(provider, path, options = {}) {
   };
 }
 
-// src/document/recovery-journal.ts
-var DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY = "docblocks:document-recovery:v1";
-var DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION = 1;
-var DEFAULT_MAX_ENTRIES = 20;
-var DEFAULT_MAX_STORAGE_BYTES = 2e6;
-var DEFAULT_MAX_RECORD_BYTES = 1e6;
-var DEFAULT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-var DEFAULT_MAX_FUTURE_SKEW_MS = 5 * 60 * 1e3;
-var MAX_TARGET_KEY_LENGTH = 4096;
-var DocumentRecoveryJournal = class {
-  constructor(storage, options = {}) {
-    this.storage = storage;
-    this.storageKey = options.storageKey?.trim() || DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY;
-    this.maxEntries = positiveInteger(options.maxEntries, DEFAULT_MAX_ENTRIES);
-    this.maxStorageBytes = positiveInteger(options.maxStorageBytes, DEFAULT_MAX_STORAGE_BYTES);
-    this.maxRecordBytes = Math.min(
-      positiveInteger(options.maxRecordBytes, DEFAULT_MAX_RECORD_BYTES),
-      this.maxStorageBytes
-    );
-    this.maxAgeMs = nonNegativeFinite(options.maxAgeMs, DEFAULT_MAX_AGE_MS);
-    this.maxFutureSkewMs = nonNegativeFinite(options.maxFutureSkewMs, DEFAULT_MAX_FUTURE_SKEW_MS);
-    this.now = options.now ?? Date.now;
-  }
-  /**
-   * Synchronously persist the latest dirty snapshot for a target.
-   * Storage/quota failures are returned, never thrown into an editor onChange.
-   */
-  write(input) {
-    const timestamp = this.now();
-    if (!isValidWrite(input) || !Number.isFinite(timestamp) || timestamp < 0) {
-      return { status: "rejected", reason: "invalid-record", evicted: 0 };
-    }
-    if (!this.storage) {
-      return { status: "rejected", reason: "storage-unavailable", evicted: 0 };
-    }
-    if (estimatedBytes(input.content) > this.maxRecordBytes || input.persistedContent !== null && estimatedBytes(input.persistedContent) > this.maxRecordBytes) {
-      return { status: "rejected", reason: "record-too-large", evicted: 0 };
-    }
-    const loaded = this.load(timestamp);
-    const existing = loaded.records.find((record) => record.targetKey === input.targetKey);
-    if (existing) {
-      const ordering = compareGenerationRevision(input, existing);
-      if (ordering < 0) return { status: "ignored-stale", evicted: 0 };
-      if (ordering === 0) {
-        if (existing.content === input.content && existing.persistedContent === input.persistedContent) {
-          return { status: "unchanged", evicted: 0 };
-        }
-        return { status: "rejected", reason: "invalid-record", evicted: 0 };
-      }
-    }
-    const candidate = {
-      targetKey: input.targetKey,
-      generation: input.generation,
-      revision: input.revision,
-      content: input.content,
-      persistedContent: input.persistedContent,
-      createdAt: existing?.createdAt ?? timestamp,
-      updatedAt: timestamp
-    };
-    if (estimatedBytes(JSON.stringify(candidate)) > this.maxRecordBytes) {
-      return { status: "rejected", reason: "record-too-large", evicted: 0 };
-    }
-    if (estimatedBytes(serializeEnvelope([candidate])) > this.maxStorageBytes) {
-      return { status: "rejected", reason: "record-too-large", evicted: 0 };
-    }
-    const next = loaded.records.filter((record) => record.targetKey !== input.targetKey);
-    next.push(candidate);
-    const persisted = this.persistBounded(next, input.targetKey);
-    if (!persisted.stored) {
-      return {
-        status: "rejected",
-        reason: persisted.reason ?? "quota-exceeded",
-        evicted: persisted.evicted
-      };
-    }
-    return { status: "stored", evicted: persisted.evicted };
-  }
-  /** Return the recoverable snapshot for one target, if present and valid. */
-  lookup(targetKey, generation) {
-    if (!isValidTargetKey(targetKey) || !isOptionalGeneration(generation)) return null;
-    const record = this.load(this.now()).records.find(
-      (candidate) => candidate.targetKey === targetKey && (generation === void 0 || candidate.generation === generation)
-    );
-    return record ? cloneRecord(record) : null;
-  }
-  /** List valid records, newest first. Optionally restrict to one target. */
-  list(targetKey) {
-    if (targetKey !== void 0 && !isValidTargetKey(targetKey)) return [];
-    return this.load(this.now()).records.filter((record) => targetKey === void 0 || record.targetKey === targetKey).sort(compareNewestFirst).map(cloneRecord);
-  }
-  /**
-   * Clear a record only when the same generation has durably acknowledged at
-   * least the journaled revision. A stale acknowledgement cannot erase a newer
-   * crash-recovery snapshot.
-   */
-  acknowledge(input) {
-    if (!isValidAcknowledgement(input) || !this.storage) return false;
-    const records = this.load(this.now()).records;
-    const record = records.find((candidate) => candidate.targetKey === input.targetKey);
-    if (!record || record.generation !== input.generation || record.revision > input.persistedRevision) {
-      return false;
-    }
-    return this.persistExact(records.filter((candidate) => candidate !== record));
-  }
-  /** Explicitly discard recovery data after a user or lifecycle decision. */
-  discard(targetKey, generation) {
-    if (!isValidTargetKey(targetKey) || !isOptionalGeneration(generation) || !this.storage) {
-      return false;
-    }
-    const records = this.load(this.now()).records;
-    const next = records.filter(
-      (record) => record.targetKey !== targetKey || generation !== void 0 && record.generation !== generation
-    );
-    if (next.length === records.length) return false;
-    return this.persistExact(next);
-  }
-  load(timestamp) {
-    if (!this.storage) return { records: [], needsRepair: false };
-    let raw;
-    try {
-      raw = this.storage.getItem(this.storageKey);
-    } catch {
-      return { records: [], needsRepair: false };
-    }
-    if (raw === null) return { records: [], needsRepair: false };
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      this.tryRemove();
-      return { records: [], needsRepair: true };
-    }
-    if (!isEnvelope(parsed)) {
-      this.tryRemove();
-      return { records: [], needsRepair: true };
-    }
-    const byTarget = /* @__PURE__ */ new Map();
-    let needsRepair = estimatedBytes(raw) > this.maxStorageBytes;
-    for (const candidate of parsed.records) {
-      if (!isValidStoredRecord(candidate, timestamp, this.maxAgeMs, this.maxFutureSkewMs)) {
-        needsRepair = true;
-        continue;
-      }
-      if (estimatedBytes(JSON.stringify(candidate)) > this.maxRecordBytes) {
-        needsRepair = true;
-        continue;
-      }
-      const current = byTarget.get(candidate.targetKey);
-      if (!current || compareStoredRecords(candidate, current) > 0) {
-        if (current) needsRepair = true;
-        byTarget.set(candidate.targetKey, cloneRecord(candidate));
-      } else {
-        needsRepair = true;
-      }
-    }
-    const records = [...byTarget.values()].sort(compareNewestFirst);
-    while (records.length > this.maxEntries) {
-      records.pop();
-      needsRepair = true;
-    }
-    while (records.length > 0 && estimatedBytes(serializeEnvelope(records)) > this.maxStorageBytes) {
-      records.pop();
-      needsRepair = true;
-    }
-    if (needsRepair) {
-      this.persistBounded(records);
-    }
-    return { records, needsRepair };
-  }
-  persistBounded(records, protectedTarget) {
-    if (!this.storage) {
-      return { stored: false, evicted: 0, reason: "storage-unavailable" };
-    }
-    const next = [...records].sort(compareNewestFirst);
-    let evicted = 0;
-    while (next.length > this.maxEntries) {
-      if (!evictOldest(next, protectedTarget)) break;
-      evicted += 1;
-    }
-    let serialized = serializeEnvelope(next);
-    while (estimatedBytes(serialized) > this.maxStorageBytes) {
-      if (!evictOldest(next, protectedTarget)) {
-        return { stored: false, evicted, reason: "quota-exceeded" };
-      }
-      evicted += 1;
-      serialized = serializeEnvelope(next);
-    }
-    for (; ; ) {
-      try {
-        this.storage.setItem(this.storageKey, serialized);
-        return { stored: true, evicted };
-      } catch {
-        if (!evictOldest(next, protectedTarget)) {
-          return { stored: false, evicted, reason: "quota-exceeded" };
-        }
-        evicted += 1;
-        serialized = serializeEnvelope(next);
-      }
-    }
-  }
-  persistExact(records) {
-    if (!this.storage) return false;
-    if (records.length === 0) {
-      try {
-        this.storage.removeItem(this.storageKey);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    try {
-      this.storage.setItem(this.storageKey, serializeEnvelope(records));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  tryRemove() {
-    try {
-      this.storage?.removeItem(this.storageKey);
-    } catch {
-    }
-  }
-};
-function getDefaultDocumentRecoveryStorage() {
-  try {
-    const candidate = Reflect.get(globalThis, "localStorage");
-    if (!isStorage(candidate)) return null;
-    return candidate;
-  } catch {
-    return null;
-  }
-}
-function serializeEnvelope(records) {
-  const envelope = {
-    schemaVersion: DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION,
-    records
-  };
-  return JSON.stringify(envelope);
-}
-function estimatedBytes(value) {
-  return value.length * 2;
-}
-function positiveInteger(value, fallback) {
-  return Number.isSafeInteger(value) && (value ?? 0) > 0 ? value : fallback;
-}
-function nonNegativeFinite(value, fallback) {
-  return Number.isFinite(value) && (value ?? -1) >= 0 ? value : fallback;
-}
-function isEnvelope(value) {
-  if (!isObject(value)) return false;
-  return value.schemaVersion === DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION && Array.isArray(value.records);
-}
-function isValidStoredRecord(value, timestamp, maxAgeMs, maxFutureSkewMs) {
-  if (!isObject(value)) return false;
-  if (!isValidTargetKey(value.targetKey) || !isNonNegativeSafeInteger(value.generation) || !isNonNegativeSafeInteger(value.revision) || typeof value.content !== "string" || value.persistedContent !== null && typeof value.persistedContent !== "string" || !isNonNegativeFiniteNumber(value.createdAt) || !isNonNegativeFiniteNumber(value.updatedAt) || value.createdAt > value.updatedAt) {
-    return false;
-  }
-  if (!Number.isFinite(timestamp) || timestamp < 0) return false;
-  if (value.updatedAt > timestamp + maxFutureSkewMs) return false;
-  return timestamp - value.updatedAt <= maxAgeMs;
-}
-function isValidWrite(value) {
-  return isValidTargetKey(value.targetKey) && isNonNegativeSafeInteger(value.generation) && isNonNegativeSafeInteger(value.revision) && typeof value.content === "string" && (value.persistedContent === null || typeof value.persistedContent === "string");
-}
-function isValidAcknowledgement(value) {
-  return isValidTargetKey(value.targetKey) && isNonNegativeSafeInteger(value.generation) && isNonNegativeSafeInteger(value.persistedRevision);
-}
-function isValidTargetKey(value) {
-  return typeof value === "string" && value.length > 0 && value.length <= MAX_TARGET_KEY_LENGTH;
-}
-function isOptionalGeneration(value) {
-  return value === void 0 || isNonNegativeSafeInteger(value);
-}
-function isNonNegativeSafeInteger(value) {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-}
-function isNonNegativeFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function isStorage(value) {
-  if (!isObject(value)) return false;
-  return typeof value.getItem === "function" && typeof value.setItem === "function" && typeof value.removeItem === "function";
-}
-function compareGenerationRevision(left, right) {
-  if (left.generation !== right.generation) return left.generation - right.generation;
-  return left.revision - right.revision;
-}
-function compareStoredRecords(left, right) {
-  return compareGenerationRevision(left, right) || left.updatedAt - right.updatedAt;
-}
-function compareNewestFirst(left, right) {
-  return right.updatedAt - left.updatedAt || right.revision - left.revision;
-}
-function cloneRecord(record) {
-  return { ...record };
-}
-function evictOldest(records, protectedTarget) {
-  let oldestIndex = -1;
-  for (let index = 0; index < records.length; index += 1) {
-    if (records[index].targetKey === protectedTarget) continue;
-    if (oldestIndex < 0 || compareNewestFirst(records[index], records[oldestIndex]) > 0) {
-      oldestIndex = index;
-    }
-  }
-  if (oldestIndex < 0) return false;
-  records.splice(oldestIndex, 1);
-  return true;
-}
-
 export {
+  FileSystemMoveRecoveryError,
+  FileSystemPartialMoveError,
+  isFileSystemPartialMoveError,
+  isFileSystemMoveRecoveryError,
+  isFileSystemMoveStateError,
+  describePartialMove,
+  describeEntryMove,
   DocumentCommitConflictError,
   DocumentSessionConflictError,
   DocumentSession,
-  createFileSystemDocumentTarget,
-  DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY,
-  DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION,
-  DocumentRecoveryJournal,
-  getDefaultDocumentRecoveryStorage
+  createFileSystemDocumentTarget
 };