@vibecook/ghosttea-react 0.10.1 → 0.11.1

package/dist/runtime.js

@@ -1,7 +1,13 @@
 import { ControlClient } from "@vibecook/ghosttea";
-import { PROTOCOL_MAJOR, PROTOCOL_MINOR, SESSION_SCROLLBACK_PROTOCOL_MINOR, STRUCTURED_ERROR_PROTOCOL_MINOR, isValidScrollbackBytes, } from "@vibecook/ghosttea-protocol";
+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";
 import { FrameResyncController } from "./frame-resync.js";
+import { initialRoutedActivation, reduceRoutedActivation, } from "./routed-activation.js";
+import { RoutedControlTransport, } from "./routed-control.js";
+const MAX_BROWSER_TIMEOUT_MS = 2_147_483_647;
+function routedConnectionRefusalIsRecoverable(refusal) {
+    return refusal.retryable || refusal.code === "GRANT_GENERATION_ROLLBACK" || refusal.code === "GRANT_NONCE_REPLAYED";
+}
 function sameSessionActivity(left, right) {
     return (left.kind === right.kind &&
         left.source === right.source &&
@@ -47,6 +53,14 @@ export function waitForGhostteaRendererPorts(timeoutMs = 10_000) {
 export class GhostteaTerminalRuntime extends EventTarget {
     #worker;
     #ports;
+    #routedHost;
+    #routedReceiverCapacities;
+    #routedCapabilities;
+    #routedControl;
+    #routedBySession = new Map();
+    #routedByActivation = new Map();
+    #routedGeometry = new Map();
+    #routedAttachDeadlineByCell = new Map();
     #platform;
     #clientBuild;
     #sessionOwnerId;
@@ -87,16 +101,33 @@ export class GhostteaTerminalRuntime extends EventTarget {
     #configSnapshot;
     #configProtocolSupported = false;
     #metadataTimers = new Map();
+    #metadataRefreshes = new Map();
+    #metadataRefreshPending = new Set();
+    #sessionGenerationByHandle = new Map();
+    #appliedRoutedExitEvents = new Set();
+    #sessionGeneration = 0;
     #resync;
     #performanceRequestId = 1;
     #performanceRequests = new Map();
+    #counterRequests = new Map();
     #disposed = false;
     constructor(options) {
         super();
         this.#worker =
             options.workerFactory?.() ??
                 new Worker(new URL("./terminal-render.worker.js", import.meta.url), { type: "module" });
-        this.#ports = Promise.resolve(options.ports);
+        this.#ports = options.transport === "routed" ? undefined : Promise.resolve(options.ports);
+        this.#routedHost = options.transport === "routed" ? options.host : undefined;
+        this.#routedReceiverCapacities = options.transport === "routed" ? options.receiverCapacities : undefined;
+        this.#routedCapabilities = options.transport === "routed" ? (options.capabilities ?? ["resume"]) : [];
+        this.#routedControl =
+            options.transport === "routed"
+                ? new RoutedControlTransport({
+                    ...(options.websocketFactory === undefined ? {} : { socketFactory: options.websocketFactory }),
+                    acceptExtensionMessages: options.host.onExtensionMessage !== undefined,
+                    emit: (event) => this.#handleRoutedControlEvent(event),
+                })
+                : undefined;
         this.#platform = options.platform;
         this.#clientBuild = options.clientBuild ?? "ghosttea-react";
         this.#sessionOwnerId = options.sessionOwnerId;
@@ -137,6 +168,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 this.#resync.complete(data.sessionHandle);
             }
             else if (data.type === "frame-committed") {
+                if (this.#routedHost?.getSession)
+                    this.#scheduleMetadataRefresh(data.sessionHandle);
                 this.#recordCommittedFrame(data.sessionHandle, data.fullSnapshot);
             }
             else if (data.type === "catalog-pressure") {
@@ -152,6 +185,17 @@ export class GhostteaTerminalRuntime extends EventTarget {
             else if (data.type === "performance-result") {
                 this.#resolvePerformanceRequest(data.requestId, data.snapshot);
             }
+            else if (data.type === "performance-counters") {
+                const pending = this.#counterRequests.get(data.requestId);
+                if (!pending)
+                    return;
+                window.clearTimeout(pending.timer);
+                this.#counterRequests.delete(data.requestId);
+                pending.resolve(data.snapshot);
+            }
+            else if (data.type === "routed-frames-event") {
+                this.#handleRoutedFramesEvent(data.event);
+            }
             else if (data.type === "renderer-reload-required") {
                 console.error(`[terminal-runtime] renderer requested reload: ${String(data.reason ?? "unknown")}`);
                 this.#platform.setForceCanvasFallback(true);
@@ -171,6 +215,16 @@ export class GhostteaTerminalRuntime extends EventTarget {
     get rendererBackend() {
         return this.#rendererBackend;
     }
+    /** Current main-authority state for a routed session. */
+    routedActivation(sessionId) {
+        return this.#routedBySession.get(sessionId)?.state;
+    }
+    routedViewInputAllowed(viewId) {
+        const view = this.#views.get(viewId);
+        if (!view?.clientReadWrite || view.readWrite === false)
+            return false;
+        return this.#routedBySession.get(view.sessionId)?.state.inputAllowed ?? false;
+    }
     #resolvePerformanceRequest(requestId, value) {
         const pending = this.#performanceRequests.get(requestId);
         if (!pending)
@@ -203,6 +257,20 @@ export class GhostteaTerminalRuntime extends EventTarget {
             throw new Error("Terminal render worker returned no performance snapshot");
         return result;
     }
+    /** Reads monotonic production counters without starting a sample window or draining the GPU. */
+    readPerformanceCounters(timeoutMs = 2_000) {
+        if (this.#disposed)
+            return Promise.reject(new Error("Terminal runtime is disposed"));
+        const requestId = this.#performanceRequestId++;
+        return new Promise((resolve, reject) => {
+            const timer = window.setTimeout(() => {
+                this.#counterRequests.delete(requestId);
+                reject(new Error(`Terminal render counter request ${requestId} timed out`));
+            }, timeoutMs);
+            this.#counterRequests.set(requestId, { resolve, reject, timer });
+            this.#postWorker({ type: "performance-counters", requestId });
+        });
+    }
     connect() {
         if (this.#disposed)
             return Promise.reject(new Error("Terminal runtime is disposed"));
@@ -210,6 +278,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
         return this.#ready;
     }
     async #connect() {
+        if (this.#routedHost)
+            return;
         const ports = await this.#ports;
         if (this.#disposed) {
             ports.control.close();
@@ -220,22 +290,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#control = new ControlClient(ports.control);
         this.#control.addEventListener("session-exited", (event) => {
             const detail = event.detail;
-            const handle = this.#handleBySessionId.get(detail.sessionId);
-            const session = handle ? this.#sessionByHandle.get(handle) : undefined;
-            if (!handle || !session)
-                return;
-            this.#cancelMetadataRefresh(handle);
-            const exited = {
-                ...session,
-                exited: true,
-                exitCode: detail.exitCode,
-                exitSignal: detail.exitSignal,
-                requestedTermination: detail.requestedTermination,
-                exitOutcome: detail.exitOutcome,
-            };
-            this.#sessionByHandle.set(handle, exited);
-            this.dispatchEvent(new CustomEvent("session-metadata", { detail: exited }));
-            this.dispatchEvent(new CustomEvent("session-exited", { detail }));
+            this.#applySessionExited(detail);
         });
         this.#control.addEventListener("events-lost", () => {
             // The daemon dropped events faster than this client drained them. Any
@@ -245,14 +300,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
         });
         this.#control.addEventListener("session-activity-changed", (event) => {
             const detail = event.detail;
-            const handle = this.#handleBySessionId.get(detail.sessionId);
-            const session = handle ? this.#sessionByHandle.get(handle) : undefined;
-            if (!handle || !session || session.exited)
-                return;
-            const updated = { ...session, activity: detail.activity };
-            this.#sessionByHandle.set(handle, updated);
-            this.dispatchEvent(new CustomEvent("session-activity", { detail }));
-            this.dispatchEvent(new CustomEvent("session-metadata", { detail: updated }));
+            this.#applySessionActivity(detail);
         });
         this.#control.addEventListener("control-changed", (event) => {
             const detail = event.detail;
@@ -342,6 +390,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     async reloadConfig() {
         await this.connect();
+        if (this.#routedHost)
+            throw new Error("Configuration reload is not part of the routed host contract");
         const response = await this.#control.request({ type: "reload-config" });
         if (response.type !== "config")
             throw new Error("ghosttead returned an unexpected configuration response");
@@ -400,54 +450,196 @@ export class GhostteaTerminalRuntime extends EventTarget {
         if (this.#frameFlowControlEnabled)
             this.#frames?.postMessage({ type: "frame-credit", bytes });
     }
+    #bumpSessionGeneration(sessionHandle) {
+        this.#sessionGeneration += 1;
+        this.#sessionGenerationByHandle.set(sessionHandle, this.#sessionGeneration);
+        return this.#sessionGeneration;
+    }
+    #applySessionExited(detail) {
+        const handle = this.#handleBySessionId.get(detail.sessionId);
+        const session = handle ? this.#sessionByHandle.get(handle) : undefined;
+        if (!handle || !session)
+            return;
+        this.#cancelMetadataRefresh(handle);
+        const exited = {
+            ...session,
+            exited: true,
+            exitCode: detail.exitCode,
+            exitSignal: detail.exitSignal,
+            requestedTermination: detail.requestedTermination,
+            exitOutcome: detail.exitOutcome,
+        };
+        this.#sessionByHandle.set(handle, exited);
+        this.#bumpSessionGeneration(handle);
+        this.dispatchEvent(new CustomEvent("session-metadata", { detail: exited }));
+        this.dispatchEvent(new CustomEvent("session-exited", { detail }));
+    }
+    #applySessionActivity(detail) {
+        const handle = this.#handleBySessionId.get(detail.sessionId);
+        const session = handle ? this.#sessionByHandle.get(handle) : undefined;
+        if (!handle || !session || session.exited)
+            return;
+        const updated = { ...session, activity: detail.activity };
+        this.#sessionByHandle.set(handle, updated);
+        this.#bumpSessionGeneration(handle);
+        this.dispatchEvent(new CustomEvent("session-activity", { detail }));
+        this.dispatchEvent(new CustomEvent("session-metadata", { detail: updated }));
+    }
+    #applyRoutedSessionSummary(sessionHandle, next, expectedGeneration) {
+        const previous = this.#sessionByHandle.get(sessionHandle);
+        if (!previous ||
+            previous.exited ||
+            previous.id !== next.id ||
+            next.handle !== sessionHandle ||
+            this.#handleBySessionId.get(next.id) !== sessionHandle ||
+            (expectedGeneration !== undefined && this.#sessionGenerationByHandle.get(sessionHandle) !== expectedGeneration)) {
+            return false;
+        }
+        this.#sessionByHandle.set(sessionHandle, next);
+        this.#bumpSessionGeneration(sessionHandle);
+        if (previous.title !== next.title ||
+            previous.cwd !== next.cwd ||
+            previous.exited !== next.exited ||
+            !sameSessionActivity(previous.activity, next.activity)) {
+            this.dispatchEvent(new CustomEvent("session-metadata", { detail: next }));
+        }
+        return true;
+    }
     #scheduleMetadataRefresh(sessionHandle) {
         const scheduledSession = this.#sessionByHandle.get(sessionHandle);
         if (!scheduledSession || scheduledSession.exited)
             return;
+        if (this.#routedHost?.getSession && this.#metadataRefreshes.has(sessionHandle)) {
+            this.#metadataRefreshPending.add(sessionHandle);
+            return;
+        }
         if (this.#metadataTimers.has(sessionHandle))
             return;
         const timer = window.setTimeout(() => {
             this.#metadataTimers.delete(sessionHandle);
             const session = this.#sessionByHandle.get(sessionHandle);
-            if (!session || session.exited || !this.#control)
+            if (!session || session.exited)
                 return;
-            void this.#control
-                .request({ type: "get-session", sessionId: session.id })
-                .then((response) => {
-                if (response.type !== "session")
-                    return;
-                const previous = this.#sessionByHandle.get(sessionHandle);
-                if (!previous || previous.id !== response.session.id || previous.exited)
-                    return;
-                this.#sessionByHandle.set(sessionHandle, response.session);
-                if (previous.title !== response.session.title ||
-                    previous.cwd !== response.session.cwd ||
-                    previous.exited !== response.session.exited ||
-                    !sameSessionActivity(previous.activity, response.session.activity)) {
-                    this.dispatchEvent(new CustomEvent("session-metadata", { detail: response.session }));
-                }
-            })
-                .catch((error) => {
-                const current = this.#sessionByHandle.get(sessionHandle);
-                if (!current || current.exited || this.#disposed)
-                    return;
-                console.warn("[terminal-runtime] session metadata refresh failed", error);
-            });
+            if (this.#control) {
+                void this.#control
+                    .request({ type: "get-session", sessionId: session.id })
+                    .then((response) => {
+                    if (response.type !== "session")
+                        return;
+                    const previous = this.#sessionByHandle.get(sessionHandle);
+                    if (!previous || previous.id !== response.session.id || previous.exited)
+                        return;
+                    this.#sessionByHandle.set(sessionHandle, response.session);
+                    if (previous.title !== response.session.title ||
+                        previous.cwd !== response.session.cwd ||
+                        previous.exited !== response.session.exited ||
+                        !sameSessionActivity(previous.activity, response.session.activity)) {
+                        this.dispatchEvent(new CustomEvent("session-metadata", { detail: response.session }));
+                    }
+                })
+                    .catch((error) => {
+                    const current = this.#sessionByHandle.get(sessionHandle);
+                    if (!current || current.exited || this.#disposed)
+                        return;
+                    console.warn("[terminal-runtime] session metadata refresh failed", error);
+                });
+                return;
+            }
+            if (this.#routedHost?.getSession)
+                this.#startRoutedMetadataRefresh(sessionHandle, session);
         }, 200);
         this.#metadataTimers.set(sessionHandle, timer);
     }
+    #startRoutedMetadataRefresh(sessionHandle, session) {
+        const host = this.#routedHost;
+        const getSession = host?.getSession;
+        if (!host || !getSession || this.#disposed)
+            return;
+        if (this.#metadataRefreshes.has(sessionHandle)) {
+            this.#metadataRefreshPending.add(sessionHandle);
+            return;
+        }
+        const expectedGeneration = this.#sessionGenerationByHandle.get(sessionHandle);
+        const refresh = Promise.resolve()
+            .then(() => getSession.call(host, session.id))
+            .then((next) => {
+            if (next === null)
+                return;
+            this.#applyRoutedSessionSummary(sessionHandle, next, expectedGeneration);
+        })
+            .catch((error) => {
+            const current = this.#sessionByHandle.get(sessionHandle);
+            if (!current || current.exited || this.#disposed)
+                return;
+            console.warn("[terminal-runtime] session metadata refresh failed", error);
+        })
+            .finally(() => {
+            if (this.#metadataRefreshes.get(sessionHandle) !== refresh)
+                return;
+            this.#metadataRefreshes.delete(sessionHandle);
+            if (!this.#metadataRefreshPending.delete(sessionHandle) || this.#disposed)
+                return;
+            const current = this.#sessionByHandle.get(sessionHandle);
+            if (current && !current.exited)
+                this.#scheduleMetadataRefresh(sessionHandle);
+        });
+        this.#metadataRefreshes.set(sessionHandle, refresh);
+    }
     #cancelMetadataRefresh(sessionHandle) {
         const timer = this.#metadataTimers.get(sessionHandle);
         if (timer !== undefined)
             window.clearTimeout(timer);
         this.#metadataTimers.delete(sessionHandle);
+        this.#metadataRefreshPending.delete(sessionHandle);
     }
     sessionMetadata(sessionHandle) {
         return this.#sessionByHandle.get(sessionHandle);
     }
     registerSession(session) {
+        const previous = this.#sessionByHandle.get(session.handle);
+        if (!previous || previous.id !== session.id || !previous.exited || !session.exited) {
+            this.#appliedRoutedExitEvents.delete(session.handle);
+        }
         this.#sessionByHandle.set(session.handle, session);
         this.#handleBySessionId.set(session.id, session.handle);
+        this.#bumpSessionGeneration(session.handle);
+    }
+    applySessionEvent(event) {
+        if (this.#disposed)
+            return;
+        if (event.type === "updated") {
+            const handle = this.#handleBySessionId.get(event.session.id);
+            if (handle)
+                this.#applyRoutedSessionSummary(handle, event.session);
+            return;
+        }
+        if (event.type === "activity-changed") {
+            this.#applySessionActivity({
+                requestId: 0,
+                type: "session-activity-changed",
+                sessionId: event.sessionId,
+                activity: event.activity,
+            });
+            return;
+        }
+        if (event.type === "exited") {
+            const handle = this.#handleBySessionId.get(event.sessionId);
+            const current = handle ? this.#sessionByHandle.get(handle) : undefined;
+            if (!handle || !current || this.#appliedRoutedExitEvents.has(handle))
+                return;
+            this.#appliedRoutedExitEvents.add(handle);
+            this.#applySessionExited({
+                requestId: 0,
+                type: "session-exited",
+                sessionId: event.sessionId,
+                exitCode: event.exitCode,
+                exitSignal: event.exitSignal,
+                requestedTermination: event.requestedTermination,
+                exitOutcome: event.exitOutcome,
+            });
+            return;
+        }
+        this.unregisterSession(event.sessionId);
     }
     #queueFrameSubscriptionSync() {
         const frames = this.#frames;
@@ -608,6 +800,13 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     async createSession(options) {
         await this.connect();
+        if (this.#routedHost) {
+            if (!this.#routedHost.createSession)
+                throw new Error("The routed host does not provide session creation");
+            const session = await this.#routedHost.createSession(options);
+            this.registerSession(session);
+            return session;
+        }
         if (options.scrollbackBytes !== undefined) {
             if (!isValidScrollbackBytes(options.scrollbackBytes)) {
                 throw new RangeError("scrollbackBytes must be a non-negative safe integer");
@@ -628,6 +827,14 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     async listSessions() {
         await this.connect();
+        if (this.#routedHost) {
+            const sessions = this.#routedHost.listSessions
+                ? await this.#routedHost.listSessions()
+                : [...this.#sessionByHandle.values()];
+            for (const session of sessions)
+                this.registerSession(session);
+            return sessions;
+        }
         const response = await this.#control.request({ type: "list-sessions" });
         if (response.type !== "sessions")
             throw new Error("ghosttead returned an unexpected response");
@@ -706,6 +913,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     async listRemoteHosts() {
         await this.connect();
+        if (this.#routedHost)
+            throw new Error("Remote-host discovery is not part of the routed host contract");
         const response = await this.#control.request({ type: "list-remote-hosts" });
         if (response.type !== "remote-hosts")
             throw new Error("ghosttead returned an unexpected response");
@@ -713,6 +922,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     async listRemoteSessions(deviceId) {
         await this.connect();
+        if (this.#routedHost)
+            throw new Error("Remote-session discovery is not part of the routed host contract");
         const response = await this.#control.request({ type: "list-remote-sessions", deviceId }, 35_000);
         if (response.type !== "remote-sessions" || response.deviceId !== deviceId)
             throw new Error("ghosttead returned an unexpected response");
@@ -720,6 +931,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     async openRemoteSession(deviceId, remoteSessionId, cols, rows, deviceName = deviceId) {
         await this.connect();
+        if (this.#routedHost)
+            throw new Error("Remote-session opening is not part of the routed host contract");
         const response = await this.#control.request({
             type: "open-remote-session",
             deviceId,
@@ -767,6 +980,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
     mount(sessionId, sessionHandle, viewId, canvas) {
         if (this.#disposed)
             throw new Error("Cannot mount a disposed terminal runtime");
+        if (this.#routedHost)
+            return this.#mountRouted(sessionId, sessionHandle, viewId, canvas);
         const mounted = this.#mountedCanvases.get(canvas);
         if (mounted) {
             if (!mounted.active)
@@ -801,6 +1016,9 @@ export class GhostteaTerminalRuntime extends EventTarget {
         const view = {
             sessionId,
             sessionHandle,
+            clientReadWrite: true,
+            resizeControlRequested: false,
+            visible: true,
             inputSequence: 0,
             resizeSequence: 0,
             controlEpoch: undefined,
@@ -869,6 +1087,723 @@ 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) {
+        const mounted = this.#mountedCanvases.get(canvas);
+        if (mounted) {
+            if (!mounted.active)
+                throw new Error("A released terminal canvas cannot be remounted");
+            if (mounted.sessionHandle !== sessionHandle) {
+                throw new Error("A terminal canvas cannot be reassigned to another session");
+            }
+            mounted.references += 1;
+            if (mounted.disposeTimer !== undefined) {
+                window.clearTimeout(mounted.disposeTimer);
+                mounted.disposeTimer = undefined;
+            }
+            return this.#createMountLease(mounted);
+        }
+        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]);
+        const entry = {
+            canvas,
+            sessionHandle,
+            sessionId,
+            viewId,
+            generation,
+            references: 1,
+            disposeTimer: undefined,
+            active: true,
+        };
+        this.#mountedCanvases.set(canvas, entry);
+        this.#mountedEntries.add(entry);
+        const session = this.#sessionByHandle.get(sessionHandle);
+        this.#views.set(viewId, {
+            sessionId,
+            sessionHandle,
+            ...(session === undefined ? {} : { readWrite: session.readWrite }),
+            clientReadWrite: true,
+            resizeControlRequested: false,
+            visible: true,
+            inputSequence: 0,
+            resizeSequence: 0,
+            controlEpoch: undefined,
+            desiredCols: undefined,
+            desiredRows: undefined,
+            pendingInput: [],
+            lastViewStateSeq: undefined,
+            lastAttachmentEpoch: undefined,
+            claimedEpoch: undefined,
+            claimedRevision: 0,
+        });
+        const activation = this.#routedBySession.get(sessionId);
+        if (activation)
+            activation.viewIds.add(viewId);
+        void this.#ensureRoutedActivation(sessionId, sessionHandle, viewId).catch((error) => {
+            if (!this.#disposed)
+                console.error(`[terminal-runtime] routed activation failed for ${sessionId}`, error);
+        });
+        return this.#createMountLease(entry);
+    }
+    async #ensureRoutedActivation(sessionId, sessionHandle, viewId) {
+        const existing = this.#routedBySession.get(sessionId);
+        if (existing) {
+            existing.viewIds.add(viewId);
+            if (existing.start)
+                await existing.start;
+            const anyWritable = this.#routedHost?.encodeInput !== undefined &&
+                [...existing.viewIds].some((candidate) => {
+                    const view = this.#views.get(candidate);
+                    return view?.clientReadWrite === true && view.readWrite !== false;
+                });
+            this.#transitionRouted(existing, { type: "input-policy", policy: anyWritable ? "read-write" : "read-only" });
+            this.#declareRoutedDemand(existing);
+            return;
+        }
+        const activationId = crypto.randomUUID();
+        const inputPolicy = this.#routedHost?.encodeInput !== undefined &&
+            this.#views.get(viewId)?.clientReadWrite !== false &&
+            this.#views.get(viewId)?.readWrite !== false
+            ? "read-write"
+            : "read-only";
+        const entry = {
+            sessionId,
+            sessionHandle,
+            state: initialRoutedActivation(sessionId, activationId, inputPolicy),
+            viewIds: new Set([viewId]),
+            recoveryAttempts: 0,
+            preAuthRemints: { control: 0, frames: 0 },
+            protocolFailures: { control: 0, frames: 0 },
+        };
+        this.#routedBySession.set(sessionId, entry);
+        this.#routedByActivation.set(activationId, entry);
+        entry.start = this.#startRoutedActivation(entry, "mount");
+        try {
+            await entry.start;
+        }
+        finally {
+            delete entry.start;
+        }
+    }
+    #routedTicketMatches(entry, ticket) {
+        return (isRoutedTerminalOpenTicket(ticket) &&
+            ticket.route.cellBootId === ticket.transportGrant.claims.audienceCellBootId &&
+            ticket.route.cellBootId === ticket.attachGrant.claims.audienceCellBootId &&
+            ticket.route.cellBootId === ticket.transportGrant.protected.kid.cellBootId &&
+            ticket.route.cellBootId === ticket.attachGrant.protected.kid.cellBootId &&
+            ticket.transportGrant.claims.clientId === ticket.attachGrant.claims.clientId &&
+            ticket.transportGrant.claims.allowedChannels.includes("control") &&
+            ticket.transportGrant.claims.allowedChannels.includes("frames") &&
+            ticket.attachGrant.claims.sessionId === entry.sessionId &&
+            ticket.attachGrant.claims.routeRevision === ticket.route.routeRevision &&
+            (ticket.route.leaseEpoch === undefined ||
+                ticket.attachGrant.claims.leaseEpoch === undefined ||
+                ticket.route.leaseEpoch === ticket.attachGrant.claims.leaseEpoch));
+    }
+    #routedRenewalMatches(entry, value, previousGeneration) {
+        const ticket = entry.ticket;
+        return (ticket !== undefined &&
+            isRoutedSessionAttachGrant(value) &&
+            value.protected.kid.cellBootId === ticket.route.cellBootId &&
+            value.claims.audienceCellBootId === ticket.route.cellBootId &&
+            value.claims.clientId === ticket.attachGrant.claims.clientId &&
+            value.claims.sessionId === entry.sessionId &&
+            value.claims.routeRevision === ticket.route.routeRevision &&
+            value.claims.leaseEpoch === ticket.attachGrant.claims.leaseEpoch &&
+            value.claims.grantGeneration > previousGeneration);
+    }
+    async #startRoutedActivation(entry, reason) {
+        const host = this.#routedHost;
+        if (!host || this.#disposed || entry.viewIds.size === 0)
+            return;
+        let ticket;
+        try {
+            ticket = await host.openTicket(entry.sessionId, { reason });
+        }
+        catch (error) {
+            this.#transitionRouted(entry, { type: "no-route", reason: String(error) });
+            return;
+        }
+        if (this.#routedBySession.get(entry.sessionId) !== entry || this.#disposed)
+            return;
+        if (!this.#routedTicketMatches(entry, ticket)) {
+            this.#transitionRouted(entry, { type: "no-route", reason: "ticket-binding-mismatch" });
+            return;
+        }
+        this.#transitionRouted(entry, { type: "ticket-minted", endpointsPresent: ticket.endpoints !== undefined });
+        if (!ticket.endpoints)
+            return;
+        entry.ticket = ticket;
+        this.#transitionRouted(entry, { type: "transport-ready" });
+        this.#routedControl.attach({
+            cellBootId: ticket.route.cellBootId,
+            controlUrl: ticket.endpoints.controlUrl,
+            transportGrant: ticket.transportGrant,
+            attachGrant: ticket.attachGrant,
+            activationId: entry.state.activationId,
+            ...(entry.replacesActivationId === undefined ? {} : { replacesActivationId: entry.replacesActivationId }),
+            initialDemand: this.#routedDemand(entry),
+            capabilities: this.#routedCapabilities,
+        });
+        this.#postWorker({
+            type: "routed-frames-attach",
+            request: {
+                cellBootId: ticket.route.cellBootId,
+                sessionHandle: entry.sessionHandle,
+                framesUrl: ticket.endpoints.framesUrl,
+                transportGrant: ticket.transportGrant,
+                attachGrant: ticket.attachGrant,
+                activationId: entry.state.activationId,
+                ...(entry.replacesActivationId === undefined ? {} : { replacesActivationId: entry.replacesActivationId }),
+                ...(this.#routedReceiverCapacities === undefined ? {} : { receiverCapacities: this.#routedReceiverCapacities }),
+                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 });
+        if (entry.attachTimer !== undefined)
+            window.clearTimeout(entry.attachTimer);
+        delete entry.attachTimer;
+        if (entry.renewalTimer !== undefined)
+            window.clearTimeout(entry.renewalTimer);
+        delete entry.renewalTimer;
+        delete entry.ticket;
+    }
+    #transitionRouted(entry, event) {
+        const previous = entry.state;
+        const next = reduceRoutedActivation(previous, event);
+        if (next === previous)
+            return;
+        entry.state = next;
+        if (next.phase !== "attaching" && entry.attachTimer !== undefined) {
+            window.clearTimeout(entry.attachTimer);
+            delete entry.attachTimer;
+        }
+        if ((next.phase === "unavailable" || next.phase === "ended") && next.phase !== previous.phase) {
+            this.#stopRoutedActivation(entry);
+        }
+        if (!previous.presentationReady && next.presentationReady) {
+            entry.recoveryAttempts = 0;
+            entry.protocolFailures.control = 0;
+            entry.protocolFailures.frames = 0;
+        }
+        this.dispatchEvent(new CustomEvent("routed-activation-state", {
+            detail: { sessionId: entry.sessionId, previous, current: next },
+        }));
+        if (previous.presentationReady !== next.presentationReady || previous.inputAllowed !== next.inputAllowed) {
+            for (const viewId of entry.viewIds) {
+                const view = this.#views.get(viewId);
+                this.dispatchEvent(new CustomEvent("routed-view-readiness", {
+                    detail: {
+                        sessionId: entry.sessionId,
+                        viewId,
+                        presentationReady: next.presentationReady,
+                        inputAllowed: next.inputAllowed && view?.clientReadWrite === true && view.readWrite !== false,
+                        phase: next.phase,
+                    },
+                }));
+            }
+        }
+    }
+    #handleRoutedControlEvent(event) {
+        if (this.#disposed)
+            return;
+        if (event.type === "extension-message") {
+            const host = this.#routedHost;
+            if (!host?.onExtensionMessage)
+                return;
+            try {
+                host.onExtensionMessage(event.message, event.context);
+            }
+            catch (error) {
+                console.error("[terminal-runtime] routed extension handler failed", error);
+            }
+            return;
+        }
+        if (event.type === "transport-ready") {
+            const deadline = event.accepted.protocolLimits.activationAttachDeadlineMs;
+            this.#routedAttachDeadlineByCell.set(event.cellBootId, deadline);
+            for (const entry of this.#routedBySession.values()) {
+                if (entry.ticket?.route.cellBootId === event.cellBootId && entry.state.phase === "attaching") {
+                    this.#armRoutedAttachDeadline(entry, deadline);
+                }
+            }
+            return;
+        }
+        if (event.type === "control-attached") {
+            const entry = this.#routedByActivation.get(event.attached.activationId);
+            if (!entry || event.attached.sessionId !== entry.sessionId)
+                return;
+            entry.preAuthRemints.control = 0;
+            this.#transitionRouted(entry, {
+                type: "control-attached",
+                grantGeneration: event.attached.grantGenerationAccepted,
+                rights: event.attached.rights,
+            });
+            const previousGeometry = this.#routedGeometry.get(entry.sessionId);
+            if (!event.attached.rights.includes("geometry") &&
+                previousGeometry?.holderViewId !== undefined &&
+                entry.viewIds.has(previousGeometry.holderViewId)) {
+                // 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, {
+                    revision: previousGeometry.revision + 1,
+                    ...(previousGeometry.cols === undefined ? {} : { cols: previousGeometry.cols }),
+                    ...(previousGeometry.rows === undefined ? {} : { rows: previousGeometry.rows }),
+                });
+            }
+            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 &&
+                    view.desiredCols !== undefined &&
+                    view.desiredRows !== undefined) {
+                    this.#claimRoutedGeometry(entry, viewId, view.desiredCols, view.desiredRows);
+                }
+            }
+            return;
+        }
+        if (event.type === "attach-refused") {
+            const entry = event.activationId ? this.#routedByActivation.get(event.activationId) : undefined;
+            if (!entry)
+                return;
+            this.#transitionRouted(entry, { type: "attach-refused", code: event.code, retryable: event.retryable });
+            if (entry.state.phase === "recovering") {
+                this.#recoverRoutedActivation(entry, event.code === "STALE_ROUTE" || event.code === "FENCED" ? "route-stale" : "retry");
+            }
+            return;
+        }
+        if (event.type === "cell-status") {
+            const entry = this.#routedByActivation.get(event.status.activationId);
+            if (!entry || event.status.sessionId !== entry.sessionId)
+                return;
+            this.#transitionRouted(entry, { type: "cell-status", status: event.status, now: performance.now() });
+            const sequence = entry.state.lastCellStatusSequence;
+            window.setTimeout(() => {
+                if (entry.state.lastCellStatusSequence !== sequence)
+                    return;
+                this.#transitionRouted(entry, { type: "cell-lease-expired" });
+            }, event.status.leaseTtlMs);
+            if (event.status.presentation.state === "revoked" &&
+                (event.status.presentation.reason === "leg-dead" || event.status.presentation.reason === "stale-route")) {
+                this.#recoverRoutedActivation(entry, event.status.presentation.reason === "stale-route" ? "route-stale" : "retry");
+            }
+            return;
+        }
+        if (event.type === "geometry-committed") {
+            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,
+                revision: event.committed.geometryRevision,
+                cols: event.committed.cols,
+                rows: event.committed.rows,
+            });
+            this.dispatchEvent(new CustomEvent("routed-geometry", { detail: { sessionId: entry.sessionId, ...event } }));
+            return;
+        }
+        if (event.type === "geometry-refused") {
+            const entry = event.activationId ? this.#routedByActivation.get(event.activationId) : undefined;
+            if (entry && event.refused.geometryRevision !== undefined) {
+                const previous = this.#routedGeometry.get(entry.sessionId);
+                const holder = event.refused.currentHolder;
+                this.#routedGeometry.set(entry.sessionId, {
+                    revision: event.refused.geometryRevision,
+                    ...(holder === undefined ? {} : { holderViewId: holder.viewId, holderGeneration: holder.holderGeneration }),
+                    ...(previous?.cols === undefined ? {} : { cols: previous.cols }),
+                    ...(previous?.rows === undefined ? {} : { rows: previous.rows }),
+                });
+            }
+            this.dispatchEvent(new CustomEvent("routed-geometry-refused", { detail: event }));
+            return;
+        }
+        if (event.type === "transport-closed") {
+            this.#routedAttachDeadlineByCell.delete(event.cellBootId);
+            for (const activationId of event.activationIds) {
+                const entry = this.#routedByActivation.get(activationId);
+                if (!entry)
+                    continue;
+                if (event.preAuth || event.refusal) {
+                    const recoverable = event.refusal ? routedConnectionRefusalIsRecoverable(event.refusal) : true;
+                    this.#transitionRouted(entry, {
+                        type: "transport-failed",
+                        ...(event.preAuth ? { preAuth: true } : {}),
+                        ...(event.refusal === undefined ? {} : { retryable: recoverable }),
+                    });
+                    if (entry.state.phase === "unavailable")
+                        continue;
+                    this.#recoverRoutedActivation(entry, event.preAuth ? "pre-auth" : "retry", "control");
+                    continue;
+                }
+                const routeStale = event.code === 4000 || event.code === 4001;
+                if (event.code === 4002) {
+                    this.#transitionRouted(entry, { type: "replaced" });
+                    continue;
+                }
+                if (event.code === 4003) {
+                    if (entry.protocolFailures.control >= 1) {
+                        this.#transitionRouted(entry, { type: "leg-lost", channel: "control", resumeCapable: false });
+                        this.#transitionRouted(entry, {
+                            type: "transport-failed",
+                            recoveryExhausted: true,
+                            reason: "protocol",
+                        });
+                        this.dispatchEvent(new CustomEvent("routed-protocol-error", {
+                            detail: { sessionId: entry.sessionId, channel: "control", reason: event.reason },
+                        }));
+                        continue;
+                    }
+                    entry.protocolFailures.control += 1;
+                }
+                this.#transitionRouted(entry, {
+                    type: routeStale ? "route-stale" : "leg-lost",
+                    channel: "control",
+                    resumeCapable: false,
+                });
+                this.#recoverRoutedActivation(entry, routeStale ? "route-stale" : "retry", "control");
+            }
+        }
+    }
+    #handleRoutedFramesEvent(event) {
+        if (event.type === "frames-attached") {
+            const entry = this.#routedByActivation.get(event.attached.activationId);
+            if (!entry || event.attached.sessionId !== entry.sessionId)
+                return;
+            entry.preAuthRemints.frames = 0;
+            this.#transitionRouted(entry, {
+                type: "frames-attached",
+                outcome: event.attached.outcome,
+                trfIdentity: event.attached.trfIdentity,
+                resumeToken: event.attached.resumeToken,
+            });
+            return;
+        }
+        if (event.type === "attach-refused") {
+            const entry = event.activationId ? this.#routedByActivation.get(event.activationId) : undefined;
+            if (!entry)
+                return;
+            this.#transitionRouted(entry, { type: "attach-refused", code: event.code, retryable: event.retryable });
+            if (entry.state.phase === "recovering") {
+                this.#recoverRoutedActivation(entry, event.code === "STALE_ROUTE" || event.code === "FENCED" ? "route-stale" : "retry", "frames");
+            }
+            return;
+        }
+        if (event.type === "frames-state") {
+            const entry = this.#routedByActivation.get(event.activationId);
+            if (!entry)
+                return;
+            this.#transitionRouted(entry, {
+                type: "frames-state",
+                state: {
+                    activationId: event.activationId,
+                    state: event.state,
+                    ...(event.resumeToken === undefined ? {} : { resumeToken: event.resumeToken }),
+                    ...(event.appliedContent === undefined ? {} : { appliedContent: event.appliedContent }),
+                },
+            });
+            if (event.state === "active" && event.appliedContent) {
+                this.#transitionRouted(entry, { type: "sync-complete", appliedContent: event.appliedContent });
+            }
+            else if (event.state === "failed") {
+                this.#transitionRouted(entry, { type: "sync-failed" });
+            }
+            return;
+        }
+        if (event.type === "presentation-status") {
+            const entry = this.#routedByActivation.get(event.status.activationId);
+            if (!entry)
+                return;
+            this.#transitionRouted(entry, { type: "presentation-status", status: event.status, now: performance.now() });
+            const sequence = entry.state.lastWorkerStatusSequence;
+            window.setTimeout(() => {
+                if (entry.state.lastWorkerStatusSequence !== sequence)
+                    return;
+                this.#transitionRouted(entry, { type: "worker-lease-expired" });
+            }, event.status.leaseTtlMs);
+            return;
+        }
+        for (const activationId of event.activationIds) {
+            const entry = this.#routedByActivation.get(activationId);
+            if (!entry)
+                continue;
+            if (event.preAuth || event.refusal) {
+                const recoverable = event.refusal ? routedConnectionRefusalIsRecoverable(event.refusal) : true;
+                this.#transitionRouted(entry, {
+                    type: "transport-failed",
+                    ...(event.preAuth ? { preAuth: true } : {}),
+                    ...(event.refusal === undefined ? {} : { retryable: recoverable }),
+                });
+                if (entry.state.phase === "unavailable")
+                    continue;
+                this.#resumeRoutedFrames(entry, event.preAuth ? "pre-auth" : "retry");
+                continue;
+            }
+            const routeStale = event.code === 4000 || event.code === 4001;
+            if (event.code === 4002) {
+                this.#transitionRouted(entry, { type: "replaced" });
+                continue;
+            }
+            if (event.code === 4003) {
+                if (entry.protocolFailures.frames >= 1) {
+                    this.#transitionRouted(entry, { type: "leg-lost", channel: "frames", resumeCapable: false });
+                    this.#transitionRouted(entry, {
+                        type: "transport-failed",
+                        recoveryExhausted: true,
+                        reason: "protocol",
+                    });
+                    this.dispatchEvent(new CustomEvent("routed-protocol-error", {
+                        detail: { sessionId: entry.sessionId, channel: "frames", reason: event.reason },
+                    }));
+                    continue;
+                }
+                entry.protocolFailures.frames += 1;
+            }
+            const activationFailed = event.code === 4002 || event.code === 4003;
+            const canResume = !routeStale &&
+                !activationFailed &&
+                this.#routedCapabilities.includes("resume") &&
+                entry.state.resumeToken !== undefined &&
+                entry.state.appliedContent !== undefined &&
+                entry.ticket?.endpoints !== undefined;
+            this.#transitionRouted(entry, {
+                type: routeStale ? "route-stale" : "leg-lost",
+                channel: "frames",
+                resumeCapable: canResume,
+            });
+            if (canResume) {
+                this.#resumeRoutedFrames(entry, "retry");
+            }
+            else {
+                this.#recoverRoutedActivation(entry, routeStale ? "route-stale" : "retry", "frames");
+            }
+        }
+    }
+    #resumeRoutedFrames(entry, reason) {
+        if (entry.framesResume || this.#disposed)
+            return;
+        const task = (async () => {
+            const host = this.#routedHost;
+            const previousTicket = entry.ticket;
+            const activationId = entry.state.activationId;
+            const resumeToken = entry.state.resumeToken;
+            const appliedContent = entry.state.appliedContent;
+            if (!host || !previousTicket?.endpoints || !resumeToken || !appliedContent) {
+                this.#recoverRoutedActivation(entry, reason, "frames");
+                return;
+            }
+            if (reason === "pre-auth") {
+                if (entry.preAuthRemints.frames >= 1) {
+                    this.#transitionRouted(entry, { type: "transport-failed", preAuth: true, recoveryExhausted: true });
+                    return;
+                }
+                entry.preAuthRemints.frames += 1;
+            }
+            entry.recoveryAttempts += 1;
+            if (entry.recoveryAttempts > 5) {
+                this.#transitionRouted(entry, { type: "transport-failed", recoveryExhausted: true });
+                return;
+            }
+            let ticket;
+            try {
+                ticket = await host.openTicket(entry.sessionId, { reason });
+            }
+            catch {
+                this.#recoverRoutedActivation(entry, "retry", "frames");
+                return;
+            }
+            if (this.#disposed ||
+                this.#routedByActivation.get(activationId) !== entry ||
+                entry.state.activationId !== activationId) {
+                return;
+            }
+            if (!this.#routedTicketMatches(entry, ticket) || !ticket.endpoints) {
+                this.#recoverRoutedActivation(entry, "route-stale", "frames");
+                return;
+            }
+            const sameRoute = ticket.route.cellBootId === previousTicket.route.cellBootId &&
+                ticket.route.routeRevision === previousTicket.route.routeRevision &&
+                ticket.route.leaseEpoch === previousTicket.route.leaseEpoch;
+            if (!sameRoute) {
+                this.#transitionRouted(entry, { type: "route-stale" });
+                this.#recoverRoutedActivation(entry, "route-stale", "frames");
+                return;
+            }
+            entry.ticket = ticket;
+            this.#routedControl?.renew(activationId, ticket.attachGrant);
+            this.#scheduleRoutedRenewal(entry);
+            this.#postWorker({
+                type: "routed-frames-attach",
+                request: {
+                    cellBootId: ticket.route.cellBootId,
+                    sessionHandle: entry.sessionHandle,
+                    framesUrl: ticket.endpoints.framesUrl,
+                    transportGrant: ticket.transportGrant,
+                    attachGrant: ticket.attachGrant,
+                    activationId,
+                    resume: { resumeToken, from: appliedContent },
+                    ...(this.#routedReceiverCapacities === undefined
+                        ? {}
+                        : { receiverCapacities: this.#routedReceiverCapacities }),
+                    capabilities: this.#routedCapabilities,
+                },
+            });
+        })();
+        entry.framesResume = task;
+        void task.finally(() => {
+            if (entry.framesResume === task)
+                delete entry.framesResume;
+        });
+    }
+    #recoverRoutedActivation(entry, reason, failedChannel) {
+        if (this.#disposed || entry.viewIds.size === 0 || entry.state.phase === "ended")
+            return;
+        if (reason === "pre-auth") {
+            const channel = failedChannel ?? "control";
+            if (entry.preAuthRemints[channel] >= 1) {
+                this.#transitionRouted(entry, { type: "transport-failed", preAuth: true, recoveryExhausted: true });
+                return;
+            }
+            entry.preAuthRemints[channel] += 1;
+        }
+        entry.recoveryAttempts += 1;
+        if (entry.recoveryAttempts > 5) {
+            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 });
+        this.#routedByActivation.delete(previousActivationId);
+        const nextActivationId = crypto.randomUUID();
+        entry.replacesActivationId = previousActivationId;
+        const inputPolicy = this.#routedHost?.encodeInput !== undefined &&
+            [...entry.viewIds].some((viewId) => {
+                const view = this.#views.get(viewId);
+                return view?.clientReadWrite === true && view.readWrite !== false;
+            })
+            ? "read-write"
+            : "read-only";
+        entry.state = {
+            ...initialRoutedActivation(entry.sessionId, nextActivationId, inputPolicy),
+            phase: "recovering",
+            replacesActivationId: previousActivationId,
+            preAuthRemintUsed: entry.preAuthRemints.control > 0 || entry.preAuthRemints.frames > 0,
+        };
+        this.#routedByActivation.set(nextActivationId, entry);
+        if (entry.attachTimer !== undefined)
+            window.clearTimeout(entry.attachTimer);
+        delete entry.attachTimer;
+        if (entry.renewalTimer !== undefined)
+            window.clearTimeout(entry.renewalTimer);
+        delete entry.renewalTimer;
+        delete entry.ticket;
+        const delay = Math.min(2_000, 100 * 2 ** Math.max(0, entry.recoveryAttempts - 1));
+        window.setTimeout(() => {
+            if (this.#routedByActivation.get(nextActivationId) !== entry)
+                return;
+            entry.start = this.#startRoutedActivation(entry, reason);
+            void entry.start.finally(() => delete entry.start);
+        }, delay);
+    }
+    #armRoutedAttachDeadline(entry, delayMs) {
+        if (entry.attachTimer !== undefined)
+            window.clearTimeout(entry.attachTimer);
+        const activationId = entry.state.activationId;
+        entry.attachTimer = window.setTimeout(() => {
+            if (this.#routedByActivation.get(activationId) !== entry || entry.state.phase !== "attaching")
+                return;
+            this.#transitionRouted(entry, { type: "attach-deadline" });
+            this.#recoverRoutedActivation(entry, "retry");
+        }, Math.max(0, delayMs));
+    }
+    #scheduleRoutedRenewal(entry) {
+        const ticket = entry.ticket;
+        const host = this.#routedHost;
+        if (!ticket || !host)
+            return;
+        if (entry.renewalTimer !== undefined)
+            window.clearTimeout(entry.renewalTimer);
+        const generation = ticket.attachGrant.claims.grantGeneration;
+        const delay = Math.max(0, ticket.attachGrant.claims.expiresAt - Date.now() - 60_000);
+        if (delay > MAX_BROWSER_TIMEOUT_MS) {
+            entry.renewalTimer = window.setTimeout(() => {
+                if (entry.ticket !== ticket || this.#disposed)
+                    return;
+                this.#scheduleRoutedRenewal(entry);
+            }, MAX_BROWSER_TIMEOUT_MS);
+            return;
+        }
+        entry.renewalTimer = window.setTimeout(() => {
+            this.#transitionRouted(entry, { type: "grant-expiring" });
+            if (!host.renewAttach) {
+                this.#transitionRouted(entry, { type: "renew-failed" });
+                return;
+            }
+            const requestId = crypto.randomUUID();
+            void host
+                .renewAttach({ sessionId: entry.sessionId, expectGeneration: generation, requestId })
+                .then(({ attachGrant }) => {
+                if (entry.ticket !== ticket || !this.#routedRenewalMatches(entry, attachGrant, generation)) {
+                    this.#transitionRouted(entry, { type: "renew-failed" });
+                    return;
+                }
+                entry.ticket = { ...ticket, attachGrant };
+                this.#routedControl?.renew(entry.state.activationId, attachGrant);
+                this.#scheduleRoutedRenewal(entry);
+            })
+                .catch(() => this.#transitionRouted(entry, { type: "renew-failed" }));
+        }, delay);
+    }
+    #routedDemand(entry) {
+        let live = false;
+        let urgent = false;
+        for (const viewId of entry.viewIds) {
+            const view = this.#views.get(viewId);
+            live ||= view?.visible === true;
+            urgent ||= view?.visible === true && this.#focusByView.get(viewId) === true;
+        }
+        return {
+            mode: live ? "live" : "none",
+            urgency: urgent ? "urgent" : "normal",
+        };
+    }
+    #declareRoutedDemand(entry) {
+        this.#routedControl?.declareDemand(entry.state.activationId, this.#routedDemand(entry));
+    }
+    #releaseRoutedView(sessionId, viewId) {
+        const entry = this.#routedBySession.get(sessionId);
+        if (!entry)
+            return;
+        entry.viewIds.delete(viewId);
+        if (entry.viewIds.size > 0) {
+            const anyWritable = this.#routedHost?.encodeInput !== undefined &&
+                [...entry.viewIds].some((candidate) => {
+                    const view = this.#views.get(candidate);
+                    return view?.clientReadWrite === true && view.readWrite !== false;
+                });
+            this.#transitionRouted(entry, { type: "input-policy", policy: anyWritable ? "read-write" : "read-only" });
+            this.#declareRoutedDemand(entry);
+            return;
+        }
+        this.#transitionRouted(entry, { type: "detach" });
+        this.#routedBySession.delete(sessionId);
+        this.#routedByActivation.delete(entry.state.activationId);
+        this.#routedGeometry.delete(sessionId);
+    }
     #createMountLease(mounted) {
         let disposed = false;
         return {
@@ -891,13 +1826,17 @@ export class GhostteaTerminalRuntime extends EventTarget {
                     if (ownsWorkerSurface) {
                         this.#postWorker({ type: "unmount", surfaceId: mounted.viewId });
                         this.#mountGenerationBySurface.delete(mounted.viewId);
-                        this.#control?.notify({ type: "detach-session", sessionId: mounted.sessionId, viewId: mounted.viewId });
+                        if (this.#routedHost)
+                            this.#releaseRoutedView(mounted.sessionId, mounted.viewId);
+                        else
+                            this.#control?.notify({ type: "detach-session", sessionId: mounted.sessionId, viewId: mounted.viewId });
                         this.#views.delete(mounted.viewId);
                         this.#focusByView.delete(mounted.viewId);
                     }
                     this.#mountedCanvases.delete(mounted.canvas);
                     this.#mountedEntries.delete(mounted);
-                    this.#releaseFrameSubscription(mounted.sessionHandle);
+                    if (!this.#routedHost)
+                        this.#releaseFrameSubscription(mounted.sessionHandle);
                 }, 0);
             },
         };
