@pisell/private-materials 6.12.166 → 6.12.168

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

@@ -24,6 +24,15 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 	let navigationTurnLocked = false;
 	const repeatCounts = /* @__PURE__ */ new Map();
 	const completedStepIds = /* @__PURE__ */ new Set();
+	const stepResolutions = /* @__PURE__ */ new Map();
+	let navigationHistory = [];
+	const readStepResolutions = () => {
+		const resolutions = {};
+		stepResolutions.forEach((resolution, stepId) => {
+			resolutions[stepId] = resolution;
+		});
+		return resolutions;
+	};
 	const configuredStartingNodeId = initialNodeId && definition.nodes[initialNodeId] ? initialNodeId : definition.initial;
 	const stepLocation = (stepId) => {
 		const node = definition.nodes[stepId];
@@ -34,6 +43,20 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			guardPhases: node.guardPhases
 		};
 	};
+	const resolveResumableTarget = (initialStepId) => {
+		let stepId = initialStepId;
+		const visited = /* @__PURE__ */ new Set();
+		while (!visited.has(stepId)) {
+			visited.add(stepId);
+			const node = definition.nodes[stepId];
+			const storedResolution = stepResolutions.get(stepId);
+			if (!node || !storedResolution || storedResolution !== "omit" && node.visitPolicy !== "once") return stepId;
+			const transition = node.on[storedResolution];
+			if (!transition) return stepId;
+			stepId = transition.target;
+		}
+		throw new Error("Workflow resumable Step cycle");
+	};
 	const resolveNavigation = ({ target, fromNodeId, candidateContext, candidateCompletedStepIds, intentId, direction: requestedDirection }) => {
 		navigationSequence += 1;
 		const navigationId = `${definition.id}:${sessionEpoch}:navigation:${navigationSequence}`;
@@ -67,7 +90,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 					type: "external",
 					to: nextTarget
 				};
