@pixelzx/genesis 2026.5.10-6 → 2026.5.14

package/dist/control-auth-BO5NLVkM.js

@@ -0,0 +1,125 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { n as resolveGatewayAuth } from "./auth-resolve-f2JHwWZP.js";
+import { a as loadConfig, y as writeConfigFile } from "./io-DK8qz7fQ.js";
+import "./text-runtime-COlr0gTx.js";
+import "./browser-config-runtime-Dq_BJXGg.js";
+import { t as ensureGatewayStartupAuth } from "./startup-auth-CnF_heB4.js";
+import "./browser-node-runtime-Cnl0XBZe.js";
+import crypto from "node:crypto";
+//#region extensions/browser/src/browser/control-auth.ts
+function resolveBrowserControlAuth(cfg, env = process.env) {
+	const auth = resolveGatewayAuth({
+		authConfig: cfg?.gateway?.auth,
+		env,
+		tailscaleMode: cfg?.gateway?.tailscale?.mode
+	});
+	const token = normalizeOptionalString(auth.token) ?? "";
+	const password = normalizeOptionalString(auth.password) ?? "";
+	switch (auth.mode) {
+		case "password":
+		case "trusted-proxy": return { password: password || void 0 };
+		case "token":
+		case "none": return { token: token || void 0 };
+		default: return {};
+	}
+}
+function shouldAutoGenerateBrowserAuth(env) {
+	if (normalizeLowercaseStringOrEmpty(env.NODE_ENV) === "test") return false;
+	const vitest = normalizeLowercaseStringOrEmpty(env.VITEST);
+	if (vitest && vitest !== "0" && vitest !== "false" && vitest !== "off") return false;
+	return true;
+}
+function hasExplicitNonStringGatewayCredentialForMode(params) {
+	const { cfg, mode } = params;
+	const auth = cfg?.gateway?.auth;
+	if (!auth) return false;
+	if (mode === "none") return auth.token != null && typeof auth.token !== "string";
+	return auth.password != null && typeof auth.password !== "string";
+}
+function generateBrowserControlToken() {
+	return crypto.randomBytes(24).toString("hex");
+}
+async function generateAndPersistBrowserControlToken(params) {
+	const token = generateBrowserControlToken();
+	await writeConfigFile({
+		...params.cfg,
+		gateway: {
+			...params.cfg.gateway,
+			auth: {
+				...params.cfg.gateway?.auth,
+				token
+			}
+		}
+	});
+	const persistedAuth = resolveBrowserControlAuth(loadConfig(), params.env);
+	if (persistedAuth.token || persistedAuth.password) return {
+		auth: persistedAuth,
+		generatedToken: persistedAuth.token === token ? token : void 0
+	};
+	return {
+		auth: { token },
+		generatedToken: token
+	};
+}
+async function generateAndPersistBrowserControlPassword(params) {
+	const password = generateBrowserControlToken();
+	await writeConfigFile({
+		...params.cfg,
+		gateway: {
+			...params.cfg.gateway,
+			auth: {
+				...params.cfg.gateway?.auth,
+				password
+			}
+		}
+	});
+	const persistedAuth = resolveBrowserControlAuth(loadConfig(), params.env);
+	if (persistedAuth.token || persistedAuth.password) return {
+		auth: persistedAuth,
+		generatedToken: persistedAuth.password === password ? password : void 0
+	};
+	return {
+		auth: { password },
+		generatedToken: password
+	};
+}
+async function ensureBrowserControlAuth(params) {
+	const env = params.env ?? process.env;
+	const auth = resolveBrowserControlAuth(params.cfg, env);
+	if (auth.token || auth.password) return { auth };
+	if (!shouldAutoGenerateBrowserAuth(env)) return { auth };
+	if (params.cfg.gateway?.auth?.mode === "password") return { auth };
+	const latestCfg = loadConfig();
+	const latestAuth = resolveBrowserControlAuth(latestCfg, env);
+	if (latestAuth.token || latestAuth.password) return { auth: latestAuth };
+	if (latestCfg.gateway?.auth?.mode === "password") return { auth: latestAuth };
+	const latestMode = latestCfg.gateway?.auth?.mode;
+	if (latestMode === "none" || latestMode === "trusted-proxy") {
+		if (hasExplicitNonStringGatewayCredentialForMode({
+			cfg: latestCfg,
+			mode: latestMode
+		})) return { auth: latestAuth };
+		if (latestMode === "trusted-proxy") return await generateAndPersistBrowserControlPassword({
+			cfg: latestCfg,
+			env
+		});
+		return await generateAndPersistBrowserControlToken({
+			cfg: latestCfg,
+			env
+		});
+	}
+	const ensured = await ensureGatewayStartupAuth({
+		cfg: latestCfg,
+		env,
+		persist: true
+	});
+	return {
+		auth: {
+			token: ensured.auth.token,
+			password: ensured.auth.password
+		},
+		generatedToken: ensured.generatedToken
+	};
+}
+//#endregion
+export { resolveBrowserControlAuth as n, shouldAutoGenerateBrowserAuth as r, ensureBrowserControlAuth as t };

