wiki-graph-core 0.3.1 → 0.4.1

package/dist/storage/wikg/archive/index.js

@@ -0,0 +1,25 @@
+import { extractWikgArchive } from "./extract.js";
+import {
+  listWikgArchiveEntries,
+  readWikgArchiveEntry,
+  readWikgArchiveFormatVersion,
+  readWikgArchiveMutationToken,
+  readWikgArchiveSchemaVersion,
+  WikgArchiveReader
+} from "./reader.js";
+import { WIKG_FORMAT_VERSION, WIKG_SCHEMA_VERSION } from "./manifest.js";
+import { writeWikgArchive, writeWikgArchiveWithOverlays } from "./write.js";
+export {
+  WIKG_FORMAT_VERSION,
+  WIKG_SCHEMA_VERSION,
+  WikgArchiveReader,
+  extractWikgArchive,
+  listWikgArchiveEntries,
+  readWikgArchiveEntry,
+  readWikgArchiveFormatVersion,
+  readWikgArchiveMutationToken,
+  readWikgArchiveSchemaVersion,
+  writeWikgArchive,
+  writeWikgArchiveWithOverlays
+};
+//# sourceMappingURL=index.js.map

package/dist/storage/wikg/archive/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/archive/index.ts"],"sourcesContent":["export { extractWikgArchive } from \"./extract.js\";\nexport {\n  listWikgArchiveEntries,\n  readWikgArchiveEntry,\n  readWikgArchiveFormatVersion,\n  readWikgArchiveMutationToken,\n  readWikgArchiveSchemaVersion,\n  WikgArchiveReader,\n} from \"./reader.js\";\nexport { WIKG_FORMAT_VERSION, WIKG_SCHEMA_VERSION } from \"./manifest.js\";\nexport { writeWikgArchive, writeWikgArchiveWithOverlays } from \"./write.js\";\nexport type { WikgArchiveOverlay } from \"./types.js\";\n"],"mappings":"AAAA,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,qBAAqB,2BAA2B;AACzD,SAAS,kBAAkB,oCAAoC;","names":[]}

package/dist/storage/wikg/archive/manifest.d.ts

@@ -0,0 +1,11 @@
+declare const WIKG_FORMAT_VERSION = 1;
+declare const WIKG_SCHEMA_VERSION = 2;
+declare const WIKG_MANIFEST_CONTENT: string;
+declare function parseWikgManifest(content: string): {
+    readonly formatVersion: number;
+    readonly schemaVersion: number;
+};
+declare function createWikgMutationTokenContent(): Buffer;
+declare function parseWikgMutationToken(content: string): string;
+
+export { WIKG_FORMAT_VERSION, WIKG_MANIFEST_CONTENT, WIKG_SCHEMA_VERSION, createWikgMutationTokenContent, parseWikgManifest, parseWikgMutationToken };

package/dist/storage/wikg/archive/manifest.js

@@ -0,0 +1,60 @@
+import { randomBytes } from "crypto";
+import { z } from "zod";
+import { WIKG_MANIFEST_PATH, WIKG_MUTATION_TOKEN_PATH } from "./constants.js";
+const WIKG_FORMAT_VERSION = 1;
+const WIKG_SCHEMA_VERSION = 2;
+const WIKG_MANIFEST_CONTENT = `${JSON.stringify({
+  formatVersion: WIKG_FORMAT_VERSION,
+  schemaVersion: WIKG_SCHEMA_VERSION
+})}
+`;
+const WIKG_MUTATION_TOKEN_MAGIC = "wikg-mutation-token:v1";
+const WIKG_MUTATION_TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/u;
+const wikgManifestSchema = z.object({
+  formatVersion: z.literal(WIKG_FORMAT_VERSION),
+  schemaVersion: z.number().int().positive().optional()
+});
+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 {
+    formatVersion: result.data.formatVersion,
+    schemaVersion: result.data.schemaVersion ?? 1
+  };
+}
+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;
+}
+export {
+  WIKG_FORMAT_VERSION,
+  WIKG_MANIFEST_CONTENT,
+  WIKG_SCHEMA_VERSION,
+  createWikgMutationTokenContent,
+  parseWikgManifest,
+  parseWikgMutationToken
+};
+//# sourceMappingURL=manifest.js.map

