@pisell/private-materials 6.12.168 → 6.12.169

package/lib/components/HDLKiosk/kernel/workflow/compiler.js

@@ -30,7 +30,7 @@ function resolveRepeat(value, path, issues) {
 		exceeded: "blocked"
 	});
 }
-function canReachSuccess(initial, nodes) {
+function canReachTerminal(initial, nodes) {
 	const visited = /* @__PURE__ */ new Set();
 	const pending = [initial];
 	while (pending.length > 0) {
@@ -39,7 +39,7 @@ function canReachSuccess(initial, nodes) {
 		visited.add(stepId);
 		const node = nodes[stepId];
 		if (!node) continue;
-		if (node.end === "success") return true;
+		if (node.isTerminal) return true;
 		Object.values(node.on).forEach((transition) => {
 			if (transition) pending.push(transition.target);
 		});
@@ -123,10 +123,10 @@ function compileWorkflowStructure(input, options) {
 			"visitPolicy",
 			"useGuards",
 			"on",
-			"end",
-			"screen"
+			"isTerminal",
+			"surface"
 		], stepPath, issues);
-		if (rawStep.screen !== void 0) addIssue(issues, "step.screen.forbidden", `${stepPath}.screen`, "Screen is resolved by the local Activity Contract");
+		if (rawStep.surface !== void 0) addIssue(issues, "step.surface.forbidden", `${stepPath}.surface`, "Surface is resolved by the local Activity Contract");
 		if (rawStep.visitPolicy !== void 0 && rawStep.visitPolicy !== "always" && rawStep.visitPolicy !== "once") addIssue(issues, "step.visitPolicy.invalid", `${stepPath}.visitPolicy`, "Step visitPolicy must be always or once");
 		const activityValue = rawStep.activity;
 		if (typeof activityValue !== "string" || !activities.has(activityValue)) addIssue(issues, "activity.unknown", `${stepPath}.activity`, `Unknown activity: ${String(activityValue)}`);
@@ -168,7 +168,7 @@ function compileWorkflowStructure(input, options) {
 			else if (rawPresentation.mode === "modal") presentation = { mode: "modal" };
 		}
 		if (rawStep.readiness !== void 0 && rawStep.readiness !== "implemented" && rawStep.readiness !== "placeholder") addIssue(issues, "step.readiness.invalid", `${stepPath}.readiness`, "Step readiness must be implemented or placeholder");
-		if (rawStep.end !== void 0 && rawStep.end !== "success" && rawStep.end !== "blocked") addIssue(issues, "step.end.invalid", `${stepPath}.end`, "Step end must be success or blocked");
+		if (rawStep.isTerminal !== void 0 && typeof rawStep.isTerminal !== "boolean") addIssue(issues, "step.isTerminal.invalid", `${stepPath}.isTerminal`, "Step isTerminal must be a boolean");
 		if (rawStep.on !== void 0 && !isRecord(rawStep.on)) addIssue(issues, "step.intents.invalid", `${stepPath}.on`, "Step intents must be an object");
 		const transitions = {};
 		const addTransition = (intent, rawTarget, path) => {
@@ -228,13 +228,13 @@ function compileWorkflowStructure(input, options) {
 		nodes[stepId] = Object.freeze({
 			id: stepId,
 			activity: activity.id,
-			screenId: activity.screenId,
+			surfaceId: activity.surfaceId,
 			presentation,
 			readiness: rawStep.readiness === "placeholder" ? "placeholder" : void 0,
 			visitPolicy: rawStep.visitPolicy === "once" ? "once" : "always",
 			guardPhases: Object.freeze([...guardPhases]),
 			on: Object.freeze(transitions),
-			end: rawStep.end === "success" || rawStep.end === "blocked" ? rawStep.end : void 0
+			isTerminal: rawStep.isTerminal === true ? true : void 0
 		});
 	});
 	if (transitionCount > maxTransitions) addIssue(issues, "workflow.transitions.limit", "steps", `Workflow cannot contain more than ${maxTransitions} transitions`);
@@ -248,8 +248,8 @@ function compileWorkflowStructure(input, options) {
 			var _nodes$transition$tar;
 			if (node.presentation.mode === "modal" && transition && ((_nodes$transition$tar = nodes[transition.target]) === null || _nodes$transition$tar === void 0 ? void 0 : _nodes$transition$tar.presentation.mode) === "modal") addIssue(issues, "transition.modal.nested", `${path}.on.${intent}`, "A modal step cannot navigate directly to another modal step");
 		});
-		if (!node.end && transitions.length === 0) addIssue(issues, "step.deadEnd", path, "A step without outgoing transitions must declare its end state");
-		if (node.end && transitions.length > 0) addIssue(issues, "step.end.hasTransitions", path, "An end step cannot expose outgoing transitions");
+		if (!node.isTerminal && transitions.length === 0) addIssue(issues, "step.deadEnd", path, "A step without outgoing transitions must declare isTerminal: true");
+		if (node.isTerminal && transitions.length > 0) addIssue(issues, "step.isTerminal.hasTransitions", path, "A terminal step cannot expose outgoing transitions");
 		transitions.forEach(([intent, transition]) => {
 			var _stepIndex$get2, _stepIndex$get3;
 			if (!transition) return;
@@ -267,15 +267,14 @@ function compileWorkflowStructure(input, options) {
 	const reachable = initial ? reachableSteps(initial, nodes) : /* @__PURE__ */ new Set();
 	const unreachable = Object.keys(nodes).filter((stepId) => !reachable.has(stepId));
 	if (unreachable.length > 0) addIssue(issues, "workflow.steps.unreachable", "steps", `Every step must be reachable from the first step: ${unreachable.join(", ")}`);
-	if (initial && nodes[initial] && !canReachSuccess(initial, nodes)) addIssue(issues, "workflow.success.unreachable", "steps", "The first step cannot reach a successful end");
+	if (initial && nodes[initial] && !canReachTerminal(initial, nodes)) addIssue(issues, "workflow.terminal.unreachable", "steps", "The first step cannot reach a terminal step");
 	if (issues.length > 0) return {
 		status: "invalid",
 		issues: Object.freeze(issues)
 	};
 	const requirements = Object.freeze([...new Set(Object.values(nodes).flatMap((node) => {
-		var _ref, _activity$requirement;
-		const activity = activities.require(node.activity);
-		return (_ref = (_activity$requirement = activity.requirements) !== null && _activity$requirement !== void 0 ? _activity$requirement : activity.checkoutRequirements) !== null && _ref !== void 0 ? _ref : [];
+		var _activity$requirement;
+		return (_activity$requirement = activities.require(node.activity).requirements) !== null && _activity$requirement !== void 0 ? _activity$requirement : [];
 	}))]);
 	return {
 		status: "valid",
@@ -284,8 +283,7 @@ function compileWorkflowStructure(input, options) {
 			initial,
 			stepOrder: Object.freeze([...stepIds]),
 			nodes: Object.freeze(nodes),
-			requirements,
-			checkoutRequirements: requirements
+			requirements
 		})
 	};
 }

package/lib/components/HDLKiosk/runtime/createRuntime.js

@@ -0,0 +1,239 @@
+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_runtime = require("../kernel/application/runtime.js");
+const require_manifest = require("../app/manifest.js");
+const require_registry = require("../app/workflow/registry.js");
+const require_triggers = require("./triggers.js");
+const require_scannerSessionRouter = require("./devices/scannerSessionRouter.js");
+const require_scannerSessionPort = require("./devices/scannerSessionPort.js");
+const require_createSession = require("./session/createSession.js");
+//#region src/components/HDLKiosk/runtime/createRuntime.ts
+function resolveHDLKioskEntryCapabilityBlockReason({ entry, capabilities, primaryWeightedProductId }) {
+	if (!capabilities.session.ensure) return "sessionEnsureUnavailable";
+	if (entry === "barcode") return capabilities.scanner.available ? void 0 : "scannerUnavailable";
+	if (!capabilities.products.primaryWeightedProductQuery || !primaryWeightedProductId) return "primaryProductUnavailable";
+	if (require_registry.builtInWorkflowHasActivity(entry, "customization") && (!capabilities.customization.weightedProduct || !capabilities.scale.available)) return "customizationUnavailable";
+	if (entry === "scale" && (!capabilities.scale.available || !capabilities.scale.weightChangeTrigger)) return "scaleTriggerUnavailable";
+}
+const ENTRY_BY_WORKFLOW_ID = Object.freeze({
+	"hdl.quick": "quick",
+	"hdl.barcode": "barcode",
+	"hdl.scale": "scale"
+});
+function readStartPayload(payload) {
+	if (!payload || typeof payload !== "object") return {};
+	return payload;
+}
+function createHDLKioskApplicationRuntime(host, options) {
+	let sessionSequence = 0;
+	let active = false;
+	let disposed = false;
+	let startPromise;
+	let returnPromise;
+	let returnSequence = 0;
+	let snapshot = Object.freeze({
+		starting: false,
+		returning: false
+	});
+	const listeners = /* @__PURE__ */ new Set();
+	const { config } = options;
+	const scannerRouter = require_scannerSessionRouter.createScannerSessionRouter({
+		host,
+		entrySupported: config.enabledEntries.includes("barcode")
+	});
+	const runtime = require_runtime.createApplicationRuntime({
+		definition: require_manifest.hdlKioskApplication,
+		triggerAdapters: require_triggers.createHDLKioskEntryTriggerAdapters(host, config, scannerRouter.triggerAdapter),
+		maxActiveSessions: 1,
+		sessionFactory: {
+			create: function() {
+				var _ref = require_asyncToGenerator._asyncToGenerator(function* ({ workflowId, payload, cause }) {
+					if (!scannerRouter.beginSessionStart(cause.correlationId)) throw new Error(`Scanner Session start conflict: ${cause.correlationId}`);
+					try {
+						const entry = ENTRY_BY_WORKFLOW_ID[workflowId];
+						if (!entry) throw new Error(`Unknown HDLKiosk Workflow: ${workflowId}`);
+						const startPayload = readStartPayload(payload);
+						sessionSequence += 1;
+						const session = require_createSession.createHDLKioskWorkflowSession(entry, host, {
+							sessionId: `${require_manifest.hdlKioskApplication.id}:${sessionSequence}`,
+							initialContext: startPayload.initialContext,
+							primaryWeightedProductId: config.primaryWeightedProductId,
+							cause
+						});
+						const ensured = yield session.ensure(`start:${cause.trigger}:${cause.occurrenceId}`);
+						if (ensured.status !== "succeeded") {
+							session.dispose();
+							throw new Error(ensured.status === "failed" || ensured.status === "partialFailure" || ensured.status === "unknown" ? `HDLKiosk Session ensure failed: ${ensured.error.traceId}` : "HDLKiosk Session ensure cancelled");
+						}
+						return session;
+					} catch (error) {
+						scannerRouter.failSessionStart(cause.correlationId);
+						throw error;
+					}
+				});
+				return function create(_x) {
+					return _ref.apply(this, arguments);
+				};
+			}(),
+			onStarted: ({ session, cause }) => {
+				if (!session.isActive()) {
+					scannerRouter.failSessionStart(cause.correlationId);
+					throw new Error(`Inactive HDLKiosk Session started: ${session.id}`);
+				}
+				if (!scannerRouter.bindSession(cause.correlationId, require_scannerSessionPort.createHDLKioskScannerSessionPort(host, session))) throw new Error(`Scanner Session bind conflict: ${cause.correlationId}`);
+			}
+		}
+	});
+	const updateSnapshot = (next) => {
+		const candidate = Object.freeze(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, snapshot), next));
+		if (candidate.session === snapshot.session && candidate.starting === snapshot.starting && candidate.startErrorReference === snapshot.startErrorReference && candidate.returning === snapshot.returning && candidate.returnError === snapshot.returnError) return;
+		snapshot = candidate;
+		listeners.forEach((listener) => listener());
+	};
+	const unsubscribeSessions = runtime.sessions.subscribe((event) => {
+		var _snapshot$session;
+		if (event.type === "started") {
+			updateSnapshot({
+				session: event.session,
+				starting: false,
+				startErrorReference: void 0,
+				returning: false,
+				returnError: void 0
+			});
+			return;
+		}
+		if (((_snapshot$session = snapshot.session) === null || _snapshot$session === void 0 ? void 0 : _snapshot$session.id) === event.sessionId) updateSnapshot({ session: void 0 });
+	});
+	const disposeSession = (sessionId) => {
+		if (!runtime.disposeSession(sessionId)) return false;
+		scannerRouter.releaseSession(sessionId);
+		return true;
+	};
+	const completeReset = (session) => {
+		if (snapshot.session !== session) return;
+		disposeSession(session.id);
+	};
+	const applicationRuntime = {
+		id: runtime.id,
+		getSnapshot: () => snapshot,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		activate: () => {
+			runtime.activate();
+			active = true;
+		},
+		deactivate: () => {
+			active = false;
+			runtime.deactivate();
+		},
+		start: (entry) => {
+			if (!active || !config.enabledEntries.includes(entry)) return Promise.resolve(void 0);
+			if (startPromise) return startPromise;
+			if (config.businessMode === "production" && !require_registry.isBuiltInWorkflowProductionReady(entry)) {
+				updateSnapshot({ startErrorReference: `workflow-placeholder-blocked-${Date.now()}` });
+				return Promise.resolve(void 0);
+			}
+			const capabilityBlockReason = resolveHDLKioskEntryCapabilityBlockReason({
+				entry,
+				capabilities: host.capabilities,
+				primaryWeightedProductId: config.primaryWeightedProductId
+			});
+			if (capabilityBlockReason) {
+				if (capabilityBlockReason === "sessionEnsureUnavailable") updateSnapshot({ startErrorReference: `session-ensure-unavailable-${Date.now()}` });
+				return Promise.resolve(void 0);
+			}
+			const current = snapshot.session;
+			if (current) return Promise.resolve(current.entry === entry ? current : void 0);
+			updateSnapshot({
+				starting: true,
+				startErrorReference: void 0
+			});
+			const launch = runtime.workflow("hdl.quick").start().then((session) => {
+				if (active && !disposed) return session;
+				disposeSession(session.id);
+			}).catch(() => {
+				if (!snapshot.session && active && !disposed) updateSnapshot({ startErrorReference: `session-start-failed-${Date.now()}` });
+			}).finally(() => {
+				if (startPromise === launch) {
+					startPromise = void 0;
+					updateSnapshot({ starting: false });
+				}
+			});
+			startPromise = launch;
+			return launch;
+		},
+		completeReset,
+		returnToEntry: (reason = "application") => {
+			if (returnPromise) return returnPromise;
+			const current = snapshot.session;
+			if (!current) return Promise.resolve({
+				status: "succeeded",
+				data: void 0
+			});
+			returnSequence += 1;
+			updateSnapshot({
+				returning: true,
+				returnError: void 0
+			});
+			const pending = current.reset(`return:${reason}:${returnSequence}`).then((result) => {
+				if (result.status === "succeeded") {
+					updateSnapshot({ returning: false });
+					completeReset(current);
+					return result;
+				}
+				updateSnapshot({
+					returning: false,
+					returnError: result.status === "failed" || result.status === "partialFailure" || result.status === "unknown" ? result.error : {
+						code: "resetCancelled",
+						source: "operation",
+						recovery: "staff",
+						safeMessageKey: "hdlKiosk.error.resetCancelled",
+						traceId: `hdl-reset-cancelled-${Date.now()}`
+					}
+				});
+				return result;
+			}).catch((cause) => {
+				const error = {
+					code: "resetUnhandled",
+					source: "operation",
+					recovery: "staff",
+					safeMessageKey: "hdlKiosk.error.resetUnhandled",
+					traceId: `hdl-reset-unhandled-${Date.now()}`,
+					cause
+				};
+				updateSnapshot({
+					returning: false,
+					returnError: error
+				});
+				return {
+					status: "failed",
+					error
+				};
+			}).finally(() => {
+				if (returnPromise === pending) returnPromise = void 0;
+			});
+			returnPromise = pending;
+			return pending;
+		},
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			active = false;
+			runtime.dispose();
+			scannerRouter.dispose();
+			unsubscribeSessions();
+			snapshot = Object.freeze({
+				starting: false,
+				returning: false
+			});
+			listeners.forEach((listener) => listener());
+			listeners.clear();
+		}
+	};
+	return Object.freeze(applicationRuntime);
+}
+//#endregion
+exports.createHDLKioskApplicationRuntime = createHDLKioskApplicationRuntime;
+exports.resolveHDLKioskEntryCapabilityBlockReason = resolveHDLKioskEntryCapabilityBlockReason;

