wiki-graph-core 0.3.1

package/dist/legacy-sdpub/upgrade.js

@@ -0,0 +1,795 @@
+import { createWriteStream } from "fs";
+import { mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
+import { dirname, join, posix, resolve, sep } from "path";
+import { pipeline } from "stream/promises";
+import { createWikiGraphTempDirectory } from "../common/wiki-graph-temp.js";
+import {
+  open as openZip
+} from "yauzl";
+import { Database } from "../document/database.js";
+import { DirectoryDocument } from "../document/document.js";
+import { writeWikgArchive } from "../wikg/index.js";
+import { isNodeError } from "../utils/node-error.js";
+const LEGACY_SDPUB_PATTERNS = [
+  /^manifest\.json$/u,
+  /^database\.db$/u,
+  /^toc\.json$/u,
+  /^cover\/(?:data\.bin|info\.json)$/u,
+  /^summaries\/serial-\d+\.txt$/u,
+  /^fragments\/serial-\d+\/fragment_\d+\.json$/u
+];
+const LEGACY_FORMAT_VERSION = 1;
+async function migrateLegacySdpubToWikg(inputPath, outputPath = defaultWikgOutputPath(inputPath)) {
+  if (resolve(inputPath) === resolve(outputPath)) {
+    throw new Error(
+      "Legacy migration output path must differ from input path."
+    );
+  }
+  const workspacePath = await createWikiGraphTempDirectory("sdpub-upgrade");
+  try {
+    await extractLegacySdpubArchive(inputPath, workspacePath);
+    await migrateLegacyDatabase(join(workspacePath, "database.db"));
+    await migrateLegacyTextStorage(workspacePath);
+    await writeWikgArchive(workspacePath, outputPath);
+    return { inputPath, outputPath };
+  } finally {
+    await rm(workspacePath, { force: true, recursive: true });
+  }
+}
+function defaultWikgOutputPath(inputPath) {
+  if (inputPath.toLowerCase().endsWith(".sdpub")) {
+    return `${inputPath.slice(0, -".sdpub".length)}.wikg`;
+  }
+  return `${inputPath}.wikg`;
+}
+async function extractLegacySdpubArchive(inputPath, outputDirectoryPath) {
+  const zipFile = await openArchive(inputPath);
+  try {
+    const entries = await indexArchiveEntries(zipFile);
+    await assertLegacySdpubArchive(zipFile, entries);
+    for (const entry of entries) {
+      const archivePath = normalizeArchivePath(entry.fileName);
+      if (archivePath === "" || !isLegacySdpubPath(archivePath)) {
+        continue;
+      }
+      const targetPath = resolve(outputDirectoryPath, archivePath);
+      assertWithinDirectory(outputDirectoryPath, targetPath, archivePath);
+      await mkdir(dirname(targetPath), { recursive: true });
+      await pipeline(
+        await openArchiveEntryStream(zipFile, entry),
+        createWriteStream(targetPath)
+      );
+    }
+  } finally {
+    zipFile.close();
+  }
+}
+async function assertLegacySdpubArchive(zipFile, entries) {
+  const paths = new Set(
+    entries.map((entry) => normalizeArchivePath(entry.fileName))
+  );
+  if (!paths.has("database.db") || !paths.has("toc.json")) {
+    throw new Error("Unsupported legacy sdpub archive.");
+  }
+  if (paths.has("manifest.json")) {
+    const manifestEntry = entries.find(
+      (entry) => normalizeArchivePath(entry.fileName) === "manifest.json"
+    );
+    if (manifestEntry === void 0) {
+      throw new Error("Unsupported legacy sdpub archive.");
+    }
+    assertSupportedManifest(await readArchiveEntryText(zipFile, manifestEntry));
+  }
+}
+function assertSupportedManifest(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.formatVersion === LEGACY_FORMAT_VERSION) {
+      return;
+    }
+  } catch {
+    throw new Error("Unsupported legacy sdpub archive.");
+  }
+  throw new Error("Unsupported legacy sdpub archive.");
+}
+async function migrateLegacyDatabase(databasePath) {
+  const database = await Database.open(databasePath);
+  try {
+    await migrateKnowledgeEdges(database);
+    await migrateSerialDocumentOrder(database);
+  } finally {
+    await database.close();
+  }
+}
+async function migrateKnowledgeEdges(database) {
+  const tables = await listTableNames(database);
+  if (tables.has("reading_edges")) {
+    return;
+  }
+  if (!tables.has("knowledge_edges")) {
+    return;
+  }
+  await database.run(`
+    ALTER TABLE knowledge_edges
+    RENAME TO reading_edges
+  `);
+}
+async function migrateSerialDocumentOrder(database) {
+  const columns = await listTableColumns(database, "serials");
+  if (!columns.has("document_order")) {
+    await database.run(`
+      ALTER TABLE serials
+      ADD COLUMN document_order INTEGER NOT NULL DEFAULT 0
+    `);
+  }
+  await database.run(`
+    CREATE INDEX IF NOT EXISTS idx_serials_document_order
+    ON serials(document_order, id)
+  `);
+}
+async function migrateLegacyTextStorage(workspacePath) {
+  const sourceSerials = await listLegacySourceSerials(workspacePath);
+  const remaps = /* @__PURE__ */ new Map();
+  for (const serialId of sourceSerials) {
+    const fragments = await readLegacySourceFragments(workspacePath, serialId);
+    const plan = createDuplicateHalfCanonicalizationPlan(fragments);
+    const canonicalFragments = plan?.canonicalFragments ?? fragments;
+    const fragmentIdMap = plan?.fragmentIdMap ?? /* @__PURE__ */ new Map();
+    const canonicalById = new Map(
+      canonicalFragments.map((fragment) => [fragment.fragmentId, fragment])
+    );
+    const sentenceMap = /* @__PURE__ */ new Map();
+    const textParts = [];
+    let globalSentenceIndex = 0;
+    for (const fragment of canonicalFragments) {
+      for (let localSentenceIndex = 0; localSentenceIndex < fragment.content.sentences.length; localSentenceIndex += 1) {
+        const sentence = fragment.content.sentences[localSentenceIndex];
+        if (sentence === void 0) {
+          continue;
+        }
+        sentenceMap.set(
+          `${fragment.fragmentId}:${localSentenceIndex}`,
+          globalSentenceIndex
+        );
+        textParts.push(sentence.text);
+        globalSentenceIndex += 1;
+      }
+    }
+    for (const [oldFragmentId, canonicalFragmentId] of fragmentIdMap) {
+      const canonicalFragment = canonicalById.get(canonicalFragmentId);
+      if (canonicalFragment === void 0) {
+        continue;
+      }
+      for (let localSentenceIndex = 0; localSentenceIndex < canonicalFragment.content.sentences.length; localSentenceIndex += 1) {
+        const mapped = sentenceMap.get(
+          `${canonicalFragmentId}:${localSentenceIndex}`
+        );
+        if (mapped !== void 0) {
+          sentenceMap.set(`${oldFragmentId}:${localSentenceIndex}`, mapped);
+        }
+      }
+    }
+    remaps.set(serialId, {
+      get: (fragmentId, sentenceIndex) => sentenceMap.get(`${fragmentId}:${sentenceIndex}`),
+      serialId
+    });
+    const database = await Database.open(join(workspacePath, "database.db"));
+    try {
+      await writeLegacySourceTextStream(database, workspacePath, {
+        fragments: canonicalFragments,
+        serialId,
+        text: textParts.join("")
+      });
+    } finally {
+      await database.close();
+    }
+  }
+  await migrateLegacySentenceReferences(workspacePath, remaps);
+  await migrateLegacySummariesToTextStreams(workspacePath);
+  await rm(join(workspacePath, "fragments"), { force: true, recursive: true });
+  await rm(join(workspacePath, "summaries"), { force: true, recursive: true });
+}
+async function migrateLegacySentenceReferences(workspacePath, remaps) {
+  const database = await Database.open(join(workspacePath, "database.db"));
+  try {
+    const tableNames = await listTableNames(database);
+    await database.transaction(async () => {
+      if (tableNames.has("chunks")) {
+        await migrateLegacyChunks(database, remaps);
+      }
+      if (tableNames.has("chunk_sentences")) {
+        await migrateLegacyChunkSentences(database, remaps);
+      }
+      if (tableNames.has("mentions")) {
+        await migrateLegacyMentions(database, remaps);
+      }
+      if (tableNames.has("mention_link_evidence_sentences")) {
+        await migrateLegacyMentionLinkEvidenceSentences(database, remaps);
+      }
+      if (tableNames.has("fragment_groups")) {
+        await migrateLegacyFragmentGroups(database, remaps);
+      }
+    });
+  } finally {
+    await database.close();
+  }
+}
+async function writeLegacySourceTextStream(database, workspacePath, input) {
+  await database.run(`
+    CREATE TABLE IF NOT EXISTS text_sentence_records (
+      id INTEGER PRIMARY KEY,
+      kind INTEGER NOT NULL,
+      chapter_id INTEGER NOT NULL,
+      sentence_index INTEGER NOT NULL,
+      words_count INTEGER NOT NULL DEFAULT 0,
+      byte_offset INTEGER NOT NULL DEFAULT 0,
+      byte_length INTEGER NOT NULL DEFAULT 0,
+      UNIQUE(kind, chapter_id, sentence_index)
+    )
+  `);
+  await mkdir(join(workspacePath, "texts", "source"), { recursive: true });
+  await writeFile(
+    join(workspacePath, "texts", "source", `${input.serialId}.txt`),
+    input.text,
+    "utf8"
+  );
+  await database.run(
+    `
+      DELETE FROM text_sentence_records
+      WHERE kind = 1 AND chapter_id = ?
+    `,
+    [input.serialId]
+  );
+  let byteOffset = 0;
+  let sentenceIndex = 0;
+  for (const fragment of input.fragments) {
+    for (const sentence of fragment.content.sentences) {
+      const byteLength = Buffer.byteLength(sentence.text, "utf8");
+      await database.run(
+        `
+          INSERT OR REPLACE INTO text_sentence_records (
+            kind,
+            chapter_id,
+            sentence_index,
+            words_count,
+            byte_offset,
+            byte_length
+          )
+          VALUES (1, ?, ?, ?, ?, ?)
+        `,
+        [
+          input.serialId,
+          sentenceIndex,
+          sentence.wordsCount,
+          byteOffset,
+          byteLength
+        ]
+      );
+      byteOffset += byteLength;
+      sentenceIndex += 1;
+    }
+  }
+}
+async function migrateLegacyChunks(database, remaps) {
+  const rows = await database.queryAll(
+    `
+      SELECT *
+      FROM chunks
+      ORDER BY id
+    `,
+    void 0,
+    (row) => row
+  );
+  await database.run("ALTER TABLE chunks RENAME TO legacy_chunks");
+  await database.run(`
+    CREATE TABLE chunks (
+      id INTEGER PRIMARY KEY,
+      generation INTEGER NOT NULL,
+      serial_id INTEGER NOT NULL,
+      sentence_index INTEGER NOT NULL,
+      label TEXT NOT NULL,
+      content TEXT NOT NULL,
+      retention TEXT,
+      importance TEXT,
+      wordsCount INTEGER NOT NULL DEFAULT 0,
+      weight REAL NOT NULL DEFAULT 0.0
+    )
+  `);
+  for (const row of rows) {
+    const serialId = Number(row.serial_id);
+    const sentenceIndex = remapSentenceIndex(
+      remaps,
+      serialId,
+      Number(row.fragment_id),
+      Number(row.sentence_index)
+    );
+    await database.run(
+      `
+        INSERT INTO chunks (
+          id, generation, serial_id, sentence_index, label, content,
+          retention, importance, wordsCount, weight
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      [
+        row.id ?? null,
+        row.generation ?? 0,
+        serialId,
+        sentenceIndex,
+        row.label ?? "",
+        row.content ?? "",
+        row.retention ?? null,
+        row.importance ?? null,
+        row.wordsCount ?? 0,
+        row.weight ?? 0
+      ]
+    );
+  }
+  await database.run("DROP TABLE legacy_chunks");
+}
+async function migrateLegacyChunkSentences(database, remaps) {
+  const rows = await database.queryAll(
+    `
+      SELECT chunk_id, serial_id, fragment_id, sentence_index
+      FROM chunk_sentences
+    `,
+    void 0,
+    (row) => row
+  );
+  await database.run("DROP TABLE chunk_sentences");
+  await database.run(`
+    CREATE TABLE chunk_sentences (
+      chunk_id INTEGER NOT NULL,
+      serial_id INTEGER NOT NULL,
+      sentence_index INTEGER NOT NULL,
+      FOREIGN KEY (chunk_id) REFERENCES chunks(id),
+      PRIMARY KEY (chunk_id, serial_id, sentence_index)
+    )
+  `);
+  for (const row of rows) {
+    const serialId = Number(row.serial_id);
+    await database.run(
+      `
+        INSERT OR IGNORE INTO chunk_sentences (
+          chunk_id, serial_id, sentence_index
+        )
+        VALUES (?, ?, ?)
+      `,
+      [
+        getRequiredSqlBindValue(row.chunk_id),
+        serialId,
+        remapSentenceIndex(
+          remaps,
+          serialId,
+          Number(row.fragment_id),
+          Number(row.sentence_index)
+        )
+      ]
+    );
+  }
+}
+async function migrateLegacyMentions(database, remaps) {
+  const rows = await database.queryAll(
+    `
+      SELECT *
+      FROM mentions
+      ORDER BY id
+    `,
+    void 0,
+    (row) => row
+  );
+  await database.run("ALTER TABLE mentions RENAME TO legacy_mentions");
+  await database.run(`
+    CREATE TABLE mentions (
+      id TEXT PRIMARY KEY,
+      chapter_id INTEGER NOT NULL,
+      sentence_index INTEGER,
+      range_start INTEGER NOT NULL,
+      range_end INTEGER NOT NULL,
+      surface TEXT NOT NULL,
+      qid TEXT NOT NULL,
+      confidence REAL,
+      note TEXT,
+      FOREIGN KEY (chapter_id) REFERENCES serials(id)
+    )
+  `);
+  for (const row of rows) {
+    const chapterId = Number(row.chapter_id);
+    const sentenceIndex = row.sentence_index === null || row.sentence_index === void 0 ? null : remapSentenceIndex(
+      remaps,
+      chapterId,
+      Number(row.fragment_id),
+      Number(row.sentence_index)
+    );
+    await database.run(
+      `
+        INSERT OR REPLACE INTO mentions (
+          id, chapter_id, sentence_index, range_start, range_end, surface,
+          qid, confidence, note
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      [
+        getRequiredSqlBindValue(row.id),
+        chapterId,
+        sentenceIndex,
+        row.range_start ?? 0,
+        row.range_end ?? 0,
+        row.surface ?? "",
+        row.qid ?? "",
+        row.confidence ?? null,
+        row.note ?? null
+      ]
+    );
+  }
+  await database.run("DROP TABLE legacy_mentions");
+}
+async function migrateLegacyMentionLinkEvidenceSentences(database, remaps) {
+  const rows = await database.queryAll(
+    `
+      SELECT link_id, chapter_id, fragment_id, sentence_index
+      FROM mention_link_evidence_sentences
+    `,
+    void 0,
+    (row) => row
+  );
+  await database.run("DROP TABLE mention_link_evidence_sentences");
+  await database.run(`
+    CREATE TABLE mention_link_evidence_sentences (
+      link_id TEXT NOT NULL,
+      chapter_id INTEGER NOT NULL,
+      sentence_index INTEGER NOT NULL,
+      FOREIGN KEY (link_id) REFERENCES mention_links(id),
+      PRIMARY KEY (link_id, chapter_id, sentence_index)
+    )
+  `);
+  for (const row of rows) {
+    const chapterId = Number(row.chapter_id);
+    await database.run(
+      `
+        INSERT OR IGNORE INTO mention_link_evidence_sentences (
+          link_id, chapter_id, sentence_index
+        )
+        VALUES (?, ?, ?)
+      `,
+      [
+        getRequiredSqlBindValue(row.link_id),
+        chapterId,
+        remapSentenceIndex(
+          remaps,
+          chapterId,
+          Number(row.fragment_id),
+          Number(row.sentence_index)
+        )
+      ]
+    );
+  }
+}
+async function migrateLegacyFragmentGroups(database, remaps) {
+  const rows = await database.queryAll(
+    `
+      SELECT serial_id, group_id, fragment_id
+      FROM fragment_groups
+      ORDER BY serial_id, group_id, fragment_id
+    `,
+    void 0,
+    (row) => row
+  );
+  await database.run("DROP TABLE fragment_groups");
+  await database.run(`
+    CREATE TABLE sentence_groups (
+      serial_id INTEGER NOT NULL,
+      group_id INTEGER NOT NULL,
+      start_sentence_index INTEGER NOT NULL,
+      end_sentence_index INTEGER NOT NULL,
+      PRIMARY KEY (serial_id, group_id, start_sentence_index, end_sentence_index)
+    )
+  `);
+  for (const row of rows) {
+    const serialId = Number(row.serial_id);
+    const startSentenceIndex = remapSentenceIndex(
+      remaps,
+      serialId,
+      Number(row.fragment_id),
+      0
+    );
+    const endSentenceIndex = findFragmentEndSentenceIndex(
+      remaps,
+      serialId,
+      Number(row.fragment_id)
+    );
+    await database.run(
+      `
+        INSERT OR IGNORE INTO sentence_groups (
+          serial_id, group_id, start_sentence_index, end_sentence_index
+        )
+        VALUES (?, ?, ?, ?)
+      `,
+      [
+        serialId,
+        getRequiredSqlBindValue(row.group_id),
+        startSentenceIndex,
+        endSentenceIndex
+      ]
+    );
+  }
+}
+function remapSentenceIndex(remaps, serialId, fragmentId, sentenceIndex) {
+  const remap = remaps.get(serialId);
+  const mapped = remap?.get(fragmentId, sentenceIndex);
+  if (mapped === void 0) {
+    throw new Error(
+      `Cannot remap legacy sentence ${serialId}:${fragmentId}:${sentenceIndex}.`
+    );
+  }
+  return mapped;
+}
+function findFragmentEndSentenceIndex(remaps, serialId, fragmentId) {
+  let sentenceIndex = 0;
+  let last;
+  while (true) {
+    const mapped = remaps.get(serialId)?.get(fragmentId, sentenceIndex);
+    if (mapped === void 0) {
+      break;
+    }
+    last = mapped;
+    sentenceIndex += 1;
+  }
+  return last ?? remapSentenceIndex(remaps, serialId, fragmentId, 0);
+}
+async function migrateLegacySummariesToTextStreams(workspacePath) {
+  const summaries = await listLegacySummaries(workspacePath);
+  const document = await DirectoryDocument.open(workspacePath);
+  try {
+    for (const summary of summaries) {
+      await document.writeSummary(summary.serialId, summary.text);
+    }
+  } finally {
+    await document.release();
+  }
+}
+async function listLegacySourceSerials(workspacePath) {
+  const fragmentsDirectory = join(workspacePath, "fragments");
+  try {
+    const entries = await readdir(fragmentsDirectory, { withFileTypes: true });
+    const serialIds = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const match = /^serial-(\d+)$/u.exec(entry.name);
+      if (match !== null) {
+        serialIds.push(Number(match[1]));
+      }
+    }
+    return serialIds.sort((left, right) => left - right);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function readLegacySourceFragments(workspacePath, serialId) {
+  const serialDirectory = join(
+    workspacePath,
+    "fragments",
+    `serial-${serialId}`
+  );
+  const entries = await readdir(serialDirectory, { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    const match = /^fragment_(\d+)\.json$/u.exec(entry.name);
+    if (match === null) {
+      continue;
+    }
+    const path = join(serialDirectory, entry.name);
+    const content = parseLegacyFragmentFile(await readFile(path, "utf8"));
+    records.push({
+      content,
+      fragmentId: Number(match[1]),
+      path,
+      signature: createLegacyFragmentSignature(content)
+    });
+  }
+  return records.sort((left, right) => left.fragmentId - right.fragmentId);
+}
+function parseLegacyFragmentFile(content) {
+  const parsed = JSON.parse(content);
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new TypeError("Legacy fragment file must contain sentences.");
+  }
+  const rawFragment = parsed;
+  if (!Array.isArray(rawFragment.sentences)) {
+    throw new TypeError("Legacy fragment file must contain sentences.");
+  }
+  const sentences = rawFragment.sentences.map((sentence) => {
+    if (typeof sentence !== "object" || sentence === null || !("text" in sentence) || typeof sentence.text !== "string") {
+      throw new TypeError("Legacy fragment sentence must contain text.");
+    }
+    const rawSentence = sentence;
+    const text = rawSentence.text;
+    const rawWordsCount = rawSentence.wordsCount;
+    const wordsCount = typeof rawWordsCount === "number" ? rawWordsCount : countWords(text);
+    return {
+      text,
+      wordsCount
+    };
+  });
+  const summary = typeof rawFragment.summary === "string" ? rawFragment.summary : "";
+  return { sentences, summary };
+}
+function countWords(text) {
+  const trimmed = text.trim();
+  return trimmed === "" ? 0 : trimmed.split(/\s+/u).length;
+}
+function createLegacyFragmentSignature(fragment) {
+  return JSON.stringify(fragment.sentences.map((sentence) => sentence.text));
+}
+function createDuplicateHalfCanonicalizationPlan(fragments) {
+  if (fragments.length < 2 || fragments.length % 2 !== 0) {
+    return void 0;
+  }
+  const halfLength = fragments.length / 2;
+  const leftHalf = fragments.slice(0, halfLength);
+  const rightHalf = fragments.slice(halfLength);
+  for (let index = 0; index < halfLength; index += 1) {
+    if (leftHalf[index]?.signature !== rightHalf[index]?.signature) {
+      return void 0;
+    }
+  }
+  const preferRightHalf = rightHalf.some(
+    (fragment) => fragment.content.summary.trim() !== ""
+  );
+  const sourceFragments = preferRightHalf ? rightHalf : leftHalf;
+  const fragmentIdMap = /* @__PURE__ */ new Map();
+  const canonicalFragments = sourceFragments.map((fragment, index) => {
+    const leftFragment = leftHalf[index];
+    const rightFragment = rightHalf[index];
+    if (leftFragment !== void 0) {
+      fragmentIdMap.set(leftFragment.fragmentId, index);
+    }
+    if (rightFragment !== void 0) {
+      fragmentIdMap.set(rightFragment.fragmentId, index);
+    }
+    return {
+      ...fragment,
+      fragmentId: index
+    };
+  });
+  return { canonicalFragments, fragmentIdMap };
+}
+function getRequiredSqlBindValue(value) {
+  if (value === void 0) {
+    throw new TypeError("Expected a SQLite bind value.");
+  }
+  return value;
+}
+async function listLegacySummaries(workspacePath) {
+  const summaryDirectory = join(workspacePath, "summaries");
+  try {
+    const entries = await readdir(summaryDirectory, { withFileTypes: true });
+    const summaries = [];
+    for (const entry of entries) {
+      if (!entry.isFile()) {
+        continue;
+      }
+      const match = /^serial-(\d+)\.txt$/u.exec(entry.name);
+      if (match === null) {
+        continue;
+      }
+      summaries.push({
+        serialId: Number(match[1]),
+        text: await readFile(join(summaryDirectory, entry.name), "utf8")
+      });
+    }
+    return summaries.sort((left, right) => left.serialId - right.serialId);
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function listTableNames(database) {
+  const names = await database.queryAll(
+    `
+      SELECT name
+      FROM sqlite_master
+      WHERE type = 'table'
+    `,
+    void 0,
+    (row) => String(row.name)
+  );
+  return new Set(names);
+}
+async function listTableColumns(database, tableName) {
+  const columns = await database.queryAll(
+    `PRAGMA table_info(${quoteSqlIdentifier(tableName)})`,
+    void 0,
+    (row) => String(row.name)
+  );
+  return new Set(columns);
+}
+function quoteSqlIdentifier(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+async function indexArchiveEntries(zipFile) {
+  return await new Promise((resolve2, reject) => {
+    const entries = [];
+    zipFile.on("entry", (entry) => {
+      if (entry.fileName.endsWith("/")) {
+        zipFile.readEntry();
+        return;
+      }
+      entries.push(entry);
+      zipFile.readEntry();
+    });
+    zipFile.once("end", () => {
+      resolve2(entries);
+    });
+    zipFile.once("error", (error) => {
+      reject(error);
+    });
+    zipFile.readEntry();
+  });
+}
+function isLegacySdpubPath(archivePath) {
+  return LEGACY_SDPUB_PATTERNS.some((pattern) => pattern.test(archivePath));
+}
+function assertWithinDirectory(rootDirectoryPath, targetPath, archivePath) {
+  const resolvedRootDirectoryPath = resolve(rootDirectoryPath);
+  const rootPrefix = resolvedRootDirectoryPath.endsWith(sep) ? resolvedRootDirectoryPath : `${resolvedRootDirectoryPath}${sep}`;
+  if (targetPath === resolvedRootDirectoryPath || targetPath.startsWith(rootPrefix)) {
+    return;
+  }
+  throw new Error(`Invalid archive entry path: ${archivePath}`);
+}
+function normalizeArchivePath(path) {
+  const normalized = path.replaceAll("\\", "/").trim();
+  const withoutLeadingSlash = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+  return posix.normalize(withoutLeadingSlash).replace(/^(\.\/)+/u, "").replace(/^\/+/u, "");
+}
+async function openArchive(path) {
+  return await new Promise((resolveOpen, rejectOpen) => {
+    openZip(path, { autoClose: false, lazyEntries: true }, (error, zipFile) => {
+      if (error !== null || zipFile === void 0) {
+        rejectOpen(error ?? new Error(`Cannot open archive: ${path}`));
+        return;
+      }
+      resolveOpen(zipFile);
+    });
+  });
+}
+async function openArchiveEntryStream(zipFile, entry) {
+  return await new Promise((resolveStream, rejectStream) => {
+    zipFile.openReadStream(entry, (error, stream) => {
+      if (error !== null || stream === void 0) {
+        rejectStream(
+          error ?? new Error(`Cannot open archive entry: ${entry.fileName}`)
+        );
+        return;
+      }
+      resolveStream(stream);
+    });
+  });
+}
+async function readArchiveEntryText(zipFile, entry) {
+  const chunks = [];
+  const stream = await openArchiveEntryStream(zipFile, entry);
+  await new Promise((resolveRead, rejectRead) => {
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    stream.once("end", resolveRead);
+    stream.once("error", rejectRead);
+  });
+  return Buffer.concat(chunks).toString("utf8");
+}
+export {
+  migrateLegacySdpubToWikg
+};
+//# sourceMappingURL=upgrade.js.map