pi-agent-browser-native 0.9.2 → 0.9.4

package/dist/extensions/agent-browser/lib/session-page-state.js

@@ -1,263 +1,12 @@
-import { randomUUID } from "node:crypto";
-import { extractUpstreamCommandTokens } from "./argv-descriptor.js";
-import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace } from "./argv-grammar.js";
-import { getBrowserRecord, snapshotFromDefinition } from "./browser-transcript.js";
-import { isCloseCommand, isOpenNavigationCommand, isReadOnlyDiagnosticSessionTargetCommand, isRecordPageTransitionCommand, isUnverifiedPageTransitionCommand, isWebMcpPageMutationCommand, isWindowOrDiffPageTransitionCommand } from "./command-taxonomy.js";
 import { isRecord } from "./parsing.js";
-import { findReadConfirmation as findPendingReadConfirmation, parseReadConfirmation } from "./read-confirmation.js";
-import { getEditableRefEvidence } from "./results/editable-ref-evidence.js";
-import { enrichSnapshotRefEntries, getFullSnapshotData, getSnapshotRefEntries } from "./results/snapshot-refs.js";
-import { parseSnapshotLines } from "./results/snapshot-segments.js";
-export function normalizeComparableUrl(url) {
-    const normalizedUrl = url?.trim();
-    if (!normalizedUrl) {
-        return undefined;
-    }
-    try {
-        const parsedUrl = new URL(normalizedUrl);
-        parsedUrl.hash = "";
-        return parsedUrl.toString();
-    }
-    catch {
-        return undefined;
-    }
-}
-export function normalizeSessionTabTarget(target) {
-    if (!target) {
-        return undefined;
-    }
-    const url = target.url?.trim();
-    if (!url || normalizeComparableUrl(url) === undefined) {
-        return undefined;
-    }
-    const title = target.title?.trim();
-    return { ...(target.targetId?.trim() ? { targetId: target.targetId.trim() } : {}), title: title && title.length > 0 ? title : undefined, url };
-}
-export function isAboutBlankUrl(url) {
-    return normalizeComparableUrl(url) === "about:blank";
-}
-export function isAboutBlankSessionTabTarget(target) {
-    return isAboutBlankUrl(target?.url);
-}
-export function commandExplicitlyTargetsAboutBlank(commandTokens) {
-    return (commandTokens[0] === "window" && commandTokens[1] === "new") || commandTokens.some((token) => isAboutBlankUrl(token));
-}
-export function targetsMatch(left, right) {
-    if (!left || !right)
-        return true;
-    return normalizeComparableUrl(left.url) === normalizeComparableUrl(right.url);
-}
-function extractStringResultField(data, fieldName) {
-    if (typeof data === "string") {
-        if (fieldName === "value")
-            return data;
-        const text = data.trim();
-        return text.length > 0 ? text : undefined;
-    }
-    if (!isRecord(data) || typeof data[fieldName] !== "string") {
-        return undefined;
-    }
-    if (fieldName === "value")
-        return data[fieldName];
-    const text = data[fieldName].trim();
-    return text.length > 0 ? text : undefined;
-}
-function extractSessionTabTargetFromData(data) {
-    const directTarget = normalizeSessionTabTarget({
-        targetId: isRecord(data) && typeof data.targetId === "string" ? data.targetId : undefined,
-        title: extractStringResultField(data, "title"),
-        url: extractStringResultField(data, "url"),
-    });
-    if (directTarget) {
-        return directTarget;
-    }
-    if (isRecord(data) && typeof data.origin === "string") {
-        return normalizeSessionTabTarget({ url: data.origin });
-    }
-    return undefined;
-}
-function extractBatchResultCommand(item) {
-    return Array.isArray(item.command) ? item.command.filter((token) => typeof token === "string") : [];
-}
-export function extractSessionTabTargetFromCommandData(commandTokens, data) {
-    const [command, subcommand] = commandTokens;
-    if (command === "get" && subcommand === "url") {
-        return normalizeSessionTabTarget({ url: extractStringResultField(data, "url") ?? extractStringResultField(data, "result") });
-    }
-    return isReadOnlyDiagnosticSessionTargetCommand(command, subcommand) ? undefined : extractSessionTabTargetFromData(data);
-}
-export function extractSessionTabTargetFromBatchResults(data) {
-    if (!Array.isArray(data)) {
-        return undefined;
-    }
-    let currentTarget;
-    let pendingTitle;
-    for (const item of data) {
-        if (!isRecord(item))
-            continue;
-        // Only this row's native identity can describe the active tab after it ran.
-        if (currentTarget?.targetId)
-            currentTarget = normalizeSessionTabTarget({ title: currentTarget.title, url: currentTarget.url });
-        const commandTokens = extractUpstreamCommandTokens(extractBatchResultCommand(item));
-        const [name, subcommand] = commandTokens;
-        if (isOpenNavigationCommand(name) || isUnverifiedPageTransitionCommand(name, subcommand)
-            || (name === "click" && commandTokens.includes("--new-tab"))) {
-            currentTarget = undefined;
-            pendingTitle = undefined;
-        }
-        if (item.success === false)
-            continue;
-        const result = item.result;
-        if (isCloseCommand(name)) {
-            currentTarget = undefined;
-            pendingTitle = undefined;
-            continue;
-        }
-        if (name === "get" && subcommand === "title") {
-            pendingTitle = extractStringResultField(result, "title");
-            continue;
-        }
-        if (name === "get" && subcommand === "url") {
-            const url = extractStringResultField(result, "url");
-            const target = normalizeSessionTabTarget({ title: pendingTitle, url });
-            if (target) {
-                currentTarget = target;
-            }
-            pendingTitle = undefined;
-            continue;
-        }
-        const resultTarget = extractSessionTabTargetFromCommandData([name, subcommand].filter((token) => token !== undefined), result);
-        if (resultTarget) {
-            currentTarget = resultTarget;
-        }
-        pendingTitle = undefined;
-    }
-    return currentTarget;
-}
-export function deriveSessionTabTarget(options) {
-    if (isCloseCommand(options.command)) {
-        return undefined;
-    }
-    const commandDataTarget = isReadOnlyDiagnosticSessionTargetCommand(options.command, options.subcommand)
-        ? undefined
-        : extractSessionTabTargetFromData(options.data);
-    const observedTarget = normalizeSessionTabTarget(options.navigationSummary)
-        ?? extractSessionTabTargetFromBatchResults(options.data)
-        ?? commandDataTarget;
-    if (observedTarget || !isUnverifiedPageTransitionCommand(options.command, options.subcommand))
-        return observedTarget ?? options.previousTarget;
-    return undefined;
-}
-function extractRefSnapshotRefs(data) {
-    if (!isRecord(data) || !isRecord(data.refs))
-        return undefined;
-    const snapshotLines = typeof data.snapshot === "string" ? parseSnapshotLines(data.snapshot) : [];
-    const lineByRef = new Map(snapshotLines.flatMap((line) => line.ref ? [[line.ref, line.raw]] : []));
-    const entries = enrichSnapshotRefEntries(getSnapshotRefEntries(data), snapshotLines);
-    const refs = Object.fromEntries(entries.flatMap((entry) => {
-        if (!/^e\d+$/.test(entry.id) || entry.role.length === 0)
-            return [];
-        const isContentEditable = getEditableRefEvidence({ ref: entry.refData, text: lineByRef.get(entry.id) });
-        return [[entry.id, { ...(isContentEditable === true ? { isContentEditable: true } : {}), ...(entry.isEditable !== undefined ? { isEditable: entry.isEditable } : {}), name: entry.name, role: entry.role }]];
-    }));
-    return Object.keys(refs).length > 0 ? refs : undefined;
-}
-export function extractRefSnapshotFromData(value) {
-    const data = getFullSnapshotData(value);
-    if (!data)
-        return undefined;
-    const refs = extractRefSnapshotRefs(data);
-    return {
-        refIds: isRecord(data.refs) ? Object.keys(data.refs).filter((refId) => /^e\d+$/.test(refId)) : [],
-        ...(refs ? { refs } : {}),
-        target: extractSessionTabTargetFromData(data),
-    };
-}
-function getBatchResultFailureText(item) {
-    const result = isRecord(item.result) ? item.result : undefined;
-    const parts = [item.error, result?.error, typeof item.result === "string" ? item.result : undefined]
-        .filter((part) => typeof part === "string" && part.trim().length > 0);
-    return parts.length > 0 ? parts.join("\n") : undefined;
-}
-export function buildNoActivePageRefSnapshotInvalidation() {
-    return {
-        reason: "no-active-page",
-        summary: "The latest snapshot for this session reported No active page. Old page-scoped refs are invalid until snapshot -i succeeds.",
-    };
-}
-export function buildPageTransitionRefSnapshotInvalidation(summary) {
-    return {
-        reason: "page-transition",
-        summary: summary ?? "Recording starts and URL-bearing restarts conservatively invalidate earlier page-scoped refs. Run snapshot -i before using refs; this is not evidence of a page change.",
-    };
-}
-export function getCommandRefSnapshotInvalidation(commandTokens) {
-    if (isRecordPageTransitionCommand(commandTokens))
-        return buildPageTransitionRefSnapshotInvalidation();
-    if (isWindowOrDiffPageTransitionCommand(commandTokens[0], commandTokens[1])) {
-        return buildPageTransitionRefSnapshotInvalidation("A window new or diff url command replaced or navigated the active page and invalidated prior refs. Run snapshot -i before using page-scoped refs.");
-    }
-    if (isWebMcpPageMutationCommand(commandTokens)) {
-        return buildPageTransitionRefSnapshotInvalidation("A WebMCP invoke, result, or cancel command can mutate, rerender, or navigate the page, so the prior snapshot refs were invalidated. Run snapshot -i before using page-scoped refs.");
-    }
-    return undefined;
-}
-export function isNoActivePageSnapshotFailure(command, text) {
-    return command === "snapshot" && /\bno active page\b/i.test(text ?? "");
-}
-export function extractLatestRefSnapshotStateFromBatchResults(data) {
-    if (!Array.isArray(data))
-        return undefined;
-    let latestState;
-    for (const item of data) {
-        if (!isRecord(item))
-            continue;
-        const commandTokens = extractUpstreamCommandTokens(extractBatchResultCommand(item));
-        const [name] = commandTokens;
-        if (item.success !== false && isCloseCommand(name)) {
-            latestState = undefined;
-            continue;
-        }
-        const transitionInvalidation = getCommandRefSnapshotInvalidation(commandTokens);
-        if (transitionInvalidation) {
-            latestState = { invalidation: transitionInvalidation };
-            continue;
-        }
-        if (name !== "snapshot")
-            continue;
-        if (item.success === false) {
-            if (isNoActivePageSnapshotFailure(name, getBatchResultFailureText(item))) {
-                latestState = { invalidation: buildNoActivePageRefSnapshotInvalidation() };
-            }
-            continue;
-        }
-        const snapshot = extractRefSnapshotFromData(item.result);
-        if (snapshot) {
-            latestState = { snapshot };
-        }
-        else if (isRecord(item.result) && isRecord(item.result.snapshot)) {
-            latestState = { refreshArgs: commandTokens.filter((token) => token !== "--delta" && token !== "--full") };
-        }
-    }
-    return latestState;
-}
-function shouldApplyTabTargetUpdate(current, unknownOrder, updateOrder) {
-    return updateOrder >= Math.max(current?.order ?? 0, unknownOrder ?? 0);
-}
-function shouldApplyRefStateUpdate(options) {
-    const currentOrder = Math.max(options.currentSnapshot?.order ?? 0, options.currentInvalidation?.order ?? 0);
-    return options.updateOrder >= currentOrder;
-}
-function stripRefSnapshotOrder(snapshot) {
-    return snapshot ? { ...(snapshot.snapshotId ? { snapshotId: snapshot.snapshotId } : {}), ...(snapshot.generation ? { generation: snapshot.generation } : {}), refIds: snapshot.refIds, ...(snapshot.refs ? { refs: snapshot.refs } : {}), target: snapshot.target } : undefined;
-}
-function stripRefSnapshotInvalidationOrder(invalidation) {
-    return invalidation ? { reason: invalidation.reason, summary: invalidation.summary } : undefined;
-}
-export function getSessionPageStateKey(sessionName, namespace) {
-    return sessionName ? getAgentBrowserSessionIdentityKey(sessionName, namespace) : undefined;
-}
+import { randomUUID } from "node:crypto";
+import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace, } from "./argv-grammar.js";
+import { getBrowserRecord, snapshotFromDefinition, } from "./browser-transcript.js";
+import { findReadConfirmation as findPendingReadConfirmation, parseReadConfirmation, } from "./read-confirmation.js";
+import { buildPageTransitionRefSnapshotInvalidation, stripRefSnapshotOrder, stripRefSnapshotInvalidationOrder, shouldApplyTabTargetUpdate, shouldApplyRefStateUpdate, } from "./session-page-observation.js";
+export * from "./session-page-observation.js";
 export class SessionPageState {
+    confirmActions = new Map();
     readConfirmations = new Map();
     refSnapshotInvalidations = new Map();
     refSnapshots = new Map();
@@ -271,16 +20,19 @@ export class SessionPageState {
         const state = new SessionPageState();
         for (const entry of branch) {
             const record = getBrowserRecord(entry);
-            if (record)
+            if (record) {
                 state.applyBrowserRecord(record);
+            }
         }
-        for (const key of state.tabTargets.keys())
+        for (const key of state.tabTargets.keys()) {
             state.tabPinningReasons.set(key, "restore");
+        }
         return state;
     }
     /** A command operates on its admitted state while the committed view is unavailable. */
     fork() {
         const state = new SessionPageState();
+        state.confirmActions = new Map(this.confirmActions);
         state.readConfirmations = new Map(this.readConfirmations);
         state.refSnapshotInvalidations = new Map(this.refSnapshotInvalidations);
         state.refSnapshots = new Map(this.refSnapshots);
@@ -293,74 +45,146 @@ export class SessionPageState {
         return state;
     }
     views() {
-        return new Map([...new Set([...this.tabTargets.keys(), ...this.tabTargetUnknownOrders.keys(), ...this.refSnapshots.keys(), ...this.refSnapshotInvalidations.keys()])].map(key => [key, this.get(key)]));
+        return new Map([
+            ...new Set([
+                ...this.confirmActions.keys(),
+                ...this.tabTargets.keys(),
+                ...this.tabTargetUnknownOrders.keys(),
+                ...this.refSnapshots.keys(),
+                ...this.refSnapshotInvalidations.keys(),
+            ]),
+        ].map((key) => [key, this.get(key)]));
     }
     /** The same reducer commits live observations and replays selected journal envelopes. */
     applyBrowserRecord({ event, snapshot }) {
         const update = this.beginUpdate();
         const confirmation = parseReadConfirmation(event.state.readConfirmation);
         for (const page of event.pages ?? []) {
-            const key = page.key;
-            if (event.phase === "begin") {
-                this.pending.set(key, { operationId: event.operationId, snapshot: this.refSnapshots.get(key) ?? this.pending.get(key)?.snapshot });
-                this.markTabTargetUnknown({ sessionName: key, update });
-                this.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation: buildPageTransitionRefSnapshotInvalidation("This browser operation has no persisted finish. Inspect the current URL and take a fresh snapshot before using refs; changes may already have happened.") });
-                continue;
-            }
-            if (page.clear) {
-                this.clearSession(key);
-                continue;
-            }
-            const pending = this.pending.get(key);
-            if (event.phase === "finish" && pending && pending.operationId !== event.operationId)
-                continue;
-            if (page.unknown || page.refs.kind === "unknown") {
-                this.markTabTargetUnknown({ sessionName: key, update });
-                this.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation: page.refs.kind === "unknown" && page.refs.invalidation
-                        ? page.refs.invalidation : buildPageTransitionRefSnapshotInvalidation("The browser target or operation outcome is unknown. Verify the current URL and take a fresh snapshot before using refs.") });
-                continue;
+            this.applyPageRecord({ page, event, snapshot, update });
+        }
+        if (confirmation) {
+            this.applyReadConfirmation(confirmation, update);
+        }
+    }
+    applyPageRecord(options) {
+        const { page, event, snapshot, update } = options;
+        const key = page.key;
+        if (page.clear === true) {
+            this.clearSession(key);
+            return;
+        }
+        const pending = this.pending.get(key);
+        if (event.phase === "finish" && pending && pending.operationId !== event.operationId) {
+            return;
+        }
+        if (page.confirmActions !== undefined) {
+            this.setConfirmActions(key, page.confirmActions ?? undefined);
+        }
+        if (this.applyUnknownPageRecord(page, event, update)) {
+            return;
+        }
+        this.applyPageTargetRecord(page, update);
+        this.applyPageRefsRecord({
+            page,
+            snapshot,
+            candidate: pending?.snapshot ?? this.refSnapshots.get(key),
+            update,
+        });
+        this.pending.delete(key);
+    }
+    applyUnknownPageRecord(page, event, update) {
+        const key = page.key;
+        if (event.phase === "begin") {
+            this.pending.set(key, {
+                operationId: event.operationId,
+                snapshot: this.refSnapshots.get(key) ?? this.pending.get(key)?.snapshot,
+            });
+            this.invalidateUnknownPage(key, update, buildPageTransitionRefSnapshotInvalidation("This browser operation has no persisted finish. Inspect the current URL and take a fresh snapshot before using refs; changes may already have happened."));
+            return true;
+        }
+        if (page.unknown === true || page.refs.kind === "unknown") {
+            this.invalidateUnknownPage(key, update, page.refs.kind === "unknown" && page.refs.invalidation
+                ? page.refs.invalidation
+                : buildPageTransitionRefSnapshotInvalidation("The browser target or operation outcome is unknown. Verify the current URL and take a fresh snapshot before using refs."));
+            return true;
+        }
+        return false;
+    }
+    invalidateUnknownPage(key, update, invalidation) {
+        this.markTabTargetUnknown({ sessionName: key, update });
+        this.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation });
+    }
+    applyPageTargetRecord(page, update) {
+        if (page.target) {
+            this.applyTabTarget({ sessionName: page.key, target: page.target, update });
+        }
+        else {
+            this.tabTargets.delete(page.key);
+            this.tabTargetUnknownOrders.delete(page.key);
+        }
+        if (page.reopenPending !== undefined) {
+            this.setTabReopenPending({ pending: page.reopenPending, sessionName: page.key, update });
+        }
+        if (page.pinningReason !== undefined) {
+            this.markPinning(page.key, page.pinningReason);
+        }
+        else {
+            this.tabPinningReasons.delete(page.key);
+        }
+    }
+    applyPageRefsRecord(options) {
+        const { page, snapshot, candidate, update } = options;
+        const key = page.key;
+        if (page.refs.kind === "replace") {
+            const definition = isRecord(snapshot) && snapshot.id === page.refs.snapshotId && Boolean(snapshot.refs)
+                ? snapshotFromDefinition(snapshot)
+                : { snapshotId: page.refs.snapshotId, refIds: [] };
+            this.applyRefSnapshot({
+                sessionName: key,
+                snapshot: definition,
+                fallbackTarget: page.target,
+                update,
+            });
+        }
+        else if (page.refs.kind === "reuse") {
+            if (candidate?.snapshotId === page.refs.snapshotId) {
+                this.applyRefSnapshot({
+                    sessionName: key,
+                    snapshot: candidate,
+                    fallbackTarget: page.target,
+                    update,
+                });
             }
-            if (page.target)
-                this.applyTabTarget({ sessionName: key, target: page.target, update });
             else {
-                this.tabTargets.delete(key);
-                this.tabTargetUnknownOrders.delete(key);
+                this.applyRefSnapshotInvalidation({
+                    sessionName: key,
+                    update,
+                    invalidation: buildPageTransitionRefSnapshotInvalidation("The ancestral snapshot definition is unavailable. Take a new complete snapshot before using refs."),
+                });
             }
-            if (page.reopenPending !== undefined)
-                this.setTabReopenPending({ pending: page.reopenPending, sessionName: key, update });
-            if (page.pinningReason)
-                this.markPinning(key, page.pinningReason);
-            else
-                this.tabPinningReasons.delete(key);
-            if (page.refs.kind === "replace") {
-                const definition = snapshot?.id === page.refs.snapshotId && snapshot.refs ? snapshotFromDefinition(snapshot)
-                    : { snapshotId: page.refs.snapshotId, refIds: [] };
-                this.applyRefSnapshot({ sessionName: key, snapshot: definition, fallbackTarget: page.target, update });
-            }
-            else if (page.refs.kind === "reuse") {
-                const candidate = pending?.snapshot ?? this.refSnapshots.get(key);
-                if (candidate?.snapshotId === page.refs.snapshotId)
-                    this.applyRefSnapshot({ sessionName: key, snapshot: candidate, fallbackTarget: page.target, update });
-                else
-                    this.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation: buildPageTransitionRefSnapshotInvalidation("The ancestral snapshot definition is unavailable. Take a new complete snapshot before using refs.") });
+        }
+        else {
+            this.refSnapshots.delete(key);
+            if (page.refs.invalidation) {
+                this.applyRefSnapshotInvalidation({
+                    sessionName: key,
+                    invalidation: page.refs.invalidation,
+                    update,
+                });
             }
             else {
-                this.refSnapshots.delete(key);
-                if (page.refs.invalidation)
-                    this.applyRefSnapshotInvalidation({ sessionName: key, invalidation: page.refs.invalidation, update });
-                else
-                    this.refSnapshotInvalidations.delete(key);
+                this.refSnapshotInvalidations.delete(key);
             }
-            this.pending.delete(key);
         }
