@bendyline/docblocks 1.1.2 → 2.1.0

package/dist/chunk-MNSZ7EZN.js

@@ -0,0 +1,111 @@
+import {
+  parseWorkspacePath
+} from "./chunk-JS6XFWQK.js";
+import {
+  getFileSystemProviderV2
+} from "./chunk-EZKJZUNJ.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 };
+}
+
+export {
+  FileSystemMoveRecoveryError,
+  FileSystemPartialMoveError,
+  isFileSystemPartialMoveError,
+  isFileSystemMoveRecoveryError,
+  isFileSystemMoveStateError,
+  describePartialMove,
+  describeEntryMove
+};
+//# sourceMappingURL=chunk-MNSZ7EZN.js.map

package/dist/chunk-MNSZ7EZN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filesystem/move-error.ts"],"sourcesContent":["import { getFileSystemProviderV2, type FileSystemProvider } from './types.js';\nimport { parseWorkspacePath } from './workspace-path.js';\n\nexport type FileSystemPathPresence = 'present' | 'missing' | 'unknown';\n\nexport interface FileSystemPartialMoveState {\n  readonly source: FileSystemPathPresence;\n  readonly destination: FileSystemPathPresence;\n  readonly companionSource: FileSystemPathPresence;\n  readonly companionDestination: FileSystemPathPresence;\n}\n\nexport type FileSystemMoveLocation = 'source' | 'destination' | 'both' | 'neither' | 'unknown';\n\nexport interface FileSystemEntryMoveState {\n  readonly source: FileSystemPathPresence;\n  readonly destination: FileSystemPathPresence;\n}\n\nfunction locationFromPresence(\n  source: FileSystemPathPresence,\n  destination: FileSystemPathPresence,\n): FileSystemMoveLocation {\n  if (source === 'unknown' || destination === 'unknown') return 'unknown';\n  if (source === 'present' && destination === 'present') return 'both';\n  if (source === 'present') return 'source';\n  if (destination === 'present') return 'destination';\n  return 'neither';\n}\n\n/**\n * One provider move failed without restoring a provable source-only state.\n * This is backend-neutral: callers must use `location`, never infer from the\n * original exception or a provider's advertised move atomicity.\n */\nexport class FileSystemMoveRecoveryError extends Error {\n  public readonly code = 'partial-move' as const;\n\n  public constructor(\n    public readonly sourcePath: string,\n    public readonly destinationPath: string,\n    public readonly state: FileSystemEntryMoveState,\n    public readonly moveError: unknown,\n  ) {\n    super(\n      `The move did not restore one authoritative path. Entry location: ${locationFromPresence(\n        state.source,\n        state.destination,\n      )}.`,\n    );\n    this.name = 'FileSystemMoveRecoveryError';\n  }\n\n  public get location(): FileSystemMoveLocation {\n    return locationFromPresence(this.state.source, this.state.destination);\n  }\n\n  /** Alias used by DocumentSession's document-retarget recovery protocol. */\n  public get documentLocation(): FileSystemMoveLocation {\n    return this.location;\n  }\n}\n\n/**\n * A compound document/companion move failed and the document rollback also\n * failed. Callers must use the recorded post-state instead of assuming the\n * original path is still authoritative.\n */\nexport class FileSystemPartialMoveError extends Error {\n  readonly code = 'partial-move' as const;\n\n  constructor(\n    readonly sourcePath: string,\n    readonly destinationPath: string,\n    readonly companionSourcePath: string,\n    readonly companionDestinationPath: string,\n    readonly state: FileSystemPartialMoveState,\n    readonly moveError: unknown,\n    readonly rollbackError: unknown,\n  ) {\n    super(\n      `The document move could not be rolled back. Document location: ${locationFromPresence(\n        state.source,\n        state.destination,\n      )}; companion location: ${locationFromPresence(\n        state.companionSource,\n        state.companionDestination,\n      )}.`,\n    );\n    this.name = 'FileSystemPartialMoveError';\n  }\n\n  get documentLocation(): FileSystemMoveLocation {\n    return locationFromPresence(this.state.source, this.state.destination);\n  }\n\n  get companionLocation(): FileSystemMoveLocation {\n    return locationFromPresence(this.state.companionSource, this.state.companionDestination);\n  }\n}\n\nexport function isFileSystemPartialMoveError(error: unknown): error is FileSystemPartialMoveError {\n  return error instanceof FileSystemPartialMoveError;\n}\n\nexport function isFileSystemMoveRecoveryError(\n  error: unknown,\n): error is FileSystemMoveRecoveryError {\n  return error instanceof FileSystemMoveRecoveryError;\n}\n\nexport function isFileSystemMoveStateError(\n  error: unknown,\n): error is FileSystemMoveRecoveryError | FileSystemPartialMoveError {\n  return isFileSystemMoveRecoveryError(error) || isFileSystemPartialMoveError(error);\n}\n\nasync function probePath(\n  provider: FileSystemProvider,\n  path: string,\n): Promise<FileSystemPathPresence> {\n  try {\n    const providerV2 = getFileSystemProviderV2(provider);\n    const present = providerV2\n      ? (await providerV2.stat(parseWorkspacePath(path))) !== null\n      : await provider.exists(path);\n    return present ? 'present' : 'missing';\n  } catch {\n    return 'unknown';\n  }\n}\n\nexport async function describePartialMove(\n  provider: FileSystemProvider,\n  sourcePath: string,\n  destinationPath: string,\n  companionSourcePath: string,\n  companionDestinationPath: string,\n): Promise<FileSystemPartialMoveState> {\n  const [source, destination, companionSource, companionDestination] = await Promise.all([\n    probePath(provider, sourcePath),\n    probePath(provider, destinationPath),\n    probePath(provider, companionSourcePath),\n    probePath(provider, companionDestinationPath),\n  ]);\n  return { source, destination, companionSource, companionDestination };\n}\n\nexport async function describeEntryMove(\n  provider: FileSystemProvider,\n  sourcePath: string,\n  destinationPath: string,\n): Promise<FileSystemEntryMoveState> {\n  const [source, destination] = await Promise.all([\n    probePath(provider, sourcePath),\n    probePath(provider, destinationPath),\n  ]);\n  return { source, destination };\n}\n"],"mappings":";;;;;;;;AAmBA,SAAS,qBACP,QACA,aACwB;AACxB,MAAI,WAAW,aAAa,gBAAgB,UAAW,QAAO;AAC9D,MAAI,WAAW,aAAa,gBAAgB,UAAW,QAAO;AAC9D,MAAI,WAAW,UAAW,QAAO;AACjC,MAAI,gBAAgB,UAAW,QAAO;AACtC,SAAO;AACT;AAOO,IAAM,8BAAN,cAA0C,MAAM;AAAA,EAG9C,YACW,YACA,iBACA,OACA,WAChB;AACA;AAAA,MACE,oEAAoE;AAAA,QAClE,MAAM;AAAA,QACN,MAAM;AAAA,MACR,CAAC;AAAA,IACH;AAVgB;AACA;AACA;AACA;AANlB,SAAgB,OAAO;AAcrB,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,IAAW,WAAmC;AAC5C,WAAO,qBAAqB,KAAK,MAAM,QAAQ,KAAK,MAAM,WAAW;AAAA,EACvE;AAAA;AAAA,EAGA,IAAW,mBAA2C;AACpD,WAAO,KAAK;AAAA,EACd;AACF;AAOO,IAAM,6BAAN,cAAyC,MAAM;AAAA,EAGpD,YACW,YACA,iBACA,qBACA,0BACA,OACA,WACA,eACT;AACA;AAAA,MACE,kEAAkE;AAAA,QAChE,MAAM;AAAA,QACN,MAAM;AAAA,MACR,CAAC,yBAAyB;AAAA,QACxB,MAAM;AAAA,QACN,MAAM;AAAA,MACR,CAAC;AAAA,IACH;AAhBS;AACA;AACA;AACA;AACA;AACA;AACA;AATX,SAAS,OAAO;AAoBd,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,IAAI,mBAA2C;AAC7C,WAAO,qBAAqB,KAAK,MAAM,QAAQ,KAAK,MAAM,WAAW;AAAA,EACvE;AAAA,EAEA,IAAI,oBAA4C;AAC9C,WAAO,qBAAqB,KAAK,MAAM,iBAAiB,KAAK,MAAM,oBAAoB;AAAA,EACzF;AACF;AAEO,SAAS,6BAA6B,OAAqD;AAChG,SAAO,iBAAiB;AAC1B;AAEO,SAAS,8BACd,OACsC;AACtC,SAAO,iBAAiB;AAC1B;AAEO,SAAS,2BACd,OACmE;AACnE,SAAO,8BAA8B,KAAK,KAAK,6BAA6B,KAAK;AACnF;AAEA,eAAe,UACb,UACA,MACiC;AACjC,MAAI;AACF,UAAM,aAAa,wBAAwB,QAAQ;AACnD,UAAM,UAAU,aACX,MAAM,WAAW,KAAK,mBAAmB,IAAI,CAAC,MAAO,OACtD,MAAM,SAAS,OAAO,IAAI;AAC9B,WAAO,UAAU,YAAY;AAAA,EAC/B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,eAAsB,oBACpB,UACA,YACA,iBACA,qBACA,0BACqC;AACrC,QAAM,CAAC,QAAQ,aAAa,iBAAiB,oBAAoB,IAAI,MAAM,QAAQ,IAAI;AAAA,IACrF,UAAU,UAAU,UAAU;AAAA,IAC9B,UAAU,UAAU,eAAe;AAAA,IACnC,UAAU,UAAU,mBAAmB;AAAA,IACvC,UAAU,UAAU,wBAAwB;AAAA,EAC9C,CAAC;AACD,SAAO,EAAE,QAAQ,aAAa,iBAAiB,qBAAqB;AACtE;AAEA,eAAsB,kBACpB,UACA,YACA,iBACmC;AACnC,QAAM,CAAC,QAAQ,WAAW,IAAI,MAAM,QAAQ,IAAI;AAAA,IAC9C,UAAU,UAAU,UAAU;AAAA,IAC9B,UAAU,UAAU,eAAe;AAAA,EACrC,CAAC;AACD,SAAO,EAAE,QAAQ,YAAY;AAC/B;","names":[]}

