@bendyline/docblocks 1.1.2 → 2.0.0

package/src/filesystem/electron-provider.ts

@@ -1,16 +1,17 @@
 /**
  * ElectronFileSystemProvider — implements FileSystemProvider by delegating
  * to the Electron desktop host's fs IPC bridge. Every operation is scoped
- * to an absolute root path that the main process validates against a
- * whitelist of registered workspace roots.
+ * to an opaque workspace id that the main process resolves against its
+ * registered workspace authority.
  *
  * This file has no Electron dependency — it is a pure IPC client that
  * relies on the `docBlocksHost` global installed by the preload script.
  */
 
-import type { FileSystemProvider, FileSystemEntry, FileMeta } from './types.js';
+import type { FileCommitResult, FileSystemProvider, FileSystemEntry, FileMeta } from './types.js';
 import { maybeGetDocBlocksHost } from '../host/index.js';
 import type { DocBlocksHostFsAPI } from '../host/types.js';
+import { ElectronFileSystemProviderV2 } from './electron-provider-v2.js';
 
 export { isElectronHost } from '../host/index.js';
 
@@ -27,6 +28,7 @@ function getHostFs(): DocBlocksHostFsAPI {
 export class ElectronFileSystemProvider implements FileSystemProvider {
   readonly id: string;
   readonly label: string;
+  readonly v2: ElectronFileSystemProviderV2;
 
   private readonly rootPath: string;
 
@@ -34,6 +36,7 @@ export class ElectronFileSystemProvider implements FileSystemProvider {
     this.id = id;
     this.label = label;
     this.rootPath = rootPath;
+    this.v2 = new ElectronFileSystemProviderV2(id, label, rootPath);
   }
 
   /** Absolute path this provider is rooted at. */
@@ -42,47 +45,55 @@ export class ElectronFileSystemProvider implements FileSystemProvider {
   }
 
   readFile(path: string): Promise<string | null> {
-    return getHostFs().readFile(this.rootPath, path);
+    return getHostFs().readFile(this.id, path);
   }
 
   writeFile(path: string, content: string): Promise<void> {
-    return getHostFs().writeFile(this.rootPath, path, content);
+    return getHostFs().writeFile(this.id, path, content);
+  }
+
+  commitFile(
+    path: string,
+    content: string,
+    expectedContent: string | null,
+  ): Promise<FileCommitResult> {
+    return getHostFs().commitFile(this.id, path, content, expectedContent);
   }
 
   delete(path: string): Promise<void> {
-    return getHostFs().delete(this.rootPath, path);
+    return getHostFs().delete(this.id, path);
   }
 
   rename(oldPath: string, newPath: string): Promise<void> {
-    return getHostFs().rename(this.rootPath, oldPath, newPath);
+    return getHostFs().rename(this.id, oldPath, newPath);
   }
 
   readDirectory(path: string): Promise<FileSystemEntry[]> {
-    return getHostFs().readDirectory(this.rootPath, path);
+    return getHostFs().readDirectory(this.id, path);
   }
 
   exists(path: string): Promise<boolean> {
-    return getHostFs().exists(this.rootPath, path);
+    return getHostFs().exists(this.id, path);
   }
 
   createDirectory(path: string): Promise<void> {
-    return getHostFs().createDirectory(this.rootPath, path);
+    return getHostFs().createDirectory(this.id, path);
   }
 
   stat(path: string): Promise<FileMeta | null> {
-    return getHostFs().stat(this.rootPath, path);
+    return getHostFs().stat(this.id, path);
   }
 
   readBinary(path: string): Promise<ArrayBuffer | null> {
-    return getHostFs().readBinary(this.rootPath, path);
+    return getHostFs().readBinary(this.id, path);
   }
 
   writeBinary(path: string, data: ArrayBuffer | Uint8Array): Promise<void> {
-    return getHostFs().writeBinary(this.rootPath, path, data);
+    return getHostFs().writeBinary(this.id, path, data);
   }
 
   /** Subscribe to external change notifications under this root. */
   watch(onChange: (changedPath: string) => void): () => void {
-    return getHostFs().watch(this.rootPath, onChange);
+    return getHostFs().watch(this.id, onChange);
   }
 }

package/src/filesystem/electron.ts

@@ -0,0 +1,3 @@
+/** Electron renderer filesystem provider entry point. */
+export { ElectronFileSystemProvider, isElectronHost } from './electron-provider.js';
+export { ElectronFileSystemProviderV2 } from './electron-provider-v2.js';

package/src/filesystem/filesystem-content-container.ts

@@ -9,7 +9,9 @@
 
 import type { ContentContainer, ContentEntry } from '@bendyline/squisq/storage';
 import { findDocumentPath } from '@bendyline/squisq/storage';
-import type { FileSystemProvider } from './types.js';
+import { FsError } from './fs-error.js';
+import { getFileSystemProviderV2, type FileSystemProvider } from './types.js';
+import { parseWorkspacePath, workspacePathContains, workspacePathJoin } from './workspace-path.js';
 
 const EXTENSION_MIME_MAP: Record<string, string> = {
   '.md': 'text/markdown',
@@ -37,8 +39,7 @@ function guessMimeType(path: string): string {
 }
 
 function joinPrefix(prefix: string, p: string): string {
-  const clean = p.replace(/^\/+/, '');
-  return prefix.replace(/\/+$/, '') + '/' + clean;
+  return workspacePathJoin(parseWorkspacePath(prefix), p);
 }
 
 export class FileSystemContentContainer implements ContentContainer {
@@ -48,11 +49,13 @@ export class FileSystemContentContainer implements ContentContainer {
     private readonly provider: FileSystemProvider,
     prefix = '.docblocks/media',
   ) {
-    this.prefix = prefix.replace(/^\/+/, '').replace(/\/+$/, '');
+    this.prefix = parseWorkspacePath(prefix);
   }
 
   async readFile(path: string): Promise<ArrayBuffer | null> {
     const full = joinPrefix(this.prefix, path);
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    if (providerV2) return (await providerV2.readFile(parseWorkspacePath(full)))?.data ?? null;
     const binary = await this.provider.readBinary(full);
     if (binary) return binary;
     // IndexedDB-backed workspaces store text via `writeFile(string)` and
@@ -67,43 +70,78 @@ export class FileSystemContentContainer implements ContentContainer {
   }
 
   async writeFile(path: string, data: ArrayBuffer | Uint8Array, _mimeType?: string): Promise<void> {
-    await this.provider.writeBinary(joinPrefix(this.prefix, path), data);
+    const full = joinPrefix(this.prefix, path);
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    if (providerV2) {
+      await providerV2.writeFile(parseWorkspacePath(full), data, {
+        mode: 'upsert',
+        createParents: true,
+      });
+      return;
+    }
+    await this.provider.writeBinary(full, data);
   }
 
   async removeFile(path: string): Promise<void> {
-    await this.provider.delete(joinPrefix(this.prefix, path));
+    const full = joinPrefix(this.prefix, path);
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    if (providerV2) {
+      await providerV2.remove(parseWorkspacePath(full), { missing: 'ignore' });
+      return;
+    }
+    await this.provider.delete(full);
   }
 
   async listFiles(prefix?: string): Promise<ContentEntry[]> {
     const entries: ContentEntry[] = [];
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    const root = parseWorkspacePath(this.prefix);
+    type ListedEntry = {
+      readonly kind: 'file' | 'directory';
+      readonly path: string;
+      readonly size?: number | null;
+    };
     const walk = async (dir: string) => {
-      let children;
+      let children: readonly ListedEntry[];
       try {
-        children = await this.provider.readDirectory(dir);
-      } catch {
-        return;
+        children = providerV2
+          ? await providerV2.readDirectory(parseWorkspacePath(dir))
+          : await this.provider.readDirectory(dir);
+      } catch (error: unknown) {
+        // An absent container root means an empty container. Every other
+        // storage fault (including a subtree disappearing mid-snapshot)
+        // remains observable to backup/export callers.
+        if (dir === root && error instanceof FsError && error.code === 'not-found') return;
+        throw error;
       }
       for (const child of children) {
         if (child.kind === 'directory') {
           await walk(child.path);
         } else {
-          const rel = child.path.replace(new RegExp('^/?' + this.prefix + '/?'), '');
+          const childPath = parseWorkspacePath(child.path);
+          const prefixPath = parseWorkspacePath(this.prefix);
+          if (!workspacePathContains(prefixPath, childPath)) continue;
+          const rel = childPath === prefixPath ? '' : childPath.slice(prefixPath.length + 1);
           if (prefix && !rel.startsWith(prefix)) continue;
-          const meta = await this.provider.stat(child.path);
+          const size = child.size ?? (await this.provider.stat(child.path))?.size ?? 0;
           entries.push({
             path: rel,
             mimeType: guessMimeType(rel),
-            size: meta?.size ?? 0,
+            size,
           });
         }
       }
     };
-    await walk('/' + this.prefix);
+    await walk(root);
     return entries;
   }
 
   async exists(path: string): Promise<boolean> {
-    return this.provider.exists(joinPrefix(this.prefix, path));
+    const full = joinPrefix(this.prefix, path);
+    const providerV2 = getFileSystemProviderV2(this.provider);
+    return providerV2
+      ? (await providerV2.stat(parseWorkspacePath(full))) !== null
+      : this.provider.exists(full);
   }
 
   async getDocumentPath(): Promise<string | null> {

package/src/filesystem/fs-error.ts

@@ -0,0 +1,234 @@
+/** Stable error codes shared by every filesystem transport and backend. */
+export type FsErrorCode =
+  | 'invalid-path'
+  | 'path-escape'
+  | 'not-found'
+  | 'already-exists'
+  | 'type-mismatch'
+  | 'not-empty'
+  | 'permission-denied'
+  | 'conflict'
+  | 'quota-exceeded'
+  | 'not-supported'
+  | 'busy'
+  | 'disposed'
+  | 'closed'
+  | 'aborted'
+  | 'io';
+
+export type FsOperation =
+  | 'parse-path'
+  | 'read'
+  | 'stat'
+  | 'list'
+  | 'write'
+  | 'create-directory'
+  | 'remove'
+  | 'move'
+  | 'snapshot'
+  | 'watch'
+  | 'dispose';
+
+/** Plain-data form safe to send over IPC, postMessage, or JSON. */
+export interface SerializedFsError {
+  readonly name: 'FsError';
+  readonly code: FsErrorCode;
+  readonly message: string;
+  readonly operation: FsOperation | null;
+  readonly path: string | null;
+  readonly destinationPath: string | null;
+  readonly retryable: boolean;
+}
+
+export interface FsErrorContext {
+  readonly operation?: FsOperation;
+  readonly path?: string;
+  readonly destinationPath?: string;
+  readonly retryable?: boolean;
+  readonly defaultCode?: FsErrorCode;
+}
+
+const FS_ERROR_CODES: ReadonlySet<string> = new Set<FsErrorCode>([
+  'invalid-path',
+  'path-escape',
+  'not-found',
+  'already-exists',
+  'type-mismatch',
+  'not-empty',
+  'permission-denied',
+  'conflict',
+  'quota-exceeded',
+  'not-supported',
+  'busy',
+  'disposed',
+  'closed',
+  'aborted',
+  'io',
+]);
+
+const FS_OPERATIONS: ReadonlySet<string> = new Set<FsOperation>([
+  'parse-path',
+  'read',
+  'stat',
+  'list',
+  'write',
+  'create-directory',
+  'remove',
+  'move',
+  'snapshot',
+  'watch',
+  'dispose',
+]);
+
+/** Error with a stable code and a deliberately serializable public shape. */
+export class FsError extends Error {
+  public readonly code: FsErrorCode;
+  public readonly operation: FsOperation | null;
+  public readonly path: string | null;
+  public readonly destinationPath: string | null;
+  public readonly retryable: boolean;
+
+  public constructor(code: FsErrorCode, message: string, context: FsErrorContext = {}) {
+    super(message);
+    this.name = 'FsError';
+    this.code = code;
+    this.operation = context.operation ?? null;
+    this.path = context.path ?? null;
+    this.destinationPath = context.destinationPath ?? null;
+    this.retryable = context.retryable ?? (code === 'io' || code === 'aborted' || code === 'busy');
+  }
+
+  public toJSON(): SerializedFsError {
+    return {
+      name: 'FsError',
+      code: this.code,
+      message: this.message,
+      operation: this.operation,
+      path: this.path,
+      destinationPath: this.destinationPath,
+      retryable: this.retryable,
+    };
+  }
+}
+
+export function mapDomExceptionToFsErrorCode(name: string): FsErrorCode {
+  switch (name) {
+    case 'NotFoundError':
+      return 'not-found';
+    case 'ConstraintError':
+      return 'already-exists';
+    case 'TypeMismatchError':
+      return 'type-mismatch';
+    case 'InvalidModificationError':
+      return 'not-empty';
+    case 'NotAllowedError':
+    case 'SecurityError':
+    case 'NoModificationAllowedError':
+      return 'permission-denied';
+    case 'QuotaExceededError':
+      return 'quota-exceeded';
+    case 'NotSupportedError':
+      return 'not-supported';
+    case 'InvalidStateError':
+      return 'disposed';
+    case 'AbortError':
+      return 'aborted';
+    default:
+      return 'io';
+  }
+}
+
+export function mapNodeErrorCodeToFsErrorCode(code: string): FsErrorCode {
+  switch (code) {
+    case 'ENOENT':
+      return 'not-found';
+    case 'ENOTDIR':
+      return 'type-mismatch';
+    case 'EEXIST':
+      return 'already-exists';
+    case 'EISDIR':
+      return 'type-mismatch';
+    case 'ENOTEMPTY':
+      return 'not-empty';
+    case 'EACCES':
+    case 'EPERM':
+      return 'permission-denied';
+    case 'ENOSPC':
+    case 'EDQUOT':
+      return 'quota-exceeded';
+    case 'EBUSY':
+      return 'busy';
+    case 'EXDEV':
+    case 'ENOTSUP':
+    case 'EOPNOTSUPP':
+      return 'not-supported';
+    default:
+      return 'io';
+  }
+}
+
+export function isSerializedFsError(value: unknown): value is SerializedFsError {
+  if (!value || typeof value !== 'object') return false;
+  const candidate = value as Partial<Record<keyof SerializedFsError, unknown>>;
+  return (
+    candidate.name === 'FsError' &&
+    typeof candidate.code === 'string' &&
+    FS_ERROR_CODES.has(candidate.code) &&
+    typeof candidate.message === 'string' &&
+    (candidate.operation === null ||
+      (typeof candidate.operation === 'string' && FS_OPERATIONS.has(candidate.operation))) &&
+    (candidate.path === null || typeof candidate.path === 'string') &&
+    (candidate.destinationPath === null || typeof candidate.destinationPath === 'string') &&
+    typeof candidate.retryable === 'boolean'
+  );
+}
+
+export function deserializeFsError(value: SerializedFsError): FsError {
+  return new FsError(value.code, value.message, {
+    operation: value.operation ?? undefined,
+    path: value.path ?? undefined,
+    destinationPath: value.destinationPath ?? undefined,
+    retryable: value.retryable,
+  });
+}
+
+export function fsErrorFromUnknown(error: unknown, context: FsErrorContext = {}): FsError {
+  if (error instanceof FsError) return error;
+  if (isSerializedFsError(error)) return deserializeFsError(error);
+
+  const name = getErrorStringField(error, 'name');
+  const nodeCode = getErrorStringField(error, 'code');
+  const message = getErrorStringField(error, 'message') ?? String(error);
+  const code =
+    context.defaultCode ??
+    (nodeCode
+      ? mapNodeErrorCodeToFsErrorCode(nodeCode)
+      : name
+        ? mapDomExceptionToFsErrorCode(name)
+        : 'io');
+  return new FsError(code, message, context);
+}
+
+export function serializeFsError(error: unknown, context: FsErrorContext = {}): SerializedFsError {
+  return fsErrorFromUnknown(error, context).toJSON();
+}
+
+/**
+ * True when a storage backend rejected an operation because the origin or
+ * device is out of space. Covers typed `FsError`s (`'quota-exceeded'`, from
+ * DOMException `QuotaExceededError` or Node `ENOSPC`/`EDQUOT`), serialized
+ * transport copies, and raw DOMExceptions from backends that do not wrap
+ * their errors (e.g. the File System Access API) — including cross-realm
+ * instances where `instanceof DOMException` would fail.
+ */
+export function isQuotaExceededError(error: unknown): boolean {
+  if (error instanceof FsError) return error.code === 'quota-exceeded';
+  if (isSerializedFsError(error)) return error.code === 'quota-exceeded';
+  return getErrorStringField(error, 'name') === 'QuotaExceededError';
+}
+
+function getErrorStringField(error: unknown, key: 'name' | 'message' | 'code'): string | null {
+  if (!error || typeof error !== 'object') return null;
+  const value = (error as Record<string, unknown>)[key];
+  return typeof value === 'string' ? value : null;
+}

package/src/filesystem/index.ts

@@ -1,15 +1,127 @@
 export type {
   FileSystemProvider,
+  FileSystemProviderWithV2,
   FileSystemEntry,
   FileEntry,
   FolderEntry,
   FileMeta,
+  FileCommitResult,
 } from './types.js';
+export { getFileSystemProviderV2, hasFileSystemProviderV2 } from './types.js';
+
+export {
+  WORKSPACE_ROOT,
+  parseWorkspacePath,
+  tryParseWorkspacePath,
+  workspacePathToLegacy,
+  workspacePathJoin,
+  workspacePathDirname,
+  workspacePathBasename,
+  workspacePathContains,
+  type WorkspacePath,
+} from './workspace-path.js';
+export {
+  FsError,
+  mapDomExceptionToFsErrorCode,
+  mapNodeErrorCodeToFsErrorCode,
+  isSerializedFsError,
+  isQuotaExceededError,
+  serializeFsError,
+  deserializeFsError,
+  fsErrorFromUnknown,
+  type FsErrorCode,
+  type FsOperation,
+  type SerializedFsError,
+  type FsErrorContext,
+} from './fs-error.js';
+export type {
+  FileSystemProviderV2,
+  FileSystemProviderCapabilities,
+  FileSystemVersion,
+  FileSystemConditionalWriteStrength,
+  FileSystemSymlinkPolicy,
+  FileSystemAtomicity,
+  FileSystemCaseSensitivity,
+  FileSystemDurability,
+  FileSystemEntrySnapshot,
+  FileSystemFileSnapshot,
+  FileSystemDirectorySnapshot,
+  FileSystemFileRead,
+  FileSystemSnapshot,
+  FileSystemSnapshotEntry,
+  FileSystemSnapshotFile,
+  FileSystemWriteMode,
+  FileSystemWriteOptions,
+  FileSystemCreateDirectoryMode,
+  FileSystemCreateDirectoryOptions,
+  FileSystemRemoveOptions,
+  FileSystemRemoveResult,
+  FileSystemMoveOptions,
+  FileSystemWatchEventType,
+  FileSystemWatchEventOrigin,
+  FileSystemWatchEvent,
+  FileSystemEntryWatchEvent,
+  FileSystemOverflowWatchEvent,
+  FileSystemWatchListener,
+  FileSystemWatchErrorListener,
+  FileSystemWatchOptions,
+  FileSystemWatchSubscription,
+} from './v2.js';
+export { parseFileSystemVersion, tryParseFileSystemVersion } from './v2.js';
+export {
+  MemoryFileSystemProviderV2,
+  type MemoryFilePayloadKind,
+  type MemoryFileSystemV2CompatibilityFile,
+  type MemoryFileSystemV2Replacement,
+  type MemoryFileSystemV2ReplacementFile,
+  type MemoryFileSystemV2State,
+  type MemoryFileSystemV2StateFile,
+} from './memory-provider-v2.js';
+export {
+  IndexedDBFileSystemProviderV2,
+  type IndexedDBFileSystemProviderV2Options,
+  type IndexedDBLegacyConflictReason,
+  type IndexedDBLegacyConflictResolution,
+  type IndexedDBLegacyMigrationConflict,
+  type IndexedDBLegacyRecoveryCandidate,
+  type IndexedDBLegacyRecoveryKind,
+} from './indexeddb-provider-v2.js';
+export {
+  LegacyFileSystemProviderV2Adapter,
+  type LegacyFilePayloadModel,
+  type LegacyFileSystemProviderV2AdapterOptions,
+} from './legacy-v2-adapter.js';
 
 export { IndexedDBFileSystemProvider } from './indexeddb-provider.js';
+export {
+  MemoryFileSystemProvider,
+  type MemoryFileSystemSnapshot,
+  type MemoryFileSystemSnapshotFile,
+} from './memory-provider.js';
+export {
+  createDbkWorkspaceSnapshot,
+  replaceMemoryWorkspaceFromDbk,
+  type DbkWorkspaceAssetLayout,
+  type DbkWorkspaceSnapshot,
+  type DbkWorkspaceSnapshotOptions,
+} from './dbk-workspace.js';
 export { IndexedDBContentContainer } from './indexeddb-content-container.js';
 export { FileSystemContentContainer } from './filesystem-content-container.js';
 export { createFileMediaProvider } from './file-media-provider.js';
+export { documentCompanionPath, moveFileSystemEntry } from './move-entry.js';
+export {
+  FileSystemMoveRecoveryError,
+  FileSystemPartialMoveError,
+  isFileSystemMoveRecoveryError,
+  isFileSystemMoveStateError,
+  isFileSystemPartialMoveError,
+  describeEntryMove,
+  describePartialMove,
+  type FileSystemEntryMoveState,
+  type FileSystemMoveLocation,
+  type FileSystemPartialMoveState,
+  type FileSystemPathPresence,
+} from './move-error.js';
 
 export {
   NativeFileSystemProvider,
@@ -20,5 +132,12 @@ export {
   loadDirectoryHandle,
   removeDirectoryHandle,
 } from './native-provider.js';
+export {
+  NativeFileSystemProviderV2,
+  NativeFileSystemMoveRecoveryError,
+  type NativeFileSystemMovePathState,
+  type NativeFileSystemMoveRecoveryState,
+} from './native-provider-v2.js';
 
 export { ElectronFileSystemProvider, isElectronHost } from './electron-provider.js';
+export { ElectronFileSystemProviderV2 } from './electron-provider-v2.js';

package/src/filesystem/indexeddb-content-container.ts

@@ -7,7 +7,8 @@
 
 import type { ContentContainer, ContentEntry } from '@bendyline/squisq/storage';
 import { findDocumentPath } from '@bendyline/squisq/storage';
-import { IndexedDBFileSystemProvider } from './indexeddb-provider.js';
+import { IndexedDBFileSystemProviderV2 } from './indexeddb-provider-v2.js';
+import { parseWorkspacePath, WORKSPACE_ROOT } from './workspace-path.js';
 
 // ── MIME type guessing ─────────────────────────────────────────────
 
@@ -39,49 +40,51 @@ function guessMimeType(path: string): string {
 // ── Implementation ─────────────────────────────────────────────────
 
 export class IndexedDBContentContainer implements ContentContainer {
-  private provider: IndexedDBFileSystemProvider;
+  private readonly provider: IndexedDBFileSystemProviderV2;
 
   constructor(workspaceId: string) {
-    this.provider = new IndexedDBFileSystemProvider(`${workspaceId}-media`, 'Media Storage');
+    this.provider = new IndexedDBFileSystemProviderV2(`${workspaceId}-media`, 'Media Storage');
   }
 
   async readFile(path: string): Promise<ArrayBuffer | null> {
-    return this.provider.readBinary(path);
+    return (await this.provider.readFile(parseWorkspacePath(path)))?.data ?? null;
   }
 
   async writeFile(path: string, data: ArrayBuffer | Uint8Array, _mimeType?: string): Promise<void> {
-    await this.provider.writeBinary(path, data);
+    await this.provider.writeFile(parseWorkspacePath(path), data, {
+      mode: 'upsert',
+      createParents: true,
+    });
   }
 
   async removeFile(path: string): Promise<void> {
-    await this.provider.delete(path);
+    await this.provider.remove(parseWorkspacePath(path), { missing: 'ignore' });
   }
 
   async listFiles(prefix?: string): Promise<ContentEntry[]> {
     const entries: ContentEntry[] = [];
     const walk = async (dir: string) => {
-      const children = await this.provider.readDirectory(dir);
+      const children = await this.provider.readDirectory(parseWorkspacePath(dir));
       for (const child of children) {
         if (child.kind === 'directory') {
           await walk(child.path);
         } else {
-          const filePath = child.path.replace(/^\//, '');
+          const filePath = child.path;
           if (prefix && !filePath.startsWith(prefix)) continue;
-          const meta = await this.provider.stat(child.path);
           entries.push({
             path: filePath,
             mimeType: guessMimeType(filePath),
-            size: meta?.size ?? 0,
+            size: child.size,
           });
         }
       }
     };
-    await walk('/');
+    await walk(WORKSPACE_ROOT);
     return entries;
   }
 
   async exists(path: string): Promise<boolean> {
-    return this.provider.exists(path);
+    return (await this.provider.stat(parseWorkspacePath(path))) !== null;
   }
 
   async getDocumentPath(): Promise<string | null> {
@@ -101,4 +104,9 @@ export class IndexedDBContentContainer implements ContentContainer {
     const data = new TextEncoder().encode(markdown);
     await this.writeFile(name, data, 'text/markdown');
   }
+
+  /** Release the IndexedDB connection when a long-lived container is retired. */
+  async dispose(): Promise<void> {
+    await this.provider.dispose();
+  }
 }