codetrellis 0.0.0-stage → 0.2.0

package/resources/tree-sitter/README.md

@@ -0,0 +1,150 @@
+# Tree-sitter grammars
+
+These `.wasm` files are the parser grammars `ast-parser.ts` loads at
+boot, one per `ParserPlugin.grammarFile`. They are committed rather
+than fetched at install time, and copied verbatim into the packaged app
+via `extraResource`.
+
+`tree-sitter.wasm` is not a grammar — it is the **runtime**, loaded by
+`Parser.init({ locateFile })`. It must stay ABI-compatible with the
+pinned `web-tree-sitter` version in `package.json`.
+
+## Compatibility
+
+A grammar built for an older tree-sitter ABI fails at
+`Language.load()` with an opaque emscripten dylink error, and
+`loadGrammars()` catches it, logs a warning and carries on — so an
+incompatible grammar presents as **a language that silently produces no
+symbols and no edges**, not as a crash. That is a slow, confusing
+failure, so:
+
+- `src/backend/services/parsers/go.test.ts` loads the Go grammar
+  directly under `npm run test:unit` and asserts it parses. It is the
+  fastest signal that a grammar swap broke something. Worth copying for
+  the other languages.
+- A grammar from a bundle that targets an older runtime will not load.
+  During Phase 20 the `tree-sitter-wasms@0.1.13` build of Go failed
+  exactly this way against `web-tree-sitter@0.27`; the grammar shipped
+  in the official `tree-sitter-go` npm package loaded cleanly.
+
+## Provenance
+
+| File | sha256 | Source |
+|---|---|---|
+| `tree-sitter-go.wasm` | `9504573f352b20be7f2f1911754d710622aedc15afff16d5ed8fb5645681aee7` | npm `tree-sitter-go@0.25.0`, the `tree-sitter-go.wasm` shipped in the package (Phase 20) |
+| `tree-sitter-ruby.wasm` | `09a96427d7c72f0613ed470cd9812223fc4a91d6a9c025c0235cc6bd59ff96f4` | npm `tree-sitter-ruby@0.23.1`, the `tree-sitter-ruby.wasm` shipped in the package (Phase 27) |
+| `tree-sitter-c-sharp.wasm` | `6f69e1cae44e1c32c1eccc170dc5a9778fb94ff716f71113fe1f8c4299aa2f40` | npm `tree-sitter-c-sharp@0.23.5`, the `tree-sitter-c_sharp.wasm` shipped in the package (Phase 27). ABI 15. |
+| `tree-sitter-kotlin.wasm` | `7009d69453bc8735e438b2818a633efb21c88f99782769abba60dffedfab73f7` | npm `@tree-sitter-grammars/tree-sitter-kotlin@1.1.0`, the `tree-sitter-kotlin.wasm` shipped in the package (Phase 27). ABI 14. |
+| `tree-sitter-swift.wasm` | `24a6afb13db61ffd7d53dd848bbf684ec1c3aacea685a0857dcd1db673d28c7e` | Built from source — npm `tree-sitter-swift@0.7.1` (tarball sha1 `e7b41402dbc29fc3a8741793513e7a0f3e35cc55`, matching npm's `dist.shasum`), compiled with `tree-sitter-cli@0.27.0`. ABI 14. See "Swift is built from source" below. |
+| `tree-sitter-java.wasm` | `4fdeac4ca6ca089f06c6f7e562abcac1733cd465728cc7031ebb73c2019122c4` | unrecorded — predates this file |
+| `tree-sitter-javascript.wasm` | `5fb488d0cabb4775a594bab85682de5ad6ce83c0d6ac997a9f82dd084d571240` | unrecorded — predates this file |
+| `tree-sitter-php.wasm` | `d4df6a6ff08c87c3ec4f9cbb785fe09998a0cb570e03f57d7b19b3acfb146aa7` | unrecorded — predates this file |
+| `tree-sitter-python.wasm` | `16108b50df4ee9a30168794252ab55e7c93bfc5765d7fa0aa3e335752c515f47` | unrecorded — predates this file |
+| `tree-sitter-rust.wasm` | `f65f354215611fd94ad34134b3427eb3d58cbb745df7b6509ba722184db73d57` | unrecorded — predates this file |
+| `tree-sitter-tsx.wasm` | `79e5da75ea62855a0cd67177685f0164eac87d5f630b3cbe1e0a099751ad30f8` | unrecorded — predates this file |
+| `tree-sitter-typescript.wasm` | `778025db5a8be0e70f8ccc3671e486dfeddd048c25d9e8a70c26de2e1bf6f97d` | unrecorded — predates this file |
+| `tree-sitter.wasm` | `c03bccdc3b448a32848f5ae327e209c982bbb0840d43eec8bc2d5759544a1ed3` | the `web-tree-sitter` runtime (see `package.json` for the pinned version) |
+
+## Swift is built from source
+
+Swift is the one grammar with no artifact of its own to take: no
+published `tree-sitter-swift` ships a wasm at any version, and there is
+no `@tree-sitter-grammars/tree-sitter-swift`. Until this build it
+shipped a third-party artifact from `@repomix/tree-sitter-wasms`. It is
+now compiled here from the maintainers' own source.
+
+Reproduce it:
+
+```bash
+npm pack tree-sitter-swift@0.7.1
+# tarball sha1 must be e7b41402dbc29fc3a8741793513e7a0f3e35cc55 — npm's dist.shasum
+tar -xzf tree-sitter-swift-0.7.1.tgz
+cd package && npx tree-sitter-cli@0.27.0 build --wasm .
+sha256sum tree-sitter-swift.wasm
+```
+
+**This needs no Emscripten.** tree-sitter-cli 0.27 downloads a pinned
+wasi-sdk and binaryen into `~/.cache/tree-sitter` and builds with those,
+so the toolchain comes from the CLI version rather than from whatever
+the machine happens to have. The CLI's minor is deliberately matched to
+the pinned `web-tree-sitter` (0.27) — the runtime that loads it.
+`src/parser.c` declares ABI 14, the same ABI as the artifact this
+replaced.
+
+**The bytes are not reproducible across machines.** A different wasi-sdk
+or wasm-opt will compile the same source to a different sha256. The hash
+in the table pins what is *committed*, so a change to it is visible in a
+diff; the tarball sha1 above is what pins the *source*.
+
+What this bought, stated plainly: trust moved from the `@repomix`
+publisher to the `tree-sitter-swift` maintainers — the same people the
+other rows already trust. It was never a large exposure. A grammar runs
+inside the wasm sandbox and imports nothing but the tree-sitter runtime:
+no filesystem, no network, no host calls. The worst a hostile grammar
+can do is return a wrong parse tree or hang the parse loop, which is far
+less than an npm package with an install script.
+
+Verified before committing, because a bad grammar swap is silent — it
+presents as a language that produces no symbols, not as a crash:
+
+- The new wasm produces **symbol and import extraction identical** to the
+  artifact it replaced, over a sample covering class, struct, enum,
+  extension, protocol, actor, init, deinit, subscript and computed
+  properties. Identical sets, no parse errors, on both.
+- `parsers/jvm-and-apple.test.ts` passes under `npm run test:unit`.
+
+The seven "unrecorded" rows are honest: those files were committed
+before provenance was tracked, and guessing a version here would be
+worse than saying so. Their hashes are recorded now, so any future
+change to them is at least visible. Re-deriving their true origin is
+worth doing the next time any of them is touched — this is a public
+repo shipping compiled binaries, and "where did this come from" should
+have an answer.
+
+## Adding a grammar
+
+1. Obtain the `.wasm`, preferring the grammar's own npm package — those
+   are built against a current runtime.
+
+   **Check every plausible package name before concluding no artifact
+   exists.** Phase 27 initially costed Kotlin and Swift as needing an
+   Emscripten toolchain because `tree-sitter-kotlin@0.3.8` ships no wasm.
+   `@tree-sitter-grammars/tree-sitter-kotlin@1.1.0` — the maintained one,
+   under the grammar org's scope — ships it. One `npm pack` of the right
+   name replaced a multi-day build story. Names to try, in order:
+   `@tree-sitter-grammars/tree-sitter-<lang>`, then
+   `tree-sitter-<lang>`, then a reputable prebuilt bundle. Record which
+   one you used.
+
+   An external C scanner (`src/scanner.c`) is a hint that a local build
+   will be fiddly, **not** evidence that no prebuilt exists — C#, Kotlin
+   and Swift all have one and all three have a usable published wasm.
+   See [docs/PHASE-27-LANGUAGE-EXPANSION.md](../../docs/PHASE-27-LANGUAGE-EXPANSION.md).
+2. **Verify it loads and parses before writing any plugin code**, and
+   read the grammar's real node shapes off a sample file rather than
+   assuming them. Several grammars pack multiple declarations into one
+   node type and separate them with an **anonymous** keyword token that
+   `namedChildren` cannot see — Kotlin's `class_declaration` is class,
+   interface and enum; Swift's is class, struct, enum and extension.
+   Guessing there produces a plausible, wrong graph rather than an error.
+   A unit test like `parsers/go.test.ts` is the cheapest way.
+3. Commit it here and add a row above with its sha256 and exact source.
+4. Register the plugin in `parsers/index.ts`, and add the extension to
+   the scanner's `LANG_MAP` and the tag to `SupportedLanguage`. The
+   file-watcher needs nothing — it derives its parseable-extension set
+   from the same registry — and `findUnparsedLanguages()` fails the unit
+   suite if the scanner tags a language no plugin claims.
+5. Emit a **flat** symbol list with qualified member names
+   (`Type.member`). Nested symbols are written to the database and then
+   filtered out by every per-file reader — see `flattenSymbols` in
+   `parsers/base.ts`.
+6. Add the language to `frontend/lib/prism-lang.ts` and
+   `frontend/lib/codemirror-lang.ts`, or deliberately leave it out.
+   Both are guarded by `prism-lang.test.ts`; naming a grammar that is not
+   installed renders plain text with no error.
+
+To re-verify every hash:
+
+```bash
+cd resources/tree-sitter && sha256sum *.wasm
+```

package/src/backend/agent/claude-code-watcher.js

@@ -0,0 +1,270 @@
+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 claude_code_watcher_exports = {};
+__export(claude_code_watcher_exports, {
+  getWatcherStatus: () => getWatcherStatus,
+  startClaudeCodeWatcher: () => startClaudeCodeWatcher,
+  stopClaudeCodeWatcher: () => stopClaudeCodeWatcher
+});
+module.exports = __toCommonJS(claude_code_watcher_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_os = __toESM(require("node:os"));
+var import_server = require("../server");
+var import_budget_service = require("../services/budget-service");
+var import_agent_event_log = require("../services/agent-event-log");
+var import_skill_use_service = require("../services/skill-use-service");
+var import_workstream_binding = require("../services/workstream-binding");
+const claudeDir = () => process.env.CODETRELLIS_CLAUDE_DIR || import_node_path.default.join(import_node_os.default.homedir(), ".claude");
+const sessionsDir = () => import_node_path.default.join(claudeDir(), "sessions");
+const projectsDir = () => import_node_path.default.join(claudeDir(), "projects");
+const pollIntervalMs = () => Number(process.env.CODETRELLIS_WATCHER_POLL_MS) || 2e3;
+let watchInterval = null;
+const watched = /* @__PURE__ */ new Map();
+let lastBound = null;
+function jsonlDirsFor(cwd) {
+  const dirs = [cwd.replace(/\//g, "-"), cwd.replace(/[^a-zA-Z0-9]/g, "-")];
+  return [...new Set(dirs)].map((d) => import_node_path.default.join(projectsDir(), d));
+}
+function findLiveSessions(folders) {
+  if (!folders.length || !import_node_fs.default.existsSync(sessionsDir())) return [];
+  const live = [];
+  for (const file of import_node_fs.default.readdirSync(sessionsDir()).filter((f) => f.endsWith(".json"))) {
+    try {
+      const session = JSON.parse(import_node_fs.default.readFileSync(import_node_path.default.join(sessionsDir(), file), "utf-8"));
+      if (typeof session.sessionId !== "string" || typeof session.cwd !== "string") continue;
+      const workstreamRoot = (0, import_workstream_binding.matchWorkstreamRoot)(session.cwd, folders);
+      if (!workstreamRoot) continue;
+      try {
+        process.kill(session.pid, 0);
+      } catch {
+        continue;
+      }
+      const jsonlPath = jsonlDirsFor(session.cwd).map((dir) => import_node_path.default.join(dir, `${session.sessionId}.jsonl`)).find((p) => import_node_fs.default.existsSync(p));
+      if (jsonlPath) live.push({ sessionId: session.sessionId, jsonlPath, workstreamRoot });
+    } catch {
+      continue;
+    }
+  }
+  return live;
+}
+function parseJsonlEntries(line) {
+  try {
+    const entry = JSON.parse(line);
+    return parseEntry(entry).map((e) => ({ ...e, timestamp: entryTime(entry, e.timestamp) }));
+  } catch {
+    return [];
+  }
+}
+function entryTime(entry, readAt) {
+  const t = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : NaN;
+  return Number.isFinite(t) && t <= readAt + 6e4 ? t : readAt;
+}
+function parseEntry(entry) {
+  try {
+    const type = entry.type;
+    if (type === "assistant") {
+      const usage = entry.message?.usage;
+      const sessionId = entry.sessionId ?? entry.session_id;
+      if (usage && typeof sessionId === "string") {
+        try {
+          (0, import_budget_service.recordTokens)({
+            sessionId,
+            model: entry.message?.model ?? null,
+            tokens: {
+              inputTokens: usage.input_tokens ?? 0,
+              outputTokens: usage.output_tokens ?? 0,
+              cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
+              cacheReadTokens: usage.cache_read_input_tokens ?? 0
+            }
+          });
+        } catch {
+        }
+      }
+      const content = entry.message?.content;
+      if (!Array.isArray(content)) return [];
+      const events = [];
+      for (const block of content) {
+        if (block.type === "tool_use") {
+          events.push(toolUseEvent(block.name, block.input || {}));
+        } else if (block.type === "text") {
+          const text = block.text || "";
+          if (isPlanLike(text)) {
+            events.push(makeEvent("plan_reported", {
+              text: text.substring(0, 1e3)
+            }));
+          }
+        }
+      }
+      return events;
+    }
+    if (type === "user") {
+      return [makeEvent("session_start", {
+        message: (entry.message?.content || "").substring(0, 200),
+        timestamp: entry.timestamp
+      })];
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function toolUseEvent(toolName, input) {
+  if (toolName === "Read") return makeEvent("file_changed", { action: "read", file: input.file_path, tool: toolName });
+  if (toolName === "Write") return makeEvent("file_changed", { action: "write", file: input.file_path, tool: toolName });
+  if (toolName === "Edit") return makeEvent("file_changed", { action: "edit", file: input.file_path, tool: toolName });
+  if (toolName === "Bash") {
+    return makeEvent("file_changed", { action: "bash", command: String(input.command ?? "").substring(0, 200), tool: toolName });
+  }
+  if (toolName === "Skill") {
+    return makeEvent("skill_used", { skill: String(input.skill ?? input.name ?? "").slice(0, 80), tool: toolName });
+  }
+  if (toolName === "Glob" || toolName === "Grep") {
+    return makeEvent("architecture_query", { tool: toolName, pattern: input.pattern || input.query });
+  }
+  return makeEvent("file_changed", { action: "tool", tool: toolName });
+}
+function isPlanLike(text) {
+  const lines = text.split("\n").filter((l) => l.trim());
+  const numberedLines = lines.filter((l) => /^\s*\d+[.)]\s/.test(l));
+  if (numberedLines.length >= 3) return true;
+  const hasHeaders = lines.some((l) => l.startsWith("##") || l.startsWith("**"));
+  const hasBullets = lines.filter((l) => /^\s*[-*]\s/.test(l)).length >= 3;
+  if (hasHeaders && hasBullets) return true;
+  return false;
+}
+function makeEvent(type, payload) {
+  return {
+    id: (0, import_agent_event_log.eventId)("cc"),
+    timestamp: Date.now(),
+    source: "claude-code-watcher",
+    type,
+    payload
+  };
+}
+function tailSession(sessionId, w) {
+  try {
+    const stat = import_node_fs.default.statSync(w.jsonlPath);
+    if (stat.size <= w.position) return;
+    const fd = import_node_fs.default.openSync(w.jsonlPath, "r");
+    const buffer = Buffer.alloc(stat.size - w.position);
+    import_node_fs.default.readSync(fd, buffer, 0, buffer.length, w.position);
+    import_node_fs.default.closeSync(fd);
+    const text = buffer.toString("utf-8");
+    const complete = text.lastIndexOf("\n") + 1;
+    w.position += Buffer.byteLength(text.slice(0, complete), "utf-8");
+    for (const line of text.slice(0, complete).split("\n")) {
+      if (!line.trim()) continue;
+      for (const event of parseJsonlEntries(line)) {
+        event.payload = { ...event.payload, sessionId, workstreamRoot: w.workstreamRoot };
+        if (event.type === "skill_used" && typeof event.payload.skill === "string") {
+          const itemUids = (0, import_skill_use_service.recordSkillUse)({ skill: event.payload.skill, sessionId, workstreamRoot: w.workstreamRoot, at: event.timestamp });
+          event.payload = { ...event.payload, itemUids };
+        }
+        (0, import_server.broadcast)("agent-event", event);
+      }
+    }
+  } catch {
+  }
+}
+const REBIND_CHECK_TICKS = 5;
+function follow(session) {
+  let position = 0;
+  try {
+    position = import_node_fs.default.statSync(session.jsonlPath).size;
+  } catch {
+  }
+  watched.set(session.sessionId, { jsonlPath: session.jsonlPath, position, workstreamRoot: session.workstreamRoot });
+  lastBound = session.sessionId;
+  console.log(`[ClaudeWatcher] Following session ${session.sessionId} in ${session.workstreamRoot}`);
+  (0, import_server.broadcast)("agent-event", makeEvent("session_start", {
+    sessionId: session.sessionId,
+    workstreamRoot: session.workstreamRoot
+  }));
+}
+function reconcile(live) {
+  const liveIds = new Set(live.map((s) => s.sessionId));
+  for (const [id, w] of watched) {
+    if (liveIds.has(id)) continue;
+    tailSession(id, w);
+    watched.delete(id);
+    if (lastBound === id) lastBound = [...watched.keys()].pop() ?? null;
+  }
+  for (const s of live) if (!watched.has(s.sessionId)) follow(s);
+}
+const FOLDERS_TTL_MS = 3e4;
+function startClaudeCodeWatcher(projectRoot, folders) {
+  stopClaudeCodeWatcher();
+  let cached = null;
+  const currentFolders = () => {
+    if (folders) return folders();
+    if (cached && Date.now() - cached.at < FOLDERS_TTL_MS) return cached.list;
+    let list;
+    try {
+      list = [.../* @__PURE__ */ new Set([projectRoot, ...(0, import_workstream_binding.candidateWorkstreamRoots)()])];
+    } catch {
+      list = [projectRoot];
+    }
+    cached = { at: Date.now(), list };
+    return list;
+  };
+  reconcile(findLiveSessions(currentFolders()));
+  if (!watched.size) console.log("[ClaudeWatcher] No active Claude Code session found, polling...");
+  let ticksSinceCheck = 0;
+  watchInterval = setInterval(() => {
+    if (!watched.size || ++ticksSinceCheck >= REBIND_CHECK_TICKS) {
+      ticksSinceCheck = 0;
+      reconcile(findLiveSessions(currentFolders()));
+    }
+    for (const [id, w] of watched) tailSession(id, w);
+  }, pollIntervalMs());
+  console.log(`[ClaudeWatcher] Watching for Claude Code sessions in ${projectRoot} and its workstreams`);
+}
+function stopClaudeCodeWatcher() {
+  if (watchInterval) {
+    clearInterval(watchInterval);
+    watchInterval = null;
+  }
+  watched.clear();
+  lastBound = null;
+}
+function getWatcherStatus() {
+  const latest = lastBound ? watched.get(lastBound) : void 0;
+  return {
+    watching: watchInterval !== null,
+    sessionId: latest ? lastBound : null,
+    jsonlPath: latest?.jsonlPath ?? null,
+    sessions: [...watched].map(([sessionId, w]) => ({ sessionId, jsonlPath: w.jsonlPath, workstreamRoot: w.workstreamRoot }))
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getWatcherStatus,
+  startClaudeCodeWatcher,
+  stopClaudeCodeWatcher
+});

package/src/backend/index.js

@@ -0,0 +1,8 @@
+var import_server = require("./server");
+var import_lifecycle = require("./lifecycle");
+const PORT = parseInt(process.env.PORT || "3001", 10);
+(0, import_lifecycle.installProcessHandlers)();
+(0, import_server.startServer)(PORT).catch((err) => {
+  console.error("[Backend] Failed to start:", err);
+  process.exit(1);
+});

package/src/backend/lib/sha256-file.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sha256_file_exports = {};
+__export(sha256_file_exports, {
+  sha256FileWithin: () => sha256FileWithin
+});
+module.exports = __toCommonJS(sha256_file_exports);
+var import_node_crypto = require("node:crypto");
+var import_confined_fs = require("../services/confined-fs");
+var import_cloud_files = require("../services/cloud-files");
+function sha256FileWithin(root, rel) {
+  if ((0, import_cloud_files.isPlaceholder)((0, import_confined_fs.resolveWithin)(root, rel, "artefact"))) return Promise.reject(new import_cloud_files.NotOnDeviceError(rel));
+  const { stream, size, mtimeMs } = (0, import_confined_fs.openReadStreamWithin)(root, rel, {}, "artefact");
+  return new Promise((resolve, reject) => {
+    const hash = (0, import_node_crypto.createHash)("sha256");
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve({ sha256: hash.digest("hex"), size, mtimeMs }));
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sha256FileWithin
+});

package/src/backend/lib/zip-entries.js

@@ -0,0 +1,98 @@
+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 zip_entries_exports = {};
+__export(zip_entries_exports, {
+  ZipError: () => ZipError,
+  listZipEntries: () => listZipEntries,
+  readZipEntry: () => readZipEntry
+});
+module.exports = __toCommonJS(zip_entries_exports);
+var import_node_zlib = __toESM(require("node:zlib"));
+class ZipError extends Error {
+}
+const EOCD_SIG = 101010256;
+const CEN_SIG = 33639248;
+const LOC_SIG = 67324752;
+function listZipEntries(buf) {
+  const floor = Math.max(0, buf.length - 22 - 65535);
+  let eocd = -1;
+  for (let i = buf.length - 22; i >= floor; i--) {
+    if (buf.readUInt32LE(i) === EOCD_SIG) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new ZipError("not a zip archive");
+  const count = buf.readUInt16LE(eocd + 10);
+  let p = buf.readUInt32LE(eocd + 16);
+  const entries = [];
+  for (let n = 0; n < count; n++) {
+    if (p + 46 > buf.length || buf.readUInt32LE(p) !== CEN_SIG) throw new ZipError("corrupt central directory");
+    const method = buf.readUInt16LE(p + 10);
+    const compressedSize = buf.readUInt32LE(p + 20);
+    const size = buf.readUInt32LE(p + 24);
+    const nameLen = buf.readUInt16LE(p + 28);
+    const extraLen = buf.readUInt16LE(p + 30);
+    const commentLen = buf.readUInt16LE(p + 32);
+    const localHeaderOffset = buf.readUInt32LE(p + 42);
+    const name = buf.toString("utf8", p + 46, p + 46 + nameLen);
+    entries.push({ name, method, compressedSize, size, localHeaderOffset });
+    p += 46 + nameLen + extraLen + commentLen;
+  }
+  return entries;
+}
+function readZipEntry(buf, name, opts = {}) {
+  const max = opts.maxEntryBytes ?? 20 * 1024 * 1024;
+  const entry = (opts.entries ?? listZipEntries(buf)).find((e) => e.name === name);
+  if (!entry) return null;
+  const at = entry.localHeaderOffset;
+  if (at + 30 > buf.length || buf.readUInt32LE(at) !== LOC_SIG) throw new ZipError("corrupt local header");
+  const start = at + 30 + buf.readUInt16LE(at + 26) + buf.readUInt16LE(at + 28);
+  const end = start + entry.compressedSize;
+  if (end > buf.length) throw new ZipError("entry runs past the end of the archive");
+  const raw = buf.subarray(start, end);
+  if (entry.method === 0) {
+    if (raw.length > max) throw new ZipError(`${name} is larger than ${max} bytes`);
+    return Buffer.from(raw);
+  }
+  if (entry.method !== 8) throw new ZipError(`${name} uses compression method ${entry.method}`);
+  try {
+    return import_node_zlib.default.inflateRawSync(raw, { maxOutputLength: max });
+  } catch (err) {
+    if (err.code === "ERR_BUFFER_TOO_LARGE") {
+      throw new ZipError(`${name} inflates past ${max} bytes`);
+    }
+    throw new ZipError(`${name} could not be inflated`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZipError,
+  listZipEntries,
+  readZipEntry
+});