@dimina-kit/devtools 0.4.0 → 0.5.0

package/dist/main/services/mcp/target-selection.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure candidate-ranking rules for the two MCP CDP targets.
+ *
+ * Split out of target-manager.ts: these functions only rank a raw CDP.List
+ * result by URL shape and carry no connection state of their own, so they can
+ * be pinned with direct unit tests independent of the connection lifecycle.
+ */
+/**
+ * Resolve which CDP target the `simulator` MCP tools should drive.
+ *
+ * Default (non-native) path: the localhost:7788 simulator shell — identical
+ * to the original behavior; `activeBridgeId` is ignored.
+ *
+ * Native-host path: the active render-host <webview> guest
+ * (pageFrame.html?...bridgeId=<id>), preferring the guest matching
+ * `activeBridgeId`, then any pageFrame guest, then degrading to the shell.
+ */
+export declare function selectSimulatorTarget<T extends {
+    url?: string;
+    type?: string;
+}>(targets: T[], opts: {
+    nativeHost: boolean;
+    activeBridgeId: string | null;
+}): T | undefined;
+/**
+ * Resolve which CDP target the `workbench` MCP tools should drive.
+ *
+ * `projectPath` is the active project window's path, fixed when that window
+ * opened; null when no project window is open, and then the project list is
+ * the only workbench surface.
+ *
+ * A project window names its own renderer from the moment it exists, so the
+ * match is exact or nothing: another project's workbench page, or the project
+ * list standing in for a project that IS open, would leave every workbench
+ * tool answering for the wrong window with nothing to correct it.
+ *
+ * Matching is on the renderer ENTRY, never on "the URL mentions the project
+ * directory" — the service-host window carries the same directory in its own
+ * `pkgRoot` query and would win a substring match.
+ */
+export declare function selectWorkbenchTarget<T extends {
+    url?: string;
+    type?: string;
+}>(candidates: T[], opts: {
+    projectPath: string | null;
+}): T | undefined;
+//# sourceMappingURL=target-selection.d.ts.map

package/dist/main/services/mcp/target-selection.js

@@ -0,0 +1,71 @@
+/**
+ * Pure candidate-ranking rules for the two MCP CDP targets.
+ *
+ * Split out of target-manager.ts: these functions only rank a raw CDP.List
+ * result by URL shape and carry no connection state of their own, so they can
+ * be pinned with direct unit tests independent of the connection lifecycle.
+ */
+import { DMB_PAGEFRAME_DOC_NAME } from '../../../shared/dmb-resource-url.js';
+import { targetQuery } from './connection-owner.js';
+const SIMULATOR_URL_PATTERN = 'localhost:7788';
+// The two renderer entries MCP can drive: a project's workbench window and the
+// always-present project list.
+const WORKBENCH_ENTRY = 'entries/workbench/index.html';
+const PROJECT_LIST_ENTRY = 'entries/main/index.html';
+// Native-host: the real mini-app page runs in a nested render-host <webview>
+// guest whose CDP target URL carries the render frame + the page's bridgeId.
+// Import the shared reserved doc name rather than hand-writing a second
+// literal — that duplication is exactly what let this pattern drift out of
+// sync with the actual document URL shape (dmb-resource-url.ts).
+const RENDER_GUEST_PATTERN = DMB_PAGEFRAME_DOC_NAME;
+/**
+ * Resolve which CDP target the `simulator` MCP tools should drive.
+ *
+ * Default (non-native) path: the localhost:7788 simulator shell — identical
+ * to the original behavior; `activeBridgeId` is ignored.
+ *
+ * Native-host path: the active render-host <webview> guest
+ * (pageFrame.html?...bridgeId=<id>), preferring the guest matching
+ * `activeBridgeId`, then any pageFrame guest, then degrading to the shell.
+ */
+export function selectSimulatorTarget(targets, opts) {
+    if (!opts.nativeHost) {
+        return targets.find((t) => t.url?.includes(SIMULATOR_URL_PATTERN));
+    }
+    // 1) Active-bridge guest takes priority over list order.
+    if (opts.activeBridgeId !== null) {
+        const bridgeMatch = `bridgeId=${opts.activeBridgeId}`;
+        const active = targets.find((t) => t.url?.includes(RENDER_GUEST_PATTERN) && t.url.includes(bridgeMatch));
+        if (active)
+            return active;
+    }
+    // 2) Any render guest (no active match / no active bridge).
+    const anyGuest = targets.find((t) => t.url?.includes(RENDER_GUEST_PATTERN));
+    if (anyGuest)
+        return anyGuest;
+    // 3) Degrade to the localhost:7788 shell when no render guest exists yet.
+    return targets.find((t) => t.url?.includes(SIMULATOR_URL_PATTERN));
+}
+/**
+ * Resolve which CDP target the `workbench` MCP tools should drive.
+ *
+ * `projectPath` is the active project window's path, fixed when that window
+ * opened; null when no project window is open, and then the project list is
+ * the only workbench surface.
+ *
+ * A project window names its own renderer from the moment it exists, so the
+ * match is exact or nothing: another project's workbench page, or the project
+ * list standing in for a project that IS open, would leave every workbench
+ * tool answering for the wrong window with nothing to correct it.
+ *
+ * Matching is on the renderer ENTRY, never on "the URL mentions the project
+ * directory" — the service-host window carries the same directory in its own
+ * `pkgRoot` query and would win a substring match.
+ */
+export function selectWorkbenchTarget(candidates, opts) {
+    const pages = candidates.filter((t) => t.type === 'page' && !t.url?.includes(SIMULATOR_URL_PATTERN));
+    if (opts.projectPath === null)
+        return pages.find((t) => t.url?.includes(PROJECT_LIST_ENTRY));
+    return pages.find((t) => t.url?.includes(WORKBENCH_ENTRY) && targetQuery(t.url, 'path') === opts.projectPath);
+}
+//# sourceMappingURL=target-selection.js.map

