@happyvertical/smrt-chat 0.42.6 → 0.42.7

package/dist/chunks/data-surface-bridge-BJomMxjS.js

@@ -0,0 +1,740 @@
+import { DATA_SURFACE_IDENTIFIER_MAX_LENGTH, DATA_SURFACE_MAX_REQUEST_BYTES } from "@happyvertical/smrt-ui/data-surface";
+//#region src/data-surface-normalizer.ts
+var MAX_QUERY_LIMIT = 1e3;
+var MAX_JSON_DEPTH = 16;
+var MAX_JSON_CONTAINER_ITEMS = 1e3;
+var PROTOTYPE_POLLUTION_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+var FORBIDDEN_BOUNDARY_KEYS = /* @__PURE__ */ new Set([
+	"tenant",
+	"tenantid",
+	"principalid",
+	"principal",
+	"actorid",
+	"auth",
+	"authtoken",
+	"authorization",
+	"authorizationtoken",
+	"authorizationheader",
+	"authentication",
+	"authenticationtoken",
+	"accesstoken",
+	"token",
+	"bearer",
+	"bearertoken",
+	"apikey",
+	"sessiontoken",
+	"credential",
+	"credentials",
+	"sql",
+	"rawsql",
+	"rawquery",
+	"where"
+]);
+var KINDS = /* @__PURE__ */ new Set([
+	"table",
+	"list",
+	"report",
+	"custom"
+]);
+var SENSITIVITIES = /* @__PURE__ */ new Set([
+	"public",
+	"personal",
+	"sensitive",
+	"secret"
+]);
+var CAPABILITIES = /* @__PURE__ */ new Set([
+	"read",
+	"search",
+	"filter",
+	"sort",
+	"project"
+]);
+var QUERY_MODES = /* @__PURE__ */ new Set([
+	"rows",
+	"count",
+	"facets"
+]);
+var SELECTION_SCOPES = /* @__PURE__ */ new Set([
+	"current-page",
+	"explicit-ids",
+	"all-matching"
+]);
+function plainObject(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype) throw new TypeError(`${label} must be a plain object`);
+	return value;
+}
+function exactKeys(value, allowed, label) {
+	const accepted = new Set(allowed);
+	for (const key of Object.keys(value)) if (!accepted.has(key)) throw new TypeError(`${label} contains unsupported field: ${key}`);
+}
+function stringValue(value, label) {
+	if (typeof value !== "string" || value.length === 0) throw new TypeError(`${label} must be a non-empty string`);
+	return value;
+}
+function identifierValue(value, label) {
+	const result = stringValue(value, label);
+	if (result.length > DATA_SURFACE_IDENTIFIER_MAX_LENGTH) throw new TypeError(`${label} is too long`);
+	return result;
+}
+function positiveInteger(value, label) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${label} must be a positive safe integer`);
+	return value;
+}
+function revisionNumber(value) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new TypeError("DataSurface revision must be a non-negative integer");
+	return value;
+}
+function addBytes(budget, bytes) {
+	if (!budget) return;
+	if (bytes > budget.limit - budget.used) throw new TypeError(`DataSurface envelope cannot exceed ${budget.limit} UTF-8 bytes`);
+	budget.used += bytes;
+}
+function jsonStringByteLength(value, budget) {
+	let bytes = 2;
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit === 34 || codeUnit === 92) bytes += 2;
+		else if (codeUnit === 8 || codeUnit === 9 || codeUnit === 10 || codeUnit === 12 || codeUnit === 13) bytes += 2;
+		else if (codeUnit <= 31) bytes += 6;
+		else if (codeUnit >= 55296 && codeUnit <= 56319) {
+			const next = value.charCodeAt(index + 1);
+			if (next >= 56320 && next <= 57343) {
+				bytes += 4;
+				index += 1;
+			} else bytes += 6;
+		} else if (codeUnit >= 56320 && codeUnit <= 57343) bytes += 6;
+		else if (codeUnit <= 127) bytes += 1;
+		else if (codeUnit <= 2047) bytes += 2;
+		else bytes += 3;
+		if (budget && bytes > budget.limit - budget.used) throw new TypeError(`DataSurface envelope cannot exceed ${budget.limit} UTF-8 bytes`);
+	}
+	addBytes(budget, bytes);
+	return bytes;
+}
+function canonicalJson(value, ancestors = /* @__PURE__ */ new Set(), depth = 0, budget) {
+	if (depth > MAX_JSON_DEPTH) throw new TypeError(`DataSurface values cannot exceed ${MAX_JSON_DEPTH} levels`);
+	if (value === null) {
+		addBytes(budget, 4);
+		return null;
+	}
+	if (typeof value === "string") {
+		jsonStringByteLength(value, budget);
+		return value;
+	}
+	if (typeof value === "boolean") {
+		addBytes(budget, value ? 4 : 5);
+		return value;
+	}
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new TypeError("DataSurface values cannot contain non-finite numbers");
+		const normalized = value === 0 ? 0 : value;
+		addBytes(budget, String(normalized).length);
+		return normalized;
+	}
+	if (!value || typeof value !== "object") throw new TypeError("DataSurface values must be JSON-safe plain data");
+	if (ancestors.has(value)) throw new TypeError("DataSurface values cannot be circular");
+	ancestors.add(value);
+	try {
+		if (Array.isArray(value)) {
+			if (value.length > MAX_JSON_CONTAINER_ITEMS) throw new TypeError("DataSurface arrays contain too many items");
+			addBytes(budget, 1);
+			const clone2 = [];
+			for (const [index, entry] of value.entries()) {
+				if (index > 0) addBytes(budget, 1);
+				clone2.push(canonicalJson(entry, ancestors, depth + 1, budget));
+			}
+			addBytes(budget, 1);
+			return clone2;
+		}
+		const object = plainObject(value, "DataSurface value");
+		const clone = {};
+		const keys = Object.keys(object).sort();
+		if (keys.length > MAX_JSON_CONTAINER_ITEMS) throw new TypeError("DataSurface objects contain too many keys");
+		addBytes(budget, 1);
+		for (const [index, key] of keys.entries()) {
+			if (index > 0) addBytes(budget, 1);
+			if (PROTOTYPE_POLLUTION_KEYS.has(key)) throw new TypeError(`DataSurface values cannot contain prototype key: ${key}`);
+			jsonStringByteLength(key, budget);
+			addBytes(budget, 1);
+			clone[key] = canonicalJson(object[key], ancestors, depth + 1, budget);
+		}
+		addBytes(budget, 1);
+		return clone;
+	} finally {
+		ancestors.delete(value);
+	}
+}
+function assertRequestByteLimit(value) {
+	canonicalJson(value, /* @__PURE__ */ new Set(), 0, {
+		used: 0,
+		limit: DATA_SURFACE_MAX_REQUEST_BYTES
+	});
+}
+function assertDataSurfaceEnvelope(value) {
+	assertRequestByteLimit(value);
+}
+function boundarySafe(value) {
+	const clone = canonicalJson(value);
+	const inspect = (entry) => {
+		if (Array.isArray(entry)) for (const item of entry) inspect(item);
+		else if (entry && typeof entry === "object") for (const [key, item] of Object.entries(entry)) {
+			if (FORBIDDEN_BOUNDARY_KEYS.has(key.replaceAll(/[-_]/g, "").toLowerCase())) throw new TypeError(`DataSurface boundary field is forbidden: ${key}`);
+			inspect(item);
+		}
+	};
+	inspect(clone);
+	return clone;
+}
+function boundarySafeObject(value) {
+	const clone = boundarySafe(value);
+	if (!clone || Array.isArray(clone) || typeof clone !== "object") throw new TypeError("DataSurface snapshot state must be an object");
+	return clone;
+}
+function normalizeIdentity(value) {
+	const object = plainObject(value, "DataSurface identity");
+	exactKeys(object, [
+		"surfaceId",
+		"kind",
+		"subject"
+	], "DataSurface identity");
+	const kind = stringValue(object.kind, "DataSurface kind");
+	if (!KINDS.has(kind)) throw new TypeError(`Unsupported DataSurface kind: ${kind}`);
+	let subject;
+	if (object.subject !== void 0) {
+		const source = plainObject(object.subject, "DataSurface subject");
+		exactKeys(source, [
+			"type",
+			"id",
+			"label"
+		], "DataSurface subject");
+		subject = {
+			type: identifierValue(source.type, "DataSurface subject type"),
+			id: identifierValue(source.id, "DataSurface subject id"),
+			...source.label === void 0 ? {} : { label: stringValue(source.label, "DataSurface subject label") }
+		};
+	}
+	return {
+		surfaceId: identifierValue(object.surfaceId, "DataSurface surface id"),
+		kind,
+		...subject ? { subject } : {}
+	};
+}
+function normalizeStringArray(value, label, sort = false) {
+	if (!Array.isArray(value) || value.length > MAX_JSON_CONTAINER_ITEMS) throw new TypeError(`${label} must be a bounded array`);
+	const values = value.map((entry) => stringValue(entry, label));
+	if (new Set(values).size !== values.length) throw new TypeError(`${label} cannot contain duplicates`);
+	return sort ? values.sort() : values;
+}
+function normalizeIdentifierArray(value, label, sort = false) {
+	return normalizeStringArray(value, label, sort).map((entry) => identifierValue(entry, label));
+}
+function normalizeSensitivity(value, label) {
+	if (value === void 0) return void 0;
+	const sensitivity = stringValue(value, label);
+	if (!SENSITIVITIES.has(sensitivity)) throw new TypeError(`Unsupported DataSurface sensitivity: ${sensitivity}`);
+	return sensitivity;
+}
+function normalizeSelection(value) {
+	const object = plainObject(value, "DataSurface selection");
+	const scope = stringValue(object.scope, "DataSurface selection scope");
+	if (!SELECTION_SCOPES.has(scope)) throw new TypeError(`Unsupported DataSurface selection scope: ${scope}`);
+	if (scope === "current-page") {
+		exactKeys(object, ["scope"], "DataSurface current-page selection");
+		return { scope };
+	}
+	if (scope === "explicit-ids") {
+		exactKeys(object, ["scope", "rowIds"], "DataSurface explicit selection");
+		if (!Array.isArray(object.rowIds) || object.rowIds.length > MAX_JSON_CONTAINER_ITEMS) throw new TypeError("DataSurface explicit selection rowIds must be bounded");
+		const rowIds = /* @__PURE__ */ new Map();
+		for (const rowId of object.rowIds) {
+			if (typeof rowId !== "string" && (typeof rowId !== "number" || !Number.isFinite(rowId))) throw new TypeError("DataSurface row ids must be finite strings or numbers");
+			const normalized = typeof rowId === "string" ? identifierValue(rowId, "DataSurface row id") : rowId === 0 ? 0 : rowId;
+			rowIds.set(`${typeof normalized}:${String(normalized)}`, normalized);
+		}
+		return {
+			scope,
+			rowIds: [...rowIds.values()].sort((left, right) => {
+				if (typeof left !== typeof right) return typeof left === "number" ? -1 : 1;
+				if (typeof left === "number" && typeof right === "number") return left - right;
+				return left < right ? -1 : left > right ? 1 : 0;
+			})
+		};
+	}
+	exactKeys(object, ["scope", "queryFingerprint"], "DataSurface all-matching selection");
+	return {
+		scope,
+		queryFingerprint: identifierValue(object.queryFingerprint, "DataSurface query fingerprint")
+	};
+}
+function normalizeDataSurfaceDescriptor(value) {
+	const object = plainObject(value, "DataSurface descriptor");
+	exactKeys(object, [
+		"version",
+		"identity",
+		"schemaVersion",
+		"label",
+		"description",
+		"rowKey",
+		"columns",
+		"query",
+		"controls",
+		"actions",
+		"limits"
+	], "DataSurface descriptor");
+	if (object.version !== 1) throw new TypeError("Unsupported DataSurface descriptor version");
+	if (!Array.isArray(object.columns) || object.columns.length > MAX_JSON_CONTAINER_ITEMS) throw new TypeError("DataSurface descriptor columns must be bounded");
+	const columns = object.columns.map((value2) => {
+		const column = plainObject(value2, "DataSurface column");
+		exactKeys(column, [
+			"id",
+			"label",
+			"description",
+			"sensitivity",
+			"capabilities"
+		], "DataSurface column");
+		const capabilities = normalizeStringArray(column.capabilities, "DataSurface column capabilities", true);
+		if (capabilities.some((capability) => !CAPABILITIES.has(capability))) throw new TypeError("Unsupported DataSurface column capability");
+		return {
+			id: identifierValue(column.id, "DataSurface column id"),
+			label: stringValue(column.label, "DataSurface column label"),
+			...column.description === void 0 ? {} : { description: stringValue(column.description, "DataSurface column description") },
+			...column.sensitivity === void 0 ? {} : { sensitivity: normalizeSensitivity(column.sensitivity, "DataSurface column sensitivity") },
+			capabilities
+		};
+	});
+	if (new Set(columns.map((column) => column.id)).size !== columns.length) throw new TypeError("DataSurface descriptor column ids must be unique");
+	const query = plainObject(object.query, "DataSurface query capabilities");
+	exactKeys(query, ["modes", "projectableColumnIds"], "DataSurface query capabilities");
+	const modes = normalizeStringArray(query.modes, "DataSurface query modes", true);
+	if (modes.some((mode) => !QUERY_MODES.has(mode))) throw new TypeError("Unsupported DataSurface query mode");
+	const projectableColumnIds = normalizeIdentifierArray(query.projectableColumnIds, "DataSurface projectable column ids", true);
+	const knownColumns = new Set(columns.map((column) => column.id));
+	if (projectableColumnIds.some((columnId) => !knownColumns.has(columnId))) throw new TypeError("Unknown projectable DataSurface column");
+	if (!Array.isArray(object.controls) || object.controls.length > MAX_JSON_CONTAINER_ITEMS) throw new TypeError("DataSurface controls must be bounded");
+	const controls = object.controls.map((value2) => {
+		const control = plainObject(value2, "DataSurface control");
+		exactKeys(control, [
+			"id",
+			"label",
+			"description"
+		], "DataSurface control");
+		return {
+			id: identifierValue(control.id, "DataSurface control id"),
+			label: stringValue(control.label, "DataSurface control label"),
+			...control.description === void 0 ? {} : { description: stringValue(control.description, "DataSurface control description") }
+		};
+	});
+	if (new Set(controls.map((control) => control.id)).size !== controls.length) throw new TypeError("DataSurface control ids must be unique");
+	if (!Array.isArray(object.actions) || object.actions.length > MAX_JSON_CONTAINER_ITEMS) throw new TypeError("DataSurface actions must be bounded");
+	const actions = object.actions.map((value2) => {
+		const action = plainObject(value2, "DataSurface action");
+		exactKeys(action, [
+			"id",
+			"label",
+			"description",
+			"sensitivity",
+			"selectionScopes",
+			"requiresConfirmation"
+		], "DataSurface action");
+		if (action.requiresConfirmation !== void 0 && typeof action.requiresConfirmation !== "boolean") throw new TypeError("DataSurface action requiresConfirmation must be boolean");
+		const selectionScopes = normalizeStringArray(action.selectionScopes, "DataSurface action selection scopes", true);
+		if (selectionScopes.some((scope) => !SELECTION_SCOPES.has(scope))) throw new TypeError("Unsupported DataSurface action selection scope");
+		return {
+			id: identifierValue(action.id, "DataSurface action id"),
+			label: stringValue(action.label, "DataSurface action label"),
+			...action.description === void 0 ? {} : { description: stringValue(action.description, "DataSurface action description") },
+			...action.sensitivity === void 0 ? {} : { sensitivity: normalizeSensitivity(action.sensitivity, "DataSurface action sensitivity") },
+			selectionScopes,
+			...action.requiresConfirmation === void 0 ? {} : { requiresConfirmation: action.requiresConfirmation }
+		};
+	});
+	if (new Set(actions.map((action) => action.id)).size !== actions.length) throw new TypeError("DataSurface action ids must be unique");
+	const limits = plainObject(object.limits, "DataSurface limits");
+	exactKeys(limits, [
+		"maxQueryRows",
+		"maxQueryBytes",
+		"maxSelectionSize"
+	], "DataSurface limits");
+	const maxQueryRows = positiveInteger(limits.maxQueryRows, "DataSurface maxQueryRows");
+	if (maxQueryRows > MAX_QUERY_LIMIT) throw new TypeError("DataSurface maxQueryRows exceeds its limit");
+	const rowKey = identifierValue(object.rowKey, "DataSurface row key");
+	if (!knownColumns.has(rowKey)) throw new TypeError("DataSurface rowKey must name a declared column");
+	return {
+		version: 1,
+		identity: normalizeIdentity(object.identity),
+		schemaVersion: positiveInteger(object.schemaVersion, "DataSurface schema version"),
+		label: stringValue(object.label, "DataSurface label"),
+		...object.description === void 0 ? {} : { description: stringValue(object.description, "DataSurface description") },
+		rowKey,
+		columns,
+		query: {
+			modes,
+			projectableColumnIds
+		},
+		controls,
+		actions,
+		limits: {
+			maxQueryRows,
+			maxQueryBytes: positiveInteger(limits.maxQueryBytes, "DataSurface maxQueryBytes"),
+			maxSelectionSize: positiveInteger(limits.maxSelectionSize, "DataSurface maxSelectionSize")
+		}
+	};
+}
+function normalizeDataSurfaceSnapshot(value) {
+	const object = plainObject(value, "DataSurface snapshot");
+	exactKeys(object, [
+		"version",
+		"descriptor",
+		"revision",
+		"state",
+		"selection"
+	], "DataSurface snapshot");
+	if (object.version !== 1) throw new TypeError("Unsupported DataSurface snapshot version");
+	return {
+		version: 1,
+		descriptor: normalizeDataSurfaceDescriptor(object.descriptor),
+		revision: revisionNumber(object.revision),
+		state: boundarySafeObject(object.state),
+		selection: object.selection === null || object.selection === void 0 ? null : normalizeSelection(object.selection)
+	};
+}
+function normalizeDataSurfaceVisibleCommand(value) {
+	const object = plainObject(value, "DataSurface visible command");
+	exactKeys(object, [
+		"version",
+		"commandId",
+		"identity",
+		"expectedRevision",
+		"controlId",
+		"payload"
+	], "DataSurface visible command");
+	if (object.version !== 1) throw new TypeError("Unsupported DataSurface visible command version");
+	const normalized = {
+		version: 1,
+		commandId: identifierValue(object.commandId, "DataSurface command id"),
+		identity: normalizeIdentity(object.identity),
+		expectedRevision: revisionNumber(object.expectedRevision),
+		controlId: identifierValue(object.controlId, "DataSurface control id"),
+		...object.payload === void 0 ? {} : { payload: boundarySafe(object.payload) }
+	};
+	assertRequestByteLimit(value);
+	assertRequestByteLimit(normalized);
+	return normalized;
+}
+//#endregion
+//#region src/data-surface-bridge.ts
+var DATA_SURFACE_BRIDGE_VERSION = 1;
+var DEFAULT_DATA_SURFACE_BRIDGE_TTL_MS = 3e4;
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isString(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= DATA_SURFACE_IDENTIFIER_MAX_LENGTH;
+}
+function isDisplayString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isPeer(value) {
+	return isRecord(value) && isString(value.sessionId) && isString(value.source);
+}
+function isFiniteInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value);
+}
+function isFailureReason(value) {
+	return value === "not_found" || value === "unsupported" || value === "stale_revision" || value === "idempotency_conflict" || value === "denied" || value === "execution_failed" || value === "non_monotonic_revision" || value === "expired" || value === "timeout" || value === "disconnected" || value === "invalid_request" || value === "source_mismatch" || value === "session_mismatch" || value === "replay_capacity_exceeded";
+}
+function isCommandResultReason(value) {
+	return value === "not_found" || value === "unsupported" || value === "stale_revision" || value === "idempotency_conflict" || value === "denied" || value === "execution_failed" || value === "non_monotonic_revision";
+}
+function identityOf(value) {
+	if (!isRecord(value) || !isString(value.surfaceId) || !isString(value.kind)) return void 0;
+	if (value.kind !== "table" && value.kind !== "list" && value.kind !== "report" && value.kind !== "custom") return void 0;
+	let subject;
+	if (value.subject !== void 0) {
+		if (!isRecord(value.subject) || !isString(value.subject.type) || !isString(value.subject.id) || value.subject.label !== void 0 && !isDisplayString(value.subject.label)) return;
+		subject = {
+			type: value.subject.type,
+			id: value.subject.id,
+			...value.subject.label === void 0 ? {} : { label: value.subject.label }
+		};
+	}
+	return {
+		surfaceId: value.surfaceId,
+		kind: value.kind,
+		...subject ? { subject } : {}
+	};
+}
+function identitySignature(identity) {
+	return JSON.stringify({
+		surfaceId: identity.surfaceId,
+		kind: identity.kind,
+		...identity.subject ? { subject: {
+			type: identity.subject.type,
+			id: identity.subject.id
+		} } : {}
+	});
+}
+function snapshotOf(value) {
+	try {
+		assertDataSurfaceEnvelope(value);
+		return normalizeDataSurfaceSnapshot(value);
+	} catch {
+		return;
+	}
+}
+function isAck(value) {
+	return Boolean(isRecord(value) && value.type === "data-surface.ack" && value.version === 1 && isString(value.commandId) && isString(value.sessionId) && isString(value.source) && typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt) && identityOf(value.identity) && typeof value.expectedRevision === "number" && Number.isSafeInteger(value.expectedRevision) && value.expectedRevision >= 0 && typeof value.ok === "boolean");
+}
+function isEvent(value) {
+	return Boolean(isRecord(value) && value.type === "data-surface.event" && value.version === 1 && isString(value.sessionId) && isString(value.source) && typeof value.sequence === "number" && Number.isSafeInteger(value.sequence) && value.sequence > 0 && identityOf(value.identity) && typeof value.revision === "number" && Number.isSafeInteger(value.revision) && value.revision >= 0 && (value.event === "registered" || value.event === "unregistered" || value.event === "command"));
+}
+function resultOf(value) {
+	if (!isRecord(value) || typeof value.ok !== "boolean") return void 0;
+	const allowed = /* @__PURE__ */ new Set([
+		"ok",
+		"commandId",
+		"identity",
+		"revision",
+		"snapshot",
+		"reason"
+	]);
+	if (Object.keys(value).some((key) => !allowed.has(key))) return void 0;
+	if (!isString(value.commandId)) return void 0;
+	const identity = identityOf(value.identity);
+	if (!identity) return void 0;
+	if (value.revision !== void 0 && (!isFiniteInteger(value.revision) || value.revision < 0)) return;
+	if (value.ok) {
+		if (value.reason !== void 0) return void 0;
+	} else if (!isCommandResultReason(value.reason)) return;
+	let snapshot;
+	if (value.snapshot !== void 0) {
+		snapshot = snapshotOf(value.snapshot);
+		if (!snapshot) return void 0;
+		if (identitySignature(snapshot.descriptor.identity) !== identitySignature(identity) || value.revision !== void 0 && snapshot.revision !== value.revision) return;
+	}
+	return {
+		ok: value.ok,
+		commandId: value.commandId,
+		identity,
+		...value.revision === void 0 ? {} : { revision: value.revision },
+		...snapshot === void 0 ? {} : { snapshot },
+		...value.reason === void 0 ? {} : { reason: value.reason }
+	};
+}
+function eventOf(value) {
+	if (!isEvent(value)) return void 0;
+	try {
+		assertDataSurfaceEnvelope(value);
+		const identity = identityOf(value.identity);
+		if (!identity) return void 0;
+		let command;
+		if (value.command !== void 0) command = normalizeDataSurfaceVisibleCommand(value.command);
+		const result = value.result === void 0 ? void 0 : resultOf(value.result);
+		if (value.result !== void 0 && result === void 0) return void 0;
+		if (value.event === "command" && (!command || !result)) return void 0;
+		if (value.event !== "command" && (command || result)) return void 0;
+		if (value.event === "command" && (result?.revision === void 0 || value.revision !== result.revision || result.ok && result.revision < (command?.expectedRevision ?? 0))) return;
+		if (command && identitySignature(command.identity) !== identitySignature(identity) || result && (identitySignature(result.identity) !== identitySignature(identity) || command !== void 0 && result.commandId !== command.commandId)) return;
+		return {
+			type: "data-surface.event",
+			version: 1,
+			sessionId: value.sessionId,
+			source: value.source,
+			sequence: value.sequence,
+			identity,
+			revision: value.revision,
+			...command === void 0 ? {} : { command },
+			...result === void 0 ? {} : { result },
+			event: value.event
+		};
+	} catch {
+		return;
+	}
+}
+function fallbackAck(command, sessionId, source, reason, expiresAt) {
+	return {
+		type: "data-surface.ack",
+		version: 1,
+		commandId: command.commandId,
+		sessionId,
+		source,
+		expiresAt,
+		identity: command.identity,
+		expectedRevision: command.expectedRevision,
+		ok: false,
+		reason
+	};
+}
+function commandSignature(command) {
+	return JSON.stringify(command);
+}
+function createDataSurfaceCommandBridge(options) {
+	if (!isString(options.sessionId) || !isString(options.source) || !isString(options.peerSource)) throw new TypeError("DataSurface bridge session/source ids are required");
+	const now = options.now ?? (() => Date.now());
+	const ttlMs = options.ttlMs ?? 3e4;
+	const timeoutMs = options.timeoutMs ?? ttlMs;
+	if (!Number.isSafeInteger(ttlMs) || ttlMs <= 0 || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > ttlMs) throw new RangeError("Invalid DataSurface bridge bounds");
+	const pending = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let state = "connected";
+	let disposed = false;
+	let lastSequence = 0;
+	const rejectPending = (reason) => {
+		for (const [commandId, item] of pending) {
+			clearTimeout(item.timer);
+			pending.delete(commandId);
+			inflight.delete(commandId);
+			item.resolve(fallbackAck(item.command, options.sessionId, options.peerSource, reason, item.expiresAt));
+		}
+	};
+	const validateAck = (value, item) => {
+		const request = item.request;
+		if (value.commandId !== request.commandId || value.sessionId !== request.sessionId || value.source !== options.peerSource || value.expiresAt !== request.expiresAt || value.expectedRevision !== request.expectedRevision || identitySignature(value.identity) !== identitySignature(request.identity)) return;
+		if (value.revision !== void 0 && (!isFiniteInteger(value.revision) || value.revision < 0)) return;
+		if (value.ok) {
+			if (value.reason !== void 0 || value.revision === void 0 || value.snapshot === void 0 || value.ok && value.revision < request.expectedRevision) return;
+		} else if (!isFailureReason(value.reason)) return;
+		let snapshot;
+		if (value.snapshot !== void 0) {
+			snapshot = snapshotOf(value.snapshot);
+			if (snapshot === void 0) return void 0;
+			if (identitySignature(snapshot.descriptor.identity) !== identitySignature(request.identity) || value.ok && snapshot.revision < request.expectedRevision || value.revision !== void 0 && snapshot.revision !== value.revision) return;
+		}
+		return {
+			type: "data-surface.ack",
+			version: 1,
+			commandId: request.commandId,
+			sessionId: request.sessionId,
+			source: options.peerSource,
+			expiresAt: request.expiresAt,
+			identity: request.identity,
+			expectedRevision: request.expectedRevision,
+			ok: value.ok,
+			...value.revision === void 0 ? {} : { revision: value.revision },
+			...snapshot === void 0 ? {} : { snapshot },
+			...value.reason === void 0 ? {} : { reason: value.reason }
+		};
+	};
+	const receive = (value, peer) => {
+		if (disposed || !isPeer(peer) || peer.sessionId !== options.sessionId || peer.source !== options.peerSource) return;
+		if (isAck(value)) {
+			if (value.sessionId !== options.sessionId || value.source !== options.peerSource) return;
+			const item = pending.get(value.commandId);
+			if (!item) return;
+			const validated = validateAck(value, item);
+			if (!validated) return;
+			pending.delete(value.commandId);
+			inflight.delete(value.commandId);
+			clearTimeout(item.timer);
+			if (value.expiresAt <= now()) item.resolve(fallbackAck(item.command, options.sessionId, options.peerSource, "expired", item.expiresAt));
+			else item.resolve(validated);
+			return;
+		}
+		const event = eventOf(value);
+		if (!event) return;
+		if (event.sessionId !== options.sessionId || event.source !== options.peerSource || event.sequence <= lastSequence) return;
+		lastSequence = event.sequence;
+		for (const listener of listeners) listener(event);
+	};
+	const unsubscribeTransport = options.transport.subscribe(receive);
+	const unsubscribeStatus = options.transport.subscribeStatus?.((next) => {
+		state = next;
+		if (next === "disconnected") rejectPending("disconnected");
+	});
+	const send = async (command) => {
+		let normalized;
+		try {
+			normalized = normalizeDataSurfaceVisibleCommand(command);
+		} catch {
+			return fallbackAck(command, options.sessionId, options.peerSource, "invalid_request", now());
+		}
+		if (disposed || state !== "connected") return fallbackAck(normalized, options.sessionId, options.peerSource, "disconnected", now());
+		let allowed = false;
+		try {
+			allowed = await options.authorize(normalized);
+		} catch {
+			allowed = false;
+		}
+		if (disposed || state !== "connected") return fallbackAck(normalized, options.sessionId, options.peerSource, "disconnected", now());
+		if (!allowed) return fallbackAck(normalized, options.sessionId, options.peerSource, "denied", now());
+		const signature = commandSignature(normalized);
+		const existing = inflight.get(normalized.commandId);
+		if (existing) return existing.signature === signature ? existing.promise : fallbackAck(normalized, options.sessionId, options.peerSource, "idempotency_conflict", now());
+		const expiresAt = now() + ttlMs;
+		const promise = new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				if (!pending.delete(normalized.commandId)) return;
+				inflight.delete(normalized.commandId);
+				resolve(fallbackAck(normalized, options.sessionId, options.peerSource, "timeout", expiresAt));
+			}, timeoutMs);
+			const request = {
+				type: "data-surface.command",
+				version: 1,
+				commandId: normalized.commandId,
+				sessionId: options.sessionId,
+				source: options.source,
+				expiresAt,
+				identity: normalized.identity,
+				expectedRevision: normalized.expectedRevision,
+				controlId: normalized.controlId,
+				...normalized.payload === void 0 ? {} : { payload: normalized.payload }
+			};
+			pending.set(normalized.commandId, {
+				command: normalized,
+				request,
+				expiresAt,
+				resolve,
+				timer
+			});
+			const handleSendFailure = () => {
+				if (!pending.delete(normalized.commandId)) return;
+				inflight.delete(normalized.commandId);
+				clearTimeout(timer);
+				resolve(fallbackAck(normalized, options.sessionId, options.peerSource, "disconnected", expiresAt));
+			};
+			try {
+				Promise.resolve(options.transport.send(request)).catch(handleSendFailure);
+			} catch {
+				handleSendFailure();
+			}
+		});
+		inflight.set(normalized.commandId, {
+			signature,
+			promise
+		});
+		if (!pending.has(normalized.commandId)) inflight.delete(normalized.commandId);
+		return promise;
+	};
+	return {
+		sessionId: options.sessionId,
+		source: options.source,
+		get state() {
+			return state;
+		},
+		send,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			unsubscribeTransport();
+			unsubscribeStatus?.();
+			rejectPending("disconnected");
+			inflight.clear();
+			listeners.clear();
+		}
+	};
+}
+var createServerDataSurfaceBridge = createDataSurfaceCommandBridge;
+var createDataSurfaceBridge = createDataSurfaceCommandBridge;
+//#endregion
+export { createServerDataSurfaceBridge as a, createDataSurfaceCommandBridge as i, DEFAULT_DATA_SURFACE_BRIDGE_TTL_MS as n, createDataSurfaceBridge as r, DATA_SURFACE_BRIDGE_VERSION as t };
+
+//# sourceMappingURL=data-surface-bridge-BJomMxjS.js.map