wiki-graph-core 0.3.1 → 0.4.1

package/dist/state-lock.d.ts

@@ -0,0 +1,21 @@
+type StateLockMode = "read" | "write";
+interface StateLockOptions {
+    readonly databasePath: string;
+    readonly heartbeatMs?: number;
+    readonly mode: StateLockMode;
+    readonly pollMs?: number;
+    readonly resourceKey: string;
+    readonly scope: string;
+    readonly staleMs?: number;
+    readonly wait?: boolean;
+}
+declare function withStateLock<T>(options: StateLockOptions, operation: () => Promise<T> | T): Promise<T>;
+declare function acquireStateLock(options: StateLockOptions): Promise<(() => Promise<void>) | undefined>;
+declare function isStateLocked(options: {
+    readonly databasePath: string;
+    readonly resourceKey: string;
+    readonly scope: string;
+    readonly staleMs?: number;
+}): Promise<boolean>;
+
+export { type StateLockMode, type StateLockOptions, acquireStateLock, isStateLocked, withStateLock };

package/dist/state-lock.js

@@ -0,0 +1,233 @@
+import { randomUUID } from "crypto";
+import {
+  getNumber,
+  getString
+} from "./document/database.js";
+import { openSharedStateDatabase } from "./document/index.js";
+import { isNodeError } from "./utils/node-error.js";
+const STATE_LOCK_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS state_locks (
+    scope TEXT NOT NULL,
+    resource_key TEXT NOT NULL,
+    mode TEXT NOT NULL,
+    owner_id TEXT NOT NULL,
+    owner_pid INTEGER NOT NULL,
+    heartbeat_at INTEGER NOT NULL,
+    created_at INTEGER NOT NULL,
+    PRIMARY KEY (scope, resource_key, owner_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_state_locks_resource
+  ON state_locks(scope, resource_key);
+`;
+const DEFAULT_STATE_LOCK_POLL_MS = 100;
+const DEFAULT_STATE_LOCK_STALE_MS = 5 * 60 * 1e3;
+const DEFAULT_STATE_LOCK_HEARTBEAT_MS = 15e3;
+async function withStateLock(options, operation) {
+  const release = await acquireStateLock({ ...options, wait: true });
+  if (release === void 0) {
+    throw new Error("State lock was not acquired.");
+  }
+  try {
+    return await operation();
+  } finally {
+    await release();
+  }
+}
+async function acquireStateLock(options) {
+  const ownerId = `${process.pid}-${randomUUID()}`;
+  const pollMs = options.pollMs ?? DEFAULT_STATE_LOCK_POLL_MS;
+  while (true) {
+    const acquired = await tryInsertStateLock(options, ownerId);
+    if (acquired) {
+      return createStateLockRelease(options, ownerId);
+    }
+    if (options.wait === false) {
+      return void 0;
+    }
+    await delay(pollMs);
+  }
+}
+async function isStateLocked(options) {
+  const database = await openStateLockDatabase(options.databasePath);
+  try {
+    await cleanupStaleStateLocks(database, options);
+    const active = await database.queryOne(
+      `
+        SELECT 1 AS active
+        FROM state_locks
+        WHERE scope = ? AND resource_key = ?
+        LIMIT 1
+      `,
+      [options.scope, options.resourceKey],
+      () => true
+    );
+    return active === true;
+  } finally {
+    await database.close();
+  }
+}
+async function tryInsertStateLock(options, ownerId) {
+  const database = await openStateLockDatabase(options.databasePath);
+  const now = Date.now();
+  try {
+    return await database.transaction(async () => {
+      await cleanupStaleStateLocks(database, options);
+      const existingLocks = await database.queryAll(
+        `
+          SELECT mode, owner_id, owner_pid, heartbeat_at
+          FROM state_locks
+          WHERE scope = ? AND resource_key = ?
+        `,
+        [options.scope, options.resourceKey],
+        mapStateLockRow
+      );
+      if (existingLocks.some(
+        (lock) => lock.ownerId !== ownerId && locksConflict(options.mode, lock.mode)
+      )) {
+        return false;
+      }
+      await database.run(
+        `
+          INSERT INTO state_locks (
+            scope, resource_key, mode, owner_id, owner_pid, heartbeat_at, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `,
+        [
+          options.scope,
+          options.resourceKey,
+          options.mode,
+          ownerId,
+          process.pid,
+          now,
+          now
+        ]
+      );
+      return true;
+    });
+  } finally {
+    await database.close();
+  }
+}
+function createStateLockRelease(options, ownerId) {
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_STATE_LOCK_HEARTBEAT_MS;
+  const heartbeat = setInterval(() => {
+    void updateStateLockHeartbeat(options, ownerId).catch(() => void 0);
+  }, heartbeatMs);
+  heartbeat.unref?.();
+  return async () => {
+    clearInterval(heartbeat);
+    const database = await openStateLockDatabase(options.databasePath);
+    try {
+      await database.run(
+        `
+          DELETE FROM state_locks
+          WHERE scope = ? AND resource_key = ? AND owner_id = ?
+        `,
+        [options.scope, options.resourceKey, ownerId]
+      );
+    } finally {
+      await database.close();
+    }
+  };
+}
+async function updateStateLockHeartbeat(options, ownerId) {
+  const database = await openStateLockDatabase(options.databasePath);
+  try {
+    await database.run(
+      `
+        UPDATE state_locks
+        SET heartbeat_at = ?, owner_pid = ?
+        WHERE scope = ? AND resource_key = ? AND owner_id = ?
+      `,
+      [Date.now(), process.pid, options.scope, options.resourceKey, ownerId]
+    );
+  } finally {
+    await database.close();
+  }
+}
+async function cleanupStaleStateLocks(database, options) {
+  const clauses = [];
+  const parameters = [];
+  if (options.scope !== void 0) {
+    clauses.push("scope = ?");
+    parameters.push(options.scope);
+  }
+  if (options.resourceKey !== void 0) {
+    clauses.push("resource_key = ?");
+    parameters.push(options.resourceKey);
+  }
+  const rows = await database.queryAll(
+    `
+      SELECT scope, resource_key, mode, owner_id, owner_pid, heartbeat_at
+      FROM state_locks
+      ${clauses.length === 0 ? "" : `WHERE ${clauses.join(" AND ")}`}
+    `,
+    parameters,
+    (row) => ({
+      lock: mapStateLockRow(row),
+      resourceKey: getString(row, "resource_key"),
+      scope: getString(row, "scope")
+    })
+  );
+  for (const { lock, resourceKey, scope } of rows) {
+    if (!isStateLockStale(lock, options.staleMs)) {
+      continue;
+    }
+    await database.run(
+      `
+        DELETE FROM state_locks
+        WHERE scope = ?
+          AND resource_key = ?
+          AND owner_id = ?
+          AND heartbeat_at = ?
+      `,
+      [scope, resourceKey, lock.ownerId, lock.heartbeatAt]
+    );
+  }
+}
+async function openStateLockDatabase(databasePath) {
+  return await openSharedStateDatabase(databasePath, STATE_LOCK_SCHEMA_SQL);
+}
+function mapStateLockRow(row) {
+  return {
+    heartbeatAt: getNumber(row, "heartbeat_at"),
+    mode: getStateLockMode(getString(row, "mode")),
+    ownerId: getString(row, "owner_id"),
+    ownerPid: getNumber(row, "owner_pid")
+  };
+}
+function getStateLockMode(value) {
+  if (value === "read" || value === "write") {
+    return value;
+  }
+  return "write";
+}
+function locksConflict(requested, existing) {
+  return requested === "write" || existing === "write";
+}
+function isStateLockStale(lock, staleMs = DEFAULT_STATE_LOCK_STALE_MS) {
+  return Date.now() - lock.heartbeatAt > staleMs && !isProcessAlive(lock.ownerPid);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ESRCH") {
+      return false;
+    }
+    return true;
+  }
+}
+async function delay(ms) {
+  await new Promise((resolveDelay) => {
+    setTimeout(resolveDelay, ms);
+  });
+}
+export {
+  acquireStateLock,
+  isStateLocked,
+  withStateLock
+};
+//# sourceMappingURL=state-lock.js.map

package/dist/state-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/state-lock.ts"],"sourcesContent":["import { randomUUID } from \"crypto\";\n\nimport {\n  getNumber,\n  getString,\n  type Database,\n  type SqlRow,\n} from \"./document/database.js\";\nimport { openSharedStateDatabase } from \"./document/index.js\";\nimport { isNodeError } from \"./utils/node-error.js\";\n\nconst STATE_LOCK_SCHEMA_SQL = `\n  CREATE TABLE IF NOT EXISTS state_locks (\n    scope TEXT NOT NULL,\n    resource_key TEXT NOT NULL,\n    mode TEXT NOT NULL,\n    owner_id TEXT NOT NULL,\n    owner_pid INTEGER NOT NULL,\n    heartbeat_at INTEGER NOT NULL,\n    created_at INTEGER NOT NULL,\n    PRIMARY KEY (scope, resource_key, owner_id)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_state_locks_resource\n  ON state_locks(scope, resource_key);\n`;\nconst DEFAULT_STATE_LOCK_POLL_MS = 100;\nconst DEFAULT_STATE_LOCK_STALE_MS = 5 * 60 * 1000;\nconst DEFAULT_STATE_LOCK_HEARTBEAT_MS = 15_000;\n\nexport type StateLockMode = \"read\" | \"write\";\n\nexport interface StateLockOptions {\n  readonly databasePath: string;\n  readonly heartbeatMs?: number;\n  readonly mode: StateLockMode;\n  readonly pollMs?: number;\n  readonly resourceKey: string;\n  readonly scope: string;\n  readonly staleMs?: number;\n  readonly wait?: boolean;\n}\n\ninterface StateLockRow {\n  readonly heartbeatAt: number;\n  readonly mode: StateLockMode;\n  readonly ownerId: string;\n  readonly ownerPid: number;\n}\n\nexport async function withStateLock<T>(\n  options: StateLockOptions,\n  operation: () => Promise<T> | T,\n): Promise<T> {\n  const release = await acquireStateLock({ ...options, wait: true });\n\n  if (release === undefined) {\n    throw new Error(\"State lock was not acquired.\");\n  }\n\n  try {\n    return await operation();\n  } finally {\n    await release();\n  }\n}\n\nexport async function acquireStateLock(\n  options: StateLockOptions,\n): Promise<(() => Promise<void>) | undefined> {\n  const ownerId = `${process.pid}-${randomUUID()}`;\n  const pollMs = options.pollMs ?? DEFAULT_STATE_LOCK_POLL_MS;\n\n  while (true) {\n    const acquired = await tryInsertStateLock(options, ownerId);\n\n    if (acquired) {\n      return createStateLockRelease(options, ownerId);\n    }\n\n    if (options.wait === false) {\n      return undefined;\n    }\n\n    await delay(pollMs);\n  }\n}\n\nexport async function isStateLocked(options: {\n  readonly databasePath: string;\n  readonly resourceKey: string;\n  readonly scope: string;\n  readonly staleMs?: number;\n}): Promise<boolean> {\n  const database = await openStateLockDatabase(options.databasePath);\n\n  try {\n    await cleanupStaleStateLocks(database, options);\n    const active = await database.queryOne(\n      `\n        SELECT 1 AS active\n        FROM state_locks\n        WHERE scope = ? AND resource_key = ?\n        LIMIT 1\n      `,\n      [options.scope, options.resourceKey],\n      () => true,\n    );\n\n    return active === true;\n  } finally {\n    await database.close();\n  }\n}\n\nasync function tryInsertStateLock(\n  options: StateLockOptions,\n  ownerId: string,\n): Promise<boolean> {\n  const database = await openStateLockDatabase(options.databasePath);\n  const now = Date.now();\n\n  try {\n    return await database.transaction(async () => {\n      await cleanupStaleStateLocks(database, options);\n      const existingLocks = await database.queryAll(\n        `\n          SELECT mode, owner_id, owner_pid, heartbeat_at\n          FROM state_locks\n          WHERE scope = ? AND resource_key = ?\n        `,\n        [options.scope, options.resourceKey],\n        mapStateLockRow,\n      );\n\n      if (\n        existingLocks.some(\n          (lock) =>\n            lock.ownerId !== ownerId && locksConflict(options.mode, lock.mode),\n        )\n      ) {\n        return false;\n      }\n\n      await database.run(\n        `\n          INSERT INTO state_locks (\n            scope, resource_key, mode, owner_id, owner_pid, heartbeat_at, created_at\n          ) VALUES (?, ?, ?, ?, ?, ?, ?)\n        `,\n        [\n          options.scope,\n          options.resourceKey,\n          options.mode,\n          ownerId,\n          process.pid,\n          now,\n          now,\n        ],\n      );\n      return true;\n    });\n  } finally {\n    await database.close();\n  }\n}\n\nfunction createStateLockRelease(\n  options: StateLockOptions,\n  ownerId: string,\n): () => Promise<void> {\n  const heartbeatMs = options.heartbeatMs ?? DEFAULT_STATE_LOCK_HEARTBEAT_MS;\n  const heartbeat = setInterval(() => {\n    void updateStateLockHeartbeat(options, ownerId).catch(() => undefined);\n  }, heartbeatMs);\n  heartbeat.unref?.();\n\n  return async () => {\n    clearInterval(heartbeat);\n    const database = await openStateLockDatabase(options.databasePath);\n\n    try {\n      await database.run(\n        `\n          DELETE FROM state_locks\n          WHERE scope = ? AND resource_key = ? AND owner_id = ?\n        `,\n        [options.scope, options.resourceKey, ownerId],\n      );\n    } finally {\n      await database.close();\n    }\n  };\n}\n\nasync function updateStateLockHeartbeat(\n  options: StateLockOptions,\n  ownerId: string,\n): Promise<void> {\n  const database = await openStateLockDatabase(options.databasePath);\n\n  try {\n    await database.run(\n      `\n        UPDATE state_locks\n        SET heartbeat_at = ?, owner_pid = ?\n        WHERE scope = ? AND resource_key = ? AND owner_id = ?\n      `,\n      [Date.now(), process.pid, options.scope, options.resourceKey, ownerId],\n    );\n  } finally {\n    await database.close();\n  }\n}\n\nasync function cleanupStaleStateLocks(\n  database: Database,\n  options: {\n    readonly resourceKey?: string;\n    readonly scope?: string;\n    readonly staleMs?: number;\n  },\n): Promise<void> {\n  const clauses: string[] = [];\n  const parameters: string[] = [];\n\n  if (options.scope !== undefined) {\n    clauses.push(\"scope = ?\");\n    parameters.push(options.scope);\n  }\n  if (options.resourceKey !== undefined) {\n    clauses.push(\"resource_key = ?\");\n    parameters.push(options.resourceKey);\n  }\n\n  const rows = await database.queryAll(\n    `\n      SELECT scope, resource_key, mode, owner_id, owner_pid, heartbeat_at\n      FROM state_locks\n      ${clauses.length === 0 ? \"\" : `WHERE ${clauses.join(\" AND \")}`}\n    `,\n    parameters,\n    (row) => ({\n      lock: mapStateLockRow(row),\n      resourceKey: getString(row, \"resource_key\"),\n      scope: getString(row, \"scope\"),\n    }),\n  );\n\n  for (const { lock, resourceKey, scope } of rows) {\n    if (!isStateLockStale(lock, options.staleMs)) {\n      continue;\n    }\n\n    await database.run(\n      `\n        DELETE FROM state_locks\n        WHERE scope = ?\n          AND resource_key = ?\n          AND owner_id = ?\n          AND heartbeat_at = ?\n      `,\n      [scope, resourceKey, lock.ownerId, lock.heartbeatAt],\n    );\n  }\n}\n\nasync function openStateLockDatabase(databasePath: string): Promise<Database> {\n  return await openSharedStateDatabase(databasePath, STATE_LOCK_SCHEMA_SQL);\n}\n\nfunction mapStateLockRow(row: SqlRow): StateLockRow {\n  return {\n    heartbeatAt: getNumber(row, \"heartbeat_at\"),\n    mode: getStateLockMode(getString(row, \"mode\")),\n    ownerId: getString(row, \"owner_id\"),\n    ownerPid: getNumber(row, \"owner_pid\"),\n  };\n}\n\nfunction getStateLockMode(value: string): StateLockMode {\n  if (value === \"read\" || value === \"write\") {\n    return value;\n  }\n\n  return \"write\";\n}\n\nfunction locksConflict(\n  requested: StateLockMode,\n  existing: StateLockMode,\n): boolean {\n  return requested === \"write\" || existing === \"write\";\n}\n\nfunction isStateLockStale(\n  lock: Pick<StateLockRow, \"heartbeatAt\" | \"ownerPid\">,\n  staleMs = DEFAULT_STATE_LOCK_STALE_MS,\n): boolean {\n  return (\n    Date.now() - lock.heartbeatAt > staleMs && !isProcessAlive(lock.ownerPid)\n  );\n}\n\nfunction isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (error) {\n    if (isNodeError(error) && error.code === \"ESRCH\") {\n      return false;\n    }\n\n    return true;\n  }\n}\n\nasync function delay(ms: number): Promise<void> {\n  await new Promise<void>((resolveDelay) => {\n    setTimeout(resolveDelay, ms);\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/storage/migration/legacy-sdpub/upgrade/archive.d.ts

@@ -0,0 +1,11 @@
+import { ZipFile, Entry } from 'yauzl';
+
+declare function indexArchiveEntries(zipFile: ZipFile): Promise<readonly Entry[]>;
+declare function isLegacySdpubPath(archivePath: string): boolean;
+declare function assertWithinDirectory(rootDirectoryPath: string, targetPath: string, archivePath: string): void;
+declare function normalizeArchivePath(path: string): string;
+declare function openArchive(path: string): Promise<ZipFile>;
+declare function openArchiveEntryStream(zipFile: ZipFile, entry: Entry): Promise<NodeJS.ReadableStream>;
+declare function readArchiveEntryText(zipFile: ZipFile, entry: Entry): Promise<string>;
+
+export { assertWithinDirectory, indexArchiveEntries, isLegacySdpubPath, normalizeArchivePath, openArchive, openArchiveEntryStream, readArchiveEntryText };

package/dist/storage/migration/legacy-sdpub/upgrade/archive.js

@@ -0,0 +1,94 @@
+import { posix, resolve, sep } from "path";
+import {
+  open as openZip
+} from "yauzl";
+const LEGACY_SDPUB_PATTERNS = [
+  /^manifest\.json$/u,
+  /^database\.db$/u,
+  /^toc\.json$/u,
+  /^cover\/(?:data\.bin|info\.json)$/u,
+  /^summaries\/serial-\d+\.txt$/u,
+  /^fragments\/serial-\d+\/fragment_\d+\.json$/u
+];
+async function indexArchiveEntries(zipFile) {
+  return await new Promise((resolve2, reject) => {
+    const entries = [];
+    zipFile.on("entry", (entry) => {
+      if (entry.fileName.endsWith("/")) {
+        zipFile.readEntry();
+        return;
+      }
+      entries.push(entry);
+      zipFile.readEntry();
+    });
+    zipFile.once("end", () => {
+      resolve2(entries);
+    });
+    zipFile.once("error", (error) => {
+      reject(error);
+    });
+    zipFile.readEntry();
+  });
+}
+function isLegacySdpubPath(archivePath) {
+  return LEGACY_SDPUB_PATTERNS.some((pattern) => pattern.test(archivePath));
+}
+function assertWithinDirectory(rootDirectoryPath, targetPath, archivePath) {
+  const resolvedRootDirectoryPath = resolve(rootDirectoryPath);
+  const rootPrefix = resolvedRootDirectoryPath.endsWith(sep) ? resolvedRootDirectoryPath : `${resolvedRootDirectoryPath}${sep}`;
+  if (targetPath === resolvedRootDirectoryPath || targetPath.startsWith(rootPrefix)) {
+    return;
+  }
+  throw new Error(`Invalid archive entry path: ${archivePath}`);
+}
+function normalizeArchivePath(path) {
+  const normalized = path.replaceAll("\\", "/").trim();
+  const withoutLeadingSlash = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+  return posix.normalize(withoutLeadingSlash).replace(/^(\.\/)+/u, "").replace(/^\/+/u, "");
+}
+async function openArchive(path) {
+  return await new Promise((resolveOpen, rejectOpen) => {
+    openZip(path, { autoClose: false, lazyEntries: true }, (error, zipFile) => {
+      if (error !== null || zipFile === void 0) {
+        rejectOpen(error ?? new Error(`Cannot open archive: ${path}`));
+        return;
+      }
+      resolveOpen(zipFile);
+    });
+  });
+}
+async function openArchiveEntryStream(zipFile, entry) {
+  return await new Promise((resolveStream, rejectStream) => {
+    zipFile.openReadStream(entry, (error, stream) => {
+      if (error !== null || stream === void 0) {
+        rejectStream(
+          error ?? new Error(`Cannot open archive entry: ${entry.fileName}`)
+        );
+        return;
+      }
+      resolveStream(stream);
+    });
+  });
+}
+async function readArchiveEntryText(zipFile, entry) {
+  const chunks = [];
+  const stream = await openArchiveEntryStream(zipFile, entry);
+  await new Promise((resolveRead, rejectRead) => {
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    stream.once("end", resolveRead);
+    stream.once("error", rejectRead);
+  });
+  return Buffer.concat(chunks).toString("utf8");
+}
+export {
+  assertWithinDirectory,
+  indexArchiveEntries,
+  isLegacySdpubPath,
+  normalizeArchivePath,
+  openArchive,
+  openArchiveEntryStream,
+  readArchiveEntryText
+};
+//# sourceMappingURL=archive.js.map

package/dist/storage/migration/legacy-sdpub/upgrade/archive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/storage/migration/legacy-sdpub/upgrade/archive.ts"],"sourcesContent":["import { posix, resolve, sep } from \"path\";\nimport {\n  open as openZip,\n  type Entry,\n  type ZipFile as YauzlZipFile,\n} from \"yauzl\";\n\nconst LEGACY_SDPUB_PATTERNS = [\n  /^manifest\\.json$/u,\n  /^database\\.db$/u,\n  /^toc\\.json$/u,\n  /^cover\\/(?:data\\.bin|info\\.json)$/u,\n  /^summaries\\/serial-\\d+\\.txt$/u,\n  /^fragments\\/serial-\\d+\\/fragment_\\d+\\.json$/u,\n] as const;\n\nexport async function indexArchiveEntries(\n  zipFile: YauzlZipFile,\n): Promise<readonly Entry[]> {\n  return await new Promise((resolve, reject) => {\n    const entries: Entry[] = [];\n\n    zipFile.on(\"entry\", (entry: Entry) => {\n      if (entry.fileName.endsWith(\"/\")) {\n        zipFile.readEntry();\n        return;\n      }\n\n      entries.push(entry);\n      zipFile.readEntry();\n    });\n    zipFile.once(\"end\", () => {\n      resolve(entries);\n    });\n    zipFile.once(\"error\", (error: Error) => {\n      reject(error);\n    });\n\n    zipFile.readEntry();\n  });\n}\n\nexport function isLegacySdpubPath(archivePath: string): boolean {\n  return LEGACY_SDPUB_PATTERNS.some((pattern) => pattern.test(archivePath));\n}\n\nexport function assertWithinDirectory(\n  rootDirectoryPath: string,\n  targetPath: string,\n  archivePath: string,\n): void {\n  const resolvedRootDirectoryPath = resolve(rootDirectoryPath);\n  const rootPrefix = resolvedRootDirectoryPath.endsWith(sep)\n    ? resolvedRootDirectoryPath\n    : `${resolvedRootDirectoryPath}${sep}`;\n\n  if (\n    targetPath === resolvedRootDirectoryPath ||\n    targetPath.startsWith(rootPrefix)\n  ) {\n    return;\n  }\n\n  throw new Error(`Invalid archive entry path: ${archivePath}`);\n}\n\nexport function normalizeArchivePath(path: string): string {\n  const normalized = path.replaceAll(\"\\\\\", \"/\").trim();\n  const withoutLeadingSlash = normalized.startsWith(\"/\")\n    ? normalized.slice(1)\n    : normalized;\n\n  return posix\n    .normalize(withoutLeadingSlash)\n    .replace(/^(\\.\\/)+/u, \"\")\n    .replace(/^\\/+/u, \"\");\n}\n\nexport async function openArchive(path: string): Promise<YauzlZipFile> {\n  return await new Promise((resolveOpen, rejectOpen) => {\n    openZip(path, { autoClose: false, lazyEntries: true }, (error, zipFile) => {\n      if (error !== null || zipFile === undefined) {\n        rejectOpen(error ?? new Error(`Cannot open archive: ${path}`));\n        return;\n      }\n\n      resolveOpen(zipFile);\n    });\n  });\n}\n\nexport async function openArchiveEntryStream(\n  zipFile: YauzlZipFile,\n  entry: Entry,\n): Promise<NodeJS.ReadableStream> {\n  return await new Promise((resolveStream, rejectStream) => {\n    zipFile.openReadStream(entry, (error, stream) => {\n      if (error !== null || stream === undefined) {\n        rejectStream(\n          error ?? new Error(`Cannot open archive entry: ${entry.fileName}`),\n        );\n        return;\n      }\n\n      resolveStream(stream);\n    });\n  });\n}\n\nexport async function readArchiveEntryText(\n  zipFile: YauzlZipFile,\n  entry: Entry,\n): Promise<string> {\n  const chunks: Buffer[] = [];\n  const stream = await openArchiveEntryStream(zipFile, entry);\n\n  await new Promise<void>((resolveRead, rejectRead) => {\n    stream.on(\"data\", (chunk: Buffer) => {\n      chunks.push(chunk);\n    });\n    stream.once(\"end\", resolveRead);\n    stream.once(\"error\", rejectRead);\n  });\n\n  return Buffer.concat(chunks).toString(\"utf8\");\n}\n"],"mappings":"AAAA,SAAS,OAAO,SAAS,WAAW;AACpC;AAAA,EACE,QAAQ;AAAA,OAGH;AAEP,MAAM,wBAAwB;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEA,eAAsB,oBACpB,SAC2B;AAC3B,SAAO,MAAM,IAAI,QAAQ,CAACA,UAAS,WAAW;AAC5C,UAAM,UAAmB,CAAC;AAE1B,YAAQ,GAAG,SAAS,CAAC,UAAiB;AACpC,UAAI,MAAM,SAAS,SAAS,GAAG,GAAG;AAChC,gBAAQ,UAAU;AAClB;AAAA,MACF;AAEA,cAAQ,KAAK,KAAK;AAClB,cAAQ,UAAU;AAAA,IACpB,CAAC;AACD,YAAQ,KAAK,OAAO,MAAM;AACxB,MAAAA,SAAQ,OAAO;AAAA,IACjB,CAAC;AACD,YAAQ,KAAK,SAAS,CAAC,UAAiB;AACtC,aAAO,KAAK;AAAA,IACd,CAAC;AAED,YAAQ,UAAU;AAAA,EACpB,CAAC;AACH;AAEO,SAAS,kBAAkB,aAA8B;AAC9D,SAAO,sBAAsB,KAAK,CAAC,YAAY,QAAQ,KAAK,WAAW,CAAC;AAC1E;AAEO,SAAS,sBACd,mBACA,YACA,aACM;AACN,QAAM,4BAA4B,QAAQ,iBAAiB;AAC3D,QAAM,aAAa,0BAA0B,SAAS,GAAG,IACrD,4BACA,GAAG,yBAAyB,GAAG,GAAG;AAEtC,MACE,eAAe,6BACf,WAAW,WAAW,UAAU,GAChC;AACA;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,+BAA+B,WAAW,EAAE;AAC9D;AAEO,SAAS,qBAAqB,MAAsB;AACzD,QAAM,aAAa,KAAK,WAAW,MAAM,GAAG,EAAE,KAAK;AACnD,QAAM,sBAAsB,WAAW,WAAW,GAAG,IACjD,WAAW,MAAM,CAAC,IAClB;AAEJ,SAAO,MACJ,UAAU,mBAAmB,EAC7B,QAAQ,aAAa,EAAE,EACvB,QAAQ,SAAS,EAAE;AACxB;AAEA,eAAsB,YAAY,MAAqC;AACrE,SAAO,MAAM,IAAI,QAAQ,CAAC,aAAa,eAAe;AACpD,YAAQ,MAAM,EAAE,WAAW,OAAO,aAAa,KAAK,GAAG,CAAC,OAAO,YAAY;AACzE,UAAI,UAAU,QAAQ,YAAY,QAAW;AAC3C,mBAAW,SAAS,IAAI,MAAM,wBAAwB,IAAI,EAAE,CAAC;AAC7D;AAAA,MACF;AAEA,kBAAY,OAAO;AAAA,IACrB,CAAC;AAAA,EACH,CAAC;AACH;AAEA,eAAsB,uBACpB,SACA,OACgC;AAChC,SAAO,MAAM,IAAI,QAAQ,CAAC,eAAe,iBAAiB;AACxD,YAAQ,eAAe,OAAO,CAAC,OAAO,WAAW;AAC/C,UAAI,UAAU,QAAQ,WAAW,QAAW;AAC1C;AAAA,UACE,SAAS,IAAI,MAAM,8BAA8B,MAAM,QAAQ,EAAE;AAAA,QACnE;AACA;AAAA,MACF;AAEA,oBAAc,MAAM;AAAA,IACtB,CAAC;AAAA,EACH,CAAC;AACH;AAEA,eAAsB,qBACpB,SACA,OACiB;AACjB,QAAM,SAAmB,CAAC;AAC1B,QAAM,SAAS,MAAM,uBAAuB,SAAS,KAAK;AAE1D,QAAM,IAAI,QAAc,CAAC,aAAa,eAAe;AACnD,WAAO,GAAG,QAAQ,CAAC,UAAkB;AACnC,aAAO,KAAK,KAAK;AAAA,IACnB,CAAC;AACD,WAAO,KAAK,OAAO,WAAW;AAC9B,WAAO,KAAK,SAAS,UAAU;AAAA,EACjC,CAAC;AAED,SAAO,OAAO,OAAO,MAAM,EAAE,SAAS,MAAM;AAC9C;","names":["resolve"]}

package/dist/storage/migration/legacy-sdpub/upgrade/database.d.ts

@@ -0,0 +1,7 @@
+import { Database } from '../../../../document/database.js';
+import 'sqlite3';
+
+declare function listTableNames(database: Database): Promise<ReadonlySet<string>>;
+declare function listTableColumns(database: Database, tableName: string): Promise<ReadonlySet<string>>;
+
+export { listTableColumns, listTableNames };

package/dist/storage/migration/legacy-sdpub/upgrade/database.js

@@ -0,0 +1,28 @@
+async function listTableNames(database) {
+  const names = await database.queryAll(
+    `
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'table'
+    `,
+    void 0,
+    (row) => String(row.name)
+  );
+  return new Set(names);
+}
+async function listTableColumns(database, tableName) {
+  const columns = await database.queryAll(
+    `PRAGMA table_info(${quoteSqlIdentifier(tableName)})`,
+    void 0,
+    (row) => String(row.name)
+  );
+  return new Set(columns);
+}
+function quoteSqlIdentifier(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+export {
+  listTableColumns,
+  listTableNames
+};
+//# sourceMappingURL=database.js.map

package/dist/storage/migration/legacy-sdpub/upgrade/database.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/storage/migration/legacy-sdpub/upgrade/database.ts"],"sourcesContent":["import type { Database } from \"../../../../document/database.js\";\n\nexport async function listTableNames(\n  database: Database,\n): Promise<ReadonlySet<string>> {\n  const names = await database.queryAll(\n    `\n      SELECT name\n      FROM sqlite_master\n      WHERE type = 'table'\n    `,\n    undefined,\n    (row) => String(row.name),\n  );\n\n  return new Set(names);\n}\n\nexport async function listTableColumns(\n  database: Database,\n  tableName: string,\n): Promise<ReadonlySet<string>> {\n  const columns = await database.queryAll(\n    `PRAGMA table_info(${quoteSqlIdentifier(tableName)})`,\n    undefined,\n    (row) => String(row.name),\n  );\n\n  return new Set(columns);\n}\n\nfunction quoteSqlIdentifier(identifier: string): string {\n  return `\"${identifier.replaceAll('\"', '\"\"')}\"`;\n}\n"],"mappings":"AAEA,eAAsB,eACpB,UAC8B;AAC9B,QAAM,QAAQ,MAAM,SAAS;AAAA,IAC3B;AAAA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA,IACA,CAAC,QAAQ,OAAO,IAAI,IAAI;AAAA,EAC1B;AAEA,SAAO,IAAI,IAAI,KAAK;AACtB;AAEA,eAAsB,iBACpB,UACA,WAC8B;AAC9B,QAAM,UAAU,MAAM,SAAS;AAAA,IAC7B,qBAAqB,mBAAmB,SAAS,CAAC;AAAA,IAClD;AAAA,IACA,CAAC,QAAQ,OAAO,IAAI,IAAI;AAAA,EAC1B;AAEA,SAAO,IAAI,IAAI,OAAO;AACxB;AAEA,SAAS,mBAAmB,YAA4B;AACtD,SAAO,IAAI,WAAW,WAAW,KAAK,IAAI,CAAC;AAC7C;","names":[]}

package/dist/storage/migration/legacy-sdpub/upgrade/extract.d.ts

@@ -0,0 +1,3 @@
+declare function extractLegacySdpubArchive(inputPath: string, outputDirectoryPath: string): Promise<void>;
+
+export { extractLegacySdpubArchive };

package/dist/storage/migration/legacy-sdpub/upgrade/extract.js

@@ -0,0 +1,68 @@
+import { createWriteStream } from "fs";
+import { mkdir } from "fs/promises";
+import { dirname, resolve } from "path";
+import { pipeline } from "stream/promises";
+import {
+  assertWithinDirectory,
+  indexArchiveEntries,
+  isLegacySdpubPath,
+  normalizeArchivePath,
+  openArchive,
+  openArchiveEntryStream,
+  readArchiveEntryText
+} from "./archive.js";
+const LEGACY_FORMAT_VERSION = 1;
+async function extractLegacySdpubArchive(inputPath, outputDirectoryPath) {
+  const zipFile = await openArchive(inputPath);
+  try {
+    const entries = await indexArchiveEntries(zipFile);
+    await assertLegacySdpubArchive(zipFile, entries);
+    for (const entry of entries) {
+      const archivePath = normalizeArchivePath(entry.fileName);
+      if (archivePath === "" || !isLegacySdpubPath(archivePath)) {
+        continue;
+      }
+      const targetPath = resolve(outputDirectoryPath, archivePath);
+      assertWithinDirectory(outputDirectoryPath, targetPath, archivePath);
+      await mkdir(dirname(targetPath), { recursive: true });
+      await pipeline(
+        await openArchiveEntryStream(zipFile, entry),
+        createWriteStream(targetPath)
+      );
+    }
+  } finally {
+    zipFile.close();
+  }
+}
+async function assertLegacySdpubArchive(zipFile, entries) {
+  const paths = new Set(
+    entries.map((entry) => normalizeArchivePath(entry.fileName))
+  );
+  if (!paths.has("database.db") || !paths.has("toc.json")) {
+    throw new Error("Unsupported legacy sdpub archive.");
+  }
+  if (paths.has("manifest.json")) {
+    const manifestEntry = entries.find(
+      (entry) => normalizeArchivePath(entry.fileName) === "manifest.json"
+    );
+    if (manifestEntry === void 0) {
+      throw new Error("Unsupported legacy sdpub archive.");
+    }
+    assertSupportedManifest(await readArchiveEntryText(zipFile, manifestEntry));
+  }
+}
+function assertSupportedManifest(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.formatVersion === LEGACY_FORMAT_VERSION) {
+      return;
+    }
+  } catch {
+    throw new Error("Unsupported legacy sdpub archive.");
+  }
+  throw new Error("Unsupported legacy sdpub archive.");
+}
+export {
+  extractLegacySdpubArchive
+};
+//# sourceMappingURL=extract.js.map

