@dp-bohrium/widget-sdk 0.0.1

package/dist/runtime-D-xKLIEj.js

@@ -0,0 +1,1121 @@
+import { r as MessagePortTransport, t as ProtocolEndpoint } from "./protocol-endpoint-CHWoXvKN.js";
+//#region src/runtime/network.ts
+const failureReasons = /* @__PURE__ */ new Set([
+	"unsupported",
+	"permission-denied",
+	"resource-limit",
+	"invalid-reference",
+	"timeout",
+	"internal-error",
+	"network-consent-denied",
+	"network-policy-denied",
+	"network-transport-unavailable",
+	"network-request-too-large",
+	"network-response-too-large",
+	"network-rate-limited",
+	"network-redirect-denied",
+	"network-credential-unavailable",
+	"network-scope-invalid",
+	"network-dns-denied",
+	"network-error"
+]);
+function createWidgetNetworkClient(dependencies) {
+	return Object.freeze({ fetch(input, options) {
+		const state = dependencies.state();
+		if (state === "disposed") return Promise.reject(/* @__PURE__ */ new Error("client is disposed"));
+		if (state !== "ready") return Promise.reject(/* @__PURE__ */ new Error("Widget network is not ready"));
+		if (!dependencies.granted()) return Promise.reject(/* @__PURE__ */ new Error("Widget network capability is not granted"));
+		return dependencies.request({
+			operation: "network.fetch",
+			input
+		}, options).then(validateNetworkResult);
+	} });
+}
+function validateNetworkResult(result) {
+	if (!isRecord$2(result) || typeof result.ok !== "boolean") invalidResult();
+	if (result.ok === false) {
+		if (!hasExactKeys$2(result, [
+			"ok",
+			"reason",
+			"message",
+			"retryable"
+		]) || !failureReasons.has(result.reason) || typeof result.message !== "string" || result.message.length === 0 || typeof result.retryable !== "boolean") invalidResult();
+		return result;
+	}
+	if (!hasExactKeys$2(result, ["ok", "data"]) || !isNetworkOutput(result.data)) invalidResult();
+	return result;
+}
+function isNetworkOutput(value) {
+	if (!hasExactKeys$2(value, [
+		"status",
+		"statusText",
+		"headers",
+		"body",
+		"bodyEncoding",
+		"finalUrl",
+		"redirected"
+	]) || !Number.isInteger(value["status"]) || Number(value["status"]) < 100 || Number(value["status"]) > 599 || typeof value["statusText"] !== "string" || !isStringRecord(value["headers"]) || typeof value["body"] !== "string" || value["bodyEncoding"] !== "utf8" && value["bodyEncoding"] !== "base64" || typeof value["finalUrl"] !== "string" || typeof value["redirected"] !== "boolean") return false;
+	try {
+		const finalUrl = new URL(value["finalUrl"]);
+		return (finalUrl.protocol === "http:" || finalUrl.protocol === "https:") && !finalUrl.username && !finalUrl.password && !finalUrl.hash;
+	} catch {
+		return false;
+	}
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+	return isRecord$2(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function hasExactKeys$2(value, keys) {
+	return isRecord$2(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function invalidResult() {
+	throw new Error("network protocol error: invalid result");
+}
+//#endregion
+//#region src/runtime/client.ts
+const PRESENTATION_CONFIRMATION_TIMEOUT_MS = 6e4;
+const presentationSurfaces = /* @__PURE__ */ new Set([
+	"workspace",
+	"floating",
+	"overlay"
+]);
+const capabilityFailureReasons = {
+	unsupported: true,
+	"permission-denied": true,
+	"resource-limit": true,
+	"invalid-reference": true,
+	timeout: true,
+	"internal-error": true,
+	"network-consent-denied": true,
+	"network-policy-denied": true,
+	"network-transport-unavailable": true,
+	"network-request-too-large": true,
+	"network-response-too-large": true,
+	"network-rate-limited": true,
+	"network-redirect-denied": true,
+	"network-credential-unavailable": true,
+	"network-scope-invalid": true,
+	"network-dns-denied": true,
+	"network-error": true
+};
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function property$1(value, key) {
+	return value[key];
+}
+function hasExactKeys$1(value, keys) {
+	const actualKeys = Object.keys(value);
+	return actualKeys.length === keys.length && keys.every((key) => actualKeys.includes(key));
+}
+function isPlainRecord(value) {
+	if (!isRecord$1(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function hasExactDescriptorKeys(descriptors, keys) {
+	return Reflect.ownKeys(descriptors).length === keys.length && keys.every((key) => Object.hasOwn(descriptors, key));
+}
+function dataDescriptorValue(descriptor, enumerable) {
+	if (descriptor === void 0 || descriptor.enumerable !== enumerable || !Object.hasOwn(descriptor, "value")) return;
+	return { value: descriptor.value };
+}
+function isGrantedPresentationSurface(value) {
+	return value === "floating" || value === "overlay";
+}
+function capturePresentationSurfaces(value) {
+	if (!Array.isArray(value)) return void 0;
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	const length = dataDescriptorValue(descriptors["length"], false)?.value;
+	if (length !== 1 && length !== 2) return void 0;
+	if (!hasExactDescriptorKeys(descriptors, ["length", ...Array.from({ length }, (_, i) => `${i}`)])) return void 0;
+	const surfaces = [];
+	for (let index = 0; index < length; index += 1) {
+		const surface = dataDescriptorValue(descriptors[`${index}`], true)?.value;
+		if (!isGrantedPresentationSurface(surface)) return void 0;
+		surfaces.push(surface);
+	}
+	if (new Set(surfaces).size !== surfaces.length) return void 0;
+	return Object.freeze(surfaces);
+}
+function captureGrantedPresentationCapability(value) {
+	try {
+		if (!isPlainRecord(value)) return void 0;
+		const descriptors = Object.getOwnPropertyDescriptors(value);
+		if (!hasExactDescriptorKeys(descriptors, [
+			"name",
+			"surfaces",
+			"requiresHostConfirmation"
+		])) return void 0;
+		const name = dataDescriptorValue(descriptors["name"], true)?.value;
+		const confirmation = dataDescriptorValue(descriptors["requiresHostConfirmation"], true)?.value;
+		const surfaceValue = dataDescriptorValue(descriptors["surfaces"], true)?.value;
+		if (name !== "ui.presentation" || confirmation !== true) return void 0;
+		const surfaces = capturePresentationSurfaces(surfaceValue);
+		if (!surfaces) return void 0;
+		return Object.freeze({
+			name,
+			surfaces,
+			requiresHostConfirmation: confirmation,
+			hasOverlay: surfaces.some((surface) => surface === "overlay")
+		});
+	} catch {
+		return;
+	}
+}
+function hasNetworkFetchGrant(capabilities) {
+	const limitKeys = [
+		"timeoutMs",
+		"maxRedirects",
+		"maxConcurrentRequests",
+		"callsPerMinute",
+		"requestHeaderBytes",
+		"responseHeaderBytes",
+		"requestBodyBytes",
+		"responseBodyBytes"
+	];
+	for (const capability of capabilities) try {
+		if (!isPlainRecord(capability)) continue;
+		const descriptors = Object.getOwnPropertyDescriptors(capability);
+		if (!hasExactDescriptorKeys(descriptors, ["name", "limits"])) continue;
+		if (dataDescriptorValue(descriptors["name"], true)?.value !== "network.fetch") continue;
+		const limits = dataDescriptorValue(descriptors["limits"], true)?.value;
+		if (!isPlainRecord(limits)) continue;
+		const limitDescriptors = Object.getOwnPropertyDescriptors(limits);
+		if (!hasExactDescriptorKeys(limitDescriptors, limitKeys)) continue;
+		if (limitKeys.every((key) => {
+			const limit = dataDescriptorValue(limitDescriptors[key], true)?.value;
+			return Number.isInteger(limit) && Number(limit) > 0;
+		})) return true;
+	} catch {}
+	return false;
+}
+function hasOverlayPresentationGrant(capabilities) {
+	for (const capability of capabilities) if (captureGrantedPresentationCapability(capability)?.hasOverlay) return true;
+	return false;
+}
+function isPresentationSurface(value) {
+	return typeof value === "string" && presentationSurfaces.has(value);
+}
+function isCapabilityFailureReason(value) {
+	return typeof value === "string" && Object.hasOwn(capabilityFailureReasons, value);
+}
+function assertPresentationResult(input, result) {
+	const action = input.action;
+	if (!isRecord$1(result) || !Object.hasOwn(result, "ok") || typeof property$1(result, "ok") !== "boolean") throw new Error(`presentation protocol error: invalid result for ${action}`);
+	if (property$1(result, "ok") === false) {
+		const message = property$1(result, "message");
+		if (hasExactKeys$1(result, [
+			"ok",
+			"reason",
+			"message",
+			"retryable"
+		]) && isCapabilityFailureReason(property$1(result, "reason")) && typeof message === "string" && message.length > 0 && typeof property$1(result, "retryable") === "boolean") return;
+		throw new Error(`presentation protocol error: invalid result for ${action}`);
+	}
+	if (!hasExactKeys$1(result, ["ok", "data"])) throw new Error(`presentation protocol error: invalid success result for ${action}`);
+	const data = property$1(result, "data");
+	let valid = false;
+	if (isRecord$1(data)) {
+		if (action === "close") valid = hasExactKeys$1(data, ["action"]) && property$1(data, "action") === action;
+		else if (action === "focus-boundary") valid = hasExactKeys$1(data, ["action", "direction"]) && property$1(data, "action") === action && property$1(data, "direction") === input.direction;
+		else valid = hasExactKeys$1(data, ["action", "surface"]) && property$1(data, "action") === action && isPresentationSurface(property$1(data, "surface"));
+	}
+	if (!valid) throw new Error(`presentation protocol error: invalid success result for ${action}`);
+}
+function requestPresentationCapability(request, capabilityRequest, options) {
+	return request(capabilityRequest, {
+		...options,
+		timeoutMs: options?.timeoutMs ?? 6e4
+	}).then((result) => {
+		assertPresentationResult(capabilityRequest.input, result);
+		return result;
+	});
+}
+function toError$1(reason, fallback) {
+	return reason instanceof Error ? reason : new Error(fallback);
+}
+function createRuntimeError(code, phase, message, correlationId) {
+	return {
+		code,
+		phase,
+		message,
+		retryable: false,
+		correlationId
+	};
+}
+const hostMessageTypes = /* @__PURE__ */ new Set([
+	"init",
+	"render",
+	"update",
+	"capability-result",
+	"error",
+	"dispose"
+]);
+function isHostToWidgetMessage(message) {
+	return hostMessageTypes.has(message.type);
+}
+var WidgetClient = class {
+	network;
+	endpoint;
+	widgetSdkVersion;
+	channelId;
+	handshakeTimeoutMs;
+	capabilityTimeoutMs;
+	createMessageId;
+	events;
+	state = "created";
+	readyPromise;
+	resolveReady;
+	rejectReady;
+	handshakeTimer;
+	instanceId;
+	renderRevision;
+	overlayPresentationGranted = false;
+	networkFetchGranted = false;
+	pending = /* @__PURE__ */ new Map();
+	hostApiVersion;
+	readySettled = false;
+	constructor(options, events = {}) {
+		this.widgetSdkVersion = options.widgetSdkVersion;
+		this.channelId = options.channelId;
+		this.hostApiVersion = options.hostApiVersion ?? 1;
+		this.handshakeTimeoutMs = options.handshakeTimeoutMs ?? 5e3;
+		this.capabilityTimeoutMs = options.capabilityTimeoutMs ?? 5e3;
+		this.createMessageId = options.createMessageId ?? (() => crypto.randomUUID());
+		this.events = events;
+		this.network = createWidgetNetworkClient({
+			state: () => this.state,
+			granted: () => this.networkFetchGranted,
+			request: (request, requestOptions) => requestOptions === void 0 ? this.requestCapability(request) : this.requestCapability(request, requestOptions)
+		});
+		this.readyPromise = new Promise((resolve, reject) => {
+			this.resolveReady = resolve;
+			this.rejectReady = reject;
+		});
+		this.endpoint = new ProtocolEndpoint({
+			transport: options.transport,
+			channelId: options.channelId,
+			createMessageId: this.createMessageId,
+			acceptsInbound: isHostToWidgetMessage,
+			onMessage: (message) => this.receive(message),
+			onError: (error) => this.handleTransportError(error)
+		});
+		this.readyPromise.catch(() => void 0);
+		this.handshakeTimer = setTimeout(() => this.failHandshake(), this.handshakeTimeoutMs);
+		if (options.initialPayload !== void 0) this.initialize(options.initialPayload);
+	}
+	get currentState() {
+		return this.state;
+	}
+	ready() {
+		return this.readyPromise;
+	}
+	resize(width, height) {
+		this.assertReady();
+		if (!Number.isFinite(width) || width < 0 || !Number.isFinite(height) || height < 0) throw new Error("resize dimensions must be finite and non-negative");
+		this.send({
+			type: "resize",
+			payload: {
+				width,
+				height
+			}
+		});
+	}
+	requestCapability(request, options = this.capabilityTimeoutMs) {
+		this.assertReady();
+		const timeoutMs = typeof options === "number" ? options : options.timeoutMs ?? this.capabilityTimeoutMs;
+		const signal = typeof options === "number" ? void 0 : options.signal;
+		const requestId = this.createMessageId();
+		if (signal?.aborted) return Promise.reject(/* @__PURE__ */ new Error(`capability request aborted: ${requestId}`));
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				const pending = this.pending.get(requestId);
+				if (!pending) return;
+				pending.removeAbortListener?.();
+				this.pending.delete(requestId);
+				reject(/* @__PURE__ */ new Error(`capability request timed out: ${requestId}`));
+			}, timeoutMs);
+			const abort = () => {
+				const pending = this.pending.get(requestId);
+				if (!pending) return;
+				clearTimeout(pending.timer);
+				pending.removeAbortListener?.();
+				this.pending.delete(requestId);
+				reject(/* @__PURE__ */ new Error(`capability request aborted: ${requestId}`));
+			};
+			const removeAbortListener = signal ? () => signal.removeEventListener("abort", abort) : void 0;
+			this.pending.set(requestId, {
+				resolve,
+				reject,
+				timer,
+				...removeAbortListener ? { removeAbortListener } : {}
+			});
+			signal?.addEventListener("abort", abort, { once: true });
+			if (signal?.aborted) {
+				abort();
+				return;
+			}
+			this.send({
+				type: "capability-request",
+				payload: {
+					requestId,
+					request
+				}
+			});
+		});
+	}
+	present(surface, options) {
+		return requestPresentationCapability((request, requestOptions) => this.requestCapability(request, requestOptions), {
+			operation: "ui.presentation",
+			input: {
+				action: "present",
+				surface
+			}
+		}, options);
+	}
+	closePresentation(options) {
+		return requestPresentationCapability((request, requestOptions) => this.requestCapability(request, requestOptions), {
+			operation: "ui.presentation",
+			input: { action: "close" }
+		}, options);
+	}
+	changePresentationSurface(surface, options) {
+		return requestPresentationCapability((request, requestOptions) => this.requestCapability(request, requestOptions), {
+			operation: "ui.presentation",
+			input: {
+				action: "change-surface",
+				surface
+			}
+		}, options);
+	}
+	focusPresentationBoundary(direction, options) {
+		if (!this.overlayPresentationGranted) return Promise.reject(/* @__PURE__ */ new Error("Overlay presentation is not granted for focus cooperation"));
+		return requestPresentationCapability((request, requestOptions) => this.requestCapability(request, requestOptions), {
+			operation: "ui.presentation",
+			input: {
+				action: "focus-boundary",
+				direction
+			}
+		}, options);
+	}
+	dispose() {
+		this.finishDispose("client-disposed");
+	}
+	finishDispose(reason, deadlineMs) {
+		if (this.state === "disposed") return;
+		const disposedBeforeReady = this.state !== "ready";
+		this.state = "disposed";
+		if (this.handshakeTimer) clearTimeout(this.handshakeTimer);
+		if (disposedBeforeReady || !this.readySettled) {
+			this.readySettled = true;
+			this.rejectReady(/* @__PURE__ */ new Error(`client disposed before ready: ${reason}`));
+		}
+		this.rejectPendingCapabilities();
+		this.endpoint.close();
+		this.events.onDispose?.(reason, deadlineMs);
+	}
+	rejectPendingCapabilities() {
+		for (const [requestId, pending] of this.pending) {
+			clearTimeout(pending.timer);
+			pending.removeAbortListener?.();
+			pending.reject(/* @__PURE__ */ new Error(`client disposed: ${requestId}`));
+		}
+		this.pending.clear();
+	}
+	receive(message) {
+		if (this.state === "disposed") return;
+		if (message.type === "init") this.initialize(message.payload);
+		else if (message.type === "render" || message.type === "update") {
+			if (this.state !== "ready") return;
+			if (!this.acceptsRender(message.type, message.payload)) return;
+			const isUpdate = message.type === "update";
+			this.events.onRender?.(message.payload, isUpdate);
+			if (isUpdate) this.events.onUpdate?.(message.payload);
+		} else if (message.type === "capability-result") {
+			const pending = this.pending.get(message.payload.requestId);
+			if (!pending) return;
+			clearTimeout(pending.timer);
+			pending.removeAbortListener?.();
+			this.pending.delete(message.payload.requestId);
+			pending.resolve(message.payload.result);
+		} else if (message.type === "error") this.events.onError?.(message.payload);
+		else if (message.type === "dispose") this.finishDispose(message.payload.reason, message.payload.deadlineMs);
+	}
+	initialize(payload) {
+		if (this.state !== "created") return;
+		this.state = "waiting-ready";
+		this.instanceId = payload.instanceId;
+		this.overlayPresentationGranted = hasOverlayPresentationGrant(payload.capabilities);
+		this.networkFetchGranted = hasNetworkFetchGrant(payload.capabilities);
+		this.initializeAsync(payload);
+	}
+	async initializeAsync(payload) {
+		try {
+			await this.events.onInit?.(payload);
+			if (this.currentState !== "waiting-ready") return;
+			this.state = "ready";
+			if (this.handshakeTimer) clearTimeout(this.handshakeTimer);
+			this.send({
+				type: "ready",
+				payload: {
+					widgetSdkVersion: this.widgetSdkVersion,
+					hostApiVersion: this.hostApiVersion
+				}
+			});
+			if (!this.readySettled) {
+				this.readySettled = true;
+				this.resolveReady();
+			}
+		} catch (reason) {
+			if (this.state === "disposed") return;
+			this.failHandshake(toError$1(reason, "widget initialization failed"), "initialization-failed", "WIDGET_CRASHED");
+		}
+	}
+	send(message) {
+		this.endpoint.send(message);
+	}
+	assertUsable() {
+		if (this.state === "disposed") throw new Error("client is disposed");
+	}
+	acceptsRender(type, request) {
+		if (request.instanceId !== this.instanceId) return false;
+		if (type === "render") {
+			if (this.renderRevision !== void 0 || request.revision !== 1) return false;
+		} else if (this.renderRevision === void 0 || request.revision <= this.renderRevision) return false;
+		this.renderRevision = request.revision;
+		return true;
+	}
+	assertReady() {
+		this.assertUsable();
+		if (this.state !== "ready") throw new Error("client is not ready");
+	}
+	handleTransportError(_reason) {
+		if (this.state === "disposed") return;
+		const error = createRuntimeError("MESSAGE_INVALID", this.state === "ready" ? "render" : "handshake", "Host sent an invalid protocol message", this.instanceId ?? this.channelId);
+		this.failWithError(/* @__PURE__ */ new Error("invalid widget protocol message"), error, "invalid-message");
+	}
+	failHandshake(reason = /* @__PURE__ */ new Error("widget handshake timed out"), disposeReason = "handshake-timeout", code = "HANDSHAKE_TIMEOUT") {
+		if (this.readySettled || this.state === "disposed") return;
+		const error = createRuntimeError(code, "handshake", code === "WIDGET_CRASHED" ? "Widget initialization failed" : "Widget handshake timed out", this.instanceId ?? this.channelId);
+		this.failWithError(reason, error, disposeReason);
+	}
+	failWithError(reason, error, disposeReason) {
+		if (this.state === "disposed") return;
+		this.state = "disposed";
+		if (this.handshakeTimer) clearTimeout(this.handshakeTimer);
+		if (!this.readySettled) {
+			this.readySettled = true;
+			this.rejectReady(reason);
+		}
+		this.rejectPendingCapabilities();
+		this.endpoint.close();
+		try {
+			this.events.onError?.(error);
+		} catch {}
+		try {
+			this.events.onDispose?.(disposeReason);
+		} catch {}
+	}
+};
+//#endregion
+//#region src/runtime/event-validation.ts
+const NAME = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
+const MAX_BATCH_BYTES = 256e3;
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function keys(value, required, optional = []) {
+	return required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+}
+function id(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= 256;
+}
+function json(value, depth = 0, ancestors = /* @__PURE__ */ new Set()) {
+	if (depth > 32) return false;
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	if (!Array.isArray(value) && Object.prototype.toString.call(value) !== "[object Object]") return false;
+	ancestors.add(value);
+	const ok = Object.values(value).every((item) => json(item, depth + 1, ancestors));
+	ancestors.delete(value);
+	return ok;
+}
+function parseWidgetEventBatch(value) {
+	if (!record(value) || !keys(value, [
+		"schemaVersion",
+		"topic",
+		"cursor",
+		"reset",
+		"hasMore",
+		"events"
+	], ["snapshot"]) || value["schemaVersion"] !== 1 || typeof value["topic"] !== "string" || !NAME.test(value["topic"]) || !id(value["cursor"]) || typeof value["reset"] !== "boolean" || typeof value["hasMore"] !== "boolean" || !Array.isArray(value["events"]) || value["events"].length > 100 || !json(value)) throw new Error("Invalid Widget event batch");
+	for (const event of value["events"]) if (!record(event) || !keys(event, [
+		"id",
+		"type",
+		"payload"
+	]) || !id(event["id"]) || typeof event["type"] !== "string" || !NAME.test(event["type"])) throw new Error("Invalid Widget event");
+	if (new TextEncoder().encode(JSON.stringify(value)).byteLength > MAX_BATCH_BYTES) throw new Error("Widget event batch exceeds budget");
+	return value;
+}
+function parseToolLifecycleEvent(value) {
+	if (!record(value) || !keys(value, [
+		"toolCallId",
+		"toolName",
+		"phase"
+	]) || !id(value["toolCallId"]) || typeof value["toolName"] !== "string" || !/^[A-Za-z0-9_.:-]{1,128}$/.test(value["toolName"]) || ![
+		"started",
+		"completed",
+		"failed",
+		"cancelled"
+	].includes(String(value["phase"]))) throw new Error("Invalid tool lifecycle event");
+	return value;
+}
+//#endregion
+//#region src/runtime/events.ts
+const MAX_SEEN_EVENTS = 256;
+/** 游标仅在消费者处理成功后推进；取消和失败都释放本实例的读取与计时器。 */
+function subscribeToWidgetEvents(options) {
+	const controller = new AbortController();
+	const seen = /* @__PURE__ */ new Set();
+	let cursor = options.cursor;
+	let timer;
+	let finish;
+	const closed = new Promise((resolve) => {
+		finish = resolve;
+	});
+	function unsubscribe() {
+		if (controller.signal.aborted) return;
+		controller.abort();
+		if (timer) clearTimeout(timer);
+		seen.clear();
+		finish();
+	}
+	function fail(reason) {
+		if (controller.signal.aborted) return;
+		unsubscribe();
+		try {
+			options.onError(reason instanceof Error ? reason : /* @__PURE__ */ new Error("Widget event subscription failed"));
+		} catch {}
+	}
+	async function read(grant) {
+		try {
+			const response = await options.request({
+				operation: "events.read",
+				input: {
+					topic: options.topic,
+					limit: grant.limits.pageSize,
+					...cursor === void 0 ? {} : { cursor }
+				}
+			}, { signal: controller.signal });
+			if (controller.signal.aborted) return;
+			if (response !== null && typeof response === "object" && "ok" in response && response.ok === false && "reason" in response && "message" in response && typeof response.reason === "string" && typeof response.message === "string") throw new Error(`Widget event read failed (${response.reason}): ${response.message.slice(0, 256)}`);
+			if (response === null || typeof response !== "object" || !("ok" in response) || response.ok !== true || !("data" in response)) throw new Error("Host denied or failed the event read");
+			const batch = parseWidgetEventBatch(response.data);
+			if (batch.topic !== options.topic || batch.events.length > grant.limits.pageSize) throw new Error("Host event scope or page limit mismatch");
+			if (!batch.reset && batch.cursor === cursor && (batch.hasMore || batch.events.length > 0)) throw new Error("Host event cursor did not advance");
+			if (batch.reset) seen.clear();
+			const events = batch.events.filter((event) => {
+				if (seen.has(event.id)) return false;
+				seen.add(event.id);
+				return true;
+			});
+			await options.onBatch({
+				...batch,
+				events
+			}, { signal: controller.signal });
+			if (controller.signal.aborted) return;
+			cursor = batch.cursor;
+			while (seen.size > MAX_SEEN_EVENTS) {
+				const first = seen.values().next().value;
+				if (first !== void 0) seen.delete(first);
+			}
+			timer = setTimeout(() => {
+				read(grant);
+			}, Math.max(grant.limits.minPollMs, Math.ceil(6e4 / grant.limits.callsPerMinute)));
+		} catch (error) {
+			fail(error);
+		}
+	}
+	options.grant().then((grant) => {
+		if (controller.signal.aborted) return;
+		if (!grant?.topics.includes(options.topic) || !Number.isSafeInteger(grant.limits.pageSize) || grant.limits.pageSize < 1 || grant.limits.pageSize > 100 || !Number.isSafeInteger(grant.limits.minPollMs) || grant.limits.minPollMs < 1e3 || grant.limits.minPollMs > 6e4 || !Number.isSafeInteger(grant.limits.callsPerMinute) || grant.limits.callsPerMinute < 1) throw new Error("Widget event topic is not granted");
+		return read(grant);
+	}).catch(fail);
+	return {
+		get cursor() {
+			return cursor;
+		},
+		closed,
+		unsubscribe
+	};
+}
+/** 工具 Hook 是执行事实的观察者；不得用浏览器回调替代服务端执行门禁。 */
+function toolHookHandlers(hooks) {
+	return async (batch, context = { signal: new AbortController().signal }) => {
+		if (context?.signal.aborted) return;
+		if (batch.reset) await hooks.onReset?.(batch.snapshot, context);
+		for (const event of batch.events) {
+			if (context?.signal.aborted) return;
+			if (event.type !== "tool.lifecycle") continue;
+			const payload = parseToolLifecycleEvent(event.payload);
+			if (hooks.toolName && payload.toolName !== hooks.toolName || hooks.toolCallId && payload.toolCallId !== hooks.toolCallId) continue;
+			if (payload.phase === "started") await hooks.onToolCall?.(payload, context);
+			else if (payload.phase === "completed") await hooks.onToolResult?.(payload, context);
+			else if (payload.phase === "failed") await hooks.onToolError?.(payload, context);
+			else await hooks.onToolCancelled?.(payload, context);
+		}
+	};
+}
+/** 实例内所有订阅共用授权额度；FIFO 防止后来的订阅抢占先到的读取。 */
+function createWidgetEventReadScheduler() {
+	const queue = [];
+	const lastPollByTopic = /* @__PURE__ */ new Map();
+	let nextReadAt = 0;
+	let timer;
+	function pump() {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+		const first = queue[0];
+		if (!first) return;
+		const now = Date.now();
+		const previous = lastPollByTopic.get(first.topic);
+		const eligibleAt = Math.max(nextReadAt, previous === void 0 ? now : previous + first.grant.limits.minPollMs);
+		if (eligibleAt > now) {
+			timer = setTimeout(pump, eligibleAt - now);
+			return;
+		}
+		queue.shift();
+		nextReadAt = now + Math.ceil(6e4 / first.grant.limits.callsPerMinute);
+		lastPollByTopic.set(first.topic, now);
+		first.run();
+		pump();
+	}
+	return { schedule(topic, grant, signal, read) {
+		return new Promise((resolve, reject) => {
+			if (signal.aborted) {
+				reject(/* @__PURE__ */ new Error("Widget event read aborted"));
+				return;
+			}
+			if (!Number.isSafeInteger(grant.limits.callsPerMinute) || grant.limits.callsPerMinute < 1 || !Number.isSafeInteger(grant.limits.minPollMs) || grant.limits.minPollMs < 1e3 || grant.limits.minPollMs > 6e4 || !grant.topics.includes(topic)) {
+				reject(/* @__PURE__ */ new Error("Widget event topic is not granted"));
+				return;
+			}
+			const pending = {
+				topic,
+				grant,
+				run: () => {
+					signal.removeEventListener("abort", abort);
+					Promise.resolve().then(() => {
+						if (signal.aborted) throw new Error("Widget event read aborted");
+						return read();
+					}).then(resolve, reject);
+				}
+			};
+			const abort = () => {
+				const index = queue.indexOf(pending);
+				if (index < 0) return;
+				queue.splice(index, 1);
+				signal.removeEventListener("abort", abort);
+				reject(/* @__PURE__ */ new Error("Widget event read aborted"));
+				pump();
+			};
+			signal.addEventListener("abort", abort, { once: true });
+			queue.push(pending);
+			pump();
+		});
+	} };
+}
+//#endregion
+//#region src/runtime/presentation-keyboard.ts
+function isCrossDocumentDeparture(target, relatedTarget) {
+	if (relatedTarget === null) return true;
+	if (typeof relatedTarget !== "object") return false;
+	return Reflect.get(relatedTarget, "ownerDocument") !== target.document;
+}
+function createPresentationKeyboardAdapter(options) {
+	let disposed = false;
+	let pendingTab;
+	const requests = /* @__PURE__ */ new Set();
+	const invoke = (request) => {
+		if (disposed) return;
+		const controller = new AbortController();
+		requests.add(controller);
+		Promise.resolve().then(() => request({ signal: controller.signal })).catch(() => void 0).finally(() => requests.delete(controller));
+	};
+	const onKeyDown = (event) => {
+		pendingTab = void 0;
+		if (!event.isTrusted || event.isComposing || event.repeat) return;
+		if (event.key === "Escape") {
+			queueMicrotask(() => {
+				if (!event.defaultPrevented) invoke((requestOptions) => options.close(requestOptions));
+			});
+			return;
+		}
+		if (event.key === "Tab") {
+			const tab = {
+				event,
+				direction: event.shiftKey ? "backward" : "forward"
+			};
+			pendingTab = tab;
+			queueMicrotask(() => {
+				if (pendingTab === tab) pendingTab = void 0;
+			});
+		}
+	};
+	const onFocusOut = (event) => {
+		const tab = pendingTab;
+		pendingTab = void 0;
+		if (!tab || tab.event.defaultPrevented || !isCrossDocumentDeparture(options.target, event.relatedTarget)) return;
+		invoke((requestOptions) => options.focusBoundary(tab.direction, requestOptions));
+	};
+	options.target.addEventListener("keydown", onKeyDown);
+	options.target.addEventListener("focusout", onFocusOut);
+	return { dispose() {
+		if (disposed) return;
+		disposed = true;
+		pendingTab = void 0;
+		options.target.removeEventListener("keydown", onKeyDown);
+		options.target.removeEventListener("focusout", onFocusOut);
+		for (const controller of requests) controller.abort();
+		requests.clear();
+	} };
+}
+//#endregion
+//#region src/runtime/bootstrap.ts
+const WIDGET_BOOTSTRAP_READY = "widget-bootstrap-ready";
+const WIDGET_HOST_CONNECT = "widget-host-connect";
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function property(value, key) {
+	return value[key];
+}
+function hasExactKeys(value, keys) {
+	const actualKeys = Object.keys(value);
+	return actualKeys.length === keys.length && keys.every((key) => actualKeys.includes(key));
+}
+function isInitPayload(value) {
+	if (!isRecord(value)) return false;
+	const instanceId = property(value, "instanceId");
+	const locale = property(value, "locale");
+	const theme = property(value, "theme");
+	const capabilities = property(value, "capabilities");
+	const resourceBudget = property(value, "resourceBudget");
+	return hasExactKeys(value, [
+		"instanceId",
+		"locale",
+		"theme",
+		"capabilities",
+		"resourceBudget"
+	]) && typeof instanceId === "string" && instanceId.length > 0 && typeof locale === "string" && locale.length > 0 && isRecord(theme) && Array.isArray(capabilities) && isRecord(resourceBudget);
+}
+function isWidgetHostConnectMessage(value) {
+	if (!isRecord(value)) return false;
+	const type = property(value, "type");
+	const protocolVersion = property(value, "protocolVersion");
+	const channelId = property(value, "channelId");
+	const initPayload = property(value, "initPayload");
+	return hasExactKeys(value, [
+		"type",
+		"protocolVersion",
+		"channelId",
+		"initPayload"
+	]) && type === "widget-host-connect" && protocolVersion === 1 && typeof channelId === "string" && channelId.length >= 16 && isInitPayload(initPayload);
+}
+function defaultWindow() {
+	if (typeof window === "undefined") throw new Error("createWidgetClient requires a browser window");
+	return window;
+}
+function createEvents(options) {
+	const base = options.events;
+	const events = {};
+	if (base?.onInit || options.onInit) events.onInit = async (payload) => {
+		await base?.onInit?.(payload);
+		await options.onInit?.(payload);
+	};
+	if (base?.onRender || base?.onUpdate || options.onRender || options.onUpdate) events.onRender = (request, update) => {
+		base?.onRender?.(request, update);
+		if (update) {
+			options.onUpdate?.(request);
+			if (!options.onUpdate) options.onRender?.(request);
+		} else {
+			options.onRender?.(request);
+			if (!options.onRender) options.onUpdate?.(request);
+		}
+	};
+	if (base?.onUpdate) events.onUpdate = base.onUpdate;
+	if (base?.onError || options.onError) events.onError = (error) => {
+		base?.onError?.(error);
+		options.onError?.(error);
+	};
+	if (base?.onDispose || options.onDispose) events.onDispose = (reason, deadlineMs) => {
+		base?.onDispose?.(reason, deadlineMs);
+		options.onDispose?.({
+			reason,
+			...deadlineMs === void 0 ? {} : { deadlineMs }
+		});
+	};
+	return events;
+}
+function cloneGrantedCapabilities(capabilities) {
+	const cloned = [];
+	for (const capability of capabilities) try {
+		cloned.push(structuredClone(capability));
+	} catch {}
+	return cloned;
+}
+/**
+* High-level Widget-side runtime. It hides bootstrap postMessage and the
+* transferred MessagePort from Widget application code.
+*/
+var WidgetRuntimeClient = class {
+	network;
+	runtimeWindow;
+	options;
+	events;
+	messageListener;
+	readyPromise;
+	resolveReady;
+	rejectReady;
+	readySettled = false;
+	connectionTimer;
+	client;
+	state = "created";
+	disposed = false;
+	capabilities = [];
+	overlayPresentationGranted = false;
+	subscriptions = /* @__PURE__ */ new Set();
+	eventReads = createWidgetEventReadScheduler();
+	eventReadsLifetime = new AbortController();
+	presentationKeyboard;
+	constructor(options) {
+		this.options = options;
+		this.runtimeWindow = options.window ?? defaultWindow();
+		const userEvents = createEvents(options);
+		this.events = {
+			...userEvents,
+			onInit: async (payload) => {
+				this.overlayPresentationGranted = hasOverlayPresentationGrant(payload.capabilities);
+				this.capabilities = cloneGrantedCapabilities(payload.capabilities);
+				await userEvents.onInit?.(payload);
+			},
+			onDispose: (reason, deadlineMs) => {
+				this.stopSubscriptions();
+				this.stopPresentationKeyboard();
+				userEvents.onDispose?.(reason, deadlineMs);
+			}
+		};
+		const network = { fetch: (input, requestOptions) => {
+			if (this.currentState === "disposed") return Promise.reject(/* @__PURE__ */ new Error("client is disposed"));
+			if (this.currentState !== "ready") return Promise.reject(/* @__PURE__ */ new Error("Widget network is not ready"));
+			return this.requireClient().network.fetch(input, requestOptions);
+		} };
+		this.network = Object.freeze(network);
+		this.readyPromise = new Promise((resolve, reject) => {
+			this.resolveReady = resolve;
+			this.rejectReady = reject;
+		});
+		this.messageListener = (event) => this.receiveConnection(event);
+		this.runtimeWindow.addEventListener("message", this.messageListener);
+		this.connectionTimer = setTimeout(() => this.failConnection(/* @__PURE__ */ new Error("widget connection timed out")), options.connectionTimeoutMs ?? options.handshakeTimeoutMs ?? 5e3);
+		try {
+			this.runtimeWindow.parent.postMessage({
+				type: WIDGET_BOOTSTRAP_READY,
+				protocolVersion: 1
+			}, "*");
+		} catch (reason) {
+			this.failConnection(reason instanceof Error ? reason : /* @__PURE__ */ new Error("failed to send widget bootstrap message"));
+		}
+	}
+	get currentState() {
+		return this.client?.currentState ?? this.state;
+	}
+	ready() {
+		return this.readyPromise;
+	}
+	resize(widthOrSize, height) {
+		const client = this.requireClient();
+		if (typeof widthOrSize === "number") {
+			if (height === void 0) throw new Error("height is required when resize uses numeric arguments");
+			client.resize(widthOrSize, height);
+			return;
+		}
+		client.resize(widthOrSize.width, widthOrSize.height);
+	}
+	requestCapability(request, timeoutMs) {
+		return this.readyPromise.then(() => {
+			const client = this.requireClient();
+			const invoke = () => timeoutMs === void 0 ? client.requestCapability(request) : client.requestCapability(request, timeoutMs);
+			if (request.operation !== "events.read") return invoke();
+			const grant = this.capabilities.find((capability) => capability.name === "events.read");
+			if (!grant) throw new Error("Widget event topic is not granted");
+			const signal = typeof timeoutMs === "object" ? timeoutMs.signal : void 0;
+			return this.eventReads.schedule(request.input.topic, grant, signal ? AbortSignal.any([signal, this.eventReadsLifetime.signal]) : this.eventReadsLifetime.signal, invoke);
+		});
+	}
+	present(surface, options) {
+		return requestPresentationCapability((request, requestOptions) => this.requestCapability(request, requestOptions), {
+			operation: "ui.presentation",
+			input: {
+				action: "present",
+				surface
+			}
+		}, options);
+	}
+	closePresentation(options) {
+		return requestPresentationCapability((request, requestOptions) => this.requestCapability(request, requestOptions), {
+			operation: "ui.presentation",
+			input: { action: "close" }
+		}, options);
+	}
+	changePresentationSurface(surface, options) {
+		return requestPresentationCapability((request, requestOptions) => this.requestCapability(request, requestOptions), {
+			operation: "ui.presentation",
+			input: {
+				action: "change-surface",
+				surface
+			}
+		}, options);
+	}
+	focusPresentationBoundary(direction, options) {
+		return this.readyPromise.then(() => this.requireClient().focusPresentationBoundary(direction, options));
+	}
+	subscribeEvents(options) {
+		const subscription = subscribeToWidgetEvents({
+			...options,
+			grant: async () => {
+				await this.readyPromise;
+				this.requireClient();
+				return this.capabilities.find((grant) => grant.name === "events.read");
+			},
+			request: (request, requestOptions) => this.requestCapability(request, requestOptions)
+		});
+		this.subscriptions.add(subscription);
+		subscription.closed.then(() => this.subscriptions.delete(subscription));
+		if (this.disposed || this.currentState === "disposed") subscription.unsubscribe();
+		return subscription;
+	}
+	onTool(hooks, options) {
+		return this.subscribeEvents({
+			...options,
+			topic: "tools.lifecycle",
+			onBatch: toolHookHandlers(hooks)
+		});
+	}
+	async invokeAction(input, options) {
+		await this.readyPromise;
+		if (!this.capabilities.find((capability) => capability.name === "actions.invoke")?.actions.includes(input.action)) throw new Error("Widget action is not granted");
+		return this.requestCapability({
+			operation: "actions.invoke",
+			input
+		}, options);
+	}
+	stopSubscriptions() {
+		this.eventReadsLifetime.abort();
+		for (const subscription of this.subscriptions) subscription.unsubscribe();
+		this.subscriptions.clear();
+	}
+	startPresentationKeyboard() {
+		if (this.presentationKeyboard || !this.overlayPresentationGranted) return;
+		const target = presentationKeyboardTarget(this.runtimeWindow);
+		if (!target) return;
+		this.presentationKeyboard = createPresentationKeyboardAdapter({
+			target,
+			close: (requestOptions) => this.closePresentation(requestOptions),
+			focusBoundary: (direction, requestOptions) => this.focusPresentationBoundary(direction, requestOptions)
+		});
+	}
+	stopPresentationKeyboard() {
+		this.presentationKeyboard?.dispose();
+		this.presentationKeyboard = void 0;
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.stopSubscriptions();
+		this.stopPresentationKeyboard();
+		this.state = "disposed";
+		this.removeConnectionListener();
+		if (this.connectionTimer) clearTimeout(this.connectionTimer);
+		if (this.client) {
+			this.client.dispose();
+			this.rejectBeforeReady(/* @__PURE__ */ new Error("client disposed"));
+		} else {
+			this.rejectBeforeReady(/* @__PURE__ */ new Error("client disposed"));
+			this.events.onDispose?.("client-disposed");
+		}
+	}
+	receiveConnection(event) {
+		if (this.disposed || this.client) return;
+		if (event.source !== this.runtimeWindow.parent) return;
+		if (this.options.expectedHostOrigin !== void 0 && event.origin !== this.options.expectedHostOrigin) return;
+		if (!isWidgetHostConnectMessage(event.data)) return;
+		const port = event.ports?.[0];
+		if (!port) return;
+		this.removeConnectionListener();
+		try {
+			const clientOptions = {
+				transport: new MessagePortTransport(port),
+				channelId: event.data.channelId,
+				widgetSdkVersion: this.options.widgetSdkVersion,
+				initialPayload: event.data.initPayload,
+				...this.options.hostApiVersion === void 0 ? {} : { hostApiVersion: this.options.hostApiVersion },
+				...this.options.capabilityTimeoutMs === void 0 ? {} : { capabilityTimeoutMs: this.options.capabilityTimeoutMs },
+				...this.options.handshakeTimeoutMs === void 0 ? {} : { handshakeTimeoutMs: this.options.handshakeTimeoutMs },
+				...this.options.createMessageId === void 0 ? {} : { createMessageId: this.options.createMessageId }
+			};
+			this.client = new WidgetClient(clientOptions, this.events);
+			this.state = this.client.currentState;
+			this.client.ready().then(() => {
+				if (this.readySettled) return;
+				this.startPresentationKeyboard();
+				this.readySettled = true;
+				this.resolveReady();
+			}).catch((reason) => this.failConnection(toError(reason)));
+		} catch (reason) {
+			this.failConnection(toError(reason));
+		}
+	}
+	requireClient() {
+		if (this.disposed) throw new Error("client is disposed");
+		if (!this.client) throw new Error("widget host connection is not ready");
+		return this.client;
+	}
+	removeConnectionListener() {
+		this.runtimeWindow.removeEventListener("message", this.messageListener);
+		if (this.connectionTimer) clearTimeout(this.connectionTimer);
+	}
+	failConnection(reason) {
+		if (this.disposed || this.readySettled) return;
+		this.disposed = true;
+		this.stopSubscriptions();
+		this.stopPresentationKeyboard();
+		this.state = "disposed";
+		this.removeConnectionListener();
+		this.client?.dispose();
+		this.rejectBeforeReady(reason);
+	}
+	rejectBeforeReady(reason) {
+		if (this.readySettled) return;
+		this.readySettled = true;
+		this.rejectReady(reason);
+	}
+};
+function toError(reason) {
+	return reason instanceof Error ? reason : /* @__PURE__ */ new Error("widget runtime failed");
+}
+function presentationKeyboardTarget(runtimeWindow) {
+	const candidate = runtimeWindow;
+	if (candidate.document === void 0 || typeof candidate.addEventListener !== "function" || typeof candidate.removeEventListener !== "function") return void 0;
+	return candidate;
+}
+function createWidgetClient(options) {
+	return new WidgetRuntimeClient(options);
+}
+//#endregion
+export { isWidgetHostConnectMessage as a, createWidgetClient as i, WIDGET_HOST_CONNECT as n, PRESENTATION_CONFIRMATION_TIMEOUT_MS as o, WidgetRuntimeClient as r, WidgetClient as s, WIDGET_BOOTSTRAP_READY as t };