pi-agent-browser-native 0.9.5 → 0.9.6

package/dist/extensions/agent-browser/lib/results/presentation/artifact-format.js

@@ -1,138 +0,0 @@
-import { isPendingRecordingArtifact } from "../artifact-manifest.js";
-import { formatRecordingReceipt } from "../recording.js";
-import { isDownloadWaitSubcommand } from "./artifact-files.js";
-export function formatByteCount(bytes) {
-    if (bytes < 1_024) {
-        return `${bytes} B`;
-    }
-    if (bytes < 1_024 * 1_024) {
-        return `${(bytes / 1_024).toFixed(1)} KiB`;
-    }
-    return `${(bytes / (1_024 * 1_024)).toFixed(1)} MiB`;
-}
-function formatPreviousRecordingLabel(artifact) {
-    if (artifact.status === "stale") {
-        return "Previous recording stale";
-    }
-    return artifact.exists === false ? "Previous recording missing" : "Previous recording saved";
-}
-function formatRecordingLabel(artifact) {
-    const previous = artifact.subcommand === "restart-previous";
-    if (artifact.status === "failed") {
-        return previous ? "Previous recording failed" : "Recording failed";
-    }
-    if (artifact.status === "unverified") {
-        return previous ? "Previous recording unverified" : "Recording unverified";
-    }
-    if (artifact.command === "record" && previous) {
-        return formatPreviousRecordingLabel(artifact);
-    }
-    if (!isPendingRecordingArtifact(artifact)) {
-        return artifact.status === "saved"
-            ? "Saved recording"
-            : "Recording reported; file not verified";
-    }
-    return formatPendingRecordingLabel(artifact.subcommand);
-}
-function formatPendingRecordingLabel(subcommand) {
-    if (subcommand === "stop") {
-        return "Recording finalization pending";
-    }
-    return subcommand === "restart"
-        ? "Recording restarted; output will be written on stop"
-        : "Recording started; output will be written on stop";
-}
-function formatDownloadLabel(artifact) {
-    const wait = artifact.command === "wait" && isDownloadWaitSubcommand(artifact.subcommand);
-    if (artifact.exists !== true) {
-        return wait
-            ? "Download event reported; file not verified"
-            : "Download reported; file not verified";
-    }
-    return wait ? "Download saved and verified" : "Downloaded file verified";
-}
-function formatImageLabel(artifact) {
-    const diff = artifact.command === "diff" && artifact.subcommand === "screenshot";
-    if (artifact.exists !== true) {
-        return diff ? "Diff image reported; file not verified" : "Image reported; file not verified";
-    }
-    return diff ? "Saved diff image" : "Saved image";
-}
-function formatArtifactLabel(artifact) {
-    switch (artifact.kind) {
-        case "download":
-            return formatDownloadLabel(artifact);
-        case "file":
-            return artifact.command === "state" ? "State file" : "Saved file";
-        case "har":
-            return "Saved HAR";
-        case "image":
-            return formatImageLabel(artifact);
-        case "pdf":
-            return "Saved PDF";
-        case "profile":
-            return "Saved profile";
-        case "trace":
-            return "Saved trace";
-        case "video":
-            return formatRecordingLabel(artifact);
-    }
-}
-export function formatArtifactSummary(artifacts) {
-    if (artifacts.length === 0) {
-        return undefined;
-    }
-    if (artifacts.length === 1) {
-        const artifact = artifacts[0];
-        return `${formatArtifactLabel(artifact)}: ${artifact.path}`;
-    }
-    const restartArtifact = artifacts.find((artifact) => isPendingRecordingArtifact(artifact) && artifact.subcommand === "restart");
-    const previous = artifacts.filter((artifact) => artifact.command === "record" && artifact.subcommand === "restart-previous");
-    if (restartArtifact && previous.length > 0) {
-        return [...previous, restartArtifact]
-            .map((artifact) => `${formatArtifactLabel(artifact)}: ${artifact.path}`)
-            .join("\n");
-    }
-    return `${artifacts.every((artifact) => artifact.status === "saved") ? "Saved" : "Reported"} ${artifacts.length} artifacts: ${artifacts.map((artifact) => `${artifact.kind} ${artifact.path}`).join(", ")}`;
-}
-function optionalField(label, value) {
-    return value !== undefined && value.length > 0 ? `${label}: ${value}` : undefined;
-}
-function formatPendingDetails(artifact) {
-    return [
-        `Exists: ${artifact.exists ?? "pending until record stop"}`,
-        `Status: ${artifact.status ?? "pending"}`,
-        `Recording state: ${artifact.recordingState ?? "openRecording"}`,
-        `Will exist on stop: ${artifact.willExistOnStop !== false}`,
-    ];
-}
-function formatFileDetails(artifact) {
-    return [
-        `Exists: ${artifact.exists ?? "unknown"}`,
-        artifact.exists === false ? "not found on disk" : undefined,
-        typeof artifact.sizeBytes === "number"
-            ? `Size: ${formatByteCount(artifact.sizeBytes)}`
-            : undefined,
-        typeof artifact.sizeBytes === "number" ? `Size bytes: ${artifact.sizeBytes}` : undefined,
-        `Status: ${artifact.status ?? (artifact.exists === false ? "missing" : "saved")}`,
-        optionalField("Reported path", artifact.tempPath),
-        optionalField("Media type", artifact.mediaType),
-    ];
-}
-export function formatArtifactMetadataLines(artifacts) {
-    return artifacts.map((artifact, index) => [
-        `${formatArtifactLabel(artifact)}: ${artifact.path}`,
-        `Artifact type: ${artifact.kind}`,
-        optionalField("Requested path", artifact.requestedPath),
-        `Absolute path: ${artifact.absolutePath}`,
-        ...(isPendingRecordingArtifact(artifact)
-            ? formatPendingDetails(artifact)
-            : formatFileDetails(artifact)),
-        optionalField("Session", artifact.session),
-        optionalField("CWD", artifact.cwd),
-        artifact.recording ? formatRecordingReceipt(artifact.recording) : undefined,
-        `Machine data: details.artifacts[${index}]`,
-    ]
-        .filter((item) => item !== undefined)
-        .join("\n"));
-}

