pi-ast-sgrep 2.0.2 → 2.2.0

package/dist/ui/present.js

@@ -0,0 +1,391 @@
+/** Neat asgrep tool chrome for the Pi TUI and the model-visible content. */
+export const ASGREP_PROMPT_SNIPPET = "Code search by intent, symbol, defs, callers, pattern (asgrep; use without being asked)";
+export const ASGREP_PROMPT_GUIDELINES = [
+    "Any code lookup (function, def, caller, intent, pattern): call asgrep first.",
+    "Compose in Code Mode (search/defs/read with Promise.all, return a small shaped value); grep only for exact strings or filenames. Bound with in: \"path\"; on 0 hits use suggested_next.",
+];
+export function paint(theme, role, text, bold = false) {
+    const body = bold && theme ? theme.bold(text) : text;
+    return theme ? theme.fg(role, body) : body;
+}
+export function hitLocation(hit) {
+    const file = sanitizeContent(String(hit.file ?? hit.path ?? ""));
+    const line = hit.start_line ?? hit.line ?? hit.lines;
+    if (typeof line === "number")
+        return `${file}:${line}`;
+    if (typeof line === "string" && line.length > 0)
+        return `${file}:${sanitizeContent(line)}`;
+    if (typeof hit.ref === "string" && hit.ref.length > 0)
+        return sanitizeContent(hit.ref);
+    return file || "?";
+}
+/** Hard caps for one result: rows shown, excerpt lines per hit, longest preview. */
+const MAX_HIT_ROWS = 24;
+const MAX_EXCERPT_LINES_OUT = 12;
+const MAX_PREVIEW_CHARS = 96;
+export function hitLabel(hit) {
+    const symbol = typeof hit.symbol === "string" ? sanitizeContent(hit.symbol) : "";
+    const kind = typeof hit.kind === "string" ? sanitizeContent(hit.kind) : "";
+    const raw = typeof hit.preview === "string" ? sanitizeContent(hit.preview).replace(/\s+/g, " ").trim() : "";
+    // Truncate instead of dropping: a long preview used to vanish entirely, so a
+    // hit could carry no hint at all about what it contained.
+    const preview = raw.length > MAX_PREVIEW_CHARS ? raw.slice(0, MAX_PREVIEW_CHARS - 1) + "\u2026" : raw;
+    return [symbol, kind, preview].filter(Boolean).join("  ");
+}
+export function formatEditResult(response, theme) {
+    const edits = Array.isArray(response.edits) ? response.edits : [];
+    const changed = edits.filter((e) => e.changed === true).length;
+    const rows = ["edit: " + changed + "/" + edits.length + " changed"];
+    for (const entry of edits.slice(0, 12)) {
+        const path = sanitizeContent(typeof entry.path === "string" ? entry.path : "?");
+        const line = typeof entry.line === "number" ? ":" + entry.line : "";
+        rows.push("  " + path + line);
+    }
+    return rows.join("\n");
+}
+/** Model-visible text for a read envelope: the window contents themselves. */
+export function formatReadResult(response, theme) {
+    const windows = Array.isArray(response.windows) ? response.windows : [];
+    if (windows.length === 0)
+        return "read: 0 windows";
+    const out = [];
+    for (const w of windows.slice(0, 8)) {
+        const path = sanitizeContent(typeof w.path === "string" ? w.path : "?");
+        // The window's own path+range is the line the model needs to cite back.
+        out.push(path + "#L" + (w.start ?? 1) + "-L" + (w.end ?? ""));
+        const text = sanitizeContent(typeof w.text === "string" ? w.text : "");
+        for (const line of text.split("\n").slice(0, 80))
+            out.push(line);
+    }
+    if (windows.length > 8)
+        out.push("… " + (windows.length - 8) + " more windows");
+    return out.join("\n");
+}
+/**
+ * Model-facing result text is deliberately lean: the tool call already carries
+ * the query/mode, the TUI card renders timing and backend for the human, and
+ * every token here is re-sent with the whole transcript. The first line is the
+ * only chrome: "<command>: <payload summary>".
+ */
+export function formatSearchResult(response, meta, theme) {
+    const hits = Array.isArray(response.hits) ? response.hits : [];
+    // Capsules carry an excerpt whether or not the caller asked; render it only
+    // when they did, or every defs/imports answer pays for body text nobody
+    // requested (measured: 2.5k tokens of unasked-for excerpts before the guard).
+    const excerptBudget = Math.max(0, Math.min(meta.excerptLines ?? 0, MAX_EXCERPT_LINES_OUT));
+    let excerptLinesLeft = excerptBudget * Math.min(hits.length, MAX_HIT_ROWS);
+    const rows = [`${meta.command}: ${hits.length} hit${hits.length === 1 ? "" : "s"}`];
+    for (const hit of hits.slice(0, MAX_HIT_ROWS)) {
+        const loc = hitLocation(hit);
+        const label = hitLabel(hit);
+        // Single-space fields: same payload, fewer tokens per row, and every row
+        // is re-sent with the transcript on each turn.
+        rows.push(label ? `  ${loc} ${label}` : `  ${loc}`);
+        // Body excerpts only exist when the caller asked for them (excerptLines);
+        // they used to be dropped here, so asking cost nothing and returned less.
+        const excerpt = hit.excerpt;
+        if (excerptLinesLeft > 0 && typeof excerpt === "string" && excerpt.trim() !== "") {
+            for (const line of sanitizeContent(excerpt).split("\n")) {
+                if (excerptLinesLeft === 0)
+                    break;
+                if (line.trim() === "")
+                    continue;
+                rows.push("    " + line.replace(/\s+$/u, ""));
+                excerptLinesLeft -= 1;
+            }
+        }
+    }
+    if (hits.length === 0) {
+        // A chain answer is nodes+edges, not hits: depth, site, symbol per row.
+        const nodes = Array.isArray(response.nodes)
+            ? (response.nodes)
+            : [];
+        if (nodes.length > 0) {
+            rows[0] = `${meta.command}: ${nodes.length} nodes`;
+            for (const node of nodes.slice(0, 24)) {
+                const file = sanitizeContent(typeof node.file === "string" ? node.file : "?");
+                const line = typeof node.line_start === "number" ? ":" + node.line_start : "";
+                const depth = typeof node.depth === "number" ? "d" + node.depth + " " : "";
+                const symbol = typeof node.symbol === "string" ? " " + sanitizeContent(node.symbol) : "";
+                rows.push(`  ${depth}${file}${line}${symbol}`);
+            }
+            return rows.join("\n");
+        }
+        const next = Array.isArray(response.suggested_next)
+            ? response.suggested_next.filter((item) => typeof item === "string")
+            : [];
+        for (const query of next.slice(0, 3))
+            rows.push(`  try: ${sanitizeContent(query)}`);
+    }
+    if (hits.length > 24)
+        rows.push(`  … ${hits.length - 24} more`);
+    return rows.join("\n");
+}
+export function formatStatusResult(response, theme) {
+    const state = typeof response.status === "string" ? response.status
+        : typeof response.index_status === "string" ? response.index_status
+            : response.ok ? "ok" : "failed";
+    const counts = response.counts && typeof response.counts === "object"
+        ? Object.entries(response.counts).map(([key, value]) => `${key}=${String(value)}`).join(" ")
+        : "";
+    const backend = typeof response.backend === "string" ? response.backend : "";
+    return ["status: " + state, counts, backend].filter(Boolean).join(" ");
+}
+export function formatIndexResult(command, response, theme) {
+    const count = typeof response.count === "number" ? response.count
+        : typeof response.total === "number" ? response.total
+            : typeof response.files_indexed === "number" ? response.files_indexed
+                : undefined;
+    return count === undefined ? `${command}: done` : `${command}: ${count} file${count === 1 ? "" : "s"}`;
+}
+/** Longest escape sequence we will skip as a unit; longer runs are treated as
+ * text so an unterminated sequence cannot swallow the rest of a line. */
+const MAX_ESCAPE_LENGTH = 512;
+/**
+ * Length of the terminal escape starting at `index`, or 0 when there is none.
+ *
+ * A lone or unterminated ESC measures zero and everything after it is text,
+ * which is what pi does (measured: "\u001b[31" is three cells, ESC included as
+ * zero). Skipping unterminated sequences whole would under-count, and pi kills
+ * the process for any rendered line wider than the terminal.
+ */
+function ansiLengthAt(text, index) {
+    if (text.charCodeAt(index) !== 0x1b)
+        return 0;
+    const limit = Math.min(text.length, index + MAX_ESCAPE_LENGTH);
+    const next = text[index + 1];
+    if (next === "[") {
+        for (let cursor = index + 2; cursor < limit; cursor += 1) {
+            const code = text.charCodeAt(cursor);
+            if (code >= 0x40 && code <= 0x7e)
+                return cursor - index + 1;
+        }
+        return 1;
+    }
+    if (next === "]") {
+        for (let cursor = index + 2; cursor < limit; cursor += 1) {
+            if (text.charCodeAt(cursor) === 0x07)
+                return cursor - index + 1;
+            if (text.charCodeAt(cursor) === 0x1b && text[cursor + 1] === "\\")
+                return cursor - index + 2;
+        }
+        return 1;
+    }
+    if (next === "P" || next === "X" || next === "^" || next === "_") {
+        for (let cursor = index + 2; cursor < limit; cursor += 1) {
+            if (text.charCodeAt(cursor) === 0x1b && text[cursor + 1] === "\\")
+                return cursor - index + 2;
+        }
+        return 1;
+    }
+    return 1;
+}
+/**
+ * Strip terminal control sequences and C0/C1 controls from untrusted content
+ * (tool output, code windows, paths) before this extension paints it. Without
+ * this a stray ESC in a file would sit inside our own SGR span, leaving an
+ * unterminated color and mis-measuring the row's width.
+ */
+export function sanitizeContent(text) {
+    let out = "";
+    for (let index = 0; index < text.length;) {
+        const ansi = ansiLengthAt(text, index);
+        if (ansi > 0) {
+            index += ansi;
+            continue;
+        }
+        const code = text.charCodeAt(index);
+        if (code === 0x09 || code === 0x0a || (code >= 0x20 && code !== 0x7f && !(code >= 0x80 && code <= 0x9f))) {
+            out += text[index];
+        }
+        index += 1;
+    }
+    return out;
+}
+/**
+ * Chrome glyphs this extension draws itself. Pi measures every one of them as a
+ * single cell (verified against `visibleWidth` from @earendil-works/pi-tui), so
+ * frame geometry can stay exact while everything else rounds UP.
+ */
+const ONE_CELL_CHROME = /^[\u00b7\u00d7\u2022\u2026\u2192\u23f5\u23f8\u2500-\u257f\u25a0-\u25cf\u2591-\u2593\u26d3\u2713\u2714\u2717\u276f\u2588]$/u;
+/**
+ * Conservative display width on pi's scale: never under-counts what pi measures.
+ *
+ * Pi expands tabs to three spaces and measures grapheme clusters with East Asian
+ * Width (CJK/fullwidth/emoji = 2); lone combining marks, variation selectors and
+ * joiners are zero there. Re-deriving that table here would be a second source of
+ * truth that can drift, so this counts only what the card itself draws exactly
+ * (one cell) and rounds every other non-ASCII code point UP to two. A line that
+ * measures `width` here is therefore at most `width` in the terminal: over-counting
+ * can only leave slack before the right border, while under-counting is what pi
+ * kills the process for ("Rendered line N exceeds terminal width").
+ */
+export function displayWidth(text) {
+    let width = 0;
+    for (let index = 0; index < text.length;) {
+        const ansi = ansiLengthAt(text, index);
+        if (ansi > 0) {
+            index += ansi;
+            continue;
+        }
+        const cell = cellWidthAt(text, index);
+        width += cell.width;
+        index += cell.length;
+    }
+    return width;
+}
+function cellWidthAt(text, index) {
+    const code = text.charCodeAt(index);
+    if (code === 0x09)
+        return { width: 3, length: 1 };
+    if (code <= 0x1f || (code >= 0x7f && code <= 0x9f))
+        return { width: 0, length: 1 };
+    if (code <= 0x7e)
+        return { width: 1, length: 1 };
+    if (code >= 0xd800 && code <= 0xdbff)
+        return { width: 2, length: 2 };
+    if (ONE_CELL_CHROME.test(text[index] ?? ""))
+        return { width: 1, length: 1 };
+    return { width: 2, length: 1 };
+}
+/** Local stand-in so we do not take a pi-tui dependency. Over-counts wide glyphs rather than under-count. */
+export function visibleWidth(text) {
+    return displayWidth(text);
+}
+export function truncateToWidth(text, maxWidth, ellipsis = "...") {
+    const limit = Math.max(0, maxWidth);
+    if (limit <= 0)
+        return "";
+    if (visibleWidth(text) <= limit)
+        return text;
+    const ellipsisWidth = visibleWidth(ellipsis);
+    if (ellipsisWidth >= limit)
+        return ellipsis.slice(0, limit);
+    const budget = limit - ellipsisWidth;
+    let kept = "";
+    let width = 0;
+    for (let index = 0; index < text.length;) {
+        const ansi = ansiLengthAt(text, index);
+        if (ansi > 0) {
+            kept += text.slice(index, index + ansi);
+            index += ansi;
+            continue;
+        }
+        const cell = cellWidthAt(text, index);
+        if (width + cell.width > budget)
+            break;
+        kept += text.slice(index, index + cell.length);
+        width += cell.width;
+        index += cell.length;
+    }
+    // The cut can land inside a painted span — its closing SGR is past the
+    // budget, so the ellipsis and everything after would inherit the open color.
+    // Close it explicitly; harmless when the kept spans were already balanced.
+    return kept + (kept.includes("\u001b[") ? "\u001b[0m" : "") + ellipsis;
+}
+/** Wire-envelope fields that describe the transport, not the answer. Showing
+ * them turns a one-line answer into a JSON dump of our own protocol. */
+const TRANSPORT_KEYS = new Set([
+    "tool",
+    "command",
+    "schema_version",
+    "ok",
+    "ref",
+    "refs",
+    "index_path",
+    "expand_hint",
+    "snapshot",
+    "backend",
+    "wall_ms",
+    "exit_code",
+    "prevented_read_bytes",
+    "read_bytes_estimate",
+    "returned_excerpt_bytes",
+]);
+/**
+ * One summary line per interesting entry of a shaped value: known shapes get a
+ * sentence ("3 windows · path:1-340"), everything else `key: value` with the
+ * value compacted. Transport fields are dropped rather than rendered.
+ */
+export function summarizeValue(value, limit = 4) {
+    if (value === null || value === undefined || typeof value !== "object" || Array.isArray(value)) {
+        return [compactValue(value)];
+    }
+    const recordValue = value;
+    const rows = [];
+    const hits = Array.isArray(recordValue.hits) ? recordValue.hits : undefined;
+    const windows = Array.isArray(recordValue.windows)
+        ? recordValue.windows
+        : undefined;
+    if (hits)
+        rows.push(hits.length + " hit" + (hits.length === 1 ? "" : "s"));
+    if (windows && windows.length > 0) {
+        const first = windows[0] ?? {};
+        const where = typeof first.path === "string" ? sanitizeContent(first.path) : "";
+        const range = typeof first.start === "number"
+            ? ":" + first.start + (typeof first.end === "number" ? "-" + first.end : "")
+            : "";
+        rows.push(windows.length + " window" + (windows.length === 1 ? "" : "s") + (where ? " · " + where + range : ""));
+    }
+    for (const [key, entry] of Object.entries(recordValue)) {
+        if (rows.length >= limit)
+            break;
+        if (TRANSPORT_KEYS.has(key))
+            continue;
+        if (hits && key === "hits")
+            continue;
+        if (windows && (key === "windows" || key === "count"))
+            continue;
+        rows.push(key + ": " + compactValue(entry));
+    }
+    return rows;
+}
+function compactValue(value) {
+    if (value === null || value === undefined)
+        return String(value);
+    if (typeof value !== "object")
+        return sanitizeContent(String(value));
+    if (Array.isArray(value))
+        return `${value.length} item${value.length === 1 ? "" : "s"}`;
+    const json = JSON.stringify(value);
+    return json.length <= 80 ? json : `${json.slice(0, 79)}…`;
+}
+export function formatCodemodeResult(value, meta = {}, theme) {
+    if (value && typeof value === "object" && Array.isArray(value.hits)) {
+        const searchMeta = { command: "codemode" };
+        if (meta.wallMs !== undefined)
+            searchMeta.activationMs = meta.wallMs;
+        if (meta.backend !== undefined)
+            searchMeta.backend = meta.backend;
+        return formatSearchResult(value, searchMeta, theme);
+    }
+    const bits = [];
+    if (value && typeof value === "object") {
+        const record = value;
+        if (typeof record.hit_count === "number")
+            bits.push(`${record.hit_count} hit${record.hit_count === 1 ? "" : "s"}`);
+        else if (typeof record.node_count === "number")
+            bits.push(`${record.node_count} node${record.node_count === 1 ? "" : "s"}`);
+    }
+    if (meta.stats && meta.stats.calls > 0) {
+        bits.push(`${meta.stats.calls} call${meta.stats.calls === 1 ? "" : "s"}`);
+        if (meta.stats.waves > 1)
+            bits.push(`${meta.stats.waves} waves`);
+    }
+    // Backend and wall time are display concerns: the card renders them, the
+    // transcript does not need them repeated on every call.
+    const title = "codemode" + (bits.length > 0 ? ": " + bits.join(" ") : "");
+    if (value === undefined) {
+        return `${title}\n${paint(theme, "muted", "  (no return statement; add `return` to send a value to the model)")}`;
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        // The program's own return shape is a deliberate choice: summarize it
+        // wider than a hit preview, or the model has to re-run to see its value.
+        const rows = summarizeValue(value, 12).map((row) => paint(theme, "toolOutput", `  ${row}`));
+        return [title, ...rows].join("\n");
+    }
+    if (Array.isArray(value)) {
+        return [title, paint(theme, "toolOutput", `  ${value.length} value${value.length === 1 ? "" : "s"}`)].join("\n");
+    }
+    return `${title}\n${paint(theme, "toolOutput", `  ${compactValue(value)}`)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ast-sgrep",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "description": "Native Code Mode, structural, graph, and semantic code search for Pi",
   "type": "module",
   "license": "MIT",
@@ -36,8 +36,8 @@
       "import": "./dist/index.js"
     },
     "./runtime": {
-      "types": "./dist/runtime.d.ts",
-      "import": "./dist/runtime.js"
+      "types": "./dist/runtime/runtime.d.ts",
+      "import": "./dist/runtime/runtime.js"
     },
     "./code-mode": {
       "types": "./dist/code-mode.d.ts",
@@ -51,18 +51,19 @@
     "image": "./assets/preview.png"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node scripts/copy-guest-worker.mjs",
     "build:native": "cargo build -p ast-sgrep-codemode-napi --release && node ./scripts/copy-native.mjs",
-    "test": "ASGREP_CODEMODE_BACKEND=cli node --import tsx --test ../../../tests/pi/extension/code-mode.test.ts ../../../tests/pi/extension/codemode.test.ts ../../../tests/pi/extension/commands.test.ts ../../../tests/pi/extension/present.test.ts ../../../tests/pi/extension/runtime.test.ts ../../../tests/pi/extension/security.test.ts ../../../tests/pi/extension/session-pool.test.ts ../../../tests/pi/extension/skill-workflow.test.ts ../../../tests/pi/extension/tools.test.ts",
+    "test": "ASGREP_CODEMODE_BACKEND=cli node --import tsx --test ../../../tests/pi/extension/code-mode.test.ts ../../../tests/pi/extension/codemode.test.ts ../../../tests/pi/extension/commands.test.ts ../../../tests/pi/extension/present.test.ts ../../../tests/pi/extension/runtime.test.ts ../../../tests/pi/extension/security.test.ts ../../../tests/pi/extension/session-pool.test.ts ../../../tests/pi/extension/skill-workflow.test.ts ../../../tests/pi/extension/sqlite.test.ts ../../../tests/pi/extension/../../../tests/pi/extension/token-budget.test.ts ../../../tests/pi/extension/tools.test.ts",
     "test:native": "node --import tsx --test ../../../tests/pi/extension/native-inprocess.test.ts",
     "test:all": "npm test && npm run test:native",
-    "prepack": "npm run build"
+    "prepack": "npm run build",
+    "bench:p100": "node scripts/p100-bench.mjs"
   },
   "engines": {
     "node": ">=22.19.0"
   },
   "dependencies": {
-    "ast-sgrep": "2.0.0",
+    "ast-sgrep": ">=2.1.0 <3",
     "typebox": "^1.0.0"
   },
   "peerDependencies": {

package/dist/codemode/sandbox-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/codemode/sandbox-worker.js

@@ -1,204 +0,0 @@
-import vm from "node:vm";
-import { parentPort, workerData } from "node:worker_threads";
-const port = (() => {
-    if (!parentPort)
-        throw new Error("codemode sandbox requires a parent port");
-    return parentPort;
-})();
-const data = workerData;
-const pending = new Map();
-const outgoing = [];
-let nextCallId = 0;
-let flushScheduled = false;
-port.on("message", (message) => {
-    if (message.type !== "callResult")
-        return;
-    const resolve = pending.get(message.id);
-    if (!resolve)
-        return;
-    pending.delete(message.id);
-    resolve(message.payload);
-});
-const bridge = (method, payload) => new Promise((resolve) => {
-    if (nextCallId >= data.limits.bridgeCalls) {
-        resolve(JSON.stringify({
-            ok: false,
-            error: `codemode exceeds ${data.limits.bridgeCalls} host calls`,
-        }));
-        return;
-    }
-    const id = nextCallId++;
-    pending.set(id, resolve);
-    outgoing.push({ id, method, payload });
-    if (!flushScheduled) {
-        flushScheduled = true;
-        queueMicrotask(() => {
-            flushScheduled = false;
-            const calls = outgoing.splice(0);
-            if (calls.length > 0)
-                port.postMessage({ type: "calls", calls });
-        });
-    }
-});
-void run();
-async function run() {
-    const logs = [];
-    let logChars = 0;
-    const logBridge = (line) => {
-        if (logs.length >= data.limits.logLines || logChars >= data.limits.logChars)
-            return;
-        const remaining = data.limits.logChars - logChars;
-        const bounded = line.length <= remaining
-            ? line
-            : `${line.slice(0, Math.max(0, remaining - 1))}…`;
-        logs.push(bounded);
-        logChars += bounded.length;
-    };
-    Object.setPrototypeOf(bridge, null);
-    Object.setPrototypeOf(logBridge, null);
-    Object.freeze(bridge);
-    Object.freeze(logBridge);
-    try {
-        const globals = Object.create(null);
-        globals.__asgrepBridge = bridge;
-        globals.__asgrepLog = logBridge;
-        const context = vm.createContext(globals, {
-            codeGeneration: { strings: false, wasm: false },
-        });
-        new vm.Script(bootstrap(data.limits), {
-            filename: "asgrep-codemode-bootstrap.js",
-        }).runInContext(context, { timeout: Math.min(data.timeoutMs, 1_000) });
-        const script = new vm.Script(data.code, { filename: "asgrep-codemode.js" });
-        const value = await Promise.resolve(script.runInContext(context, {
-            displayErrors: true,
-            timeout: data.timeoutMs,
-        }));
-        const setResult = context.__asgrepSetResult;
-        if (typeof setResult !== "function") {
-            throw new Error("codemode result bridge is unavailable");
-        }
-        setResult(value);
-        const serialized = new vm.Script("globalThis.__asgrepSerializeResult()", {
-            filename: "asgrep-codemode-result.js",
-        }).runInContext(context, {
-            displayErrors: true,
-            timeout: Math.min(data.timeoutMs, data.limits.serializeTimeoutMs),
-        });
-        const result = serialized === undefined ? undefined : JSON.parse(serialized);
-        finish({ type: "done", ok: true, result, logs });
-    }
-    catch (cause) {
-        finish({
-            type: "done",
-            ok: false,
-            error: safeErrorMessage(cause).slice(0, data.limits.errorChars),
-            logs,
-        });
-    }
-}
-function safeErrorMessage(cause) {
-    try {
-        return String(cause instanceof Error ? cause.message : cause);
-    }
-    catch {
-        return "codemode worker failed";
-    }
-}
-function finish(message) {
-    port.postMessage(message);
-    port.close();
-}
-function bootstrap(limits) {
-    return `
-  {
-    const hostCall = globalThis.__asgrepBridge;
-    const hostLog = globalThis.__asgrepLog;
-    delete globalThis.__asgrepBridge;
-    delete globalThis.__asgrepLog;
-
-    let resultValue;
-    const setResult = (value) => { resultValue = value; };
-    const stringify = JSON.stringify;
-    const stringifyBounded = (value, maxChars, label) => {
-      let remaining = maxChars;
-      const serialized = stringify(value, (key, item) => {
-        remaining -= key.length + 8;
-        if (typeof item === "string") remaining -= item.length;
-        if (remaining < 0) throw new Error(\`codemode \${label} exceeds \${maxChars} characters\`);
-        return item;
-      });
-      if (serialized !== undefined && serialized.length > maxChars) {
-        throw new Error(\`codemode \${label} exceeds \${maxChars} characters\`);
-      }
-      return serialized;
-    };
-    const serializeResult = () => stringifyBounded(resultValue, ${limits.resultJsonChars}, "result");
-    Object.freeze(setResult);
-    Object.freeze(serializeResult);
-    Object.defineProperty(globalThis, "__asgrepSetResult", {
-      value: setResult, configurable: false, writable: false,
-    });
-    Object.defineProperty(globalThis, "__asgrepSerializeResult", {
-      value: serializeResult, configurable: false, writable: false,
-    });
-
-    // Worker heap limits do not reliably account for backing stores. Code Mode
-    // exchanges JSON, so raw-memory and WebAssembly APIs add risk without utility.
-    for (const name of [
-      "ArrayBuffer", "SharedArrayBuffer", "DataView", "Atomics", "WebAssembly",
-      "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array",
-      "Int32Array", "Uint32Array", "Float32Array", "Float64Array",
-      "BigInt64Array", "BigUint64Array",
-    ]) {
-      Object.defineProperty(globalThis, name, {
-        value: undefined, configurable: false, writable: false,
-      });
-    }
-
-    const invoke = async (method, args = {}) => {
-      const payload = stringifyBounded(args, ${limits.bridgeRequestChars}, "call arguments");
-      const response = JSON.parse(await hostCall(method, payload));
-      if (!response.ok) throw new Error(response.error || \`asgrep.\${method} failed\`);
-      return response.value;
-    };
-    const api = Object.create(null);
-    for (const method of [
-      "search", "semantic", "chain", "defs", "callers", "imports",
-      "indexStatus", "indexRepo", "catalogSearch", "catalogDescribe",
-    ]) {
-      Object.defineProperty(api, method, {
-        enumerable: true,
-        value: (args = {}) => invoke(method, args),
-      });
-    }
-    Object.freeze(api);
-
-    const formatLog = (value) => {
-      if (typeof value === "string") return value.slice(0, ${limits.logLineChars});
-      try { return stringifyBounded(value, ${limits.logLineChars}, "log line"); }
-      catch { return "[unserializable or oversized log value]"; }
-    };
-    const consoleApi = Object.create(null);
-    for (const level of ["log", "info", "warn", "error", "debug"]) {
-      Object.defineProperty(consoleApi, level, {
-        enumerable: true,
-        value: (...args) => {
-          let line = "";
-          for (const arg of args) {
-            const part = formatLog(arg);
-            const prefix = line.length === 0 ? "" : " ";
-            const remaining = ${limits.logLineChars} - line.length;
-            if (remaining <= 0) break;
-            line += (prefix + part).slice(0, remaining);
-          }
-          hostLog(line);
-        },
-      });
-    }
-    Object.freeze(consoleApi);
-
-    Object.defineProperty(globalThis, "asgrep", { value: api, configurable: false, writable: false });
-    Object.defineProperty(globalThis, "console", { value: consoleApi, configurable: false, writable: false });
-  }
-  `;
-}