@pisell/private-materials 6.12.167 → 6.12.169

package/lib/components/HDLKiosk/runtime/devices/scannerSessionPort.js

@@ -0,0 +1,60 @@
+const require_asyncToGenerator = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js");
+//#region src/components/HDLKiosk/runtime/devices/scannerSessionPort.ts
+const NON_WRITABLE_ACTIVITIES = new Set(["paymentCompleted"]);
+const PAYMENT_OPERATION_IDS = new Set([
+	"checkout.open",
+	"checkout.payEftpos",
+	"checkout.requestStaffPaymentApproval",
+	"session.reset"
+]);
+function isPaymentFrozen(host) {
+	const status = host.sales.getObservedSnapshot().payment.status;
+	return status === "pending" || status === "unknown" || status === "succeeded";
+}
+function isHDLKioskSessionCartWritable(session) {
+	var _session$definition$n;
+	const snapshot = session.actor.getSnapshot();
+	if (snapshot.status === "blocked" || snapshot.status === "finished") return false;
+	const activity = (_session$definition$n = session.definition.nodes[snapshot.nodeId]) === null || _session$definition$n === void 0 ? void 0 : _session$definition$n.activity;
+	if (!activity || NON_WRITABLE_ACTIVITIES.has(activity)) return false;
+	return !(snapshot.activeOperation && PAYMENT_OPERATION_IDS.has(snapshot.activeOperation.definitionId));
+}
+function createHDLKioskScannerSessionPort(host, session) {
+	return Object.freeze({
+		id: session.id,
+		sessionEpoch: () => session.actor.getSnapshot().sessionEpoch,
+		decideConsume: () => {
+			if (isPaymentFrozen(host)) return {
+				status: "rejected",
+				reason: "paymentFrozen"
+			};
+			return isHDLKioskSessionCartWritable(session) ? { status: "accepted" } : {
+				status: "rejected",
+				reason: "sessionNotCartWritable"
+			};
+		},
+		beforeConsume: () => {
+			const pendingNavigation = session.actor.getSnapshot().pendingNavigation;
+			if (pendingNavigation) session.actor.resolvePendingNavigation(pendingNavigation.navigationId, "cancel");
+		},
+		consume: function() {
+			var _ref = require_asyncToGenerator._asyncToGenerator(function* ({ code, eventId }) {
+				const sessionEpoch = session.actor.getSnapshot().sessionEpoch;
+				const result = yield session.executeCommand("barcode.consume", { code }, `scan:${sessionEpoch}:${eventId}`);
+				if (result.status === "succeeded") return {
+					operationStatus: result.status,
+					queueDirective: result.data.code === "requiresSelection" ? "pauseForSelection" : "continue"
+				};
+				return {
+					operationStatus: result.status,
+					queueDirective: result.status === "partialFailure" || result.status === "unknown" ? "stopUncertain" : "continue"
+				};
+			});
+			return function consume(_x) {
+				return _ref.apply(this, arguments);
+			};
+		}()
+	});
+}
+//#endregion
+exports.createHDLKioskScannerSessionPort = createHDLKioskScannerSessionPort;

package/lib/components/HDLKiosk/runtime/devices/scannerSessionRouter.js

