@open-cr-agent/core 0.5.0 → 0.6.0

package/dist/runtime/effort-capability.js

@@ -0,0 +1,70 @@
+// What ocra knows of current models, matched on the model id's last path
+// segment, so "anthropic/claude-sonnet-4-5" and an OpenRouter
+// "openrouter/anthropic/claude-sonnet-4.5" both match. It goes stale as
+// models ship: a model it does not know, or a level it says a model does
+// not take, is left out of the call with a warning, never refused. The first
+// matching row wins, so a family's later versions come first.
+const CAPABILITIES = [
+    {
+        pattern: /^gpt-5\.\d/,
+        parameter: "reasoningEffort",
+        levels: ["none", "low", "medium", "high"],
+    },
+    {
+        pattern: /^gpt-5(?:$|-)/,
+        parameter: "reasoningEffort",
+        levels: ["minimal", "low", "medium", "high"],
+    },
+    { pattern: /^o[134](?:$|-)/, parameter: "reasoningEffort", levels: ["low", "medium", "high"] },
+    {
+        pattern: /^claude-(?:(?:opus|sonnet|haiku)-)?[4-9]/,
+        parameter: "thinkingBudget",
+        levels: ["none", "minimal", "low", "medium", "high"],
+        budget: { min: 1_024 },
+    },
+    {
+        pattern: /^gemini-2\.5-pro/,
+        parameter: "thinkingBudget",
+        levels: ["minimal", "low", "medium", "high"],
+        budget: { min: 128, max: 32_768 },
+    },
+    {
+        pattern: /^gemini-2\.5-flash/,
+        parameter: "thinkingBudget",
+        levels: ["none", "minimal", "low", "medium", "high"],
+        budget: { min: 512, max: 24_576 },
+    },
+    { pattern: /^gemini-3/, parameter: "thinkingLevel", levels: ["low", "high"] },
+];
+export function effortCapability(model) {
+    const id = (model.split("/").at(-1) ?? model).toLowerCase();
+    const row = CAPABILITIES.find((r) => r.pattern.test(id));
+    if (!row)
+        return undefined;
+    const { pattern: _, ...capability } = row;
+    return capability;
+}
+// Share of the model's output limit each level may spend on thinking.
+const BUDGET_SHARE = {
+    minimal: 1 / 32,
+    low: 1 / 16,
+    medium: 1 / 4,
+    high: 1 / 2,
+};
+// Claude Opus 4's output limit, the smallest among the models the table
+// knows: a budget derived from it fits all of them.
+export const FALLBACK_OUTPUT_LIMIT = 32_000;
+// The thinking budget for a level, derived from the model's output limit
+// (the fallback when the catalog gives none); 0 for "none". Undefined when
+// no budget within the bounds fits below that limit.
+export function thinkingBudget(capability, level, outputLimit) {
+    if (level === "none")
+        return 0;
+    const limit = outputLimit && outputLimit > 0 ? outputLimit : FALLBACK_OUTPUT_LIMIT;
+    const min = capability.budget?.min ?? 0;
+    const max = Math.min(capability.budget?.max ?? Number.POSITIVE_INFINITY, limit - 1);
+    if (min > max)
+        return undefined;
+    return Math.min(max, Math.max(min, Math.floor(limit * BUDGET_SHARE[level])));
+}
+//# sourceMappingURL=effort-capability.js.map

package/dist/runtime/failback.d.ts

@@ -11,15 +11,6 @@ export interface FailbackOptions {
     attempt(model: string, onUsage: (spent: Usage) => void): Promise<AttemptOutcome>;
 }
 export declare function withFailback(options: FailbackOptions): AsyncGenerator<AgentEvent>;
