wiki-graph-core 0.3.1

package/dist/wikg/archive.js

@@ -0,0 +1,496 @@
+import { randomBytes } from "crypto";
+import { createWriteStream } from "fs";
+import {
+  mkdir,
+  open as openFile,
+  readFile,
+  readdir,
+  writeFile
+} from "fs/promises";
+import { dirname, join, posix, relative, resolve, sep } from "path";
+import { finished } from "stream/promises";
+import { inflateRaw } from "zlib";
+import { z } from "zod";
+import {
+  open as openZip
+} from "yauzl";
+import { ZipFile as YazlZipFile } from "yazl";
+import { Database } from "../document/database.js";
+const WIKG_FORMAT_VERSION = 1;
+const WIKG_MUTATION_TOKEN_PATH = ".wikg-mutation-token";
+const WIKG_MANIFEST_PATH = "manifest.json";
+const SEARCH_INDEX_DATABASE_PATH = "fts.db";
+const WIKG_MANIFEST_CONTENT = `${JSON.stringify({
+  formatVersion: WIKG_FORMAT_VERSION
+})}
+`;
+const WIKG_MUTATION_TOKEN_MAGIC = "wikg-mutation-token:v1";
+const WIKG_MUTATION_TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/u;
+const WIKG_ARCHIVE_PATTERNS = [
+  /^\.wikg-mutation-token$/u,
+  /^manifest\.json$/u,
+  /^database\.db$/u,
+  /^fts\.db$/u,
+  /^toc\.json$/u,
+  /^cover\/(?:data\.bin|info\.json)$/u,
+  /^texts\/(?:source|summary)\/\d+\.txt$/u
+];
+const wikgManifestSchema = z.object({
+  formatVersion: z.literal(WIKG_FORMAT_VERSION)
+});
+class WikgArchiveReader {
+  #entryByPath;
+  #entries;
+  #file;
+  #path;
+  #zipFile;
+  constructor(path, zipFile, entries) {
+    this.#path = path;
+    this.#zipFile = zipFile;
+    this.#entryByPath = new Map(
+      entries.map((entry) => [normalizeArchivePath(entry.fileName), entry]).filter(([entryPath]) => entryPath !== "").filter(([entryPath]) => isWikgArchivePath(entryPath))
+    );
+    this.#entries = [...this.#entryByPath.keys()].sort(
+      (left, right) => left.localeCompare(right)
+    );
+  }
+  static async open(inputPath) {
+    const { entries, zipFile } = await openIndexedArchive(inputPath);
+    return new WikgArchiveReader(inputPath, zipFile, entries);
+  }
+  close() {
+    this.#zipFile.close();
+    if (this.#file !== void 0) {
+      void this.#file.then(async (file) => {
+        await file.close();
+      });
+      this.#file = void 0;
+    }
+  }
+  listEntries() {
+    return this.#entries;
+  }
+  async readEntry(entryPath) {
+    const entry = this.#entryByPath.get(normalizeArchivePath(entryPath));
+    if (entry === void 0) {
+      return void 0;
+    }
+    return await readArchiveEntryBufferFromFile(await this.#getFile(), entry);
+  }
+  async #getFile() {
+    this.#file ??= openFile(this.#path, "r");
+    return await this.#file;
+  }
+}
+async function extractWikgArchive(inputPath, outputDirectoryPath) {
+  const { entries, zipFile } = await openIndexedArchive(inputPath);
+  const file = await openFile(inputPath, "r");
+  try {
+    for (const entry of entries) {
+      const archivePath = normalizeArchivePath(entry.fileName);
+      if (archivePath === "") {
+        throw new Error(`Invalid archive entry path: ${entry.fileName}`);
+      }
+      if (!isWikgArchivePath(archivePath)) {
+        continue;
+      }
+      const targetPath = resolve(outputDirectoryPath, archivePath);
+      assertWithinDirectory(outputDirectoryPath, targetPath, archivePath);
+      await mkdir(dirname(targetPath), { recursive: true });
+      await writeFile(
+        targetPath,
+        await readArchiveEntryBufferFromFile(file, entry)
+      );
+    }
+  } finally {
+    await file.close();
+    zipFile.close();
+  }
+}
+async function writeWikgArchive(documentDirectoryPath, outputPath) {
+  await mkdir(dirname(outputPath), { recursive: true });
+  const zipFile = new YazlZipFile();
+  const files = await listDocumentFiles(documentDirectoryPath);
+  const includeSearchIndex = await shouldEmbedSearchIndex(
+    documentDirectoryPath
+  );
+  const entries = sortArchiveEntriesForWrite([
+    {
+      archivePath: WIKG_MUTATION_TOKEN_PATH,
+      content: createWikgMutationTokenContent()
+    },
+    {
+      archivePath: WIKG_MANIFEST_PATH,
+      content: Buffer.from(WIKG_MANIFEST_CONTENT, "utf8")
+    },
+    ...files.filter((file) => {
+      if (file.archivePath === WIKG_MANIFEST_PATH) {
+        return false;
+      }
+      if (file.archivePath === WIKG_MUTATION_TOKEN_PATH) {
+        return false;
+      }
+      return file.archivePath !== SEARCH_INDEX_DATABASE_PATH || includeSearchIndex;
+    })
+  ]);
+  for (const entry of entries) {
+    if ("content" in entry) {
+      zipFile.addBuffer(entry.content, entry.archivePath, {
+        compress: false
+      });
+    } else {
+      zipFile.addFile(entry.absolutePath, entry.archivePath, {
+        compress: false
+      });
+    }
+  }
+  zipFile.end();
+  const output = createWriteStream(outputPath);
+  const outputDone = finished(output);
+  const zipDone = finished(zipFile.outputStream);
+  zipFile.outputStream.pipe(output);
+  await Promise.all([outputDone, zipDone]);
+}
+async function listWikgArchiveEntries(inputPath) {
+  const reader = await WikgArchiveReader.open(inputPath);
+  try {
+    return reader.listEntries();
+  } finally {
+    reader.close();
+  }
+}
+async function readWikgArchiveEntry(inputPath, entryPath) {
+  const reader = await WikgArchiveReader.open(inputPath);
+  try {
+    return await reader.readEntry(entryPath);
+  } finally {
+    reader.close();
+  }
+}
+async function readWikgArchiveMutationToken(inputPath) {
+  const reader = await WikgArchiveReader.open(inputPath);
+  try {
+    const content = await reader.readEntry(WIKG_MUTATION_TOKEN_PATH);
+    if (content === void 0) {
+      throw new Error(
+        `Missing WIKG mutation token: ${WIKG_MUTATION_TOKEN_PATH}.`
+      );
+    }
+    return parseWikgMutationToken(content.toString("utf8"));
+  } finally {
+    reader.close();
+  }
+}
+async function writeWikgArchiveWithOverlays(inputPath, outputPath, overlays) {
+  await mkdir(dirname(outputPath), { recursive: true });
+  const { entries: sourceEntries, zipFile } = await openIndexedArchive(inputPath);
+  const overlayByPath = new Map(
+    overlays.map((overlay) => [
+      normalizeArchivePath(overlay.entryPath),
+      overlay
+    ])
+  );
+  const entryPaths = /* @__PURE__ */ new Set();
+  for (const entry of sourceEntries) {
+    const archivePath = normalizeArchivePath(entry.fileName);
+    if (archivePath !== "" && isWikgArchivePath(archivePath)) {
+      entryPaths.add(archivePath);
+    }
+  }
+  for (const overlay of overlayByPath.values()) {
+    const archivePath = normalizeArchivePath(overlay.entryPath);
+    if (archivePath !== "" && isWikgArchivePath(archivePath)) {
+      entryPaths.add(archivePath);
+    }
+  }
+  entryPaths.add(WIKG_MUTATION_TOKEN_PATH);
+  entryPaths.add(WIKG_MANIFEST_PATH);
+  const outputZipFile = new YazlZipFile();
+  const sourceFile = await openFile(inputPath, "r");
+  try {
+    for (const entryPath of sortArchiveEntryPathsForWrite(entryPaths)) {
+      const overlay = overlayByPath.get(entryPath);
+      if (entryPath === WIKG_MUTATION_TOKEN_PATH) {
+        outputZipFile.addBuffer(createWikgMutationTokenContent(), entryPath, {
+          compress: false
+        });
+        continue;
+      }
+      if (entryPath === WIKG_MANIFEST_PATH) {
+        outputZipFile.addBuffer(
+          Buffer.from(WIKG_MANIFEST_CONTENT, "utf8"),
+          entryPath,
+          { compress: false }
+        );
+        continue;
+      }
+      if (overlay?.kind === "deleted") {
+        continue;
+      }
+      if (overlay?.kind === "file") {
+        outputZipFile.addFile(overlay.workspacePath, entryPath, {
+          compress: false
+        });
+        continue;
+      }
+      const sourceEntry = sourceEntries.find(
+        (candidate) => normalizeArchivePath(candidate.fileName) === entryPath
+      );
+      if (sourceEntry === void 0) {
+        continue;
+      }
+      outputZipFile.addBuffer(
+        await readArchiveEntryBufferFromFile(sourceFile, sourceEntry),
+        entryPath,
+        { compress: false }
+      );
+    }
+  } finally {
+    await sourceFile.close();
+    zipFile.close();
+  }
+  outputZipFile.end();
+  const output = createWriteStream(outputPath);
+  const outputDone = finished(output);
+  const zipDone = finished(outputZipFile.outputStream);
+  outputZipFile.outputStream.pipe(output);
+  await Promise.all([outputDone, zipDone]);
+}
+async function readWikgArchiveFormatVersion(documentDirectoryPath) {
+  return parseWikgManifest(
+    await readFile(join(documentDirectoryPath, WIKG_MANIFEST_PATH), "utf8")
+  ).formatVersion;
+}
+async function listDocumentFiles(rootDirectoryPath, currentDirectoryPath = rootDirectoryPath) {
+  const entries = await readdir(currentDirectoryPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of [...entries].sort(compareDirEntryName)) {
+    const absolutePath = join(currentDirectoryPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listDocumentFiles(rootDirectoryPath, absolutePath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    files.push({
+      absolutePath,
+      archivePath: relative(rootDirectoryPath, absolutePath).split(sep).join(posix.sep)
+    });
+  }
+  return files.filter((file) => isWikgArchivePath(file.archivePath));
+}
+async function shouldEmbedSearchIndex(documentDirectoryPath) {
+  const database = await Database.open(
+    join(documentDirectoryPath, "database.db"),
+    "",
+    {
+      readonly: true
+    }
+  ).catch(() => void 0);
+  if (database === void 0) {
+    return false;
+  }
+  try {
+    const row = await database.queryOne(
+      `
+        SELECT fts_embedded
+        FROM archive_index_settings
+        WHERE id = 1
+      `,
+      void 0,
+      (value) => Number(value.fts_embedded) !== 0
+    );
+    return row ?? false;
+  } catch {
+    return false;
+  } finally {
+    await database.close();
+  }
+}
+async function openIndexedArchive(inputPath) {
+  const zipFile = await openArchive(inputPath);
+  try {
+    const entries = await indexArchiveEntries(zipFile);
+    await validateArchiveManifest(inputPath, entries);
+    return { entries, zipFile };
+  } catch (error) {
+    zipFile.close();
+    throw error;
+  }
+}
+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 compareDirEntryName(left, right) {
+  return left.name.localeCompare(right.name);
+}
+function sortArchiveEntriesForWrite(entries) {
+  return [...entries].sort(
+    (left, right) => compareArchiveEntryPathsForWrite(left.archivePath, right.archivePath)
+  );
+}
+function sortArchiveEntryPathsForWrite(paths) {
+  return [...paths].sort(compareArchiveEntryPathsForWrite);
+}
+function compareArchiveEntryPathsForWrite(left, right) {
+  if (left === WIKG_MUTATION_TOKEN_PATH) {
+    return right === WIKG_MUTATION_TOKEN_PATH ? 0 : -1;
+  }
+  if (right === WIKG_MUTATION_TOKEN_PATH) {
+    return 1;
+  }
+  return left.localeCompare(right);
+}
+function isWikgArchivePath(archivePath) {
+  return WIKG_ARCHIVE_PATTERNS.some((pattern) => pattern.test(archivePath));
+}
+async function validateArchiveManifest(inputPath, entries) {
+  await validateArchiveMutationToken(inputPath, entries);
+  const entry = entries.find(
+    (candidate) => normalizeArchivePath(candidate.fileName) === WIKG_MANIFEST_PATH
+  );
+  if (entry === void 0) {
+    throw new Error(`Missing WIKG manifest: ${WIKG_MANIFEST_PATH}.`);
+  }
+  parseWikgManifest(await readArchiveEntryText(inputPath, entry));
+}
+async function validateArchiveMutationToken(inputPath, entries) {
+  const firstEntryPath = normalizeArchivePath(entries[0]?.fileName ?? "");
+  if (firstEntryPath !== WIKG_MUTATION_TOKEN_PATH) {
+    throw new Error(
+      `Missing WIKG mutation token: ${WIKG_MUTATION_TOKEN_PATH}.`
+    );
+  }
+  parseWikgMutationToken(await readArchiveEntryText(inputPath, entries[0]));
+}
+function parseWikgManifest(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid WIKG manifest: ${WIKG_MANIFEST_PATH}.`);
+  }
+  const result = wikgManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Unsupported WIKG format version in ${WIKG_MANIFEST_PATH}.`
+    );
+  }
+  return result.data;
+}
+function createWikgMutationTokenContent() {
+  const token = randomBytes(32).toString("base64url");
+  return Buffer.from(`${WIKG_MUTATION_TOKEN_MAGIC}
+${token}
+`, "utf8");
+}
+function parseWikgMutationToken(content) {
+  const lines = content.split(/\r?\n/u);
+  const magic = lines[0];
+  const token = lines[1];
+  if (magic !== WIKG_MUTATION_TOKEN_MAGIC || token === void 0 || !WIKG_MUTATION_TOKEN_PATTERN.test(token)) {
+    throw new Error(
+      `Invalid WIKG mutation token: ${WIKG_MUTATION_TOKEN_PATH}.`
+    );
+  }
+  return token;
+}
+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((resolve2, reject) => {
+    openZip(path, { autoClose: false, lazyEntries: true }, (error, zipFile) => {
+      if (error !== null || zipFile === void 0) {
+        reject(error ?? new Error(`Cannot open archive: ${path}`));
+        return;
+      }
+      resolve2(zipFile);
+    });
+  });
+}
+async function readArchiveEntryText(inputPath, entry) {
+  return (await readArchiveEntryBuffer(inputPath, entry)).toString("utf8");
+}
+async function readArchiveEntryBuffer(inputPath, entry) {
+  const file = await openFile(inputPath, "r");
+  try {
+    return await readArchiveEntryBufferFromFile(file, entry);
+  } finally {
+    await file.close();
+  }
+}
+async function readArchiveEntryBufferFromFile(file, entry) {
+  const compressed = await readCompressedArchiveEntryBuffer(file, entry);
+  if (entry.compressionMethod === 0) {
+    return compressed;
+  }
+  if (entry.compressionMethod === 8) {
+    return await inflateRawBuffer(compressed);
+  }
+  throw new Error(`Unsupported ZIP compression method: ${entry.fileName}`);
+}
+async function readCompressedArchiveEntryBuffer(file, entry) {
+  const header = Buffer.alloc(30);
+  await file.read(header, 0, header.length, entry.relativeOffsetOfLocalHeader);
+  if (header.readUInt32LE(0) !== 67324752) {
+    throw new Error(`Invalid ZIP local file header: ${entry.fileName}`);
+  }
+  const fileNameLength = header.readUInt16LE(26);
+  const extraFieldLength = header.readUInt16LE(28);
+  const dataOffset = entry.relativeOffsetOfLocalHeader + 30 + fileNameLength + extraFieldLength;
+  const compressed = Buffer.alloc(entry.compressedSize);
+  await file.read(compressed, 0, compressed.length, dataOffset);
+  return compressed;
+}
+async function inflateRawBuffer(input) {
+  return await new Promise((resolveInflate, rejectInflate) => {
+    inflateRaw(input, (error, output) => {
+      if (error !== null) {
+        rejectInflate(error);
+        return;
+      }
+      resolveInflate(output);
+    });
+  });
+}
+export {
+  WIKG_FORMAT_VERSION,
+  WikgArchiveReader,
+  extractWikgArchive,
+  listWikgArchiveEntries,
+  readWikgArchiveEntry,
+  readWikgArchiveFormatVersion,
+  readWikgArchiveMutationToken,
+  writeWikgArchive,
+  writeWikgArchiveWithOverlays
+};
+//# sourceMappingURL=archive.js.map

