@pisell/private-materials 6.12.166 → 6.12.167

package/es/components/HDLKiosk/docs/README.md

@@ -9,7 +9,7 @@
 
 1. [架构设计.md](./架构设计.md)：理解独立物料边界、依赖方向和全局不变量；
 2. [00-文件导航.md](./00-文件导航.md)：快速查找每个目录和关键文件的角色、调用方与修改落点；
-3. [01-核心运行机制.md](./01-核心运行机制.md)：沿 Activity Contract、Outcome Actor、Command Coordinator、Controller 和 Screen 的真实调用链理解 Core；
+3. [01-核心运行机制.md](./01-核心运行机制.md)：沿 Activity Contract、Intent/Navigation Actor、Command Coordinator、Controller 和 Screen 的真实调用链理解 Core；
 4. [02-Host 适配与业务数据.md](./02-Host适配与业务数据.md)：理解 BigSale 兼容层每个文件解决的问题、字段映射和当前缺口；
 5. [实施进度.md](./实施进度.md)：确认当前已完成能力、临时策略和已知风险；
 6. [03-业务流程与交互规则.md](./03-业务流程与交互规则.md)：理解三入口和当前权威流程；
@@ -31,7 +31,7 @@
 | ------------------------------------------------------- | ------------------------------------------------------------------------------ | ---------------------- |
 | [00-文件导航.md](./00-文件导航.md)                      | 目录职责、关键文件角色、调用关系和常见修改落点                                 | 详细业务顺序和字段定义 |
 | [架构设计.md](./架构设计.md)                            | 边界、总图、状态所有权、不变量                                                 | 实施流水账             |
-| [01-核心运行机制.md](./01-核心运行机制.md)              | Core 代码地图、Activity/Outcome/Command/Actor/Controller 调用链、修改落点 | BigSale 原始字段       |
+| [01-核心运行机制.md](./01-核心运行机制.md)              | Core 代码地图、Activity/Intent/Navigation/Command/Actor/Controller 调用链、修改落点 | BigSale 原始字段 |
 | [02-Host 适配与业务数据.md](./02-Host适配与业务数据.md) | BigSale 兼容层代码地图、痛点与形式、Projection/Command/商品/设备映射、真实缺口 | Screen 导航            |
 | [03-业务流程与交互规则.md](./03-业务流程与交互规则.md)  | 三入口、会员、主商品提交、页面行为、UI 基线                                | OS 内部实现            |
 | [04-设备与称重.md](./04-设备与称重.md)                  | Scanner、任意页面扫码方案、Scale、事件仲裁和称重商品                           | 支付实现细节           |

package/es/components/HDLKiosk/docs//345/256/236/346/226/275/350/277/233/345/272/246.md

@@ -36,7 +36,7 @@
 | Scale                 | 待实机       | 顶层 Runtime、自动入口；有效重量先进入 Fulfillment，再进入与 Quick 共用的 Customization，本地草稿在 Next 时提交                                                                   | 真秤全矩阵、正式商品                                           |
 | Catalog               | 待实机       | HDLKiosk 模板驱动现有 retail Product Provider 正式 load 后读取快照；分类/搜索/商品卡、连续加购、订单悬浮栏及购物车 Drawer 已完成                                                     | 大目录虚拟化、复杂规格接管、实机视觉                           |
 | Cart Overlay          | 待业务/实机 | 已替代独立 Review/Voucher Slice；复用全局 BottomBar，展示 Host 商品、数量、卡券入口、小计和备注能力                                                                                | 称重/定制重新编辑、价格变化反馈、促销/税/节省明细              |
-| Identity 登录        | 待实机       | BigSale 内注册 H5 Login2/Register2；认证结果经 memberRecognized 进入 identity.sync，客户写入、订单一致性和重报价统一由 Adapter/Operation 完成                                        | 登录/注册实机交互、错误文案与客户搜索结果验收                  |
+| Identity 登录        | 待实机       | BigSale 内注册 H5 Login2/Register2；认证结果经 complete 进入 identity.sync，客户写入、订单一致性和重报价统一由 Adapter/Operation 完成                                                | 登录/注册实机交互、错误文案与客户搜索结果验收                  |
 | 会员中途登录          | 待 Host      | Activity 级本地入口策略、customer/cart 互斥、统一 Screen Command、重新计价验证；partial/unknown 阻塞 Workflow                                                                        | 将同一 H5 认证能力接入 Shell/Cart Overlay 入口                 |
 | Fulfillment           | 待 Host      | Workflow Context 已接；支付 dispatch 前的 `ensurePrepared` 统一写入并验证履约方式                                                                                                   | 当前仍允许临时模拟                                             |
 | Voucher               | 已并入 Overlay | 不再是 Workflow Slice；由 Cart Overlay 展示并操作当前用户卡券                                                                                                                       | 真实券列表、应用、撤销和 quote                                 |