package/dist/extensions/agent-browser/lib/results/presentation/artifact-images.js

@@ -1,113 +0,0 @@
-import { readFile, stat } from "node:fs/promises";
-import { resolve } from "node:path";
-import { inspect } from "node:util";
-import { getImageDimensions } from "@earendil-works/pi-tui";
-import { isRecord, parsePositiveInteger } from "../../parsing.js";
-import { LIGHTPANDA_IMAGE_REASON } from "./common.js";
-import { getImageMimeType, isNonFileArtifactPathCandidate, readImageHeader, } from "./artifact-files.js";
-import { formatByteCount } from "./artifact-format.js";
-const DEFAULT_INLINE_IMAGE_MAX_BYTES = 5 * 1_024 * 1_024;
-function getInlineImageMaxBytes(env = process.env) {
-    return (parsePositiveInteger(env.PI_AGENT_BROWSER_INLINE_IMAGE_MAX_BYTES) ??
-        DEFAULT_INLINE_IMAGE_MAX_BYTES);
-}
-export function appendPresentationNotice(presentation, message) {
-    const existingText = presentation.content[0]?.type === "text" ? presentation.content[0].text : "";
-    presentation.content[0] = {
-        type: "text",
-        text: existingText.length > 0 ? `${existingText}\n\n${message}` : message,
-    };
-}
-export function getScreenshotSummary(data) {
-    if (data.changed === false) {
-        return "Screenshot unchanged; no image saved.";
-    }
-    return typeof data.path === "string" ? `Saved image: ${data.path}` : undefined;
-}
-export function extractImagePath(commandInfo, cwd, data) {
-    if (commandInfo.command !== "screenshot") {
-        return undefined;
-    }
-    let path;
-    if (typeof data === "string") {
-        path = data;
-    }
-    else if (isRecord(data) && typeof data.path === "string") {
-        path = data.path;
-    }
-    return path !== undefined && path.trim().length > 0 && !isNonFileArtifactPathCandidate(path)
-        ? resolve(cwd, path)
-        : undefined;
-}
-function isTextRendered(data) {
-    if (!isRecord(data) || !isRecord(data.lifecycle)) {
-        return false;
-    }
-    return (isRecord(data.lifecycle.effectiveLaunch) &&
-        data.lifecycle.effectiveLaunch.engine === "lightpanda");
-}
-function buildImageObservation(imagePath, header, mimeType, textRendered) {
-    const dimensions = getImageDimensions(header.toString("base64"), mimeType);
-    let reason = "Image dimensions could not be read from the bounded header.";
-    if (dimensions) {
-        reason = "Capture geometry was not observed.";
-    }
-    if (textRendered) {
-        reason = LIGHTPANDA_IMAGE_REASON;
-    }
-    return {
-        path: imagePath,
-        mimeType,
-        ...(textRendered ? { rendering: "text" } : {}),
-        pixels: dimensions ? { width: dimensions.widthPx, height: dimensions.heightPx } : undefined,
-        capture: "unknown",
-        geometry: { status: "unknown", reason },
-    };
-}
-async function attachVisibleImage(presentation, options) {
-    if (options.textRendered) {
-        appendPresentationNotice(presentation, LIGHTPANDA_IMAGE_REASON);
-    }
-    const limit = getInlineImageMaxBytes();
-    if (options.size > limit) {
-        appendPresentationNotice(presentation, `Image attachment skipped: ${formatByteCount(options.size)} exceeds the inline limit of ${formatByteCount(limit)}.`);
-        return;
-    }
-    const file = await readFile(options.imagePath);
-    presentation.content.push({
-        type: "image",
-        data: file.toString("base64"),
-        mimeType: options.mimeType,
-    });
-}
-export async function attachInlineImage(presentation, imagePath, modelVisible = true) {
-    try {
-        const fileStats = await stat(imagePath);
-        // Pi's dimension API accepts base64. Encode only a bounded header, never the whole code-mode image.
-        const header = await readImageHeader(imagePath, 64 * 1024);
-        const mimeType = getImageMimeType(header);
-        if (mimeType === undefined) {
-            return presentation;
-        }
-        const textRendered = isTextRendered(presentation.data);
-        presentation.imagePath = imagePath;
-        presentation.imageObservations = [
-            buildImageObservation(imagePath, header, mimeType, textRendered),
-        ];
-        if (modelVisible) {
-            await attachVisibleImage(presentation, {
-                imagePath,
-                size: fileStats.size,
-                mimeType,
-                textRendered,
-            });
-        }
-        return presentation;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : inspect(error);
-        appendPresentationNotice(presentation, `Image attachment failed: ${message}`);
-        presentation.imagePath = imagePath;
-        return presentation;
-    }
-}

