@neta-art/cohub 8.24.0 → 9.0.0

package/dist/chunks/transport.js

@@ -1,70 +1,20 @@
 import { o as resolveApiBaseUrl } from "./environment.js";
-//#region ../protocol/dist/realtime/types.js
-const WS_COMPACT_STREAM_CAPABILITY = "session.compact_stream.v1";
-const WS_ROOM_SUBSCRIPTION_CAPABILITY = "realtime.rooms.v1";
-const WS_BOARD_AWARENESS_CAPABILITY = "board.awareness.v1";
-const WS_REALTIME_ROOM_CAPABILITY = "realtime.room.v1";
-const REALTIME_DOMAINS = [
-	"system",
-	"session",
-	"space",
-	"label",
-	"room",
-	"ui",
-	"desktop"
-];
-const isRealtimeDomain = (value) => typeof value === "string" && REALTIME_DOMAINS.some((domain) => domain === value);
-/** Accepted room event names. Shared so a client can reject one before sending. */
-const REALTIME_ROOM_EVENT_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/;
-/** Maximum encoded size of a room event payload. */
-const REALTIME_ROOM_MAX_PAYLOAD_BYTES = 16384;
-const getRealtimeSpaceRoom = (spaceId) => `space:${spaceId}`;
-const getRealtimeBoardRoom = (boardId) => `board:${boardId}`;
-const parseRealtimeRoom = (room) => {
-	const trimmed = room.trim();
-	const separatorIndex = trimmed.indexOf(":");
-	if (separatorIndex <= 0) return null;
-	const kind = trimmed.slice(0, separatorIndex);
-	const id = trimmed.slice(separatorIndex + 1).trim();
-	if (!id) return null;
-	if (kind !== "space" && kind !== "user" && kind !== "board" && kind !== "room") return null;
-	return {
-		kind,
-		id
-	};
-};
-const normalizeRealtimeRooms = (rooms) => {
-	const normalized = /* @__PURE__ */ new Set();
-	for (const room of rooms) {
-		const parsed = typeof room === "string" ? parseRealtimeRoom(room) : null;
-		if (!parsed) continue;
-		normalized.add(`${parsed.kind}:${parsed.id}`);
-	}
-	return [...normalized];
-};
-const getNonEmptyString = (value) => typeof value === "string" && value.trim() ? value : null;
-const getSessionTurnPatchStreamKey = (input, options = {}) => {
-	const turnId = getNonEmptyString(input.turnId);
-	const messageKey = getNonEmptyString(input.messageId) ?? getNonEmptyString(input.sourceMessageId) ?? getNonEmptyString(input.anchorUserMessageId) ?? (typeof input.messageOrdinal === "number" && Number.isFinite(input.messageOrdinal) ? `ordinal:${input.messageOrdinal}` : null);
-	if (turnId && messageKey) return `${turnId}:${messageKey}`;
-	const streamKey = messageKey ?? turnId;
-	if (streamKey) return streamKey;
-	return options.includeSessionFallback ? getNonEmptyString(input.sessionId) : null;
-};
-//#endregion
 //#region ../protocol/dist/identifiers.js
 const UUID_SHAPE_PATTERN = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}";
 const UUID_PATTERN = "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}";
 const UUID_OR_SHORT_UUID_PATTERN = `^(?:${UUID_PATTERN}|[0-9a-fA-F]{32})$`;
 const UUID_SHAPE_REGEX = new RegExp(`^${UUID_SHAPE_PATTERN}$`);
 const UUID_REGEX = new RegExp(`^${UUID_PATTERN}$`);
-new RegExp(UUID_OR_SHORT_UUID_PATTERN);
+const UUID_OR_SHORT_UUID_REGEX = new RegExp(UUID_OR_SHORT_UUID_PATTERN);
 function isUuidLike(value) {
 	return typeof value === "string" && UUID_SHAPE_REGEX.test(value);
 }
 function isUuid(value) {
 	return typeof value === "string" && UUID_REGEX.test(value);
 }