package/lib/components/HDLKiosk/{devices → runtime/devices}/dedupeStore.js

@@ -1,4 +1,4 @@
-//#region src/components/HDLKiosk/devices/dedupeStore.ts
+//#region src/components/HDLKiosk/runtime/devices/dedupeStore.ts
 const DEFAULT_MAX_ENTRIES = 256;
 const DEFAULT_TTL_MS = 2 * 6e4;
 function createDedupeStore({ maxEntries = DEFAULT_MAX_ENTRIES, ttlMs = DEFAULT_TTL_MS, now = Date.now } = {}) {

package/lib/components/HDLKiosk/{devices → runtime/devices}/scaleIngress.js

@@ -1,5 +1,5 @@
 const require_dedupeStore = require("./dedupeStore.js");
-//#region src/components/HDLKiosk/devices/scaleIngress.ts
+//#region src/components/HDLKiosk/runtime/devices/scaleIngress.ts
 const NON_NEGATIVE_DECIMAL = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
 function isValidWeightChange(weight) {
 	if (weight.unit !== "g" && weight.unit !== "kg") return false;

package/lib/components/HDLKiosk/{devices/scale/runtime.js → runtime/devices/scaleStore.js}

@@ -1,20 +1,13 @@
-const require_runtime = require("../../../../_virtual/_rolldown/runtime.js");
 const require_objectSpread2 = require("../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js");
-let react = require("react");
-react = require_runtime.__toESM(react);
-//#region src/components/HDLKiosk/devices/scale/runtime.ts
-/**
-* 文件角色：提供 HDLKiosk 生命周期内唯一的电子秤 Snapshot Hub 和 React Provider。
-* 运行机制：BigSale NativeScale owner 持续 publish 原始读数/连接状态，Entry 和称重详情
-* 通过 useSyncExternalStore 共享读取；是否消费由当前 Screen/Ingress 决定。
-* 边界：Runtime 不执行业务跳转，也不直接写购物车。
-*/
+//#region src/components/HDLKiosk/runtime/devices/scaleStore.ts
 const EMPTY_SNAPSHOT = Object.freeze({
 	active: false,
 	revision: 0,
 	status: null,
 	connectionState: null,
-	isListening: false
+	isListening: false,
+	hasLiveSample: false,
+	sampleSequence: 0
 });
 /**
 * HDLKiosk 生命周期内唯一的称重快照仓库。
@@ -23,6 +16,7 @@ const EMPTY_SNAPSHOT = Object.freeze({
 function createHDLScaleRuntime() {
 	const listeners = /* @__PURE__ */ new Set();
 	let snapshot = EMPTY_SNAPSHOT;
+	let invalidatedAtSampleSequence = 0;
 	const emit = () => listeners.forEach((listener) => listener());
 	return {
 		getSnapshot: () => snapshot,
@@ -31,6 +25,7 @@ function createHDLScaleRuntime() {
 			return () => listeners.delete(listener);
 		},
 		activate: (ownerId) => {
+			invalidatedAtSampleSequence = 0;
 			snapshot = Object.freeze(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, EMPTY_SNAPSHOT), {}, {
 				active: true,
 				ownerId,
@@ -46,14 +41,22 @@ function createHDLScaleRuntime() {
 		publish: (ownerId, publication) => {
 			var _ref, _publication$status, _publication$rawData, _ref2, _publication$connecti, _publication$rawData2, _ref3, _publication$updatedA, _publication$rawData3;
 			if (!snapshot.active || snapshot.ownerId !== ownerId) return;
+			const sampleSequence = Number.isFinite(publication.sampleSequence) ? Math.max(snapshot.sampleSequence, Number(publication.sampleSequence)) : snapshot.sampleSequence;
+			const status = (_ref = (_publication$status = publication.status) !== null && _publication$status !== void 0 ? _publication$status : (_publication$rawData = publication.rawData) === null || _publication$rawData === void 0 ? void 0 : _publication$rawData.status) !== null && _ref !== void 0 ? _ref : null;
+			const connectionState = (_ref2 = (_publication$connecti = publication.connectionState) !== null && _publication$connecti !== void 0 ? _publication$connecti : (_publication$rawData2 = publication.rawData) === null || _publication$rawData2 === void 0 ? void 0 : _publication$rawData2.connectionState) !== null && _ref2 !== void 0 ? _ref2 : null;
+			const isListening = publication.isListening === true;
+			const healthy = connectionState === "connected" && isListening && !publication.error && status !== "overload" && status !== "negative";
+			if (!healthy) invalidatedAtSampleSequence = sampleSequence;
 			snapshot = Object.freeze({
 				active: true,
 				ownerId,
 				revision: snapshot.revision + 1,
 				grossWeightKg: publication.grossWeightKg,
-				status: (_ref = (_publication$status = publication.status) !== null && _publication$status !== void 0 ? _publication$status : (_publication$rawData = publication.rawData) === null || _publication$rawData === void 0 ? void 0 : _publication$rawData.status) !== null && _ref !== void 0 ? _ref : null,
-				connectionState: (_ref2 = (_publication$connecti = publication.connectionState) !== null && _publication$connecti !== void 0 ? _publication$connecti : (_publication$rawData2 = publication.rawData) === null || _publication$rawData2 === void 0 ? void 0 : _publication$rawData2.connectionState) !== null && _ref2 !== void 0 ? _ref2 : null,
-				isListening: publication.isListening === true,
+				status,
+				connectionState,
+				isListening,
+				hasLiveSample: healthy && sampleSequence > invalidatedAtSampleSequence,
+				sampleSequence,
 				rawData: publication.rawData,
 				error: publication.error,
 				updatedAt: (_ref3 = (_publication$updatedA = publication.updatedAt) !== null && _publication$updatedA !== void 0 ? _publication$updatedA : (_publication$rawData3 = publication.rawData) === null || _publication$rawData3 === void 0 ? void 0 : _publication$rawData3.timestamp) !== null && _ref3 !== void 0 ? _ref3 : Date.now()
@@ -62,18 +65,5 @@ function createHDLScaleRuntime() {
 		}
 	};
 }
-const HDLScaleRuntimeContext = (0, react.createContext)(createHDLScaleRuntime());
-function HDLScaleRuntimeProvider({ runtime, children }) {
-	return react.default.createElement(HDLScaleRuntimeContext.Provider, {
-		value: runtime,
-		children
-	});
-}
-function useHDLScaleSnapshot() {
-	const runtime = (0, react.useContext)(HDLScaleRuntimeContext);
-	return (0, react.useSyncExternalStore)(runtime.subscribe, runtime.getSnapshot, runtime.getSnapshot);
-}
 //#endregion
-exports.HDLScaleRuntimeProvider = HDLScaleRuntimeProvider;
 exports.createHDLScaleRuntime = createHDLScaleRuntime;
-exports.useHDLScaleSnapshot = useHDLScaleSnapshot;

package/lib/components/HDLKiosk/{devices → runtime/devices}/scannerIngress.js

@@ -1,5 +1,5 @@
 const require_dedupeStore = require("./dedupeStore.js");
-//#region src/components/HDLKiosk/devices/scannerIngress.ts
+//#region src/components/HDLKiosk/runtime/devices/scannerIngress.ts
 function createScannerIngress({ maxPendingEvents = 20, dedupe = require_dedupeStore.createDedupeStore() } = {}) {
 	if (!Number.isInteger(maxPendingEvents) || maxPendingEvents < 1) throw new Error("HDLKiosk scanner queue limit must be a positive integer");
 	return {

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;