@bendyline/docblocks 2.0.0 → 2.1.0

package/dist/chunk-JS6XFWQK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filesystem/fs-error.ts","../src/filesystem/workspace-path.ts"],"sourcesContent":["/** Stable error codes shared by every filesystem transport and backend. */\nexport type FsErrorCode =\n  | 'invalid-path'\n  | 'path-escape'\n  | 'not-found'\n  | 'already-exists'\n  | 'type-mismatch'\n  | 'not-empty'\n  | 'permission-denied'\n  | 'conflict'\n  | 'corrupt'\n  | 'quota-exceeded'\n  | 'not-supported'\n  | 'busy'\n  | 'disposed'\n  | 'closed'\n  | 'aborted'\n  | 'io';\n\nexport type FsOperation =\n  | 'parse-path'\n  | 'read'\n  | 'stat'\n  | 'list'\n  | 'write'\n  | 'create-directory'\n  | 'remove'\n  | 'move'\n  | 'snapshot'\n  | 'watch'\n  | 'dispose';\n\n/** Plain-data form safe to send over IPC, postMessage, or JSON. */\nexport interface SerializedFsError {\n  readonly name: 'FsError';\n  readonly code: FsErrorCode;\n  readonly message: string;\n  readonly operation: FsOperation | null;\n  readonly path: string | null;\n  readonly destinationPath: string | null;\n  readonly retryable: boolean;\n}\n\nexport interface FsErrorContext {\n  readonly operation?: FsOperation;\n  readonly path?: string;\n  readonly destinationPath?: string;\n  readonly retryable?: boolean;\n  readonly defaultCode?: FsErrorCode;\n}\n\nconst FS_ERROR_CODES: ReadonlySet<string> = new Set<FsErrorCode>([\n  'invalid-path',\n  'path-escape',\n  'not-found',\n  'already-exists',\n  'type-mismatch',\n  'not-empty',\n  'permission-denied',\n  'conflict',\n  'corrupt',\n  'quota-exceeded',\n  'not-supported',\n  'busy',\n  'disposed',\n  'closed',\n  'aborted',\n  'io',\n]);\n\nconst FS_OPERATIONS: ReadonlySet<string> = new Set<FsOperation>([\n  'parse-path',\n  'read',\n  'stat',\n  'list',\n  'write',\n  'create-directory',\n  'remove',\n  'move',\n  'snapshot',\n  'watch',\n  'dispose',\n]);\n\n/** Error with a stable code and a deliberately serializable public shape. */\nexport class FsError extends Error {\n  public readonly code: FsErrorCode;\n  public readonly operation: FsOperation | null;\n  public readonly path: string | null;\n  public readonly destinationPath: string | null;\n  public readonly retryable: boolean;\n\n  public constructor(code: FsErrorCode, message: string, context: FsErrorContext = {}) {\n    super(message);\n    this.name = 'FsError';\n    this.code = code;\n    this.operation = context.operation ?? null;\n    this.path = context.path ?? null;\n    this.destinationPath = context.destinationPath ?? null;\n    this.retryable = context.retryable ?? (code === 'io' || code === 'aborted' || code === 'busy');\n  }\n\n  public toJSON(): SerializedFsError {\n    return {\n      name: 'FsError',\n      code: this.code,\n      message: this.message,\n      operation: this.operation,\n      path: this.path,\n      destinationPath: this.destinationPath,\n      retryable: this.retryable,\n    };\n  }\n}\n\nexport function mapDomExceptionToFsErrorCode(name: string): FsErrorCode {\n  switch (name) {\n    case 'NotFoundError':\n      return 'not-found';\n    case 'ConstraintError':\n      return 'already-exists';\n    case 'TypeMismatchError':\n      return 'type-mismatch';\n    case 'InvalidModificationError':\n      return 'not-empty';\n    case 'NotAllowedError':\n    case 'SecurityError':\n    case 'NoModificationAllowedError':\n      return 'permission-denied';\n    case 'QuotaExceededError':\n      return 'quota-exceeded';\n    case 'NotSupportedError':\n      return 'not-supported';\n    case 'InvalidStateError':\n      return 'disposed';\n    case 'AbortError':\n      return 'aborted';\n    default:\n      return 'io';\n  }\n}\n\nexport function mapNodeErrorCodeToFsErrorCode(code: string): FsErrorCode {\n  switch (code) {\n    case 'ENOENT':\n      return 'not-found';\n    case 'ENOTDIR':\n      return 'type-mismatch';\n    case 'EEXIST':\n      return 'already-exists';\n    case 'EISDIR':\n      return 'type-mismatch';\n    case 'ENOTEMPTY':\n      return 'not-empty';\n    case 'EACCES':\n    case 'EPERM':\n      return 'permission-denied';\n    case 'ENOSPC':\n    case 'EDQUOT':\n      return 'quota-exceeded';\n    case 'EBUSY':\n      return 'busy';\n    case 'EXDEV':\n    case 'ENOTSUP':\n    case 'EOPNOTSUPP':\n      return 'not-supported';\n    default:\n      return 'io';\n  }\n}\n\nexport function isSerializedFsError(value: unknown): value is SerializedFsError {\n  if (!value || typeof value !== 'object') return false;\n  const candidate = value as Partial<Record<keyof SerializedFsError, unknown>>;\n  return (\n    candidate.name === 'FsError' &&\n    typeof candidate.code === 'string' &&\n    FS_ERROR_CODES.has(candidate.code) &&\n    typeof candidate.message === 'string' &&\n    (candidate.operation === null ||\n      (typeof candidate.operation === 'string' && FS_OPERATIONS.has(candidate.operation))) &&\n    (candidate.path === null || typeof candidate.path === 'string') &&\n    (candidate.destinationPath === null || typeof candidate.destinationPath === 'string') &&\n    typeof candidate.retryable === 'boolean'\n  );\n}\n\nexport function deserializeFsError(value: SerializedFsError): FsError {\n  return new FsError(value.code, value.message, {\n    operation: value.operation ?? undefined,\n    path: value.path ?? undefined,\n    destinationPath: value.destinationPath ?? undefined,\n    retryable: value.retryable,\n  });\n}\n\nexport function fsErrorFromUnknown(error: unknown, context: FsErrorContext = {}): FsError {\n  if (error instanceof FsError) return error;\n  if (isSerializedFsError(error)) return deserializeFsError(error);\n\n  const name = getErrorStringField(error, 'name');\n  const nodeCode = getErrorStringField(error, 'code');\n  const message = getErrorStringField(error, 'message') ?? String(error);\n  const code =\n    context.defaultCode ??\n    (nodeCode\n      ? mapNodeErrorCodeToFsErrorCode(nodeCode)\n      : name\n        ? mapDomExceptionToFsErrorCode(name)\n        : 'io');\n  return new FsError(code, message, context);\n}\n\nexport function serializeFsError(error: unknown, context: FsErrorContext = {}): SerializedFsError {\n  return fsErrorFromUnknown(error, context).toJSON();\n}\n\n/**\n * True when a storage backend rejected an operation because the origin or\n * device is out of space. Covers typed `FsError`s (`'quota-exceeded'`, from\n * DOMException `QuotaExceededError` or Node `ENOSPC`/`EDQUOT`), serialized\n * transport copies, and raw DOMExceptions from backends that do not wrap\n * their errors (e.g. the File System Access API) — including cross-realm\n * instances where `instanceof DOMException` would fail.\n */\nexport function isQuotaExceededError(error: unknown): boolean {\n  if (error instanceof FsError) return error.code === 'quota-exceeded';\n  if (isSerializedFsError(error)) return error.code === 'quota-exceeded';\n  return getErrorStringField(error, 'name') === 'QuotaExceededError';\n}\n\nfunction getErrorStringField(error: unknown, key: 'name' | 'message' | 'code'): string | null {\n  if (!error || typeof error !== 'object') return null;\n  const value = (error as Record<string, unknown>)[key];\n  return typeof value === 'string' ? value : null;\n}\n","import { FsError } from './fs-error.js';\n\ndeclare const workspacePathBrand: unique symbol;\n\n/** Canonical, root-relative, forward-slash path within one workspace. */\nexport type WorkspacePath = string & { readonly [workspacePathBrand]: 'WorkspacePath' };\n\nexport const WORKSPACE_ROOT = '' as WorkspacePath;\n\n/**\n * Parse a legacy/user path into its one canonical workspace representation.\n * Leading/trailing and repeated separators are normalized; traversal and NUL\n * segments are rejected rather than resolved.\n */\nexport function parseWorkspacePath(input: string): WorkspacePath {\n  if (\n    [...input].some((character) => {\n      const codePoint = character.codePointAt(0) ?? 0;\n      return codePoint <= 0x1f || codePoint === 0x7f;\n    })\n  ) {\n    throw invalidPath(input, 'Workspace paths must not contain NUL or other control characters.');\n  }\n  if (/^[a-zA-Z]:/u.test(input)) {\n    throw new FsError('path-escape', 'Workspace paths must not be OS drive-qualified paths.', {\n      operation: 'parse-path',\n      path: input,\n    });\n  }\n\n  const normalized = input\n    .replace(/\\\\/g, '/')\n    .replace(/\\/+/g, '/')\n    .replace(/^\\/|\\/$/g, '');\n  if (!normalized) return WORKSPACE_ROOT;\n\n  const segments = normalized.split('/');\n  if (segments.some((segment) => segment === '.' || segment === '..')) {\n    throw new FsError('path-escape', 'Workspace paths must not contain \".\" or \"..\" segments.', {\n      operation: 'parse-path',\n      path: input,\n    });\n  }\n  return normalized as WorkspacePath;\n}\n\nexport function tryParseWorkspacePath(input: unknown): WorkspacePath | null {\n  if (typeof input !== 'string') return null;\n  try {\n    return parseWorkspacePath(input);\n  } catch {\n    return null;\n  }\n}\n\n/** Convert a canonical path to the slash-prefixed form accepted by v1 providers. */\nexport function workspacePathToLegacy(path: WorkspacePath): string {\n  return path ? `/${path}` : '/';\n}\n\nexport function workspacePathJoin(parent: WorkspacePath, child: string): WorkspacePath {\n  const childPath = parseWorkspacePath(child);\n  if (!parent) return childPath;\n  if (!childPath) return parent;\n  return parseWorkspacePath(`${parent}/${childPath}`);\n}\n\nexport function workspacePathDirname(path: WorkspacePath): WorkspacePath {\n  if (!path) return WORKSPACE_ROOT;\n  const slash = path.lastIndexOf('/');\n  return slash < 0 ? WORKSPACE_ROOT : (path.slice(0, slash) as WorkspacePath);\n}\n\nexport function workspacePathBasename(path: WorkspacePath): string {\n  if (!path) return '';\n  const slash = path.lastIndexOf('/');\n  return slash < 0 ? path : path.slice(slash + 1);\n}\n\nexport function workspacePathContains(\n  parent: WorkspacePath,\n  candidate: WorkspacePath,\n  inclusive = true,\n): boolean {\n  if (parent === candidate) return inclusive;\n  if (!parent) return candidate !== WORKSPACE_ROOT;\n  return candidate.startsWith(`${parent}/`);\n}\n\nfunction invalidPath(path: string, message: string): FsError {\n  return new FsError('invalid-path', message, { operation: 'parse-path', path });\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-EGNDADXB.js → chunk-MNSZ7EZN.js}

