wiki-graph-core 0.3.1 → 0.4.1

package/dist/wikg/archive-uri.js

@@ -1,37 +0,0 @@
-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 "../common/wiki-graph-uri.js";
-export {
-  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
-};
-//# sourceMappingURL=archive-uri.js.map

package/dist/wikg/archive-uri.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/wikg/archive-uri.ts"],"sourcesContent":["export {\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  type LocatedWikiGraphUri,\n} from \"../common/wiki-graph-uri.js\";\n"],"mappings":"AAAA;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,OAEK;","names":[]}

package/dist/wikg/archive.d.ts

@@ -1,28 +0,0 @@
-import { ZipFile, Entry } from 'yauzl';
-
-declare const WIKG_FORMAT_VERSION = 1;
-type WikgArchiveOverlay = {
-    readonly entryPath: string;
-    readonly kind: "deleted";
-} | {
-    readonly entryPath: string;
-    readonly kind: "file";
-    readonly workspacePath: string;
-};
-declare class WikgArchiveReader {
-    #private;
-    constructor(path: string, zipFile: ZipFile, entries: readonly Entry[]);
-    static open(inputPath: string): Promise<WikgArchiveReader>;
-    close(): void;
-    listEntries(): readonly string[];
-    readEntry(entryPath: string): Promise<Buffer | undefined>;
-}
-declare function extractWikgArchive(inputPath: string, outputDirectoryPath: string): Promise<void>;
-declare function writeWikgArchive(documentDirectoryPath: string, outputPath: string): Promise<void>;
-declare function listWikgArchiveEntries(inputPath: string): Promise<readonly string[]>;
-declare function readWikgArchiveEntry(inputPath: string, entryPath: string): Promise<Buffer | undefined>;
-declare function readWikgArchiveMutationToken(inputPath: string): Promise<string>;
-declare function writeWikgArchiveWithOverlays(inputPath: string, outputPath: string, overlays: readonly WikgArchiveOverlay[]): Promise<void>;
-declare function readWikgArchiveFormatVersion(documentDirectoryPath: string): Promise<number>;
-
-export { WIKG_FORMAT_VERSION, type WikgArchiveOverlay, WikgArchiveReader, extractWikgArchive, listWikgArchiveEntries, readWikgArchiveEntry, readWikgArchiveFormatVersion, readWikgArchiveMutationToken, writeWikgArchive, writeWikgArchiveWithOverlays };

package/dist/wikg/archive.js

@@ -1,496 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,31 +0,0 @@
-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';