wiki-graph-core 0.3.1 → 0.4.0

package/dist/storage/wikg/wikg-coordinator/gc.js

@@ -0,0 +1,197 @@
+import { readdir, rm } from "fs/promises";
+import { basename, dirname, join } from "path";
+import {
+  isDisposableDirectoryEntry,
+  readPathSize,
+  removeDisposableChildDirectories,
+  removeDisposableDescendantDirectories,
+  removeDisposableDirectory
+} from "../../../runtime/gc/files.js";
+import { isNodeError } from "../../../utils/node-error.js";
+import {
+  hasActiveArchiveOwnerOrSqliteLease,
+  hasActiveWorkspaceUse
+} from "./activity.js";
+import { pathExists } from "./archive-key.js";
+import {
+  DATABASE_ENTRY_PATH,
+  SEARCH_INDEX_DATABASE_ENTRY_PATH,
+  SQLITE_CACHE_TTL_MS
+} from "./constants.js";
+import { acquireEntryLock } from "./locks.js";
+import { deleteOverlay, listOverlays, readOverlay } from "./overlays.js";
+import { readSearchIndexCacheStatus } from "./search-index-cache.js";
+import {
+  cleanupStaleState,
+  mapEntryOverlay,
+  withStateDatabase
+} from "./state.js";
+import {
+  getCoordinatorWorkspaceRootPath,
+  listWorkspaceFiles
+} from "./workspace.js";
+async function runWikgCoordinatorGc(context) {
+  const candidates = await listSqliteCacheGcCandidates();
+  let removed = 0;
+  let freedBytes = 0;
+  for (const candidate of candidates) {
+    const result = await tryRemoveSqliteCacheCandidate(candidate, context);
+    if (result.removed) {
+      removed += 1;
+      freedBytes += result.freedBytes;
+    }
+  }
+  const orphanedFiles = await removeOrphanedWorkspaceFiles(context);
+  const childDirectories = context.dryRun ? { freedBytes: 0, removed: 0, scanned: 0 } : await removeDisposableChildDirectories(getCoordinatorWorkspaceRootPath());
+  return {
+    freedBytes: freedBytes + orphanedFiles.freedBytes + childDirectories.freedBytes,
+    removed: removed + orphanedFiles.removed + childDirectories.removed,
+    scanned: candidates.length + orphanedFiles.scanned + childDirectories.scanned
+  };
+}
+async function listSqliteCacheGcCandidates() {
+  return await withStateDatabase(async (state) => {
+    await cleanupStaleState(state);
+    return await state.queryAll(
+      `
+SELECT overlay.*
+FROM entry_overlays AS overlay
+WHERE overlay.entry_path IN (?, ?)
+  AND overlay.kind = 'file'
+  AND overlay.workspace_path IS NOT NULL
+ORDER BY overlay.updated_at ASC
+`,
+      [DATABASE_ENTRY_PATH, SEARCH_INDEX_DATABASE_ENTRY_PATH],
+      mapEntryOverlay
+    );
+  });
+}
+async function tryRemoveSqliteCacheCandidate(candidate, context) {
+  const releaseWriteLock = await acquireEntryLock(
+    candidate.archiveKey,
+    candidate.entryPath,
+    "write"
+  );
+  try {
+    const releaseStateLock = await acquireEntryLock(
+      candidate.archiveKey,
+      candidate.entryPath,
+      "state"
+    );
+    try {
+      const overlay = await readOverlay(
+        candidate.archiveKey,
+        candidate.entryPath
+      );
+      if (overlay?.workspacePath === void 0 || overlay.workspacePath !== candidate.workspacePath || !await canRemoveSqliteCacheOverlay(overlay, context)) {
+        return { freedBytes: 0, removed: false };
+      }
+      let freedBytes = await readPathSize(overlay.workspacePath);
+      if (!context.dryRun) {
+        await deleteOverlay(overlay.archiveKey, overlay.entryPath);
+        await rm(overlay.workspacePath, { force: true });
+        freedBytes += await removeDisposableDirectory(
+          dirname(overlay.workspacePath)
+        );
+      }
+      return { freedBytes, removed: true };
+    } finally {
+      await releaseStateLock();
+    }
+  } finally {
+    await releaseWriteLock();
+  }
+}
+async function canRemoveSqliteCacheOverlay(overlay, context) {
+  if (await hasActiveArchiveOwnerOrSqliteLease(
+    overlay.archiveKey,
+    overlay.entryPath
+  )) {
+    return false;
+  }
+  if (overlay.workspacePath === void 0) {
+    return false;
+  }
+  if (await isSqliteCacheOverlayDirty(overlay)) {
+    return true;
+  }
+  if (!context.force && context.now - overlay.updatedAt < SQLITE_CACHE_TTL_MS) {
+    return false;
+  }
+  if (overlay.entryPath === SEARCH_INDEX_DATABASE_ENTRY_PATH && !context.force) {
+    return false;
+  }
+  return true;
+}
+async function isSqliteCacheOverlayDirty(overlay) {
+  if (overlay.workspacePath === void 0) {
+    return true;
+  }
+  if (!await pathExists(overlay.workspacePath)) {
+    return true;
+  }
+  if (!await pathExists(overlay.archivePath)) {
+    return true;
+  }
+  if (overlay.entryPath !== SEARCH_INDEX_DATABASE_ENTRY_PATH) {
+    return false;
+  }
+  return await readSearchIndexCacheStatus(overlay) !== "current";
+}
+async function removeOrphanedWorkspaceFiles(context) {
+  const rootPath = getCoordinatorWorkspaceRootPath();
+  let archiveKeyEntries;
+  try {
+    archiveKeyEntries = await readdir(rootPath, { withFileTypes: true });
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return { freedBytes: 0, removed: 0, scanned: 0 };
+    }
+    throw error;
+  }
+  let freedBytes = 0;
+  let removed = 0;
+  let scanned = 0;
+  for (const archiveKeyEntry of archiveKeyEntries) {
+    if (!archiveKeyEntry.isDirectory()) {
+      continue;
+    }
+    const archiveKey = archiveKeyEntry.name;
+    if (await hasActiveWorkspaceUse(archiveKey)) {
+      continue;
+    }
+    const referencedWorkspacePaths = new Set(
+      (await listOverlays(archiveKey)).map((overlay) => overlay.workspacePath).filter((path) => path !== void 0)
+    );
+    for (const workspacePath of await listWorkspaceFiles(
+      join(rootPath, archiveKey)
+    )) {
+      scanned += 1;
+      if (isDisposableDirectoryEntry(basename(workspacePath))) {
+        continue;
+      }
+      if (referencedWorkspacePaths.has(workspacePath)) {
+        continue;
+      }
+      const size = await readPathSize(workspacePath);
+      if (!context.dryRun) {
+        await rm(workspacePath, { force: true });
+      }
+      freedBytes += size;
+      removed += 1;
+    }
+    if (!context.dryRun) {
+      const disposableDirectories = await removeDisposableDescendantDirectories(
+        join(rootPath, archiveKey)
+      );
+      freedBytes += disposableDirectories.freedBytes;
+      removed += disposableDirectories.removed;
+      scanned += disposableDirectories.scanned;
+    }
+  }
+  return { freedBytes, removed, scanned };
+}
+export {
+  runWikgCoordinatorGc
+};
+//# sourceMappingURL=gc.js.map

