rea-agents 6.2.0 → 6.3.0

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -6,6 +6,10 @@ import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 const OPERATION = "capture_browser_scenario";
+const throwIfScenarioCancelled = (signal) => {
+    if (signal?.aborted === true)
+        throw new BrowserObservationError(OPERATION, "cancelled");
+};
 /** Owns one browser connection and optional private profile through cleanup retries. */
 export class PlaywrightScenarioBrowserCleanupOwner {
     resources;
@@ -22,9 +26,10 @@ export class PlaywrightScenarioBrowserCleanupOwner {
         const cleanup = this.#closePromise ?? this.#closeResources(finishEvents);
         if (this.#closePromise === undefined) {
             this.#closePromise = cleanup;
-            void cleanup.catch(() => {
+            void cleanup.then(() => this.resources.onSettled?.(this.#browserClosed), () => {
                 if (this.#closePromise === cleanup)
                     this.#closePromise = undefined;
+                this.resources.onSettled?.(this.#browserClosed);
             });
         }
         return this.#awaitCleanup(cleanup, signal);
@@ -86,6 +91,79 @@ export class PlaywrightScenarioBrowserCleanupOwner {
             throw new AggregateError(failures, "Browser session cleanup failed");
     }
 }
+const attachedScenarioAdmissions = new Map();
+const releaseAttachedScenario = (key, admission) => {
+    const waiter = admission.waiters.shift();
+    if (waiter === undefined) {
+        admission.active = false;
+        if (admission.cleanupOwner === undefined &&
+            attachedScenarioAdmissions.get(key) === admission)
+            attachedScenarioAdmissions.delete(key);
+        return;
+    }
+    if (waiter.onAbort !== undefined)
+        waiter.signal?.removeEventListener("abort", waiter.onAbort);
+    if (waiter.signal?.aborted === true) {
+        waiter.reject(new BrowserObservationError(OPERATION, "cancelled"));
+        releaseAttachedScenario(key, admission);
+        return;
+    }
+    waiter.resolve(createAttachedScenarioRelease(key, admission));
+};
+const createAttachedScenarioRelease = (key, admission) => {
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        releaseAttachedScenario(key, admission);
+    };
+};
+const acquireAttachedScenario = (scenario, signal) => {
+    if (signal?.aborted === true)
+        return Promise.reject(new BrowserObservationError(OPERATION, "cancelled"));
+    const key = JSON.stringify([scenario.cdp_endpoint, scenario.target_id]);
+    const admission = attachedScenarioAdmissions.get(key) ??
+        {
+            active: false,
+            waiters: [],
+            cleanupOwner: undefined,
+        };
+    attachedScenarioAdmissions.set(key, admission);
+    return new Promise((resolve, reject) => {
+        const grant = (release) => resolve({ admission, release });
+        if (!admission.active) {
+            admission.active = true;
+            grant(createAttachedScenarioRelease(key, admission));
+            return;
+        }
+        const waiter = {
+            signal,
+            resolve: (release) => grant(release),
+            reject,
+            onAbort: undefined,
+        };
+        admission.waiters.push(waiter);
+        if (signal !== undefined) {
+            const onAbort = () => {
+                const index = admission.waiters.indexOf(waiter);
+                if (index < 0)
+                    return;
+                admission.waiters.splice(index, 1);
+                signal.removeEventListener("abort", onAbort);
+                reject(new BrowserObservationError(OPERATION, "cancelled"));
+                if (!admission.active && admission.waiters.length === 0)
+                    releaseAttachedScenario(key, admission);
+            };
+            waiter.onAbort = onAbort;
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+        }
+    });
+};
 const allowedBrowserEnvironment = (environment) => {
     const allowed = [
         "DBUS_SESSION_BUS_ADDRESS",
@@ -106,12 +184,14 @@ const allowedBrowserEnvironment = (environment) => {
         .map((name) => [name, environment[name]])
         .filter((entry) => entry[1] !== undefined));
 };
-const findConnectedPage = async (browser, targetId) => {
+const findConnectedPage = async (browser, targetId, signal) => {
     for (const context of browser.contexts())
         for (const page of context.pages()) {
             const session = await context.newCDPSession(page);
             try {
+                throwIfScenarioCancelled(signal);
                 const { targetInfo } = await session.send("Target.getTargetInfo");
+                throwIfScenarioCancelled(signal);
                 if (targetInfo.targetId !== targetId)
                     continue;
                 return { context, page };
@@ -122,33 +202,33 @@ const findConnectedPage = async (browser, targetId) => {
         }
     throw new BrowserObservationError(OPERATION, "target_not_found");
 };
-const configureAttachedEnvironment = async (context, page, scenario) => {
-    await page.setViewportSize({
-        width: scenario.environment.viewport.width,
-        height: scenario.environment.viewport.height,
-    });
+const configureAttachedEnvironment = async (context, page, environment, signal) => {
+    // setViewportSize also resizes the external browser window. The scenario's
+    // CDP metrics override below supplies the viewport and expires on disconnect.
     await page.emulateMedia({
-        colorScheme: scenario.environment.color_scheme,
-        reducedMotion: scenario.environment.reduced_motion,
+        colorScheme: environment.color_scheme,
+        reducedMotion: environment.reduced_motion,
     });
+    throwIfScenarioCancelled(signal);
     const session = await context.newCDPSession(page);
-    try {
-        await session.send("Emulation.setDeviceMetricsOverride", {
-            width: scenario.environment.viewport.width,
-            height: scenario.environment.viewport.height,
-            deviceScaleFactor: scenario.environment.viewport.device_scale_factor,
-            mobile: false,
-        });
-        await session.send("Emulation.setLocaleOverride", {
-            locale: scenario.environment.locale,
-        });
-        await session.send("Emulation.setTimezoneOverride", {
-            timezoneId: scenario.environment.timezone,
-        });
-    }
-    finally {
-        await session.detach();
-    }
+    throwIfScenarioCancelled(signal);
+    // Chromium resets these overrides when the CDP session detaches. Keep it on
+    // the scenario transport until cleanup disconnects the attached browser.
+    await session.send("Emulation.setDeviceMetricsOverride", {
+        width: environment.viewport.width,
+        height: environment.viewport.height,
+        deviceScaleFactor: environment.viewport.device_scale_factor,
+        mobile: false,
+        dontSetVisibleSize: true,
+    });
+    throwIfScenarioCancelled(signal);
+    await session.send("Emulation.setLocaleOverride", {
+        locale: environment.locale,
+    });
+    throwIfScenarioCancelled(signal);
+    await session.send("Emulation.setTimezoneOverride", {
+        timezoneId: environment.timezone,
+    });
 };
 /** Preserve an operation failure while reporting any incomplete cleanup. */
 export const failBrowserScenarioOperation = async (cleanup, primaryFailure, fallbackCleanupResources = ["browser_transport"]) => {
@@ -174,28 +254,51 @@ export const failBrowserScenarioOperation = async (cleanup, primaryFailure, fall
     }
     throw primaryFailure;
 };
-/** Launch or attach using the caller-selected environment and browser engine. */
-export const openPlaywrightScenarioBrowser = async (scenario, environment, launcher = chromium) => {
-    if (scenario.browser.mode === "connect") {
-        const browser = await launcher.connectOverCDP(scenario.browser.cdp_endpoint, { timeout: 0 });
+const openAttachedScenarioBrowser = async (browserRequest, environment, launcher, signal) => {
+    const lease = await acquireAttachedScenario(browserRequest, signal);
+    let cleanupOwner;
+    try {
+        const priorOwner = lease.admission.cleanupOwner;
+        if (priorOwner !== undefined)
+            await priorOwner.close();
+        throwIfScenarioCancelled(signal);
+        const browser = await launcher.connectOverCDP(browserRequest.cdp_endpoint);
         const cleanup = new PlaywrightScenarioBrowserCleanupOwner({
             closeBrowser: () => browser.close(),
+            onSettled: (browserClosed) => {
+                if (browserClosed && lease.admission.cleanupOwner === cleanup)
+                    lease.admission.cleanupOwner = undefined;
+                lease.release();
+            },
             removeProfile: undefined,
         });
-        try {
-            const target = await findConnectedPage(browser, scenario.browser.target_id);
-            await configureAttachedEnvironment(target.context, target.page, scenario);
-            return {
-                ...target,
-                browser,
-                profilePath: undefined,
-                cleanup,
-            };
-        }
-        catch (cause) {
-            return failBrowserScenarioOperation(() => cleanup.close(), cause);
+        cleanupOwner = cleanup;
+        lease.admission.cleanupOwner = cleanup;
+        throwIfScenarioCancelled(signal);
+        const target = await withPlaywrightExecutionBoundary(() => findConnectedPage(browser, browserRequest.target_id, signal), undefined, signal);
+        throwIfScenarioCancelled(signal);
+        await withPlaywrightExecutionBoundary(() => configureAttachedEnvironment(target.context, target.page, environment, signal), undefined, signal);
+        return {
+            ...target,
+            browser,
+            profilePath: undefined,
+            cleanup,
+        };
+    }
+    catch (cause) {
+        if (cleanupOwner === undefined) {
+            lease.release();
+            throw cause;
         }
+        const cleanup = cleanupOwner;
+        return failBrowserScenarioOperation(() => cleanup.close(), cause);
     }
+};
+/** Launch or attach using the caller-selected environment and browser engine. */
+export const openPlaywrightScenarioBrowser = async (scenario, environment, options = {}) => {
+    const launcher = options.launcher ?? chromium;
+    if (scenario.browser.mode === "connect")
+        return openAttachedScenarioBrowser(scenario.browser, scenario.environment, launcher, options.signal);
     const profilePath = await mkdtemp(join(tmpdir(), "rea-browser-scenario-"));
     let context;
     try {

package/dist/browser/PlaywrightScenarioSession.js

@@ -86,7 +86,9 @@ export class PlaywrightScenarioSession {
         if (secrets === undefined)
             throw new BrowserObservationError(OPERATION, "secret_unavailable");
         const startedAt = Date.now();
-        const opening = openPlaywrightScenarioBrowser(scenario, environment);
+        const opening = openPlaywrightScenarioBrowser(scenario, environment, {
+            signal: options.signal,
+        });
         let opened;
         let events;
         try {
@@ -203,13 +205,3 @@ export class PlaywrightScenarioSession {
         return this.secrets.redact(error instanceof Error ? error.message : "browser action failed");
     }
 }
-/** Production Playwright/CDP session factory. */
-export class PlaywrightScenarioSessionFactory {
-    environment;
-    constructor(environment) {
-        this.environment = environment;
-    }
-    open(scenario, options = {}) {
-        return PlaywrightScenarioSession.open(scenario, this.environment, options);
-    }
-}

package/dist/browser/WebSourceMapFetcher.js

@@ -106,6 +106,12 @@ class SourceMapEncodingError extends Error {
         this.name = "SourceMapEncodingError";
     }
 }
+class SourceMapRedirectLocationError extends Error {
+    constructor(url, location) {
+        super(`Source-map redirect from ${JSON.stringify(url)} supplied an invalid Location URL: ${JSON.stringify(location)}.`);
+        this.name = "SourceMapRedirectLocationError";
+    }
+}
 const fetchOne = async (request, input, signal, host, budget) => {
     if (!approvedUrl(request.fetchUrl, input.allowed_origins))
         return emptySourceMapItem(request, "policy_filtered", "Declared source-map URL is outside the approved exact origins.");
@@ -131,13 +137,25 @@ const fetchOne = async (request, input, signal, host, budget) => {
             throw cause;
         if (cause instanceof SourceMapEncodingError)
             return emptySourceMapItem(request, "invalid", cause.message);
-        return emptySourceMapItem(request, "fetch_failed", cause instanceof SourceMapSizeLimitError
+        return emptySourceMapItem(request, "fetch_failed", cause instanceof SourceMapRedirectLocationError ||
+            cause instanceof SourceMapSizeLimitError ||
+            cause instanceof SourceMapDeadlineError
             ? cause.message
-            : cause instanceof SourceMapDeadlineError
-                ? cause.message
-                : "Source-map fetch or validation failed.");
+            : "Source-map fetch or validation failed.");
     }
 };
+/**
+ * Fetch redirect statuses per WHATWG Fetch (redirect status list:
+ * 301, 302, 303, 307, 308). Single owner for redirect decisions.
+ * 300/304/305/306 carry `Location` without being redirects — following
+ * them would replace the observed failure with an unrelated map.
+ * See https://fetch.spec.whatwg.org/#redirect-status
+ */
+export const isFetchRedirectStatus = (status) => status === 301 ||
+    status === 302 ||
+    status === 303 ||
+    status === 307 ||
+    status === 308;
 const fetchFollowingApprovedRedirects = async (initialUrl, allowedOrigins, signal, host) => {
     let current = initialUrl;
     const visited = new Set();
@@ -163,13 +181,21 @@ const fetchFollowingApprovedRedirects = async (initialUrl, allowedOrigins, signa
             await response.body?.cancel(signal.reason).catch(() => undefined);
             throw signal.reason;
         }
-        if (response.status < 300 || response.status >= 400)
+        // `Location` is a redirect target only for Fetch redirect statuses.
+        // Other 3xx responses retain their own HTTP failure (strict identity:
+        // never replace the observed failure with an unrelated map).
+        if (!isFetchRedirectStatus(response.status))
             return { response, fetchedUrl: current };
         const location = response.headers.get("location");
         if (location === null)
             return { response, fetchedUrl: current };
         await response.body?.cancel();
-        current = new URL(location, current).href;
+        try {
+            current = new URL(location, current).href;
+        }
+        catch {
+            throw new SourceMapRedirectLocationError(current, location);
+        }
     }
 };
 const readBoundedText = async (response, budget, maxBytes, signal) => {

package/dist/browser/assets/ScenarioScriptCapture.js

@@ -14,9 +14,9 @@ const indexResponses = (events) => {
         requests: new Map(),
     };
     for (const event of events) {
-        if (event.kind === "request" && event.transaction_id !== undefined)
+        if (event.kind === "request")
             index.requests.set(event.transaction_id, (index.requests.get(event.transaction_id) ?? 0) + 1);
-        if (event.kind === "response" && event.transaction_id !== undefined)
+        if (event.kind === "response")
             append(index.responses, event.transaction_id, event);
         if (event.kind === "network-content" && event.phase === "response")
             append(index.contents, event.source_event_sequence, event);
@@ -25,33 +25,29 @@ const indexResponses = (events) => {
 };
 const projectRequest = (request, index) => {
     const id = request.transaction_id;
-    const matches = id === undefined ? [] : (index.responses.get(id) ?? []);
+    const matches = index.responses.get(id) ?? [];
     const response = matches.length === 1 ? matches[0] : undefined;
     const bodies = response === undefined ? [] : (index.contents.get(response.sequence) ?? []);
     const body = bodies.length === 1 ? bodies[0]?.body : undefined;
-    const ambiguous = (id !== undefined && index.requests.get(id) !== 1) ||
-        matches.length > 1 ||
-        bodies.length > 1;
+    const ambiguous = index.requests.get(id) !== 1 || matches.length > 1 || bodies.length > 1;
     return {
         source: {
             kind: "scenario-response",
-            transaction_id: id ?? null,
+            transaction_id: id,
             request_sequence: request.sequence,
             response_sequence: ambiguous ? null : (response?.sequence ?? null),
             status: ambiguous ? null : (response?.status ?? null),
         },
         url: request.url.url,
-        content: projectBody(body, id, ambiguous),
+        content: projectBody(body, ambiguous),
     };
 };
 const unavailable = (reason, message) => ({ state: "unavailable", reason, message });
-const projectBody = (body, transactionId, ambiguous) => {
+const projectBody = (body, ambiguous) => {
     if (ambiguous)
         return unavailable("ambiguous-transaction", "The capture does not identify one request, response, and content record for this transaction.");
     if (body === undefined)
-        return unavailable(transactionId === undefined
-            ? "transaction-identity-unavailable"
-            : "response-content-not-retained", "No selected, completed script response bytes were retained for this request.");
+        return unavailable("response-content-not-retained", "No selected, completed script response bytes were retained for this request.");
     if (body.state === "unavailable")
         return unavailable(body.reason, body.message);
     if (body.state !== "captured")

package/dist/cli/coreAnalysisCommands.js

@@ -1,7 +1,7 @@
 import { registerCoreBinaryCommands } from "./coreBinaryCommands.js";
 import { registerCoreNativeCommands } from "./coreNativeCommands.js";
 /** Register core binary and native deep-analysis CLI commands. */
-export const registerCoreAnalysisCommands = (cli, logger, runDirectAnalysis, resultOutput) => {
-    registerCoreBinaryCommands(cli, logger, runDirectAnalysis, resultOutput);
+export const registerCoreAnalysisCommands = (cli, logger, runDirectAnalysis) => {
+    registerCoreBinaryCommands(cli, logger, runDirectAnalysis);
     registerCoreNativeCommands(cli, logger, runDirectAnalysis);
 };

package/dist/cli/coreBinaryCommands.js

@@ -7,9 +7,10 @@ import { logCliCommand } from "../cliLogging.js";
 import { directAnalysisOptions, formatSelectionOption, providerSelectionOption, } from "./options.js";
 import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
 import { withCommandCancellation } from "./commandCancellation.js";
+import { javascriptApplicationOptions } from "../cliObservationOptions.js";
 /** Register provider-neutral binary overview and procedure CLI commands. */
-export const registerCoreBinaryCommands = (cli, logger, runDirectAnalysis, resultOutput) => {
-    registerOverviewCommands(cli, logger, runDirectAnalysis, resultOutput);
+export const registerCoreBinaryCommands = (cli, logger, runDirectAnalysis) => {
+    registerOverviewCommands(cli, logger, runDirectAnalysis);
     registerDecompileCommand(cli, logger, runDirectAnalysis);
     registerFunctionCommand(cli, logger, runDirectAnalysis);
     registerInstructionsCommand(cli, logger, runDirectAnalysis);
@@ -17,7 +18,7 @@ export const registerCoreBinaryCommands = (cli, logger, runDirectAnalysis, resul
     registerXrefsCommand(cli, logger, runDirectAnalysis);
     registerTraceCommand(cli, logger, runDirectAnalysis);
 };
-const registerOverviewCommands = (cli, logger, runDirectAnalysis, resultOutput) => {
+const registerOverviewCommands = (cli, logger, runDirectAnalysis) => {
     const overviewOptions = z.object({
         snapshot: z
             .string()
@@ -32,16 +33,19 @@ const registerOverviewCommands = (cli, logger, runDirectAnalysis, resultOutput)
         args: z.object({
             path: z.string().describe("App, program, or analysis database path"),
         }),
-        options: overviewOptions,
-        run: async ({ args, options, format }) => {
-            const output = resultOutput === undefined
-                ? undefined
-                : { output: resultOutput, command: CLI_COMMANDS.analyze, format };
+        options: overviewOptions.extend({
+            integrityPolicy: javascriptApplicationOptions.shape.integrityPolicy,
+        }),
+        alias: { integrityPolicy: "integrity-policy" },
+        run: async ({ args, options }) => {
             // Route JavaScript targets exactly like analyze-javascript-application,
             // including typed cancellation; cancellation wraps logging so its exit
             // code is not replaced by the logged failure status.
             if (await routesToJavaScriptAnalysis(args.path, options))
-                return withCommandCancellation((signal) => logCliCommand(logger, "analyze", () => runCliJavaScriptApplicationAnalysis({ input_path: resolve(args.path) }, output, signal)));
+                return withCommandCancellation((signal) => logCliCommand(logger, "analyze", () => runCliJavaScriptApplicationAnalysis({
+                    input_path: resolve(args.path),
+                    integrity_policy: options.integrityPolicy,
+                }, signal)));
             return logCliCommand(logger, "analyze", () => runDirectAnalysis(args.path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"])));
         },
     });

package/dist/cli/electronCommands.js

@@ -14,10 +14,10 @@ import { electronPageInspectionOptions, javascriptApplicationOptions, } from "..
 import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
 import { withCommandCancellation } from "./commandCancellation.js";
 /** Register CLI equivalents of the Electron MCP tools. */
-export const registerElectronCommands = (cli, logger, environment, resultOutput) => {
+export const registerElectronCommands = (cli, logger, environment) => {
     registerElectronObservationCommands(cli, logger);
     registerElectronActiveCommand(cli, logger, environment);
-    registerJavaScriptApplicationCommand(cli, logger, resultOutput);
+    registerJavaScriptApplicationCommand(cli, logger);
     registerJavaScriptRuntimeReconciliationCommand(cli, logger);
 };
 const registerElectronActiveCommand = (cli, logger, environment) => {
@@ -107,20 +107,19 @@ const registerElectronPageInspection = (cli, logger) => {
         }),
     });
 };
-const registerJavaScriptApplicationCommand = (cli, logger, resultOutput) => {
+const registerJavaScriptApplicationCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.analyzeJavaScriptApplication, {
         description: "Statically reconstruct a local JavaScript/Electron application",
         args: z.object({
             path: z.string().describe("ASAR or extracted application path"),
         }),
         options: javascriptApplicationOptions,
-        run: ({ args, options, format }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, () => runCliJavaScriptApplicationAnalysis({ input_path: args.path, format: options.artifactFormat }, resultOutput === undefined
-            ? undefined
-            : {
-                output: resultOutput,
-                command: CLI_COMMANDS.analyzeJavaScriptApplication,
-                format,
-            }, signal))),
+        alias: { integrityPolicy: "integrity-policy" },
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, () => runCliJavaScriptApplicationAnalysis({
+            input_path: args.path,
+            format: options.artifactFormat,
+            integrity_policy: options.integrityPolicy,
+        }, signal))),
     });
 };
 const electronObservationContext = async () => {

package/dist/cli/javascriptApplicationAnalysis.js

@@ -2,8 +2,7 @@ import { analyzeJavaScriptApplication } from "../application/javascript/JavaScri
 import { createProgressReporter } from "../application/ProgressReporter.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 /** Execute the shared one-shot CLI boundary for static JavaScript analysis. */
-export const runCliJavaScriptApplicationAnalysis = async (input, output, signal) => {
-    const started = performance.now();
+export const runCliJavaScriptApplicationAnalysis = async (input, signal) => {
     const progress = createProgressReporter(async (update) => {
         process.stderr.write(`${JSON.stringify({ rea_progress: update })}\n`);
     }, { minimumIntervalMs: 0 });
@@ -11,16 +10,7 @@ export const runCliJavaScriptApplicationAnalysis = async (input, output, signal)
         progress,
         ...(signal === undefined ? {} : { signal }),
     });
-    const value = result.ok ? result.value : cliError(result.error);
-    if (output !== undefined &&
-        (await output.output.write(value, {
-            command: output.command,
-            format: output.format,
-            duration: `${Math.round(performance.now() - started)}ms`,
-        })))
-        // Keep failures visible to command logging after the stream has handled stdout.
-        return result.ok ? undefined : value;
-    return value;
+    return result.ok ? result.value : cliError(result.error);
 };
 const cliError = (error) => ({
     error: "JavaScript application analysis failed",

package/dist/cli/jsonOutput.js

@@ -1,7 +1,7 @@
 import { bufferedJsonParts, jsonParts } from "../domain/jsonSerialization.js";
 /** Write ordinary JSON without constructing a document-sized string. */
 export const writeJsonOutput = async (value, destination, format = "json") => {
-    for (const part of bufferedJsonParts(documentParts(value, format)))
+    for (const part of bufferedJsonParts(jsonOutputParts(value, format)))
         await writePart(destination, part);
 };
 const writePart = (destination, part) => new Promise((resolve, reject) => {
@@ -25,7 +25,8 @@ const writePart = (destination, part) => new Promise((resolve, reject) => {
         reject(cause);
     }
 });
-function* documentParts(value, format) {
+/** The exact formatted document, including its final newline. */
+export function* jsonOutputParts(value, format) {
     if (format === "jsonl" && Array.isArray(value)) {
         for (const item of value) {
             yield* jsonParts(item);