@giovannijecha/jecode 0.8.4 → 0.8.6

package/dist/tui/turn.js

@@ -3,17 +3,14 @@
 // The controller speaks in stream events and tool results; the screen speaks in
 // blocks. This is the whole of the translation, kept out of the shell so that
 // neither has to know how the other is built.
-import { graphemes } from "../text-boundary.js";
-import { condense, diff } from "../ui/diff.js";
 import { promptFor } from "./approve.js";
+import { toolTarget, previewDetails, producedDetails, outputDetails } from "./tool-details.js";
 // Semantic activity labels feed the footer's compact state and timer while
 // reasoning and tools keep the detailed work visible in the transcript.
 const WAITING = "Waiting";
 const THINKING = "Thinking";
 const RESPONDING = "Responding";
 const ASKING = "Waiting for you";
-/** Unchanged rows kept either side of a change. */
-const CONTEXT = 2;
 export function transcribe(stage) {
     // The block the stream is currently filling. A change of kind starts a new
     // one, which is what keeps reasoning and answer from running together.
@@ -104,10 +101,10 @@ export function transcribe(stage) {
             const block = {
                 kind: "tool",
                 name: call.name,
-                target: target(call.input),
+                target: toolTarget(call.input),
                 right: "ready",
                 tone: "pending",
-                body: preview(call, look),
+                body: previewDetails(call, look),
             };
             tools.set(call.id, block);
             stage.emit(block);
@@ -117,7 +114,7 @@ export function transcribe(stage) {
             const block = tools.get(call.id);
             if (block === undefined || block.kind !== "tool" || block.tone !== "pending")
                 return;
-            block.body = details(output, "out");
+            block.body = outputDetails(output, "out");
             stage.render(block);
         },
         onToolResult(call, result, summary) {
@@ -138,8 +135,8 @@ export function transcribe(stage) {
             // A failure replaces the preview: what the call was going to do stops
             // being the interesting part the moment it did not do it.
             const outcome = result.isError
-                ? details(result.output, "out")
-                : produced(call, result.output);
+                ? outputDetails(result.output, "out")
+                : producedDetails(call, result.output);
             if (outcome !== undefined)
                 block.body = outcome;
             stage.render(block);
@@ -158,7 +155,7 @@ export function transcribe(stage) {
                 stage.render(block);
             }
             return new Promise((resolve) => {
-                stage.ask(promptFor(call, target(call.input), stage.palette), (answer) => {
+                stage.ask(promptFor(call, toolTarget(call.input), stage.palette), (answer) => {
                     if (answer === "always")
                         stage.remember(call);
                     const approved = answer !== "no";
@@ -204,133 +201,3 @@ function settleDuration(block) {
     }
     block.startedAt = undefined;
 }
-/** The argument worth showing: the thing the call acts on. */
-function target(input) {
-    const { path, command } = input;
-    if (typeof command === "string")
-        return command;
-    if (typeof path === "string")
-        return path;
-    const rest = JSON.stringify(input);
-    return rest === "{}" ? "" : rest;
-}
-/**
- * What the call is about to do, drawn before it is allowed to do it.
- *
- * The tool is asked first, because only it knows what is already on disk: a
- * write against an existing file is a replacement, and showing it as a page of
- * additions hides exactly the part worth approving. The fallback diffs what is
- * in the arguments, which is all there is when a tool has nothing to say.
- */
-function preview(call, look) {
-    if (look !== undefined)
-        return changes(look.before, look.after);
-    const input = call.input;
-    if (call.name === "write_file" && typeof input.content === "string") {
-        return changes("", input.content);
-    }
-    if (call.name === "edit_file" && typeof input.old_text === "string") {
-        return changes(input.old_text, typeof input.new_text === "string" ? input.new_text : "");
-    }
-    return undefined;
-}
-/** Two texts as the rows of their difference, unchanged runs summed up. */
-function changes(before, after) {
-    let oldLine = 1;
-    let newLine = 1;
-    const rows = [];
-    for (const changed of condense(diff(before, after), CONTEXT)) {
-        if (changed.kind === "gap") {
-            rows.push({ kind: "gap", text: `… ${changed.skipped} unchanged` });
-            oldLine += changed.skipped;
-            newLine += changed.skipped;
-            continue;
-        }
-        if (changed.kind === "keep") {
-            rows.push({ kind: "keep", text: tabs(changed.text), oldLine, newLine });
-            oldLine++;
-            newLine++;
-            continue;
-        }
-        if (changed.kind === "del") {
-            rows.push({ kind: "del", text: tabs(changed.text), oldLine });
-            oldLine++;
-            continue;
-        }
-        rows.push({ kind: "add", text: tabs(changed.text), newLine });
-        newLine++;
-    }
-    emphasizePairs(rows);
-    return rows.length === 0 ? undefined : rows;
-}
-function emphasizePairs(rows) {
-    for (let index = 0; index < rows.length - 1; index++) {
-        const removed = rows[index];
-        const added = rows[index + 1];
-        if (removed?.kind !== "del" || added?.kind !== "add")
-            continue;
-        if (rows[index - 1]?.kind === "del" || rows[index + 2]?.kind === "add")
-            continue;
-        const removedClusters = graphemes(removed.text);
-        const addedClusters = graphemes(added.text);
-        let prefix = 0;
-        let start = 0;
-        while (prefix < removedClusters.length &&
-            prefix < addedClusters.length &&
-            removedClusters[prefix] === addedClusters[prefix]) {
-            start += removedClusters[prefix].length;
-            prefix++;
-        }
-        let suffix = 0;
-        let removedSuffix = 0;
-        let addedSuffix = 0;
-        while (suffix < removedClusters.length - prefix &&
-            suffix < addedClusters.length - prefix &&
-            removedClusters[removedClusters.length - 1 - suffix] ===
-                addedClusters[addedClusters.length - 1 - suffix]) {
-            removedSuffix += removedClusters[removedClusters.length - 1 - suffix].length;
-            addedSuffix += addedClusters[addedClusters.length - 1 - suffix].length;
-            suffix++;
-        }
-        while (suffix > 0 &&
-            (!wordBoundary(removed.text, removedSuffix) || !wordBoundary(added.text, addedSuffix))) {
-            removedSuffix -= removedClusters[removedClusters.length - suffix].length;
-            addedSuffix -= addedClusters[addedClusters.length - suffix].length;
-            suffix--;
-        }
-        const removedLength = removed.text.length - start - removedSuffix;
-        const addedLength = added.text.length - start - addedSuffix;
-        if (removedLength > 0)
-            removed.emphasis = { start, length: removedLength };
-        if (addedLength > 0)
-            added.emphasis = { start, length: addedLength };
-    }
-}
-function wordBoundary(text, suffix) {
-    const at = text.length - suffix;
-    if (at <= 0 || at >= text.length)
-        return true;
-    return /\w/.test(text[at - 1]) !== /\w/.test(text[at]);
-}
-/** What the call left behind, for the calls whose output is worth a look. */
-function produced(call, output) {
-    if (call.name === "run_command")
-        return details(output, "out");
-    // A read or a listing is already summed up on the right of its own row, and
-    // the model is about to say what was in it. Printing it twice helps nobody.
-    return undefined;
-}
-function details(text, kind) {
-    const rows = split(text).map((line) => ({ kind, text: tabs(line) }));
-    return rows.length === 0 ? undefined : rows;
-}
-function split(text) {
-    const lines = text.replace(/\r\n?/g, "\n").split("\n");
-    while (lines.length > 0 && lines[lines.length - 1] === "")
-        lines.pop();
-    return lines.map(tabs);
-}
-// A tab is a width the terminal decides and the row measurement cannot see.
-function tabs(line) {
-    return line.replace(/\t/g, "  ");
-}

package/dist/tui/workflow-types.js

@@ -0,0 +1,2 @@
+// Host capabilities shared by foreground command and turn workflows.
+export {};

package/dist/tui/workspace.js

@@ -1,7 +1,10 @@
 // Compact workspace identity for the persistent footer.
-import { readFile, stat } from "node:fs/promises";
+import { lstat } from "node:fs/promises";
 import { homedir } from "node:os";
 import * as path from "node:path";
+import { readBoundedText, stableFileExpectation } from "../bounded-file.js";
+import { assertDirectoryAnchor, captureDirectDirectory, } from "../directory-anchor.js";
+const MAX_GIT_POINTER_BYTES = 4_096;
 export async function workspaceLabel(root) {
     const shown = displayRoot(root);
     const branch = await findBranch(root);
@@ -30,16 +33,24 @@ async function findBranch(root) {
 async function branchAt(directory) {
     const marker = path.join(directory, ".git");
     try {
-        const info = await stat(marker);
-        if (info.isDirectory())
-            return readHead(marker);
+        const info = await lstat(marker, { bigint: true });
+        if (info.isSymbolicLink())
+            return undefined;
+        if (info.isDirectory()) {
+            const gitDirectory = await captureDirectDirectory(marker, "Git directory");
+            return readHead(gitDirectory);
+        }
         if (!info.isFile())
             return undefined;
-        const pointer = await readFile(marker, "utf8");
+        const pointer = await readBoundedText(marker, MAX_GIT_POINTER_BYTES, {
+            label: "Git directory pointer",
+            expected: stableFileExpectation(info),
+        });
         const match = /^gitdir:\s*(.+)\s*$/im.exec(pointer);
         if (match === null)
             return undefined;
-        return readHead(path.resolve(directory, match[1]));
+        const gitDirectory = await captureDirectDirectory(path.resolve(directory, match[1]), "Git directory");
+        return readHead(gitDirectory);
     }
     catch {
         return undefined;
@@ -47,7 +58,10 @@ async function branchAt(directory) {
 }
 async function readHead(gitDirectory) {
     try {
-        const head = (await readFile(path.join(gitDirectory, "HEAD"), "utf8")).trim();
+        const head = (await readBoundedText(path.join(gitDirectory.path, "HEAD"), MAX_GIT_POINTER_BYTES, {
+            label: "Git HEAD",
+            validate: async () => assertDirectoryAnchor(gitDirectory),
+        })).trim();
         const prefix = "ref: refs/heads/";
         if (head.startsWith(prefix))
             return head.slice(prefix.length);

package/dist/user-store.js

@@ -1,6 +1,7 @@
 // Bounded synchronous reads for the tiny JSON stores under ~/.jecode.
 import { Buffer } from "node:buffer";
-import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+import { readBoundedFileSync } from "./bounded-file.js";
+import { assertDirectoryAnchorSync } from "./directory-anchor.js";
 export const USER_STORE_LIMITS = Object.freeze({
     settingsBytes: 64 * 1_024,
     credentialsBytes: 256 * 1_024,
@@ -13,38 +14,29 @@ export const USER_STORE_LIMITS = Object.freeze({
     accountToken: 32_768,
     accountLabel: 1_024,
 });
-export function readBoundedJsonSync(file, maxBytes) {
-    // Non-blocking open keeps a replaced FIFO or device from stalling startup;
-    // fstat below then accepts only regular files before any content is read.
-    const flags = process.platform === "win32"
-        ? "r"
-        : constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
-    const descriptor = openSync(file, flags);
+export function readBoundedJsonSync(file, maxBytes, directory) {
+    const validate = directory === undefined
+        ? undefined
+        : () => assertDirectoryAnchorSync(directory);
+    return JSON.parse(readBoundedFileSync(file, maxBytes, {
+        label: "user store",
+        validate,
+    }).toString("utf8"));
+}
+export function readBoundedJsonForMutationSync(file, maxBytes, label, directory) {
     try {
-        const details = fstatSync(descriptor);
-        if (!details.isFile())
-            throw new Error("user store must be a regular file");
-        if (!Number.isSafeInteger(details.size) || details.size > maxBytes) {
-            throw new Error(`user store exceeds ${maxBytes} bytes`);
-        }
-        // One extra byte detects an in-place growth after fstat without allowing
-        // the read allocation to follow the file's new size.
-        const capacity = Math.min(maxBytes + 1, Math.max(1, details.size + 1));
-        const bytes = Buffer.allocUnsafe(capacity);
-        let offset = 0;
-        while (offset < capacity) {
-            const count = readSync(descriptor, bytes, offset, capacity - offset, null);
-            if (count === 0)
-                break;
-            offset += count;
-        }
-        if (offset > maxBytes || offset > details.size) {
-            throw new Error("user store changed while it was being read");
-        }
-        return JSON.parse(bytes.toString("utf8", 0, offset));
+        const validate = directory === undefined
+            ? undefined
+            : () => assertDirectoryAnchorSync(directory);
+        return JSON.parse(readBoundedFileSync(file, maxBytes, {
+            label: "user store",
+            validate,
+        }).toString("utf8"));
     }
-    finally {
-        closeSync(descriptor);
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw new Error(`${label} is invalid, unsafe, or too large`, { cause: error });
     }
 }
 export function assertStoreText(text, maxBytes) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {
@@ -41,27 +41,26 @@
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build:release": "node dev/build-release.ts",
+    "build:release": "node scripts/build-release.ts",
     "pack:release": "npm run build:release && npm pack --ignore-scripts",
     "start": "node src/main.ts",
-    "tui:lab": "node dev/tui-lab.ts",
-    "bench:context": "node dev/benchmark-context.ts",
-    "bench:redaction": "node dev/benchmark-redaction.ts",
-    "bench:search": "node dev/benchmark-search.ts",
-    "bench:session": "node dev/benchmark-session.ts",
-    "bench:transcript": "node dev/benchmark-transcript.ts",
+    "tui:lab": "node dev/tui/main.ts",
+    "bench:context": "node dev/benchmarks/context.ts",
+    "bench:redaction": "node dev/benchmarks/redaction.ts",
+    "bench:search": "node dev/benchmarks/search.ts",
+    "bench:session": "node dev/benchmarks/session.ts",
+    "bench:transcript": "node dev/benchmarks/transcript.ts",
     "typecheck": "tsc --noEmit",
     "test": "npm run build:release && node --test",
     "coverage": "npm run build:release && node --test --experimental-test-coverage --test-coverage-include=\"src/**/*.ts\" --test-coverage-lines=80 --test-coverage-branches=75 --test-coverage-functions=75",
-    "check:source-tree": "node dev/check-source-tree.ts",
-    "check:release-tag": "node dev/check-release-tag.ts",
-    "check:package": "npm run build:release -- --quiet && node dev/check-package.ts",
-    "check:install": "npm run build:release -- --quiet && node dev/check-installed-cli.ts",
+    "check:source-tree": "node scripts/check-source-tree.ts",
+    "check:release-tag": "node scripts/check-release-tag.ts",
+    "check:package": "npm run build:release -- --quiet && node scripts/check-package.ts",
+    "check:install": "npm run build:release -- --quiet && node scripts/check-installed-cli.ts",
     "check": "npm run check:source-tree && npm run typecheck && npm run coverage && npm run check:package && npm run check:install"
   },
-  "dependencies": {},
   "devDependencies": {
-    "@types/node": "^26.4.0",
-    "typescript": "^5.9.3"
+    "@types/node": "^26.4.1",
+    "typescript": "^7.0.2"
   }
 }

package/dist/ollama-settings-command.js

@@ -1,74 +0,0 @@
-// Ollama connection choices inside the persistent settings hub.
-import { askForKey } from "./credential-commands.js";
-import { keyFor } from "./credentials.js";
-import { of } from "./tui/editor.js";
-import { heading } from "./tui/picker.js";
-import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, parseOllamaEndpoint, } from "./providers/ollama-endpoint.js";
-import { configureOllama, ollamaConnection } from "./providers/ollama.js";
-const KEY = "OLLAMA_API_KEY";
-export function ollamaConnectionHint() {
-    const connection = ollamaConnection();
-    const origin = new URL(connection.baseUrl).host;
-    const automatic = connection.inferred ? " · automatic" : "";
-    if (connection.kind === "local")
-        return `local · this computer${automatic}`;
-    return `${connection.kind} · ${origin}${automatic}`;
-}
-export async function ollamaConnectionSetting(session, host, persist) {
-    if (host.choose === undefined)
-        return;
-    const current = ollamaConnection();
-    const index = await host.choose({
-        title: heading("Ollama connection", "where Ollama requests run", session.palette),
-        options: [
-            { label: "cloud", hint: "ollama.com · API key" },
-            { label: "local", hint: "this computer · no API key" },
-            { label: "custom", hint: "HTTPS or loopback endpoint" },
-        ],
-        index: current.kind === "cloud" ? 0 : current.kind === "local" ? 1 : 2,
-    });
-    if (index === undefined)
-        return;
-    let nextHost;
-    if (index === 0)
-        nextHost = OLLAMA_CLOUD_HOST;
-    else if (index === 1)
-        nextHost = OLLAMA_LOCAL_HOST;
-    else {
-        const custom = await customEndpoint(session, host, current.kind === "custom" ? current.baseUrl : "https://");
-        if (custom === undefined)
-            return;
-        nextHost = custom;
-    }
-    const endpoint = parseOllamaEndpoint(nextHost);
-    if (!endpoint.loopback && keyFor(KEY) === undefined) {
-        const accepted = await askForKey(KEY, host, session.palette);
-        if (!accepted)
-            return;
-    }
-    if (!(await persist({ ollamaHost: endpoint.baseUrl })))
-        return;
-    configureOllama(endpoint.baseUrl);
-    session.config.ollamaHost = endpoint.baseUrl;
-}
-async function customEndpoint(session, host, initial) {
-    if (host.type === undefined)
-        return undefined;
-    const field = {
-        title: heading("Ollama endpoint", "HTTPS or exact loopback URL", session.palette),
-        right: "enter save · esc back",
-        editor: of(initial),
-        secret: false,
-        note: "Remote endpoints must use HTTPS. API keys are stored separately.",
-    };
-    const value = await host.type(field);
-    if (value === undefined)
-        return undefined;
-    try {
-        return parseOllamaEndpoint(value).baseUrl;
-    }
-    catch (error) {
-        host.emit({ kind: "notice", text: error.message, tone: "error" });
-        return undefined;
-    }
-}

package/dist/tools/ripgrep.js

@@ -1,230 +0,0 @@
-// Optional native acceleration for bounded literal search.
-import { spawn } from "node:child_process";
-import * as path from "node:path";
-import { shellEnvironment } from "../credential-safety.js";
-import { resolveExecutable } from "../executable.js";
-const MAX_BATCH_FILES = 256;
-const MAX_BATCH_BYTES = 16_000_000;
-const MAX_COMMAND_CHARS = 12_000;
-const MAX_QUERY_CHARS = 4_000;
-const MAX_EVENT_CHARS = 8_000_000;
-const MAX_STDERR_CHARS = 16_000;
-/** Return undefined when ripgrep is unavailable or cannot preserve the contract. */
-export async function trySearchWithRipgrep(options) {
-    if (options.files.length === 0)
-        return { matches: [], binaryPaths: [] };
-    if (options.query.length > MAX_QUERY_CHARS || options.query.includes("\0"))
-        return undefined;
-    const executable = resolveExecutable("rg", { rejectUnder: options.root });
-    if (executable === undefined)
-        return undefined;
-    const matches = [];
-    const binaryPaths = new Set();
-    try {
-        for (const batch of batches(options.files, options.query.length)) {
-            throwIfAborted(options.signal);
-            const searched = await searchBatch(executable, batch, options);
-            if (searched === undefined)
-                return undefined;
-            for (const match of searched.matches) {
-                if (matches.length >= options.limit)
-                    break;
-                matches.push(match);
-            }
-            for (const file of searched.binaryPaths)
-                binaryPaths.add(file);
-            if (matches.length >= options.limit)
-                break;
-        }
-    }
-    catch (error) {
-        if (options.signal?.aborted === true)
-            throw abortReason(options.signal);
-        return undefined;
-    }
-    return { matches, binaryPaths: [...binaryPaths] };
-}
-function batches(files, queryChars) {
-    const groups = [];
-    let group = [];
-    let bytes = 0;
-    let chars = queryChars;
-    for (const file of files) {
-        const nextChars = chars + file.path.length + 1;
-        if (group.length > 0 &&
-            (group.length >= MAX_BATCH_FILES ||
-                bytes + file.bytes > MAX_BATCH_BYTES ||
-                nextChars > MAX_COMMAND_CHARS)) {
-            groups.push(group);
-            group = [];
-            bytes = 0;
-            chars = queryChars;
-        }
-        group.push(file);
-        bytes += file.bytes;
-        chars += file.path.length + 1;
-    }
-    if (group.length > 0)
-        groups.push(group);
-    return groups;
-}
-function searchBatch(executable, files, options) {
-    throwIfAborted(options.signal);
-    const args = [
-        "--json",
-        "--no-config",
-        "--fixed-strings",
-        "--max-filesize",
-        "1000000",
-        "--max-count",
-        String(options.limit),
-        ...(options.caseSensitive ? [] : ["--ignore-case"]),
-        "--",
-        options.query,
-        ...files.map((file) => file.path),
-    ];
-    return new Promise((resolve, reject) => {
-        let child;
-        try {
-            child = spawn(executable, args, {
-                cwd: path.dirname(executable),
-                env: shellEnvironment(),
-                windowsHide: true,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch {
-            resolve(undefined);
-            return;
-        }
-        const matches = [];
-        const binaryPaths = new Set();
-        let buffered = "";
-        let stderr = "";
-        let invalid = false;
-        let overLimit = false;
-        let settled = false;
-        const onAbort = () => child.kill();
-        options.signal?.addEventListener("abort", onAbort, { once: true });
-        if (options.signal?.aborted === true)
-            onAbort();
-        const finish = (value, error) => {
-            if (settled)
-                return;
-            settled = true;
-            options.signal?.removeEventListener("abort", onAbort);
-            if (error !== undefined)
-                reject(error);
-            else
-                resolve(value);
-        };
-        const consume = (line) => {
-            if (line === "" || invalid || overLimit)
-                return;
-            try {
-                const event = JSON.parse(line);
-                const parsed = ripgrepEvent(event);
-                if (parsed?.kind === "match") {
-                    // `rg --max-count` is per file, not global. Once the raw stream
-                    // exceeds the requested result count, stop the accelerator and let
-                    // the portable scanner produce the exact bounded answer. Returning
-                    // early here would lose the later binary-file end marker.
-                    if (matches.length >= options.limit) {
-                        overLimit = true;
-                        child.kill();
-                        return;
-                    }
-                    matches.push(parsed.match);
-                }
-                if (parsed?.kind === "binary")
-                    binaryPaths.add(parsed.path);
-            }
-            catch {
-                invalid = true;
-                child.kill();
-            }
-        };
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            buffered += chunk;
-            if (buffered.length > MAX_EVENT_CHARS) {
-                invalid = true;
-                child.kill();
-                return;
-            }
-            let newline = buffered.indexOf("\n");
-            while (newline !== -1) {
-                consume(buffered.slice(0, newline));
-                buffered = buffered.slice(newline + 1);
-                newline = buffered.indexOf("\n");
-            }
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr = `${stderr}${chunk}`.slice(-MAX_STDERR_CHARS);
-        });
-        child.on("error", (error) => {
-            if (options.signal?.aborted === true)
-                finish(undefined, abortReason(options.signal));
-            else if (error.code === "ENOENT")
-                finish(undefined);
-            else
-                finish(undefined);
-        });
-        child.on("close", (code) => {
-            if (options.signal?.aborted === true) {
-                finish(undefined, abortReason(options.signal));
-                return;
-            }
-            consume(buffered);
-            if (invalid || overLimit || (code !== 0 && code !== 1) || stderr.trim() !== "") {
-                finish(undefined);
-                return;
-            }
-            const order = new Map(files.map((file, index) => [file.path, index]));
-            finish({
-                matches: matches
-                    .filter((match) => !binaryPaths.has(match.path))
-                    .sort((a, b) => ((order.get(a.path) ?? Number.MAX_SAFE_INTEGER) -
-                    (order.get(b.path) ?? Number.MAX_SAFE_INTEGER) ||
-                    a.line - b.line)),
-                binaryPaths: [...binaryPaths],
-            });
-        });
-    });
-}
-function ripgrepEvent(value) {
-    if (!record(value) || !record(value["data"]))
-        return undefined;
-    const data = value["data"];
-    const file = textField(data["path"]);
-    if (file === undefined)
-        return undefined;
-    if (value["type"] === "match") {
-        const line = data["line_number"];
-        const text = textField(data["lines"]);
-        if (typeof line !== "number" || !Number.isInteger(line) || text === undefined)
-            return undefined;
-        return {
-            kind: "match",
-            match: { path: file, line, text: text.replace(/\r?\n$/, "") },
-        };
-    }
-    if (value["type"] === "end" && typeof data["binary_offset"] === "number") {
-        return { kind: "binary", path: file };
-    }
-    return undefined;
-}
-function textField(value) {
-    return record(value) && typeof value["text"] === "string" ? value["text"] : undefined;
-}
-function record(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function throwIfAborted(signal) {
-    if (signal?.aborted === true)
-        throw abortReason(signal);
-}
-function abortReason(signal) {
-    return signal.reason instanceof Error ? signal.reason : new Error("interrupted");
-}