pi-agent-browser-native 0.9.3 → 0.9.5

package/dist/extensions/agent-browser/lib/results/presentation/batch-contracts.js

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

package/dist/extensions/agent-browser/lib/results/presentation/batch-recording.js

@@ -0,0 +1,118 @@
+import { stat } from "node:fs/promises";
+import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
+import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
+import { isCloseCommand } from "../../command-taxonomy.js";
+import { isRecord } from "../../parsing.js";
+import { isPendingRecordingArtifact } from "../artifact-manifest.js";
+async function unverifiedRecordingArtifact(artifact, subcommand) {
+    const { recordingState: _recordingState, willExistOnStop: _willExistOnStop, ...terminal } = artifact;
+    try {
+        const file = await stat(artifact.absolutePath);
+        return {
+            ...terminal,
+            exists: file.isFile(),
+            sizeBytes: file.size,
+            status: file.isFile() ? "unverified" : "missing",
+            subcommand,
+        };
+    }
+    catch (error) {
+        const missing = isRecord(error) && error.code === "ENOENT";
+        return {
+            ...terminal,
+            exists: missing ? false : undefined,
+            status: missing ? "missing" : "unverified",
+            subcommand,
+        };
+    }
+}
+class TerminalBatchRecordings {
+    artifacts = [];
+    pendingBySession = new Map();
+    removed = new Set();
+    session;
+    constructor(sessionName, namespace) {
+        this.session =
+            sessionName !== undefined && sessionName.length > 0
+                ? getAgentBrowserSessionIdentityKey(sessionName, namespace)
+                : "";
+    }
+    removeMatchingPending(artifact, session) {
+        const pending = this.pendingBySession.get(session) ?? [];
+        const matching = pending.map((index) => this.artifacts[index].kind).lastIndexOf(artifact.kind);
+        if (matching !== -1) {
+            const removed = pending.splice(matching, 1).at(0);
+            if (removed !== undefined) {
+                this.removed.add(removed);
+            }
+        }
+        return pending;
+    }
+    append(artifact) {
+        const index = this.artifacts.push(artifact) - 1;
+        if (artifact.command !== "record") {
+            return undefined;
+        }
+        const session = artifact.session !== undefined && artifact.session.length > 0
+            ? getAgentBrowserSessionIdentityKey(artifact.session, artifact.namespace)
+            : "";
+        if (isPendingRecordingArtifact(artifact)) {
+            const pending = this.pendingBySession.get(session) ?? [];
+            pending.push(index);
+            this.pendingBySession.set(session, pending);
+            return undefined;
+        }
+        const pending = this.removeMatchingPending(artifact, session);
+        if (artifact.kind !== "video") {
+            return undefined;
+        }
+        // A terminal video also ends its sheet; a native sheet below replaces this unverified row.
+        const sheets = pending.filter((position) => this.artifacts[position].kind === "image" &&
+            isPendingRecordingArtifact(this.artifacts[position]));
+        return sheets.length > 0 ? sheets : undefined;
+    }
+    getClosePending(step) {
+        const command = step.details.command;
+        if (!step.details.success ||
+            !command ||
+            !isCloseCommand(extractUpstreamCommandTokens(command)[0])) {
+            return [];
+        }
+        return (this.pendingBySession.get(this.session) ?? []).filter((index) => {
+            const current = this.artifacts.at(index);
+            return (current !== undefined && isPendingRecordingArtifact(current) && !this.removed.has(index));
+        });
+    }
+    async abandon(indices, subcommand) {
+        for (const index of indices) {
+            const current = this.artifacts.at(index);
+            if (current && isPendingRecordingArtifact(current) && !this.removed.has(index)) {
+                // Each replacement must finish before later lifecycle rows inspect the same artifact state.
+                // oxlint-disable-next-line no-await-in-loop
+                this.artifacts[index] = await unverifiedRecordingArtifact(current, subcommand);
+            }
+        }
+    }
+    async fold(steps) {
+        for (const step of steps) {
+            for (const artifact of step.presentation.artifacts ?? []) {
+                const sheets = this.append(artifact);
+                if (sheets) {
+                    // Terminal receipt order determines which pending sheet the next row can replace.
+                    // oxlint-disable-next-line no-await-in-loop
+                    await this.abandon(sheets, artifact.subcommand ?? "stop");
+                }
+            }
+            const pending = this.getClosePending(step);
+            if (pending.length > 0) {
+                // Close abandonment must finish before any later recording receipt is folded.
+                // oxlint-disable-next-line no-await-in-loop
+                await this.abandon(pending, "close-abandoned");
+            }
+        }
+        return this.artifacts.filter((_, index) => !this.removed.has(index));
+    }
+}
+export async function coalesceTerminalBatchRecordingArtifacts(steps, sessionName, namespace) {
+    return new TerminalBatchRecordings(sessionName, namespace).fold(steps);
+}

