@fluid-app/droplet-bridge 0.0.0-stage → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1248 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/errors.ts
+var FluidBridgeError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "FluidBridgeError";
+		this.code = code;
+		this.details = details;
+	}
+};
+var FluidBridgeConfigurationError = class extends FluidBridgeError {
+	constructor(message, details) {
+		super("configuration_error", message, details);
+		this.name = "ConfigurationError";
+	}
+};
+var FluidBridgeHostUnavailableError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge host is unavailable", details) {
+		super("host_unavailable", message, details);
+		this.name = "HostUnavailableError";
+	}
+};
+var FluidBridgeHandshakeTimeoutError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge host did not respond before the handshake timed out", details) {
+		super("handshake_timeout", message, details);
+		this.name = "HandshakeTimeoutError";
+	}
+};
+var FluidBridgeIncompatibleVersionError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge SDK is not compatible with the host", details) {
+		super("incompatible_version", message, details);
+		this.name = "IncompatibleVersionError";
+	}
+};
+var FluidBridgeTokenMintError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge host could not mint a session token", details) {
+		super("token_mint_failed", message, details);
+		this.name = "TokenMintFailedError";
+	}
+};
+var FluidBridgeUnauthorizedError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge request is unauthorized", details) {
+		super("unauthorized", message, details);
+		this.name = "UnauthorizedError";
+	}
+};
+var FluidBridgeForbiddenOriginError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge host origin is forbidden", details) {
+		super("forbidden_origin", message, details);
+		this.name = "ForbiddenOriginError";
+	}
+};
+var FluidBridgeInvalidContextError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge context is invalid", details) {
+		super("invalid_context", message, details);
+		this.name = "InvalidContextError";
+	}
+};
+var FluidBridgeRequestTimeoutError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge request timed out", details) {
+		super("request_timeout", message, details);
+		this.name = "RequestTimeoutError";
+	}
+};
+var FluidBridgeFetchTargetError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge fetch target is not allowed", details) {
+		super("fetch_target_not_allowed", message, details);
+		this.name = "FetchTargetNotAllowedError";
+	}
+};
+var FluidBridgeNetworkError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge fetch failed", details) {
+		super("network_error", message, details);
+		this.name = "NetworkError";
+	}
+};
+var FluidBridgeFailedAuthenticationError = class extends FluidBridgeError {
+	constructor(message = "Fluid App Bridge authentication failed", details) {
+		super("failed_authentication", message, details);
+		this.name = "FailedAuthenticationError";
+	}
+};
+//#endregion
+//#region src/protocol.ts
+const FLUID_BRIDGE_PROTOCOL_VERSION = "2026-07";
+const APP_BRIDGE_SDK_NAME = "@fluid-app/droplet-bridge";
+const APP_BRIDGE_SDK_VERSION = "0.1.0";
+const FluidBridgeMessageType = {
+	SessionTokenRequest: "FLUID::SESSION_TOKEN_REQUEST",
+	SessionTokenRespond: "FLUID::SESSION_TOKEN_RESPOND",
+	ContextRequest: "FLUID::CONTEXT_REQUEST",
+	ContextRespond: "FLUID::CONTEXT_RESPOND",
+	FailedAuthentication: "FLUID::ERROR::FAILED_AUTHENTICATION",
+	Unauthorized: "FLUID::ERROR::UNAUTHORIZED",
+	IncompatibleVersion: "FLUID::ERROR::INCOMPATIBLE_VERSION",
+	TokenMintFailed: "FLUID::ERROR::TOKEN_MINT_FAILED",
+	InvalidContext: "FLUID::ERROR::INVALID_CONTEXT"
+};
+//#endregion
+//#region src/host.ts
+function createFluidBridgeHost(options) {
+	const targetWindow = options.targetWindow ?? window;
+	const appOrigin = normalizeOrigin(options.appOrigin);
+	const handleMessage = (event) => {
+		if (event.origin !== appOrigin) return;
+		if (event.source !== options.iframe.contentWindow) return;
+		if (!isBridgeEnvelope(event.data)) return;
+		respondToBridgeMessage(options, event.data, appOrigin);
+	};
+	targetWindow.addEventListener("message", handleMessage);
+	return { destroy: () => targetWindow.removeEventListener("message", handleMessage) };
+}
+async function respondToBridgeMessage(options, envelope, appOrigin) {
+	const childWindow = options.iframe.contentWindow;
+	if (!childWindow) return;
+	try {
+		validateRequestPayload(envelope.payload, options.clientId);
+		switch (envelope.type) {
+			case FluidBridgeMessageType.ContextRequest: {
+				const context = await options.getContext();
+				childWindow.postMessage({
+					id: envelope.id,
+					type: FluidBridgeMessageType.ContextRespond,
+					payload: context
+				}, appOrigin);
+				return;
+			}
+			case FluidBridgeMessageType.SessionTokenRequest: {
+				const context = await options.getContext();
+				const sessionToken = await options.getSessionToken(context);
+				if (sessionToken.length === 0) throw new FluidBridgeTokenMintError("Fluid App Bridge host returned an empty session token");
+				childWindow.postMessage({
+					id: envelope.id,
+					type: FluidBridgeMessageType.SessionTokenRespond,
+					payload: { sessionToken }
+				}, appOrigin);
+				return;
+			}
+			default: throw new FluidBridgeForbiddenOriginError("Fluid App Bridge host received an unsupported message type", { type: envelope.type });
+		}
+	} catch (error) {
+		childWindow.postMessage({
+			id: envelope.id,
+			type: errorTypeFor(error),
+			payload: errorPayloadFor(error)
+		}, appOrigin);
+	}
+}
+function validateRequestPayload(value, clientId) {
+	if (typeof value !== "object" || value === null) throw new FluidBridgeInvalidContextError("Fluid App Bridge request payload is invalid");
+	if (!("clientId" in value) || value.clientId !== clientId) throw new FluidBridgeFailedAuthenticationError("Fluid App Bridge request client ID does not match the host context");
+	if (!("protocol" in value) || value.protocol !== "2026-07") throw new FluidBridgeIncompatibleVersionError();
+	return value;
+}
+function isBridgeEnvelope(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return "id" in value && "type" in value && "payload" in value && typeof value.id === "string" && typeof value.type === "string";
+}
+function errorTypeFor(error) {
+	if (error instanceof FluidBridgeFailedAuthenticationError) return FluidBridgeMessageType.FailedAuthentication;
+	if (error instanceof FluidBridgeIncompatibleVersionError) return FluidBridgeMessageType.IncompatibleVersion;
+	if (error instanceof FluidBridgeUnauthorizedError) return FluidBridgeMessageType.Unauthorized;
+	if (error instanceof FluidBridgeTokenMintError) return FluidBridgeMessageType.TokenMintFailed;
+	if (error instanceof FluidBridgeInvalidContextError) return FluidBridgeMessageType.InvalidContext;
+	if (error instanceof FluidBridgeForbiddenOriginError) return FluidBridgeMessageType.InvalidContext;
+	return FluidBridgeMessageType.TokenMintFailed;
+}
+function errorPayloadFor(error) {
+	if (error instanceof Error && "code" in error && typeof error.code === "string") return {
+		code: error.code,
+		message: error.message,
+		details: "details" in error ? error.details : void 0
+	};
+	return {
+		code: "token_mint_failed",
+		message: "Fluid App Bridge host could not complete the request",
+		details: error
+	};
+}
+function normalizeOrigin(origin) {
+	return new URL(origin).origin;
+}
+const unknownShape = { kind: "unknown" };
+const stringShape = { kind: "string" };
+const nonEmptyStringShape = {
+	kind: "string",
+	nonEmpty: true
+};
+const emptyObjectShape = { kind: "object" };
+const unspecifiedObjectShape = {
+	kind: "object",
+	additionalProperties: true
+};
+const stringArrayShape = { kind: "string-array" };
+const bridgeContextShape = {
+	kind: "object",
+	required: {
+		protocolVersion: {
+			kind: "string-enum",
+			values: ["1"]
+		},
+		app: {
+			kind: "object",
+			required: { clientId: nonEmptyStringShape }
+		},
+		store: {
+			kind: "object",
+			required: {
+				subdomain: nonEmptyStringShape,
+				url: nonEmptyStringShape
+			},
+			optional: {
+				uuid: stringShape,
+				name: stringShape,
+				locale: nonEmptyStringShape
+			}
+		},
+		actor: {
+			kind: "object",
+			required: { type: {
+				kind: "string-enum",
+				values: ["store_admin", "store_member"]
+			} },
+			optional: {
+				uuid: stringShape,
+				roles: stringArrayShape,
+				permissions: stringArrayShape,
+				memberType: stringShape
+			}
+		},
+		entry: {
+			kind: "object",
+			required: { type: {
+				kind: "string-enum",
+				values: [
+					"droplet",
+					"drop_zone",
+					"mobile_embed",
+					"portal_embed",
+					"app_extension"
+				]
+			} },
+			optional: { name: stringShape }
+		},
+		resources: {
+			kind: "array",
+			items: {
+				kind: "object",
+				required: {
+					type: nonEmptyStringShape,
+					id: nonEmptyStringShape
+				}
+			}
+		},
+		fetch: {
+			kind: "object",
+			required: { allowedOrigins: { kind: "absolute-origin-array" } }
+		},
+		sdk: {
+			kind: "object",
+			required: { minVersion: nonEmptyStringShape },
+			optional: { recommendedVersion: stringShape }
+		}
+	}
+};
+const BRIDGE_MESSAGE_CATALOG = {
+	"bridge.ready": {
+		direction: "iframe-to-shell",
+		expectsResponse: false,
+		payloadShape: emptyObjectShape
+	},
+	"session_token.deliver": {
+		direction: "shell-to-iframe",
+		expectsResponse: false,
+		payloadShape: {
+			kind: "object",
+			required: { sessionToken: nonEmptyStringShape }
+		}
+	},
+	"session_token.refresh_request": {
+		direction: "iframe-to-shell",
+		expectsResponse: {
+			messageTypes: ["session_token.deliver"],
+			correlation: "request_id"
+		},
+		payloadShape: {
+			kind: "object",
+			required: {
+				clientId: nonEmptyStringShape,
+				sdkVersion: nonEmptyStringShape,
+				protocolVersion: nonEmptyStringShape
+			}
+		}
+	},
+	"context.deliver": {
+		direction: "shell-to-iframe",
+		expectsResponse: false,
+		payloadShape: bridgeContextShape
+	},
+	"nav.request": {
+		direction: "iframe-to-shell",
+		expectsResponse: {
+			messageTypes: ["nav.ack", "nav.reject"],
+			correlation: "request_id"
+		},
+		payloadShape: {
+			kind: "object",
+			required: {
+				target: nonEmptyStringShape,
+				params: {
+					kind: "record",
+					values: unknownShape
+				}
+			}
+		}
+	},
+	"nav.ack": {
+		direction: "shell-to-iframe",
+		expectsResponse: false,
+		payloadShape: emptyObjectShape
+	},
+	"nav.reject": {
+		direction: "shell-to-iframe",
+		expectsResponse: false,
+		payloadShape: {
+			kind: "object",
+			required: { reason: nonEmptyStringShape }
+		}
+	},
+	"modal.open": {
+		direction: "iframe-to-shell",
+		expectsResponse: {
+			messageTypes: ["modal.close"],
+			correlation: "lifecycle"
+		},
+		payloadShape: unspecifiedObjectShape
+	},
+	"modal.close": {
+		direction: "shell-to-iframe",
+		expectsResponse: false,
+		payloadShape: emptyObjectShape
+	},
+	"toast.show": {
+		direction: "iframe-to-shell",
+		expectsResponse: false,
+		payloadShape: unspecifiedObjectShape
+	},
+	"redirect.request": {
+		direction: "iframe-to-shell",
+		expectsResponse: false,
+		payloadShape: unspecifiedObjectShape
+	},
+	error: {
+		direction: "both",
+		expectsResponse: false,
+		payloadShape: {
+			kind: "object",
+			required: {
+				code: nonEmptyStringShape,
+				message: nonEmptyStringShape
+			},
+			optional: { details: {
+				kind: "record",
+				values: unknownShape
+			} }
+		}
+	}
+};
+function parseBridgeEnvelope(value, options) {
+	try {
+		if (!isRecord(value)) return {
+			ok: false,
+			reason: "malformed"
+		};
+		const requestId = typeof value.request_id === "string" && uuidV7Pattern.test(value.request_id) ? value.request_id : void 0;
+		if (!hasExactKeys(value, envelopeKeys)) return parseFailure("malformed", requestId);
+		if (value.version !== "1") return parseFailure("version_mismatch", requestId);
+		if (typeof value.type !== "string" || typeof value.request_id !== "string" || !uuidV7Pattern.test(value.request_id)) return parseFailure("malformed", requestId);
+		if (!isBridgeMessageType(value.type)) return parseFailure("unknown_type", requestId);
+		const catalogEntry = BRIDGE_MESSAGE_CATALOG[value.type];
+		if (!isDirectionAllowed(catalogEntry.direction, options.receivedBy)) return parseFailure("wrong_direction", requestId);
+		if (!matchesPayloadShape(value.payload, catalogEntry.payloadShape)) return parseFailure("invalid_payload", requestId);
+		return {
+			ok: true,
+			envelope: value
+		};
+	} catch {
+		return {
+			ok: false,
+			reason: "malformed"
+		};
+	}
+}
+const envelopeKeys = [
+	"type",
+	"payload",
+	"request_id",
+	"version"
+];
+const uuidV7Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function isDenseArray(value) {
+	if (!Array.isArray(value)) return false;
+	if (Object.keys(value).length !== value.length) return false;
+	for (let index = 0; index < value.length; index += 1) if (!Object.hasOwn(value, index)) return false;
+	return true;
+}
+function hasExactKeys(value, expectedKeys) {
+	return Object.keys(value).length === expectedKeys.length && expectedKeys.every((key) => Object.hasOwn(value, key));
+}
+function isBridgeMessageType(value) {
+	return Object.hasOwn(BRIDGE_MESSAGE_CATALOG, value);
+}
+function parseFailure(reason, requestId) {
+	return requestId === void 0 ? {
+		ok: false,
+		reason
+	} : {
+		ok: false,
+		reason,
+		requestId
+	};
+}
+function isDirectionAllowed(direction, receivedBy) {
+	return direction === "both" || direction === "iframe-to-shell" && receivedBy === "shell" || direction === "shell-to-iframe" && receivedBy === "iframe";
+}
+function matchesPayloadShape(value, shape) {
+	if (shape.kind === "unknown") return true;
+	if (shape.kind === "string") return typeof value === "string" && (shape.nonEmpty !== true || value.length > 0);
+	if (shape.kind === "string-array") return isDenseArray(value) && value.every((item) => typeof item === "string");
+	if (shape.kind === "absolute-origin-array") return isDenseArray(value) && value.every(isAbsoluteOrigin);
+	if (shape.kind === "string-enum") return typeof value === "string" && shape.values.includes(value);
+	if (shape.kind === "array") return isDenseArray(value) && value.every((item) => matchesPayloadShape(item, shape.items));
+	if (shape.kind === "record") return isRecord(value) && Object.values(value).every((item) => matchesPayloadShape(item, shape.values));
+	if (!isRecord(value)) return false;
+	const required = shape.required ?? {};
+	const optional = shape.optional ?? {};
+	const knownKeys = new Set([...Object.keys(required), ...Object.keys(optional)]);
+	if (!Object.entries(required).every(([key, fieldShape]) => Object.hasOwn(value, key) && matchesPayloadShape(value[key], fieldShape))) return false;
+	if (!Object.entries(optional).every(([key, fieldShape]) => !Object.hasOwn(value, key) || matchesPayloadShape(value[key], fieldShape))) return false;
+	return shape.additionalProperties === true || Object.keys(value).every((key) => knownKeys.has(key));
+}
+function isAbsoluteOrigin(value) {
+	if (typeof value !== "string" || value === "*") return false;
+	try {
+		const url = new URL(value);
+		return (url.protocol === "https:" || url.protocol === "http:") && url.origin !== "null" && url.origin === value;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/canonical-host.ts
+const REQUEST_TIMEOUT_MS = 5e3;
+const MAX_PENDING_REQUESTS = 16;
+const CONTEXT_VALIDATION_ID = "00000000-0000-7000-8000-000000000000";
+/** Push handshake and correlated refresh on the single canonical envelope. */
+function createCanonicalBridgeHost(options) {
+	const targetWindow = options.targetWindow ?? window;
+	const appOrigin = exactOrigin$1(options.appOrigin);
+	const mount = Object.freeze({
+		...options.mount,
+		actor: Object.freeze({ ...options.mount.actor }),
+		entry: Object.freeze({ ...options.mount.entry })
+	});
+	if (!mount.clientId.trim() || !mount.storeUuid.trim() || !mount.actor.uuid.trim() || !mount.installationId.trim() || !mount.entry.name.trim() || !mount.sid.trim()) throw new FluidBridgeConfigurationError("Host mount identifiers must be present");
+	const iframe = options.iframe;
+	const frameWindow = iframe.contentWindow;
+	if (!frameWindow) throw new FluidBridgeConfigurationError("Host requires a mounted iframe");
+	const frameSrc = iframe.src;
+	if (new URL(frameSrc).origin !== appOrigin) throw new FluidBridgeConfigurationError("Iframe does not match its registered origin");
+	let destroyed = false;
+	let context;
+	let originBaseline;
+	let ready = false;
+	const pendingReady = /* @__PURE__ */ new Map();
+	const pendingRefresh = /* @__PURE__ */ new Map();
+	const isCurrent = () => !destroyed && iframe.contentWindow === frameWindow && iframe.src === frameSrc;
+	const post = (envelope) => {
+		if (isCurrent()) frameWindow.postMessage(envelope, appOrigin);
+	};
+	const fail = (requestId, payload) => {
+		post({
+			type: "error",
+			payload,
+			request_id: requestId,
+			version: "1"
+		});
+	};
+	const run = async (requestId, operation, initial) => {
+		const pool = initial ? pendingReady : pendingRefresh;
+		if (pool.has(requestId)) return;
+		if (pool.size >= MAX_PENDING_REQUESTS) {
+			fail(requestId, {
+				code: "host_unavailable",
+				message: "Host request capacity exceeded"
+			});
+			return;
+		}
+		const controller = new AbortController();
+		pool.set(requestId, controller);
+		const timer = setTimeout(() => controller.abort(new FluidBridgeRequestTimeoutError()), REQUEST_TIMEOUT_MS);
+		try {
+			await abortable$1(operation(controller.signal), controller.signal);
+		} catch (error) {
+			if (isCurrent()) fail(requestId, safeError(error, initial));
+		} finally {
+			clearTimeout(timer);
+			pool.delete(requestId);
+		}
+	};
+	const mint = async (signal) => {
+		const token = await options.getSessionToken(mount, signal);
+		if (signal.aborted) throw signal.reason;
+		if (typeof token !== "string" || !tokenMatchesMount(token, mount)) throw new FluidBridgeTokenMintError();
+		return token;
+	};
+	const fetchContext = async (signal) => {
+		let candidate;
+		try {
+			candidate = await options.getContext(signal);
+		} catch (error) {
+			if (signal.aborted || error instanceof FluidBridgeError) throw error;
+			throw new FluidBridgeInvalidContextError();
+		}
+		if (signal.aborted) throw signal.reason;
+		return boundContext(candidate, mount, appOrigin);
+	};
+	const deliver = async (requestId, signal) => {
+		const deliveredContext = await fetchContext(signal);
+		const token = await mint(signal);
+		if (signal.aborted) throw signal.reason;
+		if (!isCurrent()) return;
+		context = deliveredContext;
+		originBaseline = originBaseline ? new Set([...originBaseline, ...deliveredContext.fetch.allowedOrigins]) : new Set(deliveredContext.fetch.allowedOrigins);
+		post({
+			type: "context.deliver",
+			payload: deliveredContext,
+			request_id: requestId,
+			version: "1"
+		});
+		post({
+			type: "session_token.deliver",
+			payload: { sessionToken: token },
+			request_id: requestId,
+			version: "1"
+		});
+		ready = true;
+	};
+	const refresh = async (requestId, payload, signal) => {
+		if (!ready || !context) {
+			fail(requestId, {
+				code: "host_unavailable",
+				message: "Complete the handshake before refreshing"
+			});
+			return;
+		}
+		if (payload.clientId !== mount.clientId) {
+			fail(requestId, {
+				code: "failed_authentication",
+				message: "Request does not match the mounted app"
+			});
+			return;
+		}
+		if (payload.protocolVersion !== "1" || !supportsSdk$1(payload.sdkVersion, context.sdk.minVersion)) {
+			fail(requestId, {
+				code: "incompatible_version",
+				message: "SDK or protocol version is incompatible",
+				details: {
+					received: {
+						sdkVersion: payload.sdkVersion.slice(0, 32),
+						protocolVersion: payload.protocolVersion.slice(0, 32)
+					},
+					required: {
+						sdkVersion: context.sdk.minVersion,
+						protocolVersion: "1"
+					}
+				}
+			});
+			return;
+		}
+		const authorizedContext = await fetchContext(signal);
+		if (!supportsSdk$1(payload.sdkVersion, authorizedContext.sdk.minVersion)) {
+			fail(requestId, {
+				code: "incompatible_version",
+				message: "SDK version is incompatible with the current context"
+			});
+			return;
+		}
+		if (originBaseline && [...originBaseline].some((origin) => !authorizedContext.fetch.allowedOrigins.includes(origin))) {
+			fail(requestId, {
+				code: "unauthorized",
+				message: "Authorized fetch origins changed for the current document"
+			});
+			return;
+		}
+		context = authorizedContext;
+		const token = await mint(signal);
+		if (signal.aborted) throw signal.reason;
+		post({
+			type: "session_token.deliver",
+			payload: { sessionToken: token },
+			request_id: requestId,
+			version: "1"
+		});
+	};
+	const handleMessage = (event) => {
+		if (!isCurrent() || event.origin !== appOrigin || event.source !== frameWindow) return;
+		const parsed = parseBridgeEnvelope(event.data, { receivedBy: "shell" });
+		if (!parsed.ok) {
+			if (parsed.reason === "version_mismatch" && parsed.requestId) fail(parsed.requestId, {
+				code: "version_mismatch",
+				message: "Unsupported bridge protocol version"
+			});
+			else if (parsed.reason === "invalid_payload" && parsed.requestId && typeof event.data === "object" && event.data !== null && "type" in event.data && event.data.type === "session_token.refresh_request") fail(parsed.requestId, {
+				code: "incompatible_version",
+				message: "Refresh requires client, SDK and protocol metadata"
+			});
+			return;
+		}
+		const envelope = parsed.envelope;
+		if (envelope.type === "bridge.ready") {
+			if (pendingReady.has(envelope.request_id)) return;
+			run(envelope.request_id, (signal) => deliver(envelope.request_id, signal), true);
+		} else if (envelope.type === "session_token.refresh_request") run(envelope.request_id, (signal) => refresh(envelope.request_id, envelope.payload, signal), false);
+	};
+	targetWindow.addEventListener("message", handleMessage);
+	return { destroy: () => {
+		destroyed = true;
+		targetWindow.removeEventListener("message", handleMessage);
+		for (const controller of pendingReady.values()) controller.abort();
+		for (const controller of pendingRefresh.values()) controller.abort();
+		pendingReady.clear();
+		pendingRefresh.clear();
+		context = void 0;
+		originBaseline = void 0;
+		ready = false;
+	} };
+}
+function tokenMatchesMount(token, mount) {
+	try {
+		if (!/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(token)) return false;
+		const encoded = token.split(".")[1];
+		if (!encoded) return false;
+		const claims = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(atob(encoded.replace(/-/g, "+").replace(/_/g, "/")), (character) => character.charCodeAt(0))));
+		if (typeof claims !== "object" || claims === null || Array.isArray(claims)) return false;
+		const payload = claims;
+		const entry = payload.entry;
+		return payload.aud === mount.clientId && payload.dest === `urn:fluid:store:${mount.storeUuid}` && payload.sub === `urn:fluid:${mount.actor.type}:${mount.actor.uuid}` && payload.sid === mount.sid && typeof payload.exp === "number" && Number.isInteger(payload.exp) && typeof entry === "object" && entry !== null && "type" in entry && entry.type === mount.entry.type && "name" in entry && entry.name === mount.entry.name;
+	} catch {
+		return false;
+	}
+}
+function exactOrigin$1(value) {
+	try {
+		const url = new URL(value);
+		if ((url.protocol === "https:" || url.protocol === "http:") && url.origin === value) return value;
+	} catch {}
+	throw new FluidBridgeConfigurationError("Host requires an exact HTTP(S) app origin");
+}
+function boundContext(value, mount, appOrigin) {
+	const parsed = parseBridgeEnvelope({
+		type: "context.deliver",
+		payload: value,
+		request_id: CONTEXT_VALIDATION_ID,
+		version: "1"
+	}, { receivedBy: "iframe" });
+	if (!parsed.ok || parsed.envelope.type !== "context.deliver") throw new FluidBridgeInvalidContextError();
+	const context = parsed.envelope.payload;
+	if (context.app.clientId !== mount.clientId || context.store.uuid !== mount.storeUuid || context.actor.type !== mount.actor.type || context.actor.uuid !== mount.actor.uuid || context.entry.type !== mount.entry.type || context.entry.name !== mount.entry.name || !context.fetch.allowedOrigins.includes(appOrigin) || !supportsSdk$1(context.sdk.minVersion, context.sdk.minVersion)) throw new FluidBridgeInvalidContextError();
+	return context;
+}
+function supportsSdk$1(received, minimum) {
+	const pattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+	if (!pattern.test(received) || !pattern.test(minimum)) return false;
+	const current = received.split(".").map(Number);
+	const required = minimum.split(".").map(Number);
+	if (![...current, ...required].every(Number.isSafeInteger)) return false;
+	for (const index of [
+		0,
+		1,
+		2
+	]) {
+		const left = current[index];
+		const right = required[index];
+		if (left === void 0 || right === void 0) return false;
+		if (left !== right) return left > right;
+	}
+	return true;
+}
+function safeError(error, initial) {
+	if (error instanceof FluidBridgeRequestTimeoutError) return {
+		code: initial ? "handshake_timeout" : "request_timeout",
+		message: "Host request timed out"
+	};
+	if (error instanceof FluidBridgeError) {
+		const code = error.code;
+		if (code === "unauthorized" || code === "failed_authentication" || code === "invalid_context" || code === "incompatible_version" || code === "host_unavailable") return {
+			code,
+			message: "Host could not complete the bridge request"
+		};
+	}
+	return {
+		code: "token_mint_failed",
+		message: "Host could not obtain a session token"
+	};
+}
+function abortable$1(operation, signal) {
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason);
+		if (signal.aborted) {
+			abort();
+			return;
+		}
+		signal.addEventListener("abort", abort, { once: true });
+		operation.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+	});
+}
+//#endregion
+//#region src/session-token-api.ts
+const DEFAULT_SESSION_TOKEN_PATH = "api/v2025-06/app_bridge/session_token";
+async function mintAppBridgeSessionToken({ request, apiBaseUrl, authToken, fetch: fetchImplementation = globalThis.fetch?.bind(globalThis) }) {
+	if (!fetchImplementation) throw new FluidBridgeTokenMintError("Fluid App Bridge host requires a fetch implementation to mint session tokens");
+	const response = await fetchImplementation(resolveSessionTokenUrl(apiBaseUrl), {
+		method: "POST",
+		headers: sessionTokenHeaders(authToken),
+		body: JSON.stringify(sessionTokenRequestBody(request))
+	});
+	const body = await response.json().catch(() => null);
+	if (!response.ok) throw errorForTokenResponse(response.status, body);
+	if (!isSessionTokenSuccessResponse(body) || body.session_token.length === 0) throw new FluidBridgeTokenMintError("Fluid App Bridge backend returned an invalid session token response", { body });
+	return body.session_token;
+}
+function sessionTokenRequestFromContext(context, sessionId) {
+	return {
+		clientId: context.app.clientId,
+		entry: context.entry,
+		resources: context.resources,
+		allowedOrigins: context.fetch.allowedOrigins,
+		...sessionId ? { sessionId } : {}
+	};
+}
+function sessionTokenHeaders(authToken) {
+	const headers = new Headers({
+		"Content-Type": "application/json",
+		"X-Fluid-App-Bridge-Protocol": FLUID_BRIDGE_PROTOCOL_VERSION,
+		"X-Fluid-App-Bridge-Version": APP_BRIDGE_SDK_VERSION,
+		"X-Fluid-App-Bridge-Sdk": APP_BRIDGE_SDK_NAME
+	});
+	if (authToken) headers.set("Authorization", `Bearer ${authToken}`);
+	return headers;
+}
+function sessionTokenRequestBody(request) {
+	return {
+		client_id: request.clientId,
+		entry: request.entry,
+		resources: request.resources ?? [],
+		allowed_origins: request.allowedOrigins ?? [],
+		...request.sessionId ? { session_id: request.sessionId } : {}
+	};
+}
+function resolveSessionTokenUrl(apiBaseUrl) {
+	if (!apiBaseUrl) return `/${DEFAULT_SESSION_TOKEN_PATH}`;
+	return new URL(DEFAULT_SESSION_TOKEN_PATH, ensureTrailingSlash(apiBaseUrl)).toString();
+}
+function ensureTrailingSlash(url) {
+	return url.endsWith("/") ? url : `${url}/`;
+}
+function isSessionTokenSuccessResponse(value) {
+	return typeof value === "object" && value !== null && "session_token" in value && typeof value.session_token === "string";
+}
+function errorForTokenResponse(status, body) {
+	const errorBody = isLegacyErrorResponse(body) ? body.error : void 0;
+	const message = errorBody?.message ?? "Fluid App Bridge backend rejected the session-token request";
+	const details = errorBody?.details ?? body;
+	if (status === 401) return new FluidBridgeUnauthorizedError(message, details);
+	if (status === 403) return new FluidBridgeFailedAuthenticationError(message, details);
+	if (status === 422) return new FluidBridgeIncompatibleVersionError(message, details);
+	return new FluidBridgeTokenMintError(message, details);
+}
+function isLegacyErrorResponse(value) {
+	return typeof value === "object" && value !== null && "error" in value;
+}
+//#endregion
+//#region src/client-fetch.ts
+/** Both explicit and ambient fetch use only server-delivered exact origins. */
+function createAuthenticatedFetch(options) {
+	return async (input, init) => {
+		const baseUrl = options.getBaseUrl();
+		let url;
+		try {
+			url = new URL(input instanceof Request ? input.url : input.toString(), baseUrl);
+		} catch {
+			throw new FluidBridgeFetchTargetError();
+		}
+		if (url.hostname === "api.fluid.app" || url.hostname.endsWith(".api.fluid.app")) {
+			if (options.ambient) return options.nativeFetch(input, init);
+			throw new FluidBridgeFetchTargetError();
+		}
+		if (options.ambient) {
+			const state = options.getHandshakeState();
+			if (state === "failed") return options.nativeFetch(input, init);
+			if (state === "destroyed" && url.origin !== documentOrigin(baseUrl)) return options.nativeFetch(input, init);
+			const delivered = options.getDeliveredContext();
+			if (delivered) {
+				if (!delivered.fetch.allowedOrigins.includes(url.origin)) return options.nativeFetch(input, init);
+			} else if (url.origin !== documentOrigin(baseUrl)) return options.nativeFetch(input, init);
+		}
+		const signal = resolveSignal(input, init);
+		if (signal?.aborted) throw signal.reason;
+		let context;
+		try {
+			context = signal ? await abortable(options.getContext(), signal) : await options.getContext();
+		} catch (error) {
+			if (options.ambient && options.getHandshakeState() === "failed") return options.nativeFetch(input, init);
+			throw error;
+		}
+		if (!context.fetch.allowedOrigins.includes(url.origin)) {
+			if (options.ambient) return options.nativeFetch(input, init);
+			throw new FluidBridgeFetchTargetError();
+		}
+		const locale = context.store.locale;
+		if (!locale || !/^[a-z]{2,3}(?:[-_][a-z0-9]{2,8})*$/i.test(locale)) throw new FluidBridgeInvalidContextError();
+		let request;
+		try {
+			request = new Request(input instanceof Request ? input : url, init);
+		} catch {
+			throw new FluidBridgeNetworkError();
+		}
+		request.signal.throwIfAborted();
+		const token = await abortable(options.getSessionToken(), request.signal);
+		const headers = new Headers(request.headers);
+		headers.set("Authorization", `Bearer ${token}`);
+		headers.set("Accept-Language", locale.replaceAll("_", "-"));
+		let authenticated;
+		try {
+			authenticated = new Request(request, {
+				headers,
+				...options.ambient ? {} : { redirect: "error" }
+			});
+		} catch {
+			throw new FluidBridgeNetworkError();
+		}
+		let response;
+		try {
+			response = await options.nativeFetch(authenticated);
+		} catch {
+			if (request.signal.aborted) throw request.signal.reason;
+			throw new FluidBridgeNetworkError();
+		}
+		if (!options.ambient && (response.status === 401 || response.status === 403)) throw new FluidBridgeFailedAuthenticationError();
+		return response;
+	};
+}
+function documentOrigin(baseUrl) {
+	try {
+		return new URL(baseUrl).origin;
+	} catch {
+		return;
+	}
+}
+function resolveSignal(input, init) {
+	if (init?.signal !== void 0) return init.signal ?? void 0;
+	return input instanceof Request ? input.signal : void 0;
+}
+function abortable(promise, signal) {
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason);
+		if (signal.aborted) {
+			abort();
+			return;
+		}
+		signal.addEventListener("abort", abort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+	});
+}
+//#endregion
+//#region src/canonical-client.ts
+const activeDocuments = /* @__PURE__ */ new WeakSet();
+/** One canonical client per iframe document. Tokens are decoded for delivery binding only. */
+function createFluidBridge(options) {
+	if (!options || typeof options.clientId !== "string" || !options.clientId.trim() || "appOrigins" in options) throw new FluidBridgeConfigurationError("Use clientId and the server-delivered origin list");
+	const hostOrigin = exactOrigin(options.hostOrigin);
+	const current = options.targetWindow ?? globalThis.window;
+	if (!current || current.parent === current) throw new FluidBridgeHostUnavailableError();
+	const parent = current.parent;
+	const nativeFetch = options.fetch ?? current.fetch?.bind(current);
+	const timeout = options.timeoutMs ?? 1e4;
+	if (typeof nativeFetch !== "function" || !Number.isFinite(timeout) || timeout < 1 || timeout > 6e4) throw new FluidBridgeConfigurationError("A fetch implementation and bounded timeout are required");
+	if (activeDocuments.has(current)) throw new FluidBridgeConfigurationError("Destroy the existing bridge before initializing another");
+	const bootstrap = new URL(current.location.href);
+	if (bootstrap.searchParams.has("session_token")) {
+		bootstrap.searchParams.delete("session_token");
+		current.history.replaceState(current.history.state, "", bootstrap.href);
+	}
+	activeDocuments.add(current);
+	const readyId = uuidV7();
+	const pending = /* @__PURE__ */ new Map();
+	let context;
+	let sid;
+	let destroyed = false;
+	let settled = false;
+	let handshakeFailed = false;
+	let refreshInFlight;
+	let attempts = 0;
+	let retryTimer;
+	let refreshTimer;
+	let resolveHandshake;
+	let rejectHandshake;
+	const handshake = new Promise((resolve, reject) => {
+		resolveHandshake = resolve;
+		rejectHandshake = reject;
+	});
+	handshake.catch(() => void 0);
+	const startHandshakeTimer = () => setTimeout(() => failHandshake(new FluidBridgeHandshakeTimeoutError()), timeout);
+	let handshakeTimer = startHandshakeTimer();
+	function handshakeState() {
+		if (destroyed) return "destroyed";
+		if (handshakeFailed) return "failed";
+		return context ? "resolved" : "pending";
+	}
+	function post(envelope) {
+		if (destroyed) return;
+		try {
+			parent.postMessage(envelope, hostOrigin);
+		} catch {
+			rejectRequest(envelope.request_id, new FluidBridgeHostUnavailableError());
+		}
+	}
+	function failHandshake(error) {
+		if (settled) return;
+		settled = true;
+		handshakeFailed = true;
+		clearTimeout(handshakeTimer);
+		clearTimeout(retryTimer);
+		rejectHandshake(error);
+	}
+	function sendReady(force = false) {
+		if (destroyed || settled || attempts >= 8) return;
+		if (context && !force) return;
+		post({
+			type: "bridge.ready",
+			payload: {},
+			request_id: readyId,
+			version: "1"
+		});
+		attempts += 1;
+		if (!context && !settled) retryTimer = setTimeout(sendReady, Math.min(100 * 2 ** (attempts - 1), 1600));
+	}
+	async function getSessionToken() {
+		await handshake;
+		if (destroyed) throw new FluidBridgeHostUnavailableError();
+		if (refreshInFlight) return refreshInFlight;
+		const requestId = uuidV7();
+		refreshInFlight = new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				pending.delete(requestId);
+				reject(new FluidBridgeRequestTimeoutError());
+			}, timeout);
+			pending.set(requestId, {
+				resolve,
+				reject,
+				timer
+			});
+			post({
+				type: "session_token.refresh_request",
+				payload: {
+					clientId: options.clientId,
+					sdkVersion: APP_BRIDGE_SDK_VERSION,
+					protocolVersion: "1"
+				},
+				request_id: requestId,
+				version: "1"
+			});
+		}).finally(() => {
+			refreshInFlight = void 0;
+		});
+		return refreshInFlight;
+	}
+	const DEFAULT_TOKEN_LIFETIME_MS = 6e4;
+	function scheduleRefresh(claims) {
+		clearTimeout(refreshTimer);
+		const lifetimeMs = typeof claims.iat === "number" && Number.isSafeInteger(claims.iat) && claims.iat < claims.exp ? (claims.exp - claims.iat) * 1e3 : DEFAULT_TOKEN_LIFETIME_MS;
+		const delay = Math.max(1e3, lifetimeMs / 2, lifetimeMs - 1e4);
+		refreshTimer = setTimeout(() => {
+			getSessionToken().catch(() => void 0);
+		}, Math.min(2147483647, delay));
+	}
+	function onMessage(event) {
+		if (destroyed || event.source !== parent || event.origin !== hostOrigin) return;
+		const parsed = parseBridgeEnvelope(event.data, { receivedBy: "iframe" });
+		const id = parsed.ok ? parsed.envelope.request_id : parsed.requestId;
+		if (!id || id !== readyId && !pending.has(id)) return;
+		if (id === readyId && settled) return;
+		if (!parsed.ok) {
+			rejectRequest(id, parsed.reason === "version_mismatch" ? new FluidBridgeIncompatibleVersionError() : new FluidBridgeInvalidContextError());
+			return;
+		}
+		const envelope = parsed.envelope;
+		if (envelope.type === "error") rejectRequest(id, errorFromHost(envelope.payload));
+		else if (envelope.type === "context.deliver" && id === readyId && !context) {
+			const candidate = envelope.payload;
+			if (candidate.app.clientId !== options.clientId || !candidate.store.uuid || !candidate.actor.uuid || !candidate.entry.name || !candidate.fetch.allowedOrigins.includes(current.location.origin)) {
+				failHandshake(new FluidBridgeInvalidContextError());
+				return;
+			}
+			if (!supportsSdk("0.1.0", candidate.sdk.minVersion)) {
+				failHandshake(new FluidBridgeIncompatibleVersionError(void 0, {
+					received: APP_BRIDGE_SDK_VERSION,
+					required: candidate.sdk.minVersion
+				}));
+				return;
+			}
+			context = freezeContext(candidate);
+			clearTimeout(retryTimer);
+		} else if (envelope.type === "session_token.deliver") {
+			const claims = boundToken(envelope.payload.sessionToken, context, sid);
+			if (!claims) {
+				rejectRequest(id, new FluidBridgeFailedAuthenticationError());
+				return;
+			}
+			sid ??= claims.sid;
+			scheduleRefresh(claims);
+			if (id === readyId && context) {
+				settled = true;
+				clearTimeout(handshakeTimer);
+				resolveHandshake(context);
+			} else {
+				const request = pending.get(id);
+				if (request) {
+					clearTimeout(request.timer);
+					pending.delete(id);
+					request.resolve(envelope.payload.sessionToken);
+				}
+			}
+		}
+	}
+	function rejectRequest(id, error) {
+		if (id === readyId) failHandshake(error);
+		const request = pending.get(id);
+		if (request) {
+			clearTimeout(request.timer);
+			pending.delete(id);
+			request.reject(error);
+		}
+	}
+	const getContext = async () => {
+		if (destroyed) throw new FluidBridgeHostUnavailableError();
+		return handshake;
+	};
+	const getBaseUrl = () => current.location.href;
+	const getDeliveredContext = () => context;
+	const authenticatedFetch = createAuthenticatedFetch({
+		nativeFetch,
+		getContext,
+		getSessionToken,
+		getBaseUrl,
+		getHandshakeState: handshakeState,
+		getDeliveredContext,
+		ambient: false
+	});
+	const ambientFetch = createAuthenticatedFetch({
+		nativeFetch,
+		getContext,
+		getSessionToken,
+		getBaseUrl,
+		getHandshakeState: handshakeState,
+		getDeliveredContext,
+		ambient: true
+	});
+	const previousFetch = current.fetch;
+	if (!options.disableFetchPatch) current.fetch = ambientFetch;
+	function destroy() {
+		if (destroyed) return;
+		destroyed = true;
+		activeDocuments.delete(current);
+		current.removeEventListener("message", onMessage);
+		current.removeEventListener("pagehide", onPageHide);
+		current.removeEventListener("pageshow", onPageShow);
+		current.removeEventListener("unload", destroy);
+		clearTimeout(retryTimer);
+		clearTimeout(refreshTimer);
+		failHandshake(new FluidBridgeHostUnavailableError());
+		for (const request of pending.values()) {
+			clearTimeout(request.timer);
+			request.reject(new FluidBridgeHostUnavailableError());
+		}
+		pending.clear();
+		context = void 0;
+		sid = void 0;
+		if (current.fetch === ambientFetch) current.fetch = previousFetch;
+	}
+	function onPageHide(event) {
+		if (event.persisted) return;
+		destroy();
+	}
+	function onPageShow(event) {
+		if (!event.persisted || destroyed || settled) return;
+		clearTimeout(handshakeTimer);
+		handshakeTimer = startHandshakeTimer();
+		clearTimeout(retryTimer);
+		attempts = 0;
+		sendReady(true);
+	}
+	current.addEventListener("message", onMessage);
+	current.addEventListener("pagehide", onPageHide);
+	current.addEventListener("pageshow", onPageShow);
+	current.addEventListener("unload", destroy);
+	sendReady();
+	return {
+		getContext,
+		getSessionToken,
+		fetch: authenticatedFetch,
+		destroy
+	};
+}
+function exactOrigin(origin) {
+	try {
+		const url = new URL(origin);
+		if ((url.protocol === "http:" || url.protocol === "https:") && url.origin === origin) return origin;
+	} catch {}
+	throw new FluidBridgeConfigurationError("hostOrigin must be an exact HTTP(S) origin");
+}
+function uuidV7() {
+	const bytes = crypto.getRandomValues(new Uint8Array(16));
+	let timestamp = BigInt(Date.now());
+	for (let index = 5; index >= 0; index -= 1) {
+		bytes[index] = Number(timestamp & 255n);
+		timestamp >>= 8n;
+	}
+	bytes[6] = bytes[6] & 15 | 112;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function supportsSdk(received, minimum) {
+	const semver = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+	if (!semver.test(received) || !semver.test(minimum)) return false;
+	const left = received.split(".").map(Number), right = minimum.split(".").map(Number);
+	if (![...left, ...right].every(Number.isSafeInteger)) return false;
+	for (let index = 0; index < 3; index += 1) if (left[index] !== right[index]) return left[index] > right[index];
+	return true;
+}
+function boundToken(token, context, sid) {
+	try {
+		if (!context || !/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(token)) return;
+		const encoded = token.split(".")[1];
+		const claims = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(atob(encoded.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0))));
+		if (!claims || typeof claims !== "object" || Array.isArray(claims)) return;
+		const payload = claims;
+		const entry = payload.entry;
+		if (payload.aud !== context.app.clientId || payload.dest !== `urn:fluid:store:${context.store.uuid}` || payload.sub !== `urn:fluid:${context.actor.type}:${context.actor.uuid}` || typeof payload.sid !== "string" || !payload.sid || sid !== void 0 && payload.sid !== sid || typeof payload.exp !== "number" || !Number.isSafeInteger(payload.exp) || typeof entry !== "object" || !entry || !("type" in entry) || !("name" in entry) || entry.type !== context.entry.type || entry.name !== context.entry.name) return;
+		const iat = typeof payload.iat === "number" && Number.isSafeInteger(payload.iat) ? payload.iat : void 0;
+		return iat === void 0 ? {
+			sid: payload.sid,
+			exp: payload.exp
+		} : {
+			sid: payload.sid,
+			exp: payload.exp,
+			iat
+		};
+	} catch {
+		return;
+	}
+}
+function freezeContext(context) {
+	Object.freeze(context.store);
+	Object.freeze(context.app);
+	Object.freeze(context.entry);
+	if (context.actor.roles) Object.freeze(context.actor.roles);
+	if (context.actor.permissions) Object.freeze(context.actor.permissions);
+	Object.freeze(context.actor);
+	context.resources.forEach(Object.freeze);
+	Object.freeze(context.resources);
+	Object.freeze(context.fetch.allowedOrigins);
+	Object.freeze(context.fetch);
+	Object.freeze(context.sdk);
+	return Object.freeze(context);
+}
+function errorFromHost(payload) {
+	switch (payload.code) {
+		case "version_mismatch":
+		case "incompatible_version": return new FluidBridgeIncompatibleVersionError(void 0, versionDetails(payload.details));
+		case "unauthorized": return new FluidBridgeUnauthorizedError();
+		case "failed_authentication": return new FluidBridgeFailedAuthenticationError();
+		case "invalid_context": return new FluidBridgeInvalidContextError();
+		case "request_timeout": return new FluidBridgeRequestTimeoutError();
+		case "handshake_timeout": return new FluidBridgeHandshakeTimeoutError();
+		case "host_unavailable": return new FluidBridgeHostUnavailableError();
+		case "forbidden_origin": return new FluidBridgeForbiddenOriginError();
+		default: return new FluidBridgeTokenMintError();
+	}
+}
+function versionDetails(details) {
+	if (!details) return void 0;
+	const sanitize = (value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+		const record = value;
+		return Object.fromEntries(["sdkVersion", "protocolVersion"].flatMap((key) => typeof record[key] === "string" ? [[key, record[key].slice(0, 32)]] : []));
+	};
+	return {
+		received: sanitize(details.received),
+		required: sanitize(details.required)
+	};
+}
+//#endregion
+exports.APP_BRIDGE_SDK_NAME = APP_BRIDGE_SDK_NAME;
+exports.APP_BRIDGE_SDK_VERSION = APP_BRIDGE_SDK_VERSION;
+exports.ConfigurationError = FluidBridgeConfigurationError;
+exports.FLUID_BRIDGE_PROTOCOL_VERSION = FLUID_BRIDGE_PROTOCOL_VERSION;
+exports.FailedAuthenticationError = FluidBridgeFailedAuthenticationError;
+exports.FetchTargetNotAllowedError = FluidBridgeFetchTargetError;
+exports.FluidBridgeConfigurationError = FluidBridgeConfigurationError;
+exports.FluidBridgeError = FluidBridgeError;
+exports.FluidBridgeFailedAuthenticationError = FluidBridgeFailedAuthenticationError;
+exports.FluidBridgeFetchTargetError = FluidBridgeFetchTargetError;
+exports.FluidBridgeForbiddenOriginError = FluidBridgeForbiddenOriginError;
+exports.FluidBridgeHandshakeTimeoutError = FluidBridgeHandshakeTimeoutError;
+exports.FluidBridgeHostUnavailableError = FluidBridgeHostUnavailableError;
+exports.FluidBridgeIncompatibleVersionError = FluidBridgeIncompatibleVersionError;
+exports.FluidBridgeInvalidContextError = FluidBridgeInvalidContextError;
+exports.FluidBridgeMessageType = FluidBridgeMessageType;
+exports.FluidBridgeNetworkError = FluidBridgeNetworkError;
+exports.FluidBridgeRequestTimeoutError = FluidBridgeRequestTimeoutError;
+exports.FluidBridgeTokenMintError = FluidBridgeTokenMintError;
+exports.FluidBridgeUnauthorizedError = FluidBridgeUnauthorizedError;
+exports.ForbiddenOriginError = FluidBridgeForbiddenOriginError;
+exports.HandshakeTimeoutError = FluidBridgeHandshakeTimeoutError;
+exports.HostUnavailableError = FluidBridgeHostUnavailableError;
+exports.IncompatibleVersionError = FluidBridgeIncompatibleVersionError;
+exports.InvalidContextError = FluidBridgeInvalidContextError;
+exports.NetworkError = FluidBridgeNetworkError;
+exports.RequestTimeoutError = FluidBridgeRequestTimeoutError;
+exports.TokenMintFailedError = FluidBridgeTokenMintError;
+exports.UnauthorizedError = FluidBridgeUnauthorizedError;
+exports.createCanonicalBridgeHost = createCanonicalBridgeHost;
+exports.createFluidBridge = createFluidBridge;
+exports.createFluidBridgeHost = createFluidBridgeHost;
+exports.mintAppBridgeSessionToken = mintAppBridgeSessionToken;
+exports.sessionTokenRequestFromContext = sessionTokenRequestFromContext;
+
+//# sourceMappingURL=index.cjs.map