knodin 0.5.0

package/dist/src/output-compression.js

@@ -0,0 +1,629 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+const DEFAULT_LINE_BUDGET = 200;
+const DEFAULT_BYTE_BUDGET = 16_384;
+const DEFAULT_INPUT_LIMIT = 16 * 1024 * 1024;
+const MAX_INPUT_LIMIT = 64 * 1024 * 1024;
+// JSON escaping can expand a one-byte control character to six bytes.
+const MAX_STORED_ARTIFACT_BYTES = MAX_INPUT_LIMIT * 6 + 1024 * 1024;
+const MAX_LINE_BUDGET = 10_000;
+const MAX_BYTE_BUDGET = 4 * 1024 * 1024;
+const ARTIFACT_ID = /^[a-f0-9]{64}$/;
+const ESCAPE_CODE_POINT = 0x1b;
+const BELL_CODE_POINT = 0x07;
+function validateInteger(name, value, minimum, maximum, fallback) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) || value < minimum || value > maximum)
+        throw new Error(`knodin compress: ${name} must be an integer from ${minimum} to ${maximum}`);
+    return value;
+}
+function normalizeEvents(request) {
+    const hasText = request.text !== undefined;
+    const hasEvents = request.events !== undefined;
+    if (hasText === hasEvents)
+        throw new Error("knodin compress: provide exactly one of text or events");
+    if (hasText)
+        return [{ stream: "combined", text: request.text ?? "" }];
+    if (!Array.isArray(request.events) ||
+        request.events.some((event) => !event ||
+            !["combined", "stdout", "stderr"].includes(event.stream) ||
+            typeof event.text !== "string"))
+        throw new Error("knodin compress: events must contain valid stream/text records");
+    return request.events.map(({ stream, text }) => ({ stream, text }));
+}
+function inputBytes(events) {
+    return events.reduce((total, event) => total + Buffer.byteLength(event.text), 0);
+}
+function boundedInputLimit(value) {
+    return validateInteger("maxInputBytes", value, 1, MAX_INPUT_LIMIT, DEFAULT_INPUT_LIMIT);
+}
+function resolveInputFile(repo, relativePath) {
+    if (!relativePath || path.isAbsolute(relativePath))
+        throw new Error("knodin compress: input file must be a repo-relative path");
+    const resolvedRepo = fs.realpathSync(repo);
+    const lexical = path.resolve(resolvedRepo, relativePath);
+    const lexicalRelative = path.relative(resolvedRepo, lexical);
+    if (lexicalRelative === ".." ||
+        lexicalRelative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(lexicalRelative))
+        throw new Error("knodin compress: input file escapes the repository");
+    if (fs.lstatSync(lexical).isSymbolicLink())
+        throw new Error("knodin compress: refusing symlinked input file");
+    const resolvedFile = fs.realpathSync(lexical);
+    const resolvedRelative = path.relative(resolvedRepo, resolvedFile);
+    if (resolvedRelative === ".." ||
+        resolvedRelative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(resolvedRelative))
+        throw new Error("knodin compress: input file resolves outside the repository");
+    if (!fs.statSync(resolvedFile).isFile())
+        throw new Error("knodin compress: input path is not a regular file");
+    return resolvedFile;
+}
+function splitEvent(event) {
+    const lines = [];
+    let start = 0;
+    let index = 0;
+    while (index < event.text.length) {
+        const character = event.text[index];
+        if (character !== "\r" && character !== "\n") {
+            index++;
+            continue;
+        }
+        const separatorLength = character === "\r" && event.text[index + 1] === "\n" ? 2 : 1;
+        const end = index + separatorLength;
+        lines.push({
+            raw: event.text.slice(start, index),
+            sourceBytes: Buffer.byteLength(event.text.slice(start, end)),
+        });
+        start = end;
+        index = end;
+    }
+    if (start < event.text.length)
+        lines.push({
+            raw: event.text.slice(start),
+            sourceBytes: Buffer.byteLength(event.text.slice(start)),
+        });
+    if (lines.length === 0)
+        lines.push({ raw: "", sourceBytes: 0 });
+    return lines;
+}
+function redact(text) {
+    let count = 0;
+    const replace = (pattern, replacement) => {
+        text = text.replace(pattern, (...values) => {
+            count++;
+            return typeof replacement === "string" ? replacement : replacement(...values);
+        });
+    };
+    replace(/\b(authorization|password|passwd|secret|token|api[_-]?key)\s*([:=])\s*([^\s,;]+)/gi, (_match, name, separator) => `${name}${separator}[REDACTED:credential]`);
+    replace(/\bAKIA[A-Z0-9]{16}\b/g, "[REDACTED:aws-access-key]");
+    replace(/\bgh[pousr]_\w{20,}\b/g, "[REDACTED:github-token]");
+    replace(/\bBearer\s+[-\w.~+/]{12,}=*\b/gi, "Bearer [REDACTED:bearer-token]");
+    replace(/\beyJ[\w-]{8,}\.[\w-]{8,}\.[\w-]{8,}\b/g, "[REDACTED:jwt]");
+    return { text, count };
+}
+function csiSequenceEnd(text, escapeIndex) {
+    for (let index = escapeIndex + 2; index < text.length; index++) {
+        const codePoint = text.codePointAt(index) ?? 0;
+        if (codePoint >= 0x40 && codePoint <= 0x7e)
+            return index + 1;
+    }
+    return null;
+}
+function oscSequenceEnd(text, escapeIndex) {
+    for (let index = escapeIndex + 2; index < text.length; index++) {
+        const codePoint = text.codePointAt(index);
+        if (codePoint === BELL_CODE_POINT)
+            return index + 1;
+        if (codePoint === ESCAPE_CODE_POINT && text[index + 1] === "\\")
+            return index + 2;
+    }
+    return null;
+}
+function ansiSequenceEnd(text, escapeIndex) {
+    const sequenceType = text.codePointAt(escapeIndex + 1);
+    let detectedEnd = null;
+    if (sequenceType === 0x5b)
+        detectedEnd = csiSequenceEnd(text, escapeIndex);
+    else if (sequenceType === 0x5d)
+        detectedEnd = oscSequenceEnd(text, escapeIndex);
+    // Incomplete or unknown escape: drop only ESC so printable diagnostic text
+    // after it is not accidentally discarded.
+    return detectedEnd ?? escapeIndex + 1;
+}
+function sanitizeTerminalText(raw) {
+    let sanitized = "";
+    for (let index = 0; index < raw.length;) {
+        const codePoint = raw.codePointAt(index) ?? 0;
+        if (codePoint === ESCAPE_CODE_POINT) {
+            index = ansiSequenceEnd(raw, index);
+            continue;
+        }
+        const width = codePoint > 0xffff ? 2 : 1;
+        const isControl = codePoint <= 0x08 ||
+            codePoint === 0x0b ||
+            codePoint === 0x0c ||
+            (codePoint >= 0x0e && codePoint <= 0x1f) ||
+            codePoint === 0x7f;
+        sanitized += isControl ? `<0x${codePoint.toString(16)}>` : raw.slice(index, index + width);
+        index += width;
+    }
+    return sanitized;
+}
+function displayText(raw, redactSecrets) {
+    const sanitized = sanitizeTerminalText(raw);
+    return redactSecrets ? redact(sanitized) : { text: sanitized, count: 0 };
+}
+function harmlessErrorPhrase(text) {
+    return (/\b(?:0|zero|no)\s+errors?\b/i.test(text) ||
+        /\berror\s+(?:budget|handling|rate|page|message|type)\b/i.test(text));
+}
+const classifyVitestOrJest = (trimmed) => ["test files", "tests", "snapshots", "time"].some((label) => trimmed.toLowerCase().startsWith(label))
+    ? "summary"
+    : null;
+const classifyPytest = (trimmed) => trimmed.startsWith("=") && trimmed.endsWith("=") && /\b(?:failed|passed|errors?)\b/i.test(trimmed)
+    ? "summary"
+    : null;
+const classifyGoTest = (trimmed) => trimmed.startsWith("--- FAIL:") || trimmed === "FAIL" || trimmed.startsWith("FAIL ")
+    ? "error"
+    : null;
+const classifyMaven = (trimmed) => {
+    if (trimmed.startsWith("[ERROR]"))
+        return "error";
+    if (trimmed.startsWith("[WARNING]"))
+        return "warning";
+    return null;
+};
+const classifyGradle = (trimmed) => {
+    if (((trimmed.startsWith("> Task ") || trimmed.startsWith("BUILD FAILED")) &&
+        trimmed.includes("FAILED")) ||
+        trimmed.startsWith("FAILURE:"))
+        return "error";
+    return null;
+};
+const classifyDotnet = (trimmed) => /\berror [A-Z]{1,4}\d+\b/i.test(trimmed) || trimmed.startsWith("Failed! -") ? "error" : null;
+const classifyCargo = (trimmed) => {
+    if (trimmed.startsWith("test result:"))
+        return "summary";
+    if (/^error(?:\[E\d+\])?:/i.test(trimmed))
+        return "error";
+    return null;
+};
+const ADAPTER_CLASSIFIERS = {
+    generic: () => null,
+    vitest: classifyVitestOrJest,
+    jest: classifyVitestOrJest,
+    pytest: classifyPytest,
+    "go-test": classifyGoTest,
+    maven: classifyMaven,
+    gradle: classifyGradle,
+    dotnet: classifyDotnet,
+    cargo: classifyCargo,
+};
+function classifyAdapterLine(text, adapter) {
+    return ADAPTER_CLASSIFIERS[adapter](text.trimStart());
+}
+function isStackLine(text, previousKind) {
+    const trimmed = text.trimStart();
+    return (/^at\s+\S/i.test(trimmed) ||
+        (/^File\s+"/i.test(trimmed) && /",\s+line\s+\d+/i.test(trimmed)) ||
+        trimmed.startsWith("Caused by:") ||
+        trimmed.startsWith("Suppressed:") ||
+        /^\.\.\. \d+ more/i.test(trimmed) ||
+        (previousKind === "error" && trimmed !== text && trimmed.length > 0));
+}
+function isErrorLine(text) {
+    if (harmlessErrorPhrase(text))
+        return false;
+    if (/(?:^|\W)(?:error|exception|fatal|panic|failed|failure|assertion|segmentation fault|caused by|erro|fehler|erreur|エラー)(?:\W|$)/i.test(text))
+        return true;
+    return /(?:^(?:[ \t]*(?:FAIL\b|✗|✕|×))|(?:\b(?:test|tests|suite|suites)\s+failed\b))/i.test(text);
+}
+function isWarningLine(text) {
+    return /(?:^|\W)(?:warn(?:ing)?|deprecated|avertissement|advertencia|警告)(?:\W|$)/i.test(text);
+}
+function isSummaryLine(text) {
+    return (/\b(?:tests?|suites?|passed|skipped)\s*[:=]/i.test(text) ||
+        /\b(?:duration|time|total|summary|failures?|warnings?|errors?)\s*[:=]/i.test(text) ||
+        /\b\d+\s+(?:passed|failed|skipped)\b/i.test(text) ||
+        /\b(?:0|zero|no)\s+errors?\b/i.test(text));
+}
+function classify(text, previousKind, adapter) {
+    const adapterKind = classifyAdapterLine(text, adapter);
+    if (adapterKind)
+        return adapterKind;
+    if (isStackLine(text, previousKind))
+        return "stack";
+    if (isErrorLine(text))
+        return "error";
+    if (isWarningLine(text))
+        return "warning";
+    if (isSummaryLine(text))
+        return "summary";
+    return null;
+}
+function detectAdapter(events, requested) {
+    if (requested !== "auto")
+        return requested;
+    const sample = events
+        .map(({ text }) => text)
+        .join("\n")
+        .slice(0, 256_000);
+    const lowerSample = sample.toLowerCase();
+    const sampleLines = sample.split(/\r\n|\r|\n/).map((line) => line.trimStart());
+    if (lowerSample.includes("vitest") || sampleLines.some((line) => line.startsWith("Test Files ")))
+        return "vitest";
+    if (lowerSample.includes("jest") || sampleLines.some((line) => line.startsWith("Snapshots:")))
+        return "jest";
+    if (lowerSample.includes("pytest") ||
+        sampleLines.some((line) => line.startsWith("=") && line.endsWith("=") && /\sin\s\d+(?:\.\d+)?s\s/.test(line)))
+        return "pytest";
+    if (sampleLines.some((line) => line.startsWith("ok ") ||
+        line.startsWith("FAIL ") ||
+        line.startsWith("--- PASS:") ||
+        line.startsWith("--- FAIL:")))
+        return "go-test";
+    if (sampleLines.some((line) => (line.startsWith("[INFO]") || line.startsWith("[ERROR]") || line.startsWith("[WARNING]")) &&
+        (line.toLowerCase().includes("maven") || line.includes("BUILD"))))
+        return "maven";
+    if (sampleLines.some((line) => line.startsWith("> Task ") || line.startsWith("* What went wrong:")))
+        return "gradle";
+    if (sampleLines.some((line) => /\berror [A-Z]{1,4}\d+\b/i.test(line) || line.startsWith("Failed! -")))
+        return "dotnet";
+    if (sampleLines.some((line) => /^error\[E\d+\]:/.test(line) || line.startsWith("test result:")))
+        return "cargo";
+    return "generic";
+}
+function flatten(events, redactSecrets, adapter) {
+    const lines = [];
+    let previousKind = null;
+    for (const event of events) {
+        for (const { raw, sourceBytes } of splitEvent(event)) {
+            const displayed = displayText(raw, redactSecrets);
+            const kind = classify(displayed.text, previousKind, adapter);
+            lines.push({
+                line: lines.length + 1,
+                stream: event.stream,
+                raw,
+                sourceBytes,
+                display: displayed.text,
+                kind,
+                secretRedactions: displayed.count,
+            });
+            previousKind = kind;
+        }
+    }
+    return lines;
+}
+function renderLine(line) {
+    if (line.stream === "combined")
+        return line.display;
+    return `[${line.stream} L${line.line}] ${line.display}`;
+}
+function renderedBytes(lines) {
+    return Buffer.byteLength(lines.map(renderLine).join("\n"));
+}
+function rangesFor(lines, selected, includeSelected) {
+    const ranges = [];
+    let active = [];
+    const flush = () => {
+        if (active.length === 0)
+            return;
+        ranges.push({
+            startLine: active[0].line,
+            endLine: active.at(-1)?.line ?? active[0].line,
+            lineCount: active.length,
+            byteCount: active.reduce((total, line) => total + line.sourceBytes, 0),
+        });
+        active = [];
+    };
+    for (const line of lines) {
+        if (selected.has(line.line) === includeSelected)
+            active.push(line);
+        else
+            flush();
+    }
+    flush();
+    return ranges;
+}
+function percentReduction(input, output) {
+    if (input === 0)
+        return 0;
+    return Math.round((1 - output / input) * 10_000) / 100;
+}
+function artifactDirectory(repo) {
+    const resolvedRepo = fs.realpathSync(repo);
+    const knodinDirectory = path.join(resolvedRepo, ".reckon");
+    const outputDirectory = path.join(knodinDirectory, "output");
+    for (const candidate of [knodinDirectory, outputDirectory]) {
+        if (fs.existsSync(candidate) && fs.lstatSync(candidate).isSymbolicLink())
+            throw new Error(`knodin compress: refusing symlinked artifact directory ${candidate}`);
+    }
+    fs.mkdirSync(outputDirectory, { recursive: true, mode: 0o700 });
+    fs.chmodSync(outputDirectory, 0o700);
+    return outputDirectory;
+}
+function artifactPath(repo, id) {
+    if (!ARTIFACT_ID.test(id))
+        throw new Error("knodin compress: invalid artifact id");
+    return path.join(artifactDirectory(repo), `${id}.json`);
+}
+function artifactIdentity(events, exit) {
+    return crypto.createHash("sha256").update(JSON.stringify({ events, exit })).digest("hex");
+}
+function persistArtifact(repo, events, exit) {
+    const id = artifactIdentity(events, exit);
+    const target = artifactPath(repo, id);
+    if (!fs.existsSync(target)) {
+        const artifact = {
+            schemaVersion: 1,
+            id,
+            createdAt: new Date().toISOString(),
+            exit,
+            events,
+        };
+        const descriptor = fs.openSync(target, fs.constants.O_WRONLY |
+            fs.constants.O_CREAT |
+            fs.constants.O_EXCL |
+            (fs.constants.O_NOFOLLOW ?? 0), 0o600);
+        try {
+            fs.writeFileSync(descriptor, `${JSON.stringify(artifact)}\n`);
+            fs.fsyncSync(descriptor);
+        }
+        finally {
+            fs.closeSync(descriptor);
+        }
+    }
+    if (!fs.lstatSync(target).isFile())
+        throw new Error("knodin compress: artifact target is not a regular file");
+    // Existing content-addressed artifacts must still match their name. This
+    // catches local tampering and partial writes instead of silently reusing them.
+    loadArtifact(repo, id);
+    fs.chmodSync(target, 0o600);
+    return {
+        id,
+        relativePath: path.relative(fs.realpathSync(repo), target).split(path.sep).join("/"),
+        bytes: fs.statSync(target).size,
+    };
+}
+function loadArtifact(repo, id) {
+    const target = artifactPath(repo, id);
+    const stats = fs.lstatSync(target);
+    if (!stats.isFile())
+        throw new Error("knodin compress: artifact target is not a regular file");
+    if (stats.size > MAX_STORED_ARTIFACT_BYTES)
+        throw new Error("knodin compress: retained artifact exceeds the bounded storage limit");
+    const descriptor = fs.openSync(target, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+    try {
+        const parsed = JSON.parse(fs.readFileSync(descriptor, "utf-8"));
+        if (parsed.schemaVersion !== 1 ||
+            parsed.id !== id ||
+            !parsed.exit ||
+            !(parsed.exit.code === null ||
+                (typeof parsed.exit.code === "number" && Number.isInteger(parsed.exit.code))) ||
+            !(parsed.exit.signal === null || typeof parsed.exit.signal === "string") ||
+            !Array.isArray(parsed.events) ||
+            parsed.events.some((event) => !event ||
+                !["combined", "stdout", "stderr"].includes(event.stream) ||
+                typeof event.text !== "string"))
+            throw new Error("knodin compress: invalid retained artifact");
+        if (artifactIdentity(parsed.events, parsed.exit) !== id)
+            throw new Error("knodin compress: retained artifact identity mismatch");
+        return parsed;
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+function setCandidateScore(scores, line, value) {
+    scores.set(line, Math.max(value, scores.get(line) ?? 0));
+}
+function scoreMandatoryContext(scores, lines, mandatory, contextLines) {
+    for (const line of mandatory) {
+        setCandidateScore(scores, line, 1_000);
+        for (let offset = 1; offset <= contextLines; offset++) {
+            if (line - offset >= 1)
+                setCandidateScore(scores, line - offset, 600 - offset);
+            if (line + offset <= lines.length)
+                setCandidateScore(scores, line + offset, 600 - offset);
+        }
+    }
+}
+function scoreEdges(scores, lineCount, edgeLines) {
+    for (let index = 1; index <= Math.min(edgeLines, lineCount); index++)
+        setCandidateScore(scores, index, 300 - index);
+    for (let index = Math.max(1, lineCount - edgeLines + 1); index <= lineCount; index++)
+        setCandidateScore(scores, index, 300 - (lineCount - index));
+}
+function scoreHeadTail(scores, lineCount) {
+    const window = Math.min(10, Math.ceil(lineCount / 2));
+    for (let index = 1; index <= window; index++)
+        setCandidateScore(scores, index, 400 - index);
+    for (let index = Math.max(1, lineCount - window + 1); index <= lineCount; index++)
+        setCandidateScore(scores, index, 400 - (lineCount - index));
+}
+function candidateScores(lines, mandatory, strategy, contextLines) {
+    const scores = new Map();
+    scoreMandatoryContext(scores, lines, mandatory, contextLines);
+    if (strategy !== "errors-only" || mandatory.size === 0)
+        scoreEdges(scores, lines.length, mandatory.size > 0 ? 1 : 3);
+    if (strategy === "head-tail")
+        scoreHeadTail(scores, lines.length);
+    return scores;
+}
+function selectLines(lines, mandatory, strategy, lineBudget, byteBudget, contextLines) {
+    const selected = new Set();
+    const fits = (candidate) => {
+        const next = [...selected, candidate.line]
+            .sort((left, right) => left - right)
+            .map((line) => lines[line - 1]);
+        return next.length <= lineBudget && renderedBytes(next) <= byteBudget;
+    };
+    for (const lineNumber of [...mandatory].sort((left, right) => left - right)) {
+        const candidate = lines[lineNumber - 1];
+        if (candidate && fits(candidate))
+            selected.add(lineNumber);
+    }
+    const scores = candidateScores(lines, mandatory, strategy, contextLines);
+    const candidates = [...scores]
+        .filter(([line]) => !selected.has(line))
+        .sort(([leftLine, leftScore], [rightLine, rightScore]) => {
+        if (leftScore !== rightScore)
+            return rightScore - leftScore;
+        return leftLine - rightLine;
+    });
+    for (const [lineNumber] of candidates) {
+        const candidate = lines[lineNumber - 1];
+        if (candidate && fits(candidate))
+            selected.add(lineNumber);
+    }
+    return {
+        selected,
+        unpreservedSignals: [...mandatory].filter((line) => !selected.has(line)).sort((a, b) => a - b),
+    };
+}
+export function compressOutput(repo, request) {
+    const events = normalizeEvents(request);
+    const lineBudget = validateInteger("lineBudget", request.lineBudget, 1, MAX_LINE_BUDGET, DEFAULT_LINE_BUDGET);
+    const byteBudget = validateInteger("byteBudget", request.byteBudget, 256, MAX_BYTE_BUDGET, DEFAULT_BYTE_BUDGET);
+    const contextLines = validateInteger("contextLines", request.contextLines, 0, 10, 1);
+    const maxInputBytes = boundedInputLimit(request.maxInputBytes);
+    const bytes = inputBytes(events);
+    if (bytes > maxInputBytes)
+        throw new Error(`knodin compress: input is ${bytes} bytes; bounded retention limit is ${maxInputBytes}`);
+    const strategy = request.strategy ?? "smart";
+    if (!["smart", "head-tail", "errors-only"].includes(strategy))
+        throw new Error("knodin compress: invalid strategy");
+    const requestedAdapter = request.adapter ?? "auto";
+    if (![
+        "auto",
+        "generic",
+        "vitest",
+        "jest",
+        "pytest",
+        "go-test",
+        "maven",
+        "gradle",
+        "dotnet",
+        "cargo",
+    ].includes(requestedAdapter))
+        throw new Error("knodin compress: invalid adapter");
+    const adapter = detectAdapter(events, requestedAdapter);
+    const exit = { code: request.exitCode ?? null, signal: request.signal ?? null };
+    const retained = request.retain === false ? null : persistArtifact(repo, events, { ...exit });
+    const lines = flatten(events, request.redactSecrets !== false, adapter);
+    const mandatory = new Set(lines.filter(({ kind }) => kind !== null).map(({ line }) => line));
+    const allFit = lines.length <= lineBudget && renderedBytes(lines) <= byteBudget;
+    const selection = allFit
+        ? { selected: new Set(lines.map(({ line }) => line)), unpreservedSignals: [] }
+        : selectLines(lines, mandatory, strategy, lineBudget, byteBudget, contextLines);
+    const selectedLines = lines.filter(({ line }) => selection.selected.has(line));
+    const content = selectedLines.map(renderLine).join("\n");
+    const contentBytes = Buffer.byteLength(content);
+    const complete = selection.selected.size === lines.length;
+    const insufficient = selection.unpreservedSignals.length > 0;
+    let status = "compressed";
+    if (complete)
+        status = "complete";
+    else if (insufficient)
+        status = "insufficient-budget";
+    return {
+        schemaVersion: 1,
+        status,
+        complete,
+        strategy,
+        adapter,
+        content,
+        exit,
+        artifact: {
+            id: retained?.id ?? artifactIdentity(events, exit),
+            retained: retained !== null,
+            path: retained?.relativePath ?? null,
+            bytes: retained?.bytes ?? 0,
+        },
+        input: {
+            lines: lines.length,
+            bytes,
+            streams: [...new Set(events.map(({ stream }) => stream))],
+        },
+        output: {
+            lines: selectedLines.length,
+            bytes: contentBytes,
+            lineBudget,
+            byteBudget,
+            budgetAppliesTo: "content-utf8",
+            reductionPercent: percentReduction(bytes, contentBytes),
+        },
+        fidelity: {
+            detectedSignals: mandatory.size,
+            preservedSignals: mandatory.size - selection.unpreservedSignals.length,
+            unpreservedSignals: selection.unpreservedSignals,
+            secretRedactions: lines.reduce((total, line) => total + line.secretRedactions, 0),
+            unknownFormat: mandatory.size === 0,
+        },
+        includedRanges: rangesFor(lines, selection.selected, true),
+        omittedRanges: rangesFor(lines, selection.selected, false),
+        continuation: retained
+            ? {
+                operation: "compress",
+                compressionAction: "read",
+                artifactId: retained.id,
+            }
+            : null,
+    };
+}
+export function compressOutputFile(repo, relativePath, request = {}) {
+    const input = resolveInputFile(repo, relativePath);
+    const limit = boundedInputLimit(request.maxInputBytes);
+    const size = fs.statSync(input).size;
+    if (size > limit)
+        throw new Error(`knodin compress: input is ${size} bytes; bounded retention limit is ${limit}`);
+    return compressOutput(repo, {
+        ...request,
+        text: fs.readFileSync(input, "utf-8"),
+        maxInputBytes: limit,
+    });
+}
+export function readOutputArtifact(repo, id, request = {}) {
+    const artifact = loadArtifact(repo, id);
+    const byteBudget = validateInteger("byteBudget", request.byteBudget, 256, MAX_BYTE_BUDGET, DEFAULT_BYTE_BUDGET);
+    const lines = flatten(artifact.events, request.raw !== true, detectAdapter(artifact.events, "auto"));
+    const startLine = validateInteger("startLine", request.startLine, 1, Math.max(1, lines.length), 1);
+    const endLine = validateInteger("endLine", request.endLine, startLine, Math.max(startLine, lines.length), Math.min(lines.length, startLine + 199));
+    const selected = [];
+    for (const line of lines.slice(startLine - 1, endLine)) {
+        const candidate = [...selected, line];
+        if (renderedBytes(candidate) > byteBudget)
+            break;
+        selected.push(line);
+    }
+    const content = selected.map(renderLine).join("\n");
+    const actualEnd = selected.at(-1)?.line ?? startLine - 1;
+    return {
+        schemaVersion: 1,
+        artifactId: id,
+        content,
+        raw: request.raw === true,
+        range: { startLine, endLine: actualEnd, totalLines: lines.length },
+        bytes: Buffer.byteLength(content),
+        byteBudget,
+        complete: startLine === 1 && actualEnd === lines.length,
+        secretRedactions: lines.reduce((total, line) => total + line.secretRedactions, 0),
+    };
+}
+export function deleteOutputArtifact(repo, id) {
+    const target = artifactPath(repo, id);
+    try {
+        const descriptor = fs.openSync(target, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+        fs.closeSync(descriptor);
+        fs.unlinkSync(target);
+        return { deleted: true, artifactId: id };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { deleted: false, artifactId: id };
+        throw error;
+    }
+}