@@ -73,7 +73,7 @@
 - Customization 将称重/options 保持为页面本地草稿，输入变化不写 OS；Next 才通过 `addProductWithFlow` 提交，加购成功后前进；底栏和 Drawer 统一读取已确认的 `summary.due/cart.lines`；
 - Customization 通过本物料内的 `HDLKioskSkuOptionsSelection` 将原 ProductData 直接作为共享 `skuOptionsSelection` 的 dataSource，只转换选中结果；独立运行缺少 Engine 上下文时直接读取同一 option 结构兜底；
 - HDLKiosk 已删除主商品额外业务弹窗相关的 Activity、Host Contract、Projection 和 Checkout Requirement；是否展示额外弹窗由 OS 加购流内部决定；
-- Customization 称重/options 只保持本地草稿，Next 才调用 `addProductWithFlow`，加购成功后才前进；Barcode 主商品询问仍归入 `catalogWithPrimaryProductPrompt` Activity 内部；
+- Barcode 主商品询问使用独立 Modal Slice；拒绝或 Customization 跳过后直接进入 Fulfillment，Back 按真实页面历史返回 Catalog，再次前进沿用已提交的标准结果；
 - Cart Mutation 以 Host consistency barrier 为权威，不再被晚一帧提交的 `consistencyPending` 展示态误判为 unknown；
 - 普通 Catalog/Cart Overlay 写操作不显示全屏遮罩；Catalog 批量锁定卡片时保持原视觉，减少短操作闪烁；
 - Scale Hook 在顶层单一运行，Entry 和 Customization 详情消费同一快照；Scale workflow 从 `fulfillment` 开始，再复用 `customization` 页面分支；
@@ -111,7 +111,7 @@
 - Result 取餐号只读取当前订单或匹配 `salesDetail.header` 的 `shop_full_order_number`；支付成功后 Projection 仍缺号时按已确认 `orderId` 回查订单详情，始终不从支付结果猜测字段，也不以其它订单编号降级；
 - Barcode 当前使用“激活 Session → 消费首码 → Catalog → 缺主商品时询问 → Yes 时 Fulfillment → 称重详情 → Next/OS 加购成功 → Catalog”的路径；No 保持在 Catalog 且不要求 Fulfillment，Cart Overlay 完成订单复核与卡券操作；
 - 移除遗留 `hdl-shell__footer` 与 `resolveScreenBottomBar`：Fulfillment、Customization、Catalog 改为声明实时 BottomBar，由 Shell 内唯一 `HDLKioskBottomBarHost` 渲染。BottomBar 当前区分 `visible / masked / hidden`：退出确认及 Catalog 主商品询问等普通 Modal 保留底栏并由遮罩阻止交互，同时自动收起 CartDrawer；只有等待员工、支付未决和 blocked 等不可导航状态才隐藏。购物车图标已接入基于 `CompensatedPisellContainer` 的底部 Drawer，展示 Host 已确认的商品、定制摘要、数量和金额，并在三个 Catalog workflow 中复用既有改数量/删除 Operation；
