pi-agent-browser-native 0.9.5 → 0.9.7

package/dist/extensions/agent-browser/lib/results/network-routes.js

@@ -1,133 +0,0 @@
-import { isRecord } from "../parsing.js";
-import { redactSensitiveText } from "../runtime-redaction.js";
-import { getStringRecordField, isApiLikeNetworkRequest } from "./network.js";
-function getArrayField(data, key) {
-    const value = data[key];
-    return Array.isArray(value) ? value : undefined;
-}
-function networkRoutePatternMatchesUrl(pattern, url) {
-    if (pattern === url) {
-        return true;
-    }
-    if (pattern.includes("*")) {
-        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-        return new RegExp(`^${escaped}$`).test(url);
-    }
-    return pattern.length >= 4 && url.includes(pattern);
-}
-function getSafeRequestId(item) {
-    const requestId = getStringRecordField(item, "requestId") ?? getStringRecordField(item, "id");
-    if (requestId === undefined ||
-        requestId.length === 0 ||
-        redactSensitiveText(requestId) !== requestId) {
-        return undefined;
-    }
-    return requestId;
-}
-function routedRequestFailed(item, error) {
-    return ((typeof item.status === "number" && item.status >= 400) ||
-        item.failed === true ||
-        error !== undefined);
-}
-function getRouteDiagnosticReason(item, route) {
-    const statusMissing = typeof item.status !== "number";
-    const error = getStringRecordField(item, "error") ??
-        getStringRecordField(item, "failureText") ??
-        getStringRecordField(item, "errorText");
-    if (error !== undefined &&
-        /(?:cors|cross-origin|preflight|access-control-allow-origin)/i.test(error)) {
-        return "cors-likely-routed-request";
-    }
-    if (statusMissing && isApiLikeNetworkRequest(item)) {
-        return "pending-routed-request";
-    }
-    if (route.mode !== "abort" && routedRequestFailed(item, error)) {
-        return "unfulfilled-routed-request";
-    }
-    return undefined;
-}
-function getNetworkRouteMode(args) {
-    if (args.includes("--abort")) {
-        return "abort";
-    }
-    if (args.includes("--body")) {
-        return "body";
-    }
-    return "handler";
-}
-export function applyNetworkRouteRecords(routes, commandTokens, succeeded) {
-    if (!succeeded || commandTokens?.[0] !== "network") {
-        return routes;
-    }
-    const subcommand = commandTokens[1];
-    if (subcommand !== "route" && subcommand !== "unroute") {
-        return routes;
-    }
-    return updateNetworkRoutes(routes, commandTokens);
-}
-function updateNetworkRoutes(routes, commandTokens) {
-    const existing = routes ?? [];
-    const pattern = commandTokens.at(2);
-    if (commandTokens[1] === "route" && pattern !== undefined && pattern.length > 0) {
-        return [
-            ...existing.filter((route) => route.pattern !== pattern),
-            { mode: getNetworkRouteMode(commandTokens), pattern },
-        ];
-    }
-    if (pattern === undefined || pattern.length === 0) {
-        return undefined;
-    }
-    const next = existing.filter((route) => route.pattern !== pattern);
-    return next.length > 0 ? next : undefined;
-}
-function formatNetworkRouteDiagnosticSummary(reason, request, pattern) {
-    switch (reason) {
-        case "cors-likely-routed-request":
-            return `Routed request ${request} looks CORS/preflight-related for route ${pattern}.`;
-        case "unfulfilled-routed-request":
-            return `Routed request ${request} failed instead of returning the configured route ${pattern}.`;
-        case "pending-routed-request":
-            return `Routed request ${request} is still pending/no-status for route ${pattern}.`;
-    }
-}
-function buildRoutedRequestDiagnostic(item, routes) {
-    if (!isRecord(item)) {
-        return undefined;
-    }
-    const url = getStringRecordField(item, "url");
-    if (url === undefined) {
-        return undefined;
-    }
-    const route = routes.find((candidate) => networkRoutePatternMatchesUrl(candidate.pattern, url));
-    if (!route) {
-        return undefined;
-    }
-    const reason = getRouteDiagnosticReason(item, route);
-    if (reason === undefined) {
-        return undefined;
-    }
-    const requestId = getSafeRequestId(item);
-    const requestUrl = redactSensitiveText(url);
-    const routePattern = redactSensitiveText(route.pattern);
-    return {
-        mode: route.mode,
-        reason,
-        ...(requestId !== undefined ? { requestId } : {}),
-        requestUrl,
-        routePattern,
-        summary: formatNetworkRouteDiagnosticSummary(reason, requestId ?? requestUrl, routePattern),
-    };
-}
-export function buildNetworkRouteDiagnostics(data, routes) {
-    if (!routes || routes.length === 0 || !isRecord(data)) {
-        return undefined;
-    }
-    const requests = getArrayField(data, "requests");
-    if (!requests) {
-        return undefined;
-    }
-    const diagnostics = requests
-        .map((item) => buildRoutedRequestDiagnostic(item, routes))
-        .filter((item) => item !== undefined);
-    return diagnostics.length > 0 ? diagnostics.slice(0, 5) : undefined;
-}