@@ -950,8 +1889,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 this.#sendResize(viewId, view, view.desiredCols, view.desiredRows);
             }
         }
-        // A cleared controller is the one case worth re-evaluating: the pane that
-        // still holds focus may now take control back.
+        // A cleared controller is the one case worth re-evaluating: a view with an
+        // outstanding explicit resize-control request may now take the seat.
         for (const viewId of this.#viewIdsForSession(sessionId))
             this.#maybeReclaim(viewId);
     }
@@ -963,10 +1902,9 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     /**
      * The single funnel for taking resize control (§4.2.3). Every condition that
-     * gates a claim re-enters here when it changes, because no one event is
-     * enough: recovery marks a view attached before its session reaches live, and
-     * the focus setter suppresses repeat `true` updates, so a claim keyed on
-     * either alone would be skipped and never retried.
+     * gates an explicit claim re-enters here when it changes, because no one
+     * event is enough: recovery can mark a view attached before its session
+     * reaches live, while the resize-control request already exists.
      *
      * At most one claim per attachment epoch, plus one more each time the
      * controller is cleared at a newer revision.
@@ -980,15 +1918,13 @@ export class GhostteaTerminalRuntime extends EventTarget {
      */
     #maybeReclaim(viewId) {
         const view = this.#views.get(viewId);