package/dist/extensions/agent-browser/lib/results/presentation/batch-redaction.js

@@ -0,0 +1,68 @@
+import { extractUpstreamCommandTokens } from "../../argv-descriptor.js";
+import { redactSensitiveText, redactSensitiveValue } from "../../runtime-redaction.js";
+import { isRecord } from "../../parsing.js";
+import { getClipboardWritePayloadCandidates, redactClipboardPermissionErrorValue, } from "./errors.js";
+export function hasModelFacingArgRedaction(args) {
+    return (args?.some((arg) => arg === "[REDACTED]" || arg.includes("%5BREDACTED%5D") || arg.includes("[REDACTED]")) === true);
+}
+function getPasswordValues(tokens) {
+    const values = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        const next = tokens.at(index + 1);
+        if (token === "--password" && next !== undefined && next.length > 0) {
+            values.push(next);
+        }
+        else if (token.startsWith("--password=")) {
+            values.push(token.slice("--password=".length));
+        }
+    }
+    return values;
+}
+function getStatefulValue(tokens) {
+    if (tokens[0] === "cookies" && tokens[1] === "set" && !tokens.slice(2).includes("--curl")) {
+        return tokens.at(3);
+    }
+    if (tokens[0] === "storage" &&
+        ["local", "session"].includes(tokens[1] ?? "") &&
+        tokens[2] === "set") {
+        return tokens.at(4);
+    }
+    return undefined;
+}
+function getStatefulCommandSensitiveValues(command) {
+    if (!command) {
+        return [];
+    }
+    const tokens = extractUpstreamCommandTokens(command);
+    const statefulValue = getStatefulValue(tokens);
+    const values = getPasswordValues(tokens);
+    if (statefulValue !== undefined) {
+        values.unshift(statefulValue);
+    }
+    return values.filter((value) => value.length > 0);
+}
+function redactExactValues(value, sensitiveValues) {
+    if (sensitiveValues.length === 0) {
+        return redactSensitiveValue(value);
+    }
+    if (typeof value === "string") {
+        let redacted = value;
+        for (const sensitive of sensitiveValues) {
+            redacted = redacted.split(sensitive).join("[REDACTED]");
+        }
+        return redactSensitiveText(redacted);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactExactValues(item, sensitiveValues));
+    }
+    if (!isRecord(value)) {
+        return value;
+    }
+    return redactSensitiveValue(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactExactValues(item, sensitiveValues)])));
+}
+export function redactBatchStepErrorData(command, value) {
+    return command?.[0] === "clipboard"
+        ? redactSensitiveValue(redactClipboardPermissionErrorValue({ command: "clipboard", subcommand: command[1] }, value, getClipboardWritePayloadCandidates(command)))
+        : redactExactValues(value, getStatefulCommandSensitiveValues(command));
+}

package/dist/extensions/agent-browser/lib/results/presentation/batch-rendering.js