-- Workflow 使用线性优先的 Slice 数组：数组表达主路径，Slice Outcome 通过 `next()` / `back()` 或带方向的 Guard/Effect 补齐默认相邻移动，`on` 只描述分支、合流和跳跃；同一 Slice 可用 `slice:用途` 多次出现。非 Back 回路必须声明有限 repeat，Actor 超限即阻塞；Outcome 同时携带 `stepId/activityId`，避免同类 Activity 的旧实例误触发当前 Step。支付不确定是 Actor blocked 状态，不作为业务节点；
+- Workflow 使用线性优先的 Slice 数组：数组表达主路径，Slice Intent 通过 `next()` 或 `navigate: 'next'` 补齐默认前进，`on` 只描述分支、合流和跳跃；Back 是独立 Navigation，并按实际页面历史解析。同一 Slice 可用 `slice:用途` 多次出现，回路必须声明有限 repeat，Actor 超限即阻塞；Intent 同时携带 `stepId/activityId`，避免同类 Activity 的迟到实例误触发当前 Step。支付不确定是 Actor blocked 状态，不作为业务节点；
 - `slices/<name>/slice.ts` 是各业务能力唯一导出的 `defineSlice` 结果：Slice `id` 标识业务 Activity，`screen.id` 标识页面类别；`view.tsx` 就地完成该 Slice 的 ViewModel 派生和组件装配，`app/views.ts` 单独维护完整的 Activity → View 本地注册表，`ScreenRenderer` 进行同步解析。Kernel、Slice 和 Workflow 不依赖 React View；公共类型与跨 Slice 纯方法分别集中在根 `types.ts`、`utils.ts`；
 - Kernel 已不依赖 HDLKiosk contracts：结构 Compiler、Actor 和通用 Coordinator 位于 `kernel/`；`app/operations.ts` 是共享业务副作用的公共入口，私有实现位于 `app/operations/`，其中 Coordinator 注入 HDLKioskHost、冲突矩阵、支付冻结、错误分类和遥测。Slice 专属 Operation 与对应 Slice 同置；
 - HDLKiosk 阻断式 Dialog 已统一到 `HDLKioskModal → PisellModal`，默认层级高于 CartDrawer；BottomBar 的三态解析、组件依赖边界、Checkout 安全及现有 Dialog/Screen 定向用例通过，HDLKiosk 汇总 Less 编译、变更组件 esbuild 语法转换和 `git diff --check` 通过；

package/es/components/HDLKiosk/docs//346/236/266/346/236/204/350/256/276/350/256/241.md

@@ -71,7 +71,7 @@ flowchart TB
     HOST --> OPS
     PROJ --> CONTROLLER
     PROJ --> VIEW --> UI
-    UI -->|"Activity Outcome"| VIEW
+    UI -->|"Activity Intent / Navigation"| VIEW
     VIEW --> ACTOR
     UI -->|"Screen Command"| VIEW
     VIEW --> COORD
@@ -106,20 +106,20 @@ Kernel ✕ HDLKiosk contracts / BigSale / SalesSDK / merchant workflows / Screen
 | ----------------------- | -------------------------------------------------------------------- | --------------------------------------------- |
 | Contracts/Ports         | HDLKiosk 自有 DTO、能力和结果语义                                    | BigSale 字段兼容                              |
 | Projection              | 标准化 Host 可观察事实                                               | 发业务命令                                    |
-| Slice                 | 将 Screen、合法 Outcome、局部 Command、退出 Effect 和 Requirement 收敛为业务能力 | 前后节点和 Host 实现             |
+| Slice                 | 将 Screen、合法 Intent、局部 Command、退出 Effect 和 Requirement 收敛为业务能力 | 前后节点和 Host 实现              |
 | Application Manifest    | 汇总 Slice、Workflow 和 Operation 引用并生成可信注册表              | React 生命周期和订单事实                       |
 | Structural Compiler     | Step ID、相邻导航、可达性、终点、Modal 和有界循环                    | 支付和购物车策略                              |
 | HDLKiosk Policy         | 编译后检查支付来源和 Checkout Prepare 等交易约束                     | 修改节点结构                                  |
-| Workflow Actor          | mailbox、step/activity 防迟到、running/blocked、节点提交和循环计数   | Host、Guard、Operation、支付解释和持久化       |
-| Transition Runner       | 执行 Guard/Exit Command，把结果归一为 advance/stay/blocked           | React、节点数组位置                           |
+| Workflow Actor          | mailbox、step/activity 防迟到、running/blocked、节点提交和循环计数   | Host、Predicate、Operation、支付解释和持久化   |
+| Transition Runner       | 求值 Predicate/执行 Exit Command，将结果归一为 advance/stay/blocked  | React、节点数组位置                           |
 | Operations              | 封装业务 Command 和写后验证                                          | Screen 导航                                   |
 | Requirement Registry    | 判断支付前业务要求对当前订单是否适用，并校验 Host Projection         | Workflow 节点编排和 UI                        |
 | Kernel Coordinator      | 用应用注入的 Context/Scope/Policy 处理冲突、去重、timeout 和 epoch    | 支付含义、Host、业务错误和节点目标             |
 | HDLKiosk Operation Policy | 注入 Host Context、冲突矩阵、支付 freeze、错误分类和遥测            | Screen 导航                                   |
 | Workflow                | 用有序 Slice 数组表达主路径，以 `on` 描述分支、合流和受限回路      | Screen 内部动作和订单事实                      |
 | Controllers             | session/device/customer 生命周期；提供验证式 `returnToEntry`         | OS 字段转换、决定自动返回时机                  |
