token-goat 2.9.13 → 2.9.15

package/dist/token-goat-chunk-3NSDDTGL.mjs

@@ -0,0 +1,34 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  XlsxScanTooLargeError,
+  allSheetsHeadText,
+  formatXlsxColumns,
+  formatXlsxRange,
+  headSheet,
+  listSheets,
+  querySheet,
+  rangeSheet,
+  xlsxColumns
+} from "./token-goat-chunk-NU7TLMQK.mjs";
+import "./token-goat-chunk-YKG35VHC.mjs";
+import "./token-goat-chunk-3BTK54F3.mjs";
+import "./token-goat-chunk-MZDIJJ3R.mjs";
+import "./token-goat-chunk-XTQAOTSO.mjs";
+import "./token-goat-chunk-AH6QILZM.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  XlsxScanTooLargeError,
+  allSheetsHeadText,
+  formatXlsxColumns,
+  formatXlsxRange,
+  headSheet,
+  listSheets,
+  querySheet,
+  rangeSheet,
+  xlsxColumns
+};

package/dist/token-goat-chunk-4EXFN2AW.mjs

@@ -0,0 +1,29 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  SQLITE_QUERY_ROW_CAP,
+  formatSqliteQueryTable,
+  formatSqliteSchema,
+  formatSqliteTables,
+  getSqliteSchema,
+  getSqliteTables,
+  isSqliteFile,
+  openReadonlySqlite,
+  runReadOnlySqliteQuery,
+  validateReadOnlySelect
+} from "./token-goat-chunk-LMFO66YD.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  SQLITE_QUERY_ROW_CAP,
+  formatSqliteQueryTable,
+  formatSqliteSchema,
+  formatSqliteTables,
+  getSqliteSchema,
+  getSqliteTables,
+  isSqliteFile,
+  openReadonlySqlite,
+  runReadOnlySqliteQuery,
+  validateReadOnlySelect
+};

package/dist/token-goat-chunk-5V7DAC7V.mjs