package/dist/chunk-P3DVZQ6S.js

@@ -0,0 +1,228 @@
+import {
+  RawIndexedDBFileSystemStore
+} from "./chunk-RVPGQBWR.js";
+import {
+  getFileSystemProviderV2
+} from "./chunk-EZKJZUNJ.js";
+
+// src/workspace/workspace-schema.ts
+var MAX_IDENTIFIER_CHARACTERS = 256;
+var MAX_LABEL_CHARACTERS = 1024;
+var MAX_PATH_CHARACTERS = 4096;
+var MAX_WORKSPACES = 1e4;
+function parsePersistedWorkspaceList(value) {
+  if (!Array.isArray(value)) throw new Error("Persisted workspaces must be an array.");
+  if (value.length > MAX_WORKSPACES) throw new Error("Persisted workspace list is too large.");
+  const parsed = value.map(parsePersistedWorkspace);
+  if (new Set(parsed.map((workspace) => workspace.id)).size !== parsed.length) {
+    throw new Error("Persisted workspace IDs must be unique.");
+  }
+  return parsed;
+}
+function parsePersistedWorkspace(value, index) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`Persisted workspace ${index} must be an object.`);
+  }
+  const record = value;
+  const allowed = ["id", "name", "type", "lastOpened", "rootPath", "versioningOverride"];
+  const unknownKey = Object.keys(record).find((key) => !allowed.includes(key));
+  if (unknownKey) throw new Error(`Persisted workspace ${index} has unknown field ${unknownKey}.`);
+  const id = boundedString(record.id, MAX_IDENTIFIER_CHARACTERS, `workspace ${index} id`);
+  const name = boundedString(record.name, MAX_LABEL_CHARACTERS, `workspace ${index} name`);
+  if (record.type !== "indexeddb" && record.type !== "native" && record.type !== "electron-native") {
+    throw new Error(`Persisted workspace ${index} has an invalid provider type.`);
+  }
+  const lastOpened = boundedString(
+    record.lastOpened,
+    MAX_IDENTIFIER_CHARACTERS,
+    `workspace ${index} lastOpened`
+  );
+  if (!Number.isFinite(Date.parse(lastOpened)) || new Date(lastOpened).toISOString() !== lastOpened) {
+    throw new Error(`Persisted workspace ${index} has an invalid lastOpened timestamp.`);
+  }
+  const descriptor = { id, name, type: record.type, lastOpened };
+  if (record.rootPath !== void 0) {
+    descriptor.rootPath = boundedString(
+      record.rootPath,
+      MAX_PATH_CHARACTERS,
+      `workspace ${index} rootPath`
+    );
+  }
+  if (record.type === "electron-native" && descriptor.rootPath === void 0) {
+    throw new Error(`Persisted Electron workspace ${index} is missing rootPath.`);
+  }
+  if (record.type !== "electron-native" && descriptor.rootPath !== void 0) {
+    throw new Error(`Persisted workspace ${index} must not contain rootPath.`);
+  }
+  if (record.versioningOverride !== void 0) {
+    if (record.versioningOverride !== "inherit" && record.versioningOverride !== "on" && record.versioningOverride !== "off") {
+      throw new Error(`Persisted workspace ${index} has an invalid versioning override.`);
+    }
+    descriptor.versioningOverride = record.versioningOverride;
+  }
+  return descriptor;
+}
+function boundedString(value, maximum, label) {
+  if (typeof value !== "string" || value.length < 1 || value.length > maximum || value.includes("\0")) {
+    throw new Error(`Persisted ${label} must be a bounded non-empty string.`);
+  }
+  return value;
+}
+
+// src/workspace/workspace-manager.ts
+var DB_NAME = "docblocks-workspaces";
+var STORE_NAME = "workspaces";
+var LIST_KEY = "workspace-list";
+var DEFAULT_WORKSPACE_ID = "default";
+var registryStore = null;
+function store() {
+  registryStore ?? (registryStore = new RawIndexedDBFileSystemStore(DB_NAME, STORE_NAME));
+  return registryStore;
+}
+var transientWorkspaces = /* @__PURE__ */ new Map();
+var persistedMutationTail = Promise.resolve();
+function registerTransientWorkspace(descriptor, provider) {
+  const previous = transientWorkspaces.get(descriptor.id);
+  if (previous && previous.provider !== provider) {
+    void getFileSystemProviderV2(previous.provider)?.dispose();
+  }
+  transientWorkspaces.set(descriptor.id, { descriptor, provider });
+}
+function getTransientWorkspace(id) {
+  return transientWorkspaces.get(id) ?? null;
+}
+async function unregisterTransientWorkspace(id) {
+  const entry = transientWorkspaces.get(id);
+  if (!entry) return;
+  transientWorkspaces.delete(id);
+  await getFileSystemProviderV2(entry.provider)?.dispose();
+}
+async function readPersistedIn(transaction) {
+  const list = await transaction.get(LIST_KEY);
+  return list == null ? [] : parsePersistedWorkspaceList(list);
+}
+async function readPersisted() {
+  return store().transaction("readonly", readPersistedIn);
+}
+async function listPersisted() {
+  await persistedMutationTail;
+  return readPersisted();
+}
+function mutatePersisted(mutation) {
+  const operation = persistedMutationTail.then(async () => {
+    await store().transaction("readwrite", async (transaction) => {
+      const current = await readPersistedIn(transaction);
+      const next = parsePersistedWorkspaceList(mutation([...current]));
+      await transaction.put(LIST_KEY, next);
+    });
+  });
+  persistedMutationTail = operation.then(
+    () => void 0,
+    () => void 0
+  );
+  return operation;
+}
+async function listWorkspaces() {
+  const persisted = await listPersisted();
+  const transient = [...transientWorkspaces.values()].map((t) => t.descriptor);
+  return [...persisted, ...transient];
+}
+async function getWorkspace(id) {
+  const transient = transientWorkspaces.get(id);
+  if (transient) return transient.descriptor;
+  const list = await listPersisted();
+  return list.find((w) => w.id === id) ?? null;
+}
+async function saveWorkspace(workspace) {
+  if (workspace.type === "transient") return;
+  const persisted = parsePersistedWorkspaceList([workspace])[0];
+  await mutatePersisted((list) => {
+    const idx = list.findIndex((candidate) => candidate.id === persisted.id);
+    if (idx >= 0) list[idx] = persisted;
+    else list.push(persisted);
+    return list;
+  });
+}
+async function removeWorkspace(id) {
+  if (transientWorkspaces.has(id)) {
+    await unregisterTransientWorkspace(id);
+    return;
+  }
+  await mutatePersisted((list) => list.filter((workspace) => workspace.id !== id));
+}
+async function touchWorkspace(id) {
+  const transient = transientWorkspaces.get(id);
+  if (transient) {
+    transient.descriptor.lastOpened = (/* @__PURE__ */ new Date()).toISOString();
+    return;
+  }
+  await mutatePersisted((list) => {
+    const workspace = list.find((candidate) => candidate.id === id);
+    if (workspace) workspace.lastOpened = (/* @__PURE__ */ new Date()).toISOString();
+    return list;
+  });
+}
+async function ensureDefaultWorkspace() {
+  const existing = await getWorkspace(DEFAULT_WORKSPACE_ID);
+  if (existing) return existing;
+  const descriptor = {
+    id: DEFAULT_WORKSPACE_ID,
+    name: "My Documents",
+    type: "indexeddb",
+    lastOpened: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveWorkspace(descriptor);
+  return descriptor;
+}
+
+// src/workspace/reconcile-electron.ts
+function comparableRoot(rootPath, platform) {
+  const normalized = rootPath.replace(/\\/gu, "/").replace(/\/+$/gu, "");
+  return platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function reconcileElectronWorkspaceDescriptors(local, hostWorkspaces, platform, now) {
+  const electron = local.filter((workspace) => workspace.type === "electron-native");
+  const matchedLocalIds = /* @__PURE__ */ new Set();
+  const idRemap = {};
+  const upsert = hostWorkspaces.map((hostWorkspace) => {
+    const root = comparableRoot(hostWorkspace.rootPath, platform);
+    const candidates = electron.filter(
+      (workspace) => workspace.rootPath && comparableRoot(workspace.rootPath, platform) === root
+    );
+    const matching = candidates.sort(
+      (left, right) => right.lastOpened.localeCompare(left.lastOpened)
+    )[0];
+    if (matching) {
+      matchedLocalIds.add(matching.id);
+      if (matching.id !== hostWorkspace.id) idRemap[matching.id] = hostWorkspace.id;
+    }
+    return {
+      id: hostWorkspace.id,
+      name: matching?.name ?? hostWorkspace.name,
+      type: "electron-native",
+      rootPath: hostWorkspace.rootPath,
+      lastOpened: matching?.lastOpened ?? now,
+      ...matching?.versioningOverride ? { versioningOverride: matching.versioningOverride } : {}
+    };
+  });
+  const canonicalIds = new Set(hostWorkspaces.map((workspace) => workspace.id));
+  const removeIds = electron.filter(
+    (workspace) => !canonicalIds.has(workspace.id) || matchedLocalIds.has(workspace.id) && !upsert.some((candidate) => candidate.id === workspace.id)
+  ).map((workspace) => workspace.id);
+  return { removeIds, upsert, idRemap };
+}
+
+export {
+  parsePersistedWorkspaceList,
+  registerTransientWorkspace,
+  getTransientWorkspace,
+  unregisterTransientWorkspace,
+  listWorkspaces,
+  getWorkspace,
+  saveWorkspace,
+  removeWorkspace,
+  touchWorkspace,
+  ensureDefaultWorkspace,
+  reconcileElectronWorkspaceDescriptors
+};
+//# sourceMappingURL=chunk-P3DVZQ6S.js.map

package/dist/chunk-P3DVZQ6S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/workspace/workspace-schema.ts","../src/workspace/workspace-manager.ts","../src/workspace/reconcile-electron.ts"],"sourcesContent":["import type { WorkspaceDescriptor } from './types.js';\n\nconst MAX_IDENTIFIER_CHARACTERS = 256;\nconst MAX_LABEL_CHARACTERS = 1_024;\nconst MAX_PATH_CHARACTERS = 4_096;\nconst MAX_WORKSPACES = 10_000;\n\n/** Parse the complete persisted workspace list before it reaches startup code. */\nexport function parsePersistedWorkspaceList(value: unknown): WorkspaceDescriptor[] {\n  if (!Array.isArray(value)) throw new Error('Persisted workspaces must be an array.');\n  if (value.length > MAX_WORKSPACES) throw new Error('Persisted workspace list is too large.');\n  const parsed = value.map(parsePersistedWorkspace);\n  if (new Set(parsed.map((workspace) => workspace.id)).size !== parsed.length) {\n    throw new Error('Persisted workspace IDs must be unique.');\n  }\n  return parsed;\n}\n\nfunction parsePersistedWorkspace(value: unknown, index: number): WorkspaceDescriptor {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    throw new Error(`Persisted workspace ${index} must be an object.`);\n  }\n  const record = value as Record<string, unknown>;\n  const allowed = ['id', 'name', 'type', 'lastOpened', 'rootPath', 'versioningOverride'];\n  const unknownKey = Object.keys(record).find((key) => !allowed.includes(key));\n  if (unknownKey) throw new Error(`Persisted workspace ${index} has unknown field ${unknownKey}.`);\n\n  const id = boundedString(record.id, MAX_IDENTIFIER_CHARACTERS, `workspace ${index} id`);\n  const name = boundedString(record.name, MAX_LABEL_CHARACTERS, `workspace ${index} name`);\n  if (\n    record.type !== 'indexeddb' &&\n    record.type !== 'native' &&\n    record.type !== 'electron-native'\n  ) {\n    throw new Error(`Persisted workspace ${index} has an invalid provider type.`);\n  }\n  const lastOpened = boundedString(\n    record.lastOpened,\n    MAX_IDENTIFIER_CHARACTERS,\n    `workspace ${index} lastOpened`,\n  );\n  if (\n    !Number.isFinite(Date.parse(lastOpened)) ||\n    new Date(lastOpened).toISOString() !== lastOpened\n  ) {\n    throw new Error(`Persisted workspace ${index} has an invalid lastOpened timestamp.`);\n  }\n\n  const descriptor: WorkspaceDescriptor = { id, name, type: record.type, lastOpened };\n  if (record.rootPath !== undefined) {\n    descriptor.rootPath = boundedString(\n      record.rootPath,\n      MAX_PATH_CHARACTERS,\n      `workspace ${index} rootPath`,\n    );\n  }\n  if (record.type === 'electron-native' && descriptor.rootPath === undefined) {\n    throw new Error(`Persisted Electron workspace ${index} is missing rootPath.`);\n  }\n  if (record.type !== 'electron-native' && descriptor.rootPath !== undefined) {\n    throw new Error(`Persisted workspace ${index} must not contain rootPath.`);\n  }\n  if (record.versioningOverride !== undefined) {\n    if (\n      record.versioningOverride !== 'inherit' &&\n      record.versioningOverride !== 'on' &&\n      record.versioningOverride !== 'off'\n    ) {\n      throw new Error(`Persisted workspace ${index} has an invalid versioning override.`);\n    }\n    descriptor.versioningOverride = record.versioningOverride;\n  }\n  return descriptor;\n}\n\nfunction boundedString(value: unknown, maximum: number, label: string): string {\n  if (\n    typeof value !== 'string' ||\n    value.length < 1 ||\n    value.length > maximum ||\n    value.includes('\\0')\n  ) {\n    throw new Error(`Persisted ${label} must be a bounded non-empty string.`);\n  }\n  return value;\n}\n","/**\n * WorkspaceManager — manages the list of known workspaces in IndexedDB\n * and provides helpers for creating / switching / removing them.\n *\n * The actual FileSystemProvider instances are created by the caller\n * (since native providers need a DirectoryHandle from user interaction).\n */\n\nimport {\n  RawIndexedDBFileSystemStore,\n  type IndexedDBFileSystemStore,\n  type IndexedDBFileSystemTransaction,\n} from '../filesystem/indexeddb-store.js';\nimport { getFileSystemProviderV2, type FileSystemProvider } from '../filesystem/types.js';\nimport type { WorkspaceDescriptor } from './types.js';\nimport { parsePersistedWorkspaceList } from './workspace-schema.js';\n\nconst DB_NAME = 'docblocks-workspaces';\nconst STORE_NAME = 'workspaces';\nconst LIST_KEY = 'workspace-list';\nconst DEFAULT_WORKSPACE_ID = 'default';\n\n/**\n * The registry deliberately uses the error-propagating store rather than the\n * Squisq LocalForage adapter: that adapter converts a failed read into `null`,\n * which this module cannot tell apart from \"no workspaces yet\". A single\n * transient IndexedDB failure therefore read as an empty registry, and the next\n * mutation persisted that emptiness over every workspace the user had.\n *\n * The database and object store names are unchanged, and the raw store uses the\n * same out-of-line keys LocalForage did, so existing registries load as-is.\n */\nlet registryStore: IndexedDBFileSystemStore | null = null;\n\nfunction store(): IndexedDBFileSystemStore {\n  registryStore ??= new RawIndexedDBFileSystemStore(DB_NAME, STORE_NAME);\n  return registryStore;\n}\n\n/**\n * Replace the registry's storage backend, or restore the default with `null`.\n * Mirrors the `store` option the IndexedDB providers accept; tests inject an\n * in-memory store through it and production code never calls it.\n */\nexport function setWorkspaceRegistryStore(next: IndexedDBFileSystemStore | null): void {\n  registryStore = next;\n}\n\n/**\n * Session-only transient workspaces (a loose file/`.dbk` opened from the OS,\n * or a document copied from a shared URL). Kept purely in memory — never\n * written to the persisted list — with their pre-built provider registered\n * alongside the descriptor. Lost on reload, which is the intended\n * \"transient for the app session\" behaviour.\n */\ninterface TransientEntry {\n  descriptor: WorkspaceDescriptor;\n  provider: FileSystemProvider;\n}\nconst transientWorkspaces = new Map<string, TransientEntry>();\nlet persistedMutationTail: Promise<void> = Promise.resolve();\n\n/** Register a transient workspace and its (already-built) provider. */\nexport function registerTransientWorkspace(\n  descriptor: WorkspaceDescriptor,\n  provider: FileSystemProvider,\n): void {\n  const previous = transientWorkspaces.get(descriptor.id);\n  if (previous && previous.provider !== provider) {\n    void getFileSystemProviderV2(previous.provider)?.dispose();\n  }\n  transientWorkspaces.set(descriptor.id, { descriptor, provider });\n}\n\n/** Look up a transient workspace (descriptor + provider) by id, if any. */\nexport function getTransientWorkspace(\n  id: string,\n): { descriptor: WorkspaceDescriptor; provider: FileSystemProvider } | null {\n  return transientWorkspaces.get(id) ?? null;\n}\n\n/** Forget a transient workspace (e.g. when it is closed). */\nexport async function unregisterTransientWorkspace(id: string): Promise<void> {\n  const entry = transientWorkspaces.get(id);\n  if (!entry) return;\n  transientWorkspaces.delete(id);\n  await getFileSystemProviderV2(entry.provider)?.dispose();\n}\n\n/**\n * The persisted (on-disk) workspace list only — excludes transient ones.\n *\n * An unreadable registry throws. Only a store that positively reports \"no such\n * key\" is an empty registry; anything else is an unknown registry, and callers\n * must not act as though the user has no workspaces.\n */\nasync function readPersistedIn(\n  transaction: IndexedDBFileSystemTransaction,\n): Promise<WorkspaceDescriptor[]> {\n  const list = await transaction.get<unknown>(LIST_KEY);\n  return list == null ? [] : parsePersistedWorkspaceList(list);\n}\n\nasync function readPersisted(): Promise<WorkspaceDescriptor[]> {\n  return store().transaction('readonly', readPersistedIn);\n}\n\nasync function listPersisted(): Promise<WorkspaceDescriptor[]> {\n  await persistedMutationTail;\n  return readPersisted();\n}\n\nfunction mutatePersisted(\n  mutation: (workspaces: WorkspaceDescriptor[]) => WorkspaceDescriptor[],\n): Promise<void> {\n  const operation = persistedMutationTail.then(async () => {\n    // Read and write in one transaction. A failed read aborts the mutation\n    // instead of rebuilding the registry from a phantom empty list, and no\n    // concurrent writer (another tab) can land between the read and the write\n    // only to be clobbered by this mutation's stale copy.\n    await store().transaction('readwrite', async (transaction) => {\n      const current = await readPersistedIn(transaction);\n      const next = parsePersistedWorkspaceList(mutation([...current]));\n      await transaction.put(LIST_KEY, next);\n    });\n  });\n  persistedMutationTail = operation.then(\n    () => undefined,\n    () => undefined,\n  );\n  return operation;\n}\n\n/**\n * Get all known workspace descriptors — persisted plus any session-only\n * transient ones (so they show in the picker and resolve for the session).\n */\nexport async function listWorkspaces(): Promise<WorkspaceDescriptor[]> {\n  const persisted = await listPersisted();\n  const transient = [...transientWorkspaces.values()].map((t) => t.descriptor);\n  return [...persisted, ...transient];\n}\n\n/**\n * Get a specific workspace descriptor by id (transient or persisted).\n */\nexport async function getWorkspace(id: string): Promise<WorkspaceDescriptor | null> {\n  const transient = transientWorkspaces.get(id);\n  if (transient) return transient.descriptor;\n  const list = await listPersisted();\n  return list.find((w) => w.id === id) ?? null;\n}\n\n/**\n * Add or update a workspace descriptor. If a workspace with the same id\n * already exists, it is replaced. Transient workspaces are never persisted.\n */\nexport async function saveWorkspace(workspace: WorkspaceDescriptor): Promise<void> {\n  if (workspace.type === 'transient') return;\n  const persisted = parsePersistedWorkspaceList([workspace])[0];\n  await mutatePersisted((list) => {\n    const idx = list.findIndex((candidate) => candidate.id === persisted.id);\n    if (idx >= 0) list[idx] = persisted;\n    else list.push(persisted);\n    return list;\n  });\n}\n\n/**\n * Remove a workspace descriptor by id (transient or persisted).\n */\nexport async function removeWorkspace(id: string): Promise<void> {\n  if (transientWorkspaces.has(id)) {\n    await unregisterTransientWorkspace(id);\n    return;\n  }\n  await mutatePersisted((list) => list.filter((workspace) => workspace.id !== id));\n}\n\n/**\n * Touch the lastOpened timestamp on a workspace. For transient workspaces this\n * updates the in-memory descriptor only (nothing is persisted).\n */\nexport async function touchWorkspace(id: string): Promise<void> {\n  const transient = transientWorkspaces.get(id);\n  if (transient) {\n    transient.descriptor.lastOpened = new Date().toISOString();\n    return;\n  }\n  await mutatePersisted((list) => {\n    const workspace = list.find((candidate) => candidate.id === id);\n    if (workspace) workspace.lastOpened = new Date().toISOString();\n    return list;\n  });\n}\n\n/**\n * Ensure a default IndexedDB workspace exists. Called on app startup.\n * Returns the descriptor.\n */\nexport async function ensureDefaultWorkspace(): Promise<WorkspaceDescriptor> {\n  const existing = await getWorkspace(DEFAULT_WORKSPACE_ID);\n  if (existing) return existing;\n\n  const descriptor: WorkspaceDescriptor = {\n    id: DEFAULT_WORKSPACE_ID,\n    name: 'My Documents',\n    type: 'indexeddb',\n    lastOpened: new Date().toISOString(),\n  };\n  await saveWorkspace(descriptor);\n  return descriptor;\n}\n","import type { ElectronWorkspaceInfo, HostEnvironment } from '../host/types.js';\nimport type { WorkspaceDescriptor } from './types.js';\n\nexport interface ElectronWorkspaceReconciliation {\n  /** Obsolete renderer descriptors to remove before attempting restoration. */\n  readonly removeIds: readonly string[];\n  /** Canonical main-authorized descriptors to insert or replace. */\n  readonly upsert: readonly WorkspaceDescriptor[];\n  /** Safe navigation migration for a local descriptor matched by root. */\n  readonly idRemap: Readonly<Record<string, string>>;\n}\n\nfunction comparableRoot(rootPath: string, platform: HostEnvironment['platform']): string {\n  const normalized = rootPath.replace(/\\\\/gu, '/').replace(/\\/+$/gu, '');\n  return platform === 'win32' ? normalized.toLowerCase() : normalized;\n}\n\n/**\n * Reconcile renderer IndexedDB metadata with the main process authority list.\n * `hostWorkspaces` is authoritative: local Electron descriptors absent from\n * it cannot be opened safely and are removed. Root-path matching carries user\n * metadata across an id migration without treating that display path as\n * authority.\n */\nexport function reconcileElectronWorkspaceDescriptors(\n  local: readonly WorkspaceDescriptor[],\n  hostWorkspaces: readonly ElectronWorkspaceInfo[],\n  platform: HostEnvironment['platform'],\n  now: string,\n): ElectronWorkspaceReconciliation {\n  const electron = local.filter((workspace) => workspace.type === 'electron-native');\n  const matchedLocalIds = new Set<string>();\n  const idRemap: Record<string, string> = {};\n  const upsert = hostWorkspaces.map((hostWorkspace): WorkspaceDescriptor => {\n    const root = comparableRoot(hostWorkspace.rootPath, platform);\n    const candidates = electron.filter(\n      (workspace) => workspace.rootPath && comparableRoot(workspace.rootPath, platform) === root,\n    );\n    const matching = candidates.sort((left, right) =>\n      right.lastOpened.localeCompare(left.lastOpened),\n    )[0];\n    if (matching) {\n      matchedLocalIds.add(matching.id);\n      if (matching.id !== hostWorkspace.id) idRemap[matching.id] = hostWorkspace.id;\n    }\n    return {\n      id: hostWorkspace.id,\n      name: matching?.name ?? hostWorkspace.name,\n      type: 'electron-native',\n      rootPath: hostWorkspace.rootPath,\n      lastOpened: matching?.lastOpened ?? now,\n      ...(matching?.versioningOverride ? { versioningOverride: matching.versioningOverride } : {}),\n    };\n  });\n  const canonicalIds = new Set(hostWorkspaces.map((workspace) => workspace.id));\n  const removeIds = electron\n    .filter(\n      (workspace) =>\n        !canonicalIds.has(workspace.id) ||\n        (matchedLocalIds.has(workspace.id) &&\n          !upsert.some((candidate) => candidate.id === workspace.id)),\n    )\n    .map((workspace) => workspace.id);\n  return { removeIds, upsert, idRemap };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-P4WATND4.js

@@ -0,0 +1,52 @@
+// src/filesystem/v2.ts
+function parseFileSystemVersion(value) {
+  if (typeof value !== "string" || !value || value.length > 1024 || value.includes("\0")) {
+    throw new TypeError("Filesystem version tokens must be non-empty bounded strings.");
+  }
+  return value;
+}
+function tryParseFileSystemVersion(value) {
+  try {
+    return parseFileSystemVersion(value);
+  } catch {
+    return null;
+  }
+}
+
+// src/filesystem/internal/bytes.ts
+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 bytesEqual(left, right) {
+  const leftBytes = ArrayBuffer.isView(left) ? new Uint8Array(left.buffer, left.byteOffset, left.byteLength) : new Uint8Array(left);
+  const rightBytes = ArrayBuffer.isView(right) ? new Uint8Array(right.buffer, right.byteOffset, right.byteLength) : new Uint8Array(right);
+  if (leftBytes.byteLength !== rightBytes.byteLength) return false;
+  return leftBytes.every((byte, index) => byte === rightBytes[index]);
+}
+
+// src/filesystem/internal/entry-order.ts
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareSnapshotsByName(left, right) {
+  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
+  return compareText(left.name, right.name);
+}
+function compareSnapshotsByPath(left, right) {
+  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
+  return compareText(left.path, right.path);
+}
+
+export {
+  parseFileSystemVersion,
+  tryParseFileSystemVersion,
+  copyBytes,
+  bytesEqual,
+  compareText,
+  compareSnapshotsByName,
+  compareSnapshotsByPath
+};
+//# sourceMappingURL=chunk-P4WATND4.js.map

package/dist/chunk-P4WATND4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filesystem/v2.ts","../src/filesystem/internal/bytes.ts","../src/filesystem/internal/entry-order.ts"],"sourcesContent":["import type { FsError } from './fs-error.js';\nimport type { WorkspacePath } from './workspace-path.js';\n\n/**\n * Opaque provider-issued token representing one observed entry/tree state.\n * Tokens support equality only within the issuing provider; callers must not\n * parse them or assume a move or byte-identical rewrite changes the token.\n * A token need not be a content hash, but it must change whenever the issuing\n * provider observes a potentially different kind, payload, or descendant\n * state. Detection of non-cooperating external changes is bounded by the\n * backend's declared capabilities and metadata precision.\n */\ndeclare const fileSystemVersionBrand: unique symbol;\nexport type FileSystemVersion = string & {\n  readonly [fileSystemVersionBrand]: 'FileSystemVersion';\n};\n\n/** Validate/rebrand a version received from a provider transport. */\nexport function parseFileSystemVersion(value: unknown): FileSystemVersion {\n  if (typeof value !== 'string' || !value || value.length > 1024 || value.includes('\\0')) {\n    throw new TypeError('Filesystem version tokens must be non-empty bounded strings.');\n  }\n  return value as FileSystemVersion;\n}\n\nexport function tryParseFileSystemVersion(value: unknown): FileSystemVersion | null {\n  try {\n    return parseFileSystemVersion(value);\n  } catch {\n    return null;\n  }\n}\n\n/** `process` excludes this provider's local peers; `cross-context` also excludes cooperating tabs/processes. */\nexport type FileSystemAtomicity = 'none' | 'process' | 'cross-context';\nexport type FileSystemCaseSensitivity = 'sensitive' | 'insensitive' | 'platform';\nexport type FileSystemDurability = 'volatile' | 'best-effort' | 'durable';\nexport type FileSystemConditionalWriteStrength =\n  | 'none'\n  | 'process'\n  | 'cross-context'\n  | 'storage-atomic';\nexport type FileSystemSymlinkPolicy = 'unsupported' | 'reject' | 'follow-contained' | 'preserve';\n\n/** Serializable feature declaration; consumers never need provider instanceof checks. */\nexport interface FileSystemProviderCapabilities {\n  /** Isolation of one successful file replacement from cooperating writers. */\n  readonly writeAtomicity: FileSystemAtomicity;\n  /** Isolation of one successful source-to-destination move. */\n  readonly moveAtomicity: FileSystemAtomicity;\n  /** Writers excluded while one complete snapshot is captured. */\n  readonly snapshotAtomicity: FileSystemAtomicity;\n  /** Strongest boundary at which expectedVersion is checked with mutation. */\n  readonly conditionalWrite: FileSystemConditionalWriteStrength;\n  readonly recursiveRemove: boolean;\n  /** True only when watch has a real ready barrier and sequenced events. */\n  readonly watch: boolean;\n  readonly caseSensitivity: FileSystemCaseSensitivity;\n  readonly symlinkPolicy: FileSystemSymlinkPolicy;\n  readonly durability: FileSystemDurability;\n}\n\ninterface FileSystemEntrySnapshotBase {\n  readonly path: WorkspacePath;\n  readonly name: string;\n  readonly version: FileSystemVersion;\n  /** ISO-8601 timestamp supplied by the backend; versions remain authoritative. */\n  readonly lastModified: string;\n}\n\nexport interface FileSystemFileSnapshot extends FileSystemEntrySnapshotBase {\n  readonly kind: 'file';\n  readonly size: number;\n}\n\nexport interface FileSystemDirectorySnapshot extends FileSystemEntrySnapshotBase {\n  readonly kind: 'directory';\n  readonly size: null;\n}\n\nexport type FileSystemEntrySnapshot = FileSystemFileSnapshot | FileSystemDirectorySnapshot;\n\n/** A read always couples owned bytes to the exact metadata version they represent. */\nexport interface FileSystemFileRead {\n  readonly entry: FileSystemFileSnapshot;\n  readonly data: ArrayBuffer;\n}\n\nexport interface FileSystemSnapshotFile extends FileSystemFileSnapshot {\n  readonly data: ArrayBuffer;\n}\n\nexport type FileSystemSnapshotEntry = FileSystemSnapshotFile | FileSystemDirectorySnapshot;\n\n/**\n * Complete best-available tree traversal. `snapshotAtomicity` declares\n * whether concurrent local/cross-context mutations are excluded while it is\n * captured. Implementations must never expose aliased buffers.\n */\nexport interface FileSystemSnapshot {\n  readonly version: FileSystemVersion;\n  readonly entries: readonly FileSystemSnapshotEntry[];\n}\n\nexport type FileSystemWriteMode = 'upsert' | 'create' | 'replace';\n\nexport interface FileSystemWriteOptions {\n  /** Defaults to upsert. */\n  readonly mode?: FileSystemWriteMode;\n  /** Defaults to false so structure creation is never implicit. */\n  readonly createParents?: boolean;\n  /** null means the entry must not exist; a token requires an exact match. */\n  readonly expectedVersion?: FileSystemVersion | null;\n}\n\nexport type FileSystemCreateDirectoryMode = 'ensure' | 'create';\n\nexport interface FileSystemCreateDirectoryOptions {\n  /** Defaults to ensure (idempotently return an existing directory). */\n  readonly mode?: FileSystemCreateDirectoryMode;\n  /** Defaults to false. */\n  readonly createParents?: boolean;\n}\n\nexport interface FileSystemRemoveOptions {\n  /** Defaults to false; non-empty directories otherwise fail with not-empty. */\n  readonly recursive?: boolean;\n  /** Defaults to error. */\n  readonly missing?: 'ignore' | 'error';\n  readonly expectedVersion?: FileSystemVersion;\n}\n\nexport interface FileSystemRemoveResult {\n  readonly removed: boolean;\n  /** Version of the complete tree after the removal attempt. */\n  readonly version: FileSystemVersion;\n}\n\nexport interface FileSystemMoveOptions {\n  /** Defaults to false. Destinations are never overwritten. */\n  readonly createParents?: boolean;\n  readonly expectedVersion?: FileSystemVersion;\n}\n\nexport type FileSystemWatchEventType = 'created' | 'modified' | 'removed' | 'moved' | 'overflow';\nexport type FileSystemWatchEventOrigin = 'local' | 'external' | 'unknown';\n\ninterface FileSystemWatchEventBase {\n  readonly sequence: number;\n  readonly origin: FileSystemWatchEventOrigin;\n  readonly path: WorkspacePath;\n}\n\nexport interface FileSystemEntryWatchEvent extends FileSystemWatchEventBase {\n  readonly type: Exclude<FileSystemWatchEventType, 'overflow'>;\n  readonly kind: 'file' | 'directory';\n  readonly destinationPath: WorkspacePath | null;\n  readonly version: FileSystemVersion | null;\n  readonly previousVersion: FileSystemVersion | null;\n}\n\nexport interface FileSystemOverflowWatchEvent extends FileSystemWatchEventBase {\n  readonly type: 'overflow';\n  readonly kind: null;\n  readonly destinationPath: null;\n  readonly version: null;\n  readonly previousVersion: null;\n}\n\nexport type FileSystemWatchEvent = FileSystemEntryWatchEvent | FileSystemOverflowWatchEvent;\n\nexport type FileSystemWatchListener = (event: FileSystemWatchEvent) => void;\nexport type FileSystemWatchErrorListener = (error: FsError) => void;\n\nexport interface FileSystemWatchOptions {\n  readonly onError?: FileSystemWatchErrorListener;\n}\n\nexport interface FileSystemWatchSubscription {\n  readonly closed: boolean;\n  /** Resolves after the backend watch is installed and no initial event can be missed. */\n  readonly ready: Promise<void>;\n  /** Idempotent and awaitable so resource release can join provider shutdown. */\n  dispose(): Promise<void>;\n}\n\n/**\n * Correctness-first filesystem contract. Every logical path has exactly one\n * kind and one byte payload; conditional writes and lifecycle disposal are\n * mandatory rather than optional provider extensions.\n */\nexport interface FileSystemProviderV2 {\n  readonly id: string;\n  readonly label: string;\n  readonly capabilities: FileSystemProviderCapabilities;\n\n  /** Absence is represented only by null; permission/I/O/wrong-kind errors throw FsError. */\n  stat(path: WorkspacePath): Promise<FileSystemEntrySnapshot | null>;\n  /** Absence is represented only by null; a directory at path is type-mismatch. */\n  readFile(path: WorkspacePath): Promise<FileSystemFileRead | null>;\n  /** Missing paths and file paths throw; results are canonical and deterministic. */\n  readDirectory(path: WorkspacePath): Promise<readonly FileSystemEntrySnapshot[]>;\n\n  writeFile(\n    path: WorkspacePath,\n    data: ArrayBuffer | Uint8Array,\n    options?: FileSystemWriteOptions,\n  ): Promise<FileSystemFileSnapshot>;\n  createDirectory(\n    path: WorkspacePath,\n    options?: FileSystemCreateDirectoryOptions,\n  ): Promise<FileSystemDirectorySnapshot>;\n  remove(path: WorkspacePath, options?: FileSystemRemoveOptions): Promise<FileSystemRemoveResult>;\n  move(\n    oldPath: WorkspacePath,\n    newPath: WorkspacePath,\n    options?: FileSystemMoveOptions,\n  ): Promise<FileSystemEntrySnapshot>;\n\n  snapshot(): Promise<FileSystemSnapshot>;\n  /**\n   * Always returns a disposable subscription. When `capabilities.watch` is\n   * false, `ready` rejects with `FsError('not-supported')` and `onError`\n   * observes the same failure; callers can therefore use one cleanup path.\n   */\n  watch(\n    listener: FileSystemWatchListener,\n    options?: FileSystemWatchOptions,\n  ): FileSystemWatchSubscription;\n  dispose(): Promise<void>;\n}\n","/**\n * Byte helpers shared by every filesystem provider.\n *\n * Providers own their stored buffers, so every value that crosses the provider\n * boundary is copied rather than aliased. Keeping one implementation here stops\n * the copy semantics (notably: honouring a view's byteOffset/byteLength instead\n * of its whole backing buffer) from drifting between backends.\n */\n\n/** Copy only the visible bytes of a buffer or view into a fresh ArrayBuffer. */\nexport function copyBytes(data: ArrayBuffer | Uint8Array): ArrayBuffer {\n  const source = ArrayBuffer.isView(data)\n    ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)\n    : new Uint8Array(data);\n  const copy = new Uint8Array(source.byteLength);\n  copy.set(source);\n  return copy.buffer as ArrayBuffer;\n}\n\n/** Compare the visible bytes of two buffers or views for exact equality. */\nexport function bytesEqual(\n  left: ArrayBuffer | Uint8Array,\n  right: ArrayBuffer | Uint8Array,\n): boolean {\n  const leftBytes = ArrayBuffer.isView(left)\n    ? new Uint8Array(left.buffer, left.byteOffset, left.byteLength)\n    : new Uint8Array(left);\n  const rightBytes = ArrayBuffer.isView(right)\n    ? new Uint8Array(right.buffer, right.byteOffset, right.byteLength)\n    : new Uint8Array(right);\n  if (leftBytes.byteLength !== rightBytes.byteLength) return false;\n  return leftBytes.every((byte, index) => byte === rightBytes[index]);\n}\n","/**\n * Deterministic listing order shared by every filesystem provider.\n *\n * Providers must return byte-stable orderings so snapshots can be compared\n * across backends and across runs. `compareText` is deliberately a raw code\n * unit comparison rather than `localeCompare`, which is locale-dependent.\n */\n\nimport type { FileSystemEntrySnapshot } from '../v2.js';\n\n/** Locale-independent, deterministic string ordering. */\nexport function compareText(left: string, right: string): number {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n\n/** Directory-first, then by entry name. Used for sibling listings. */\nexport function compareSnapshotsByName(\n  left: FileSystemEntrySnapshot,\n  right: FileSystemEntrySnapshot,\n): number {\n  if (left.kind !== right.kind) return left.kind === 'directory' ? -1 : 1;\n  return compareText(left.name, right.name);\n}\n\n/**\n * Directory-first, then by full path.\n *\n * Equivalent to `compareSnapshotsByName` for siblings, and used where entries\n * may not share a parent — the Electron transport re-sorts host-supplied\n * listings defensively and cannot assume a single directory's children.\n */\nexport function compareSnapshotsByPath(\n  left: FileSystemEntrySnapshot,\n  right: FileSystemEntrySnapshot,\n): number {\n  if (left.kind !== right.kind) return left.kind === 'directory' ? -1 : 1;\n  return compareText(left.path, right.path);\n}\n"],"mappings":";AAkBO,SAAS,uBAAuB,OAAmC;AACxE,MAAI,OAAO,UAAU,YAAY,CAAC,SAAS,MAAM,SAAS,QAAQ,MAAM,SAAS,IAAI,GAAG;AACtF,UAAM,IAAI,UAAU,8DAA8D;AAAA,EACpF;AACA,SAAO;AACT;AAEO,SAAS,0BAA0B,OAA0C;AAClF,MAAI;AACF,WAAO,uBAAuB,KAAK;AAAA,EACrC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;;;ACrBO,SAAS,UAAU,MAA6C;AACrE,QAAM,SAAS,YAAY,OAAO,IAAI,IAClC,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU,IAC5D,IAAI,WAAW,IAAI;AACvB,QAAM,OAAO,IAAI,WAAW,OAAO,UAAU;AAC7C,OAAK,IAAI,MAAM;AACf,SAAO,KAAK;AACd;AAGO,SAAS,WACd,MACA,OACS;AACT,QAAM,YAAY,YAAY,OAAO,IAAI,IACrC,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU,IAC5D,IAAI,WAAW,IAAI;AACvB,QAAM,aAAa,YAAY,OAAO,KAAK,IACvC,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU,IAC/D,IAAI,WAAW,KAAK;AACxB,MAAI,UAAU,eAAe,WAAW,WAAY,QAAO;AAC3D,SAAO,UAAU,MAAM,CAAC,MAAM,UAAU,SAAS,WAAW,KAAK,CAAC;AACpE;;;ACrBO,SAAS,YAAY,MAAc,OAAuB;AAC/D,SAAO,OAAO,QAAQ,KAAK,OAAO,QAAQ,IAAI;AAChD;AAGO,SAAS,uBACd,MACA,OACQ;AACR,MAAI,KAAK,SAAS,MAAM,KAAM,QAAO,KAAK,SAAS,cAAc,KAAK;AACtE,SAAO,YAAY,KAAK,MAAM,MAAM,IAAI;AAC1C;AASO,SAAS,uBACd,MACA,OACQ;AACR,MAAI,KAAK,SAAS,MAAM,KAAM,QAAO,KAAK,SAAS,cAAc,KAAK;AACtE,SAAO,YAAY,KAAK,MAAM,MAAM,IAAI;AAC1C;","names":[]}

package/dist/chunk-RVPGQBWR.js

@@ -0,0 +1,169 @@
+// src/filesystem/indexeddb-store.ts
+function indexedDBWorkspaceDatabaseName(workspaceId) {
+  return `docblocks-fs-${workspaceId}`;
+}
+function deleteIndexedDBDatabase(databaseName) {
+  if (typeof indexedDB === "undefined") {
+    return Promise.reject(new Error("IndexedDB is not available in this environment."));
+  }
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.deleteDatabase(databaseName);
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject(request.error ?? new Error(`Failed to delete the "${databaseName}" database.`));
+  });
+}
+function deleteIndexedDBWorkspaceData(workspaceId) {
+  return deleteIndexedDBDatabase(indexedDBWorkspaceDatabaseName(workspaceId));
+}
+var RawIndexedDBFileSystemStore = class {
+  constructor(databaseName, storeName) {
+    this.databaseName = databaseName;
+    this.storeName = storeName;
+    this.database = null;
+    this.opening = null;
+    this.closed = false;
+  }
+  async transaction(mode, operation) {
+    const database = await this.getDatabase();
+    const nativeTransaction = database.transaction(this.storeName, mode);
+    const completion = waitForTransaction(nativeTransaction);
+    const transaction = new RawIndexedDBFileSystemTransaction(
+      nativeTransaction.objectStore(this.storeName)
+    );
+    let result;
+    try {
+      result = await operation(transaction);
+    } catch (error) {
+      try {
+        nativeTransaction.abort();
+      } catch {
+      }
+      await completion.catch(() => void 0);
+      throw error;
+    }
+    await completion;
+    return result;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.database?.close();
+    this.database = null;
+    this.opening = null;
+  }
+  getDatabase() {
+    if (this.closed) {
+      return Promise.reject(new Error("The IndexedDB filesystem store is closed."));
+    }
+    if (this.database) return Promise.resolve(this.database);
+    if (this.opening) return this.opening;
+    if (typeof indexedDB === "undefined") {
+      return Promise.reject(new Error("IndexedDB is not available in this environment."));
+    }
+    this.opening = openDatabaseWithStore(this.databaseName, this.storeName).then((database) => {
+      if (this.closed) {
+        database.close();
+        throw new Error("The IndexedDB filesystem store is closed.");
+      }
+      this.database = database;
+      this.opening = null;
+      database.onversionchange = () => {
+        database.close();
+        if (this.database === database) this.database = null;
+      };
+      return database;
+    }).catch((error) => {
+      this.opening = null;
+      throw error;
+    });
+    return this.opening;
+  }
+};
+var RawIndexedDBFileSystemTransaction = class {
+  constructor(store) {
+    this.store = store;
+  }
+  async get(key) {
+    const value = await requestResult(this.store.get(key));
+    return value === void 0 ? null : value;
+  }
+  async put(key, value) {
+    await requestResult(this.store.put(value, key));
+  }
+  async delete(key) {
+    await requestResult(this.store.delete(key));
+  }
+  async keys() {
+    const keys = await requestResult(this.store.getAllKeys());
+    return keys.map((key) => {
+      if (typeof key !== "string") {
+        throw new Error("The DocBlocks filesystem store contains a non-string key.");
+      }
+      return key;
+    });
+  }
+  async hasKeyWithPrefix(prefix) {
+    const cursor = await requestResult(this.store.openKeyCursor(IDBKeyRange.lowerBound(prefix)));
+    return cursor !== null && typeof cursor.key === "string" && cursor.key.startsWith(prefix);
+  }
+};
+async function openDatabaseWithStore(databaseName, storeName) {
+  const database = await openDatabase(databaseName, void 0, (upgradeDatabase) => {
+    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {
+      upgradeDatabase.createObjectStore(storeName);
+    }
+  });
+  if (database.objectStoreNames.contains(storeName)) return database;
+  const nextVersion = database.version + 1;
+  database.close();
+  return openDatabase(databaseName, nextVersion, (upgradeDatabase) => {
+    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {
+      upgradeDatabase.createObjectStore(storeName);
+    }
+  });
+}
+function openDatabase(databaseName, version, upgrade) {
+  return new Promise((resolve, reject) => {
+    const request = version === void 0 ? indexedDB.open(databaseName) : indexedDB.open(databaseName, version);
+    let settled = false;
+    request.onupgradeneeded = () => upgrade(request.result);
+    request.onsuccess = () => {
+      if (settled) {
+        request.result.close();
+        return;
+      }
+      settled = true;
+      resolve(request.result);
+    };
+    request.onerror = () => {
+      if (settled) return;
+      settled = true;
+      reject(request.error ?? new Error(`Could not open IndexedDB database ${databaseName}.`));
+    };
+    request.onblocked = () => {
+      if (settled) return;
+      settled = true;
+      reject(new Error(`IndexedDB database ${databaseName} is blocked by another open page.`));
+    };
+  });
+}
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed."));
+  });
+}
+function waitForTransaction(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction was aborted."));
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed."));
+  });
+}
+
+export {
+  indexedDBWorkspaceDatabaseName,
+  deleteIndexedDBWorkspaceData,
+  RawIndexedDBFileSystemStore
+};
+//# sourceMappingURL=chunk-RVPGQBWR.js.map