@reticlehq/server 3.8.2 → 3.9.0

package/dist/surface/tools/error-recovery.js

@@ -32,8 +32,9 @@ const ELISION = '… [elided] …';
  */
 function capMessage(message) {
     const max = TRANSPORT_LIMITS.MAX_ERROR_LENGTH;
-    if (max >= message.length)
+    if (max >= message.length) {
         return message;
+    }
     const keep = Math.floor((max - ELISION.length) / 2);
     return `${message.slice(0, keep)}${ELISION}${message.slice(message.length - keep)}`;
 }
@@ -83,8 +84,9 @@ function isUnissuedRefRefusal(message) {
 }
 /** A message that already carries its own concrete next action, so nothing should be appended. */
 function isSelfRecovering(message) {
-    if (message.includes(SELF_RECOVERING_MARKER))
+    if (message.includes(SELF_RECOVERING_MARKER)) {
         return true;
+    }
     return SELF_RECOVERING.some((rule) => rule.match.test(message));
 }
 /** The recovery hints, named so they are not free strings and can be asserted in tests. */
@@ -142,8 +144,9 @@ export const RECOVERY = {
      * carry: which of them to reach for, and that nothing was acted on.
      */
     TARGET_MISSED: 'The call was valid — the selector matched nothing on the page RIGHT NOW, and nothing was ' +
-        'acted on. Take a reticle_snapshot to see what is actually there (a view may still be ' +
-        'rendering, or the control may be named differently), then retry with what it shows. This is ' +
+        'acted on. If the message lists the nearest targets and one is the element you meant, retry ' +
+        'with its ref. If not, take a reticle_snapshot to see what is actually there (a view may still ' +
+        'be rendering, or the control may be named differently), then retry with what it shows. This is ' +
         'a miss, not a Reticle defect: there is nothing to report.',
     /**
      * The selector was underspecified, which is the caller's to fix and the same class as a miss.
@@ -464,13 +467,16 @@ const RULES = [
  * saying a server is running and the recovery saying to go start one.
  */
 export function recoveryFor(message) {
-    if (isUnissuedRefRefusal(message))
+    if (isUnissuedRefRefusal(message)) {
         return RECOVERY.UNISSUED_REF;
-    if (isSelfRecovering(message))
+    }
+    if (isSelfRecovering(message)) {
         return undefined;
+    }
     for (const rule of RULES) {
-        if (rule.match.test(message))
+        if (rule.match.test(message)) {
             return rule.hint;
+        }
     }
     return undefined;
 }
@@ -483,25 +489,31 @@ export function recoveryFor(message) {
  * this table rather than about anybody's app.
  */
 export function refusalReasonFor(rawMessage, coded) {
-    if (coded !== undefined)
+    if (coded !== undefined) {
         return REASON_OF_CODE[coded.code];
+    }
     const message = zodArrayAsSentence(rawMessage);
-    if (isUnissuedRefRefusal(message))
+    if (isUnissuedRefRefusal(message)) {
         return RefusalReason.BAD_ARGS;
+    }
     // The no-session diagnosis inspected the machine and named the cause itself, so it never reaches
     // the recovery table. It is the single largest refusal there is; missing it would gut the metric.
-    if (message.includes(SELF_RECOVERING_MARKER))
+    if (message.includes(SELF_RECOVERING_MARKER)) {
         return RefusalReason.NO_SESSION;
+    }
     for (const rule of SELF_RECOVERING) {
-        if (rule.match.test(message))
+        if (rule.match.test(message)) {
             return rule.reason;
+        }
     }
     // Same order as buildErrorPayload: a schema rejection is the agent's own call, whatever else in
     // the message might also match.
-    if (ARGUMENT_REJECTION.test(message))
+    if (ARGUMENT_REJECTION.test(message)) {
         return RefusalReason.BAD_ARGS;
-    if (INVALID_NAME_REJECTION.test(message))
+    }
+    if (INVALID_NAME_REJECTION.test(message)) {
         return RefusalReason.BAD_ARGS;
+    }
     const hint = recoveryFor(message);
     return (hint === undefined ? undefined : REASON_BY_HINT.get(hint)) ?? RefusalReason.OTHER;
 }
@@ -520,8 +532,9 @@ export function refusalReasonFor(rawMessage, coded) {
 /** Max issues rendered — a union rejection can emit one per member, which is how the array became unreadable. */
 const MAX_RENDERED_ISSUES = 3;
 function isZodIssue(value) {
-    if (typeof value !== 'object' || null === value)
+    if (typeof value !== 'object' || null === value) {
         return false;
+    }
     const v = value;
     return 'string' === typeof v['code'] && 'string' === typeof v['message'];
 }
@@ -548,8 +561,9 @@ function issueClause(issue) {
  */
 function zodArrayAsSentence(message) {
     const text = message.trim();
-    if (!text.startsWith('['))
+    if (!text.startsWith('[')) {
         return message;
+    }
     let parsed;
     try {
         parsed = JSON.parse(text);
@@ -557,8 +571,9 @@ function zodArrayAsSentence(message) {
     catch {
         return message; // not JSON at all — e.g. prose that happens to open with a bracket
     }
-    if (!Array.isArray(parsed) || 0 === parsed.length || !parsed.every(isZodIssue))
+    if (!Array.isArray(parsed) || 0 === parsed.length || !parsed.every(isZodIssue)) {
         return message;
+    }
     const shown = parsed.slice(0, MAX_RENDERED_ISSUES).map(issueClause).join('; ');
     const rest = parsed.length - MAX_RENDERED_ISSUES;
     return rest > 0 ? `${shown} (and ${String(rest)} more)` : shown;
@@ -613,8 +628,9 @@ const REASON_OF_CODE = {
  * its sentence: the not-linked refusal was matched by its prose, and the prose was rewritten.
  */
 export function codedRefusalOf(error) {
-    if (!(error instanceof Error))
+    if (!(error instanceof Error)) {
         return undefined;
+    }
     const parsed = CodedRefusalSchema.safeParse({
         code: 'code' in error ? error.code : undefined,
         next: 'next' in error ? error.next : undefined,
@@ -631,24 +647,29 @@ export function buildErrorPayload(rawMessage, coded) {
     // leave an unparseable fragment as the agent's error text — the worst of both shapes.
     const message = capMessage(zodArrayAsSentence(rawMessage));
     // A coded refusal says who does what next itself: no hint beside it, and no bug-report ask.
-    if (coded !== undefined)
+    if (coded !== undefined) {
         return { error: message, code: coded.code, next: coded.next };
-    if (isUnissuedRefRefusal(message))
+    }
+    if (isUnissuedRefRefusal(message)) {
         return { error: message, recovery: RECOVERY.UNISSUED_REF };
+    }
     // A self-diagnosing message gets NEITHER a generic recovery nor the feedback ask. It already
     // inspected the machine and named the cause; a second, contradictory hint is noise, and inviting a
     // bug report about a condition Reticle diagnosed itself is exactly backwards.
-    if (isSelfRecovering(message))
+    if (isSelfRecovering(message)) {
         return { error: message };
+    }
     // An argument rejection is the agent's to fix, not a Reticle defect. Reported from the field: a
     // clean `unrecognized_keys: ["value"]` came back wrapped in "may be a defect in Reticle", which
     // spends the agent's turn and fills the feedback channel with reports about malformed calls.
-    if (ARGUMENT_REJECTION.test(message))
+    if (ARGUMENT_REJECTION.test(message)) {
         return { error: message, recovery: ARGUMENT_RECOVERY };
+    }
     // Reticle's own name validators rejecting a caller's value: an argument rejection that the schema
     // cannot express (the shape is a runtime pattern, not a type), so it needs its own arm.
-    if (INVALID_NAME_REJECTION.test(message))
+    if (INVALID_NAME_REJECTION.test(message)) {
         return { error: message, recovery: RECOVERY.INVALID_NAME };
+    }
     const recovery = recoveryFor(message);
     return recovery !== undefined
         ? { error: message, recovery }

package/dist/surface/tools/invoke-tool.js

@@ -17,6 +17,7 @@ import { endsRun, noteToolResult, runReportField } from './run-report.js';
 import { runLedger } from '../../judgement/runs/run-ledger.js';
 import { readAppNotes } from './agent/app-notes.js';
 import { forTheAgent } from './agent/for-the-agent.js';
+import { inRepeatStreak, withHintOn } from './repeat-hint.js';
 import { feedbackAlreadyAsked, noteFeedbackAsked } from './agent/notices.js';
 import { SKEW_SHORT_WARNING, SKEW_VERDICT_WARNING } from '../../portal/session/session-health.js';
 import { verifyNextBaton, SUPPRESS_VERIFY_NEXT_ENV } from './verify-next-baton.js';
@@ -46,6 +47,7 @@ import { takeStepShot } from '../../features/visual/step-shots.js';
 import { defectForToolResult, deltaForToolResult, impactSnapshot, initImpact, recordImpact, } from '../../memory/impact/impact-recorder.js';
 import { FrictionKind, frictionOf, inviteFor } from './feedback-invite.js';
 import { VACUOUS_BECAUSE } from '@reticlehq/engine/evidence/verified.js';
+import { NEXT_STEP_FIELD } from './empty-session-list.js';
 /**
  * Emit `verification_completed` when a verification tool produced a verdict.
  *
@@ -134,11 +136,11 @@ function reportBugsFound(toolName, result, sessionId) {
  * tool's name, and then hands the same failure back out to be reported a second time as
  * `reticle_run`. A count that doubles because of HOW a tool was reached is not a measurement.
  */
-function reportRefusal(toolName, message, error) {
+function reportRefusal(toolName, args, message, error) {
     if (toolName === ReticleTool.RUN) {
         return;
     }
-    reportToolRefused(toolName, refusalReasonFor(message, codedRefusalOf(error)));
+    reportToolRefused(toolName, refusalReasonFor(message, codedRefusalOf(error)), args);
 }
 /**
  * Which friction this result represents, counting the invitation if there is one.
@@ -256,25 +258,20 @@ export async function runTool(tool, deps, given, call) {
         // The project of the session a call ends, read while the session still exists: releasing a
         // tab removes it, and an unreadable project lost an unlinked user's cloud line.
         const endedIn = agentCall && ends ? safeRoot(() => sessionRoot(deps, sessionIdFromArgs(args))) : undefined;
-        const raw = await loggedTool(tool, deps, args, call);
+        // `reticle_run` is counted once, as the tool it reached; never another agent's call (rule 8).
+        const owner = currentDrivenBy() === undefined && ReticleTool.RUN !== tool.name;
+        const { raw, hint } = await inRepeatStreak(owner ? deps.attachId : undefined, tool.name, args, () => loggedTool(tool, deps, args, call));
         const attach = currentDrivenBy() === undefined ? deps.attachId : undefined;
         const root = attach === undefined
             ? undefined
             : safeRoot(() => sessionRoot(deps, sessionIdFromArgs(args)));
         // The app notes before this call, so a note it learns counts as memory written.
         const notesBefore = agentCall && root !== undefined ? readAppNotes(root) : [];
-        const answer = forTheAgent({
-            name: tool.name,
-            args,
-            result: raw,
-            attach,
-            root,
-            fold: NOTICE_FOLD,
-        });
+        const answer = withHintOn(forTheAgent({ name: tool.name, args, result: raw, attach, root, fold: NOTICE_FOLD }), hint);
         if (!agentCall) {
             return answer;
         }
-        runLedger.after(deps.now());
+        runLedger.after(deps.now(), deps.attachId);
         noteToolResult(runLedger, tool.name, args, raw);
         const notesAfter = root === undefined ? [] : readAppNotes(root);
         runLedger.memoryWritten(notesAfter.filter((note) => !notesBefore.includes(note)).length);
@@ -282,7 +279,10 @@ export async function runTool(tool, deps, given, call) {
         if (!ends || null === answer || 'object' !== typeof answer) {
             return answer;
         }
-        return { ...answer, ...runReportField(runLedger, endedIn ?? root, process.env, deps.now()) };
+        return {
+            ...answer,
+            ...runReportField(runLedger, endedIn ?? root, process.env, deps.now(), deps.attachId),
+        };
     }));
 }
 /** Advisories that become once-per-session notice lines. See agent/notices.ts. */
@@ -391,7 +391,7 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
             'value — a selector or an id rather than a document, or a slice of the text you need.';
         // Refused before the handler was ever entered, and still a refusal the agent has to recover
         // from. Reported here rather than at the return below, which this branch never reaches.
-        reportRefusal(tool.name, error);
+        reportRefusal(tool.name, args, error);
         return { error };
     }
     // One driver per tab. The Harness clicking through a page while the agent clicks too is two hands
@@ -399,7 +399,7 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
     const busy = ACTION_TOOLS.has(tool.name) ? harnessDriving(deps, args) : undefined;
     if (busy !== undefined) {
         const error = msgHarnessHasTheTab(busy);
-        reportRefusal(tool.name, error);
+        reportRefusal(tool.name, args, error);
         return { error };
     }
     // An ACTION is what gets abandoned. Counted here, against verifications, so "the agent drove the
@@ -448,7 +448,7 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
     // before Playwright invents a closed page. ready:true leases still hit this path.
     if (session?.versionSkew !== undefined && CDP_TOOLS.has(tool.name)) {
         const message = session.versionSkew;
-        reportRefusal(tool.name, message);
+        reportRefusal(tool.name, args, message);
         throw new Error(message);
     }
     // A ref that was handed out by a DIFFERENT tab, on a call that named no session. Refused here, at
@@ -466,7 +466,7 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
         if (wrongTab !== undefined) {
             // Refused before the handler was entered, so it is reported here — the same shape as the
             // oversized-argument refusal above.
-            reportRefusal(tool.name, wrongTab);
+            reportRefusal(tool.name, args, wrongTab);
             return { error: wrongTab };
         }
     }
@@ -516,7 +516,7 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
         const rewritten = rewriteClosedAsSkew(error, skewText);
         const toThrow = rewritten ?? error;
         const message = toThrow instanceof Error ? toThrow.message : String(toThrow);
-        reportRefusal(tool.name, message, toThrow);
+        reportRefusal(tool.name, args, message, toThrow);
         // The invitation on THIS path is the one `buildErrorPayload` attaches when it does not recognise
         // the error, and it was never counted — so the denominator excluded the commonest friction there
         // is. Gated on the payload actually carrying the ask, because a recognised error gets a recovery
@@ -580,7 +580,7 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
     // project the daemon was started in.
     session?.pushImpact?.(() => impactSnapshot(artifactRoot));
     if (resultIsError(raw)) {
-        reportRefusal(tool.name, raw.error);
+        reportRefusal(tool.name, args, raw.error);
     }
     else {
         noteToolServed();
@@ -660,6 +660,11 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
         })
         : undefined;
     const platformLine = platform === undefined ? nudge : nudge === undefined ? platform : `${platform}\n${nudge}`;
+    // The first call of this connection, in an unwired app with nothing attached: the offer the
+    // plugin's SessionStart hook makes, which `/reload-plugins` never fires. Always taken, so a call
+    // that already said it (the opened tab's notice, an empty list's `next_step`) still uses the once.
+    const firstOffer = agentCall && deps.attachId !== undefined ? deps.firstSessionOffer?.(deps.attachId) : undefined;
+    const offer = opened === undefined && !(NEXT_STEP_FIELD in (answer ?? {})) ? firstOffer : undefined;
     const drives = agentCall
         ? takeDriveNotes('string' === typeof answer?.['runId'] ? answer['runId'] : undefined)
         : [];
@@ -675,7 +680,8 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
         undelivered === undefined &&
         friction === undefined &&
         platformLine === undefined &&
-        next === undefined
+        next === undefined &&
+        offer === undefined
         ? raw
         : {
             // First, so a model that truncates a long result still reads it.
@@ -696,6 +702,7 @@ async function dispatchTool(tool, deps, args, call, seen = {}) {
             ...(update !== undefined ? { [EnvelopeKey.UPDATE_AVAILABLE]: update } : {}),
             ...(skew !== undefined ? { [EnvelopeKey.VERSION_SKEW]: skew } : {}),
             ...(platformLine !== undefined ? { [EnvelopeKey.PLATFORM]: platformLine } : {}),
+            ...(offer === undefined ? {} : { [EnvelopeKey.FIRST_SESSION_OFFER]: offer }),
             ...(0 === drives.length ? {} : { [EnvelopeKey.HARNESS]: drives.join('\n') }),
             ...(notes === undefined ? {} : { [EnvelopeKey.CONTROL]: notes }),
             ...(undelivered !== undefined

package/dist/surface/tools/lease-hint.d.ts

@@ -56,6 +56,13 @@ export interface LeaseEvidence {
      */
     dialledUrl?: string;
 }
+/**
+ * The last sentence of every not-connected hint. It is true for an MCP caller, which keeps the
+ * lease. The CLI releases the lease itself, and puts `LEASE_RELEASED_SENTENCE` in its place.
+ */
+export declare const LEASE_KEPT_SENTENCE = "The tab stays leased. Release it with reticle_lease{action:\"release\"}.";
+/** The sentence for a lease that is already released. */
+export declare const LEASE_RELEASED_SENTENCE = "The lease is released.";
 export declare function leaseNotConnectedHint(url: string, port: number, evidence?: LeaseEvidence): string;
 /**
  * The leased page was still loading when the wait ran out, so nothing has failed yet: a slow first

package/dist/surface/tools/lease-hint.js

@@ -37,7 +37,14 @@ const REAL_CAUSES = 'Causes that produce exactly this and are NOT a port problem
 const NUXT_FIRST = 'This project is Nuxt: the most likely cause by a distance is a dev server that predates the ' +
     'Reticle plugin, because Nuxt does NOT register a newly added plugin on HMR. Restart `nuxt dev` ' +
     'and re-acquire before investigating anything else.';
-const RELEASE = 'The tab stays leased either way — release it with reticle_lease{action:"release"}.';
+/**
+ * The last sentence of every not-connected hint. It is true for an MCP caller, which keeps the
+ * lease. The CLI releases the lease itself, and puts `LEASE_RELEASED_SENTENCE` in its place.
+ */
+export const LEASE_KEPT_SENTENCE = 'The tab stays leased. Release it with reticle_lease{action:"release"}.';
+const RELEASE = LEASE_KEPT_SENTENCE;
+/** The sentence for a lease that is already released. */
+export const LEASE_RELEASED_SENTENCE = 'The lease is released.';
 const PRODUCTION_STUB = ' If this is a production build (`vite build`, `next build`, `next start`, or a deployed site), it strips ' +
     'Reticle or replaces it with an inert stub by design; point the lease at the dev server instead.';
 function isRemoteUrl(url) {
@@ -168,8 +175,8 @@ export function leaseStillLoadingHint(url, waitedMs) {
 /** The hint for a lease whose zero-install reader did not run (#1701). The lease is already released. */
 export function leaseReaderFailedHint(url, failure) {
     return failure.reason === LeaseNotReadyReason.NOT_HTML_DOCUMENT
-        ? `${url} is not an HTML page, so no SDK can connect to it. The lease is released. ` +
+        ? `${url} is not an HTML page, so no SDK can connect to it. ${LEASE_RELEASED_SENTENCE} ` +
             'Acquire an HTML page of the app instead.'
-        : `The zero-install reader failed on ${url}: ${failure.cause}. The lease is released. ` +
+        : `The zero-install reader failed on ${url}: ${failure.cause}. ${LEASE_RELEASED_SENTENCE} ` +
             'If the tab closed during setup, acquire again.';
 }

package/dist/surface/tools/lease-readiness.d.ts

@@ -43,6 +43,27 @@ export declare function notReadyReason(answered: boolean, session: unknown, fail
  * failure than the one being fixed.
  */
 export declare function probeLeaseAlive(session: ProbeableSession | undefined, timeoutMs?: number): Promise<boolean>;
+/**
+ * The longest `reticle_lease { action: "acquire" }` waits for its tab to be ready, when the caller
+ * gives no `timeout_ms`. It is the longest wait before this bound existed: the connect wait, the
+ * wait after the reader, and the loading grace rounds. So no acquire that was ready before is now
+ * refused.
+ */
+export declare const LEASE_READY_TIMEOUT_MS: number;
+/**
+ * A connect wait for `connectOrInject` that ends at the deadline. Each wait is one connect wait at
+ * most, so the reader still goes in at the same time. A wait that starts after the deadline looks
+ * once and does not sleep.
+ */
+export declare function connectWaitUntil(deadline: number, now: () => number, sleeper?: (ms: number) => Promise<void>): (isConnected: () => boolean) => Promise<boolean>;
+/**
+ * Wait until the leased tab is registered, answers a probe and is visible, or the deadline passes.
+ *
+ * A row in the sessions map is not proof that the next call works (#1650): the tab can be attached
+ * and answer nothing. So `ready` waits for a reply. Returns the reason at the deadline, or
+ * `undefined` when the tab is ready. It always looks once, also when the deadline has passed.
+ */
+export declare function awaitLeaseAnswering(registered: () => ProbeableSession | undefined, deadline: number, now: () => number, sleeper?: (ms: number) => Promise<void>): Promise<LeaseNotReadyReason | undefined>;
 /**
  * Poll until the leased tab's SDK has actually registered on the bridge, so the sessionId we return
  * is immediately usable (the page navigates first, then connects a moment later — without this wait

package/dist/surface/tools/lease-readiness.js

@@ -6,6 +6,7 @@
  */
 import { LeaseNotReadyReason, ReticleCommand, RETICLE_URL_PARAM } from '@reticlehq/core';
 import { NotHtmlDocumentError } from '../../portal/pool/zero-install.js';
+import { waitForReconnect } from '../../portal/session/session-reconnect.js';
 /**
  * How long a liveness probe waits for the tab to say anything at all.
  *
@@ -74,6 +75,52 @@ const LEASE_READY_POLL_MS = 100;
 /** Extra readiness waits allowed while the leased page is still loading (each one is ~10 s). */
 const LEASE_LOADING_GRACE_ROUNDS = 3;
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** One connect wait: how long a tab gets to dial in before the zero-install reader goes in. */
+const LEASE_CONNECT_WAIT_MS = LEASE_READY_ATTEMPTS * LEASE_READY_POLL_MS;
+/**
+ * The longest `reticle_lease { action: "acquire" }` waits for its tab to be ready, when the caller
+ * gives no `timeout_ms`. It is the longest wait before this bound existed: the connect wait, the
+ * wait after the reader, and the loading grace rounds. So no acquire that was ready before is now
+ * refused.
+ */
+export const LEASE_READY_TIMEOUT_MS = LEASE_CONNECT_WAIT_MS * (2 + LEASE_LOADING_GRACE_ROUNDS);
+/** `waitForReconnect` waits for `current` to differ from `previous`: these two always differ. */
+const NOT_REGISTERED = {};
+const REGISTERED = {};
+/**
+ * A connect wait for `connectOrInject` that ends at the deadline. Each wait is one connect wait at
+ * most, so the reader still goes in at the same time. A wait that starts after the deadline looks
+ * once and does not sleep.
+ */
+export function connectWaitUntil(deadline, now, sleeper = sleep) {
+    return (isConnected) => waitForReconnect({
+        current: () => (isConnected() ? REGISTERED : undefined),
+        previous: NOT_REGISTERED,
+        timeoutMs: Math.min(LEASE_CONNECT_WAIT_MS, Math.max(0, deadline - now())),
+        now,
+        sleep: sleeper,
+        pollMs: LEASE_READY_POLL_MS,
+    });
+}
+/**
+ * Wait until the leased tab is registered, answers a probe and is visible, or the deadline passes.
+ *
+ * A row in the sessions map is not proof that the next call works (#1650): the tab can be attached
+ * and answer nothing. So `ready` waits for a reply. Returns the reason at the deadline, or
+ * `undefined` when the tab is ready. It always looks once, also when the deadline has passed.
+ */
+export async function awaitLeaseAnswering(registered, deadline, now, sleeper = sleep) {
+    for (;;) {
+        const session = registered();
+        const reason = session === undefined
+            ? LeaseNotReadyReason.SDK_STOPPED_ANSWERING
+            : notReadyReason(await probeLeaseAlive(session), session);
+        if (reason === undefined || now() >= deadline) {
+            return reason;
+        }
+        await sleeper(LEASE_READY_POLL_MS);
+    }
+}
 /**
  * Poll until the leased tab's SDK has actually registered on the bridge, so the sessionId we return
  * is immediately usable (the page navigates first, then connects a moment later — without this wait

package/dist/surface/tools/lease-seed.d.ts

@@ -36,6 +36,8 @@ export declare const NAV_TIMEOUT_ADVICE: string;
  * cases and leads with the retry.
  */
 export declare function navFailureMessage(url: string, err: unknown, seed?: SeedStorage): string;
+/** Whether a path is a sign-in page, by its name: `/login`, `/signin`, `/auth/login` and similar. */
+export declare const isAuthPath: (pathname: string) => boolean;
 /**
  * Determine if a required seedStorage application precondition failed.
  *

package/dist/surface/tools/lease-seed.js

@@ -127,6 +127,8 @@ export function navFailureMessage(url, err, seed) {
         : `within ${String(Number(budgetMs) / 1000)} s`;
     return `could not open ${url} — ${NAV_TIMEOUT_LEAD} ${within} (${reason}). ${NAV_TIMEOUT_ADVICE}`;
 }
+/** Whether a path is a sign-in page, by its name: `/login`, `/signin`, `/auth/login` and similar. */
+export const isAuthPath = (pathname) => /(?:^|\/)(?:login|signin|sign-in|auth\/login|auth\/signin|session\/new)(?:$|\/)/i.test(pathname);
 /**
  * Determine if a required seedStorage application precondition failed.
  *
@@ -159,7 +161,6 @@ export function evaluateSeedPrecondition(requestedUrl, actualUrl, seed, navStatu
         return `seeded storage precondition not established: cross-origin redirect from ${reqParsed.origin} to ${actParsed.origin} skipped origin-scoped storage injection`;
     }
     // Clear redirect to an authentication/login endpoint when the requested URL was not a login page
-    const isAuthPath = (pathname) => /(?:^|\/)(?:login|signin|sign-in|auth\/login|auth\/signin|session\/new)(?:$|\/)/i.test(pathname);
     if (!isAuthPath(reqParsed.pathname) && isAuthPath(actParsed.pathname)) {
         return `seeded authentication precondition not established: redirected from ${reqParsed.pathname} to login page (${actParsed.pathname})`;
     }