-        if (!view || view.readWrite === false)
+        if (!view || view.readWrite === false || !view.clientReadWrite || !view.resizeControlRequested)
             return;
         const attachmentEpoch = view.attachmentEpoch;
         if (attachmentEpoch === undefined)
             return;
         if (view.desiredCols === undefined || view.desiredRows === undefined)
             return;
-        if (this.#focusByView.get(viewId) !== true)
-            return;
         const remote = this.#remoteSessions.get(view.sessionId);
         if (remote && (remote.state !== "live" || remote.awaitingRecoveryFrame))
             return;
@@ -1181,7 +2117,7 @@ export class GhostteaTerminalRuntime extends EventTarget {
      */
     #sendViewInput(viewId, operation, silent = false) {
         const view = this.#views.get(viewId);
-        if (!view || view.readWrite === false)
+        if (!view || view.readWrite === false || !view.clientReadWrite)
             return;
         const remote = this.#remoteSessions.get(view.sessionId);
         const attachmentEpoch = view.attachmentEpoch;
@@ -1206,36 +2142,100 @@ export class GhostteaTerminalRuntime extends EventTarget {
     #reportSuppressedInput(sessionId, viewId, state) {
         this.dispatchEvent(new CustomEvent("input-suppressed", { detail: { sessionId, viewId, state } }));
     }
+    #sendRoutedInput(sessionId, viewId, operation, silent = false) {
+        const host = this.#routedHost;
+        const view = this.#views.get(viewId);
+        const activation = this.#routedBySession.get(sessionId);
+        if (!host ||
+            !view ||
+            view.sessionId !== sessionId ||
+            view.readWrite === false ||
+            !view.clientReadWrite ||
+            !activation?.state.inputAllowed) {
+            if (!silent) {
+                this.dispatchEvent(new CustomEvent("routed-input-suppressed", {
+                    detail: {
+                        sessionId,
+                        viewId,
+                        reason: !host?.encodeInput ? "wire-verb-unavailable" : "input-not-allowed",
+                    },
+                }));
+            }
+            return false;
+        }
+        if (!host.encodeInput) {
+            if (!silent) {
+                this.dispatchEvent(new CustomEvent("routed-input-suppressed", {
+                    detail: { sessionId, viewId, reason: "wire-verb-unavailable" },
+                }));
+            }
+            return false;
+        }
+        view.inputSequence += 1;
+        const message = host.encodeInput({
+            sessionId,
+            viewId,
+            activationId: activation.state.activationId,
+            leaseEpoch: activation.ticket?.attachGrant.claims.leaseEpoch ?? 0,
+            inputSequence: view.inputSequence,
+            operation,
+        });
+        return message !== null && this.#routedControl.sendExtension(activation.state.activationId, message);
+    }
     sendText(sessionId, viewId, text) {
+        if (this.#routedHost) {
+            this.#sendRoutedInput(sessionId, viewId, { kind: "text", text });
+            return;
+        }
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => this.#control?.notify({ type: "send-text", sessionId, viewId, attachmentEpoch, inputSequence, text }));
         const handle = this.#handleBySessionId.get(sessionId);
         if (handle)
             this.#postWorker({ type: "cursor-activity", sessionHandle: handle });
     }
     paste(sessionId, viewId, text) {
+        if (this.#routedHost) {
+            this.#sendRoutedInput(sessionId, viewId, { kind: "paste", text });
+            return;
+        }
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => this.#control?.notify({ type: "paste", sessionId, viewId, attachmentEpoch, inputSequence, text }));
         const handle = this.#handleBySessionId.get(sessionId);
         if (handle)
             this.#postWorker({ type: "cursor-activity", sessionHandle: handle });
     }
     sendKey(sessionId, viewId, event) {
+        if (this.#routedHost) {
+            this.#sendRoutedInput(sessionId, viewId, { kind: "key", event });
+            return;
+        }
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => this.#control?.notify({ type: "send-key", sessionId, viewId, attachmentEpoch, inputSequence, event }));
         const handle = this.#handleBySessionId.get(sessionId);
         if (handle)
             this.#postWorker({ type: "cursor-activity", sessionHandle: handle });
     }
     sendMouse(sessionId, viewId, event) {
+        if (this.#routedHost) {
+            this.#sendRoutedInput(sessionId, viewId, { kind: "mouse", event }, true);
+            return;
+        }
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => this.#control?.notify({ type: "send-mouse", sessionId, viewId, attachmentEpoch, inputSequence, event }), true);
     }
     scroll(sessionId, viewId, rows) {
         if (rows === 0)
             return;
+        if (this.#routedHost) {
+            this.#sendRoutedInput(sessionId, viewId, { kind: "scroll", rows }, true);
+            return;
+        }
         // Scrolling is host-side input, so it is simply inert while frozen.
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => this.#control?.notify({ type: "scroll", sessionId, viewId, attachmentEpoch, inputSequence, rows }), true);
     }
     scrollTo(sessionId, viewId, row) {
         if (!Number.isSafeInteger(row) || row < 0)
             return;
+        if (this.#routedHost) {
+            this.#sendRoutedInput(sessionId, viewId, { kind: "scroll-to", row }, true);
+            return;
+        }
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => this.#control?.notify({ type: "scroll-to", sessionId, viewId, attachmentEpoch, inputSequence, row }), true);
     }
     scrollbar(sessionHandle) {
@@ -1246,6 +2246,10 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     setTheme(sessionHandle, theme, surfaceId) {
         this.#postWorker({ type: "theme", sessionHandle, ...(surfaceId ? { surfaceId } : {}), theme });
+        // A surface-scoped theme is renderer-local. Updating the daemon's
+        // session-wide palette here would repaint every mirrored viewer.
+        if (surfaceId)
+            return;
         const session = this.#sessionByHandle.get(sessionHandle);
         if (!session)
             return;
@@ -1270,6 +2274,25 @@ export class GhostteaTerminalRuntime extends EventTarget {
     }
     setVisible(sessionHandle, visible, surfaceId) {
         this.#postWorker({ type: "visibility", sessionHandle, ...(surfaceId ? { surfaceId } : {}), visible });
+        if (this.#routedHost) {
+            const session = this.#sessionByHandle.get(sessionHandle);
+            if (!session)
+                return;
+            if (surfaceId) {
+                const view = this.#views.get(surfaceId);
+                if (view)
+                    view.visible = visible;
+            }
+            else {
+                for (const view of this.#views.values()) {
+                    if (view.sessionId === session.id)
+                        view.visible = visible;
+                }
+            }
+            const entry = this.#routedBySession.get(session.id);
+            if (entry)
+                this.#declareRoutedDemand(entry);
+        }
     }
     forceFullRedraw(sessionHandle) {
         this.#postWorker({ type: "force-full-redraw", sessionHandle });
@@ -1280,28 +2303,92 @@ export class GhostteaTerminalRuntime extends EventTarget {
     setPartialRenderingEnabled(enabled) {
         this.#postWorker({ type: "partial-rendering", enabled });
     }
+    #claimRoutedGeometry(entry, viewId, cols, rows) {
+        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, {
+            sessionId: entry.sessionId,
+            activationId: entry.state.activationId,
+            leaseEpoch: ticket.attachGrant.claims.leaseEpoch ?? 0,
+            claimant: { clientId: ticket.attachGrant.claims.clientId, viewId },
+            cols,
+            rows,
+            expectRevision: geometry?.revision ?? 0,
+        });
+    }
     claimResizeControl(sessionHandle, viewId, cols, rows) {
         const view = this.#views.get(viewId);
         if (view) {
             view.desiredCols = cols;
             view.desiredRows = rows;
-            // An explicit claim is the funnel's outcome, not a competing path.
-            view.claimedEpoch = view.attachmentEpoch;
-            view.claimedRevision = this.#controlBySession.get(view.sessionId)?.revision ?? 0;
+            view.resizeControlRequested = true;
         }
-        const session = this.#sessionByHandle.get(sessionHandle);
-        if (!session)
+        if (this.#routedHost) {
+            const session = this.#sessionByHandle.get(sessionHandle);
+            const entry = session ? this.#routedBySession.get(session.id) : undefined;
+            if (entry)
+                this.#claimRoutedGeometry(entry, viewId, cols, rows);
             return;
-        this.#sendViewInput(viewId, (attachmentEpoch) => {
-            this.#control?.notify({
-                type: "focus-and-resize",
-                sessionId: session.id,
-                viewId,
-                attachmentEpoch,
-                cols,
-                rows,
-            });
-        }, true);
+        }
+        if (!this.#sessionByHandle.has(sessionHandle))
+            return;
+        this.#maybeReclaim(viewId);
+    }
+    releaseResizeControl(viewId) {
+        const view = this.#views.get(viewId);
+        if (!view)
+            return;
+        view.resizeControlRequested = false;
+        if (this.#routedHost) {
+            const entry = this.#routedBySession.get(view.sessionId);
+            const geometry = this.#routedGeometry.get(view.sessionId);
+            const ticket = entry?.ticket;
+            if (entry && ticket && geometry?.holderViewId === viewId && geometry.holderGeneration !== undefined) {
+                const sent = this.#routedControl?.releaseGeometry(entry.state.activationId, {
+                    sessionId: view.sessionId,
+                    activationId: entry.state.activationId,
+                    leaseEpoch: ticket.attachGrant.claims.leaseEpoch ?? 0,
+                    holder: {
+                        clientId: ticket.attachGrant.claims.clientId,
+                        viewId,
+                        holderGeneration: geometry.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, {
+                        revision: geometry.revision + 1,
+                        ...(geometry.cols === undefined ? {} : { cols: geometry.cols }),
+                        ...(geometry.rows === undefined ? {} : { rows: geometry.rows }),
+                    });
+                }
+            }
+            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;
+    }
+    setViewInputPolicy(viewId, readWrite) {
+        const view = this.#views.get(viewId);
+        if (!view)
+            return;
+        view.clientReadWrite = readWrite;
+        if (!readWrite)
+            view.pendingInput.length = 0;
+        const entry = this.#routedBySession.get(view.sessionId);
+        if (entry) {
+            const anyWritable = this.#routedHost?.encodeInput !== undefined &&
+                [...entry.viewIds].some((candidate) => {
+                    const candidateView = this.#views.get(candidate);
+                    return candidateView?.clientReadWrite === true && candidateView.readWrite !== false;
+                });
+            this.#transitionRouted(entry, { type: "input-policy", policy: anyWritable ? "read-write" : "read-only" });
+        }
     }
     setFocused(sessionHandle, viewId, focused, cols, rows) {
         const view = this.#views.get(viewId);
@@ -1310,10 +2397,6 @@ export class GhostteaTerminalRuntime extends EventTarget {
             view.desiredRows = rows;
         }
         if (this.#focusByView.get(viewId) === focused) {
-            // Focus has not moved, so the claim below will not run — but an epoch or
-            // controller change since the last update may have made one possible,
-            // and nothing else would ever retry it after a resume.
-            this.#maybeReclaim(viewId);
             return;
         }
         this.#focusByView.set(viewId, focused);
@@ -1321,6 +2404,12 @@ export class GhostteaTerminalRuntime extends EventTarget {
         const session = this.#sessionByHandle.get(sessionHandle);
         if (!session)
             return;
+        if (this.#routedHost) {
+            const entry = this.#routedBySession.get(session.id);
+            if (entry)
+                this.#declareRoutedDemand(entry);
+            return;
+        }
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => {
             this.#control?.notify({
                 type: "focus",
@@ -1330,25 +2419,12 @@ export class GhostteaTerminalRuntime extends EventTarget {
                 inputSequence,
                 focused,
             });
-            if (focused) {
-                // Taking focus is a deliberate claim, and counts as this epoch's.
-                if (view) {
-                    view.claimedEpoch = attachmentEpoch;
-                    view.claimedRevision = this.#controlBySession.get(view.sessionId)?.revision ?? 0;
-                }
-                this.#control?.notify({
-                    type: "focus-and-resize",
-                    sessionId: session.id,
-                    viewId,
-                    attachmentEpoch,
-                    cols,
-                    rows,
-                });
-            }
         }, true);
     }
     async copySelection(sessionId, viewId, selection, selectAll = false) {
         await this.connect();
+        if (this.#routedHost)
+            return "";
         const view = this.#views.get(viewId);
         if (!view || view.sessionId !== sessionId)
             return "";
@@ -1383,6 +2459,10 @@ export class GhostteaTerminalRuntime extends EventTarget {
         return response.text;
     }
     interrupt(sessionId, viewId) {
+        if (this.#routedHost) {
+            this.#sendRoutedInput(sessionId, viewId, { kind: "interrupt" });
+            return;
+        }
         this.#sendViewInput(viewId, (attachmentEpoch, inputSequence) => this.#control?.notify({ type: "interrupt", sessionId, viewId, attachmentEpoch, inputSequence }));
         const handle = this.#handleBySessionId.get(sessionId);
         if (handle)
@@ -1431,6 +2511,8 @@ export class GhostteaTerminalRuntime extends EventTarget {
             }
         }
         this.#sessionByHandle.delete(handle);
+        this.#sessionGenerationByHandle.delete(handle);
+        this.#appliedRoutedExitEvents.delete(handle);
         this.#handleBySessionId.delete(sessionId);
         this.#remoteSessions.delete(sessionId);
         this.#controlBySession.delete(sessionId);
@@ -1443,9 +2525,24 @@ export class GhostteaTerminalRuntime extends EventTarget {
         this.#postWorker({ type: "drop-session", sessionHandle: handle });
     }
     unregisterSession(sessionId) {
+        const routed = this.#routedBySession.get(sessionId);
+        if (routed) {
+            for (const viewId of [...routed.viewIds])
+                this.#releaseRoutedView(sessionId, viewId);
+        }
         this.#removeRegisteredSession(sessionId, true);
     }
     terminate(sessionId, source = "user") {
+        if (this.#routedHost) {
+            void this.#routedHost.terminate?.(sessionId, source);
+            const entry = this.#routedBySession.get(sessionId);
+            if (entry) {
+                for (const viewId of [...entry.viewIds])
+                    this.#releaseRoutedView(sessionId, viewId);
+            }
+            this.#removeRegisteredSession(sessionId, false);
+            return;
+        }
         this.#control?.notify({ type: "terminate", sessionId, source });
         this.#removeRegisteredSession(sessionId, false);
     }
@@ -1455,6 +2552,14 @@ export class GhostteaTerminalRuntime extends EventTarget {
             return;
         view.desiredCols = cols;
         view.desiredRows = rows;
+        if (!view.resizeControlRequested)
+            return;
+        if (this.#routedHost) {
+            const entry = this.#routedBySession.get(sessionId);
+            if (entry)
+                this.#claimRoutedGeometry(entry, viewId, cols, rows);
+            return;
+        }
         if (view.attachmentEpoch === undefined || view.controlEpoch === undefined) {
             // Dimensions are one of the funnel's conditions: a pane that measured
             // itself while uncontrolled may now be able to take control.
@@ -1489,12 +2594,21 @@ export class GhostteaTerminalRuntime extends EventTarget {
         for (const timer of this.#metadataTimers.values())
             window.clearTimeout(timer);
         this.#metadataTimers.clear();
+        this.#metadataRefreshPending.clear();
+        this.#metadataRefreshes.clear();
+        this.#sessionGenerationByHandle.clear();
+        this.#appliedRoutedExitEvents.clear();
         this.#resync.dispose();
         for (const request of this.#performanceRequests.values()) {
             window.clearTimeout(request.timer);
             request.reject(new Error("Terminal runtime was disposed during a performance request"));
         }
         this.#performanceRequests.clear();
+        for (const request of this.#counterRequests.values()) {
+            window.clearTimeout(request.timer);
+            request.reject(new Error("Terminal runtime was disposed during a counter request"));
+        }
+        this.#counterRequests.clear();
         this.#views.clear();
         this.#remoteSessions.clear();
         this.#controlBySession.clear();
@@ -1515,15 +2629,28 @@ export class GhostteaTerminalRuntime extends EventTarget {
         }
         this.#control?.dispose();
         this.#control = undefined;
+        this.#routedControl?.dispose();
+        for (const entry of this.#routedBySession.values()) {
+            if (entry.attachTimer !== undefined)
+                window.clearTimeout(entry.attachTimer);
+            if (entry.renewalTimer !== undefined)
+                window.clearTimeout(entry.renewalTimer);
+        }
+        this.#routedBySession.clear();
+        this.#routedByActivation.clear();
+        this.#routedGeometry.clear();
+        this.#routedAttachDeadlineByCell.clear();
         this.#serverProtocolMinor = 0;
         this.#worker.terminate();
-        void this.#ports.then((ports) => {
-            ports.control.close();
-            ports.frames.close();
-        }, () => undefined);
+        if (this.#ports) {
+            void this.#ports.then((ports) => {
+                ports.control.close();
+                ports.frames.close();
+            }, () => undefined);
+        }
     }
     #sendResize(viewId, view, cols, rows) {
-        if (view.attachmentEpoch === undefined || view.controlEpoch === undefined)
+        if (!view.resizeControlRequested || view.attachmentEpoch === undefined || view.controlEpoch === undefined)
             return;
         view.resizeSequence += 1;
         this.#control?.notify({