@@ -0,0 +1,135 @@
+import { getPresentationImages } from "./content.js";
+function getTypedTextLength(command) {
+    return command?.[0] === "keyboard" && command[1] === "type" && typeof command.at(2) === "string"
+        ? Array.from(command[2]).length
+        : undefined;
+}
+function getWaitDelayMs(command) {
+    const delay = command?.at(1);
+    return command?.[0] === "wait" && delay !== undefined && /^\d+$/.test(delay) ? delay : undefined;
+}
+function getTypingDelayBetween(steps, index) {
+    const delay = steps.at(index + 1)?.details;
+    const next = steps.at(index + 2)?.details;
+    if (!delay ||
+        !next ||
+        !delay.success ||
+        !next.success ||
+        getTypedTextLength(next.command) === undefined) {
+        return undefined;
+    }
+    return getWaitDelayMs(delay.command);
+}
+function getTypedPulse(steps, index) {
+    const step = steps.at(index)?.details;
+    if (!step || !step.success) {
+        return undefined;
+    }
+    const chars = getTypedTextLength(step.command);
+    if (chars === undefined) {
+        return undefined;
+    }
+    const delay = getTypingDelayBetween(steps, index);
+    return { chars, delay, nextIndex: index + (delay === undefined ? 1 : 2) };
+}
+function scanTypingRun(steps, start) {
+    let index = start;
+    let typedCharCount = 0;
+    let typedStepCount = 0;
+    let delayMs;
+    while (index < steps.length) {
+        const pulse = getTypedPulse(steps, index);
+        if (!pulse) {
+            break;
+        }
+        typedCharCount += pulse.chars;
+        typedStepCount += 1;
+        if (pulse.delay !== undefined) {
+            if (delayMs !== undefined && delayMs !== pulse.delay) {
+                return undefined;
+            }
+            delayMs = pulse.delay;
+        }
+        index = pulse.nextIndex;
+    }
+    return typedStepCount >= 2 ? { nextIndex: index, typedCharCount, delayMs } : undefined;
+}
+function getTypingStart(steps, index) {
+    const details = steps.at(index)?.details;
+    if (!details || !details.success) {
+        return undefined;
+    }
+    if (details.command?.[0] === "focus" && typeof details.command.at(1) === "string") {
+        return { firstIndex: details.index, typingIndex: index + 1, target: details.command[1] };
+    }
+    return { firstIndex: details.index, typingIndex: index };
+}
+function getPressAfterTyping(steps, index) {
+    const details = steps.at(index)?.details;
+    if (!details || !details.success || details.command?.[0] !== "press") {
+        return undefined;
+    }
+    return details.command.at(1);
+}
+function formatTypedSequenceSummary(steps, startIndex) {
+    const start = getTypingStart(steps, startIndex);
+    if (!start) {
+        return undefined;
+    }
+    const run = scanTypingRun(steps, start.typingIndex);
+    if (!run) {
+        return undefined;
+    }
+    const pressedKey = getPressAfterTyping(steps, run.nextIndex);
+    const nextIndex = run.nextIndex + (pressedKey !== undefined ? 1 : 0);
+    const firstStep = start.firstIndex + 1;
+    const lastIndex = steps.at(nextIndex - 1)?.details.index;
+    const lastStep = lastIndex === undefined ? undefined : lastIndex + 1;
+    const range = lastStep !== undefined && lastStep > firstStep ? `${firstStep}-${lastStep}` : String(firstStep);
+    return { nextIndex, text: formatTypingSummaryText(range, start.target, run, pressedKey) };
+}
+function formatTypingSummaryText(range, target, run, pressedKey) {
+    const label = target !== undefined && target.length > 0 ? `type ${target}` : "keyboard type";
+    const lines = [
+        `Step ${range} — ${label} (succeeded)`,
+        `Typed ${run.typedCharCount} char${run.typedCharCount === 1 ? "" : "s"}${run.delayMs !== undefined ? ` with delayMs=${run.delayMs}` : ""}.`,
+    ];
+    if (pressedKey !== undefined && pressedKey.length > 0) {
+        lines.push(`Pressed ${pressedKey}.`);
+    }
+    return lines.join("\n");
+}
+function formatBatchStepDetails(step) {
+    const details = step.details;
+    const images = getPresentationImages(step.presentation).length;
+    const lines = [
+        `Step ${details.index + 1} — ${details.commandText} (${details.success ? "succeeded" : "failed"})`,
+    ];
+    if (details.text.length > 0) {
+        lines.push(details.text);
+    }
+    if (images > 0) {
+        lines.push(`(${images} inline image attachment${images === 1 ? "" : "s"} below)`);
+    }
+    return lines.join("\n");
+}
+export function formatBatchStepsText(steps) {
+    if (steps.length === 0) {
+        return "(no batch steps)";
+    }
+    const lines = [];
+    for (let index = 0; index < steps.length;) {
+        const sequence = formatTypedSequenceSummary(steps, index);
+        if (sequence) {
+            lines.push(sequence.text);
+            index = sequence.nextIndex;
+            continue;
+        }
+        const step = steps.at(index);
+        if (step) {
+            lines.push(formatBatchStepDetails(step));
+        }
+        index += 1;
+    }
+    return lines.join("\n\n");
+}

package/dist/extensions/agent-browser/lib/results/presentation/batch-step.js