package/dist/control-service-Iw7H8uVc.js

@@ -0,0 +1,156 @@
+import { c as escapeRegExp } from "./utils-DaGfogP-.js";
+import { t as createSubsystemLogger } from "./subsystem-DTMy5YmO.js";
+import { a as loadConfig } from "./io-DK8qz7fQ.js";
+import { t as ensureBrowserControlAuth } from "./control-auth-BO5NLVkM.js";
+import "./paths-DggEdGB3.js";
+import { t as resolveBrowserConfig } from "./config-9L6gNFMn.js";
+import { t as registerBrowserRoutes } from "./routes-D5U1TqcB.js";
+import "./subsystem-B_uAMIaV.js";
+import { t as createBrowserRouteContext } from "./server-context-B6XEIceO.js";
+import { n as createBrowserRuntimeState, r as stopBrowserRuntime, t as isDefaultBrowserPluginEnabled } from "./plugin-enabled-C28BqYaN.js";
+//#region extensions/browser/src/browser/routes/dispatcher.ts
+function compileRoute(path) {
+	const paramNames = [];
+	const parts = path.split("/").map((part) => {
+		if (part.startsWith(":")) {
+			const name = part.slice(1);
+			paramNames.push(name);
+			return "([^/]+)";
+		}
+		return escapeRegExp(part);
+	});
+	return {
+		regex: new RegExp(`^${parts.join("/")}$`),
+		paramNames
+	};
+}
+function createRegistry() {
+	const routes = [];
+	const register = (method) => (path, handler) => {
+		const { regex, paramNames } = compileRoute(path);
+		routes.push({
+			method,
+			path,
+			regex,
+			paramNames,
+			handler
+		});
+	};
+	return {
+		routes,
+		router: {
+			get: register("GET"),
+			post: register("POST"),
+			delete: register("DELETE")
+		}
+	};
+}
+function normalizePath(path) {
+	if (!path) return "/";
+	return path.startsWith("/") ? path : `/${path}`;
+}
+function createBrowserRouteDispatcher(ctx) {
+	const registry = createRegistry();
+	registerBrowserRoutes(registry.router, ctx);
+	return { dispatch: async (req) => {
+		const method = req.method;
+		const path = normalizePath(req.path);
+		const query = req.query ?? {};
+		const body = req.body;
+		const signal = req.signal;
+		const match = registry.routes.find((route) => {
+			if (route.method !== method) return false;
+			return route.regex.test(path);
+		});
+		if (!match) return {
+			status: 404,
+			body: { error: "Not Found" }
+		};
+		const exec = match.regex.exec(path);
+		const params = {};
+		if (exec) for (const [idx, name] of match.paramNames.entries()) {
+			const value = exec[idx + 1];
+			if (typeof value === "string") try {
+				params[name] = decodeURIComponent(value);
+			} catch {
+				return {
+					status: 400,
+					body: { error: `invalid path parameter encoding: ${name}` }
+				};
+			}
+		}
+		let status = 200;
+		let payload = void 0;
+		const res = {
+			status(code) {
+				status = code;
+				return res;
+			},
+			json(bodyValue) {
+				payload = bodyValue;
+			}
+		};
+		try {
+			await match.handler({
+				params,
+				query,
+				body,
+				signal
+			}, res);
+		} catch (err) {
+			return {
+				status: 500,
+				body: { error: String(err) }
+			};
+		}
+		return {
+			status,
+			body: payload
+		};
+	} };
+}
+//#endregion
+//#region extensions/browser/src/control-service.ts
+let state = null;
+const logService = createSubsystemLogger("browser").child("service");
+function getBrowserControlState() {
+	return state;
+}
+function createBrowserControlContext() {
+	return createBrowserRouteContext({
+		getState: () => state,
+		refreshConfigFromDisk: true
+	});
+}
+async function startBrowserControlServiceFromConfig() {
+	if (state) return state;
+	const cfg = loadConfig();
+	if (!isDefaultBrowserPluginEnabled(cfg)) return null;
+	const resolved = resolveBrowserConfig(cfg.browser, cfg);
+	if (!resolved.enabled) return null;
+	try {
+		if ((await ensureBrowserControlAuth({ cfg })).generatedToken) logService.info("No browser auth configured; generated gateway.auth.token automatically.");
+	} catch (err) {
+		logService.warn(`failed to auto-configure browser auth: ${String(err)}`);
+	}
+	state = await createBrowserRuntimeState({
+		server: null,
+		port: resolved.controlPort,
+		resolved,
+		onWarn: (message) => logService.warn(message)
+	});
+	logService.info(`Browser control service ready (profiles=${Object.keys(resolved.profiles).length})`);
+	return state;
+}
+async function stopBrowserControlService() {
+	await stopBrowserRuntime({
+		current: state,
+		getState: () => state,
+		clearState: () => {
+			state = null;
+		},
+		onWarn: (message) => logService.warn(message)
+	});
+}
+//#endregion
+export { createBrowserRouteDispatcher as a, stopBrowserControlService as i, getBrowserControlState as n, startBrowserControlServiceFromConfig as r, createBrowserControlContext as t };

