@vibecook/ghosttea-react 0.11.1 → 0.13.0

package/dist/runtime.js

@@ -1,3 +1,4 @@
+import { terminalLinkUrl } from "@vibecook/ghosttea-protocol";
 import { ControlClient } from "@vibecook/ghosttea";
 import { DEFAULT_ROUTED_PROTOCOL_LIMITS, PROTOCOL_MAJOR, PROTOCOL_MINOR, SESSION_SCROLLBACK_PROTOCOL_MINOR, STRUCTURED_ERROR_PROTOCOL_MINOR, isRoutedSessionAttachGrant, isRoutedTerminalOpenTicket, isValidScrollbackBytes, } from "@vibecook/ghosttea-protocol";
 import { FRAME_MAGIC, FrameFlag } from "@vibecook/ghosttea-frame";
@@ -24,6 +25,57 @@ export function showsStaleScreen(state) {
 export function sessionIsFrozen(state) {
     return showsStaleScreen(state.state) || state.awaitingRecoveryFrame;
 }
+function geometryHolderRecord(holder) {
+    return { clientId: holder.clientId, viewId: holder.viewId, holderGeneration: holder.holderGeneration };
+}
+function sameGeometryHolder(a, b) {
+    if (a === undefined || b === undefined)
+        return a === b;
+    return a.clientId === b.clientId && a.viewId === b.viewId && a.holderGeneration === b.holderGeneration;
+}
+/** A take's context on the control leg: which view and take it is, and the seat state it was built on. */
+class RoutedGeometryTake {
+    viewId;
+    /** The view's request serial this take was sent under. */
+    viewSerial;
+    /** The session's take serial. */
+    serial;
+    attempt;
+    basisHolder;
+    basisRevision;
+    constructor(viewId, viewSerial, serial, attempt, basis) {
+        this.viewId = viewId;
+        this.viewSerial = viewSerial;
+        this.serial = serial;
+        this.attempt = attempt;
+        this.basisHolder = basis?.holder;
+        this.basisRevision = basis?.revision ?? 0;
+    }
+}
+/** A plain claim's context: the view that sent it, under which serial, and whether it re-sends a grid that did not land. */
+class RoutedGeometryClaim {
+    viewId;
+    viewSerial;
+    trailing;
+    constructor(viewId, viewSerial, trailing) {
+        this.viewId = viewId;
+        this.viewSerial = viewSerial;
+        this.trailing = trailing;
+    }
+}
+/** Refusals that describe the seat as it is, so a take built on older news can retry against them. */
+const RETRYABLE_TAKE_REFUSALS = new Set(["SEAT_HELD", "STALE_REVISION", "NOT_HOLDER"]);
+/**
+ * Whether a take's refusal names a seat other than the one the take was built
+ * on. A refusal that repeats the take's own view of the seat (a cell that does
+ * not allow the take at all) would only be refused again.
+ */
+function takeRefusalNamesNews(refused, take) {
+    if (!RETRYABLE_TAKE_REFUSALS.has(refused.code) || refused.geometryRevision === undefined)
+        return false;
+    const holder = refused.currentHolder === undefined ? undefined : geometryHolderRecord(refused.currentHolder);
+    return refused.geometryRevision !== take.basisRevision || !sameGeometryHolder(holder, take.basisHolder);
+}
 const FRAME_SUBSCRIPTION_ACK_TIMEOUT_MS = 10_000;
 const FRAME_SUBSCRIPTION_ACK_PROTOCOL_MINOR = 7;
 const FRAME_BRIDGE_CAPABILITY_VERSION = 1;
@@ -52,6 +104,9 @@ export function waitForGhostteaRendererPorts(timeoutMs = 10_000) {
 }
 export class GhostteaTerminalRuntime extends EventTarget {
     #worker;
+    #sessionsCreatedHere = new Set();
+    #sessionsWithInput = new Set();
+    #sessionsDrawn = new Set();
     #ports;
     #routedHost;
     #routedReceiverCapacities;
@@ -110,6 +165,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
     #performanceRequestId = 1;
     #performanceRequests = new Map();
     #counterRequests = new Map();
+    #linksByHandle = new Map();
     #disposed = false;
     constructor(options) {
         super();
@@ -155,6 +211,10 @@ export class GhostteaTerminalRuntime extends EventTarget {
             else if (data.type === "clipboard-write") {
                 this.#platform.writeClipboard(data.text);
             }
+            else if (data.type === "link-targets") {
+                this.#linksByHandle.set(data.sessionHandle, data.links.filter((link) => terminalLinkUrl(link.uri) !== null));
+                this.dispatchEvent(new CustomEvent("link-targets", { detail: { sessionHandle: data.sessionHandle } }));
+            }
             else if (data.type === "scrollbar-state") {
                 this.#scrollbarByHandle.set(data.sessionHandle, data.scrollbar);
                 this.dispatchEvent(new CustomEvent("scrollbar-state", {
@@ -172,6 +232,9 @@ export class GhostteaTerminalRuntime extends EventTarget {
                     this.#scheduleMetadataRefresh(data.sessionHandle);
                 this.#recordCommittedFrame(data.sessionHandle, data.fullSnapshot);
             }
+            else if (data.type === "session-drawn") {
+                this.#recordSessionDrawn(data.sessionHandle);
+            }
             else if (data.type === "catalog-pressure") {
                 console.warn(`[terminal-runtime] native text catalog budget exceeded for ${data.sessionHandle}; using bounded fallback text`);
                 this.dispatchEvent(new CustomEvent("catalog-pressure", { detail: data }));
@@ -196,6 +259,9 @@ export class GhostteaTerminalRuntime extends EventTarget {
             else if (data.type === "routed-frames-event") {
                 this.#handleRoutedFramesEvent(data.event);
             }
+            else if (data.type === "terminal-modes") {
+                this.#noteMouseTracking(data.sessionHandle, data.mouseTracking);
+            }
             else if (data.type === "renderer-reload-required") {
                 console.error(`[terminal-runtime] renderer requested reload: ${String(data.reason ?? "unknown")}`);
                 this.#platform.setForceCanvasFallback(true);
@@ -212,6 +278,26 @@ export class GhostteaTerminalRuntime extends EventTarget {
             return;
         this.#worker.postMessage(message, transfer);
     }
+    /** Whether this renderer has attempted terminal input during this session's lifetime.
+     * Restored or externally created sessions must never be treated as unused from this alone. */
+    sessionHasInput(sessionId) {
+        return this.#sessionsWithInput.has(sessionId);
+    }
+    /**
+     * Whether a committed frame of this session has put something on screen in
+     * this renderer: what a host that just started a program waits for before it
+     * reveals the terminal. Once true it stays true while the session is
+     * registered here (a restart in place is the same session and does not draw
+     * "first" again); a `session-drawn` event (`detail: { sessionId }`) announces
+     * the change, and a session registered again announces again.
+     */
+    sessionHasDrawn(sessionId) {
+        return this.#sessionsDrawn.has(sessionId);
+    }
+    /** A local birth receipt, never inferred from registration or an empty input history. */
+    sessionCreatedHere(sessionId) {
+        return this.#sessionsCreatedHere.has(sessionId);
+    }
     get rendererBackend() {
         return this.#rendererBackend;
     }
@@ -225,6 +311,48 @@ export class GhostteaTerminalRuntime extends EventTarget {
             return false;
         return this.#routedBySession.get(view.sessionId)?.state.inputAllowed ?? false;
     }
+    /**
+     * The routed session's geometry seat as this runtime last saw it, or
+     * `undefined` before anything was seen (and always on the port-pair
+     * transport). A change of holder also fires `geometry-holder-changed`; a
+     * resize by the same holder only moves `revision`, without an event.
+     */
+    geometryHolder(sessionHandle) {
+        const session = this.#sessionByHandle.get(sessionHandle);
+        const entry = session ? this.#routedBySession.get(session.id) : undefined;
+        const geometry = entry ? this.#routedGeometry.get(entry.sessionId) : undefined;
+        return entry && geometry ? this.#geometryHolderState(entry, geometry) : undefined;
+    }
+    #geometryHolderState(entry, geometry) {
+        const holder = geometry.holder;
+        return {
+            holder: holder === undefined ? null : { ...holder },
+            revision: geometry.revision,
+            local: holder !== undefined && holder.clientId === entry.clientId,
+        };
+    }
+    /** Whether this view, under this runtime's client, holds the seat as last seen. */
+    #routedViewHolds(entry, geometry, viewId) {
+        const holder = geometry?.holder;
+        return holder !== undefined && holder.viewId === viewId && holder.clientId === entry.clientId;
+    }
+    /** Every write of a session's seat state goes through here, so a holder change always fires its event. */
+    #setRoutedGeometry(entry, next) {
+        const previous = this.#routedGeometry.get(entry.sessionId);
+        if (next === undefined)
+            this.#routedGeometry.delete(entry.sessionId);
+        else
+            this.#routedGeometry.set(entry.sessionId, next);
+        if ((previous === undefined) === (next === undefined) && sameGeometryHolder(previous?.holder, next?.holder))
+            return;
+        const detail = {
+            sessionId: entry.sessionId,
+            sessionHandle: entry.sessionHandle,
+            previous: previous === undefined ? undefined : this.#geometryHolderState(entry, previous),
+            current: next === undefined ? undefined : this.#geometryHolderState(entry, next),
+        };
+        this.dispatchEvent(new CustomEvent("geometry-holder-changed", { detail }));
+    }
     #resolvePerformanceRequest(requestId, value) {
         const pending = this.#performanceRequests.get(requestId);
         if (!pending)
@@ -352,11 +480,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 this.#returnFrameCredit(data.byteLength);
                 return;
             }
-            const tracking = (view.getUint16(6, true) & FrameFlag.MouseTracking) !== 0;
-            if (this.#mouseTrackingByHandle.get(sessionHandle) !== tracking) {
-                this.#mouseTrackingByHandle.set(sessionHandle, tracking);
-                this.dispatchEvent(new CustomEvent("terminal-modes", { detail: { sessionHandle, mouseTracking: tracking } }));
-            }
+            this.#noteMouseTracking(sessionHandle, (view.getUint16(6, true) & FrameFlag.MouseTracking) !== 0);
             this.#scheduleMetadataRefresh(sessionHandle);
             this.#postWorker({ type: "frame", packet: data }, [data]);
         };
@@ -804,6 +928,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
             if (!this.#routedHost.createSession)
                 throw new Error("The routed host does not provide session creation");
             const session = await this.#routedHost.createSession(options);
+            this.#sessionsCreatedHere.add(session.id);
             this.registerSession(session);
             return session;
         }
@@ -821,6 +946,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         });
         if (response.type !== "session-created")
             throw new Error("ghosttead returned an unexpected response");
+        this.#sessionsCreatedHere.add(response.session.id);
         this.registerSession(response.session);
         console.info(`[terminal-runtime] created session ${response.session.id}`);
         return response.session;
@@ -977,11 +1103,11 @@ export class GhostteaTerminalRuntime extends EventTarget {
         if (response.type !== "ok")
             throw new Error("ghosttead rejected frame resynchronization");
     }
-    mount(sessionId, sessionHandle, viewId, canvas) {
+    mount(sessionId, sessionHandle, viewId, canvas, initialSize) {
         if (this.#disposed)
             throw new Error("Cannot mount a disposed terminal runtime");
         if (this.#routedHost)
-            return this.#mountRouted(sessionId, sessionHandle, viewId, canvas);
+            return this.#mountRouted(sessionId, sessionHandle, viewId, canvas, initialSize);
         const mounted = this.#mountedCanvases.get(canvas);
         if (mounted) {
             if (!mounted.active)
@@ -996,11 +1122,20 @@ export class GhostteaTerminalRuntime extends EventTarget {
             }
             return this.#createMountLease(mounted);
         }
+        const size = initialSize ?? {
+            width: canvas.clientWidth || 0,
+            height: canvas.clientHeight || 0,
+            dpr: window.devicePixelRatio || 1,
+        };
+        // Allocate the first render target at its actual size, too: the backend
+        // must not build a default 300x150 scene texture and immediately replace it.
+        canvas.width = Math.max(1, Math.round(size.width * size.dpr));
+        canvas.height = Math.max(1, Math.round(size.height * size.dpr));
         const offscreen = canvas.transferControlToOffscreen();
         const subscription = this.#retainFrameSubscription(sessionHandle);
         const generation = (this.#mountGenerationBySurface.get(viewId) ?? 0) + 1;
         this.#mountGenerationBySurface.set(viewId, generation);
-        this.#postWorker({ type: "mount", surfaceId: viewId, sessionHandle, canvas: offscreen }, [offscreen]);
+        this.#postWorker({ type: "mount", surfaceId: viewId, sessionHandle, canvas: offscreen, size }, [offscreen]);
         const entry = {
             canvas,
             sessionHandle,
@@ -1029,6 +1164,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
             lastAttachmentEpoch: undefined,
             claimedEpoch: undefined,
             claimedRevision: 0,
+            routedGeometrySerial: 0,
         };
         this.#views.set(viewId, view);
         const remote = this.#remoteSessions.get(sessionId);
@@ -1087,7 +1223,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
             .catch((error) => console.error(`[terminal-runtime] failed to attach view ${viewId}`, error));
         return this.#createMountLease(entry);
     }
-    #mountRouted(sessionId, sessionHandle, viewId, canvas) {
+    #mountRouted(sessionId, sessionHandle, viewId, canvas, initialSize) {
         const mounted = this.#mountedCanvases.get(canvas);
         if (mounted) {
             if (!mounted.active)
@@ -1102,10 +1238,19 @@ export class GhostteaTerminalRuntime extends EventTarget {
             }
             return this.#createMountLease(mounted);
         }
+        const size = initialSize ?? {
+            width: canvas.clientWidth || 0,
+            height: canvas.clientHeight || 0,
+            dpr: window.devicePixelRatio || 1,
+        };
+        // Allocate the first render target at its actual size, too: the backend
+        // must not build a default 300x150 scene texture and immediately replace it.
+        canvas.width = Math.max(1, Math.round(size.width * size.dpr));
+        canvas.height = Math.max(1, Math.round(size.height * size.dpr));
         const offscreen = canvas.transferControlToOffscreen();
         const generation = (this.#mountGenerationBySurface.get(viewId) ?? 0) + 1;
         this.#mountGenerationBySurface.set(viewId, generation);
-        this.#postWorker({ type: "mount", surfaceId: viewId, sessionHandle, canvas: offscreen }, [offscreen]);
+        this.#postWorker({ type: "mount", surfaceId: viewId, sessionHandle, canvas: offscreen, size }, [offscreen]);
         const entry = {
             canvas,
             sessionHandle,
@@ -1136,6 +1281,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
             lastAttachmentEpoch: undefined,
             claimedEpoch: undefined,
             claimedRevision: 0,
+            routedGeometrySerial: 0,
         });
         const activation = this.#routedBySession.get(sessionId);
         if (activation)
@@ -1172,6 +1318,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
             sessionHandle,
             state: initialRoutedActivation(sessionId, activationId, inputPolicy),
             viewIds: new Set([viewId]),
+            takeSerial: 0,
             recoveryAttempts: 0,
             preAuthRemints: { control: 0, frames: 0 },
             protocolFailures: { control: 0, frames: 0 },
@@ -1217,15 +1364,22 @@ export class GhostteaTerminalRuntime extends EventTarget {
         const host = this.#routedHost;
         if (!host || this.#disposed || entry.viewIds.size === 0)
             return;
+        const activationId = entry.state.activationId;
+        const isCurrent = () => !this.#disposed &&
+            entry.viewIds.size > 0 &&
+            entry.state.activationId === activationId &&
+            this.#routedByActivation.get(activationId) === entry &&
+            this.#routedBySession.get(entry.sessionId) === entry;
         let ticket;
         try {
             ticket = await host.openTicket(entry.sessionId, { reason });
         }
         catch (error) {
-            this.#transitionRouted(entry, { type: "no-route", reason: String(error) });
+            if (isCurrent())
+                this.#transitionRouted(entry, { type: "no-route", reason: String(error) });
             return;
         }
-        if (this.#routedBySession.get(entry.sessionId) !== entry || this.#disposed)
+        if (!isCurrent())
             return;
         if (!this.#routedTicketMatches(entry, ticket)) {
             this.#transitionRouted(entry, { type: "no-route", reason: "ticket-binding-mismatch" });
@@ -1235,6 +1389,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         if (!ticket.endpoints)
             return;
         entry.ticket = ticket;
+        entry.clientId = ticket.attachGrant.claims.clientId;
         this.#transitionRouted(entry, { type: "transport-ready" });
         this.#routedControl.attach({
             cellBootId: ticket.route.cellBootId,
@@ -1242,10 +1397,22 @@ export class GhostteaTerminalRuntime extends EventTarget {
             transportGrant: ticket.transportGrant,
             attachGrant: ticket.attachGrant,
             activationId: entry.state.activationId,
+            replacePreviousActivation: true,
             ...(entry.replacesActivationId === undefined ? {} : { replacesActivationId: entry.replacesActivationId }),
             initialDemand: this.#routedDemand(entry),
             capabilities: this.#routedCapabilities,
         });
+        this.#armRoutedAttachDeadline(entry, this.#routedAttachDeadlineByCell.get(ticket.route.cellBootId) ??
+            DEFAULT_ROUTED_PROTOCOL_LIMITS.activationAttachDeadlineMs);
+        this.#scheduleRoutedRenewal(entry);
+    }
+    #startRoutedFrames(entry) {
+        const ticket = entry.ticket;
+        if (!ticket?.endpoints || !entry.state.controlAttached || entry.framesAttachStarted || entry.viewIds.size === 0)
+            return;
+        // Control creates the native activation. The frames socket may already be
+        // warm; sending on both legs at once races that creation on every remount.
+        entry.framesAttachStarted = true;
         this.#postWorker({
             type: "routed-frames-attach",
             request: {
@@ -1260,19 +1427,23 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 capabilities: this.#routedCapabilities,
             },
         });
-        this.#armRoutedAttachDeadline(entry, this.#routedAttachDeadlineByCell.get(ticket.route.cellBootId) ??
-            DEFAULT_ROUTED_PROTOCOL_LIMITS.activationAttachDeadlineMs);
-        this.#scheduleRoutedRenewal(entry);
     }
     #stopRoutedActivation(entry) {
         this.#routedControl?.detach(entry.state.activationId);
         this.#postWorker({ type: "routed-frames-detach", activationId: entry.state.activationId });
+        delete entry.framesAttachStarted;
         if (entry.attachTimer !== undefined)
             window.clearTimeout(entry.attachTimer);
         delete entry.attachTimer;
         if (entry.renewalTimer !== undefined)
             window.clearTimeout(entry.renewalTimer);
         delete entry.renewalTimer;
+        if (entry.cellLeaseTimer !== undefined)
+            window.clearTimeout(entry.cellLeaseTimer);
+        delete entry.cellLeaseTimer;
+        if (entry.workerLeaseTimer !== undefined)
+            window.clearTimeout(entry.workerLeaseTimer);
+        delete entry.workerLeaseTimer;
         delete entry.ticket;
     }
     #transitionRouted(entry, event) {
@@ -1346,23 +1517,36 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 grantGeneration: event.attached.grantGenerationAccepted,
                 rights: event.attached.rights,
             });
+            this.#startRoutedFrames(entry);
             const previousGeometry = this.#routedGeometry.get(entry.sessionId);
+            const previousHolder = previousGeometry?.holder;
             if (!event.attached.rights.includes("geometry") &&
-                previousGeometry?.holderViewId !== undefined &&
-                entry.viewIds.has(previousGeometry.holderViewId)) {
+                previousGeometry !== undefined &&
+                previousHolder !== undefined &&
+                this.#routedViewHolds(entry, previousGeometry, previousHolder.viewId) &&
+                entry.viewIds.has(previousHolder.viewId)) {
                 // The cell auto-releases a holder when renewal drops the geometry
                 // right. Preserve its next CAS revision without retaining authority.
-                this.#routedGeometry.set(entry.sessionId, {
+                this.#setRoutedGeometry(entry, {
                     revision: previousGeometry.revision + 1,
                     ...(previousGeometry.cols === undefined ? {} : { cols: previousGeometry.cols }),
                     ...(previousGeometry.rows === undefined ? {} : { rows: previousGeometry.rows }),
                 });
             }