@@ -0,0 +1,227 @@
+import { parseCommandInfo } from "../../argv-descriptor.js";
+import { isRecord } from "../../parsing.js";
+import { redactInvocationArgs } from "../../runtime-redaction.js";
+import { buildAgentBrowserNextActions } from "../action-recommendations.js";
+import { buildPendingWebMcpNextActions } from "../recovery-next-actions.js";
+import { classifyAgentBrowserFailureCategory } from "../categories.js";
+import { detectConfirmationRequired } from "../confirmation.js";
+import { applyNamespaceToNextActions, withOptionalSessionArgs } from "../next-actions.js";
+import { buildNetworkRouteDiagnostics } from "../network-routes.js";
+import { extractAgentBrowserLifecycle, stringifyModelFacing } from "./common.js";
+import { classifyPresentationSuccessCategory } from "./artifacts.js";
+import { formatBatchStepCommand, getPresentationPaths, getPresentationText, isStringArray, } from "./content.js";
+import { buildPageChangeSummary } from "./navigation.js";
+import { appendSelectorRecoveryHint, isOverlayBlockedClickError } from "./errors.js";
+import { hasModelFacingArgRedaction, redactBatchStepErrorData } from "./batch-redaction.js";
+function createStepIdentity(item, index) {
+    const command = isStringArray(item.command) ? item.command : undefined;
+    const redactedCommand = command ? redactInvocationArgs(command) : undefined;
+    return {
+        command,
+        redactedCommand,
+        index,
+        commandText: formatBatchStepCommand(hasModelFacingArgRedaction(redactedCommand) ? redactedCommand : command, index),
+        lifecycle: extractAgentBrowserLifecycle(item.result),
+    };
+}
+function formatBatchStepError(error) {
+    const text = stringifyModelFacing(error).trim();
+    return appendSelectorRecoveryHint(text.length > 0 ? `Error: ${text}` : "Error: batch step failed.");
+}
+function buildWaitTextAssertionFailureAction(sessionName) {
+    return {
+        id: "inspect-after-text-assertion-failure",
+        params: { args: withOptionalSessionArgs(sessionName, ["snapshot", "-i"]) },
+        reason: "Inspect the current page after the text assertion failed before concluding the expected text is absent.",
+        safety: "Read-only snapshot; use current refs or visible text from this page before retrying the assertion.",
+        tool: "agent_browser",
+    };
+}
+function describeStepFailure(command, error) {
+    const data = redactBatchStepErrorData(command, error);
+    const text = formatBatchStepError(data);
+    return {
+        data,
+        text,
+        category: classifyAgentBrowserFailureCategory({
+            args: command,
+            command: command?.[0],
+            errorText: text,
+        }),
+        confirmationId: detectConfirmationRequired(error)?.id,
+        overlayBlocked: isOverlayBlockedClickError(command?.[0], text, command),
+    };
+}
+function buildFailedStepActions(command, failure, scope) {
+    const recovery = buildAgentBrowserNextActions({
+        args: command,
+        command: command?.[0],
+        confirmationId: failure.confirmationId,
+        failureCategory: failure.category,
+        overlayBlockedClick: failure.overlayBlocked,
+        resultCategory: "failure",
+        sessionName: scope.sessionName,
+        subcommand: command?.[1],
+    });
+    const waitAction = command?.[0] === "wait" && command.includes("--text")
+        ? [buildWaitTextAssertionFailureAction(scope.sessionName)]
+        : [];
+    const seen = new Set();
+    const actions = [...waitAction, ...(recovery ?? [])].filter((action) => {
+        if (seen.has(action.id)) {
+            return false;
+        }
+        seen.add(action.id);
+        return true;
+    });
+    return applyNamespaceToNextActions(actions.length > 0 ? actions : undefined, scope.namespace);
+}
+function buildFailedStep(item, identity, scope) {
+    const failure = describeStepFailure(identity.command, item.error);
+    const { data, text, category: failureCategory } = failure;
+    const nextActions = buildFailedStepActions(identity.command, failure, scope);
+    const presentation = {
+        content: [{ type: "text", text }],
+        failureCategory,
+        nextActions,
+        resultCategory: "failure",
+        summary: text,
+    };
+    return {
+        presentation,
+        details: {
+            artifactVerification: presentation.artifactVerification,
+            artifacts: presentation.artifacts,
+            command: identity.redactedCommand,
+            commandText: identity.commandText,
+            data,
+            failureCategory,
+            index: identity.index,
+            lifecycle: identity.lifecycle,
+            nextActions,
+            resultCategory: "failure",
+            success: false,
+            summary: text,
+            text,
+        },
+    };
+}
+function buildNestedRequest(options, command) {
+    const commandInfo = parseCommandInfo(command ?? []);
+    return {
+        modelVisible: options.modelVisible,
+        artifactManifest: options.artifactManifest,
+        artifactMaxUpdatedAtMs: options.artifactMaxUpdatedAtMs,
+        artifactMinUpdatedAtMs: options.artifactMinUpdatedAtMs,
+        artifactRequest: options.artifactRequest,
+        commandInfo: command ? { ...commandInfo, commandTokens: command } : commandInfo,
+        cwd: options.cwd,
+        args: command,
+        envelope: {
+            data: options.item.result,
+            success: options.item.success !== false,
+            error: options.item.error,
+        },
+        errorText: options.item.success === false
+            ? formatBatchStepError(redactBatchStepErrorData(command, options.item.error))
+            : undefined,
+        piCleanupOwnership: options.piCleanupOwnership,
+        networkRouteDiagnostics: commandInfo.command === "network" && commandInfo.subcommand === "requests"
+            ? buildNetworkRouteDiagnostics(options.item.result, options.networkRoutes)
+            : undefined,
+        namespace: options.namespace,
+        persistentArtifactStore: options.persistentArtifactStore,
+        sessionName: options.sessionName,
+    };
+}
+function isPendingWebMcpMutation(command, data) {
+    return (command.command === "webmcp" &&
+        ["invoke", "result"].includes(command.subcommand ?? "") &&
+        isRecord(data) &&
+        data.status === "pending");
+}
+function buildStandardStepActions(presentation, command, sessionName) {
+    return (presentation.nextActions ??
+        buildAgentBrowserNextActions({
+            artifacts: presentation.artifacts,
+            args: command,
+            command: command?.[0],
+            failureCategory: presentation.failureCategory,
+            resultCategory: presentation.resultCategory !== "failure" ? "success" : "failure",
+            savedFilePath: presentation.savedFilePath,
+            sessionName,
+            subcommand: command?.[1],
+            successCategory: presentation.successCategory,
+        }));
+}
+function getStepNextActions(presentation, commandInfo, command, scope) {
+    const actions = presentation.resultCategory !== "failure" &&
+        isPendingWebMcpMutation(commandInfo, presentation.data)
+        ? buildPendingWebMcpNextActions(scope.sessionName)
+        : buildStandardStepActions(presentation, command, scope.sessionName);
+    return applyNamespaceToNextActions(actions, scope.namespace);
+}
+function buildStepDetails(presentation, identity, command, scope) {
+    const fullOutputPaths = getPresentationPaths({
+        primaryPath: presentation.fullOutputPath,
+        secondaryPaths: presentation.fullOutputPaths,
+    });
+    const imagePaths = getPresentationPaths({
+        primaryPath: presentation.imagePath,
+        secondaryPaths: presentation.imagePaths,
+    });
+    const text = getPresentationText(presentation);
+    const succeeded = presentation.resultCategory !== "failure";
+    const nextActions = getStepNextActions(presentation, command, identity.command, scope);
+    return {
+        artifactVerification: presentation.artifactVerification,
+        artifacts: presentation.artifacts,
+        command: identity.redactedCommand,
+        commandText: identity.commandText,
+        data: presentation.data,
+        failureCategory: succeeded ? undefined : presentation.failureCategory,
+        fullOutputPath: fullOutputPaths.at(0),
+        fullOutputPaths: fullOutputPaths.length > 0 ? fullOutputPaths : undefined,
+        imagePath: imagePaths.at(0),
+        imagePaths: imagePaths.length > 0 ? imagePaths : undefined,
+        imageObservations: presentation.imageObservations,
+        index: identity.index,
+        lifecycle: identity.lifecycle,
+        networkRouteDiagnostics: presentation.networkRouteDiagnostics,
+        nextActions,
+        pageChangeSummary: buildPageChangeSummary({
+            artifacts: presentation.artifacts,
+            commandInfo: command,
+            data: presentation.data,
+            nextActions,
+            savedFilePath: presentation.savedFilePath,
+            summary: presentation.summary,
+        }),
+        resultCategory: succeeded ? "success" : "failure",
+        savedFile: presentation.savedFile,
+        savedFilePath: presentation.savedFilePath,
+        success: succeeded,
+        successCategory: succeeded
+            ? classifyPresentationSuccessCategory({
+                artifactVerification: presentation.artifactVerification,
+                artifacts: presentation.artifacts,
+                savedFile: presentation.savedFile,
+            })
+            : undefined,
+        summary: presentation.summary,
+        text: text.length > 0 ? text : presentation.summary,
+    };
+}
+export async function buildBatchStepPresentation(options) {
+    const identity = createStepIdentity(options.item, options.index);
+    const scope = { namespace: options.namespace, sessionName: options.sessionName };
+    if (options.item.success === false && identity.command?.[0] !== "record") {
+        return buildFailedStep(options.item, identity, scope);
+    }
+    const request = buildNestedRequest(options, identity.command);
+    const presentation = await options.buildNestedToolPresentation(request);
+    return {
+        details: buildStepDetails(presentation, identity, request.commandInfo, scope),
+        presentation,
+    };
+}

