@north-light/crouter 0.3.172 → 0.3.174

package/dist/clients/inbox/review/launch.js

@@ -1,129 +1,89 @@
-import { ApiError } from '../../../api/errors.js';
-import { CompanionRegion } from '../../conversation/region.js';
-import { createCommentAuthority } from './comments-client.js';
-import { ReviewCompositionComponent } from './composition.js';
-import { DocumentRegion } from './document-region.js';
+import { ReviewDocumentSurface } from './document-surface.js';
 import { openLiveSource } from './live-source.js';
-import { createReviewClient, ReviewTerminalError } from './review-client.js';
-/** Mount the canonical live-document and companion-conversation review. */
-export async function openComposedReview(host, opts) {
-    if (host.capabilities.remote) {
-        host.notice('The composed review is unavailable in a remote attach — the file and companion live on the host.');
-        return;
-    }
-    const reviewClient = createReviewClient();
-    let opened;
-    try {
-        opened = await reviewClient.open(opts.reviewId);
-    }
-    catch (error) {
-        host.notice(error instanceof ReviewTerminalError
-            ? terminalRefusalNotice(error)
-            : `couldn't open review: ${describeError(error)}`);
-        return;
-    }
+import { createReviewClient } from './review-client.js';
+/** Mount the review document. Both callers — the inbox's `ReviewAdapter` and
+ *  the viewer's `launchFileReview` — refuse a remote attach and resolve the
+ *  review record themselves, so this function is never reached from a remote
+ *  viewer and never reads a review record of its own. */
+export async function openReviewSurface(host, opts) {
+    const review = opts.review;
     let source;
     try {
-        source = openLiveSource(opened.file);
+        source = openLiveSource(review.file);
     }
     catch (error) {
-        host.notice(`couldn't open ${opened.file}: ${describeError(error)}`);
+        host.notice(`couldn't open ${review.file}: ${describeError(error)}`);
         return;
     }
-    const comments = createCommentAuthority(opened.reviewId);
+    let terminalConflict = false;
+    const reviewClient = createReviewClient({
+        onTerminalConflict: (notice) => {
+            terminalConflict = true;
+            surface.teardown(notice);
+        },
+    });
+    const comments = reviewClient.comments(review.reviewId);
     let handle;
-    let composition;
     let submitting = false;
-    const documentRegion = new DocumentRegion({
-        reviewId: opened.reviewId,
-        absFile: opened.file,
-        cwd: opened.cwd,
+    let canceling = false;
+    const surface = new ReviewDocumentSurface({
+        review,
         source,
         comments,
+        callerPane: host.capabilities.selfPane,
         services: {
-            notice: (text) => host.notice(text),
-            suspendForChild: () => {
-                const resumeHost = host.suspendForChild();
-                const resumeComposition = composition?.suspendForChild() ?? (() => { });
-                let resumed = false;
-                return () => {
-                    if (resumed)
-                        return;
-                    resumed = true;
-                    resumeComposition();
-                    resumeHost();
-                };
-            },
+            notice: (text, opts) => host.notice(text, opts),
+            suspendForChild: () => host.suspendForChild(),
             requestClose: () => handle?.close(),
             submit: () => { void submit(); },
+            cancel: () => { void cancel(); },
         },
     });
-    const companionRegion = new CompanionRegion({
-        companionNodeId: opened.companionNodeId,
-        tui: opts.tui,
-        canvasSource: opts.canvasSource,
-        reopenDormantCompanion: async () => {
-            await reviewClient.open(opened.reviewId);
-        },
-        onRequestClose: () => handle?.close(),
-    });
-    await documentRegion.open();
-    composition = new ReviewCompositionComponent({
-        document: documentRegion,
-        companion: companionRegion,
-        notice: (text) => host.notice(text),
-        onRequestClose: () => { },
-    });
-    handle = host.mount(composition);
-    composition.setHandle(handle);
-    void companionRegion.open();
+    await surface.open();
+    handle = host.mount(surface);
+    surface.setHandle(handle);
+    // The conversation is opened only once the document is standing, so a tmux
+    // refusal costs the person a notice rather than the review. The tmux calls
+    // are blocking subprocesses, so they are deferred past the render tick the
+    // mount just scheduled — a macrotask lands after it, a microtask would not.
+    setImmediate(() => { surface.openCompanion(); });
     async function submit() {
         if (submitting)
             return;
         submitting = true;
         try {
-            const result = await reviewClient.submit(opened.reviewId);
-            host.notice(approvalNotice(result));
-            handle?.close();
+            const result = await reviewClient.submit(review.reviewId);
+            surface.teardown(approvalNotice(result));
         }
         catch (error) {
-            const conflict = terminalConflictNotice(error);
-            if (conflict !== undefined) {
-                host.notice(conflict);
-                handle?.close();
+            if (terminalConflict)
                 return;
-            }
             submitting = false;
             host.notice(`couldn't submit review: ${describeError(error)}`);
         }
     }
-}
-function terminalRefusalNotice(error) {
-    if (error.state === 'approved')
-        return `This review was already approved. Result: ${error.resultPath ?? 'unknown'}`;
-    return error.reason === undefined || error.reason === '' ? 'This review was canceled.' : `This review was canceled: ${error.reason}`;
+    async function cancel() {
+        if (canceling)
+            return;
+        canceling = true;
+        try {
+            await reviewClient.cancel(review.reviewId, 'canceled from the review surface');
+            surface.teardown('Review canceled.');
+        }
+        catch (error) {
+            if (terminalConflict)
+                return;
+            // Nothing moved: the review is still open and both panes stand.
+            canceling = false;
+            host.notice(`couldn't cancel review: ${describeError(error)}`);
+        }
+    }
 }
 function approvalNotice(result) {
     return result.changed
         ? `Approved — the document changed during review. Result: ${result.resultPath}`
         : `Approved — the document was not modified. Result: ${result.resultPath}`;
 }
-function terminalConflictNotice(error) {
-    if (!(error instanceof ApiError) || error.status !== 409 || error.code !== 'review_terminal_conflict')
-        return undefined;
-    const review = error.details?.review;
-    if (review === undefined)
-        return undefined;
-    if (review.state === 'approved')
-        return review.result_path === undefined
-            ? 'This review was already approved by someone else.'
-            : `This review was already approved by someone else. Result: ${review.result_path}`;
-    if (review.state === 'canceled')
-        return review.cancel_reason === undefined || review.cancel_reason === ''
-            ? 'This review was canceled before this submission landed.'
-            : `This review was canceled before this submission landed: ${review.cancel_reason}`;
-    return undefined;
-}
 function describeError(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/clients/inbox/review/nvim.d.ts

@@ -1,6 +1,8 @@
 /**
  * Open the reviewed file in the user's configured editor, optionally at a specific line.
  * Resolves $VISUAL, then $EDITOR, then falls back to 'vi'.
+ * The configured value may be a shell fragment such as "code --wait" — it runs whole
+ * through /bin/sh, exactly like the comment-compose round-trip editor.
  * For vi-family editors (nvim, vim, vi, view), passes the line with the +line syntax.
  * For other editors, opens the file without line positioning.
  *

package/dist/clients/inbox/review/nvim.js

@@ -2,6 +2,8 @@ import { spawnSync } from 'node:child_process';
 /**
  * Open the reviewed file in the user's configured editor, optionally at a specific line.
  * Resolves $VISUAL, then $EDITOR, then falls back to 'vi'.
+ * The configured value may be a shell fragment such as "code --wait" — it runs whole
+ * through /bin/sh, exactly like the comment-compose round-trip editor.
  * For vi-family editors (nvim, vim, vi, view), passes the line with the +line syntax.
  * For other editors, opens the file without line positioning.
  *
@@ -10,28 +12,28 @@ import { spawnSync } from 'node:child_process';
  * @returns An object with an optional `error` property if the editor launch or execution failed
  */
 export function openReviewedFileInEditor(absFile, line) {
-    const editor = process.env.VISUAL ?? process.env.EDITOR ?? 'vi';
-    // Extract the first shell token (the command itself)
-    const firstToken = editor.trim().split(/\s+/)[0];
-    if (!firstToken) {
+    const editor = (process.env.VISUAL ?? process.env.EDITOR ?? 'vi').trim();
+    if (!editor) {
         return { error: 'editor configuration is empty' };
     }
-    // Determine if this is a vi-family editor
+    // Determine if this is a vi-family editor from the fragment's command token
+    const firstToken = editor.split(/\s+/)[0] ?? '';
     const editorBasename = firstToken.split('/').pop() || firstToken;
     const isViFamily = ['nvim', 'vim', 'vi', 'view'].includes(editorBasename);
-    // Build the command arguments
-    const args = isViFamily ? [`+${line}`, absFile] : [absFile];
+    const lineArg = isViFamily ? ` "+${line}"` : '';
     try {
-        const result = spawnSync(firstToken, args, { stdio: 'inherit' });
-        // Check for errors
+        const result = spawnSync('/bin/sh', ['-c', `${editor}${lineArg} "$1"`, 'sh', absFile], { stdio: 'inherit' });
         if (result.error) {
-            return { error: result.error.message };
+            return { error: `$EDITOR ("${editor}") failed to launch: ${result.error.message}` };
         }
         if (result.signal !== null) {
-            return { error: `editor was killed by signal ${result.signal}` };
+            return { error: `$EDITOR ("${editor}") was killed by signal ${result.signal}` };
+        }
+        if (result.status === 127 || result.status === 126) {
+            return { error: `$EDITOR ("${editor}") failed to launch (shell exit ${result.status}) — check $VISUAL/$EDITOR` };
         }
         if (result.status !== 0) {
-            return { error: `editor exited with code ${result.status}` };
+            return { error: `$EDITOR ("${editor}") exited with code ${result.status}` };
         }
         return {};
     }

package/dist/clients/inbox/review/review-client.d.ts

@@ -1,3 +1,4 @@
+import { type CommentAuthority } from './comments-client.js';
 export declare class ReviewTerminalError extends Error {
     readonly state: 'approved' | 'canceled';
     readonly resultPath?: string;
@@ -5,26 +6,29 @@ export declare class ReviewTerminalError extends Error {
     constructor(state: 'approved', resultPath: string);
     constructor(state: 'canceled', reason?: string);
 }
-export interface OpenedReview {
+export interface ResolvedReview {
     reviewId: string;
     companionNodeId: string;
     file: string;
     cwd: string;
 }
 export interface ReviewClient {
-    open(reviewId: string): Promise<OpenedReview>;
-    byBridge(bridgeNodeId: string): Promise<{
-        reviewId: string;
-    }>;
+    byBridge(bridgeNodeId: string): Promise<ResolvedReview>;
     createInline(p: {
         originNodeId: string;
         file: string;
-    }): Promise<OpenedReview>;
+    }): Promise<ResolvedReview>;
+    comments(reviewId: string): CommentAuthority;
     submit(reviewId: string): Promise<{
         changed: boolean;
         resultPath: string;
     }>;
     cancel(reviewId: string, reason: string): Promise<void>;
 }
-/** The terminal's complete daemon seam for review lifecycle operations. */
-export declare function createReviewClient(): ReviewClient;
+export interface ReviewClientOptions {
+    onTerminalConflict?: (notice: string) => void;
+}
+/** The terminal's complete daemon seam for review lifecycle and comment operations. */
+export declare function createReviewClient(opts?: ReviewClientOptions): ReviewClient;
+export declare function terminalRefusalNotice(error: ReviewTerminalError): string;
+export declare function terminalConflictNotice(error: unknown): string | undefined;

package/dist/clients/inbox/review/review-client.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { ApiError } from '../../../api/errors.js';
 import { cliClient } from '../../../commands/api-client.js';
+import { createCommentAuthority } from './comments-client.js';
 export class ReviewTerminalError extends Error {
     state;
     resultPath;
@@ -21,49 +22,52 @@ export class ReviewTerminalError extends Error {
         this.state = state;
     }
 }
-/** The terminal's complete daemon seam for review lifecycle operations. */
-export function createReviewClient() {
+/** The terminal's complete daemon seam for review lifecycle and comment operations. */
+export function createReviewClient(opts = {}) {
+    const request = async (operation) => {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            const notice = terminalConflictNotice(error);
+            if (notice !== undefined)
+                opts.onTerminalConflict?.(notice);
+            throw error;
+        }
+    };
     return {
-        async open(reviewId) {
-            try {
-                const opened = await cliClient().openReview(reviewId);
-                if (opened.disposition === 'terminal')
-                    throw terminalError(opened.review);
-                return await openedReview(opened.review, opened.companion_node_id);
-            }
-            catch (error) {
-                throw terminalErrorFromApi(error);
-            }
-        },
         async byBridge(bridgeNodeId) {
-            const review = await cliClient().getReviewByBridge(bridgeNodeId);
-            return { reviewId: review.review_id };
+            const review = await request(() => cliClient().getReviewByBridge(bridgeNodeId));
+            return await resolveReview(review, review.companion_node_id, request);
         },
         async createInline(p) {
-            const review = await cliClient().createReview({
+            const review = await request(() => cliClient().createReview({
                 origin_kind: 'inline',
                 origin_node_id: p.originNodeId,
                 file: p.file,
                 idempotency_key: randomUUID(),
-            });
-            return await openedReview(review, review.companion_node_id);
+            }));
+            return await resolveReview(review, review.companion_node_id, request);
+        },
+        comments(reviewId) {
+            return createCommentAuthority(reviewId, request);
         },
         async submit(reviewId) {
-            const submitted = await cliClient().submitReview(reviewId);
+            const submitted = await request(() => cliClient().submitReview(reviewId));
             return {
                 changed: requireChanged(submitted.review),
                 resultPath: requireResultPath(submitted.review),
             };
         },
         async cancel(reviewId, reason) {
-            await cliClient().cancelReview(reviewId, { reason, actor: 'human' });
+            await request(() => cliClient().cancelReview(reviewId, { reason, actor: 'human' }));
         },
     };
 }
-async function openedReview(review, companionNodeId) {
+async function resolveReview(review, companionNodeId, request) {
     if (review.state !== 'open')
         throw terminalError(review);
-    const companion = await cliClient().getNode(companionNodeId);
+    const companion = await request(() => cliClient().getNode(companionNodeId));
     return {
         reviewId: review.review_id,
         companionNodeId,
@@ -71,14 +75,6 @@ async function openedReview(review, companionNodeId) {
         cwd: companion.cwd,
     };
 }
-function terminalErrorFromApi(error) {
-    if (!(error instanceof ApiError) || error.status !== 409 || error.code !== 'review_terminal_conflict')
-        return error;
-    const review = error.details?.review;
-    if (!isTerminalReview(review))
-        return error;
-    return terminalError(review);
-}
 function terminalError(review) {
     if (review.state !== 'approved' && review.state !== 'canceled') {
         throw new Error(`terminal review ${review.review_id} has invalid state ${review.state}`);
@@ -99,9 +95,24 @@ function requireResultPath(review) {
     }
     return review.result_path;
 }
-function isTerminalReview(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const state = value.state;
-    return state === 'approved' || state === 'canceled';
+export function terminalRefusalNotice(error) {
+    if (error.state === 'approved')
+        return `This review was already approved. Result: ${error.resultPath ?? 'unknown'}`;
+    return error.reason === undefined || error.reason === '' ? 'This review was canceled.' : `This review was canceled: ${error.reason}`;
+}
+export function terminalConflictNotice(error) {
+    if (!(error instanceof ApiError) || error.status !== 409 || error.code !== 'review_terminal_conflict')
+        return undefined;
+    const review = error.details?.review;
+    if (review === undefined)
+        return undefined;
+    if (review.state === 'approved')
+        return review.result_path === undefined
+            ? 'This review was already approved by someone else.'
+            : `This review was already approved by someone else. Result: ${review.result_path}`;
+    if (review.state === 'canceled')
+        return review.cancel_reason === undefined || review.cancel_reason === ''
+            ? 'This review was canceled before this submission landed.'
+            : `This review was canceled before this submission landed: ${review.cancel_reason}`;
+    return undefined;
 }

package/dist/clients/inbox/review-adapter.d.ts

@@ -1,20 +1,13 @@
-import type { TUI } from '@earendil-works/pi-tui';
-import type { CanvasSource } from '../../core/canvas/source.js';
 import type { SurfaceHost } from '../surfaces/host.js';
 export interface ReviewAdapterOptions {
     host: SurfaceHost;
     dir: string;
-    /** Threaded from the attach session so the composed surface can attach the
-     *  companion's transcript through the same terminal and canvas read authority
-     *  the outer viewer already holds. */
-    tui: TUI;
-    canvasSource: CanvasSource;
 }
 /**
  * Resolves a durable review ticket to its canonical daemon review and mounts
- * the one composed terminal review surface. Approval flows entirely through
- * `reviewClient.submit` inside that composition — this adapter owns only the
- * bridge lookup and the mounted surface's lifecycle.
+ * the one terminal review surface. Approval flows entirely through
+ * `reviewClient.submit` inside that surface — this adapter owns only the
+ * remote refusal, the bridge lookup, and the mounted surface's lifecycle.
  */
 export declare class ReviewAdapter {
     private readonly opts;

package/dist/clients/inbox/review-adapter.js

@@ -1,12 +1,12 @@
 import { basename } from 'node:path';
 import { ApiError } from '../../api/errors.js';
-import { openComposedReview } from './review/launch.js';
-import { createReviewClient } from './review/review-client.js';
+import { openReviewSurface } from './review/launch.js';
+import { createReviewClient, ReviewTerminalError, terminalRefusalNotice } from './review/review-client.js';
 /**
  * Resolves a durable review ticket to its canonical daemon review and mounts
- * the one composed terminal review surface. Approval flows entirely through
- * `reviewClient.submit` inside that composition — this adapter owns only the
- * bridge lookup and the mounted surface's lifecycle.
+ * the one terminal review surface. Approval flows entirely through
+ * `reviewClient.submit` inside that surface — this adapter owns only the
+ * remote refusal, the bridge lookup, and the mounted surface's lifecycle.
  */
 export class ReviewAdapter {
     opts;
@@ -32,15 +32,19 @@ export class ReviewAdapter {
             await this.running;
     }
     async run() {
+        // The refusal precedes the record read: a remote viewer can reach neither
+        // the reviewed file nor the companion's pane.
+        if (this.opts.host.capabilities.remote) {
+            this.opts.host.notice('The review is unavailable in a remote attach — the file and companion live on the host.');
+            return;
+        }
         const bridgeNodeId = basename(this.opts.dir);
-        let reviewId;
+        let review;
         try {
-            ({ reviewId } = await createReviewClient().byBridge(bridgeNodeId));
+            review = await createReviewClient().byBridge(bridgeNodeId);
         }
         catch (error) {
-            if (!isReviewPredatesSystem(error))
-                throw error;
-            this.opts.host.notice('This review predates canonical review records — cancel it and re-file the review.');
+            this.opts.host.notice(noticeForBridgeFailure(error));
             return;
         }
         if (this.stopped)
@@ -54,13 +58,9 @@ export class ReviewAdapter {
                 resolveClosed();
             });
         });
-        await openComposedReview(host, {
-            reviewId,
-            tui: this.opts.tui,
-            canvasSource: this.opts.canvasSource,
-        });
-        // A remote refusal, a terminal-review notice, or a live-source failure
-        // reports through `host.notice` and returns without ever mounting.
+        await openReviewSurface(host, { review });
+        // A live-source failure reports through `host.notice` and returns without
+        // ever mounting.
         if (this.mountedHandle === undefined)
             return;
         if (this.stopped) {
@@ -70,7 +70,7 @@ export class ReviewAdapter {
         await closed;
     }
 }
-/** Observes the one surface `openComposedReview` mounts so this adapter can
+/** Observes the one surface `openReviewSurface` mounts so this adapter can
  *  await its close and close it itself from `stop()`, without widening
  *  `SurfaceHost` or reaching into the real host's internals. */
 function wrapHostForMount(host, onMount) {
@@ -81,12 +81,20 @@ function wrapHostForMount(host, onMount) {
             onMount(handle);
             return handle;
         },
-        notice: (text) => host.notice(text),
+        notice: (text, opts) => host.notice(text, opts),
         suspendForChild: () => host.suspendForChild(),
         focusNode: (nodeId) => host.focusNode(nodeId),
         pickReviewFile: (spec) => host.pickReviewFile(spec),
     };
 }
+function noticeForBridgeFailure(error) {
+    if (error instanceof ReviewTerminalError)
+        return terminalRefusalNotice(error);
+    if (isReviewPredatesSystem(error)) {
+        return 'This review predates canonical review records — cancel it and re-file the review.';
+    }
+    return error instanceof Error ? error.message : String(error);
+}
 function isReviewPredatesSystem(error) {
     return error instanceof ApiError && error.status === 409 && error.code === 'review_predates_system';
 }

package/dist/clients/inbox/surface.d.ts

@@ -1,11 +1,7 @@
-import type { TUI } from '@earendil-works/pi-tui';
 import type { SurfaceHost } from '../surfaces/host.js';
 import type { TicketSummary } from '../../core/human/types.js';
-import type { CanvasSource } from '../../core/canvas/source.js';
 export interface InboxSurfaceOptions {
     host: SurfaceHost;
-    tui: TUI;
-    canvasSource: CanvasSource;
     /** Injection seams for tests; production passes none. */
     scan?: () => TicketSummary[];
 }

package/dist/clients/inbox/surface.js

@@ -65,8 +65,6 @@ export function createInboxSurface(opts) {
         const localScan = opts.scan ?? scanInbox;
         const nextController = new InboxController({
             host: opts.host,
-            tui: opts.tui,
-            canvasSource: opts.canvasSource,
             onDirty: () => current.handle?.invalidate(),
             onClosed: close,
             scan: () => filterVisibleReviewTickets(localScan(), current.visibleIds),

package/dist/clients/surfaces/host.d.ts

@@ -9,11 +9,16 @@ import type { Component } from '@earendil-works/pi-tui';
 export interface SurfaceComponent extends Component {
     /** Set the number of rows assigned by the host for the next render. */
     setRows(rows: number): void;
-    /** Consume wheel input at the terminal's 1-based column, when applicable. */
-    handleWheel?(direction: 'up' | 'down', lines: number, column: number): boolean;
+    /** Consume wheel input when applicable. */
+    handleWheel?(direction: 'up' | 'down', lines: number): boolean;
 }
 /** The identities used for mounted Phase 3 surfaces. */
 export type SurfaceId = 'inbox' | 'review';
+/** How long a notice stays up. */
+export interface SurfaceNoticeOptions {
+    /** Keep the notice up until it is replaced or cleared, with no auto-clear. */
+    sticky?: boolean;
+}
 /**
  * The only host boundary available to a surface. Surfaces render only through
  * the mounted component and use {@link notice} as their only output channel;
@@ -29,7 +34,7 @@ export interface SurfaceHost {
         focus?: Component;
     }): SurfaceHandle;
     /** Report transient output through the host; this is the only surface output channel. */
-    notice(text: string): void;
+    notice(text: string, opts?: SurfaceNoticeOptions): void;
     /**
      * Temporarily release the terminal for a child process and return a resume
      * closure. Callers must invoke the closure in a `finally` block.
@@ -49,6 +54,9 @@ export interface SurfaceHost {
         readonly remote: boolean;
         /** True when focusing another node's viewer is available. */
         readonly canFocusNode: boolean;
+        /** This viewer's own tmux pane — the target a surface splits against.
+         *  Undefined outside tmux. */
+        readonly selfPane: string | undefined;
     };
 }
 /** A mounted surface's lifecycle controls. */

package/dist/commands/__tests__/api-client-cold-start-diagnostic.test.js

@@ -4,17 +4,16 @@
 // (`../api-client.ts`) is what `cliClient()` wires into `CrtrClient` as
 // `coldStartDiagnostic` — this proves it reads a BOUNDED tail of crtrd.err
 // (never the whole file) and degrades to `undefined` (not a throw) when the
-// log is missing. The two tests below prove the READ itself is bounded (not
-// just the returned string) — the prior implementation `readFileSync`'d the
-// whole append-only log before slicing, which allocates/blocks unboundedly on
-// a runaway log. Node ESM snapshots named imports of builtins at load time
+// log is missing. The final test proves the READ itself is bounded (not just
+// the returned string) — the prior implementation `readFileSync`'d the whole
+// append-only log before slicing, which allocates/blocks unboundedly on a
+// runaway log. Node ESM snapshots named imports of builtins at load time
 // (mocking `node:fs` per-call does not reach `api-client.ts`'s own import
-// binding), so both tests exercise real I/O instead of spying on it: one
-// proves the read stays fast/cheap against a huge (sparse) file, the other
-// proves the byte offset the read starts from is exact.
+// binding), so it exercises real I/O instead of spying on it: the byte offset
+// the read starts from is exact.
 import { after, before, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { closeSync, ftruncateSync, mkdtempSync, openSync, rmSync, writeFileSync, writeSync } from 'node:fs';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { COLD_START_DIAGNOSTIC_TAIL_BYTES, readColdStartDiagnostic } from '../api-client.js';
 let home;
@@ -55,32 +54,6 @@ test('bounds the tail instead of leaking the whole log', () => {
     assert.match(diagnostic, /line 4999/);
     assert.doesNotMatch(diagnostic, /line 0:/);
 });
-test('bounds the READ itself — stays fast/cheap against a huge sparse log instead of materializing it whole', () => {
-    // A sparse 400MB file: `ftruncateSync` sets the logical size instantly
-    // without writing 400MB of real content, so creating it is cheap, but a
-    // `readFileSync` of the whole file would still have to MATERIALIZE all
-    // 400MB into a JS string — measurably (100ms+) slower than a bounded tail
-    // read (sub-millisecond). The marker sits inside the final
-    // `COLD_START_DIAGNOSTIC_TAIL_BYTES` so a correctly bounded read still
-    // surfaces it.
-    const path = join(home, 'crtrd.err');
-    const size = 400 * 1024 * 1024;
-    const marker = 'Error: EADDRINUSE (huge-log marker)\n';
-    const fd = openSync(path, 'w');
-    ftruncateSync(fd, size);
-    writeSync(fd, Buffer.from(marker), 0, marker.length, size - 200);
-    closeSync(fd);
-    const startedAt = performance.now();
-    const diagnostic = readColdStartDiagnostic();
-    const elapsedMs = performance.now() - startedAt;
-    assert.match(diagnostic ?? '', /EADDRINUSE \(huge-log marker\)/);
-    // A bounded 4KB read finishes in low single-digit ms; a whole-file
-    // `readFileSync` of 400MB measured ~150-175ms locally (and scales with log
-    // size, which is exactly the unbounded-resource bug) — 100ms leaves ample
-    // margin above the bounded read and below the whole-file read even on a
-    // slower CI runner.
-    assert.ok(elapsedMs < 100, `expected a bounded read well under 100ms, took ${elapsedMs.toFixed(2)}ms`);
-});
 test('bounds the READ itself — the tail window starts at an exact byte offset, not an in-memory slice', () => {
     // Bytes immediately BEFORE the tail window must never be read at all, not
     // just excluded from the output — place a sentinel there and one at the