package/dist/extensions/agent-browser/lib/results/presentation/artifact-verification.js

@@ -1,145 +0,0 @@
-import { isPendingRecordingArtifact } from "../artifact-manifest.js";
-import { classifyAgentBrowserSuccessCategory } from "../categories.js";
-function artifactState(artifact) {
-    if (["failed", "stale", "unverified"].includes(artifact.status ?? "")) {
-        return "unverified";
-    }
-    if (artifact.exists === true) {
-        return "verified";
-    }
-    return artifact.exists === false ? "missing" : "unverified";
-}
-function artifactLimitation(artifact, state) {
-    if (artifact.status === "failed" || artifact.status === "unverified") {
-        return "File presence does not prove successful native recording finalization or encoding. Inspect the receipt and original failure.";
-    }
-    if (artifact.status === "stale") {
-        return "The reported path's modification time fell outside this command's bounded artifact window. Treat the artifact as stale until regenerated.";
-    }
-    if (state === "missing") {
-        return "The wrapper did not find the reported artifact at absolutePath. Treat the path as unverified until recovered or regenerated.";
-    }
-    return state === "unverified"
-        ? "The wrapper could not prove local filesystem existence for this artifact."
-        : undefined;
-}
-function getArtifactVerificationEntry(artifact) {
-    const common = {
-        absolutePath: artifact.absolutePath,
-        exists: artifact.exists,
-        kind: artifact.kind,
-        recording: artifact.recording,
-        recordingStartedAtMs: artifact.recordingStartedAtMs,
-        mediaType: artifact.mediaType,
-        path: artifact.path,
-        requestedPath: artifact.requestedPath,
-        sizeBytes: artifact.sizeBytes,
-    };
-    if (isPendingRecordingArtifact(artifact)) {
-        return {
-            ...common,
-            limitation: "Recording output is pending until native finalization succeeds and the file is verified.",
-            recordingState: artifact.recordingState ?? "openRecording",
-            retentionState: undefined,
-            state: "pending",
-            status: artifact.status ?? "pending",
-            storageScope: undefined,
-            willExistOnStop: artifact.willExistOnStop ?? true,
-        };
-    }
-    const state = artifactState(artifact);
-    return {
-        ...common,
-        limitation: artifactLimitation(artifact, state),
-        retentionState: artifact.exists === false ? "missing" : "live",
-        state,
-        status: artifact.status,
-        storageScope: "explicit-path",
-        updatedAtMs: artifact.updatedAtMs,
-    };
-}
-const MANIFEST_STATES = {
-    live: "verified",
-    missing: "missing",
-    evicted: "missing",
-    ephemeral: "unverified",
-};
-function getManifestVerificationEntry(entry) {
-    if (entry.storageScope === "explicit-path") {
-        return undefined;
-    }
-    let limitation;
-    if (entry.retentionState === "ephemeral") {
-        limitation = "This spill file is process-temporary and may not survive reload or restart.";
-    }
-    if (entry.retentionState === "evicted") {
-        limitation = "This persisted spill file was evicted from the bounded session artifact store.";
-    }
-    return {
-        absolutePath: entry.absolutePath,
-        exists: entry.exists,
-        kind: entry.kind,
-        limitation,
-        mediaType: entry.mediaType,
-        path: entry.path,
-        requestedPath: entry.requestedPath,
-        retentionState: entry.retentionState,
-        sizeBytes: entry.sizeBytes,
-        state: MANIFEST_STATES[entry.retentionState],
-        storageScope: entry.storageScope,
-    };
-}
-export function buildArtifactVerificationSummary(artifacts, manifest, manifestPaths) {
-    const entries = [
-        ...artifacts.map(getArtifactVerificationEntry),
-        ...(manifest?.entries.flatMap((entry) => {
-            if (manifestPaths && !manifestPaths.has(entry.path)) {
-                return [];
-            }
-            const verificationEntry = getManifestVerificationEntry(entry);
-            return verificationEntry ? [verificationEntry] : [];
-        }) ?? []),
-    ];
-    if (entries.length === 0) {
-        return undefined;
-    }
-    const counts = { verified: 0, missing: 0, pending: 0, unverified: 0 };
-    for (const entry of entries) {
-        counts[entry.state] += 1;
-    }
-    return {
-        artifacts: entries,
-        missingCount: counts.missing,
-        pendingCount: counts.pending,
-        unverifiedCount: counts.unverified,
-        verified: counts.verified === entries.length,
-        verifiedCount: counts.verified,
-    };
-}
-function isMissingFileArtifact(artifact) {
-    return (!isPendingRecordingArtifact(artifact) &&
-        (artifact.exists === false || artifact.status === "stale"));
-}
-export function hasMissingFileArtifact(artifacts) {
-    return (artifacts ?? []).some(isMissingFileArtifact);
-}
-export function formatMissingArtifactFailureText(artifacts) {
-    const failedArtifacts = (artifacts ?? []).filter(isMissingFileArtifact);
-    if (failedArtifacts.length === 0) {
-        return undefined;
-    }
-    if (failedArtifacts.length === 1) {
-        const artifact = failedArtifacts[0];
-        return artifact.status === "stale"
-            ? `Artifact verification failed: requested ${artifact.kind} path ${artifact.absolutePath} has a modification time outside the current command window.`
-            : `Artifact verification failed: requested ${artifact.kind} was not found at ${artifact.absolutePath}.`;
-    }
-    return `Artifact verification failed: ${failedArtifacts.length} requested artifacts were missing or stale.`;
-}
-export function classifyPresentationSuccessCategory(options) {
-    if ((options.artifactVerification?.missingCount ?? 0) > 0 ||
-        (options.artifactVerification?.unverifiedCount ?? 0) > 0) {
-        return "artifact-unverified";
-    }
-    return classifyAgentBrowserSuccessCategory({ ...options, artifacts: options.artifacts?.slice() });
-}

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