package/dist/storage/wikg/wikg-coordinator/gc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/wikg-coordinator/gc.ts"],"sourcesContent":["import { readdir, rm } from \"fs/promises\";\nimport { basename, dirname, join } from \"path\";\n\nimport {\n  isDisposableDirectoryEntry,\n  readPathSize,\n  removeDisposableChildDirectories,\n  removeDisposableDescendantDirectories,\n  removeDisposableDirectory,\n} from \"../../../runtime/gc/files.js\";\nimport type { GcContext, GcJobResult } from \"../../../runtime/gc/index.js\";\nimport { isNodeError } from \"../../../utils/node-error.js\";\n\nimport {\n  hasActiveArchiveOwnerOrSqliteLease,\n  hasActiveWorkspaceUse,\n} from \"./activity.js\";\nimport { pathExists } from \"./archive-key.js\";\nimport {\n  DATABASE_ENTRY_PATH,\n  SEARCH_INDEX_DATABASE_ENTRY_PATH,\n  SQLITE_CACHE_TTL_MS,\n} from \"./constants.js\";\nimport { acquireEntryLock } from \"./locks.js\";\nimport { deleteOverlay, listOverlays, readOverlay } from \"./overlays.js\";\nimport { readSearchIndexCacheStatus } from \"./search-index-cache.js\";\nimport {\n  cleanupStaleState,\n  mapEntryOverlay,\n  withStateDatabase,\n} from \"./state.js\";\nimport type { EntryOverlay, WorkspaceDirectoryEntry } from \"./types.js\";\nimport {\n  getCoordinatorWorkspaceRootPath,\n  listWorkspaceFiles,\n} from \"./workspace.js\";\n\nexport async function runWikgCoordinatorGc(\n  context: GcContext,\n): Promise<GcJobResult> {\n  const candidates = await listSqliteCacheGcCandidates();\n  let removed = 0;\n  let freedBytes = 0;\n\n  for (const candidate of candidates) {\n    const result = await tryRemoveSqliteCacheCandidate(candidate, context);\n\n    if (result.removed) {\n      removed += 1;\n      freedBytes += result.freedBytes;\n    }\n  }\n\n  const orphanedFiles = await removeOrphanedWorkspaceFiles(context);\n  const childDirectories = context.dryRun\n    ? { freedBytes: 0, removed: 0, scanned: 0 }\n    : await removeDisposableChildDirectories(getCoordinatorWorkspaceRootPath());\n\n  return {\n    freedBytes:\n      freedBytes + orphanedFiles.freedBytes + childDirectories.freedBytes,\n    removed: removed + orphanedFiles.removed + childDirectories.removed,\n    scanned:\n      candidates.length + orphanedFiles.scanned + childDirectories.scanned,\n  };\n}\n\nasync function listSqliteCacheGcCandidates(): Promise<readonly EntryOverlay[]> {\n  return await withStateDatabase(async (state) => {\n    await cleanupStaleState(state);\n    return await state.queryAll(\n      `\nSELECT overlay.*\nFROM entry_overlays AS overlay\nWHERE overlay.entry_path IN (?, ?)\n  AND overlay.kind = 'file'\n  AND overlay.workspace_path IS NOT NULL\nORDER BY overlay.updated_at ASC\n`,\n      [DATABASE_ENTRY_PATH, SEARCH_INDEX_DATABASE_ENTRY_PATH],\n      mapEntryOverlay,\n    );\n  });\n}\n\nasync function tryRemoveSqliteCacheCandidate(\n  candidate: EntryOverlay,\n  context: GcContext,\n): Promise<{ readonly freedBytes: number; readonly removed: boolean }> {\n  const releaseWriteLock = await acquireEntryLock(\n    candidate.archiveKey,\n    candidate.entryPath,\n    \"write\",\n  );\n\n  try {\n    const releaseStateLock = await acquireEntryLock(\n      candidate.archiveKey,\n      candidate.entryPath,\n      \"state\",\n    );\n\n    try {\n      const overlay = await readOverlay(\n        candidate.archiveKey,\n        candidate.entryPath,\n      );\n\n      if (\n        overlay?.workspacePath === undefined ||\n        overlay.workspacePath !== candidate.workspacePath ||\n        !(await canRemoveSqliteCacheOverlay(overlay, context))\n      ) {\n        return { freedBytes: 0, removed: false };\n      }\n\n      let freedBytes = await readPathSize(overlay.workspacePath);\n\n      if (!context.dryRun) {\n        await deleteOverlay(overlay.archiveKey, overlay.entryPath);\n        await rm(overlay.workspacePath, { force: true });\n        freedBytes += await removeDisposableDirectory(\n          dirname(overlay.workspacePath),\n        );\n      }\n\n      return { freedBytes, removed: true };\n    } finally {\n      await releaseStateLock();\n    }\n  } finally {\n    await releaseWriteLock();\n  }\n}\n\nasync function canRemoveSqliteCacheOverlay(\n  overlay: EntryOverlay,\n  context: GcContext,\n): Promise<boolean> {\n  if (\n    await hasActiveArchiveOwnerOrSqliteLease(\n      overlay.archiveKey,\n      overlay.entryPath,\n    )\n  ) {\n    return false;\n  }\n  if (overlay.workspacePath === undefined) {\n    return false;\n  }\n\n  if (await isSqliteCacheOverlayDirty(overlay)) {\n    return true;\n  }\n  if (!context.force && context.now - overlay.updatedAt < SQLITE_CACHE_TTL_MS) {\n    return false;\n  }\n  if (\n    overlay.entryPath === SEARCH_INDEX_DATABASE_ENTRY_PATH &&\n    !context.force\n  ) {\n    return false;\n  }\n\n  return true;\n}\n\nasync function isSqliteCacheOverlayDirty(\n  overlay: EntryOverlay,\n): Promise<boolean> {\n  if (overlay.workspacePath === undefined) {\n    return true;\n  }\n  if (!(await pathExists(overlay.workspacePath))) {\n    return true;\n  }\n  if (!(await pathExists(overlay.archivePath))) {\n    return true;\n  }\n  if (overlay.entryPath !== SEARCH_INDEX_DATABASE_ENTRY_PATH) {\n    return false;\n  }\n\n  return (await readSearchIndexCacheStatus(overlay)) !== \"current\";\n}\n\nasync function removeOrphanedWorkspaceFiles(\n  context: GcContext,\n): Promise<Pick<GcJobResult, \"freedBytes\" | \"removed\" | \"scanned\">> {\n  const rootPath = getCoordinatorWorkspaceRootPath();\n  let archiveKeyEntries: readonly WorkspaceDirectoryEntry[];\n\n  try {\n    archiveKeyEntries = await readdir(rootPath, { withFileTypes: true });\n  } catch (error) {\n    if (isNodeError(error) && error.code === \"ENOENT\") {\n      return { freedBytes: 0, removed: 0, scanned: 0 };\n    }\n\n    throw error;\n  }\n\n  let freedBytes = 0;\n  let removed = 0;\n  let scanned = 0;\n\n  for (const archiveKeyEntry of archiveKeyEntries) {\n    if (!archiveKeyEntry.isDirectory()) {\n      continue;\n    }\n\n    const archiveKey = archiveKeyEntry.name;\n\n    if (await hasActiveWorkspaceUse(archiveKey)) {\n      continue;\n    }\n\n    const referencedWorkspacePaths = new Set(\n      (await listOverlays(archiveKey))\n        .map((overlay) => overlay.workspacePath)\n        .filter((path): path is string => path !== undefined),\n    );\n\n    for (const workspacePath of await listWorkspaceFiles(\n      join(rootPath, archiveKey),\n    )) {\n      scanned += 1;\n\n      if (isDisposableDirectoryEntry(basename(workspacePath))) {\n        continue;\n      }\n      if (referencedWorkspacePaths.has(workspacePath)) {\n        continue;\n      }\n\n      const size = await readPathSize(workspacePath);\n\n      if (!context.dryRun) {\n        await rm(workspacePath, { force: true });\n      }\n\n      freedBytes += size;\n      removed += 1;\n    }\n\n    if (!context.dryRun) {\n      const disposableDirectories = await removeDisposableDescendantDirectories(\n        join(rootPath, archiveKey),\n      );\n\n      freedBytes += disposableDirectories.freedBytes;\n      removed += disposableDirectories.removed;\n      scanned += disposableDirectories.scanned;\n    }\n  }\n\n  return { freedBytes, removed, scanned };\n}\n"],"mappings":"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","names":[]}