+function isUuidOrShortUuid(value) {
+	return typeof value === "string" && UUID_OR_SHORT_UUID_REGEX.test(value);
+}
 //#endregion
 //#region ../protocol/dist/provenance.js
 /** Request provenance via X-Cohub-Source-* headers. Never used for authorization. */
@@ -125,7 +75,8 @@ const normalizeRequestSource = (input) => {
 	const spaceId = asUuid(record.spaceId);
 	const sessionId = asUuid(record.sessionId);
 	const turnId = asUuid(record.turnId);
-	const toolCallId = asUuid(record.toolCallId);
+	const toolCallId = asNonEmpty(record.toolCallId);
+	const validToolCallId = toolCallId && toolCallId.length <= 255 ? toolCallId : void 0;
 	const clientId = asClientId(record.clientId);
 	const sandboxVersion = asSandboxVersion(record.sandboxVersion);
 	const via = asVia(record.via);
@@ -133,7 +84,7 @@ const normalizeRequestSource = (input) => {
 		...spaceId ? { spaceId } : {},
 		...sessionId ? { sessionId } : {},
 		...turnId ? { turnId } : {},
-		...toolCallId ? { toolCallId } : {},
+		...validToolCallId ? { toolCallId: validToolCallId } : {},
 		...clientId ? { clientId } : {},
 		...sandboxVersion ? { sandboxVersion } : {},
 		...via ? { via } : {}
@@ -196,10 +147,98 @@ const mergeRequestSourceIntoMeta = (meta, headerSource) => {
 };
 const COHUB_SOURCE_HEADER_NAMES = Object.values(COHUB_SOURCE_HEADER);
 //#endregion
+//#region ../protocol/dist/realtime/types.js
+const WS_COMPACT_STREAM_CAPABILITY = "session.compact_stream.v1";
+const WS_ROOM_SUBSCRIPTION_CAPABILITY = "realtime.rooms.v1";
+const WS_BOARD_AWARENESS_CAPABILITY = "board.awareness.v1";
+const WS_REALTIME_ROOM_CAPABILITY = "realtime.room.v1";
+const REALTIME_DOMAINS = [
+	"system",
+	"session",
+	"space",
+	"label",
+	"room",
+	"ui",
+	"desktop"
+];
+const isRealtimeDomain = (value) => typeof value === "string" && REALTIME_DOMAINS.some((domain) => domain === value);
+/** Accepted room event names. Shared so a client can reject one before sending. */
+const REALTIME_ROOM_EVENT_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/;
+/** Maximum encoded size of a room event payload. */
+const REALTIME_ROOM_MAX_PAYLOAD_BYTES = 16384;
+const getRealtimeSpaceRoom = (spaceId) => `space:${spaceId}`;
+const getRealtimeBoardRoom = (boardId) => `board:${boardId}`;
+const parseRealtimeRoom = (room) => {
+	const trimmed = room.trim();
+	const separatorIndex = trimmed.indexOf(":");
+	if (separatorIndex <= 0) return null;
+	const kind = trimmed.slice(0, separatorIndex);
+	const id = trimmed.slice(separatorIndex + 1).trim();
+	if (!id) return null;
+	if (kind !== "space" && kind !== "user" && kind !== "board" && kind !== "room") return null;
+	return {
+		kind,
+		id
+	};
+};
+const normalizeRealtimeRooms = (rooms) => {
+	const normalized = /* @__PURE__ */ new Set();
+	for (const room of rooms) {
+		const parsed = typeof room === "string" ? parseRealtimeRoom(room) : null;
+		if (!parsed) continue;
+		normalized.add(`${parsed.kind}:${parsed.id}`);
+	}
+	return [...normalized];
+};
+const getNonEmptyString = (value) => typeof value === "string" && value.trim() ? value : null;
+const getSessionTurnPatchStreamKey = (input, options = {}) => {
+	const turnId = getNonEmptyString(input.turnId);
+	const messageKey = getNonEmptyString(input.messageId) ?? getNonEmptyString(input.sourceMessageId) ?? getNonEmptyString(input.anchorUserMessageId) ?? (typeof input.messageOrdinal === "number" && Number.isFinite(input.messageOrdinal) ? `ordinal:${input.messageOrdinal}` : null);
+	if (turnId && messageKey) return `${turnId}:${messageKey}`;
+	const streamKey = messageKey ?? turnId;
+	if (streamKey) return streamKey;
+	return options.includeSessionFallback ? getNonEmptyString(input.sessionId) : null;
+};
+//#endregion
+//#region src/revalidation-cache.ts
+const MAX_ENTRY_CHARS = 262144;
+const MAX_TOTAL_CHARS = 8388608;
+const entries = /* @__PURE__ */ new Map();
+let totalChars = 0;
+const runtime = globalThis;
+const revalidationEnabled = runtime.window === void 0 && Boolean(runtime.process?.versions?.node);
+function remove(key) {
+	const entry = entries.get(key);
+	if (!entry) return;
+	entries.delete(key);
+	totalChars -= entry.body.length;
+}
+function readRevalidationEntry(key) {
+	const entry = entries.get(key);
+	if (!entry) return void 0;
+	entries.delete(key);
+	entries.set(key, entry);
+	return entry;
+}
+function writeRevalidationEntry(key, etag, body) {
+	remove(key);
+	if (!etag || body.length > MAX_ENTRY_CHARS) return;
+	entries.set(key, {
+		etag,
+		body
+	});
+	totalChars += body.length;
+	for (const oldest of entries.keys()) {
+		if (totalChars <= MAX_TOTAL_CHARS) break;
+		remove(oldest);
+	}
+}
+//#endregion
 //#region src/transport.ts
 const responseBodyForError = async (response) => {
 	return (response.headers.get("content-type") ?? "").includes("application/json") ? await response.json().catch(() => null) : await response.text().catch(() => response.statusText);
 };
+const isFailure = (response) => !response.ok && response.status !== 304;
 const messageFromErrorBody = (body, fallback) => {
 	if (typeof body === "string") return body.trim() || fallback;
 	if (body && typeof body === "object") {
@@ -399,7 +438,7 @@ var HttpTransport = class {
 					throw error;
 				}
 				if (retryResponse.status !== 401) {
-					if (!retryResponse.ok) {
+					if (isFailure(retryResponse)) {
 						const body = await responseBodyForError(retryResponse);
 						throw new HttpError(messageFromErrorBody(body, retryResponse.statusText), retryResponse.status, body);
 					}
@@ -427,7 +466,7 @@ var HttpTransport = class {
 			rejectedTokenByError.set(error, rejectedToken);
 			throw error;
 		}
-		if (!response.ok) {
+		if (isFailure(response)) {
 			const body = await responseBodyForError(response);
 			throw new HttpError(messageFromErrorBody(body, response.statusText), response.status, body);
 		}
@@ -438,6 +477,21 @@ var HttpTransport = class {
 		if (response.status === 204) return null;
 		return response.json();
 	}
+	async requestRevalidated(path, init) {
+		if (!revalidationEnabled) return this.request(path, init);
+		const key = joinApiUrl(this.baseUrl, path);
+		const cached = readRevalidationEntry(key);
+		const headers = new Headers(init?.headers);
+		if (cached) headers.set("If-None-Match", cached.etag);
+		const response = await this.send(path, {
+			...init,
+			headers
+		});
+		if (response.status === 304 && cached) return JSON.parse(cached.body);
+		const body = await response.text();
+		writeRevalidationEntry(key, response.headers.get("etag"), body);
+		return JSON.parse(body);
+	}
 	async raw(path, init) {
 		const response = await this.send(path, init);
 		return {
@@ -453,4 +507,4 @@ var HttpTransport = class {
 	}
 };
 //#endregion
-export { normalizeRealtimeRooms as A, WS_COMPACT_STREAM_CAPABILITY as C, getRealtimeSpaceRoom as D, getRealtimeBoardRoom as E, getSessionTurnPatchStreamKey as O, WS_BOARD_AWARENESS_CAPABILITY as S, WS_ROOM_SUBSCRIPTION_CAPABILITY as T, requestSourceToHeaders as _, sanitizeAccessToken as a, REALTIME_ROOM_EVENT_NAME_PATTERN as b, REQUEST_SOURCE_VIA_MAX_LENGTH as c, isRequestSourceEmpty as d, isRequestSourceUuid as f, readRequestSourceFromEnv as g, parseRequestSourceFromHeaders as h, matchesUnauthorizedErrorToken as i, isRealtimeDomain as k, hasRequestSourceIdentity as l, normalizeRequestSource as m, HttpTransport as n, COHUB_SOURCE_HEADER as o, mergeRequestSourceIntoMeta as p, joinApiUrl as r, COHUB_SOURCE_HEADER_NAMES as s, HttpError as t, isRequestSourceClientId as u, resolveRequestSourceChannel as v, WS_REALTIME_ROOM_CAPABILITY as w, REALTIME_ROOM_MAX_PAYLOAD_BYTES as x, isUuid as y };
+export { isUuid as A, isRequestSourceUuid as C, readRequestSourceFromEnv as D, parseRequestSourceFromHeaders as E, isUuidOrShortUuid as M, requestSourceToHeaders as O, isRequestSourceEmpty as S, normalizeRequestSource as T, COHUB_SOURCE_HEADER as _, sanitizeAccessToken as a, hasRequestSourceIdentity as b, WS_BOARD_AWARENESS_CAPABILITY as c, WS_ROOM_SUBSCRIPTION_CAPABILITY as d, getRealtimeBoardRoom as f, normalizeRealtimeRooms as g, isRealtimeDomain as h, matchesUnauthorizedErrorToken as i, isUuidLike as j, resolveRequestSourceChannel as k, WS_COMPACT_STREAM_CAPABILITY as l, getSessionTurnPatchStreamKey as m, HttpTransport as n, REALTIME_ROOM_EVENT_NAME_PATTERN as o, getRealtimeSpaceRoom as p, joinApiUrl as r, REALTIME_ROOM_MAX_PAYLOAD_BYTES as s, HttpError as t, WS_REALTIME_ROOM_CAPABILITY as u, COHUB_SOURCE_HEADER_NAMES as v, mergeRequestSourceIntoMeta as w, isRequestSourceClientId as x, REQUEST_SOURCE_VIA_MAX_LENGTH as y };

package/dist/chunks/websocket.d.ts

@@ -1,4 +1,4 @@
-import { Bo as BoardAwarenessUpdate, J as BillingResponsePayload, Wa as ChannelEnvelope, Ya as RealtimeRoom, dc as ModelThinkingLevel, hc as ContentBlock, r as CohubEnvironment } from "./environment.js";
+import { Dc as ModelThinkingLevel, J as BillingResponsePayload, ao as RealtimeRoom, eo as ChannelEnvelope, is as BoardAwarenessUpdate, jc as ContentBlock, r as CohubEnvironment } from "./environment.js";
 import { z } from "zod";
 //#region src/websocket.d.ts
 type WebsocketEventPayload = ChannelEnvelope;

package/dist/chunks/websocket.js

@@ -1,4 +1,4 @@
-import { A as normalizeRealtimeRooms, C as WS_COMPACT_STREAM_CAPABILITY, D as getRealtimeSpaceRoom, O as getSessionTurnPatchStreamKey, S as WS_BOARD_AWARENESS_CAPABILITY, T as WS_ROOM_SUBSCRIPTION_CAPABILITY, k as isRealtimeDomain, t as HttpError, w as WS_REALTIME_ROOM_CAPABILITY } from "./transport.js";
+import { c as WS_BOARD_AWARENESS_CAPABILITY, d as WS_ROOM_SUBSCRIPTION_CAPABILITY, g as normalizeRealtimeRooms, h as isRealtimeDomain, l as WS_COMPACT_STREAM_CAPABILITY, m as getSessionTurnPatchStreamKey, p as getRealtimeSpaceRoom, t as HttpError, u as WS_REALTIME_ROOM_CAPABILITY } from "./transport.js";
 import { f as resolveWebsocketUrl } from "./environment.js";
 //#region src/http-error.ts
 /** Shared HTTP error code for every plan entitlement gate (402). */

package/dist/host-bridge.d.ts

@@ -0,0 +1,54 @@
+import { a as HostPlatform, i as HostBridgeMethod, n as HostBridgeCapability, r as HostBridgeEvent, t as HOST_BRIDGE_METHODS } from "./chunks/host-bridge.js";
+import { z } from "zod";
+//#region src/host-bridge.d.ts
+type HostBridgeError = HostBridgeErrorClass;
+type HostBridgeResult<M extends HostBridgeMethod> = z.infer<(typeof HOST_BRIDGE_METHODS)[M]["result"]>;
+type HostBridgeParams<M extends HostBridgeMethod> = z.infer<(typeof HOST_BRIDGE_METHODS)[M]["params"]>;
+declare class HostBridgeErrorClass extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+  get isCanceled(): boolean;
+  get isUnsupported(): boolean;
+}
+/** Minimal surface a host must provide (Android: web message listener). */
+type HostBridgeChannel = {
+  postMessage(message: string): void;
+  addEventListener(type: "message", listener: (event: {
+    data: unknown;
+  }) => void): void;
+  removeEventListener(type: "message", listener: (event: {
+    data: unknown;
+  }) => void): void;
+};
+type HostBridgeStatus = {
+  platform: HostPlatform;
+  version: number;
+  hostId: string;
+  capabilities: readonly HostBridgeCapability[];
+};
+type HostBridgeCallOptions = {
+  timeoutMs?: number;
+  signal?: AbortSignal;
+};
+type HostBridgeClient = {
+  readonly status: HostBridgeStatus | null;
+  readonly connected: boolean;
+  ready(): Promise<HostBridgeStatus | null>;
+  supports(capability: HostBridgeCapability): boolean;
+  call<M extends HostBridgeMethod>(method: M, params?: HostBridgeParams<M>, options?: HostBridgeCallOptions): Promise<HostBridgeResult<M>>;
+  onEvent(listener: (event: HostBridgeEvent) => void): () => void;
+  dispose(): void;
+};
+/**
+ * Connect to the injected host, if any. With no channel this resolves `null`
+ * immediately — the browser path must not pay for a host that is not there.
+ *
+ * Until the handshake completes every capability is absent, so a
+ * half-initialised host is never mistaken for a capable one.
+ */
+declare function createHostBridge(options?: {
+  channel?: HostBridgeChannel | null;
+  handshakeTimeoutMs?: number;
+}): HostBridgeClient;
+//#endregion
+export { HostBridgeCallOptions, HostBridgeChannel, HostBridgeClient, HostBridgeError, HostBridgeErrorClass, HostBridgeParams, HostBridgeResult, HostBridgeStatus, createHostBridge };

package/dist/host-bridge.js

@@ -0,0 +1,322 @@
+import { z } from "zod";
+//#region ../protocol/dist/host-bridge.js
+const HOST_BRIDGE_GLOBAL = "cohubHost";
+const hostBridgeCapabilitySchema = z.enum([
+	"auth.token",
+	"auth.signIn",
+	"auth.session",
+	"notifications",
+	"share",
+	"filePicker",
+	"navigation",
+	"cache",
+	"runtime",
+	"appearance",
+	"launch",
+	"haptics",
+	"files",
+	"navigation.back",
+	"shortcuts",
+	"display"
+]);
+const hostPlatformSchema = z.enum([
+	"android",
+	"ios",
+	"web",
+	"unknown"
+]);
+const identifier = z.string().min(1).max(128);
+/** Unknown capabilities from a newer host are dropped, not rejected. */
+const knownCapabilitiesSchema = z.array(z.string().min(1).max(64)).max(64).transform((names) => names.filter((name) => hostBridgeCapabilitySchema.safeParse(name).success));
+/** Pushed by hosts that predate the `host.describe` handshake. */
+const hostBridgeHelloSchema = z.object({
+	type: z.literal("hello"),
+	version: z.number().int().positive(),
+	platform: hostPlatformSchema,
+	hostId: identifier,
+	capabilities: knownCapabilitiesSchema
+}).strict();
+const hostDescriptionSchema = hostBridgeHelloSchema.omit({ type: true });
+const hostBridgeRequestSchema = z.object({
+	type: z.literal("request"),
+	id: identifier,
+	method: z.string().min(1).max(64),
+	params: z.unknown().optional()
+}).strict();
+const hostBridgeResponseSchema = z.object({
+	type: z.literal("response"),
+	id: identifier,
+	result: z.unknown().optional(),
+	error: z.object({
+		code: z.string().min(1).max(64),
+		message: z.string().min(1).max(2e3)
+	}).strict().optional()
+}).strict();
+const hostBridgeEventSchema = z.object({
+	type: z.literal("event"),
+	name: z.string().min(1).max(64),
+	payload: z.unknown().optional()
+}).strict();
+const hostBridgeMessageSchema = z.discriminatedUnion("type", [
+	hostBridgeHelloSchema,
+	hostBridgeRequestSchema,
+	hostBridgeResponseSchema,
+	hostBridgeEventSchema
+]);
+z.object({ forceRefresh: z.boolean().optional() }).strict();
+z.object({
+	authenticated: z.boolean(),
+	userUuid: z.string().min(1).max(128).nullable(),
+	subject: z.string().min(1).max(255).nullable(),
+	email: z.string().max(320).nullable()
+}).strict();
+const DEVICE_RUNTIME_REFUSALS = [
+	"space_in_use",
+	"folder_in_use",
+	"folder_unavailable"
+];
+const devicePath = z.string().min(1).max(4096);
+const deviceLabel = z.string().min(1).max(4096);
+const deviceRuntimeInstanceSchema = z.object({
+	spaceId: z.uuid(),
+	root: devicePath,
+	label: deviceLabel,
+	state: z.enum([
+		"stopped",
+		"connecting",
+		"ready",
+		"error"
+	]),
+	error: z.string().min(1).max(64).nullable()
+}).strict();
+const deviceRuntimeSchema = z.object({ instances: z.array(deviceRuntimeInstanceSchema).max(256) }).strict();
+z.object({
+	path: devicePath,
+	label: deviceLabel,
+	parent: devicePath.nullable(),
+	spaceId: z.uuid().nullable(),
+	folders: z.array(z.object({
+		name: z.string().min(1).max(255),
+		path: devicePath
+	}).strict()).max(1e4),
+	volumes: z.array(z.object({
+		path: devicePath,
+		label: deviceLabel
+	}).strict()).max(16)
+}).strict();
+z.object({
+	sharedWith: z.uuid().nullable(),
+	control: z.boolean(),
+	error: z.string().min(1).max(64).nullable()
+}).strict();
+const hostColorSchema = z.string().regex(/^#[0-9a-f]{6}$/i);
+const HOST_HAPTICS = [
+	"tick",
+	"confirm",
+	"reject",
+	"longPress"
+];
+/** Hosts parse messages on their UI thread; larger files go by URL. */
+const HOST_FILE_DATA_MAX_LENGTH = 16777216;
+const savedFileSchema = z.object({
+	name: z.string().min(1).max(255),
+	mimeType: z.string().min(1).max(255).optional()
+});
+z.union([savedFileSchema.extend({ url: z.url({ protocol: /^https$/ }).max(8192) }).strict(), savedFileSchema.extend({ data: z.base64().max(HOST_FILE_DATA_MAX_LENGTH) }).strict()]);
+z.object({
+	id: z.string().min(1).max(128),
+	label: z.string().min(1).max(64),
+	path: z.string().regex(/^\/(?!\/)/, "an in-app path").max(2048)
+}).strict();
+z.undefined(), z.string().min(1).nullable(), z.undefined(), z.number().int().nonnegative(), z.undefined(), z.object({ redirectPath: z.string().max(2048).optional() }).strict(), z.boolean(), z.undefined(), z.boolean(), z.undefined(), z.boolean(), z.object({
+	text: z.string().max(1e5),
+	title: z.string().max(512).optional()
+}).strict(), z.boolean(), z.object({ path: z.string().min(1).max(2048) }).strict(), z.boolean(), z.object({ scope: z.enum(["all", "user"]) }).strict(), z.boolean(), z.undefined(), z.object({ path: devicePath.optional() }).strict(), z.object({
+	spaceId: z.uuid(),
+	root: devicePath
+}).strict(), deviceRuntimeSchema.extend({ refused: z.enum(DEVICE_RUNTIME_REFUSALS).nullable() }).strict(), z.object({ spaceId: z.uuid() }).strict(), z.object({ backgroundColor: hostColorSchema }).strict(), z.boolean(), z.undefined(), z.boolean(), z.object({ kind: z.enum(HOST_HAPTICS) }).strict(), z.boolean(), z.boolean(), z.object({ enabled: z.boolean() }).strict(), z.boolean(), z.boolean(), z.undefined(), z.object({ spaceId: z.uuid() }).strict(), z.undefined(), z.undefined(), z.boolean();
+const HOST_BRIDGE_ERROR = {
+	unsupported: "unsupported",
+	unauthorized: "unauthorized",
+	canceled: "canceled",
+	failed: "failed"
+};
+//#endregion
+//#region src/host-bridge.ts
+var HostBridgeErrorClass = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "HostBridgeError";
+		this.code = code;
+	}
+	get isCanceled() {
+		return this.code === HOST_BRIDGE_ERROR.canceled;
+	}
+	get isUnsupported() {
+		return this.code === HOST_BRIDGE_ERROR.unsupported;
+	}
+};
+const readChannel = () => {
+	const candidate = globalThis[HOST_BRIDGE_GLOBAL];
+	if (!candidate || typeof candidate !== "object") return null;
+	const channel = candidate;
+	return typeof channel.postMessage === "function" ? channel : null;
+};
+const parseIncoming = (data) => {
+	if (typeof data === "string") try {
+		return hostBridgeMessageSchema.safeParse(JSON.parse(data));
+	} catch {
+		return {
+			success: false,
+			error: null
+		};
+	}
+	return hostBridgeMessageSchema.safeParse(data);
+};
+/**
+* Connect to the injected host, if any. With no channel this resolves `null`
+* immediately — the browser path must not pay for a host that is not there.
+*
+* Until the handshake completes every capability is absent, so a
+* half-initialised host is never mistaken for a capable one.
+*/
+function createHostBridge(options = {}) {
+	const channel = options.channel === void 0 ? readChannel() : options.channel;
+	const handshakeTimeoutMs = options.handshakeTimeoutMs ?? 2e3;
+	const pending = /* @__PURE__ */ new Map();
+	const eventListeners = /* @__PURE__ */ new Set();
+	let status = null;
+	let disposed = false;
+	let sequence = 0;
+	let handshake = null;
+	const nextRequestId = () => {
+		sequence += 1;
+		const random = globalThis.crypto?.randomUUID?.().replaceAll("-", "").slice(0, 16);
+		return `h${sequence}-${random ?? sequence.toString(36)}`;
+	};
+	const settle = (id, apply) => {
+		const call = pending.get(id);
+		if (!call) return;
+		pending.delete(id);
+		clearTimeout(call.timer);
+		if (call.signal && call.onAbort) call.signal.removeEventListener("abort", call.onAbort);
+		apply(call);
+	};
+	const adoptHello = (hello) => {
+		status = {
+			platform: hello.platform,
+			version: hello.version,
+			hostId: hello.hostId,
+			capabilities: hello.capabilities
+		};
+	};
+	const onMessage = (event) => {
+		const parsed = parseIncoming(event.data);
+		if (!parsed.success) return;
+		const message = parsed.data;
+		if (message.type === "hello") {
+			adoptHello(message);
+			return;
+		}
+		if (message.type === "response") {
+			const response = message;
+			settle(response.id, (call) => {
+				if (response.error) {
+					call.reject(new HostBridgeErrorClass(response.error.code, response.error.message));
+					return;
+				}
+				call.resolve(response.result);
+			});
+			return;
+		}
+		if (message.type === "event") for (const listener of eventListeners) listener(message);
+	};
+	if (channel && !disposed) channel.addEventListener("message", onMessage);
+	const rawCall = (method, params, callOptions) => {
+		if (!channel || disposed) return Promise.reject(new HostBridgeErrorClass(HOST_BRIDGE_ERROR.unsupported, `Host bridge method is unavailable: ${method}`));
+		const id = nextRequestId();
+		const timeoutMs = callOptions?.timeoutMs ?? 3e4;
+		return new Promise((resolve, reject) => {
+			const signal = callOptions?.signal;
+			if (signal?.aborted) {
+				reject(new HostBridgeErrorClass(HOST_BRIDGE_ERROR.canceled, "canceled before send"));
+				return;
+			}
+			const onAbort = () => settle(id, (call) => call.reject(new HostBridgeErrorClass(HOST_BRIDGE_ERROR.canceled, "canceled")));
+			const timer = setTimeout(() => {
+				settle(id, (call) => call.reject(new HostBridgeErrorClass(HOST_BRIDGE_ERROR.failed, `Host bridge timed out: ${method}`)));
+			}, timeoutMs);
+			pending.set(id, {
+				resolve,
+				reject,
+				timer,
+				signal,
+				onAbort
+			});
+			if (signal) signal.addEventListener("abort", onAbort, { once: true });
+			const request = {
+				type: "request",
+				id,
+				method,
+				...params === void 0 ? {} : { params }
+			};
+			try {
+				channel.postMessage(JSON.stringify(request));
+			} catch (error) {
+				settle(id, (call) => call.reject(error));
+			}
+		});
+	};
+	const describe = async () => {
+		if (!channel || disposed) return null;
+		try {
+			const described = await rawCall("host.describe", void 0, { timeoutMs: handshakeTimeoutMs });
+			const parsed = hostDescriptionSchema.safeParse(described);
+			if (!parsed.success) return null;
+			adoptHello(parsed.data);
+			return status;
+		} catch {
+			return null;
+		}
+	};
+	const failAll = (error) => {
+		for (const call of pending.values()) {
+			clearTimeout(call.timer);
+			if (call.signal && call.onAbort) call.signal.removeEventListener("abort", call.onAbort);
+			call.reject(error);
+		}
+		pending.clear();
+	};
+	return {
+		get status() {
+			return status;
+		},
+		get connected() {
+			return Boolean(channel) && status !== null && !disposed;
+		},
+		ready() {
+			handshake ??= describe();
+			return handshake;
+		},
+		supports(capability) {
+			return status?.capabilities.includes(capability) ?? false;
+		},
+		call(method, params, callOptions) {
+			if (!status) return Promise.reject(new HostBridgeErrorClass(HOST_BRIDGE_ERROR.unsupported, `Host bridge is not connected; awaiting handshake before ${method}`));
+			return rawCall(method, params, callOptions);
+		},
+		onEvent(listener) {
+			eventListeners.add(listener);
+			return () => eventListeners.delete(listener);
+		},
+		dispose() {
+			disposed = true;
+			failAll(new HostBridgeErrorClass(HOST_BRIDGE_ERROR.failed, "Host bridge disposed"));
+			eventListeners.clear();
+			if (channel) channel.removeEventListener("message", onMessage);
+		}
+	};
+}
+//#endregion
+export { HostBridgeErrorClass, createHostBridge };