package/dist/storage/wikg/archive/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/archive/manifest.ts"],"sourcesContent":["import { randomBytes } from \"crypto\";\n\nimport { z } from \"zod\";\n\nimport { WIKG_MANIFEST_PATH, WIKG_MUTATION_TOKEN_PATH } from \"./constants.js\";\n\nexport const WIKG_FORMAT_VERSION = 1;\nexport const WIKG_SCHEMA_VERSION = 2;\nexport const WIKG_MANIFEST_CONTENT = `${JSON.stringify({\n  formatVersion: WIKG_FORMAT_VERSION,\n  schemaVersion: WIKG_SCHEMA_VERSION,\n})}\\n`;\n\nconst WIKG_MUTATION_TOKEN_MAGIC = \"wikg-mutation-token:v1\";\nconst WIKG_MUTATION_TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/u;\n\nconst wikgManifestSchema = z.object({\n  formatVersion: z.literal(WIKG_FORMAT_VERSION),\n  schemaVersion: z.number().int().positive().optional(),\n});\n\nexport function parseWikgManifest(content: string): {\n  readonly formatVersion: number;\n  readonly schemaVersion: number;\n} {\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 {\n    formatVersion: result.data.formatVersion,\n    schemaVersion: result.data.schemaVersion ?? 1,\n  };\n}\n\nexport function createWikgMutationTokenContent(): Buffer {\n  const token = randomBytes(32).toString(\"base64url\");\n\n  return Buffer.from(`${WIKG_MUTATION_TOKEN_MAGIC}\\n${token}\\n`, \"utf8\");\n}\n\nexport function 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"],"mappings":"AAAA,SAAS,mBAAmB;AAE5B,SAAS,SAAS;AAElB,SAAS,oBAAoB,gCAAgC;AAEtD,MAAM,sBAAsB;AAC5B,MAAM,sBAAsB;AAC5B,MAAM,wBAAwB,GAAG,KAAK,UAAU;AAAA,EACrD,eAAe;AAAA,EACf,eAAe;AACjB,CAAC,CAAC;AAAA;AAEF,MAAM,4BAA4B;AAClC,MAAM,8BAA8B;AAEpC,MAAM,qBAAqB,EAAE,OAAO;AAAA,EAClC,eAAe,EAAE,QAAQ,mBAAmB;AAAA,EAC5C,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS;AACtD,CAAC;AAEM,SAAS,kBAAkB,SAGhC;AACA,MAAI;AAEJ,MAAI;AACF,aAAS,KAAK,MAAM,OAAO;AAAA,EAC7B,QAAQ;AACN,UAAM,IAAI,MAAM,0BAA0B,kBAAkB,GAAG;AAAA,EACjE;AAEA,QAAM,SAAS,mBAAmB,UAAU,MAAM;AAElD,MAAI,CAAC,OAAO,SAAS;AACnB,UAAM,IAAI;AAAA,MACR,sCAAsC,kBAAkB;AAAA,IAC1D;AAAA,EACF;AAEA,SAAO;AAAA,IACL,eAAe,OAAO,KAAK;AAAA,IAC3B,eAAe,OAAO,KAAK,iBAAiB;AAAA,EAC9C;AACF;AAEO,SAAS,iCAAyC;AACvD,QAAM,QAAQ,YAAY,EAAE,EAAE,SAAS,WAAW;AAElD,SAAO,OAAO,KAAK,GAAG,yBAAyB;AAAA,EAAK,KAAK;AAAA,GAAM,MAAM;AACvE;AAEO,SAAS,uBAAuB,SAAyB;AAC9D,QAAM,QAAQ,QAAQ,MAAM,QAAQ;AACpC,QAAM,QAAQ,MAAM,CAAC;AACrB,QAAM,QAAQ,MAAM,CAAC;AAErB,MACE,UAAU,6BACV,UAAU,UACV,CAAC,4BAA4B,KAAK,KAAK,GACvC;AACA,UAAM,IAAI;AAAA,MACR,gCAAgC,wBAAwB;AAAA,IAC1D;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/storage/wikg/archive/paths.d.ts