package/dist/storage/migration/legacy-sdpub/upgrade/extract.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/storage/migration/legacy-sdpub/upgrade/extract.ts"],"sourcesContent":["import { createWriteStream } from \"fs\";\nimport { mkdir } from \"fs/promises\";\nimport { dirname, resolve } from \"path\";\nimport { pipeline } from \"stream/promises\";\n\nimport type { Entry, ZipFile as YauzlZipFile } from \"yauzl\";\n\nimport {\n  assertWithinDirectory,\n  indexArchiveEntries,\n  isLegacySdpubPath,\n  normalizeArchivePath,\n  openArchive,\n  openArchiveEntryStream,\n  readArchiveEntryText,\n} from \"./archive.js\";\n\nconst LEGACY_FORMAT_VERSION = 1;\n\nexport async function extractLegacySdpubArchive(\n  inputPath: string,\n  outputDirectoryPath: string,\n): Promise<void> {\n  const zipFile = await openArchive(inputPath);\n\n  try {\n    const entries = await indexArchiveEntries(zipFile);\n\n    await assertLegacySdpubArchive(zipFile, entries);\n    for (const entry of entries) {\n      const archivePath = normalizeArchivePath(entry.fileName);\n\n      if (archivePath === \"\" || !isLegacySdpubPath(archivePath)) {\n        continue;\n      }\n\n      const targetPath = resolve(outputDirectoryPath, archivePath);\n\n      assertWithinDirectory(outputDirectoryPath, targetPath, archivePath);\n      await mkdir(dirname(targetPath), { recursive: true });\n      await pipeline(\n        await openArchiveEntryStream(zipFile, entry),\n        createWriteStream(targetPath),\n      );\n    }\n  } finally {\n    zipFile.close();\n  }\n}\n\nasync function assertLegacySdpubArchive(\n  zipFile: YauzlZipFile,\n  entries: readonly Entry[],\n): Promise<void> {\n  const paths = new Set(\n    entries.map((entry) => normalizeArchivePath(entry.fileName)),\n  );\n\n  if (!paths.has(\"database.db\") || !paths.has(\"toc.json\")) {\n    throw new Error(\"Unsupported legacy sdpub archive.\");\n  }\n  if (paths.has(\"manifest.json\")) {\n    const manifestEntry = entries.find(\n      (entry) => normalizeArchivePath(entry.fileName) === \"manifest.json\",\n    );\n\n    if (manifestEntry === undefined) {\n      throw new Error(\"Unsupported legacy sdpub archive.\");\n    }\n\n    assertSupportedManifest(await readArchiveEntryText(zipFile, manifestEntry));\n  }\n}\n\nfunction assertSupportedManifest(content: string): void {\n  try {\n    const parsed = JSON.parse(content) as { readonly formatVersion?: unknown };\n\n    if (parsed.formatVersion === LEGACY_FORMAT_VERSION) {\n      return;\n    }\n  } catch {\n    throw new Error(\"Unsupported legacy sdpub archive.\");\n  }\n\n  throw new Error(\"Unsupported legacy sdpub archive.\");\n}\n"],"mappings":"AAAA,SAAS,yBAAyB;AAClC,SAAS,aAAa;AACtB,SAAS,SAAS,eAAe;AACjC,SAAS,gBAAgB;AAIzB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,MAAM,wBAAwB;AAE9B,eAAsB,0BACpB,WACA,qBACe;AACf,QAAM,UAAU,MAAM,YAAY,SAAS;AAE3C,MAAI;AACF,UAAM,UAAU,MAAM,oBAAoB,OAAO;AAEjD,UAAM,yBAAyB,SAAS,OAAO;AAC/C,eAAW,SAAS,SAAS;AAC3B,YAAM,cAAc,qBAAqB,MAAM,QAAQ;AAEvD,UAAI,gBAAgB,MAAM,CAAC,kBAAkB,WAAW,GAAG;AACzD;AAAA,MACF;AAEA,YAAM,aAAa,QAAQ,qBAAqB,WAAW;AAE3D,4BAAsB,qBAAqB,YAAY,WAAW;AAClE,YAAM,MAAM,QAAQ,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACpD,YAAM;AAAA,QACJ,MAAM,uBAAuB,SAAS,KAAK;AAAA,QAC3C,kBAAkB,UAAU;AAAA,MAC9B;AAAA,IACF;AAAA,EACF,UAAE;AACA,YAAQ,MAAM;AAAA,EAChB;AACF;AAEA,eAAe,yBACb,SACA,SACe;AACf,QAAM,QAAQ,IAAI;AAAA,IAChB,QAAQ,IAAI,CAAC,UAAU,qBAAqB,MAAM,QAAQ,CAAC;AAAA,EAC7D;AAEA,MAAI,CAAC,MAAM,IAAI,aAAa,KAAK,CAAC,MAAM,IAAI,UAAU,GAAG;AACvD,UAAM,IAAI,MAAM,mCAAmC;AAAA,EACrD;AACA,MAAI,MAAM,IAAI,eAAe,GAAG;AAC9B,UAAM,gBAAgB,QAAQ;AAAA,MAC5B,CAAC,UAAU,qBAAqB,MAAM,QAAQ,MAAM;AAAA,IACtD;AAEA,QAAI,kBAAkB,QAAW;AAC/B,YAAM,IAAI,MAAM,mCAAmC;AAAA,IACrD;AAEA,4BAAwB,MAAM,qBAAqB,SAAS,aAAa,CAAC;AAAA,EAC5E;AACF;AAEA,SAAS,wBAAwB,SAAuB;AACtD,MAAI;AACF,UAAM,SAAS,KAAK,MAAM,OAAO;AAEjC,QAAI,OAAO,kBAAkB,uBAAuB;AAClD;AAAA,IACF;AAAA,EACF,QAAQ;AACN,UAAM,IAAI,MAAM,mCAAmC;AAAA,EACrD;AAEA,QAAM,IAAI,MAAM,mCAAmC;AACrD;","names":[]}

