@orion-agents/orion-code 0.3.2 → 0.3.4

package/dist/web/session-runtime-registry.js

@@ -0,0 +1,448 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSessionRuntimeRegistryError = exports.WebSessionRuntimeRegistryV1 = void 0;
+const crypto_1 = require("crypto");
+const DEFAULT_MAX_RUNNING_SESSIONS = 3;
+const DEFAULT_MAX_RESIDENT_SESSION_ACTORS = 4;
+/**
+ * Bounded Web-only Session actor pool.
+ *
+ * It owns concurrency admission and actor lifetime, but deliberately knows
+ * nothing about React, HTTP, OrionRuntime, or TUI semantics. Callers provide a
+ * Session-scoped actor and a logical-turn terminal promise. This keeps Web
+ * parallelism out of the single-session CLI/TUI runner.
+ */
+class WebSessionRuntimeRegistryV1 {
+    constructor(options) {
+        this.options = options;
+        this.records = new Map();
+        this.queue = [];
+        this.capacityQueue = Promise.resolve();
+        this.ordinal = 0;
+        this.runningCountValue = 0;
+        this.closed = false;
+        this.maxRunningSessions = boundedInteger(options.maxRunningSessions, DEFAULT_MAX_RUNNING_SESSIONS, 1, 8, 'maxRunningSessions');
+        this.maxResidentSessionActors = boundedInteger(options.maxResidentSessionActors, DEFAULT_MAX_RESIDENT_SESSION_ACTORS, 1, 8, 'maxResidentSessionActors');
+        if (this.maxResidentSessionActors < this.maxRunningSessions) {
+            throw new Error('maxResidentSessionActors must be greater than or equal to maxRunningSessions.');
+        }
+        this.now = options.now ?? Date.now;
+        this.createRevision = options.createRevision ?? crypto_1.randomUUID;
+    }
+    get runningCount() {
+        return this.runningCountValue;
+    }
+    get residentCount() {
+        let count = 0;
+        for (const record of this.records.values())
+            if (record.actor !== undefined)
+                count += 1;
+        return count;
+    }
+    summary(key) {
+        return this.snapshot(this.record(key));
+    }
+    summaries() {
+        return Object.freeze([...this.records.values()]
+            .sort((left, right) => right.lastUsedOrdinal - left.lastUsedOrdinal)
+            .map(record => this.snapshot(record)));
+    }
+    /**
+     * Return the current resident actor without starting a cold Session.
+     *
+     * Snapshot/read paths use this to project live state while preserving the
+     * cold-read invariant: merely selecting or inspecting a Session must not
+     * allocate a Runtime or consume a running slot.
+     */
+    residentActor(key) {
+        this.assertOpen();
+        const record = this.record(key);
+        if (!record.actor || !record.actorReady)
+            return undefined;
+        this.touch(record);
+        return Object.freeze({ actor: record.actor, runtime: this.snapshot(record) });
+    }
+    async ensureResident(key, expectedRuntimeRevision) {
+        return this.withCapacityLock(async () => {
+            this.assertOpen();
+            const record = this.record(key);
+            this.assertRevision(record, expectedRuntimeRevision);
+            const actor = await this.ensureResidentLocked(record);
+            return Object.freeze({ actor, runtime: this.snapshot(record) });
+        });
+    }
+    async withActor(key, expectedRuntimeRevision, action) {
+        return this.withCapacityLock(async () => {
+            this.assertOpen();
+            const record = this.record(key);
+            this.assertRevision(record, expectedRuntimeRevision);
+            const actor = await this.ensureResidentLocked(record);
+            const result = await action(actor);
+            this.touch(record);
+            return Object.freeze({ result, runtime: this.snapshot(record) });
+        });
+    }
+    async admitTurn(input) {
+        return this.withCapacityLock(async () => {
+            this.assertOpen();
+            const record = this.record(input.key);
+            this.assertRevision(record, input.expectedRuntimeRevision);
+            if (record.activeRun || record.queueId) {
+                throw new WebSessionRuntimeRegistryError(409, 'session_turn_already_active', 'The Session already has a running or queued logical turn.');
+            }
+            const actor = await this.ensureResidentLocked(record);
+            if (this.runningCountValue >= this.maxRunningSessions) {
+                const queueId = this.createRevision();
+                record.queueId = queueId;
+                this.queue.push({
+                    queueId,
+                    record,
+                    start: input.start,
+                });
+                record.queuePosition = this.queue.length;
+                this.transition(record, 'queued');
+                this.publishQueuePositions();
+                const runtime = this.snapshot(record);
+                return Object.freeze({
+                    status: 'queued',
+                    queueId,
+                    queuePosition: runtime.queuePosition,
+                    runtime,
+                });
+            }
+            const started = await this.startTurn(record, actor, input.start);
+            return Object.freeze({
+                status: 'started',
+                accepted: started.accepted,
+                runtime: started.runtime,
+            });
+        });
+    }
+    cancelQueued(key, queueId, expectedRuntimeRevision) {
+        this.assertOpen();
+        const record = this.record(key);
+        this.assertRevision(record, expectedRuntimeRevision);
+        if (!record.queueId || record.queueId !== queueId) {
+            throw new WebSessionRuntimeRegistryError(409, 'session_queue_conflict', 'The queued turn no longer matches this Session.');
+        }
+        const index = this.queue.findIndex(item => item.queueId === queueId && item.record === record);
+        if (index < 0) {
+            throw new WebSessionRuntimeRegistryError(409, 'session_queue_conflict', 'The queued turn is no longer pending.');
+        }
+        this.queue.splice(index, 1);
+        record.queueId = undefined;
+        record.queuePosition = undefined;
+        this.transition(record, 'idle');
+        this.publishQueuePositions();
+        return this.snapshot(record);
+    }
+    setPendingApprovalCount(key, count) {
+        this.assertOpen();
+        const record = this.record(key);
+        if (!Number.isSafeInteger(count) || count < 0) {
+            throw new Error('pending approval count must be a non-negative integer.');
+        }
+        const normalized = count;
+        if (record.pendingApprovalCount === normalized)
+            return this.snapshot(record);
+        record.pendingApprovalCount = normalized;
+        if (record.activeRun)
+            this.transition(record, normalized > 0 ? 'waiting_approval' : 'running');
+        else
+            this.bump(record);
+        return this.snapshot(record);
+    }
+    async evict(key, reason = 'session actor evicted') {
+        this.assertOpen();
+        const record = this.record(key);
+        await this.withCapacityLock(async () => {
+            if (!record.actor)
+                return;
+            if (!this.isEvictable(record)) {
+                throw new WebSessionRuntimeRegistryError(409, 'session_actor_busy', 'Running, queued, approval-waiting, or stopping actors cannot be evicted.');
+            }
+            await this.closeResidentLocked(record, reason, 'cold');
+        });
+    }
+    async shutdown(reason = 'Web Session registry shutdown') {
+        this.closed = true;
+        const queued = this.queue.splice(0);
+        for (const item of queued) {
+            item.record.queueId = undefined;
+            item.record.queuePosition = undefined;
+            this.transition(item.record, 'interrupted');
+        }
+        const cleanupErrors = [];
+        await this.withCapacityLock(async () => {
+            const residents = [...this.records.values()].filter(record => record.actor !== undefined);
+            await Promise.all(residents.map(async (record) => {
+                const actor = record.actor;
+                if (!actor)
+                    return;
+                const wasActive = record.activeRun;
+                if (wasActive)
+                    this.runningCountValue = Math.max(0, this.runningCountValue - 1);
+                record.activeRun = false;
+                record.pendingApprovalCount = 0;
+                record.actorReady = false;
+                this.transition(record, 'stopping');
+                try {
+                    await this.options.closeActor(actor, reason);
+                    record.actor = undefined;
+                    record.estimatedBytes = 0;
+                    this.transition(record, wasActive ? 'interrupted' : 'cold');
+                }
+                catch (error) {
+                    record.failure = error;
+                    this.transition(record, 'failed');
+                    cleanupErrors.push(error);
+                }
+            }));
+        });
+        if (cleanupErrors.length > 0) {
+            throw new WebSessionRuntimeRegistryError(503, 'session_actor_cleanup_failed', `${cleanupErrors.length} Session actor(s) could not be closed safely.`);
+        }
+    }
+    record(key) {
+        const normalized = normalizeKey(key);
+        const id = keyId(normalized);
+        let record = this.records.get(id);
+        if (!record) {
+            const now = this.now();
+            record = {
+                key: normalized,
+                phase: 'cold',
+                runtimeRevision: this.createRevision(),
+                pendingApprovalCount: 0,
+                estimatedBytes: 0,
+                updatedAtMs: now,
+                lastUsedOrdinal: ++this.ordinal,
+                activeRun: false,
+                actorReady: false,
+            };
+            this.records.set(id, record);
+            this.publish(record);
+        }
+        return record;
+    }
+    async ensureResidentLocked(record) {
+        if (record.actor && record.actorReady) {
+            this.touch(record);
+            return record.actor;
+        }
+        if (record.actor) {
+            await this.closeResidentLocked(record, 'retry quarantined Session actor cleanup', 'cold');
+        }
+        await this.makeCapacityLocked(record);
+        this.transition(record, 'starting');
+        let actor;
+        try {
+            actor = await this.options.createActor(record.key);
+            await this.options.initializeActor?.(actor, record.key);
+            if (this.closed) {
+                throw new WebSessionRuntimeRegistryError(503, 'session_registry_closed', 'The Web Session registry is closed.');
+            }
+            record.estimatedBytes = normalizeBytes(this.options.estimateActorBytes?.(actor));
+            record.actor = actor;
+            record.actorReady = true;
+            actor = undefined;
+            record.failure = undefined;
+            this.transition(record, 'idle');
+            return record.actor;
+        }
+        catch (error) {
+            if (actor) {
+                try {
+                    await this.options.closeActor(actor, 'Session actor start failed');
+                }
+                catch (cleanupError) {
+                    // Preserve the only handle to the partially initialized actor. It is
+                    // never returned by residentActor/ensureResident and still counts
+                    // against the resident budget until a later eviction or shutdown
+                    // successfully closes it.
+                    record.actor = actor;
+                    record.actorReady = false;
+                    record.estimatedBytes = 0;
+                    record.failure = cleanupError;
+                    this.transition(record, 'failed');
+                    throw new WebSessionRuntimeRegistryError(503, 'session_actor_cleanup_failed', 'A failed Session actor could not be closed safely.');
+                }
+            }
+            record.actor = undefined;
+            record.actorReady = false;
+            record.estimatedBytes = 0;
+            record.failure = error;
+            this.transition(record, 'failed');
+            throw error;
+        }
+    }
+    async makeCapacityLocked(target) {
+        if (this.residentCount < this.maxResidentSessionActors)
+            return;
+        const candidate = [...this.records.values()]
+            .filter(record => record !== target && record.actor && this.isEvictable(record))
+            .sort((left, right) => left.lastUsedOrdinal - right.lastUsedOrdinal)[0];
+        if (!candidate) {
+            throw new WebSessionRuntimeRegistryError(503, 'session_concurrency_limit', 'All resident Session actors are busy; the requested Session remains available read-only.');
+        }
+        await this.closeResidentLocked(candidate, 'idle Session actor evicted by LRU', 'cold');
+    }
+    isEvictable(record) {
+        return (Boolean(record.actor) &&
+            !record.activeRun &&
+            !record.queueId &&
+            record.pendingApprovalCount === 0 &&
+            ['idle', 'failed', 'interrupted'].includes(record.phase));
+    }
+    async closeResidentLocked(record, reason, terminalPhase) {
+        const actor = record.actor;
+        if (!actor)
+            return;
+        record.actorReady = false;
+        this.transition(record, 'stopping');
+        try {
+            await this.options.closeActor(actor, reason);
+            record.actor = undefined;
+            record.estimatedBytes = 0;
+            this.transition(record, terminalPhase);
+        }
+        catch (error) {
+            record.failure = error;
+            this.transition(record, 'failed');
+            throw error;
+        }
+    }
+    async startTurn(record, actor, start) {
+        record.activeRun = true;
+        record.queueId = undefined;
+        record.pendingApprovalCount = 0;
+        this.runningCountValue += 1;
+        this.transition(record, 'running');
+        try {
+            const started = await start(actor);
+            void Promise.resolve(started.settled).then(() => this.finishTurn(record), error => this.finishTurn(record, error));
+            return Object.freeze({ accepted: started.accepted, runtime: this.snapshot(record) });
+        }
+        catch (error) {
+            this.finishTurn(record, error);
+            throw error;
+        }
+    }
+    finishTurn(record, error) {
+        if (!record.activeRun)
+            return;
+        record.activeRun = false;
+        record.pendingApprovalCount = 0;
+        this.runningCountValue = Math.max(0, this.runningCountValue - 1);
+        if (error) {
+            record.failure = error;
+            this.transition(record, 'failed');
+        }
+        else {
+            record.failure = undefined;
+            this.transition(record, 'idle');
+        }
+        this.drainQueue();
+    }
+    drainQueue() {
+        while (!this.closed && this.runningCountValue < this.maxRunningSessions && this.queue.length) {
+            const item = this.queue.shift();
+            item.record.queueId = undefined;
+            item.record.queuePosition = undefined;
+            const actor = item.record.actor;
+            if (!actor) {
+                item.record.failure = new Error('Queued Session actor is no longer resident.');
+                this.transition(item.record, 'failed');
+                continue;
+            }
+            void this.startTurn(item.record, actor, item.start).catch(() => undefined);
+        }
+        this.publishQueuePositions();
+    }
+    publishQueuePositions() {
+        for (const [index, item] of this.queue.entries()) {
+            const queuePosition = index + 1;
+            if (item.record.queuePosition === queuePosition)
+                continue;
+            item.record.queuePosition = queuePosition;
+            this.bump(item.record);
+        }
+    }
+    snapshot(record) {
+        return Object.freeze({
+            ...record.key,
+            runtimeRevision: record.runtimeRevision,
+            phase: record.phase,
+            ...(record.queueId ? { queueId: record.queueId } : {}),
+            ...(record.queueId && record.queuePosition ? { queuePosition: record.queuePosition } : {}),
+            pendingApprovalCount: record.pendingApprovalCount,
+            resident: record.actor !== undefined,
+            estimatedBytes: record.estimatedBytes,
+            updatedAt: new Date(record.updatedAtMs).toISOString(),
+        });
+    }
+    assertRevision(record, expectedRuntimeRevision) {
+        if (expectedRuntimeRevision === undefined)
+            return;
+        if (expectedRuntimeRevision !== record.runtimeRevision) {
+            throw new WebSessionRuntimeRegistryError(409, 'session_runtime_revision_conflict', 'The Session Runtime changed before the operation was admitted.');
+        }
+    }
+    transition(record, phase) {
+        record.phase = phase;
+        this.bump(record);
+    }
+    touch(record) {
+        record.lastUsedOrdinal = ++this.ordinal;
+        record.updatedAtMs = this.now();
+    }
+    bump(record) {
+        record.runtimeRevision = this.createRevision();
+        this.touch(record);
+        this.publish(record);
+    }
+    publish(record) {
+        this.options.onSummaryChanged?.(this.snapshot(record));
+    }
+    withCapacityLock(operation) {
+        const result = this.capacityQueue.then(operation, operation);
+        this.capacityQueue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new WebSessionRuntimeRegistryError(503, 'session_registry_closed', 'The Web Session registry is closed.');
+        }
+    }
+}
+exports.WebSessionRuntimeRegistryV1 = WebSessionRuntimeRegistryV1;
+class WebSessionRuntimeRegistryError extends Error {
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = 'WebSessionRuntimeRegistryError';
+    }
+}
+exports.WebSessionRuntimeRegistryError = WebSessionRuntimeRegistryError;
+function normalizeKey(key) {
+    const workspaceId = key.workspaceId.trim();
+    const sessionId = key.sessionId.trim();
+    if (!workspaceId || !sessionId)
+        throw new Error('Session actor identity must not be empty.');
+    return Object.freeze({ workspaceId, sessionId });
+}
+function keyId(key) {
+    return `${key.workspaceId}\u0000${key.sessionId}`;
+}
+function normalizeBytes(value) {
+    return Number.isSafeInteger(value) && value > 0 ? value : 0;
+}
+function boundedInteger(value, fallback, minimum, maximum, name) {
+    const candidate = value ?? fallback;
+    if (!Number.isSafeInteger(candidate) || candidate < minimum || candidate > maximum) {
+        throw new Error(`${name} must be an integer between ${minimum} and ${maximum}.`);
+    }
+    return candidate;
+}
+//# sourceMappingURL=session-runtime-registry.js.map

