@bendyline/docblocks 2.6.1 → 2.7.0

package/dist/document/index.d.ts

@@ -1,4 +1,5 @@
-import { q as FileSystemProvider } from '../types-Bb3yccTH.js';
+import { d as FileSystemProvider } from '../types-BvDnr3YU.js';
+import '../v2-BVnZZyd4.js';
 import '../workspace-path-CWVrcuPL.js';
 
 /**
@@ -16,8 +17,13 @@ interface DocumentRecoveryStorage {
     getItem(key: string): string | null;
     setItem(key: string, value: string): void;
     removeItem(key: string): void;
+    /** Browser Storage enumeration permits discovery of separately owned journals. */
+    readonly length?: number;
+    key?(index: number): string | null;
 }
 interface DocumentRecoveryRecord {
+    /** Storage owner of a recovered record; absent for legacy journals. */
+    ownerId?: string;
     /** Stable commit-target key, including the workspace/provider scope. */
     targetKey: string;
     /** DocumentSession generation that produced this snapshot. */
@@ -67,6 +73,8 @@ type DocumentRecoveryWriteResult = {
 };
 interface DocumentRecoveryJournalOptions {
     storageKey?: string;
+    /** Unique live-session identity. Each owner/revision has a separate storage item. */
+    ownerId?: string;
     /** Maximum number of document records retained. Defaults to 20. */
     maxEntries?: number;
     /** Conservative UTF-16 estimate for the whole serialized journal. */
@@ -91,6 +99,9 @@ interface DocumentRecoveryJournalOptions {
 declare class DocumentRecoveryJournal {
     private readonly storage;
     private readonly storageKey;
+    private readonly baseStorageKey;
+    private readonly options;
+    private loadedKeys;
     private readonly maxEntries;
     private readonly maxStorageBytes;
     private readonly maxRecordBytes;
@@ -98,15 +109,22 @@ declare class DocumentRecoveryJournal {
     private readonly maxFutureSkewMs;
     private readonly now;
     constructor(storage: DocumentRecoveryStorage | null, options?: DocumentRecoveryJournalOptions);
+    /** Isolate writes and acknowledgements from every other live session. */
+    forOwner(ownerId: string): DocumentRecoveryJournal;
+    /** Consume only the exact recovered snapshot, never a newer draft from its owner. */
+    acknowledgeRecord(record: DocumentRecoveryRecord): boolean;
     /**
      * Synchronously persist the latest dirty snapshot for a target.
      * Storage/quota failures are returned, never thrown into an editor onChange.
      */
     write(input: DocumentRecoveryWrite): DocumentRecoveryWriteResult;
+    private pruneOwners;
     /** 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[];
+    private loadAll;
+    private storageKeys;
     /**
      * Clear a record only when the same generation has durably acknowledged at
      * least the journaled revision. A stale acknowledgement cannot erase a newer
@@ -118,6 +136,12 @@ declare class DocumentRecoveryJournal {
     private load;
     private persistBounded;
     private persistExact;
+    /**
+     * Each owner/revision is immutable and has its own key. A recovering window
+     * may remove that exact key without racing a live owner's newer write.
+     * Only explicit writes create records; cleanup never recreates a saved draft.
+     */
+    private persistOwned;
     private tryRemove;
 }
 /**
@@ -169,6 +193,10 @@ interface DocumentExternalSnapshot {
     version?: DocumentExternalVersion;
 }
 interface DocumentSessionConflict {
+    /** The local branch was restored from a previous session's recovery journal. */
+    recoveredDraft?: boolean;
+    /** Capture time of the recovered copy, not an acknowledgement of a file save. */
+    recoveredDraftCapturedAt?: number;
     targetKey: string;
     localContent: string;
     localRevision: number;
@@ -243,6 +271,7 @@ declare class DocumentSession {
     private readonly autoSaveDelayMs;
     private readonly autoSaveRetryDelaysMs;
     private readonly recoveryJournal;
+    private recoveredRecords;
     private readonly listeners;
     private autoSaveEnabled;
     private target;
@@ -333,6 +362,7 @@ declare class DocumentSession {
     private restoreRecoverySnapshot;
     private writeRecoverySnapshot;
     private discardRecoverySnapshot;
+    private acknowledgeRecoveredRecords;
     private detach;
     private assertNotPreparingClose;
     private enqueueOperation;

package/dist/document/index.js

@@ -1,17 +1,18 @@
 import {
   DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION,
   DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY,
-  DocumentCommitConflictError,
   DocumentRecoveryJournal,
+  getDefaultDocumentRecoveryStorage
+} from "../chunk-XTNWCNSK.js";
+import {
+  DocumentCommitConflictError,
   DocumentSession,
   DocumentSessionConflictError,
-  createFileSystemDocumentTarget,
-  getDefaultDocumentRecoveryStorage
-} from "../chunk-KLQKU74Q.js";
-import "../chunk-QI6YKTQV.js";
+  createFileSystemDocumentTarget
+} from "../chunk-IGB2VSRE.js";
+import "../chunk-XAMILHQP.js";
 import "../chunk-M5ZNQGR5.js";
 import "../chunk-AYWKIZLD.js";
-import "../chunk-XAMILHQP.js";
 export {
   DOCUMENT_RECOVERY_JOURNAL_SCHEMA_VERSION,
   DOCUMENT_RECOVERY_JOURNAL_STORAGE_KEY,

package/dist/filesystem/electron.d.ts

@@ -1,40 +1,14 @@
-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-Bb3yccTH.js';
-import { a as WorkspacePath } from '../workspace-path-CWVrcuPL.js';
+import { d as FileSystemProvider, F as FileCommitResult, c as FileSystemEntry, b as FileMeta } from '../types-BvDnr3YU.js';
+import { H as HostFileSystemProviderV2 } from '../host-provider-v2-CyLTRKJF.js';
 export { isElectronHost } from '../host/index.js';
-import '../types-DBYraXxE.js';
+import '../v2-BVnZZyd4.js';
+import '../workspace-path-CWVrcuPL.js';
+import '../filesystem-v2-C8AdSXUN.js';
+import '../capabilities-CdQAc745.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;
+/** Compatibility entry point retaining the Electron backend's exact guarantees. */
+declare class ElectronFileSystemProviderV2 extends HostFileSystemProviderV2 {
     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;
 }
 
 /**

package/dist/filesystem/electron.js

@@ -1,13 +1,16 @@
 import {
   ElectronFileSystemProvider,
   ElectronFileSystemProviderV2
-} from "../chunk-BVY7GGNV.js";
+} from "../chunk-IDYE73TU.js";
+import "../chunk-L6PRMR7T.js";
 import {
   isElectronHost
-} from "../chunk-6XHOOBYF.js";
-import "../chunk-2WDJ27EH.js";
+} from "../chunk-YNUQG4GF.js";
+import "../chunk-245W57QP.js";
+import "../chunk-46AGYHDY.js";
 import "../chunk-73OOROXH.js";
-import "../chunk-M62ZGJ5I.js";
+import "../chunk-HABG2JM3.js";
+import "../chunk-LPIJ6HKL.js";
 import "../chunk-AYWKIZLD.js";
 export {
   ElectronFileSystemProvider,

package/dist/filesystem/host.d.ts

@@ -0,0 +1,28 @@
+import { H as HostFileSystemProviderV2, a as HostFileSystemClientOptions } from '../host-provider-v2-CyLTRKJF.js';
+import { d as FileSystemProvider, F as FileCommitResult, c as FileSystemEntry, b as FileMeta } from '../types-BvDnr3YU.js';
+import '../v2-BVnZZyd4.js';
+import '../workspace-path-CWVrcuPL.js';
+import '../filesystem-v2-C8AdSXUN.js';
+
+/** Temporary text facade; all storage and conditional mutation is owned by v2. */
+declare class HostFileSystemProvider implements FileSystemProvider {
+    readonly id: string;
+    readonly label: string;
+    private readonly rootPath;
+    readonly v2: HostFileSystemProviderV2;
+    constructor(id: string, label: string, rootPath: string, options?: HostFileSystemClientOptions);
+    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(from: string, to: 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>;
+}
+
+export { HostFileSystemClientOptions, HostFileSystemProvider, HostFileSystemProviderV2 };

package/dist/filesystem/host.js

@@ -0,0 +1,103 @@
+import {
+  HostFileSystemProviderV2
+} from "../chunk-L6PRMR7T.js";
+import {
+  ELECTRON_FILE_SYSTEM_V2_CAPABILITIES,
+  maybeGetDocBlocksHost
+} from "../chunk-YNUQG4GF.js";
+import "../chunk-245W57QP.js";
+import "../chunk-46AGYHDY.js";
+import "../chunk-73OOROXH.js";
+import "../chunk-HABG2JM3.js";
+import "../chunk-LPIJ6HKL.js";
+import {
+  decodeUtf8Text
+} from "../chunk-M5ZNQGR5.js";
+import {
+  FsError,
+  parseWorkspacePath
+} from "../chunk-AYWKIZLD.js";
+
+// src/filesystem/host-provider.ts
+var HostFileSystemProvider = class {
+  constructor(id, label, rootPath, options) {
+    this.id = id;
+    this.label = label;
+    this.rootPath = rootPath;
+    const host = maybeGetDocBlocksHost()?.fsV2;
+    this.v2 = new HostFileSystemProviderV2(
+      id,
+      label,
+      rootPath,
+      options ?? {
+        capabilities: host?.capabilitiesFor?.(id) ?? ELECTRON_FILE_SYSTEM_V2_CAPABILITIES,
+        limits: host?.transferLimits
+      }
+    );
+  }
+  getRootPath() {
+    return this.rootPath;
+  }
+  async readFile(path) {
+    const file = await this.v2.readFile(parseWorkspacePath(path));
+    return file ? decodeUtf8Text(file.data, { label: "The file", operation: "read", path }) : null;
+  }
+  async writeFile(path, content) {
+    await this.v2.writeFile(parseWorkspacePath(path), new TextEncoder().encode(content), {
+      createParents: true
+    });
+  }
+  async commitFile(path, content, expectedContent) {
+    const canonical = parseWorkspacePath(path);
+    const current = await this.v2.readFile(canonical);
+    const actual = current ? decodeUtf8Text(current.data, { label: "The file", operation: "read", path }) : null;
+    if (actual !== expectedContent)
+      return { status: "conflict", content: actual, version: current?.entry.version ?? null };
+    try {
+      const written = await this.v2.writeFile(canonical, new TextEncoder().encode(content), {
+        createParents: true,
+        expectedVersion: current?.entry.version ?? null
+      });
+      return { status: "committed", version: written.version };
+    } catch (error) {
+      if (!(error instanceof FsError && error.code === "conflict")) throw error;
+      const external = await this.v2.readFile(canonical);
+      return {
+        status: "conflict",
+        content: external ? decodeUtf8Text(external.data, { label: "The file", operation: "read", path }) : null,
+        version: external?.entry.version ?? null
+      };
+    }
+  }
+  async delete(path) {
+    await this.v2.remove(parseWorkspacePath(path), { recursive: true, missing: "ignore" });
+  }
+  async rename(from, to) {
+    await this.v2.move(parseWorkspacePath(from), parseWorkspacePath(to), { createParents: true });
+  }
+  async readDirectory(path) {
+    return (await this.v2.readDirectory(parseWorkspacePath(path))).map(
+      ({ kind, name, path: entryPath }) => ({ kind, name, path: entryPath })
+    );
+  }
+  async exists(path) {
+    return await this.v2.stat(parseWorkspacePath(path)) !== null;
+  }
+  async createDirectory(path) {
+    await this.v2.createDirectory(parseWorkspacePath(path), { createParents: true });
+  }
+  async stat(path) {
+    const entry = await this.v2.stat(parseWorkspacePath(path));
+    return entry?.kind === "file" ? { name: entry.name, path: entry.path, size: entry.size, lastModified: entry.lastModified } : null;
+  }
+  async readBinary(path) {
+    return (await this.v2.readFile(parseWorkspacePath(path)))?.data ?? null;
+  }
+  async writeBinary(path, data) {
+    await this.v2.writeFile(parseWorkspacePath(path), data, { createParents: true });
+  }
+};
+export {
+  HostFileSystemProvider,
+  HostFileSystemProviderV2
+};

package/dist/filesystem/index.d.ts

@@ -1,7 +1,9 @@
-import { P as FsOperation, s as FileSystemProviderV2, r as FileSystemProviderCapabilities, q as FileSystemProvider, c as FileSystemAtomicity, d as FileSystemCaseSensitivity, z as FileSystemSymlinkPolicy, i as FileSystemDurability, 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, G as FileSystemWatchListener, H as FileSystemWatchOptions, I as FileSystemWatchSubscription } from '../types-Bb3yccTH.js';
-export { F as FileCommitResult, a as FileEntry, b as FileMeta, e as FileSystemConditionalWriteStrength, f as FileSystemCreateDirectoryMode, j as FileSystemEntry, l as FileSystemEntryWatchEvent, p as FileSystemOverflowWatchEvent, t as FileSystemProviderWithV2, x as FileSystemSnapshotEntry, y as FileSystemSnapshotFile, A as FileSystemVersion, B as FileSystemWatchErrorListener, C as FileSystemWatchEvent, D as FileSystemWatchEventOrigin, E as FileSystemWatchEventType, J as FileSystemWriteMode, L as FolderEntry, M as FsError, N as FsErrorCode, O as FsErrorContext, S as SerializedFsError, Q as deserializeFsError, R as fsErrorFromUnknown, T as getFileSystemProviderV2, U as hasFileSystemProviderV2, V as isQuotaExceededError, W as isSerializedFsError, X as mapDomExceptionToFsErrorCode, Y as mapNodeErrorCodeToFsErrorCode, Z as parseFileSystemVersion, _ as serializeFsError, $ as tryParseFileSystemVersion } from '../types-Bb3yccTH.js';
+import { d as FileSystemProvider } from '../types-BvDnr3YU.js';
+export { F as FileCommitResult, a as FileEntry, b as FileMeta, c as FileSystemEntry, e as FileSystemProviderWithV2, f as FolderEntry, g as getFileSystemProviderV2, h as hasFileSystemProviderV2 } from '../types-BvDnr3YU.js';
 import { a as WorkspacePath } from '../workspace-path-CWVrcuPL.js';
 export { W as WORKSPACE_ROOT, p as parseWorkspacePath, t as tryParseWorkspacePath, w as workspacePathBasename, b as workspacePathContains, c as workspacePathDirname, d as workspacePathJoin, e as workspacePathToLegacy } from '../workspace-path-CWVrcuPL.js';
+import { I as FsOperation, n as FileSystemProviderV2, m as FileSystemProviderCapabilities, F as FileSystemAtomicity, a as FileSystemCaseSensitivity, t as FileSystemSymlinkPolicy, f as FileSystemDurability, g as FileSystemEntrySnapshot, i as FileSystemFileRead, D as FileSystemWriteOptions, j as FileSystemFileSnapshot, d as FileSystemCreateDirectoryOptions, e as FileSystemDirectorySnapshot, o as FileSystemRemoveOptions, p as FileSystemRemoveResult, k as FileSystemMoveOptions, q as FileSystemSnapshot, z as FileSystemWatchListener, A as FileSystemWatchOptions, B as FileSystemWatchSubscription } from '../v2-BVnZZyd4.js';
+export { b as FileSystemConditionalWriteStrength, c as FileSystemCreateDirectoryMode, h as FileSystemEntryWatchEvent, l as FileSystemOverflowWatchEvent, r as FileSystemSnapshotEntry, s as FileSystemSnapshotFile, u as FileSystemVersion, v as FileSystemWatchErrorListener, w as FileSystemWatchEvent, x as FileSystemWatchEventOrigin, y as FileSystemWatchEventType, C as FileSystemWriteMode, E as FsError, G as FsErrorCode, H as FsErrorContext, S as SerializedFsError, J as deserializeFsError, K as fsErrorFromUnknown, L as isQuotaExceededError, M as isSerializedFsError, N as mapDomExceptionToFsErrorCode, O as mapNodeErrorCodeToFsErrorCode, P as parseFileSystemVersion, Q as serializeFsError, R as tryParseFileSystemVersion } from '../v2-BVnZZyd4.js';
 import { MemoryFileSystemSnapshot, MemoryFileSystemProvider } from './memory.js';
 export { MemoryFilePayloadKind, MemoryFileSystemProviderV2, MemoryFileSystemSnapshotFile, MemoryFileSystemV2CompatibilityFile, MemoryFileSystemV2Replacement, MemoryFileSystemV2ReplacementFile, MemoryFileSystemV2State, MemoryFileSystemV2StateFile } from './memory.js';
 export { IndexedDBContentContainer, IndexedDBFileSystemProvider, IndexedDBFileSystemProviderV2, IndexedDBFileSystemProviderV2Options, IndexedDBLegacyConflictReason, IndexedDBLegacyConflictResolution, IndexedDBLegacyMigrationConflict, IndexedDBLegacyOpaqueDiscardTarget, IndexedDBLegacyOpaqueRecord, IndexedDBLegacyOpaqueRecordSummary, IndexedDBLegacyOpaqueValue, IndexedDBLegacyRecoveryCandidate, IndexedDBLegacyRecoveryKind } from './indexeddb.js';
@@ -10,7 +12,9 @@ import { MediaProvider } from '@bendyline/squisq/schemas';
 export { NativeFileSystemMovePathState, NativeFileSystemMoveRecoveryError, NativeFileSystemMoveRecoveryState, NativeFileSystemProvider, NativeFileSystemProviderV2, isNativeFileSystemSupported, loadDirectoryHandle, openNativeFolder, removeDirectoryHandle, restoreNativeFolder, storeDirectoryHandle } from './native.js';
 export { ElectronFileSystemProvider, ElectronFileSystemProviderV2 } from './electron.js';
 export { isElectronHost } from '../host/index.js';
-import '../types-DBYraXxE.js';
+import '../host-provider-v2-CyLTRKJF.js';
+import '../filesystem-v2-C8AdSXUN.js';
+import '../capabilities-CdQAc745.js';
 
 interface DecodeUtf8TextOptions {
     /** User-facing description of the payload being decoded. */
@@ -132,7 +136,14 @@ declare function replaceMemoryWorkspaceFromDbk(provider: MemoryFileSystemProvide
 declare class FileSystemContentContainer implements ContentContainer {
     private readonly provider;
     private readonly prefix;
-    constructor(provider: FileSystemProvider, prefix?: string);
+    private readonly documentMediaPrefix;
+    constructor(provider: FileSystemProvider, prefix?: string, options?: {
+        documentMediaPrefix?: string;
+    });
+    /** A document-scoped container also accepts the media references written
+     * into its Markdown, e.g. notes_files/audio/take.webm. Version paths and
+     * container-relative discovery still live directly under the scoped root. */
+    private resolve;
     readFile(path: string): Promise<ArrayBuffer | null>;
     writeFile(path: string, data: ArrayBuffer | Uint8Array, _mimeType?: string): Promise<void>;
     removeFile(path: string): Promise<void>;
@@ -161,10 +172,42 @@ declare class FileSystemContentContainer implements ContentContainer {
  *   • Resolves both bare (`image.png`) and folder-qualified
  *     (`notes_files/image.png`) references — so legacy markdown and
  *     exports from other tools both work
+ *   • Types resolved URLs by file extension, as the workspace containers do
  */
 
 declare function createFileMediaProvider(container: ContentContainer, markdownBasename: string): MediaProvider;
 
+/**
+ * Which workspace entries DocBlocks browses, discovers, and watches.
+ *
+ * The explorer, link picker, catalog generator, and watcher each used to keep
+ * a private copy of these rules, and the copies drifted (`.md` in one place,
+ * `.md`/`.markdown` in another, `_files` matched case-insensitively in only
+ * one walker). Storage operations (read, write, move, remove, snapshot) still
+ * reach every entry; these rules only decide what is shown and indexed.
+ */
+/** True for dot-entries (`.git`, `.vscode`, `.DS_Store`) and tool-managed folders (`node_modules`). */
+declare function isIgnoredWorkspaceEntryName(name: string): boolean;
+/** Extensions DocBlocks opens as Markdown documents, lower-case. */
+declare const MARKDOWN_FILE_EXTENSIONS: readonly string[];
+/** True for `notes.md`, `Notes.MARKDOWN`, or a path ending in one. */
+declare function isMarkdownFileName(name: string): boolean;
+/**
+ * The media folder paired with a document (`notes.md` → `notes_files/`).
+ * Case-sensitive, matching what DocBlocks writes.
+ */
+declare function isCompanionDirectoryName(name: string): boolean;
+/** Folder where outside-in exports keep the shared Squisq player runtime. */
+declare const SQUISQ_RUNTIME_DIRECTORY_NAME = "_squisq";
+/** Entries the file explorer shows. */
+declare function isBrowsableWorkspaceEntry(name: string, kind: 'file' | 'directory'): boolean;
+/** Entries that document discovery (link picker, catalog, workspace index) lists or descends into. */
+declare function isDiscoverableWorkspaceEntry(name: string, kind: 'file' | 'directory'): boolean;
+
+interface FileSystemEntryMoveOptions {
+    /** An active session performs its own rewrite after retargeting. */
+    rewriteMarkdown?: boolean;
+}
 /** Return the hidden companion directory used for a document's media and versions. */
 declare function documentCompanionPath(documentPath: string): string;
 /**
@@ -172,7 +215,10 @@ declare function documentCompanionPath(documentPath: string): string;
  * outside-in rendered documents carry their hidden `<basename>_files`
  * companion directory with them.
  */
-declare function moveFileSystemEntry(provider: FileSystemProvider, oldPath: string, newPath: string, kind: 'file' | 'directory'): Promise<void>;
+declare function moveFileSystemEntry(provider: FileSystemProvider, oldPath: string, newPath: string, kind: 'file' | 'directory', options?: FileSystemEntryMoveOptions): Promise<void>;
+
+/** Rewrite owned media references after a Markdown companion changes name. */
+declare function rewriteCompanionReferences(content: string, oldPath: string, newPath: string): Promise<string>;
 
 type FileSystemPathPresence = 'present' | 'missing' | 'unknown';
 interface FileSystemPartialMoveState {
@@ -226,4 +272,4 @@ declare function isFileSystemMoveStateError(error: unknown): error is FileSystem
 declare function describePartialMove(provider: FileSystemProvider, sourcePath: string, destinationPath: string, companionSourcePath: string, companionDestinationPath: string): Promise<FileSystemPartialMoveState>;
 declare function describeEntryMove(provider: FileSystemProvider, sourcePath: string, destinationPath: string): Promise<FileSystemEntryMoveState>;
 
-export { type DbkWorkspaceAssetLayout, type DbkWorkspaceSnapshot, type DbkWorkspaceSnapshotOptions, type DecodeUtf8TextOptions, FileSystemAtomicity, FileSystemCaseSensitivity, FileSystemContentContainer, FileSystemCreateDirectoryOptions, FileSystemDirectorySnapshot, FileSystemDurability, type FileSystemEntryMoveState, FileSystemEntrySnapshot, FileSystemFileRead, FileSystemFileSnapshot, type FileSystemMoveLocation, FileSystemMoveOptions, FileSystemMoveRecoveryError, FileSystemPartialMoveError, type FileSystemPartialMoveState, type FileSystemPathPresence, FileSystemProvider, FileSystemProviderCapabilities, FileSystemProviderV2, FileSystemRemoveOptions, FileSystemRemoveResult, FileSystemSnapshot, FileSystemSymlinkPolicy, FileSystemWatchListener, FileSystemWatchOptions, FileSystemWatchSubscription, FileSystemWriteOptions, FsOperation, type LegacyFilePayloadModel, LegacyFileSystemProviderV2Adapter, type LegacyFileSystemProviderV2AdapterOptions, MemoryFileSystemProvider, MemoryFileSystemSnapshot, WorkspacePath, createDbkWorkspaceSnapshot, createFileMediaProvider, decodeUtf8Text, describeEntryMove, describePartialMove, documentCompanionPath, isFileSystemMoveRecoveryError, isFileSystemMoveStateError, isFileSystemPartialMoveError, moveFileSystemEntry, replaceMemoryWorkspaceFromDbk };
+export { type DbkWorkspaceAssetLayout, type DbkWorkspaceSnapshot, type DbkWorkspaceSnapshotOptions, type DecodeUtf8TextOptions, FileSystemAtomicity, FileSystemCaseSensitivity, FileSystemContentContainer, FileSystemCreateDirectoryOptions, FileSystemDirectorySnapshot, FileSystemDurability, type FileSystemEntryMoveOptions, type FileSystemEntryMoveState, FileSystemEntrySnapshot, FileSystemFileRead, FileSystemFileSnapshot, type FileSystemMoveLocation, FileSystemMoveOptions, FileSystemMoveRecoveryError, FileSystemPartialMoveError, type FileSystemPartialMoveState, type FileSystemPathPresence, FileSystemProvider, FileSystemProviderCapabilities, FileSystemProviderV2, FileSystemRemoveOptions, FileSystemRemoveResult, FileSystemSnapshot, FileSystemSymlinkPolicy, FileSystemWatchListener, FileSystemWatchOptions, FileSystemWatchSubscription, FileSystemWriteOptions, FsOperation, type LegacyFilePayloadModel, LegacyFileSystemProviderV2Adapter, type LegacyFileSystemProviderV2AdapterOptions, MARKDOWN_FILE_EXTENSIONS, MemoryFileSystemProvider, MemoryFileSystemSnapshot, SQUISQ_RUNTIME_DIRECTORY_NAME, WorkspacePath, createDbkWorkspaceSnapshot, createFileMediaProvider, decodeUtf8Text, describeEntryMove, describePartialMove, documentCompanionPath, isBrowsableWorkspaceEntry, isCompanionDirectoryName, isDiscoverableWorkspaceEntry, isFileSystemMoveRecoveryError, isFileSystemMoveStateError, isFileSystemPartialMoveError, isIgnoredWorkspaceEntryName, isMarkdownFileName, moveFileSystemEntry, replaceMemoryWorkspaceFromDbk, rewriteCompanionReferences };

package/dist/filesystem/index.js

@@ -5,17 +5,28 @@ import {
   createFileMediaProvider,
   documentCompanionPath,
   moveFileSystemEntry,
-  replaceMemoryWorkspaceFromDbk
-} from "../chunk-UMWCTEXW.js";
+  replaceMemoryWorkspaceFromDbk,
+  rewriteCompanionReferences
+} from "../chunk-7SN7YQL4.js";
+import {
+  MARKDOWN_FILE_EXTENSIONS,
+  SQUISQ_RUNTIME_DIRECTORY_NAME,
+  isBrowsableWorkspaceEntry,
+  isCompanionDirectoryName,
+  isDiscoverableWorkspaceEntry,
+  isIgnoredWorkspaceEntryName,
+  isMarkdownFileName
+} from "../chunk-YHSFRPBS.js";
 import {
   IndexedDBContentContainer,
   IndexedDBFileSystemProvider,
   IndexedDBFileSystemProviderV2
-} from "../chunk-YM7O3PWO.js";
+} from "../chunk-HKOOHM67.js";
+import "../chunk-DAPFSEKY.js";
 import {
   MemoryFileSystemProvider,
   MemoryFileSystemProviderV2
-} from "../chunk-ZO7G53QP.js";
+} from "../chunk-UDEWLHQI.js";
 import {
   NativeFileSystemMoveRecoveryError,
   NativeFileSystemProvider,
@@ -26,22 +37,25 @@ import {
   removeDirectoryHandle,
   restoreNativeFolder,
   storeDirectoryHandle
-} from "../chunk-4437YWLE.js";
+} from "../chunk-6UPO2GE6.js";
 import "../chunk-DZB666V7.js";
 import "../chunk-KQ6756AJ.js";
 import {
   ElectronFileSystemProvider,
   ElectronFileSystemProviderV2
-} from "../chunk-BVY7GGNV.js";
+} from "../chunk-IDYE73TU.js";
+import "../chunk-L6PRMR7T.js";
 import {
   isElectronHost
-} from "../chunk-6XHOOBYF.js";
-import "../chunk-2WDJ27EH.js";
+} from "../chunk-YNUQG4GF.js";
+import "../chunk-245W57QP.js";
+import "../chunk-46AGYHDY.js";
 import "../chunk-73OOROXH.js";
+import "../chunk-HABG2JM3.js";
 import {
   parseFileSystemVersion,
   tryParseFileSystemVersion
-} from "../chunk-M62ZGJ5I.js";
+} from "../chunk-LPIJ6HKL.js";
 import {
   FileSystemMoveRecoveryError,
   FileSystemPartialMoveError,
@@ -50,7 +64,11 @@ import {
   isFileSystemMoveRecoveryError,
   isFileSystemMoveStateError,
   isFileSystemPartialMoveError
-} from "../chunk-QI6YKTQV.js";
+} from "../chunk-IGB2VSRE.js";
+import {
+  getFileSystemProviderV2,
+  hasFileSystemProviderV2
+} from "../chunk-XAMILHQP.js";
 import {
   decodeUtf8Text
 } from "../chunk-M5ZNQGR5.js";
@@ -72,11 +90,6 @@ import {
   workspacePathJoin,
   workspacePathToLegacy
 } from "../chunk-AYWKIZLD.js";
-import "../chunk-OQCPBOQA.js";
-import {
-  getFileSystemProviderV2,
-  hasFileSystemProviderV2
-} from "../chunk-XAMILHQP.js";
 export {
   ElectronFileSystemProvider,
   ElectronFileSystemProviderV2,
@@ -88,11 +101,13 @@ export {
   IndexedDBFileSystemProvider,
   IndexedDBFileSystemProviderV2,
   LegacyFileSystemProviderV2Adapter,
+  MARKDOWN_FILE_EXTENSIONS,
   MemoryFileSystemProvider,
   MemoryFileSystemProviderV2,
   NativeFileSystemMoveRecoveryError,
   NativeFileSystemProvider,
   NativeFileSystemProviderV2,
+  SQUISQ_RUNTIME_DIRECTORY_NAME,
   WORKSPACE_ROOT,
   createDbkWorkspaceSnapshot,
   createFileMediaProvider,
@@ -104,10 +119,15 @@ export {
   fsErrorFromUnknown,
   getFileSystemProviderV2,
   hasFileSystemProviderV2,
+  isBrowsableWorkspaceEntry,
+  isCompanionDirectoryName,
+  isDiscoverableWorkspaceEntry,
   isElectronHost,
   isFileSystemMoveRecoveryError,
   isFileSystemMoveStateError,
   isFileSystemPartialMoveError,
+  isIgnoredWorkspaceEntryName,
+  isMarkdownFileName,
   isNativeFileSystemSupported,
   isQuotaExceededError,
   isSerializedFsError,
@@ -121,6 +141,7 @@ export {
   removeDirectoryHandle,
   replaceMemoryWorkspaceFromDbk,
   restoreNativeFolder,
+  rewriteCompanionReferences,
   serializeFsError,
   storeDirectoryHandle,
   tryParseFileSystemVersion,

package/dist/filesystem/indexeddb.d.ts

@@ -1,4 +1,5 @@
-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, G as FileSystemWatchListener, H as FileSystemWatchOptions, I as FileSystemWatchSubscription, b as FileMeta, q as FileSystemProvider, F as FileCommitResult, j as FileSystemEntry } from '../types-Bb3yccTH.js';
+import { b as FileMeta, d as FileSystemProvider, F as FileCommitResult, c as FileSystemEntry } from '../types-BvDnr3YU.js';
+import { n as FileSystemProviderV2, m as FileSystemProviderCapabilities, g as FileSystemEntrySnapshot, i as FileSystemFileRead, D as FileSystemWriteOptions, j as FileSystemFileSnapshot, d as FileSystemCreateDirectoryOptions, e as FileSystemDirectorySnapshot, o as FileSystemRemoveOptions, p as FileSystemRemoveResult, k as FileSystemMoveOptions, q as FileSystemSnapshot, z as FileSystemWatchListener, A as FileSystemWatchOptions, B as FileSystemWatchSubscription } from '../v2-BVnZZyd4.js';
 import { a as WorkspacePath } from '../workspace-path-CWVrcuPL.js';
 import { ContentContainer, ContentEntry } from '@bendyline/squisq/storage';
 
@@ -29,6 +30,12 @@ interface IndexedDBFileSystemTransaction {
     keys(): Promise<string[]>;
     /** O(log n) namespace probe in the concrete IndexedDB implementation. */
     hasKeyWithPrefix(prefix: string): Promise<boolean>;
+    /**
+     * Keys directly under `prefix` (the remainder contains no `/`), in key
+     * order, skipping each child's subtree instead of visiting it. Optional:
+     * callers fall back to filtering `keys()`.
+     */
+    childKeys?(prefix: string): Promise<string[]>;
 }
 interface IndexedDBFileSystemStore {
     transaction<T>(mode: IndexedDBFileSystemTransactionMode, operation: (transaction: IndexedDBFileSystemTransaction) => Promise<T>): Promise<T>;

package/dist/filesystem/indexeddb.js

@@ -2,17 +2,18 @@ import {
   IndexedDBContentContainer,
   IndexedDBFileSystemProvider,
   IndexedDBFileSystemProviderV2
-} from "../chunk-YM7O3PWO.js";
+} from "../chunk-HKOOHM67.js";
+import {
+  deleteIndexedDBWorkspaceData,
+  indexedDBWorkspaceDatabaseName
+} from "../chunk-DAPFSEKY.js";
 import "../chunk-DZB666V7.js";
 import "../chunk-KQ6756AJ.js";
 import "../chunk-73OOROXH.js";
-import "../chunk-M62ZGJ5I.js";
+import "../chunk-HABG2JM3.js";
+import "../chunk-LPIJ6HKL.js";
 import "../chunk-M5ZNQGR5.js";
 import "../chunk-AYWKIZLD.js";
-import {
-  deleteIndexedDBWorkspaceData,
-  indexedDBWorkspaceDatabaseName
-} from "../chunk-OQCPBOQA.js";
 export {
   IndexedDBContentContainer,
   IndexedDBFileSystemProvider,

package/dist/filesystem/memory.d.ts

@@ -1,4 +1,5 @@
-import { s as FileSystemProviderV2, r as FileSystemProviderCapabilities, K as FileSystemWriteOptions, n as FileSystemFileSnapshot, F as FileCommitResult, k as FileSystemEntrySnapshot, m as FileSystemFileRead, g as FileSystemCreateDirectoryOptions, h as FileSystemDirectorySnapshot, u as FileSystemRemoveOptions, v as FileSystemRemoveResult, o as FileSystemMoveOptions, w as FileSystemSnapshot, G as FileSystemWatchListener, H as FileSystemWatchOptions, I as FileSystemWatchSubscription, q as FileSystemProvider, j as FileSystemEntry, b as FileMeta } from '../types-Bb3yccTH.js';
+import { F as FileCommitResult, d as FileSystemProvider, c as FileSystemEntry, b as FileMeta } from '../types-BvDnr3YU.js';
+import { n as FileSystemProviderV2, m as FileSystemProviderCapabilities, D as FileSystemWriteOptions, j as FileSystemFileSnapshot, g as FileSystemEntrySnapshot, i as FileSystemFileRead, d as FileSystemCreateDirectoryOptions, e as FileSystemDirectorySnapshot, o as FileSystemRemoveOptions, p as FileSystemRemoveResult, k as FileSystemMoveOptions, q as FileSystemSnapshot, z as FileSystemWatchListener, A as FileSystemWatchOptions, B as FileSystemWatchSubscription } from '../v2-BVnZZyd4.js';
 import { a as WorkspacePath } from '../workspace-path-CWVrcuPL.js';
 
 type MemoryFilePayloadKind = 'text' | 'binary';

package/dist/filesystem/memory.js

@@ -1,9 +1,10 @@
 import {
   MemoryFileSystemProvider,
   MemoryFileSystemProviderV2
-} from "../chunk-ZO7G53QP.js";
+} from "../chunk-UDEWLHQI.js";
 import "../chunk-KQ6756AJ.js";
-import "../chunk-M62ZGJ5I.js";
+import "../chunk-HABG2JM3.js";
+import "../chunk-LPIJ6HKL.js";
 import "../chunk-M5ZNQGR5.js";
 import "../chunk-AYWKIZLD.js";
 export {

package/dist/filesystem/native.d.ts

@@ -1,4 +1,5 @@
-import { M as FsError, 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, G as FileSystemWatchListener, H as FileSystemWatchOptions, I as FileSystemWatchSubscription, q as FileSystemProvider, F as FileCommitResult, j as FileSystemEntry, b as FileMeta } from '../types-Bb3yccTH.js';
+import { d as FileSystemProvider, F as FileCommitResult, c as FileSystemEntry, b as FileMeta } from '../types-BvDnr3YU.js';
+import { E as FsError, n as FileSystemProviderV2, m as FileSystemProviderCapabilities, g as FileSystemEntrySnapshot, i as FileSystemFileRead, D as FileSystemWriteOptions, j as FileSystemFileSnapshot, d as FileSystemCreateDirectoryOptions, e as FileSystemDirectorySnapshot, o as FileSystemRemoveOptions, p as FileSystemRemoveResult, k as FileSystemMoveOptions, q as FileSystemSnapshot, z as FileSystemWatchListener, A as FileSystemWatchOptions, B as FileSystemWatchSubscription } from '../v2-BVnZZyd4.js';
 import { a as WorkspacePath } from '../workspace-path-CWVrcuPL.js';
 
 type NativeFileSystemMovePathState = 'present' | 'missing' | 'unknown';