package/dist/storage/migration/legacy-sdpub/upgrade/index.js

@@ -0,0 +1,47 @@
+import { rm } from "fs/promises";
+import { join, resolve } from "path";
+import { createWikiGraphTempDirectory } from "../../../../runtime/common/wiki-graph/temp.js";
+import { DirectoryDocument } from "../../../../document/index.js";
+import { writeWikgArchive } from "../../../wikg/index.js";
+import { extractLegacySdpubArchive } from "./extract.js";
+import { migrateLegacyDatabase } from "./schema.js";
+import { migrateLegacyTextStorage } from "./text-storage/index.js";
+async function migrateLegacySdpubToWikg(inputPath, outputPath = defaultWikgOutputPath(inputPath)) {
+  if (resolve(inputPath) === resolve(outputPath)) {
+    throw new Error(
+      "Legacy migration output path must differ from input path."
+    );
+  }
+  const workspacePath = await createWikiGraphTempDirectory("sdpub-upgrade");
+  try {
+    await extractLegacySdpubArchive(inputPath, workspacePath);
+    await migrateLegacyDatabase(join(workspacePath, "database.db"));
+    await migrateLegacyTextStorage(workspacePath);
+    await normalizeLegacyToc(workspacePath);
+    await writeWikgArchive(workspacePath, outputPath);
+    return { inputPath, outputPath };
+  } finally {
+    await rm(workspacePath, { force: true, recursive: true });
+  }
+}
+async function normalizeLegacyToc(workspacePath) {
+  const document = await DirectoryDocument.open(workspacePath);
+  try {
+    const toc = await document.readToc();
+    if (toc !== void 0) {
+      await document.replaceToc(toc);
+    }
+  } finally {
+    await document.release();
+  }
+}
+function defaultWikgOutputPath(inputPath) {
+  if (inputPath.toLowerCase().endsWith(".sdpub")) {
+    return `${inputPath.slice(0, -".sdpub".length)}.wikg`;
+  }
+  return `${inputPath}.wikg`;
+}
+export {
+  migrateLegacySdpubToWikg
+};
+//# sourceMappingURL=index.js.map