package/dist/wikg/archive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wikg/archive.ts"],"sourcesContent":["import { randomBytes } from \"crypto\";\nimport { createWriteStream } from \"fs\";\nimport {\n  mkdir,\n  open as openFile,\n  readFile,\n  readdir,\n  writeFile,\n  type FileHandle,\n} from \"fs/promises\";\nimport { dirname, join, posix, relative, resolve, sep } from \"path\";\nimport { finished } from \"stream/promises\";\nimport { inflateRaw } from \"zlib\";\n\nimport { z } from \"zod\";\nimport {\n  open as openZip,\n  type Entry,\n  type ZipFile as YauzlZipFile,\n} from \"yauzl\";\nimport { ZipFile as YazlZipFile } from \"yazl\";\n\nimport { Database } from \"../document/database.js\";\n\nexport const WIKG_FORMAT_VERSION = 1;\nconst WIKG_MUTATION_TOKEN_PATH = \".wikg-mutation-token\";\nconst WIKG_MANIFEST_PATH = \"manifest.json\";\nconst SEARCH_INDEX_DATABASE_PATH = \"fts.db\";\nconst WIKG_MANIFEST_CONTENT = `${JSON.stringify({\n  formatVersion: WIKG_FORMAT_VERSION,\n})}\\n`;\nconst WIKG_MUTATION_TOKEN_MAGIC = \"wikg-mutation-token:v1\";\nconst WIKG_MUTATION_TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/u;\n\nconst WIKG_ARCHIVE_PATTERNS = [\n  /^\\.wikg-mutation-token$/u,\n  /^manifest\\.json$/u,\n  /^database\\.db$/u,\n  /^fts\\.db$/u,\n  /^toc\\.json$/u,\n  /^cover\\/(?:data\\.bin|info\\.json)$/u,\n  /^texts\\/(?:source|summary)\\/\\d+\\.txt$/u,\n] as const;\n\nconst wikgManifestSchema = z.object({\n  formatVersion: z.literal(WIKG_FORMAT_VERSION),\n});\n\nexport type WikgArchiveOverlay =\n  | {\n      readonly entryPath: string;\n      readonly kind: \"deleted\";\n    }\n  | {\n      readonly entryPath: string;\n      readonly kind: \"file\";\n      readonly workspacePath: string;\n    };\n\nexport class WikgArchiveReader {\n  readonly #entryByPath: Map<string, Entry>;\n  readonly #entries: readonly string[];\n  #file: Promise<FileHandle> | undefined;\n  readonly #path: string;\n  readonly #zipFile: YauzlZipFile;\n\n  public constructor(\n    path: string,\n    zipFile: YauzlZipFile,\n    entries: readonly Entry[],\n  ) {\n    this.#path = path;\n    this.#zipFile = zipFile;\n    this.#entryByPath = new Map(\n      entries\n        .map((entry) => [normalizeArchivePath(entry.fileName), entry] as const)\n        .filter(([entryPath]) => entryPath !== \"\")\n        .filter(([entryPath]) => isWikgArchivePath(entryPath)),\n    );\n    this.#entries = [...this.#entryByPath.keys()].sort((left, right) =>\n      left.localeCompare(right),\n    );\n  }\n\n  public static async open(inputPath: string): Promise<WikgArchiveReader> {\n    const { entries, zipFile } = await openIndexedArchive(inputPath);\n\n    return new WikgArchiveReader(inputPath, zipFile, entries);\n  }\n\n  public close(): void {\n    this.#zipFile.close();\n    if (this.#file !== undefined) {\n      void this.#file.then(async (file) => {\n        await file.close();\n      });\n      this.#file = undefined;\n    }\n  }\n\n  public listEntries(): readonly string[] {\n    return this.#entries;\n  }\n\n  public async readEntry(entryPath: string): Promise<Buffer | undefined> {\n    const entry = this.#entryByPath.get(normalizeArchivePath(entryPath));\n\n    if (entry === undefined) {\n      return undefined;\n    }\n\n    return await readArchiveEntryBufferFromFile(await this.#getFile(), entry);\n  }\n\n  async #getFile(): Promise<FileHandle> {\n    this.#file ??= openFile(this.#path, \"r\");\n    return await this.#file;\n  }\n}\n\nexport async function extractWikgArchive(\n  inputPath: string,\n  outputDirectoryPath: string,\n): Promise<void> {\n  const { entries, zipFile } = await openIndexedArchive(inputPath);\n  const file = await openFile(inputPath, \"r\");\n\n  try {\n    for (const entry of entries) {\n      const archivePath = normalizeArchivePath(entry.fileName);\n\n      if (archivePath === \"\") {\n        throw new Error(`Invalid archive entry path: ${entry.fileName}`);\n      }\n      if (!isWikgArchivePath(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 writeFile(\n        targetPath,\n        await readArchiveEntryBufferFromFile(file, entry),\n      );\n    }\n  } finally {\n    await file.close();\n    zipFile.close();\n  }\n}\n\nexport async function writeWikgArchive(\n  documentDirectoryPath: string,\n  outputPath: string,\n): Promise<void> {\n  await mkdir(dirname(outputPath), { recursive: true });\n\n  const zipFile = new YazlZipFile();\n  const files = await listDocumentFiles(documentDirectoryPath);\n  const includeSearchIndex = await shouldEmbedSearchIndex(\n    documentDirectoryPath,\n  );\n  const entries = sortArchiveEntriesForWrite([\n    {\n      archivePath: WIKG_MUTATION_TOKEN_PATH,\n      content: createWikgMutationTokenContent(),\n    },\n    {\n      archivePath: WIKG_MANIFEST_PATH,\n      content: Buffer.from(WIKG_MANIFEST_CONTENT, \"utf8\"),\n    },\n    ...files.filter((file) => {\n      if (file.archivePath === WIKG_MANIFEST_PATH) {\n        return false;\n      }\n      if (file.archivePath === WIKG_MUTATION_TOKEN_PATH) {\n        return false;\n      }\n\n      return (\n        file.archivePath !== SEARCH_INDEX_DATABASE_PATH || includeSearchIndex\n      );\n    }),\n  ]);\n\n  for (const entry of entries) {\n    if (\"content\" in entry) {\n      zipFile.addBuffer(entry.content, entry.archivePath, {\n        compress: false,\n      });\n    } else {\n      zipFile.addFile(entry.absolutePath, entry.archivePath, {\n        compress: false,\n      });\n    }\n  }\n\n  zipFile.end();\n\n  const output = createWriteStream(outputPath);\n  const outputDone = finished(output);\n  const zipDone = finished(zipFile.outputStream);\n\n  zipFile.outputStream.pipe(output);\n  await Promise.all([outputDone, zipDone]);\n}\n\nexport async function listWikgArchiveEntries(\n  inputPath: string,\n): Promise<readonly string[]> {\n  const reader = await WikgArchiveReader.open(inputPath);\n\n  try {\n    return reader.listEntries();\n  } finally {\n    reader.close();\n  }\n}\n\nexport async function readWikgArchiveEntry(\n  inputPath: string,\n  entryPath: string,\n): Promise<Buffer | undefined> {\n  const reader = await WikgArchiveReader.open(inputPath);\n\n  try {\n    return await reader.readEntry(entryPath);\n  } finally {\n    reader.close();\n  }\n}\n\nexport async function readWikgArchiveMutationToken(\n  inputPath: string,\n): Promise<string> {\n  const reader = await WikgArchiveReader.open(inputPath);\n\n  try {\n    const content = await reader.readEntry(WIKG_MUTATION_TOKEN_PATH);\n\n    if (content === undefined) {\n      throw new Error(\n        `Missing WIKG mutation token: ${WIKG_MUTATION_TOKEN_PATH}.`,\n      );\n    }\n\n    return parseWikgMutationToken(content.toString(\"utf8\"));\n  } finally {\n    reader.close();\n  }\n}\n\nexport async function writeWikgArchiveWithOverlays(\n  inputPath: string,\n  outputPath: string,\n  overlays: readonly WikgArchiveOverlay[],\n): Promise<void> {\n  await mkdir(dirname(outputPath), { recursive: true });\n\n  const { entries: sourceEntries, zipFile } =\n    await openIndexedArchive(inputPath);\n  const overlayByPath = new Map(\n    overlays.map((overlay) => [\n      normalizeArchivePath(overlay.entryPath),\n      overlay,\n    ]),\n  );\n  const entryPaths = new Set<string>();\n\n  for (const entry of sourceEntries) {\n    const archivePath = normalizeArchivePath(entry.fileName);\n\n    if (archivePath !== \"\" && isWikgArchivePath(archivePath)) {\n      entryPaths.add(archivePath);\n    }\n  }\n  for (const overlay of overlayByPath.values()) {\n    const archivePath = normalizeArchivePath(overlay.entryPath);\n\n    if (archivePath !== \"\" && isWikgArchivePath(archivePath)) {\n      entryPaths.add(archivePath);\n    }\n  }\n  entryPaths.add(WIKG_MUTATION_TOKEN_PATH);\n  entryPaths.add(WIKG_MANIFEST_PATH);\n\n  const outputZipFile = new YazlZipFile();\n  const sourceFile = await openFile(inputPath, \"r\");\n\n  try {\n    for (const entryPath of sortArchiveEntryPathsForWrite(entryPaths)) {\n      const overlay = overlayByPath.get(entryPath);\n\n      if (entryPath === WIKG_MUTATION_TOKEN_PATH) {\n        outputZipFile.addBuffer(createWikgMutationTokenContent(), entryPath, {\n          compress: false,\n        });\n        continue;\n      }\n      if (entryPath === WIKG_MANIFEST_PATH) {\n        outputZipFile.addBuffer(\n          Buffer.from(WIKG_MANIFEST_CONTENT, \"utf8\"),\n          entryPath,\n          { compress: false },\n        );\n        continue;\n      }\n      if (overlay?.kind === \"deleted\") {\n        continue;\n      }\n      if (overlay?.kind === \"file\") {\n        outputZipFile.addFile(overlay.workspacePath, entryPath, {\n          compress: false,\n        });\n        continue;\n      }\n\n      const sourceEntry = sourceEntries.find(\n        (candidate) => normalizeArchivePath(candidate.fileName) === entryPath,\n      );\n\n      if (sourceEntry === undefined) {\n        continue;\n      }\n\n      outputZipFile.addBuffer(\n        await readArchiveEntryBufferFromFile(sourceFile, sourceEntry),\n        entryPath,\n        { compress: false },\n      );\n    }\n  } finally {\n    await sourceFile.close();\n    zipFile.close();\n  }\n\n  outputZipFile.end();\n\n  const output = createWriteStream(outputPath);\n  const outputDone = finished(output);\n  const zipDone = finished(outputZipFile.outputStream);\n\n  outputZipFile.outputStream.pipe(output);\n  await Promise.all([outputDone, zipDone]);\n}\n\nexport async function readWikgArchiveFormatVersion(\n  documentDirectoryPath: string,\n): Promise<number> {\n  return parseWikgManifest(\n    await readFile(join(documentDirectoryPath, WIKG_MANIFEST_PATH), \"utf8\"),\n  ).formatVersion;\n}\n\nasync function listDocumentFiles(\n  rootDirectoryPath: string,\n  currentDirectoryPath = rootDirectoryPath,\n): Promise<Array<{ absolutePath: string; archivePath: string }>> {\n  const entries = await readdir(currentDirectoryPath, { withFileTypes: true });\n  const files: Array<{ absolutePath: string; archivePath: string }> = [];\n\n  for (const entry of [...entries].sort(compareDirEntryName)) {\n    const absolutePath = join(currentDirectoryPath, entry.name);\n\n    if (entry.isDirectory()) {\n      files.push(...(await listDocumentFiles(rootDirectoryPath, absolutePath)));\n      continue;\n    }\n    if (!entry.isFile()) {\n      continue;\n    }\n\n    files.push({\n      absolutePath,\n      archivePath: relative(rootDirectoryPath, absolutePath)\n        .split(sep)\n        .join(posix.sep),\n    });\n  }\n\n  return files.filter((file) => isWikgArchivePath(file.archivePath));\n}\n\nasync function shouldEmbedSearchIndex(\n  documentDirectoryPath: string,\n): Promise<boolean> {\n  const database = await Database.open(\n    join(documentDirectoryPath, \"database.db\"),\n    \"\",\n    {\n      readonly: true,\n    },\n  ).catch(() => undefined);\n\n  if (database === undefined) {\n    return false;\n  }\n\n  try {\n    const row = await database.queryOne(\n      `\n        SELECT fts_embedded\n        FROM archive_index_settings\n        WHERE id = 1\n      `,\n      undefined,\n      (value) => Number(value.fts_embedded) !== 0,\n    );\n\n    return row ?? false;\n  } catch {\n    return false;\n  } finally {\n    await database.close();\n  }\n}\n\nasync function openIndexedArchive(inputPath: string): Promise<{\n  readonly entries: readonly Entry[];\n  readonly zipFile: YauzlZipFile;\n}> {\n  const zipFile = await openArchive(inputPath);\n\n  try {\n    const entries = await indexArchiveEntries(zipFile);\n\n    await validateArchiveManifest(inputPath, entries);\n    return { entries, zipFile };\n  } catch (error) {\n    zipFile.close();\n    throw error;\n  }\n}\n\nasync 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\nfunction compareDirEntryName(\n  left: { readonly name: string },\n  right: { readonly name: string },\n): number {\n  return left.name.localeCompare(right.name);\n}\n\nfunction sortArchiveEntriesForWrite<T extends { readonly archivePath: string }>(\n  entries: readonly T[],\n): T[] {\n  return [...entries].sort((left, right) =>\n    compareArchiveEntryPathsForWrite(left.archivePath, right.archivePath),\n  );\n}\n\nfunction sortArchiveEntryPathsForWrite(paths: Iterable<string>): string[] {\n  return [...paths].sort(compareArchiveEntryPathsForWrite);\n}\n\nfunction compareArchiveEntryPathsForWrite(left: string, right: string): number {\n  if (left === WIKG_MUTATION_TOKEN_PATH) {\n    return right === WIKG_MUTATION_TOKEN_PATH ? 0 : -1;\n  }\n  if (right === WIKG_MUTATION_TOKEN_PATH) {\n    return 1;\n  }\n\n  return left.localeCompare(right);\n}\n\nfunction isWikgArchivePath(archivePath: string): boolean {\n  return WIKG_ARCHIVE_PATTERNS.some((pattern) => pattern.test(archivePath));\n}\n\nasync function validateArchiveManifest(\n  inputPath: string,\n  entries: readonly Entry[],\n): Promise<void> {\n  await validateArchiveMutationToken(inputPath, entries);\n\n  const entry = entries.find(\n    (candidate) =>\n      normalizeArchivePath(candidate.fileName) === WIKG_MANIFEST_PATH,\n  );\n\n  if (entry === undefined) {\n    throw new Error(`Missing WIKG manifest: ${WIKG_MANIFEST_PATH}.`);\n  }\n\n  parseWikgManifest(await readArchiveEntryText(inputPath, entry));\n}\n\nasync function validateArchiveMutationToken(\n  inputPath: string,\n  entries: readonly Entry[],\n): Promise<void> {\n  const firstEntryPath = normalizeArchivePath(entries[0]?.fileName ?? \"\");\n\n  if (firstEntryPath !== WIKG_MUTATION_TOKEN_PATH) {\n    throw new Error(\n      `Missing WIKG mutation token: ${WIKG_MUTATION_TOKEN_PATH}.`,\n    );\n  }\n\n  parseWikgMutationToken(await readArchiveEntryText(inputPath, entries[0]!));\n}\n\nfunction parseWikgManifest(\n  content: string,\n): z.infer<typeof wikgManifestSchema> {\n  let parsed: unknown;\n\n  try {\n    parsed = JSON.parse(content);\n  } catch {\n    throw new Error(`Invalid WIKG manifest: ${WIKG_MANIFEST_PATH}.`);\n  }\n\n  const result = wikgManifestSchema.safeParse(parsed);\n\n  if (!result.success) {\n    throw new Error(\n      `Unsupported WIKG format version in ${WIKG_MANIFEST_PATH}.`,\n    );\n  }\n\n  return result.data;\n}\n\nfunction createWikgMutationTokenContent(): Buffer {\n  const token = randomBytes(32).toString(\"base64url\");\n\n  return Buffer.from(`${WIKG_MUTATION_TOKEN_MAGIC}\\n${token}\\n`, \"utf8\");\n}\n\nfunction parseWikgMutationToken(content: string): string {\n  const lines = content.split(/\\r?\\n/u);\n  const magic = lines[0];\n  const token = lines[1];\n\n  if (\n    magic !== WIKG_MUTATION_TOKEN_MAGIC ||\n    token === undefined ||\n    !WIKG_MUTATION_TOKEN_PATTERN.test(token)\n  ) {\n    throw new Error(\n      `Invalid WIKG mutation token: ${WIKG_MUTATION_TOKEN_PATH}.`,\n    );\n  }\n\n  return token;\n}\n\nfunction 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\nfunction 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\nasync function openArchive(path: string): Promise<YauzlZipFile> {\n  return await new Promise((resolve, reject) => {\n    openZip(path, { autoClose: false, lazyEntries: true }, (error, zipFile) => {\n      if (error !== null || zipFile === undefined) {\n        reject(error ?? new Error(`Cannot open archive: ${path}`));\n        return;\n      }\n\n      resolve(zipFile);\n    });\n  });\n}\n\nasync function readArchiveEntryText(\n  inputPath: string,\n  entry: Entry,\n): Promise<string> {\n  return (await readArchiveEntryBuffer(inputPath, entry)).toString(\"utf8\");\n}\n\nasync function readArchiveEntryBuffer(\n  inputPath: string,\n  entry: Entry,\n): Promise<Buffer> {\n  const file = await openFile(inputPath, \"r\");\n\n  try {\n    return await readArchiveEntryBufferFromFile(file, entry);\n  } finally {\n    await file.close();\n  }\n}\n\nasync function readArchiveEntryBufferFromFile(\n  file: FileHandle,\n  entry: Entry,\n): Promise<Buffer> {\n  const compressed = await readCompressedArchiveEntryBuffer(file, entry);\n\n  if (entry.compressionMethod === 0) {\n    return compressed;\n  }\n  if (entry.compressionMethod === 8) {\n    return await inflateRawBuffer(compressed);\n  }\n\n  throw new Error(`Unsupported ZIP compression method: ${entry.fileName}`);\n}\n\nasync function readCompressedArchiveEntryBuffer(\n  file: FileHandle,\n  entry: Entry,\n): Promise<Buffer> {\n  const header = Buffer.alloc(30);\n\n  await file.read(header, 0, header.length, entry.relativeOffsetOfLocalHeader);\n  if (header.readUInt32LE(0) !== 0x04034b50) {\n    throw new Error(`Invalid ZIP local file header: ${entry.fileName}`);\n  }\n\n  const fileNameLength = header.readUInt16LE(26);\n  const extraFieldLength = header.readUInt16LE(28);\n  const dataOffset =\n    entry.relativeOffsetOfLocalHeader + 30 + fileNameLength + extraFieldLength;\n  const compressed = Buffer.alloc(entry.compressedSize);\n\n  await file.read(compressed, 0, compressed.length, dataOffset);\n  return compressed;\n}\n\nasync function inflateRawBuffer(input: Buffer): Promise<Buffer> {\n  return await new Promise((resolveInflate, rejectInflate) => {\n    inflateRaw(input, (error, output) => {\n      if (error !== null) {\n        rejectInflate(error);\n        return;\n      }\n\n      resolveInflate(output);\n    });\n  });\n}\n"],"mappings":"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","names":["resolve"]}

