@pisell/private-materials 6.12.167 → 6.12.169

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

@@ -8,13 +8,12 @@ function createWorkflowError(code, recovery, cause) {
 		code,
 		source: "workflow",
 		recovery,
-		safeMessageKey: `hdlKiosk.error.${code}`,
-		traceId: `hdl-workflow-${Date.now()}-${workflowErrorSequence}`,
+		safeMessageKey: `workflow.error.${code}`,
+		traceId: `workflow-${Date.now()}-${workflowErrorSequence}`,
 		cause
 	};
 }
 function createWorkflowActor({ definition, context, sessionEpoch, transitionRunner, lifecycle, reduceContext, beforeEach, now = Date.now, initialNodeId, initialError }) {
-	var _ref2;
 	const listeners = /* @__PURE__ */ new Set();
 	const mailbox = [];
 	let executionSequence = 0;
@@ -50,7 +49,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			visited.add(stepId);
 			const node = definition.nodes[stepId];
 			const storedResolution = stepResolutions.get(stepId);
-			if (!node || !storedResolution || node.visitPolicy !== "reuseResolution" && node.visitPolicy !== "once") return stepId;
+			if (!node || !storedResolution || storedResolution !== "omit" && node.visitPolicy !== "once") return stepId;
 			const transition = node.on[storedResolution];
 			if (!transition) return stepId;
 			stepId = transition.target;
@@ -116,7 +115,16 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			const direction = !fromNodeId ? "initial" : delta < 0 ? "backward" : "forward";
 			for (let candidateIndex = targetIndex; candidateIndex >= 0 && candidateIndex < definition.stepOrder.length; candidateIndex += delta) {
 				const candidateStepId = definition.stepOrder[candidateIndex];
-				if (definition.nodes[candidateStepId].visitPolicy === "once" && stepResolutions.has(candidateStepId)) continue;
+				const candidateNode = definition.nodes[candidateStepId];
+				if (candidateNode.presentation.mode === "modal") {
+					const fromNode = fromNodeId ? definition.nodes[fromNodeId] : void 0;
+					if (!fromNode || fromNode.presentation.mode === "modal") return {
+						type: "block",
+						error: createWorkflowError(fromNode ? "workflowNestedModalUnsupported" : "workflowModalRequiresPage", "staff")
+					};
+				}
+				const candidateResolution = stepResolutions.get(candidateStepId);
+				if (candidateResolution === "omit" || candidateNode.visitPolicy === "once" && candidateResolution) continue;
 				const decision = beforeEach({
 					navigationId,
 					intentId,
@@ -172,40 +180,56 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 		sessionEpoch,
 		workflowId: definition.id,
 		nodeId: startingNodeId,
-		status: initialError || initialResolutionError || startingNode.end === "blocked" ? "blocked" : startingNode.end === "success" ? "finished" : "idle",
+		status: initialError || initialResolutionError ? "blocked" : startingNode.isTerminal ? "finished" : "idle",
 		context: Object.freeze(require_objectSpread2._objectSpread2({}, context)),
 		completedStepIds: Object.freeze([]),
 		stepResolutions: Object.freeze({}),
+		surface: Object.freeze({
+			pageStepId: startingNodeId,
+			overlays: Object.freeze([])
+		}),
 		navigationHistory: Object.freeze([]),
-		lastError: (_ref2 = initialError !== null && initialError !== void 0 ? initialError : initialResolutionError) !== null && _ref2 !== void 0 ? _ref2 : startingNode.end === "blocked" ? createWorkflowError("workflowEndedBlocked", "staff") : void 0
+		lastError: initialError !== null && initialError !== void 0 ? initialError : initialResolutionError
 	});
 	const publish = (next) => {
 		snapshot = Object.freeze(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, next), {}, {
 			context: Object.freeze(require_objectSpread2._objectSpread2({}, next.context)),
 			completedStepIds: Object.freeze([...next.completedStepIds]),
 			stepResolutions: Object.freeze(require_objectSpread2._objectSpread2({}, next.stepResolutions)),
+			surface: Object.freeze({
+				pageStepId: next.surface.pageStepId,
+				overlays: Object.freeze([...next.surface.overlays])
+			}),
 			navigationHistory: Object.freeze([...next.navigationHistory]),
 			pendingNavigation: next.pendingNavigation ? Object.freeze(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, next.pendingNavigation), {}, {
 				to: Object.freeze(require_objectSpread2._objectSpread2({}, next.pendingNavigation.to)),
 				request: Object.freeze(require_objectSpread2._objectSpread2({}, next.pendingNavigation.request))
 			})) : void 0,
-			confirmedCheckout: next.confirmedCheckout,
+			receipt: next.receipt,
 			activeOperation: next.activeOperation ? Object.freeze(require_objectSpread2._objectSpread2({}, next.activeOperation)) : void 0
 		}));
 		listeners.forEach((listener) => listener());
 	};
 	const commit = function() {
-		var _ref3 = require_asyncToGenerator._asyncToGenerator(function* (fromNodeId, nodeId, event, nextContext, blocked, lastError, confirmedCheckout) {
+		var _ref2 = require_asyncToGenerator._asyncToGenerator(function* (fromNodeId, nodeId, event, nextContext, blocked, lastError, receipt) {
 			const node = definition.nodes[nodeId];
+			const surface = node.presentation.mode === "modal" ? Object.freeze({
+				pageStepId: snapshot.surface.pageStepId,
+				overlays: Object.freeze([nodeId])
+			}) : Object.freeze({
+				pageStepId: nodeId,
+				overlays: Object.freeze([])
+			});
 			publish(require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, snapshot), {}, {
 				nodeId,
-				status: blocked || node.end === "blocked" ? "blocked" : node.end === "success" ? "finished" : "idle",
+				status: blocked ? "blocked" : node.isTerminal ? "finished" : "idle",
 				context: nextContext,
 				completedStepIds: Object.freeze([...completedStepIds]),
 				stepResolutions: Object.freeze(readStepResolutions()),
+				surface,
 				navigationHistory: Object.freeze([...navigationHistory]),
 				pendingNavigation: void 0,
-				confirmedCheckout: confirmedCheckout !== null && confirmedCheckout !== void 0 ? confirmedCheckout : snapshot.confirmedCheckout,
+				receipt: receipt !== null && receipt !== void 0 ? receipt : snapshot.receipt,
 				activeOperation: void 0,
 				lastError
 			}));
@@ -216,11 +240,11 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			});
 		});
 		return function commit(_x, _x2, _x3, _x4, _x5, _x6, _x7) {
-			return _ref3.apply(this, arguments);
+			return _ref2.apply(this, arguments);
 		};
 	}();
 	const blockForRuntimeError = function() {
-		var _ref4 = require_asyncToGenerator._asyncToGenerator(function* (fromNodeId, event, code, cause) {
+		var _ref3 = require_asyncToGenerator._asyncToGenerator(function* (fromNodeId, event, code, cause) {
 			const workflowError = createWorkflowError(code, "staff", cause);
 			lifecycle.runtimeError({
 				stepId: fromNodeId,
@@ -230,11 +254,11 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			yield commit(fromNodeId, fromNodeId, event, snapshot.context, true, workflowError);
 		});
 		return function blockForRuntimeError(_x8, _x9, _x10, _x11) {
-			return _ref4.apply(this, arguments);
+			return _ref3.apply(this, arguments);
 		};
 	}();
 	const handleEvent = function() {
-		var _ref5 = require_asyncToGenerator._asyncToGenerator(function* (event) {
+		var _ref4 = require_asyncToGenerator._asyncToGenerator(function* (event) {
 			var _repeatCounts$get, _transition$exitPolic;
 			if (disposed || snapshot.status === "finished" || snapshot.status === "blocked") return;
 			const fromNodeId = snapshot.nodeId;
@@ -357,8 +381,8 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 				if (event.intent === "complete" && node.presentation.mode === "page" && movesForward && node.visitPolicy !== "once") {
 					navigationHistory = navigationHistory.filter((stepId) => stepId !== fromNodeId);
 					navigationHistory.push(fromNodeId);
-				} else if (event.intent === "skip") navigationHistory = navigationHistory.filter((stepId) => stepId !== fromNodeId);
-				yield commit(fromNodeId, resolvedTarget, event, nextContext, false, void 0, result.confirmedCheckout);
+				} else if (event.intent === "omit") navigationHistory = navigationHistory.filter((stepId) => stepId !== fromNodeId);
+				yield commit(fromNodeId, resolvedTarget, event, nextContext, false, void 0, result.receipt);
 				return;
 			}
 			if (result.status === "blocked") {
@@ -368,7 +392,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			yield commit(fromNodeId, fromNodeId, event, previousContext, false, result.lastError);
 		});
 		return function handleEvent(_x12) {
-			return _ref5.apply(this, arguments);
+			return _ref4.apply(this, arguments);
 		};
 	}();
 	function handleDirectNavigation(_x13, _x14) {
@@ -411,8 +435,13 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			if (resolution.type === "step") {
 				const fromIndex = definition.stepOrder.indexOf(fromNodeId);
 				if (definition.stepOrder.indexOf(resolution.stepId) < fromIndex) stepResolutions.delete(fromNodeId);
-				const historyIndex = navigationHistory.lastIndexOf(resolution.stepId);
-				if (historyIndex >= 0) navigationHistory = navigationHistory.slice(0, historyIndex);
+				if (definition.nodes[resolution.stepId].presentation.mode === "modal" && definition.nodes[fromNodeId].presentation.mode === "page") {
+					navigationHistory = navigationHistory.filter((stepId) => stepId !== fromNodeId);
+					navigationHistory.push(fromNodeId);
+				} else {
+					const historyIndex = navigationHistory.lastIndexOf(resolution.stepId);
+					if (historyIndex >= 0) navigationHistory = navigationHistory.slice(0, historyIndex);
+				}
 				yield commit(fromNodeId, resolution.stepId, {
 					intentId,
 					intent: "directNavigation"
@@ -435,7 +464,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 		return _handleDirectNavigation.apply(this, arguments);
 	}
 	const drain = function() {
-		var _ref6 = require_asyncToGenerator._asyncToGenerator(function* () {
+		var _ref5 = require_asyncToGenerator._asyncToGenerator(function* () {
 			if (processing || disposed) return;
 			processing = true;
 			try {
@@ -448,7 +477,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			}
 		});
 		return function drain() {
-			return _ref6.apply(this, arguments);
+			return _ref5.apply(this, arguments);
 		};
 	}();
 	return {

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,11 +123,11 @@ 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.visitPolicy !== void 0 && rawStep.visitPolicy !== "always" && rawStep.visitPolicy !== "reuseResolution" && rawStep.visitPolicy !== "once") addIssue(issues, "step.visitPolicy.invalid", `${stepPath}.visitPolicy`, "Step visitPolicy must be always, reuseResolution or once");
+		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)}`);
 		const fallbackActivityId = activities.ids[0];
@@ -161,18 +161,14 @@ function compileWorkflowStructure(input, options) {
 		const rawPresentation = rawStep.presentation;
 		let presentation = { mode: "page" };
 		if (rawPresentation !== void 0) {
-			if (isRecord(rawPresentation)) rejectUnknownFields(rawPresentation, ["mode", "base"], `${stepPath}.presentation`, issues);
+			if (isRecord(rawPresentation)) rejectUnknownFields(rawPresentation, ["mode"], `${stepPath}.presentation`, issues);
 			if (!isRecord(rawPresentation)) addIssue(issues, "step.presentation.invalid", `${stepPath}.presentation`, "Step presentation must be an object");
 			else if (rawPresentation.mode !== "page" && rawPresentation.mode !== "modal") addIssue(issues, "step.presentation.mode.invalid", `${stepPath}.presentation.mode`, "Presentation mode must be page or modal");
 			else if (!activity.allowedPresentations.includes(rawPresentation.mode)) addIssue(issues, "activity.presentation.unsupported", `${stepPath}.presentation.mode`, `Activity ${activity.id} does not support ${rawPresentation.mode}`);
-			else if (rawPresentation.mode === "modal") if (typeof rawPresentation.base !== "string" || !rawPresentation.base.trim()) addIssue(issues, "step.presentation.base.invalid", `${stepPath}.presentation.base`, "Modal base must be a non-empty step id");
-			else presentation = {
-				mode: "modal",
-				base: rawPresentation.base.trim()
-			};
+			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) => {
@@ -232,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 === "reuseResolution" || rawStep.visitPolicy === "once" ? rawStep.visitPolicy : "always",
+			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`);
@@ -246,15 +242,14 @@ function compileWorkflowStructure(input, options) {
 	Object.entries(nodes).forEach(([stepId, node]) => {
 		var _stepIndex$get;
 		const path = `steps.${(_stepIndex$get = stepIndex.get(stepId)) !== null && _stepIndex$get !== void 0 ? _stepIndex$get : 0}`;
-		if (node.presentation.mode === "modal") {
-			const base = nodes[node.presentation.base];
-			if (!base) addIssue(issues, "step.presentation.base.missing", `${path}.presentation.base`, `Modal base step does not exist: ${node.presentation.base}`);
-			else if (node.presentation.base === stepId) addIssue(issues, "step.presentation.base.self", `${path}.presentation.base`, "Modal step cannot use itself as its base");
-			else if (base.presentation.mode === "modal") addIssue(issues, "step.presentation.base.modal", `${path}.presentation.base`, "Modal step cannot use another modal step as its base");
-		}
+		if (node.presentation.mode === "modal" && stepId === stepIds[0]) addIssue(issues, "workflow.initial.modal", `${path}.presentation.mode`, "Workflow initial step must provide a page surface");
 		const transitions = Object.entries(node.on).filter((entry) => entry[1]);
-		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");
+		transitions.forEach(([intent, transition]) => {
+			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.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;
@@ -272,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",
@@ -289,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 {