-| View assembly           | 把 Activity 节点和 Projection 转换为组件输入，并路由 Outcome/Command | 决定目标节点                                  |
-| Screens/Dialogs/Layouts | 展示、局部输入、Screen Command 和 Activity Outcome                   | 直接调用 Host、Actor 或 Controller            |
+| View assembly           | 把 Activity 节点和 Projection 转换为组件输入，并路由 Intent/Navigation/Command | 决定目标节点                           |
+| Screens/Dialogs/Layouts | 展示、局部输入、Screen Command、Activity Intent 和 Back Navigation           | 直接调用 Host、Actor 或 Controller     |
 | BigSale Adapter         | DTO 转换、callback、插件、capability                                 | 决定流程节点                                  |
 
 ## 5. Host 契约
@@ -157,9 +157,9 @@ Screen：输入和展示状态
 
 1. Core 不 import BigSale、SalesSDK、Engine plugin 或 raw tempOrder。
 2. Adapter 不决定 Workflow 目标节点。
-3. Screen 不直接调用 Host；内部写操作发送 Command，离开步骤发送 Activity Outcome。
-4. Slice 是 Screen、Outcome、Command 和退出策略的唯一业务定义；Activity Registry 和 Operation Registry 从 Application Manifest 派生，不维护平行清单。
-5. Workflow 作者只排列已注册 Slice；规范化后的运行结构不得包含 Screen、Guard、Operation 或 failureTarget。重复 Slice 必须使用 `slice:用途` 标识每次出现。
+3. Screen 不直接调用 Host；内部写操作发送 Command，离开步骤发送 Activity Intent，返回发送 Navigation。
+4. Slice 是 Screen、Intent、Command 和退出策略的唯一业务定义；Activity Registry 和 Operation Registry 从 Application Manifest 派生，不维护平行清单。
+5. Workflow 作者只排列已注册 Slice；规范化后的运行结构不得包含 Screen、Predicate、Operation 或 failureTarget。重复 Slice 必须使用 `slice:用途` 标识每次出现。
 6. 只有可被业务编排者独立排序或分支的里程碑才成为节点；Dialog 内部询问、选择和等待阶段留在 Activity 内。
 7. Operation 不渲染 UI，不直接切 Screen。
 8. Cart/Customer/Summary/Payment 以 Host Projection 为权威。
@@ -186,7 +186,7 @@ Scale ───────┘
 
 入口定义不同顺序，复用 Identity、Fulfillment、Customization、Catalog、Cart、Checkout 等 Screen/Operation。会员中途登录是共享 session 行为，不复制到每个 Workflow 节点。
 
-Barcode/Scale 是外部 ingress，不放入 Step 数组。Barcode 首码先归属并激活 Session，在 Session `readyForCommands && cartWritable` 后通过 `barcode.consume` 完成；首屏类型由 Workflow Definition 决定，Scanner 不依赖 Catalog。Scale 当前从 Fulfillment 开始。Slice 在 `guards` 中声明纯函数，Workflow occurrence 用 `useGuards` 选择启用阶段，Compiler 只在 Node 中保留 `guardPhases`。Actor 的全局 `beforeEach` 管线对初始进入、前进、后退、显式目标和 `sessionExit` 使用同一套 `to/from` 导航判定。退出确认是全局 guard 的 `defer` 决策，Shell 只消费 `pendingNavigation.request`，不在 View 或 Kernel 中判断具体 Activity 名称。
+Barcode/Scale 是外部 ingress，不放入 Step 数组。Barcode 首码先归属并激活 Session，在 Session `readyForCommands && cartWritable` 后通过 `barcode.consume` 完成；首屏类型由 Workflow Definition 决定，Scanner 不依赖 Catalog。Scale 当前从 Fulfillment 开始。业务 Step 当前不启用本地 `beforeEnter`；Identity 通过 Workflow 中可见的 `visitPolicy: 'once'` 表达会话内只进入一次。Actor 的全局 `beforeEach` 管线仅承载会话安全策略。退出确认由其返回 `defer`，Shell 只消费 `pendingNavigation.request`，不在 View 或 Kernel 中判断具体 Activity 名称。
 
 权威节点顺序见 [03-业务流程与交互规则.md](./03-业务流程与交互规则.md)。
 