package/dist/wikg/index.d.ts

@@ -0,0 +1,31 @@
+export { WIKG_FORMAT_VERSION, WikgArchiveOverlay, WikgArchiveReader, extractWikgArchive, listWikgArchiveEntries, readWikgArchiveEntry, readWikgArchiveFormatVersion, writeWikgArchive, writeWikgArchiveWithOverlays } from './archive.js';
+export { LocatedWikiGraphUri, WIKI_GRAPH_ARCHIVE_EXTENSION, WIKI_GRAPH_JOB_URI_PREFIX, WIKI_GRAPH_URI_PREFIX, formatLocatedChapterResourceUri, formatLocatedChapterSourceCollectionUri, formatLocatedChapterUri, formatLocatedWikiGraphUri, formatWikiGraphCommandUri, formatWikiGraphObjectUri, formatWikiGraphUriExpectedError, isWikiGraphJobUri, isWikiGraphUri, parseLocatedWikiGraphUri, requireArchiveUri, requireLocatedObjectOrArchiveUri, requireLocatedObjectUri } from '../common/wiki-graph-uri.js';
+export { WikiGraphArchiveFile } from './wiki-graph-archive-file.js';
+export { WikgCoordinator, runWikgCoordinatorGc } from './wikg-coordinator.js';
+import 'yauzl';
+import '../document/document.js';
+import '../source/meta.js';
+import 'zod';
+import '../source/toc.js';
+import '../source/types.js';
+import '../document/database.js';
+import 'sqlite3';
+import '../document/text-streams.js';
+import '../document/types.js';
+import '../document/stores.js';
+import '../facade/wiki-graph-archive.js';
+import '../facade/chapter.js';
+import '../common/language.js';
+import '../common/llm-scope.js';
+import '../llm/client.js';
+import '../llm/context.js';
+import '../llm/cache.js';
+import '../llm/types.js';
+import 'ai';
+import '../reader/types.js';
+import '../reader/attention/attention.js';
+import '../reader/chunk-batch/types.js';
+import '../reader/segment/types.js';
+import '../serial.js';
+import '../facade/types.js';
+import '../gc/types.js';