@@ -0,0 +1,212 @@
+const require_asyncToGenerator = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js");
+const require_scannerIngress = require("./scannerIngress.js");
+//#region src/components/HDLKiosk/runtime/devices/scannerSessionRouter.ts
+function createScannerSessionRouter({ host, entrySupported, maxPendingEvents = 5 }) {
+	const ingress = require_scannerIngress.createScannerIngress({ maxPendingEvents });
+	let phase = "idle";
+	let activeStartId;
+	let listening = false;
+	let session;
+	let queue = [];
+	let currentTask;
+	let processing = false;
+	let generation = 0;
+	let rejectionSequence = 0;
+	const emitRejected = (task, reason) => {
+		rejectionSequence += 1;
+		try {
+			host.telemetry.emit({
+				name: "hdlKiosk.device.eventRejected",
+				traceId: `hdl-scanner-rejected-${rejectionSequence}`,
+				occurredAt: Date.now(),
+				attributes: {
+					eventType: task.event.type,
+					eventId: task.event.eventId,
+					reason
+				}
+			});
+		} catch (_unused) {}
+	};
+	const rejectQueue = (reason) => {
+		const rejected = queue;
+		queue = [];
+		rejected.forEach((task) => emitRejected(task, reason));
+	};
+	const emitCompleted = (task, target, result, stale) => {
+		try {
+			host.telemetry.emit({
+				name: "hdlKiosk.scanner.taskFinished",
+				traceId: `hdl-scan:${target.sessionEpoch()}:${task.event.eventId}`,
+				occurredAt: Date.now(),
+				attributes: {
+					eventId: task.event.eventId,
+					sessionEpoch: target.sessionEpoch(),
+					status: result.operationStatus,
+					stale
+				}
+			});
+		} catch (_unused2) {}
+	};
+	const processQueue = function() {
+		var _ref = require_asyncToGenerator._asyncToGenerator(function* () {
+			if (processing || phase !== "active" || !listening || !session) return;
+			processing = true;
+			const processGeneration = generation;
+			try {
+				while (phase === "active" && listening && generation === processGeneration && session && queue.length > 0) {
+					const target = session;
+					const task = queue.shift();
+					if (!task) continue;
+					const decision = target.decideConsume();
+					if (decision.status === "rejected") {
+						emitRejected(task, decision.reason);
+						continue;
+					}
+					let result;
+					try {
+						var _target$beforeConsume;
+						(_target$beforeConsume = target.beforeConsume) === null || _target$beforeConsume === void 0 || _target$beforeConsume.call(target);
+						currentTask = task;
+						result = yield target.consume({
+							eventId: task.event.eventId,
+							code: task.code
+						});
+					} catch (_unused3) {
+						currentTask = void 0;
+						emitRejected(task, "scanExecutionFailed");
+						rejectQueue("previousScanExecutionFailed");
+						break;
+					}
+					currentTask = void 0;
+					const stale = generation !== processGeneration || phase !== "active" || !listening || session !== target;
+					emitCompleted(task, target, result, stale);
+					if (stale) break;
+					if (result.queueDirective === "pauseForSelection") {
+						rejectQueue("barcodeSelectionPending");
+						break;
+					}
+					if (result.queueDirective === "stopUncertain") {
+						rejectQueue("previousScanResultUncertain");
+						break;
+					}
+				}
+			} finally {
+				currentTask = void 0;
+				processing = false;
+				if (phase === "active" && listening && queue.length > 0) processQueue();
+			}
+		});
+		return function processQueue() {
+			return _ref.apply(this, arguments);
+		};
+	}();
+	const beginSessionStart = (startId) => {
+		if (!startId.trim() || phase === "disposed" || phase === "active") return false;
+		if (phase === "starting") return activeStartId === startId;
+		phase = "starting";
+		activeStartId = startId;
+		return true;
+	};
+	const failSessionStart = (startId, reason = "sessionStartFailed") => {
+		if (phase !== "starting" || activeStartId !== startId) return false;
+		generation += 1;
+		rejectQueue(reason);
+		activeStartId = void 0;
+		session = void 0;
+		phase = "idle";
+		return true;
+	};
+	const triggerAdapter = Object.freeze({
+		trigger: "onScan",
+		activate: ({ emit }) => {
+			if (phase === "disposed") return void 0;
+			listening = true;
+			const unsubscribe = host.devices.subscribe((event) => {
+				if (!listening || phase === "disposed" || event.type !== "barcode") return;
+				const target = session;
+				const decision = target === null || target === void 0 ? void 0 : target.decideConsume();
+				const rejectedReason = (decision === null || decision === void 0 ? void 0 : decision.status) === "rejected" ? decision.reason : void 0;
+				const result = ingress.accept(event, {
+					active: listening,
+					supported: host.capabilities.scanner.available && (phase !== "idle" || entrySupported),
+					workflowLocked: false,
+					nodeAcceptsEvent: phase !== "active" || (decision === null || decision === void 0 ? void 0 : decision.status) === "accepted" || rejectedReason === "paymentFrozen",
+					paymentFrozen: phase === "active" && rejectedReason === "paymentFrozen",
+					pendingEventCount: queue.length + (currentTask ? 1 : 0)
+				});
+				if (result.status === "rejected") {
+					emitRejected({
+						event,
+						code: event.code
+					}, result.reason);
+					return;
+				}
+				const task = {
+					event: result.event,
+					code: result.code
+				};
+				queue.push(task);
+				if (phase === "active") {
+					processQueue();
+					return;
+				}
+				if (phase === "starting") return;
+				const startId = `device:scanner:${result.event.eventId}`;
+				if (!beginSessionStart(startId)) {
+					queue.pop();
+					emitRejected(task, "sessionStartConflict");
+					return;
+				}
+				emit({
+					channel: "product",
+					occurrenceId: result.event.eventId,
+					correlationId: startId
+				}).then((startResult) => {
+					if (startResult.status === "rejected") failSessionStart(startId, startResult.reason);
+				}).catch(() => failSessionStart(startId, "sessionStartFailed"));
+			}, { sources: ["scanner"] });
+			return () => {
+				listening = false;
+				generation += 1;
+				rejectQueue("inactive");
+				if (phase === "starting" && activeStartId) failSessionStart(activeStartId, "inactive");
+				unsubscribe();
+			};
+		}
+	});
+	return Object.freeze({
+		triggerAdapter,
+		beginSessionStart,
+		bindSession: (startId, nextSession) => {
+			if (phase !== "starting" || activeStartId !== startId) return false;
+			activeStartId = void 0;
+			session = nextSession;
+			phase = "active";
+			processQueue();
+			return true;
+		},
+		failSessionStart,
+		releaseSession: (sessionId) => {
+			if ((session === null || session === void 0 ? void 0 : session.id) !== sessionId) return false;
+			generation += 1;
+			rejectQueue("sessionDisposed");
+			activeStartId = void 0;
+			session = void 0;
+			phase = "idle";
+			ingress.reset();
+			return true;
+		},
+		dispose: () => {
+			if (phase === "disposed") return;
+			generation += 1;
+			rejectQueue("inactive");
+			activeStartId = void 0;
+			session = void 0;
+			listening = false;
+			phase = "disposed";
+			ingress.reset();
+		}
+	});
+}
+//#endregion
+exports.createScannerSessionRouter = createScannerSessionRouter;