@@ -222,7 +222,7 @@ HDLKiosk 无法独立保证：
 ```text
 components/HDLKiosk/
 ├── app/              # 应用清单、三入口流程、共享 Operation 入口和节点渲染装配
-│   ├── workflow/     # Quick / Barcode / Scale + registry / guards / policy
+│   ├── workflow/     # Quick / Barcode / Scale + registry / predicates / navigation guards / policy
 │   ├── operations.ts # 跨 Slice Operation 的唯一公共导入面
 │   ├── operations/   # 公共入口背后的私有实现与测试
 │   └── entry/        # Workflow 外三入口页面

package/es/components/HDLKiosk/index.js

@@ -61,7 +61,6 @@ function HDLKioskContent({ host, config, isActive = true, entryDataPreparing = f
 		config,
 		isActive,
 		starting,
-		session,
 		sessionRef,
 		activeRef,
 		scannerIngress,

package/es/components/HDLKiosk/kernel/README.md

@@ -10,10 +10,9 @@
 const identity = defineSlice({
   id: 'identity',
   screen: { id: 'identity' },
-  outcomes: {
-    identified: effect(identifyCustomer, { navigate: 'next' }),
-    skipped: next(),
-    back: back(),
+  intents: {
+    complete: effect(identifyCustomer, { navigate: 'next' }),
+    skip: next(),
   },
   commands: {
     requestSmsCode,
@@ -40,11 +39,11 @@ const views = {
 ```
 
 - `defineSlice`：把业务 Activity、Screen 描述、语义出口、Screen 内 Command 和离开时 Effect 放在一起；
-- `next()` / `back()`：声明默认相邻移动，不再额外维护 navigation 清单；
+- `next()`：声明默认前进；Back 由独立 Navigation 和页面历史处理；
 - `defineWorkflow`：数组只表达 Slice 顺序，`on` 只处理跳跃、分支、合流和有界回路；
 - `defineKioskApplication`：汇总 Slice、Workflow 与应用级 Operation，并自动生成 Activity/Operation Manifest。
 
-Slice 的 `outcomes` 是“业务活动对流程公开的结果”，不是按钮或 DOM 事件。不会离开 Screen 的动作放进 `commands`。支付门禁、设备监听、购物车写入验证等商家规则不进入 Kernel。
+Slice 的 `intents` 是“业务活动请求流程执行的意图”，不是按钮或 DOM 事件。Back 使用独立 Navigation；不会离开 Screen 的动作放进 `commands`。支付门禁、设备监听、购物车写入验证等商家规则不进入 Kernel。
 
 三个标识的职责固定如下：Slice `id` 是 Workflow 引用的业务 Activity；`screen.id` 是 Shell、数据加载和展示策略使用的页面类别；React View 由应用层按 Activity 单独注册。不导航的业务操作声明为当前 Slice 的 Command，例如 `paymentMethod` 内的店员支付授权。
 
@@ -54,8 +53,8 @@ Compiler 只把 `screen.id` 复制为节点的 `screenId`。Renderer 再按节
 
 | 目录 | 负责 | 由应用注入 |
 | --- | --- | --- |
-| `application/` | Slice/Workflow/Application 作者 API、Manifest 生成 | Screen 描述、Outcome、Operation 引用 |
-| `workflow/` | 结构编译、Actor mailbox、节点提交、有界循环 | Activity Registry、Guard Registry、Transition Runner、Context Reducer |
+| `application/` | Slice/Workflow/Application 作者 API、Manifest 生成 | Screen 描述、Intent、Operation 引用 |
+| `workflow/` | 结构编译、Actor mailbox、节点提交、有界循环 | Activity Registry、Predicate Registry、Navigation Guard Registry、Transition Runner、Context Reducer |
 | `operations/` | 排队、冲突仲裁、intent 去重、timeout、Abort、session epoch | Context factory、错误分类、冲突规则、业务 Policy、观察器 |
 | `lifecycle.ts` | 组合 Actor 提交后的只读观察器 | telemetry、审计或持久化观察器 |
 
@@ -71,7 +70,7 @@ Workflow ┘                                      │
                                     Structural Compiler ─ Actor
                                                 │
 Screen Command ───────────────────── Operation Coordinator