@@ -0,0 +1,123 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  NotAnOfficeDocumentError,
+  collectElements,
+  collectParagraphTexts,
+  collectTextRuns,
+  decodeZipEntry,
+  ooxmlPartBudget,
+  parseOoxmlPart,
+  readOoxmlZip
+} from "./token-goat-chunk-MZDIJJ3R.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-ERTXEKB6.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/docx_extract.ts
+init_define_import_meta_env();
+function paragraphStyleVal(p) {
+  return p["w:pPr"]?.["w:pStyle"]?.["@_w:val"];
+}
+function headingLevel(styleVal) {
+  if (styleVal === void 0) return null;
+  if (/^title$/i.test(styleVal)) return 1;
+  const m = /^heading\s*(\d)$/i.exec(styleVal);
+  return m?.[1] !== void 0 ? parseInt(m[1], 10) : null;
+}
+async function loadDocumentBody(filePath) {
+  const entries = await readOoxmlZip(filePath, ".docx");
+  const xml = decodeZipEntry(entries, "word/document.xml", ooxmlPartBudget());
+  if (xml === null) throw new NotAnOfficeDocumentError(`no word/document.xml found in ${filePath} (not a valid .docx?)`);
+  return parseOoxmlPart(xml);
+}
+async function docxOutline(filePath) {
+  const parsed = await loadDocumentBody(filePath);
+  const paragraphs = collectElements(parsed, "w:p");
+  const out = [];
+  for (const p of paragraphs) {
+    const level = headingLevel(paragraphStyleVal(p));
+    if (level === null) continue;
+    const text = collectTextRuns(p, "w:t").join("").trim();
+    if (text.length > 0) out.push({ level, text });
+  }
+  return out;
+}
+async function docxText(filePath) {
+  const parsed = await loadDocumentBody(filePath);
+  const paragraphs = collectElements(parsed, "w:p");
+  const lines = paragraphs.map((p) => collectTextRuns(p, "w:t").join("")).filter((t) => t.trim().length > 0);
+  return lines.join("\n\n");
+}
+async function docxTables(filePath) {
+  const parsed = await loadDocumentBody(filePath);
+  const tbls = collectElements(parsed, "w:tbl", { includeNested: true });
+  const out = [];
+  for (let i = 0; i < tbls.length; i++) {
+    const tbl = tbls[i];
+    const trElements = collectElements(tbl, "w:tr");
+    const rows = [];
+    let maxCols = 0;
+    for (const tr of trElements) {
+      const tcElements = collectElements(tr, "w:tc");
+      const rowCells = [];
+      for (const tc of tcElements) {
+        const cellText = collectParagraphTexts(tc, "w:p", "w:t", ["w:tbl"], "w:br").map((t) => t.replace(/\r?\n/g, " ").trim()).filter((t) => t.length > 0).join(" ");
+        rowCells.push(cellText);
+      }
+      if (rowCells.length > maxCols) maxCols = rowCells.length;
+      rows.push(rowCells);
+    }
+    if (rows.length > 0) {
+      out.push({
+        tableIndex: i + 1,
+        rowCount: rows.length,
+        colCount: maxCols,
+        rows
+      });
+    }
+  }
+  return out;
+}
+function formatDocxTables(tables, opts) {
+  if (tables.length === 0) return "no tables found in document";
+  const selected = opts?.tableIndex !== void 0 ? tables.filter((t) => t.tableIndex === opts.tableIndex) : tables;
+  if (selected.length === 0) {
+    return `table ${opts?.tableIndex} not found (document has ${tables.length} table${tables.length === 1 ? "" : "s"})`;
+  }
+  const sections = [];
+  for (const table of selected) {
+    const lines = [
+      `Table ${table.tableIndex} (${table.rowCount} row${table.rowCount === 1 ? "" : "s"} x ${table.colCount} col${table.colCount === 1 ? "" : "s"}):`
+    ];
+    if (table.rows.length === 0) {
+      lines.push("  (empty)");
+      sections.push(lines.join("\n"));
+      continue;
+    }
+    const header = table.rows[0];
+    const padCols = Math.max(table.colCount, 1);
+    const paddedHeader = [...header];
+    while (paddedHeader.length < padCols) paddedHeader.push("");
+    lines.push("| " + paddedHeader.map((c) => displaySafeText(c.replace(/\|/g, "\\|"))).join(" | ") + " |");
+    lines.push("| " + Array.from({ length: padCols }, () => "---").join(" | ") + " |");
+    for (let r = 1; r < table.rows.length; r++) {
+      const row = table.rows[r];
+      const paddedRow = [...row];
+      while (paddedRow.length < padCols) paddedRow.push("");
+      lines.push("| " + paddedRow.map((c) => displaySafeText(c.replace(/\|/g, "\\|"))).join(" | ") + " |");
+    }
+    sections.push(lines.join("\n"));
+  }
+  return sections.join("\n\n");
+}
+
+export {
+  docxOutline,
+  docxText,
+  docxTables,
+  formatDocxTables
+};

package/dist/token-goat-chunk-6DLVZDB6.mjs

@@ -0,0 +1,34 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildEvent,
+  relay,
+  relayInProcess
+} from "./token-goat-chunk-SZWYESBS.mjs";
+import "./token-goat-chunk-YZX7EFG4.mjs";
+import {
+  MAX_STDIN_BYTES,
+  readStdinJson
+} from "./token-goat-chunk-OUGNPMDA.mjs";
+import "./token-goat-chunk-BL5LNGBG.mjs";
+import "./token-goat-chunk-YQ7WI2CO.mjs";
+import "./token-goat-chunk-3BTK54F3.mjs";
+import "./token-goat-chunk-NDRP4KJQ.mjs";
+import "./token-goat-chunk-2X2EBBC6.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-IVUQLQWN.mjs";
+import "./token-goat-chunk-K7F2BFIK.mjs";
+import "./token-goat-chunk-S4XRY446.mjs";
+import "./token-goat-chunk-EEIDFMEM.mjs";
+import "./token-goat-chunk-OSUFN2FV.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  MAX_STDIN_BYTES,
+  buildEvent,
+  readStdinJson,
+  relay,
+  relayInProcess
+};