package/lib/components/HDLKiosk/runtime/operations/barcode.js

@@ -0,0 +1,17 @@
+const require_asyncToGenerator = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js");
+const require_operations = require("../../app/operations.js");
+const require_cartConsistency = require("./cartConsistency.js");
+//#region src/components/HDLKiosk/runtime/operations/barcode.ts
+const barcodeConsumeOperationBinding = require("./types.js").bindOperation(require_operations.barcodeConsumeOperation, { execute: function() {
+	var _ref = require_asyncToGenerator._asyncToGenerator(function* (context, input, signal) {
+		const beforeFingerprint = context.host.sales.getObservedSnapshot().fingerprint.value;
+		const mutation = yield context.host.sales.consumeBarcode(input.code, signal);
+		if (mutation.status === "succeeded" && mutation.data.code === "requiresSelection") return mutation;
+		return require_cartConsistency.finalizeCartMutation(context, mutation, signal, () => mutation.status === "succeeded" && mutation.data.code === "added" && mutation.data.cartChangeConfirmed === true || context.host.sales.getObservedSnapshot().fingerprint.value !== beforeFingerprint);
+	});
+	return function execute(_x, _x2, _x3) {
+		return _ref.apply(this, arguments);
+	};
+}() });
+//#endregion
+exports.barcodeConsumeOperationBinding = barcodeConsumeOperationBinding;

package/lib/components/HDLKiosk/runtime/operations/cart.js