-				if (decision.type === "cancel" || decision.type === "skip") return { type: "cancel" };
+				if (decision.type === "cancel" || decision.type === "bypass") return { type: "cancel" };
 				if (decision.type === "redirect") return resolveTarget(decision.to, redirectCount + 1, direction);
 				if (decision.type === "defer") return {
 					type: "defer",
@@ -93,6 +116,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];
+				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,
@@ -151,12 +184,24 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 		status: initialError || initialResolutionError || startingNode.end === "blocked" ? "blocked" : startingNode.end === "success" ? "finished" : "idle",
 		context: Object.freeze(_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
 	});
 	const publish = (next) => {
 		snapshot = Object.freeze(_objectSpread2(_objectSpread2({}, next), {}, {
 			context: Object.freeze(_objectSpread2({}, next.context)),
 			completedStepIds: Object.freeze([...next.completedStepIds]),
+			stepResolutions: Object.freeze(_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(_objectSpread2(_objectSpread2({}, next.pendingNavigation), {}, {
 				to: Object.freeze(_objectSpread2({}, next.pendingNavigation.to)),
 				request: Object.freeze(_objectSpread2({}, next.pendingNavigation.request))
@@ -169,11 +214,21 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 	const commit = function() {
 		var _ref3 = _asyncToGenerator(function* (fromNodeId, nodeId, event, nextContext, blocked, lastError, confirmedCheckout) {
 			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(_objectSpread2(_objectSpread2({}, snapshot), {}, {
 				nodeId,
 				status: blocked || node.end === "blocked" ? "blocked" : node.end === "success" ? "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,
 				activeOperation: void 0,
@@ -194,7 +249,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			const workflowError = createWorkflowError(code, "staff", cause);
 			lifecycle.runtimeError({
 				stepId: fromNodeId,
-				outcome: event.outcome,
+				intent: event.intent,
 				error: workflowError
 			});
 			yield commit(fromNodeId, fromNodeId, event, snapshot.context, true, workflowError);
@@ -209,10 +264,22 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			if (disposed || snapshot.status === "finished" || snapshot.status === "blocked") return;
 			const fromNodeId = snapshot.nodeId;
 			const node = definition.nodes[fromNodeId];
-			if (event.type !== "ACTIVITY_OUTCOME" || event.stepId !== fromNodeId || event.activityId !== node.activity) return;
-			const transition = node.on[event.outcome];
-			if (!transition || !event.intentId.trim()) return;
-			const repeatKey = `${fromNodeId}:${event.outcome}:${transition.target}`;
+			if (event.stepId !== fromNodeId || event.activityId !== node.activity) return;
+			if (!event.intentId.trim()) return;
+			if (event.type === "NAVIGATE_BACK") {
+				const previousStepId = navigationHistory[navigationHistory.length - 1];
+				yield handleDirectNavigation(previousStepId ? {
+					kind: "step",
+					stepId: previousStepId
+				} : {
+					kind: "sessionExit",
+					reason: "workflowBoundary"
+				}, event.intentId);
+				return;
+			}
+			const transition = node.on[event.intent];
+			if (!transition) return;
+			const repeatKey = `${fromNodeId}:${event.intent}:${transition.target}`;
 			if (transition.repeat && ((_repeatCounts$get = repeatCounts.get(repeatKey)) !== null && _repeatCounts$get !== void 0 ? _repeatCounts$get : 0) >= transition.repeat.max) {
 				yield blockForRuntimeError(fromNodeId, event, "workflowRepeatLimitExceeded");
 				return;
@@ -222,16 +289,24 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 				if (!transition.repeat) return;
 				repeatCounts.set(repeatKey, ((_repeatCounts$get2 = repeatCounts.get(repeatKey)) !== null && _repeatCounts$get2 !== void 0 ? _repeatCounts$get2 : 0) + 1);
 			};
-			const nextContext = reduceContext(snapshot.context, event.contextPatch);
+			const previousContext = snapshot.context;
+			const nextContext = reduceContext(previousContext, event.contextPatch);
+			let requestedTarget = transition.target;
+			try {
+				requestedTarget = resolveResumableTarget(requestedTarget);
+			} catch (cause) {
+				yield blockForRuntimeError(fromNodeId, event, "workflowResumeCycle", cause);
+				return;
+			}
 			const fromIndex = definition.stepOrder.indexOf(fromNodeId);
-			const movesForward = definition.stepOrder.indexOf(transition.target) > fromIndex;
+			const movesForward = definition.stepOrder.indexOf(requestedTarget) > fromIndex;
 			const candidateCompletedStepIds = movesForward ? [...new Set([...completedStepIds, fromNodeId])] : [...completedStepIds];
 			let navigationResolution;
 			try {
 				navigationResolution = resolveNavigation({
 					target: {
 						kind: "step",
-						stepId: transition.target
+						stepId: requestedTarget
 					},
 					fromNodeId,
 					candidateContext: nextContext,
@@ -245,10 +320,10 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			if (navigationResolution.type === "block") {
 				lifecycle.runtimeError({
 					stepId: fromNodeId,
-					outcome: event.outcome,
+					intent: event.intent,
 					error: navigationResolution.error
 				});
-				yield commit(fromNodeId, fromNodeId, event, snapshot.context, true, navigationResolution.error);
+				yield commit(fromNodeId, fromNodeId, event, previousContext, true, navigationResolution.error);
 				return;
 			}
 			if (navigationResolution.type === "cancel") return;
@@ -268,9 +343,9 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 				return;
 			}
 			const resolvedTarget = navigationResolution.stepId;
-			const operationInput = "operationInput" in event ? event.operationInput : void 0;
+			"operationInput" in event && event.operationInput;
 			const command = (_transition$exitPolic = transition.exitPolicy) === null || _transition$exitPolic === void 0 ? void 0 : _transition$exitPolic.command;
-			const commandWillRun = Boolean(command && (command.when !== "inputPresent" || operationInput != null));
+			const commandWillRun = Boolean(command);
 			executionSequence += 1;
 			const executionId = `${definition.id}:${snapshot.sessionEpoch}:${executionSequence}`;
 			if (commandWillRun && command) publish(_objectSpread2(_objectSpread2({}, snapshot), {}, {
@@ -303,21 +378,29 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			if (result.status === "advance") {
 				recordRepeat();
 				if (movesForward) completedStepIds.add(fromNodeId);
+				stepResolutions.set(fromNodeId, event.intent);
+				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 === "omit") navigationHistory = navigationHistory.filter((stepId) => stepId !== fromNodeId);
 				yield commit(fromNodeId, resolvedTarget, event, nextContext, false, void 0, result.confirmedCheckout);
 				return;
 			}
 			if (result.status === "blocked") {
-				yield commit(fromNodeId, fromNodeId, event, nextContext, true, result.lastError);
+				yield commit(fromNodeId, fromNodeId, event, previousContext, true, result.lastError);
 				return;
 			}
-			yield commit(fromNodeId, fromNodeId, event, nextContext, false, result.lastError);
+			yield commit(fromNodeId, fromNodeId, event, previousContext, false, result.lastError);
 		});
 		return function handleEvent(_x12) {
 			return _ref5.apply(this, arguments);
 		};
 	}();
-	const handleDirectNavigation = function() {
-		var _ref6 = _asyncToGenerator(function* (target, intentId) {
+	function handleDirectNavigation(_x13, _x14) {
+		return _handleDirectNavigation.apply(this, arguments);
+	}
+	function _handleDirectNavigation() {
+		_handleDirectNavigation = _asyncToGenerator(function* (target, intentId) {
 			if (!intentId.trim()) return;
 			const fromNodeId = snapshot.nodeId;
 			let resolution;
@@ -333,7 +416,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			} catch (cause) {
 				yield blockForRuntimeError(fromNodeId, {
 					intentId,
-					outcome: "directNavigation"
+					intent: "directNavigation"
 				}, "workflowBeforeEachGuardFailed", cause);
 				return;
 			}
@@ -341,19 +424,28 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			if (resolution.type === "block") {
 				lifecycle.runtimeError({
 					stepId: fromNodeId,
-					outcome: "directNavigation",
+					intent: "directNavigation",
 					error: resolution.error
 				});
 				yield commit(fromNodeId, fromNodeId, {
 					intentId,
-					outcome: "directNavigation"
+					intent: "directNavigation"
 				}, snapshot.context, true, resolution.error);
 				return;
 			}
 			if (resolution.type === "step") {
+				const fromIndex = definition.stepOrder.indexOf(fromNodeId);
+				if (definition.stepOrder.indexOf(resolution.stepId) < fromIndex) stepResolutions.delete(fromNodeId);
+				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,
-					outcome: "directNavigation"
+					intent: "directNavigation"
 				}, snapshot.context, false);
 				return;
 			}
@@ -370,12 +462,10 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 				lastError: void 0
 			}));
 		});
-		return function handleDirectNavigation(_x13, _x14) {
-			return _ref6.apply(this, arguments);
-		};
-	}();
+		return _handleDirectNavigation.apply(this, arguments);
+	}
 	const drain = function() {
-		var _ref7 = _asyncToGenerator(function* () {
+		var _ref6 = _asyncToGenerator(function* () {
 			if (processing || disposed) return;
 			processing = true;
 			try {
@@ -388,7 +478,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			}
 		});
 		return function drain() {
-			return _ref7.apply(this, arguments);
+			return _ref6.apply(this, arguments);
 		};
 	}();
 	return {
@@ -430,7 +520,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			const fromNodeId = snapshot.nodeId;
 			commit(fromNodeId, fromNodeId, {
 				intentId,
-				outcome: "systemBlocked"
+				intent: "systemBlocked"
 			}, snapshot.context, true, error);
 		},
 		dispose: () => {

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

@@ -65,7 +65,7 @@ function compileWorkflowStructure(input, options) {
 	var _options$maxSteps, _options$maxTransitio, _input$id, _stepIds$;
 	const issues = [];
 	const activities = options.activities;
-	const guards = options.guards;
+	const predicates = options.predicates;
 	const maxSteps = (_options$maxSteps = options.maxSteps) !== null && _options$maxSteps !== void 0 ? _options$maxSteps : 32;
 	const maxTransitions = (_options$maxTransitio = options.maxTransitions) !== null && _options$maxTransitio !== void 0 ? _options$maxTransitio : 96;
 	if (!isRecord(input)) return {
@@ -120,12 +120,14 @@ function compileWorkflowStructure(input, options) {
 			"activity",
 			"presentation",
 			"readiness",
+			"visitPolicy",
 			"useGuards",
 			"on",
 			"end",
 			"screen"
 		], 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 !== "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];
@@ -140,11 +142,12 @@ function compileWorkflowStructure(input, options) {
 				addIssue(issues, "step.useGuards.phase.invalid", phasePath, `Unknown navigation guard phase: ${String(rawPhase)}`);
 				return;
 			}
-			if (guardPhases.includes(rawPhase)) {
+			const phase = rawPhase;
+			if (guardPhases.includes(phase)) {
 				addIssue(issues, "step.useGuards.phase.duplicate", phasePath, `Duplicate navigation guard phase: ${rawPhase}`);
 				return;
 			}
-			const guardId = (_activity$navigationG = activity.navigationGuards) === null || _activity$navigationG === void 0 ? void 0 : _activity$navigationG[rawPhase];
+			const guardId = (_activity$navigationG = activity.navigationGuards) === null || _activity$navigationG === void 0 ? void 0 : _activity$navigationG[phase];
 			if (!guardId) {
 				addIssue(issues, "step.useGuards.unavailable", phasePath, `Activity ${activity.id} does not define ${rawPhase}`);
 				return;
@@ -153,29 +156,25 @@ function compileWorkflowStructure(input, options) {
 				addIssue(issues, "step.useGuards.guard.unknown", phasePath, `Activity ${activity.id} uses unknown navigation guard ${guardId}`);
 				return;
 			}
-			guardPhases.push(rawPhase);
+			guardPhases.push(phase);
 		});
 		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.on !== void 0 && !isRecord(rawStep.on)) addIssue(issues, "step.outcomes.invalid", `${stepPath}.on`, "Step outcomes must be an object");
+		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 = (outcome, rawTarget, path) => {
+		const addTransition = (intent, rawTarget, path) => {
 			var _activity$exitPolicie;
-			if (!activity.outcomes.includes(outcome)) {
-				addIssue(issues, "activity.outcome.unknown", path, `Activity ${activity.id} does not expose outcome ${outcome}`);
+			if (!activity.intents.some((availableIntent) => availableIntent === intent)) {
+				addIssue(issues, "activity.intent.unknown", path, `Activity ${activity.id} does not expose intent ${intent}`);
 				return;
 			}
 			let targetValue = rawTarget;
@@ -185,12 +184,12 @@ function compileWorkflowStructure(input, options) {
 					"target",
 					"repeat",
 					"operation",
-					"guard",
+					"precondition",
 					"failureTarget"
 				], path, issues);
 				[
 					"operation",
-					"guard",
+					"precondition",
 					"failureTarget"
 				].forEach((field) => {
 					if (rawTarget[field] !== void 0) addIssue(issues, "transition.untrustedField", `${path}.${field}`, `${field} belongs to the local Activity Contract`);
@@ -203,15 +202,15 @@ function compileWorkflowStructure(input, options) {
 				return;
 			}
 			const symbolicTarget = targetValue.trim();
-			const target = symbolicTarget === "$next" ? stepIds[index + 1] : symbolicTarget === "$prev" ? stepIds[index - 1] : symbolicTarget;
+			const target = symbolicTarget === "$next" ? stepIds[index + 1] : symbolicTarget;
 			if (!target) {
-				addIssue(issues, symbolicTarget === "$prev" ? "transition.prev.missing" : "transition.next.missing", path, `${symbolicTarget} does not exist for step ${stepId}`);
+				addIssue(issues, "transition.next.missing", path, `${symbolicTarget} does not exist for step ${stepId}`);
 				return;
 			}
-			const exitPolicy = (_activity$exitPolicie = activity.exitPolicies) === null || _activity$exitPolicie === void 0 ? void 0 : _activity$exitPolicie[outcome];
-			if ((exitPolicy === null || exitPolicy === void 0 ? void 0 : exitPolicy.guard) && !guards.has(exitPolicy.guard)) addIssue(issues, "activity.guard.unknown", path, `Activity ${activity.id} uses unknown guard ${exitPolicy.guard}`);
+			const exitPolicy = (_activity$exitPolicie = activity.exitPolicies) === null || _activity$exitPolicie === void 0 ? void 0 : _activity$exitPolicie[intent];
+			if ((exitPolicy === null || exitPolicy === void 0 ? void 0 : exitPolicy.precondition) && !predicates.has(exitPolicy.precondition)) addIssue(issues, "activity.precondition.unknown", path, `Activity ${activity.id} uses unknown precondition predicate ${exitPolicy.precondition}`);
 			if ((exitPolicy === null || exitPolicy === void 0 ? void 0 : exitPolicy.command) && !options.operations.has(exitPolicy.command.id)) addIssue(issues, "activity.command.unknown", path, `Activity ${activity.id} uses unknown command ${exitPolicy.command.id}`);
-			transitions[outcome] = Object.freeze({
+			transitions[intent] = Object.freeze({
 				target,
 				exitPolicy,
 				repeat
@@ -219,15 +218,11 @@ function compileWorkflowStructure(input, options) {
 		};
 		if (index + 1 < rawSteps.length) {
 			var _activity$navigation;
-			(_activity$navigation = activity.navigation) === null || _activity$navigation === void 0 || (_activity$navigation = _activity$navigation.forward) === null || _activity$navigation === void 0 || _activity$navigation.forEach((outcome) => addTransition(outcome, "$next", `${stepPath}.navigation.${outcome}`));
-		}
-		if (index > 0) {
-			var _activity$navigation2;
-			(_activity$navigation2 = activity.navigation) === null || _activity$navigation2 === void 0 || (_activity$navigation2 = _activity$navigation2.backward) === null || _activity$navigation2 === void 0 || _activity$navigation2.forEach((outcome) => addTransition(outcome, "$prev", `${stepPath}.navigation.${outcome}`));
+			(_activity$navigation = activity.navigation) === null || _activity$navigation === void 0 || (_activity$navigation = _activity$navigation.forward) === null || _activity$navigation === void 0 || _activity$navigation.forEach((intent) => addTransition(intent, "$next", `${stepPath}.navigation.${intent}`));
 		}
 		const rawTransitions = isRecord(rawStep.on) ? rawStep.on : {};
-		Object.entries(rawTransitions).forEach(([outcome, transition]) => {
-			addTransition(outcome, transition, `${stepPath}.on.${outcome}`);
+		Object.entries(rawTransitions).forEach(([intent, transition]) => {
+			addTransition(intent, transition, `${stepPath}.on.${intent}`);
 		});
 		transitionCount += Object.keys(transitions).length;
 		nodes[stepId] = Object.freeze({
@@ -236,6 +231,7 @@ function compileWorkflowStructure(input, options) {
 			screenId: activity.screenId,
 			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
@@ -246,27 +242,25 @@ 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]);
+		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.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(([outcome, transition]) => {
-			var _stepIndex$get2, _stepIndex$get3, _activities$require$n;
+		transitions.forEach(([intent, transition]) => {
+			var _stepIndex$get2, _stepIndex$get3;
 			if (!transition) return;
 			if (!nodes[transition.target]) {
-				addIssue(issues, "transition.target.missing", `${path}.on.${outcome}`, `Target step does not exist: ${transition.target}`);
+				addIssue(issues, "transition.target.missing", `${path}.on.${intent}`, `Target step does not exist: ${transition.target}`);
 				return;
 			}
 			const sourceIndex = (_stepIndex$get2 = stepIndex.get(stepId)) !== null && _stepIndex$get2 !== void 0 ? _stepIndex$get2 : -1;
-			const targetIndex = (_stepIndex$get3 = stepIndex.get(transition.target)) !== null && _stepIndex$get3 !== void 0 ? _stepIndex$get3 : -1;
-			const needsBound = !((_activities$require$n = activities.require(node.activity).navigation) === null || _activities$require$n === void 0 || (_activities$require$n = _activities$require$n.backward) === null || _activities$require$n === void 0 ? void 0 : _activities$require$n.includes(outcome)) && targetIndex <= sourceIndex;
-			if (needsBound && !transition.repeat) addIssue(issues, "transition.cycle.unbounded", `${path}.on.${outcome}`, "A non-backward jump to the same or an earlier step requires a repeat limit");
-			if (!needsBound && transition.repeat) addIssue(issues, "transition.repeat.unnecessary", `${path}.on.${outcome}.repeat`, "Repeat limits are only valid on cyclic non-backward jumps");
+			const needsBound = ((_stepIndex$get3 = stepIndex.get(transition.target)) !== null && _stepIndex$get3 !== void 0 ? _stepIndex$get3 : -1) <= sourceIndex;
+			if (needsBound && !transition.repeat) addIssue(issues, "transition.cycle.unbounded", `${path}.on.${intent}`, "A jump to the same or an earlier step requires a repeat limit");
+			if (!needsBound && transition.repeat) addIssue(issues, "transition.repeat.unnecessary", `${path}.on.${intent}.repeat`, "Repeat limits are only valid on cyclic jumps");
 		});
 	});
 	const initial = (_stepIds$ = stepIds[0]) !== null && _stepIds$ !== void 0 ? _stepIds$ : "";

package/es/components/HDLKiosk/kernel/workflow/selectors.js

@@ -0,0 +1,9 @@
+//#region src/components/HDLKiosk/kernel/workflow/selectors.ts
+function canReopenWorkflowStep(snapshot, stepId) {
+	return Boolean(stepId && snapshot.stepResolutions[stepId] === "complete");
+}
+function canNavigateBack(snapshot) {
+	return snapshot.navigationHistory.length > 0 || snapshot.stepResolutions[snapshot.nodeId] !== void 0;
+}
+//#endregion
+export { canNavigateBack, canReopenWorkflowStep };

package/es/components/HDLKiosk/runtime/HDLKioskWorkflowView.js

@@ -1,6 +1,7 @@
 import { _asyncToGenerator } from "../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/asyncToGenerator.js";
 import { useHDLKioskCustomerController } from "./controllers/useHDLKioskCustomerController.js";
 import { useHDLKioskScreenData } from "./controllers/useHDLKioskScreenData.js";
+import { canReopenWorkflowStep } from "../kernel/workflow/selectors.js";
 import { EndOrderDialog } from "../components/overlays/EndOrderDialog/index.js";
 import { HDLKioskHeader } from "../components/shell/HDLKioskHeader/index.js";
 import { CartDrawer } from "../components/overlays/CartDrawer/index.js";
@@ -46,7 +47,7 @@ function HDLKioskWorkflowCartOverlay({ model, busy, memberAction, send, renderCa
 * Host、Workflow Actor 或会话计时器。
 */
 function HDLKioskWorkflowView({ session, host, sales, config, isActive, renderIdentityAuth, renderCartContent, cartOverlayActions, returnToEntry }) {
-	var _snapshot$pendingNavi, _snapshot$pendingNavi2, _activeNode$presentat, _customer$error, _activeNode$presentat2;
+	var _snapshot$pendingNavi, _snapshot$pendingNavi2, _session$definition$n2, _customer$error, _activeNode$presentat;
 	const snapshot = useWorkflowSnapshot(session.actor);
 	const sequence = useRef(0);
 	const resetInFlight = useRef(false);
@@ -65,7 +66,7 @@ function HDLKioskWorkflowView({ session, host, sales, config, isActive, renderId
 		var _session$definition$n;
 		return ((_session$definition$n = session.definition.nodes[stepId]) === null || _session$definition$n === void 0 ? void 0 : _session$definition$n.activity) === "customization";
 	});
-	const screenDataActivity = ((_activeNode$presentat = activeNode.presentation) === null || _activeNode$presentat === void 0 ? void 0 : _activeNode$presentat.mode) === "modal" ? session.definition.nodes[activeNode.presentation.base].activity : activeNode.activity;
+	const screenDataNode = (_session$definition$n2 = session.definition.nodes[snapshot.surface.pageStepId]) !== null && _session$definition$n2 !== void 0 ? _session$definition$n2 : activeNode;
 	const paymentSafeForReset = sales.payment.status === "idle" || sales.payment.status === "failed";
 	const resetSession = useCallback(_asyncToGenerator(function* () {
 		if (resetInFlight.current) return;
@@ -143,8 +144,8 @@ function HDLKioskWorkflowView({ session, host, sales, config, isActive, renderId
 	]);
 	const { catalog, customization, payment } = useHDLKioskScreenData({
 		host,
-		currentScreenId,
-		activity: screenDataActivity,
+		currentScreenId: screenDataNode.screenId,
+		activity: screenDataNode.activity,
 		isActive,
 		primaryWeightedProductId: config.primaryWeightedProductId
 	});
@@ -161,7 +162,7 @@ function HDLKioskWorkflowView({ session, host, sales, config, isActive, renderId
 		}
 		sequence.current += 1;
 		const intentId = `ui:${snapshot.sessionEpoch}:${sequence.current}`;
-		if (action.kind === "outcome") {
+		if (action.kind === "intent" || action.kind === "navigation") {
 			const event = createWorkflowEvent(action, activeNode.activity, snapshot.nodeId, intentId);
 			if (event) session.actor.send(event);
 			return;
@@ -191,9 +192,9 @@ function HDLKioskWorkflowView({ session, host, sales, config, isActive, renderId
 	useEffect(() => {
 		if (activeNode.activity !== "paymentMethod" || snapshot.status !== "idle" || sales.payment.status !== "succeeded") return;
 		send({
-			kind: "outcome",
+			kind: "intent",
 			activityId: "paymentMethod",
-			outcome: "confirmed"
+			intent: "complete"
 		});
 	}, [
 		activeNode.activity,
@@ -243,7 +244,7 @@ function HDLKioskWorkflowView({ session, host, sales, config, isActive, renderId
 		memberAction,
 		variant: currentScreenId === "identity" ? "identityGate" : "default"
 	}, /* @__PURE__ */ React.createElement(HDLKioskBottomBarHost, {
-		mode: ((_activeNode$presentat2 = activeNode.presentation) === null || _activeNode$presentat2 === void 0 ? void 0 : _activeNode$presentat2.mode) === "modal" || endOrderConfirmationOpen || memberLoginOpen ? "masked" : "visible",
+		mode: ((_activeNode$presentat = activeNode.presentation) === null || _activeNode$presentat === void 0 ? void 0 : _activeNode$presentat.mode) === "modal" || endOrderConfirmationOpen || memberLoginOpen ? "masked" : "visible",
 		fallback: endOrderBottomBar,
 		cartOverlayActions,
 		promotionsAvailable: Boolean(renderCartContent)
@@ -271,7 +272,7 @@ function HDLKioskWorkflowView({ session, host, sales, config, isActive, renderId
 		memberAction,
 		send,
 		renderCartContent,
-		onEditPrimaryProduct: customizationStepId && config.primaryWeightedProductId ? editPrimaryProduct : void 0
+		onEditPrimaryProduct: customizationStepId && config.primaryWeightedProductId && canReopenWorkflowStep(snapshot, customizationStepId) ? editPrimaryProduct : void 0
 	}), endOrderConfirmationOpen ? /* @__PURE__ */ React.createElement(EndOrderDialog, {
 		onCancel: cancelEndOrder,
 		onConfirm: confirmEndOrder

package/es/components/HDLKiosk/runtime/controllers/useHDLKioskCustomerController.js

@@ -11,7 +11,7 @@ const MEMBER_ACTION_ACTIVITIES = new Set([
 	"fulfillment",
 	"customization",
 	"catalog",
-	"catalogWithPrimaryProductPrompt",
+	"primaryProductPrompt",
 	"paymentMethod"
 ]);
 /**

package/es/components/HDLKiosk/runtime/createWorkflowSession.js

@@ -2,7 +2,7 @@ import { _asyncToGenerator } from "../../../_virtual/_@oxc-project_runtime@0.122
 import { createOperationCoordinator } from "../app/operations/coordinator.js";
 import { createHDLKioskOperationRegistry } from "../app/manifest.js";
 import { defaultActivityRegistry, getBuiltInWorkflowDefinition } from "../app/workflow/registry.js";
-import { defaultGuardRegistry } from "../app/workflow/guards.js";
+import { defaultPredicateRegistry } from "../app/workflow/predicates.js";
 import { createHDLKioskBeforeEachGuard, defaultNavigationGuardRegistry } from "../app/workflow/navigationGuards.js";
 import { validateHDLKioskWorkflowPolicy } from "../app/workflow/policy.js";
 import { HDL_WORKFLOW_IDS } from "../app/constants.js";
@@ -26,7 +26,7 @@ function createHDLKioskWorkflowSession(entry, host, options = {}) {
 	const structuralCompilation = compileWorkflowStructure(getBuiltInWorkflowDefinition(entry), {
 		operations,
 		activities: defaultActivityRegistry,
-		guards: defaultGuardRegistry,
+		predicates: defaultPredicateRegistry,
 		navigationGuards: defaultNavigationGuardRegistry,
 		workflowIds: HDL_WORKFLOW_IDS
 	});
@@ -54,7 +54,7 @@ function createHDLKioskWorkflowSession(entry, host, options = {}) {
 	const transitionRunner = createHDLKioskTransitionRunner({
 		host,
 		coordinator,
-		guards: defaultGuardRegistry
+		predicates: defaultPredicateRegistry
 	});
 	const workflowActor = createWorkflowActor({
 		definition,