wiki-graph-core 0.3.1 → 0.4.1

package/dist/library/membership.js

@@ -0,0 +1,812 @@
+import { randomBytes } from "crypto";
+import {
+  constants,
+  copyFile,
+  mkdir,
+  opendir,
+  realpath,
+  rename,
+  rm,
+  stat
+} from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+import {
+  getNumber,
+  getOptionalString,
+  getString
+} from "../document/database.js";
+import { openSharedStateDatabase } from "../document/index.js";
+import { resolveWikiGraphCoreDatabasePath } from "../runtime/common/wiki-graph/dir.js";
+import { WIKI_GRAPH_ARCHIVE_EXTENSION } from "../runtime/common/wiki-graph/uri.js";
+import {
+  readWikgArchiveEntry,
+  readWikgArchiveMutationToken,
+  WikiGraphArchiveFile
+} from "../storage/wikg/index.js";
+import { isNodeError } from "../utils/node-error.js";
+import {
+  parseWikiGraphLibraryUri,
+  resolveWikiGraphLibrary,
+  resolveWikiGraphLibraryForScan,
+  updateWikiGraphLibraryFolderPathForRebind
+} from "./registry.js";
+import { markWikiGraphLibraryIndexDirty } from "./search-index.js";
+import { withWikiGraphLibraryLock } from "./lock.js";
+const PUBLIC_ID_BYTES = 6;
+const SEARCH_INDEX_ARCHIVE_ENTRY_PATH = "fts.db";
+const LIBRARY_ARCHIVES_TABLE_COLUMNS_SQL = `
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    library_id INTEGER NOT NULL,
+    public_id TEXT NOT NULL,
+    relative_path TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'present',
+    last_seen_mutation_token TEXT,
+    last_seen_size INTEGER,
+    last_seen_mtime_ms INTEGER,
+    last_scanned_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(library_id, public_id)
+`;
+const LIBRARY_ARCHIVE_MEMBERSHIP_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS library_archives (
+${LIBRARY_ARCHIVES_TABLE_COLUMNS_SQL}
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_library_archives_library
+  ON library_archives(library_id);
+
+  CREATE INDEX IF NOT EXISTS idx_library_archives_library_path
+  ON library_archives(library_id, relative_path);
+`;
+async function scanWikiGraphLibrary(target) {
+  const library = await resolveWikiGraphLibraryForScan(target);
+  return await withWikiGraphLibraryLock(library.id, "write", async () => {
+    const result = await scanWikiGraphLibraryUnlocked(target, library, {
+      pathIdentity: "trusted"
+    });
+    await markWikiGraphLibraryIndexDirty(library);
+    return result;
+  });
+}
+async function rebindWikiGraphLibrary(input) {
+  if (input.target.kind !== "scope" || input.target.objectUri !== void 0) {
+    throw new Error("Library rebind requires a library scope URI.");
+  }
+  const library = await resolveWikiGraphLibrary(input.target);
+  return await withWikiGraphLibraryLock(library.id, "write", async () => {
+    const rebound = await updateWikiGraphLibraryFolderPathForRebind(
+      library,
+      input.folderPath
+    );
+    const result = await scanWikiGraphLibraryUnlocked(input.target, rebound, {
+      pathIdentity: "untrusted"
+    });
+    await markWikiGraphLibraryIndexDirty(rebound);
+    return result;
+  });
+}
+async function scanWikiGraphLibraryUnlocked(target, library, options) {
+  const files = await listWikgFiles(library.folderPath);
+  await withLibraryArchiveMembershipDatabase(async (database) => {
+    await database.transaction(async () => {
+      const existing = await listLibraryArchiveRows(database, library);
+      const currentPaths = new Set(files.map((file) => file.relativePath));
+      const seenArchiveIds = /* @__PURE__ */ new Set();
+      for (const file of files) {
+        const existingAtPath = findExistingArchiveAtPath(existing, file);
+        if (options.pathIdentity === "trusted" && existingAtPath !== void 0) {
+          await updateLibraryArchiveSeen(database, existingAtPath.id, file, {
+            status: "present"
+          });
+          seenArchiveIds.add(existingAtPath.id);
+          continue;
+        }
+        const matchingTokenArchives = file.mutationToken === void 0 ? [] : existing.filter(
+          (archive) => archive.lastSeenMutationToken === file.mutationToken && !seenArchiveIds.has(archive.id)
+        );
+        const adoptable = matchingTokenArchives.filter(
+          (archive) => archive.relativePath === file.relativePath || !currentPaths.has(archive.relativePath)
+        );
+        if (matchingTokenArchives.length === 1 && adoptable.length === 1 && file.mutationToken !== void 0) {
+          const archive = adoptable[0];
+          await database.run(
+            `
+              UPDATE library_archives
+              SET relative_path = ?
+              WHERE id = ?
+            `,
+            [file.relativePath, archive.id]
+          );
+          await updateLibraryArchiveSeen(database, archive.id, file, {
+            status: "present"
+          });
+          seenArchiveIds.add(archive.id);
+          continue;
+        }
+        await insertLibraryArchive(database, library.id, file, {
+          status: matchingTokenArchives.length === 0 || file.mutationToken === void 0 ? "present" : "conflict"
+        });
+      }
+      for (const archive of existing) {
+        if (seenArchiveIds.has(archive.id) || options.pathIdentity === "trusted" && currentPaths.has(archive.relativePath)) {
+          continue;
+        }
+        await database.run(
+          `
+            DELETE FROM library_archives
+            WHERE id = ?
+          `,
+          [archive.id]
+        );
+      }
+    });
+  });
+  return { library, archives: await listWikiGraphLibraryArchives(target) };
+}
+async function listWikiGraphLibraryArchives(target) {
+  const library = await resolveWikiGraphLibrary(target);
+  return await withLibraryArchiveMembershipDatabase(
+    async (database) => await listLibraryArchives(database, library)
+  );
+}
+async function getWikiGraphLibraryArchive(target) {
+  const library = await resolveWikiGraphLibrary(target);
+  return await resolveLibraryArchiveTarget(target, library);
+}
+async function getWikiGraphLibraryArchiveById(library, archiveId) {
+  return await withLibraryArchiveMembershipDatabase(
+    async (database) => await requireLibraryArchiveById(database, library, archiveId)
+  );
+}
+async function resolveWikiGraphLibraryArchivePath(archiveLocator) {
+  const target = parseWikiGraphLibraryUri(archiveLocator);
+  if (target === void 0 || target.kind !== "archive") {
+    throw new Error(
+      `Expected a Wiki Graph library archive locator: ${archiveLocator}`
+    );
+  }
+  const archive = await getWikiGraphLibraryArchive(target);
+  if (!archive.exists || archive.status === "missing") {
+    throw new Error(`Wiki Graph library archive is missing: ${archiveLocator}`);
+  }
+  if (archive.status === "conflict") {
+    throw new Error(
+      `Wiki Graph library archive has a conflict and cannot be resolved: ${archiveLocator}`
+    );
+  }
+  return archive.path;
+}
+async function addWikiGraphLibraryArchive(input) {
+  if (input.inputPath.startsWith("wikg://")) {
+    throw new Error(
+      "Library add --input accepts a file path, not a Wiki Graph URI."
+    );
+  }
+  if (/^[a-z][a-z0-9+.-]*:\/\//iu.test(input.inputPath)) {
+    throw new Error("Library add does not support URL inputs yet.");
+  }
+  const library = await resolveWikiGraphLibrary(input.target);
+  await mkdir(library.folderPath, { recursive: true });
+  const sourcePath = resolve(input.inputPath);
+  const sourceStats = await stat(sourcePath);
+  if (!sourceStats.isFile()) {
+    throw new Error(`Library add --input must be a file: ${input.inputPath}`);
+  }
+  const sourceBasename = sourcePath.split(/[\\/]/u).at(-1) ?? "";
+  const targetRelativePath = validateLibraryArchiveRelativePath(
+    input.to ?? sourceBasename
+  );
+  const targetPath = resolveLibraryRelativePath(
+    library.folderPath,
+    targetRelativePath
+  );
+  return await withWikiGraphLibraryLock(library.id, "write", async () => {
+    await mkdir(dirname(targetPath), { recursive: true });
+    await assertInsideLibrary(
+      await realpath(dirname(targetPath)),
+      library.folderPath
+    );
+    await copyFile(sourcePath, targetPath, constants.COPYFILE_EXCL);
+    await assertInsideLibrary(await realpath(targetPath), library.folderPath);
+    const targetFile = await ensureLibraryArchiveFileHasNoSearchIndexAndInspect(
+      library.folderPath,
+      targetRelativePath
+    );
+    const archive = await withLibraryArchiveMembershipDatabase(
+      async (database) => {
+        await database.transaction(async () => {
+          await ensureLibraryArchiveByRelativePath(
+            database,
+            library.id,
+            targetFile
+          );
+        });
+        return await requireLibraryArchiveByRelativePath(
+          database,
+          library,
+          targetRelativePath
+        );
+      }
+    );
+    await markWikiGraphLibraryIndexDirty(library);
+    return archive;
+  });
+}
+async function finalizeWikiGraphLibraryArchiveWrite(input) {
+  if (input.target.kind !== "archive") {
+    throw new Error("Expected a Wiki Graph library archive URI.");
+  }
+  const library = await resolveWikiGraphLibrary(input.target);
+  return await withWikiGraphLibraryLock(library.id, "write", async () => {
+    const archive = await resolveLibraryArchiveTarget(input.target, library);
+    const removed = await ensureLibraryManagedArchiveHasNoSearchIndex(
+      archive.path
+    );
+    const refreshedFile = await inspectLibraryArchiveFile(
+      library.folderPath,
+      archive.relativePath
+    );
+    await withLibraryArchiveMembershipDatabase(async (database) => {
+      await updateLibraryArchiveSeen(database, archive.id, refreshedFile, {
+        status: "present"
+      });
+    });
+    return removed;
+  });
+}
+async function ensureLibraryManagedArchiveHasNoSearchIndex(archivePath) {
+  if (await readOptionalWikgMutationToken(archivePath) === void 0) {
+    return false;
+  }
+  const searchIndex = await readWikgArchiveEntry(
+    archivePath,
+    SEARCH_INDEX_ARCHIVE_ENTRY_PATH
+  );
+  if (searchIndex === void 0) {
+    return false;
+  }
+  await new WikiGraphArchiveFile(archivePath).write(
+    async (document) => {
+      await document.deleteSearchIndexDatabase();
+    },
+    { searchIndexWritebackPolicy: "archive" }
+  );
+  return true;
+}
+async function removeWikiGraphLibraryArchive(input) {
+  const library = await resolveWikiGraphLibrary(input.target);
+  const archive = await resolveLibraryArchiveTarget(input.target, library);
+  await withWikiGraphLibraryLock(library.id, "write", async () => {
+    await rm(archive.path, { force: true });
+    await withLibraryArchiveMembershipDatabase(async (database) => {
+      await database.run("DELETE FROM library_archives WHERE id = ?", [
+        archive.id
+      ]);
+    });
+    await markWikiGraphLibraryIndexDirty(library);
+  });
+  return { ...archive, exists: false, status: "missing" };
+}
+async function moveWikiGraphLibraryArchive(input) {
+  const library = await resolveWikiGraphLibrary(input.target);
+  const archive = await resolveLibraryArchiveTarget(input.target, library);
+  const targetRelativePath = validateLibraryArchiveRelativePath(input.to);
+  const targetPath = resolveLibraryRelativePath(
+    library.folderPath,
+    targetRelativePath
+  );
+  return await withWikiGraphLibraryLock(library.id, "write", async () => {
+    await mkdir(dirname(targetPath), { recursive: true });
+    await assertInsideLibrary(
+      await realpath(dirname(targetPath)),
+      library.folderPath
+    );
+    if (await pathExists(targetPath)) {
+      throw new Error(
+        `Library archive target already exists: ${targetRelativePath}`
+      );
+    }
+    await rename(archive.path, targetPath);
+    await assertInsideLibrary(await realpath(targetPath), library.folderPath);
+    const targetFile = await inspectLibraryArchiveFile(
+      library.folderPath,
+      targetRelativePath
+    );
+    const moved = await withLibraryArchiveMembershipDatabase(
+      async (database) => {
+        await database.run(
+          "UPDATE library_archives SET relative_path = ? WHERE id = ?",
+          [targetRelativePath, archive.id]
+        );
+        await updateLibraryArchiveSeen(database, archive.id, targetFile, {
+          status: "present"
+        });
+        return await requireLibraryArchiveByPublicId(
+          database,
+          library,
+          archive.publicId
+        );
+      }
+    );
+    await markWikiGraphLibraryIndexDirty(library);
+    return moved;
+  });
+}
+async function withLibraryArchiveMembershipDatabase(operation) {
+  const database = await openSharedStateDatabase(
+    resolveWikiGraphCoreDatabasePath(),
+    LIBRARY_ARCHIVE_MEMBERSHIP_SCHEMA_SQL
+  );
+  try {
+    await ensureLibraryArchiveMembershipColumns(database);
+    await ensureLibraryArchiveMembershipPathIndex(database);
+    return await operation(database);
+  } finally {
+    await database.close();
+  }
+}
+async function listLibraryArchives(database, library) {
+  const rows = await queryLibraryArchiveRows(database, library.id);
+  const archives = [];
+  for (const row of rows) {
+    const relativePath = getString(row, "relative_path");
+    archives.push(
+      mapLibraryArchiveRecord(
+        library,
+        row,
+        await pathExists(join(library.folderPath, relativePath))
+      )
+    );
+  }
+  return archives;
+}
+async function listLibraryArchiveRows(database, library) {
+  const rows = await queryLibraryArchiveRows(database, library.id);
+  return rows.map((row) => mapLibraryArchiveRecord(library, row, false));
+}
+async function queryLibraryArchiveRows(database, libraryId) {
+  return await database.queryAll(
+    `
+      SELECT id, public_id, relative_path, status, last_seen_mutation_token,
+             last_seen_size, last_seen_mtime_ms, last_scanned_at,
+             created_at, updated_at
+      FROM library_archives
+      WHERE library_id = ?
+      ORDER BY relative_path
+    `,
+    [libraryId],
+    (row) => row
+  );
+}
+async function ensureLibraryArchiveByRelativePath(database, libraryId, file) {
+  const existing = await database.queryOne(
+    `
+      SELECT id
+      FROM library_archives
+      WHERE library_id = ? AND relative_path = ?
+      ORDER BY CASE status
+        WHEN 'present' THEN 0
+        WHEN 'conflict' THEN 1
+        ELSE 2
+      END, id DESC
+    `,
+    [libraryId, file.relativePath],
+    (row) => getNumber(row, "id")
+  );
+  if (existing !== void 0) {
+    await updateLibraryArchiveSeen(database, existing, file, {
+      status: "present"
+    });
+    return;
+  }
+  await insertLibraryArchive(database, libraryId, file, { status: "present" });
+}
+async function insertLibraryArchive(database, libraryId, file, options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await database.run(
+    `
+      INSERT INTO library_archives (
+        library_id, public_id, relative_path, status, last_seen_mutation_token,
+        last_seen_size, last_seen_mtime_ms, last_scanned_at, created_at, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    [
+      libraryId,
+      await createUniqueLibraryArchivePublicId(database, libraryId),
+      file.relativePath,
+      options.status,
+      file.mutationToken ?? null,
+      file.size,
+      Math.round(file.mtimeMs),
+      now,
+      now,
+      now
+    ]
+  );
+}
+async function updateLibraryArchiveSeen(database, archiveId, file, options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await database.run(
+    `
+      UPDATE library_archives
+      SET status = ?,
+          last_seen_mutation_token = ?,
+          last_seen_size = ?,
+          last_seen_mtime_ms = ?,
+          last_scanned_at = ?,
+          updated_at = ?
+      WHERE id = ?
+    `,
+    [
+      options.status,
+      file.mutationToken ?? null,
+      file.size,
+      Math.round(file.mtimeMs),
+      now,
+      now,
+      archiveId
+    ]
+  );
+}
+async function requireLibraryArchiveByRelativePath(database, library, relativePath) {
+  const archive = await database.queryOne(
+    `
+      SELECT id, public_id, relative_path, status, last_seen_mutation_token,
+             last_seen_size, last_seen_mtime_ms, last_scanned_at,
+             created_at, updated_at
+      FROM library_archives
+      WHERE library_id = ? AND relative_path = ?
+      ORDER BY CASE status
+        WHEN 'present' THEN 0
+        WHEN 'conflict' THEN 1
+        ELSE 2
+      END, id DESC
+    `,
+    [library.id, relativePath],
+    (row) => mapLibraryArchiveRecord(library, row, true)
+  );
+  if (archive === void 0) {
+    throw new Error(
+      `Library archive registry record is missing: ${relativePath}`
+    );
+  }
+  return archive;
+}
+async function requireLibraryArchiveByPublicId(database, library, publicId) {
+  const row = await database.queryOne(
+    `
+      SELECT id, public_id, relative_path, status, last_seen_mutation_token,
+             last_seen_size, last_seen_mtime_ms, last_scanned_at,
+             created_at, updated_at
+      FROM library_archives
+      WHERE library_id = ? AND public_id = ?
+    `,
+    [library.id, publicId],
+    (row2) => row2
+  );
+  if (row === void 0) {
+    throw new Error(`Unknown Wiki Graph library archive: ${publicId}`);
+  }
+  const relativePath = getString(row, "relative_path");
+  return mapLibraryArchiveRecord(
+    library,
+    row,
+    await pathExists(join(library.folderPath, relativePath))
+  );
+}
+async function requireLibraryArchiveById(database, library, archiveId) {
+  const row = await database.queryOne(
+    `
+      SELECT id, public_id, relative_path, status, last_seen_mutation_token,
+             last_seen_size, last_seen_mtime_ms, last_scanned_at,
+             created_at, updated_at
+      FROM library_archives
+      WHERE library_id = ? AND id = ?
+    `,
+    [library.id, archiveId],
+    (row2) => row2
+  );
+  if (row === void 0) {
+    throw new Error(`Unknown Wiki Graph library archive: ${archiveId}`);
+  }
+  const relativePath = getString(row, "relative_path");
+  return mapLibraryArchiveRecord(
+    library,
+    row,
+    await pathExists(join(library.folderPath, relativePath))
+  );
+}
+async function resolveLibraryArchiveTarget(target, library) {
+  if (target.kind !== "archive" || target.archivePublicId === void 0) {
+    throw new Error("Expected a Wiki Graph library archive URI.");
+  }
+  return await withLibraryArchiveMembershipDatabase(
+    async (database) => await requireLibraryArchiveByPublicId(
+      database,
+      library,
+      target.archivePublicId
+    )
+  );
+}
+function mapLibraryArchiveRecord(library, row, exists) {
+  const publicId = getString(row, "public_id");
+  const relativePath = getString(row, "relative_path");
+  const databaseStatus = normalizeArchiveStatus(
+    getOptionalString(row, "status") ?? "present"
+  );
+  return {
+    createdAt: getString(row, "created_at"),
+    exists,
+    id: getNumber(row, "id"),
+    libraryId: library.id,
+    libraryUri: library.uri,
+    ...optionalStringField(
+      row,
+      "last_seen_mutation_token",
+      "lastSeenMutationToken"
+    ),
+    ...optionalNumberField(row, "last_seen_mtime_ms", "lastSeenMtimeMs"),
+    ...optionalNumberField(row, "last_seen_size", "lastSeenSize"),
+    ...optionalStringField(row, "last_scanned_at", "lastScannedAt"),
+    path: join(library.folderPath, relativePath),
+    publicId,
+    relativePath,
+    status: exists ? databaseStatus : "missing",
+    updatedAt: getString(row, "updated_at"),
+    uri: `${library.uri}/arc/${publicId}`
+  };
+}
+function findExistingArchiveAtPath(archives, file) {
+  return archives.filter((archive) => archive.relativePath === file.relativePath).sort((a, b) => archivePathMatchRank(a) - archivePathMatchRank(b))[0];
+}
+function archivePathMatchRank(archive) {
+  if (archive.status === "present") {
+    return 0;
+  }
+  if (archive.status === "conflict") {
+    return 1;
+  }
+  return 2;
+}
+async function listWikgFiles(root) {
+  await assertLibraryFolderExists(root);
+  const relativePaths = [];
+  await walkLibraryDirectory(root, root, relativePaths);
+  const files = [];
+  for (const relativePath of relativePaths.sort((a, b) => a.localeCompare(b))) {
+    files.push(
+      await ensureLibraryArchiveFileHasNoSearchIndexAndInspect(
+        root,
+        relativePath
+      )
+    );
+  }
+  return files;
+}
+async function assertLibraryFolderExists(root) {
+  try {
+    const rootStat = await stat(root);
+    if (!rootStat.isDirectory()) {
+      throw new Error(`Wiki Graph library folder is not a directory: ${root}`);
+    }
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      throw new Error(`Wiki Graph library folder is missing: ${root}`);
+    }
+    throw error;
+  }
+}
+async function ensureLibraryArchiveFileHasNoSearchIndexAndInspect(root, relativePath) {
+  await ensureLibraryManagedArchiveHasNoSearchIndex(join(root, relativePath));
+  return await inspectLibraryArchiveFile(root, relativePath);
+}
+async function walkLibraryDirectory(root, directory, files) {
+  let entries;
+  try {
+    entries = await opendir(directory);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  for await (const entry of entries) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      await walkLibraryDirectory(root, path, files);
+    } else if (entry.isFile() && entry.name.endsWith(WIKI_GRAPH_ARCHIVE_EXTENSION)) {
+      files.push(relative(root, path).replace(/\\/gu, "/"));
+    }
+  }
+}
+async function inspectLibraryArchiveFile(root, relativePath) {
+  const path = join(root, relativePath);
+  const fileStat = await stat(path);
+  const mutationToken = await readOptionalWikgMutationToken(path);
+  return {
+    mtimeMs: fileStat.mtimeMs,
+    ...mutationToken === void 0 ? {} : { mutationToken },
+    path,
+    relativePath,
+    size: fileStat.size
+  };
+}
+async function readOptionalWikgMutationToken(path) {
+  try {
+    return await readWikgArchiveMutationToken(path);
+  } catch {
+    return void 0;
+  }
+}
+function validateLibraryArchiveRelativePath(relativePath) {
+  const normalized = relativePath.replace(/\\/gu, "/").replace(/^\/+|\/+$/gu, "");
+  if (normalized === "" || isAbsolute(relativePath) || normalized.split("/").includes("..")) {
+    throw new Error(
+      "Library archive target must be a relative path inside the library folder."
+    );
+  }
+  if (!normalized.endsWith(WIKI_GRAPH_ARCHIVE_EXTENSION)) {
+    throw new Error("Library archive target must end with .wikg.");
+  }
+  return normalized;
+}
+function resolveLibraryRelativePath(root, relativePath) {
+  const path = resolve(root, relativePath);
+  const rel = relative(resolve(root), path);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error("Library archive target escapes the library folder.");
+  }
+  return path;
+}
+async function assertInsideLibrary(path, root) {
+  const rootRealPath = await realpath(root);
+  const rel = relative(rootRealPath, path);
+  if (rel.startsWith("..") || isAbsolute(rel)) {
+    throw new Error("Library archive path escapes the library folder.");
+  }
+}
+async function ensureLibraryArchiveMembershipColumns(database) {
+  const columns = await database.queryAll(
+    "PRAGMA table_info(library_archives)",
+    void 0,
+    (row) => getString(row, "name")
+  );
+  const columnSet = new Set(columns);
+  const additions = [
+    ["status", "TEXT NOT NULL DEFAULT 'present'"],
+    ["last_seen_mutation_token", "TEXT"],
+    ["last_seen_size", "INTEGER"],
+    ["last_seen_mtime_ms", "INTEGER"],
+    ["last_scanned_at", "TEXT"]
+  ];
+  for (const [name, definition] of additions) {
+    if (!columnSet.has(name)) {
+      await database.run(
+        `ALTER TABLE library_archives ADD COLUMN ${name} ${definition}`
+      );
+    }
+  }
+}
+async function ensureLibraryArchiveMembershipPathIndex(database) {
+  if (await hasUniqueLibraryArchiveRelativePathIndex(database)) {
+    await rebuildLibraryArchiveMembershipTable(database);
+  }
+  await database.run(
+    `
+      CREATE INDEX IF NOT EXISTS idx_library_archives_library_path
+      ON library_archives(library_id, relative_path)
+    `
+  );
+}
+async function hasUniqueLibraryArchiveRelativePathIndex(database) {
+  const indexes = await database.queryAll(
+    "PRAGMA index_list(library_archives)",
+    void 0,
+    (row) => ({
+      name: getString(row, "name"),
+      unique: getNumber(row, "unique") === 1
+    })
+  );
+  for (const index of indexes) {
+    if (!index.unique) {
+      continue;
+    }
+    const columns = await database.queryAll(
+      `PRAGMA index_info(${sqlStringLiteral(index.name)})`,
+      void 0,
+      (row) => getString(row, "name")
+    );
+    if (columns.length === 2 && columns[0] === "library_id" && columns[1] === "relative_path") {
+      return true;
+    }
+  }
+  return false;
+}
+async function rebuildLibraryArchiveMembershipTable(database) {
+  await database.transaction(async () => {
+    await database.run(
+      "ALTER TABLE library_archives RENAME TO library_archives_unique_path_legacy"
+    );
+    await database.run(`
+      CREATE TABLE library_archives (
+${LIBRARY_ARCHIVES_TABLE_COLUMNS_SQL}
+      )
+    `);
+    await database.run(`
+      INSERT INTO library_archives (
+        id, library_id, public_id, relative_path, status,
+        last_seen_mutation_token, last_seen_size, last_seen_mtime_ms,
+        last_scanned_at, created_at, updated_at
+      )
+      SELECT id, library_id, public_id, relative_path, status,
+        last_seen_mutation_token, last_seen_size, last_seen_mtime_ms,
+        last_scanned_at, created_at, updated_at
+      FROM library_archives_unique_path_legacy
+    `);
+    await database.run("DROP TABLE library_archives_unique_path_legacy");
+  });
+}
+function sqlStringLiteral(value) {
+  return `'${value.replace(/'/gu, "''")}'`;
+}
+async function createUniqueLibraryArchivePublicId(database, libraryId) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const publicId = randomBytes(PUBLIC_ID_BYTES).toString("hex");
+    const existing = await database.queryOne(
+      "SELECT public_id FROM library_archives WHERE library_id = ? AND public_id = ?",
+      [libraryId, publicId],
+      (row) => getString(row, "public_id")
+    );
+    if (existing === void 0) {
+      return publicId;
+    }
+  }
+  throw new Error("Could not generate a unique library archive id.");
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function normalizeArchiveStatus(value) {
+  if (value === "conflict" || value === "missing" || value === "present") {
+    return value;
+  }
+  return "present";
+}
+function optionalNumberField(row, dbKey, outputKey) {
+  const value = row[dbKey];
+  if (typeof value !== "number") {
+    return {};
+  }
+  return { [outputKey]: value };
+}
+function optionalStringField(row, dbKey, outputKey) {
+  const value = getOptionalString(row, dbKey);
+  if (value === void 0) {
+    return {};
+  }
+  return { [outputKey]: value };
+}
+export {
+  addWikiGraphLibraryArchive,
+  ensureLibraryManagedArchiveHasNoSearchIndex,
+  finalizeWikiGraphLibraryArchiveWrite,
+  getWikiGraphLibraryArchive,
+  getWikiGraphLibraryArchiveById,
+  listWikiGraphLibraryArchives,
+  moveWikiGraphLibraryArchive,
+  rebindWikiGraphLibrary,
+  removeWikiGraphLibraryArchive,
+  resolveWikiGraphLibraryArchivePath,
+  scanWikiGraphLibrary
+};
+//# sourceMappingURL=membership.js.map