package/dist/storage/migration/legacy-sdpub/upgrade/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/storage/migration/legacy-sdpub/upgrade/index.ts"],"sourcesContent":["import { rm } from \"fs/promises\";\nimport { join, resolve } from \"path\";\n\nimport { createWikiGraphTempDirectory } from \"../../../../runtime/common/wiki-graph/temp.js\";\nimport { DirectoryDocument } from \"../../../../document/index.js\";\nimport { writeWikgArchive } from \"../../../wikg/index.js\";\nimport { extractLegacySdpubArchive } from \"./extract.js\";\nimport { migrateLegacyDatabase } from \"./schema.js\";\nimport { migrateLegacyTextStorage } from \"./text-storage/index.js\";\n\nexport interface LegacySdpubMigrationResult {\n  readonly inputPath: string;\n  readonly outputPath: string;\n}\n\nexport async function migrateLegacySdpubToWikg(\n  inputPath: string,\n  outputPath = defaultWikgOutputPath(inputPath),\n): Promise<LegacySdpubMigrationResult> {\n  if (resolve(inputPath) === resolve(outputPath)) {\n    throw new Error(\n      \"Legacy migration output path must differ from input path.\",\n    );\n  }\n\n  const workspacePath = await createWikiGraphTempDirectory(\"sdpub-upgrade\");\n\n  try {\n    await extractLegacySdpubArchive(inputPath, workspacePath);\n    await migrateLegacyDatabase(join(workspacePath, \"database.db\"));\n    await migrateLegacyTextStorage(workspacePath);\n    await normalizeLegacyToc(workspacePath);\n    await writeWikgArchive(workspacePath, outputPath);\n\n    return { inputPath, outputPath };\n  } finally {\n    await rm(workspacePath, { force: true, recursive: true });\n  }\n}\n\nasync function normalizeLegacyToc(workspacePath: string): Promise<void> {\n  const document = await DirectoryDocument.open(workspacePath);\n\n  try {\n    const toc = await document.readToc();\n\n    if (toc !== undefined) {\n      await document.replaceToc(toc);\n    }\n  } finally {\n    await document.release();\n  }\n}\n\nfunction defaultWikgOutputPath(inputPath: string): string {\n  if (inputPath.toLowerCase().endsWith(\".sdpub\")) {\n    return `${inputPath.slice(0, -\".sdpub\".length)}.wikg`;\n  }\n\n  return `${inputPath}.wikg`;\n}\n"],"mappings":"AAAA,SAAS,UAAU;AACnB,SAAS,MAAM,eAAe;AAE9B,SAAS,oCAAoC;AAC7C,SAAS,yBAAyB;AAClC,SAAS,wBAAwB;AACjC,SAAS,iCAAiC;AAC1C,SAAS,6BAA6B;AACtC,SAAS,gCAAgC;AAOzC,eAAsB,yBACpB,WACA,aAAa,sBAAsB,SAAS,GACP;AACrC,MAAI,QAAQ,SAAS,MAAM,QAAQ,UAAU,GAAG;AAC9C,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,gBAAgB,MAAM,6BAA6B,eAAe;AAExE,MAAI;AACF,UAAM,0BAA0B,WAAW,aAAa;AACxD,UAAM,sBAAsB,KAAK,eAAe,aAAa,CAAC;AAC9D,UAAM,yBAAyB,aAAa;AAC5C,UAAM,mBAAmB,aAAa;AACtC,UAAM,iBAAiB,eAAe,UAAU;AAEhD,WAAO,EAAE,WAAW,WAAW;AAAA,EACjC,UAAE;AACA,UAAM,GAAG,eAAe,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAAA,EAC1D;AACF;AAEA,eAAe,mBAAmB,eAAsC;AACtE,QAAM,WAAW,MAAM,kBAAkB,KAAK,aAAa;AAE3D,MAAI;AACF,UAAM,MAAM,MAAM,SAAS,QAAQ;AAEnC,QAAI,QAAQ,QAAW;AACrB,YAAM,SAAS,WAAW,GAAG;AAAA,IAC/B;AAAA,EACF,UAAE;AACA,UAAM,SAAS,QAAQ;AAAA,EACzB;AACF;AAEA,SAAS,sBAAsB,WAA2B;AACxD,MAAI,UAAU,YAAY,EAAE,SAAS,QAAQ,GAAG;AAC9C,WAAO,GAAG,UAAU,MAAM,GAAG,CAAC,SAAS,MAAM,CAAC;AAAA,EAChD;AAEA,SAAO,GAAG,SAAS;AACrB;","names":[]}