package/dist/wikg/index.js

@@ -0,0 +1,60 @@
+import {
+  extractWikgArchive,
+  listWikgArchiveEntries,
+  readWikgArchiveEntry,
+  readWikgArchiveFormatVersion,
+  WikgArchiveReader,
+  WIKG_FORMAT_VERSION,
+  writeWikgArchive,
+  writeWikgArchiveWithOverlays
+} from "./archive.js";
+import {
+  formatLocatedChapterResourceUri,
+  formatLocatedChapterSourceCollectionUri,
+  formatLocatedChapterUri,
+  formatLocatedWikiGraphUri,
+  formatWikiGraphCommandUri,
+  formatWikiGraphObjectUri,
+  formatWikiGraphUriExpectedError,
+  isWikiGraphJobUri,
+  isWikiGraphUri,
+  parseLocatedWikiGraphUri,
+  requireArchiveUri,
+  requireLocatedObjectOrArchiveUri,
+  requireLocatedObjectUri,
+  WIKI_GRAPH_ARCHIVE_EXTENSION,
+  WIKI_GRAPH_JOB_URI_PREFIX,
+  WIKI_GRAPH_URI_PREFIX
+} from "./archive-uri.js";
+import { WikiGraphArchiveFile } from "./wiki-graph-archive-file.js";
+import { runWikgCoordinatorGc, WikgCoordinator } from "./wikg-coordinator.js";
+export {
+  WIKG_FORMAT_VERSION,
+  WIKI_GRAPH_ARCHIVE_EXTENSION,
+  WIKI_GRAPH_JOB_URI_PREFIX,
+  WIKI_GRAPH_URI_PREFIX,
+  WikgArchiveReader,
+  WikgCoordinator,
+  WikiGraphArchiveFile,
+  extractWikgArchive,
+  formatLocatedChapterResourceUri,
+  formatLocatedChapterSourceCollectionUri,
+  formatLocatedChapterUri,
+  formatLocatedWikiGraphUri,
+  formatWikiGraphCommandUri,
+  formatWikiGraphObjectUri,
+  formatWikiGraphUriExpectedError,
+  isWikiGraphJobUri,
+  isWikiGraphUri,
+  listWikgArchiveEntries,
+  parseLocatedWikiGraphUri,
+  readWikgArchiveEntry,
+  readWikgArchiveFormatVersion,
+  requireArchiveUri,
+  requireLocatedObjectOrArchiveUri,
+  requireLocatedObjectUri,
+  runWikgCoordinatorGc,
+  writeWikgArchive,
+  writeWikgArchiveWithOverlays
+};
+//# sourceMappingURL=index.js.map

