@openclaw/codex 2026.7.1-beta.6 → 2026.7.2-beta.1

package/dist/{session-binding-C1ZXdP-x.js → session-binding-BMfX1OX-.js}

@@ -1,18 +1,20 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { l as normalizeCodexServiceTier, t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-CYEDnLJ2.js";
+import { n as CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME, t as CODEX_PLUGINS_MARKETPLACE_NAME, u as normalizeCodexServiceTier } from "./config-c48K5HP9.js";
 import { n as CODEX_APP_SERVER_BINDING_NAMESPACE, t as CODEX_APP_SERVER_BINDING_MAX_ENTRIES } from "./session-binding-meta-B7aEMU7g.js";
 import { createHash, randomUUID } from "node:crypto";
 import { ensureAuthProfileStore, resolveDefaultAgentDir, resolveProviderIdForAuth, resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
 import { z } from "zod";
 import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { loadSessionStore, resolveSessionStoreEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { getSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/codex/src/app-server/session-binding.ts
 /** SQLite-backed Codex app-server thread bindings. */
 var session_binding_exports = /* @__PURE__ */ __exportAll({
 	CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS: () => CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS,
 	CODEX_APP_SERVER_BINDING_MAX_ENTRIES: () => CODEX_APP_SERVER_BINDING_MAX_ENTRIES,
 	CODEX_APP_SERVER_BINDING_NAMESPACE: () => CODEX_APP_SERVER_BINDING_NAMESPACE,
+	CodexSupervisionBindingReplacementError: () => CodexSupervisionBindingReplacementError,
+	assertCodexBindingMayBeReplaced: () => assertCodexBindingMayBeReplaced,
 	bindingStoreKey: () => bindingStoreKey,
 	createCodexAppServerBindingStore: () => createCodexAppServerBindingStore,
 	createStoredCodexAppServerBinding: () => createStoredCodexAppServerBinding,
@@ -50,6 +52,22 @@ const optionalStringSchema = z.string().optional().catch(void 0);
 const optionalBooleanSchema = z.boolean().optional().catch(void 0);
 const optionalNonBlankStringSchema = z.string().refine((value) => Boolean(value.trim())).optional().catch(void 0);
 const optionalTimestampSchema = z.string().refine((value) => Number.isFinite(Date.parse(value))).optional().catch(void 0);
+const pendingSupervisionBranchSchema = z.object({
+	sourceThreadId: z.string().trim().min(1),
+	connectionFingerprint: z.string().trim().min(1).optional(),
+	lastTurnId: z.string().trim().min(1).optional(),
+	cleanupThreadIds: z.array(z.string().trim().min(1)).max(2).optional()
+}).strict().superRefine((pending, context) => {
+	const cleanupThreadIds = pending.cleanupThreadIds ?? [];
+	if (new Set(cleanupThreadIds).size !== cleanupThreadIds.length) context.addIssue({
+		code: "custom",
+		message: "pending supervision cleanup thread ids must be unique"
+	});
+	if (cleanupThreadIds.includes(pending.sourceThreadId)) context.addIssue({
+		code: "custom",
+		message: "pending supervision cleanup cannot target its source"
+	});
+});
 const contextEngineProjectionSchema = z.object({
 	schemaVersion: z.literal(1),
 	mode: z.literal("thread_bootstrap"),
@@ -78,7 +96,7 @@ const accountAppPolicyEntrySchema = z.object({
 const pluginAppPolicyEntrySchema = z.object({
 	source: z.literal("plugin").optional(),
 	configKey: z.string(),
-	marketplaceName: z.literal(CODEX_PLUGINS_MARKETPLACE_NAME),
+	marketplaceName: z.enum([CODEX_PLUGINS_MARKETPLACE_NAME, CODEX_PLUGINS_WORKSPACE_MARKETPLACE_NAME]),
 	pluginName: z.string(),
 	allowDestructiveActions: z.boolean(),
 	destructiveApprovalMode: destructiveApprovalModeSchema,
@@ -91,9 +109,14 @@ const pluginAppPolicyContextSchema = z.object({
 }).strict();
 const threadBindingSchema = z.object({
 	threadId: z.string().refine((value) => Boolean(value.trim())),
+	clientId: optionalStringSchema,
 	cwd: z.string(),
+	connectionScope: z.literal("supervision").optional(),
+	supervisionSourceThreadId: z.string().trim().min(1).optional(),
 	authProfileId: optionalStringSchema,
 	model: optionalStringSchema,
+	preserveNativeModel: z.literal(true).optional().catch(void 0),
+	pendingSupervisionBranch: pendingSupervisionBranchSchema.optional(),
 	modelProvider: z.string().transform((value) => value.trim()).pipe(z.string().min(1)).optional().catch(void 0),
 	approvalPolicy: z.preprocess((value) => value === "on-failure" ? "on-request" : value, z.enum([
 		"never",
@@ -113,6 +136,8 @@ const threadBindingSchema = z.object({
 	webSearchThreadConfigFingerprint: optionalStringSchema,
 	userMcpServersFingerprint: optionalStringSchema,
 	mcpServersFingerprint: optionalStringSchema,
+	ringZeroConfigFingerprint: optionalStringSchema,
+	ringZeroClientInstanceId: optionalStringSchema,
 	nativeHookRelayGeneration: optionalNonBlankStringSchema,
 	appServerRuntimeFingerprint: optionalStringSchema,
 	pluginAppsFingerprint: optionalStringSchema,
@@ -123,7 +148,56 @@ const threadBindingSchema = z.object({
 	conversationStartId: optionalStringSchema,
 	conversationSourceTransferComplete: z.literal(true).optional().catch(void 0),
 	historyCoveredThrough: optionalTimestampSchema
+}).superRefine((binding, context) => {
+	if (binding.connectionScope === "supervision") {
+		if (!binding.supervisionSourceThreadId) context.addIssue({
+			code: "custom",
+			message: "supervision connection ownership requires its native source thread id"
+		});
+		if (binding.preserveNativeModel !== true) context.addIssue({
+			code: "custom",
+			message: "supervision connection ownership requires native model ownership"
+		});
+		if (binding.conversationSourceTransferComplete !== true) context.addIssue({
+			code: "custom",
+			message: "supervision connection ownership requires a completed source transfer"
+		});
+		if (!binding.pendingSupervisionBranch && (!binding.model?.trim() || !binding.modelProvider)) context.addIssue({
+			code: "custom",
+			message: "materialized supervision bindings require a native model and provider"
+		});
+	}
+	if (binding.supervisionSourceThreadId && binding.connectionScope !== "supervision") context.addIssue({
+		code: "custom",
+		message: "a supervision source thread id requires supervision connection ownership"
+	});
+	if (!binding.pendingSupervisionBranch) return;
+	if (binding.threadId !== binding.pendingSupervisionBranch.sourceThreadId) context.addIssue({
+		code: "custom",
+		message: "pending supervision source must match the provisional thread binding"
+	});
+	if (binding.supervisionSourceThreadId !== binding.pendingSupervisionBranch.sourceThreadId) context.addIssue({
+		code: "custom",
+		message: "pending supervision source must match its durable source identity"
+	});
+	if (binding.preserveNativeModel !== true) context.addIssue({
+		code: "custom",
+		message: "pending supervision bindings must defer model selection to Codex App Server"
+	});
+	if (binding.connectionScope !== "supervision") context.addIssue({
+		code: "custom",
+		message: "pending supervision bindings require supervision connection ownership"
+	});
 });
+var CodexSupervisionBindingReplacementError = class extends Error {
+	constructor(threadId, operation) {
+		super(`Refusing to replace supervised Codex thread ${threadId} while ${operation}; its native user-home connection and model ownership must be preserved`);
+		this.name = "CodexSupervisionBindingReplacementError";
+	}
+};
+function assertCodexBindingMayBeReplaced(binding, operation) {
+	if (binding?.connectionScope === "supervision") throw new CodexSupervisionBindingReplacementError(binding.threadId, operation);
+}
 const bindingLeaseSchema = z.object({
 	token: z.string().refine((value) => Boolean(value.trim())),
 	expiresAt: z.number().finite()
@@ -205,13 +279,14 @@ async function reclaimCurrentCodexSessionGeneration(params) {
 	const plan = await params.bindingStore.prepareSessionGenerationReclaim(params.identity);
 	if (plan.kind === "resolved") return plan.result;
 	try {
-		if (resolveSessionStoreEntry({
-			store: loadSessionStore(resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId }), {
-				skipCache: true,
-				hydrateSkillPromptRefs: false
-			}),
-			sessionKey
-		}).existing?.sessionId !== params.identity.sessionId) return false;
+		const storePath = resolveStorePath(params.config?.session?.store, { agentId: params.identity.agentId });
+		if (getSessionEntry({
+			agentId: params.identity.agentId,
+			hydrateSkillPromptRefs: false,
+			readConsistency: "latest",
+			sessionKey,
+			storePath
+		})?.sessionId !== params.identity.sessionId) return false;
 	} catch {
 		return false;
 	}
@@ -225,6 +300,32 @@ function createCodexAppServerBindingStore(state) {
 	const update = state.update?.bind(state);
 	if (!update) throw new Error("Codex app-server bindings require atomic plugin-state updates");
 	const leaseContext = new AsyncLocalStorage();
+	const archiveContext = new AsyncLocalStorage();
+	let activeBindingMutations = 0;
+	let pendingArchives = 0;
+	let archiveTail = Promise.resolve();
+	let bindingMutationsDrained = [];
+	const waitForBindingMutations = async () => {
+		if (activeBindingMutations === 0) return;
+		await new Promise((resolve) => {
+			bindingMutationsDrained.push(resolve);
+		});
+	};
+	const runBindingMutation = async (run) => {
+		if (archiveContext.getStore() === true) return await run();
+		if (pendingArchives > 0) throw new Error("Codex binding mutation blocked while a native archive is in progress; retry");
+		activeBindingMutations += 1;
+		try {
+			return await run();
+		} finally {
+			activeBindingMutations -= 1;
+			if (activeBindingMutations === 0) {
+				const drained = bindingMutationsDrained;
+				bindingMutationsDrained = [];
+				for (const resolve of drained) resolve();
+			}
+		}
+	};
 	const renewLease = (key, owner) => {
 		if (owner.failure) return;
 		try {
@@ -293,6 +394,16 @@ function createCodexAppServerBindingStore(state) {
 			if (raw !== void 0 && !stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
 			return stored?.state === "active" && ownsStoredSessionGeneration(identity, stored) ? stored.binding : void 0;
 		},
+		async hasOtherThreadOwner(threadId, currentIdentity) {
+			const currentKey = currentIdentity ? bindingStoreKey(currentIdentity) : void 0;
+			return state.entries().some(({ key, value }) => {
+				const stored = readStoredCodexAppServerBinding(value);
+				if (!stored) throw new Error(`Invalid Codex app-server binding row: ${key}`);
+				const isCurrentOwner = currentIdentity !== void 0 && key === currentKey && (currentIdentity.kind === "conversation" || stored.sessionId === currentIdentity.sessionId.trim());
+				if (stored.state !== "active" || stored.binding.threadId !== threadId || isCurrentOwner) return false;
+				return true;
+			});
+		},
 		async prepareSessionGenerationReclaim(identity) {
 			const key = bindingStoreKey(identity);
 			const raw = state.lookup(key);
@@ -313,94 +424,126 @@ function createCodexAppServerBindingStore(state) {
 			};
 		},
 		async mutate(identity, mutation) {
-			const key = bindingStoreKey(identity);
-			const retainLegacyClear = mutation.kind === "clear" && key.startsWith("conversation:legacy-");
-			return await transactKey(key, (current, leaseToken) => {
-				const ownsGeneration = ownsStoredSessionGeneration(identity, current);
-				const ownedLease = current?.lease && current.lease.token === leaseToken ? { lease: current.lease } : {};
-				if (mutation.kind === "reclaim-generation") {
-					if (identity.kind !== "session" || !identity.sessionKey?.trim()) return { result: false };
-					if (!current) return { result: true };
-					if (ownsGeneration) return { result: current.state !== "cleared" || current.retired !== true };
-					if (current.sessionId !== mutation.expectedPreviousSessionId) return { result: false };
-					return {
+			return await runBindingMutation(async () => {
+				const key = bindingStoreKey(identity);
+				const retainLegacyClear = mutation.kind === "clear" && key.startsWith("conversation:legacy-");
+				return await transactKey(key, (current, leaseToken) => {
+					const ownsGeneration = ownsStoredSessionGeneration(identity, current);
+					const ownedLease = current?.lease && current.lease.token === leaseToken ? { lease: current.lease } : {};
+					if (mutation.kind === "reclaim-generation") {
+						if (identity.kind !== "session" || !identity.sessionKey?.trim()) return { result: false };
+						if (!current) return { result: true };
+						if (ownsGeneration) return { result: current.state !== "cleared" || current.retired !== true };
+						if (current.sessionId !== mutation.expectedPreviousSessionId) return { result: false };
+						if (current.state === "active" && current.binding.connectionScope === "supervision") return { result: false };
+						return {
+							result: true,
+							next: {
+								version: 1,
+								state: "cleared",
+								sessionId: identity.sessionId,
+								...ownedLease
+							}
+						};
+					}
+					const storedActive = current?.state === "active" ? current : void 0;
+					const active = ownsGeneration ? storedActive : void 0;
+					const retiredGeneration = current?.state === "cleared" && current.retired === true && ownsGeneration;
+					const preservesSupervisionOwner = mutation.kind === "set" && active?.binding.connectionScope === "supervision" && isSameSupervisionOwner(active.binding, mutation.binding);
+					const clearsPendingSupervisionOwner = mutation.kind === "clear" && active?.binding.connectionScope === "supervision" && matchesPendingSupervisionClear(active.binding, mutation.threadId, mutation.expectedPendingSupervisionBranch);
+					if (mutation.kind === "set" && (mutation.if?.kind === "absent" && storedActive || current !== void 0 && !ownsGeneration || retiredGeneration || active?.binding.connectionScope === "supervision" && !preservesSupervisionOwner) || mutation.kind === "patch" && active?.binding.threadId !== mutation.threadId || (mutation.kind === "patch-pending-supervision-branch" || mutation.kind === "commit-pending-supervision-branch") && !matchesPendingSupervisionBranch(active?.binding, mutation.expected) || mutation.kind === "clear" && (mutation.threadId !== void 0 && active?.binding.threadId !== mutation.threadId || !ownsGeneration || active?.binding.connectionScope === "supervision" && !clearsPendingSupervisionOwner)) return { result: false };
+					if (mutation.kind === "clear" && retiredGeneration) return { result: true };
+					if (mutation.kind === "clear") return {
 						result: true,
 						next: {
 							version: 1,
 							state: "cleared",
-							sessionId: identity.sessionId,
+							...storedSessionGeneration(identity, current),
 							...ownedLease
 						}
 					};
-				}
-				const storedActive = current?.state === "active" ? current : void 0;
-				const active = ownsGeneration ? storedActive : void 0;
-				const retiredGeneration = current?.state === "cleared" && current.retired === true && ownsGeneration;
-				if (mutation.kind === "set" && (mutation.if?.kind === "absent" && storedActive || current !== void 0 && !ownsGeneration || retiredGeneration) || mutation.kind === "patch" && active?.binding.threadId !== mutation.threadId || mutation.kind === "clear" && (mutation.threadId !== void 0 && active?.binding.threadId !== mutation.threadId || !ownsGeneration)) return { result: false };
-				if (mutation.kind === "clear" && retiredGeneration) return { result: true };
-				if (mutation.kind === "clear") return {
-					result: true,
-					next: {
-						version: 1,
-						state: "cleared",
-						...storedSessionGeneration(identity, current),
-						...ownedLease
-					}
-				};
-				let binding;
-				if (mutation.kind === "set") binding = validateBindingForWrite(mutation.binding);
-				else binding = validateBindingForWrite({
-					...active.binding,
-					...mutation.patch,
-					threadId: mutation.threadId
-				});
-				return {
-					result: true,
-					next: {
-						version: 1,
-						state: "active",
-						binding,
-						...storedSessionGeneration(identity, current),
-						...ownedLease
-					}
-				};
-			}, mutation.kind === "clear" && !retainLegacyClear && !leaseContext.getStore()?.has(key) ? 1 : void 0);
+					let binding;
+					if (mutation.kind === "set") binding = validateBindingForWrite(mutation.binding);
+					else if (mutation.kind === "patch-pending-supervision-branch") binding = validateBindingForWrite({
+						...active.binding,
+						pendingSupervisionBranch: mutation.pending
+					});
+					else if (mutation.kind === "commit-pending-supervision-branch") binding = validateBindingForWrite({
+						...active.binding,
+						...mutation.patch,
+						threadId: mutation.threadId,
+						pendingSupervisionBranch: void 0
+					});
+					else binding = validateBindingForWrite({
+						...active.binding,
+						...mutation.patch,
+						threadId: mutation.threadId
+					});
+					return {
+						result: true,
+						next: {
+							version: 1,
+							state: "active",
+							binding,
+							...storedSessionGeneration(identity, current),
+							...ownedLease
+						}
+					};
+				}, mutation.kind === "clear" && !retainLegacyClear && !leaseContext.getStore()?.has(key) ? 1 : void 0);
+			});
 		},
 		async adoptSessionGeneration(identity, expectedPreviousSessionId) {
-			const key = bindingStoreKey(identity);
-			const expectedSessionId = expectedPreviousSessionId.trim();
-			const targetSessionId = identity.sessionId.trim();
-			if (!expectedSessionId) throw new Error("Codex session generation adoption requires the previous session id");
-			return await transactKey(key, (current) => {
-				if (current?.state !== "active") return { result: "absent" };
-				if (current.sessionId === targetSessionId) return { result: "current" };
-				if (current.sessionId !== expectedSessionId) return { result: "conflict" };
-				return {
-					result: "adopted",
-					next: {
-						...current,
-						sessionId: targetSessionId
-					}
-				};
+			return await runBindingMutation(async () => {
+				const key = bindingStoreKey(identity);
+				const expectedSessionId = expectedPreviousSessionId.trim();
+				const targetSessionId = identity.sessionId.trim();
+				if (!expectedSessionId) throw new Error("Codex session generation adoption requires the previous session id");
+				return await transactKey(key, (current) => {
+					if (current?.state !== "active") return { result: "absent" };
+					if (current.sessionId === targetSessionId) return { result: "current" };
+					if (current.sessionId !== expectedSessionId) return { result: "conflict" };
+					return {
+						result: "adopted",
+						next: {
+							...current,
+							sessionId: targetSessionId
+						}
+					};
+				});
 			});
 		},
 		async retireSessionGeneration(identity) {
-			const key = bindingStoreKey(identity);
-			return await transactKey(key, (current, leaseToken) => {
-				if (!current) return { result: "absent" };
-				if (!ownsStoredSessionGeneration(identity, current)) return { result: "conflict" };
-				if (current.state === "cleared" && current.retired === true) return { result: "applied" };
-				return {
-					result: "applied",
-					next: {
-						version: 1,
-						state: "cleared",
-						retired: true,
-						...storedSessionGeneration(identity, current),
-						...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
-					}
-				};
-			}, identity.sessionKey?.trim() ? void 0 : PHYSICAL_SESSION_RETIRE_TTL_MS);
+			return await runBindingMutation(async () => {
+				const key = bindingStoreKey(identity);
+				return await transactKey(key, (current, leaseToken) => {
+					if (!current) return { result: "absent" };
+					if (!ownsStoredSessionGeneration(identity, current)) return { result: "conflict" };
+					if (current.state === "cleared" && current.retired === true) return { result: "applied" };
+					return {
+						result: "applied",
+						next: {
+							version: 1,
+							state: "cleared",
+							retired: true,
+							...storedSessionGeneration(identity, current),
+							...current.lease && current.lease.token === leaseToken ? { lease: current.lease } : {}
+						}
+					};
+				}, identity.sessionKey?.trim() ? void 0 : PHYSICAL_SESSION_RETIRE_TTL_MS);
+			});
+		},
+		async withThreadArchiveFence(run) {
+			pendingArchives += 1;
+			const operation = archiveTail.then(async () => {
+				await waitForBindingMutations();
+				return await archiveContext.run(true, run);
+			});
+			archiveTail = operation.then(() => void 0, () => void 0);
+			try {
+				return await operation;
+			} finally {
+				pendingArchives -= 1;
+			}
 		},
 		async withLease(identity, run) {
 			const key = bindingStoreKey(identity);
@@ -477,6 +620,22 @@ function createCodexAppServerBindingStore(state) {
 		}
 	};
 }
+function matchesPendingSupervisionBranch(binding, expected) {
+	const pending = binding?.pendingSupervisionBranch;
+	if (!pending || binding?.threadId !== expected.sourceThreadId) return false;
+	if (pending.sourceThreadId !== expected.sourceThreadId || pending.connectionFingerprint !== expected.connectionFingerprint || pending.lastTurnId !== expected.lastTurnId) return false;
+	const currentCleanup = pending.cleanupThreadIds ?? [];
+	const expectedCleanup = expected.cleanupThreadIds ?? [];
+	return currentCleanup.length === expectedCleanup.length && currentCleanup.every((threadId, index) => threadId === expectedCleanup[index]);
+}
+function isSameSupervisionOwner(current, replacement) {
+	return replacement.connectionScope === "supervision" && replacement.threadId === current.threadId && replacement.supervisionSourceThreadId === current.supervisionSourceThreadId;
+}
+function matchesPendingSupervisionClear(binding, threadId, expected) {
+	if (!expected) return false;
+	const sourceThreadId = expected.sourceThreadId;
+	return threadId === sourceThreadId && binding.supervisionSourceThreadId === sourceThreadId && matchesPendingSupervisionBranch(binding, expected);
+}
 /** Stable plugin-state key for one current binding owner. */
 function bindingStoreKey(identity) {
 	if (identity.kind === "session") {
@@ -555,7 +714,7 @@ function readPluginAppPolicyContext(value, bindingSchemaVersion) {
 			};
 			continue;
 		}
-		if ("appId" in entry || entry.source !== void 0 && entry.source !== "plugin" || typeof entry.configKey !== "string" || entry.marketplaceName !== "openai-curated" || typeof entry.pluginName !== "string" || typeof entry.allowDestructiveActions !== "boolean" || destructiveApprovalMode === "invalid" || !mcpServerNamesValid) return;
+		if ("appId" in entry || entry.source !== void 0 && entry.source !== "plugin" || typeof entry.configKey !== "string" || entry.marketplaceName !== "openai-curated" && entry.marketplaceName !== "workspace-directory" || typeof entry.pluginName !== "string" || typeof entry.allowDestructiveActions !== "boolean" || destructiveApprovalMode === "invalid" || !mcpServerNamesValid) return;
 		parsedApps[appId] = {
 			configKey: entry.configKey,
 			marketplaceName: entry.marketplaceName,
@@ -624,4 +783,4 @@ function resolveCodexAppServerBindingModelProvider(params) {
 	return params.modelProvider?.trim() || (isCodexAppServerNativeAuthProfile(params) ? PUBLIC_OPENAI_MODEL_PROVIDER : void 0);
 }
 //#endregion
-export { normalizeCodexAppServerBindingModelProvider as a, session_binding_exports as c, isCodexAppServerNativeAuthProfile as i, bindingStoreKey as n, reclaimCurrentCodexSessionGeneration as o, hashCodexAppServerBindingFingerprint as r, sessionBindingIdentity as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t };
+export { isCodexAppServerNativeAuthProfile as a, sessionBindingIdentity as c, hashCodexAppServerBindingFingerprint as i, session_binding_exports as l, assertCodexBindingMayBeReplaced as n, normalizeCodexAppServerBindingModelProvider as o, bindingStoreKey as r, reclaimCurrentCodexSessionGeneration as s, CODEX_APP_SERVER_BINDING_GUARDED_REQUEST_TIMEOUT_MS as t };