Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
feat(desktop): add favicons to the Browser panel (#5644)
Chris Deeming710fd0eeb3b4
diff --git a/apps/desktop/src/preview/FaviconCapture.test.ts b/apps/desktop/src/preview/FaviconCapture.test.tsnew file mode 100644index 000000000..a18c839a7--- /dev/null+++ b/apps/desktop/src/preview/FaviconCapture.test.ts@@ -0,0 +1,999 @@+import { describe, expect, it, vi } from "vite-plus/test";++import {+ MAX_FAVICON_CANDIDATES,+ MAX_FAVICON_RESPONSE_BYTES,+ captureFavicon,+ selectFaviconCandidates,+} from "./FaviconCapture.ts";++const PNG = "data:image/png;base64,cG5n";+const SOURCE_PNG = Buffer.alloc(24);+Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]).copy(SOURCE_PNG);+SOURCE_PNG.writeUInt32BE(1, 16);+SOURCE_PNG.writeUInt32BE(1, 20);+const SOURCE_PNG_URL = `data:image/png;base64,${SOURCE_PNG.toString("base64")}`;++function sourceGif(+ width: number,+ height: number,+ frameWidth = width,+ frameHeight = height,+ additionalFrames: ReadonlyArray<{+ readonly left?: number;+ readonly top?: number;+ readonly width: number;+ readonly height: number;+ }> = [],+): Buffer {+ const frames = [{ width: frameWidth, height: frameHeight }, ...additionalFrames];+ const buffer = Buffer.alloc(13 + frames.length * 12 + 1);+ buffer.write("GIF89a", 0, "ascii");+ buffer.writeUInt16LE(width, 6);+ buffer.writeUInt16LE(height, 8);+ let offset = 13;+ for (const frame of frames) {+ buffer[offset] = 0x2c;+ buffer.writeUInt16LE(frame.left ?? 0, offset + 1);+ buffer.writeUInt16LE(frame.top ?? 0, offset + 3);+ buffer.writeUInt16LE(frame.width, offset + 5);+ buffer.writeUInt16LE(frame.height, offset + 7);+ offset += 10;+ buffer[offset] = 2;+ buffer[offset + 1] = 0;+ offset += 2;+ }+ buffer[offset] = 0x3b;+ return buffer;+}++function sourceJpeg(+ width: number,+ height: number,+ orientations: number | ReadonlyArray<number> = [],+): Buffer {+ const frame = Buffer.from([+ 0xff,+ 0xd8,+ 0xff,+ 0xc0,+ 0x00,+ 0x07,+ 0x08,+ height >>> 8,+ height & 0xff,+ width >>> 8,+ width & 0xff,+ ]);+ const app1Segments = (typeof orientations === "number" ? [orientations] : orientations).map(+ (orientation) => sourceJpegExifSegment([orientation]),+ );+ return Buffer.concat([frame.subarray(0, 2), ...app1Segments, frame.subarray(2)]);+}++function sourceJpegApp1Segment(payload: Buffer): Buffer {+ const app1 = Buffer.alloc(4 + payload.byteLength);+ app1[0] = 0xff;+ app1[1] = 0xe1;+ app1.writeUInt16BE(payload.byteLength + 2, 2);+ payload.copy(app1, 4);+ return app1;+}++function sourceJpegExifSegment(+ orientations: ReadonlyArray<number>,+ options?: {+ readonly byteOrder?: "II" | "MM";+ readonly magic?: number;+ readonly padding?: number;+ },+): Buffer {+ const exif = Buffer.alloc(20 + orientations.length * 12);+ exif.write("Exif\0\0", 0, "binary");+ exif[5] = options?.padding ?? 0;+ const littleEndian = options?.byteOrder !== "MM";+ exif.write(littleEndian ? "II" : "MM", 6, "ascii");+ const writeUInt16 = (value: number, offset: number) =>+ littleEndian ? exif.writeUInt16LE(value, offset) : exif.writeUInt16BE(value, offset);+ const writeUInt32 = (value: number, offset: number) =>+ littleEndian ? exif.writeUInt32LE(value, offset) : exif.writeUInt32BE(value, offset);+ writeUInt16(options?.magic ?? 42, 8);+ writeUInt32(8, 10);+ writeUInt16(orientations.length, 14);+ orientations.forEach((orientation, index) => {+ const entryOffset = 16 + index * 12;+ writeUInt16(0x0112, entryOffset);+ writeUInt16(3, entryOffset + 2);+ writeUInt32(1, entryOffset + 4);+ writeUInt16(orientation, entryOffset + 8);+ });+ return sourceJpegApp1Segment(exif);+}++function sourceJpegWithApp1Segments(+ width: number,+ height: number,+ segments: ReadonlyArray<Buffer>,+): Buffer {+ const frame = sourceJpeg(width, height);+ return Buffer.concat([frame.subarray(0, 2), ...segments, frame.subarray(2)]);+}++function sourceJpegWithOrientationEntries(+ width: number,+ height: number,+ orientations: ReadonlyArray<number>,+): Buffer {+ return sourceJpegWithApp1Segments(width, height, [sourceJpegExifSegment(orientations)]);+}++function sourceJpegWithEndianAlias(alias: number, byteOrder: "II" | "MM"): Buffer {+ const exif = sourceJpegExifSegment([6], { byteOrder });+ exif[10] = alias;+ exif[11] = alias;+ return sourceJpegWithApp1Segments(64, 32, [exif]);+}++function sourceJpegExifWithSubIfd(options: {+ readonly rootOrientation?: number;+ readonly subIfdFirst?: boolean;+ readonly subIfdOrientation: number;+}): Buffer {+ const rootEntries = options.rootOrientation === undefined ? 1 : 2;+ const rootIfdOffset = 14;+ const subIfdOffset = rootIfdOffset + 2 + rootEntries * 12 + 4;+ const exif = Buffer.alloc(subIfdOffset + 2 + 12 + 4);+ exif.write("Exif\0\0", 0, "binary");+ exif.write("II", 6, "ascii");+ exif.writeUInt16LE(42, 8);+ exif.writeUInt32LE(8, 10);+ exif.writeUInt16LE(rootEntries, rootIfdOffset);++ const writeOrientation = (offset: number, orientation: number) => {+ exif.writeUInt16LE(0x0112, offset);+ exif.writeUInt16LE(3, offset + 2);+ exif.writeUInt32LE(1, offset + 4);+ exif.writeUInt16LE(orientation, offset + 8);+ };+ const writeSubIfdPointer = (offset: number) => {+ exif.writeUInt16LE(0x8769, offset);+ exif.writeUInt16LE(4, offset + 2);+ exif.writeUInt32LE(1, offset + 4);+ exif.writeUInt32LE(subIfdOffset - 6, offset + 8);+ };++ const firstRootEntryOffset = rootIfdOffset + 2;+ if (options.rootOrientation === undefined) {+ writeSubIfdPointer(firstRootEntryOffset);+ } else if (options.subIfdFirst) {+ writeSubIfdPointer(firstRootEntryOffset);+ writeOrientation(firstRootEntryOffset + 12, options.rootOrientation);+ } else {+ writeOrientation(firstRootEntryOffset, options.rootOrientation);+ writeSubIfdPointer(firstRootEntryOffset + 12);+ }++ exif.writeUInt16LE(1, subIfdOffset);+ writeOrientation(subIfdOffset + 2, options.subIfdOrientation);+ return sourceJpegApp1Segment(exif);+}++function sourceJpegExifWithSubIfdPointers(options: {+ readonly pointerCount: number;+ readonly subIfdEntries: number;+}): Buffer {+ const { pointerCount, subIfdEntries } = options;+ const rootIfdOffset = 14;+ const rootEntries = pointerCount + 1;+ const subIfdOffset = rootIfdOffset + 2 + rootEntries * 12 + 4;+ const exif = Buffer.alloc(subIfdOffset + 2 + subIfdEntries * 12 + 4);+ exif.write("Exif\0\0", 0, "binary");+ exif.write("II", 6, "ascii");+ exif.writeUInt16LE(42, 8);+ exif.writeUInt32LE(8, 10);+ exif.writeUInt16LE(rootEntries, rootIfdOffset);+ for (let index = 0; index < pointerCount; index += 1) {+ const entryOffset = rootIfdOffset + 2 + index * 12;+ exif.writeUInt16LE(0x8769, entryOffset);+ exif.writeUInt16LE(4, entryOffset + 2);+ exif.writeUInt32LE(1, entryOffset + 4);+ exif.writeUInt32LE(subIfdOffset - 6, entryOffset + 8);+ }+ const orientationOffset = rootIfdOffset + 2 + pointerCount * 12;+ exif.writeUInt16LE(0x0112, orientationOffset);+ exif.writeUInt16LE(3, orientationOffset + 2);+ exif.writeUInt32LE(1, orientationOffset + 4);+ exif.writeUInt16LE(6, orientationOffset + 8);++ exif.writeUInt16LE(subIfdEntries, subIfdOffset);+ for (let index = 0; index < subIfdEntries; index += 1) {+ const entryOffset = subIfdOffset + 2 + index * 12;+ exif.writeUInt16LE(1, entryOffset);+ exif.writeUInt16LE(3, entryOffset + 2);+ exif.writeUInt32LE(1, entryOffset + 4);+ }+ return sourceJpegApp1Segment(exif);+}++function sourceJpegExifWithOverlappingSubIfds(pointerCount: number, subIfdEntries: number): Buffer {+ const rootIfdOffset = 14;+ const rootEntries = pointerCount + 1;+ const subIfdOffset = rootIfdOffset + 2 + rootEntries * 12 + 4;+ const exif = Buffer.alloc(subIfdOffset + pointerCount * 2 + 2 + subIfdEntries * 12);+ exif.write("Exif\0\0", 0, "binary");+ exif.write("II", 6, "ascii");+ exif.writeUInt32LE(8, 10);+ exif.writeUInt16LE(rootEntries, rootIfdOffset);+ for (let index = 0; index < pointerCount; index += 1) {+ const entryOffset = rootIfdOffset + 2 + index * 12;+ exif.writeUInt16LE(0x8769, entryOffset);+ exif.writeUInt16LE(4, entryOffset + 2);+ exif.writeUInt32LE(1, entryOffset + 4);+ exif.writeUInt32LE(subIfdOffset + index * 2 - 6, entryOffset + 8);+ exif.writeUInt16LE(subIfdEntries, subIfdOffset + index * 2);+ }+ const orientationOffset = rootIfdOffset + 2 + pointerCount * 12;+ exif.writeUInt16LE(0x0112, orientationOffset);+ exif.writeUInt16LE(3, orientationOffset + 2);+ exif.writeUInt32LE(1, orientationOffset + 4);+ exif.writeUInt16LE(6, orientationOffset + 8);+ return sourceJpegApp1Segment(exif);+}++function sourceWebp(width: number, height: number): Buffer {+ const buffer = Buffer.alloc(30);+ buffer.write("RIFF", 0, "ascii");+ buffer.write("WEBP", 8, "ascii");+ buffer.write("VP8X", 12, "ascii");+ buffer.writeUIntLE(width - 1, 24, 3);+ buffer.writeUIntLE(height - 1, 27, 3);+ return buffer;+}++function sourceIco(embedded: Buffer): Buffer {+ const buffer = Buffer.alloc(22 + embedded.byteLength);+ buffer.writeUInt16LE(1, 2);+ buffer.writeUInt16LE(1, 4);+ buffer.writeUInt32LE(embedded.byteLength, 14);+ buffer.writeUInt32LE(22, 18);+ embedded.copy(buffer, 22);+ return buffer;+}++function makeUnsafePng(): Buffer {+ const buffer = Buffer.from(SOURCE_PNG);+ buffer.writeUInt32BE(4096, 16);+ buffer.writeUInt32BE(4096, 20);+ return buffer;+}++function sourcePng(width: number, height: number): Buffer {+ const buffer = Buffer.from(SOURCE_PNG);+ buffer.writeUInt32BE(width, 16);+ buffer.writeUInt32BE(height, 20);+ return buffer;+}++function makeUnsafeDib(): Buffer {+ const buffer = Buffer.alloc(40);+ buffer.writeUInt32LE(40, 0);+ buffer.writeInt32LE(4096, 4);+ buffer.writeInt32LE(4096, 8);+ return buffer;+}++function makeWebContents(options?: {+ readonly fetch?: (url: string, init?: RequestInit) => Promise<Response>;+ readonly rasterize?: (code: string) => Promise<unknown>;+}) {+ const fetch = vi.fn(+ options?.fetch ??+ (async () =>+ new Response(new Uint8Array(SOURCE_PNG), {+ headers: { "content-type": "image/png" },+ })),+ );+ const executeJavaScriptInIsolatedWorld = vi.fn(+ async (_worldId: number, scripts: ReadonlyArray<{ readonly code: string }>) =>+ options?.rasterize ? options.rasterize(scripts[0]?.code ?? "") : PNG,+ );+ return {+ webContents: {+ session: { fetch },+ executeJavaScriptInIsolatedWorld,+ } as never,+ executeJavaScriptInIsolatedWorld,+ fetch,+ };+}++const JPEG_LANDSCAPE_LAYOUT = {+ draw: "context.drawImage(bitmap, 0, 8, 32, 16)",+ resizeHeight: 16,+ resizeWidth: 32,+} as const;+const JPEG_PORTRAIT_LAYOUT = {+ draw: "context.drawImage(bitmap, 8, 0, 16, 32)",+ resizeHeight: 32,+ resizeWidth: 16,+} as const;++async function expectJpegLayout(+ source: Buffer,+ layout: typeof JPEG_LANDSCAPE_LAYOUT | typeof JPEG_PORTRAIT_LAYOUT,+): Promise<void> {+ const { webContents } = makeWebContents({+ rasterize: async (code) => {+ expect(code).toContain(`resizeWidth: ${layout.resizeWidth}`);+ expect(code).toContain(`resizeHeight: ${layout.resizeHeight}`);+ expect(code).toContain(layout.draw);+ return PNG;+ },+ });++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [`data:image/jpeg;base64,${source.toString("base64")}`],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "captured", dataUrl: PNG });+}++describe("selectFaviconCandidates", () => {+ it("filters and deduplicates before applying the candidate cap", () => {+ const valid = Array.from(+ { length: MAX_FAVICON_CANDIDATES + 2 },+ (_, index) => `https://example.com/favicon-${index}.png`,+ );+ expect(+ selectFaviconCandidates([+ ...Array.from({ length: 64 }, () => "javascript:alert(1)"),+ valid[0]!,+ valid[0]!,+ ...valid.slice(1),+ ]),+ ).toEqual(valid.slice(0, MAX_FAVICON_CANDIDATES));+ });++ it("bounds raw candidate scanning independently of the usable-candidate cap", () => {+ const oversizedInvalid = `javascript:${"x".repeat(2_048)}`;+ expect(+ selectFaviconCandidates([+ ...Array.from({ length: 128 }, () => oversizedInvalid),+ "https://example.com/too-late.png",+ ]),+ ).toEqual([]);+ });+});++describe("captureFavicon", () => {+ it.each([+ {+ label: "same-origin",+ pageUrl: "https://example.com/page",+ faviconUrl: "https://example.com/favicon.png",+ credentials: "include",+ },+ {+ label: "cross-origin",+ pageUrl: "https://example.com/page",+ faviconUrl: "https://cdn.example.net/favicon.png",+ credentials: "omit",+ },+ ])("uses the explicit credential policy for $label requests", async (testCase) => {+ const { webContents, fetch } = makeWebContents();+ const result = await captureFavicon({+ webContents,+ pageUrl: testCase.pageUrl,+ candidates: [testCase.faviconUrl],+ signal: new AbortController().signal,+ });++ expect(result).toEqual({ kind: "captured", dataUrl: PNG });+ expect(fetch).toHaveBeenCalledWith(+ testCase.faviconUrl,+ expect.objectContaining({ credentials: testCase.credentials, redirect: "error" }),+ );+ });++ it("decodes base64 and percent-encoded inline images without fetching", async () => {+ const { webContents, fetch, executeJavaScriptInIsolatedWorld } = makeWebContents();+ const percentEncodedPng = [...SOURCE_PNG]+ .map((byte) => `%${byte.toString(16).padStart(2, "0")}`)+ .join("");++ for (const candidate of [SOURCE_PNG_URL, `data:image/png,${percentEncodedPng}`]) {+ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [candidate],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "captured", dataUrl: PNG });+ }++ expect(fetch).not.toHaveBeenCalled();+ expect(executeJavaScriptInIsolatedWorld).toHaveBeenCalledTimes(2);+ });++ it("tries the next candidate after an ordinary rejection", async () => {+ const { webContents, fetch } = makeWebContents({+ fetch: async (url) =>+ url.endsWith("first.png")+ ? new Response(null, { status: 404 })+ : new Response(new Uint8Array(SOURCE_PNG), {+ headers: { "content-type": "image/png" },+ }),+ });++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: ["https://example.com/first.png", "https://example.com/second.png"],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "captured", dataUrl: PNG });+ expect(fetch).toHaveBeenCalledTimes(2);+ });++ it("cancels a rejected response body before trying the next candidate", async () => {+ const cancel = vi.fn();+ const body = new ReadableStream<Uint8Array>({+ start(controller) {+ controller.enqueue(new Uint8Array(1));+ },+ cancel,+ });+ const { webContents, fetch } = makeWebContents({+ fetch: async (url) =>+ url.endsWith("first.png")+ ? new Response(body, { status: 404 })+ : new Response(new Uint8Array(SOURCE_PNG), {+ headers: { "content-type": "image/png" },+ }),+ });++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: ["https://example.com/first.png", "https://example.com/second.png"],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "captured", dataUrl: PNG });+ expect(cancel).toHaveBeenCalledOnce();+ expect(fetch).toHaveBeenCalledTimes(2);+ });++ it("stops a pending fetch when its capture is aborted", async () => {+ const controller = new AbortController();+ const { webContents } = makeWebContents({+ fetch: (_url, init) =>+ new Promise<Response>((_resolve, reject) => {+ init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), {+ once: true,+ });+ }),+ });+ const capture = captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: ["https://example.com/favicon.png"],+ signal: controller.signal,+ });+ controller.abort();+ expect(await capture).toEqual({ kind: "none" });+ });++ it("ends candidate fallback when the overall capture deadline expires", async () => {+ const timeoutController = new AbortController();+ const timeout = vi.spyOn(AbortSignal, "timeout").mockReturnValue(timeoutController.signal);+ const { webContents, fetch } = makeWebContents({+ fetch: (url, init) => {+ if (url.endsWith("first.png")) return Promise.resolve(new Response(null, { status: 404 }));+ return new Promise<Response>((_resolve, reject) => {+ init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), {+ once: true,+ });+ });+ },+ });+ try {+ const capture = captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [+ "https://example.com/first.png",+ "https://example.com/second.png",+ "https://example.com/third.png",+ ],+ signal: new AbortController().signal,+ });+ await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(2));+ timeoutController.abort(new DOMException("capture timed out", "TimeoutError"));++ expect(await capture).toEqual({ kind: "timed-out" });+ expect(fetch).toHaveBeenCalledTimes(2);+ expect(timeout).toHaveBeenCalledOnce();+ } finally {+ timeout.mockRestore();+ }+ });++ it("does not publish a rasterization that completes after the capture deadline", async () => {+ const captureTimeoutController = new AbortController();+ const rasterTimeoutController = new AbortController();+ const timeout = vi+ .spyOn(AbortSignal, "timeout")+ .mockImplementation((milliseconds) =>+ milliseconds === 5_000 ? captureTimeoutController.signal : rasterTimeoutController.signal,+ );+ let resolveRasterization!: (value: unknown) => void;+ const { webContents, executeJavaScriptInIsolatedWorld } = makeWebContents({+ rasterize: () =>+ new Promise((resolve) => {+ resolveRasterization = resolve;+ }),+ });+ try {+ const capture = captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [SOURCE_PNG_URL],+ signal: new AbortController().signal,+ });+ await vi.waitFor(() => expect(executeJavaScriptInIsolatedWorld).toHaveBeenCalledOnce());+ captureTimeoutController.abort(new DOMException("capture timed out", "TimeoutError"));++ expect(await capture).toEqual({ kind: "timed-out" });+ resolveRasterization(PNG);+ } finally {+ timeout.mockRestore();+ }+ });++ it("cancels a stalled response body when the capture deadline expires", async () => {+ const timeoutController = new AbortController();+ const timeout = vi.spyOn(AbortSignal, "timeout").mockReturnValue(timeoutController.signal);+ const cancel = vi.fn();+ const { webContents } = makeWebContents({+ fetch: async () =>+ new Response(+ new ReadableStream<Uint8Array>({+ cancel,+ }),+ { headers: { "content-type": "image/png" } },+ ),+ });+ try {+ const capture = captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: ["https://example.com/favicon.png"],+ signal: new AbortController().signal,+ });+ timeoutController.abort(new DOMException("capture timed out", "TimeoutError"));++ expect(await capture).toEqual({ kind: "timed-out" });+ expect(cancel).toHaveBeenCalledOnce();+ } finally {+ timeout.mockRestore();+ }+ });++ it("rejects and cancels an oversized streamed response", async () => {+ const cancel = vi.fn();+ const body = new ReadableStream<Uint8Array>({+ start(controller) {+ controller.enqueue(new Uint8Array(MAX_FAVICON_RESPONSE_BYTES));+ controller.enqueue(new Uint8Array(1));+ },+ cancel,+ });+ const { webContents, executeJavaScriptInIsolatedWorld } = makeWebContents({+ fetch: async () => new Response(body, { headers: { "content-type": "image/png" } }),+ });++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: ["https://example.com/favicon.png"],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "none" });+ expect(cancel).toHaveBeenCalledOnce();+ expect(executeJavaScriptInIsolatedWorld).not.toHaveBeenCalled();+ });++ it("retains bounded compatibility with common favicon formats", async () => {+ const { webContents, executeJavaScriptInIsolatedWorld } = makeWebContents();+ for (const [mime, buffer] of [+ ["image/gif", sourceGif(32, 32)],+ ["image/jpeg", sourceJpeg(32, 32)],+ ["image/webp", sourceWebp(32, 32)],+ ["image/x-icon", sourceIco(SOURCE_PNG)],+ ] as const) {+ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [`data:${mime};base64,${buffer.toString("base64")}`],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "captured", dataUrl: PNG });+ }+ expect(executeJavaScriptInIsolatedWorld).toHaveBeenCalledTimes(4);+ });++ it.each([+ {+ label: "landscape",+ source: sourcePng(64, 32),+ resizeWidth: 32,+ resizeHeight: 16,+ draw: "context.drawImage(bitmap, 0, 8, 32, 16)",+ },+ {+ label: "portrait",+ source: sourcePng(32, 64),+ resizeWidth: 16,+ resizeHeight: 32,+ draw: "context.drawImage(bitmap, 8, 0, 16, 32)",+ },+ ])("preserves $label aspect ratio within the 32x32 output", async (testCase) => {+ const { webContents } = makeWebContents({+ rasterize: async (code) => {+ expect(code).toContain(`resizeWidth: ${testCase.resizeWidth}`);+ expect(code).toContain(`resizeHeight: ${testCase.resizeHeight}`);+ expect(code).toContain('resizeQuality: "high"');+ expect(code).toContain(testCase.draw);+ return PNG;+ },+ });++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [`data:image/png;base64,${testCase.source.toString("base64")}`],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "captured", dataUrl: PNG });+ });++ it.each([+ ...[1, 2, 3, 4].map((orientation) => ({+ label: `keeps stored dimensions for orientation ${orientation}`,+ layout: JPEG_LANDSCAPE_LAYOUT,+ source: sourceJpeg(64, 32, orientation),+ })),+ ...[5, 6, 7, 8].map((orientation) => ({+ label: `uses display dimensions for orientation ${orientation}`,+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpeg(64, 32, orientation),+ })),+ {+ label: "uses the first separate EXIF segment when it is transposed",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpeg(64, 32, [6, 1]),+ },+ {+ label: "uses the first separate EXIF segment when it is untransposed",+ layout: JPEG_LANDSCAPE_LAYOUT,+ source: sourceJpeg(64, 32, [1, 6]),+ },+ {+ label: "does not consult a later EXIF segment after an invalid orientation",+ layout: JPEG_LANDSCAPE_LAYOUT,+ source: sourceJpeg(64, 32, [9, 6]),+ },+ {+ label: "uses a later valid orientation in the same IFD",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithOrientationEntries(64, 32, [9, 6]),+ },+ {+ label: "skips a non-EXIF APP1 segment",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [+ sourceJpegApp1Segment(Buffer.from("not-exif")),+ sourceJpegExifSegment([6]),+ ]),+ },+ {+ label: "skips an empty EXIF APP1 segment",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [+ sourceJpegApp1Segment(Buffer.from("Exif\0\0", "binary")),+ sourceJpegExifSegment([6]),+ ]),+ },+ {+ label: "stops after a malformed qualifying EXIF APP1 segment",+ layout: JPEG_LANDSCAPE_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [+ sourceJpegApp1Segment(Buffer.from("Exif\0\0broken", "binary")),+ sourceJpegExifSegment([6]),+ ]),+ },+ {+ label: "ignores the EXIF padding byte",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [sourceJpegExifSegment([6], { padding: 0xff })]),+ },+ {+ label: "reads big-endian EXIF",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [sourceJpegExifSegment([6], { byteOrder: "MM" })]),+ },+ {+ label: "matches Chromium for a nonstandard TIFF magic field",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [sourceJpegExifSegment([6], { magic: 0 })]),+ },+ {+ label: "rejects a high-bit little-endian alias",+ layout: JPEG_LANDSCAPE_LAYOUT,+ source: sourceJpegWithEndianAlias(0xc9, "II"),+ },+ {+ label: "rejects a high-bit big-endian alias",+ layout: JPEG_LANDSCAPE_LAYOUT,+ source: sourceJpegWithEndianAlias(0xcd, "MM"),+ },+ {+ label: "reads an orientation from a SubIFD",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [+ sourceJpegExifWithSubIfd({ subIfdOrientation: 6 }),+ ]),+ },+ {+ label: "uses a SubIFD orientation before a later root orientation",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [+ sourceJpegExifWithSubIfd({+ rootOrientation: 1,+ subIfdFirst: true,+ subIfdOrientation: 6,+ }),+ ]),+ },+ {+ label: "uses a root orientation before a later SubIFD orientation",+ layout: JPEG_LANDSCAPE_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [+ sourceJpegExifWithSubIfd({ rootOrientation: 1, subIfdOrientation: 6 }),+ ]),+ },+ {+ label: "memoizes repeated aliases to the same SubIFD",+ layout: JPEG_PORTRAIT_LAYOUT,+ source: sourceJpegWithApp1Segments(64, 32, [+ sourceJpegExifWithSubIfdPointers({ pointerCount: 32, subIfdEntries: 32 }),+ ]),+ },+ ])("matches Chromium JPEG layout: $label", async ({ source, layout }) => {+ await expectJpegLayout(source, layout);+ });++ it("rejects JPEG metadata when distinct SubIFDs exhaust the linear work budget", async () => {+ const source = sourceJpegWithApp1Segments(64, 32, [+ sourceJpegExifWithOverlappingSubIfds(32, 32),+ ]);+ const { webContents, executeJavaScriptInIsolatedWorld } = makeWebContents();++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [`data:image/jpeg;base64,${source.toString("base64")}`],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "none" });+ expect(executeJavaScriptInIsolatedWorld).not.toHaveBeenCalled();+ });++ it("rejects JPEGs with multiple frame headers before rasterization", async () => {+ const buffer = Buffer.concat([sourceJpeg(4096, 4096), sourceJpeg(1, 1).subarray(2)]);+ const { webContents, executeJavaScriptInIsolatedWorld } = makeWebContents();++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [`data:image/jpeg;base64,${buffer.toString("base64")}`],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "none" });+ expect(executeJavaScriptInIsolatedWorld).not.toHaveBeenCalled();+ });++ it("rejects an unsafe PNG size before rasterization", async () => {+ const buffer = makeUnsafePng();+ const { webContents, executeJavaScriptInIsolatedWorld } = makeWebContents({+ fetch: async () =>+ new Response(new Uint8Array(buffer), {+ headers: { "content-type": "image/png" },+ }),+ });++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: ["https://example.com/favicon.png"],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "none" });+ expect(executeJavaScriptInIsolatedWorld).not.toHaveBeenCalled();+ });++ it.each([+ ["GIF", "image/gif", sourceGif(4096, 4096)],+ ["GIF frame", "image/gif", sourceGif(1, 1, 4096, 4096)],+ ["GIF later frame", "image/gif", sourceGif(1, 1, 1, 1, [{ width: 4096, height: 4096 }])],+ [+ "GIF cumulative frames",+ "image/gif",+ sourceGif(+ 64,+ 64,+ 64,+ 64,+ Array.from({ length: 256 }, () => ({ width: 64, height: 64 })),+ ),+ ],+ ["JPEG", "image/jpeg", sourceJpeg(4096, 4096)],+ ["WebP", "image/webp", sourceWebp(4096, 4096)],+ ["ICO with PNG", "image/x-icon", sourceIco(makeUnsafePng())],+ ["ICO with DIB", "image/x-icon", sourceIco(makeUnsafeDib())],+ ["SVG", "image/svg+xml", Buffer.from('<svg width="1" height="1"/>')],+ [+ "SVG with embedded bitmap",+ "image/svg+xml",+ Buffer.from(+ `<svg width="1" height="1"><image href="data:image/png;base64,${makeUnsafePng().toString("base64")}"/></svg>`,+ ),+ ],+ [+ "ICO invalid payload span",+ "image/x-icon",+ (() => {+ const buffer = Buffer.alloc(22);+ buffer.writeUInt16LE(1, 2);+ buffer.writeUInt16LE(1, 4);+ buffer.writeUInt32LE(100, 14);+ buffer.writeUInt32LE(22, 18);+ return buffer;+ })(),+ ],+ ])("rejects unsafe or unsupported %s before rasterization", async (_label, mime, buffer) => {+ const { webContents, executeJavaScriptInIsolatedWorld } = makeWebContents();+ const candidate = `data:${mime};base64,${buffer.toString("base64")}`;+ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [candidate],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "none" });+ expect(executeJavaScriptInIsolatedWorld).not.toHaveBeenCalled();+ });++ it("ignores output that is not a bounded PNG data URL", async () => {+ const { webContents } = makeWebContents({+ rasterize: async () => "data:image/svg+xml;base64,c3Zn",+ });++ expect(+ await captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [SOURCE_PNG_URL],+ signal: new AbortController().signal,+ }),+ ).toEqual({ kind: "none" });+ });++ it("waits for physical rasterization settlement after a logical timeout", async () => {+ vi.useFakeTimers();+ try {+ let resolveOld!: (value: unknown) => void;+ let executions = 0;+ const { webContents } = makeWebContents({+ rasterize: () => {+ executions += 1;+ return executions === 1+ ? new Promise((resolve) => {+ resolveOld = resolve;+ })+ : Promise.resolve(PNG);+ },+ });+ const input = {+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [SOURCE_PNG_URL],+ signal: new AbortController().signal,+ };+ const timedOut = captureFavicon(input);+ await vi.advanceTimersByTimeAsync(1_001);+ expect(await timedOut).toEqual({ kind: "timed-out" });++ const newer = captureFavicon(input);+ await Promise.resolve();+ expect(executions).toBe(1);+ resolveOld(PNG);+ expect(await newer).toEqual({ kind: "captured", dataUrl: PNG });+ expect(executions).toBe(2);+ } finally {+ vi.useRealTimers();+ }+ });++ it("ends candidate fallback after a rasterization timeout", async () => {+ vi.useFakeTimers();+ try {+ let resolveRasterization!: (value: unknown) => void;+ const { webContents, fetch, executeJavaScriptInIsolatedWorld } = makeWebContents({+ rasterize: () =>+ new Promise((resolve) => {+ resolveRasterization = resolve;+ }),+ });+ const capture = captureFavicon({+ webContents,+ pageUrl: "https://example.com/page",+ candidates: ["https://example.com/first.png", "https://example.com/second.png"],+ signal: new AbortController().signal,+ });++ await vi.advanceTimersByTimeAsync(1_001);++ expect(await capture).toEqual({ kind: "timed-out" });+ expect(fetch).toHaveBeenCalledOnce();+ expect(executeJavaScriptInIsolatedWorld).toHaveBeenCalledOnce();+ resolveRasterization(PNG);+ } finally {+ vi.useRealTimers();+ }+ });++ it("coalesces queued rasterizations so only the latest pending capture launches", async () => {+ let resolveFirst!: (value: unknown) => void;+ let executions = 0;+ const { webContents } = makeWebContents({+ rasterize: () => {+ executions += 1;+ return executions === 1+ ? new Promise((resolve) => {+ resolveFirst = resolve;+ })+ : Promise.resolve(PNG);+ },+ });+ const input = {+ webContents,+ pageUrl: "https://example.com/page",+ candidates: [SOURCE_PNG_URL],+ signal: new AbortController().signal,+ };+ const first = captureFavicon(input);+ const superseded = captureFavicon(input);+ const newest = captureFavicon(input);++ expect(executions).toBe(1);+ resolveFirst(PNG);+ expect(await first).toEqual({ kind: "captured", dataUrl: PNG });+ expect(await superseded).toEqual({ kind: "none" });+ expect(await newest).toEqual({ kind: "captured", dataUrl: PNG });+ expect(executions).toBe(2);+ });+});diff --git a/apps/desktop/src/preview/FaviconCapture.ts b/apps/desktop/src/preview/FaviconCapture.tsnew file mode 100644index 000000000..c72662822--- /dev/null+++ b/apps/desktop/src/preview/FaviconCapture.ts@@ -0,0 +1,679 @@+import { FAVICON_DATA_URL_MAX_LENGTH } from "@t3tools/contracts";++export const MAX_FAVICON_RESPONSE_BYTES = 100_000;+export const MAX_FAVICON_CANDIDATES = 8;+export const MAX_FAVICON_HTTP_URL_LENGTH = 2_048;++const MAX_FAVICON_CANDIDATE_INPUT_UNITS = 262_144;+const MIN_FAVICON_CANDIDATE_INPUT_UNITS = 256;+const MAX_FAVICON_SOURCE_PIXELS = 1_048_576;+const MAX_FAVICON_INLINE_URL_LENGTH = Math.ceil((MAX_FAVICON_RESPONSE_BYTES * 4) / 3) + 128;+const FAVICON_CAPTURE_TIMEOUT_MS = 5_000;+const FAVICON_RASTER_WORLD_ID = 1001;+const FAVICON_RASTER_TIMEOUT_MS = 1_000;+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);++interface RasterizationGate {+ generation: number;+ launchAllowed?: Promise<void>;+}++const rasterizationGates = new WeakMap<Electron.WebContents, RasterizationGate>();++async function waitForRasterLaunch(previous: Promise<void>, signal: AbortSignal): Promise<void> {+ if (signal.aborted) return;+ await new Promise<void>((resolve) => {+ const finish = () => {+ signal.removeEventListener("abort", finish);+ resolve();+ };+ signal.addEventListener("abort", finish, { once: true });+ void previous.then(finish);+ });+}++export type FaviconCaptureResult =+ | { readonly kind: "captured"; readonly dataUrl: string }+ | { readonly kind: "none" }+ | { readonly kind: "timed-out" };++type RasterizationResult =+ | { readonly kind: "completed"; readonly value: unknown }+ | { readonly kind: "timed-out" };++export function safeHttpOrigin(url: string): string | null {+ try {+ const parsed = new URL(url);+ return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.origin : null;+ } catch {+ return null;+ }+}++export function selectFaviconCandidates(candidates: ReadonlyArray<string>): ReadonlyArray<string> {+ const selected: string[] = [];+ const seen = new Set<string>();+ let inputUnits = 0;+ for (const candidate of candidates) {+ // Charge a minimum per entry so a large array of tiny malformed values is bounded too.+ inputUnits += Math.max(MIN_FAVICON_CANDIDATE_INPUT_UNITS, candidate.length);+ if (inputUnits > MAX_FAVICON_CANDIDATE_INPUT_UNITS) break;+ if (!isSupportedFaviconUrl(candidate) || seen.has(candidate)) continue;+ seen.add(candidate);+ selected.push(candidate);+ if (selected.length === MAX_FAVICON_CANDIDATES) break;+ }+ return selected;+}++export async function captureFavicon(input: {+ readonly webContents: Electron.WebContents;+ readonly pageUrl: string;+ readonly candidates: ReadonlyArray<string>;+ readonly signal: AbortSignal;+}): Promise<FaviconCaptureResult> {+ const pageOrigin = safeHttpOrigin(input.pageUrl);+ if (!pageOrigin) return { kind: "none" };+ const captureTimeout = AbortSignal.timeout(FAVICON_CAPTURE_TIMEOUT_MS);+ const captureSignal = AbortSignal.any([input.signal, captureTimeout]);++ for (const candidate of selectFaviconCandidates(input.candidates)) {+ if (captureSignal.aborted) {+ return input.signal.aborted ? { kind: "none" } : { kind: "timed-out" };+ }+ const captured = await captureCandidate({+ webContents: input.webContents,+ pageOrigin,+ candidate,+ signal: captureSignal,+ });+ if (captureSignal.aborted) {+ return input.signal.aborted ? { kind: "none" } : { kind: "timed-out" };+ }+ if (captured.kind === "captured" || captured.kind === "timed-out") return captured;+ }++ return { kind: "none" };+}++async function captureCandidate(input: {+ readonly webContents: Electron.WebContents;+ readonly pageOrigin: string;+ readonly candidate: string;+ readonly signal: AbortSignal;+}): Promise<FaviconCaptureResult> {+ try {+ const inline = parseInlineFavicon(input.candidate);+ if (inline) {+ return await normalizeFaviconBuffer(+ input.webContents,+ inline.mime,+ inline.buffer,+ input.signal,+ );+ }++ const candidateOrigin = safeHttpOrigin(input.candidate);+ if (!candidateOrigin) return { kind: "none" };+ const response = await input.webContents.session.fetch(input.candidate, {+ credentials: candidateOrigin === input.pageOrigin ? "include" : "omit",+ redirect: "error",+ signal: input.signal,+ });+ if (!response.ok) {+ await response.body?.cancel();+ return { kind: "none" };+ }+ const buffer = await readFaviconResponse(response, input.signal);+ if (!buffer || input.signal.aborted) return { kind: "none" };+ const mime = response.headers.get("content-type")?.split(";", 1)[0] ?? null;+ return await normalizeFaviconBuffer(input.webContents, mime, buffer, input.signal);+ } catch {+ return { kind: "none" };+ }+}++async function readFaviconResponse(+ response: Response,+ signal: AbortSignal,+): Promise<Buffer | null> {+ const contentLength = Number(response.headers.get("content-length"));+ if (Number.isFinite(contentLength) && contentLength > MAX_FAVICON_RESPONSE_BYTES) {+ await response.body?.cancel();+ return null;+ }+ if (!response.body) {+ const buffer = Buffer.from(await response.arrayBuffer());+ return buffer.byteLength <= MAX_FAVICON_RESPONSE_BYTES ? buffer : null;+ }++ const reader = response.body.getReader();+ const cancelForAbort = () => {+ void reader.cancel(signal.reason).catch(() => undefined);+ };+ signal.addEventListener("abort", cancelForAbort, { once: true });+ if (signal.aborted) cancelForAbort();+ const chunks: Buffer[] = [];+ let byteLength = 0;+ try {+ while (true) {+ const next = await reader.read();+ if (next.done) return Buffer.concat(chunks, byteLength);+ byteLength += next.value.byteLength;+ if (byteLength > MAX_FAVICON_RESPONSE_BYTES) {+ await reader.cancel();+ return null;+ }+ chunks.push(Buffer.from(next.value));+ }+ } finally {+ signal.removeEventListener("abort", cancelForAbort);+ reader.releaseLock();+ }+}++function isSupportedFaviconUrl(url: string): boolean {+ if (url.length > MAX_FAVICON_INLINE_URL_LENGTH) return false;+ if (/^data:/i.test(url)) return /^data:image\/[a-z0-9.+-]+(?:;[^,]*)?,/i.test(url);+ try {+ const protocol = new URL(url).protocol;+ return (+ (protocol === "http:" || protocol === "https:") && url.length <= MAX_FAVICON_HTTP_URL_LENGTH+ );+ } catch {+ return false;+ }+}++function decodeInlineFaviconPayload(payload: string): Buffer | null {+ const decoded = Buffer.allocUnsafe(Buffer.byteLength(payload));+ let inputOffset = 0;+ let outputOffset = 0;+ while (inputOffset < payload.length) {+ const escapeOffset = payload.indexOf("%", inputOffset);+ const literalEnd = escapeOffset === -1 ? payload.length : escapeOffset;+ outputOffset += decoded.write(payload.slice(inputOffset, literalEnd), outputOffset, "utf8");+ if (escapeOffset === -1) break;+ const hex = payload.slice(escapeOffset + 1, escapeOffset + 3);+ if (!/^[0-9a-f]{2}$/i.test(hex)) return null;+ decoded[outputOffset] = Number.parseInt(hex, 16);+ outputOffset += 1;+ inputOffset = escapeOffset + 3;+ }+ return decoded.subarray(0, outputOffset);+}++function parseInlineFavicon(+ url: string,+): { readonly buffer: Buffer; readonly mime: string } | null {+ if (url.length > MAX_FAVICON_INLINE_URL_LENGTH) return null;+ const match = /^data:(image\/[a-z0-9.+-]+)((?:;[^,]*)?),(.*)$/is.exec(url);+ if (!match) return null;+ const mime = match[1]?.toLowerCase();+ const parameters = match[2]+ ?.split(";")+ .filter(Boolean)+ .map((parameter) => parameter.toLowerCase());+ const payload = match[3];+ if (!mime || !parameters || !payload) return null;+ const base64 = parameters.at(-1) === "base64";+ if (parameters.includes("base64") && !base64) return null;++ let buffer: Buffer;+ try {+ if (base64) {+ if (!/^[a-z0-9+/]*={0,2}$/i.test(payload) || payload.length % 4 === 1) return null;+ buffer = Buffer.from(payload, "base64");+ if (buffer.toString("base64").replace(/=+$/, "") !== payload.replace(/=+$/, "")) {+ return null;+ }+ } else {+ const decoded = decodeInlineFaviconPayload(payload);+ if (!decoded) return null;+ buffer = decoded;+ }+ } catch {+ return null;+ }++ return buffer.byteLength > 0 && buffer.byteLength <= MAX_FAVICON_RESPONSE_BYTES+ ? { buffer, mime }+ : null;+}++interface ImageDimensions {+ readonly width: number;+ readonly height: number;+}++function safeDimensions(dimensions: ImageDimensions | null): dimensions is ImageDimensions {+ return (+ dimensions !== null &&+ Number.isSafeInteger(dimensions.width) &&+ Number.isSafeInteger(dimensions.height) &&+ dimensions.width > 0 &&+ dimensions.height > 0 &&+ dimensions.width * dimensions.height <= MAX_FAVICON_SOURCE_PIXELS+ );+}++function pngDimensions(buffer: Buffer): ImageDimensions | null {+ if (!buffer.subarray(0, PNG_SIGNATURE.length).equals(PNG_SIGNATURE) || buffer.byteLength < 24) {+ return null;+ }+ return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };+}++function skipGifSubBlocks(buffer: Buffer, startOffset: number): number | null {+ let offset = startOffset;+ while (offset < buffer.byteLength) {+ const blockLength = buffer[offset]!;+ offset += 1;+ if (blockLength === 0) return offset;+ if (offset + blockLength > buffer.byteLength) return null;+ offset += blockLength;+ }+ return null;+}++function gifDimensions(buffer: Buffer): ImageDimensions | null {+ if (buffer.byteLength < 13 || !/^GIF8[79]a$/u.test(buffer.subarray(0, 6).toString("ascii"))) {+ return null;+ }+ const logicalWidth = buffer.readUInt16LE(6);+ const logicalHeight = buffer.readUInt16LE(8);+ if (!safeDimensions({ width: logicalWidth, height: logicalHeight })) return null;+ const packed = buffer[10]!;+ let offset = 13 + ((packed & 0x80) === 0 ? 0 : 3 * 2 ** ((packed & 0x07) + 1));+ if (offset > buffer.byteLength) return null;+ let width = logicalWidth;+ let height = logicalHeight;+ let frameCount = 0;+ let framePixels = 0;+ while (offset < buffer.byteLength) {+ const marker = buffer[offset];+ if (marker === 0x3b) return frameCount > 0 ? { width, height } : null;+ if (marker === 0x2c) {+ if (offset + 10 > buffer.byteLength) return null;+ const left = buffer.readUInt16LE(offset + 1);+ const top = buffer.readUInt16LE(offset + 3);+ const frameWidth = buffer.readUInt16LE(offset + 5);+ const frameHeight = buffer.readUInt16LE(offset + 7);+ if (frameWidth === 0 || frameHeight === 0) return null;+ framePixels += frameWidth * frameHeight;+ if (framePixels > MAX_FAVICON_SOURCE_PIXELS) return null;+ width = Math.max(width, left + frameWidth);+ height = Math.max(height, top + frameHeight);+ if (!safeDimensions({ width, height })) return null;+ const framePacked = buffer[offset + 9]!;+ offset += 10;+ if ((framePacked & 0x80) !== 0) {+ offset += 3 * 2 ** ((framePacked & 0x07) + 1);+ }+ if (offset >= buffer.byteLength) return null;+ const minimumCodeSize = buffer[offset]!;+ if (minimumCodeSize < 2 || minimumCodeSize > 8) return null;+ offset += 1;+ const nextOffset = skipGifSubBlocks(buffer, offset);+ if (nextOffset === null) return null;+ offset = nextOffset;+ frameCount += 1;+ continue;+ }+ if (marker !== 0x21 || offset + 2 > buffer.byteLength) return null;+ const nextOffset = skipGifSubBlocks(buffer, offset + 2);+ if (nextOffset === null) return null;+ offset = nextOffset;+ }+ return null;+}++interface JpegExifMetadata {+ readonly complete: boolean;+ readonly orientation: number | null;+}++function jpegExifMetadata(segment: Buffer): JpegExifMetadata | null {+ if (segment.byteLength <= 6 || segment.subarray(0, 5).toString("binary") !== "Exif\0") {+ return null;+ }+ const metadataWithoutOrientation = (): JpegExifMetadata => ({+ complete: true,+ orientation: null,+ });+ if (segment.byteLength < 14) return metadataWithoutOrientation();+ const tiffOffset = 6;+ const littleEndian = segment[tiffOffset] === 0x49 && segment[tiffOffset + 1] === 0x49;+ const bigEndian = segment[tiffOffset] === 0x4d && segment[tiffOffset + 1] === 0x4d;+ if (!littleEndian && !bigEndian) return metadataWithoutOrientation();+ const readUInt16 = (offset: number): number | null => {+ if (offset < 0 || offset + 2 > segment.byteLength) return null;+ return littleEndian ? segment.readUInt16LE(offset) : segment.readUInt16BE(offset);+ };+ const readUInt32 = (offset: number): number | null => {+ if (offset < 0 || offset + 4 > segment.byteLength) return null;+ return littleEndian ? segment.readUInt32LE(offset) : segment.readUInt32BE(offset);+ };+ const relativeIfdOffset = readUInt32(tiffOffset + 4);+ if (relativeIfdOffset === null) return metadataWithoutOrientation();+ // Keep untrusted metadata parsing linear even when IFD pointers overlap.+ let remainingIfdEntryVisits = Math.ceil(segment.byteLength / 12);+ const budgetExhausted = Symbol("ifd-entry-budget-exhausted");+ type IfdOrientation = number | null | typeof budgetExhausted;+ const subIfdOrientationByOffset = new Map<number, number | null>();+ const readIfdOrientation = (ifdOffset: number, isRoot: boolean): IfdOrientation => {+ if (!isRoot && subIfdOrientationByOffset.has(ifdOffset)) {+ return subIfdOrientationByOffset.get(ifdOffset) ?? null;+ }+ const entryCount = readUInt16(ifdOffset);+ if (entryCount === null) return null;+ let result: IfdOrientation = null;+ for (let index = 0; index < entryCount; index += 1) {+ if (remainingIfdEntryVisits === 0) return budgetExhausted;+ remainingIfdEntryVisits -= 1;+ const entryOffset = ifdOffset + 2 + index * 12;+ if (entryOffset + 12 > segment.byteLength) break;+ const tag = readUInt16(entryOffset);+ const type = readUInt16(entryOffset + 2);+ const count = readUInt32(entryOffset + 4);+ if (tag === 0x0112 && type === 3 && count === 1) {+ const orientation = readUInt16(entryOffset + 8);+ if (orientation !== null && orientation >= 1 && orientation <= 8) {+ result = orientation;+ break;+ }+ } else if (isRoot && tag === 0x8769 && type === 4 && count === 1) {+ const relativeSubIfdOffset = readUInt32(entryOffset + 8);+ if (relativeSubIfdOffset !== null) {+ const orientation = readIfdOrientation(tiffOffset + relativeSubIfdOffset, false);+ if (orientation === budgetExhausted) return budgetExhausted;+ if (orientation !== null) {+ result = orientation;+ break;+ }+ }+ }+ }+ if (!isRoot) subIfdOrientationByOffset.set(ifdOffset, result);+ return result;+ };+ const orientation = readIfdOrientation(tiffOffset + relativeIfdOffset, true);+ return orientation === budgetExhausted+ ? { complete: false, orientation: null }+ : { complete: true, orientation };+}++function jpegDimensions(buffer: Buffer): ImageDimensions | null {+ if (buffer.byteLength < 4 || buffer[0] !== 0xff || buffer[1] !== 0xd8) return null;+ const startOfFrameMarkers = new Set([+ 0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf,+ ]);+ let offset = 2;+ let dimensions: ImageDimensions | null = null;+ let exifMetadata: JpegExifMetadata | null = null;+ while (offset + 3 < buffer.byteLength) {+ if (buffer[offset] !== 0xff) {+ offset += 1;+ continue;+ }+ while (buffer[offset] === 0xff) offset += 1;+ const marker = buffer[offset];+ offset += 1;+ if (marker === undefined || marker === 0xd9 || marker === 0xda) break;+ if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd8)) continue;+ if (offset + 1 >= buffer.byteLength) return null;+ const length = buffer.readUInt16BE(offset);+ if (length < 2 || offset + length > buffer.byteLength) return null;+ if (marker === 0xe1 && exifMetadata === null) {+ exifMetadata = jpegExifMetadata(buffer.subarray(offset + 2, offset + length));+ }+ if (startOfFrameMarkers.has(marker)) {+ if (length < 7) return null;+ if (dimensions !== null) return null;+ dimensions = {+ height: buffer.readUInt16BE(offset + 3),+ width: buffer.readUInt16BE(offset + 5),+ };+ }+ offset += length;+ }+ if (!dimensions) return null;+ if (exifMetadata?.complete === false) return null;+ const orientation = exifMetadata?.orientation;+ return orientation !== undefined && orientation !== null && orientation >= 5 && orientation <= 8+ ? { width: dimensions.height, height: dimensions.width }+ : dimensions;+}++function webpDimensions(buffer: Buffer): ImageDimensions | null {+ if (+ buffer.byteLength < 30 ||+ buffer.subarray(0, 4).toString("ascii") !== "RIFF" ||+ buffer.subarray(8, 12).toString("ascii") !== "WEBP"+ ) {+ return null;+ }+ const kind = buffer.subarray(12, 16).toString("ascii");+ if (kind === "VP8X") {+ return {+ width: 1 + buffer.readUIntLE(24, 3),+ height: 1 + buffer.readUIntLE(27, 3),+ };+ }+ if (kind === "VP8 " && buffer.subarray(23, 26).equals(Buffer.from([0x9d, 0x01, 0x2a]))) {+ return {+ width: buffer.readUInt16LE(26) & 0x3fff,+ height: buffer.readUInt16LE(28) & 0x3fff,+ };+ }+ if (kind === "VP8L" && buffer[20] === 0x2f) {+ return {+ width: 1 + buffer[21]! + ((buffer[22]! & 0x3f) << 8),+ height: 1 + (buffer[22]! >> 6) + (buffer[23]! << 2) + ((buffer[24]! & 0x0f) << 10),+ };+ }+ return null;+}++function dibDimensions(buffer: Buffer): ImageDimensions | null {+ if (buffer.byteLength < 12) return null;+ const headerSize = buffer.readUInt32LE(0);+ if (headerSize === 12) {+ return {+ width: buffer.readUInt16LE(4),+ height: buffer.readUInt16LE(6),+ };+ }+ if (headerSize < 40 || buffer.byteLength < 12) return null;+ return {+ width: Math.abs(buffer.readInt32LE(4)),+ height: Math.abs(buffer.readInt32LE(8)),+ };+}++function icoDimensions(buffer: Buffer): ImageDimensions | null {+ if (+ buffer.byteLength < 22 ||+ buffer.readUInt16LE(0) !== 0 ||+ (buffer.readUInt16LE(2) !== 1 && buffer.readUInt16LE(2) !== 2)+ ) {+ return null;+ }+ const count = buffer.readUInt16LE(4);+ if (count === 0 || count > 256 || buffer.byteLength < 6 + count * 16) return null;+ let width = 0;+ let height = 0;+ for (let index = 0; index < count; index += 1) {+ const offset = 6 + index * 16;+ width = Math.max(width, buffer[offset] === 0 ? 256 : buffer[offset]!);+ height = Math.max(height, buffer[offset + 1] === 0 ? 256 : buffer[offset + 1]!);+ if (!safeDimensions({ width, height })) return null;+ const byteLength = buffer.readUInt32LE(offset + 8);+ const imageOffset = buffer.readUInt32LE(offset + 12);+ if (+ byteLength === 0 ||+ imageOffset < 6 + count * 16 ||+ imageOffset > buffer.byteLength ||+ byteLength > buffer.byteLength - imageOffset+ )+ return null;+ const embedded = buffer.subarray(imageOffset, imageOffset + byteLength);+ const embeddedDimensions = pngDimensions(embedded) ?? dibDimensions(embedded);+ if (!safeDimensions(embeddedDimensions)) return null;+ }+ return { width, height };+}++function sourceDimensions(buffer: Buffer): ImageDimensions | null {+ return (+ pngDimensions(buffer) ??+ gifDimensions(buffer) ??+ jpegDimensions(buffer) ??+ webpDimensions(buffer) ??+ icoDimensions(buffer)+ );+}++async function normalizeFaviconBuffer(+ webContents: Electron.WebContents,+ mime: string | null,+ buffer: Buffer,+ signal: AbortSignal,+): Promise<FaviconCaptureResult> {+ const declaredMime = mime?.trim().toLowerCase() || null;+ const normalizedMime =+ declaredMime === "application/x-icon"+ ? "image/x-icon"+ : declaredMime === "application/octet-stream" || declaredMime === "binary/octet-stream"+ ? null+ : declaredMime;+ const dimensions = sourceDimensions(buffer);+ if (+ (normalizedMime !== null && !/^image\/[a-z0-9.+-]+$/i.test(normalizedMime)) ||+ normalizedMime === "image/svg+xml" ||+ buffer.byteLength > MAX_FAVICON_RESPONSE_BYTES ||+ !safeDimensions(dimensions)+ ) {+ return { kind: "none" };+ }++ const rasterized = await rasterizeFavicon(+ webContents,+ normalizedMime,+ buffer,+ dimensions,+ signal,+ );+ if (rasterized.kind === "timed-out") return rasterized;+ return typeof rasterized.value === "string" &&+ rasterized.value.startsWith("data:image/png;base64,") &&+ rasterized.value.length <= FAVICON_DATA_URL_MAX_LENGTH+ ? { kind: "captured", dataUrl: rasterized.value }+ : { kind: "none" };+}++async function rasterizeFavicon(+ webContents: Electron.WebContents,+ mime: string | null,+ buffer: Buffer,+ dimensions: ImageDimensions,+ signal: AbortSignal,+): Promise<RasterizationResult> {+ const gate = rasterizationGates.get(webContents) ?? { generation: 0 };+ rasterizationGates.set(webContents, gate);+ const generation = ++gate.generation;+ const previousLaunchAllowed = gate.launchAllowed;+ if (previousLaunchAllowed) {+ await waitForRasterLaunch(previousLaunchAllowed, signal);+ }+ if (signal.aborted || generation !== gate.generation) {+ return { kind: "completed", value: null };+ }++ const payload = buffer.toString("base64");+ const blobType = mime ?? "";+ const scale = Math.min(32 / dimensions.width, 32 / dimensions.height);+ const decodeWidth = Math.max(1, Math.round(dimensions.width * scale));+ const decodeHeight = Math.max(1, Math.round(dimensions.height * scale));+ const drawX = (32 - decodeWidth) / 2;+ const drawY = (32 - decodeHeight) / 2;+ const code = `+ (() => {+ const rasterize = async () => {+ try {+ const source = Uint8Array.from(atob("${payload}"), (char) => char.charCodeAt(0));+ const bitmap = await createImageBitmap(new Blob([source], { type: "${blobType}" }), {+ resizeWidth: ${decodeWidth},+ resizeHeight: ${decodeHeight},+ resizeQuality: "high",+ });+ try {+ if (bitmap.width <= 0 || bitmap.height <= 0 || bitmap.width * bitmap.height > ${MAX_FAVICON_SOURCE_PIXELS}) {+ return null;+ }+ const canvas = new OffscreenCanvas(32, 32);+ const context = canvas.getContext("2d");+ if (!context) return null;+ context.drawImage(bitmap, ${drawX}, ${drawY}, ${decodeWidth}, ${decodeHeight});+ const blob = await canvas.convertToBlob({ type: "image/png" });+ const output = new Uint8Array(await blob.arrayBuffer());+ let binary = "";+ for (const byte of output) binary += String.fromCharCode(byte);+ return "data:image/png;base64," + btoa(binary);+ } finally {+ bitmap.close();+ }+ } catch {+ return null;+ }+ };+ return rasterize();+ })()+ `;++ const execution = webContents.executeJavaScriptInIsolatedWorld(FAVICON_RASTER_WORLD_ID, [+ { code },+ ]);++ const result = new Promise<RasterizationResult>((resolve, reject) => {+ // Electron cannot cancel isolated-world execution. This timeout ends only+ // the logical attempt; renderer work may finish after a newer attempt starts.+ const timeout = AbortSignal.timeout(FAVICON_RASTER_TIMEOUT_MS);+ let settled = false;+ const finish = (complete: () => void) => {+ if (settled) return;+ settled = true;+ timeout.removeEventListener("abort", onTimeout);+ signal.removeEventListener("abort", onAbort);+ complete();+ };+ const onTimeout = () => {+ finish(() => resolve({ kind: "timed-out" }));+ };+ const onAbort = () => {+ finish(() => resolve({ kind: "completed", value: null }));+ };+ timeout.addEventListener("abort", onTimeout, { once: true });+ signal.addEventListener("abort", onAbort, { once: true });+ void execution.then(+ (value) => {+ finish(() => resolve({ kind: "completed", value }));+ },+ (cause: unknown) => {+ finish(() => reject(cause));+ },+ );+ if (signal.aborted) onAbort();+ });+ // The logical timeout does not cancel Electron's renderer work. Keep the+ // gate closed until that physical execution actually settles.+ const launchAllowed = execution.then(+ () => undefined,+ () => undefined,+ );+ gate.launchAllowed = launchAllowed;+ void launchAllowed.then(() => {+ if (gate.launchAllowed === launchAllowed) delete gate.launchAllowed;+ });+ return await result;+}diff --git a/apps/desktop/src/preview/Manager.test.ts b/apps/desktop/src/preview/Manager.test.tsindex a6ef30c27..c24dca802 100644--- a/apps/desktop/src/preview/Manager.test.ts+++ b/apps/desktop/src/preview/Manager.test.ts@@ -186,6 +186,102 @@ const makeTestPreviewWebContents = (capturePage,}) as never;+const TEST_FAVICON = "data:image/png;base64,cG5n";++const makeSourcePng = (width = 1, height = 1): Buffer => {+ const buffer = Buffer.alloc(24);+ Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]).copy(buffer);+ buffer.writeUInt32BE(width, 16);+ buffer.writeUInt32BE(height, 20);+ return buffer;+};++const makeFaviconWebContents = (options?: {+ readonly fetch?: (url: string, init?: RequestInit) => Promise<Response>;+ readonly id?: number;+ readonly rasterize?: (code: string) => Promise<unknown>;+ readonly url?: string;+}) => {+ const sourcePng = makeSourcePng();+ const listeners = new Map<string, (...args: never[]) => void>();+ let currentUrl = options?.url ?? "http://localhost:3200/";+ let destroyed = false;+ let loading = false;+ const fetch = vi.fn(+ options?.fetch ??+ (async () =>+ new Response(new Uint8Array(sourcePng), {+ headers: { "content-type": "image/png" },+ })),+ );+ const executeJavaScriptInIsolatedWorld = vi.fn(+ async (_worldId: number, scripts: ReadonlyArray<{ readonly code: string }>) =>+ options?.rasterize ? options.rasterize(scripts[0]?.code ?? "") : TEST_FAVICON,+ );+ const reload = vi.fn();+ const loadURL = vi.fn(async (url: string) => {+ currentUrl = url;+ });+ const off = vi.fn();+ const debuggerOff = vi.fn();+ const webContents = {+ id: options?.id ?? 42,+ isDestroyed: () => destroyed,+ getType: () => "webview",+ getURL: () => currentUrl,+ getTitle: () => "Preview",+ isLoading: () => loading,+ isDevToolsOpened: () => false,+ getZoomFactor: () => 1,+ setZoomFactor: vi.fn(),+ reload,+ reloadIgnoringCache: vi.fn(),+ loadURL,+ on: vi.fn((event: string, listener: (...args: never[]) => void) => {+ listeners.set(event, listener);+ }),+ off,+ ipc: { on: vi.fn(), off: vi.fn() },+ send: webviewSend,+ session: { fetch },+ navigationHistory: { canGoBack: () => false, canGoForward: () => false },+ setWindowOpenHandler: vi.fn(),+ executeJavaScriptInIsolatedWorld,+ debugger: {+ isAttached: () => false,+ attach: vi.fn(),+ sendCommand: vi.fn(async () => undefined),+ on: vi.fn(),+ off: debuggerOff,+ },+ };+ return {+ executeJavaScriptInIsolatedWorld,+ fetch,+ debuggerOff,+ listeners,+ loadURL,+ off,+ reload,+ setDestroyed: (value: boolean) => {+ destroyed = value;+ },+ setLoading: (value: boolean) => {+ loading = value;+ },+ setUrl: (url: string) => {+ currentUrl = url;+ },+ webContents: webContents as never,+ };+};++const settle = function* (until: () => boolean) {+ for (let attempt = 0; attempt < 30 && !until(); attempt++) {+ yield* Effect.promise(() => Promise.resolve());+ }+};+const makeTestPictureInPictureWindow = (loadURL: () => Promise<void> = async () => undefined) => {const listeners = new Map<string, () => void>();const send = vi.fn();@@ -257,6 +353,32 @@ describe("PreviewManager", () => {),);+ effectIt.effect("rejects a destroyed webview during registration", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const getType = vi.fn(() => "webview" as const);+ fromId.mockReturnValue({+ id: 42,+ isDestroyed: () => true,+ getType,+ } as never);+ yield* manager.createTab("tab_destroyed_registration");++ const exit = yield* Effect.exit(manager.registerWebview("tab_destroyed_registration", 42));++ expect(Exit.isFailure(exit)).toBe(true);+ if (Exit.isFailure(exit)) {+ expect(Option.getOrThrow(Cause.findErrorOption(exit.cause))).toMatchObject({+ _tag: "PreviewWebContentsNotFoundError",+ tabId: "tab_destroyed_registration",+ webContentsId: 42,+ });+ }+ expect(getType).not.toHaveBeenCalled();+ }),+ ),+ );+effectIt.effect("isolates failed state listeners and continues delivery", () => {const loggedErrors: Array<unknown> = [];const logger = Logger.make(({ message }) => {@@ -375,6 +497,488 @@ describe("PreviewManager", () => {),);+ effectIt.effect("detaches a destroyed webview instead of navigating it", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const preview = makeFaviconWebContents();+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_destroyed_navigation");+ yield* manager.registerWebview("tab_destroyed_navigation", 42);+ yield* manager.setColorScheme("tab_destroyed_navigation", "dark");+ preview.setDestroyed(true);++ yield* manager.navigate("tab_destroyed_navigation", "https://example.com/");++ expect(preview.loadURL).not.toHaveBeenCalled();+ expect(preview.reload).not.toHaveBeenCalled();+ expect(preview.off).toHaveBeenCalled();+ expect(preview.debuggerOff).toHaveBeenCalled();+ expect(states.at(-1)).toMatchObject({+ webContentsId: null,+ navStatus: { kind: "Loading", url: "https://example.com/" },+ });+ }),+ ),+ );++ effectIt.effect("does not let destroyed-webview cleanup detach a same-id replacement", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const previous = makeFaviconWebContents();+ const replacement = makeFaviconWebContents({ url: "https://example.com/" });+ let current = previous.webContents;+ let startReplacementRegistration: () => void = () => void 0;+ const replacementReady = new Promise<void>((resolve) => {+ startReplacementRegistration = resolve;+ });+ fromId.mockImplementation(() => current);+ yield* manager.createTab("tab_destroyed_replacement_race");+ yield* manager.registerWebview("tab_destroyed_replacement_race", 42);+ yield* manager.setColorScheme("tab_destroyed_replacement_race", "dark");+ const replacementRegistration = yield* Effect.promise(() => replacementReady).pipe(+ Effect.flatMap(() => manager.registerWebview("tab_destroyed_replacement_race", 42)),+ Effect.forkChild({ startImmediately: true }),+ );+ previous.setDestroyed(true);+ previous.debuggerOff.mockImplementationOnce(() => {+ current = replacement.webContents;+ startReplacementRegistration();+ });+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );++ yield* manager.navigate("tab_destroyed_replacement_race", "https://example.com/");+ const registrationExit = yield* Fiber.await(replacementRegistration);++ expect(Exit.isSuccess(registrationExit)).toBe(true);+ expect(previous.off).toHaveBeenCalled();+ expect(replacement.off).not.toHaveBeenCalled();+ expect(states.at(-1)).toMatchObject({+ webContentsId: 42,+ navStatus: { kind: "Loading", url: "https://example.com/" },+ });+ }),+ ),+ );++ effectIt.effect("publishes a canonical favicon origin while the page is loading", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const preview = makeFaviconWebContents({+ url: `http://localhost:3200/${"x".repeat(3_000)}`,+ });+ preview.setLoading(true);+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_loading");+ yield* manager.registerWebview("tab_favicon_loading", 42);++ preview.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ expect(states.at(-1)?.favicon).toMatchObject({+ dataUrl: TEST_FAVICON,+ pageUrl: "http://localhost:3200",+ });+ expect(states.at(-1)?.favicon?.capturedAt).toEqual(expect.any(Number));+ }),+ ),+ );++ effectIt.effect("shares an identical in-flight event and lets a changed event win", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ let resolveFirst!: (response: Response) => void;+ const firstResponse = new Promise<Response>((resolve) => {+ resolveFirst = resolve;+ });+ const preview = makeFaviconWebContents({+ fetch: (url) =>+ url.endsWith("first.png")+ ? firstResponse+ : Promise.resolve(+ new Response(new Uint8Array(makeSourcePng()), {+ headers: { "content-type": "image/png" },+ }),+ ),+ });+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_latest");+ yield* manager.registerWebview("tab_favicon_latest", 42);++ const faviconUpdated = preview.listeners.get("page-favicon-updated")!;+ faviconUpdated({} as never, ["http://localhost:3200/first.png"] as never);+ faviconUpdated({} as never, ["http://localhost:3200/first.png"] as never);+ yield* settle(() => preview.fetch.mock.calls.length === 1);+ faviconUpdated({} as never, ["http://localhost:3200/second.png"] as never);+ yield* settle(() => states.at(-1)?.favicon !== undefined);+ resolveFirst(+ new Response(new Uint8Array(makeSourcePng()), {+ headers: { "content-type": "image/png" },+ }),+ );+ yield* settle(() => false);++ expect(preview.fetch).toHaveBeenCalledTimes(2);+ expect(states.filter((state) => state.favicon !== undefined)).toHaveLength(1);+ }),+ ),+ );++ effectIt.effect("allows an identical retry after an undecodable capture", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ let rasterizations = 0;+ const preview = makeFaviconWebContents({+ rasterize: async () => (++rasterizations === 1 ? null : TEST_FAVICON),+ });+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_retry");+ yield* manager.registerWebview("tab_favicon_retry", 42);+ const faviconUpdated = preview.listeners.get("page-favicon-updated")!;++ faviconUpdated({} as never, ["http://localhost:3200/favicon.png"] as never);+ yield* settle(() => rasterizations === 1);+ yield* settle(() => false);+ faviconUpdated({} as never, ["http://localhost:3200/favicon.png"] as never);+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ expect(rasterizations).toBe(2);+ expect(states.at(-1)?.favicon?.dataUrl).toBe(TEST_FAVICON);+ }),+ ),+ );++ effectIt.effect("does not publish a capture invalidated by navigation", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ let resolveFetch!: (response: Response) => void;+ const preview = makeFaviconWebContents({+ fetch: () =>+ new Promise<Response>((resolve) => {+ resolveFetch = resolve;+ }),+ });+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_navigation");+ yield* manager.registerWebview("tab_favicon_navigation", 42);+ preview.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => preview.fetch.mock.calls.length === 1);+ preview.listeners.get("did-start-navigation")?.({+ isMainFrame: true,+ isSameDocument: false,+ } as never);+ preview.setUrl("https://example.com/");+ resolveFetch(+ new Response(new Uint8Array(makeSourcePng()), {+ headers: { "content-type": "image/png" },+ }),+ );+ yield* settle(() => false);++ expect(states.some((state) => state.favicon !== undefined)).toBe(false);+ }),+ ),+ );++ effectIt.effect("retains a favicon when reloading the current URL without a new event", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const preview = makeFaviconWebContents();+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_reload");+ yield* manager.registerWebview("tab_favicon_reload", 42);+ preview.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ yield* manager.navigate("tab_favicon_reload", "http://localhost:3200/");++ expect(preview.reload).toHaveBeenCalledOnce();+ expect(states.at(-1)?.favicon?.dataUrl).toBe(TEST_FAVICON);+ }),+ ),+ );++ effectIt.effect("clears a published favicon after a confirmed cross-origin navigation", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const preview = makeFaviconWebContents();+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_origin");+ yield* manager.registerWebview("tab_favicon_origin", 42);+ preview.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ preview.setUrl("https://example.com/");+ preview.listeners.get("did-navigate")?.({} as never);+ yield* settle(() => states.at(-1)?.navStatus.kind === "Success");++ expect(states.at(-1)?.favicon).toBeUndefined();+ }),+ ),+ );++ effectIt.effect(+ "retains the previous document icon across a failed cross-origin navigation",+ () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const preview = makeFaviconWebContents();+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_failed_origin");+ yield* manager.registerWebview("tab_favicon_failed_origin", 42);+ preview.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ preview.listeners.get("did-fail-load")?.(+ {} as never,+ -105 as never,+ "Name not resolved" as never,+ "https://unreachable.example/" as never,+ true as never,+ );+ yield* settle(() => states.at(-1)?.navStatus.kind === "LoadFailed");+ expect(states.at(-1)?.favicon?.dataUrl).toBe(TEST_FAVICON);++ preview.listeners.get("did-navigate")?.({} as never);+ yield* settle(() => states.at(-1)?.navStatus.kind === "Success");+ expect(states.at(-1)?.favicon?.dataUrl).toBe(TEST_FAVICON);+ }),+ ),+ );++ effectIt.effect("does not resurrect an icon after a confirmed about:blank document", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const preview = makeFaviconWebContents();+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_blank");+ yield* manager.registerWebview("tab_favicon_blank", 42);+ preview.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ preview.setUrl("about:blank");+ preview.listeners.get("did-navigate")?.({} as never);+ yield* settle(() => states.at(-1)?.navStatus.kind === "Idle");+ expect(states.at(-1)?.favicon).toBeUndefined();++ preview.setUrl("http://localhost:3200/");+ preview.listeners.get("did-navigate")?.({} as never);+ yield* settle(() => states.at(-1)?.navStatus.kind === "Success");+ expect(states.at(-1)?.favicon).toBeUndefined();+ }),+ ),+ );++ effectIt.effect("clears a published favicon when a replacement webview attaches", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const initial = makeFaviconWebContents({ id: 42 });+ const replacement = makeFaviconWebContents({ id: 43 });+ fromId.mockImplementation((id?: number) => {+ if (id === 42) return initial.webContents;+ if (id === 43) return replacement.webContents;+ return null;+ });+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_replace");+ yield* manager.registerWebview("tab_favicon_replace", 42);+ initial.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ yield* manager.registerWebview("tab_favicon_replace", 43);++ expect(states.at(-1)?.webContentsId).toBe(43);+ expect(states.at(-1)?.favicon).toBeUndefined();+ }),+ ),+ );++ effectIt.effect("ignores an old capture that completes after webview replacement", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ let resolveFetch!: (response: Response) => void;+ const initial = makeFaviconWebContents({+ id: 42,+ fetch: () =>+ new Promise<Response>((resolve) => {+ resolveFetch = resolve;+ }),+ });+ const replacement = makeFaviconWebContents({ id: 43 });+ fromId.mockImplementation((id?: number) =>+ id === 42 ? initial.webContents : id === 43 ? replacement.webContents : null,+ );+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_late_replace");+ yield* manager.registerWebview("tab_favicon_late_replace", 42);+ initial.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => initial.fetch.mock.calls.length === 1);++ yield* manager.registerWebview("tab_favicon_late_replace", 43);+ resolveFetch(+ new Response(new Uint8Array(makeSourcePng()), {+ headers: { "content-type": "image/png" },+ }),+ );+ yield* settle(() => false);++ expect(states.at(-1)?.webContentsId).toBe(43);+ expect(+ states.some((state) => state.webContentsId === 43 && state.favicon !== undefined),+ ).toBe(false);+ }),+ ),+ );++ effectIt.effect("treats a reused WebContents id as a new attachment", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const initial = makeFaviconWebContents({ id: 42 });+ const replacement = makeFaviconWebContents({ id: 42 });+ let active = initial.webContents;+ fromId.mockImplementation(() => active);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_reused_id");+ yield* manager.registerWebview("tab_favicon_reused_id", 42);+ initial.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ active = replacement.webContents;+ yield* manager.registerWebview("tab_favicon_reused_id", 42);++ expect(states.at(-1)?.favicon).toBeUndefined();+ expect(initial.off).toHaveBeenCalled();+ expect(replacement.listeners.has("page-favicon-updated")).toBe(true);+ }),+ ),+ );++ effectIt.effect("preserves a favicon when the active attachment registers again", () =>+ withManager((manager) =>+ Effect.gen(function* () {+ const preview = makeFaviconWebContents();+ fromId.mockReturnValue(preview.webContents);+ const states: PreviewManager.PreviewTabState[] = [];+ yield* manager.subscribeStateChanges((_tabId, state) =>+ Effect.sync(() => {+ states.push(state);+ }),+ );+ yield* manager.createTab("tab_favicon_reregister");+ yield* manager.registerWebview("tab_favicon_reregister", 42);+ preview.listeners.get("page-favicon-updated")?.(+ {} as never,+ ["http://localhost:3200/favicon.png"] as never,+ );+ yield* settle(() => states.at(-1)?.favicon !== undefined);++ yield* manager.registerWebview("tab_favicon_reregister", 42);++ expect(states.at(-1)?.favicon?.dataUrl).toBe(TEST_FAVICON);+ }),+ ),+ );+effectIt.effect("mirrors Electron's effective zoom across registration and navigation", () =>withManager((manager) =>Effect.gen(function* () {diff --git a/apps/desktop/src/preview/Manager.ts b/apps/desktop/src/preview/Manager.tsindex 169fe2992..4799a7dfa 100644--- a/apps/desktop/src/preview/Manager.ts+++ b/apps/desktop/src/preview/Manager.ts@@ -8,6 +8,7 @@import type {DesktopPreviewAnnotationTheme,DesktopPreviewColorScheme,+ DesktopPreviewFavicon,DesktopPreviewPointerEvent,PreviewAnnotationPayload,PreviewAnnotationRect,@@ -62,6 +63,7 @@ import {import { isPreviewAnnotationPayload } from "./PickedElementPayload.ts";import { playwrightInjectedRuntimeInstallExpression } from "./PlaywrightInjectedRuntime.ts";import { makePreviewAutomationKeySequence } from "./PreviewKeyboard.ts";+import { captureFavicon, safeHttpOrigin, selectFaviconCandidates } from "./FaviconCapture.ts";export type PreviewNavStatus =| { kind: "Idle" }@@ -85,6 +87,7 @@ export interface PreviewTabState {pictureInPicture: boolean;colorScheme: DesktopPreviewColorScheme;controller: "human" | "agent" | "none";+ favicon?: DesktopPreviewFavicon;updatedAt: string;}@@ -346,7 +349,10 @@ type PreviewInputSignal =| { readonly kind: "key"; readonly key: string; readonly code: string };interface ManagedListeners {+ readonly attachmentId: symbol;+ readonly cancelFaviconCapture: () => void;readonly scope: Scope.Closeable;+ readonly webContents: Electron.WebContents;}type FrameCaptureConsumer = "picture-in-picture" | "recording";@@ -613,6 +619,15 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function);});+ const emitIfCurrent = Effect.fn("PreviewManager.emitIfCurrent")(function* (+ tabId: string,+ state: PreviewTabState,+ ) {+ if ((yield* SynchronizedRef.get(tabsRef)).get(tabId) === state) {+ yield* emit(tabId, state);+ }+ });+const update = Effect.fn("PreviewManager.update")(function* (tabId: string,patch: Partial<PreviewTabState>,@@ -1204,7 +1219,10 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(functioncopy.delete(webContentsId);}),]);- if (managed) yield* Scope.close(managed.scope, Exit.void).pipe(Effect.ignore);+ if (managed) {+ managed.cancelFaviconCapture();+ yield* Scope.close(managed.scope, Exit.void).pipe(Effect.ignore);+ }});const isAppShortcut = (input: Electron.Input): boolean =>@@ -1268,8 +1286,23 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(functionwc: Electron.WebContents,) {const scope = yield* Scope.fork(parentScope, "sequential");+ const attachmentId = Symbol();+ let documentId = 0;+ let nextRequestId = 0;+ let activeCapture: {+ readonly controller: AbortController;+ readonly documentId: number;+ readonly eventKey: string;+ readonly requestId: number;+ } | null = null;+ const cancelFaviconCapture = () => {+ documentId += 1;+ activeCapture?.controller.abort();+ activeCapture = null;+ };const syncState = Effect.fn("PreviewManager.syncWebContentsState")(function* (preserveLoadFailure: boolean,+ confirmedNavigation = false,) {if (wc.isDestroyed()) return;const zoomFactor = yield* attempt(@@ -1282,7 +1315,9 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(functionconst updatedAt = yield* currentIso;const next = yield* SynchronizedRef.modify(tabsRef, (tabs) => {const current = tabs.get(tabId);- if (!current) return [Option.none<PreviewTabState>(), tabs] as const;+ if (!current || current.webContentsId !== wc.id || webContents.fromId(wc.id) !== wc) {+ return [Option.none<PreviewTabState>(), tabs] as const;+ }// Electron emits did-stop-loading after did-fail-load. At that point the// failed guest is no longer "loading", but it has not successfully// navigated anywhere. Keep the failure until a new load actually starts.@@ -1292,8 +1327,14 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(functioncomputedNavStatus.kind === "Success"? current.navStatus: computedNavStatus;+ const clearFavicon =+ confirmedNavigation &&+ current.favicon !== undefined &&+ safeHttpOrigin(current.favicon.pageUrl) !==+ safeHttpOrigin(navStatus.kind === "Idle" ? wc.getURL() : navStatus.url);+ const { favicon: _favicon, ...currentWithoutFavicon } = current;const state: PreviewTabState = {- ...current,+ ...(clearFavicon ? currentWithoutFavicon : current),navStatus,canGoBack,canGoForward,@@ -1307,10 +1348,109 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function}),] as const;});- if (Option.isSome(next)) yield* emit(tabId, next.value);+ if (Option.isSome(next)) yield* emitIfCurrent(tabId, next.value);});const sync = () => runFork(syncState(true));- const syncNavigation = () => runFork(syncState(false));+ const syncNavigation = () => runFork(syncState(false, true));+ const syncInPageNavigation = () => runFork(syncState(false));+ const navigationStarted = (+ event: Electron.Event<Electron.WebContentsDidStartNavigationEventParams>,+ ) => {+ if (event.isMainFrame && !event.isSameDocument) cancelFaviconCapture();+ };+ const publishFavicon = Effect.fn("PreviewManager.publishFavicon")(function* (input: {+ readonly captureDocumentId: number;+ readonly dataUrl: string;+ readonly pageUrl: string;+ readonly requestId: number;+ }) {+ const pageOrigin = safeHttpOrigin(input.pageUrl);+ const managed = (yield* Ref.get(attachedRef)).get(wc.id);+ if (+ !pageOrigin ||+ wc.isDestroyed() ||+ webContents.fromId(wc.id) !== wc ||+ managed?.attachmentId !== attachmentId ||+ activeCapture?.documentId !== input.captureDocumentId ||+ activeCapture.requestId !== input.requestId ||+ safeHttpOrigin(wc.getURL()) !== pageOrigin+ ) {+ return;+ }+ const capturedAt = yield* currentMillis;+ const updatedAt = yield* currentIso;+ const next = yield* SynchronizedRef.modify(tabsRef, (tabs) => {+ const current = tabs.get(tabId);+ if (+ !current ||+ current.webContentsId !== wc.id ||+ webContents.fromId(wc.id) !== wc ||+ activeCapture?.documentId !== input.captureDocumentId ||+ activeCapture.requestId !== input.requestId+ ) {+ return [Option.none<PreviewTabState>(), tabs] as const;+ }+ const state: PreviewTabState = {+ ...current,+ favicon: { dataUrl: input.dataUrl, pageUrl: pageOrigin, capturedAt },+ updatedAt,+ };+ return [+ Option.some(state),+ replaceMap(tabs, (copy) => {+ copy.set(tabId, state);+ }),+ ] as const;+ });+ if (Option.isSome(next)) yield* emitIfCurrent(tabId, next.value);+ });+ const faviconUpdated = (_event: Event, rawCandidates: ReadonlyArray<string>): void => {+ const pageUrl = wc.getURL();+ if (!safeHttpOrigin(pageUrl)) return;+ const candidates = selectFaviconCandidates(rawCandidates);+ if (candidates.length === 0) return;+ const eventKey = JSON.stringify([pageUrl, ...candidates]);+ if (activeCapture?.eventKey === eventKey) return;+ activeCapture?.controller.abort();+ const captureDocumentId = documentId;+ const requestId = ++nextRequestId;+ const controller = new AbortController();+ activeCapture = { controller, documentId: captureDocumentId, eventKey, requestId };+ runFork(+ Effect.tryPromise({+ try: () =>+ captureFavicon({ webContents: wc, pageUrl, candidates, signal: controller.signal }),+ catch: (cause) =>+ new PreviewOperationError({+ operation: "captureFavicon",+ tabId,+ webContentsId: wc.id,+ cause,+ }),+ }).pipe(+ Effect.flatMap((result) =>+ result.kind === "captured"+ ? publishFavicon({+ captureDocumentId,+ dataUrl: result.dataUrl,+ pageUrl,+ requestId,+ })+ : Effect.void,+ ),+ Effect.catch((error) =>+ controller.signal.aborted+ ? Effect.void+ : Effect.logDebug("Favicon capture failed.", { error, tabId, webContentsId: wc.id }),+ ),+ Effect.ensuring(+ Effect.sync(() => {+ if (activeCapture?.requestId === requestId) activeCapture = null;+ }),+ ),+ ),+ );+ };const failed = (_event: Event,code: number,@@ -1387,9 +1527,12 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(functionyield* Scope.addFinalizer(scope,attempt({ operation: "detachListeners", tabId, webContentsId: wc.id }, () => {+ cancelFaviconCapture();+ wc.off("did-start-navigation", navigationStarted);wc.off("did-navigate", syncNavigation);- wc.off("did-navigate-in-page", syncNavigation);+ wc.off("did-navigate-in-page", syncInPageNavigation);wc.off("page-title-updated", sync);+ wc.off("page-favicon-updated", faviconUpdated as never);wc.off("did-start-loading", sync);wc.off("did-stop-loading", sync);wc.off("did-fail-load", failed as never);@@ -1399,9 +1542,11 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function);const install = Effect.fn("PreviewManager.installWebContentsListeners")(function* () {yield* attempt({ operation: "attachListeners", tabId, webContentsId: wc.id }, () => {+ wc.on("did-start-navigation", navigationStarted);wc.on("did-navigate", syncNavigation);- wc.on("did-navigate-in-page", syncNavigation);+ wc.on("did-navigate-in-page", syncInPageNavigation);wc.on("page-title-updated", sync);+ wc.on("page-favicon-updated", faviconUpdated as never);wc.on("did-start-loading", sync);wc.on("did-stop-loading", sync);wc.on("did-fail-load", failed as never);@@ -1418,7 +1563,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function});yield* Ref.update(attachedRef, (attached) =>replaceMap(attached, (copy) => {- copy.set(wc.id, { scope });+ copy.set(wc.id, { attachmentId, cancelFaviconCapture, scope, webContents: wc });}),);});@@ -1561,6 +1706,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(functionconst mainWindow = yield* Ref.get(mainWindowRef);if (!wc ||+ wc.isDestroyed() ||wc.getType() !== "webview" ||(Option.isSome(mainWindow) && wc.hostWebContents !== mainWindow.value.webContents)) {@@ -1568,7 +1714,8 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function}const attached = yield* Ref.get(attachedRef);const annotationTheme = yield* Ref.get(annotationThemeRef);- if (tab.webContentsId === webContentsId && attached.has(webContentsId)) {+ const currentAttachment = attached.get(webContentsId);+ if (tab.webContentsId === webContentsId && currentAttachment?.webContents === wc) {const zoomFactor = yield* attempt({ operation: "registerWebview.getZoomFactor", tabId, webContentsId },() => wc.getZoomFactor(),@@ -1580,7 +1727,10 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(functionreturn;}const replacedWebContentsId =- tab.webContentsId != null && tab.webContentsId !== webContentsId ? tab.webContentsId : null;+ tab.webContentsId != null &&+ (tab.webContentsId !== webContentsId || currentAttachment?.webContents !== wc)+ ? tab.webContentsId+ : null;if (replacedWebContentsId !== null) {yield* Effect.all([@@ -1627,8 +1777,9 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function] as const;}const pendingUrl = current.navStatus.kind === "Loading" ? current.navStatus.url : null;+ const { favicon: _favicon, ...currentWithoutFavicon } = current;const next: PreviewTabState = {- ...current,+ ...currentWithoutFavicon,webContentsId,navStatus: pendingUrl === null ? computeNavStatus(wc) : current.navStatus,canGoBack: wc.navigationHistory.canGoBack(),@@ -1707,6 +1858,7 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(functionpictureInPicture: current?.pictureInPicture ?? false,colorScheme: current?.colorScheme ?? "system",controller: current?.controller ?? "none",+ ...(current?.favicon ? { favicon: current.favicon } : {}),updatedAt,};return [@@ -1718,17 +1870,48 @@ const makeNativeOperations = Effect.fn("PreviewManager.makeOperations")(function});yield* emit(tabId, pending);if (pending.webContentsId == null) return;- const wc = webContents.fromId(pending.webContentsId);- if (!wc) {- const detached = { ...pending, webContentsId: null };- yield* SynchronizedRef.update(tabsRef, (tabs) =>- tabs.get(tabId)?.webContentsId !== pending.webContentsId- ? tabs- : replaceMap(tabs, (copy) => {- copy.set(tabId, detached);- }),+ const webContentsId = pending.webContentsId;+ const wc = webContents.fromId(webContentsId);+ if (!wc || wc.isDestroyed()) {+ const expectedAttachment = (yield* Ref.get(attachedRef)).get(webContentsId);+ yield* withTabLifecycleLock(+ tabId,+ Effect.gen(function* () {+ const currentTab = (yield* SynchronizedRef.get(tabsRef)).get(tabId);+ const currentAttachment = (yield* Ref.get(attachedRef)).get(webContentsId);+ const currentWebContents = webContents.fromId(webContentsId);+ if (+ currentTab?.webContentsId !== webContentsId ||+ currentAttachment !== expectedAttachment ||+ (currentWebContents && !currentWebContents.isDestroyed())+ ) {+ return;+ }+ yield* Effect.all(+ [+ detachControlSession(webContentsId),+ detachListeners(webContentsId),+ cancelPickElement(tabId),+ ],+ { concurrency: 3, discard: true },+ );+ const detached = yield* SynchronizedRef.modify(tabsRef, (tabs) => {+ const current = tabs.get(tabId);+ if (current?.webContentsId !== webContentsId) {+ return [Option.none<PreviewTabState>(), tabs] as const;+ }+ const { favicon: _favicon, ...currentWithoutFavicon } = current;+ const next: PreviewTabState = { ...currentWithoutFavicon, webContentsId: null };+ return [+ Option.some(next),+ replaceMap(tabs, (copy) => {+ copy.set(tabId, next);+ }),+ ] as const;+ });+ if (Option.isSome(detached)) yield* emitIfCurrent(tabId, detached.value);+ }),);- yield* emit(tabId, detached);return;}if (wc.getURL() === url) {diff --git a/apps/web/src/browser/browserTargetResolver.test.ts b/apps/web/src/browser/browserTargetResolver.test.tsindex 6f89d86df..558924b63 100644--- a/apps/web/src/browser/browserTargetResolver.test.ts+++ b/apps/web/src/browser/browserTargetResolver.test.ts@@ -180,4 +180,135 @@ describe("browser target resolver", () => {const { resolveDiscoveredServerUrl } = await import("./browserTargetResolver");expect(resolveDiscoveredServerUrl(EnvironmentId.make("environment-1"), " ")).toBe(" ");});++ it("classifies exact private IPv4 and IPv6 boundaries", async () => {+ const { isPrivateNetworkHost } = await import("./browserTargetResolver");+ const privateHosts = [+ "0.0.0.0",+ "10.0.0.0",+ "10.255.255.255",+ "100.64.0.0",+ "100.127.255.255",+ "127.0.0.0",+ "127.255.255.255",+ "169.254.0.0",+ "169.254.255.255",+ "172.16.0.0",+ "172.31.255.255",+ "192.168.0.0",+ "192.168.255.255",+ "198.18.0.0",+ "198.19.255.255",+ "fc00::",+ "fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",+ "fe80::",+ "febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff",+ "::ffff:192.168.1.1",+ "localhost.",+ "localhost..",+ "devbox.",+ "devbox..",+ "printer.local.",+ "printer.local..",+ "printer.home.arpa.",+ "printer.home.arpa..",+ "devbox.example.ts.net.",+ "devbox.example.ts.net..",+ ];+ const publicHosts = [+ "1.0.0.0",+ "100.63.255.255",+ "100.128.0.0",+ "169.253.255.255",+ "169.255.0.0",+ "172.15.255.255",+ "172.32.0.0",+ "192.167.255.255",+ "192.169.0.0",+ "198.17.255.255",+ "198.20.0.0",+ "fbff:ffff::",+ "fec0::",+ "2001:4860:4860::8888",+ "::ffff:8.8.8.8",+ "example.com.",+ ];+ expect(privateHosts.filter((host) => !isPrivateNetworkHost(host))).toEqual([]);+ expect(publicHosts.filter(isPrivateNetworkHost)).toEqual([]);+ });++ it("allows only globally routable hosts to reach a public favicon provider", async () => {+ const { isPublicFaviconHost } = await import("./browserTargetResolver");+ const nonPublic = [+ "192.0.0.0",+ "192.0.0.255",+ "192.0.2.0",+ "192.0.2.255",+ "192.88.99.0",+ "192.88.99.255",+ "198.51.100.0",+ "198.51.100.255",+ "203.0.113.0",+ "203.0.113.255",+ "224.0.0.0",+ "255.255.255.255",+ "::2",+ "100::",+ "100::ffff:ffff:ffff:ffff",+ "100:0:0:1::",+ "100:0:0:1:ffff:ffff:ffff:ffff",+ "64:ff9b:1::1",+ "64:ff9b::a00:1",+ "64:ff9b::7f00:1",+ "64:ff9b::c0a8:101",+ "64:ff9b::c000:201",+ "2001:5::1",+ "2001:2::",+ "2001:2:0:ffff:ffff:ffff:ffff:ffff",+ "2001:db8::",+ "2001:db8:ffff:ffff:ffff:ffff:ffff:ffff",+ "3fff::",+ "3fff:fff:ffff:ffff:ffff:ffff:ffff:ffff",+ "5f00::1",+ "fec0::",+ "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",+ "::ffff:192.0.2.1",+ "app.test",+ "app.test..",+ "printer.local..",+ "printer.home.arpa..",+ "devbox.example.ts.net..",+ "127.0.0.1..",+ "127.1..",+ "10.1..",+ "172.16.1..",+ "192.168.1..",+ "service.internal",+ "hidden.onion",+ ];+ const publicHosts = [+ "191.255.255.255",+ "192.0.1.255",+ "192.0.3.0",+ "198.51.99.255",+ "198.51.101.0",+ "203.0.112.255",+ "203.0.114.0",+ "223.255.255.255",+ "1.1.1.1",+ "2001:4860:4860::8888",+ "2606:4700:4700::1111",+ "64:ff9b::808:808",+ "2001:1::1",+ "2001:3::1",+ "2001:4:112::1",+ "2001:20::1",+ "2001:30::1",+ "::ffff:8.8.8.8",+ "example.com",+ "example.com.",+ ];+ expect(nonPublic.filter(isPublicFaviconHost)).toEqual([]);+ expect(publicHosts.filter((host) => !isPublicFaviconHost(host))).toEqual([]);+ });});diff --git a/apps/web/src/browser/browserTargetResolver.ts b/apps/web/src/browser/browserTargetResolver.tsindex 3c3be59b4..149248d17 100644--- a/apps/web/src/browser/browserTargetResolver.ts+++ b/apps/web/src/browser/browserTargetResolver.ts@@ -8,7 +8,10 @@ import { isLoopbackHost, normalizePreviewUrl } from "@t3tools/shared/preview";import { readPreparedConnection } from "~/state/session";export const normalizeHostname = (host: string): string =>- host.toLowerCase().replace(/^\[|\]$/g, "");+ host+ .toLowerCase()+ .replace(/^\[|\]$/g, "")+ .replace(/\.+$/u, "");const parseIpv4Address = (host: string): readonly number[] | null => {const parts = normalizeHostname(host).split(".").map(Number);@@ -18,28 +21,91 @@ const parseIpv4Address = (host: string): readonly number[] | null => {: null;};+const parseIpv4MappedIpv6Address = (host: string): readonly number[] | null => {+ const normalized = normalizeHostname(host);+ if (!normalized.startsWith("::ffff:")) return null;+ const suffix = normalized.slice("::ffff:".length);+ const dotted = parseIpv4Address(suffix);+ if (dotted) return dotted;+ const hextets = suffix.split(":");+ if (hextets.length !== 2 || hextets.some((part) => !/^[\da-f]{1,4}$/u.test(part))) return null;+ const high = Number.parseInt(hextets[0]!, 16);+ const low = Number.parseInt(hextets[1]!, 16);+ return [high >>> 8, high & 0xff, low >>> 8, low & 0xff];+};++const parseIpv6Address = (host: string): readonly number[] | null => {+ const normalized = normalizeHostname(host);+ if (!normalized.includes(":")) return null;+ const halves = normalized.split("::");+ if (halves.length > 2) return null;+ const head = halves[0] ? halves[0].split(":") : [];+ const tail = halves[1] ? halves[1].split(":") : [];+ if ([...head, ...tail].some((part) => !/^[\da-f]{1,4}$/u.test(part))) return null;+ const missing = 8 - head.length - tail.length;+ if ((halves.length === 1 && missing !== 0) || (halves.length === 2 && missing < 1)) return null;+ return [...head, ...Array.from({ length: missing }, () => "0"), ...tail].map((part) =>+ Number.parseInt(part, 16),+ );+};++const ipv6PrefixMatches = (+ address: readonly number[],+ prefix: readonly number[],+ prefixLength: number,+): boolean => {+ const fullHextets = Math.floor(prefixLength / 16);+ if (address.slice(0, fullHextets).some((part, index) => part !== prefix[index])) return false;+ const remainingBits = prefixLength % 16;+ if (remainingBits === 0) return true;+ const mask = (0xffff << (16 - remainingBits)) & 0xffff;+ return (address[fullHextets]! & mask) === (prefix[fullHextets]! & mask);+};++const isPrivateIpv4Address = (parts: readonly number[]): boolean =>+ parts[0] === 0 ||+ parts[0] === 10 ||+ parts[0] === 127 ||+ (parts[0] === 100 && parts[1]! >= 64 && parts[1]! <= 127) ||+ (parts[0] === 172 && parts[1]! >= 16 && parts[1]! <= 31) ||+ (parts[0] === 192 && parts[1] === 168) ||+ (parts[0] === 169 && parts[1] === 254) ||+ (parts[0] === 198 && parts[1]! >= 18 && parts[1]! <= 19);++const isSpecialPurposeIpv4Address = (parts: readonly number[]): boolean =>+ isPrivateIpv4Address(parts) ||+ parts[0]! >= 224 ||+ // Deliberately suppress the whole protocol-assignment block. IANA marks+ // .9 and .10 globally reachable, but privacy-safe false negatives are+ // preferable to disclosing another special-purpose address by mistake.+ (parts[0] === 192 && parts[1] === 0 && parts[2] === 0) ||+ (parts[0] === 192 && parts[1] === 0 && parts[2] === 2) ||+ (parts[0] === 192 && parts[1] === 88 && parts[2] === 99) ||+ (parts[0] === 198 && parts[1] === 51 && parts[2] === 100) ||+ (parts[0] === 203 && parts[1] === 0 && parts[2] === 113);+export const isLocalLoopbackHost = (host: string): boolean => {const normalized = normalizeHostname(host);if (normalized === "localhost" || normalized === "::1") return true;return parseIpv4Address(normalized)?.[0] === 127;};-const isPrivateNetworkHost = (host: string): boolean => {+export const isPrivateNetworkHost = (host: string): boolean => {const normalized = normalizeHostname(host);- if (isLocalLoopbackHost(normalized) || normalized.endsWith(".local")) {+ if (+ normalized === "::" ||+ isLocalLoopbackHost(normalized) ||+ normalized.endsWith(".localhost") ||+ normalized.endsWith(".local") ||+ normalized === "home.arpa" ||+ normalized.endsWith(".home.arpa") ||+ (!normalized.includes(".") && !normalized.includes(":"))+ ) {return true;}if (normalized.endsWith(".ts.net")) return true;- const parts = parseIpv4Address(normalized);- if (parts) {- return (- parts[0] === 10 ||- (parts[0] === 100 && parts[1]! >= 64 && parts[1]! <= 127) ||- (parts[0] === 172 && parts[1]! >= 16 && parts[1]! <= 31) ||- (parts[0] === 192 && parts[1] === 168) ||- (parts[0] === 169 && parts[1] === 254)- );- }+ const parts = parseIpv4Address(normalized) ?? parseIpv4MappedIpv6Address(normalized);+ if (parts) return isPrivateIpv4Address(parts);const firstIpv6Token = normalized.split(":", 1)[0] ?? "";if (!normalized.includes(":") || !/^[\da-f]{1,4}$/u.test(firstIpv6Token)) return false;const firstIpv6Hextet = Number.parseInt(firstIpv6Token, 16);@@ -49,6 +115,48 @@ const isPrivateNetworkHost = (host: string): boolean => {);};+/** Whether a hostname is eligible to be disclosed to a public favicon provider. */+export const isPublicFaviconHost = (host: string): boolean => {+ // A single trailing dot is a valid absolute DNS name. Repeated trailing+ // dots are malformed and can conceal legacy numeric forms such as 127.1.+ if (host.endsWith("..")) return false;+ const normalized = normalizeHostname(host);+ if (isPrivateNetworkHost(normalized)) return false;+ if (+ [".alt", ".example", ".internal", ".invalid", ".onion", ".test"].some(+ (suffix) => normalized === suffix.slice(1) || normalized.endsWith(suffix),+ )+ ) {+ return false;+ }+ const ipv4 = parseIpv4Address(normalized) ?? parseIpv4MappedIpv6Address(normalized);+ if (ipv4) return !isSpecialPurposeIpv4Address(ipv4);+ if (!normalized.includes(":")) return true;+ const ipv6 = parseIpv6Address(normalized);+ if (!ipv6) return false;+ if (ipv6PrefixMatches(ipv6, [0x0064, 0xff9b, 0, 0, 0, 0, 0, 0], 96)) {+ const embeddedIpv4 = [ipv6[6]! >>> 8, ipv6[6]! & 0xff, ipv6[7]! >>> 8, ipv6[7]! & 0xff];+ return !isSpecialPurposeIpv4Address(embeddedIpv4);+ }+ const first = ipv6[0]!;+ if ((first & 0xe000) !== 0x2000) return false;+ if (ipv6PrefixMatches(ipv6, [0x2001, 0, 0, 0, 0, 0, 0, 0], 23)) {+ const publicProtocolAssignment =+ (ipv6[1] === 1 &&+ ipv6.slice(2, 7).every((part) => part === 0) &&+ [1, 2, 3].includes(ipv6[7]!)) ||+ ipv6PrefixMatches(ipv6, [0x2001, 3, 0, 0, 0, 0, 0, 0], 32) ||+ ipv6PrefixMatches(ipv6, [0x2001, 4, 0x0112, 0, 0, 0, 0, 0], 48) ||+ ipv6PrefixMatches(ipv6, [0x2001, 0x20, 0, 0, 0, 0, 0, 0], 28) ||+ ipv6PrefixMatches(ipv6, [0x2001, 0x30, 0, 0, 0, 0, 0, 0], 28);+ return publicProtocolAssignment;+ }+ if (ipv6PrefixMatches(ipv6, [0x2001, 0x0db8, 0, 0, 0, 0, 0, 0], 32)) return false;+ if (ipv6PrefixMatches(ipv6, [0x2002, 0, 0, 0, 0, 0, 0, 0], 16)) return false;+ if (first === 0x3fff && (ipv6[1]! & 0xf000) === 0) return false;+ return true;+};+const readEnvironmentUrl = (environmentId: EnvironmentId): URL => {const connection = readPreparedConnection(environmentId);if (!connection) throw new Error(`Environment ${environmentId} is not connected.`);diff --git a/apps/web/src/browserFaviconLogic.test.ts b/apps/web/src/browserFaviconLogic.test.tsnew file mode 100644index 000000000..39ee76ef1--- /dev/null+++ b/apps/web/src/browserFaviconLogic.test.ts@@ -0,0 +1,124 @@+import { describe, expect, it } from "vite-plus/test";++import {+ BROWSER_FAVICON_MAX_ENTRIES,+ type BrowserFaviconEntry,+ evictExcessFavicons,+ faviconKey,+ faviconStorageLocation,+ isStorableFaviconDataUrl,+ migratePersistedBrowserFaviconState,+} from "./browserFaviconLogic";++const PNG = "data:image/png;base64,AAAA";++function entry(capturedAt = 0): BrowserFaviconEntry {+ return { dataUrl: PNG, capturedAt };+}++describe("browser favicon logic", () => {+ it("keys valid origins canonically while keeping distinct scopes separate", () => {+ expect(faviconKey("env:project", "http://myapp.test:3000/admin?x=1", null)).toBe(+ "env:project http://myapp.test:3000",+ );+ expect(faviconKey("env:project", "http://192.168.64.2:3000/", "192.168.64.2")).toBe(+ faviconKey("env:project", "http://localhost:3000/", "192.168.64.2"),+ );+ expect(faviconKey("env:project", "http://127.0.0.1:3000/", null)).toBe(+ faviconKey("env:project", "http://0.0.0.0:3000/", null),+ );+ const keys = [+ faviconKey("env:a", "http://localhost:3000/", null),+ faviconKey("env:b", "http://localhost:3000/", null),+ faviconKey("env:a", "http://localhost:5173/", null),+ faviconKey("env:a", "https://localhost:3000/", null),+ faviconKey("env:a", "http://192.168.1.50:3000/", "192.168.64.2"),+ ];+ expect(new Set(keys).size).toBe(keys.length);+ expect(faviconKey("env:a", "not a url", null)).toBeNull();+ expect(faviconKey("env:a", "ftp://example.com/", null)).toBeNull();+ expect(faviconKey("", "http://localhost/", null)).toBeNull();+ expect(faviconKey("env:a", "http://local:3000/", null)).not.toBe(+ faviconKey("env:a", "http://localhost:3000/", null),+ );+ });++ it("retains an exact environment-host alias for offline lookup", () => {+ const expected = {+ aliases: ["192.168.64.2"],+ key: "env:project http://localhost:3000",+ };+ expect(+ faviconStorageLocation("env:project", "http://localhost:3000/app", "192.168.64.2"),+ ).toEqual(expected);+ expect(+ faviconStorageLocation("env:project", "http://192.168.64.2:3000/app", "192.168.64.2"),+ ).toEqual(expected);+ expect(+ faviconStorageLocation("env:project", "https://example.com/app", "192.168.64.2"),+ ).toEqual({ aliases: [], key: "env:project https://example.com:443" });+ expect(faviconStorageLocation("env:project", "http://localhost:3000/app", "fd00::1")).toEqual({+ aliases: ["fd00::1"],+ key: "env:project http://localhost:3000",+ });+ expect(faviconKey("env:project", "http://[2001:4860:4860::8888]/", null)).toBe(+ "env:project http://[2001:4860:4860::8888]:80",+ );+ });++ it("accepts only bounded base64 PNG data", () => {+ expect(isStorableFaviconDataUrl(PNG)).toBe(true);+ expect(isStorableFaviconDataUrl("data:image/svg+xml;base64,AAAA")).toBe(false);+ expect(isStorableFaviconDataUrl("data:image/png;base64,")).toBe(false);+ expect(isStorableFaviconDataUrl("data:image/png;base64,%%%%")).toBe(false);+ expect(isStorableFaviconDataUrl(`data:image/png;base64,${"A".repeat(8192)}`)).toBe(false);+ });++ it("evicts old entries and sanitizes hydrated state", () => {+ const byKey = Object.fromEntries(+ Array.from({ length: BROWSER_FAVICON_MAX_ENTRIES + 2 }, (_, index) => [+ `key-${index}`,+ entry(index),+ ]),+ );+ const result = evictExcessFavicons(byKey);+ expect(Object.keys(result)).toHaveLength(BROWSER_FAVICON_MAX_ENTRIES);+ expect(result["key-0"]).toBeUndefined();+ expect(result["key-1"]).toBeUndefined();+ expect(+ migratePersistedBrowserFaviconState({+ byKey: {+ "env:project http://local:3000": entry(4),+ "env:project http://localhost:3000": entry(5),+ "env:project http://localhost:3003": {+ ...entry(6),+ aliases: [+ "192.168.64.2",+ "192.168.64.2",+ "192.168.64.3",+ "192.168.64.4",+ "192.168.64.5",+ "192.168.64.6",+ "Not Normalized",+ "not a host/",+ "x".repeat(5_000),+ ],+ },+ "env:project http://localhost:3001": {+ dataUrl: "https://example.com/icon.png",+ capturedAt: 6,+ },+ "env:project http://localhost:3002": { dataUrl: PNG, capturedAt: Number.NaN },+ },+ }),+ ).toEqual({+ byKey: {+ "env:project http://localhost:3000": entry(5),+ "env:project http://localhost:3003": {+ ...entry(6),+ aliases: ["192.168.64.2", "192.168.64.3", "192.168.64.4", "192.168.64.5"],+ },+ },+ });+ });+});diff --git a/apps/web/src/browserFaviconLogic.ts b/apps/web/src/browserFaviconLogic.tsnew file mode 100644index 000000000..695bcff20--- /dev/null+++ b/apps/web/src/browserFaviconLogic.ts@@ -0,0 +1,201 @@+import { FAVICON_CAPTURED_AT_MAX, FAVICON_DATA_URL_MAX_LENGTH } from "@t3tools/contracts";++import { isLocalLoopbackHost, normalizeHostname } from "./browser/browserTargetResolver";++export type BrowserFaviconEntry = {+ dataUrl: string;+ capturedAt: number;+ aliases?: ReadonlyArray<string>;+};++export const BROWSER_FAVICON_MAX_ENTRIES = 40;+export const BROWSER_FAVICON_MAX_KEY_LENGTH = 4_096;+const BROWSER_FAVICON_MAX_FUTURE_SKEW_MS = 5 * 60 * 1_000;+export const BROWSER_FAVICON_MAX_ALIASES_PER_ENTRY = 4;+const BROWSER_FAVICON_MAX_ALIAS_LENGTH = 255;++function formatFaviconHost(host: string): string {+ return host.includes(":") ? `[${host}]` : host;+}++export function canCanonicalizeFaviconWithoutEnvironment(url: string): boolean {+ try {+ const parsed = new URL(url);+ const host = normalizeHostname(parsed.hostname);+ return (+ (parsed.protocol === "http:" || parsed.protocol === "https:") &&+ (isLocalLoopbackHost(host) || host === "0.0.0.0")+ );+ } catch {+ return false;+ }+}++export function isValidFaviconCapturedAt(value: unknown): value is number {+ return (+ typeof value === "number" &&+ Number.isFinite(value) &&+ value >= 0 &&+ value <= FAVICON_CAPTURED_AT_MAX &&+ value <= Date.now() + BROWSER_FAVICON_MAX_FUTURE_SKEW_MS+ );+}++function migratePersistedFaviconKey(key: string): string | null {+ if (key.length === 0 || key.length > BROWSER_FAVICON_MAX_KEY_LENGTH) return null;+ const separator = key.indexOf(" ");+ if (separator <= 0) return null;+ const scope = key.slice(0, separator);+ const origin = key.slice(separator + 1);+ try {+ const parsed = new URL(origin);+ if (+ (parsed.protocol !== "http:" && parsed.protocol !== "https:") ||+ parsed.pathname !== "/" ||+ parsed.search !== "" ||+ parsed.hash !== "" ||+ parsed.username !== "" ||+ parsed.password !== ""+ )+ return null;+ if (normalizeHostname(parsed.hostname) !== "local") return key;+ const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80");+ return `${scope} ${parsed.protocol}//localhost:${port}`;+ } catch {+ return null;+ }+}++function persistedFaviconAlias(value: unknown): string | null {+ if (typeof value !== "string" || value.length > BROWSER_FAVICON_MAX_ALIAS_LENGTH) return null;+ const normalized = normalizeHostname(value);+ if (!normalized || normalized !== value) return null;+ try {+ const parsed = new URL(`http://${formatFaviconHost(normalized)}`);+ return normalizeHostname(parsed.hostname) === normalized ? normalized : null;+ } catch {+ return null;+ }+}++export function faviconKey(+ projectRefKey: string,+ url: string,+ environmentHostname: string | null,+): string | null {+ if (projectRefKey.length === 0) return null;+ try {+ const parsed = new URL(url);+ if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;+ const host = normalizeHostname(parsed.hostname);+ const canonicalHost =+ isLocalLoopbackHost(host) ||+ host === "0.0.0.0" ||+ (environmentHostname !== null && host === normalizeHostname(environmentHostname))+ ? "localhost"+ : host;+ const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80");+ return `${projectRefKey} ${parsed.protocol}//${formatFaviconHost(canonicalHost)}:${port}`;+ } catch {+ return null;+ }+}++export function faviconStorageLocation(+ projectRefKey: string,+ url: string,+ environmentHostname: string | null,+): { readonly aliases: ReadonlyArray<string>; readonly key: string } | null {+ const canonicalKey = faviconKey(projectRefKey, url, environmentHostname);+ if (!canonicalKey) return null;+ if (environmentHostname === null) return { aliases: [], key: canonicalKey };+ try {+ const parsed = new URL(url);+ const host = normalizeHostname(parsed.hostname);+ const normalizedEnvironmentHostname = normalizeHostname(environmentHostname);+ if (+ normalizedEnvironmentHostname.length === 0 ||+ (!isLocalLoopbackHost(host) && host !== "0.0.0.0" && host !== normalizedEnvironmentHostname)+ ) {+ return { aliases: [], key: canonicalKey };+ }+ return {+ aliases:+ isLocalLoopbackHost(normalizedEnvironmentHostname) ||+ normalizedEnvironmentHostname === "0.0.0.0"+ ? []+ : [normalizedEnvironmentHostname],+ key: canonicalKey,+ };+ } catch {+ return { aliases: [], key: canonicalKey };+ }+}++export function isStorableFaviconDataUrl(value: unknown): value is string {+ if (+ typeof value !== "string" ||+ !value.startsWith("data:image/png;base64,") ||+ value.length > FAVICON_DATA_URL_MAX_LENGTH+ ) {+ return false;+ }+ const payload = value.slice("data:image/png;base64,".length);+ return (+ payload.length > 0 &&+ payload.length % 4 !== 1 &&+ !/[^a-z0-9+/=]/i.test(payload) &&+ /^[a-z0-9+/]*={0,2}$/i.test(payload)+ );+}++export function evictExcessFavicons(+ byKey: Record<string, BrowserFaviconEntry>,+): Record<string, BrowserFaviconEntry> {+ const keys = Object.keys(byKey);+ if (keys.length <= BROWSER_FAVICON_MAX_ENTRIES) return byKey;+ return Object.fromEntries(+ keys+ .toSorted((left, right) => (byKey[right]?.capturedAt ?? 0) - (byKey[left]?.capturedAt ?? 0))+ .slice(0, BROWSER_FAVICON_MAX_ENTRIES)+ .map((key) => [key, byKey[key] as BrowserFaviconEntry]),+ );+}++export function migratePersistedBrowserFaviconState(persistedState: unknown): {+ byKey: Record<string, BrowserFaviconEntry>;+} {+ if (!persistedState || typeof persistedState !== "object") return { byKey: {} };+ const raw = "byKey" in persistedState ? (persistedState as { byKey?: unknown }).byKey : null;+ if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { byKey: {} };+ const byKey: Record<string, BrowserFaviconEntry> = {};+ for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {+ const migratedKey = migratePersistedFaviconKey(key);+ if (!migratedKey) continue;+ if (!value || typeof value !== "object") continue;+ const { dataUrl, capturedAt } = value as Record<string, unknown>;+ if (!isStorableFaviconDataUrl(dataUrl)) continue;+ if (!isValidFaviconCapturedAt(capturedAt)) continue;+ const rawAliases = (value as Record<string, unknown>).aliases;+ const aliases = Array.isArray(rawAliases)+ ? [...new Set(rawAliases.map(persistedFaviconAlias).filter((alias) => alias !== null))].slice(+ 0,+ BROWSER_FAVICON_MAX_ALIASES_PER_ENTRY,+ )+ : [];+ const existing = byKey[migratedKey];+ const newest = !existing || capturedAt > existing.capturedAt;+ const mergedAliases = [+ ...new Set([+ ...(newest ? aliases : (existing?.aliases ?? [])),+ ...(newest ? (existing?.aliases ?? []) : aliases),+ ]),+ ].slice(0, BROWSER_FAVICON_MAX_ALIASES_PER_ENTRY);+ byKey[migratedKey] = {+ dataUrl: newest ? dataUrl : existing.dataUrl,+ capturedAt: newest ? capturedAt : existing.capturedAt,+ ...(mergedAliases.length > 0 ? { aliases: mergedAliases } : {}),+ };+ }+ return { byKey: evictExcessFavicons(byKey) };+}diff --git a/apps/web/src/browserFaviconStore.test.ts b/apps/web/src/browserFaviconStore.test.tsnew file mode 100644index 000000000..8aef763dd--- /dev/null+++ b/apps/web/src/browserFaviconStore.test.ts@@ -0,0 +1,316 @@+import { scopeProjectRef } from "@t3tools/client-runtime/environment";+import { EnvironmentId, ProjectId, ThreadId } from "@t3tools/contracts";+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";++vi.mock("~/state/entities", () => ({ useThreadShell: () => null }));+vi.mock("~/state/session", () => ({ usePreparedConnection: () => ({ _tag: "None" }) }));++import {+ flushPendingFaviconsForThread,+ lookupFavicon,+ mergeBrowserFaviconState,+ recordFaviconForProject,+ recordFaviconForThread,+ registerFaviconProjectForThread,+ resetBrowserFaviconsForTests,+ resolveBrowserFaviconStorage,+ useBrowserFaviconStore,+} from "./browserFaviconStore";+import {+ BROWSER_FAVICON_MAX_ENTRIES,+ migratePersistedBrowserFaviconState,+} from "./browserFaviconLogic";++const environmentId = EnvironmentId.make("env-1");+const projectRef = scopeProjectRef(environmentId, ProjectId.make("project-1"));+const threadRef = { environmentId, threadId: ThreadId.make("thread-1") };+const PNG = "data:image/png;base64,AAAA";+const favicon = (pageUrl: string, capturedAt: number, dataUrl = PNG) => ({+ pageUrl,+ capturedAt,+ dataUrl,+});++describe("browser favicon store", () => {+ beforeEach(resetBrowserFaviconsForTests);+ afterEach(() => {+ vi.unstubAllGlobals();+ vi.restoreAllMocks();+ });++ it("keeps the newest capture for an origin and permits an identical later revisit", () => {+ const recordFavicon = vi.spyOn(useBrowserFaviconStore.getState(), "recordFavicon");+ recordFaviconForProject(projectRef, favicon("http://localhost:3000/", 20), null);+ recordFaviconForProject(+ projectRef,+ favicon("http://localhost:3000/old", 10, "data:image/png;base64,QkJCQg=="),+ null,+ );+ recordFaviconForProject(projectRef, favicon("http://localhost:3000/new", 30), null);+ recordFaviconForProject(projectRef, favicon("http://localhost:3000/new", 30), null);+ expect(Object.values(useBrowserFaviconStore.getState().byKey)).toEqual([+ { dataUrl: PNG, capturedAt: 30 },+ ]);+ expect(recordFavicon).toHaveBeenCalledTimes(2);+ });++ it("does not share localhost icons across environments or physical projects", () => {+ const otherEnvironment = scopeProjectRef(+ EnvironmentId.make("env-2"),+ ProjectId.make("project-1"),+ );+ const otherProject = scopeProjectRef(environmentId, ProjectId.make("project-2"));+ recordFaviconForProject(projectRef, favicon("http://localhost:3000/", 1), null);+ recordFaviconForProject(otherEnvironment, favicon("http://localhost:3000/", 2), null);+ recordFaviconForProject(otherProject, favicon("http://localhost:3000/", 3), null);+ expect(Object.keys(useBrowserFaviconStore.getState().byKey)).toEqual([+ "env-1:project-1 http://localhost:3000",+ "env-2:project-1 http://localhost:3000",+ "env-1:project-2 http://localhost:3000",+ ]);+ });++ it("finds a persisted environment icon after shell hydration without a live connection", () => {+ recordFaviconForProject(projectRef, favicon("http://192.168.64.2:3000/app", 5), "192.168.64.2");+ const byKey = useBrowserFaviconStore.getState().byKey;+ expect(lookupFavicon(byKey, null, "http://localhost:3000/app", null)).toBeNull();+ expect(lookupFavicon(byKey, projectRef, "http://localhost:3000/app", null)).toBe(PNG);+ expect(lookupFavicon(byKey, projectRef, "http://192.168.64.2:3000/app", null)).toBe(PNG);+ expect(lookupFavicon(byKey, projectRef, "http://192.168.64.3:3000/app", null)).toBeNull();+ expect(lookupFavicon(byKey, projectRef, "https://192.168.64.2:3000/app", null)).toBeNull();+ expect(lookupFavicon(byKey, projectRef, "http://192.168.64.2:3001/app", null)).toBeNull();+ expect(+ lookupFavicon(+ byKey,+ scopeProjectRef(environmentId, ProjectId.make("project-2")),+ "http://192.168.64.2:3000/app",+ null,+ ),+ ).toBeNull();+ });++ it("finds a persisted IPv6 environment icon without a live connection", () => {+ recordFaviconForProject(projectRef, favicon("http://[fd00::1]:3000/app", 5), "fd00::1");+ const migrated = migratePersistedBrowserFaviconState({+ byKey: useBrowserFaviconStore.getState().byKey,+ }).byKey;+ expect(lookupFavicon(migrated, projectRef, "http://[fd00::1]:3000/app", null)).toBe(PNG);+ });++ it("keeps exact host aliases attached to the newest canonical icon", () => {+ const olderPng = "data:image/png;base64,QkJCQg==";+ const newerPng = "data:image/png;base64,Q0NDQw==";+ recordFaviconForProject(+ projectRef,+ favicon("http://192.168.64.2:3000/", 10, olderPng),+ "192.168.64.2",+ );+ recordFaviconForProject(+ projectRef,+ favicon("http://192.168.64.3:3000/", 20, newerPng),+ "192.168.64.3",+ );+ recordFaviconForProject(+ projectRef,+ favicon("http://192.168.64.4:3000/", 15, olderPng),+ "192.168.64.4",+ );+ const byKey = useBrowserFaviconStore.getState().byKey;+ for (const host of ["192.168.64.2", "192.168.64.3", "192.168.64.4"]) {+ expect(lookupFavicon(byKey, projectRef, `http://${host}:3000/`, null)).toBe(newerPng);+ }+ expect(byKey["env-1:project-1 http://localhost:3000"]?.capturedAt).toBe(20);+ });++ it("evicts an icon and its exact host aliases atomically", () => {+ recordFaviconForProject(projectRef, favicon("http://192.168.64.2:3000/", 100), "192.168.64.2");+ for (let index = 1; index < BROWSER_FAVICON_MAX_ENTRIES; index += 1) {+ recordFaviconForProject(+ projectRef,+ favicon(`https://example-${index}.com/`, 100 + index),+ null,+ );+ }+ expect(+ lookupFavicon(+ useBrowserFaviconStore.getState().byKey,+ projectRef,+ "http://192.168.64.2:3000/",+ null,+ ),+ ).toBe(PNG);++ recordFaviconForProject(projectRef, favicon("https://evicts-oldest.example/", 1_000), null);+ expect(+ lookupFavicon(+ useBrowserFaviconStore.getState().byKey,+ projectRef,+ "http://192.168.64.2:3000/",+ null,+ ),+ ).toBeNull();+ });++ it("retains multiple origins until project and connection metadata hydrate", () => {+ expect(+ recordFaviconForThread(threadRef, favicon("http://localhost:3000/", 1), null, undefined),+ ).toBe(false);+ expect(+ recordFaviconForThread(threadRef, favicon("http://localhost:5173/", 2), null, undefined),+ ).toBe(false);+ expect(+ Object.keys(Object.values(useBrowserFaviconStore.getState().pendingByThreadKey)[0] ?? {}),+ ).toHaveLength(2);++ expect(flushPendingFaviconsForThread(threadRef, projectRef, "192.168.64.2")).toBe(true);+ expect(Object.keys(useBrowserFaviconStore.getState().byKey).toSorted()).toEqual([+ "env-1:project-1 http://localhost:3000",+ "env-1:project-1 http://localhost:5173",+ ]);+ expect(useBrowserFaviconStore.getState().pendingByThreadKey).toEqual({});+ });++ it("persists unambiguous loopback captures while the environment is offline", () => {+ expect(+ recordFaviconForThread(+ threadRef,+ favicon("http://localhost:3000/", 1),+ projectRef,+ undefined,+ ),+ ).toBe(true);+ expect(useBrowserFaviconStore.getState().byKey).toEqual({+ "env-1:project-1 http://localhost:3000": { dataUrl: PNG, capturedAt: 1 },+ });++ recordFaviconForThread(+ threadRef,+ favicon("http://192.168.64.2:5173/", 2),+ projectRef,+ undefined,+ );+ expect(flushPendingFaviconsForThread(threadRef, projectRef, undefined)).toBe(false);+ expect(Object.values(useBrowserFaviconStore.getState().pendingByThreadKey)[0]).toBeDefined();+ });++ it("keeps pending captures in store-owned state independent of bridge lifetime", () => {+ recordFaviconForThread(threadRef, favicon("http://localhost:3000/", 10), null, undefined);+ const pendingAfterUnmount = useBrowserFaviconStore.getState().pendingByThreadKey;+ useBrowserFaviconStore.setState({ pendingByThreadKey: pendingAfterUnmount });+ flushPendingFaviconsForThread(threadRef, projectRef, "localhost");+ expect(useBrowserFaviconStore.getState().byKey).toEqual({+ "env-1:project-1 http://localhost:3000": { dataUrl: PNG, capturedAt: 10 },+ });+ });++ it("flushes and resolves a pending draft-thread favicon after physical project registration", () => {+ recordFaviconForThread(threadRef, favicon("http://localhost:8025/", 10), null, undefined);+ registerFaviconProjectForThread(threadRef, projectRef);+ const registered = useBrowserFaviconStore.getState().projectRefByThreadKey["env-1:thread-1"];+ expect(registered).toEqual(projectRef);+ expect(flushPendingFaviconsForThread(threadRef, registered!, undefined)).toBe(true);+ expect(+ lookupFavicon(+ useBrowserFaviconStore.getState().byKey,+ registered!,+ "http://localhost:8025/",+ null,+ ),+ ).toBe(PNG);+ });++ it("bounds pending memory by origin and thread", () => {+ for (let thread = 0; thread < 22; thread += 1) {+ for (let port = 3000; port < 3012; port += 1) {+ recordFaviconForThread(+ { environmentId, threadId: ThreadId.make(`thread-${thread}`) },+ favicon(`http://localhost:${port}/`, port),+ null,+ undefined,+ );+ }+ }+ const pending = useBrowserFaviconStore.getState().pendingByThreadKey;+ expect(Object.keys(pending)).toHaveLength(20);+ expect(Object.values(pending).every((byOrigin) => Object.keys(byOrigin).length === 10)).toBe(+ true,+ );+ });++ it("sanitizes hydrated state while preserving actions and transient pending data", () => {+ recordFaviconForThread(threadRef, favicon("http://localhost:3000/", 1), null, undefined);+ const current = useBrowserFaviconStore.getState();+ const merged = mergeBrowserFaviconState(+ {+ byKey: {+ "env-1:project-1 http://localhost:3000": { dataUrl: PNG, capturedAt: 2 },+ "env-1:project-1 http://localhost:3001": { dataUrl: "bad", capturedAt: 3 },+ "env-1:project-1 http://localhost:3002": { dataUrl: PNG, capturedAt: 1e308 },+ ["x".repeat(5_000)]: { dataUrl: PNG, capturedAt: 4 },+ },+ },+ current,+ );+ expect(merged.byKey).toEqual({+ "env-1:project-1 http://localhost:3000": { dataUrl: PNG, capturedAt: 2 },+ });+ expect(merged.pendingByThreadKey).toEqual(current.pendingByThreadKey);+ expect(typeof merged.recordFavicon).toBe("function");+ });++ it("falls back to memory when localStorage access throws", () => {+ vi.stubGlobal(+ "window",+ Object.defineProperty({}, "localStorage", {+ get: () => {+ throw new Error("storage blocked");+ },+ }),+ );+ const storage = resolveBrowserFaviconStorage();+ storage.setItem("key", "value");+ expect(storage.getItem("key")).toBe("value");+ });++ it("falls back to memory when localStorage operations throw", () => {+ vi.stubGlobal("window", {+ localStorage: {+ getItem: vi.fn(() => {+ throw new Error("read blocked");+ }),+ setItem: vi.fn(() => {+ throw new Error("quota exceeded");+ }),+ removeItem: vi.fn(() => {+ throw new Error("remove blocked");+ }),+ },+ });+ const storage = resolveBrowserFaviconStorage();++ storage.setItem("key", "value");+ expect(storage.getItem("key")).toBe("value");+ storage.removeItem("key");+ expect(storage.getItem("key")).toBeNull();+ });++ it("keeps the memory shadow authoritative after an asymmetric primary write failure", () => {+ vi.stubGlobal("window", {+ localStorage: {+ getItem: vi.fn(() => "stale"),+ setItem: vi.fn(() => {+ throw new Error("quota exceeded");+ }),+ removeItem: vi.fn(() => {+ throw new Error("remove blocked");+ }),+ },+ });+ const storage = resolveBrowserFaviconStorage();++ storage.setItem("key", "fresh");+ expect(storage.getItem("key")).toBe("fresh");+ storage.removeItem("key");+ expect(storage.getItem("key")).toBeNull();+ });+});diff --git a/apps/web/src/browserFaviconStore.ts b/apps/web/src/browserFaviconStore.tsnew file mode 100644index 000000000..3354cea50--- /dev/null+++ b/apps/web/src/browserFaviconStore.ts@@ -0,0 +1,342 @@+import {+ scopedProjectKey,+ scopedThreadKey,+ scopeProjectRef,+} from "@t3tools/client-runtime/environment";+import type { DesktopPreviewFavicon, ScopedProjectRef, ScopedThreadRef } from "@t3tools/contracts";+import * as Option from "effect/Option";+import { useMemo } from "react";+import { create } from "zustand";+import { createJSONStorage, persist } from "zustand/middleware";++import { normalizeHostname } from "~/browser/browserTargetResolver";+import { useThreadShell } from "~/state/entities";+import { usePreparedConnection } from "~/state/session";++import {+ BROWSER_FAVICON_MAX_ALIASES_PER_ENTRY,+ type BrowserFaviconEntry,+ canCanonicalizeFaviconWithoutEnvironment,+ evictExcessFavicons,+ faviconKey,+ faviconStorageLocation,+ isStorableFaviconDataUrl,+ isValidFaviconCapturedAt,+ migratePersistedBrowserFaviconState,+} from "./browserFaviconLogic";+import { createMemoryStorage, type StateStorage } from "./lib/storage";++const BROWSER_FAVICON_STORAGE_KEY = "t3code:browser-favicons:v1";+const MAX_PENDING_ORIGINS_PER_THREAD = 10;+const MAX_PENDING_THREADS = 20;+const MAX_REGISTERED_THREADS = 100;++type PendingFavicon = DesktopPreviewFavicon;+type PendingFaviconsByOrigin = Record<string, PendingFavicon>;++export interface BrowserFaviconStoreState {+ byKey: Record<string, BrowserFaviconEntry>;+ /** Capture buffering only. */+ pendingByThreadKey: Record<string, PendingFaviconsByOrigin>;+ /** Non-persisted fallback for draft/background threads without a hydrated shell. */+ projectRefByThreadKey: Record<string, ScopedProjectRef>;+ recordFavicon: (+ key: string,+ dataUrl: string,+ capturedAt: number,+ aliases?: ReadonlyArray<string>,+ ) => void;+}++function pendingOriginKey(pageUrl: string): string | null {+ return faviconKey("pending", pageUrl, null)?.slice("pending ".length) ?? null;+}++function addPendingFavicon(+ pendingByThreadKey: Record<string, PendingFaviconsByOrigin>,+ threadKey: string,+ favicon: PendingFavicon,+): Record<string, PendingFaviconsByOrigin> {+ const originKey = pendingOriginKey(favicon.pageUrl);+ if (!originKey) return pendingByThreadKey;+ const current = pendingByThreadKey[threadKey] ?? {};+ const existing = current[originKey];+ if (existing && existing.capturedAt >= favicon.capturedAt) return pendingByThreadKey;+ const nextForThread = {+ ...current,+ [originKey]: favicon,+ };+ const boundedForThread = Object.fromEntries(+ Object.entries(nextForThread)+ .toSorted(([, left], [, right]) => right.capturedAt - left.capturedAt)+ .slice(0, MAX_PENDING_ORIGINS_PER_THREAD),+ );++ const withoutThread = { ...pendingByThreadKey };+ delete withoutThread[threadKey];+ return Object.fromEntries(+ [...Object.entries(withoutThread), [threadKey, boundedForThread]].slice(-MAX_PENDING_THREADS),+ );+}++export function resolveBrowserFaviconStorage(): StateStorage {+ const fallback = createMemoryStorage();+ const shadowedNames = new Set<string>();+ let primary: Storage;+ try {+ if (typeof window === "undefined") return fallback;+ primary = window.localStorage;+ } catch {+ return fallback;+ }+ return {+ getItem: (name) => {+ if (shadowedNames.has(name)) return fallback.getItem(name);+ try {+ return primary.getItem(name);+ } catch {+ return fallback.getItem(name);+ }+ },+ setItem: (name, value) => {+ fallback.setItem(name, value);+ try {+ primary.setItem(name, value);+ shadowedNames.delete(name);+ } catch {+ shadowedNames.add(name);+ }+ },+ removeItem: (name) => {+ fallback.removeItem(name);+ try {+ primary.removeItem(name);+ shadowedNames.delete(name);+ } catch {+ shadowedNames.add(name);+ }+ },+ };+}++export const useBrowserFaviconStore = create<BrowserFaviconStoreState>()(+ persist(+ (set) => ({+ byKey: {},+ pendingByThreadKey: {},+ projectRefByThreadKey: {},+ recordFavicon: (key, dataUrl, capturedAt, aliases = []) =>+ set((state) => {+ if (!isStorableFaviconDataUrl(dataUrl)) return state;+ if (!isValidFaviconCapturedAt(capturedAt)) return state;+ const existing = state.byKey[key];+ const aliasCandidates =+ capturedAt > (existing?.capturedAt ?? -1)+ ? [...aliases, ...(existing?.aliases ?? [])]+ : [...(existing?.aliases ?? []), ...aliases];+ const nextAliases = [...new Set(aliasCandidates)].slice(+ 0,+ BROWSER_FAVICON_MAX_ALIASES_PER_ENTRY,+ );+ const aliasesUnchanged =+ nextAliases.length === (existing?.aliases?.length ?? 0) &&+ nextAliases.every((alias, index) => alias === existing?.aliases?.[index]);+ if (existing && capturedAt <= existing.capturedAt && aliasesUnchanged) return state;+ return {+ byKey: evictExcessFavicons({+ ...state.byKey,+ [key]: {+ dataUrl: capturedAt > (existing?.capturedAt ?? -1) ? dataUrl : existing!.dataUrl,+ capturedAt: Math.max(capturedAt, existing?.capturedAt ?? -1),+ ...(nextAliases.length > 0 ? { aliases: nextAliases } : {}),+ },+ }),+ };+ }),+ }),+ {+ name: BROWSER_FAVICON_STORAGE_KEY,+ version: 1,+ storage: createJSONStorage(resolveBrowserFaviconStorage),+ partialize: (state) => ({ byKey: state.byKey }),+ migrate: migratePersistedBrowserFaviconState,+ merge: mergeBrowserFaviconState,+ },+ ),+);++export function mergeBrowserFaviconState(+ persistedState: unknown,+ currentState: BrowserFaviconStoreState,+): BrowserFaviconStoreState {+ return {+ ...currentState,+ ...migratePersistedBrowserFaviconState(persistedState),+ };+}++export function registerFaviconProjectForThread(+ threadRef: ScopedThreadRef,+ projectRef: ScopedProjectRef,+): void {+ const threadKey = scopedThreadKey(threadRef);+ const state = useBrowserFaviconStore.getState();+ const current = state.projectRefByThreadKey[threadKey];+ if (+ current?.environmentId === projectRef.environmentId &&+ current.projectId === projectRef.projectId+ ) {+ return;+ }+ useBrowserFaviconStore.setState({+ projectRefByThreadKey: Object.fromEntries(+ [+ ...Object.entries(state.projectRefByThreadKey).filter(([key]) => key !== threadKey),+ [threadKey, projectRef],+ ].slice(-MAX_REGISTERED_THREADS),+ ),+ });+}++export function useFaviconProjectRefForThread(threadRef: ScopedThreadRef): ScopedProjectRef | null {+ const shell = useThreadShell(threadRef);+ const shellProjectId = shell?.projectId ?? null;+ const shellProjectRef = useMemo(+ () => (shellProjectId ? scopeProjectRef(threadRef.environmentId, shellProjectId) : null),+ [shellProjectId, threadRef.environmentId],+ );+ const registered = useBrowserFaviconStore(+ (state) => state.projectRefByThreadKey[scopedThreadKey(threadRef)] ?? null,+ );+ return shellProjectRef ?? registered;+}++export function recordFaviconForProject(+ projectRef: ScopedProjectRef,+ favicon: DesktopPreviewFavicon,+ environmentHostname: string | null,+): boolean {+ if (!isStorableFaviconDataUrl(favicon.dataUrl) || !isValidFaviconCapturedAt(favicon.capturedAt)) {+ return false;+ }+ const location = faviconStorageLocation(+ scopedProjectKey(projectRef),+ favicon.pageUrl,+ environmentHostname,+ );+ if (!location) return false;+ const state = useBrowserFaviconStore.getState();+ const existing = state.byKey[location.key];+ if (+ existing &&+ existing.capturedAt >= favicon.capturedAt &&+ location.aliases.every((alias) => existing.aliases?.includes(alias))+ )+ return true;+ state.recordFavicon(location.key, favicon.dataUrl, favicon.capturedAt, location.aliases);+ return true;+}++export function recordFaviconForThread(+ threadRef: ScopedThreadRef,+ favicon: DesktopPreviewFavicon,+ projectRef: ScopedProjectRef | null,+ environmentHostname: string | undefined,+): boolean {+ if (+ !isStorableFaviconDataUrl(favicon.dataUrl) ||+ !isValidFaviconCapturedAt(favicon.capturedAt) ||+ !pendingOriginKey(favicon.pageUrl)+ )+ return false;+ const hostname =+ environmentHostname !== undefined+ ? environmentHostname+ : canCanonicalizeFaviconWithoutEnvironment(favicon.pageUrl)+ ? null+ : undefined;+ if (+ projectRef &&+ hostname !== undefined &&+ recordFaviconForProject(projectRef, favicon, hostname)+ ) {+ return true;+ }+ const threadKey = scopedThreadKey(threadRef);+ const state = useBrowserFaviconStore.getState();+ const pendingByThreadKey = addPendingFavicon(state.pendingByThreadKey, threadKey, favicon);+ if (pendingByThreadKey !== state.pendingByThreadKey) {+ useBrowserFaviconStore.setState({ pendingByThreadKey });+ }+ return false;+}++export function flushPendingFaviconsForThread(+ threadRef: ScopedThreadRef,+ projectRef: ScopedProjectRef,+ environmentHostname: string | undefined,+): boolean {+ const threadKey = scopedThreadKey(threadRef);+ const pending = useBrowserFaviconStore.getState().pendingByThreadKey[threadKey];+ if (!pending) return true;+ const remaining = Object.fromEntries(+ Object.entries(pending).filter(([, favicon]) => {+ const hostname =+ environmentHostname !== undefined+ ? environmentHostname+ : canCanonicalizeFaviconWithoutEnvironment(favicon.pageUrl)+ ? null+ : undefined;+ return hostname === undefined || !recordFaviconForProject(projectRef, favicon, hostname);+ }),+ );+ useBrowserFaviconStore.setState((state) => {+ const pendingByThreadKey = { ...state.pendingByThreadKey };+ if (Object.keys(remaining).length === 0) delete pendingByThreadKey[threadKey];+ else pendingByThreadKey[threadKey] = remaining;+ return { pendingByThreadKey };+ });+ return Object.keys(remaining).length === 0;+}++export function useFaviconForThreadUrl(threadRef: ScopedThreadRef, url: string): string | null {+ const projectRef = useFaviconProjectRefForThread(threadRef);+ const preparedConnection = usePreparedConnection(threadRef.environmentId);+ const environmentHostname = Option.isSome(preparedConnection)+ ? new URL(preparedConnection.value.httpBaseUrl).hostname+ : null;+ return useBrowserFaviconStore((state) =>+ lookupFavicon(state.byKey, projectRef, url, environmentHostname),+ );+}++export function lookupFavicon(+ byKey: Record<string, BrowserFaviconEntry>,+ projectRef: ScopedProjectRef | null,+ url: string,+ environmentHostname: string | null,+): string | null {+ const key = projectRef+ ? faviconKey(scopedProjectKey(projectRef), url, environmentHostname)+ : null;+ if (!key) return null;+ const direct = byKey[key];+ if (direct) return direct.dataUrl;+ try {+ const requestedHost = normalizeHostname(new URL(url).hostname);+ const localKey = faviconKey(scopedProjectKey(projectRef!), url, requestedHost);+ const localEntry = localKey ? byKey[localKey] : null;+ return localEntry?.aliases?.includes(requestedHost) ? localEntry.dataUrl : null;+ } catch {+ return null;+ }+}++export function resetBrowserFaviconsForTests(): void {+ useBrowserFaviconStore.setState({+ byKey: {},+ pendingByThreadKey: {},+ projectRefByThreadKey: {},+ });+ useBrowserFaviconStore.persist.clearStorage();+}diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex fdc7e7dee..e459d6d09 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -179,6 +179,7 @@ import {} from "~/projectScripts";import { newDraftId, newMessageId, newThreadId } from "~/lib/utils";import { useBrowserHistoryStore } from "~/browserHistoryStore";+import { registerFaviconProjectForThread } from "~/browserFaviconStore";import { getProviderModelCapabilities, resolveSelectableProvider } from "../providerModels";import { NO_PROVIDER_MODEL_SELECTION } from "../providerInstances";import {@@ -1704,9 +1705,11 @@ function ChatViewContent(props: ChatViewProps) {});}, [activeThreadKey, existingOpenTerminalThreadKeys, terminalUiState.terminalOpen]);const latestTurnSettled = isLatestTurnSettled(activeLatestTurn, activeThread?.session ?? null);- const activeProjectRef = activeThread- ? scopeProjectRef(activeThread.environmentId, activeThread.projectId)- : null;+ const activeProjectRef = useMemo(+ () =>+ activeThread ? scopeProjectRef(activeThread.environmentId, activeThread.projectId) : null,+ [activeThread?.environmentId, activeThread?.projectId],+ );const activeProject = useProject(activeProjectRef);const handleNewThreadInActiveProject = useCallback(() => {startNewThreadForProject(activeProjectRef, handleNewThread);@@ -1758,6 +1761,10 @@ function ChatViewContent(props: ChatViewProps) {// drive the environment picker in BranchToolbar.const allProjects = useProjects();const primaryEnvironmentId = primaryEnvironment?.environmentId ?? null;+ useEffect(() => {+ if (!activeThreadRef || !activeProjectRef) return;+ registerFaviconProjectForThread(activeThreadRef, activeProjectRef);+ }, [activeProjectRef, activeThreadRef]);useEffect(() => {if (!clientSettingsHydrated || !activeThreadRef || !activeProject) return;// Reuse the sidebar's grouping so history follows the project rows the user@@ -6546,6 +6553,7 @@ function ChatViewContent(props: ChatViewProps) {activeSurfaceId={activeRightPanelSurface?.id ?? null}pendingSurfaceIds={pendingFileSurfaceIds}previewSessions={activePreviewState.sessions}+ desktopByTabId={activePreviewState.desktopByTabId}terminalLabelsById={activeTerminalLabelsById}onActivate={activateRightPanelSurface}onCloseSurface={closeRightPanelSurface}@@ -6580,6 +6588,7 @@ function ChatViewContent(props: ChatViewProps) {activeSurfaceId={activeRightPanelSurface?.id ?? null}pendingSurfaceIds={pendingFileSurfaceIds}previewSessions={activePreviewState.sessions}+ desktopByTabId={activePreviewState.desktopByTabId}terminalLabelsById={activeTerminalLabelsById}onActivate={activateRightPanelSurface}onCloseSurface={closeRightPanelSurface}diff --git a/apps/web/src/components/RightPanelTabs.test.tsx b/apps/web/src/components/RightPanelTabs.test.tsxnew file mode 100644index 000000000..7312f0b8c--- /dev/null+++ b/apps/web/src/components/RightPanelTabs.test.tsx@@ -0,0 +1,115 @@+import type { DesktopPreviewFavicon, PreviewSessionSnapshot } from "@t3tools/contracts";+import { renderToStaticMarkup } from "react-dom/server";+import { describe, expect, it } from "vite-plus/test";++import { RightPanelTabs } from "./RightPanelTabs";++const previewSurface = {+ id: "browser:tab-1" as const,+ kind: "preview" as const,+ resourceId: "tab-1",+};+const secondSurface = {+ id: "browser:tab-2" as const,+ kind: "preview" as const,+ resourceId: "tab-2",+};+const sessions: Readonly<Record<string, PreviewSessionSnapshot>> = {+ "tab-1": {+ threadId: "thread-1",+ tabId: "tab-1",+ navStatus: { _tag: "Success", url: "http://24x.xf.local/", title: "Local site" },+ canGoBack: false,+ canGoForward: false,+ updatedAt: "2026-08-09T00:00:00.000Z",+ },+ "tab-2": {+ threadId: "thread-1",+ tabId: "tab-2",+ navStatus: { _tag: "Success", url: "http://24x.xf.local/admin", title: "Admin" },+ canGoBack: false,+ canGoForward: false,+ updatedAt: "2026-08-09T00:00:00.000Z",+ },+};++const favicon = (dataUrl: string, pageUrl: string): DesktopPreviewFavicon => ({+ dataUrl,+ pageUrl,+ capturedAt: 1,+});++function overlay(icon: DesktopPreviewFavicon | null) {+ return {+ hasWebContents: true,+ canGoBack: false,+ canGoForward: false,+ loading: false,+ zoomFactor: 1,+ pictureInPicture: false,+ colorScheme: "system" as const,+ controller: "none" as const,+ favicon: icon,+ };+}++function renderTabs(first: DesktopPreviewFavicon | null, second?: DesktopPreviewFavicon) {+ return renderToStaticMarkup(+ <RightPanelTabs+ mode="inline"+ surfaces={second ? [previewSurface, secondSurface] : [previewSurface]}+ activeSurfaceId={previewSurface.id}+ pendingSurfaceIds={new Set()}+ previewSessions={sessions}+ desktopByTabId={{+ "tab-1": overlay(first),+ ...(second ? { "tab-2": overlay(second) } : {}),+ }}+ terminalLabelsById={new Map()}+ onActivate={() => undefined}+ onCloseSurface={() => undefined}+ onCloseOtherSurfaces={() => undefined}+ onCloseSurfacesToRight={() => undefined}+ onCloseAllSurfaces={() => undefined}+ onCopyFilePath={() => undefined}+ onAddBrowser={() => undefined}+ onAddTerminal={() => undefined}+ onAddPullRequest={() => undefined}+ onAddDiff={() => undefined}+ onAddFiles={() => undefined}+ onAddAgents={() => undefined}+ liveAgentCount={0}+ browserAvailable+ terminalAvailable={false}+ diffAvailable={false}+ filesAvailable={false}+ pullRequestAvailable={false}+ agentsAvailable={false}+ >+ <div>content</div>+ </RightPanelTabs>,+ );+}++describe("RightPanelTabs preview favicon", () => {+ it("prefers a live capture and never asks Google about a private hostname", () => {+ const captured = renderTabs(favicon("data:image/png;base64,AAAA", "http://24x.xf.local/"));+ expect(captured).toContain("data:image/png;base64,AAAA");+ expect(captured).not.toContain("s2/favicons");+ expect(renderTabs(null)).not.toContain("s2/favicons");+ });++ it("keeps route-specific captures isolated between live tabs on one origin", () => {+ const html = renderTabs(+ favicon("data:image/png;base64,AAAA", "http://24x.xf.local/"),+ favicon("data:image/png;base64,BBBB", "http://24x.xf.local/admin"),+ );+ expect(html).toContain("data:image/png;base64,AAAA");+ expect(html).toContain("data:image/png;base64,BBBB");+ });++ it("hides a capture while the server session still describes another origin", () => {+ const html = renderTabs(favicon("data:image/png;base64,AAAA", "https://example.com/"));+ expect(html).not.toContain("data:image/png;base64,AAAA");+ });+});diff --git a/apps/web/src/components/RightPanelTabs.tsx b/apps/web/src/components/RightPanelTabs.tsxindex 32c66dca6..21abd873c 100644--- a/apps/web/src/components/RightPanelTabs.tsx+++ b/apps/web/src/components/RightPanelTabs.tsx@@ -22,6 +22,7 @@ import {} from "react";import { isElectron } from "~/env";+import type { DesktopPreviewOverlay } from "~/previewStateStore";import type { RightPanelSurface } from "~/rightPanelStore";import { cn } from "~/lib/utils";import { readLocalApi } from "~/localApi";@@ -34,6 +35,7 @@ import { useTheme } from "~/hooks/useTheme";import { COLLAPSED_SIDEBAR_TITLEBAR_INSET_CLASS } from "~/workspaceTitlebar";import { PreviewPanelShell, type PreviewPanelMode } from "./preview/PreviewPanelShell";+import { FaviconImage } from "./preview/PreviewFaviconIcon";import { PierreEntryIcon } from "./chat/PierreEntryIcon";interface RightPanelTabsProps {@@ -48,6 +50,7 @@ interface RightPanelTabsProps {activeSurfaceId: string | null;pendingSurfaceIds: ReadonlySet<string>;previewSessions: Readonly<Record<string, PreviewSessionSnapshot>>;+ desktopByTabId: Readonly<Record<string, DesktopPreviewOverlay>>;terminalLabelsById: ReadonlyMap<string, string>;onActivate: (surface: RightPanelSurface) => void;onCloseSurface: (surface: RightPanelSurface) => void;@@ -435,30 +438,35 @@ function surfaceTitle(}}-function PreviewFavicon({ url }: { url: string | null }) {- const faviconUrl = faviconUrlForOrigin(url, 32);- const [failedUrl, setFailedUrl] = useState<string | null>(null);- if (!faviconUrl || failedUrl === faviconUrl) return <Globe2 className="size-3 shrink-0" />;+function PreviewFavicon({ capturedUrl, url }: { capturedUrl: string | null; url: string | null }) {+ const publicProviderUrl = faviconUrlForOrigin(url, 32);return (- <img- src={faviconUrl}- alt=""- aria-hidden- draggable={false}- className="size-3 shrink-0 rounded-sm"- onError={() => setFailedUrl(faviconUrl)}+ <FaviconImage+ sources={[capturedUrl, publicProviderUrl]}+ fallback={<Globe2 className="size-3 shrink-0" />}+ className="size-3 shrink-0 rounded-sm object-contain"/>);}+function sameOrigin(left: string, right: string): boolean {+ try {+ return new URL(left).origin === new URL(right).origin;+ } catch {+ return false;+ }+}+function SurfaceIcon({surface,sessions,+ desktopByTabId,theme,pullRequestStatuses,}: {surface: RightPanelSurface;sessions: Readonly<Record<string, PreviewSessionSnapshot>>;+ desktopByTabId: Readonly<Record<string, DesktopPreviewOverlay>>;theme: "light" | "dark";pullRequestStatuses: Readonly<Record<string, PullRequestTabStatus>> | undefined;}) {@@ -466,7 +474,10 @@ function SurfaceIcon({case "preview": {const snapshot = surface.resourceId ? sessions[surface.resourceId] : null;const url = !snapshot || snapshot.navStatus._tag === "Idle" ? null : snapshot.navStatus.url;- return <PreviewFavicon url={url} />;+ const favicon = snapshot ? (desktopByTabId[snapshot.tabId]?.favicon ?? null) : null;+ const capturedUrl =+ favicon && url && sameOrigin(favicon.pageUrl, url) ? favicon.dataUrl : null;+ return <PreviewFavicon capturedUrl={capturedUrl} url={url} />;}case "diff":return <FileDiff className="size-3 shrink-0" />;@@ -636,6 +647,7 @@ export function RightPanelTabs(props: RightPanelTabsProps) {<SurfaceIconsurface={surface}sessions={props.previewSessions}+ desktopByTabId={props.desktopByTabId}theme={resolvedTheme}pullRequestStatuses={props.pullRequestStatuses}/>diff --git a/apps/web/src/components/preview/PreviewEmptyState.test.tsx b/apps/web/src/components/preview/PreviewEmptyState.test.tsxindex 86cab6dbe..95e21c026 100644--- a/apps/web/src/components/preview/PreviewEmptyState.test.tsx+++ b/apps/web/src/components/preview/PreviewEmptyState.test.tsx@@ -1,4 +1,4 @@-import { EnvironmentId } from "@t3tools/contracts";+import { EnvironmentId, ThreadId } from "@t3tools/contracts";import { renderToStaticMarkup } from "react-dom/server";import { describe, expect, it, vi } from "vite-plus/test";@@ -19,10 +19,14 @@ const mocks = vi.hoisted(() => ({vi.mock("./useDiscoveredLocalServers", () => ({useDiscoveredLocalServers: () => mocks.servers,}));+vi.mock("./PreviewFaviconIcon", () => ({+ PreviewFaviconIcon: () => <span data-favicon-icon />,+}));import { PreviewEmptyState } from "./PreviewEmptyState";const environmentId = EnvironmentId.make("env-1");+const threadRef = { environmentId, threadId: ThreadId.make("thread-1") };function server(port: number) {return {@@ -41,6 +45,7 @@ function server(port: number) {function render(recentEntries: Array<{ url: string; lastVisitedAt: number; title?: string }>) {return renderToStaticMarkup(<PreviewEmptyState+ threadRef={threadRef}environmentId={environmentId}recentEntries={recentEntries}onRemoveRecent={() => undefined}diff --git a/apps/web/src/components/preview/PreviewEmptyState.tsx b/apps/web/src/components/preview/PreviewEmptyState.tsxindex 3b9aacf4d..4e74f44cb 100644--- a/apps/web/src/components/preview/PreviewEmptyState.tsx+++ b/apps/web/src/components/preview/PreviewEmptyState.tsx@@ -1,4 +1,4 @@-import type { EnvironmentId } from "@t3tools/contracts";+import type { EnvironmentId, ScopedThreadRef } from "@t3tools/contracts";import { Globe, History, RadioTower } from "lucide-react";import type { BrowserHistoryEntry } from "~/browserHistoryStore";@@ -9,6 +9,7 @@ import { PreviewRecentUrlCard } from "./PreviewRecentUrlCard";import { useDiscoveredLocalServers } from "./useDiscoveredLocalServers";interface Props {+ threadRef: ScopedThreadRef;environmentId: EnvironmentId;configuredUrls?: ReadonlyArray<string> | undefined;recentlySeenUrls?: ReadonlyArray<string> | undefined;@@ -18,6 +19,7 @@ interface Props {}export function PreviewEmptyState({+ threadRef,environmentId,configuredUrls,recentlySeenUrls,@@ -60,6 +62,7 @@ export function PreviewEmptyState({{recents.map((entry) => (<PreviewRecentUrlCardkey={entry.url}+ threadRef={threadRef}entry={entry}onOpen={() => onOpenUrl(entry.url)}onRemove={() => onRemoveRecent(entry.url)}@@ -78,6 +81,7 @@ export function PreviewEmptyState({{servers.map((server) => (<PreviewLocalServerCardkey={`${server.host}:${server.port}`}+ threadRef={threadRef}server={server}onOpen={() => onOpenUrl(server.requestedUrl)}/>diff --git a/apps/web/src/components/preview/PreviewFaviconIcon.test.tsx b/apps/web/src/components/preview/PreviewFaviconIcon.test.tsxnew file mode 100644index 000000000..d950a99b5--- /dev/null+++ b/apps/web/src/components/preview/PreviewFaviconIcon.test.tsx@@ -0,0 +1,51 @@+import { EnvironmentId, ThreadId } from "@t3tools/contracts";+import { renderToStaticMarkup } from "react-dom/server";+import { describe, expect, it, vi } from "vite-plus/test";++const mocks = vi.hoisted(() => ({ favicon: null as string | null }));++vi.mock("~/browserFaviconStore", () => ({+ useFaviconForThreadUrl: () => mocks.favicon,+}));++import { FaviconImage, PreviewFaviconIcon, selectFaviconSource } from "./PreviewFaviconIcon";++const threadRef = {+ environmentId: EnvironmentId.make("env-1"),+ threadId: ThreadId.make("thread-1"),+};++describe("preview favicon image", () => {+ it("renders a captured source before later fallback sources", () => {+ expect(+ renderToStaticMarkup(+ <FaviconImage+ sources={["data:image/png;base64,AAAA", "https://public.example/icon"]}+ fallback={<span>fallback</span>}+ />,+ ),+ ).toContain('src="data:image/png;base64,AAAA"');+ const captured = "data:image/png;base64,AAAA";+ const google = "https://public.example/icon";+ expect(selectFaviconSource([captured, google], new Set())).toBe(captured);+ expect(selectFaviconSource([captured, google], new Set([captured]))).toBe(google);+ expect(selectFaviconSource([captured, google], new Set([captured, google]))).toBeNull();+ expect(selectFaviconSource(["data:image/png;base64,BBBB", google], new Set([captured]))).toBe(+ "data:image/png;base64,BBBB",+ );+ });++ it("uses a stored project icon or falls back to the browser mockup", () => {+ mocks.favicon = null;+ const html = renderToStaticMarkup(+ <PreviewFaviconIcon threadRef={threadRef} url="http://localhost:3000/" />,+ );+ expect(html).not.toContain("<img");+ expect(html).toContain("rounded-[5px]");+ mocks.favicon = "data:image/png;base64,AAAA";+ const faviconHtml = renderToStaticMarkup(+ <PreviewFaviconIcon threadRef={threadRef} url="http://localhost:3000/" />,+ );+ expect(faviconHtml).toContain('src="data:image/png;base64,AAAA"');+ });+});diff --git a/apps/web/src/components/preview/PreviewFaviconIcon.tsx b/apps/web/src/components/preview/PreviewFaviconIcon.tsxnew file mode 100644index 000000000..111facfd8--- /dev/null+++ b/apps/web/src/components/preview/PreviewFaviconIcon.tsx@@ -0,0 +1,66 @@+import type { ScopedThreadRef } from "@t3tools/contracts";+import { type ReactNode, useState } from "react";++import { useFaviconForThreadUrl } from "~/browserFaviconStore";+import { cn } from "~/lib/utils";++import { BrowserMockup } from "./BrowserMockup";++export function selectFaviconSource(+ sources: ReadonlyArray<string>,+ failed: ReadonlySet<string>,+): string | null {+ return sources.find((candidate) => !failed.has(candidate)) ?? null;+}++export function FaviconImage(props: {+ sources: ReadonlyArray<string | null | undefined>;+ fallback: ReactNode;+ className?: string | undefined;+}) {+ const sources = props.sources.filter((source): source is string => Boolean(source));+ return (+ <FaviconImageAttempt+ key={sources.join("\0")}+ sources={sources}+ fallback={props.fallback}+ className={props.className}+ />+ );+}++function FaviconImageAttempt(props: {+ sources: ReadonlyArray<string>;+ fallback: ReactNode;+ className?: string | undefined;+}) {+ const [failed, setFailed] = useState<ReadonlySet<string>>(() => new Set());+ const source = selectFaviconSource(props.sources, failed);+ if (!source) return props.fallback;+ return (+ <img+ src={source}+ alt=""+ aria-hidden="true"+ draggable={false}+ className={props.className}+ onError={() => setFailed((current) => new Set(current).add(source))}+ />+ );+}++export function PreviewFaviconIcon(props: {+ threadRef: ScopedThreadRef;+ url: string;+ className?: string | undefined;+}) {+ const source = useFaviconForThreadUrl(props.threadRef, props.url);+ const fallback = <BrowserMockup className={cn("size-7 shrink-0", props.className)} />;+ return (+ <FaviconImage+ sources={[source]}+ fallback={fallback}+ className={cn("size-7 shrink-0 rounded object-contain", props.className)}+ />+ );+}diff --git a/apps/web/src/components/preview/PreviewLocalServerCard.tsx b/apps/web/src/components/preview/PreviewLocalServerCard.tsxindex c7b08ad28..1e0f01324 100644--- a/apps/web/src/components/preview/PreviewLocalServerCard.tsx+++ b/apps/web/src/components/preview/PreviewLocalServerCard.tsx@@ -1,12 +1,15 @@-import { BrowserMockup } from "./BrowserMockup";+import type { ScopedThreadRef } from "@t3tools/contracts";++import { PreviewFaviconIcon } from "./PreviewFaviconIcon";import type { PreviewableServer } from "./useDiscoveredLocalServers";interface Props {+ threadRef: ScopedThreadRef;server: PreviewableServer;onOpen: () => void;}-export function PreviewLocalServerCard({ server, onOpen }: Props) {+export function PreviewLocalServerCard({ threadRef, server, onOpen }: Props) {const subtitle = describeServer(server);return (<button@@ -14,7 +17,7 @@ export function PreviewLocalServerCard({ server, onOpen }: Props) {onClick={onOpen}className="group flex w-full items-center gap-3 px-3 py-3 text-left hover:bg-accent/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring">- <BrowserMockup className="size-7 shrink-0" />+ <PreviewFaviconIcon threadRef={threadRef} url={server.requestedUrl} /><div className="flex min-w-0 flex-1 flex-col"><span className="truncate text-sm font-medium text-foreground">{subtitle}</span><span className="truncate text-xs text-muted-foreground">diff --git a/apps/web/src/components/preview/PreviewRecentUrlCard.tsx b/apps/web/src/components/preview/PreviewRecentUrlCard.tsxindex 892ff579d..39af63a90 100644--- a/apps/web/src/components/preview/PreviewRecentUrlCard.tsx+++ b/apps/web/src/components/preview/PreviewRecentUrlCard.tsx@@ -1,18 +1,20 @@+import type { ScopedThreadRef } from "@t3tools/contracts";import { X } from "lucide-react";import { isValidHistoryTimestamp, type BrowserHistoryEntry } from "~/browserHistoryStore";import { useNowMinute } from "~/hooks/useNowMinute";import { formatRelativeTimeLabel } from "~/timestampFormat";-import { BrowserMockup } from "./BrowserMockup";+import { PreviewFaviconIcon } from "./PreviewFaviconIcon";interface Props {+ threadRef: ScopedThreadRef;entry: BrowserHistoryEntry;onOpen: () => void;onRemove: () => void;}-export function PreviewRecentUrlCard({ entry, onOpen, onRemove }: Props) {+export function PreviewRecentUrlCard({ threadRef, entry, onOpen, onRemove }: Props) {const parsed = new URL(entry.url);const path = parsed.pathname === "/" ? "" : parsed.pathname;const label = `${parsed.host}${path}${parsed.search}${parsed.hash}`;@@ -27,7 +29,7 @@ export function PreviewRecentUrlCard({ entry, onOpen, onRemove }: Props) {onClick={onOpen}className="flex w-full items-center gap-3 px-3 py-3 pr-10 text-left hover:bg-accent/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring">- <BrowserMockup className="size-7 shrink-0" />+ <PreviewFaviconIcon threadRef={threadRef} url={entry.url} /><div className="flex min-w-0 flex-1 flex-col"><span className="truncate text-sm font-medium text-foreground">{entry.title ?? label}diff --git a/apps/web/src/components/preview/PreviewView.tsx b/apps/web/src/components/preview/PreviewView.tsxindex 6979a1a40..723fd59a9 100644--- a/apps/web/src/components/preview/PreviewView.tsx+++ b/apps/web/src/components/preview/PreviewView.tsx@@ -710,6 +710,7 @@ export function PreviewView({) : null}{showEmptyState ? (<PreviewEmptyState+ threadRef={threadRef}environmentId={threadRef.environmentId}configuredUrls={configuredUrls}recentlySeenUrls={previewState.recentlySeenUrls}diff --git a/apps/web/src/components/preview/usePreviewBridge.test.ts b/apps/web/src/components/preview/usePreviewBridge.test.tsnew file mode 100644index 000000000..75387f0c8--- /dev/null+++ b/apps/web/src/components/preview/usePreviewBridge.test.ts@@ -0,0 +1,48 @@+import type { DesktopPreviewTabState } from "@t3tools/contracts";+import { describe, expect, it } from "vite-plus/test";++import { projectDesktopState } from "./usePreviewBridge";++const favicon = {+ dataUrl: "data:image/png;base64,AAAA",+ pageUrl: "http://localhost:3000/app",+ capturedAt: 1,+};++function state(navStatus: DesktopPreviewTabState["navStatus"]): DesktopPreviewTabState {+ return {+ tabId: "tab-1",+ webContentsId: 1,+ navStatus,+ canGoBack: false,+ canGoForward: false,+ zoomFactor: 1,+ pictureInPicture: false,+ colorScheme: "system",+ controller: "none",+ favicon,+ updatedAt: "2026-08-09T00:00:00.000Z",+ };+}++describe("projectDesktopState", () => {+ it("shows a retained icon only while the current document has the captured origin", () => {+ expect(+ projectDesktopState(+ state({ kind: "Loading", url: "http://localhost:3000/reload", title: "" }),+ ).favicon,+ ).toEqual(favicon);+ expect(+ projectDesktopState(+ state({+ kind: "LoadFailed",+ url: "https://example.com/",+ title: "",+ code: -105,+ description: "failed",+ }),+ ).favicon,+ ).toBeNull();+ expect(projectDesktopState(state({ kind: "Idle" })).favicon).toBeNull();+ });+});diff --git a/apps/web/src/components/preview/usePreviewBridge.ts b/apps/web/src/components/preview/usePreviewBridge.tsindex 259748c41..dc62ef981 100644--- a/apps/web/src/components/preview/usePreviewBridge.ts+++ b/apps/web/src/components/preview/usePreviewBridge.ts@@ -6,15 +6,31 @@ import type {ScopedThreadRef,ThreadId,} from "@t3tools/contracts";-import { useEffect, useRef } from "react";+import { parseScopedThreadKey, scopedThreadKey } from "@t3tools/client-runtime/environment";+import * as Option from "effect/Option";+import { useEffect, useEffectEvent, useMemo, useRef } from "react";+import {+ flushPendingFaviconsForThread,+ recordFaviconForThread,+ useFaviconProjectRefForThread,+} from "~/browserFaviconStore";import { useBrowserPointerStore } from "~/browser/browserPointerStore";import { applyPreviewDesktopState, type DesktopPreviewOverlay } from "~/previewStateStore";import { previewEnvironment } from "~/state/preview";+import { usePreparedConnection } from "~/state/session";import { useAtomCommand } from "~/state/use-atom-command";import { previewBridge } from "./previewBridge";+function originOf(url: string): string | null {+ try {+ return new URL(url).origin;+ } catch {+ return null;+ }+}+/*** Mirrors low-latency desktop state into the store and reflects navigation* events back to the server. Webview lifetime is owned by ElectronBrowserHost.@@ -28,26 +44,36 @@ export function usePreviewBridge(input: {const clearBrowserPointer = useBrowserPointerStore((state) => state.clear);const reportStatus = useAtomCommand(previewEnvironment.reportStatus, "preview status report");const bridge = previewBridge;+ const threadKey = scopedThreadKey(threadRef);+ const stableThreadRef = useMemo(() => {+ const parsed = parseScopedThreadKey(threadKey);+ if (!parsed) throw new Error(`Invalid scoped thread key: ${threadKey}`);+ return parsed;+ }, [threadKey]);+ const projectRef = useFaviconProjectRefForThread(stableThreadRef);+ const preparedConnection = usePreparedConnection(stableThreadRef.environmentId);+ const environmentHostname = Option.isSome(preparedConnection)+ ? new URL(preparedConnection.value.httpBaseUrl).hostname+ : undefined;// One bridge subscription does both jobs (mirror state + forward to// server) so the desktop bridge keeps a single listener entry per tab.const lastReportedUrl = useRef<string | null>(null);const lastReportedKind = useRef<DesktopPreviewTabState["navStatus"]["kind"] | null>(null);const lastDesktopNavStatus = useRef<DesktopPreviewTabState["navStatus"] | null>(null);- useEffect(() => {- if (!bridge || typeof window === "undefined") return;- lastReportedUrl.current = null;- lastReportedKind.current = null;- lastDesktopNavStatus.current = null;- const unsubscribe = bridge.onStateChange((changedTabId, state) => {+ const handleStateChange = useEffectEvent(+ (changedTabId: string, state: DesktopPreviewTabState): void => {if (changedTabId !== runtimeTabId) return;if (shouldClearBrowserPointer(lastDesktopNavStatus.current, state.navStatus)) {clearBrowserPointer(runtimeTabId);}lastDesktopNavStatus.current = state.navStatus;- applyPreviewDesktopState(threadRef, tabId, projectDesktopState(state));+ applyPreviewDesktopState(stableThreadRef, tabId, projectDesktopState(state));+ if (state.favicon) {+ recordFaviconForThread(stableThreadRef, state.favicon, projectRef, environmentHostname);+ }const reported = buildReportInput({- threadId: threadRef.threadId,+ threadId: stableThreadRef.threadId,tabId,state,lastReportedUrl: lastReportedUrl.current,@@ -57,12 +83,22 @@ export function usePreviewBridge(input: {lastReportedUrl.current = reported.lastReportedUrl;lastReportedKind.current = reported.lastReportedKind;void reportStatus({- environmentId: threadRef.environmentId,+ environmentId: stableThreadRef.environmentId,input: reported.input,});- });- return unsubscribe;- }, [bridge, clearBrowserPointer, reportStatus, runtimeTabId, tabId, threadRef]);+ },+ );+ useEffect(() => {+ if (!bridge || typeof window === "undefined") return;+ lastReportedUrl.current = null;+ lastReportedKind.current = null;+ lastDesktopNavStatus.current = null;+ return bridge.onStateChange(handleStateChange);+ }, [bridge, runtimeTabId, stableThreadRef, tabId]);+ useEffect(() => {+ if (!projectRef) return;+ flushPendingFaviconsForThread(stableThreadRef, projectRef, environmentHostname);+ }, [environmentHostname, projectRef, stableThreadRef]);}function shouldClearBrowserPointer(@@ -75,7 +111,8 @@ function shouldClearBrowserPointer(return current.url !== previous.url;}-function projectDesktopState(state: DesktopPreviewTabState): DesktopPreviewOverlay {+export function projectDesktopState(state: DesktopPreviewTabState): DesktopPreviewOverlay {+ const navOrigin = state.navStatus.kind === "Idle" ? null : originOf(state.navStatus.url);return {hasWebContents: state.webContentsId !== null,canGoBack: state.canGoBack,@@ -85,6 +122,7 @@ function projectDesktopState(state: DesktopPreviewTabState): DesktopPreviewOverlpictureInPicture: state.pictureInPicture,colorScheme: state.colorScheme,controller: state.controller,+ favicon: state.favicon && originOf(state.favicon.pageUrl) === navOrigin ? state.favicon : null,};}diff --git a/apps/web/src/lib/favicon.test.ts b/apps/web/src/lib/favicon.test.tsnew file mode 100644index 000000000..8fe9e65eb--- /dev/null+++ b/apps/web/src/lib/favicon.test.ts@@ -0,0 +1,42 @@+import { describe, expect, it } from "vite-plus/test";++import { faviconUrlForOrigin } from "./favicon";++describe("faviconUrlForOrigin", () => {+ it("never sends private origin hostnames to the public provider", () => {+ for (const url of [+ "http://localhost:3000/",+ "http://127.0.0.1:3000/",+ "http://0.0.0.0:3000/",+ "http://devbox:3000/",+ "https://24x.xf.local/",+ "http://printer.home.arpa/",+ "http://192.168.1.20:3000/",+ "http://[::]/",+ "http://[::ffff:192.168.1.20]/",+ "http://100.65.180.100:3000/",+ "https://devbox.example.ts.net/",+ "http://192.0.2.1/",+ "http://198.51.100.1/",+ "http://203.0.113.1/",+ "http://224.0.0.1/",+ "http://240.0.0.1/",+ "http://[2001:db8::1]/",+ "http://[ff02::1]/",+ "http://app.test../",+ "https://24x.xf.local../",+ "http://printer.home.arpa../",+ "https://devbox.example.ts.net../",+ "http://127.0.0.1../",+ "http://127.1../",+ "http://10.1../",+ "http://172.16.1../",+ "http://192.168.1../",+ ]) {+ expect(faviconUrlForOrigin(url)).toBeNull();+ }+ expect(faviconUrlForOrigin("https://example.com/path", 32)).toBe(+ "https://www.google.com/s2/favicons?domain=example.com&sz=32",+ );+ });+});diff --git a/apps/web/src/lib/favicon.ts b/apps/web/src/lib/favicon.tsindex e5e94b266..b327146b6 100644--- a/apps/web/src/lib/favicon.ts+++ b/apps/web/src/lib/favicon.ts@@ -1,3 +1,5 @@+import { isPublicFaviconHost } from "~/browser/browserTargetResolver";+/*** Favicon helpers for the preview tab strip.*@@ -13,6 +15,7 @@ export function faviconUrlForOrigin(rawUrl: string | null | undefined, size = 32const url = new URL(rawUrl);if (!url.host) return null;if (url.protocol !== "http:" && url.protocol !== "https:") return null;+ if (!isPublicFaviconHost(url.hostname)) return null;return `${FAVICON_PROVIDER}?domain=${encodeURIComponent(url.host)}&sz=${size}`;} catch {return null;diff --git a/apps/web/src/previewStateStore.test.ts b/apps/web/src/previewStateStore.test.tsindex 50bda95c9..975ef59f4 100644--- a/apps/web/src/previewStateStore.test.ts+++ b/apps/web/src/previewStateStore.test.ts@@ -322,6 +322,7 @@ describe("previewStateStore (single-tab)", () => {pictureInPicture: false,colorScheme: "system",controller: "none",+ favicon: null,});const state = readThreadPreviewState(ref);expect(state.desktopOverlay?.canGoBack).toBe(true);@@ -342,6 +343,7 @@ describe("previewStateStore (single-tab)", () => {pictureInPicture: false,colorScheme: "system",controller: "none",+ favicon: null,});setActivePreviewTab(ref, first.tabId);@@ -390,6 +392,7 @@ describe("previewStateStore (single-tab)", () => {pictureInPicture: false,colorScheme: "system",controller: "none",+ favicon: null,});reconcilePreviewServerSessions(ref, { sessions: [active], serverEpoch, revision: 1 });@@ -504,6 +507,7 @@ describe("previewStateStore (single-tab)", () => {pictureInPicture: false,colorScheme: "system",controller: "none",+ favicon: null,});const restarted = makeSnapshot({navStatus: { _tag: "Success", url: "https://new.example", title: "New" },diff --git a/apps/web/src/previewStateStore.ts b/apps/web/src/previewStateStore.tsindex f3dced0a7..5a65d1709 100644--- a/apps/web/src/previewStateStore.ts+++ b/apps/web/src/previewStateStore.ts@@ -9,6 +9,7 @@ import { useAtomValue } from "@effect/atom-react";import { scopedThreadKey } from "@t3tools/client-runtime/environment";import {type DesktopPreviewColorScheme,+ type DesktopPreviewFavicon,type PreviewEvent,type PreviewListResult,type PreviewSessionSnapshot,@@ -28,6 +29,7 @@ export interface DesktopPreviewOverlay {pictureInPicture: boolean;colorScheme: DesktopPreviewColorScheme;controller: "human" | "agent" | "none";+ favicon: DesktopPreviewFavicon | null;}export interface ThreadPreviewState {diff --git a/apps/web/src/routes/_chat.pull-requests.tsx b/apps/web/src/routes/_chat.pull-requests.tsxindex 4d36861f8..f3ccf54be 100644--- a/apps/web/src/routes/_chat.pull-requests.tsx+++ b/apps/web/src/routes/_chat.pull-requests.tsx@@ -175,6 +175,7 @@ const PULL_REQUESTS_PANEL_ENVIRONMENT_ID = "pull-requests-panel" as EnvironmentI/** Stable so a read that is not wanted right now does not re-key on every render. */const NO_LIST_TARGETS: ReadonlyArray<EnvironmentQueryTarget<PullRequestListInput>> = [];const EMPTY_PREVIEW_SESSIONS = {};+const EMPTY_PREVIEW_DESKTOP_STATE = {};const EMPTY_TERMINAL_LABELS = new Map<string, string>();const EMPTY_PENDING_SURFACES = new Set<string>();@@ -1540,6 +1541,7 @@ function PullRequestsRouteView() {activeSurfaceId={activePullRequestSurface.id}pendingSurfaceIds={EMPTY_PENDING_SURFACES}previewSessions={EMPTY_PREVIEW_SESSIONS}+ desktopByTabId={EMPTY_PREVIEW_DESKTOP_STATE}terminalLabelsById={EMPTY_TERMINAL_LABELS}onActivate={(surface) => {if (surface.kind === "pull-request") activateSurface(surface);diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.tsindex 7f9fdb271..4e4d4baa1 100644--- a/packages/contracts/src/ipc.ts+++ b/packages/contracts/src/ipc.ts@@ -524,6 +524,28 @@ export type DesktopPreviewColorScheme = "system" | "light" | "dark";export const DesktopPreviewColorSchemeSchema: Schema.Codec<DesktopPreviewColorScheme> =Schema.Literals(["system", "light", "dark"]);+export const FAVICON_DATA_URL_MAX_LENGTH = 8192;+export const FAVICON_CAPTURED_AT_MAX = 8_640_000_000_000_000;++export interface DesktopPreviewFavicon {+ dataUrl: string;+ pageUrl: string;+ capturedAt: number;+}++export const DesktopPreviewFaviconSchema: Schema.Codec<DesktopPreviewFavicon> = Schema.Struct({+ dataUrl: Schema.String.check(+ Schema.isMaxLength(FAVICON_DATA_URL_MAX_LENGTH),+ Schema.isPattern(/^data:image\/png;base64,[a-z0-9+/]+={0,2}$/i),+ ),+ pageUrl: Schema.String.check(Schema.isMaxLength(2_048)),+ capturedAt: Schema.Number.check(+ Schema.isFinite(),+ Schema.isGreaterThanOrEqualTo(0),+ Schema.isLessThanOrEqualTo(FAVICON_CAPTURED_AT_MAX),+ ),+});+export interface DesktopPreviewTabState {tabId: string;webContentsId: number | null;@@ -536,6 +558,7 @@ export interface DesktopPreviewTabState {pictureInPicture: boolean;colorScheme: DesktopPreviewColorScheme;controller: "human" | "agent" | "none";+ favicon?: DesktopPreviewFavicon;updatedAt: string;}@@ -574,6 +597,7 @@ export const DesktopPreviewTabStateSchema: Schema.Codec<DesktopPreviewTabState>pictureInPicture: Schema.Boolean,colorScheme: DesktopPreviewColorSchemeSchema,controller: Schema.Literals(["human", "agent", "none"]),+ favicon: Schema.optionalKey(DesktopPreviewFaviconSchema),updatedAt: Schema.String,});