@reticlehq/server 3.8.0 → 3.8.1

package/dist/memory/journal/self-observation.js

@@ -46,6 +46,7 @@ const NET_TYPES = new Set([
     EventType.NET_REQUEST,
     EventType.NET_PENDING,
     EventType.NET_DETAIL,
+    EventType.NET_RESPONSE_BODY,
     EventType.NET_STREAM,
 ]);
 /** A base for parsing relative URLs. Never dereferenced — only the path is read. */
@@ -60,8 +61,9 @@ function pathOf(url) {
 }
 /** True when this event is the page fetching Reticle's own code rather than doing anything. */
 export function isSelfObservation(event) {
-    if (!NET_TYPES.has(event.type))
+    if (!NET_TYPES.has(event.type)) {
         return false;
+    }
     const path = pathOf(urlForMatch(event.data));
     return path.includes(SCOPE_PATH) || path.includes(SCOPE_FLATTENED);
 }

package/dist/memory/journal/session-journal.js

@@ -49,8 +49,9 @@ const CACHE_COMPACT_AT = 1024;
  * bound is used in and silently disable it, which is the one failure mode a bound must not have.
  */
 function boundedOption(value, fallback, name) {
-    if (value === undefined)
+    if (value === undefined) {
         return fallback;
+    }
     if (!Number.isSafeInteger(value) || value <= 0) {
         throw new Error(`refusing a journal ${name} that is not a positive whole number: ${String(value)}`);
     }
@@ -184,11 +185,13 @@ export class SessionJournal {
      * already on disk is deleted, and the loss is at the end where it can be declared.
      */
     async appendEvents(events) {
-        if (0 === events.length)
+        if (0 === events.length) {
             return;
+        }
         // Durable, not a field: see #writeLoss. A closed ledger is closed for a one-event batch too.
-        if ((await this.#closureReport()) !== undefined)
+        if ((await this.#closureReport()) !== undefined) {
             return;
+        }
         await this.#ensureDir();
         const path = journalEventsPath(this.#root, this.#sessionId);
         const written = await this.#eventBytesOnDisk(path);
@@ -221,8 +224,9 @@ export class SessionJournal {
      */
     async #eventBytesOnDisk(path) {
         const known = this.#eventBytes;
-        if (known !== undefined)
+        if (known !== undefined) {
             return known;
+        }
         let size;
         try {
             size = (await this.#fs.stat(path)).size;
@@ -235,8 +239,9 @@ export class SessionJournal {
             // by exactly the conditions most likely to accompany a failing disk. Thrown before anything is
             // appended; `JournalRecorder` swallows sink errors, so a live session is never taken down by
             // one.
-            if (!this.#fs.isNotFound(error))
+            if (!this.#fs.isNotFound(error)) {
                 throw error;
+            }
             size = 0;
         }
         this.#eventBytes = size;
@@ -252,16 +257,18 @@ export class SessionJournal {
      * necessarily the ceiling that closed the file.
      */
     async #closureReport() {
-        if (this.#lossLoaded)
+        if (this.#lossLoaded) {
             return this.#writeLoss;
+        }
         let text;
         try {
             text = await this.#fs.readFile(journalClosedPath(this.#root, this.#sessionId));
         }
         catch (error) {
             // Same rule as the size read above, and for the same reason: only ENOENT is "never closed".
-            if (!this.#fs.isNotFound(error))
+            if (!this.#fs.isNotFound(error)) {
                 throw error;
+            }
             this.#lossLoaded = true;
             return undefined;
         }
@@ -371,8 +378,9 @@ export class SessionJournal {
             await this.#fs.appendFile(path, text);
         }
         catch (error) {
-            if (!this.#fs.isNotFound(error))
+            if (!this.#fs.isNotFound(error)) {
                 throw error;
+            }
             this.#dirEnsured = false;
             await this.#ensureDir();
             await this.#fs.appendFile(path, text);
@@ -390,8 +398,9 @@ export class SessionJournal {
                 chunk = await readFrom(path, this.#eventBytesConsumed, this.#maxReadBytes);
             }
             catch (error) {
-                if (this.#fs.isNotFound(error))
+                if (this.#fs.isNotFound(error)) {
                     return this.#liveEvents();
+                }
                 throw error;
             }
             // Shrink guard: if the file is smaller than what we consumed, the offset is meaningless — reset
@@ -408,8 +417,9 @@ export class SessionJournal {
             const from = chunk.from ?? this.#eventBytesConsumed;
             const skipped = Math.max(0, from - this.#eventBytesConsumed);
             this.#ingestTail(chunk.text);
-            if (skipped > 0)
+            if (skipped > 0) {
                 this.#noteCut(skipped);
+            }
             // Resume at the end of the last COMPLETE line, counted forward over the bytes that actually
             // ARRIVED. Not from `chunk.size`: that is the file's end as `fstat` reported it, and a read
             // truncated or cut short returns less — a cursor there would skip every unread byte, silently
@@ -424,8 +434,9 @@ export class SessionJournal {
             text = await this.#fs.readFile(path);
         }
         catch (error) {
-            if (this.#fs.isNotFound(error))
+            if (this.#fs.isNotFound(error)) {
                 return this.#liveEvents();
+            }
             throw error;
         }
         // Fallback (whole-file) path: #eventCharsConsumed is a UTF-16 offset into the whole text. Shrink
@@ -467,11 +478,13 @@ export class SessionJournal {
      */
     #ingestTail(tail) {
         const end = tail.lastIndexOf('\n') + 1;
-        if (0 === end)
-            return; // no complete line yet
+        if (0 === end) {
+            return;
+        } // no complete line yet
         for (const line of tail.slice(0, end).split('\n')) {
-            if (0 === line.length)
+            if (0 === line.length) {
                 continue;
+            }
             let parsed;
             try {
                 parsed = JSON.parse(line);
@@ -515,8 +528,9 @@ export class SessionJournal {
             this.#droppedBytes += cost;
             this.#droppedEvents += 1;
             // Exact, unlike a byte cut: this record was parsed, so the millisecond it was lost at is known.
-            if (victim !== undefined)
+            if (victim !== undefined) {
                 this.#lostThroughT = Math.max(this.#lostThroughT, victim.t);
+            }
             // Release the payload now. Waiting for slot compaction keeps evicted snapshots strongly
             // reachable, so a short returned list alone would not bound retained evidence in memory.
             this.#eventCache[this.#cacheHead] = undefined;
@@ -545,8 +559,9 @@ export class SessionJournal {
      * is what carries this to a verdict.
      */
     readLoss() {
-        if (0 === this.#droppedBytes && 0 === this.#droppedEvents)
+        if (0 === this.#droppedBytes && 0 === this.#droppedEvents) {
             return undefined;
+        }
         const bounded = Number.isFinite(this.#lostThroughT);
         return {
             droppedBytes: this.#droppedBytes,
@@ -568,8 +583,9 @@ export class SessionJournal {
         return this.#readLines(journalActionsPath(this.#root, this.#sessionId), JournalActionSchema);
     }
     async #ensureDir() {
-        if (this.#dirEnsured)
+        if (this.#dirEnsured) {
             return;
+        }
         await this.#fs.mkdir(sessionDirPath(this.#root, this.#sessionId));
         this.#dirEnsured = true;
     }
@@ -579,14 +595,16 @@ export class SessionJournal {
             text = await this.#fs.readFile(path);
         }
         catch (error) {
-            if (this.#fs.isNotFound(error))
+            if (this.#fs.isNotFound(error)) {
                 return [];
+            }
             throw error;
         }
         const out = [];
         for (const line of text.split('\n')) {
-            if (0 === line.length)
+            if (0 === line.length) {
                 continue;
+            }
             let parsed;
             try {
                 parsed = JSON.parse(line);
@@ -596,8 +614,9 @@ export class SessionJournal {
             }
             const result = schema.safeParse(parsed);
             // Validated at this boundary; ZodTypeAny widens `.data` to any, so re-narrow to the schema output.
-            if (result.success)
+            if (result.success) {
                 out.push(result.data);
+            }
         }
         return out;
     }

package/dist/portal/input/viewport-tools.d.ts

@@ -1,24 +1,28 @@
 import { z } from 'zod';
 import type { ToolDef } from '../../surface/tools/tool-kit.js';
 import { type LeaseEmulation, type LeaseMedia } from '../pool/lease-emulation.js';
-export declare const COLOR_SCHEME_ARG: z.ZodOptional<z.ZodEnum<["light", "dark", "no-preference"]>>;
-export declare const REDUCED_MOTION_ARG: z.ZodOptional<z.ZodEnum<["reduce", "no-preference"]>>;
+export declare const COLOR_SCHEME_ARG: z.ZodOptional<z.ZodEnum<{
+    light: "light";
+    dark: "dark";
+    "no-preference": "no-preference";
+}>>;
+export declare const REDUCED_MOTION_ARG: z.ZodOptional<z.ZodEnum<{
+    reduce: "reduce";
+    "no-preference": "no-preference";
+}>>;
 export declare const LEASE_EMULATE_ARG: z.ZodOptional<z.ZodObject<{
-    colorScheme: z.ZodOptional<z.ZodEnum<["light", "dark", "no-preference"]>>;
-    reducedMotion: z.ZodOptional<z.ZodEnum<["reduce", "no-preference"]>>;
+    colorScheme: z.ZodOptional<z.ZodEnum<{
+        light: "light";
+        dark: "dark";
+        "no-preference": "no-preference";
+    }>>;
+    reducedMotion: z.ZodOptional<z.ZodEnum<{
+        reduce: "reduce";
+        "no-preference": "no-preference";
+    }>>;
     width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    width?: number | undefined;
-    height?: number | undefined;
-    colorScheme?: "light" | "dark" | "no-preference" | undefined;
-    reducedMotion?: "reduce" | "no-preference" | undefined;
-}, {
-    width?: number | undefined;
-    height?: number | undefined;
-    colorScheme?: "light" | "dark" | "no-preference" | undefined;
-    reducedMotion?: "reduce" | "no-preference" | undefined;
-}>>;
+}, z.core.$strict>>;
 /** The media part of what a caller asked for, or undefined when it asked for none. */
 export declare function mediaOf(raw: {
     colorScheme?: unknown;

package/dist/portal/pool/browser-pool.d.ts

@@ -14,61 +14,9 @@ import type { Launcher, PooledMockRule, ScreenshotOptions } from './pool-contrac
 import type { RealInputArgs, RealInputResult } from '../input/real-input.js';
 import { type LeaseEmulation, type LeaseMedia } from './lease-emulation.js';
 export type { InitScriptHandle, Launcher, PooledBrowser, PooledContext, PooledCookie, PooledDialog, PooledMockRule, PooledPage, } from './pool-contract.js';
-/** A leased context+page for one flow. `release` frees the slot and closes the context. */
-export interface Lease {
-    readonly sessionId: string;
-    readonly url: string;
-    readonly navStatus?: number;
-    release(): Promise<void>;
-    /**
-     * Hand the page the zero-install reader: evaluated in the live document, and added ahead of every
-     * document this lease loads next. False when there is no reader, or the page cannot run one.
-     * Rejects with `NotHtmlDocumentError` when the page is not an HTML document.
-     */
-    injectReader?(): Promise<boolean>;
-    /** Whether the page's document has not reached `complete` yet. False when it cannot be read. */
-    isLoading?(): Promise<boolean>;
-}
-/** Default lease time-to-live: a lease untouched for this long is presumed orphaned and reclaimed. */
-export declare const DEFAULT_LEASE_TTL_MS: number;
-/**
- * How long a lease outlives the MCP connection that took it. Long enough for an agent whose
- * connection only blipped to touch it again; short enough that a gone agent's window closes soon.
- */
-export declare const ORPHANED_LEASE_GRACE_MS = 30000;
-interface BrowserPoolOptions {
-    /** Max simultaneous leased contexts. Over-cap acquires queue. */
-    maxContexts: number;
-    /** Stable id generator for lease sessionIds (injected to stay clock-/random-free in logic). */
-    genSessionId: () => string;
-    /** Injected clock (ms). Defaults to Date.now; tests pass a controllable one. */
-    now?: () => number;
-    /** A lease untouched for longer than this is reclaimed by sweepExpired. */
-    leaseTtlMs?: number;
-    /** Per-lease navigation timeout — a page that won't load fails its own lease, never blocks a slot. */
-    navTimeoutMs?: number;
-    /**
-     * The zero-install reader, built where the daemon knows its own port and pairing token. A thunk so
-     * the ~450KB build is only read if some page ever needs it; undefined when there is none to give.
-     */
-    zeroInstallScript?: () => string | undefined;
-    /**
-     * Launches a browser with a window, for a lease somebody wants to watch. Launched only when the
-     * first headed lease is asked for. Absent: a headed lease is refused.
-     */
-    launchHeaded?: Launcher;
-}
-/** What a headed lease is refused with where no window can be opened. */
-export declare const NO_HEADED_BROWSER = "no headed browser can be opened here";
-/**
- * An acquire that asked to be refused rather than queued found every slot taken (#1535). Queued,
- * it waited behind the cap with no deadline and no status, and `reticle drive` reported the 60 s
- * timeout as a daemon shutting down. The message names the cap and the one override for it.
- */
-export declare class PoolAtCapacityError extends Error {
-    readonly max: number;
-    constructor(max: number);
-}
+import { type BrowserPoolOptions, type Lease } from './pool-lease.js';
+export { DEFAULT_LEASE_TTL_MS, NO_HEADED_BROWSER, ORPHANED_LEASE_GRACE_MS, PoolAtCapacityError, } from './pool-lease.js';
+export type { Lease } from './pool-lease.js';
 /**
  * Owns a headless browser (and, when asked, a headed one) and leases isolated contexts out of them,
  * capped at `maxContexts` across both.
@@ -171,6 +119,8 @@ export declare class BrowserPool {
     hoverLease(sessionId: string, x: number, y: number): Promise<boolean>;
     /** Set a live lease's media features, or false when this is not a lease or its page cannot. */
     emulateLease(sessionId: string, media: LeaseMedia): Promise<boolean>;
+    /** Whether this lease's page is still loading. False for a non-lease, or a page that cannot say. */
+    leaseLoading(sessionId: string): Promise<boolean>;
     /** Whether this session is a lease whose page has a real keyboard. */
     hasKeyboard(sessionId: string): boolean;
     /**