@@ -1,6 +1,6 @@
 import {
   parseWorkspacePath
-} from "./chunk-SI2LU2RP.js";
+} from "./chunk-JS6XFWQK.js";
 import {
   getFileSystemProviderV2
 } from "./chunk-EZKJZUNJ.js";
@@ -108,4 +108,4 @@ export {
   describePartialMove,
   describeEntryMove
 };
-//# sourceMappingURL=chunk-EGNDADXB.js.map
+//# sourceMappingURL=chunk-MNSZ7EZN.js.map

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

package/dist/chunk-RVPGQBWR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filesystem/indexeddb-store.ts"],"sourcesContent":["/**\n * Minimal, error-propagating IndexedDB store used by the virtual filesystem.\n *\n * The previous Squisq LocalForage adapter intentionally converted failed\n * reads/enumerations/removals into null/empty/success. Those semantics are\n * unsuitable for filesystem mutations: an unavailable database must never be\n * interpreted as an absent file. This layer opens the old database and object\n * store directly so existing data can be migrated in one transaction.\n */\n\nexport type IndexedDBFileSystemTransactionMode = 'readonly' | 'readwrite';\n\n/** The database holding one browser-local workspace's files. */\nexport function indexedDBWorkspaceDatabaseName(workspaceId: string): string {\n  return `docblocks-fs-${workspaceId}`;\n}\n\n/**\n * Delete a database and everything in it.\n *\n * Open connections do not have to be closed first: deletion fires\n * `versionchange` on them, and this module's connections close themselves in\n * response, after which the deletion proceeds. A `blocked` event is therefore\n * transient (an in-flight transaction) and is deliberately not treated as a\n * failure — the deletion still completes once that transaction finishes.\n */\nexport function deleteIndexedDBDatabase(databaseName: string): Promise<void> {\n  if (typeof indexedDB === 'undefined') {\n    return Promise.reject(new Error('IndexedDB is not available in this environment.'));\n  }\n  return new Promise((resolve, reject) => {\n    const request = indexedDB.deleteDatabase(databaseName);\n    request.onsuccess = () => resolve();\n    request.onerror = () =>\n      reject(request.error ?? new Error(`Failed to delete the \"${databaseName}\" database.`));\n  });\n}\n\n/**\n * Delete a browser-local workspace's stored files.\n *\n * Removing a workspace descriptor alone leaves these bytes behind: invisible to\n * the user, still counted against the origin's quota, and ready to reappear\n * under any later workspace that reuses the same id.\n */\nexport function deleteIndexedDBWorkspaceData(workspaceId: string): Promise<void> {\n  return deleteIndexedDBDatabase(indexedDBWorkspaceDatabaseName(workspaceId));\n}\n\nexport interface IndexedDBFileSystemTransaction {\n  get<T>(key: string): Promise<T | null>;\n  put<T>(key: string, value: T): Promise<void>;\n  delete(key: string): Promise<void>;\n  keys(): Promise<string[]>;\n  /** O(log n) namespace probe in the concrete IndexedDB implementation. */\n  hasKeyWithPrefix(prefix: string): Promise<boolean>;\n}\n\nexport interface IndexedDBFileSystemStore {\n  transaction<T>(\n    mode: IndexedDBFileSystemTransactionMode,\n    operation: (transaction: IndexedDBFileSystemTransaction) => Promise<T>,\n  ): Promise<T>;\n  close?(): void;\n}\n\nexport class RawIndexedDBFileSystemStore implements IndexedDBFileSystemStore {\n  private database: IDBDatabase | null = null;\n  private opening: Promise<IDBDatabase> | null = null;\n  private closed = false;\n\n  public constructor(\n    private readonly databaseName: string,\n    private readonly storeName: string,\n  ) {}\n\n  public async transaction<T>(\n    mode: IndexedDBFileSystemTransactionMode,\n    operation: (transaction: IndexedDBFileSystemTransaction) => Promise<T>,\n  ): Promise<T> {\n    const database = await this.getDatabase();\n    const nativeTransaction = database.transaction(this.storeName, mode);\n    const completion = waitForTransaction(nativeTransaction);\n    const transaction = new RawIndexedDBFileSystemTransaction(\n      nativeTransaction.objectStore(this.storeName),\n    );\n\n    let result: T;\n    try {\n      result = await operation(transaction);\n    } catch (error: unknown) {\n      try {\n        nativeTransaction.abort();\n      } catch {\n        // The request failure may already have aborted the transaction.\n      }\n      await completion.catch(() => undefined);\n      throw error;\n    }\n\n    await completion;\n    return result;\n  }\n\n  public close(): void {\n    if (this.closed) return;\n    this.closed = true;\n    this.database?.close();\n    this.database = null;\n    this.opening = null;\n  }\n\n  private getDatabase(): Promise<IDBDatabase> {\n    if (this.closed) {\n      return Promise.reject(new Error('The IndexedDB filesystem store is closed.'));\n    }\n    if (this.database) return Promise.resolve(this.database);\n    if (this.opening) return this.opening;\n    if (typeof indexedDB === 'undefined') {\n      return Promise.reject(new Error('IndexedDB is not available in this environment.'));\n    }\n\n    this.opening = openDatabaseWithStore(this.databaseName, this.storeName)\n      .then((database) => {\n        if (this.closed) {\n          database.close();\n          throw new Error('The IndexedDB filesystem store is closed.');\n        }\n        this.database = database;\n        this.opening = null;\n        database.onversionchange = () => {\n          database.close();\n          if (this.database === database) this.database = null;\n        };\n        return database;\n      })\n      .catch((error: unknown) => {\n        this.opening = null;\n        throw error;\n      });\n    return this.opening;\n  }\n}\n\nclass RawIndexedDBFileSystemTransaction implements IndexedDBFileSystemTransaction {\n  public constructor(private readonly store: IDBObjectStore) {}\n\n  public async get<T>(key: string): Promise<T | null> {\n    const value = await requestResult(this.store.get(key));\n    return value === undefined ? null : (value as T);\n  }\n\n  public async put<T>(key: string, value: T): Promise<void> {\n    await requestResult(this.store.put(value, key));\n  }\n\n  public async delete(key: string): Promise<void> {\n    await requestResult(this.store.delete(key));\n  }\n\n  public async keys(): Promise<string[]> {\n    const keys = await requestResult(this.store.getAllKeys());\n    return keys.map((key) => {\n      if (typeof key !== 'string') {\n        throw new Error('The DocBlocks filesystem store contains a non-string key.');\n      }\n      return key;\n    });\n  }\n\n  public async hasKeyWithPrefix(prefix: string): Promise<boolean> {\n    const cursor = await requestResult(this.store.openKeyCursor(IDBKeyRange.lowerBound(prefix)));\n    return cursor !== null && typeof cursor.key === 'string' && cursor.key.startsWith(prefix);\n  }\n}\n\nasync function openDatabaseWithStore(\n  databaseName: string,\n  storeName: string,\n): Promise<IDBDatabase> {\n  const database = await openDatabase(databaseName, undefined, (upgradeDatabase) => {\n    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {\n      upgradeDatabase.createObjectStore(storeName);\n    }\n  });\n  if (database.objectStoreNames.contains(storeName)) return database;\n\n  const nextVersion = database.version + 1;\n  database.close();\n  return openDatabase(databaseName, nextVersion, (upgradeDatabase) => {\n    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {\n      upgradeDatabase.createObjectStore(storeName);\n    }\n  });\n}\n\nfunction openDatabase(\n  databaseName: string,\n  version: number | undefined,\n  upgrade: (database: IDBDatabase) => void,\n): Promise<IDBDatabase> {\n  return new Promise((resolve, reject) => {\n    const request =\n      version === undefined ? indexedDB.open(databaseName) : indexedDB.open(databaseName, version);\n    let settled = false;\n\n    request.onupgradeneeded = () => upgrade(request.result);\n    request.onsuccess = () => {\n      if (settled) {\n        request.result.close();\n        return;\n      }\n      settled = true;\n      resolve(request.result);\n    };\n    request.onerror = () => {\n      if (settled) return;\n      settled = true;\n      reject(request.error ?? new Error(`Could not open IndexedDB database ${databaseName}.`));\n    };\n    request.onblocked = () => {\n      if (settled) return;\n      settled = true;\n      reject(new Error(`IndexedDB database ${databaseName} is blocked by another open page.`));\n    };\n  });\n}\n\nfunction requestResult<T>(request: IDBRequest<T>): Promise<T> {\n  return new Promise((resolve, reject) => {\n    request.onsuccess = () => resolve(request.result);\n    request.onerror = () => reject(request.error ?? new Error('IndexedDB request failed.'));\n  });\n}\n\nfunction waitForTransaction(transaction: IDBTransaction): Promise<void> {\n  return new Promise((resolve, reject) => {\n    transaction.oncomplete = () => resolve();\n    transaction.onabort = () =>\n      reject(transaction.error ?? new Error('IndexedDB transaction was aborted.'));\n    transaction.onerror = () =>\n      reject(transaction.error ?? new Error('IndexedDB transaction failed.'));\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-U722UUFN.js

@@ -0,0 +1,9 @@
+// src/filesystem/internal/records.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+export {
+  isRecord
+};
+//# sourceMappingURL=chunk-U722UUFN.js.map

package/dist/chunk-U722UUFN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/filesystem/internal/records.ts"],"sourcesContent":["/**\n * Structural guard shared by the filesystem providers that validate untrusted\n * payloads — stored IndexedDB records and Electron transport messages.\n */\n\n/** True for any non-null object, including arrays and class instances. */\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null;\n}\n"],"mappings":";AAMO,SAAS,SAAS,OAAkD;AACzE,SAAO,OAAO,UAAU,YAAY,UAAU;AAChD;","names":[]}