package/dist/conversation-id-Ch1pkxe7.js

@@ -0,0 +1,38 @@
+import { A as parseBlueBubblesTarget, D as normalizeBlueBubblesHandle, x as extractHandleFromChatGuid } from "./probe-DsUVRbVb.js";
+//#region extensions/bluebubbles/src/conversation-id.ts
+function normalizeBlueBubblesAcpConversationId(conversationId) {
+	const trimmed = conversationId.trim();
+	if (!trimmed) return null;
+	try {
+		const parsed = parseBlueBubblesTarget(trimmed);
+		if (parsed.kind === "handle") {
+			const handle = normalizeBlueBubblesHandle(parsed.to);
+			return handle ? { conversationId: handle } : null;
+		}
+		if (parsed.kind === "chat_id") return { conversationId: String(parsed.chatId) };
+		if (parsed.kind === "chat_guid") return { conversationId: extractHandleFromChatGuid(parsed.chatGuid) || parsed.chatGuid };
+		return { conversationId: parsed.chatIdentifier };
+	} catch {
+		const handle = normalizeBlueBubblesHandle(trimmed);
+		return handle ? { conversationId: handle } : null;
+	}
+}
+function matchBlueBubblesAcpConversation(params) {
+	const binding = normalizeBlueBubblesAcpConversationId(params.bindingConversationId);
+	const conversation = normalizeBlueBubblesAcpConversationId(params.conversationId);
+	if (!binding || !conversation) return null;
+	if (binding.conversationId !== conversation.conversationId) return null;
+	return {
+		conversationId: conversation.conversationId,
+		matchPriority: 2
+	};
+}
+function resolveBlueBubblesInboundConversationId(params) {
+	if (!params.isGroup) return normalizeBlueBubblesHandle(params.sender) || void 0;
+	return params.chatGuid && normalizeBlueBubblesAcpConversationId(params.chatGuid)?.conversationId || params.chatIdentifier && normalizeBlueBubblesAcpConversationId(params.chatIdentifier)?.conversationId || (params.chatId != null && Number.isFinite(params.chatId) ? String(params.chatId) : "") || void 0;
+}
+function resolveBlueBubblesConversationIdFromTarget(target) {
+	return normalizeBlueBubblesAcpConversationId(target)?.conversationId;
+}
+//#endregion
+export { resolveBlueBubblesInboundConversationId as i, normalizeBlueBubblesAcpConversationId as n, resolveBlueBubblesConversationIdFromTarget as r, matchBlueBubblesAcpConversation as t };

