codetrellis 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codetrellis",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CodeTrellis for agents and CI: run it headless, keep agents on track, check changes against your rules, and download the desktop app.",
   "keywords": [
     "codetrellis",
@@ -33,9 +33,7 @@
     "express": "^5.0.0",
     "fast-json-patch": "^3.1.1",
     "ignore": "^7.0.5",
-    "mammoth": "^1.12.3",
     "node-pty": "^1.2.0-beta.13",
-    "pdfjs-dist": "^6.3.289",
     "web-tree-sitter": "^0.27.0",
     "werift": "^0.24.4",
     "ws": "^8.18.0",

package/src/backend/services/cli-install.js

@@ -0,0 +1,249 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_install_exports = {};
+__export(cli_install_exports, {
+  LAUNCHER_MARK: () => LAUNCHER_MARK,
+  appImageLauncher: () => appImageLauncher,
+  applyCliInstall: () => applyCliInstall,
+  planCliInstall: () => planCliInstall,
+  refreshCliInstall: () => refreshCliInstall,
+  removeCliInstall: () => removeCliInstall,
+  thisCliMachine: () => thisCliMachine
+});
+module.exports = __toCommonJS(cli_install_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_command = require("../mcp/connector/command");
+const LAUNCHER_MARK = "Written by the CodeTrellis app";
+const join = (m, ...p) => m.platform === "win32" ? import_node_path.default.win32.join(...p) : import_node_path.default.posix.join(...p);
+function onPathOf(m, dir) {
+  const list = (m.env.PATH ?? "").split(m.platform === "win32" ? ";" : ":").map((d) => d.replace(/[\\/]+$/, ""));
+  return list.some((d) => m.platform === "win32" ? d.toLowerCase() === dir.toLowerCase() : d === dir);
+}
+function appImageLauncher(appImage) {
+  const q = `'${appImage.replace(/'/g, `'\\''`)}'`;
+  return [
+    "#!/bin/sh",
+    `# codetrellis: ${LAUNCHER_MARK} for the AppImage below; it rewrites this`,
+    "# file if the AppImage moves. Runs the CLI the app carries, in Node mode.",
+    // --no-sandbox last, after --: the AppImage's AppRun adds it as the first
+    // argument unless it is already there, and in Node mode that is a "bad
+    // option". As the connector's AppImage command does; app.cjs drops it.
+    `ELECTRON_RUN_AS_NODE=1 exec ${q} -e "require(require('path').join(process.resourcesPath, 'cli', 'bin', 'app.cjs'))" -- "$@" --no-sandbox`,
+    ""
+  ].join("\n");
+}
+function readLink(p) {
+  try {
+    return import_node_fs.default.readlinkSync(p);
+  } catch {
+    return null;
+  }
+}
+function readText(p) {
+  try {
+    return import_node_fs.default.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+function present(p) {
+  try {
+    import_node_fs.default.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function oursAt(p) {
+  const link = readLink(p);
+  if (link) return /[\\/]cli[\\/]bin[\\/]codetrellis$/.test(link);
+  return (readText(p) ?? "").includes(LAUNCHER_MARK);
+}
+function planCliInstall(m) {
+  if (!(0, import_command.isPackagedElectron)({ execPath: m.execPath, electronVersion: m.electronVersion }) || !m.resourcesPath) {
+    return { ok: false, reason: "Only the installed app can add the codetrellis command. From a checkout, run npm link; anywhere, npm install -g codetrellis." };
+  }
+  if (m.platform === "win32" && m.env.PORTABLE_EXECUTABLE_FILE) {
+    return { ok: false, reason: "The portable build unpacks to a temporary folder each time it starts, so a command on the PATH would stop working. Use the installer, or npm install -g codetrellis." };
+  }
+  const binDir = join(m, m.resourcesPath, "cli", "bin");
+  if (m.platform === "win32") {
+    const userPath = m.windowsUserPath?.() ?? "";
+    const has = userPath.split(";").some((d) => d.replace(/[\\/]+$/, "").toLowerCase() === binDir.toLowerCase());
+    return {
+      ok: true,
+      how: "path",
+      target: binDir,
+      source: join(m, binDir, "codetrellis.cmd"),
+      admin: false,
+      state: has ? "installed" : "missing",
+      onPath: onPathOf(m, binDir),
+      says: `Adds ${binDir} to your PATH. Open a new terminal afterwards.`
+    };
+  }
+  const localBin = import_node_path.default.posix.join(m.home, ".local", "bin");
+  const appImage = m.platform === "linux" && m.env.APPIMAGE && m.env.APPDIR && import_node_path.default.isAbsolute(m.env.APPIMAGE) && m.resourcesPath.startsWith(m.env.APPDIR) ? m.env.APPIMAGE : null;
+  const source = appImage ?? import_node_path.default.posix.join(binDir, "codetrellis");
+  const how = appImage ? "launcher" : "link";
+  const target = m.platform === "darwin" ? import_node_path.default.posix.join(m.macBin ?? "/usr/local/bin", "codetrellis") : import_node_path.default.posix.join(localBin, "codetrellis");
+  const dir = import_node_path.default.posix.dirname(target);
+  const admin = m.platform === "darwin" && !writable(dir);
+  let state = "missing";
+  let existing;
+  if (present(target)) {
+    const link = readLink(target);
+    if (how === "link" && link === source) state = "installed";
+    else if (how === "launcher" && readText(target) === appImageLauncher(appImage)) state = "installed";
+    else if (oursAt(target)) state = "stale";
+    else {
+      state = "other";
+      existing = link ? `a link to ${link}` : "a file CodeTrellis did not write";
+    }
+  }
+  const says = how === "launcher" ? `Writes ${target}, which runs this AppImage as the codetrellis command.` : `Links ${target} to the codetrellis command inside the app${admin ? ". macOS asks for your password to write there" : ""}.`;
+  return { ok: true, how, target, source, admin, state, existing, onPath: onPathOf(m, dir), says };
+}
+function writable(dir) {
+  try {
+    import_node_fs.default.accessSync(dir, import_node_fs.default.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+const appleString = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+const runProgram = (command, args, env) => new Promise((resolve, reject) => {
+  (0, import_node_child_process.execFile)(command, args, { env: env ? { ...process.env, ...env } : process.env }, (err) => err ? reject(err) : resolve());
+});
+async function applyCliInstall(m, opts = {}, run = runProgram) {
+  const plan = planCliInstall(m);
+  if (!plan.ok) return plan;
+  if (plan.state === "installed") return { ok: true, target: plan.target, onPath: plan.onPath };
+  if (plan.state === "other" && !opts.replace) {
+    return { ok: false, reason: `${plan.target} is already ${plan.existing}. Choose Replace to put the app's command there instead.` };
+  }
+  try {
+    if (plan.how === "path") {
+      await run(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "$p=[Environment]::GetEnvironmentVariable('Path','User'); if (-not $p) { $p='' }; $parts=@($p -split ';' | Where-Object { $_ -and ($_.TrimEnd('\\') -ne $env:CT_DIR.TrimEnd('\\')) }); [Environment]::SetEnvironmentVariable('Path', (($parts + $env:CT_DIR) -join ';'), 'User')"
+        ],
+        { CT_DIR: plan.target }
+      );
+    } else if (plan.how === "launcher") {
+      import_node_fs.default.mkdirSync(import_node_path.default.posix.dirname(plan.target), { recursive: true });
+      if (present(plan.target)) import_node_fs.default.rmSync(plan.target, { force: true });
+      import_node_fs.default.writeFileSync(plan.target, appImageLauncher(plan.source), { mode: 493 });
+    } else if (plan.admin) {
+      const dir = import_node_path.default.posix.dirname(plan.target);
+      const script = `do shell script "mkdir -p " & quoted form of ${appleString(dir)} & " && ln -sf " & quoted form of ${appleString(plan.source)} & " " & quoted form of ${appleString(plan.target)} with administrator privileges`;
+      await run("osascript", ["-e", script]);
+    } else {
+      import_node_fs.default.mkdirSync(import_node_path.default.posix.dirname(plan.target), { recursive: true });
+      if (present(plan.target)) import_node_fs.default.rmSync(plan.target, { force: true });
+      import_node_fs.default.symlinkSync(plan.source, plan.target);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: /User canceled|-128/.test(msg) ? "Cancelled: macOS did not get the password." : `Could not add the command: ${msg}` };
+  }
+  const after = planCliInstall(m);
+  if (!after.ok || after.state !== "installed") return { ok: false, reason: `The command was not added at ${plan.target}.` };
+  return { ok: true, target: after.target, onPath: after.onPath };
+}
+async function refreshCliInstall(m) {
+  const plan = planCliInstall(m);
+  if (!plan.ok || plan.state !== "stale" || plan.admin || plan.how === "path") return false;
+  return (await applyCliInstall(m)).ok;
+}
+async function removeCliInstall(m, run = runProgram) {
+  const plan = planCliInstall(m);
+  if (!plan.ok) return plan;
+  if (plan.state === "missing") return { ok: true, target: plan.target, onPath: plan.onPath };
+  if (plan.state === "other") return { ok: false, reason: `${plan.target} is not CodeTrellis's; it was left as it is.` };
+  try {
+    if (plan.how === "path") {
+      await run(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "$p=[Environment]::GetEnvironmentVariable('Path','User'); if (-not $p) { $p='' }; [Environment]::SetEnvironmentVariable('Path', ((@($p -split ';' | Where-Object { $_ -and ($_.TrimEnd('\\') -ne $env:CT_DIR.TrimEnd('\\')) })) -join ';'), 'User')"
+        ],
+        { CT_DIR: plan.target }
+      );
+    } else if (plan.admin) {
+      await run("osascript", ["-e", `do shell script "rm -f " & quoted form of ${appleString(plan.target)} with administrator privileges`]);
+    } else {
+      import_node_fs.default.rmSync(plan.target, { force: true });
+    }
+  } catch (err) {
+    return { ok: false, reason: `Could not remove the command: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  return { ok: true, target: plan.target, onPath: plan.onPath };
+}
+function thisCliMachine() {
+  return {
+    platform: process.platform,
+    home: process.env.HOME || process.env.USERPROFILE || "",
+    execPath: process.execPath,
+    resourcesPath: process.resourcesPath,
+    electronVersion: process.versions.electron,
+    env: {
+      APPIMAGE: process.env.APPIMAGE,
+      APPDIR: process.env.APPDIR,
+      PORTABLE_EXECUTABLE_FILE: process.env.PORTABLE_EXECUTABLE_FILE,
+      PATH: process.env.PATH
+    },
+    windowsUserPath: () => {
+      try {
+        const out = (0, import_node_child_process.execFileSync)("reg", ["query", "HKCU\\Environment", "/v", "Path"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        return /Path\s+REG_(?:EXPAND_)?SZ\s+(.*)/i.exec(out)?.[1]?.trim() ?? null;
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAUNCHER_MARK,
+  appImageLauncher,
+  applyCliInstall,
+  planCliInstall,
+  refreshCliInstall,
+  removeCliInstall,
+  thisCliMachine
+});

package/src/backend/services/rule-approvals.js

@@ -156,6 +156,13 @@ function signRuleChange(projectRoot, change, device, now = Date.now()) {
   (0, import_confined_fs.writeFileWithin)(projectRoot, rel, approvalYaml(statement, signature), "rule approval");
   return { file: rel, how: signature.how, as: statement.signer };
 }
+function canonicalFolderOf(file) {
+  try {
+    return import_node_path.default.join(import_node_fs.default.realpathSync(import_node_path.default.dirname(file)), import_node_path.default.basename(file));
+  } catch {
+    return file;
+  }
+}
 function keysAt(projectRoot, commit) {
   const devices = /* @__PURE__ */ new Map();
   const listing = git(projectRoot, ["ls-tree", "--name-only", commit, `./${import_trust.KEYS_DIR}/`]);
@@ -173,7 +180,7 @@ function keysAt(projectRoot, commit) {
   const configured = (0, import_signed_approvals.signingSetup)(projectRoot).allowedSigners;
   if (configured) {
     const top = git(projectRoot, ["rev-parse", "--show-toplevel"])?.trim();
-    const inRepo = top ? import_node_path.default.relative(import_node_fs.default.realpathSync(top), import_node_path.default.resolve(configured)) : null;
+    const inRepo = top ? import_node_path.default.relative(import_node_fs.default.realpathSync(top), canonicalFolderOf(import_node_path.default.resolve(configured))) : null;
     if (inRepo !== null && !inRepo.startsWith("..") && !import_node_path.default.isAbsolute(inRepo)) {
       const text = git(top, ["show", `${commit}:${inRepo.split(import_node_path.default.sep).join("/")}`]);
       if (text !== null) {

package/src/cli/args.js

@@ -32,7 +32,8 @@ __export(args_exports, {
   flag: () => flag,
   headlessCacheRoot: () => headlessCacheRoot,
   headlessDataDir: () => headlessDataDir,
-  parseArgs: () => parseArgs
+  parseArgs: () => parseArgs,
+  selfCommand: () => selfCommand
 });
 module.exports = __toCommonJS(args_exports);
 var import_node_path = __toESM(require("node:path"));
@@ -86,13 +87,19 @@ function headlessCacheRoot(env, home, platform = process.platform) {
   return import_node_path.default.join(cache, "codetrellis");
 }
 const quote = (s) => /^[A-Za-z0-9_./:=@-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
-function connectorLine(nodePath, binPath, dataDir) {
-  const args = [binPath, "mcp", "--data-dir", dataDir];
+function selfCommand(binDir, proc) {
+  if (proc.electron) return { command: proc.execPath, args: [import_node_path.default.join(binDir, "app.cjs")], env: { ELECTRON_RUN_AS_NODE: "1" } };
+  return { command: proc.execPath, args: [import_node_path.default.join(binDir, "codetrellis.mjs")], env: {} };
+}
+function connectorLine(self, dataDir) {
+  const args = [...self.args, "mcp", "--data-dir", dataDir];
+  const env = Object.keys(self.env).length ? self.env : void 0;
+  const envFlags = Object.entries(self.env).map(([k, v]) => `-e ${quote(`${k}=${v}`)} `).join("");
   return {
-    command: nodePath,
+    command: self.command,
     args,
-    claude: `claude mcp add codetrellis -- ${[nodePath, ...args].map(quote).join(" ")}`,
-    json: JSON.stringify({ mcpServers: { codetrellis: { command: nodePath, args } } })
+    claude: `claude mcp add codetrellis ${envFlags}-- ${[self.command, ...args].map(quote).join(" ")}`,
+    json: JSON.stringify({ mcpServers: { codetrellis: { command: self.command, args, ...env ? { env } : {} } } })
   };
 }
 const USAGE = `codetrellis \u2014 CodeTrellis for agents, without the desktop app
@@ -197,5 +204,6 @@ Changing and committing the plan:
   flag,
   headlessCacheRoot,
   headlessDataDir,
-  parseArgs
+  parseArgs,
+  selfCommand
 });

package/src/cli/main.js

@@ -111,7 +111,7 @@ async function serve(p) {
   const project = projectOf(p);
   const dataDir = import_node_path.default.resolve((0, import_args.flag)(p, "data-dir") ?? (0, import_args.headlessDataDir)(project, process.env, import_node_os.default.homedir()));
   const { base, scan, mcp: mcp2 } = await boot(p, project, dataDir);
-  const line = (0, import_args.connectorLine)(process.execPath, binPath(), dataDir);
+  const line = (0, import_args.connectorLine)(self(), dataDir);
   const c = counts(scan);
   markReady(dataDir, project);
   if (p.flags.json) {
@@ -179,7 +179,7 @@ async function runningIn(dataDir) {
 async function start(p) {
   const project = projectOf(p);
   const dataDir = import_node_path.default.resolve((0, import_args.flag)(p, "data-dir") ?? (0, import_args.headlessDataDir)(project, process.env, import_node_os.default.homedir()));
-  const line = (0, import_args.connectorLine)(process.execPath, binPath(), dataDir);
+  const line = (0, import_args.connectorLine)(self(), dataDir);
   const say = (state, pid) => {
     if (p.flags.quiet) return;
     if (p.flags.json) out(JSON.stringify({ state, pid, project, dataDir, connector: { command: line.command, args: line.args } }));
@@ -191,13 +191,14 @@ Connect an agent with:
   if (up) return say("running", up.pid);
   import_node_fs.default.mkdirSync(dataDir, { recursive: true });
   const log = import_node_fs.default.openSync(import_node_path.default.join(dataDir, "serve.log"), "a");
-  const args = [binPath(), "serve", "--project", project, "--data-dir", dataDir];
+  const me = self();
+  const args = [...me.args, "serve", "--project", project, "--data-dir", dataDir];
   for (const k of ["port", "mcp-port"]) {
     const v = portOf(p, k);
     if (v !== void 0) args.push(`--${k}`, v);
   }
   if (p.flags["share-task-state"]) args.push("--share-task-state");
-  const child = (0, import_node_child_process.spawn)(process.execPath, args, { detached: true, stdio: ["ignore", log, log], cwd: project, env: process.env });
+  const child = (0, import_node_child_process.spawn)(me.command, args, { detached: true, stdio: ["ignore", log, log], cwd: project, env: { ...process.env, ...me.env } });
   child.unref();
   import_node_fs.default.closeSync(log);
   let exited = null;
@@ -292,7 +293,8 @@ async function reviewCmd(p) {
     throw err;
   }
   try {
-    const sinkFor = (dir) => ({ command: process.execPath, args: [binPath(), "review-sink", "--pass", dir] });
+    const me = self();
+    const sinkFor = (dir) => ({ command: me.command, args: [...me.args, "review-sink", "--pass", dir], env: me.env });
     const post = opts.post ? await reviewPoster(opts.post, cwd) : void 0;
     const { out: text, code, note } = await review(agent, opts, cwd, process.env, sinkFor, { post, version: import_package.version });
     out(text);
@@ -371,8 +373,8 @@ async function desktopCmd(p) {
   if (error instanceof DesktopUsageError) fail(error.message);
   if (error) fail(error instanceof Error ? error.message : String(error), 1);
 }
-function binPath() {
-  return import_node_path.default.resolve(__dirname, "..", "..", "bin", "codetrellis.mjs");
+function self() {
+  return (0, import_args.selfCommand)(import_node_path.default.resolve(__dirname, "..", "..", "bin"), { execPath: process.execPath, electron: process.versions.electron });
 }
 async function main() {
   const p = (0, import_args.parseArgs)(process.argv.slice(2));

package/src/cli/review-adapters.js

@@ -63,7 +63,8 @@ const claudeCode = {
   command({ instructions, message, sink, model, maxTurns, dir, auth, tools }) {
     const withKey = auth.kind === "oidc" || auth.kind === "key" && !oauthToken(auth);
     const mcp = import_node_path.default.join(dir, "mcp.json");
-    import_node_fs.default.writeFileSync(mcp, JSON.stringify({ mcpServers: { [SINK]: { type: "stdio", command: sink.command, args: sink.args } } }));
+    const env = sink.env && Object.keys(sink.env).length ? { env: sink.env } : {};
+    import_node_fs.default.writeFileSync(mcp, JSON.stringify({ mcpServers: { [SINK]: { type: "stdio", command: sink.command, args: sink.args, ...env } } }));
     const system = import_node_path.default.join(dir, "system.md");
     import_node_fs.default.writeFileSync(system, instructions);
     return {
@@ -159,6 +160,7 @@ const codex = {
         ...set("project_doc_max_bytes", "0"),
         ...set(`${server}.command`, toml(sink.command)),
         ...set(`${server}.args`, `[${sink.args.map(toml).join(", ")}]`),
+        ...sink.env && Object.keys(sink.env).length ? set(`${server}.env`, `{ ${Object.entries(sink.env).map(([k, v]) => `${k} = ${toml(v)}`).join(", ")} }`) : [],
         ...set(`${server}.enabled_tools`, `[${tools.map(toml).join(", ")}]`),
         ...set(`${server}.default_tools_approval_mode`, toml("approve")),
         ...set("model_providers.codetrellis_review.name", toml("codetrellis review")),

package/src/cli/verbs.js

@@ -292,7 +292,8 @@ async function pipelined(ctx, root, changed) {
       if (err instanceof ReviewUsageError) throw new UsageError(err.message);
       throw err;
     }
-    const sinkFor = (dir) => ({ command: process.execPath, args: [import_node_path.default.resolve(__dirname, "..", "..", "bin", "codetrellis.mjs"), "review-sink", "--pass", dir] });
+    const me = (0, import_args.selfCommand)(import_node_path.default.resolve(__dirname, "..", "..", "bin"), { execPath: process.execPath, electron: process.versions.electron });
+    const sinkFor = (dir) => ({ command: me.command, args: [...me.args, "review-sink", "--pass", dir], env: me.env });
     review = async (stage, scope, grounding) => {
       const r = await runReview(ctx.agent, { ...o, scope: { suite: scope.suite, rule: scope.rule, path: scope.path, engine: scope.engine, strength: scope.strength, tag: scope.tag }, stage: stage.id, grounding, format: "json", failOn: /* @__PURE__ */ new Set(["block"]), post: null }, ctx.cwd, process.env, sinkFor, { version: import_package.version });
       let j;

package/src/backend/services/material-reader/child.js

@@ -1,4 +0,0 @@
-var import_read = require("./read");
-process.once("message", (req) => {
-  (0, import_read.readMaterialBytes)(req).catch((err) => ({ ok: false, reason: `The file could not be read (${err.message})` })).then((reply) => process.send?.(reply, () => process.disconnect()));
-});

package/src/backend/services/material-reader/read.js

@@ -1,430 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var read_exports = {};
-__export(read_exports, {
-  MAX_OUTPUT_CHARS: () => MAX_OUTPUT_CHARS,
-  readMaterialBytes: () => readMaterialBytes
-});
-module.exports = __toCommonJS(read_exports);
-var import_mammoth = __toESM(require("mammoth"));
-var import_zip_reader = require("../../../shared/lib/zip-reader");
-var import_xlsx_xml = require("../../../shared/lib/xlsx-xml");
-var import_pptx_xml = require("../../../shared/lib/pptx-xml");
-var import_locator = require("../../../shared/lib/locator");
-var import_docx_markdown = require("./docx-markdown");
-var import_csv = require("../../../shared/lib/csv");
-const MAX_OUTPUT_CHARS = 1e5;
-const MAX_PART_BYTES = 30 * 1024 * 1024;
-const MAX_TOTAL_BYTES = 100 * 1024 * 1024;
-const SHEET_CAPS = { maxRows: 5e3, maxCols: 200, maxCells: 25e4 };
-const MAX_PDF_PAGES = 500;
-const MAX_SLIDES = 500;
-const TEXT_CONTEXT_LINES = 15;
-class ReadError extends Error {
-}
-const squash = (s) => s.replace(/\s+/g, " ").trim().toLowerCase();
-const dash = (a, b) => a === b ? String(a) : `${a}\u2013${b}`;
-function fit(sections, notes, rest) {
-  const out = [];
-  let left = MAX_OUTPUT_CHARS;
-  for (const [i, s] of sections.entries()) {
-    const cost = s.heading.length + s.body.length + 4;
-    if (cost <= left) {
-      out.push(s);
-      left -= cost;
-      continue;
-    }
-    let partly = false;
-    if (left > 2e3) {
-      const heading = `${s.heading} (cut short)`;
-      const cut = s.body.slice(0, left - heading.length - 4);
-      out.push({ heading, body: cut.slice(0, Math.max(0, cut.lastIndexOf("\n"))) });
-      partly = true;
-    }
-    const skipped = sections.slice(partly ? i + 1 : i).map((x) => x.heading);
-    notes.push(`Stopped at about ${MAX_OUTPUT_CHARS.toLocaleString("en-GB")} characters. ${rest(s.heading)}${skipped.length ? ` Not shown: ${skipped.slice(0, 20).join(", ")}${skipped.length > 20 ? ", \u2026" : ""}.` : ""}`);
-    break;
-  }
-  return out;
-}
-function numbered(lines, start, end) {
-  const width = String(end).length;
-  const out = [];
-  for (let n = start; n <= end; n++) out.push(`${String(n).padStart(width)}  ${lines[n - 1]}`);
-  return out.join("\n");
-}
-function readLines(lines, locator, opts) {
-  const total = lines.length;
-  const body = (a, b) => opts.number ? numbered(lines, a, b) : lines.slice(a - 1, b).join("\n");
-  if (locator.lines !== void 0) {
-    const span = (0, import_locator.toSpan)(locator.lines);
-    if (!span || span.start < 1 || span.end < span.start) {
-      throw new ReadError(`lines must be a line number or a span such as "10-20" \u2014 got ${JSON.stringify(locator.lines)}`);
-    }
-    if (span.start > total) throw new ReadError(`${opts.name} has ${total} lines; ${span.start} is past the end`);
-    const end = Math.min(span.end, total);
-    return { where: `lines ${dash(span.start, end)}`, section: { heading: `Lines ${dash(span.start, end)} of ${total}`, body: body(span.start, end) } };
-  }
-  if (locator.text !== void 0) {
-    const quote = squash(locator.text);
-    if (!quote) throw new ReadError("text must be the words to find");
-    const at = lines.findIndex((_, i) => squash(lines.slice(i, i + 8).join(" ")).includes(quote));
-    if (at < 0) throw new ReadError(`${opts.name} does not contain "${locator.text.slice(0, 80)}"`);
-    let first = at;
-    while (first + 1 < total && squash(lines.slice(first + 1, first + 9).join(" ")).includes(quote)) first++;
-    const a = Math.max(1, first + 1 - TEXT_CONTEXT_LINES);
-    const b = Math.min(total, first + 1 + TEXT_CONTEXT_LINES);
-    return { where: `the passage at line ${first + 1}`, section: { heading: `Lines ${dash(a, b)} of ${total}`, body: body(a, b) } };
-  }
-  return { where: null, section: { heading: `Lines 1\u2013${total}`, body: body(1, total) } };
-}
-function readTextFile(req, locator) {
-  const text = new TextDecoder("utf-8", { fatal: false }).decode(req.bytes);
-  const lines = text.split(/\r?\n/);
-  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
-  const notes = [];
-  refuseKeys(locator, req.ext === "csv" ? ["lines", "text", "range"] : ["lines", "text"], req);
-  const { where, section } = readLines(lines, locator, { number: true, name: req.name });
-  const sections = fit([section], notes, () => 'Ask for {"lines": "N-M"} to read further.');
-  return { ok: true, format: "text", where, outline: `${lines.length} lines`, sections, notes };
-}
-function readCsvRange(req, locator) {
-  refuseKeys(locator, ["range"], req);
-  const text = new TextDecoder("utf-8", { fatal: false }).decode(req.bytes);
-  const rows = (0, import_csv.parseCsv)(text);
-  const shape = (0, import_csv.csvShape)(rows);
-  const range = (0, import_locator.parseRange)(String(locator.range).trim());
-  if (!range) throw new ReadError(`"${locator.range}" is not a cell or range \u2014 write it as C14 or A1:F20`);
-  if (range.to.row > shape.rows || range.to.col > shape.cols) {
-    throw new ReadError(`${locator.range} is outside ${req.name}, which has ${shape.rows} rows and ${shape.cols} columns`);
-  }
-  const at = `${(0, import_xlsx_xml.colLetters)(range.from.col)}${range.from.row}:${(0, import_xlsx_xml.colLetters)(range.to.col)}${range.to.row}`;
-  const body = toCsv(rows.slice(range.from.row - 1, range.to.row).map((r) => r.slice(range.from.col - 1, range.to.col)));
-  const notes = [];
-  return {
-    ok: true,
-    format: "csv",
-    where: `cells ${at}`,
-    outline: `${shape.rows} rows, ${shape.cols} columns`,
-    sections: fit([{ heading: `Cells ${at}`, body }], notes, () => 'Ask for a smaller {"range"} to read the rest.'),
-    notes
-  };
-}
-function csvField(v) {
-  return /[",\r\n]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v;
-}
-function toCsv(rows) {
-  let lastRow = rows.length;
-  while (lastRow > 0 && rows[lastRow - 1].every((c) => c === "")) lastRow--;
-  const width = Math.max(0, ...rows.slice(0, lastRow).map((r) => {
-    let w = r.length;
-    while (w > 0 && r[w - 1] === "") w--;
-    return w;
-  }));
-  return rows.slice(0, lastRow).map((r) => Array.from({ length: width }, (_, i) => csvField(r[i] ?? "")).join(",")).join("\n");
-}
-async function readWorkbook(req, locator) {
-  refuseKeys(locator, ["sheet", "range", "text"], req);
-  const view = new DataView(req.bytes.buffer, req.bytes.byteOffset, req.bytes.byteLength);
-  const entries = (0, import_zip_reader.listEntries)(view);
-  const budget = { maxPart: MAX_PART_BYTES, maxTotal: MAX_TOTAL_BYTES, used: 0 };
-  const part = (name) => (0, import_zip_reader.readText)(view, entries, name, budget);
-  const workbook = await part("xl/workbook.xml");
-  if (!workbook) throw new ReadError(`${req.name} is not an Excel workbook \u2014 it has no workbook part`);
-  const refs = (0, import_xlsx_xml.parseWorkbookSheets)(workbook, await part("xl/_rels/workbook.xml.rels") ?? "");
-  const shared = (0, import_xlsx_xml.parseSharedStrings)(await part("xl/sharedStrings.xml") ?? "");
-  const dates = (0, import_xlsx_xml.parseDateStyles)(await part("xl/styles.xml") ?? "");
-  const notes = ["Each cell is the value the spreadsheet app last saved; formulas are not re-calculated."];
-  if (entries.some((e) => /vbaProject\.bin$/i.test(e.name))) notes.push("This workbook carries macros. They were not run.");
-  let range = null;
-  if (locator.range !== void 0) {
-    range = (0, import_locator.parseRange)(String(locator.range).trim());
-    if (!range) throw new ReadError(`"${locator.range}" is not a cell or range \u2014 write it as C14 or A1:F20`);
-  }
-  let chosen = refs;
-  if (locator.sheet !== void 0) {
-    const want = String(locator.sheet);
-    const hit = refs.find((r) => r.name === want) ?? refs.find((r) => r.name.toLowerCase() === want.trim().toLowerCase());
-    if (!hit) throw new ReadError(`${req.name} has no sheet "${want}" \u2014 it has ${refs.map((r) => `"${r.name}"`).join(", ") || "none"}`);
-    chosen = [hit];
-  } else if (range) {
-    chosen = refs.slice(0, 1);
-  }
-  const dims = [];
-  const sections = [];
-  let cellsLeft = SHEET_CAPS.maxCells;
-  for (const ref of refs) {
-    const xml = ref.part ? await part(ref.part) : null;
-    const dimension = xml ? (0, import_xlsx_xml.sheetDimension)(xml) : null;
-    dims.push(`${ref.name}${dimension ? ` (${dimension})` : ""}`);
-    if (!chosen.includes(ref) || !xml) continue;
-    const caps = range ? { maxRows: range.to.row, maxCols: range.to.col, maxCells: cellsLeft } : { ...SHEET_CAPS, maxCells: cellsLeft };
-    const grid = (0, import_xlsx_xml.parseSheetGrid)(xml, shared, dates, caps);
-    cellsLeft = Math.max(0, cellsLeft - grid.cells);
-    let rows = grid.rows;
-    let heading = `Sheet "${ref.name}"`;
-    if (range) {
-      rows = rows.slice(range.from.row - 1, range.to.row).map((r) => r.slice(range.from.col - 1, range.to.col));
-      heading += `, ${(0, import_xlsx_xml.colLetters)(range.from.col)}${range.from.row}:${(0, import_xlsx_xml.colLetters)(range.to.col)}${range.to.row}`;
-    } else if (grid.truncated) {
-      notes.push(`Sheet "${ref.name}" goes past ${SHEET_CAPS.maxRows.toLocaleString("en-GB")} rows or ${SHEET_CAPS.maxCols} columns; ask for {"sheet": "${ref.name}", "range": "A${SHEET_CAPS.maxRows + 1}:\u2026"} to read further.`);
-    }
-    if (!range) heading += " from A1";
-    sections.push({ heading, body: toCsv(rows) });
-  }
-  let shown = sections;
-  let where = locator.sheet !== void 0 || range ? sections.map((s) => s.heading.replace(/^Sheet /, "sheet ").replace(/ from A1$/, "")).join("; ") : null;
-  if (locator.text !== void 0) {
-    const quote = squash(locator.text);
-    if (!quote) throw new ReadError("text must be the words to find");
-    shown = sections.filter((s) => squash(s.body.replace(/"/g, "")).includes(quote) || squash(s.body).includes(quote));
-    if (shown.length === 0) throw new ReadError(`No sheet in ${req.name} contains "${locator.text.slice(0, 80)}"`);
-    where = shown.map((s) => s.heading.replace(/^Sheet /, "sheet ").replace(/ from A1$/, "")).join("; ");
-  }
-  return {
-    ok: true,
-    format: "csv",
-    where,
-    outline: `${refs.length} sheet${refs.length === 1 ? "" : "s"}: ${dims.join(", ")}`,
-    sections: fit(shown, notes, () => 'Ask for one {"sheet"} and a {"range"} to read the rest.'),
-    notes
-  };
-}
-async function readWord(req, locator) {
-  if (req.rendition && locator.lines === void 0) {
-    refuseKeys(locator, ["page", "text", "lines"], req);
-    const read = await readPdfPages(req.rendition, req.name, locator, "page");
-    return pagesReply(read, locator, "page", [
-      "Read from the pages CodeTrellis shows: its rendition of this document, laid out as the person sees it.",
-      `To cite this document, quote it: {"text": "\u2026"}. A {"page"} says where the words are on these pages, but is not checked \u2014 a Word document's pages depend on layout.`,
-      'Ask for {"lines": "1-200"} to read it as markdown instead, with its headings and tables.'
-    ]);
-  }
-  if (locator.page !== void 0) {
-    throw new ReadError(`${req.name} is a Word document; its pages depend on layout. Ask for {"lines"} of what this returns, or {"text"}`);
-  }
-  refuseKeys(locator, ["lines", "text"], req);
-  const view = new DataView(req.bytes.buffer, req.bytes.byteOffset, req.bytes.byteLength);
-  const entries = (0, import_zip_reader.listEntries)(view);
-  if (!entries.some((e) => e.name === "word/document.xml")) {
-    throw new ReadError(`${req.name} is not a Word document \u2014 it has no document part`);
-  }
-  const budget = { maxPart: MAX_PART_BYTES, maxTotal: MAX_TOTAL_BYTES, used: 0 };
-  for (const e of entries) await (0, import_zip_reader.readEntry)(view, e, budget);
-  let images = 0;
-  const result = await import_mammoth.default.convertToHtml({ buffer: Buffer.from(req.bytes.buffer, req.bytes.byteOffset, req.bytes.byteLength) }, {
-    // A document can link an image by path instead of embedding it. Never follow one.
-    externalFileAccess: false,
-    convertImage: import_mammoth.default.images.imgElement(async () => {
-      images++;
-      return { src: "" };
-    })
-  });
-  const markdown = (0, import_docx_markdown.docxHtmlToMarkdown)(result.value);
-  const lines = markdown.split("\n");
-  while (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
-  const notes = [
-    "Converted to markdown: headings, lists, tables and emphasis survive; page layout does not.",
-    `To cite this document, quote it: {"text": "\u2026"}. Line numbers here are this markdown's, not the document's.`
-  ];
-  if (images) notes.push(`${images} image${images === 1 ? "" : "s"} shown as [image]; open the document in CodeTrellis to see them.`);
-  const { where, section } = readLines(lines, locator, { number: false, name: req.name });
-  return {
-    ok: true,
-    format: "markdown",
-    where,
-    outline: `${lines.length} lines of markdown`,
-    sections: fit([section], notes, () => 'Ask for {"lines": "N-M"} of this markdown to read further.'),
-    notes
-  };
-}
-function pageSpan(locator, count, noun, name) {
-  if (locator.page === void 0) return null;
-  const span = (0, import_locator.toSpan)(locator.page);
-  if (!span || span.start < 1 || span.end < span.start) {
-    throw new ReadError(`page must be a ${noun} number from 1, or a span such as "2-4" \u2014 got ${JSON.stringify(locator.page)}`);
-  }
-  if (span.start > count) throw new ReadError(`${name} has ${count} ${noun}s; ${span.start} is not one of them`);
-  return { start: span.start, end: Math.min(span.end, count) };
-}
-function narrowByText(sections, locator, name) {
-  if (locator.text === void 0) return sections;
-  const quote = squash(locator.text);
-  if (!quote) throw new ReadError("text must be the words to find");
-  const hits = sections.filter((s) => squash(`${s.heading} ${s.body}`).includes(quote));
-  if (hits.length === 0) throw new ReadError(`${name} does not contain "${locator.text.slice(0, 80)}"`);
-  return hits;
-}
-async function readDeck(req, locator) {
-  refuseKeys(locator, ["page", "text"], req);
-  const view = new DataView(req.bytes.buffer, req.bytes.byteOffset, req.bytes.byteLength);
-  const entries = (0, import_zip_reader.listEntries)(view);
-  const names = entries.map((e) => e.name);
-  if (!names.includes("ppt/presentation.xml")) throw new ReadError(`${req.name} is not a PowerPoint deck \u2014 it has no presentation part`);
-  const budget = { maxPart: MAX_PART_BYTES, maxTotal: MAX_TOTAL_BYTES, used: 0 };
-  const order = (0, import_pptx_xml.slideOrder)(
-    await (0, import_zip_reader.readText)(view, entries, "ppt/presentation.xml", budget),
-    await (0, import_zip_reader.readText)(view, entries, "ppt/_rels/presentation.xml.rels", budget),
-    names
-  );
-  const notes = ["Each slide's title and words in presentation order; pictures and charts are not described."];
-  if (req.rendition) {
-    const read = await readPdfPages(req.rendition, req.name, locator, "slide", order.length);
-    if (read) {
-      return pagesReply(read, locator, "slide", [
-        "Read from the slides as CodeTrellis shows them: the words on each, laid out as the person sees it. Pictures are not described."
-      ]);
-    }
-    notes.push("Read from the slides themselves: the view CodeTrellis shows leaves some out (hidden slides), so its pages are not numbered as the slides are.");
-  }
-  const span = pageSpan(locator, order.length, "slide", req.name);
-  const first = span?.start ?? 1;
-  const last = Math.min(span?.end ?? order.length, MAX_SLIDES);
-  if (order.length > MAX_SLIDES && !span) notes.push(`Only the first ${MAX_SLIDES} slides are read.`);
-  const sections = [];
-  for (let n = first; n <= last; n++) {
-    const xml = await (0, import_zip_reader.readText)(view, entries, order[n - 1], budget);
-    const s = xml ? (0, import_pptx_xml.slideText)(n, xml) : { n, title: null, paragraphs: [] };
-    sections.push({ heading: `Slide ${n}${s.title ? ` \u2014 ${s.title}` : ""}`, body: s.paragraphs.join("\n") || "(no words)" });
-  }
-  const shown = narrowByText(sections, locator, req.name);
-  const where = locator.text !== void 0 ? shown.map((s) => s.heading.split(" \u2014 ")[0].toLowerCase()).join(", ") : span ? `slide${span.start === span.end ? "" : "s"} ${dash(span.start, span.end)}` : null;
-  return {
-    ok: true,
-    format: "markdown",
-    where,
-    outline: `${order.length} slide${order.length === 1 ? "" : "s"}`,
-    sections: fit(shown, notes, () => 'Ask for {"page": "N-M"} to read further slides.'),
-    notes
-  };
-}
-let pdfjsLoaded = null;
-function loadPdfJs() {
-  pdfjsLoaded ??= (async () => {
-    globalThis.pdfjsWorker = await Promise.resolve().then(() => __toESM(require("pdfjs-dist/legacy/build/pdf.worker.mjs")));
-    return await Promise.resolve().then(() => __toESM(require("pdfjs-dist/legacy/build/pdf.mjs")));
-  })();
-  return pdfjsLoaded;
-}
-async function readPdfPages(bytes, name, locator, noun, expectPages) {
-  const Noun = noun === "page" ? "Page" : "Slide";
-  const pdfjs = await loadPdfJs();
-  const task = pdfjs.getDocument({
-    data: bytes,
-    isEvalSupported: false,
-    enableXfa: false,
-    disableFontFace: true,
-    useSystemFonts: false,
-    stopAtErrors: false,
-    verbosity: 0
-  });
-  try {
-    let doc;
-    try {
-      doc = await task.promise;
-    } catch (err) {
-      const errName = err.name;
-      throw new ReadError(errName === "PasswordException" ? `${name} is password-protected, so its text cannot be read` : `${name} could not be read as a PDF (${err.message})`);
-    }
-    if (expectPages !== void 0 && doc.numPages !== expectPages) return null;
-    const span = pageSpan(locator, doc.numPages, noun, name);
-    const notes = [];
-    const first = span?.start ?? 1;
-    const last = Math.min(span?.end ?? doc.numPages, first + MAX_PDF_PAGES - 1);
-    if (!span && doc.numPages > MAX_PDF_PAGES) notes.push(`Only the first ${MAX_PDF_PAGES} ${noun}s are read.`);
-    const sections = [];
-    let chars = 0;
-    for (let n = first; n <= last; n++) {
-      const page = await doc.getPage(n);
-      const content = await page.getTextContent();
-      const body = content.items.map((it) => (it.str ?? "") + (it.hasEOL ? "\n" : "")).join("").replace(/[ \t]+\n/g, "\n").trim();
-      page.cleanup();
-      sections.push({ heading: `${Noun} ${n}`, body: body || (noun === "page" ? "(no text on this page \u2014 it may be a scanned image)" : "(no text on this slide \u2014 it may be a picture)") });
-      chars += body.length;
-      if (chars > MAX_OUTPUT_CHARS * 2 && locator.text === void 0) break;
-    }
-    return { count: doc.numPages, span, sections: narrowByText(sections, locator, name), notes };
-  } finally {
-    await task.destroy().catch(() => {
-    });
-  }
-}
-function pagesReply(read, locator, noun, notes) {
-  const { count, span, sections } = read;
-  const all = [...notes, ...read.notes];
-  const where = locator.text !== void 0 ? sections.map((s) => s.heading.toLowerCase()).join(", ") : span ? `${noun}${span.start === span.end ? "" : "s"} ${dash(span.start, span.end)}` : null;
-  return {
-    ok: true,
-    format: "text",
-    where,
-    outline: `${count} ${noun}${count === 1 ? "" : "s"}`,
-    sections: fit(sections, all, () => `Ask for {"page": "N-M"} to read further ${noun}s.`),
-    notes: all
-  };
-}
-async function readPdf(req, locator) {
-  refuseKeys(locator, ["page", "text"], req);
-  const read = await readPdfPages(req.bytes, req.name, locator, "page");
-  return pagesReply(read, locator, "page", []);
-}
-function refuseKeys(locator, allowed, req) {
-  const extra = Object.keys(locator).filter((k) => locator[k] !== void 0 && !allowed.includes(k));
-  if (extra.length) {
-    throw new ReadError(`A .${req.ext} file is read by ${allowed.map((k) => `{${k}}`).join(", ")} \u2014 not by ${extra.map((k) => `{${k}}`).join(", ")}`);
-  }
-}
-async function readMaterialBytes(input) {
-  const view = (b) => new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
-  const req = { ...input, bytes: view(input.bytes), rendition: input.rendition ? view(input.rendition) : null };
-  const locator = req.locator ?? {};
-  try {
-    switch (req.ext) {
-      case "xlsx":
-      case "xlsm":
-        return await readWorkbook(req, locator);
-      case "docx":
-        return await readWord(req, locator);
-      case "pptx":
-        return await readDeck(req, locator);
-      case "pdf":
-        return await readPdf(req, locator);
-      default:
-        if (req.ext === "csv" && locator.range !== void 0) return readCsvRange(req, locator);
-        if (import_locator.TEXT_EXTS.has(req.ext)) return readTextFile(req, locator);
-        return { ok: false, reason: `.${req.ext} files are not read as text` };
-    }
-  } catch (err) {
-    if (err instanceof ReadError || err instanceof import_zip_reader.CapError) return { ok: false, reason: err.message };
-    return { ok: false, reason: `${req.name} could not be read as a .${req.ext} file (${err.message})` };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MAX_OUTPUT_CHARS,
-  readMaterialBytes
-});