@@ -0,0 +1,46 @@
+const require_asyncToGenerator = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js");
+const require_operations = require("../../app/operations.js");
+const require_cartConsistency = require("./cartConsistency.js");
+const require_types = require("./types.js");
+//#region src/components/HDLKiosk/runtime/operations/cart.ts
+const cartAddProductOperationBinding = require_types.bindOperation(require_operations.cartAddProductOperation, { execute: function() {
+	var _ref = require_asyncToGenerator._asyncToGenerator(function* (context, input, signal) {
+		return require_cartConsistency.finalizeCartMutation(context, yield context.host.sales.addProduct(input, signal), signal);
+	});
+	return function execute(_x, _x2, _x3) {
+		return _ref.apply(this, arguments);
+	};
+}() });
+const cartUpdateQuantityOperationBinding = require_types.bindOperation(require_operations.cartUpdateQuantityOperation, { execute: function() {
+	var _ref2 = require_asyncToGenerator._asyncToGenerator(function* (context, input, signal) {
+		const mutation = yield context.host.sales.updateQuantity(input, signal);
+		return require_cartConsistency.finalizeCartMutation(context, mutation, signal, () => {
+			var _mutation$data$confir;
+			if (mutation.status === "succeeded" && mutation.data.affectedLineId === input.lineId && ((_mutation$data$confir = mutation.data.confirmedLine) === null || _mutation$data$confir === void 0 ? void 0 : _mutation$data$confir.lineId) === input.lineId && decimalValuesEqual(mutation.data.confirmedLine.quantity, input.quantity)) return true;
+			const line = context.host.sales.getObservedSnapshot().cart.lines.find((item) => item.lineId === input.lineId);
+			return decimalValuesEqual(line === null || line === void 0 ? void 0 : line.quantity, input.quantity);
+		});
+	});
+	return function execute(_x4, _x5, _x6) {
+		return _ref2.apply(this, arguments);
+	};
+}() });
+function decimalValuesEqual(left, right) {
+	if (left === void 0) return false;
+	const leftNumber = Number(left);
+	const rightNumber = Number(right);
+	return Number.isFinite(leftNumber) && Number.isFinite(rightNumber) && leftNumber === rightNumber;
+}
+const cartRemoveLineOperationBinding = require_types.bindOperation(require_operations.cartRemoveLineOperation, { execute: function() {
+	var _ref3 = require_asyncToGenerator._asyncToGenerator(function* (context, input, signal) {
+		const mutation = yield context.host.sales.removeLine(input, signal);
+		return require_cartConsistency.finalizeCartMutation(context, mutation, signal, () => mutation.status === "succeeded" && mutation.data.removedLineId === input.lineId || !context.host.sales.getObservedSnapshot().cart.lines.some((item) => item.lineId === input.lineId));
+	});
+	return function execute(_x7, _x8, _x9) {
+		return _ref3.apply(this, arguments);
+	};
+}() });
+//#endregion
+exports.cartAddProductOperationBinding = cartAddProductOperationBinding;
+exports.cartRemoveLineOperationBinding = cartRemoveLineOperationBinding;
+exports.cartUpdateQuantityOperationBinding = cartUpdateQuantityOperationBinding;

package/lib/components/HDLKiosk/{app → runtime}/operations/cartConsistency.js

@@ -1,6 +1,6 @@
 const require_asyncToGenerator = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js");
 const require_errors = require("./errors.js");
-//#region src/components/HDLKiosk/app/operations/cartConsistency.ts
+//#region src/components/HDLKiosk/runtime/operations/cartConsistency.ts
 function finalizeCartMutation(_x, _x2, _x3, _x4) {
 	return _finalizeCartMutation.apply(this, arguments);
 }

package/lib/components/HDLKiosk/{app → runtime}/operations/checkout.js

@@ -1,11 +1,23 @@
+const require_objectSpread2 = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js");
 const require_asyncToGenerator = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js");
+const require_operations = require("../../app/operations.js");
 const require_errors = require("./errors.js");
 const require_types = require("./types.js");
 const require_checkoutRequirements = require("./checkoutRequirements.js");
-//#region src/components/HDLKiosk/app/operations/checkout.ts
+//#region src/components/HDLKiosk/runtime/operations/checkout.ts
 function forwardFailure(result) {
 	return result;
 }