package/dist/storage/wikg/wikg-coordinator/index.d.ts

@@ -0,0 +1,29 @@
+export { WikgCoordinator } from './facade.js';
+export { WikgArchiveSession } from './session.js';
+export { tryStartWikgFlusher } from './flusher.js';
+export { runWikgCoordinatorGc } from './gc.js';
+import '../../../document/directory/types.js';
+import '../../../text/source/meta.js';
+import 'zod';
+import '../../../text/source/toc.js';
+import '../../../text/source/types.js';
+import '../../../document/database.js';
+import 'sqlite3';
+import '../../../document/types.js';
+import '../../../document/text-streams/serial.js';
+import '../../../document/text-streams/draft.js';
+import '../../../document/text-streams/types.js';
+import '../../../document/stores/chunk.js';
+import '../../../document/stores/types.js';
+import '../../../document/stores/fragment-group.js';
+import '../../../document/stores/graph-build-parameter.js';
+import '../../../document/stores/mention-link.js';
+import '../../../document/stores/mention.js';
+import '../../../document/stores/object-metadata.js';
+import '../../../document/stores/reading-edge.js';
+import '../../../document/stores/serial.js';
+import '../../../document/stores/snake/chunk.js';
+import '../../../document/stores/snake/core.js';
+import '../../../document/stores/snake/edge.js';
+import './types.js';
+import '../../../runtime/gc/types.js';