@@ -0,0 +1,9 @@
+declare function normalizeArchivePath(path: string): string;
+declare function isWikgArchivePath(archivePath: string): boolean;
+declare function assertWithinDirectory(rootDirectoryPath: string, targetPath: string, archivePath: string): void;
+declare function sortArchiveEntriesForWrite<T extends {
+    readonly archivePath: string;
+}>(entries: readonly T[]): T[];
+declare function sortArchiveEntryPathsForWrite(paths: Iterable<string>): string[];
+
+export { assertWithinDirectory, isWikgArchivePath, normalizeArchivePath, sortArchiveEntriesForWrite, sortArchiveEntryPathsForWrite };

package/dist/storage/wikg/archive/paths.js

@@ -0,0 +1,46 @@
+import { posix, resolve, sep } from "path";
+import {
+  WIKG_ARCHIVE_PATTERNS,
+  WIKG_MUTATION_TOKEN_PATH
+} from "./constants.js";
+function normalizeArchivePath(path) {
+  const normalized = path.replaceAll("\\", "/").trim();
+  const withoutLeadingSlash = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+  return posix.normalize(withoutLeadingSlash).replace(/^(\.\/)+/u, "").replace(/^\/+/u, "");
+}
+function isWikgArchivePath(archivePath) {
+  return WIKG_ARCHIVE_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 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);
+}
+export {
+  assertWithinDirectory,
+  isWikgArchivePath,
+  normalizeArchivePath,
+  sortArchiveEntriesForWrite,
+  sortArchiveEntryPathsForWrite
+};
+//# sourceMappingURL=paths.js.map

package/dist/storage/wikg/archive/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/archive/paths.ts"],"sourcesContent":["import { posix, resolve, sep } from \"path\";\n\nimport {\n  WIKG_ARCHIVE_PATTERNS,\n  WIKG_MUTATION_TOKEN_PATH,\n} from \"./constants.js\";\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 function isWikgArchivePath(archivePath: string): boolean {\n  return WIKG_ARCHIVE_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 sortArchiveEntriesForWrite<\n  T extends { readonly archivePath: string },\n>(entries: readonly T[]): T[] {\n  return [...entries].sort((left, right) =>\n    compareArchiveEntryPathsForWrite(left.archivePath, right.archivePath),\n  );\n}\n\nexport function sortArchiveEntryPathsForWrite(\n  paths: Iterable<string>,\n): 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"],"mappings":"AAAA,SAAS,OAAO,SAAS,WAAW;AAEpC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEA,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;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,2BAEd,SAA4B;AAC5B,SAAO,CAAC,GAAG,OAAO,EAAE;AAAA,IAAK,CAAC,MAAM,UAC9B,iCAAiC,KAAK,aAAa,MAAM,WAAW;AAAA,EACtE;AACF;AAEO,SAAS,8BACd,OACU;AACV,SAAO,CAAC,GAAG,KAAK,EAAE,KAAK,gCAAgC;AACzD;AAEA,SAAS,iCAAiC,MAAc,OAAuB;AAC7E,MAAI,SAAS,0BAA0B;AACrC,WAAO,UAAU,2BAA2B,IAAI;AAAA,EAClD;AACA,MAAI,UAAU,0BAA0B;AACtC,WAAO;AAAA,EACT;AAEA,SAAO,KAAK,cAAc,KAAK;AACjC;","names":[]}

package/dist/storage/wikg/archive/reader.d.ts

@@ -0,0 +1,17 @@
+import { ZipFile, Entry } from 'yauzl';
+
+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 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 readWikgArchiveFormatVersion(documentDirectoryPath: string): Promise<number>;
+declare function readWikgArchiveSchemaVersion(documentDirectoryPath: string): Promise<number>;
+
+export { WikgArchiveReader, listWikgArchiveEntries, readWikgArchiveEntry, readWikgArchiveFormatVersion, readWikgArchiveMutationToken, readWikgArchiveSchemaVersion };