-Activity Outcome ─ Transition Runner ───────────┘
+Activity Intent ─ Transition Runner ────────────┘
 ```
 
 当前会话只在内存中运行，不包含 checkpoint 或恢复策略。需要恢复时，由应用层读取 OS 事实和持久化证据，形成 Actor 初始化输入；Kernel 只保留 Lifecycle 和初始化参数这些扩展点。

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

@@ -27,10 +27,10 @@ function defineKioskApplication(definition) {
 		var _slice$commands;
 		if (slices.has(slice.id)) throw new Error(`Duplicate Kiosk Slice: ${slice.id}`);
 		const operationIds = /* @__PURE__ */ new Set();
-		Object.values(slice.outcomes).forEach((outcome) => {
-			if (outcome.kind !== "effect") return;
-			registerOperation(outcome.operation);
-			operationIds.add(outcome.operation.id);
+		Object.values(slice.intents).forEach((intent) => {
+			if (intent.kind !== "effect") return;
+			registerOperation(intent.operation);
+			operationIds.add(intent.operation.id);
 		});
 		Object.values((_slice$commands = slice.commands) !== null && _slice$commands !== void 0 ? _slice$commands : {}).forEach((operation) => {
 			registerOperation(operation);
@@ -77,31 +77,30 @@ function createApplicationActivityRegistry(application) {
 	const contracts = /* @__PURE__ */ new Map();
 	application.slices.forEach(({ definition }) => {
 		var _definition$presentat, _definition$additiona;
-		const exitPolicies = Object.fromEntries(Object.entries(definition.outcomes).flatMap(([outcome, behavior]) => {
+		const exitPolicies = {};
+		Object.entries(definition.intents).forEach(([intent, behavior]) => {
 			let policy;
-			if (behavior.kind === "guard") policy = { guard: behavior.guard };
+			if (behavior.kind === "precondition") policy = { precondition: behavior.predicate };
 			else if (behavior.kind === "effect") policy = {
-				guard: behavior.guard,
-				command: {
-					id: behavior.operation.id,
-					when: behavior.when
-				}
+				precondition: behavior.precondition,
+				command: { id: behavior.operation.id }
 			};
-			return policy ? [[outcome, Object.freeze(policy)]] : [];
-		}));
+			if (policy) exitPolicies[intent] = Object.freeze(policy);
+		});
 		const primaryPresentation = (_definition$presentat = definition.presentation) !== null && _definition$presentat !== void 0 ? _definition$presentat : "page";
 		contracts.set(definition.id, Object.freeze({
 			id: definition.id,
 			screenId: definition.screen.id,
-			outcomes: Object.freeze(Object.keys(definition.outcomes)),
+			intents: Object.freeze(Object.keys(definition.intents)),
 			exitPolicies: Object.freeze(exitPolicies),
-			navigationGuards: definition.guards ? Object.freeze(Object.fromEntries(Object.keys(definition.guards).map((phase) => [phase, getKioskSliceNavigationGuardId(definition.id, phase)]))) : void 0,
+			navigationGuards: definition.guards ? Object.freeze(Object.keys(definition.guards).reduce((guards, rawPhase) => {
+				const phase = rawPhase;
+				guards[phase] = getKioskSliceNavigationGuardId(definition.id, phase);
+				return guards;
+			}, {})) : void 0,
 			allowedPresentations: Object.freeze([...new Set([primaryPresentation, ...(_definition$additiona = definition.additionalPresentations) !== null && _definition$additiona !== void 0 ? _definition$additiona : []])]),
 			requirements: definition.requirements ? Object.freeze([...definition.requirements]) : void 0,
-			navigation: Object.freeze({
-				forward: Object.freeze(Object.entries(definition.outcomes).filter(([, behavior]) => behavior.navigate === "next").map(([outcome]) => outcome)),
-				backward: Object.freeze(Object.entries(definition.outcomes).filter(([, behavior]) => behavior.navigate === "previous").map(([outcome]) => outcome))
-			})
+			navigation: Object.freeze({ forward: Object.freeze(Object.entries(definition.intents).filter(([, behavior]) => behavior.navigate === "next").map(([intent]) => intent)) })
 		}));
 	});
 	return Object.freeze({

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

@@ -1,27 +1,22 @@
 import { _objectSpread2 } from "../../../../_virtual/_@oxc-project_runtime@0.122.0/helpers/objectSpread2.js";
 //#region src/components/HDLKiosk/kernel/application/defineSlice.ts
-const back = () => Object.freeze({
-	kind: "complete",
-	navigate: "previous"
-});
-const guard = (guardId, options = {}) => Object.freeze({
-	kind: "guard",
-	guard: guardId,
+const intentPrecondition = (predicate, options = {}) => Object.freeze({
+	kind: "precondition",
+	predicate,
 	navigate: options.navigate
 });
 const effect = (operation, options = {}) => Object.freeze({
 	kind: "effect",
 	operation,
-	when: options.when,
-	guard: options.guard,
+	precondition: options.precondition,
 	navigate: options.navigate
 });
 function defineSlice(slice) {
 	var _slice$guards;
 	if (!slice.id.trim()) throw new Error("Kiosk Slice id cannot be empty");
 	if (!slice.screen.id.trim()) throw new Error(`Kiosk Slice ${slice.id} screen id cannot be empty`);
-	Object.entries(slice.outcomes).forEach(([outcome]) => {
-		if (!outcome.trim()) throw new Error(`Kiosk Slice ${slice.id} has an empty outcome`);
+	Object.entries(slice.intents).forEach(([intent]) => {
+		if (!intent.trim()) throw new Error(`Kiosk Slice ${slice.id} has an empty intent`);
 	});
 	Object.entries((_slice$guards = slice.guards) !== null && _slice$guards !== void 0 ? _slice$guards : {}).forEach(([phase, navigationGuard]) => {
 		if (phase !== "beforeEnter") throw new Error(`Kiosk Slice ${slice.id} has an unknown navigation guard phase: ${phase}`);
@@ -29,11 +24,11 @@ function defineSlice(slice) {
 	});
 	return Object.freeze(_objectSpread2(_objectSpread2({}, slice), {}, {
 		screen: Object.freeze(_objectSpread2({}, slice.screen)),
-		outcomes: Object.freeze(_objectSpread2({}, slice.outcomes)),
+		intents: Object.freeze(_objectSpread2({}, slice.intents)),
 		guards: slice.guards ? Object.freeze(_objectSpread2({}, slice.guards)) : void 0,
 		commands: slice.commands ? Object.freeze(_objectSpread2({}, slice.commands)) : void 0,
 		requirements: slice.requirements ? Object.freeze([...slice.requirements]) : void 0
 	}));
 }
 //#endregion
-export { back, defineSlice, effect, guard };
+export { defineSlice, effect, intentPrecondition };

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 || node.visitPolicy !== "reuseResolution" && 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,7 @@ 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 decision = beforeEach({
 					navigationId,
 					intentId,
@@ -151,12 +175,16 @@ 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({}),
+		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)),
+			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))
@@ -174,6 +202,8 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 				status: blocked || node.end === "blocked" ? "blocked" : node.end === "success" ? "finished" : "idle",
 				context: nextContext,
 				completedStepIds: Object.freeze([...completedStepIds]),
+				stepResolutions: Object.freeze(readStepResolutions()),
+				navigationHistory: Object.freeze([...navigationHistory]),
 				pendingNavigation: void 0,
 				confirmedCheckout: confirmedCheckout !== null && confirmedCheckout !== void 0 ? confirmedCheckout : snapshot.confirmedCheckout,
 				activeOperation: void 0,
@@ -194,7 +224,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 +239,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 +264,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 +295,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 +318,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 +353,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 === "skip") 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 +391,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			} catch (cause) {
 				yield blockForRuntimeError(fromNodeId, {
 					intentId,
-					outcome: "directNavigation"
+					intent: "directNavigation"
 				}, "workflowBeforeEachGuardFailed", cause);
 				return;
 			}
@@ -341,19 +399,23 @@ 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);
+				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 +432,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 +448,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			}
 		});
 		return function drain() {
-			return _ref7.apply(this, arguments);
+			return _ref6.apply(this, arguments);
 		};
 	}();
 	return {
@@ -430,7 +490,7 @@ function createWorkflowActor({ definition, context, sessionEpoch, transitionRunn
 			const fromNodeId = snapshot.nodeId;
 			commit(fromNodeId, fromNodeId, {
 				intentId,
-				outcome: "systemBlocked"
+				intent: "systemBlocked"
 			}, snapshot.context, true, error);
 		},
 		dispose: () => {