package/dist/web/terminal-manager.js

@@ -361,7 +361,7 @@ class TerminalManagerV1 {
             entry.outputFlushTimer.unref();
         }
     }
-    flushPendingOutput(entry, force) {
+    flushPendingOutput(entry, force, final = false) {
         let emitted = false;
         while (entry.pendingOutput.length > 0 &&
             (force || entry.pendingOutput.length >= MAX_OUTPUT_FRAME_CHARS)) {
@@ -372,14 +372,14 @@ class TerminalManagerV1 {
                 isLowSurrogate(entry.pendingOutput.charCodeAt(end))) {
                 end -= 1;
             }
-            if (!force &&
+            if (!final &&
                 end === entry.pendingOutput.length &&
                 isHighSurrogate(entry.pendingOutput.charCodeAt(end - 1))) {
                 break;
             }
             if (end <= 0)
                 break;
-            const value = entry.pendingOutput.slice(0, end);
+            const value = replaceUnpairedSurrogates(entry.pendingOutput.slice(0, end));
             entry.pendingOutput = entry.pendingOutput.slice(end);
             const frame = Object.freeze({
                 sequence: entry.nextSequence++,
@@ -405,7 +405,7 @@ class TerminalManagerV1 {
     handleExit(entry, event) {
         if (this.terminals.get(entry.id) !== entry)
             return;
-        this.flushPendingOutput(entry, true);
+        this.flushPendingOutput(entry, true, true);
         entry.state = 'exited';
         entry.exitCode = event.exitCode;
         entry.signal = event.signal;
@@ -610,6 +610,25 @@ function isHighSurrogate(value) {
 function isLowSurrogate(value) {
     return value >= 0xdc00 && value <= 0xdfff;
 }
+function replaceUnpairedSurrogates(value) {
+    let normalized = '';
+    for (let index = 0; index < value.length; index += 1) {
+        const current = value.charCodeAt(index);
+        if (isHighSurrogate(current)) {
+            const next = value.charCodeAt(index + 1);
+            if (isLowSurrogate(next)) {
+                normalized += value[index] + value[index + 1];
+                index += 1;
+            }
+            else {
+                normalized += '\ufffd';
+            }
+            continue;
+        }
+        normalized += isLowSurrogate(current) ? '\ufffd' : value[index];
+    }
+    return normalized;
+}
 function terminateProcessTree(entry) {
     signalProcessTree(entry, 'SIGTERM');
 }

package/dist/web/terminal-server.js

@@ -67,6 +67,8 @@ function ownTerminalSocket(webSocket, terminalId, manager) {
     let connection;
     let backpressurePaused = false;
     let replayPaused = false;
+    const replayTail = [];
+    let replayExit;
     let drainTimer;
     let replayTimer;
     const timer = setTimeout(() => webSocket.close(4401, 'Authentication timeout'), AUTH_TIMEOUT_MS);
@@ -134,12 +136,33 @@ function ownTerminalSocket(webSocket, terminalId, manager) {
         checkBackpressure();
         return true;
     };
+    const sendExit = (event) => {
+        if (!send(event, () => webSocket.close(1000, 'Terminal exited'))) {
+            webSocket.close(1000, 'Terminal exited');
+        }
+    };
+    const drainReplayTail = () => {
+        if (webSocket.readyState !== ws_1.WebSocket.OPEN)
+            return;
+        const next = replayTail.shift();
+        if (next !== undefined) {
+            send(next, drainReplayTail);
+            return;
+        }
+        if (replayExit !== undefined) {
+            const exit = replayExit;
+            replayExit = undefined;
+            sendExit(exit);
+            return;
+        }
+        replayPaused = false;
+        applyFlowControl();
+    };
     const sendReplay = (values, index = 0) => {
         if (webSocket.readyState !== ws_1.WebSocket.OPEN)
             return;
         if (index >= values.length) {
-            replayPaused = false;
-            applyFlowControl();
+            drainReplayTail();
             return;
         }
         if (webSocket.bufferedAmount >= PAUSE_WS_BUFFERED_BYTES) {
@@ -183,11 +206,17 @@ function ownTerminalSocket(webSocket, terminalId, manager) {
                     terminalId,
                     ticket: auth.ticket,
                     afterSequence: auth.afterSequence,
-                    onFrame: frame => send(frame),
+                    onFrame: frame => {
+                        if (replayPaused)
+                            replayTail.push(frame);
+                        else
+                            send(frame);
+                    },
                     onExit: event => {
-                        if (!send(event, () => webSocket.close(1000, 'Terminal exited'))) {
-                            webSocket.close(1000, 'Terminal exited');
-                        }
+                        if (replayPaused)
+                            replayExit = event;
+                        else
+                            sendExit(event);
                     },
                     onReplaced: () => webSocket.close(4409, 'Terminal connection replaced'),
                 });

package/dist/web/workbench-controller.d.ts

@@ -5,28 +5,36 @@ import { WebEventHub } from './event-hub';
 import { FileReadServiceV1 } from './file-read-service';
 import { GitReadModelServiceV1 } from './git-read-model-service';
 import { type WebComposerActionResultV1, type WebComposerActionV1, type WebComposerControlStateV1, type WebBootstrapV1, type WebCommandResultV1, type WebContextActivateRequestV1, type WebContextGuardV1, type WebMcpServerSummaryV1, type WebPageV1, type WebSessionSnapshotV1, type WebSessionSummaryV1, type WebSettingsMutationResultV1, type WebSettingsSnapshotV1, type WebSettingsUpdateRequestV1, type WebSkillSummaryV1, type WebToolDetailPageV1, type WebToolDetailSummaryV1, type WebWorkspaceSummaryV1, type WebWorkspaceProjectSummaryV1 } from './protocol';
+import { type WebSessionRuntimeSummaryV1 } from './session-runtime-registry';
 import { TerminalManagerV1 } from './terminal-manager';
 export { WebWorkbenchError } from './errors';
 export interface WebWorkbenchControllerOptions {
     readonly cwd: string;
     readonly eventHub?: WebEventHub;
     readonly createRuntime?: (cwd: string) => Promise<OrionCodeUiRuntime>;
+    readonly createSessionRuntime?: (cwd: string) => Promise<OrionCodeUiRuntime>;
     readonly workspaceRegistry?: WorkspaceRegistryV1;
 }
-/** Owns the sole runtime/controller pair exposed through the local Web host. */
+/** Owns the Workspace surface plus the bounded Web Session actor registry. */
 export declare class WebWorkbenchController {
     readonly eventHub: WebEventHub;
     private workspaceValue;
     private runtimeValue;
     private controllerValue;
     private activeOrionRuntime?;
+    private readonly activeOrionRuntimes;
     private readonly createRuntime;
+    private readonly createSessionRuntime;
+    private sessionRegistry;
     private readonly workspaceRegistry;
     readonly terminalManager: TerminalManagerV1;
     private readonly mutationResults;
     private readonly sessionViews;
     private sessionViewBytes;
     private readonly toolDetails;
+    private readonly workspaceMutations;
+    private readonly workspaceMutationOwners;
+    private readonly pendingWorkspaceMutationStates;
     private fileService;
     private gitService;
     private reviewService;
@@ -40,8 +48,10 @@ export declare class WebWorkbenchController {
     private suppressContextEdges;
     private latestStatus;
     private transition;
-    private sessionTransition;
+    private activeMutationCount;
+    private contextTransitionReserved;
     private closed;
+    private shutdownResult?;
     private workspaceWatchers;
     private resourceInvalidationTimer?;
     private constructor();
@@ -60,7 +70,9 @@ export declare class WebWorkbenchController {
     listSessions(context?: WebContextGuardV1): readonly WebSessionSummaryV1[];
     sessionSnapshot(sessionId: string, cursor?: string, pageSize?: number, tail?: boolean, context?: WebContextGuardV1): WebSessionSnapshotV1;
     composerState(sessionId: string, context?: WebContextGuardV1): WebComposerControlStateV1;
-    private projectComposerState;
+    sessionRuntimeSummary(sessionId: string): WebSessionRuntimeSummaryV1;
+    waitForSessionIdle(sessionId: string): Promise<void>;
+    private projectActorComposerState;
     private projectComposerStateValue;
     modelCatalog(sessionId: string, context?: WebContextGuardV1): import("../runtime/session-composer-control").SessionModelCatalogV1;
     applyComposerAction(input: WebComposerActionV1): Promise<WebComposerActionResultV1>;
@@ -89,6 +101,14 @@ export declare class WebWorkbenchController {
     executeMutation<T>(requestId: string, operation: string, payload: unknown, action: () => T | Promise<T>): Promise<T>;
     diagnostics(context?: WebContextGuardV1): Promise<Record<string, unknown>>;
     shutdown(): Promise<void>;
+    private shutdownOwnedResources;
+    private createSessionRegistry;
+    private createSessionActor;
+    private closeSessionActor;
+    private emitSessionActorRuntimeEvent;
+    private emitWorkspaceMutationState;
+    private scheduleActorComposerStateChanged;
+    private publishActorComposerState;
     private installRuntime;
     private emitState;
     private emitWorkspaceResourceInvalidation;
@@ -105,8 +125,12 @@ export declare class WebWorkbenchController {
     private rememberSessionView;
     private assertReadyForTransition;
     private assertMutationAdmission;
+    private reserveMutation;
+    private releaseMutation;
     private assertContextGuard;
     private assertCommandSession;
+    private assertSessionWorkspace;
+    private sessionActorKey;
     private assertSettingsAvailable;
     private initializeWorkspaceRegistry;
     private activeWorkspaceEntry;