package/dist/storage/wikg/archive/reader.js

@@ -0,0 +1,101 @@
+import { open as openFile, readFile } from "fs/promises";
+import { join } from "path";
+import { WIKG_MANIFEST_PATH, WIKG_MUTATION_TOKEN_PATH } from "./constants.js";
+import { parseWikgManifest, parseWikgMutationToken } from "./manifest.js";
+import { isWikgArchivePath, normalizeArchivePath } from "./paths.js";
+import { openIndexedArchive, readArchiveEntryBufferFromFile } from "./zip.js";
+import { ensureWikiGraphArchiveSchemaCurrent } from "../../schema-upgrade/index.js";
+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) {
+    await ensureWikiGraphArchiveSchemaCurrent(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 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 readWikgArchiveFormatVersion(documentDirectoryPath) {
+  return parseWikgManifest(
+    await readFile(join(documentDirectoryPath, WIKG_MANIFEST_PATH), "utf8")
+  ).formatVersion;
+}
+async function readWikgArchiveSchemaVersion(documentDirectoryPath) {
+  return parseWikgManifest(
+    await readFile(join(documentDirectoryPath, WIKG_MANIFEST_PATH), "utf8")
+  ).schemaVersion;
+}
+export {
+  WikgArchiveReader,
+  listWikgArchiveEntries,
+  readWikgArchiveEntry,
+  readWikgArchiveFormatVersion,
+  readWikgArchiveMutationToken,
+  readWikgArchiveSchemaVersion
+};
+//# sourceMappingURL=reader.js.map

package/dist/storage/wikg/archive/reader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/archive/reader.ts"],"sourcesContent":["import { open as openFile, readFile, type FileHandle } from \"fs/promises\";\nimport { join } from \"path\";\n\nimport type { Entry, ZipFile as YauzlZipFile } from \"yauzl\";\n\nimport { WIKG_MANIFEST_PATH, WIKG_MUTATION_TOKEN_PATH } from \"./constants.js\";\nimport { parseWikgManifest, parseWikgMutationToken } from \"./manifest.js\";\nimport { isWikgArchivePath, normalizeArchivePath } from \"./paths.js\";\nimport { openIndexedArchive, readArchiveEntryBufferFromFile } from \"./zip.js\";\nimport { ensureWikiGraphArchiveSchemaCurrent } from \"../../schema-upgrade/index.js\";\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    await ensureWikiGraphArchiveSchemaCurrent(inputPath);\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 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 readWikgArchiveFormatVersion(\n  documentDirectoryPath: string,\n): Promise<number> {\n  return parseWikgManifest(\n    await readFile(join(documentDirectoryPath, WIKG_MANIFEST_PATH), \"utf8\"),\n  ).formatVersion;\n}\n\nexport async function readWikgArchiveSchemaVersion(\n  documentDirectoryPath: string,\n): Promise<number> {\n  return parseWikgManifest(\n    await readFile(join(documentDirectoryPath, WIKG_MANIFEST_PATH), \"utf8\"),\n  ).schemaVersion;\n}\n"],"mappings":"AAAA,SAAS,QAAQ,UAAU,gBAAiC;AAC5D,SAAS,YAAY;AAIrB,SAAS,oBAAoB,gCAAgC;AAC7D,SAAS,mBAAmB,8BAA8B;AAC1D,SAAS,mBAAmB,4BAA4B;AACxD,SAAS,oBAAoB,sCAAsC;AACnE,SAAS,2CAA2C;AAE7C,MAAM,kBAAkB;AAAA,EACpB;AAAA,EACA;AAAA,EACT;AAAA,EACS;AAAA,EACA;AAAA,EAEF,YACL,MACA,SACA,SACA;AACA,SAAK,QAAQ;AACb,SAAK,WAAW;AAChB,SAAK,eAAe,IAAI;AAAA,MACtB,QACG,IAAI,CAAC,UAAU,CAAC,qBAAqB,MAAM,QAAQ,GAAG,KAAK,CAAU,EACrE,OAAO,CAAC,CAAC,SAAS,MAAM,cAAc,EAAE,EACxC,OAAO,CAAC,CAAC,SAAS,MAAM,kBAAkB,SAAS,CAAC;AAAA,IACzD;AACA,SAAK,WAAW,CAAC,GAAG,KAAK,aAAa,KAAK,CAAC,EAAE;AAAA,MAAK,CAAC,MAAM,UACxD,KAAK,cAAc,KAAK;AAAA,IAC1B;AAAA,EACF;AAAA,EAEA,aAAoB,KAAK,WAA+C;AACtE,UAAM,oCAAoC,SAAS;AACnD,UAAM,EAAE,SAAS,QAAQ,IAAI,MAAM,mBAAmB,SAAS;AAE/D,WAAO,IAAI,kBAAkB,WAAW,SAAS,OAAO;AAAA,EAC1D;AAAA,EAEO,QAAc;AACnB,SAAK,SAAS,MAAM;AACpB,QAAI,KAAK,UAAU,QAAW;AAC5B,WAAK,KAAK,MAAM,KAAK,OAAO,SAAS;AACnC,cAAM,KAAK,MAAM;AAAA,MACnB,CAAC;AACD,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA,EAEO,cAAiC;AACtC,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,MAAa,UAAU,WAAgD;AACrE,UAAM,QAAQ,KAAK,aAAa,IAAI,qBAAqB,SAAS,CAAC;AAEnE,QAAI,UAAU,QAAW;AACvB,aAAO;AAAA,IACT;AAEA,WAAO,MAAM,+BAA+B,MAAM,KAAK,SAAS,GAAG,KAAK;AAAA,EAC1E;AAAA,EAEA,MAAM,WAAgC;AACpC,SAAK,UAAU,SAAS,KAAK,OAAO,GAAG;AACvC,WAAO,MAAM,KAAK;AAAA,EACpB;AACF;AAEA,eAAsB,uBACpB,WAC4B;AAC5B,QAAM,SAAS,MAAM,kBAAkB,KAAK,SAAS;AAErD,MAAI;AACF,WAAO,OAAO,YAAY;AAAA,EAC5B,UAAE;AACA,WAAO,MAAM;AAAA,EACf;AACF;AAEA,eAAsB,qBACpB,WACA,WAC6B;AAC7B,QAAM,SAAS,MAAM,kBAAkB,KAAK,SAAS;AAErD,MAAI;AACF,WAAO,MAAM,OAAO,UAAU,SAAS;AAAA,EACzC,UAAE;AACA,WAAO,MAAM;AAAA,EACf;AACF;AAEA,eAAsB,6BACpB,WACiB;AACjB,QAAM,SAAS,MAAM,kBAAkB,KAAK,SAAS;AAErD,MAAI;AACF,UAAM,UAAU,MAAM,OAAO,UAAU,wBAAwB;AAE/D,QAAI,YAAY,QAAW;AACzB,YAAM,IAAI;AAAA,QACR,gCAAgC,wBAAwB;AAAA,MAC1D;AAAA,IACF;AAEA,WAAO,uBAAuB,QAAQ,SAAS,MAAM,CAAC;AAAA,EACxD,UAAE;AACA,WAAO,MAAM;AAAA,EACf;AACF;AAEA,eAAsB,6BACpB,uBACiB;AACjB,SAAO;AAAA,IACL,MAAM,SAAS,KAAK,uBAAuB,kBAAkB,GAAG,MAAM;AAAA,EACxE,EAAE;AACJ;AAEA,eAAsB,6BACpB,uBACiB;AACjB,SAAO;AAAA,IACL,MAAM,SAAS,KAAK,uBAAuB,kBAAkB,GAAG,MAAM;AAAA,EACxE,EAAE;AACJ;","names":[]}