package/dist/main/services/mcp/tools/context-tools.js

@@ -136,8 +136,21 @@ export function registerContextTools(server) {
             return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
         }
         let result;
+        // Snapshot the provider AND the console/network summaries in the same
+        // tick as `getClient`: the provider reads the active window live off
+        // `resolveActiveOwner()`, and the buffers are process-wide and get
+        // cleared and re-owned the moment a reconnect lands on another window.
+        // Both awaits below (the CDP probe, the native provider) are windows the
+        // user can switch projects during; reading either after them would mix
+        // this window's probe with whichever window is active by then.
+        let nativeOverviewProvider;
+        let consoleSum;
+        let networkSum;
         try {
             const c = getClient('simulator');
+            nativeOverviewProvider = getNativeOverviewProvider();
+            consoleSum = summarizeConsole('simulator');
+            networkSum = summarizeNetwork('simulator');
             result = await c.Runtime.evaluate({ expression: SIMULATOR_PROBE_EXPR, returnByValue: true });
         }
         catch {
@@ -160,7 +173,6 @@ export function registerContextTools(server) {
                 isError: true,
             };
         }
-        const nativeOverviewProvider = getNativeOverviewProvider();
         if (nativeOverviewProvider) {
             try {
                 const nativeOverview = await nativeOverviewProvider();
@@ -182,8 +194,6 @@ export function registerContextTools(server) {
             hints.push('no active miniapp page (empty page stack)');
         if (probe.storageCount > MAX_KEYS)
             hints.push(`storageKeys truncated to first ${MAX_KEYS} of ${probe.storageCount}`);
-        const consoleSum = summarizeConsole('simulator');
-        const networkSum = summarizeNetwork('simulator');
         const payload = {
             connected: true,
             url: probe.url,
@@ -213,8 +223,15 @@ export function registerContextTools(server) {
             return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
         }
         let result;
+        // Same snapshot rule as the simulator overview: the buffers belong to
+        // the connection `getClient` just vouched for, so they are read before
+        // the probe's await, not after it.
+        let consoleSum;
+        let networkSum;
         try {
             const c = getClient('workbench');
+            consoleSum = summarizeConsole('workbench');
+            networkSum = summarizeNetwork('workbench');
             result = await c.Runtime.evaluate({ expression: WORKBENCH_PROBE_EXPR, returnByValue: true });
         }
         catch {
@@ -237,8 +254,6 @@ export function registerContextTools(server) {
                 isError: true,
             };
         }
-        const consoleSum = summarizeConsole('workbench');
-        const networkSum = summarizeNetwork('workbench');
         const payload = {
             connected: true,
             url: probe.url,

package/dist/main/services/mcp/tools/project-tools.d.ts

@@ -0,0 +1,72 @@
+/**
+ * MCP project lifecycle tools: open (launch the mini-program in the
+ * simulator), close, query compile status, await the compile settling, and
+ * pull compile logs incrementally.
+ *
+ * `project_open` does NOT call `workspace.openProject` directly: the renderer
+ * owns the open path (mounting ProjectRuntime is what compiles AND attaches
+ * the simulator), so the tool pushes a `window:openProject` event and then
+ * awaits the session-status store — the same main-process authority the
+ * notifier tap feeds from the renderer-driven compile.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CompileLogBuffer } from '../../workspace/compile-log-buffer.js';
+import type { SessionStatusStore } from '../../workspace/session-status-store.js';
+import type { McpOpenedProject } from '../opened-project.js';
+/**
+ * Narrow structural slice of WorkspaceService the project tools need.
+ * Structural (not a Pick of the real interface) so tests can hand in a
+ * plain object and this module never imports workbench-context.
+ */
+export interface McpProjectWorkspace {
+    validateProjectDir(dirPath: string): Promise<string | null>;
+    hasProject(dirPath: string): Promise<boolean>;
+    addProject(dirPath: string): Promise<{
+        name: string;
+        path: string;
+    }>;
+    listProjects(): Promise<{
+        name: string;
+        path: string;
+    }[]>;
+    closeProject(): Promise<void>;
+    getProjectPath(): string;
+    hasActiveSession(): boolean;
+}
+/**
+ * One project window's surfaces, resolved together. A project lives in its own
+ * window with its own workspace, status store and log buffer, so a tool call
+ * that read them one by one could mix two projects: every surface here comes
+ * from the same window at the same instant.
+ */
+export interface McpProjectTarget {
+    workspace: McpProjectWorkspace;
+    sessionStatus: SessionStatusStore;
+    compileLogs: CompileLogBuffer;
+    /** Close this target's project window; a no-op when it has none. */
+    closeWindow(): void;
+}
+/** Everything `registerProjectTools` needs, assembled by app bootstrap. */
+export interface McpProjectHost {
+    /**
+     * The project window a call arriving now is aimed at. Taken ONCE per tool
+     * call and held for its whole lifetime: tools await compiles and teardowns,
+     * and the user is free to focus another project meanwhile — re-resolving
+     * afterwards would report one project's compile as another's, or close the
+     * window they just moved to.
+     */
+    currentProject(): McpProjectTarget;
+    /**
+     * Push the renderer to open the project (the user-click-equivalent path) and
+     * resolve with the window it landed in. A project lives in its own window
+     * with its own status store, so the caller can only await the right compile
+     * by holding that window — the window active when the call arrived is a
+     * different project.
+     */
+    requestOpenInUi(project: {
+        name: string;
+        path: string;
+    }): Promise<McpOpenedProject>;
+}
+export declare function registerProjectTools(server: McpServer, host: McpProjectHost): void;
+//# sourceMappingURL=project-tools.d.ts.map

package/dist/main/services/mcp/tools/project-tools.js

@@ -0,0 +1,133 @@
+/**
+ * MCP project lifecycle tools: open (launch the mini-program in the
+ * simulator), close, query compile status, await the compile settling, and
+ * pull compile logs incrementally.
+ *
+ * `project_open` does NOT call `workspace.openProject` directly: the renderer
+ * owns the open path (mounting ProjectRuntime is what compiles AND attaches
+ * the simulator), so the tool pushes a `window:openProject` event and then
+ * awaits the session-status store — the same main-process authority the
+ * notifier tap feeds from the renderer-driven compile.
+ */
+import path from 'node:path';
+import { z } from 'zod';
+const DEFAULT_OPEN_TIMEOUT_MS = 180_000;
+const DEFAULT_WAIT_TIMEOUT_MS = 60_000;
+function text(payload) {
+    return { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] };
+}
+function errorText(message) {
+    return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+}
+/**
+ * Public phase: a settled store snapshot with no live session means no
+ * project is open ('idle'), while 'error'/'compiling' pass through as-is —
+ * `hasActiveSession()` is false during a compile and after a failed open,
+ * so those phases are the truthful answer even without a session.
+ */
+function publicPhase(snapshot, sessionActive) {
+    if (!sessionActive && snapshot.phase === 'ready')
+        return 'idle';
+    return snapshot.phase;
+}
+/** Reads one window's own status: the pinned target, or the window an open landed in. */
+function statusPayload(source) {
+    const snapshot = source.sessionStatus.get();
+    const sessionActive = source.workspace.hasActiveSession();
+    return {
+        phase: publicPhase(snapshot, sessionActive),
+        message: snapshot.message,
+        projectPath: source.workspace.getProjectPath(),
+        sessionActive,
+        watcherAlive: snapshot.watcherAlive,
+        updatedAt: snapshot.updatedAt,
+        generation: snapshot.generation,
+    };
+}
+export function registerProjectTools(server, host) {
+    server.tool('project_open', 'Open a mini-program project: registers the directory if needed, launches it in the simulator (compile + attach), and waits until the compile settles. Returns the settled status; on compile error, pull stderr via compile_logs.', {
+        path: z.string().describe('Absolute path to the mini-program project directory'),
+        timeoutMs: z.number().optional().default(DEFAULT_OPEN_TIMEOUT_MS)
+            .describe('Max time to wait for the compile to settle'),
+    }, async ({ path: rawPath, timeoutMs }) => {
+        const target = host.currentProject();
+        const dir = path.resolve(rawPath);
+        // Already open and settled: report instead of re-triggering a compile.
+        const current = target.sessionStatus.get();
+        if (target.workspace.getProjectPath() === dir
+            && target.workspace.hasActiveSession()
+            && current.phase === 'ready') {
+            return text({ ...statusPayload(target), note: 'project already open' });
+        }
+        const invalid = await target.workspace.validateProjectDir(dir);
+        if (invalid)
+            return errorText(invalid);
+        let project;
+        if (await target.workspace.hasProject(dir)) {
+            const known = (await target.workspace.listProjects()).find((p) => p.path === dir);
+            project = known ?? { name: path.basename(dir), path: dir };
+        }
+        else {
+            project = await target.workspace.addProject(dir);
+        }
+        // The open hands back the window it landed in; that window's store is the
+        // only place this compile is reported, and its `afterGeneration` keeps a
+        // state that predates the open from being read as this open's result.
+        let opened;
+        let settled;
+        try {
+            opened = await host.requestOpenInUi({ name: project.name, path: project.path });
+            settled = await opened.sessionStatus.waitForSettled({
+                afterGeneration: opened.afterGeneration,
+                timeoutMs,
+            });
+        }
+        catch (err) {
+            return errorText(err instanceof Error ? err.message : String(err));
+        }
+        if (settled.phase === 'error') {
+            return errorText(`compile failed: ${settled.message} — call compile_logs (stream: "stderr") for details`);
+        }
+        return text(statusPayload(opened));
+    });
+    server.tool('project_close', 'Close the currently open project session and return the workbench to the project list.', {}, async () => {
+        // Held across the await: `closeProject()` yields, and a window the user
+        // focuses while it runs must not become the window this close takes down.
+        const target = host.currentProject();
+        if (!target.workspace.getProjectPath() && !target.workspace.hasActiveSession()) {
+            return text({ closed: false, note: 'no project is open' });
+        }
+        await target.workspace.closeProject();
+        target.closeWindow();
+        return text({ closed: true });
+    });
+    server.tool('project_status', 'Query the current project compile status (phase: idle | compiling | ready | error). Includes `generation` — pass it to project_wait_ready to await the NEXT settled state.', {}, async () => text(statusPayload(host.currentProject())));
+    server.tool('project_wait_ready', 'Wait until the compile pipeline settles (phase leaves "compiling"). Watcher rebuilds emit no "compiling" phase, so to await a rebuild after editing files pass the `generation` from a prior project_status.', {
+        afterGeneration: z.number().optional()
+            .describe('Only accept states recorded after this generation (from project_status). Omit to accept the current state when already settled.'),
+        timeoutMs: z.number().optional().default(DEFAULT_WAIT_TIMEOUT_MS)
+            .describe('Max time to wait'),
+    }, async ({ afterGeneration, timeoutMs }) => {
+        // Held across the wait: the state this call reports must come from the
+        // window it was aimed at, whichever window is focused when it settles.
+        const target = host.currentProject();
+        try {
+            await target.sessionStatus.waitForSettled({ afterGeneration, timeoutMs });
+        }
+        catch (err) {
+            return errorText(err instanceof Error ? err.message : String(err));
+        }
+        return text(statusPayload(target));
+    });
+    server.tool('compile_logs', 'Pull compile log lines incrementally. Pass the previous call\'s nextCursor as `cursor` to receive only new lines. The buffer resets on each fresh project open; watcher rebuilds append to the same timeline.', {
+        cursor: z.number().optional().default(0)
+            .describe('Return only lines after this cursor (0 = from the start of the buffer)'),
+        limit: z.number().optional().default(100).describe('Max lines to return'),
+        stream: z.enum(['stdout', 'stderr']).optional()
+            .describe('Only lines from this stream (stderr carries compile errors)'),
+    }, async ({ cursor, limit, stream }) => {
+        const read = host.currentProject().compileLogs.read({ afterSeq: cursor, limit, stream });
+        return text(read);
+    });
+}
+//# sourceMappingURL=project-tools.js.map

package/dist/main/services/module.d.ts

@@ -1,17 +1,25 @@
 import type { Disposable } from '@dimina-kit/electron-deck/main';
 import type { WorkbenchContext } from './workbench-context.js';
+import type { IpcContextSource } from '../utils/ipc-context-source.js';
 /**
  * A composable unit of workbench functionality.
  *
  * Built-in modules (projects, session, simulator, popover, settings) are
  * implemented as `WorkbenchModule` values.
  *
- * `setup` is invoked once during workbench bootstrap. The returned
- * Disposable is added to `ctx.registry` so module teardown is symmetric
- * with the rest of the workbench lifecycle.
+ * The two hooks differ in what they own. `setup` registers IPC once for the
+ * application and answers each message with the context the sender belongs to,
+ * so its handlers must read everything from that argument. `setupWindow` is the
+ * escape hatch for wiring that genuinely belongs to a single window — it
+ * receives that window's concrete context and may mutate it.
+ *
+ * Both returned Disposables are added to a registry so module teardown is
+ * symmetric with the rest of the workbench lifecycle.
  */
 export interface WorkbenchModule {
-    /** Set up the module against ctx. Returns a Disposable owned by ctx.registry. */
-    setup(ctx: WorkbenchContext): Disposable;
+    /** Register the module's IPC against every live window context. */
+    setup(source: IpcContextSource<WorkbenchContext>): Disposable;
+    /** Optional per-window wiring, run once for each window that opens. */
+    setupWindow?(ctx: WorkbenchContext): Disposable;
 }
 //# sourceMappingURL=module.d.ts.map

package/dist/main/services/network-forward/body-cache.d.ts

@@ -0,0 +1,72 @@
+/**
+ * PrefetchCache — a bounded, TTL'd "prime now / read later" promise cache.
+ *
+ * The network forwarder prefetches `Network.getResponseBody` /
+ * `Network.getRequestPostData` from the simulator's CDP session the moment a
+ * request finishes (the renderer may evict the resource soon after), keyed by
+ * the namespaced virtual requestId. A later Response-tab click resolves from
+ * here instead of re-issuing a debugger round-trip against a session that may
+ * have moved on.
+ *
+ * Contract:
+ *  - `prime(id, fetch)` is idempotent per id: while an entry is pending or a
+ *    settled entry is still live, later primes are ignored.
+ *  - A fetch rejection — or a resolved value whose `sizeOf` exceeds
+ *    `perEntryMaxChars` — becomes an ERROR SENTINEL: the id stays known but
+ *    every lookup rejects with the canonical not-found message (the same
+ *    answer a real CDP backend gives for an unknown requestId, so the
+ *    front-end renders its normal failure state).
+ *  - `lookup(id)` resolves the cached value, awaits a still-pending fetch (a
+ *    panel click can land before the prefetch settles), and rejects
+ *    not-found for unknown / expired / evicted / sentinel entries.
+ *  - Bounds apply to SETTLED entries only: LRU by settle/lookup recency up to
+ *    `maxEntries`, plus a `maxTotalChars` budget over `sizeOf`. A pending
+ *    entry counts 0 and is never evicted — evicting an in-flight prefetch
+ *    would strand its waiters.
+ *  - TTL is anchored to the SETTLE time (not the prime() call time) and is
+ *    enforced lazily on the next prime/lookup.
+ */
+/**
+ * Default per-entry size ceiling (chars). Exported so callers that need to
+ * pre-screen a fetch BEFORE issuing it (e.g. skipping a CDP round-trip for a
+ * response already known to be oversized) reference the exact same number
+ * `PrefetchCache`'s own default enforces — one source of truth, not two
+ * independently-configured limits that could silently drift apart.
+ */
+export declare const DEFAULT_PER_ENTRY_MAX_CHARS: number;
+export interface PrefetchCacheOptions {
+    maxEntries?: number;
+    maxTotalChars?: number;
+    perEntryMaxChars?: number;
+    ttlMs?: number;
+    /** Injectable clock for TTL tests. */
+    now?: () => number;
+}
+export declare class PrefetchCache<V> {
+    private readonly sizeOf;
+    private readonly map;
+    private readonly maxEntries;
+    private readonly maxTotalChars;
+    private readonly perEntryMaxChars;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(sizeOf: (v: V) => number, opts?: PrefetchCacheOptions);
+    /**
+     * Returns `true` when this call actually started a new fetch, `false` when
+     * it was a no-op (idempotent re-prime of an id that's already pending or
+     * still live). Callers that admission-gate priming (a concurrency cap) need
+     * this to know whether they actually consumed a slot — incrementing a
+     * counter unconditionally would leak a slot on every no-op re-prime.
+     */
+    prime(id: string, fetch: () => Promise<V>): boolean;
+    lookup(id: string): Promise<V>;
+    /** Retire a previous redirect hop without disturbing unrelated cached requests. */
+    delete(id: string): void;
+    clear(): void;
+    get size(): number;
+    private isExpired;
+    private sweepExpired;
+    /** Evict oldest SETTLED entries until both bounds hold; pending are exempt. */
+    private evict;
+}
+//# sourceMappingURL=body-cache.d.ts.map

package/dist/main/services/network-forward/body-cache.js

@@ -0,0 +1,179 @@
+/**
+ * PrefetchCache — a bounded, TTL'd "prime now / read later" promise cache.
+ *
+ * The network forwarder prefetches `Network.getResponseBody` /
+ * `Network.getRequestPostData` from the simulator's CDP session the moment a
+ * request finishes (the renderer may evict the resource soon after), keyed by
+ * the namespaced virtual requestId. A later Response-tab click resolves from
+ * here instead of re-issuing a debugger round-trip against a session that may
+ * have moved on.
+ *
+ * Contract:
+ *  - `prime(id, fetch)` is idempotent per id: while an entry is pending or a
+ *    settled entry is still live, later primes are ignored.
+ *  - A fetch rejection — or a resolved value whose `sizeOf` exceeds
+ *    `perEntryMaxChars` — becomes an ERROR SENTINEL: the id stays known but
+ *    every lookup rejects with the canonical not-found message (the same
+ *    answer a real CDP backend gives for an unknown requestId, so the
+ *    front-end renders its normal failure state).
+ *  - `lookup(id)` resolves the cached value, awaits a still-pending fetch (a
+ *    panel click can land before the prefetch settles), and rejects
+ *    not-found for unknown / expired / evicted / sentinel entries.
+ *  - Bounds apply to SETTLED entries only: LRU by settle/lookup recency up to
+ *    `maxEntries`, plus a `maxTotalChars` budget over `sizeOf`. A pending
+ *    entry counts 0 and is never evicted — evicting an in-flight prefetch
+ *    would strand its waiters.
+ *  - TTL is anchored to the SETTLE time (not the prime() call time) and is
+ *    enforced lazily on the next prime/lookup.
+ */
+const NOT_FOUND = 'No resource with given identifier found';
+/**
+ * Default per-entry size ceiling (chars). Exported so callers that need to
+ * pre-screen a fetch BEFORE issuing it (e.g. skipping a CDP round-trip for a
+ * response already known to be oversized) reference the exact same number
+ * `PrefetchCache`'s own default enforces — one source of truth, not two
+ * independently-configured limits that could silently drift apart.
+ */
+export const DEFAULT_PER_ENTRY_MAX_CHARS = 16 * 1024 * 1024;
+export class PrefetchCache {
+    sizeOf;
+    map = new Map();
+    maxEntries;
+    maxTotalChars;
+    perEntryMaxChars;
+    ttlMs;
+    now;
+    constructor(sizeOf, opts = {}) {
+        this.sizeOf = sizeOf;
+        this.maxEntries = opts.maxEntries ?? 256;
+        this.maxTotalChars = opts.maxTotalChars ?? 64 * 1024 * 1024;
+        this.perEntryMaxChars = opts.perEntryMaxChars ?? DEFAULT_PER_ENTRY_MAX_CHARS;
+        this.ttlMs = opts.ttlMs ?? 5 * 60_000;
+        this.now = opts.now ?? (() => Date.now());
+    }
+    /**
+     * Returns `true` when this call actually started a new fetch, `false` when
+     * it was a no-op (idempotent re-prime of an id that's already pending or
+     * still live). Callers that admission-gate priming (a concurrency cap) need
+     * this to know whether they actually consumed a slot — incrementing a
+     * counter unconditionally would leak a slot on every no-op re-prime.
+     */
+    prime(id, fetch) {
+        this.sweepExpired();
+        const existing = this.map.get(id);
+        if (existing && (existing.pending || !this.isExpired(existing)))
+            return false;
+        if (existing)
+            this.map.delete(id);
+        // A synchronously-throwing fetch (destroyed webContents) is a rejection.
+        let fetched;
+        try {
+            fetched = fetch();
+        }
+        catch (err) {
+            fetched = Promise.reject(err instanceof Error ? err : new Error(String(err)));
+        }
+        const entry = {
+            promise: fetched,
+            pending: true,
+            failed: false,
+            value: null,
+            size: 0,
+            settledAt: 0,
+        };
+        entry.promise = fetched.then((v) => {
+            entry.pending = false;
+            entry.settledAt = this.now();
+            const size = this.sizeOf(v);
+            if (size > this.perEntryMaxChars) {
+                entry.failed = true;
+                throw new Error(NOT_FOUND);
+            }
+            entry.value = v;
+            entry.size = size;
+            // Refresh recency at settle time (identity-checked: a clear() while
+            // pending must not resurrect the entry) and enforce the bounds now
+            // that this entry's real size is known.
+            if (this.map.get(id) === entry) {
+                this.map.delete(id);
+                this.map.set(id, entry);
+                this.evict();
+            }
+            return v;
+        }, () => {
+            entry.pending = false;
+            entry.failed = true;
+            entry.settledAt = this.now();
+            throw new Error(NOT_FOUND);
+        });
+        // A never-looked-up sentinel must not surface as an unhandled rejection.
+        entry.promise.catch(() => { });
+        this.map.set(id, entry);
+        return true;
+    }
+    lookup(id) {
+        this.sweepExpired();
+        const e = this.map.get(id);
+        if (!e)
+            return Promise.reject(new Error(NOT_FOUND));
+        // A pending entry's normalized promise already carries the outcome the
+        // waiter needs (value, sentinel, or size overflow) — hand it out directly
+        // so the answer never races the map bookkeeping.
+        if (e.pending)
+            return e.promise;
+        if (e.failed || this.isExpired(e)) {
+            if (!e.failed)
+                this.map.delete(id);
+            return Promise.reject(new Error(NOT_FOUND));
+        }
+        const v = e.value;
+        if (v === null)
+            return Promise.reject(new Error(NOT_FOUND));
+        // A hit refreshes LRU recency.
+        this.map.delete(id);
+        this.map.set(id, e);
+        return Promise.resolve(v);
+    }
+    /** Retire a previous redirect hop without disturbing unrelated cached requests. */
+    delete(id) {
+        this.map.delete(id);
+    }
+    clear() {
+        this.map.clear();
+    }
+    get size() {
+        return this.map.size;
+    }
+    isExpired(e) {
+        return !e.pending && this.now() - e.settledAt > this.ttlMs;
+    }
+    sweepExpired() {
+        for (const [k, e] of this.map) {
+            if (this.isExpired(e))
+                this.map.delete(k);
+        }
+    }
+    /** Evict oldest SETTLED entries until both bounds hold; pending are exempt. */
+    evict() {
+        let settled = 0;
+        let total = 0;
+        for (const e of this.map.values()) {
+            if (!e.pending) {
+                settled++;
+                total += e.size;
+            }
+        }
+        if (settled <= this.maxEntries && total <= this.maxTotalChars)
+            return;
+        for (const [k, e] of this.map) {
+            if (settled <= this.maxEntries && total <= this.maxTotalChars)
+                break;
+            if (e.pending)
+                continue;
+            this.map.delete(k);
+            settled--;
+            total -= e.size;
+        }
+    }
+}
+//# sourceMappingURL=body-cache.js.map