-export declare class LiveUsage {
-    private seen;
-    private given;
-    private wake;
-    observe(spent: Usage): void;
-    changed(): Promise<void>;
-    take(): Usage;
-    rest(total: Usage): Usage;
-}
 export interface CompleteOptions {
     tier: ModelTier;
     agent?: string;

package/dist/runtime/failback.js

@@ -1,5 +1,5 @@
+import { addUsage, emptyUsage } from "../agent/usage.js";
 import { CompletionError } from "../errors.js";
-import { addUsage, emptyUsage } from "../pipeline/usage.js";
 import { attemptSummary } from "./attempt.js";
 import { sleep } from "./quota.js";
 // Findings from a failed attempt are still emitted: the pipeline deduplicates
@@ -75,7 +75,7 @@ export async function* withFailback(options) {
 // Hands out what an attempt has spent in increments, each what grew since the
 // last one; `rest` settles the finished attempt's total, so the increments
 // add up to it and nothing is counted twice.
-export class LiveUsage {
+class LiveUsage {
     seen = emptyUsage();
     given = emptyUsage();
     wake;
@@ -113,11 +113,21 @@ const FIELDS = [
     "cachedTokens",
     "costUsd",
 ];
+// Each field of a usage from the same field of two others.
+function mapUsage(a, b, combine) {
+    return {
+        inputTokens: combine(a.inputTokens, b.inputTokens),
+        outputTokens: combine(a.outputTokens, b.outputTokens),
+        reasoningTokens: combine(a.reasoningTokens, b.reasoningTokens),
+        cachedTokens: combine(a.cachedTokens, b.cachedTokens),
+        costUsd: combine(a.costUsd, b.costUsd),
+    };
+}
 function larger(a, b) {
-    return Object.fromEntries(FIELDS.map((f) => [f, Math.max(a[f], b[f])]));
+    return mapUsage(a, b, Math.max);
 }
 function beyond(a, b) {
-    return Object.fromEntries(FIELDS.map((f) => [f, Math.max(0, a[f] - b[f])]));
+    return mapUsage(a, b, (x, y) => Math.max(0, x - y));
 }
 function ahead(a, b) {
     return FIELDS.some((f) => a[f] > b[f]);

package/dist/runtime/models.d.ts

@@ -1,5 +1,4 @@
-import type { ModelTier } from "../contracts.js";
-import type { ModelChains } from "../plugin/types.js";
+import type { ModelChains, ModelTier } from "../contracts.js";
 import { type QuotaError } from "./quota.js";
 export interface ModelRef {
     providerID: string;

package/dist/runtime/tools.d.ts

@@ -1,21 +1,5 @@
-import { z } from "zod";
 import type { ToolDefinition } from "../plugin/types.js";
-export declare const MAX_READ_LINES = 400;
-export declare const MAX_SEARCH_RESULTS = 50;
 export declare const MAX_LINE_CHARS = 2000;
 export declare const MAX_RESULT_CHARS = 50000;
-export declare const reportFindingInput: z.ZodObject<{
-    file: z.ZodString;
-    existingCode: z.ZodString;
-    severity: z.ZodEnum<{
-        critical: "critical";
-        suggestion: "suggestion";
-        warning: "warning";
-    }>;
-    title: z.ZodString;
-    body: z.ZodString;
-    suggestion: z.ZodOptional<z.ZodString>;
-    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
 export declare const reviewTools: readonly ToolDefinition[];
 //# sourceMappingURL=tools.d.ts.map

package/dist/runtime/tools.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { severitySchema } from "../domain.js";
 import { data as promptData } from "../review/prompt-text.js";
 import { REVIEW_TOOLS } from "../review/tools.js";
-export const MAX_READ_LINES = 400;
-export const MAX_SEARCH_RESULTS = 50;
+const MAX_READ_LINES = 400;
+const MAX_SEARCH_RESULTS = 50;
 // Lines and results are also capped in characters: one line of a minified
 // bundle or a JSON fixture can be megabytes, and every step resends it.
 export const MAX_LINE_CHARS = 2_000;
@@ -23,7 +23,7 @@ function fitting(lines) {
     }
     return kept;
 }
-export const reportFindingInput = z.object({
+const reportFindingInput = z.object({
     file: z.string().min(1).describe("Path of a file in <ocra_review_files>"),
     existingCode: z
         .string()

package/dist/sarif/candidates.d.ts

@@ -1,6 +1,6 @@
 import type { LineRange, Severity } from "../domain.js";
 import type { SarifRun } from "./schema.js";
-export interface SarifTool {
+interface SarifTool {
     name: string;
     slug: string;
     version?: string;
@@ -24,4 +24,5 @@ export interface SarifCandidates {
     };
 }
 export declare function sarifCandidates(run: SarifRun): SarifCandidates;
+export {};
 //# sourceMappingURL=candidates.d.ts.map

package/dist/sarif/schema.d.ts

@@ -37,7 +37,7 @@ declare const result: z.ZodObject<{
         }, z.core.$loose>>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
-export declare const sarifRunSchema: z.ZodObject<{
+declare const sarifRunSchema: z.ZodObject<{
     tool: z.ZodObject<{
         driver: z.ZodObject<{
             name: z.ZodString;
@@ -83,7 +83,7 @@ export declare const sarifRunSchema: z.ZodObject<{
         }, z.core.$loose>>>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
-export declare const sarifLogSchema: z.ZodObject<{
+declare const sarifLogSchema: z.ZodObject<{
     version: z.ZodLiteral<"2.1.0">;
     runs: z.ZodArray<z.ZodObject<{
         tool: z.ZodObject<{

package/dist/sarif/schema.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { OcraError } from "../errors.js";
+import { errorMessage, OcraError } from "../errors.js";
 // The part of SARIF 2.1.0 an import reads. Objects are loose: a log carries
 // far more than this, and none of it is trusted beyond what is checked here.
 // https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html
@@ -34,7 +34,7 @@ const result = z.looseObject({
     message,
     locations: z.array(location).optional(),
 });
-export const sarifRunSchema = z.looseObject({
+const sarifRunSchema = z.looseObject({
     tool: z.looseObject({
         driver: z.looseObject({
             name: z.string().min(1),
@@ -45,7 +45,7 @@ export const sarifRunSchema = z.looseObject({
     }),
     results: z.array(result).optional(),
 });
-export const sarifLogSchema = z.looseObject({
+const sarifLogSchema = z.looseObject({
     version: z.literal("2.1.0"),
     runs: z.array(sarifRunSchema),
 });
@@ -61,7 +61,7 @@ export function parseSarifLog(text) {
         data = JSON.parse(text);
     }
     catch (error) {
-        throw new SarifError(`not valid JSON: ${error.message}`);
+        throw new SarifError(`not valid JSON: ${errorMessage(error)}`);
     }
     const parsed = sarifLogSchema.safeParse(data);
     if (!parsed.success)

package/dist/session/jsonl.d.ts

@@ -1,9 +1,9 @@
-import type { ReviewEvent } from "../pipeline/report.js";
+import type { ReviewEvent } from "../report/report.js";
 export declare const EVENTS_FILE = "events.jsonl";
 export declare const REPORT_FILE = "report.json";
 export declare class JsonlSessionWriter {
-    readonly id: string;
     readonly dir: string;
+    readonly id: string;
     constructor(sessionsDir: string, id?: string);
     write(event: ReviewEvent): void;
 }

package/dist/session/jsonl.js

@@ -1,15 +1,16 @@
 import { appendFileSync, closeSync, constants, lstatSync, mkdirSync, openSync, writeFileSync, writeSync, } from "node:fs";
 import { dirname, join } from "node:path";
-import { OcraError } from "../errors.js";
-import { serializeOutput, toReportOutput } from "../pipeline/output.js";
+import { isNotFound, OcraError } from "../errors.js";
 import { newRunId } from "../pipeline/run-id.js";
+import { toReportOutput } from "../report/output.js";
+import { serializeOutput } from "../report/serialize.js";
 export const EVENTS_FILE = "events.jsonl";
 export const REPORT_FILE = "report.json";
 // Events are appended synchronously, one JSON object per line, so the log
 // stays valid and ordered even if the process dies mid-run.
 export class JsonlSessionWriter {
-    id;
     dir;
+    id;
     constructor(sessionsDir, id = newRunId()) {
         this.id = id;
         // The sessions directory lives in the reviewed tree, which may carry
@@ -44,7 +45,7 @@ function refuseSymlink(path) {
         }
     }
     catch (error) {
-        if (error.code !== "ENOENT")
+        if (!isNotFound(error))
             throw error;
     }
 }

package/dist/triage.d.ts

@@ -1,11 +1,11 @@
 import type { FileDiff, RiskTier } from "./domain.js";
-export interface TriagePolicy {
+interface TriagePolicy {
     trivialMaxLines: number;
     liteMaxLines: number;
     maxFilesBeforeFull: number;
     sensitivePathPatterns: RegExp[];
     sensitivePathWords: ReadonlySet<string>;
 }
-export declare const defaultTriagePolicy: TriagePolicy;
 export declare function triage(diffs: readonly FileDiff[], policy?: TriagePolicy): RiskTier;
+export {};
 //# sourceMappingURL=triage.d.ts.map

package/dist/triage.js

@@ -1,4 +1,4 @@
-export const defaultTriagePolicy = {
+const defaultTriagePolicy = {
     trivialMaxLines: 10,
     liteMaxLines: 100,
     maxFilesBeforeFull: 20,

package/dist/vcs.d.ts

@@ -0,0 +1,15 @@
+import type { CodeMatch } from "./contracts.js";
+import type { ChangeRequest, FileDiff, PriorReview } from "./domain.js";
+import type { ReviewReport } from "./report/report.js";
+export interface VcsAdapter {
+    readonly name: string;
+    getChangeRequest(): Promise<ChangeRequest>;
+    getDiff(): Promise<FileDiff[]>;
+    readFile(path: string): Promise<string | undefined>;
+    searchCode(literal: string): Promise<CodeMatch[]>;
+    getPriorReview(): Promise<PriorReview | undefined>;
+    publish(report: ReviewReport): Promise<{
+        warnings: string[];
+    }>;
+}
+//# sourceMappingURL=vcs.d.ts.map

package/dist/vcs.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vcs.js.map

package/dist/verify/prompt.d.ts

@@ -1,11 +1,5 @@
 import { z } from "zod";
 import type { Finding } from "../domain.js";
-export declare const verificationVerdictSchema: z.ZodEnum<{
-    confirmed: "confirmed";
-    refuted: "refuted";
-    uncertain: "uncertain";
-}>;
-export type VerificationVerdict = z.infer<typeof verificationVerdictSchema>;
 export declare const verificationResponseSchema: z.ZodArray<z.ZodObject<{
     index: z.ZodNumber;
     verdict: z.ZodEnum<{

package/dist/verify/prompt.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { data, join, labelled, oneLine, section } from "../review/prompt-text.js";
-export const verificationVerdictSchema = z.enum(["confirmed", "refuted", "uncertain"]);
+const verificationVerdictSchema = z.enum(["confirmed", "refuted", "uncertain"]);
 export const verificationResponseSchema = z.array(z.object({
     index: z.number().int(),
     verdict: verificationVerdictSchema,

package/dist/verify/verify.d.ts

@@ -1,8 +1,7 @@
+import type { SpendTracker } from "../agent/budget.js";
+import { type AgentCallSettings } from "../agent/settings.js";
 import type { AgentRuntime, ReviewContext, Usage } from "../contracts.js";
 import type { FileDiff, Finding } from "../domain.js";
-import { type AgentCallSettings } from "../pipeline/agents.js";
-import type { SpendTracker } from "../pipeline/budget.js";
-export declare const VERIFY_TIMEOUT_MS = 120000;
 export interface RefutedFinding {
     fingerprint: string;
     file: string;

package/dist/verify/verify.js

@@ -1,9 +1,9 @@
+import { parseJsonAnswer } from "../agent/json.js";
+import { mapWithConcurrency } from "../agent/pool.js";
+import { agentCall } from "../agent/settings.js";
 import { errorMessage, OcraError, usageSpent } from "../errors.js";
-import { agentCall } from "../pipeline/agents.js";
-import { parseJsonAnswer } from "../pipeline/helpers.js";
-import { mapWithConcurrency } from "../pipeline/pool.js";
 import { buildVerificationPrompt, fileExcerpt, verificationResponseSchema } from "./prompt.js";
-export const VERIFY_TIMEOUT_MS = 120_000;
+const VERIFY_TIMEOUT_MS = 120_000;
 // Precision without losing recall to doubt: a finding is dropped only when
 // the verifier says the code shown proves it wrong. Any failure keeps it.
 export async function verifyFindings(findings, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-cr-agent/core",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Domain types, review pipeline stages and plugin contracts for Open-CR-Agent",
   "keywords": [
     "code-review",

package/dist/pipeline/helpers.d.ts

@@ -1,7 +0,0 @@
-import type { FileGrouper } from "../bundle/grouping.js";
-import type { AgentRuntime, Usage } from "../contracts.js";
-import { type AgentCallSettings } from "./agents.js";
-export declare const HELPER_TIMEOUT_MS = 60000;
-export declare function runtimeGrouper(runtime: AgentRuntime, signal: AbortSignal, onUsage: (usage: Usage) => void, call?: AgentCallSettings): FileGrouper | undefined;
-export declare function parseJsonAnswer(text: string): unknown;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/pipeline/output.d.ts

@@ -1,79 +0,0 @@
-import type { Usage } from "../contracts.js";
-import type { ChangeRequest, RiskTier, Severity, Verdict, Verification } from "../domain.js";
-import type { JudgeDecisions } from "../judge/judge.js";
-import type { MemoryEntry, MemorySource } from "../memory/memory.js";
-import type { RefutedFinding } from "../verify/verify.js";
-import type { SkippedCell } from "./matrix.js";
-import type { ReviewPreview } from "./preview.js";
-import type { RunProvenance } from "./provenance.js";
-import type { AnchoringSummary, CoverageEntry, ReviewReport, TaskOutcome } from "./report.js";
-export declare const REPORT_VERSION = 1;
-export interface OutputFinding {
-    fingerprint: string;
-    reviewer: string;
-    category: string;
-    severity: Severity;
-    verification: Verification;
-    file: string;
-    lines?: {
-        start: number;
-        end: number;
-    };
-    inDiff: boolean;
-    status: "new" | "unfixed";
-    title: string;
-    body: string;
-    suggestion?: string;
-    evidence: string[];
-    code: string;
-    lowConfidence?: true;
-    provenance?: {
-        task: string;
-        model?: string;
-    };
-}
-export interface OutputPriorFinding {
-    fingerprint: string;
-    title: string;
-    file: string;
-    severity: Severity;
-    verification: Verification;
-}
-export interface ReportOutput {
-    version: typeof REPORT_VERSION;
-    runId?: string;
-    changeRequest: ChangeRequest;
-    tier: RiskTier;
-    verdict: Verdict;
-    summary: string;
-    scope?: ReviewReport["scope"];
-    coverage: CoverageEntry[];
-    findings: OutputFinding[];
-    unverifiedCriticals: number;
-    refuted: RefutedFinding[];
-    remembered: (MemoryEntry & {
-        source?: MemorySource;
-    })[];
-    judgement?: JudgeDecisions;
-    rereview?: Record<"fixed" | "notReproduced" | "notRechecked" | "unchanged" | "dismissed", OutputPriorFinding[]>;
-    tasks: TaskOutcome[];
-    skipped: SkippedCell[];
-    bundles: {
-        label: string;
-        files: string[];
-    }[];
-    anchoring?: AnchoringSummary;
-    spendLimit?: ReviewReport["spendLimit"];
-    provenance?: RunProvenance;
-    usage: Usage;
-    warnings: string[];
-}
-export declare function toReportOutput(report: ReviewReport): ReportOutput;
-export declare const PLAN_VERSION = 1;
-export type PlanOutput = {
-    version: typeof PLAN_VERSION;
-} & ReviewPreview;
-export declare function toPlanOutput(preview: ReviewPreview): PlanOutput;
-export declare function isUnsafeCodePoint(code: number): boolean;
-export declare function serializeOutput(value: unknown, indent?: number): string;
-//# sourceMappingURL=output.d.ts.map

package/dist/pipeline/output.js

@@ -1,132 +0,0 @@
-// The published shape of a review: `--format json` and a session's
-// report.json. It is a contract with scripts and CI, so it carries a version
-// and only what a reader can rely on; internal fields (per-run ids, how each
-// finding was anchored, code signatures, platform state) stay out, though the
-// anchoring counts of the whole run are in. Change it
-// only by adding optional fields, or by a new version.
-export const REPORT_VERSION = 1;
-export function toReportOutput(report) {
-    const output = {
-        version: REPORT_VERSION,
-        runId: report.runId,
-        changeRequest: report.changeRequest,
-        tier: report.tier,
-        verdict: report.verdict,
-        summary: report.summary,
-        coverage: report.coverage,
-        findings: report.findings.map(outputFinding),
-        unverifiedCriticals: report.unverifiedCriticals,
-        refuted: report.refuted,
-        remembered: report.remembered,
-        tasks: report.tasks,
-        skipped: report.skipped,
-        bundles: report.bundles,
-        usage: report.usage,
-        warnings: report.warnings,
-    };
-    if (report.scope)
-        output.scope = report.scope;
-    if (report.judgement)
-        output.judgement = report.judgement;
-    if (report.anchoring)
-        output.anchoring = report.anchoring;
-    if (report.spendLimit)
-        output.spendLimit = report.spendLimit;
-    if (report.provenance)
-        output.provenance = report.provenance;
-    if (report.rereview) {
-        const r = report.rereview;
-        output.rereview = {
-            fixed: r.fixed.map(outputPrior),
-            notReproduced: r.notReproduced.map(outputPrior),
-            notRechecked: r.notRechecked.map(outputPrior),
-            unchanged: r.unchanged.map(outputPrior),
-            dismissed: r.dismissed.map(outputPrior),
-        };
-    }
-    return output;
-}
-function outputFinding(f) {
-    const output = {
-        fingerprint: f.fingerprint,
-        reviewer: f.reviewer,
-        category: f.category,
-        severity: f.severity,
-        verification: f.verification ?? "unchecked",
-        file: f.file,
-        inDiff: f.anchor.inDiff,
-        status: f.status === "unfixed" ? "unfixed" : "new",
-        title: f.title,
-        body: f.body,
-        evidence: f.evidence,
-        code: f.existingCode,
-    };
-    if (f.lineRange)
-        output.lines = { start: f.lineRange.start, end: f.lineRange.end };
-    if (f.suggestion !== undefined)
-        output.suggestion = f.suggestion;
-    if (f.lowConfidence)
-        output.lowConfidence = true;
-    output.provenance =
-        f.provenance.model === undefined
-            ? { task: f.provenance.task }
-            : { task: f.provenance.task, model: f.provenance.model };
-    return output;
-}
-function outputPrior(f) {
-    return {
-        fingerprint: f.fingerprint,
-        title: f.title,
-        file: f.file,
-        severity: f.severity,
-        verification: f.verification ?? "unchecked",
-    };
-}
-// The published shape of `ocra review --plan --format json`, versioned like
-// the report. The preview is already free of internal fields; the version
-// makes the contract explicit.
-export const PLAN_VERSION = 1;
-export function toPlanOutput(preview) {
-    return {
-        version: PLAN_VERSION,
-        changeRequest: preview.changeRequest,
-        tier: preview.tier,
-        selected: preview.selected,
-        excluded: preview.excluded,
-        bundles: preview.bundles,
-        groupingSkipped: preview.groupingSkipped,
-        tasks: preview.tasks,
-        skipped: preview.skipped,
-        promptTokens: preview.promptTokens,
-        // Added in version 1 without a bump: a new field older readers ignore.
-        planCalls: preview.planCalls,
-        warnings: preview.warnings,
-    };
-}
-// Characters a terminal or an editor acts on: C0 controls but tab and
-// newline, DEL and C1 controls (ANSI and OSC escapes), line and paragraph
-// separators, and bidirectional marks and overrides ("Trojan Source"). One
-// definition for every output: terminal text replaces them, JSON escapes them.
-export function isUnsafeCodePoint(code) {
-    return ((code <= 0x1f && code !== 0x09 && code !== 0x0a) ||
-        (code >= 0x7f && code <= 0x9f) ||
-        code === 0x061c ||
-        code === 0x200e ||
-        code === 0x200f ||
-        code === 0x2028 ||
-        code === 0x2029 ||
-        (code >= 0x202a && code <= 0x202e) ||
-        (code >= 0x2066 && code <= 0x2069));
-}
-// JSON for files and stdout. JSON.stringify escapes C0 controls but not the
-// rest; model and pull request text reaches these files.
-export function serializeOutput(value, indent = 2) {
-    let out = "";
-    for (const char of JSON.stringify(value, null, indent)) {
-        const code = char.codePointAt(0) ?? 0;
-        out +=
-            code > 0x1f && isUnsafeCodePoint(code) ? `\\u${code.toString(16).padStart(4, "0")}` : char;
-    }
-    return out;
-}
-//# sourceMappingURL=output.js.map