+const PAYMENT_ALREADY_STARTED_ERRORS = new Set([
+	"checkoutPaymentAlreadySettled",
+	"checkoutPaymentAlreadyStarted",
+	"checkoutAlreadyStarted"
+]);
+/** 标记当前支付命令尚未进入 Host dispatch，供硬阻断策略安全放行。 */
+function forwardPreDispatchFailure(result) {
+	if ((result.status === "partialFailure" || result.status === "unknown") && !PAYMENT_ALREADY_STARTED_ERRORS.has(result.error.code)) return require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, result), {}, { error: require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, result.error), {}, { details: require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, result.error.details), {}, { checkoutDispatched: false }) }) });
+	return result;
+}
 function evaluateCheckoutRequirements(context, sales) {
 	return require_checkoutRequirements.defaultCheckoutRequirementRegistry.evaluate(context.checkoutRequirementIds, {
 		workflow: context.workflowContext,
@@ -98,126 +110,99 @@ function _ensureCheckoutPrepared() {
 	});
 	return _ensureCheckoutPrepared.apply(this, arguments);
 }
-const checkoutPrepareOperation = require_types.defineOperation({
-	id: "checkout.prepare",
-	conflictScope: "checkout",
-	timeoutMs: 2e4,
-	retry: "explicit-user",
-	execute: (context, _input, signal) => {
-		const fulfillment = context.workflowContext.fulfillment;
-		return prepareCheckout(context, signal, fulfillment ? { mode: fulfillment } : void 0);
-	}
-});
-const checkoutOpenOperation = require_types.defineOperation({
-	id: "checkout.open",
-	tags: ["checkout-dispatch"],
-	conflictScope: "checkout",
-	timeoutMs: 12e4,
-	retry: "never",
-	execute: function() {
-		var _ref = require_asyncToGenerator._asyncToGenerator(function* (context, _input, signal) {
-			const { host, checkoutSafety, sessionEpoch } = context;
-			const preparation = yield ensureCheckoutPrepared(context, signal);
-			if (preparation.status !== "succeeded") return forwardFailure(preparation);
-			const snapshot = host.sales.getObservedSnapshot();
-			const requirements = evaluateCheckoutRequirements(context, snapshot);
-			const validationFailure = requirementFailure(requirements);
-			if (validationFailure) return validationFailure;
-			const decision = checkoutSafety.beginOpen(snapshot, sessionEpoch, requirements.requirementIds);
-			if (decision.status === "rejected") return decision.reason === "checkoutAlreadyStarted" ? require_errors.operationUnknown(decision.reason) : require_errors.operationFailed(decision.reason, "back");
-			if (signal.aborted) {
-				const result = {
-					status: "cancelled",
-					reason: "checkoutAbortedBeforeDispatch"
-				};
-				checkoutSafety.settle(result);
-				return result;
-			}
-			let result;
-			try {
-				result = yield host.sales.openCheckout(signal);
-			} catch (error) {
-				result = require_errors.operationUnknown("checkoutInvocationUnhandled", error);
-			}
+const checkoutPrepareOperationBinding = require_types.bindOperation(require_operations.checkoutPrepareOperation, { execute: (context, _input, signal) => {
+	const fulfillment = context.workflowContext.fulfillment;
+	return prepareCheckout(context, signal, fulfillment ? { mode: fulfillment } : void 0);
+} });
+const checkoutOpenOperationBinding = require_types.bindOperation(require_operations.checkoutOpenOperation, { execute: function() {
+	var _ref = require_asyncToGenerator._asyncToGenerator(function* (context, _input, signal) {
+		const { host, checkoutSafety, sessionEpoch } = context;
+		const preparation = yield ensureCheckoutPrepared(context, signal);
+		if (preparation.status !== "succeeded") return forwardPreDispatchFailure(preparation);
+		const snapshot = host.sales.getObservedSnapshot();
+		const requirements = evaluateCheckoutRequirements(context, snapshot);
+		const validationFailure = requirementFailure(requirements);
+		if (validationFailure) return validationFailure;
+		const decision = checkoutSafety.beginOpen(snapshot, sessionEpoch, requirements.requirementIds);
+		if (decision.status === "rejected") return decision.reason === "checkoutAlreadyStarted" ? require_errors.operationUnknown(decision.reason) : require_errors.operationFailed(decision.reason, "back");
+		if (signal.aborted) {
+			const result = {
+				status: "cancelled",
+				reason: "checkoutAbortedBeforeDispatch"
+			};
 			checkoutSafety.settle(result);
 			return result;
-		});
-		return function execute(_x8, _x9, _x10) {
-			return _ref.apply(this, arguments);
-		};
-	}()
-});
+		}
+		let result;
+		try {
+			result = yield host.sales.openCheckout(signal);
+		} catch (error) {
+			result = require_errors.operationUnknown("checkoutInvocationUnhandled", error);
+		}
+		checkoutSafety.settle(result);
+		return result;
+	});
+	return function execute(_x8, _x9, _x10) {
+		return _ref.apply(this, arguments);
+	};
+}() });
 /** Kiosk EFTPOS 直连入口：Host 只能调用嵌入式 PaymentMethodRuntime。 */
-const checkoutPayEftposOperation = require_types.defineOperation({
-	id: "checkout.payEftpos",
-	tags: ["checkout-dispatch"],
-	conflictScope: "checkout",
-	timeoutMs: 12e4,
-	retry: "never",
-	execute: function() {
-		var _ref2 = require_asyncToGenerator._asyncToGenerator(function* (context, input, signal) {
-			const { host, checkoutSafety, sessionEpoch } = context;
-			const preparation = yield ensureCheckoutPrepared(context, signal);
-			if (preparation.status !== "succeeded") return forwardFailure(preparation);
-			const snapshot = host.sales.getObservedSnapshot();
-			const requirements = evaluateCheckoutRequirements(context, snapshot);
-			const validationFailure = requirementFailure(requirements);
-			if (validationFailure) return validationFailure;
-			const decision = checkoutSafety.beginOpen(snapshot, sessionEpoch, requirements.requirementIds);
-			if (decision.status === "rejected") return decision.reason === "checkoutAlreadyStarted" ? require_errors.operationUnknown(decision.reason) : require_errors.operationFailed(decision.reason, "back");
-			if (signal.aborted) {
-				const result = {
-					status: "cancelled",
-					reason: "checkoutAbortedBeforeDispatch"
-				};
-				checkoutSafety.settle(result);
-				return result;
-			}
-			let result;
-			try {
-				result = yield host.sales.payEftpos(input, signal);
-			} catch (error) {
-				result = require_errors.operationUnknown("checkoutInvocationUnhandled", error);
-			}
-			if (result.status === "succeeded" && !(yield waitForPaymentProjection(context, signal))) result = require_errors.operationUnknown("checkoutPaymentProjectionNotConfirmed");
+const checkoutPayEftposOperationBinding = require_types.bindOperation(require_operations.checkoutPayEftposOperation, { execute: function() {
+	var _ref2 = require_asyncToGenerator._asyncToGenerator(function* (context, input, signal) {
+		const { host, checkoutSafety, sessionEpoch } = context;
+		const preparation = yield ensureCheckoutPrepared(context, signal);
+		if (preparation.status !== "succeeded") return forwardPreDispatchFailure(preparation);
+		const snapshot = host.sales.getObservedSnapshot();
+		const requirements = evaluateCheckoutRequirements(context, snapshot);
+		const validationFailure = requirementFailure(requirements);
+		if (validationFailure) return validationFailure;
+		const decision = checkoutSafety.beginOpen(snapshot, sessionEpoch, requirements.requirementIds);
+		if (decision.status === "rejected") return decision.reason === "checkoutAlreadyStarted" ? require_errors.operationUnknown(decision.reason) : require_errors.operationFailed(decision.reason, "back");
+		if (signal.aborted) {
+			const result = {
+				status: "cancelled",
+				reason: "checkoutAbortedBeforeDispatch"
+			};
 			checkoutSafety.settle(result);
 			return result;
-		});
-		return function execute(_x11, _x12, _x13) {
-			return _ref2.apply(this, arguments);
-		};
-	}()
-});
+		}
+		let result;
+		try {
+			result = yield host.sales.payEftpos(input, signal);
+		} catch (error) {
+			result = require_errors.operationUnknown("checkoutInvocationUnhandled", error);
+		}
+		if (result.status === "succeeded" && !(yield waitForPaymentProjection(context, signal))) result = require_errors.operationUnknown("checkoutPaymentProjectionNotConfirmed");
+		checkoutSafety.settle(result);
+		return result;
+	});
+	return function execute(_x11, _x12, _x13) {
+		return _ref2.apply(this, arguments);
+	};
+}() });
 /** 店员付款只请求主屏授权；授权派发绝不视作付款成功。 */
-const checkoutRequestStaffPaymentApprovalOperation = require_types.defineOperation({
-	id: "checkout.requestStaffPaymentApproval",
-	tags: ["checkout-authorization"],
-	conflictScope: "checkout",
-	timeoutMs: 2e4,
-	retry: "explicit-user",
-	execute: function() {
-		var _ref3 = require_asyncToGenerator._asyncToGenerator(function* (context, input, signal) {
-			const preparation = yield ensureCheckoutPrepared(context, signal);
-			if (preparation.status !== "succeeded") return forwardFailure(preparation);
-			const validationFailure = requirementFailure(evaluateCheckoutRequirements(context, context.host.sales.getObservedSnapshot()));
-			if (validationFailure) return validationFailure;
-			if (signal.aborted) return {
-				status: "cancelled",
-				reason: "authorizationAborted"
-			};
-			return context.host.sales.requestStaffPaymentApproval(input, signal);
-		});
-		return function execute(_x14, _x15, _x16) {
-			return _ref3.apply(this, arguments);
+const checkoutRequestStaffPaymentApprovalOperationBinding = require_types.bindOperation(require_operations.checkoutRequestStaffPaymentApprovalOperation, { execute: function() {
+	var _ref3 = require_asyncToGenerator._asyncToGenerator(function* (context, input, signal) {
+		const preparation = yield ensureCheckoutPrepared(context, signal);
+		if (preparation.status !== "succeeded") return forwardFailure(preparation);
+		const validationFailure = requirementFailure(evaluateCheckoutRequirements(context, context.host.sales.getObservedSnapshot()));
+		if (validationFailure) return validationFailure;
+		if (signal.aborted) return {
+			status: "cancelled",
+			reason: "authorizationAborted"
 		};
-	}()
-});
+		return context.host.sales.requestStaffPaymentApproval(input, signal);
+	});
+	return function execute(_x14, _x15, _x16) {
+		return _ref3.apply(this, arguments);
+	};
+}() });
 const MONEY = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
 function isSafeMoney(value) {
 	return MONEY.test(value) && Number.isFinite(Number(value));
 }
 //#endregion
-exports.checkoutOpenOperation = checkoutOpenOperation;
-exports.checkoutPayEftposOperation = checkoutPayEftposOperation;
-exports.checkoutPrepareOperation = checkoutPrepareOperation;
-exports.checkoutRequestStaffPaymentApprovalOperation = checkoutRequestStaffPaymentApprovalOperation;
+exports.checkoutOpenOperationBinding = checkoutOpenOperationBinding;
+exports.checkoutPayEftposOperationBinding = checkoutPayEftposOperationBinding;
+exports.checkoutPrepareOperationBinding = checkoutPrepareOperationBinding;
+exports.checkoutRequestStaffPaymentApprovalOperationBinding = checkoutRequestStaffPaymentApprovalOperationBinding;

package/lib/components/HDLKiosk/{app → runtime}/operations/checkoutRequirements.js

@@ -1,5 +1,5 @@
 const require_objectSpread2 = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js");
-//#region src/components/HDLKiosk/app/operations/checkoutRequirements.ts
+//#region src/components/HDLKiosk/runtime/operations/checkoutRequirements.ts
 function createCheckoutRequirementRegistry(definitions) {
 	const byId = /* @__PURE__ */ new Map();
 	definitions.forEach((definition) => {

package/lib/components/HDLKiosk/{app → runtime}/operations/checkoutSafety.js

@@ -1,5 +1,5 @@
 const require_objectSpread2 = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js");
-//#region src/components/HDLKiosk/app/operations/checkoutSafety.ts
+//#region src/components/HDLKiosk/runtime/operations/checkoutSafety.ts
 const DEFAULT_TOKEN_TTL_MS = 3e4;
 function createCheckoutSafetyController({ tokenTtlMs = DEFAULT_TOKEN_TTL_MS, now = Date.now } = {}) {
 	if (!Number.isFinite(tokenTtlMs) || tokenTtlMs <= 0) throw new Error("HDLKiosk checkout token TTL must be positive");

package/lib/components/HDLKiosk/{app → runtime}/operations/coordinator.js

@@ -1,8 +1,8 @@
 const require_objectSpread2 = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js");
-const require_errors = require("./errors.js");
 const require_coordinator = require("../../kernel/operations/coordinator.js");
+const require_errors = require("./errors.js");
 const require_checkoutSafety = require("./checkoutSafety.js");
-//#region src/components/HDLKiosk/app/operations/coordinator.ts
+//#region src/components/HDLKiosk/runtime/operations/coordinator.ts
 function conflicts(left, right) {
 	if (left === "none" || right === "none") return false;
 	if (left === "session" || right === "session") return true;