@@ -1,165 +0,0 @@
-import { isRecord } from "../../parsing.js";
-import { formatSessionArtifactRetentionSummary, getSessionArtifactManifestEntryKey, isPendingRecordingArtifact, mergeSessionArtifactManifest, } from "../artifact-manifest.js";
-import { getRecordingReceipt } from "../recording.js";
-import { buildFileArtifactMetadata, buildPreviousRestartRecordingArtifact, extractPathStrings, isDownloadWaitSubcommand, isNonFileArtifactPathCandidate, } from "./artifact-files.js";
-import { appendPresentationNotice } from "./artifact-images.js";
-export { attachInlineImage, extractImagePath, getScreenshotSummary } from "./artifact-images.js";
-export { formatArtifactMetadataLines, formatArtifactSummary } from "./artifact-format.js";
-export { buildArtifactVerificationSummary, classifyPresentationSuccessCategory, formatMissingArtifactFailureText, hasMissingFileArtifact, } from "./artifact-verification.js";
-function noticeWorthy(entry) {
-    return entry.retentionState === "evicted" || entry.storageScope !== "explicit-path";
-}
-export function manifestHasNewNoticeWorthyEntries(base, current) {
-    if (!current) {
-        return false;
-    }
-    const baseKeys = new Set((base?.entries ?? []).map(getSessionArtifactManifestEntryKey));
-    return current.entries.some((entry) => !baseKeys.has(getSessionArtifactManifestEntryKey(entry)) && noticeWorthy(entry));
-}
-export function applyArtifactManifest(presentation, baseManifest, entries) {
-    if (entries.length === 0) {
-        return presentation;
-    }
-    const artifactManifest = mergeSessionArtifactManifest({
-        base: baseManifest,
-        entries: [...entries],
-    });
-    if (!artifactManifest) {
-        return presentation;
-    }
-    presentation.artifactManifest = artifactManifest;
-    presentation.artifactRetentionSummary = formatSessionArtifactRetentionSummary(artifactManifest);
-    if (entries.some(noticeWorthy)) {
-        appendPresentationNotice(presentation, presentation.artifactRetentionSummary);
-    }
-    return presentation;
-}
-function getRecordingPending(options, recording) {
-    return (options.recordingPending ??
-        (recording?.success === null &&
-            isRecord(options.data) &&
-            isRecord(options.data.capture) &&
-            recording.capture.endedAt === null));
-}
-async function extractContactSheet(options, recordingPending) {
-    if (options.commandInfo.command !== "record" || !isRecord(options.data)) {
-        return undefined;
-    }
-    const path = options.data.contactSheetPath;
-    if (typeof path !== "string" ||
-        path.trim().length === 0 ||
-        isNonFileArtifactPathCandidate(path)) {
-        return undefined;
-    }
-    const sheet = await buildFileArtifactMetadata({
-        ...options,
-        artifactRequest: undefined,
-        kind: "image",
-        path,
-        recordingPending: recordingPending === true ||
-            ["start", "restart"].includes(options.commandInfo.subcommand ?? ""),
-    });
-    return sheet ? { ...sheet, requestedPath: undefined } : undefined;
-}
-async function extractPreviousContactSheet(options) {
-    if (options.commandInfo.command !== "record" ||
-        options.commandInfo.subcommand !== "restart" ||
-        options.recordingOutcome !== true) {
-        return undefined;
-    }
-    const path = options.previousRecordingContactSheetPath;
-    if (path === undefined || path.length === 0) {
-        return undefined;
-    }
-    const sheet = await buildFileArtifactMetadata({
-        ...options,
-        artifactRequest: undefined,
-        commandInfo: { command: "record", subcommand: "restart-previous" },
-        kind: "image",
-        path,
-        recordingPending: false,
-    });
-    // Native restart omits the previous sheet's terminal receipt. Disk presence isn't finalization proof.
-    return sheet
-        ? { ...sheet, status: sheet.status === "saved" ? "unverified" : sheet.status }
-        : undefined;
-}
-export async function extractFileArtifacts(options) {
-    if (options.commandInfo.command === "screenshot" &&
-        isRecord(options.data) &&
-        options.data.changed === false) {
-        return [];
-    }
-    const recording = options.commandInfo.command === "record"
-        ? getRecordingReceipt(options.data, options.commandInfo.subcommand === "stop" ? options.recordingOutcome : undefined)
-        : undefined;
-    const recordingPending = getRecordingPending(options, recording);
-    const current = (await Promise.all(extractPathStrings(options.data).map((path) => buildFileArtifactMetadata({ ...options, path, recording, recordingPending })))).filter((artifact) => artifact !== undefined);
-    const sheet = await extractContactSheet(options, recordingPending);
-    if (sheet) {
-        current.push(sheet);
-    }
-    const previousSheet = await extractPreviousContactSheet(options);
-    if (previousSheet) {
-        current.unshift(previousSheet);
-    }
-    const previous = await buildPreviousRestartRecordingArtifact(options);
-    return previous ? [previous, ...current] : current;
-}
-export function buildManifestEntriesForFileArtifacts(artifacts, nowMs = Date.now()) {
-    return artifacts.map((artifact) => ({
-        absolutePath: artifact.absolutePath,
-        command: artifact.command,
-        createdAtMs: nowMs,
-        cwd: artifact.cwd,
-        exists: artifact.exists,
-        extension: artifact.extension,
-        kind: artifact.kind,
-        mediaType: artifact.mediaType,
-        namespace: artifact.namespace,
-        path: artifact.path,
-        recording: artifact.recording,
-        recordingStartedAtMs: artifact.recordingStartedAtMs,
-        recordingState: artifact.recordingState,
-        status: artifact.status,
-        requestedPath: artifact.requestedPath,
-        retentionState: artifact.exists === false || artifact.status === "stale" ? "missing" : "live",
-        session: artifact.session,
-        sizeBytes: artifact.sizeBytes,
-        storageScope: "explicit-path",
-        subcommand: artifact.subcommand,
-    }));
-}
-export function isManifestFileArtifact(artifact) {
-    return artifact.kind === "video" && artifact.command === "record"
-        ? true
-        : artifact.status !== "stale" && !isPendingRecordingArtifact(artifact);
-}
-function getSavedFileCommand(commandInfo) {
-    if (commandInfo.command === "wait" && isDownloadWaitSubcommand(commandInfo.subcommand)) {
-        return "wait";
-    }
-    return commandInfo.command === "download" || commandInfo.command === "pdf"
-        ? commandInfo.command
-        : undefined;
-}
-export function getSavedFileDetails(commandInfo, data) {
-    const path = typeof data.path === "string" && data.path.trim().length > 0 ? data.path : undefined;
-    if (path === undefined || isNonFileArtifactPathCandidate(path)) {
-        return undefined;
-    }
-    const command = getSavedFileCommand(commandInfo);
-    if (command === undefined) {
-        return undefined;
-    }
-    const { path: _path, ...metadata } = data;
-    return {
-        command,
-        kind: command === "pdf" ? "pdf" : "download",
-        path,
-        ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
-        ...(commandInfo.subcommand !== undefined && commandInfo.subcommand.length > 0
-            ? { subcommand: commandInfo.subcommand }
-            : {}),
-    };
-}

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

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

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

@@ -1,118 +0,0 @@
-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);
-}