package/dist/extensions/agent-browser/lib/results/presentation/batch-summary.js

@@ -0,0 +1,91 @@
+import { formatBatchStepsText } from "./batch-rendering.js";
+import { buildPageChangeSummary } from "./navigation.js";
+function getBatchFailure(steps) {
+    const failed = steps.filter((step) => !step.details.success);
+    const first = failed.at(0);
+    return first
+        ? {
+            failedStep: first.details,
+            failureCount: failed.length,
+            successCount: steps.length - failed.length,
+            totalCount: steps.length,
+        }
+        : undefined;
+}
+function countUnverifiedMutations(steps) {
+    return steps.filter((step) => step.details.pageChangeSummary?.changeType === "mutation" &&
+        !step.details.pageChangeSummary.observed).length;
+}
+export function summarizeBatchStatus(steps, requestedSummary) {
+    const failure = getBatchFailure(steps);
+    const summary = failure
+        ? `Batch failed: ${failure.successCount}/${failure.totalCount} succeeded`
+        : requestedSummary;
+    const mutations = countUnverifiedMutations(steps);
+    return {
+        failure,
+        summary,
+        header: failure
+            ? [
+                summary,
+                `First failing step: ${failure.failedStep.index + 1} — ${failure.failedStep.commandText}`,
+                failure.failureCount > 1
+                    ? `${failure.failureCount} steps failed. See the per-step results below.`
+                    : "See the per-step results below.",
+            ].join("\n")
+            : undefined,
+        mutationEvidenceText: mutations > 0
+            ? `Mutation evidence: ${mutations} action result${mutations === 1 ? " proves" : "s prove"} dispatch only, not application state change. Use explicit later assertions or external receipts as postconditions; fixed waits are not postconditions.`
+            : undefined,
+    };
+}
+export function formatBatchStatusText(steps, status, modelVisible) {
+    return [
+        status.header,
+        status.mutationEvidenceText,
+        modelVisible === false ? "" : formatBatchStepsText(steps),
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n\n");
+}
+export function serializeBatchData(steps) {
+    return steps.map(({ details }) => details.success
+        ? { command: details.command, result: details.data, success: true }
+        : {
+            command: details.command,
+            error: details.text,
+            ...(details.command?.[0] === "record" ? { result: details.data } : {}),
+            success: false,
+        });
+}
+function formatBatchChangeText(observed, unverified) {
+    if (observed === 0) {
+        return `batch → ${unverified} action${unverified === 1 ? "" : "s"} dispatched → application change unverified`;
+    }
+    return `batch → ${observed} observed change${observed === 1 ? "" : "s"}${unverified > 0 ? `; ${unverified} dispatched action${unverified === 1 ? "" : "s"} unverified` : ""}`;
+}
+export function buildBatchPageChangeSummary(steps, artifacts, nextActions, summary) {
+    if (artifacts.length > 0) {
+        return buildPageChangeSummary({
+            artifacts,
+            commandInfo: { command: "batch" },
+            data: serializeBatchData(steps),
+            nextActions,
+            summary,
+        });
+    }
+    const changed = steps
+        .map((step) => step.details)
+        .filter((details) => details.pageChangeSummary !== undefined);
+    if (changed.length === 0) {
+        return undefined;
+    }
+    const observed = changed.filter((details) => details.pageChangeSummary?.observed === true).length;
+    return {
+        changeType: "mutation",
+        command: "batch",
+        nextActionIds: nextActions?.map((action) => action.id),
+        observed: observed > 0,
+        summary: formatBatchChangeText(observed, countUnverifiedMutations(steps)),
+    };
+}