package/dist/token-goat-chunk-7ZYK25AO.mjs

@@ -0,0 +1,24 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  pptxAllSlidesText,
+  pptxNotesText,
+  pptxOutline,
+  pptxSlideText,
+  pptxTextGrep
+} from "./token-goat-chunk-ASYEPR3S.mjs";
+import "./token-goat-chunk-MZDIJJ3R.mjs";
+import "./token-goat-chunk-XTQAOTSO.mjs";
+import "./token-goat-chunk-AH6QILZM.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-PM76YS22.mjs";
+import "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  pptxAllSlidesText,
+  pptxNotesText,
+  pptxOutline,
+  pptxSlideText,
+  pptxTextGrep
+};

package/dist/token-goat-chunk-A4JYKD5H.mjs

@@ -0,0 +1,144 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  loadConfig
+} from "./token-goat-chunk-S4XRY446.mjs";
+import "./token-goat-chunk-EEIDFMEM.mjs";
+import {
+  VERSION
+} from "./token-goat-chunk-PM76YS22.mjs";
+import {
+  displaySafeJson
+} from "./token-goat-chunk-ERTXEKB6.mjs";
+import "./token-goat-chunk-GMOUBOX4.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/cli_upgrade.ts
+init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as https from "node:https";
+async function fetchLatestVersion(timeoutMs = 3500) {
+  if (loadConfig().network.offline) {
+    return null;
+  }
+  return new Promise((resolve) => {
+    const req = https.get(
+      "https://registry.npmjs.org/token-goat/latest",
+      {
+        headers: { "User-Agent": `token-goat/${VERSION} (node/${process.version})` },
+        timeout: timeoutMs
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          resolve(null);
+          return;
+        }
+        let data = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          data += chunk;
+          if (data.length > 32768) {
+            req.destroy();
+            resolve(null);
+          }
+        });
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(data);
+            resolve(typeof parsed.version === "string" ? parsed.version : null);
+          } catch {
+            resolve(null);
+          }
+        });
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+    req.on("error", () => {
+      resolve(null);
+    });
+  });
+}
+function compareSemver(a, b) {
+  const pa = a.split("-")[0].split(".").map((x) => parseInt(x, 10) || 0);
+  const pb = b.split("-")[0].split(".").map((x) => parseInt(x, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const na = pa[i] ?? 0;
+    const nb = pb[i] ?? 0;
+    if (na > nb) return 1;
+    if (na < nb) return -1;
+  }
+  return 0;
+}
+async function checkUpdateStatus(timeoutMs = 3500) {
+  const latest = await fetchLatestVersion(timeoutMs);
+  if (!latest) {
+    return {
+      current: VERSION,
+      latest: null,
+      updateAvailable: false,
+      error: "Could not reach npm registry (offline or request timed out)"
+    };
+  }
+  const updateAvailable = compareSemver(latest, VERSION) > 0;
+  return {
+    current: VERSION,
+    latest,
+    updateAvailable
+  };
+}
+async function cmdUpgrade(opts = {}, onSyncHooks) {
+  const status = await checkUpdateStatus();
+  if (opts.check) {
+    if (opts.json) {
+      console.log(displaySafeJson(status, 2));
+      return;
+    }
+    if (status.error) {
+      console.log(`Current version: v${status.current}`);
+      console.log(`[!] ${status.error}`);
+      return;
+    }
+    if (status.updateAvailable && status.latest) {
+      console.log(`Update available: v${status.current} -> v${status.latest}`);
+      console.log(`Run 'token-goat upgrade' to update.`);
+    } else {
+      console.log(`token-goat is up to date (v${status.current})`);
+    }
+    return;
+  }
+  const isLocalGitRepo = fs.existsSync(path.join(process.cwd(), ".git")) && fs.existsSync(path.join(process.cwd(), "esbuild.config.mjs"));
+  if (isLocalGitRepo) {
+    console.log(`Detected local token-goat development repository.`);
+    console.log(`To update your local build, run:`);
+    console.log(`  git pull && npm run build && token-goat install`);
+    return;
+  }
+  console.log(`Upgrading token-goat to latest...`);
+  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  const npmRes = spawnSync(npmCmd, ["install", "-g", "token-goat@latest"], {
+    stdio: "inherit"
+  });
+  if (npmRes.status !== 0) {
+    console.error(`npm install failed with exit code ${npmRes.status ?? 1}.`);
+    process.exit(npmRes.status ?? 1);
+  }
+  console.log(`Syncing token-goat hooks and integration manifests...`);
+  if (onSyncHooks) {
+    await onSyncHooks();
+  }
+  console.log(`[\u2713] token-goat successfully updated.`);
+}
+export {
+  checkUpdateStatus,
+  cmdUpgrade,
+  compareSemver,
+  fetchLatestVersion
+};

package/dist/token-goat-chunk-AH6QILZM.mjs

@@ -0,0 +1,26 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/lazy_module.ts
+init_define_import_meta_env();
+function createLazyModuleLoader(load, errorLabel) {
+  let cache;
+  return async () => {
+    if (cache !== void 0) return cache;
+    try {
+      cache = await load();
+    } catch (err) {
+      process.stderr.write(`token-goat: ${errorLabel}: ${String(err)}
+`);
+      cache = null;
+    }
+    return cache;
+  };
+}
+
+export {
+  createLazyModuleLoader
+};

package/dist/token-goat-chunk-ASYEPR3S.mjs

@@ -0,0 +1,212 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  NotAnOfficeDocumentError,
+  assertOoxmlWithinDeadline,
+  collectElements,
+  collectParagraphTexts,
+  decodeZipEntry,
+  ooxmlPartBudget,
+  ooxmlWorkDeadline,
+  parseOoxmlPart,
+  readOoxmlZip,
+  sortNumberedParts
+} from "./token-goat-chunk-MZDIJJ3R.mjs";
+import {
+  compileGuardedRegex
+} from "./token-goat-chunk-GMOUBOX4.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/pptx_extract.ts
+init_define_import_meta_env();
+function shapePlaceholderType(shape) {
+  const sp = shape;
+  return sp["p:nvSpPr"]?.["p:nvPr"]?.["p:ph"]?.["@_type"];
+}
+function slideShapes(parsedSlide) {
+  return collectElements(parsedSlide, "p:sp");
+}
+function flatSlideText(node) {
+  return collectParagraphTexts(node, "a:p", "a:t", [], "a:br").map((t) => t.trim()).filter((t) => t.length > 0).join(" ");
+}
+function shapeText(shape) {
+  return flatSlideText(shape);
+}
+function tableRowBlocks(parsedSlide) {
+  const blocks = [];
+  for (const tbl of collectElements(parsedSlide, "a:tbl")) {
+    for (const row of collectElements(tbl, "a:tr")) {
+      const cellTexts = collectElements(row, "a:tc").map((cell) => flatSlideText(cell));
+      const rowText = cellTexts.join(" | ").trim();
+      if (rowText.length > 0) blocks.push(rowText);
+    }
+  }
+  return blocks;
+}
+async function slidePathsInPresentationOrder(entries, budget) {
+  const presXml = decodeZipEntry(entries, "ppt/presentation.xml", budget);
+  const relsXml = decodeZipEntry(entries, "ppt/_rels/presentation.xml.rels", budget);
+  if (presXml === null || relsXml === null) return null;
+  const presParsed = await parseOoxmlPart(presXml);
+  const relsParsed = await parseOoxmlPart(relsXml);
+  const ridToTarget = /* @__PURE__ */ new Map();
+  for (const rel of collectElements(relsParsed, "Relationship")) {
+    if (rel["@_Id"] !== void 0 && rel["@_Target"] !== void 0) {
+      ridToTarget.set(rel["@_Id"], rel["@_Target"]);
+    }
+  }
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const sldId of collectElements(presParsed, "p:sldId")) {
+    const rid = sldId["@_r:id"];
+    if (rid === void 0) continue;
+    const target = ridToTarget.get(rid);
+    if (target === void 0) continue;
+    const normalized = target.startsWith("slides/") ? `ppt/${target}` : `ppt/slides/${target}`;
+    if (entries[normalized] === void 0 || seen.has(normalized)) continue;
+    seen.add(normalized);
+    ordered.push(normalized);
+  }
+  return ordered.length > 0 ? ordered : null;
+}
+async function listSlideParts(filePath) {
+  const entries = await readOoxmlZip(filePath, ".pptx");
+  const budget = ooxmlPartBudget();
+  const slidePaths = await slidePathsInPresentationOrder(entries, budget) ?? sortNumberedParts(
+    Object.keys(entries).filter((p) => /^ppt\/slides\/slide\d+\.xml$/.test(p)),
+    /slide(\d+)\.xml$/
+  );
+  if (slidePaths.length === 0) throw new NotAnOfficeDocumentError(`no slides found in ${filePath} (not a valid .pptx?)`);
+  return { entries, slidePaths, budget };
+}
+function relsPathFor(slidePath) {
+  const idx = slidePath.lastIndexOf("/");
+  return `${slidePath.slice(0, idx)}/_rels/${slidePath.slice(idx + 1)}.rels`;
+}
+function resolveRelativeTarget(basePath, target) {
+  const baseDir = basePath.slice(0, basePath.lastIndexOf("/"));
+  const segments = `${baseDir}/${target}`.split("/");
+  const resolved = [];
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") resolved.pop();
+    else resolved.push(segment);
+  }
+  return resolved.join("/");
+}
+async function notesPathFor(entries, slidePath, budget) {
+  const relsXml = decodeZipEntry(entries, relsPathFor(slidePath), budget);
+  if (relsXml === null) return null;
+  const relsParsed = await parseOoxmlPart(relsXml);
+  for (const rel of collectElements(relsParsed, "Relationship")) {
+    if (rel["@_Target"] !== void 0 && rel["@_Type"]?.endsWith("/notesSlide") === true) {
+      return resolveRelativeTarget(slidePath, rel["@_Target"]);
+    }
+  }
+  return null;
+}
+async function parseSlide(entries, path, budget) {
+  const xml = decodeZipEntry(entries, path, budget);
+  if (xml === null) throw new Error(`missing part: ${path}`);
+  return parseOoxmlPart(xml);
+}
+async function notesTextFor(entries, notesPath, budget) {
+  if (notesPath === null) return "";
+  const xml = decodeZipEntry(entries, notesPath, budget);
+  if (xml === null) return "";
+  const parsed = await parseOoxmlPart(xml);
+  const shapes = collectElements(parsed, "p:sp");
+  const bodyShape = shapes.find((s) => shapePlaceholderType(s) === "body");
+  return bodyShape !== void 0 ? shapeText(bodyShape) : flatSlideText(parsed);
+}
+async function pptxOutline(filePath, deadline = ooxmlWorkDeadline()) {
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
+  const out = [];
+  for (let i = 0; i < slidePaths.length; i++) {
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to specific slides with pptx-slide, or use a smaller deck.");
+    const path = slidePaths[i];
+    const parsed = await parseSlide(entries, path, budget);
+    const shapes = slideShapes(parsed);
+    const titleShape = shapes.find((s) => {
+      const t = shapePlaceholderType(s);
+      return t === "title" || t === "ctrTitle";
+    });
+    const title = titleShape !== void 0 ? shapeText(titleShape) : "";
+    const allText = flatSlideText(parsed);
+    const bodyChars = Math.max(0, allText.length - title.length);
+    const hasNotes = (await notesTextFor(entries, await notesPathFor(entries, path, budget), budget)).length > 0;
+    out.push({ slide: i + 1, title, bodyChars, hasNotes });
+  }
+  return out;
+}
+async function slideTextFromParts(entries, slidePaths, slideNumber, includeNotes, budget) {
+  if (slideNumber < 1 || slideNumber > slidePaths.length) {
+    throw new Error(`slide ${slideNumber} out of range (this deck has ${slidePaths.length} slides)`);
+  }
+  const path = slidePaths[slideNumber - 1];
+  const parsed = await parseSlide(entries, path, budget);
+  const shapes = slideShapes(parsed);
+  const blocks = [...shapes.map(shapeText).filter((t) => t.length > 0), ...tableRowBlocks(parsed)];
+  const lines = [`# Slide ${slideNumber}`, ...blocks];
+  if (includeNotes) {
+    const notes = await notesTextFor(entries, await notesPathFor(entries, path, budget), budget);
+    if (notes.length > 0) lines.push("", "## Speaker notes", notes);
+  }
+  return lines.join("\n\n");
+}
+async function pptxSlideText(filePath, slideNumber, includeNotes) {
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
+  return slideTextFromParts(entries, slidePaths, slideNumber, includeNotes, budget);
+}
+async function pptxAllSlidesText(filePath, includeNotes, deadline = ooxmlWorkDeadline()) {
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
+  const slideTexts = [];
+  for (let i = 1; i <= slidePaths.length; i++) {
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to specific slides with pptx-slide, or use a smaller deck.");
+    slideTexts.push(await slideTextFromParts(entries, slidePaths, i, includeNotes, budget));
+  }
+  return slideTexts.join("\n\n");
+}
+async function pptxNotesText(filePath, slideNumber, deadline = ooxmlWorkDeadline()) {
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
+  const targets = slideNumber !== void 0 ? [slideNumber] : slidePaths.map((_, i) => i + 1);
+  const sections = [];
+  for (const n of targets) {
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to one slide with the slide-number argument, or use a smaller deck.");
+    if (n < 1 || n > slidePaths.length) throw new Error(`slide ${n} out of range (this deck has ${slidePaths.length} slides)`);
+    const notesPath = await notesPathFor(entries, slidePaths[n - 1], budget);
+    const text = await notesTextFor(entries, notesPath, budget);
+    if (text.length > 0) sections.push(`# Slide ${n} notes
+
+${text}`);
+  }
+  return sections.join("\n\n");
+}
+async function pptxTextGrep(filePath, pattern, deadline = ooxmlWorkDeadline()) {
+  const { entries, slidePaths, budget } = await listSlideParts(filePath);
+  const guarded = compileGuardedRegex(pattern, "i");
+  if (!guarded.ok) throw new Error(`invalid --grep pattern: ${pattern} -- the pattern ${guarded.reason}`);
+  const re = guarded.re;
+  const out = [];
+  for (let i = 0; i < slidePaths.length; i++) {
+    assertOoxmlWithinDeadline(deadline, "Narrow the read to specific slides with pptx-slide, or use a smaller deck.");
+    const parsed = await parseSlide(entries, slidePaths[i], budget);
+    const text = flatSlideText(parsed);
+    if (re.test(text)) {
+      const idx = text.search(re);
+      const snippet = text.slice(Math.max(0, idx - 40), idx + 80).trim();
+      out.push({ slide: i + 1, snippet });
+    }
+  }
+  return out;
+}
+
+export {
+  pptxOutline,
+  pptxSlideText,
+  pptxAllSlidesText,
+  pptxNotesText,
+  pptxTextGrep
+};