package/dist/storage/migration/legacy-sdpub/upgrade/schema.d.ts

@@ -0,0 +1,3 @@
+declare function migrateLegacyDatabase(databasePath: string): Promise<void>;
+
+export { migrateLegacyDatabase };

package/dist/storage/migration/legacy-sdpub/upgrade/schema.js

@@ -0,0 +1,41 @@
+import { Database } from "../../../../document/database.js";
+import { listTableColumns, listTableNames } from "./database.js";
+async function migrateLegacyDatabase(databasePath) {
+  const database = await Database.open(databasePath);
+  try {
+    await migrateKnowledgeEdges(database);
+    await migrateSerialDocumentOrder(database);
+  } finally {
+    await database.close();
+  }
+}
+async function migrateKnowledgeEdges(database) {
+  const tables = await listTableNames(database);
+  if (tables.has("reading_edges")) {
+    return;
+  }
+  if (!tables.has("knowledge_edges")) {
+    return;
+  }
+  await database.run(`
+    ALTER TABLE knowledge_edges
+    RENAME TO reading_edges
+  `);
+}
+async function migrateSerialDocumentOrder(database) {
+  const columns = await listTableColumns(database, "serials");
+  if (!columns.has("document_order")) {
+    await database.run(`
+      ALTER TABLE serials
+      ADD COLUMN document_order INTEGER NOT NULL DEFAULT 0
+    `);
+  }
+  await database.run(`
+    CREATE INDEX IF NOT EXISTS idx_serials_document_order
+    ON serials(document_order, id)
+  `);
+}
+export {
+  migrateLegacyDatabase
+};
+//# sourceMappingURL=schema.js.map