package/dist/conversation-id-DeXgCGeL.js

@@ -0,0 +1,235 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { u as normalizeE164 } from "./utils-DaGfogP-.js";
+import "./text-runtime-COlr0gTx.js";
+import "./core-Bg858J0J.js";
+import { i as parseChatTargetPrefixesOrThrow, o as resolveServicePrefixedChatTarget, s as resolveServicePrefixedOrChatAllowTarget, t as createAllowedChatSenderMatcher } from "./chat-target-prefixes-DpIhEQMm.js";
+import "./channel-targets-_AroIqqP.js";
+import "./status-helpers-s7kNnR0u.js";
+import "./media-runtime-DFk_-1jK.js";
+import "./account-resolution-Dv292vQL.js";
+import "./channel-status-BGa1Zh6l.js";
+import { s as resolveIMessageAccount } from "./media-contract-CDJ7_GLf.js";
+//#region extensions/imessage/src/config-accessors.ts
+function resolveIMessageConfigAllowFrom(params) {
+	return (resolveIMessageAccount(params).config.allowFrom ?? []).map((entry) => String(entry));
+}
+function resolveIMessageConfigDefaultTo(params) {
+	const defaultTo = resolveIMessageAccount(params).config.defaultTo;
+	if (defaultTo == null) return;
+	return defaultTo.trim() || void 0;
+}
+//#endregion
+//#region extensions/imessage/src/normalize.ts
+const SERVICE_PREFIXES$1 = [
+	"imessage:",
+	"sms:",
+	"auto:"
+];
+const CHAT_TARGET_PREFIX_RE = /^(chat_id:|chatid:|chat:|chat_guid:|chatguid:|guid:|chat_identifier:|chatidentifier:|chatident:)/i;
+function looksLikeHandleOrPhoneTarget(params) {
+	const trimmed = params.raw.trim();
+	if (!trimmed) return false;
+	if (params.prefixPattern.test(trimmed)) return true;
+	if (trimmed.includes("@")) return true;
+	return (params.phonePattern ?? /^\+?\d{3,}$/).test(trimmed);
+}
+function normalizeIMessageHandle$1(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("imessage:")) return normalizeIMessageHandle$1(trimmed.slice(9));
+	if (lowered.startsWith("sms:")) return normalizeIMessageHandle$1(trimmed.slice(4));
+	if (lowered.startsWith("auto:")) return normalizeIMessageHandle$1(trimmed.slice(5));
+	if (CHAT_TARGET_PREFIX_RE.test(trimmed)) {
+		const prefix = trimmed.match(CHAT_TARGET_PREFIX_RE)?.[0];
+		if (!prefix) return "";
+		const value = trimmed.slice(prefix.length).trim();
+		return `${normalizeLowercaseStringOrEmpty(prefix)}${value}`;
+	}
+	if (trimmed.includes("@")) return normalizeLowercaseStringOrEmpty(trimmed);
+	const normalized = normalizeE164(trimmed);
+	if (normalized) return normalized;
+	return trimmed.replace(/\s+/g, "");
+}
+function normalizeIMessageMessagingTarget(raw) {
+	const trimmed = normalizeOptionalString(raw);
+	if (!trimmed) return;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	for (const prefix of SERVICE_PREFIXES$1) if (lower.startsWith(prefix)) {
+		const normalizedHandle = normalizeIMessageHandle$1(trimmed.slice(prefix.length).trim());
+		if (!normalizedHandle) return;
+		if (CHAT_TARGET_PREFIX_RE.test(normalizedHandle)) return normalizedHandle;
+		return `${prefix}${normalizedHandle}`;
+	}
+	return normalizeIMessageHandle$1(trimmed) || void 0;
+}
+function looksLikeIMessageTargetId(raw) {
+	const trimmed = normalizeOptionalString(raw);
+	if (!trimmed) return false;
+	if (CHAT_TARGET_PREFIX_RE.test(trimmed)) return true;
+	return looksLikeHandleOrPhoneTarget({
+		raw: trimmed,
+		prefixPattern: /^(imessage:|sms:|auto:)/i
+	});
+}
+//#endregion
+//#region extensions/imessage/src/targets.ts
+const CHAT_ID_PREFIXES = [
+	"chat_id:",
+	"chatid:",
+	"chat:"
+];
+const CHAT_GUID_PREFIXES = [
+	"chat_guid:",
+	"chatguid:",
+	"guid:"
+];
+const CHAT_IDENTIFIER_PREFIXES = [
+	"chat_identifier:",
+	"chatidentifier:",
+	"chatident:"
+];
+const SERVICE_PREFIXES = [
+	{
+		prefix: "imessage:",
+		service: "imessage"
+	},
+	{
+		prefix: "sms:",
+		service: "sms"
+	},
+	{
+		prefix: "auto:",
+		service: "auto"
+	}
+];
+function normalizeIMessageHandle(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("imessage:")) return normalizeIMessageHandle(trimmed.slice(9));
+	if (lowered.startsWith("sms:")) return normalizeIMessageHandle(trimmed.slice(4));
+	if (lowered.startsWith("auto:")) return normalizeIMessageHandle(trimmed.slice(5));
+	for (const prefix of CHAT_ID_PREFIXES) if (lowered.startsWith(prefix)) return `chat_id:${trimmed.slice(prefix.length).trim()}`;
+	for (const prefix of CHAT_GUID_PREFIXES) if (lowered.startsWith(prefix)) return `chat_guid:${trimmed.slice(prefix.length).trim()}`;
+	for (const prefix of CHAT_IDENTIFIER_PREFIXES) if (lowered.startsWith(prefix)) return `chat_identifier:${trimmed.slice(prefix.length).trim()}`;
+	if (trimmed.includes("@")) return normalizeLowercaseStringOrEmpty(trimmed);
+	const normalized = normalizeE164(trimmed);
+	if (normalized) return normalized;
+	return trimmed.replace(/\s+/g, "");
+}
+function parseIMessageTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) throw new Error("iMessage target is required");
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	const servicePrefixed = resolveServicePrefixedChatTarget({
+		trimmed,
+		lower,
+		servicePrefixes: SERVICE_PREFIXES,
+		chatIdPrefixes: CHAT_ID_PREFIXES,
+		chatGuidPrefixes: CHAT_GUID_PREFIXES,
+		chatIdentifierPrefixes: CHAT_IDENTIFIER_PREFIXES,
+		parseTarget: parseIMessageTarget
+	});
+	if (servicePrefixed) return servicePrefixed;
+	const chatTarget = parseChatTargetPrefixesOrThrow({
+		trimmed,
+		lower,
+		chatIdPrefixes: CHAT_ID_PREFIXES,
+		chatGuidPrefixes: CHAT_GUID_PREFIXES,
+		chatIdentifierPrefixes: CHAT_IDENTIFIER_PREFIXES
+	});
+	if (chatTarget) return chatTarget;
+	return {
+		kind: "handle",
+		to: trimmed,
+		service: "auto"
+	};
+}
+function looksLikeIMessageExplicitTargetId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return false;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	if (/^(imessage:|sms:|auto:)/.test(lower)) return true;
+	return CHAT_ID_PREFIXES.some((prefix) => lower.startsWith(prefix)) || CHAT_GUID_PREFIXES.some((prefix) => lower.startsWith(prefix)) || CHAT_IDENTIFIER_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}
+function inferIMessageTargetChatType(raw) {
+	try {
+		if (parseIMessageTarget(raw).kind === "handle") return "direct";
+		return "group";
+	} catch {
+		return;
+	}
+}
+function parseIMessageAllowTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {
+		kind: "handle",
+		handle: ""
+	};
+	const servicePrefixed = resolveServicePrefixedOrChatAllowTarget({
+		trimmed,
+		lower: normalizeLowercaseStringOrEmpty(trimmed),
+		servicePrefixes: SERVICE_PREFIXES,
+		parseAllowTarget: parseIMessageAllowTarget,
+		chatIdPrefixes: CHAT_ID_PREFIXES,
+		chatGuidPrefixes: CHAT_GUID_PREFIXES,
+		chatIdentifierPrefixes: CHAT_IDENTIFIER_PREFIXES
+	});
+	if (servicePrefixed) return servicePrefixed;
+	return {
+		kind: "handle",
+		handle: normalizeIMessageHandle(trimmed)
+	};
+}
+const isAllowedIMessageSenderMatcher = createAllowedChatSenderMatcher({
+	normalizeSender: normalizeIMessageHandle,
+	parseAllowTarget: parseIMessageAllowTarget
+});
+function isAllowedIMessageSender(params) {
+	return isAllowedIMessageSenderMatcher(params);
+}
+function formatIMessageChatTarget(chatId) {
+	if (!chatId || !Number.isFinite(chatId)) return "";
+	return `chat_id:${chatId}`;
+}
+//#endregion
+//#region extensions/imessage/src/conversation-id-core.ts
+function normalizeIMessageAcpConversationId(conversationId) {
+	const trimmed = conversationId.trim();
+	if (!trimmed) return null;
+	try {
+		const parsed = parseIMessageTarget(trimmed);
+		if (parsed.kind === "handle") {
+			const handle = normalizeIMessageHandle(parsed.to);
+			return handle ? { conversationId: handle } : null;
+		}
+		if (parsed.kind === "chat_id") return { conversationId: String(parsed.chatId) };
+		if (parsed.kind === "chat_guid") return { conversationId: parsed.chatGuid };
+		return { conversationId: parsed.chatIdentifier };
+	} catch {
+		const handle = normalizeIMessageHandle(trimmed);
+		return handle ? { conversationId: handle } : null;
+	}
+}
+function matchIMessageAcpConversation(params) {
+	const binding = normalizeIMessageAcpConversationId(params.bindingConversationId);
+	const conversation = normalizeIMessageAcpConversationId(params.conversationId);
+	if (!binding || !conversation) return null;
+	if (binding.conversationId !== conversation.conversationId) return null;
+	return {
+		conversationId: conversation.conversationId,
+		matchPriority: 2
+	};
+}
+function resolveIMessageConversationIdFromTarget(target) {
+	return normalizeIMessageAcpConversationId(target)?.conversationId;
+}
+//#endregion
+//#region extensions/imessage/src/conversation-id.ts
+function resolveIMessageInboundConversationId(params) {
+	if (params.isGroup) return params.chatId != null && Number.isFinite(params.chatId) ? String(params.chatId) : void 0;
+	return normalizeIMessageHandle(params.sender) || void 0;
+}
+//#endregion
+export { formatIMessageChatTarget as a, looksLikeIMessageExplicitTargetId as c, parseIMessageTarget as d, looksLikeIMessageTargetId as f, resolveIMessageConfigDefaultTo as h, resolveIMessageConversationIdFromTarget as i, normalizeIMessageHandle as l, resolveIMessageConfigAllowFrom as m, matchIMessageAcpConversation as n, inferIMessageTargetChatType as o, normalizeIMessageMessagingTarget as p, normalizeIMessageAcpConversationId as r, isAllowedIMessageSender as s, resolveIMessageInboundConversationId as t, parseIMessageAllowTarget as u };