package/dist/extensions/agent-browser/lib/results/network.js

@@ -1,89 +0,0 @@
-import { isRecord } from "../parsing.js";
-export function getStringRecordField(value, key) {
-    const field = value[key];
-    return typeof field === "string" && field.trim().length > 0 ? field.trim() : undefined;
-}
-function getNetworkRequestUrlPath(url) {
-    if (url === undefined || url.length === 0) {
-        return undefined;
-    }
-    try {
-        return new URL(url).pathname;
-    }
-    catch {
-        const withoutQuery = url.split(/[?#]/, 1)[0];
-        return withoutQuery.length > 0 ? withoutQuery : undefined;
-    }
-}
-function isFailedNetworkRequest(request) {
-    return ((typeof request.status === "number" && request.status >= 400) ||
-        request.failed === true ||
-        typeof request.error === "string");
-}
-export function isNetworkArtifactNoiseRequest(request) {
-    const url = getStringRecordField(request, "url") ?? "";
-    const resourceType = (getStringRecordField(request, "resourceType") ??
-        getStringRecordField(request, "mimeType") ??
-        "").toLowerCase();
-    return /^data:image\//i.test(url) || (url.startsWith("data:") && resourceType.includes("image"));
-}
-function isIconResourceType(resourceType) {
-    const normalized = resourceType?.toLowerCase() ?? "";
-    return (normalized.length === 0 ||
-        ["image", "img", "other"].includes(normalized) ||
-        normalized.startsWith("image/"));
-}
-function isBenignAssetFailure(request, url, resourceType) {
-    const path = getNetworkRequestUrlPath(url);
-    if (path === undefined || path.length === 0) {
-        return false;
-    }
-    return (/(?:^|\/)(?:favicon(?:[-.\w]*)?\.(?:ico|png|svg)|apple-touch-icon(?:[-.\w]*)?\.png)$/i.test(path) &&
-        (request.status === 404 || request.failed === true || typeof request.error === "string") &&
-        isIconResourceType(resourceType));
-}
-export function isApiLikeNetworkRequest(request) {
-    const method = (getStringRecordField(request, "method") ?? "GET").toUpperCase();
-    const resourceType = (getStringRecordField(request, "resourceType") ?? "").toLowerCase();
-    const mimeType = (getStringRecordField(request, "mimeType") ?? "").toLowerCase();
-    const path = getNetworkRequestUrlPath(getStringRecordField(request, "url")) ?? "";
-    return (resourceType === "fetch" ||
-        resourceType === "xhr" ||
-        mimeType.includes("json") ||
-        /\/(?:api|graphql|rpc)(?:\/|$)/i.test(path) ||
-        !["GET", "HEAD"].includes(method));
-}
-export function classifyNetworkRequestFailure(request) {
-    if (!isFailedNetworkRequest(request)) {
-        return undefined;
-    }
-    const url = getStringRecordField(request, "url");
-    const resourceType = getStringRecordField(request, "resourceType") ?? getStringRecordField(request, "mimeType");
-    const status = typeof request.status === "number" ? request.status : undefined;
-    if (isBenignAssetFailure(request, url, resourceType)) {
-        return { impact: "benign", reason: "low-impact browser icon asset", resourceType, status, url };
-    }
-    return {
-        impact: "actionable",
-        reason: "document, script, API, or non-benign request failure",
-        resourceType,
-        status,
-        url,
-    };
-}
-export function summarizeNetworkFailures(requests) {
-    const failures = requests.flatMap((request) => {
-        if (!isRecord(request) || isNetworkArtifactNoiseRequest(request)) {
-            return [];
-        }
-        const classification = classifyNetworkRequestFailure(request);
-        return classification ? [classification] : [];
-    });
-    const benignCount = failures.filter((failure) => failure.impact === "benign").length;
-    return {
-        actionableCount: failures.length - benignCount,
-        benignCount,
-        failures,
-        totalCount: failures.length,
-    };
-}

package/dist/extensions/agent-browser/lib/results/next-actions.js

@@ -1,111 +0,0 @@
-export function withOptionalNamespaceArgs(namespace, args) {
-    return namespace !== undefined && args[0] !== "--namespace"
-        ? ["--namespace", namespace, ...args]
-        : args;
-}
-export function withOptionalSessionArgs(sessionName, args) {
-    if (sessionName === undefined ||
-        sessionName.length === 0 ||
-        args[0] === "--session" ||
-        (args[0] === "--namespace" && args[2] === "--session")) {
-        return args;
-    }
-    if (args[0] === "--namespace" && args.length >= 2) {
-        return [args[0], args[1], "--session", sessionName, ...args.slice(2)];
-    }
-    return ["--session", sessionName, ...args];
-}
-export function applyNamespaceToNextActions(actions, namespace) {
-    if (namespace === undefined || !actions) {
-        return actions;
-    }
-    return actions.map((action) => {
-        const args = action.params?.args;
-        if (args) {
-            return {
-                ...action,
-                params: { ...action.params, args: withOptionalNamespaceArgs(namespace, args) },
-            };
-        }
-        return action.tool === "agent_browser_network_source"
-            ? { ...action, params: { ...action.params, namespace } }
-            : action;
-    });
-}
-export function applySessionToNextActions(actions, sessionName) {
-    if (sessionName === undefined || sessionName.length === 0 || !actions) {
-        return actions;
-    }
-    return actions.map((action) => {
-        // Fresh-session actions deliberately target a new session; the planner ignores sessionMode when an
-        // explicit --session is present, so prefixing one here would silently downgrade them to reuse.
-        if (action.params?.sessionMode === "fresh") {
-            return action;
-        }
-        const args = action.params?.args;
-        return args
-            ? {
-                ...action,
-                params: { ...action.params, args: withOptionalSessionArgs(sessionName, args) },
-            }
-            : action;
-    });
-}
-export function buildNextToolAction(options) {
-    return {
-        id: options.id,
-        params: {
-            args: options.args,
-            ...(options.sessionMode !== undefined ? { sessionMode: options.sessionMode } : {}),
-            ...(options.stdin !== undefined && options.stdin.length > 0 ? { stdin: options.stdin } : {}),
-        },
-        reason: options.reason,
-        ...(options.safety !== undefined && options.safety.length > 0
-            ? { safety: options.safety }
-            : {}),
-        tool: "agent_browser",
-    };
-}
-export function buildInspectOverlayStateAction(sessionName) {
-    return buildNextToolAction({
-        args: withOptionalSessionArgs(sessionName, ["snapshot", "-i"]),
-        id: "inspect-overlay-state",
-        reason: "Refresh interactive refs and inspect whether an overlay, banner, modal, or dialog is blocking the intended click.",
-        safety: "Read-only inspection; do not blindly retry the blocked click, and use current refs from this snapshot before interacting.",
-    });
-}
-export function appendUniqueAgentBrowserNextActions(target, additions) {
-    if (!additions || additions.length === 0) {
-        return target;
-    }
-    const existingIds = new Set(target.map((action) => action.id));
-    for (const action of additions) {
-        if (existingIds.has(action.id)) {
-            continue;
-        }
-        target.push(action);
-        existingIds.add(action.id);
-    }
-    return target;
-}
-export function isStandaloneSnapshotNextAction(action) {
-    const args = action.params?.args;
-    if (!args || (action.params.stdin !== undefined && action.params.stdin.length > 0)) {
-        return false;
-    }
-    let commandIndex = args[0] === "--namespace" ? 2 : 0;
-    if (args[commandIndex] === "--session") {
-        commandIndex += 2;
-    }
-    return args[commandIndex] === "snapshot";
-}
-export function alignPageChangeSummaryNextActionIds(summary, nextActions) {
-    if (!summary?.nextActionIds || !nextActions) {
-        return summary;
-    }
-    const nextActionIds = new Set(nextActions.map((action) => action.id));
-    const alignedIds = summary.nextActionIds.filter((id) => nextActionIds.has(id));
-    return alignedIds.length > 0
-        ? { ...summary, nextActionIds: alignedIds }
-        : { ...summary, nextActionIds: undefined };
-}

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

@@ -1,320 +0,0 @@
-import { open, stat } from "node:fs/promises";
-import { extname, resolve } from "node:path";
-import { getAgentBrowserSessionIdentityKey } from "../../argv-grammar.js";
-import { getExplicitArtifactDestination } from "../../orchestration/browser-run/artifact-paths.js";
-import { isRecord } from "../../parsing.js";
-import { isPendingRecordingCommand } from "../artifact-manifest.js";
-import { getRecordingReceipt } from "../recording.js";
-const PNG_HEADER = Buffer.from("89504e470d0a1a0a0000000d49484452", "hex");
-const ARTIFACT_MTIME_TOLERANCE_MS = 2_000;
-export function getImageMimeType(bytes) {
-    if (bytes.length < 16) {
-        return undefined;
-    }
-    if (bytes.subarray(0, 16).equals(PNG_HEADER)) {
-        return "image/png";
-    }
-    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff && bytes[3] !== 0xf7) {
-        return "image/jpeg";
-    }
-    if (["GIF87a", "GIF89a"].includes(bytes.toString("utf8", 0, 6))) {
-        return "image/gif";
-    }
-    if (bytes.toString("utf8", 0, 4) === "RIFF" && bytes.toString("utf8", 8, 12) === "WEBP") {
-        return "image/webp";
-    }
-    return undefined;
-}
-export async function readImageHeader(path, length) {
-    const file = await open(path, "r");
-    try {
-        const bytes = Buffer.alloc(length);
-        const { bytesRead } = await file.read(bytes, 0, bytes.length, 0);
-        return bytes.subarray(0, bytesRead);
-    }
-    finally {
-        await file.close();
-    }
-}
-async function getFileImageMimeType(path) {
-    try {
-        return getImageMimeType(await readImageHeader(path, 16));
-    }
-    catch {
-        return undefined;
-    }
-}
-function isMissingFileError(error) {
-    return (isRecord(error) && typeof error.code === "string" && ["ENOENT", "ENOTDIR"].includes(error.code));
-}
-async function readDiskEvidence(absolutePath) {
-    try {
-        const fileStats = await stat(absolutePath);
-        return {
-            exists: fileStats.isFile(),
-            sizeBytes: fileStats.size,
-            updatedAtMs: fileStats.mtimeMs,
-            mediaType: fileStats.isFile() ? await getFileImageMimeType(absolutePath) : undefined,
-        };
-    }
-    catch (error) {
-        return { exists: isMissingFileError(error) ? false : undefined };
-    }
-}
-export function isDownloadWaitSubcommand(subcommand) {
-    return subcommand === "--download" || subcommand === "-d";
-}
-function getArtifactKind(info) {
-    switch (info.command) {
-        case "screenshot":
-            return "image";
-        case "diff":
-            return info.subcommand === "screenshot" ? "image" : undefined;
-        case "pdf":
-            return "pdf";
-        case "download":
-            return "download";
-        case "wait":
-            return isDownloadWaitSubcommand(info.subcommand) ? "download" : undefined;
-        case "state":
-            return info.subcommand === "save" ? "file" : undefined;
-        case "trace":
-            return "trace";
-        case "profiler":
-            return "profile";
-        case "record":
-            return "video";
-        case "network":
-            return info.subcommand === "har" ? "har" : undefined;
-        case undefined:
-            return undefined;
-        default:
-            return undefined;
-    }
-}
-export function isNonFileArtifactPathCandidate(path) {
-    return /^(?:data|blob|https?|javascript|mailto):/i.test(path.trim());
-}
-function validPath(value) {
-    return (typeof value === "string" && value.trim().length > 0 && !isNonFileArtifactPathCandidate(value));
-}
-const PATH_FIELDS = [
-    "path",
-    "file",
-    "filePath",
-    "outputPath",
-    "downloadPath",
-    "diffPath",
-    "harPath",
-    "savedPath",
-    "statePath",
-    "tracePath",
-    "profilePath",
-    "videoPath",
-];
-export function extractPathStrings(data) {
-    if (typeof data === "string") {
-        return data.trim().length > 0 && !isNonFileArtifactPathCandidate(data) ? [data] : [];
-    }
-    if (!isRecord(data)) {
-        return [];
-    }
-    return [
-        ...new Set(PATH_FIELDS.flatMap((key) => {
-            const value = data[key];
-            if (Array.isArray(value)) {
-                return value.filter(validPath);
-            }
-            return validPath(value) ? [value] : [];
-        })),
-    ];
-}
-function artifactMtimeIsOutsideCommandWindow(updatedAtMs, options, minUpdatedAtMs = options.artifactMinUpdatedAtMs) {
-    if (updatedAtMs === undefined || minUpdatedAtMs === undefined) {
-        return false;
-    }
-    return (updatedAtMs < minUpdatedAtMs - ARTIFACT_MTIME_TOLERANCE_MS ||
-        (options.artifactMaxUpdatedAtMs !== undefined &&
-            updatedAtMs > options.artifactMaxUpdatedAtMs + ARTIFACT_MTIME_TOLERANCE_MS));
-}
-function isPendingRecording(options, kind) {
-    return (options.recordingPending === true ||
-        (isPendingRecordingCommand(options.commandInfo.command, options.commandInfo.subcommand, kind) &&
-            options.recordingOutcome !== false &&
-            options.recording?.success !== false));
-}
-function getRecordingStartedAtMs(options) {
-    const startedAt = options.recording?.capture.startedAt;
-    const captureStartedAtMs = startedAt !== undefined && startedAt !== null && startedAt.length > 0
-        ? Date.parse(startedAt)
-        : NaN;
-    return Number.isFinite(captureStartedAtMs) ? captureStartedAtMs : options.artifactMinUpdatedAtMs;
-}
-function nativeRecordingFailed(options) {
-    const receipt = options.recording;
-    return (receipt?.success === false ||
-        receipt?.output.encoderSucceeded === false ||
-        (options.recordingOutcome === false && receipt?.success !== null));
-}
-function recordingSizeMismatch(options, sizeBytes) {
-    const recordedSize = options.recording?.file.sizeBytes;
-    return recordedSize !== undefined && recordedSize !== null && recordedSize !== sizeBytes;
-}
-function getRecordingStatus(options, sizeBytes) {
-    const receipt = options.recording;
-    if (nativeRecordingFailed(options)) {
-        return "failed";
-    }
-    if ((receipt?.success !== true && options.recordingOutcome !== true) ||
-        recordingSizeMismatch(options, sizeBytes)) {
-        return "unverified";
-    }
-    return options.artifactRequest?.status ?? "saved";
-}
-function getArtifactStatus(options, evidence, kind, state) {
-    if (state.pending) {
-        return "pending";
-    }
-    if (evidence.exists === false) {
-        return "missing";
-    }
-    if (evidence.exists !== true) {
-        return "unverified";
-    }
-    if (state.stale) {
-        return "stale";
-    }
-    return kind === "video"
-        ? getRecordingStatus(options, evidence.sizeBytes)
-        : (options.artifactRequest?.status ?? "saved");
-}
-function buildArtifactIdentity(options, kind) {
-    const { absolutePath = resolve(options.cwd, options.path), path: requestedPath, tempPath, } = options.artifactRequest ?? {};
-    const extension = extname(absolutePath.length > 0 ? absolutePath : options.path).toLowerCase();
-    return {
-        absolutePath,
-        artifactType: kind,
-        command: options.commandInfo.command,
-        cwd: options.cwd,
-        extension: extension.length > 0 ? extension : undefined,
-        kind,
-        namespace: options.namespace,
-        path: requestedPath ?? options.path,
-        requestedPath: requestedPath ??
-            getExplicitArtifactDestination([...(options.commandInfo.commandTokens ?? [])]),
-        session: options.sessionName,
-        subcommand: options.commandInfo.subcommand,
-        tempPath,
-    };
-}
-function artifactIsStale(options, evidence, kind, recordingStartedAtMs) {
-    if (options.commandInfo.command === "wait" &&
-        isDownloadWaitSubcommand(options.commandInfo.subcommand)) {
-        return false;
-    }
-    return artifactMtimeIsOutsideCommandWindow(evidence.updatedAtMs, options, kind === "video" ? recordingStartedAtMs : options.artifactMinUpdatedAtMs);
-}
-export async function buildFileArtifactMetadata(options) {
-    const kind = options.kind ?? getArtifactKind(options.commandInfo);
-    if (kind === undefined) {
-        return undefined;
-    }
-    const identity = buildArtifactIdentity(options, kind);
-    const pending = isPendingRecording(options, kind);
-    const recordingStartedAtMs = getRecordingStartedAtMs(options);
-    const evidence = !pending || options.commandInfo.subcommand === "stop"
-        ? await readDiskEvidence(identity.absolutePath)
-        : {};
-    const stale = artifactIsStale(options, evidence, kind, recordingStartedAtMs);
-    return {
-        ...identity,
-        exists: evidence.exists,
-        sizeBytes: evidence.sizeBytes,
-        mediaType: evidence.mediaType,
-        updatedAtMs: evidence.updatedAtMs,
-        recording: options.recording,
-        recordingStartedAtMs: kind === "video" ? recordingStartedAtMs : undefined,
-        recordingState: pending ? "openRecording" : undefined,
-        status: getArtifactStatus(options, evidence, kind, { pending, stale }),
-        willExistOnStop: pending ? true : undefined,
-    };
-}
-function findPreviousRecording(options) {
-    const sessionKey = options.sessionName !== undefined && options.sessionName.length > 0
-        ? getAgentBrowserSessionIdentityKey(options.sessionName, options.namespace)
-        : undefined;
-    return options.artifactManifest?.entries.find((entry) => {
-        if (entry.command !== "record" ||
-            !["start", "restart"].includes(entry.subcommand ?? "") ||
-            entry.kind !== "video") {
-            return false;
-        }
-        if (sessionKey === undefined || sessionKey.length === 0) {
-            return true;
-        }
-        return (entry.session !== undefined &&
-            entry.session.length > 0 &&
-            getAgentBrowserSessionIdentityKey(entry.session, entry.namespace) === sessionKey);
-    });
-}
-function buildPreviousIdentity(previous, options) {
-    const absolutePath = previous.absolutePath ?? resolve(options.cwd, previous.path);
-    const extension = extname(absolutePath).toLowerCase();
-    return {
-        absolutePath,
-        artifactType: "video",
-        command: "record",
-        cwd: previous.cwd ?? options.cwd,
-        extension: previous.extension ?? (extension.length > 0 ? extension : undefined),
-        kind: "video",
-        namespace: previous.namespace ?? options.namespace,
-        path: previous.path,
-        requestedPath: previous.requestedPath,
-        session: previous.session ?? options.sessionName,
-        subcommand: "restart-previous",
-    };
-}
-async function buildPreviousDiskRecording(options) {
-    const previous = findPreviousRecording(options);
-    if (!previous) {
-        return undefined;
-    }
-    const identity = buildPreviousIdentity(previous, options);
-    const evidence = await readDiskEvidence(identity.absolutePath);
-    const stale = artifactMtimeIsOutsideCommandWindow(evidence.updatedAtMs, options);
-    let status = "unverified";
-    if (stale) {
-        status = "stale";
-    }
-    if (evidence.exists === false && evidence.updatedAtMs === undefined) {
-        status = "missing";
-    }
-    // Restart's path and disk evidence alone never prove native finalization.
-    return {
-        ...identity,
-        ...evidence,
-        exists: evidence.updatedAtMs !== undefined ? true : evidence.exists,
-        status,
-    };
-}
-export async function buildPreviousRestartRecordingArtifact(options) {
-    if (options.commandInfo.command !== "record" || options.commandInfo.subcommand !== "restart") {
-        return undefined;
-    }
-    if (isRecord(options.data) && "previousRecording" in options.data) {
-        const recording = getRecordingReceipt(options.data.previousRecording);
-        return recording
-            ? buildFileArtifactMetadata({
-                ...options,
-                commandInfo: { command: "record", subcommand: "restart-previous" },
-                path: recording.path,
-                recording,
-            })
-            : undefined;
-    }
-    // A rejected or pending restart has not acknowledged replacement of the active take.
-    if (!isRecord(options.data) || options.data.restarted !== true) {
-        return undefined;
-    }
-    return buildPreviousDiskRecording(options);
-}