@pasko70/pibo 1.11.4 → 1.12.0

package/dist/apps/context-files-ui/index.html

@@ -4,7 +4,7 @@
 		<meta charset="UTF-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<title>Pibo Context Files</title>
-		<script type="module" crossorigin src="/apps/context-files/assets/index-B5j33Q2B.js"></script>
+		<script type="module" crossorigin src="/apps/context-files/assets/index-CQ25ablG.js"></script>
 		<link rel="modulepreload" crossorigin href="/apps/context-files/assets/dist-D1KyNDg5.js">
 		<link rel="stylesheet" crossorigin href="/apps/context-files/assets/index-CukPnd6A.css">
 	</head>

package/dist/debug/web.js

@@ -486,7 +486,7 @@ async function runStreamingBenchmarkSeries(client, runs, durationMs, options) {
 async function runStreamingBenchmark(client, durationMs, options = {}) {
     await client.send("Page.bringToFront").catch(() => undefined);
     const benchmarkTimeoutMs = durationMs + (options.startBackendFixture ? 20_000 : 10_000);
-    const benchmark = await client.evaluate(buildStreamingBenchmarkExpression(durationMs, options), benchmarkTimeoutMs);
+    const benchmark = await client.evaluateJson(buildStreamingBenchmarkExpression(durationMs, options), benchmarkTimeoutMs);
     const withRenderOrder = { ...benchmark, renderOrder: analyzeStreamingRenderOrderCapture(benchmark.renderOrder) };
     const withProvider = { ...withRenderOrder, provider: options.providerTelemetry };
     const scored = { ...withProvider, score: scoreStreamingBenchmark(withProvider), providerPreservation: summarizeStreamingProviderPreservation(withProvider) };

package/dist/tools/cdp-client.js

@@ -1,5 +1,7 @@
+import { randomUUID } from "node:crypto";
 export const DEFAULT_CDP_URL = "http://127.0.0.1:56663";
 export const DEFAULT_CDP_TIMEOUT_MS = 2_500;
+const CDP_JSON_CHUNK_SIZE = 256 * 1024;
 export class CdpClient {
     webSocketUrl;
     nextId = 0;
@@ -32,10 +34,11 @@ export class CdpClient {
             socket.addEventListener("open", succeed);
             socket.addEventListener("message", (event) => this.handleMessage(String(event.data)));
             socket.addEventListener("error", () => fail(new Error(`CDP WebSocket error connecting to ${this.webSocketUrl}`)));
-            socket.addEventListener("close", () => {
+            socket.addEventListener("close", (event) => {
+                const detail = `code ${event.code}${event.reason ? `: ${event.reason}` : ""}`;
                 for (const [id, pending] of this.pending) {
                     clearTimeout(pending.timer);
-                    pending.reject(new Error("CDP target closed"));
+                    pending.reject(new Error(`CDP target closed during ${pending.method} (${detail})`));
                     this.pending.delete(id);
                 }
             });
@@ -51,11 +54,17 @@ export class CdpClient {
                 this.pending.delete(id);
                 reject(new Error(`Timed out waiting for CDP method ${method}`));
             }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
+            this.pending.set(id, { method, resolve, reject, timer });
         });
         this.socket.send(JSON.stringify(payload));
         return promise;
     }
+    sendDetached(method, params) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN)
+            return;
+        const id = ++this.nextId;
+        this.socket.send(JSON.stringify(params ? { id, method, params } : { id, method }));
+    }
     async evaluate(expression, timeoutMs = 10_000) {
         const response = await this.send("Runtime.evaluate", {
             expression,
@@ -67,6 +76,72 @@ export class CdpClient {
             throw new Error(`Browser evaluation failed: ${JSON.stringify(response.exceptionDetails)}`);
         return response.result?.value;
     }
+    async evaluateJson(expression, timeoutMs = 10_000) {
+        const deadlineMs = Date.now() + timeoutMs;
+        const cleanupReserveMs = Math.min(100, Math.max(1, Math.floor(timeoutMs / 10)));
+        const transferDeadlineMs = deadlineMs - cleanupReserveMs;
+        const storageKey = `__piboCdpJsonResult_${randomUUID()}`;
+        const keyLiteral = JSON.stringify(storageKey);
+        try {
+            const descriptor = await this.evaluate(`(async () => {
+				const deadlineMs = ${deadlineMs};
+				if (Date.now() >= deadlineMs) throw new Error("CDP JSON evaluation exceeded its deadline");
+				const state = { cancelled: false, json: undefined, cleanupTimer: undefined };
+				Object.defineProperty(globalThis, ${keyLiteral}, { value: state, configurable: true });
+				state.cleanupTimer = setTimeout(() => {
+					state.cancelled = true;
+					if (globalThis[${keyLiteral}] === state) delete globalThis[${keyLiteral}];
+				}, Math.max(0, deadlineMs - Date.now()));
+				try {
+					const value = await (${expression});
+					const json = JSON.stringify(value);
+					if (typeof json !== "string") throw new Error("CDP evaluation result is not JSON serializable");
+					if (Date.now() >= deadlineMs || state.cancelled || globalThis[${keyLiteral}] !== state) throw new Error("CDP JSON evaluation exceeded its deadline");
+					state.json = json;
+					return { length: json.length };
+				} catch (error) {
+					state.cancelled = true;
+					clearTimeout(state.cleanupTimer);
+					if (globalThis[${keyLiteral}] === state) delete globalThis[${keyLiteral}];
+					throw error;
+				}
+			})()`, remainingTime(transferDeadlineMs, "evaluating JSON through CDP"));
+            if (!Number.isInteger(descriptor?.length) || descriptor.length < 0)
+                throw new Error("CDP evaluation returned an invalid JSON result length");
+            const chunks = [];
+            for (let offset = 0; offset < descriptor.length; offset += CDP_JSON_CHUNK_SIZE) {
+                const end = Math.min(descriptor.length, offset + CDP_JSON_CHUNK_SIZE);
+                chunks.push(await this.evaluate(`(() => {
+					const state = globalThis[${keyLiteral}];
+					if (!state || typeof state.json !== "string") throw new Error("CDP JSON result storage is unavailable");
+					return state.json.slice(${offset}, ${end});
+				})()`, remainingTime(transferDeadlineMs, "retrieving JSON chunks through CDP")));
+            }
+            return JSON.parse(chunks.join(""));
+        }
+        finally {
+            const cleanupExpression = `(() => {
+				const state = globalThis[${keyLiteral}];
+				if (state && typeof state === "object") {
+					state.cancelled = true;
+					clearTimeout(state.cleanupTimer);
+				}
+				return delete globalThis[${keyLiteral}];
+			})()`;
+            const cleanupTimeoutMs = remainingTimeOrZero(deadlineMs);
+            if (cleanupTimeoutMs > 0) {
+                await this.evaluate(cleanupExpression, cleanupTimeoutMs).catch(() => undefined);
+            }
+            else {
+                this.sendDetached("Runtime.evaluate", {
+                    expression: cleanupExpression,
+                    awaitPromise: true,
+                    returnByValue: true,
+                    userGesture: true,
+                });
+            }
+        }
+    }
     close() {
         try {
             this.socket?.close();
@@ -187,3 +262,12 @@ function optionalStringValue(value) {
     const text = stringValue(value);
     return text || undefined;
 }
+function remainingTime(deadlineMs, operation) {
+    const remainingMs = remainingTimeOrZero(deadlineMs);
+    if (remainingMs <= 0)
+        throw new Error(`Timed out ${operation}`);
+    return remainingMs;
+}
+function remainingTimeOrZero(deadlineMs) {
+    return Math.max(0, Math.floor(deadlineMs - Date.now()));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.11.4",
+  "version": "1.12.0",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"