package/dist/conversation-runtime-d5Fy5tiD.js

@@ -0,0 +1,31 @@
+import "./session-binding-service-DzTd4LUl.js";
+import "./binding-registry-MjKme2uF.js";
+import "./conversation-binding-BgzB_fBO.js";
+import "./session-C6lVUcfi.js";
+import "./pairing-store-AKS6-Yc5.js";
+import "./dm-policy-shared-BwRPldF2.js";
+import "./binding-targets-D80eeoHa.js";
+import "./binding-routing-hI8tQvXL.js";
+import "./thread-bindings-policy-BgW0fXFT.js";
+import "./pairing-labels-GSRU4031.js";
+//#region src/channels/session-meta.ts
+let inboundSessionRuntimePromise = null;
+function loadInboundSessionRuntime() {
+	inboundSessionRuntimePromise ??= import("./inbound.runtime-DE2sJi9-.js");
+	return inboundSessionRuntimePromise;
+}
+async function recordInboundSessionMetaSafe(params) {
+	const runtime = await loadInboundSessionRuntime();
+	const storePath = runtime.resolveStorePath(params.cfg.session?.store, { agentId: params.agentId });
+	try {
+		await runtime.recordSessionMetaFromInbound({
+			storePath,
+			sessionKey: params.sessionKey,
+			ctx: params.ctx
+		});
+	} catch (err) {
+		params.onError?.(err);
+	}
+}
+//#endregion
+export { recordInboundSessionMetaSafe as t };