package/dist/storage/wikg/wikg-coordinator/index.js

@@ -0,0 +1,11 @@
+import { WikgCoordinator } from "./facade.js";
+import { WikgArchiveSession } from "./session.js";
+import { tryStartWikgFlusher } from "./flusher.js";
+import { runWikgCoordinatorGc } from "./gc.js";
+export {
+  WikgArchiveSession,
+  WikgCoordinator,
+  runWikgCoordinatorGc,
+  tryStartWikgFlusher
+};
+//# sourceMappingURL=index.js.map

package/dist/storage/wikg/wikg-coordinator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/wikg-coordinator/index.ts"],"sourcesContent":["export { WikgCoordinator } from \"./facade.js\";\nexport { WikgArchiveSession } from \"./session.js\";\nexport { tryStartWikgFlusher } from \"./flusher.js\";\nexport { runWikgCoordinatorGc } from \"./gc.js\";\n"],"mappings":"AAAA,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AACnC,SAAS,2BAA2B;AACpC,SAAS,4BAA4B;","names":[]}

package/dist/storage/wikg/wikg-coordinator/locks.d.ts

@@ -0,0 +1,19 @@
+import { EntryLockMode, SqliteLeaseMode } from './types.js';
+
+declare function acquireArchiveCommitLock(archiveKey: string): Promise<() => Promise<void>>;
+declare function acquireEntryLock(archiveKey: string, entryPath: string, mode: EntryLockMode): Promise<() => Promise<void>>;
+declare function withEntryLock<T>(archiveKey: string, entryPath: string, mode: EntryLockMode, operation: () => Promise<T> | T): Promise<T>;
+declare function acquireSqliteLease(input: {
+    readonly archiveKey: string;
+    readonly entryPath: string;
+    readonly mode: SqliteLeaseMode;
+    readonly ownerId: string;
+}): Promise<void>;
+declare function releaseSqliteLease(input: {
+    readonly archiveKey: string;
+    readonly entryPath: string;
+    readonly ownerId: string;
+}): Promise<void>;
+declare function waitForSqliteLeasesToDrain(archiveKey: string, entryPath: string): Promise<void>;
+
+export { acquireArchiveCommitLock, acquireEntryLock, acquireSqliteLease, releaseSqliteLease, waitForSqliteLeasesToDrain, withEntryLock };