package/dist/wikg/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wikg/index.ts"],"sourcesContent":["export {\n  extractWikgArchive,\n  listWikgArchiveEntries,\n  readWikgArchiveEntry,\n  readWikgArchiveFormatVersion,\n  WikgArchiveReader,\n  WIKG_FORMAT_VERSION,\n  writeWikgArchive,\n  writeWikgArchiveWithOverlays,\n} from \"./archive.js\";\nexport type { WikgArchiveOverlay } from \"./archive.js\";\nexport {\n  formatLocatedChapterResourceUri,\n  formatLocatedChapterSourceCollectionUri,\n  formatLocatedChapterUri,\n  formatLocatedWikiGraphUri,\n  formatWikiGraphCommandUri,\n  formatWikiGraphObjectUri,\n  formatWikiGraphUriExpectedError,\n  isWikiGraphJobUri,\n  isWikiGraphUri,\n  parseLocatedWikiGraphUri,\n  requireArchiveUri,\n  requireLocatedObjectOrArchiveUri,\n  requireLocatedObjectUri,\n  WIKI_GRAPH_ARCHIVE_EXTENSION,\n  WIKI_GRAPH_JOB_URI_PREFIX,\n  WIKI_GRAPH_URI_PREFIX,\n} from \"./archive-uri.js\";\nexport type { LocatedWikiGraphUri } from \"./archive-uri.js\";\nexport { WikiGraphArchiveFile } from \"./wiki-graph-archive-file.js\";\nexport { runWikgCoordinatorGc, WikgCoordinator } from \"./wikg-coordinator.js\";\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,4BAA4B;AACrC,SAAS,sBAAsB,uBAAuB;","names":[]}