@pisell/private-materials 6.12.167 → 6.12.169

package/es/components/HDLKiosk/kernel/application/defineApplication.js

@@ -1,31 +1,51 @@
 import { _objectSpread2 } from "../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js";
 import { _objectWithoutProperties } from "../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectWithoutProperties.js";
 //#region src/components/HDLKiosk/kernel/application/defineApplication.ts
-const _excluded = ["slice"];
-function getKioskSliceNavigationGuardId(sliceId, phase) {
+const _excluded = ["start"], _excluded2 = ["slice"];
+function getSliceNavigationGuardId(sliceId, phase) {
 	return `${sliceId}.${phase}`;
 }
 function isWorkflowStep(value) {
 	return "slice" in value;
 }
 function defineWorkflow(workflow) {
-	if (!workflow.id.trim()) throw new Error("Kiosk Workflow id cannot be empty");
-	if (workflow.steps.length === 0) throw new Error(`Kiosk Workflow ${workflow.id} must contain steps`);
-	return Object.freeze(_objectSpread2(_objectSpread2({}, workflow), {}, { steps: Object.freeze([...workflow.steps]) }));
+	if (!workflow.id.trim()) throw new Error("Workflow id cannot be empty");
+	if (workflow.steps.length === 0) throw new Error(`Workflow ${workflow.id} must contain steps`);
+	return Object.freeze(_objectSpread2(_objectSpread2(_objectSpread2({}, workflow), workflow.start ? { start: Object.freeze(_objectSpread2({}, workflow.start)) } : {}), {}, { steps: Object.freeze([...workflow.steps]) }));
 }
-function defineKioskApplication(definition) {
-	var _definition$operation;
-	if (!definition.id.trim()) throw new Error("Kiosk Application id cannot be empty");
+const manualTrigger = Object.freeze({
+	id: "manual",
+	mode: "manual"
+});
+function defineTrigger(trigger) {
+	if (!trigger.id.trim()) throw new Error("Application Trigger id cannot be empty");
+	return Object.freeze(_objectSpread2({}, trigger));
+}
+function resolveWorkflowStartBinding(workflow) {
+	var _workflow$start;
+	const start = (_workflow$start = workflow.start) !== null && _workflow$start !== void 0 ? _workflow$start : {
+		trigger: manualTrigger.id,
+		channel: workflow.id
+	};
+	if (!start.trigger.trim()) throw new Error(`Workflow ${workflow.id} trigger cannot be empty`);
+	if (!start.channel.trim()) throw new Error(`Workflow ${workflow.id} trigger channel cannot be empty`);
+	return Object.freeze(_objectSpread2({}, start));
+}
+function defineApplication(definition) {
+	var _definition$operation, _definition$triggers;
+	if (!definition.id.trim()) throw new Error("Application id cannot be empty");
 	const slices = /* @__PURE__ */ new Map();
 	const operations = /* @__PURE__ */ new Map();
+	const triggers = new Map([[manualTrigger.id, manualTrigger]]);
+	const workflowStarts = /* @__PURE__ */ new Map();
 	const registerOperation = (operation) => {
 		const existing = operations.get(operation.id);
-		if (existing && existing !== operation) throw new Error(`Duplicate Kiosk Operation: ${operation.id}`);
+		if (existing && existing !== operation) throw new Error(`Duplicate Operation: ${operation.id}`);
 		operations.set(operation.id, operation);
 	};
 	definition.slices.forEach((slice) => {
 		var _slice$commands;
-		if (slices.has(slice.id)) throw new Error(`Duplicate Kiosk Slice: ${slice.id}`);
+		if (slices.has(slice.id)) throw new Error(`Duplicate Slice: ${slice.id}`);
 		const operationIds = /* @__PURE__ */ new Set();
 		Object.values(slice.intents).forEach((intent) => {
 			if (intent.kind !== "effect") return;
@@ -42,22 +62,41 @@ function defineKioskApplication(definition) {
 		}));
 	});
 	(_definition$operation = definition.operations) === null || _definition$operation === void 0 || _definition$operation.forEach(registerOperation);
+	(_definition$triggers = definition.triggers) === null || _definition$triggers === void 0 || _definition$triggers.forEach((trigger) => {
+		if (triggers.has(trigger.id)) throw new Error(`Duplicate Application Trigger: ${trigger.id}`);
+		if (!trigger.id.trim()) throw new Error("Application Trigger id cannot be empty");
+		triggers.set(trigger.id, Object.freeze(_objectSpread2({}, trigger)));
+	});
+	const automaticTriggerOwners = /* @__PURE__ */ new Map();
 	Object.values(definition.workflows).forEach((workflow) => {
+		if (workflowStarts.has(workflow.id)) throw new Error(`Duplicate Workflow: ${workflow.id}`);
+		const start = resolveWorkflowStartBinding(workflow);
+		const trigger = triggers.get(start.trigger);
+		if (!trigger) throw new Error(`Workflow ${workflow.id} references unknown Trigger ${start.trigger}`);
+		if (trigger.mode === "automatic") {
+			const owner = automaticTriggerOwners.get(trigger.id);
+			if (owner) throw new Error(`Automatic Trigger ${trigger.id} is already bound to Workflow ${owner}`);
+			automaticTriggerOwners.set(trigger.id, workflow.id);
+		}
+		workflowStarts.set(workflow.id, start);
 		workflow.steps.forEach((rawStep) => {
 			var _slices$get;
 			const slice = isWorkflowStep(rawStep) ? rawStep.slice : rawStep;
-			if (((_slices$get = slices.get(slice.id)) === null || _slices$get === void 0 ? void 0 : _slices$get.definition) !== slice) throw new Error(`Kiosk Workflow ${workflow.id} references unregistered Slice ${slice.id}`);
+			if (((_slices$get = slices.get(slice.id)) === null || _slices$get === void 0 ? void 0 : _slices$get.definition) !== slice) throw new Error(`Workflow ${workflow.id} references unregistered Slice ${slice.id}`);
 		});
 	});
 	return Object.freeze({
 		id: definition.id,
 		slices,
 		operations,
+		triggers,
+		workflowStarts,
 		workflows: Object.freeze(_objectSpread2({}, definition.workflows))
 	});
 }
-function normalizeKioskWorkflow(workflow) {
-	return Object.freeze(_objectSpread2(_objectSpread2({}, workflow), {}, { steps: Object.freeze(workflow.steps.map((rawStep) => {
+function normalizeApplicationWorkflow(workflow) {
+	const { start: _start } = workflow, structure = _objectWithoutProperties(workflow, _excluded);
+	return Object.freeze(_objectSpread2(_objectSpread2({}, structure), {}, { steps: Object.freeze(workflow.steps.map((rawStep) => {
 		if (!isWorkflowStep(rawStep)) {
 			const authoringOverrides = rawStep;
 			return Object.freeze({
@@ -65,10 +104,10 @@ function normalizeKioskWorkflow(workflow) {
 				presentation: typeof authoringOverrides.presentation === "object" ? authoringOverrides.presentation : void 0,
 				readiness: authoringOverrides.readiness,
 				on: authoringOverrides.on,
-				end: authoringOverrides.end
+				isTerminal: authoringOverrides.isTerminal
 			});
 		}
-		const { slice } = rawStep, step = _objectWithoutProperties(rawStep, _excluded);
+		const { slice } = rawStep, step = _objectWithoutProperties(rawStep, _excluded2);
 		return Object.freeze(_objectSpread2(_objectSpread2({}, step), {}, { activity: slice.id }));
 	})) }));
 }
@@ -76,7 +115,7 @@ function normalizeKioskWorkflow(workflow) {
 function createApplicationActivityRegistry(application) {
 	const contracts = /* @__PURE__ */ new Map();
 	application.slices.forEach(({ definition }) => {
-		var _definition$presentat, _definition$additiona;
+		var _definition$presentat, _definition$surface$i, _definition$surface, _definition$additiona;
 		const exitPolicies = {};
 		Object.entries(definition.intents).forEach(([intent, behavior]) => {
 			let policy;
@@ -90,12 +129,12 @@ function createApplicationActivityRegistry(application) {
 		const primaryPresentation = (_definition$presentat = definition.presentation) !== null && _definition$presentat !== void 0 ? _definition$presentat : "page";
 		contracts.set(definition.id, Object.freeze({
 			id: definition.id,
-			screenId: definition.screen.id,
+			surfaceId: (_definition$surface$i = (_definition$surface = definition.surface) === null || _definition$surface === void 0 ? void 0 : _definition$surface.id) !== null && _definition$surface$i !== void 0 ? _definition$surface$i : definition.id,
 			intents: Object.freeze(Object.keys(definition.intents)),
 			exitPolicies: Object.freeze(exitPolicies),
 			navigationGuards: definition.guards ? Object.freeze(Object.keys(definition.guards).reduce((guards, rawPhase) => {
 				const phase = rawPhase;
-				guards[phase] = getKioskSliceNavigationGuardId(definition.id, phase);
+				guards[phase] = getSliceNavigationGuardId(definition.id, phase);
 				return guards;
 			}, {})) : void 0,
 			allowedPresentations: Object.freeze([...new Set([primaryPresentation, ...(_definition$additiona = definition.additionalPresentations) !== null && _definition$additiona !== void 0 ? _definition$additiona : []])]),
@@ -108,7 +147,7 @@ function createApplicationActivityRegistry(application) {
 		has: (id) => contracts.has(id),
 		require: (id) => {
 			const contract = contracts.get(id);
-			if (!contract) throw new Error(`Unknown Kiosk Slice: ${id}`);
+			if (!contract) throw new Error(`Unknown Slice: ${id}`);
 			return contract;
 		}
 	});
@@ -123,8 +162,8 @@ function createApplicationNavigationGuardRegistry(application) {
 		var _definition$guards;
 		Object.entries((_definition$guards = definition.guards) !== null && _definition$guards !== void 0 ? _definition$guards : {}).forEach(([rawPhase, guard]) => {
 			const phase = rawPhase;
-			const id = getKioskSliceNavigationGuardId(definition.id, phase);
-			if (navigationGuards.has(id)) throw new Error(`Duplicate Kiosk Navigation Guard: ${id}`);
+			const id = getSliceNavigationGuardId(definition.id, phase);
+			if (navigationGuards.has(id)) throw new Error(`Duplicate Navigation Guard: ${id}`);
 			navigationGuards.set(id, guard);
 		});
 	});
@@ -133,8 +172,8 @@ function createApplicationNavigationGuardRegistry(application) {
 		has: (id) => navigationGuards.has(id),
 		evaluate: (id, context) => {
 			const navigationGuard = navigationGuards.get(id);
-			if (!navigationGuard) throw new Error(`Unknown Kiosk Navigation Guard: ${id}`);
-			if (context.to.kind !== "step") throw new Error(`Kiosk Slice Navigation Guard ${id} requires a Step target`);
+			if (!navigationGuard) throw new Error(`Unknown Navigation Guard: ${id}`);
+			if (context.to.kind !== "step") throw new Error(`Slice Navigation Guard ${id} requires a Step target`);
 			return navigationGuard(_objectSpread2(_objectSpread2({}, context), {}, {
 				workflow: context.context,
 				to: context.to
@@ -143,4 +182,4 @@ function createApplicationNavigationGuardRegistry(application) {
 	});
 }
 //#endregion
-export { createApplicationActivityRegistry, createApplicationNavigationGuardRegistry, defineKioskApplication, defineWorkflow, normalizeKioskWorkflow };
+export { createApplicationActivityRegistry, createApplicationNavigationGuardRegistry, defineApplication, defineTrigger, defineWorkflow, normalizeApplicationWorkflow };

package/es/components/HDLKiosk/kernel/application/defineSlice.js

@@ -13,17 +13,17 @@ const effect = (operation, options = {}) => Object.freeze({
 });
 function defineSlice(slice) {
 	var _slice$guards;
-	if (!slice.id.trim()) throw new Error("Kiosk Slice id cannot be empty");
-	if (!slice.screen.id.trim()) throw new Error(`Kiosk Slice ${slice.id} screen id cannot be empty`);
+	if (!slice.id.trim()) throw new Error("Slice id cannot be empty");
+	if (slice.surface && !slice.surface.id.trim()) throw new Error(`Slice ${slice.id} surface id cannot be empty`);
 	Object.entries(slice.intents).forEach(([intent]) => {
-		if (!intent.trim()) throw new Error(`Kiosk Slice ${slice.id} has an empty intent`);
+		if (!intent.trim()) throw new Error(`Slice ${slice.id} has an empty intent`);
 	});
 	Object.entries((_slice$guards = slice.guards) !== null && _slice$guards !== void 0 ? _slice$guards : {}).forEach(([phase, navigationGuard]) => {
-		if (phase !== "beforeEnter") throw new Error(`Kiosk Slice ${slice.id} has an unknown navigation guard phase: ${phase}`);
-		if (typeof navigationGuard !== "function") throw new Error(`Kiosk Slice ${slice.id} guard ${phase} must be a function`);
+		if (phase !== "beforeEnter") throw new Error(`Slice ${slice.id} has an unknown navigation guard phase: ${phase}`);
+		if (typeof navigationGuard !== "function") throw new Error(`Slice ${slice.id} guard ${phase} must be a function`);
 	});
 	return Object.freeze(_objectSpread2(_objectSpread2({}, slice), {}, {
-		screen: Object.freeze(_objectSpread2({}, slice.screen)),
+		surface: slice.surface ? Object.freeze(_objectSpread2({}, slice.surface)) : void 0,
 		intents: Object.freeze(_objectSpread2({}, slice.intents)),
 		guards: slice.guards ? Object.freeze(_objectSpread2({}, slice.guards)) : void 0,
 		commands: slice.commands ? Object.freeze(_objectSpread2({}, slice.commands)) : void 0,

package/es/components/HDLKiosk/kernel/application/runtime.js

@@ -0,0 +1,237 @@
+import { _objectSpread2 } from "../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js";
+import { _asyncToGenerator } from "../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js";
+//#region src/components/HDLKiosk/kernel/application/runtime.ts
+function createApplicationRuntime({ definition, sessionFactory, triggerAdapters = [], maxActiveSessions = Number.POSITIVE_INFINITY }) {
+	if (maxActiveSessions <= 0) throw new Error("Application Runtime maxActiveSessions must be positive");
+	const workflowsByTrigger = /* @__PURE__ */ new Map();
+	definition.workflowStarts.forEach((start, workflowId) => {
+		if (start.trigger === "manual") return;
+		if (workflowsByTrigger.has(start.trigger)) throw new Error(`Automatic Trigger ${start.trigger} has multiple Workflow bindings`);
+		workflowsByTrigger.set(start.trigger, {
+			workflowId,
+			start
+		});
+	});
+	const adapters = /* @__PURE__ */ new Map();
+	triggerAdapters.forEach((adapter) => {
+		if (adapters.has(adapter.trigger)) throw new Error(`Duplicate Trigger Adapter: ${adapter.trigger}`);
+		const contract = definition.triggers.get(adapter.trigger);
+		if (!contract || contract.mode !== "automatic") throw new Error(`Unknown automatic Trigger Adapter: ${adapter.trigger}`);
+		adapters.set(adapter.trigger, adapter);
+	});
+	const sessions = /* @__PURE__ */ new Map();
+	const ownedSessionIds = /* @__PURE__ */ new Set();
+	const sessionListeners = /* @__PURE__ */ new Set();
+	const occurrenceSessions = /* @__PURE__ */ new Map();
+	const pendingOccurrences = /* @__PURE__ */ new Map();
+	const cleanups = [];
+	let state = "inactive";
+	let activationEpoch = 0;
+	let manualSequence = 0;
+	let pendingStartCount = 0;
+	const publishSessionEvent = (event) => {
+		sessionListeners.forEach((listener) => listener(event));
+	};
+	const create = function() {
+		var _ref = _asyncToGenerator(function* (input) {
+			if (state !== "active") return {
+				status: "rejected",
+				reason: "runtimeInactive"
+			};
+			const occurrenceKey = `${input.cause.trigger}\u0000${input.cause.occurrenceId}`;
+			const existingId = occurrenceSessions.get(occurrenceKey);
+			const existing = existingId ? sessions.get(existingId) : void 0;
+			if (existing) return {
+				status: "duplicate",
+				session: existing
+			};
+			const pending = pendingOccurrences.get(occurrenceKey);
+			if (pending) return pending;
+			if (ownedSessionIds.size + pendingStartCount >= maxActiveSessions) return {
+				status: "rejected",
+				reason: "admissionRejected"
+			};
+			const startActivationEpoch = activationEpoch;
+			pendingStartCount += 1;
+			const promise = sessionFactory.create(input).then((session) => {
+				if (state !== "active" || activationEpoch !== startActivationEpoch) {
+					session.dispose();
+					return {
+						status: "rejected",
+						reason: "runtimeInactive"
+					};
+				}
+				if (session.workflowId !== input.workflowId) {
+					session.dispose();
+					return {
+						status: "rejected",
+						reason: "sessionStartFailed",
+						error: /* @__PURE__ */ new Error(`Session Workflow ${session.workflowId} does not match ${input.workflowId}`)
+					};
+				}
+				if (sessions.has(session.id)) {
+					session.dispose();
+					return {
+						status: "rejected",
+						reason: "sessionStartFailed",
+						error: /* @__PURE__ */ new Error(`Duplicate Workflow Session: ${session.id}`)
+					};
+				}
+				sessions.set(session.id, session);
+				ownedSessionIds.add(session.id);
+				occurrenceSessions.set(occurrenceKey, session.id);
+				publishSessionEvent({
+					type: "started",
+					session
+				});
+				try {
+					var _sessionFactory$onSta;
+					(_sessionFactory$onSta = sessionFactory.onStarted) === null || _sessionFactory$onSta === void 0 || _sessionFactory$onSta.call(sessionFactory, _objectSpread2({ session }, input));
+				} catch (error) {
+					sessions.delete(session.id);
+					ownedSessionIds.delete(session.id);
+					occurrenceSessions.delete(occurrenceKey);
+					session.dispose();
+					publishSessionEvent({
+						type: "disposed",
+						sessionId: session.id
+					});
+					return {
+						status: "rejected",
+						reason: "sessionStartFailed",
+						error
+					};
+				}
+				return {
+					status: "started",
+					session
+				};
+			}).catch((error) => ({
+				status: "rejected",
+				reason: "sessionStartFailed",
+				error
+			})).finally(() => {
+				pendingStartCount -= 1;
+				pendingOccurrences.delete(occurrenceKey);
+			});
+			pendingOccurrences.set(occurrenceKey, promise);
+			return promise;
+		});
+		return function create(_x) {
+			return _ref.apply(this, arguments);
+		};
+	}();
+	const emitAutomatic = (trigger, occurrence) => {
+		var _occurrence$correlati;
+		const binding = workflowsByTrigger.get(trigger);
+		if (!binding || binding.start.channel !== occurrence.channel) return Promise.resolve({
+			status: "rejected",
+			reason: "unknownChannel"
+		});
+		return create({
+			workflowId: binding.workflowId,
+			payload: occurrence.payload,
+			cause: Object.freeze({
+				trigger,
+				channel: occurrence.channel,
+				occurrenceId: occurrence.occurrenceId,
+				correlationId: (_occurrence$correlati = occurrence.correlationId) !== null && _occurrence$correlati !== void 0 ? _occurrence$correlati : `${definition.id}:${trigger}:${occurrence.occurrenceId}`
+			})
+		});
+	};
+	const registry = Object.freeze({
+		get: (sessionId) => sessions.get(sessionId),
+		list: () => Object.freeze([...sessions.values()]),
+		listActive: () => Object.freeze([...sessions.values()].filter((session) => session.isActive())),
+		subscribe: (listener) => {
+			sessionListeners.add(listener);
+			return () => sessionListeners.delete(listener);
+		}
+	});
+	const runtime = {
+		id: definition.id,
+		sessions: registry,
+		activate: () => {
+			if (state === "disposed") throw new Error(`Application Runtime ${definition.id} is disposed`);
+			if (state === "active") return;
+			workflowsByTrigger.forEach((_binding, trigger) => {
+				if (!adapters.has(trigger)) throw new Error(`Missing Trigger Adapter: ${trigger}`);
+			});
+			activationEpoch += 1;
+			state = "active";
+			try {
+				adapters.forEach((adapter) => {
+					const cleanup = adapter.activate({ emit: (occurrence) => emitAutomatic(adapter.trigger, occurrence) });
+					if (cleanup) cleanups.push(cleanup);
+				});
+			} catch (error) {
+				var _cleanups$pop;
+				state = "inactive";
+				while (cleanups.length > 0) (_cleanups$pop = cleanups.pop()) === null || _cleanups$pop === void 0 || _cleanups$pop();
+				throw error;
+			}
+		},
+		deactivate: () => {
+			var _cleanups$pop2;
+			if (state !== "active") return;
+			state = "inactive";
+			while (cleanups.length > 0) (_cleanups$pop2 = cleanups.pop()) === null || _cleanups$pop2 === void 0 || _cleanups$pop2();
+		},
+		workflow: (workflowId) => {
+			if (!definition.workflowStarts.get(workflowId)) throw new Error(`Unknown Workflow: ${workflowId}`);
+			return Object.freeze({
+				id: workflowId,
+				start: function() {
+					var _ref2 = _asyncToGenerator(function* (payload) {
+						if (start.trigger !== "manual") throw new Error(`Workflow ${workflowId} cannot be started through manual Trigger`);
+						manualSequence += 1;
+						const occurrenceId = `${workflowId}:${manualSequence}`;
+						const result = yield create({
+							workflowId,
+							payload,
+							cause: Object.freeze({
+								trigger: "manual",
+								channel: start.channel,
+								occurrenceId,
+								correlationId: `${definition.id}:manual:${occurrenceId}`
+							})
+						});
+						if (result.status === "started" || result.status === "duplicate") return result.session;
+						throw result.error instanceof Error ? result.error : /* @__PURE__ */ new Error(`Workflow ${workflowId} start rejected: ${result.reason}`);
+					});
+					return function start(_x2) {
+						return _ref2.apply(this, arguments);
+					};
+				}()
+			});
+		},
+		disposeSession: (sessionId) => {
+			const session = sessions.get(sessionId);
+			if (!session) return false;
+			if (!ownedSessionIds.delete(sessionId)) return false;
+			sessions.delete(sessionId);
+			const occurrenceKey = `${session.cause.trigger}\u0000${session.cause.occurrenceId}`;
+			if (occurrenceSessions.get(occurrenceKey) === sessionId) occurrenceSessions.delete(occurrenceKey);
+			session.dispose();
+			publishSessionEvent({
+				type: "disposed",
+				sessionId
+			});
+			return true;
+		},
+		dispose: () => {
+			var _cleanups$pop3;
+			if (state === "disposed") return;
+			state = "disposed";
+			while (cleanups.length > 0) (_cleanups$pop3 = cleanups.pop()) === null || _cleanups$pop3 === void 0 || _cleanups$pop3();
+			sessions.forEach((session) => session.dispose());
+			ownedSessionIds.clear();
+			sessions.clear();
+			pendingOccurrences.clear();
+			sessionListeners.clear();
+		}
+	};
+	return Object.freeze(runtime);
+}
+//#endregion
+export { createApplicationRuntime };

package/es/components/HDLKiosk/kernel/operations/coordinator.js

@@ -16,7 +16,7 @@ function createKernelOperationCoordinator(registry, policy, options = {}) {
 	const queue = [];
 	const active = /* @__PURE__ */ new Set();
 	const queueLimit = policy.queueLimit;
-	if (queueLimit && (!Number.isSafeInteger(queueLimit.max) || queueLimit.max < 1)) throw new Error("Kiosk operation queue limit must be a positive integer");
+	if (queueLimit && (!Number.isSafeInteger(queueLimit.max) || queueLimit.max < 1)) throw new Error("Operation queue limit must be a positive integer");
 	let disposed = false;
 	const metadata = (execution) => {
 		var _execution$operation$;

package/es/components/HDLKiosk/kernel/operations/registry.js

@@ -2,8 +2,8 @@
 function createKernelOperationRegistry(operations) {
 	const definitions = /* @__PURE__ */ new Map();
 	operations.forEach((operation) => {
-		if (definitions.has(operation.id)) throw new Error(`Duplicate Kiosk operation: ${operation.id}`);
-		if (operation.timeoutMs !== void 0 && (!Number.isFinite(operation.timeoutMs) || operation.timeoutMs <= 0)) throw new Error(`Invalid timeout for Kiosk operation: ${operation.id}`);
+		if (definitions.has(operation.id)) throw new Error(`Duplicate Operation: ${operation.id}`);
+		if (operation.timeoutMs !== void 0 && (!Number.isFinite(operation.timeoutMs) || operation.timeoutMs <= 0)) throw new Error(`Invalid timeout for Operation: ${operation.id}`);
 		definitions.set(operation.id, operation);
 	});
 	return Object.freeze({
@@ -12,7 +12,7 @@ function createKernelOperationRegistry(operations) {
 		get: (id) => definitions.get(id),
 		require: (id) => {
 			const operation = definitions.get(id);
-			if (!operation) throw new Error(`Unknown Kiosk operation: ${id}`);
+			if (!operation) throw new Error(`Unknown Operation: ${id}`);
 			return operation;
 		}
 	});

package/es/components/HDLKiosk/kernel/operations/sessionEpoch.js

@@ -1,6 +1,6 @@
 //#region src/components/HDLKiosk/kernel/operations/sessionEpoch.ts
 function createSessionEpochController(initialEpoch = 1) {
-	if (!Number.isSafeInteger(initialEpoch) || initialEpoch < 1) throw new Error("Kiosk session epoch must be a positive integer");
+	if (!Number.isSafeInteger(initialEpoch) || initialEpoch < 1) throw new Error("Session epoch must be a positive integer");
 	let epoch = initialEpoch;
 	return Object.freeze({
 		current: () => epoch,

package/es/components/HDLKiosk/kernel/operations/types.js

@@ -1,6 +1,10 @@
+import { _objectSpread2 } from "../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js";
 //#region src/components/HDLKiosk/kernel/operations/types.ts
-function defineKernelOperation(operation) {
-	return Object.freeze(operation);
+function defineKernelOperationContract(contract) {
+	return Object.freeze(contract);
+}
+function bindKernelOperation(contract, handler) {
+	return Object.freeze(_objectSpread2(_objectSpread2({}, contract), handler));
 }
 //#endregion
-export { defineKernelOperation };
+export { bindKernelOperation, defineKernelOperationContract };