package/dist/storage/migration/legacy-sdpub/upgrade/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/storage/migration/legacy-sdpub/upgrade/schema.ts"],"sourcesContent":["import { Database } from \"../../../../document/database.js\";\nimport { listTableColumns, listTableNames } from \"./database.js\";\n\nexport async function migrateLegacyDatabase(\n  databasePath: string,\n): Promise<void> {\n  const database = await Database.open(databasePath);\n\n  try {\n    await migrateKnowledgeEdges(database);\n    await migrateSerialDocumentOrder(database);\n  } finally {\n    await database.close();\n  }\n}\n\nasync function migrateKnowledgeEdges(database: Database): Promise<void> {\n  const tables = await listTableNames(database);\n\n  if (tables.has(\"reading_edges\")) {\n    return;\n  }\n  if (!tables.has(\"knowledge_edges\")) {\n    return;\n  }\n\n  await database.run(`\n    ALTER TABLE knowledge_edges\n    RENAME TO reading_edges\n  `);\n}\n\nasync function migrateSerialDocumentOrder(database: Database): Promise<void> {\n  const columns = await listTableColumns(database, \"serials\");\n\n  if (!columns.has(\"document_order\")) {\n    await database.run(`\n      ALTER TABLE serials\n      ADD COLUMN document_order INTEGER NOT NULL DEFAULT 0\n    `);\n  }\n\n  await database.run(`\n    CREATE INDEX IF NOT EXISTS idx_serials_document_order\n    ON serials(document_order, id)\n  `);\n}\n"],"mappings":"AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB,sBAAsB;AAEjD,eAAsB,sBACpB,cACe;AACf,QAAM,WAAW,MAAM,SAAS,KAAK,YAAY;AAEjD,MAAI;AACF,UAAM,sBAAsB,QAAQ;AACpC,UAAM,2BAA2B,QAAQ;AAAA,EAC3C,UAAE;AACA,UAAM,SAAS,MAAM;AAAA,EACvB;AACF;AAEA,eAAe,sBAAsB,UAAmC;AACtE,QAAM,SAAS,MAAM,eAAe,QAAQ;AAE5C,MAAI,OAAO,IAAI,eAAe,GAAG;AAC/B;AAAA,EACF;AACA,MAAI,CAAC,OAAO,IAAI,iBAAiB,GAAG;AAClC;AAAA,EACF;AAEA,QAAM,SAAS,IAAI;AAAA;AAAA;AAAA,GAGlB;AACH;AAEA,eAAe,2BAA2B,UAAmC;AAC3E,QAAM,UAAU,MAAM,iBAAiB,UAAU,SAAS;AAE1D,MAAI,CAAC,QAAQ,IAAI,gBAAgB,GAAG;AAClC,UAAM,SAAS,IAAI;AAAA;AAAA;AAAA,KAGlB;AAAA,EACH;AAEA,QAAM,SAAS,IAAI;AAAA;AAAA;AAAA,GAGlB;AACH;","names":[]}

package/dist/storage/migration/legacy-sdpub/upgrade/text-storage/core.d.ts

@@ -0,0 +1,3 @@
+declare function migrateLegacyTextStorage(workspacePath: string): Promise<void>;
+
+export { migrateLegacyTextStorage };