+            // A take asked before the leg could carry it goes out now. It decides
+            // the seat, so the plain claims below would only draw refusals.
+            const queuedTake = entry.queuedTake;
+            delete entry.queuedTake;
+            if (queuedTake !== undefined &&
+                queuedTake.serial === entry.takeSerial &&
+                this.#sendRoutedTake(entry, queuedTake.viewId, queuedTake.serial, 0)) {
+                return;
+            }
             const geometry = this.#routedGeometry.get(entry.sessionId);
             for (const viewId of entry.viewIds) {
                 const view = this.#views.get(viewId);
                 if (view?.resizeControlRequested &&
-                    geometry?.holderViewId !== viewId &&
+                    !this.#routedViewHolds(entry, geometry, viewId) &&
                     view.desiredCols !== undefined &&
                     view.desiredRows !== undefined) {
                     this.#claimRoutedGeometry(entry, viewId, view.desiredCols, view.desiredRows);
@@ -1384,9 +1568,15 @@ export class GhostteaTerminalRuntime extends EventTarget {
             const entry = this.#routedByActivation.get(event.status.activationId);
             if (!entry || event.status.sessionId !== entry.sessionId)
                 return;
+            const previousSequence = entry.state.lastCellStatusSequence;
             this.#transitionRouted(entry, { type: "cell-status", status: event.status, now: performance.now() });
             const sequence = entry.state.lastCellStatusSequence;
-            window.setTimeout(() => {
+            if (sequence === previousSequence)
+                return;
+            if (entry.cellLeaseTimer !== undefined)
+                window.clearTimeout(entry.cellLeaseTimer);
+            entry.cellLeaseTimer = window.setTimeout(() => {
+                delete entry.cellLeaseTimer;
                 if (entry.state.lastCellStatusSequence !== sequence)
                     return;
                 this.#transitionRouted(entry, { type: "cell-lease-expired" });
@@ -1401,14 +1591,21 @@ export class GhostteaTerminalRuntime extends EventTarget {
             const entry = event.activationId ? this.#routedByActivation.get(event.activationId) : undefined;
             if (!entry)
                 return;
-            this.#routedGeometry.set(entry.sessionId, {
-                holderViewId: event.committed.holder.viewId,
-                holderGeneration: event.committed.holder.holderGeneration,
+            this.#setRoutedGeometry(entry, {
+                holder: geometryHolderRecord(event.committed.holder),
                 revision: event.committed.geometryRevision,
                 cols: event.committed.cols,
                 rows: event.committed.rows,
             });
-            this.dispatchEvent(new CustomEvent("routed-geometry", { detail: { sessionId: entry.sessionId, ...event } }));
+            this.#trailRoutedResize(entry, event.request?.context, undefined);
+            this.dispatchEvent(new CustomEvent("routed-geometry", {
+                detail: {
+                    sessionId: entry.sessionId,
+                    type: event.type,
+                    ...(event.activationId === undefined ? {} : { activationId: event.activationId }),
+                    committed: event.committed,
+                },
+            }));
             return;
         }
         if (event.type === "geometry-refused") {
@@ -1416,14 +1613,32 @@ export class GhostteaTerminalRuntime extends EventTarget {
             if (entry && event.refused.geometryRevision !== undefined) {
                 const previous = this.#routedGeometry.get(entry.sessionId);
                 const holder = event.refused.currentHolder;
-                this.#routedGeometry.set(entry.sessionId, {
+                this.#setRoutedGeometry(entry, {
                     revision: event.refused.geometryRevision,
-                    ...(holder === undefined ? {} : { holderViewId: holder.viewId, holderGeneration: holder.holderGeneration }),
+                    ...(holder === undefined ? {} : { holder: geometryHolderRecord(holder) }),
                     ...(previous?.cols === undefined ? {} : { cols: previous.cols }),
                     ...(previous?.rows === undefined ? {} : { rows: previous.rows }),
                 });
             }
-            this.dispatchEvent(new CustomEvent("routed-geometry-refused", { detail: event }));
+            // A take refused on stale news retries once against the seat the
+            // refusal names; only the session's latest take does.
+            const take = event.request?.context instanceof RoutedGeometryTake ? event.request.context : undefined;
+            if (entry &&
+                take &&
+                take.attempt === 0 &&
+                take.serial === entry.takeSerial &&
+                takeRefusalNamesNews(event.refused, take)) {
+                this.#sendRoutedTake(entry, take.viewId, take.serial, 1);
+            }
+            if (entry)
+                this.#trailRoutedResize(entry, event.request?.context, event.refused.code);
+            this.dispatchEvent(new CustomEvent("routed-geometry-refused", {
+                detail: {
+                    type: event.type,
+                    ...(event.activationId === undefined ? {} : { activationId: event.activationId }),
+                    refused: event.refused,
+                },
+            }));
             return;
         }
         if (event.type === "transport-closed") {
@@ -1522,9 +1737,15 @@ export class GhostteaTerminalRuntime extends EventTarget {
             const entry = this.#routedByActivation.get(event.status.activationId);
             if (!entry)
                 return;
+            const previousSequence = entry.state.lastWorkerStatusSequence;
             this.#transitionRouted(entry, { type: "presentation-status", status: event.status, now: performance.now() });
             const sequence = entry.state.lastWorkerStatusSequence;
-            window.setTimeout(() => {
+            if (sequence === previousSequence)
+                return;
+            if (entry.workerLeaseTimer !== undefined)
+                window.clearTimeout(entry.workerLeaseTimer);
+            entry.workerLeaseTimer = window.setTimeout(() => {
+                delete entry.workerLeaseTimer;
                 if (entry.state.lastWorkerStatusSequence !== sequence)
                     return;
                 this.#transitionRouted(entry, { type: "worker-lease-expired" });
@@ -1638,6 +1859,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 return;
             }
             entry.ticket = ticket;
+            entry.clientId = ticket.attachGrant.claims.clientId;
             this.#routedControl?.renew(activationId, ticket.attachGrant);
             this.#scheduleRoutedRenewal(entry);
             this.#postWorker({
@@ -1679,14 +1901,10 @@ export class GhostteaTerminalRuntime extends EventTarget {
             this.#transitionRouted(entry, { type: "transport-failed", recoveryExhausted: true });
             return;
         }
-        // Geometry belongs to the cell-side attach/client/view scope. Preserve it
-        // across a same-route leg replacement, but never carry its revision or
-        // holder generation to a newly routed cell.
-        if (reason === "route-stale")
-            this.#routedGeometry.delete(entry.sessionId);
         const previousActivationId = entry.state.activationId;
         this.#routedControl?.detach(previousActivationId);
         this.#postWorker({ type: "routed-frames-detach", activationId: previousActivationId });
+        delete entry.framesAttachStarted;
         this.#routedByActivation.delete(previousActivationId);
         const nextActivationId = crypto.randomUUID();
         entry.replacesActivationId = previousActivationId;
@@ -1710,7 +1928,20 @@ export class GhostteaTerminalRuntime extends EventTarget {
         if (entry.renewalTimer !== undefined)
             window.clearTimeout(entry.renewalTimer);
         delete entry.renewalTimer;
+        if (entry.cellLeaseTimer !== undefined)
+            window.clearTimeout(entry.cellLeaseTimer);
+        delete entry.cellLeaseTimer;
+        if (entry.workerLeaseTimer !== undefined)
+            window.clearTimeout(entry.workerLeaseTimer);
+        delete entry.workerLeaseTimer;
         delete entry.ticket;
+        // Geometry belongs to the cell-side attach/client/view scope. Preserve it
+        // across a same-route leg replacement, but never carry its revision or
+        // holder generation to a newly routed cell. Forgotten only now, once the
+        // old activation is gone, so a listener of the holder event cannot act
+        // on it.
+        if (reason === "route-stale")
+            this.#setRoutedGeometry(entry, undefined);
         const delay = Math.min(2_000, 100 * 2 ** Math.max(0, entry.recoveryAttempts - 1));
         window.setTimeout(() => {
             if (this.#routedByActivation.get(nextActivationId) !== entry)
@@ -1789,6 +2020,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
         if (!entry)
             return;
         entry.viewIds.delete(viewId);
+        if (entry.queuedTake?.viewId === viewId)
+            delete entry.queuedTake;
         if (entry.viewIds.size > 0) {
             const anyWritable = this.#routedHost?.encodeInput !== undefined &&
                 [...entry.viewIds].some((candidate) => {
@@ -1802,7 +2035,30 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#transitionRouted(entry, { type: "detach" });
         this.#routedBySession.delete(sessionId);
         this.#routedByActivation.delete(entry.state.activationId);
-        this.#routedGeometry.delete(sessionId);
+        this.#setRoutedGeometry(entry, undefined);
+    }
+    /**
+     * Detach one of our views and let the seat go with it.
+     *
+     * The daemon clears the resize controller when its holder detaches, but a
+     * local session announces control only through the legacy `control-changed`
+     * frame, which cannot say "no controller": the clear never reaches this
+     * client, and a pane that remounts (a split re-parents its surface) would
+     * see its own previous incarnation on the record forever and never claim.
+     * Our own detach is the one clear this client can predict, so the record is
+     * cleared here at the same revision and the session's remaining views get
+     * their one look at the empty seat (§4.2.3).
+     */
+    #detachView(sessionId, viewId) {
+        this.#control?.notify({ type: "detach-session", sessionId, viewId });
+        const control = this.#controlBySession.get(sessionId);
+        if (!control?.controller || control.controller.viewId !== viewId)
+            return;
+        this.#controlBySession.set(sessionId, { controller: null, revision: control.revision });
+        for (const other of this.#viewIdsForSession(sessionId)) {
+            if (other !== viewId)
+                this.#maybeReclaim(other);
+        }
     }
     #createMountLease(mounted) {
         let disposed = false;
@@ -1829,7 +2085,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
                         if (this.#routedHost)
                             this.#releaseRoutedView(mounted.sessionId, mounted.viewId);
                         else
-                            this.#control?.notify({ type: "detach-session", sessionId: mounted.sessionId, viewId: mounted.viewId });
+                            this.#detachView(mounted.sessionId, mounted.viewId);
                         this.#views.delete(mounted.viewId);
                         this.#focusByView.delete(mounted.viewId);
                     }
@@ -2043,6 +2299,13 @@ export class GhostteaTerminalRuntime extends EventTarget {
      * screen: a partial update repaints part of the stale one, which is exactly
      * what would thaw a pane too early.
      */
+    #recordSessionDrawn(sessionHandle) {
+        const sessionId = this.#sessionByHandle.get(sessionHandle)?.id;
+        if (sessionId === undefined || this.#sessionsDrawn.has(sessionId))
+            return;
+        this.#sessionsDrawn.add(sessionId);
+        this.dispatchEvent(new CustomEvent("session-drawn", { detail: { sessionId } }));
+    }
     #recordCommittedFrame(sessionHandle, fullSnapshot) {
         if (!fullSnapshot)
             return;
@@ -2183,6 +2446,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
         return message !== null && this.#routedControl.sendExtension(activation.state.activationId, message);
     }
     sendText(sessionId, viewId, text) {
+        if (text.length > 0)
+            this.#sessionsWithInput.add(sessionId);
         if (this.#routedHost) {
             this.#sendRoutedInput(sessionId, viewId, { kind: "text", text });
             return;
@@ -2193,6 +2458,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
             this.#postWorker({ type: "cursor-activity", sessionHandle: handle });
     }
     paste(sessionId, viewId, text) {
+        if (text.length > 0)
+            this.#sessionsWithInput.add(sessionId);
         if (this.#routedHost) {
             this.#sendRoutedInput(sessionId, viewId, { kind: "paste", text });
             return;
@@ -2203,6 +2470,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
             this.#postWorker({ type: "cursor-activity", sessionHandle: handle });
     }
     sendKey(sessionId, viewId, event) {
+        if (event.type === "down" && !["Shift", "Control", "Alt", "Meta"].includes(event.key))
+            this.#sessionsWithInput.add(sessionId);
         if (this.#routedHost) {
             this.#sendRoutedInput(sessionId, viewId, { kind: "key", event });
             return;
@@ -2244,6 +2513,14 @@ export class GhostteaTerminalRuntime extends EventTarget {
     isMouseTracking(sessionHandle) {
         return this.#mouseTrackingByHandle.get(sessionHandle) ?? false;
     }
+    /** A session's mouse modes, from whichever path carried its frame: the legacy
+     * bridge's header, read here, or the worker's word for a routed frame. */
+    #noteMouseTracking(sessionHandle, tracking) {
+        if (this.#mouseTrackingByHandle.get(sessionHandle) === tracking)
+            return;
+        this.#mouseTrackingByHandle.set(sessionHandle, tracking);
+        this.dispatchEvent(new CustomEvent("terminal-modes", { detail: { sessionHandle, mouseTracking: tracking } }));
+    }
     setTheme(sessionHandle, theme, surfaceId) {
         this.#postWorker({ type: "theme", sessionHandle, ...(surfaceId ? { surfaceId } : {}), theme });
         // A surface-scoped theme is renderer-local. Updating the daemon's
@@ -2269,6 +2546,16 @@ export class GhostteaTerminalRuntime extends EventTarget {
     setEffects(sessionHandle, effects, surfaceId) {
         this.#postWorker({ type: "effects", sessionHandle, ...(surfaceId ? { surfaceId } : {}), effects });
     }
+    links(sessionHandle) {
+        return this.#platform.openExternal
+            ? (this.#linksByHandle.get(sessionHandle) ?? []).filter((link) => link.explicit || this.#configSnapshot?.renderer.linkUrl !== false)
+            : [];
+    }
+    async openLink(uri) {
+        const url = terminalLinkUrl(uri);
+        if (url)
+            await this.#platform.openExternal?.(url);
+    }
     setSelection(sessionHandle, selection, surfaceId) {
         this.#postWorker({ type: "selection", sessionHandle, ...(surfaceId ? { surfaceId } : {}), selection });
     }
@@ -2303,13 +2590,14 @@ export class GhostteaTerminalRuntime extends EventTarget {
     setPartialRenderingEnabled(enabled) {
         this.#postWorker({ type: "partial-rendering", enabled });
     }
-    #claimRoutedGeometry(entry, viewId, cols, rows) {
+    #claimRoutedGeometry(entry, viewId, cols, rows, trailing = false) {
         const ticket = entry.ticket;
         const view = this.#views.get(viewId);
         if (!ticket || !view?.resizeControlRequested || !entry.state.rights.includes("geometry"))
             return;
         const geometry = this.#routedGeometry.get(entry.sessionId);
-        this.#routedControl?.claimGeometry(entry.state.activationId, {
+        const viewSerial = view.routedGeometrySerial + 1;
+        const sent = this.#routedControl?.claimGeometry(entry.state.activationId, {
             sessionId: entry.sessionId,
             activationId: entry.state.activationId,
             leaseEpoch: ticket.attachGrant.claims.leaseEpoch ?? 0,
@@ -2317,7 +2605,139 @@ export class GhostteaTerminalRuntime extends EventTarget {
             cols,
             rows,
             expectRevision: geometry?.revision ?? 0,
-        });
+        }, new RoutedGeometryClaim(viewId, viewSerial, trailing));
+        if (sent)
+            view.routedGeometrySerial = viewSerial;
+    }
+    /**
+     * Overlapping claims from one view name the same revision, so the cell
+     * commits the first and refuses the rest as stale: on a slow control leg
+     * the last grid of a resize would never land. When the reply to a view's
+     * latest claim or take (a commit, or a STALE_REVISION refusal) leaves the
+     * seat with this view at a grid other than the one it shows, that grid goes
+     * once more. Only for the holder, and never after a re-sent claim is
+     * refused.
+     */
+    #trailRoutedResize(entry, context, refusal) {
+        const request = context instanceof RoutedGeometryClaim || context instanceof RoutedGeometryTake ? context : undefined;
+        if (request === undefined)
+            return;
+        if (refusal !== undefined) {
+            if (refusal !== "STALE_REVISION")
+                return;
+            if (request instanceof RoutedGeometryClaim && request.trailing)
+                return;
+        }
+        const view = this.#views.get(request.viewId);
+        if (!view?.resizeControlRequested || view.routedGeometrySerial !== request.viewSerial)
+            return;
+        if (view.desiredCols === undefined || view.desiredRows === undefined)
+            return;
+        const geometry = this.#routedGeometry.get(entry.sessionId);
+        if (!geometry || !this.#routedViewHolds(entry, geometry, request.viewId))
+            return;
+        if (geometry.cols === view.desiredCols && geometry.rows === view.desiredRows)
+            return;
+        this.#claimRoutedGeometry(entry, request.viewId, view.desiredCols, view.desiredRows, true);
+    }
+    /**
+     * Send a take of the seat for `viewId`, built on the holder this runtime
+     * last saw. False when it cannot go out: no ticket or attached control leg,
+     * no `geometry` right, or the view no longer asks for resize control.
+     */
+    #sendRoutedTake(entry, viewId, serial, attempt) {
+        const ticket = entry.ticket;
+        const view = this.#views.get(viewId);
+        if (!ticket ||
+            !entry.state.controlAttached ||
+            !entry.state.rights.includes("geometry") ||
+            !entry.viewIds.has(viewId) ||
+            !view?.resizeControlRequested ||
+            view.desiredCols === undefined ||
+            view.desiredRows === undefined) {
+            return false;
+        }
+        const clientId = ticket.attachGrant.claims.clientId;
+        const geometry = this.#routedGeometry.get(entry.sessionId);
+        const holder = geometry?.holder;
+        const viewSerial = view.routedGeometrySerial + 1;
+        const context = new RoutedGeometryTake(viewId, viewSerial, serial, attempt, geometry);
+        const lease = {
+            sessionId: entry.sessionId,
+            activationId: entry.state.activationId,
+            leaseEpoch: ticket.attachGrant.claims.leaseEpoch ?? 0,
+        };
+        const expectRevision = geometry?.revision ?? 0;
+        const cols = view.desiredCols;
+        const rows = view.desiredRows;
+        // An empty seat is claimed; a claim of the view's own seat is committed
+        // by the cell as a resize (at the same size, the PTY is left alone).
+        const sent = holder === undefined || (holder.clientId === clientId && holder.viewId === viewId)
+            ? this.#routedControl?.claimGeometry(entry.state.activationId, { ...lease, claimant: { clientId, viewId }, cols, rows, expectRevision }, context)
+            : this.#routedControl?.transferGeometry(entry.state.activationId, { ...lease, from: { ...holder }, to: { clientId, viewId }, expectRevision, cols, rows }, context);
+        if (sent)
+            view.routedGeometrySerial = viewSerial;
+        return sent ?? false;
+    }
+    /**
+     * Take the session's geometry seat for `viewId`: the host's policy verb.
+     *
+     * Focus is a scheduling fact. The runtime never turns it into geometry;
+     * the host decides when a view takes the seat. VibeField's rule (DS-D5) is
+     * that the pane focused last holds the PTY's cols×rows, on any device, last
+     * write wins, and `TerminalSurface`'s `takeGeometryOnFocus` applies it.
+     *
+     * On the routed transport the take is built on the holder this runtime last
+     * saw (`geometryHolder`):
+     * - an empty seat draws a `ClaimGeometry`;
+     * - a seat this view holds draws a `ClaimGeometry` of its own seat, which
+     *   the cell commits as a resize;
+     * - a seat held by another view, of this client or another, draws one
+     *   `TransferGeometry {from: holder, to: {clientId, viewId}, expectRevision,
+     *   cols, rows}`, with `clientId` from this session's attach grant.
+     *
+     * A refusal is the only announcement a take gets. The cell answers only the
+     * caller's control leg, so a pane whose seat another client took still
+     * believes it holds it, and its take is a resize that the cell refuses. A
+     * `SEAT_HELD`, `STALE_REVISION` or `NOT_HOLDER` refusal that names a holder
+     * or revision other than the one the take was built on is retried once,
+     * against what it names: one `TransferGeometry` from the named holder at
+     * the named revision; a claim of the view's own seat if it names this
+     * view; a `ClaimGeometry` if it names an empty seat. A refusal that repeats
+     * the take's own view of the seat, or names no seat, is not retried, and
+     * neither is a second refusal. The runtime owns that one retry: a host
+     * calls this once per focus gain of a controller view and never retries
+     * it. Only the session's latest take retries. A take asked before the
+     * control leg attaches is sent when it attaches, unless the view's focus
+     * ends first. Without the grant's `geometry` right nothing is sent.
+     *
+     * On the port-pair transport this is `claimResizeControl`, which never
+     * displaces another view.
+     *
+     * Like `claimResizeControl`, it leaves the view asking for resize control:
+     * its later grid changes resize the PTY while it holds the seat, until
+     * `releaseResizeControl`.
+     */
+    takeResizeControl(sessionHandle, viewId, cols, rows) {
+        if (!this.#routedHost) {
+            this.claimResizeControl(sessionHandle, viewId, cols, rows);
+            return;
+        }
+        const view = this.#views.get(viewId);
+        const session = this.#sessionByHandle.get(sessionHandle);
+        const entry = session ? this.#routedBySession.get(session.id) : undefined;
+        if (!view || !entry || view.sessionId !== entry.sessionId || !entry.viewIds.has(viewId))
+            return;
+        view.desiredCols = cols;
+        view.desiredRows = rows;
+        view.resizeControlRequested = true;
+        entry.takeSerial += 1;
+        const serial = entry.takeSerial;
+        delete entry.queuedTake;
+        if (this.#sendRoutedTake(entry, viewId, serial, 0))
+            return;
+        if (!entry.state.controlAttached)
+            entry.queuedTake = { viewId, serial };
     }
     claimResizeControl(sessionHandle, viewId, cols, rows) {
         const view = this.#views.get(viewId);
@@ -2344,9 +2764,12 @@ export class GhostteaTerminalRuntime extends EventTarget {
         view.resizeControlRequested = false;
         if (this.#routedHost) {
             const entry = this.#routedBySession.get(view.sessionId);
+            if (entry?.queuedTake?.viewId === viewId)
+                delete entry.queuedTake;
             const geometry = this.#routedGeometry.get(view.sessionId);
             const ticket = entry?.ticket;
-            if (entry && ticket && geometry?.holderViewId === viewId && geometry.holderGeneration !== undefined) {
+            const holder = geometry?.holder;
+            if (entry && ticket && geometry && holder && this.#routedViewHolds(entry, geometry, viewId)) {
                 const sent = this.#routedControl?.releaseGeometry(entry.state.activationId, {
                     sessionId: view.sessionId,
                     activationId: entry.state.activationId,
@@ -2354,13 +2777,14 @@ export class GhostteaTerminalRuntime extends EventTarget {
                     holder: {
                         clientId: ticket.attachGrant.claims.clientId,
                         viewId,
-                        holderGeneration: geometry.holderGeneration,
+                        holderGeneration: holder.holderGeneration,
                     },
                 });
                 if (sent) {
                     // T1 sends no success body for release. The ordered control leg and
-                    // cell state machine make the next revision deterministic.
-                    this.#routedGeometry.set(view.sessionId, {
+                    // cell state machine make the next revision deterministic; if the
+                    // seat had moved on, the cell's refusal names the holder instead.
+                    this.#setRoutedGeometry(entry, {
                         revision: geometry.revision + 1,
                         ...(geometry.cols === undefined ? {} : { cols: geometry.cols }),
                         ...(geometry.rows === undefined ? {} : { rows: geometry.rows }),
@@ -2369,9 +2793,12 @@ export class GhostteaTerminalRuntime extends EventTarget {
             }
             return;
         }
-        // The legacy protocol has no release verb. Clearing the local epoch still
-        // closes every resize path immediately; a later explicit claim can renew it.
-        view.controlEpoch = undefined;
+        // The legacy protocol has no release verb, so the daemon keeps this view
+        // seated. Dropping the request is what closes every resize path; the epoch
+        // stays, because it is still the seat's truth and a later explicit claim
+        // resumes on it. Clearing it here would leave the view with the record in
+        // its own name and no epoch: the funnel's one-claim-per-attachment guard
+        // refuses that claim, and a pane hidden by a zoom never resizes again.
     }
     setViewInputPolicy(viewId, readWrite) {
         const view = this.#views.get(viewId);
@@ -2406,8 +2833,12 @@ export class GhostteaTerminalRuntime extends EventTarget {
             return;
         if (this.#routedHost) {
             const entry = this.#routedBySession.get(session.id);
-            if (entry)
-                this.#declareRoutedDemand(entry);
+            if (!entry)
+                return;
+            // The focus that asked for a take still waiting on the leg has ended.
+            if (!focused && entry.queuedTake?.viewId === viewId)
+                delete entry.queuedTake;
+            this.#declareRoutedDemand(entry);
             return;
         }
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => {
@@ -2459,6 +2890,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         return response.text;
     }
     interrupt(sessionId, viewId) {
+        this.#sessionsWithInput.add(sessionId);
         if (this.#routedHost) {
             this.#sendRoutedInput(sessionId, viewId, { kind: "interrupt" });
             return;
@@ -2480,6 +2912,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#sessionMountReferences.delete(handle);
         const subscriptionChanged = this.#subscribedSessionHandles.delete(handle);
         this.#cancelMetadataRefresh(handle);
+        this.#linksByHandle.delete(handle);
         this.#mouseTrackingByHandle.delete(handle);
         this.#scrollbarByHandle.delete(handle);
         for (const mounted of [...this.#mountedEntries]) {
@@ -2494,7 +2927,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 this.#postWorker({ type: "unmount", surfaceId: mounted.viewId });
                 this.#mountGenerationBySurface.delete(mounted.viewId);
                 if (detachViews)
-                    this.#control?.notify({ type: "detach-session", sessionId: mounted.sessionId, viewId: mounted.viewId });
+                    this.#detachView(mounted.sessionId, mounted.viewId);
                 this.#views.delete(mounted.viewId);
                 this.#focusByView.delete(mounted.viewId);
             }
@@ -2505,7 +2938,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
             if (view.sessionId === sessionId) {
                 view.pendingInput.length = 0;
                 if (detachViews)
-                    this.#control?.notify({ type: "detach-session", sessionId, viewId });
+                    this.#detachView(sessionId, viewId);
                 this.#views.delete(viewId);
                 this.#focusByView.delete(viewId);
             }
@@ -2517,6 +2950,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#remoteSessions.delete(sessionId);
         this.#controlBySession.delete(sessionId);
         this.#recoveredSessions.delete(sessionId);
+        // The worker forgets the handle's first frame with its snapshot (`drop-session`).
+        this.#sessionsDrawn.delete(sessionId);
         if (subscriptionChanged) {
             this.#frameSubscriptionVersion += 1;
             this.#syncFrameSubscriptionsInBackground();
@@ -2615,6 +3050,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#recoveredSessions.clear();
         this.#focusByView.clear();
         this.#mountGenerationBySurface.clear();
+        this.#linksByHandle.clear();
         this.#mouseTrackingByHandle.clear();
         this.#scrollbarByHandle.clear();
         this.#subscribedSessionHandles.clear();
@@ -2635,6 +3071,10 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 window.clearTimeout(entry.attachTimer);
             if (entry.renewalTimer !== undefined)
                 window.clearTimeout(entry.renewalTimer);
+            if (entry.cellLeaseTimer !== undefined)
+                window.clearTimeout(entry.cellLeaseTimer);
+            if (entry.workerLeaseTimer !== undefined)
+                window.clearTimeout(entry.workerLeaseTimer);
         }
         this.#routedBySession.clear();
         this.#routedByActivation.clear();