package/dist/storage/wikg/archive/types.d.ts

@@ -0,0 +1,10 @@
+type WikgArchiveOverlay = {
+    readonly entryPath: string;
+    readonly kind: "deleted";
+} | {
+    readonly entryPath: string;
+    readonly kind: "file";
+    readonly workspacePath: string;
+};
+
+export type { WikgArchiveOverlay };

package/dist/storage/wikg/archive/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/storage/wikg/archive/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/storage/wikg/archive/write.d.ts

@@ -0,0 +1,8 @@
+import { WikgArchiveOverlay } from './types.js';
+
+declare function writeWikgArchive(documentDirectoryPath: string, outputPath: string): Promise<void>;
+declare function writeWikgArchiveWithOverlays(inputPath: string, outputPath: string, overlays: readonly WikgArchiveOverlay[], options?: {
+    readonly preserveMutationToken?: boolean;
+}): Promise<void>;
+
+export { writeWikgArchive, writeWikgArchiveWithOverlays };

package/dist/storage/wikg/archive/write.js

@@ -0,0 +1,155 @@
+import { createWriteStream } from "fs";
+import { mkdir, open as openFile } from "fs/promises";
+import { dirname } from "path";
+import { finished } from "stream/promises";
+import { ZipFile as YazlZipFile } from "yazl";
+import { WIKG_MANIFEST_PATH, WIKG_MUTATION_TOKEN_PATH } from "./constants.js";
+import {
+  listDocumentFiles,
+  shouldEmbedSearchIndex,
+  shouldWriteDocumentFile
+} from "./document-files.js";
+import {
+  createWikgMutationTokenContent,
+  WIKG_MANIFEST_CONTENT
+} from "./manifest.js";
+import {
+  isWikgArchivePath,
+  normalizeArchivePath,
+  sortArchiveEntriesForWrite,
+  sortArchiveEntryPathsForWrite
+} from "./paths.js";
+import { openIndexedArchive, readArchiveEntryBufferFromFile } from "./zip.js";
+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) => shouldWriteDocumentFile({
+        archivePath: file.archivePath,
+        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();
+  await writeZipFile(zipFile, outputPath);
+}
+async function writeWikgArchiveWithOverlays(inputPath, outputPath, overlays, options = {}) {
+  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) {
+        if (options.preserveMutationToken === true) {
+          const sourceEntry2 = sourceEntries.find(
+            (candidate) => normalizeArchivePath(candidate.fileName) === entryPath
+          );
+          if (sourceEntry2 !== void 0) {
+            outputZipFile.addBuffer(
+              await readArchiveEntryBufferFromFile(sourceFile, sourceEntry2),
+              entryPath,
+              { compress: false }
+            );
+            continue;
+          }
+        }
+        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();
+  await writeZipFile(outputZipFile, outputPath);
+}
+async function writeZipFile(zipFile, outputPath) {
+  const output = createWriteStream(outputPath);
+  const outputDone = finished(output);
+  const zipDone = finished(zipFile.outputStream);
+  zipFile.outputStream.pipe(output);
+  await Promise.all([outputDone, zipDone]);
+}
+export {
+  writeWikgArchive,
+  writeWikgArchiveWithOverlays
+};
+//# sourceMappingURL=write.js.map

package/dist/storage/wikg/archive/write.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/storage/wikg/archive/write.ts"],"sourcesContent":["import { createWriteStream } from \"fs\";\nimport { mkdir, open as openFile } from \"fs/promises\";\nimport { dirname } from \"path\";\nimport { finished } from \"stream/promises\";\n\nimport { ZipFile as YazlZipFile } from \"yazl\";\n\nimport { WIKG_MANIFEST_PATH, WIKG_MUTATION_TOKEN_PATH } from \"./constants.js\";\nimport {\n  listDocumentFiles,\n  shouldEmbedSearchIndex,\n  shouldWriteDocumentFile,\n} from \"./document-files.js\";\nimport {\n  createWikgMutationTokenContent,\n  WIKG_MANIFEST_CONTENT,\n} from \"./manifest.js\";\nimport {\n  isWikgArchivePath,\n  normalizeArchivePath,\n  sortArchiveEntriesForWrite,\n  sortArchiveEntryPathsForWrite,\n} from \"./paths.js\";\nimport type { WikgArchiveOverlay } from \"./types.js\";\nimport { openIndexedArchive, readArchiveEntryBufferFromFile } from \"./zip.js\";\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      shouldWriteDocumentFile({\n        archivePath: file.archivePath,\n        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  await writeZipFile(zipFile, outputPath);\n}\n\nexport async function writeWikgArchiveWithOverlays(\n  inputPath: string,\n  outputPath: string,\n  overlays: readonly WikgArchiveOverlay[],\n  options: { readonly preserveMutationToken?: boolean } = {},\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        if (options.preserveMutationToken === true) {\n          const sourceEntry = sourceEntries.find(\n            (candidate) =>\n              normalizeArchivePath(candidate.fileName) === entryPath,\n          );\n\n          if (sourceEntry !== undefined) {\n            outputZipFile.addBuffer(\n              await readArchiveEntryBufferFromFile(sourceFile, sourceEntry),\n              entryPath,\n              { compress: false },\n            );\n            continue;\n          }\n        }\n\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  await writeZipFile(outputZipFile, outputPath);\n}\n\nasync function writeZipFile(\n  zipFile: YazlZipFile,\n  outputPath: string,\n): Promise<void> {\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"],"mappings":"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","names":["sourceEntry"]}

