@rynx-ai/server 0.1.11-beta.3 → 0.1.11-beta.31

package/dist/server.js

@@ -1,3 +1,4 @@
+import { basename, extname, isAbsolute } from "node:path";
 import { pathToFileURL } from "node:url";
 import Koa from "koa";
 import Router from "@koa/router";
@@ -10,10 +11,13 @@ import { attachBrowserSurfaceWs } from "./browser-surface-ws.js";
 import { attachEmulatorSurfaceWs } from "./emulator-surface-ws.js";
 import { attachDesktopBrowserHostServer, } from "./desktop-browser-host.js";
 import { resolveControlWebDist, sendSpaFile } from "./control-web-dist.js";
+import { startSessionPortal, } from "./session-portal.js";
+export { createSessionPortalApp, startSessionPortal } from "./session-portal.js";
 import { SessionRuntimeIndex } from "./session-runtime-index.js";
 import { createRunnerSessionTerminalHost, } from "./session-terminal-host.js";
 import { runtimeWebAccessPolicyForBindHost, } from "./runtime-web-auth.js";
 export { MachineSessionService, MachineSessionServiceFailure, MachineSessionServiceInputError, synthesizeSessionTitle, } from "./machine-session-service.js";
+export { SessionPendingInputIndex } from "./session-pending-inputs.js";
 export { SessionBrowserHostError, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceUnsupportedError, } from "./session-browser-service.js";
 export { SessionEmulatorBindingConflictError, SessionEmulatorService, SessionEmulatorServiceError, } from "./session-emulator-service.js";
 export { SessionBrowserSurfaceCoordinator } from "./session-browser-surface-coordinator.js";
@@ -64,19 +68,41 @@ export function createSessionRuntimeServices(input) {
     });
     const sessionBus = new InMemorySessionBus();
     const sessionRuntimeIndex = new SessionRuntimeIndex();
