# Files changed · PR \#18588 · pingdotgg/t3code [View on GitCafe](https://git.cafe/pingdotgg/t3code/pull/18588/diffs) Repository: [pingdotgg/t3code](https://git.cafe/pingdotgg/t3code) Visibility: public [fix\(server,desktop\): browser tools report why a page failed to load](https://git.cafe/pingdotgg/t3code/pull/18588.md) Version: 19 Head commit: 5dbd412d6964143b874134d7b8265e017fdb3af0 Base commit: 8acbefefc51b4d281dcd04108c82baa1ab902b0e Comparison base: 8acbefefc51b4d281dcd04108c82baa1ab902b0e Showing up to 20 entries from this revision. If the pull request changes, reopen the first page before continuing. ## apps/desktop/src/preview/DesktopBrowserHost.ts Status: modified; +7; −0 ```diff @@ -7,6 +7,7 @@ DesktopBrowserCommand, DesktopBrowserEvent, type DesktopBrowserEvent as DesktopBrowserEventType, + type PreviewAutomationLoadError, } from "@t3tools/contracts"; import * as Context from "effect/Context"; import * as NodePath from "node:path"; @@ -61,6 +62,7 @@ readonly handleCommandLine: (line: string) => Effect.Effect; readonly attach: (key: DesktopBrowserTabKey, debuggee: DesktopBrowserTabDebugger) => void; readonly detach: (key: DesktopBrowserTabKey) => void; + readonly loadFailed: (key: DesktopBrowserTabKey, failure: PreviewAutomationLoadError) => void; readonly humanStartedDownload: (source: Electron.WebContents) => boolean; readonly placeDownload: (source: Electron.WebContents, item: Electron.DownloadItem) => boolean; readonly pointers: Stream.Stream<{ @@ -161,6 +163,10 @@ emit({ type: "attached", ...key }); }; + const loadFailed: DesktopBrowserHost["Service"]["loadFailed"] = (key, failure) => { + if (tabs.has(keyOf(key))) emit({ type: "loadFailed", ...key, ...failure }); + }; + const handleCommandLine = (line: string) => Effect.sync(() => { const command = decodeCommand(line); @@ -209,6 +215,7 @@ handleCommandLine, attach, detach, + loadFailed, placeDownload, humanStartedDownload, }); ``` ## apps/desktop/src/preview/Manager.test.ts Status: modified; +91; −0 ```diff @@ -1735,6 +1735,97 @@ }).pipe(Effect.provide(managerLayer()), Effect.scoped), ); + effectIt.effect("reports early and subsequent load failures for the current guest", () => + Effect.gen(function* () { + const host = yield* DesktopBrowserHost.DesktopBrowserHost; + const serverTab = { threadId: "thread-1", tabId: "server-tab-1" }; + const lines = yield* Queue.unbounded(); + yield* host.events.pipe( + Stream.runForEach((line) => Queue.offer(lines, new TextDecoder().decode(line))), + Effect.forkScoped({ startImmediately: true }), + ); + const makeGuest = (id: number) => { + const listeners = new Map void>>(); + const wc = Object.assign( + makeTestPreviewWebContents( + async () => ({ + toJPEG: () => Buffer.from("jpeg"), + getSize: () => ({ width: 100, height: 80 }), + }), + id, + ), + { + isDevToolsOpened: () => false, + getUserAgent: () => "Electron", + once: vi.fn(), + on: (event: string, listener: (...args: unknown[]) => void) => { + listeners.set(event, [...(listeners.get(event) ?? []), listener]); + }, + }, + ); + const emit = (event: string, ...args: unknown[]) => { + for (const listener of listeners.get(event) ?? []) listener(...args); + }; + return { + wc, + emit, + fail: (url: string) => + emit("did-fail-load", {}, -202, "ERR_CERT_AUTHORITY_INVALID", url, true), + }; + }; + const initial = makeGuest(42); + const replacement = makeGuest(43); + const manager = yield* PreviewManager.PreviewManager; + const statuses: PreviewManager.PreviewNavStatus[] = []; + yield* manager.subscribeStateChanges((_tabId, state) => + Effect.sync(() => { + statuses.push(state.navStatus); + }), + ); + yield* manager.createTab("tab_1", { serverTab }); + yield* manager.prepareWebview(initial.wc); + yield* manager.prepareWebview(replacement.wc); + initial.fail("https://first.local/"); + initial.emit("did-start-navigation", { isMainFrame: false, isSameDocument: false }); + initial.emit("did-start-loading"); + replacement.fail("https://second.local/"); + const failure = (url: string) => ({ + type: "loadFailed", + ...serverTab, + url, + code: -202, + description: "ERR_CERT_AUTHORITY_INVALID", + }); + + fromId.mockReturnValue(initial.wc); + yield* manager.registerWebview("tab_1", 42); + expect(JSON.parse(yield* Queue.take(lines))).toEqual({ type: "attached", ...serverTab }); + expect(JSON.parse(yield* Queue.take(lines))).toEqual(failure("https://first.local/")); + + fromId.mockReturnValue(replacement.wc); + yield* manager.registerWebview("tab_1", 43); + expect(JSON.parse(yield* Queue.take(lines))).toEqual({ type: "detached", ...serverTab }); + expect(JSON.parse(yield* Queue.take(lines))).toEqual({ type: "attached", ...serverTab }); + expect(JSON.parse(yield* Queue.take(lines))).toEqual(failure("https://second.local/")); + + // A callback queued by the old guest must not report a failure for its replacement. + initial.fail("https://stale.local/"); + replacement.fail("https://current.local/"); + expect(JSON.parse(yield* Queue.take(lines))).toEqual(failure("https://current.local/")); + expect(statuses).not.toContainEqual(expect.objectContaining({ url: "https://stale.local/" })); + + const retried = makeGuest(44); + yield* manager.prepareWebview(retried.wc); + retried.fail("https://retry.local/"); + retried.emit("did-start-navigation", { isMainFrame: true, isSameDocument: false }); + fromId.mockReturnValue(retried.wc); + yield* manager.registerWebview("tab_1", 44); + expect(JSON.parse(yield* Queue.take(lines))).toEqual({ type: "detached", ...serverTab }); + expect(JSON.parse(yield* Queue.take(lines))).toEqual({ type: "attached", ...serverTab }); + expect(statuses.at(-1)?.kind).toBe("Success"); + }).pipe(Effect.provide(managerLayer()), Effect.scoped), + ); + effectIt.effect("discards a screenshot that resolves after its guest is replaced", () => withManager((manager) => Effect.gen(function* () { ``` ## apps/desktop/src/preview/Manager.ts Status: modified; +64; −11 ```diff @@ -25,6 +25,7 @@ DesktopPreviewScreenshotArtifact, DesktopPreviewTabDefaults, PreviewForwardedShortcut, + PreviewAutomationLoadError, } from "@t3tools/contracts"; import * as HostProcess from "@t3tools/shared/HostProcess"; import { matchesKeybindingShortcut } from "@t3tools/shared/keybindings"; @@ -603,6 +604,8 @@ { readonly semaphore: Semaphore.Semaphore; users: number } >(); const tabLifecycleGenerations = new Map(); + // A guest can fail its first load before registerWebview installs its tab listeners. + const guestLoadFailures = new Map(); const attempt = (errorContext: PreviewOperationContext, evaluate: () => A) => Effect.try({ @@ -1451,16 +1454,39 @@ validatedUrl: string, isMainFrame: boolean, ): void => { - if (code === -3 || !isMainFrame) return; + if (code === -3 || !isMainFrame || wc.isDestroyed()) return; + const url = validatedUrl || wc.getURL(); runFork( + Effect.gen(function* () { + const updatedAt = yield* currentIso; + const next = yield* SynchronizedRef.modify(tabsRef, (tabs) => { + const current = tabs.get(tabId); + if ( + !current || + current.webContentsId !== wc.id || + wc.isDestroyed() || + webContents.fromId(wc.id) !== wc - update(tabId, { - navStatus: { + ) { + return [Option.none(), tabs] as const; + } + const state: PreviewTabState = { + ...current, + navStatus: { kind: "LoadFailed", url, title: wc.getTitle(), code, description }, + updatedAt, + }; + return [ + Option.some(state), + replaceMap(tabs, (copy) => copy.set(tabId, state)), + ] as const; + }); + if (Option.isNone(next)) return; + const current = (yield* SynchronizedRef.get(tabsRef)).get(tabId); + if (current?.webContentsId !== wc.id || current.navStatus !== next.value.navStatus) + return; + if (current.serverTab) { + browserHost.loadFailed(current.serverTab, { url, code, description }); + } + yield* emitIfCurrent(tabId, next.value); - kind: "LoadFailed", - url: validatedUrl || wc.getURL(), - title: wc.getTitle(), - code, - description, - }, }), ); }; @@ -1905,11 +1931,17 @@ ] as const; } const pendingUrl = current.navStatus.kind === "Loading" ? current.navStatus.url : null; + const failure = guestLoadFailures.get(webContentsId); const { favicon: _favicon, ...currentWithoutFavicon } = current; const next: PreviewTabState = { ...currentWithoutFavicon, webContentsId, + navStatus: + failure && (pendingUrl === null || pendingUrl === failure.url) + ? { kind: "LoadFailed", title: wc.getTitle(), ...failure } + : pendingUrl === null + ? computeNavStatus(wc) + : current.navStatus, - navStatus: pendingUrl === null ? computeNavStatus(wc) : current.navStatus, canGoBack: wc.navigationHistory.canGoBack(), canGoForward: wc.navigationHistory.canGoForward(), audible: attachedAudible, @@ -1983,7 +2015,19 @@ ) { yield* rendererHistory.register(wc, { surface: "preview" }); const webContentsId = wc.id; + wc.on("did-start-navigation", (event) => { + if (event.isMainFrame && !event.isSameDocument) guestLoadFailures.delete(webContentsId); + }); + wc.on("did-fail-load", (_event, code, description, validatedUrl, isMainFrame) => { + if (code === -3 || !isMainFrame) return; + guestLoadFailures.set(webContentsId, { + url: validatedUrl || wc.getURL(), + code, + description, + }); + }); wc.once("destroyed", () => { + guestLoadFailures.delete(webContentsId); runFork(detachControlSession(webContentsId)); }); yield* ensureControlSession(wc).pipe( @@ -2380,14 +2424,23 @@ const beforeAttach = (yield* SynchronizedRef.get(tabsRef)).get(tabId); if (beforeAttach?.webContentsId !== wc.id) return; const control = yield* ensureControlSession(wc); + if (beforeAttach.serverTab) yield* listenForAgentPointers; const afterAttach = (yield* SynchronizedRef.get(tabsRef)).get(tabId); if (afterAttach?.webContentsId !== wc.id) { yield* detachControlSession(wc.id); return; } if (afterAttach.serverTab) { - yield* listenForAgentPointers; browserHost.attach(afterAttach.serverTab, { webContents: wc, debugger: control.debugger }); + // CDP cannot recover a failure that happened before it attached. + const { navStatus } = afterAttach; + if (navStatus.kind === "LoadFailed") { + browserHost.loadFailed(afterAttach.serverTab, { + url: navStatus.url, + code: navStatus.code, + description: navStatus.description, + }); + } } if (afterAttach.colorScheme !== "system") { yield* attemptPromise({ operation: "applyColorScheme", tabId, webContentsId: wc.id }, () => ``` ## apps/server/src/mcp/toolkits/preview/tools.ts Status: modified; +2; −2 ```diff @@ -60,7 +60,7 @@ const PreviewStatusTool = Tool.make("preview_status", { description: - "Report whether a collaborative browser tab is automation-capable, including its control owner, pending dialog, URL, title, visibility, loading state, viewport mode, and measured CSS-pixel size. Pass tabId to inspect a specific tab; omit it to use this agent session's current tab, or the tab the user is viewing when you have none. Server hosts also list every tab in the thread (tabs) with its owner, including tabs the user opened, and the browser profiles preview_open accepts. You can read any listed tab; act only on your own tabs, or on an unclaimed tab while no human controls it.", + "Report whether a collaborative browser tab is automation-capable, including its control owner, pending dialog, URL, title, visibility, loading state, why a failed page did not load, viewport mode, and measured CSS-pixel size. Pass tabId to inspect a specific tab; omit it to use this agent session's current tab, or the tab the user is viewing when you have none. Server hosts also list every tab in the thread (tabs) with its owner, including tabs the user opened, and the browser profiles preview_open accepts. You can read any listed tab; act only on your own tabs, or on an unclaimed tab while no human controls it.", parameters: PreviewAutomationTabTargetInput, success: PreviewAutomationStatus, failure: PreviewToolFailure, @@ -139,7 +139,7 @@ export const PreviewSnapshotTool = safeBrowserTool( Tool.make("preview_snapshot", { description: - "Inspect a page before interacting. Pass tabId to inspect a specific tab, including one the user opened (see preview_status tabs), even while they control it; omit it to use this agent session's current tab, or the tab the user is viewing when you have none. Returns page state, semantic elements, diagnostics, action history, and screenshot dimensions. Server snapshots include an accessibilityTree with refs; pass locator=aria-ref= to target one exact element, including inside frames. Refresh refs after navigation, another snapshot, or human takeover. The text is capped near 20 KB and lists what it omitted; use preview_evaluate to read more. Set includeImage=true only when you need to see the page; the image stays in tool history. Set save=true to write the PNG to disk and get back only the url and screenshotPath. Embed that path in your reply as ![alt](screenshotPath) so the user sees it. This is the only way to show the user a screenshot; the image in the tool result is not saved anywhere.", + "Inspect a page before interacting. Pass tabId to inspect a specific tab, including one the user opened (see preview_status tabs), even while they control it; omit it to use this agent session's current tab, or the tab the user is viewing when you have none. Returns page state, semantic elements, diagnostics, action history, and screenshot dimensions. A page that failed to load includes loadError with the browser's error code. Server snapshots include an accessibilityTree with refs; pass locator=aria-ref= to target one exact element, including inside frames. Refresh refs after navigation, another snapshot, or human takeover. The text is capped near 20 KB and lists what it omitted; use preview_evaluate to read more. Set includeImage=true only when you need to see the page; the image stays in tool history. Set save=true to write the PNG to disk and get back only the url and screenshotPath. Embed that path in your reply as ![alt](screenshotPath) so the user sees it. This is the only way to show the user a screenshot; the image in the tool result is not saved anywhere.", parameters: Schema.Struct({ ...PreviewAutomationTabTargetInput.fields, includeImage: Schema.optional( ``` ## apps/server/src/preview/DesktopBrowserChannel.ts Status: modified; +15; −0 ```diff @@ -11,6 +11,7 @@ DesktopBrowserCommand, DesktopBrowserEvent, type DesktopBrowserCommand as DesktopBrowserCommandType, + type PreviewAutomationLoadError, } from "@t3tools/contracts"; import * as Context from "effect/Context"; import * as Duration from "effect/Duration"; @@ -52,6 +53,9 @@ readonly detached: Stream.Stream; readonly attached: Stream.Stream; readonly isAttached: (key: DesktopTabKey) => Effect.Effect; + readonly loadFailure: ( + key: DesktopTabKey, + ) => Effect.Effect>; readonly endpoint: (key: DesktopTabKey) => Effect.Effect; readonly pointer: ( key: DesktopTabKey, @@ -66,6 +70,7 @@ const controlFd = config.desktopBrowserControlFd; const changes = yield* PubSub.unbounded<{ key: DesktopTabKey; attached: boolean }>(); const attachedTabs = new Set(); + const loadFailures = new Map(); const inbound = new Map>(); const writeLock = yield* Semaphore.make(1); @@ -76,6 +81,7 @@ detached: Stream.empty, attached: Stream.empty, isAttached: () => Effect.succeed(false), + loadFailure: () => Effect.succeedNone, endpoint: () => Effect.die("No desktop app is attached to this server."), pointer: () => Effect.void, }); @@ -117,8 +123,16 @@ case "attached": attachedTabs.add(id); return PubSub.publish(changes, { key, attached: true }); + case "loadFailed": + loadFailures.set(id, { + url: event.url.slice(0, 2048), + code: event.code, + description: event.description, + }); + return Effect.void; case "detached": { attachedTabs.delete(id); + loadFailures.delete(id); const queue = inbound.get(id); return (queue ? Queue.shutdown(queue) : Effect.void).pipe( Effect.andThen(PubSub.publish(changes, { key, attached: false })), @@ -214,6 +228,7 @@ Stream.map((change) => change.key), ), isAttached: (key) => Effect.sync(() => attachedTabs.has(keyOf(key))), + loadFailure: (key) => Effect.sync(() => Option.fromUndefinedOr(loadFailures.get(keyOf(key)))), endpoint, pointer: (key, pointer) => command({ type: "pointer", ...key, ...pointer }), }); ``` ## apps/server/src/preview/ServerBrowser.test.ts Status: modified; +106; −0 ```diff @@ -10,6 +10,7 @@ PreviewTabId, ProviderInstanceId, ThreadId, + type PreviewAutomationLoadError, type PreviewAutomationSnapshot, type PreviewAutomationStatus, } from "@t3tools/contracts"; @@ -231,6 +232,7 @@ return desktopTabs.has(tabId); }; const releasedDesktopTabs: Array = []; +const desktopLoadFailures = new Map(); const desktopConnections: Array<{ endpoint: string; context: ReturnType }> = []; const testThread = { threadId: ThreadId.make("browser-test-thread"), @@ -286,6 +288,8 @@ ), ), isAttached: (key) => Effect.sync(() => desktopRenders(key.tabId)), + loadFailure: (key) => + Effect.sync(() => Option.fromUndefinedOr(desktopLoadFailures.get(key.tabId))), endpoint: (key) => Effect.acquireRelease(Effect.succeed(`ws://desktop/${key.tabId}`), () => Effect.sync(() => releasedDesktopTabs.push(key.tabId)), @@ -331,6 +335,7 @@ desktopRendersNext = false; releasedDesktopTabs.length = 0; desktopConnections.length = 0; + desktopLoadFailures.clear(); }); it.live.each(["desktop" as const, undefined])( @@ -1148,3 +1153,104 @@ }), ).pipe(Effect.provide(layer)), ); + +const certificateError = { + url: "https://device.local/", + code: -202, + description: "ERR_CERT_AUTHORITY_INVALID", +}; +const dataUrl = `data:text/html,${"PAYLOAD".repeat(300)}`; + +it.live("reports why a page failed to load while the tab shows the error page", () => + Effect.scoped( + Effect.gen(function* () { + const { broker, tabId } = yield* ready; + const page = contexts[0]!.page; + const request = { + url: () => certificateError.url, + method: () => "GET", + isNavigationRequest: () => true, + frame: () => page, + failure: () => ({ errorText: "net::ERR_CERT_AUTHORITY_INVALID" }), + }; + const status = () => + broker.invoke({ scope, tabId, operation: "status", input: {} }); + const snapshot = () => + broker.invoke({ + scope, + tabId, + operation: "snapshot", + input: {}, + }); + expect(yield* status()).not.toHaveProperty("loadError"); + expect(yield* snapshot()).not.toHaveProperty("loadError"); + page.emit("request", request); + page.emit("requestfailed", request); + page.url = () => "chrome-error://chromewebdata/"; + expect((yield* status()).loadError).toEqual(certificateError); + expect((yield* snapshot()).loadError).toEqual(certificateError); + + const subframeRequest = { + ...request, + url: () => "https://frame.local/", + frame: () => ({}), + }; + page.emit("request", subframeRequest); + page.emit("requestfailed", subframeRequest); + expect((yield* status()).loadError).toEqual(certificateError); + + // Clearing must happen before the next navigation replaces the error page. + page.emit("request", { ...request, url: () => "https://device.local/login" }); + expect(yield* status()).not.toHaveProperty("loadError"); + expect(yield* snapshot()).not.toHaveProperty("loadError"); + + const dataRequest = { ...request, url: () => dataUrl }; + page.emit("request", dataRequest); + page.emit("requestfailed", dataRequest); + expect((yield* status()).loadError?.url).toBe("data:text/html,…"); + }), + ).pipe(Effect.provide(layer)), +); + +it.live("reports a desktop tab's load failure from before the server connected", () => + Effect.scoped( + Effect.gen(function* () { + const browser = yield* ServerBrowser.ServerBrowser; + const broker = yield* Broker.PreviewAutomationBroker; + const manager = yield* Manager.PreviewManager; + yield* Effect.yieldNow; + desktopRendersNext = true; + const opened = yield* manager.open({ threadId: scope.thread.threadId, runtime: "server" }); + desktopLoadFailures.set(opened.tabId, certificateError); + yield* browser.attachViewer(viewerInput(opened.tabId, false)); + const page = desktopConnections[0]!.context.page; + page.url = () => "chrome-error://chromewebdata/"; + const status = () => + broker.invoke({ + scope, + operation: "status", + input: {}, + tabId: PreviewTabId.make(opened.tabId), + }); + const snapshot = () => + broker.invoke({ + scope, + operation: "snapshot", + input: {}, + tabId: PreviewTabId.make(opened.tabId), + }); + expect((yield* status()).loadError).toEqual(certificateError); + expect((yield* snapshot()).loadError).toEqual(certificateError); + desktopLoadFailures.set(opened.tabId, { ...certificateError, url: dataUrl }); + expect((yield* status()).loadError?.url).toBe("data:text/html,…"); + // A navigation the server sees supersedes it, even before the error page goes. + page.emit("request", { + url: () => "https://device.local/retry", + isNavigationRequest: () => true, + frame: () => page, + }); + expect(yield* status()).not.toHaveProperty("loadError"); + expect(yield* snapshot()).not.toHaveProperty("loadError"); + }), + ).pipe(Effect.provide(layer)), +); ``` ## apps/server/src/preview/ServerBrowser.ts Status: modified; +27; −8 ```diff @@ -20,6 +20,7 @@ type PreviewAutomationDragInput, type PreviewAutomationEvaluateInput, type PreviewAutomationHoverInput, + type PreviewAutomationLoadError, type PreviewAutomationNavigateInput, type PreviewAutomationNetworkEntry, type PreviewAutomationOpenInput, @@ -307,6 +308,7 @@ colorScheme: PreviewAppearancePreference; zoomFactor: number; loading: boolean; + loadError: PreviewAutomationLoadError | undefined; closing: boolean; recording: Recording | null; initialNavigation: Promise | null; @@ -774,6 +776,7 @@ colorScheme: "system", zoomFactor: 1, loading: false, + loadError: undefined, closing: false, recording: null, recordingStart: null, @@ -795,6 +798,7 @@ navigationGenerations.set(request, ++tab.navigationGeneration); clearAbortedNavigation(tab); tab.loading = true; + tab.loadError = undefined; report(tab, { _tag: "Loading", url: ServerBrowserPage.withoutDataPayload(request.url()).slice(0, 2048), @@ -846,13 +850,9 @@ } tab.loading = false; const { code, description } = ServerBrowserPage.parseNetError(errorText); - report(tab, { - _tag: "LoadFailed", - url: ServerBrowserPage.withoutDataPayload(request.url()).slice(0, 2048), - title: "", - code, + const url = ServerBrowserPage.withoutDataPayload(request.url()).slice(0, 2048); + tab.loadError = { url, code, description }; + report(tab, { _tag: "LoadFailed", url, title: "", code, description }); - description, - }); }); page.on("response", (response) => { pushBounded(tab.networkEntries, { @@ -1352,6 +1352,21 @@ ); }; + const loadErrorOf = async (tab: ServerTab) => { + if (!tab.page.url().startsWith("chrome-error://")) return undefined; + // A desktop failure from before CDP attached is superseded by any navigation we observe. + if (tab.loadError || !tab.desktop || tab.navigationGeneration > 0) return tab.loadError; + const reported = await Effect.runPromise( + desktopChannel.loadFailure({ threadId: tab.threadId, tabId: tab.tabId }), + ); + return Option.getOrUndefined( + Option.map(reported, (error) => ({ + ...error, + url: ServerBrowserPage.withoutDataPayload(error.url), + })), + ); + }; + const statusWithTitle = async ( tab: ServerTab | undefined, agentSessionId?: string, @@ -1369,6 +1384,7 @@ } const url = tab.page.url(); const viewport = tab.page.viewportSize(); + const loadError = await loadErrorOf(tab); const status = { available: true, visible: tab.viewers.size > 0, @@ -1376,6 +1392,7 @@ url: url === "about:blank" ? null : url, title: null, loading: tab.loading, + ...(loadError ? { loadError } : {}), control: { owner: tabOwner(tab), ownedByCaller: tab.control.agentId === agentSessionId, @@ -1968,12 +1985,14 @@ return { tabId: tab.tabId, colorScheme }; } case "snapshot": { - return withScreencastsPaused(tab, () => + const snapshot = await withScreencastsPaused(tab, () => ServerBrowserPage.snapshot({ ...tab, renderScale: tab.desktop ? "display" : RENDER_SCALE, }), ); + const loadError = await loadErrorOf(tab); + return loadError ? { ...snapshot, loadError } : snapshot; } case "click": { const clickInput = input as PreviewAutomationClickInput; ``` ## packages/contracts/src/desktopBrowser.ts Status: modified; +11; −0 ```diff @@ -12,6 +12,17 @@ /** Its `` went away: closed, crashed, swapped, or devtools took the debugger. */ Schema.Struct({ type: Schema.Literal("detached"), ...TabKey }), Schema.Struct({ type: Schema.Literal("cdp"), ...TabKey, message: Schema.String }), + /** + * The tab's page failed to load. The desktop starts a tab's first load before + * the server connects, so the server cannot always observe the failure itself. + */ + Schema.Struct({ + type: Schema.Literal("loadFailed"), + ...TabKey, + url: Schema.String, + code: Schema.Int, + description: Schema.String, + }), ]); export type DesktopBrowserEvent = typeof DesktopBrowserEvent.Type; ``` ## packages/contracts/src/previewAutomation.ts Status: modified; +10; −0 ```diff @@ -82,6 +82,14 @@ }); export type PreviewAutomationProfile = typeof PreviewAutomationProfile.Type; +/** Why the tab shows the browser's error page instead of the page it tried to load. */ +export const PreviewAutomationLoadError = Schema.Struct({ + url: Schema.String, + code: Schema.Int, + description: Schema.String, +}); +export type PreviewAutomationLoadError = typeof PreviewAutomationLoadError.Type; + export const PreviewAutomationStatus = Schema.Struct({ available: Schema.Boolean, visible: Schema.Boolean, @@ -89,6 +97,7 @@ url: Schema.NullOr(Schema.String), title: Schema.NullOr(Schema.String), loading: Schema.Boolean, + loadError: Schema.optional(PreviewAutomationLoadError), control: Schema.optional( Schema.Struct({ owner: PreviewAutomationTabOwner, @@ -718,6 +727,7 @@ url: Schema.String, title: Schema.String, loading: Schema.Boolean, + loadError: Schema.optional(PreviewAutomationLoadError), visibleText: Schema.String, interactiveElements: Schema.Array(PreviewAutomationElement), accessibilityTree: Schema.Unknown, ```