@bendyline/docblocks 2.0.0 → 2.1.1

package/dist/{chunk-RQJRQF46.js → chunk-ZO7G53QP.js}

@@ -1,6 +1,15 @@
 import {
+  parentChainWithRoot
+} from "./chunk-KQ6756AJ.js";
+import {
+  compareSnapshotsByName,
+  compareText,
+  copyBytes,
   parseFileSystemVersion
-} from "./chunk-AYZ4HN5M.js";
+} from "./chunk-M62ZGJ5I.js";
+import {
+  decodeUtf8Text
+} from "./chunk-M5ZNQGR5.js";
 import {
   FsError,
   WORKSPACE_ROOT,
@@ -8,7 +17,7 @@ import {
   workspacePathBasename,
   workspacePathContains,
   workspacePathDirname
-} from "./chunk-SI2LU2RP.js";
+} from "./chunk-AYWKIZLD.js";
 
 // src/filesystem/memory-provider-v2.ts
 var MEMORY_CAPABILITIES = Object.freeze({
@@ -126,7 +135,7 @@ var MemoryFileSystemProviderV2 = class {
           "Replacement path has conflicting file and directory kinds."
         );
       }
-      for (const parent of parentChain(path)) {
+      for (const parent of parentChainWithRoot(path)) {
         if (parent && stagedFiles.has(parent)) {
           throw this.error("type-mismatch", "write", parent, "A replacement parent is a file.");
         }
@@ -185,8 +194,12 @@ var MemoryFileSystemProviderV2 = class {
     if (existing?.kind === "directory") {
       throw this.error("type-mismatch", "write", canonical, "Cannot replace a directory.");
     }
-    const currentContent = existing?.kind === "file" && existing.payloadKind === "text" ? new TextDecoder().decode(existing.data) : null;
-    if (existing?.kind === "file" && existing.payloadKind === "binary" || currentContent !== expectedContent && currentContent !== content) {
+    const currentContent = existing?.kind === "file" ? decodeUtf8Text(existing.data, {
+      label: "The stored file",
+      operation: "write",
+      path: canonical
+    }) : null;
+    if (currentContent !== expectedContent && currentContent !== content) {
       return {
         status: "conflict",
         content: currentContent,
@@ -246,7 +259,7 @@ var MemoryFileSystemProviderV2 = class {
         children.push(this.toEntrySnapshot(entryPath2, entry));
       }
     }
-    children.sort(compareSnapshots);
+    children.sort(compareSnapshotsByName);
     return Object.freeze(children);
   }
   async writeFile(path, data, options = {}) {
@@ -537,7 +550,7 @@ var MemoryFileSystemProviderV2 = class {
   }
   planParents(path, createParents, operation) {
     const missing = [];
-    for (const parent of parentChain(path)) {
+    for (const parent of parentChainWithRoot(path)) {
       if (!parent) continue;
       const entry = this.entries.get(parent);
       if (entry?.kind === "file") {
@@ -563,7 +576,7 @@ var MemoryFileSystemProviderV2 = class {
     }
   }
   touchParents(target, path, version, lastModified) {
-    for (const parent of parentChain(path)) {
+    for (const parent of parentChainWithRoot(path)) {
       const entry = target.get(parent);
       if (entry?.kind === "directory") {
         target.set(parent, { kind: "directory", version, lastModified });
@@ -635,36 +648,14 @@ var MemoryFileSystemProviderV2 = class {
     return new FsError(code, message, { operation, path });
   }
 };
-function parentChain(path) {
-  const parents = [];
-  let current = workspacePathDirname(path);
-  while (true) {
-    parents.unshift(current);
-    if (!current) return parents;
-    current = workspacePathDirname(current);
-  }
-}
 function addParentPaths(target, path) {
-  for (const parent of parentChain(path)) {
+  for (const parent of parentChainWithRoot(path)) {
     if (parent) target.add(parent);
   }
 }
 function isMemoryFilePayloadKind(value) {
   return value === "text" || value === "binary";
 }
-function copyBytes(data) {
-  const source = ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
-  const copy = new Uint8Array(source.byteLength);
-  copy.set(source);
-  return copy.buffer;
-}
-function compareSnapshots(left, right) {
-  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
-  return compareText(left.name, right.name);
-}
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
 
 // src/filesystem/memory-provider.ts
 function canonicalPath(path) {
@@ -680,8 +671,8 @@ function entryPath(path, operation) {
   }
   return canonical;
 }
-function decode(data) {
-  return new TextDecoder().decode(data);
+function decode(data, path) {
+  return decodeUtf8Text(data, { label: "The file", operation: "read", path });
 }
 var MemoryFileSystemProvider = class {
   constructor(id, label) {
@@ -698,7 +689,7 @@ var MemoryFileSystemProvider = class {
     const state = this.v2.captureState();
     return {
       files: state.files.map(
-        (file) => file.payloadKind === "text" ? { kind: "text", path: file.path, content: decode(file.data) } : { kind: "binary", path: file.path, data: file.data.slice(0) }
+        (file) => file.payloadKind === "text" ? { kind: "text", path: file.path, content: decode(file.data, file.path) } : { kind: "binary", path: file.path, data: file.data.slice(0) }
       ),
       directories: [...state.directories]
     };
@@ -720,20 +711,21 @@ var MemoryFileSystemProvider = class {
     this.v2.seedText(entryPath(path, "write"), content);
   }
   async readFile(path) {
-    const file = await this.v2.readFile(entryPath(path, "read"));
-    return file ? decode(file.data) : null;
+    const canonical = canonicalPath(path);
+    const file = await this.v2.readFile(canonical);
+    return file ? decode(file.data, canonical) : null;
   }
   async writeFile(path, content) {
-    await this.v2.writeText(entryPath(path, "write"), content, { createParents: true });
+    await this.v2.writeText(canonicalPath(path), content, { createParents: true });
   }
   commitFile(path, content, expectedContent) {
-    return this.v2.commitText(entryPath(path, "write"), content, expectedContent);
+    return this.v2.commitText(canonicalPath(path), content, expectedContent);
   }
   async delete(path) {
-    await this.v2.remove(entryPath(path, "remove"), { recursive: true, missing: "ignore" });
+    await this.v2.remove(canonicalPath(path), { recursive: true, missing: "ignore" });
   }
   async rename(oldPath, newPath) {
-    await this.v2.move(entryPath(oldPath, "move"), entryPath(newPath, "move"), {
+    await this.v2.move(canonicalPath(oldPath), canonicalPath(newPath), {
       createParents: true
     });
   }
@@ -758,9 +750,7 @@ var MemoryFileSystemProvider = class {
     await this.v2.createDirectory(canonicalPath(path), { createParents: true });
   }
   async stat(path) {
-    const canonical = canonicalPath(path);
-    if (!canonical) return null;
-    const entry = await this.v2.stat(canonical);
+    const entry = await this.v2.stat(canonicalPath(path));
     if (!entry || entry.kind !== "file") return null;
     return {
       name: entry.name,
@@ -769,14 +759,17 @@ var MemoryFileSystemProvider = class {
       lastModified: entry.lastModified
     };
   }
+  /**
+   * Every stored file is bytes, so every stored file is readable as binary.
+   * `payloadKind` records how a file was written for DBK export fidelity; it is
+   * not a filter. Gating on it made `readBinary` report an existing text file as
+   * missing, which no other provider does and which callers read as "no file".
+   */
   async readBinary(path) {
-    const canonical = entryPath(path, "read");
-    const file = this.v2.readCompatibilityFile(canonical);
-    if (!file || file.payloadKind !== "binary") return null;
-    return file.data;
+    return this.v2.readCompatibilityFile(canonicalPath(path))?.data ?? null;
   }
   async writeBinary(path, data) {
-    await this.v2.writeBinary(entryPath(path, "write"), data, { createParents: true });
+    await this.v2.writeBinary(canonicalPath(path), data, { createParents: true });
   }
 };
 
@@ -784,4 +777,3 @@ export {
   MemoryFileSystemProviderV2,
   MemoryFileSystemProvider
 };
-//# sourceMappingURL=chunk-RQJRQF46.js.map

package/dist/document/index.d.ts

@@ -1,6 +1,358 @@
-export { DocumentCommitConflictError, DocumentSession, DocumentSessionConflictError, } from './document-session.js';
-export { createFileSystemDocumentTarget, type FileSystemDocumentTargetOptions, } from './filesystem-target.js';
-export { DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION, DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY, DocumentRecoveryJournal, getDefaultDocumentRecoveryStorage, } from './recovery-journal.js';
-export type { DocumentCommitRequest, DocumentCommitResult, DocumentCommitTarget, DocumentConflictStrategy, DocumentExternalChangeResult, DocumentExternalSnapshot, DocumentExternalVersion, DocumentSaveReason, DocumentSessionConflict, DocumentSessionEditScope, DocumentSessionLifecycle, DocumentSessionOptions, DocumentSessionSnapshot, DocumentSessionStatus, DocumentSessionTransition, } from './types.js';
-export type { DocumentRecoveryAcknowledgement, DocumentRecoveryJournalOptions, DocumentRecoveryRecord, DocumentRecoveryStorage, DocumentRecoveryWrite, DocumentRecoveryWriteFailure, DocumentRecoveryWriteResult, } from './recovery-journal.js';
-//# sourceMappingURL=index.d.ts.map
+import { q as FileSystemProvider } from '../types-BEg5SQ1_.js';
+import '../workspace-path-CWVrcuPL.js';
+
+/**
+ * Synchronous crash-recovery journal for dirty document snapshots.
+ *
+ * The journal deliberately depends on a tiny injected Storage-like contract
+ * instead of reading `window.localStorage` at module load time. This keeps the
+ * document package usable in Node, Electron main, VS Code extension hosts, and
+ * tests while allowing browser renderers to use localStorage for a best-effort
+ * write that completes before the current JavaScript turn ends.
+ */
+declare const DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY = "docblocks:document-recovery:v1";
+declare const DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION = 1;
+interface DocumentRecoveryStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+interface DocumentRecoveryRecord {
+    /** Stable commit-target key, including the workspace/provider scope. */
+    targetKey: string;
+    /** DocumentSession generation that produced this snapshot. */
+    generation: number;
+    /** Monotonic DocumentSession revision represented by `content`. */
+    revision: number;
+    /** Complete markdown snapshot. */
+    content: string;
+    /**
+     * Content last acknowledged by the commit target when this draft was made.
+     * Recovery may be applied automatically only when storage still matches this
+     * baseline; otherwise the caller must surface an external-change conflict.
+     */
+    persistedContent: string | null;
+    /** Time the dirty record for this target was first created. */
+    createdAt: number;
+    /** Time the record was most recently replaced. */
+    updatedAt: number;
+}
+interface DocumentRecoveryWrite {
+    targetKey: string;
+    generation: number;
+    revision: number;
+    content: string;
+    persistedContent: string | null;
+}
+interface DocumentRecoveryAcknowledgement {
+    targetKey: string;
+    generation: number;
+    /** Highest revision durably acknowledged by the commit target. */
+    persistedRevision: number;
+}
+type DocumentRecoveryWriteFailure = 'invalid-record' | 'record-too-large' | 'storage-unavailable' | 'quota-exceeded';
+type DocumentRecoveryWriteResult = {
+    status: 'stored';
+    evicted: number;
+} | {
+    status: 'unchanged';
+    evicted: 0;
+} | {
+    status: 'ignored-stale';
+    evicted: 0;
+} | {
+    status: 'rejected';
+    reason: DocumentRecoveryWriteFailure;
+    evicted: number;
+};
+interface DocumentRecoveryJournalOptions {
+    storageKey?: string;
+    /** Maximum number of document records retained. Defaults to 20. */
+    maxEntries?: number;
+    /** Conservative UTF-16 estimate for the whole serialized journal. */
+    maxStorageBytes?: number;
+    /** Conservative UTF-16 estimate for one serialized record. */
+    maxRecordBytes?: number;
+    /** Records older than this are discarded while reading. Defaults to 7 days. */
+    maxAgeMs?: number;
+    /** Tolerated clock skew for records dated in the future. Defaults to 5 minutes. */
+    maxFutureSkewMs?: number;
+    /** Injected for deterministic tests. */
+    now?: () => number;
+}
+/**
+ * Best-effort, synchronous recovery storage.
+ *
+ * Normal save acknowledgement is the only automatic path that removes the
+ * current record. Explicit discard, age expiry, corruption repair, and bounded
+ * eviction are intentional exceptions: callers can discard after the user
+ * rejects recovery, and the journal must never grow without limit.
+ */
+declare class DocumentRecoveryJournal {
+    private readonly storage;
+    private readonly storageKey;
+    private readonly maxEntries;
+    private readonly maxStorageBytes;
+    private readonly maxRecordBytes;
+    private readonly maxAgeMs;
+    private readonly maxFutureSkewMs;
+    private readonly now;
+    constructor(storage: DocumentRecoveryStorage | null, options?: DocumentRecoveryJournalOptions);
+    /**
+     * Synchronously persist the latest dirty snapshot for a target.
+     * Storage/quota failures are returned, never thrown into an editor onChange.
+     */
+    write(input: DocumentRecoveryWrite): DocumentRecoveryWriteResult;
+    /** Return the recoverable snapshot for one target, if present and valid. */
+    lookup(targetKey: string, generation?: number): DocumentRecoveryRecord | null;
+    /** List valid records, newest first. Optionally restrict to one target. */
+    list(targetKey?: string): DocumentRecoveryRecord[];
+    /**
+     * 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: DocumentRecoveryAcknowledgement): boolean;
+    /** Explicitly discard recovery data after a user or lifecycle decision. */
+    discard(targetKey: string, generation?: number): boolean;
+    private load;
+    private persistBounded;
+    private persistExact;
+    private tryRemove;
+}
+/**
+ * Resolve browser localStorage on demand. Importing this module never touches
+ * browser globals, and access errors (sandboxing/security settings) yield null.
+ */
+declare function getDefaultDocumentRecoveryStorage(): DocumentRecoveryStorage | null;
+
+/**
+ * Framework-neutral document persistence contracts.
+ *
+ * A DocumentSession owns one logical document at a time. Storage-specific
+ * adapters implement DocumentCommitTarget; the session owns revisions,
+ * serialization, lifecycle transitions, and conflict state.
+ */
+
+type DocumentSaveReason = 'autosave' | 'manual' | 'transition' | 'close' | 'backup' | 'conflict';
+type DocumentExternalVersion = string | number | null;
+interface DocumentCommitRequest {
+    /** Stable key for the target this commit was created for. */
+    targetKey: string;
+    /** Latest complete document snapshot to persist. */
+    content: string;
+    /** Monotonic session revision represented by content. */
+    revision: number;
+    /** Most recent revision acknowledged by this target. */
+    persistedRevision: number;
+    /** Content last acknowledged by the target, or null if it did not exist. */
+    persistedContent: string | null;
+    reason: DocumentSaveReason;
+}
+interface DocumentCommitResult {
+    /** Optional backend version (mtime, TextDocument.version, etag, and so on). */
+    version?: DocumentExternalVersion;
+}
+interface DocumentCommitTarget {
+    readonly key: string;
+    commit(request: DocumentCommitRequest): Promise<DocumentCommitResult | void>;
+}
+type DocumentSessionStatus = 'idle' | 'saved' | 'dirty' | 'saving' | 'error' | 'conflict' | 'closed';
+type DocumentSessionLifecycle = 'open' | 'transitioning' | 'closing' | 'closed';
+interface DocumentExternalSnapshot {
+    /** Target key captured before the external read began. */
+    targetKey: string;
+    /** Monotonic observation number assigned by the target watcher. */
+    sequence?: number;
+    /** Null represents an externally deleted document. */
+    content: string | null;
+    version?: DocumentExternalVersion;
+}
+interface DocumentSessionConflict {
+    targetKey: string;
+    localContent: string;
+    localRevision: number;
+    externalContent: string | null;
+    externalVersion: DocumentExternalVersion;
+}
+interface DocumentSessionSnapshot {
+    targetKey: string | null;
+    content: string;
+    revision: number;
+    persistedRevision: number;
+    persistedContent: string | null;
+    savingRevision: number | null;
+    generation: number;
+    status: DocumentSessionStatus;
+    lifecycle: DocumentSessionLifecycle;
+    frozen: boolean;
+    error: Error | null;
+    conflict: DocumentSessionConflict | null;
+}
+interface DocumentSessionOptions {
+    autoSaveDelayMs?: number;
+    /** Whether edits schedule automatic persistence. Manual and lifecycle flushes remain available. */
+    autoSaveEnabled?: boolean;
+    /**
+     * Bounded delays used after an automatic save fails. Each entry permits
+     * one retry; exhausting the list leaves the session in error state until
+     * the user edits again or explicitly flushes it. Conflicts never retry.
+     */
+    autoSaveRetryDelaysMs?: readonly number[];
+    /** Optional synchronous crash-recovery journal owned by this session. */
+    recoveryJournal?: DocumentRecoveryJournal | null;
+}
+/** Scope captured by an editor instance when it mounts. */
+interface DocumentSessionEditScope {
+    targetKey: string;
+    generation: number;
+}
+/** Result produced while a session transition is frozen. */
+interface DocumentSessionTransition {
+    target: DocumentCommitTarget | null;
+    content: string;
+}
+type DocumentExternalChangeResult = 'applied' | 'conflict' | 'ignored';
+type DocumentConflictStrategy = 'use-local' | 'use-external';
+
+type SessionListener = () => void;
+/**
+ * Raised by a commit target when optimistic external-change verification
+ * fails. The session converts it into durable conflict state.
+ */
+declare class DocumentCommitConflictError extends Error {
+    readonly externalContent: string | null;
+    readonly externalVersion: string | number | null;
+    constructor(message: string, externalContent: string | null, externalVersion?: string | number | null);
+}
+declare class DocumentSessionConflictError extends Error {
+    readonly conflict: DocumentSessionConflict;
+    constructor(conflict: DocumentSessionConflict);
+}
+/**
+ * A revisioned, serialized persistence boundary for one active document.
+ *
+ * Invariants:
+ * - only drain() calls target.commit();
+ * - at most one commit is in flight;
+ * - revisions never decrease, including across target transitions;
+ * - destructive operations wait for an in-flight commit and run last;
+ * - a target is never changed by a React effect cleanup.
+ */
+declare class DocumentSession {
+    private readonly autoSaveDelayMs;
+    private readonly autoSaveRetryDelaysMs;
+    private readonly recoveryJournal;
+    private readonly listeners;
+    private autoSaveEnabled;
+    private target;
+    private content;
+    private persistedContent;
+    private revision;
+    private persistedRevision;
+    private savingRevision;
+    private savingContent;
+    private generation;
+    private externalSequence;
+    private lifecycle;
+    private frozen;
+    private error;
+    private conflict;
+    private autoSaveTimer;
+    private autoSaveRetryAttempt;
+    private drainPromise;
+    private haltDrain;
+    private operationTail;
+    private snapshot;
+    constructor(options?: DocumentSessionOptions);
+    readonly subscribe: (listener: SessionListener) => (() => void);
+    readonly getSnapshot: () => DocumentSessionSnapshot;
+    /** Enable or disable automatic persistence without weakening explicit or lifecycle flushes. */
+    setAutoSaveEnabled(enabled: boolean): void;
+    /**
+     * Record a complete local snapshot and schedule its persistence.
+     * Returns the assigned monotonic revision.
+     */
+    edit(content: string, scope: DocumentSessionEditScope): number;
+    /**
+     * Persist the revision current when flush() is called. A later edit may
+     * advance the session again, but commits remain strictly serialized.
+     */
+    flush(reason?: DocumentSaveReason): Promise<DocumentSessionSnapshot>;
+    /**
+     * Flush the old document, then replace it with a new clean baseline.
+     * UI state should change only after this promise resolves.
+     */
+    transitionTo(target: DocumentCommitTarget | null, content: string): Promise<DocumentSessionSnapshot>;
+    /**
+     * Freeze and flush the current document before reading the next one. The
+     * loader may return null when a navigation request was superseded, leaving
+     * the current target active and clean.
+     */
+    transitionWithLoad(load: () => Promise<DocumentSessionTransition | null>): Promise<DocumentSessionSnapshot | null>;
+    /**
+     * Flush the current path, run the storage move, and only then swap the
+     * commit target. No edit can enter between those steps.
+     */
+    retarget(nextTarget: DocumentCommitTarget, moveStorage: () => Promise<void>): Promise<DocumentSessionSnapshot>;
+    /**
+     * Cancel queued writes, wait for an already-running write, then delete.
+     * The deletion is therefore the final storage operation for this target.
+     */
+    delete(deleteStorage: () => Promise<void>): Promise<DocumentSessionSnapshot>;
+    /**
+     * Discard queued changes and detach without mutating storage. This is used
+     * for explicitly abandoned sessions, never as an implicit effect cleanup.
+     */
+    cancel(): Promise<DocumentSessionSnapshot>;
+    /**
+     * Observe a filesystem/host change captured for targetKey. Clean sessions
+     * adopt it. Dirty or saving sessions preserve local text and enter conflict.
+     */
+    observeExternal(change: DocumentExternalSnapshot): DocumentExternalChangeResult;
+    resolveConflict(strategy: DocumentConflictStrategy): Promise<DocumentSessionSnapshot>;
+    /**
+     * Freeze edits and flush through the latest revision. A successful call
+     * remains frozen until cancelClose(); the owning host may now destroy it.
+     */
+    prepareClose(): Promise<DocumentSessionSnapshot>;
+    /** Resume editing when a host cancels a prepared close. */
+    cancelClose(): void;
+    private performTransition;
+    private scheduleAutoSave;
+    private clearAutoSaveTimer;
+    private ensureDrain;
+    private drain;
+    private awaitActiveDrain;
+    /**
+     * Rehydrate a synchronous crash snapshot after the durable baseline has
+     * been read. A matching baseline is safe to resume as dirty; a changed
+     * baseline becomes an explicit conflict and is never auto-overwritten.
+     */
+    private restoreRecoverySnapshot;
+    private writeRecoverySnapshot;
+    private discardRecoverySnapshot;
+    private detach;
+    private assertNotPreparingClose;
+    private enqueueOperation;
+    private createSnapshot;
+    private computeStatus;
+    private emit;
+}
+
+interface FileSystemDocumentTargetOptions {
+    /**
+     * Compare the current file with the session's persisted baseline before
+     * replacing it. Enabled by default.
+     */
+    verifyExternalChanges?: boolean;
+    onCommitted?: (content: string, revision: number) => void;
+}
+/**
+ * Adapt a FileSystemProvider path to the commit protocol used by
+ * DocumentSession. The optimistic read catches external edits/deletions
+ * before a local write recreates or silently replaces them.
+ */
+declare function createFileSystemDocumentTarget(provider: FileSystemProvider, path: string, options?: FileSystemDocumentTargetOptions): DocumentCommitTarget;
+
+export { DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION, DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY, DocumentCommitConflictError, type DocumentCommitRequest, type DocumentCommitResult, type DocumentCommitTarget, type DocumentConflictStrategy, type DocumentExternalChangeResult, type DocumentExternalSnapshot, type DocumentExternalVersion, type DocumentRecoveryAcknowledgement, DocumentRecoveryJournal, type DocumentRecoveryJournalOptions, type DocumentRecoveryRecord, type DocumentRecoveryStorage, type DocumentRecoveryWrite, type DocumentRecoveryWriteFailure, type DocumentRecoveryWriteResult, type DocumentSaveReason, DocumentSession, type DocumentSessionConflict, DocumentSessionConflictError, type DocumentSessionEditScope, type DocumentSessionLifecycle, type DocumentSessionOptions, type DocumentSessionSnapshot, type DocumentSessionStatus, type DocumentSessionTransition, type FileSystemDocumentTargetOptions, createFileSystemDocumentTarget, getDefaultDocumentRecoveryStorage };

package/dist/document/index.js

@@ -1,4 +1,24 @@
-export { DocumentCommitConflictError, DocumentSession, DocumentSessionConflictError, } from './document-session.js';
-export { createFileSystemDocumentTarget, } from './filesystem-target.js';
-export { DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION, DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY, DocumentRecoveryJournal, getDefaultDocumentRecoveryStorage, } from './recovery-journal.js';
-//# sourceMappingURL=index.js.map
+import {
+  DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION,
+  DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY,
+  DocumentCommitConflictError,
+  DocumentRecoveryJournal,
+  DocumentSession,
+  DocumentSessionConflictError,
+  createFileSystemDocumentTarget,
+  getDefaultDocumentRecoveryStorage
+} from "../chunk-6L3JRDE7.js";
+import "../chunk-QI6YKTQV.js";
+import "../chunk-M5ZNQGR5.js";
+import "../chunk-AYWKIZLD.js";
+import "../chunk-XAMILHQP.js";
+export {
+  DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION,
+  DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY,
+  DocumentCommitConflictError,
+  DocumentRecoveryJournal,
+  DocumentSession,
+  DocumentSessionConflictError,
+  createFileSystemDocumentTarget,
+  getDefaultDocumentRecoveryStorage
+};

package/dist/filesystem/electron.d.ts

@@ -1,4 +1,73 @@
-/** Electron renderer filesystem provider entry point. */
-export { ElectronFileSystemProvider, isElectronHost } from './electron-provider.js';
-export { ElectronFileSystemProviderV2 } from './electron-provider-v2.js';
-//# sourceMappingURL=electron.d.ts.map
+import { s as FileSystemProviderV2, r as FileSystemProviderCapabilities, k as FileSystemEntrySnapshot, m as FileSystemFileRead, K as FileSystemWriteOptions, n as FileSystemFileSnapshot, g as FileSystemCreateDirectoryOptions, h as FileSystemDirectorySnapshot, u as FileSystemRemoveOptions, v as FileSystemRemoveResult, o as FileSystemMoveOptions, w as FileSystemSnapshot, C as FileSystemWatchEvent, H as FileSystemWatchOptions, I as FileSystemWatchSubscription, q as FileSystemProvider, F as FileCommitResult, j as FileSystemEntry, b as FileMeta } from '../types-BEg5SQ1_.js';
+import { a as WorkspacePath } from '../workspace-path-CWVrcuPL.js';
+export { isElectronHost } from '../host/index.js';
+import '../types-CueK0tvU.js';
+
+/** Pure renderer-side client for the typed Electron filesystem v2 transport. */
+declare class ElectronFileSystemProviderV2 implements FileSystemProviderV2 {
+    readonly id: string;
+    readonly label: string;
+    readonly capabilities: FileSystemProviderCapabilities;
+    private readonly rootPath;
+    private readonly instanceId;
+    private readonly watchers;
+    private readonly subscriptions;
+    private readonly inFlight;
+    private openPromise;
+    private removeWatchBridge;
+    private disposePromise;
+    private hostOpened;
+    private disposed;
+    constructor(id: string, label: string, rootPath: string);
+    getRootPath(): string;
+    stat(path: WorkspacePath): Promise<FileSystemEntrySnapshot | null>;
+    readFile(path: WorkspacePath): Promise<FileSystemFileRead | null>;
+    readDirectory(path: WorkspacePath): Promise<readonly FileSystemEntrySnapshot[]>;
+    writeFile(path: WorkspacePath, data: ArrayBuffer | Uint8Array, options?: FileSystemWriteOptions): Promise<FileSystemFileSnapshot>;
+    createDirectory(path: WorkspacePath, options?: FileSystemCreateDirectoryOptions): Promise<FileSystemDirectorySnapshot>;
+    remove(path: WorkspacePath, options?: FileSystemRemoveOptions): Promise<FileSystemRemoveResult>;
+    move(oldPath: WorkspacePath, newPath: WorkspacePath, options?: FileSystemMoveOptions): Promise<FileSystemEntrySnapshot>;
+    snapshot(): Promise<FileSystemSnapshot>;
+    watch(listener: (event: FileSystemWatchEvent) => void, options?: FileSystemWatchOptions): FileSystemWatchSubscription;
+    dispose(): Promise<void>;
+    private request;
+    private ensureOpen;
+    private ensureWatchBridge;
+    private handleWatchMessage;
+    private assertOpen;
+}
+
+/**
+ * ElectronFileSystemProvider — implements FileSystemProvider by delegating
+ * to the Electron desktop host's fs IPC bridge. Every operation is scoped
+ * 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.
+ */
+
+declare class ElectronFileSystemProvider implements FileSystemProvider {
+    readonly id: string;
+    readonly label: string;
+    readonly v2: ElectronFileSystemProviderV2;
+    private readonly rootPath;
+    constructor(id: string, label: string, rootPath: string);
+    /** Absolute path this provider is rooted at. */
+    getRootPath(): string;
+    readFile(path: string): Promise<string | null>;
+    writeFile(path: string, content: string): Promise<void>;
+    commitFile(path: string, content: string, expectedContent: string | null): Promise<FileCommitResult>;
+    delete(path: string): Promise<void>;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    readDirectory(path: string): Promise<FileSystemEntry[]>;
+    exists(path: string): Promise<boolean>;
+    createDirectory(path: string): Promise<void>;
+    stat(path: string): Promise<FileMeta | null>;
+    readBinary(path: string): Promise<ArrayBuffer | null>;
+    writeBinary(path: string, data: ArrayBuffer | Uint8Array): Promise<void>;
+    /** Subscribe to external change notifications under this root. */
+    watch(onChange: (changedPath: string) => void): () => void;
+}
+
+export { ElectronFileSystemProvider, ElectronFileSystemProviderV2 };