package/dist/storage/wikg/wikg-coordinator/locks.js

@@ -0,0 +1,194 @@
+import { createOwnerId, delay } from "./archive-key.js";
+import { LOCK_POLL_INTERVAL_MS, LOCK_STALE_TIMEOUT_MS } from "./constants.js";
+import {
+  cleanupStaleState,
+  getNumber,
+  mapArchiveCommitLock,
+  mapEntryLock,
+  withStateDatabase
+} from "./state.js";
+async function acquireArchiveCommitLock(archiveKey) {
+  const ownerId = createOwnerId();
+  while (true) {
+    const acquired = await withStateDatabase(async (state) => {
+      await cleanupStaleState(state);
+      return await state.transaction(async () => {
+        const existing = await state.queryOne(
+          "SELECT * FROM archive_commit_locks WHERE archive_key = ?",
+          [archiveKey],
+          mapArchiveCommitLock
+        );
+        if (existing !== void 0) {
+          return false;
+        }
+        await state.run(
+          `
+INSERT INTO archive_commit_locks (
+  archive_key, owner_id, owner_pid, heartbeat_at, created_at
+) VALUES (?, ?, ?, ?, ?)
+`,
+          [archiveKey, ownerId, process.pid, Date.now(), Date.now()]
+        );
+        return true;
+      });
+    });
+    if (acquired) {
+      return async () => {
+        await withStateDatabase(async (releaseState) => {
+          await releaseState.run(
+            "DELETE FROM archive_commit_locks WHERE archive_key = ? AND owner_id = ?",
+            [archiveKey, ownerId]
+          );
+        });
+      };
+    }
+    await delay(LOCK_POLL_INTERVAL_MS);
+  }
+}
+async function acquireEntryLock(archiveKey, entryPath, mode) {
+  const ownerId = createOwnerId();
+  while (true) {
+    const acquired = await withStateDatabase(async (state) => {
+      await cleanupStaleState(state);
+      return await state.transaction(async () => {
+        const conflicts = await state.queryAll(
+          `
+SELECT *
+FROM entry_locks
+WHERE archive_key = ?
+`,
+          [archiveKey],
+          mapEntryLock
+        );
+        if (conflicts.some(
+          (lock) => lock.ownerId !== ownerId && lockPathsConflict(entryPath, lock.entryPath) && locksConflict(mode, lock.mode)
+        )) {
+          return false;
+        }
+        await state.run(
+          `
+INSERT INTO entry_locks (
+  archive_key, entry_path, mode, owner_id, owner_pid, heartbeat_at, created_at
+) VALUES (?, ?, ?, ?, ?, ?, ?)
+`,
+          [
+            archiveKey,
+            entryPath,
+            mode,
+            ownerId,
+            process.pid,
+            Date.now(),
+            Date.now()
+          ]
+        );
+        return true;
+      });
+    });
+    if (acquired) {
+      return async () => {
+        await withStateDatabase(async (releaseState) => {
+          await releaseState.run(
+            `
+DELETE FROM entry_locks
+WHERE archive_key = ? AND entry_path = ? AND owner_id = ?
+`,
+            [archiveKey, entryPath, ownerId]
+          );
+        });
+      };
+    }
+    await delay(LOCK_POLL_INTERVAL_MS);
+  }
+}
+async function withEntryLock(archiveKey, entryPath, mode, operation) {
+  const release = await acquireEntryLock(archiveKey, entryPath, mode);
+  try {
+    return await operation();
+  } finally {
+    await release();
+  }
+}
+function locksConflict(requested, existing) {
+  if (requested === "state" || existing === "state") {
+    return requested === "state" && existing === "state";
+  }
+  if (requested === "read" && existing === "read") {
+    return false;
+  }
+  return true;
+}
+function lockPathsConflict(requested, existing) {
+  return requested === existing || lockPathContains(requested, existing) || lockPathContains(existing, requested);
+}
+function lockPathContains(parent, child) {
+  return parent.endsWith("/") && child.startsWith(parent);
+}
+async function acquireSqliteLease(input) {
+  await withStateDatabase(async (state) => {
+    await cleanupStaleState(state);
+    await state.run(
+      `
+INSERT OR REPLACE INTO entry_sqlite_leases (
+  archive_key, entry_path, mode, owner_id, owner_pid, heartbeat_at, created_at
+) VALUES (?, ?, ?, ?, ?, ?, ?)
+`,
+      [
+        input.archiveKey,
+        input.entryPath,
+        input.mode,
+        input.ownerId,
+        process.pid,
+        Date.now(),
+        Date.now()
+      ]
+    );
+  });
+}
+async function releaseSqliteLease(input) {
+  await withStateDatabase(async (state) => {
+    await state.run(
+      `
+DELETE FROM entry_sqlite_leases
+WHERE archive_key = ? AND entry_path = ? AND owner_id = ?
+`,
+      [input.archiveKey, input.entryPath, input.ownerId]
+    );
+  });
+}
+async function waitForSqliteLeasesToDrain(archiveKey, entryPath) {
+  while (true) {
+    const count = await withStateDatabase(async (state) => {
+      await cleanupStaleState(state);
+      return await state.queryOne(
+        `
+SELECT COUNT(*) AS count
+FROM entry_sqlite_leases AS lease
+LEFT JOIN archive_owners AS owner
+  ON owner.archive_key = lease.archive_key
+ AND owner.owner_id = lease.owner_id
+WHERE lease.archive_key = ?
+  AND lease.entry_path = ?
+  AND (
+    owner.owner_id IS NULL
+    OR owner.heartbeat_at > ?
+  )
+`,
+        [archiveKey, entryPath, Date.now() - LOCK_STALE_TIMEOUT_MS],
+        (row) => getNumber(row, "count")
+      );
+    });
+    if (count === 0) {
+      return;
+    }
+    await delay(LOCK_POLL_INTERVAL_MS);
+  }
+}
+export {
+  acquireArchiveCommitLock,
+  acquireEntryLock,
+  acquireSqliteLease,
+  releaseSqliteLease,
+  waitForSqliteLeasesToDrain,
+  withEntryLock
+};
+//# sourceMappingURL=locks.js.map

