@deepseek-harness-tui/dsh-tui 0.8.0 → 0.8.2

package/vendor/dsh-std/packages/command/node_modules/@dsh-std/presentation/lib/index.js

@@ -0,0 +1,550 @@
+import { EXTERNAL_REDIRECT_KIND, externalRedirectClient, externalRedirectImplementation, externalRedirectProtocol, externalRedirectSupport, validateExternalRedirectReady, validateExternalRedirectRequest, validateExternalRedirectResult } from "./callback.js";
+import { defineCapabilityProtocol } from "@dsh-std/connection";
+//#region src/index.ts
+const API_VERSION = "presentation.dsh/v1alpha1";
+const OPEN_EXTERNAL_KIND = "OpenExternal";
+const COPY_TEXT_KIND = "CopyText";
+const NOTIFICATION_KIND = "Notification";
+const USER_INTERACTION_KIND = "UserInteraction";
+const emptySpec = (value) => {
+	if (value !== void 0) throw new TypeError("Presentation operation does not accept spec in v1alpha1");
+};
+const openExternalProtocol = defineCapabilityProtocol({
+	apiVersion: API_VERSION,
+	kind: OPEN_EXTERNAL_KIND,
+	validateRequirement: emptySpec,
+	validateSupport: emptySpec
+});
+const copyTextProtocol = defineCapabilityProtocol({
+	apiVersion: API_VERSION,
+	kind: COPY_TEXT_KIND,
+	validateRequirement: emptySpec,
+	validateSupport: emptySpec
+});
+const notificationProtocol = defineCapabilityProtocol({
+	apiVersion: API_VERSION,
+	kind: NOTIFICATION_KIND,
+	validateRequirement: emptySpec,
+	validateSupport: emptySpec
+});
+const openExternalSupport = Object.freeze({
+	apiVersion: API_VERSION,
+	kind: OPEN_EXTERNAL_KIND
+});
+const copyTextSupport = Object.freeze({
+	apiVersion: API_VERSION,
+	kind: COPY_TEXT_KIND
+});
+const notificationSupport = Object.freeze({
+	apiVersion: API_VERSION,
+	kind: NOTIFICATION_KIND
+});
+const userInteractionSupport = (spec) => Object.freeze({
+	apiVersion: API_VERSION,
+	kind: USER_INTERACTION_KIND,
+	spec: validateUserInteractionSupport(spec)
+});
+const userInteractionProtocol = Object.freeze({
+	apiVersion: API_VERSION,
+	kind: USER_INTERACTION_KIND,
+	validateRequirement: validateUserInteractionRequirement,
+	validateSupport: validateUserInteractionSupport,
+	negotiate: negotiateUserInteraction
+});
+const protocols = Object.freeze([
+	openExternalProtocol,
+	copyTextProtocol,
+	notificationProtocol,
+	userInteractionProtocol,
+	externalRedirectProtocol
+]);
+function register(catalog) {
+	const disposers = protocols.map((protocol) => catalog.register(protocol));
+	return () => {
+		for (const dispose of disposers.reverse()) dispose();
+	};
+}
+function openExternalClient(client, scope) {
+	const request = requestFactory(scope);
+	return Object.freeze({ async openExternal(input, options) {
+		const value = request(input);
+		validateOpenExternalRequest(value);
+		return validatePresentationResult(await client.invoke(openExternalSupport, "openExternal", value, options).result, validateAcceptedReceipt, "OpenExternal result");
+	} });
+}
+function copyTextClient(client, scope) {
+	const request = requestFactory(scope);
+	return Object.freeze({ async copyText(input, options) {
+		const value = request(input);
+		validateCopyTextRequest(value);
+		return validatePresentationResult(await client.invoke(copyTextSupport, "copyText", value, options).result, validateAcceptedReceipt, "CopyText result");
+	} });
+}
+function notificationClient(client, scope) {
+	const request = requestFactory(scope);
+	return Object.freeze({ async notify(input, options) {
+		const value = request(input);
+		validateNotificationRequest(value);
+		return validatePresentationResult(await client.invoke(notificationSupport, "notify", value, options).result, validateAcceptedReceipt, "Notification result");
+	} });
+}
+function userInteractionClient(client, scope) {
+	const request = requestFactory(scope);
+	return Object.freeze({ async interact(input, options) {
+		const value = request(input);
+		validateUserInteractionRequest(value);
+		return validateInteractionResult(value, await client.invoke({
+			apiVersion: API_VERSION,
+			kind: USER_INTERACTION_KIND
+		}, "interact", value, options).result);
+	} });
+}
+function presentationClients(descriptor, client, scope) {
+	validatePresentationDescriptor(descriptor);
+	validateInvocationScope(scope);
+	const has = (kind) => descriptor.contracts.some((contract) => contract.apiVersion === "presentation.dsh/v1alpha1" && contract.kind === kind && client.binding(contract) !== void 0);
+	return Object.freeze({
+		descriptor: freezeClone(descriptor),
+		...has("OpenExternal") ? { openExternal: openExternalClient(client, scope) } : {},
+		...has("CopyText") ? { copyText: copyTextClient(client, scope) } : {},
+		...has("Notification") ? { notification: notificationClient(client, scope) } : {},
+		...has("UserInteraction") ? { interaction: userInteractionClient(client, scope) } : {},
+		...has("ExternalRedirect") ? { externalRedirect: externalRedirectClient(client, scope) } : {}
+	});
+}
+function openExternalImplementation(participantId, handler) {
+	return implementation(participantId, openExternalSupport, "openExternal", validateOpenExternalRequest, handler.openExternal.bind(handler), (result) => validatePresentationResult(result, validateAcceptedReceipt, "OpenExternal result"));
+}
+function copyTextImplementation(participantId, handler) {
+	return implementation(participantId, copyTextSupport, "copyText", validateCopyTextRequest, handler.copyText.bind(handler), (result) => validatePresentationResult(result, validateAcceptedReceipt, "CopyText result"));
+}
+function notificationImplementation(participantId, handler) {
+	return implementation(participantId, notificationSupport, "notify", validateNotificationRequest, handler.notify.bind(handler), (result) => validatePresentationResult(result, validateAcceptedReceipt, "Notification result"));
+}
+function userInteractionImplementation(participantId, spec, handler) {
+	const protocol = userInteractionSupport(spec);
+	return Object.freeze({
+		participantId,
+		protocol,
+		async handle(operationName, input, context) {
+			if (operationName !== "interact") throw new TypeError(`unsupported UserInteraction operation ${JSON.stringify(operationName)}`);
+			validateUserInteractionRequest(input);
+			if (!spec.operations.includes(input.kind)) throw new TypeError(`UserInteraction provider does not support ${JSON.stringify(input.kind)}`);
+			return validateInteractionResult(input, await handler.interact(input, context));
+		}
+	});
+}
+function validatePresentationDescriptor(value) {
+	const descriptor = exactRecord(value, ["clientId", "contracts"], ["clientId", "contracts"], "Presentation descriptor");
+	nonEmpty(descriptor.clientId, "Presentation descriptor.clientId");
+	if (!Array.isArray(descriptor.contracts)) throw new TypeError("Presentation descriptor.contracts must be an array");
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, contractValue] of descriptor.contracts.entries()) {
+		const contract = exactRecord(contractValue, [
+			"apiVersion",
+			"kind",
+			"spec"
+		], ["apiVersion", "kind"], `Presentation descriptor.contracts[${index}]`);
+		nonEmpty(contract.apiVersion, `Presentation descriptor.contracts[${index}].apiVersion`);
+		nonEmpty(contract.kind, `Presentation descriptor.contracts[${index}].kind`);
+		const key = `${String(contract.apiVersion)}\0${String(contract.kind)}`;
+		if (seen.has(key)) throw new TypeError(`Presentation descriptor contains duplicate contract ${JSON.stringify(key)}`);
+		seen.add(key);
+	}
+}
+function validateOpenExternalRequest(value) {
+	const request = requestRecord(value, ["uri"], "OpenExternal request");
+	nonEmpty(request.uri, "OpenExternal request.uri");
+	const uri = new URL(request.uri);
+	if (uri.protocol !== "https:" && uri.protocol !== "http:") throw new TypeError("OpenExternal only accepts HTTP(S) URIs");
+}
+function validateCopyTextRequest(value) {
+	const request = requestRecord(value, ["text", "sensitivity"], "CopyText request");
+	nonEmpty(request.text, "CopyText request.text");
+	if (request.sensitivity !== void 0 && request.sensitivity !== "public" && request.sensitivity !== "private") throw new TypeError("CopyText request.sensitivity is invalid");
+}
+function validateNotificationRequest(value) {
+	const request = requestRecord(value, [
+		"text",
+		"level",
+		"deduplicationKey"
+	], "Notification request");
+	nonEmpty(request.text, "Notification request.text");
+	if (request.level !== void 0 && request.level !== "info" && request.level !== "warning" && request.level !== "error") throw new TypeError("Notification request.level is invalid");
+	if (request.deduplicationKey !== void 0) nonEmpty(request.deduplicationKey, "Notification request.deduplicationKey");
+}
+function validateUserInteractionRequest(value) {
+	if (!record(value)) throw new TypeError("UserInteraction request must be an object");
+	if (value.kind === "question") return validateQuestionRequest(value);
+	if (value.kind === "approval") return validateApprovalRequest(value);
+	if (value.kind === "secret-input") return validateSecretInputRequest(value);
+	throw new TypeError("UserInteraction request.kind is invalid");
+}
+function validateUserInteractionRequirement(value) {
+	const spec = exactRecord(value, ["operations", "optionalOperations"], ["operations"], "UserInteraction requirement spec");
+	const operations = operationList(spec.operations, "UserInteraction requirement spec.operations");
+	const optionalOperations = spec.optionalOperations === void 0 ? void 0 : operationList(spec.optionalOperations, "UserInteraction requirement spec.optionalOperations");
+	if (optionalOperations?.some((operation) => operations.includes(operation)) === true) throw new TypeError("UserInteraction optionalOperations must not duplicate required operations");
+	return deepFreeze({
+		operations,
+		...optionalOperations === void 0 ? {} : { optionalOperations }
+	});
+}
+function validateUserInteractionSupport(value) {
+	const spec = exactRecord(value, ["operations", "limits"], ["operations"], "UserInteraction support spec");
+	const operations = operationList(spec.operations, "UserInteraction support spec.operations");
+	const limits = spec.limits === void 0 ? void 0 : validateLimits(spec.limits);
+	return deepFreeze({
+		operations,
+		...limits === void 0 ? {} : { limits }
+	});
+}
+function negotiateUserInteraction(input) {
+	const issues = [];
+	const bindings = [];
+	const connectionPolicy = connectionNegotiationPolicy(input.policy);
+	for (const row of input.requirements) {
+		const consumerEndpoint = connectionPolicy?.endpointByParticipant[row.participant];
+		const candidates = input.supports.filter((candidate) => {
+			if (candidate.participant === row.participant) return false;
+			if (consumerEndpoint !== void 0 && connectionPolicy?.endpointByParticipant[candidate.participant] === consumerEndpoint) return false;
+			return row.requirement.spec.operations.every((operation) => candidate.support.spec.operations.includes(operation));
+		});
+		if (candidates.length === 0) {
+			issues.push(Object.freeze({
+				code: row.requirement.optional === true ? "optional-support-missing" : "required-support-missing",
+				severity: row.requirement.optional === true ? "warning" : "error",
+				participant: row.participant,
+				message: `no participant supports the required ${USER_INTERACTION_KIND} operations`
+			}));
+			continue;
+		}
+		if (candidates.length > 1) {
+			issues.push(Object.freeze({
+				code: "support-ambiguous",
+				severity: "error",
+				participant: row.participant,
+				message: `multiple participants support ${API_VERSION} ${USER_INTERACTION_KIND}`
+			}));
+			continue;
+		}
+		const provider = candidates[0];
+		bindings.push(Object.freeze({
+			consumer: row.participant,
+			provider: provider.participant,
+			requirement: row.requirement,
+			support: provider.support
+		}));
+		for (const operation of row.requirement.spec.optionalOperations ?? []) {
+			if (provider.support.spec.operations.includes(operation)) continue;
+			issues.push(Object.freeze({
+				code: "optional-operation-missing",
+				severity: "warning",
+				participant: row.participant,
+				message: `${USER_INTERACTION_KIND} provider does not support optional operation ${JSON.stringify(operation)}`
+			}));
+		}
+	}
+	return {
+		agreement: Object.freeze({
+			kind: "CapabilityBindings",
+			bindings: Object.freeze(bindings)
+		}),
+		issues: Object.freeze(issues)
+	};
+}
+function connectionNegotiationPolicy(value) {
+	return record(value) && record(value.endpointByParticipant) ? value : void 0;
+}
+function implementation(participantId, protocol, operationName, validateInput, handler, validateOutput) {
+	return Object.freeze({
+		participantId,
+		protocol,
+		async handle(operation, input, context) {
+			if (operation !== operationName) throw new TypeError(`unsupported ${protocol.kind} operation ${JSON.stringify(operation)}`);
+			validateInput(input);
+			return validateOutput(await handler(input, context));
+		}
+	});
+}
+function validateQuestionRequest(value) {
+	const request = requestRecord(value, [
+		"kind",
+		"title",
+		"description",
+		"fields"
+	], "Question request");
+	if (request.kind !== "question") throw new TypeError("Question request.kind must be \"question\"");
+	optionalText(request.title, "Question request.title");
+	optionalText(request.description, "Question request.description");
+	if (!Array.isArray(request.fields) || request.fields.length === 0) throw new TypeError("Question request.fields must be a non-empty array");
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, fieldValue] of request.fields.entries()) {
+		const label = `Question request.fields[${index}]`;
+		if (!record(fieldValue)) throw new TypeError(`${label} must be an object`);
+		const common = [
+			"id",
+			"kind",
+			"label",
+			"description",
+			"required"
+		];
+		const field = exactRecord(fieldValue, fieldValue.kind === "text" ? [
+			...common,
+			"multiline",
+			"minLength",
+			"maxLength"
+		] : fieldValue.kind === "select" ? [
+			...common,
+			"multiple",
+			"options"
+		] : common, [
+			"id",
+			"kind",
+			"label"
+		], label);
+		localId(field.id, `${label}.id`);
+		if (ids.has(field.id)) throw new TypeError("Question request contains duplicate field id");
+		ids.add(field.id);
+		nonEmpty(field.label, `${label}.label`);
+		optionalText(field.description, `${label}.description`);
+		optionalBoolean(field.required, `${label}.required`);
+		if (field.kind === "text") {
+			optionalBoolean(field.multiline, `${label}.multiline`);
+			lengthBounds(field.minLength, field.maxLength, label);
+		} else if (field.kind === "select") {
+			optionalBoolean(field.multiple, `${label}.multiple`);
+			if (!Array.isArray(field.options) || field.options.length === 0) throw new TypeError(`${label}.options must be a non-empty array`);
+			const options = /* @__PURE__ */ new Set();
+			for (const [optionIndex, optionValue] of field.options.entries()) {
+				const optionLabel = `${label}.options[${optionIndex}]`;
+				const option = exactRecord(optionValue, [
+					"id",
+					"label",
+					"description"
+				], ["id", "label"], optionLabel);
+				localId(option.id, `${optionLabel}.id`);
+				if (options.has(option.id)) throw new TypeError(`${label} contains duplicate option id`);
+				options.add(option.id);
+				nonEmpty(option.label, `${optionLabel}.label`);
+				optionalText(option.description, `${optionLabel}.description`);
+			}
+		} else if (field.kind !== "confirm") throw new TypeError(`${label}.kind is invalid`);
+	}
+}
+function validateApprovalRequest(value) {
+	const request = requestRecord(value, [
+		"kind",
+		"action",
+		"summary",
+		"details",
+		"risk"
+	], "Approval request");
+	if (request.kind !== "approval") throw new TypeError("Approval request.kind must be \"approval\"");
+	nonEmpty(request.action, "Approval request.action");
+	nonEmpty(request.summary, "Approval request.summary");
+	if (request.risk !== void 0 && request.risk !== "low" && request.risk !== "medium" && request.risk !== "high") throw new TypeError("Approval request.risk is invalid");
+	if (request.details !== void 0) {
+		if (!Array.isArray(request.details)) throw new TypeError("Approval request.details must be an array");
+		for (const [index, detailValue] of request.details.entries()) {
+			const label = `Approval request.details[${index}]`;
+			const detail = exactRecord(detailValue, [
+				"label",
+				"value",
+				"sensitivity"
+			], ["label", "value"], label);
+			nonEmpty(detail.label, `${label}.label`);
+			nonEmpty(detail.value, `${label}.value`);
+			if (detail.sensitivity !== void 0 && detail.sensitivity !== "public" && detail.sensitivity !== "private") throw new TypeError(`${label}.sensitivity is invalid`);
+		}
+	}
+}
+function validateSecretInputRequest(value) {
+	const request = requestRecord(value, [
+		"kind",
+		"label",
+		"description",
+		"minLength",
+		"maxLength"
+	], "SecretInput request");
+	if (request.kind !== "secret-input") throw new TypeError("SecretInput request.kind must be \"secret-input\"");
+	nonEmpty(request.label, "SecretInput request.label");
+	optionalText(request.description, "SecretInput request.description");
+	lengthBounds(request.minLength, request.maxLength, "SecretInput request");
+}
+function validateInteractionResult(request, value) {
+	if (request.kind === "question") return validatePresentationResult(value, (result) => validateQuestionAnswers(request, result), "Question result");
+	if (request.kind === "approval") return validatePresentationResult(value, validateApprovalValue, "Approval result");
+	return validatePresentationResult(value, (result) => validateSecretInputValue(request, result), "SecretInput result");
+}
+function validateQuestionAnswers(request, value) {
+	const result = exactRecord(value, ["answers"], ["answers"], "Question answers");
+	if (!record(result.answers)) throw new TypeError("Question answers.answers must be an object");
+	const fields = new Map(request.fields.map((field) => [field.id, field]));
+	for (const field of request.fields) if (field.required === true && !Object.hasOwn(result.answers, field.id)) throw new TypeError(`Question answers is missing required field ${JSON.stringify(field.id)}`);
+	for (const [id, answer] of Object.entries(result.answers)) {
+		const field = fields.get(id);
+		if (field === void 0) throw new TypeError(`Question answers contains unknown field ${JSON.stringify(id)}`);
+		if (field.kind === "text") {
+			if (typeof answer !== "string") throw new TypeError(`Question answer ${JSON.stringify(id)} must be a string`);
+			if (field.minLength !== void 0 && answer.length < field.minLength) throw new TypeError(`Question answer ${JSON.stringify(id)} is too short`);
+			if (field.maxLength !== void 0 && answer.length > field.maxLength) throw new TypeError(`Question answer ${JSON.stringify(id)} is too long`);
+		} else if (field.kind === "confirm") {
+			if (typeof answer !== "boolean") throw new TypeError(`Question answer ${JSON.stringify(id)} must be boolean`);
+		} else {
+			const allowed = new Set(field.options.map((option) => option.id));
+			const selected = field.multiple === true ? answer : [answer];
+			if (!Array.isArray(selected) || selected.some((option) => typeof option !== "string" || !allowed.has(option))) throw new TypeError(`Question answer ${JSON.stringify(id)} contains an invalid option`);
+		}
+	}
+	return freezeClone(value);
+}
+function validateApprovalValue(value) {
+	const result = exactRecord(value, ["decision"], ["decision"], "Approval value");
+	if (result.decision !== "approved" && result.decision !== "denied") throw new TypeError("Approval value.decision is invalid");
+	return freezeClone(value);
+}
+function validateSecretInputValue(request, value) {
+	const result = exactRecord(value, ["secret"], ["secret"], "SecretInput value");
+	if (typeof result.secret !== "string") throw new TypeError("SecretInput value.secret must be a string");
+	if (request.minLength !== void 0 && result.secret.length < request.minLength) throw new TypeError("SecretInput value.secret is too short");
+	if (request.maxLength !== void 0 && result.secret.length > request.maxLength) throw new TypeError("SecretInput value.secret is too long");
+	return freezeClone(value);
+}
+function validatePresentationResult(value, validateSubmitted, label) {
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	if (value.status === "submitted") return deepFreeze({
+		status: "submitted",
+		value: validateSubmitted(exactRecord(value, ["status", "value"], ["status", "value"], label).value)
+	});
+	if (value.status === "unavailable") {
+		optionalText(exactRecord(value, ["status", "reason"], ["status"], label).reason, `${label}.reason`);
+		return freezeClone(value);
+	}
+	if (value.status === "cancelled" || value.status === "expired") {
+		exactRecord(value, ["status"], ["status"], label);
+		return freezeClone(value);
+	}
+	throw new TypeError(`${label}.status is invalid`);
+}
+function validateAcceptedReceipt(value) {
+	if (exactRecord(value, ["accepted"], ["accepted"], "Presentation receipt").accepted !== true) throw new TypeError("Presentation receipt.accepted must be true");
+	return Object.freeze({ accepted: true });
+}
+function requestRecord(value, fields, label) {
+	const required = [
+		"requestId",
+		"invocationId",
+		"origin",
+		...fields.filter((field) => ![
+			"title",
+			"description",
+			"details",
+			"risk",
+			"level",
+			"deduplicationKey",
+			"sensitivity",
+			"minLength",
+			"maxLength"
+		].includes(field))
+	];
+	const request = exactRecord(value, [
+		"requestId",
+		"invocationId",
+		"origin",
+		"deadline",
+		...fields
+	], required, label);
+	nonEmpty(request.requestId, `${label}.requestId`);
+	nonEmpty(request.invocationId, `${label}.invocationId`);
+	nonEmpty(request.origin, `${label}.origin`);
+	if (request.deadline !== void 0 && (typeof request.deadline !== "string" || Number.isNaN(Date.parse(request.deadline)))) throw new TypeError(`${label}.deadline must be an RFC 3339 date-time`);
+	return request;
+}
+function validateLimits(value) {
+	const limits = exactRecord(value, [
+		"maxConcurrentRequests",
+		"maxFields",
+		"maxOptionsPerField",
+		"maxTextLength"
+	], [], "UserInteraction limits");
+	for (const [name, limit] of Object.entries(limits)) positiveInteger(limit, `UserInteraction limits.${name}`);
+	return freezeClone(value);
+}
+function operationList(value, label) {
+	if (!Array.isArray(value) || value.length === 0) throw new TypeError(`${label} must be a non-empty array`);
+	const operations = value.map((operation) => {
+		if (operation !== "question" && operation !== "approval" && operation !== "secret-input") throw new TypeError(`${label} contains an invalid operation`);
+		return operation;
+	});
+	if (new Set(operations).size !== operations.length) throw new TypeError(`${label} contains a duplicate operation`);
+	return Object.freeze(operations);
+}
+function lengthBounds(minimum, maximum, label) {
+	if (minimum !== void 0) nonNegativeInteger(minimum, `${label}.minLength`);
+	if (maximum !== void 0) nonNegativeInteger(maximum, `${label}.maxLength`);
+	if (typeof minimum === "number" && typeof maximum === "number" && minimum > maximum) throw new TypeError(`${label}.minLength must not exceed maxLength`);
+}
+function exactRecord(value, allowed, required, label) {
+	if (!record(value)) throw new TypeError(`${label} must be an object`);
+	const unknown = Object.keys(value).filter((key) => !allowed.includes(key));
+	if (unknown.length > 0) throw new TypeError(`${label} contains unknown field ${JSON.stringify(unknown[0])}`);
+	for (const key of required) if (!Object.hasOwn(value, key)) throw new TypeError(`${label}.${key} is required`);
+	return value;
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmpty(value, label) {
+	if (typeof value !== "string" || value.trim() === "") throw new TypeError(`${label} must be a non-empty string`);
+}
+function validateInvocationScope(scope) {
+	if (!record(scope)) throw new TypeError("Presentation invocation scope must be an object");
+	nonEmpty(scope.invocationId, "Presentation invocation scope.invocationId");
+	nonEmpty(scope.origin, "Presentation invocation scope.origin");
+	if (scope.deadline !== void 0 && (typeof scope.deadline !== "string" || Number.isNaN(Date.parse(scope.deadline)))) throw new TypeError("Presentation invocation scope.deadline must be an RFC 3339 date-time");
+	if (typeof scope.nextRequestId !== "function") throw new TypeError("Presentation invocation scope.nextRequestId must be a function");
+}
+function requestFactory(scope) {
+	validateInvocationScope(scope);
+	return (input) => {
+		if (!record(input)) throw new TypeError("Presentation input must be an object");
+		const requestId = scope.nextRequestId();
+		nonEmpty(requestId, "Presentation requestId");
+		return freezeClone({
+			...input,
+			requestId,
+			invocationId: scope.invocationId,
+			origin: scope.origin,
+			...scope.deadline === void 0 ? {} : { deadline: scope.deadline }
+		});
+	};
+}
+function optionalText(value, label) {
+	if (value !== void 0) nonEmpty(value, label);
+}
+function optionalBoolean(value, label) {
+	if (value !== void 0 && typeof value !== "boolean") throw new TypeError(`${label} must be boolean`);
+}
+function localId(value, label) {
+	if (typeof value !== "string" || !/^[A-Za-z][A-Za-z0-9._-]*$/u.test(value)) throw new TypeError(`${label} is invalid`);
+}
+function positiveInteger(value, label) {
+	if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`${label} must be a positive safe integer`);
+}
+function nonNegativeInteger(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(`${label} must be a non-negative safe integer`);
+}
+function freezeClone(value) {
+	return deepFreeze(structuredClone(value));
+}
+function deepFreeze(value) {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	Object.freeze(value);
+	for (const child of Object.values(value)) deepFreeze(child);
+	return value;
+}
+//#endregion
+export { API_VERSION, COPY_TEXT_KIND, EXTERNAL_REDIRECT_KIND, NOTIFICATION_KIND, OPEN_EXTERNAL_KIND, USER_INTERACTION_KIND, copyTextClient, copyTextImplementation, copyTextProtocol, copyTextSupport, externalRedirectClient, externalRedirectImplementation, externalRedirectProtocol, externalRedirectSupport, notificationClient, notificationImplementation, notificationProtocol, notificationSupport, openExternalClient, openExternalImplementation, openExternalProtocol, openExternalSupport, presentationClients, protocols, register, userInteractionClient, userInteractionImplementation, userInteractionProtocol, userInteractionSupport, validateCopyTextRequest, validateExternalRedirectReady, validateExternalRedirectRequest, validateExternalRedirectResult, validateNotificationRequest, validateOpenExternalRequest, validatePresentationDescriptor, validateUserInteractionRequest, validateUserInteractionRequirement, validateUserInteractionSupport };
+
+//# sourceMappingURL=index.js.map