package/dist/storage/wikg/archive/zip.d.ts

@@ -0,0 +1,13 @@
+import { FileHandle } from 'fs/promises';
+import { ZipFile, Entry } from 'yauzl';
+
+declare function openIndexedArchive(inputPath: string): Promise<{
+    readonly entries: readonly Entry[];
+    readonly zipFile: ZipFile;
+}>;
+declare function indexArchiveEntries(zipFile: ZipFile): Promise<readonly Entry[]>;
+declare function readArchiveEntryText(inputPath: string, entry: Entry): Promise<string>;
+declare function readArchiveEntryBuffer(inputPath: string, entry: Entry): Promise<Buffer>;
+declare function readArchiveEntryBufferFromFile(file: FileHandle, entry: Entry): Promise<Buffer>;
+
+export { indexArchiveEntries, openIndexedArchive, readArchiveEntryBuffer, readArchiveEntryBufferFromFile, readArchiveEntryText };

package/dist/storage/wikg/archive/zip.js

@@ -0,0 +1,122 @@
+import { open as openFile } from "fs/promises";
+import { inflateRaw } from "zlib";
+import {
+  open as openZip
+} from "yauzl";
+import { WIKG_MANIFEST_PATH, WIKG_MUTATION_TOKEN_PATH } from "./constants.js";
+import { parseWikgManifest, parseWikgMutationToken } from "./manifest.js";
+import { normalizeArchivePath } from "./paths.js";
+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((resolve, reject) => {
+    const entries = [];
+    zipFile.on("entry", (entry) => {
+      if (entry.fileName.endsWith("/")) {
+        zipFile.readEntry();
+        return;
+      }
+      entries.push(entry);
+      zipFile.readEntry();
+    });
+    zipFile.once("end", () => {
+      resolve(entries);
+    });
+    zipFile.once("error", (error) => {
+      reject(error);
+    });
+    zipFile.readEntry();
+  });
+}
+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 openArchive(path) {
+  return await new Promise((resolve, reject) => {
+    openZip(path, { autoClose: false, lazyEntries: true }, (error, zipFile) => {
+      if (error !== null || zipFile === void 0) {
+        reject(error ?? new Error(`Cannot open archive: ${path}`));
+        return;
+      }
+      resolve(zipFile);
+    });
+  });
+}
+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]));
+}
+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 {
+  indexArchiveEntries,
+  openIndexedArchive,
+  readArchiveEntryBuffer,
+  readArchiveEntryBufferFromFile,
+  readArchiveEntryText
+};
+//# sourceMappingURL=zip.js.map