package/dist/storage/wikg/wikg-coordinator/locks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/wikg-coordinator/locks.ts"],"sourcesContent":["import { createOwnerId, delay } from \"./archive-key.js\";\nimport { LOCK_POLL_INTERVAL_MS, LOCK_STALE_TIMEOUT_MS } from \"./constants.js\";\nimport {\n  cleanupStaleState,\n  getNumber,\n  mapArchiveCommitLock,\n  mapEntryLock,\n  withStateDatabase,\n} from \"./state.js\";\nimport type { EntryLockMode, SqliteLeaseMode } from \"./types.js\";\n\nexport async function acquireArchiveCommitLock(\n  archiveKey: string,\n): Promise<() => Promise<void>> {\n  const ownerId = createOwnerId();\n\n  while (true) {\n    const acquired = await withStateDatabase(async (state) => {\n      await cleanupStaleState(state);\n      return await state.transaction(async () => {\n        const existing = await state.queryOne(\n          \"SELECT * FROM archive_commit_locks WHERE archive_key = ?\",\n          [archiveKey],\n          mapArchiveCommitLock,\n        );\n\n        if (existing !== undefined) {\n          return false;\n        }\n\n        await state.run(\n          `\nINSERT INTO archive_commit_locks (\n  archive_key, owner_id, owner_pid, heartbeat_at, created_at\n) VALUES (?, ?, ?, ?, ?)\n`,\n          [archiveKey, ownerId, process.pid, Date.now(), Date.now()],\n        );\n        return true;\n      });\n    });\n\n    if (acquired) {\n      return async () => {\n        await withStateDatabase(async (releaseState) => {\n          await releaseState.run(\n            \"DELETE FROM archive_commit_locks WHERE archive_key = ? AND owner_id = ?\",\n            [archiveKey, ownerId],\n          );\n        });\n      };\n    }\n\n    await delay(LOCK_POLL_INTERVAL_MS);\n  }\n}\n\nexport async function acquireEntryLock(\n  archiveKey: string,\n  entryPath: string,\n  mode: EntryLockMode,\n): Promise<() => Promise<void>> {\n  const ownerId = createOwnerId();\n\n  while (true) {\n    const acquired = await withStateDatabase(async (state) => {\n      await cleanupStaleState(state);\n      return await state.transaction(async () => {\n        const conflicts = await state.queryAll(\n          `\nSELECT *\nFROM entry_locks\nWHERE archive_key = ?\n`,\n          [archiveKey],\n          mapEntryLock,\n        );\n\n        if (\n          conflicts.some(\n            (lock) =>\n              lock.ownerId !== ownerId &&\n              lockPathsConflict(entryPath, lock.entryPath) &&\n              locksConflict(mode, lock.mode),\n          )\n        ) {\n          return false;\n        }\n\n        await state.run(\n          `\nINSERT INTO entry_locks (\n  archive_key, entry_path, mode, owner_id, owner_pid, heartbeat_at, created_at\n) VALUES (?, ?, ?, ?, ?, ?, ?)\n`,\n          [\n            archiveKey,\n            entryPath,\n            mode,\n            ownerId,\n            process.pid,\n            Date.now(),\n            Date.now(),\n          ],\n        );\n        return true;\n      });\n    });\n\n    if (acquired) {\n      return async () => {\n        await withStateDatabase(async (releaseState) => {\n          await releaseState.run(\n            `\nDELETE FROM entry_locks\nWHERE archive_key = ? AND entry_path = ? AND owner_id = ?\n`,\n            [archiveKey, entryPath, ownerId],\n          );\n        });\n      };\n    }\n\n    await delay(LOCK_POLL_INTERVAL_MS);\n  }\n}\n\nexport async function withEntryLock<T>(\n  archiveKey: string,\n  entryPath: string,\n  mode: EntryLockMode,\n  operation: () => Promise<T> | T,\n): Promise<T> {\n  const release = await acquireEntryLock(archiveKey, entryPath, mode);\n\n  try {\n    return await operation();\n  } finally {\n    await release();\n  }\n}\n\nfunction locksConflict(requested: EntryLockMode, existing: EntryLockMode) {\n  if (requested === \"state\" || existing === \"state\") {\n    return requested === \"state\" && existing === \"state\";\n  }\n  if (requested === \"read\" && existing === \"read\") {\n    return false;\n  }\n\n  return true;\n}\n\nfunction lockPathsConflict(requested: string, existing: string): boolean {\n  return (\n    requested === existing ||\n    lockPathContains(requested, existing) ||\n    lockPathContains(existing, requested)\n  );\n}\n\nfunction lockPathContains(parent: string, child: string): boolean {\n  return parent.endsWith(\"/\") && child.startsWith(parent);\n}\n\nexport async function acquireSqliteLease(input: {\n  readonly archiveKey: string;\n  readonly entryPath: string;\n  readonly mode: SqliteLeaseMode;\n  readonly ownerId: string;\n}): Promise<void> {\n  await withStateDatabase(async (state) => {\n    await cleanupStaleState(state);\n    await state.run(\n      `\nINSERT OR REPLACE INTO entry_sqlite_leases (\n  archive_key, entry_path, mode, owner_id, owner_pid, heartbeat_at, created_at\n) VALUES (?, ?, ?, ?, ?, ?, ?)\n`,\n      [\n        input.archiveKey,\n        input.entryPath,\n        input.mode,\n        input.ownerId,\n        process.pid,\n        Date.now(),\n        Date.now(),\n      ],\n    );\n  });\n}\n\nexport async function releaseSqliteLease(input: {\n  readonly archiveKey: string;\n  readonly entryPath: string;\n  readonly ownerId: string;\n}): Promise<void> {\n  await withStateDatabase(async (state) => {\n    await state.run(\n      `\nDELETE FROM entry_sqlite_leases\nWHERE archive_key = ? AND entry_path = ? AND owner_id = ?\n`,\n      [input.archiveKey, input.entryPath, input.ownerId],\n    );\n  });\n}\n\nexport async function waitForSqliteLeasesToDrain(\n  archiveKey: string,\n  entryPath: string,\n): Promise<void> {\n  while (true) {\n    const count = await withStateDatabase(async (state) => {\n      await cleanupStaleState(state);\n      return await state.queryOne(\n        `\nSELECT COUNT(*) AS count\nFROM entry_sqlite_leases AS lease\nLEFT JOIN archive_owners AS owner\n  ON owner.archive_key = lease.archive_key\n AND owner.owner_id = lease.owner_id\nWHERE lease.archive_key = ?\n  AND lease.entry_path = ?\n  AND (\n    owner.owner_id IS NULL\n    OR owner.heartbeat_at > ?\n  )\n`,\n        [archiveKey, entryPath, Date.now() - LOCK_STALE_TIMEOUT_MS],\n        (row) => getNumber(row, \"count\"),\n      );\n    });\n\n    if (count === 0) {\n      return;\n    }\n\n    await delay(LOCK_POLL_INTERVAL_MS);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/storage/wikg/wikg-coordinator/overlays.d.ts