-        if (confirmation)
-            this.applyReadConfirmation(confirmation, update);
     }
     beginUpdate() {
         this.updateOrder += 1;
+        // This sole constructor brands the privately incremented numeric order without changing runtime comparison semantics.
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
         return this.updateOrder;
     }
     reset() {
+        this.confirmActions.clear();
         this.readConfirmations.clear();
         this.pending.clear();
         this.nativeGenerations.clear();
@@ -372,27 +196,42 @@ export class SessionPageState {
         this.updateOrder = 0;
     }
     get(sessionName) {
-        if (!sessionName)
+        if (sessionName === undefined || sessionName.length === 0) {
             return {};
+        }
         return {
+            ...(this.confirmActions.has(sessionName)
+                ? { confirmActions: this.confirmActions.get(sessionName) }
+                : {}),
             pinningReason: this.tabPinningReasons.get(sessionName),
-            ...(this.tabTargets.get(sessionName)?.reopenPending !== undefined ? { tabReopenPending: this.tabTargets.get(sessionName)?.reopenPending } : {}),
+            ...(this.tabTargets.get(sessionName)?.reopenPending !== undefined
+                ? { tabReopenPending: this.tabTargets.get(sessionName)?.reopenPending }
+                : {}),
             refSnapshot: stripRefSnapshotOrder(this.refSnapshots.get(sessionName)),
             refSnapshotInvalidation: stripRefSnapshotInvalidationOrder(this.refSnapshotInvalidations.get(sessionName)),
             ...(this.tabTargetUnknownOrders.has(sessionName) ? { tabTargetUnknown: true } : {}),
             tabTarget: this.tabTargets.get(sessionName)?.target,
         };
     }
-    findReadConfirmation(args, namespace) {
-        return findPendingReadConfirmation(args, [...this.readConfirmations.values()].map(entry => entry.value), namespace);
+    findReadConfirmation(args, namespace, stdin) {
+        return findPendingReadConfirmation(args, [...this.readConfirmations.values()].map((entry) => entry.value), namespace, stdin);
+    }
+    setConfirmActions(sessionName, value) {
+        if (value !== undefined) {
+            this.confirmActions.set(sessionName, value);
+        }
+        else {
+            this.confirmActions.delete(sessionName);
+        }
     }
     getReadConfirmation(sessionKey) {
         return this.readConfirmations.get(sessionKey)?.value;
     }
     applyReadConfirmation(value, update) {
         const key = getAgentBrowserSessionIdentityKey(value.sessionName, value.namespace);
-        if (update >= (this.readConfirmations.get(key)?.order ?? 0))
+        if (update >= (this.readConfirmations.get(key)?.order ?? 0)) {
             this.readConfirmations.set(key, { value, order: update });
+        }
     }
     applyTabTarget(options) {
         const current = this.tabTargets.get(options.sessionName);
@@ -400,14 +239,24 @@ export class SessionPageState {
             return { ...this.get(options.sessionName), applied: false, stale: true };
         }
         this.tabTargetUnknownOrders.delete(options.sessionName);
-        this.tabTargets.set(options.sessionName, { order: options.update, reopenPending: current?.reopenPending, target: options.target });
+        this.tabTargets.set(options.sessionName, {
+            order: options.update,
+            reopenPending: current?.reopenPending,
+            target: options.target,
+        });
         return { ...this.get(options.sessionName), applied: true };
     }
     setTabReopenPending(options) {
         const current = this.tabTargets.get(options.sessionName);
-        if (!current || !shouldApplyTabTargetUpdate(current, this.tabTargetUnknownOrders.get(options.sessionName), options.update))
+        if (!current ||
+            !shouldApplyTabTargetUpdate(current, this.tabTargetUnknownOrders.get(options.sessionName), options.update)) {
             return;
-        this.tabTargets.set(options.sessionName, { ...current, order: options.update, reopenPending: options.pending });
+        }
+        this.tabTargets.set(options.sessionName, {
+            ...current,
+            order: options.update,
+            reopenPending: options.pending,
+        });
     }
     applyRefSnapshot(options) {
         if (!shouldApplyRefStateUpdate({
@@ -417,19 +266,27 @@ export class SessionPageState {
         })) {
             return { ...this.get(options.sessionName), applied: false, stale: true };
         }
-        const snapshot = { ...options.snapshot, generation: options.snapshot.generation ?? this.nativeGenerations.get(options.sessionName), snapshotId: options.snapshot.snapshotId ?? randomUUID(), target: options.snapshot.target ?? options.fallbackTarget };
+        const snapshot = {
+            ...options.snapshot,
+            generation: options.snapshot.generation ?? this.nativeGenerations.get(options.sessionName),
+            snapshotId: options.snapshot.snapshotId ?? randomUUID(),
+            target: options.snapshot.target ?? options.fallbackTarget,
+        };
         this.refSnapshotInvalidations.delete(options.sessionName);
         this.refSnapshots.set(options.sessionName, { ...snapshot, order: options.update });
         return { ...this.get(options.sessionName), applied: true };
     }
     bindSnapshotGeneration(sessionName, generation) {
-        if (generation)
+        if (generation !== undefined && generation.length > 0) {
             this.nativeGenerations.set(sessionName, generation);
-        else
+        }
+        else {
             this.nativeGenerations.delete(sessionName);
+        }
         const snapshot = this.refSnapshots.get(sessionName);
-        if (snapshot)
+        if (snapshot) {
             this.refSnapshots.set(sessionName, { ...snapshot, generation });
+        }
     }
     applyRefSnapshotInvalidation(options) {
         if (!shouldApplyRefStateUpdate({
@@ -440,13 +297,17 @@ export class SessionPageState {
             return { ...this.get(options.sessionName), applied: false, stale: true };
         }
         this.refSnapshots.delete(options.sessionName);
-        this.refSnapshotInvalidations.set(options.sessionName, { ...options.invalidation, order: options.update });
+        this.refSnapshotInvalidations.set(options.sessionName, {
+            ...options.invalidation,
+            order: options.update,
+        });
         return { ...this.get(options.sessionName), applied: true };
     }
     markTabTargetUnknown(options) {
         const current = this.tabTargets.get(options.sessionName);
-        if (!shouldApplyTabTargetUpdate(current, this.tabTargetUnknownOrders.get(options.sessionName), options.update))
+        if (!shouldApplyTabTargetUpdate(current, this.tabTargetUnknownOrders.get(options.sessionName), options.update)) {
             return { ...this.get(options.sessionName), applied: false, stale: true };
+        }
         this.refSnapshotInvalidations.delete(options.sessionName);
         this.refSnapshots.delete(options.sessionName);
         this.tabPinningReasons.delete(options.sessionName);
@@ -455,6 +316,7 @@ export class SessionPageState {
         return { ...this.get(options.sessionName), applied: true };
     }
     clearSession(sessionName) {
+        this.confirmActions.delete(sessionName);
         this.pending.delete(sessionName);
         this.nativeGenerations.delete(sessionName);
         this.readConfirmations.delete(sessionName);
@@ -466,6 +328,7 @@ export class SessionPageState {
     }
     clearNamespace(namespace) {
         const sessionKeys = new Set([
+            ...this.confirmActions.keys(),
             ...this.readConfirmations.keys(),
             ...this.refSnapshotInvalidations.keys(),
             ...this.refSnapshots.keys(),
@@ -474,8 +337,9 @@ export class SessionPageState {
             ...this.tabTargets.keys(),
         ]);
         for (const sessionKey of sessionKeys) {
-            if (isAgentBrowserSessionIdentityKeyInNamespace(sessionKey, namespace))
+            if (isAgentBrowserSessionIdentityKeyInNamespace(sessionKey, namespace)) {
                 this.clearSession(sessionKey);
+            }
         }
     }
     markPinning(sessionName, reason) {

package/dist/extensions/agent-browser/lib/session-page-types.js

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