pi-agent-browser-native 0.9.2 → 0.9.4

package/dist/extensions/agent-browser/lib/orchestration/batch-stdin.js

@@ -1,92 +1,126 @@
 import { projectUpstreamGlobalFlags } from "../argv-grammar.js";
+import { isStringArray } from "../input-modes/shared.js";
+import { stringifyUnknown } from "../results/text.js";
 /** Bare open's native launch action drops prior launch options. URL reads lazily launch without navigating. */
 export function normalizeUrlLessOpen(args, stdin, batchStep = false) {
-    const { tokens, indices } = batchStep ? { tokens: args, indices: args.map((_, index) => index) } : projectUpstreamGlobalFlags(args);
-    if (tokens[0] === "open" && !tokens.slice(1).some(token => !token.startsWith("--"))) {
+    const { tokens, indices } = batchStep
+        ? { tokens: args, indices: args.map((_, index) => index) }
+        : projectUpstreamGlobalFlags(args);
+    if (tokens[0] === "open" && !tokens.slice(1).some((token) => !token.startsWith("--"))) {
         const index = indices[0];
         return { args: [...args.slice(0, index), "get", "url", ...args.slice(index + 1)], stdin };
     }
-    if (tokens[0] !== "batch")
+    if (tokens[0] !== "batch") {
         return { args, stdin };
-    const rawSteps = tokens.slice(1).flatMap((token, offset) => {
-        const step = token === "--bail" ? undefined : parseBatchCommandArgument(token).step;
-        return step ? [{ index: indices[offset + 1], step }] : [];
-    });
-    if (tokens.slice(1).some(token => token !== "--bail")) {
-        let normalized = args;
-        for (const { index, step } of rawSteps) {
-            const row = normalizeUrlLessOpen(step, undefined, true).args;
-            if (row === step)
-                continue;
-            if (normalized === args)
-                normalized = [...args];
-            normalized[index] = row.map(token => `'${token.replaceAll("'", "'\\''")}'`).join(" ");
-        }
-        return { args: normalized, stdin };
+    }
+    if (tokens.slice(1).some((token) => token !== "--bail")) {
+        return { args: normalizeRawBatchRows(args, tokens, indices), stdin };
     }
     const steps = parseUserBatchStdin(stdin).steps;
-    if (!steps?.length)
+    if (steps === undefined || steps.length === 0) {
         return { args, stdin };
-    const normalized = steps.map(step => normalizeUrlLessOpen(step, undefined, true).args);
-    return { args, stdin: normalized.some((step, index) => step !== steps[index]) ? JSON.stringify(normalized) : stdin };
+    }
+    const normalized = steps.map((step) => normalizeUrlLessOpen(step, undefined, true).args);
+    return {
+        args,
+        stdin: normalized.some((step, index) => step !== steps[index])
+            ? JSON.stringify(normalized)
+            : stdin,
+    };
+}
+function normalizeRawBatchRows(args, tokens, indices) {
+    let normalized;
+    for (const [offset, token] of tokens.slice(1).entries()) {
+        if (token === "--bail") {
+            continue;
+        }
+        const step = parseBatchCommandArgument(token).step;
+        if (step === undefined) {
+            continue;
+        }
+        const row = normalizeUrlLessOpen(step, undefined, true).args;
+        if (row === step) {
+            continue;
+        }
+        normalized ??= [...args];
+        normalized[indices[offset + 1]] = row
+            .map((word) => `'${word.replaceAll("'", "'\\''")}'`)
+            .join(" ");
+    }
+    return normalized ?? args;
 }
 const BATCH_STDIN_EXAMPLE = ' Example: { "args": ["batch"], "stdin": "[[\\"get\\",\\"title\\"],[\\"get\\",\\"url\\"]]" }';
-// Mirror upstream commands::shell_words_split so policy inspection sees the same argv.
-export function parseBatchCommandArgument(command) {
-    const tokens = [];
-    let token = "";
-    let inDoubleQuote = false;
-    let inSingleQuote = false;
-    for (let index = 0; index < command.length; index += 1) {
-        const character = command[index];
-        if (character === "\\" && !inSingleQuote) {
-            const next = command[index + 1];
-            if (next !== undefined) {
-                token += next;
-                index += 1;
-            }
+// Mirrors upstream commands::shell_words_split for policy inspection.
+class BatchWords {
+    token = "";
+    tokens = [];
+    inDoubleQuote = false;
+    inSingleQuote = false;
+    consumeQuote(character) {
+        if (character === '"' && !this.inSingleQuote) {
+            this.inDoubleQuote = !this.inDoubleQuote;
+            return true;
         }
-        else if (character === '"' && !inSingleQuote) {
-            inDoubleQuote = !inDoubleQuote;
+        if (character === "'" && !this.inDoubleQuote) {
+            this.inSingleQuote = !this.inSingleQuote;
+            return true;
         }
-        else if (character === "'" && !inDoubleQuote) {
-            inSingleQuote = !inSingleQuote;
+        return false;
+    }
+    finishWord() {
+        if (this.token.length > 0) {
+            this.tokens.push(this.token);
+            this.token = "";
         }
-        else if (character === " " && !inDoubleQuote && !inSingleQuote) {
-            if (token !== "") {
-                tokens.push(token);
-                token = "";
+    }
+    consume(character, next) {
+        if (character === "\\" && !this.inSingleQuote) {
+            if (next !== undefined) {
+                this.token += next;
+                return true;
             }
+            return false;
+        }
+        if (this.consumeQuote(character)) {
+            return false;
+        }
+        if (character === " " && !this.inDoubleQuote && !this.inSingleQuote) {
+            this.finishWord();
         }
         else {
-            token += character;
+            this.token += character;
+        }
+        return false;
+    }
+    finish() {
+        this.finishWord();
+        return this.tokens.length > 0 ? { step: this.tokens } : { error: "batch command is empty" };
+    }
+}
+export function parseBatchCommandArgument(command) {
+    const words = new BatchWords();
+    for (let index = 0; index < command.length; index++) {
+        if (words.consume(command[index], command.at(index + 1))) {
+            index++;
         }
     }
-    if (token !== "")
-        tokens.push(token);
-    return tokens.length > 0 ? { step: tokens } : { error: "batch command is empty" };
+    return words.finish();
 }
 function validateUserBatchStep(step, index) {
     if (!Array.isArray(step)) {
         return {
-            error: `agent_browser batch stdin step ${index} must be a non-empty array of string command tokens.${BATCH_STDIN_EXAMPLE}`,
+            error: `agent_browser batch stdin step ${index} must be an array of string command tokens.${BATCH_STDIN_EXAMPLE}`,
             ok: false,
         };
     }
-    if (step.length === 0) {
-        return {
-            error: `agent_browser batch stdin step ${index} must not be empty.${BATCH_STDIN_EXAMPLE}`,
-            ok: false,
-        };
-    }
-    const invalidTokenIndex = step.findIndex((token) => typeof token !== "string");
-    if (invalidTokenIndex !== -1) {
+    if (!isStringArray(step)) {
+        const invalidTokenIndex = step.findIndex((token) => typeof token !== "string");
         return {
             error: `agent_browser batch stdin step ${index} token ${invalidTokenIndex} must be a string.${BATCH_STDIN_EXAMPLE}`,
             ok: false,
         };
     }
-    return { ok: true, step: step };
+    return { ok: true, step };
 }
 export function parseBatchStdinJsonArray(stdin) {
     if (stdin === undefined) {
@@ -95,19 +129,23 @@ export function parseBatchStdinJsonArray(stdin) {
     try {
         const parsed = JSON.parse(stdin);
         if (!Array.isArray(parsed)) {
-            return { error: `agent_browser batch stdin must be a JSON array of command steps.${BATCH_STDIN_EXAMPLE}` };
+            return {
+                error: `agent_browser batch stdin must be a JSON array of command steps.${BATCH_STDIN_EXAMPLE}`,
+            };
         }
         return { steps: parsed };
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { error: `agent_browser batch stdin could not be parsed as JSON: ${message}.${BATCH_STDIN_EXAMPLE}` };
+        const message = error instanceof Error ? error.message : stringifyUnknown(error);
+        return {
+            error: `agent_browser batch stdin could not be parsed as JSON: ${message}.${BATCH_STDIN_EXAMPLE}`,
+        };
     }
 }
 export function parseUserBatchStdin(stdin) {
     const parsed = parseBatchStdinJsonArray(stdin);
-    if (parsed.error || parsed.steps === undefined) {
-        return parsed.error ? { error: parsed.error } : { steps: [] };
+    if (parsed.error !== undefined || parsed.steps === undefined) {
+        return parsed.error !== undefined ? { error: parsed.error } : { steps: [] };
     }
     const steps = [];
     for (const [index, rawStep] of parsed.steps.entries()) {
@@ -127,15 +165,18 @@ export function parseUserBatchStdin(stdin) {
  * ignored.
  */
 export function getUpstreamEffectiveBatchSteps(commandTokens, stdin) {
-    if (commandTokens[0] !== "batch")
+    if (commandTokens[0] !== "batch") {
         return [];
+    }
     const argumentSteps = commandTokens.slice(1).flatMap((command) => {
-        if (command === "--bail")
+        if (command === "--bail") {
             return [];
+        }
         const step = parseBatchCommandArgument(command).step;
         return step ? [step] : [];
     });
-    if (argumentSteps.length > 0)
+    if (commandTokens.slice(1).some((token) => token !== "--bail")) {
         return argumentSteps;
-    return parseUserBatchStdin(stdin).steps ?? [];
+    }
+    return parseUserBatchStdin(stdin).steps?.filter((step) => step.length > 0) ?? [];
 }

package/dist/extensions/agent-browser/lib/orchestration/browser-run/artifact-merge.js

@@ -1,16 +1,24 @@
-import { getSessionArtifactManifestEntryKey, isPendingRecordingCommand, mergeSessionArtifactManifest } from "../../results/artifact-manifest.js";
+import { getSessionArtifactManifestEntryKey, isPendingRecordingCommand, mergeSessionArtifactManifest, } from "../../results/artifact-manifest.js";
 export function mergeBrowserRunArtifactManifest(current, initial, updated) {
-    if (!updated || updated === initial)
+    if (!updated || updated === initial) {
         return current;
-    if (current === initial)
+    }
+    if (current === initial) {
         return updated;
+    }
     const initialEntries = new Map((initial?.entries ?? []).map((entry) => [getSessionArtifactManifestEntryKey(entry), entry]));
     const changedEntries = updated.entries
         .map((entry, index) => ({ entry, index }))
         .filter(({ entry }) => initialEntries.get(getSessionArtifactManifestEntryKey(entry)) !== entry)
-        .sort((left, right) => left.entry.createdAtMs - right.entry.createdAtMs
-        || Number(isPendingRecordingCommand(left.entry.command, left.entry.subcommand, left.entry.kind)) - Number(isPendingRecordingCommand(right.entry.command, right.entry.subcommand, right.entry.kind))
-        || left.index - right.index)
+        .sort((left, right) => {
+        const timestampOrder = left.entry.createdAtMs - right.entry.createdAtMs;
+        if (timestampOrder !== 0 && !Number.isNaN(timestampOrder)) {
+            return timestampOrder;
+        }
+        const pendingOrder = Number(isPendingRecordingCommand(left.entry.command, left.entry.subcommand, left.entry.kind)) -
+            Number(isPendingRecordingCommand(right.entry.command, right.entry.subcommand, right.entry.kind));
+        return pendingOrder !== 0 ? pendingOrder : left.index - right.index;
+    })
         .map(({ entry }) => entry);
     return changedEntries.length === 0
         ? current

package/dist/extensions/agent-browser/lib/orchestration/browser-run/artifact-paths.js

@@ -2,22 +2,29 @@ import { lstatSync, readlinkSync, realpathSync, statSync } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { foldAgentBrowserFilesystemIdentity } from "../../argv-grammar.js";
 import { parseWaitCommandTokens } from "../../argv-descriptor.js";
-import { getRecordCommandOperandIndices, getRecordCommandOperands } from "../../command-taxonomy.js";
+import { getRecordCommandOperandIndices, getRecordCommandOperands, } from "../../command-taxonomy.js";
 const SCREENSHOT_IMAGE_EXTENSIONS = [".jpeg", ".jpg", ".png", ".webp"];
 function isSingleScreenshotPathToken(token) {
     const explicitlyRelative = token.startsWith("./") || token.startsWith("../");
-    if (token.startsWith("#") || token.startsWith("@") || (token.startsWith(".") && !explicitlyRelative && !token.includes("/")))
+    if (token.startsWith("#") ||
+        token.startsWith("@") ||
+        (token.startsWith(".") && !explicitlyRelative && !token.includes("/"))) {
         return false;
-    return explicitlyRelative || token.includes("/") || SCREENSHOT_IMAGE_EXTENSIONS.some((extension) => token.endsWith(extension));
+    }
+    return (explicitlyRelative ||
+        token.includes("/") ||
+        SCREENSHOT_IMAGE_EXTENSIONS.some((extension) => token.endsWith(extension)));
 }
 export function getScreenshotPositionalIndices(commandTokens) {
-    if (commandTokens[0] !== "screenshot")
+    if (commandTokens[0] !== "screenshot") {
         return [];
+    }
     const positionalIndices = [];
     for (let index = 1; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
-        if (token === "--full" || token === "-f" || token === "--if-changed")
+        if (token === "--full" || token === "-f" || token === "--if-changed") {
             continue;
+        }
         if (token === "--threshold") {
             index += 1;
             continue;
@@ -28,8 +35,9 @@ export function getScreenshotPositionalIndices(commandTokens) {
 }
 export function getScreenshotPathTokenIndex(commandTokens) {
     const positionalIndices = getScreenshotPositionalIndices(commandTokens);
-    if (positionalIndices.length === 0)
+    if (positionalIndices.length === 0) {
         return undefined;
+    }
     const candidateIndex = positionalIndices.length >= 2 ? positionalIndices[1] : positionalIndices[0];
     const candidate = commandTokens[candidateIndex];
     if (positionalIndices.length >= 2 || isSingleScreenshotPathToken(candidate)) {
@@ -37,64 +45,93 @@ export function getScreenshotPathTokenIndex(commandTokens) {
     }
     return undefined;
 }
-const DIFF_SCREENSHOT_VALUE_FLAGS = new Set(["-b", "--baseline", "-o", "--output", "-s", "--selector", "-t", "--threshold"]);
+const DIFF_SCREENSHOT_VALUE_FLAGS = new Set([
+    "-b",
+    "--baseline",
+    "-o",
+    "--output",
+    "-s",
+    "--selector",
+    "-t",
+    "--threshold",
+]);
 export function getDiffFilePathIndices(commandTokens) {
-    if (commandTokens[0] !== "diff" || !["snapshot", "screenshot"].includes(commandTokens[1]))
+    if (commandTokens[0] !== "diff" || !["snapshot", "screenshot"].includes(commandTokens[1])) {
         return {};
-    const valueFlags = commandTokens[1] === "screenshot" ? DIFF_SCREENSHOT_VALUE_FLAGS : new Set(["-b", "--baseline", "-s", "--selector", "-d", "--depth"]);
+    }
+    const valueFlags = commandTokens[1] === "screenshot"
+        ? DIFF_SCREENSHOT_VALUE_FLAGS
+        : new Set(["-b", "--baseline", "-s", "--selector", "-d", "--depth"]);
     const paths = {};
     for (let index = 2; index < commandTokens.length; index += 1) {
         const token = commandTokens[index];
-        if (!valueFlags.has(token))
+        if (!valueFlags.has(token)) {
             continue;
-        const value = commandTokens[index + 1];
-        if (value === undefined)
+        }
+        const value = commandTokens.at(index + 1);
+        if (value === undefined) {
             return {};
-        if (token === "-o" || token === "--output")
+        }
+        if (["-o", "--output"].includes(token)) {
             paths.output = index + 1;
-        if (token === "-b" || token === "--baseline")
+        }
+        if (["-b", "--baseline"].includes(token)) {
             paths.baseline = index + 1;
+        }
         index += 1;
     }
     return paths;
 }
+function canonicalFileIdentity(path, platform) {
+    try {
+        const stats = statSync(path, { bigint: true });
+        if (stats.ino > 0n) {
+            return `inode:${stats.dev}:${stats.ino}`;
+        }
+    }
+    catch {
+        // The destination does not exist yet; canonical ancestry still catches aliases.
+    }
+    return foldAgentBrowserFilesystemIdentity(path, platform);
+}
+function readSymlinkTarget(path) {
+    try {
+        return lstatSync(path).isSymbolicLink()
+            ? resolve(dirname(path), readlinkSync(path))
+            : undefined;
+    }
+    catch {
+        // Missing ancestry is resolved by walking to the next existing parent.
+        return undefined;
+    }
+}
 function canonicalizeArtifactPath(absolutePath, platform, seenSymlinks) {
     let cursor = absolutePath;
     const suffix = [];
     while (true) {
         try {
             const canonicalPath = join(realpathSync.native(cursor), ...suffix);
-            try {
-                const stats = statSync(canonicalPath, { bigint: true });
-                if (stats.ino > 0n)
-                    return `inode:${stats.dev}:${stats.ino}`;
-            }
-            catch {
-                // The destination does not exist yet; canonical ancestry still catches aliases.
-            }
-            return foldAgentBrowserFilesystemIdentity(canonicalPath, platform);
+            return canonicalFileIdentity(canonicalPath, platform);
         }
         catch {
-            let symlinkTarget;
-            try {
-                if (lstatSync(cursor).isSymbolicLink())
-                    symlinkTarget = resolve(dirname(cursor), readlinkSync(cursor));
+            // Resolve missing destinations through their existing ancestry below.
+        }
+        const symlinkTarget = readSymlinkTarget(cursor);
+        if (symlinkTarget !== undefined && symlinkTarget !== "") {
+            if (seenSymlinks.has(cursor)) {
+                throw new Error(`Artifact destination contains a symlink loop: ${absolutePath}`);
             }
-            catch { }
-            if (symlinkTarget) {
-                if (seenSymlinks.has(cursor))
-                    throw new Error(`Artifact destination contains a symlink loop: ${absolutePath}`);
-                if (seenSymlinks.size >= 32)
-                    throw new Error(`Artifact destination has too many symlink hops: ${absolutePath}`);
-                seenSymlinks.add(cursor);
-                return canonicalizeArtifactPath(join(symlinkTarget, ...suffix), platform, seenSymlinks);
+            if (seenSymlinks.size >= 32) {
+                throw new Error(`Artifact destination has too many symlink hops: ${absolutePath}`);
             }
-            const parent = dirname(cursor);
-            if (parent === cursor)
-                return foldAgentBrowserFilesystemIdentity(absolutePath, platform);
-            suffix.unshift(basename(cursor));
-            cursor = parent;
+            return canonicalizeArtifactPath(join(symlinkTarget, ...suffix), platform, new Set([...seenSymlinks, cursor]));
+        }
+        const parent = dirname(cursor);
+        if (parent === cursor) {
+            return foldAgentBrowserFilesystemIdentity(absolutePath, platform);
         }
+        suffix.unshift(basename(cursor));
+        cursor = parent;
     }
 }
 export function canonicalizeExplicitArtifactDestination(cwd, destination, platform = process.platform) {
@@ -102,33 +139,48 @@ export function canonicalizeExplicitArtifactDestination(cwd, destination, platfo
 }
 export function getRecordContactSheetDestination(commandTokens) {
     const path = getRecordCommandOperands(commandTokens).path;
-    if (!path || !commandTokens.some((token) => token === "--contact-sheet" || token === "--contact-sheet-threshold"))
+    if (path === undefined ||
+        path === "" ||
+        !commandTokens.some((token) => token === "--contact-sheet" || token === "--contact-sheet-threshold")) {
         return undefined;
+    }
     const extension = extname(path);
-    return extension ? `${path.slice(0, -extension.length)}.contact-sheet.png` : undefined;
+    return extension !== "" ? `${path.slice(0, -extension.length)}.contact-sheet.png` : undefined;
+}
+function getCompoundArtifactDestinationIndex(commandTokens) {
+    const [command, subcommand] = commandTokens;
+    if (command === "state" && subcommand === "save") {
+        return 2;
+    }
+    if (command === "diff" && subcommand === "screenshot") {
+        return getDiffFilePathIndices(commandTokens).output;
+    }
+    if (command === "network" && subcommand === "har" && commandTokens[2] === "stop") {
+        return 3;
+    }
+    if (["trace", "profiler"].includes(command) && subcommand === "stop") {
+        return 2;
+    }
+    return undefined;
 }
 export function getExplicitArtifactDestinationIndex(commandTokens) {
     const command = commandTokens[0];
-    const subcommand = commandTokens[1];
-    if (command === "screenshot")
+    if (command === "screenshot") {
         return getScreenshotPathTokenIndex(commandTokens);
-    if (command === "download")
+    }
+    if (command === "download") {
         return 2;
-    if (command === "pdf")
+    }
+    if (command === "pdf") {
         return 1;
-    if (command === "wait")
+    }
+    if (command === "wait") {
         return parseWaitCommandTokens(commandTokens).downloadPathIndex;
-    if (command === "state" && subcommand === "save")
-        return 2;
-    if (command === "diff" && subcommand === "screenshot")
-        return getDiffFilePathIndices(commandTokens).output;
-    if (command === "network" && subcommand === "har" && commandTokens[2] === "stop")
-        return 3;
-    if ((command === "trace" || command === "profiler") && subcommand === "stop")
-        return 2;
-    if (command === "record")
+    }
+    if (command === "record") {
         return getRecordCommandOperandIndices(commandTokens)[0];
-    return undefined;
+    }
+    return getCompoundArtifactDestinationIndex(commandTokens);
 }
 export function getExplicitArtifactDestination(commandTokens) {
     const index = getExplicitArtifactDestinationIndex(commandTokens);

package/dist/extensions/agent-browser/lib/orchestration/browser-run/browser-observation-result.js

@@ -0,0 +1,82 @@
+import { isBooleanFlagEnabled } from "../../argv-grammar.js";
+import { isRecord } from "../../parsing.js";
+import { redactSensitiveValue } from "../../runtime-redaction.js";
+import { getNativeWebMcpCatalog } from "../../webmcp-observation.js";
+import { formatWebMcpCatalogUpdate } from "../../results/presentation/common.js";
+import { getSessionContextKey } from "./session-state.js";
+function appendCatalogNotice(result, catalog, data, args) {
+    if (isBooleanFlagEnabled(args, "--json") ||
+        JSON.stringify(getNativeWebMcpCatalog(data)) === JSON.stringify(catalog)) {
+        return result;
+    }
+    const notice = formatWebMcpCatalogUpdate(catalog);
+    const content = [...result.content];
+    const first = content.at(0);
+    if (first?.type === "text") {
+        content[0] = { ...first, text: `${first.text}\n\n${notice}` };
+    }
+    else {
+        content.push({ type: "text", text: notice });
+    }
+    return { ...result, content };
+}
+function addCatalog(result, catalog, args) {
+    if (!catalog) {
+        return result;
+    }
+    const redacted = redactSensitiveValue(catalog);
+    if (!isRecord(redacted)) {
+        throw new Error("Browser catalog redaction did not preserve its object shape.");
+    }
+    const details = isRecord(result.details) ? result.details : undefined;
+    return appendCatalogNotice({ ...result, details: { ...details, webMcpCatalog: redacted } }, redacted, details?.data, args);
+}
+function addFailureError(result) {
+    const details = isRecord(result.details) ? result.details : undefined;
+    if (result.isError !== true || details?.error !== undefined) {
+        return result;
+    }
+    return {
+        ...result,
+        details: {
+            ...details,
+            error: details?.validationError ??
+                details?.summary ??
+                result.content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text)
+                    .join("\n"),
+        },
+    };
+}
+function addPendingPageState(result, state) {
+    const details = isRecord(result.details) ? result.details : undefined;
+    const key = getSessionContextKey(typeof details?.sessionName === "string" ? details.sessionName : undefined, typeof details?.namespace === "string" ? details.namespace : undefined);
+    const page = state.sessionPageState.get(key);
+    if (page.tabReopenPending === undefined) {
+        return result;
+    }
+    return {
+        ...result,
+        details: {
+            ...details,
+            sessionTabReopenPending: page.tabReopenPending,
+            ...(page.refSnapshotInvalidation
+                ? { refSnapshotInvalidation: page.refSnapshotInvalidation }
+                : {}),
+        },
+    };
+}
+export function projectBrowserObservationResult(options) {
+    let result = options.result;
+    const details = isRecord(result.details) ? result.details : undefined;
+    const confirmation = options.state.observedBrowserEffects?.readConfirmation;
+    if (details?.readConfirmation === undefined && Boolean(confirmation)) {
+        result = { ...result, details: { ...details, readConfirmation: confirmation } };
+    }
+    result = addFailureError(addCatalog(result, options.catalog, options.args));
+    if (options.modelVisible === false) {
+        result = { ...result, content: [] };
+    }
+    return addPendingPageState(result, options.state);
+}