@@ -0,0 +1,32 @@
+import { WikgArchiveOverlay } from '../archive/types.js';
+import { EntryOverlay } from './types.js';
+
+declare function listVisibleEntryPaths(archiveEntries: readonly string[], input: {
+    readonly archiveKey: string;
+    readonly prefix: string;
+}): Promise<readonly string[]>;
+declare function resolveEntrySource(input: {
+    readonly archiveKey: string;
+    readonly entryPath: string;
+}): Promise<{
+    readonly kind: "archive";
+} | {
+    readonly kind: "deleted";
+} | {
+    readonly kind: "workspace";
+    readonly path: string;
+}>;
+declare function readOverlay(archiveKey: string, entryPath: string): Promise<EntryOverlay | undefined>;
+declare function listOverlays(archiveKey: string): Promise<readonly EntryOverlay[]>;
+declare function upsertOverlay(input: {
+    readonly archiveKey: string;
+    readonly archivePath: string;
+    readonly entryPath: string;
+    readonly kind: "deleted" | "file";
+    readonly workspacePath?: string;
+}): Promise<void>;
+declare function deleteOverlay(archiveKey: string, entryPath: string): Promise<void>;
+declare function resolveArchivePathFromKey(archiveKey: string): Promise<string | undefined>;
+declare function toArchiveOverlay(overlay: EntryOverlay): WikgArchiveOverlay;
+
+export { deleteOverlay, listOverlays, listVisibleEntryPaths, readOverlay, resolveArchivePathFromKey, resolveEntrySource, toArchiveOverlay, upsertOverlay };