-    const sessionMirrorQueue = new SessionMirrorQueue((sessionId, event) => persistSessionEvent(sessionId, event, { sessionLog: input.sessionLog, sessionBus }));
+    const sessionMirrorQueue = new SessionMirrorQueue(async (sessionId, event) => {
+        const generatedImageFinalized = await finalizeGeneratedImageEvent(sessionId, event, input);
+        const pendingFinalized = resolvePendingInputEvent(sessionId, generatedImageFinalized, input.pendingInputs);
+        const finalized = pendingFinalized.event;
+        sessionRuntimeIndex.observe(sessionId, finalized);
+        await persistSessionEvent(sessionId, finalized, {
+            sessionLog: input.sessionLog,
+            sessionBus,
+            ...(input.onPendingInputPersisted
+                ? {
+                    onInputPersisted: async (persistedEvent) => {
+                        if (!persistedEvent.clearedPendingId || !pendingFinalized.clientMessageId)
+                            return;
+                        await input.onPendingInputPersisted({
+                            sessionId,
+                            pendingId: persistedEvent.clearedPendingId,
+                            clientMessageId: pendingFinalized.clientMessageId,
+                            responseId: persistedEvent.item.responseId,
+                            messageItemId: persistedEvent.item.id,
+                        });
+                    },
+                }
+                : {}),
+        });
+    });
     const mirrorSessionEvent = (sessionId, event) => {
-        sessionRuntimeIndex.observe(sessionId, event);
         return sessionMirrorQueue.enqueue(sessionId, event);
     };
     const conversationRuntime = new ConversationRuntime({
         config: input.config,
         executor: runnerManager,
         sessionBus,
-        sessionEventSink: mirrorSessionEvent,
     });
     runnerManager.onMirror((sessionId, event) => {
-        void mirrorSessionEvent(sessionId, event).catch((error) => {
+        return mirrorSessionEvent(sessionId, event).catch((error) => {
             input.onMirrorError?.(error, sessionId);
         });
     });
@@ -89,6 +115,113 @@ export function createSessionRuntimeServices(input) {
         publishSessionEvent: mirrorSessionEvent,
     };
 }
+/** Drain the oldest pending web input when the Provider transcript produces a
+ * real user record. The transcript is the only durable writer; the returned id
+ * lets clients replace the exact temporary bubble. */
+function resolvePendingInputEvent(sessionId, event, pendingInputs) {
+    if (event.type !== "session.input.consumed" ||
+        event.item.type !== "message" ||
+        event.item.data.role !== "user" ||
+        event.item.data.isMeta) {
+        return { event };
+    }
+    const pending = pendingInputs?.resolveOldest(sessionId);
+    if (!pending)
+        return { event };
+    const fileParts = pending.content.filter((part) => part.type === "input_image" || part.type === "input_file");
+    const alreadyHasFiles = event.item.data.content.some((part) => part.type === "input_image" || part.type === "input_file");
+    const containsInternalResourceMarker = event.item.data.content.some((part) => part.type === "input_text" &&
+        /\[\[RYNX_(?:IMAGE|FILE)_RESOURCE\s/.test(part.text));
+    const content = containsInternalResourceMarker
+        ? pending.content
+        : fileParts.length > 0 && !alreadyHasFiles
+            ? [...fileParts, ...event.item.data.content]
+            : event.item.data.content;
+    return {
+        clientMessageId: pending.clientMessageId,
+        event: {
+            ...event,
+            clearedPendingId: pending.pendingId,
+            ...(content !== event.item.data.content
+                ? {
+                    item: {
+                        ...event.item,
+                        data: {
+                            ...event.item.data,
+                            content,
+                        },
+                    },
+                }
+                : {}),
+        },
+    };
+}
+async function finalizeGeneratedImageEvent(sessionId, event, input) {
+    if (event.type !== "response.output_item.done" ||
+        event.item.type !== "function_call_output") {
+        return event;
+    }
+    const rawData = event.item.data;
+    const pending = rawData.__rynxGeneratedImage;
+    if (!pending)
+        return event;
+    const { __rynxGeneratedImage: _omitted, ...data } = rawData;
+    try {
+        const pathMediaType = pending.savedPath && isAbsolute(pending.savedPath)
+            ? imageMediaTypeFromPath(pending.savedPath)
+            : undefined;
+        const generatedImage = pathMediaType && pending.savedPath
+            ? {
+                path: pending.savedPath,
+                filename: basename(pending.savedPath),
+                mediaType: pathMediaType,
+            }
+            : pending.result && input.materializeGeneratedImage
+                ? await input.materializeGeneratedImage({
+                    sessionId,
+                    sourceId: event.item.id,
+                    result: pending.result,
+                })
+                : undefined;
+        return {
+            ...event,
+            item: {
+                ...event.item,
+                data: {
+                    ...data,
+                    ...(generatedImage ? { generatedImage } : {}),
+                    ...(!generatedImage && pending.savedPath && !isAbsolute(pending.savedPath)
+                        ? { output: `${data.output}\nImage path was not absolute; preview omitted.`.trim() }
+                        : {}),
+                },
+            },
+        };
+    }
+    catch (error) {
+        input.onMirrorError?.(error, sessionId);
+        return {
+            ...event,
+            item: {
+                ...event.item,
+                data: {
+                    ...data,
+                    output: `${data.output}\nImage preview unavailable.`.trim(),
+                },
+            },
+        };
+    }
+}
+function imageMediaTypeFromPath(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".png": return "image/png";
+        case ".jpg":
+        case ".jpeg": return "image/jpeg";
+        case ".webp": return "image/webp";
+        case ".gif": return "image/gif";
+        case ".svg": return "image/svg+xml";
+        default: return undefined;
+    }
+}
 /**
  * The HTTP surface is just a liveness probe for container orchestration — all
  * agent capabilities are forwarded through the mounted channel plugins (the
@@ -137,7 +270,7 @@ export function createApp({ config = loadConfig(), control } = {}) {
     }
     return app;
 }
-export async function startServer({ config = loadConfig(), control, sessionLog, sessionRegistry, pluginRuntime, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, localSessionResources, localMachineSessions, sessionEmulators, sessionRuntimeServices, sessionLifecycle, sessionTerminals, runtimeLocalBrowser, providerClis, desktopBrowserHost, } = {}) {
+export async function startServer({ config = loadConfig(), control, sessionLog, sessionRegistry, pluginRuntime, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, localSessionResources, localMachineSessions, sessionEmulators, sessionRuntimeServices, sessionLifecycle, sessionTerminals, runtimeLocalBrowser, providerClis, desktopBrowserHost, sessionPortalAuthorization, } = {}) {
     const runtimeWebAccess = runtimeWebAccessPolicyForBindHost(config.HOST);
     const desktopBrowserManagementToken = desktopBrowserHost
         ? requireDaemonManagementToken(daemonManagement)
@@ -160,14 +293,58 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                 return { cwd: session.workspace.cwd };
             },
         });
+    const controlShutdown = new AbortController();
+    const controlSurface = control
+        ? {
+            deps: control,
+            runtime: conversationRuntime,
+            sessionBus,
+            sessionLog,
+            runnerManager,
+            sessionStore,
+            pluginRuntimeStatus: pluginRuntime
+                ? () => pluginRuntime.statusSnapshot()
+                : undefined,
+            daemonManagement,
+            remoteRuntime,
+            remoteRuntimeAdmin,
+            runtimeTargetControl,
+            runtimeConnectionResolver,
+            localSessionResources,
+            localMachineSessions,
+            sessionEmulators,
+            shutdownSignal: controlShutdown.signal,
+            sessionRuntimeIndex,
+            sessionLifecycle,
+            runtimeLocalBrowser,
+            providerClis,
+        }
+        : undefined;
+    const sessionPortalConfig = config.RYNX_SESSION_PORTAL_PORT !== undefined
+        ? (() => {
+            if (runtimeWebAccess.mode !== "loopback") {
+                throw new Error("Session Portal requires the ordinary Control listener to bind loopback only");
+            }
+            const controlWebDist = resolveControlWebDist();
+            if (!sessionPortalAuthorization || !controlSurface || !controlWebDist) {
+                throw new Error("Session Portal requires authorization, Control services, and the native Control Web build");
+            }
+            return { authorization: sessionPortalAuthorization, controlWebDist };
+        })()
+        : undefined;
+    let sessionPortalServer;
     if (pluginRuntime) {
         if (!sessionRegistry)
             throw new Error("plugin runtime requires a machine session registry");
+        if (!localMachineSessions) {
+            throw new Error("plugin runtime requires the machine Session service");
+        }
         pluginRuntime.bindHostServices({
-            conversationRuntime,
             capabilities: runnerManager,
             sessionStore,
             sessionRegistry,
+            sessionRuns: localMachineSessions,
+            sessionFiles: localMachineSessions,
             agentCatalog: {
                 list: async () => (await listAgentSpecs()).map(toPluginAgentSummary),
                 get: async (id) => {
@@ -180,9 +357,57 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                     session: input.session,
                 }),
             },
+            sessionActivity: (sessionId) => {
+                const snapshot = sessionRuntimeIndex.snapshot(sessionId);
+                return {
+                    ...snapshot,
+                    status: snapshot.pendingInteractions.length > 0
+                        ? "waiting"
+                        : snapshot.status,
+                };
+            },
             interruptSession: (sessionId) => runnerManager.interruptLiveSession(sessionId),
             terminateSession: (sessionId) => runnerManager.terminateLiveSession(sessionId),
+            ...(sessionLog
+                ? {
+                    sessionTimeline: {
+                        hasItem: async (sessionId, itemId) => Boolean(await sessionLog.get(sessionId, itemId)),
+                        projectText: async ({ sessionId, responseId, itemId, text }) => {
+                            const event = {
+                                type: "response.output_item.done",
+                                responseId,
+                                item: {
+                                    id: itemId,
+                                    sessionId,
+                                    position: -1,
+                                    responseId,
+                                    status: "completed",
+                                    createdAt: Date.now(),
+                                    createdBy: "plugin_projection",
+                                    type: "message",
+                                    data: { role: "assistant", content: [{ type: "output_text", text }] },
+                                },
+                            };
+                            // Projection is an acknowledged durable operation, unlike the
+                            // provider mirror's deliberately best-effort live fan-out.
+                            // Append first and only then publish; a failed append leaves the
+                            // projection ledger pending so the Plugin can retry safely.
+                            await sessionLog.append(sessionId, [event.item]);
+                            sessionServices.sessionBus.publish(sessionId, event);
+                        },
+                    },
+                }
+                : {}),
             resolveSessionInteraction: (sessionId, interactionId, resolution) => runnerManager.resolveInteraction(sessionId, interactionId, resolution),
+            ...(sessionPortalConfig
+                ? {
+                    sessionPortal: {
+                        scheme: "http",
+                        bindHost: config.RYNX_SESSION_PORTAL_HOST,
+                        port: config.RYNX_SESSION_PORTAL_PORT,
+                    },
+                }
+                : {}),
         });
     }
     // Provider TUI `/clear`·`/fork` uses the same publication boundary as an
@@ -198,38 +423,37 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
             kind: r.kind,
         });
     });
-    const controlShutdown = new AbortController();
+    if (localMachineSessions) {
+        runnerManager.onCollaborationMode((sessionId, mode) => {
+            localMachineSessions.recordNativeCollaborationMode(sessionId, mode);
+        });
+    }
     const app = createApp({
         config,
-        control: control
-            ? {
-                deps: control,
-                runtime: conversationRuntime,
-                sessionBus,
-                sessionLog,
-                runnerManager,
-                sessionStore,
-                pluginRuntimeStatus: pluginRuntime
-                    ? () => pluginRuntime.statusSnapshot()
-                    : undefined,
-                daemonManagement,
-                remoteRuntime,
-                remoteRuntimeAdmin,
-                runtimeTargetControl,
-                runtimeConnectionResolver,
-                localSessionResources,
-                localMachineSessions,
-                sessionEmulators,
-                shutdownSignal: controlShutdown.signal,
-                sessionRuntimeIndex,
-                sessionLifecycle,
-                runtimeLocalBrowser,
-                providerClis,
-            }
-            : undefined,
+        control: controlSurface,
     });
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
+        let startupWebSocketServers = [];
+        const rejectBeforeListening = (error) => reject(error);
         const server = app.listen(config.PORT, config.HOST, () => {
+            server.off("error", rejectBeforeListening);
+            void finishStartup(server).catch(async (error) => {
+                controlShutdown.abort(asError(error));
+                sessionPortalServer?.stopAccepting();
+                server.closeAllConnections?.();
+                await Promise.allSettled([
+                    closeWebSocketServers(startupWebSocketServers),
+                    sessionPortalServer?.shutdown() ?? Promise.resolve(),
+                    new Promise((done) => server.close(() => done())),
+                    Promise.resolve(daemonManagement?.pluginManagement?.dispose?.()),
+                    Promise.resolve(pluginRuntime?.dispose()),
+                    runnerManager.stop(),
+                ]);
+                reject(error);
+            });
+        });
+        server.once("error", rejectBeforeListening);
+        const finishStartup = async (server) => {
             console.log(JSON.stringify({
                 level: config.LOG_LEVEL,
                 msg: "Harness agent server listening",
@@ -238,15 +462,6 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
                 runtime: config.DEFAULT_RUNTIME,
                 model: resolveRuntimeModel(config, config.DEFAULT_RUNTIME),
             }));
-            const startup = pluginRuntime?.startPluginRuntimes() ?? Promise.resolve();
-            void startup.catch((error) => {
-                console.error(JSON.stringify({
-                    level: "error",
-                    type: "plugin-runtime",
-                    event: "startup_failed",
-                    error: error instanceof Error ? error.message : String(error),
-                }));
-            });
             const webSocketServers = [
                 attachTerminalWs(server, {
                     runtimeConnectionResolver,
@@ -265,19 +480,48 @@ export async function startServer({ config = loadConfig(), control, sessionLog,
             if (control?.emulator) {
                 webSocketServers.push(attachEmulatorTouchWs(server, { emulator: control.emulator }));
             }
+            startupWebSocketServers = webSocketServers;
+            // Plugin recovery fences and revokes any product-owned Portal authority.
+            // Do not expose the listener until every enabled Plugin got its serialized
+            // startup attempt; startPluginRuntimes absorbs individual failures.
+            await (pluginRuntime?.startPluginRuntimes() ?? Promise.resolve());
+            if (sessionPortalConfig) {
+                sessionPortalServer = await startSessionPortal({
+                    host: config.RYNX_SESSION_PORTAL_HOST,
+                    port: config.RYNX_SESSION_PORTAL_PORT,
+                    scheme: "http",
+                    authorization: sessionPortalConfig.authorization,
+                    controlOrigin: listeningHttpOrigin(server),
+                    controlWebDist: sessionPortalConfig.controlWebDist,
+                    shutdownSignal: controlShutdown.signal,
+                });
+            }
             resolve(bindServerLifecycle(server, {
-                fence: () => controlShutdown.abort(new Error("Rynx server is shutting down")),
-                closeUpgrades: () => closeWebSocketServers(webSocketServers),
+                fence: () => {
+                    controlShutdown.abort(new Error("Rynx server is shutting down"));
+                    sessionPortalServer?.stopAccepting();
+                },
+                closeUpgrades: () => Promise.all([
+                    closeWebSocketServers(webSocketServers),
+                    sessionPortalServer?.shutdown() ?? Promise.resolve(),
+                ]).then(() => undefined),
                 cleanup: async () => runCleanupSteps([
-                    () => startup.catch(() => undefined),
                     () => Promise.resolve(daemonManagement?.pluginManagement?.dispose?.()),
                     () => pluginRuntime?.dispose() ?? Promise.resolve(),
                     () => runnerManager.stop(),
                 ]),
             }));
-        });
+        };
     });
 }
+function listeningHttpOrigin(server) {
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        throw new Error("Control listener did not expose an HTTP address");
+    }
+    const host = address.address.includes(":") ? `[${address.address}]` : address.address;
+    return `http://${host}:${address.port}`;
+}
 function requireDaemonManagementToken(host) {
     const token = host?.managementToken;
     const bytes = typeof token === "string" ? Buffer.byteLength(token, "utf8") : 0;

package/dist/session-browser-service.d.ts

@@ -1,10 +1,14 @@
 import type { AdmissionReservation } from "@rynx-ai/core";
-import { type RuntimeBrowserCloseParams, type RuntimeBrowserCloseResult, type RuntimeBrowserExecutionBackend, type RuntimeBrowserOpenParams, type RuntimeBrowserPageCreateParams, type RuntimeBrowserPageMutationParams, type RuntimeBrowserPageNavigateParams, type RuntimeBrowserState, type RuntimeBrowserStateGetParams } from "@rynx-ai/protocol/runtime-browser";
+import { type RuntimeBrowserCloseParams, type RuntimeBrowserCloseResult, type RuntimeBrowserExecutionBackend, type RuntimeBrowserOpenParams, type RuntimeBrowserPageCreateParams, type RuntimeBrowserPageMutationParams, type RuntimeBrowserPageNavigateParams, type RuntimeBrowserRequestHeadersConfig, type RuntimeBrowserRequestHeadersGetParams, type RuntimeBrowserRequestHeadersPolicy, type RuntimeBrowserRequestHeadersSetParams, type RuntimeBrowserState, type RuntimeBrowserStateGetParams } from "@rynx-ai/protocol/runtime-browser";
 import type { RuntimeBrowserSurfaceFormat, RuntimeBrowserSurfaceInputEvent } from "@rynx-ai/protocol/runtime-browser-surface";
 import { type RuntimeBrowserEndpointDescriptor } from "@rynx-ai/protocol/runtime-browser-bootstrap";
 export interface SessionBrowserHostCreateInput {
     sessionId: string;
     browserGeneration: number;
+    /** Required at this internal boundary so every Host installs the policy
+     * before it permits the first navigation. Wire-version compatibility stays
+     * inside the concrete Host adapter. */
+    requestHeaders: RuntimeBrowserRequestHeadersConfig;
     url?: string;
 }
 /** Generation-scoped physical page state. `hostPageId` never leaves the service. */
@@ -136,6 +140,8 @@ export interface SessionBrowserHostHandle {
     goBack(hostPageId: string): Promise<void>;
     goForward(hostPageId: string): Promise<void>;
     reload(hostPageId: string): Promise<void>;
+    /** Replaces the Session-wide desired request Header projection for this generation. */
+    setRequestHeaders(config: RuntimeBrowserRequestHeadersConfig): Promise<void>;
     close(): Promise<void>;
 }
 /** Physical Browser factory selected by the Runtime composition root. */
@@ -156,19 +162,26 @@ export interface SessionBrowserServiceOptions {
     pageIdFactory?: () => string;
     /** Injectable boot nonce; production randomization fences stale pre-restart mutations. */
     bootGenerationSeed?: number;
+    /** Injectable only for deterministic CAS tests; production uses 128 random bits. */
+    requestHeaderRevisionSeed?: string;
     /**
      * Synchronous daemon admission fence. A successful reservation is held until
      * Browser open has either failed or registered the physical Host handle.
      */
     admissionReserve?: () => AdmissionReservation | undefined;
 }
-export type SessionBrowserHostErrorCode = "unavailable" | "page_not_found" | "capacity" | "outcome_unknown";
+export type SessionBrowserHostErrorCode = "unavailable" | "unsupported" | "page_not_found" | "capacity" | "outcome_unknown";
 /** Expected failure reported by a Browser Host implementation. */
 export declare class SessionBrowserHostError extends Error {
     readonly code: SessionBrowserHostErrorCode;
     constructor(code: SessionBrowserHostErrorCode, message: string, options?: ErrorOptions);
 }
-export type SessionBrowserServiceErrorCode = "invalid_request" | "not_found" | "generation_mismatch" | "unavailable" | "capacity" | "host_failure" | "outcome_unknown" | "shutting_down";
+/** Narrow Session-owned policy port used by transports and Plugin hosting. */
+export interface SessionBrowserRequestHeadersPort {
+    getRequestHeaders(input: RuntimeBrowserRequestHeadersGetParams): Promise<RuntimeBrowserRequestHeadersPolicy>;
+    setRequestHeaders(input: RuntimeBrowserRequestHeadersSetParams): Promise<RuntimeBrowserRequestHeadersPolicy>;
+}
+export type SessionBrowserServiceErrorCode = "invalid_request" | "not_found" | "generation_mismatch" | "revision_mismatch" | "unsupported" | "unavailable" | "capacity" | "host_failure" | "outcome_unknown" | "shutting_down";
 /** Stable application error; transports map the code without exposing Host diagnostics. */
 export declare class SessionBrowserServiceError extends Error {
     readonly code: SessionBrowserServiceErrorCode;
@@ -178,15 +191,18 @@ export declare class SessionBrowserServiceError extends Error {
  * Transport-neutral owner of the Runtime -> Session -> Browser -> Page model.
  * Every operation for one Session shares one queue; different Sessions remain independent.
  */
-export declare class SessionBrowserService {
+export declare class SessionBrowserService implements SessionBrowserRequestHeadersPort {
     private readonly ports;
     private readonly records;
     private readonly generations;
+    private readonly requestHeaderPolicies;
     private readonly queues;
     private readonly deletingSessions;
     private readonly observers;
     private readonly pageIdFactory;
     private readonly bootGenerationSeed;
+    private readonly requestHeaderRevisionSeed;
+    private requestHeaderRevision;
     private readonly admissionReserve?;
     private shuttingDown;
     private closeAllPromise?;
@@ -205,6 +221,8 @@ export declare class SessionBrowserService {
      */
     getInspectionPageEndpoint(input: RuntimeBrowserPageMutationParams): Promise<SessionBrowserInspectionEndpoint>;
     getState(input: RuntimeBrowserStateGetParams): Promise<RuntimeBrowserState | null>;
+    getRequestHeaders(input: RuntimeBrowserRequestHeadersGetParams): Promise<RuntimeBrowserRequestHeadersPolicy>;
+    setRequestHeaders(input: RuntimeBrowserRequestHeadersSetParams): Promise<RuntimeBrowserRequestHeadersPolicy>;
     /**
      * Runtime-local automation handoff. This method is deliberately absent from
      * RemoteRuntimeBrowserHost and Direct RPC so a CDP endpoint cannot cross a
@@ -233,6 +251,8 @@ export declare class SessionBrowserService {
     private closeEveryRecord;
     private createBrowser;
     private reserveOpenAdmission;
+    private currentRequestHeaders;
+    private nextRequestHeadersRevision;
     private closeUnavailableForRecreate;
     private pageMutation;
     private pageMutationParsed;