package/dist/storage/wikg/wikg-coordinator/overlays.js

@@ -0,0 +1,141 @@
+import {
+  readWikgArchiveMutationToken
+} from "../archive/index.js";
+import { createArchiveSignature } from "./archive-key.js";
+import { SEARCH_INDEX_DATABASE_ENTRY_PATH } from "./constants.js";
+import { getString, mapEntryOverlay, withStateDatabase } from "./state.js";
+async function listVisibleEntryPaths(archiveEntries, input) {
+  const matchingArchiveEntries = archiveEntries.filter(
+    (entryPath) => entryPath.startsWith(input.prefix)
+  );
+  const overlays = await withStateDatabase(
+    async (state) => await state.queryAll(
+      `
+SELECT *
+FROM entry_overlays
+WHERE archive_key = ?
+`,
+      [input.archiveKey],
+      mapEntryOverlay
+    )
+  );
+  const entries = new Set(matchingArchiveEntries);
+  for (const overlay of overlays) {
+    if (!overlay.entryPath.startsWith(input.prefix)) {
+      continue;
+    }
+    if (overlay.kind === "deleted") {
+      entries.delete(overlay.entryPath);
+    } else {
+      entries.add(overlay.entryPath);
+    }
+  }
+  return [...entries].sort((left, right) => left.localeCompare(right));
+}
+async function resolveEntrySource(input) {
+  const overlay = await readOverlay(input.archiveKey, input.entryPath);
+  if (overlay?.kind === "deleted") {
+    return { kind: "deleted" };
+  }
+  if (overlay?.workspacePath !== void 0) {
+    return { kind: "workspace", path: overlay.workspacePath };
+  }
+  return { kind: "archive" };
+}
+async function readOverlay(archiveKey, entryPath) {
+  return await withStateDatabase(
+    async (state) => await state.queryOne(
+      "SELECT * FROM entry_overlays WHERE archive_key = ? AND entry_path = ?",
+      [archiveKey, entryPath],
+      mapEntryOverlay
+    )
+  );
+}
+async function listOverlays(archiveKey) {
+  return await withStateDatabase(
+    async (state) => await state.queryAll(
+      `
+SELECT *
+FROM entry_overlays
+WHERE archive_key = ?
+ORDER BY entry_path ASC
+`,
+      [archiveKey],
+      mapEntryOverlay
+    )
+  );
+}
+async function upsertOverlay(input) {
+  const mutationToken = input.entryPath === SEARCH_INDEX_DATABASE_ENTRY_PATH ? await readWikgArchiveMutationToken(input.archivePath) : void 0;
+  await withStateDatabase(async (state) => {
+    await state.run(
+      `
+INSERT INTO entry_overlays (
+  archive_key, archive_path, entry_path, kind, workspace_path,
+  archive_signature, mutation_token, updated_at
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ON CONFLICT(archive_key, entry_path)
+DO UPDATE SET kind = excluded.kind,
+              archive_path = excluded.archive_path,
+              workspace_path = excluded.workspace_path,
+              archive_signature = excluded.archive_signature,
+              mutation_token = excluded.mutation_token,
+              updated_at = excluded.updated_at
+`,
+      [
+        input.archiveKey,
+        input.archivePath,
+        input.entryPath,
+        input.kind,
+        input.workspacePath ?? null,
+        await createArchiveSignature(input.archivePath),
+        mutationToken ?? null,
+        Date.now()
+      ]
+    );
+  });
+}
+async function deleteOverlay(archiveKey, entryPath) {
+  await withStateDatabase(async (state) => {
+    await state.run(
+      "DELETE FROM entry_overlays WHERE archive_key = ? AND entry_path = ?",
+      [archiveKey, entryPath]
+    );
+  });
+}
+async function resolveArchivePathFromKey(archiveKey) {
+  return await withStateDatabase(
+    async (state) => await state.queryOne(
+      "SELECT archive_path FROM entry_overlays WHERE archive_key = ? LIMIT 1",
+      [archiveKey],
+      (row) => getString(row, "archive_path")
+    )
+  );
+}
+function toArchiveOverlay(overlay) {
+  if (overlay.kind === "deleted") {
+    return {
+      entryPath: overlay.entryPath,
+      kind: "deleted"
+    };
+  }
+  if (overlay.workspacePath === void 0) {
+    throw new Error(`Missing workspace path for ${overlay.entryPath}.`);
+  }
+  return {
+    entryPath: overlay.entryPath,
+    kind: "file",
+    workspacePath: overlay.workspacePath
+  };
+}
+export {
+  deleteOverlay,
+  listOverlays,
+  listVisibleEntryPaths,
+  readOverlay,
+  resolveArchivePathFromKey,
+  resolveEntrySource,
+  toArchiveOverlay,
+  upsertOverlay
+};
+//# sourceMappingURL=overlays.js.map