@happyvertical/smrt-manufacturing 0.53.5 → 0.54.0

package/AGENTS.md

@@ -1,6 +1,6 @@
 # @happyvertical/smrt-manufacturing
 
-Bills of materials, operations and routing, cost and labour rollup, and production-order stock movement. Strictly industry-neutral — the same primitives serve apparel, furniture, automotive, CPG, electronics, food production, custom hardware, and any vertical that builds finished goods from a recipe.
+Bills of materials (multi-level through sub-assemblies), operations and routing, cost and labour rollup, production runs, and production-order stock movement. Strictly industry-neutral — the same primitives serve apparel, furniture, automotive, CPG, electronics, food production, custom hardware, and any vertical that builds finished goods from a recipe.
 
 Sits on top of `@happyvertical/smrt-inventory` (stock) and `@happyvertical/smrt-products` (catalog: `Product`, `Material`, `Sku`), and works alongside the `ProductionOrder` Contract STI subtype already shipped in `@happyvertical/smrt-commerce`.
 
@@ -12,6 +12,8 @@ Sits on top of `@happyvertical/smrt-inventory` (stock) and `@happyvertical/smrt-
 | `BillOfMaterials` | Recipe for a finished product. `productId` (plain string) references the upstream `Product` or any STI subtype. Multiple revisions per product via `version` + `status` (`draft` / `active` / `superseded`). `conflictColumns: ['product_id', 'version', 'tenant_id']`. |
 | `BomLine` | One component on a BOM. `bomId` (FK), `componentSkuId` (plain string ref — the `Sku` model lives in `@happyvertical/smrt-products`; inventory tracks stock motion against the id), `qtyPerUnit`, `uom` (open-ended — `yards`, `each`, `grams`, `kg`, ...), `wastePercent`, `notes`. `conflictColumns: ['bom_id', 'component_sku_id', 'tenant_id']`. |
 | `Operation` | A kind of work (cut, weld, inspect), a managed list per tenant. `code` (unique per tenant; `conflictColumns: ['code', 'tenant_id']`, fixed once defined), `name`, `category`, `isActive` (retire/reinstate; never deleted, `delete()` throws), `requiredQualificationId` (nullable `@crossPackageRef('@happyvertical/smrt-human-resources:Qualification')`: metadata only, no dependency, unvalidated; an application reads it to gate who may start the operation). |
+| `ProductionRun` | A build against one bill, reported as it happens ("25 to build, 12 done"). `bomId` (`@foreignKey(BillOfMaterials)`, RESTRICT: pinned when created), `targetQty` and `completedQty` (decimal; completed is the sum of completions), `status` (`planned` / `in_progress` / `done` / `cancelled`). Generated list/get only; `ProductionRunService` owns writes. |
+| `ProductionRunCompletion` | One dated report on a run: `runId` (`@foreignKey(ProductionRun)`, CASCADE), `qty` (decimal, > 0), `completedAt`. Generated list/get only. |
 | `RoutingStep` | One operation in a BOM's optional routing. `bomId` (`@foreignKey(BillOfMaterials)`, CASCADE: a routing belongs to its bill), `operationId` (`@foreignKey(Operation)`, RESTRICT: operations are retired, never deleted), `sequence` (1..n, unique per bom), `estimatedMinutes` (decimal, per produced unit), `notes`. `conflictColumns: ['bom_id', 'sequence', 'tenant_id']`. |
 
 All models are `@TenantScoped({ mode: 'optional' })` with a nullable `tenantId` so they can be used either tenant-scoped or globally.
@@ -33,16 +35,24 @@ A sub-assembly is a `BomLine` whose component SKU belongs to an `Assembly`; ther
 |---|---|
 | `resolveComponent(skuId, { tenantId? })` | `{ kind, sku, product, assembly, activeBom, buildable }`. `kind` is `assembly`, `material` (`Material`), `bought` (any other `Product`), or `missing` (unknown SKU, SKU with no product, or a non-UUID id; never throws). `activeBom` is the assembly's highest active bill, `null` when it has none; `buildable` is `assembly && activeBom`. Multi-level explosion (#3444) recurses on `activeBom` and stops at every other kind. |
 | `isAssembly(skuId)` | `resolveComponent(skuId).kind === 'assembly'`. |
-| `findActiveBom(productId, { tenantId? })` | Highest active bill. With `tenantId` (including `null`), only that tenant's bills count, and `resolveComponent` reports another tenant's SKU, product or bill line as `missing` (global rows stay visible), whatever the tenant context; the cycle walk and `getBillStructure` pass the bill's own tenant, so a shared assembly resolves to the right tenant's bill on writes made without `withTenant()`. |
+| `findActiveBom(productId, { tenantId? })` | Highest active bill. With `tenantId` (including `null`), that tenant's own bill, else a global one, and `resolveComponent` reads the SKU and product as that tenant's or global (through `tenant-scope.ts`, so a shared global component stays visible under a tenant context) and reports another tenant's as `missing`, whatever the tenant context; the cycle walk and `getBillStructure` pass the bill's own tenant, so a shared assembly resolves to the right tenant's bill on writes made without `withTenant()`. |
 | `getBillStructure(bomId)` | One level: the bill plus each line with its resolved component. Throws `BomNotFoundError`. |
 | `findCycle(productId, componentSkuIds)` | The path by which those components would make `productId` contain itself, following sub-assemblies' **active** bills only; `null` when none. |
 | `assertLineAcyclic(line)` / `assertBillAcyclic(bom)` | Throw `BomCycleError` (a `ValidationError`, code `MANUFACTURING_BOM_CYCLE`, `path` from the product back to itself). |
 
 **Cycle refusal runs in the models.** `BomLine.validateBeforeSave` checks every line save (draft bills too, so a loop is refused when written); `BillOfMaterials.validateBeforeSave` checks every save of an `active` bill (activation), including the lines of a stored bill with the same `(productId, version, tenantId)` that the save would upsert onto. The generated REST routes go through `save()`, so they refuse cycles as well. Not covered: re-pointing a `Sku.productId` (owned by `smrt-products`) and two concurrent saves that each close half of a loop.
 
+## Multi-level walks and production runs
+
+Detail: [agents/multilevel-and-runs.md](agents/multilevel-and-runs.md).
+
+- Every `BomService` method takes `{ levels }` (default `1`, unchanged; up to `MAX_EXPLOSION_DEPTH` = 32, or `'all'`). One walk (`services/structure-walk.ts`) serves `explode` (gross lines and totals), `planRequirements` (net of stock: available, short, what building a shortfall takes; facts, no make-or-buy policy), `canProduce`, cost and labour. A loop already in stored data fails with `BomStructureCycleError`; size limits with `BomExplosionLimitError`.
+- `ProductionRunService` writes `ProductionRun` / `ProductionRunCompletion` in one transaction per call, locking the run row through its revision-guarded save and retrying on a revision conflict; no adapter without `transaction()`. Stock moves only when the caller passes `consume` / `produce`.
+- A run is not commerce's `ProductionOrder` (a `Contract` with terms and money, in a package this one does not depend on); an application that has both links them.
+
 ## Svelte components (`./svelte`)
 
-Props-driven; the host loads and persists. `AssemblyList` (field policy drops hidden columns via `policyToVisibleColumnIds`), `AssemblyForm` (smrt-fields `ObjectForm` for `@happyvertical/smrt-manufacturing:Assembly`, so price and every other field follow the consumer's field policy), `BomEditor` (add/edit/remove lines through host handlers; a sub-assembly shows whether it has its own bill and expands read-only through `loadBill`), `BomStructureTree` (the read-only nested view). Adapters: `toAssemblyView`, `toBomEditorLines`. Strings are under `manufacturing.` in `src/svelte/i18n.ts`; the package is strict for raw primitives, hardcoded strings and JSDoc.
+Props-driven; the host loads and persists. `AssemblyList` (a structural `policy` drops hidden columns), `AssemblyForm` (smrt-ui controls like `OperationForm`: `assembly`, `onsubmit`, `operations` for the default-operation picker, a retired or unlisted current operation stays selected and marked, `hiddenFields`/`readonlyFields` for the reader's field policy; price is major units in the form and integer minor units in `onsubmit`; `validateAssemblyForm` mirrors the model's whole-minutes rule). `smrt-fields` is not a dependency: never add `ObjectForm`, `BomEditor` (add/edit/remove lines through host handlers; a sub-assembly shows whether it has its own bill and expands read-only through `loadBill`), `BomStructureTree` (the read-only nested view). `ProductionRunList` (progress, status, and with `oncomplete` a quantity field per open run; rows from `toProductionRunView`), `RequirementsTree` (read-only `explode` / `planRequirements` result by level with totals; `toRequirementTree`, `toRequirementTotals`; internal `RequirementsTreeLevel`). Adapters: `toAssemblyView`, `toBomEditorLines`. Strings are under `manufacturing.` in `src/svelte/i18n.ts`; the package is strict for raw primitives, hardcoded strings and JSDoc.
 
 
 ## BomService — planning helpers
@@ -72,6 +82,7 @@ const check = await bom.canProduce(bomId, 100);
 | `computeMaterialCost(bomId)` | Walks every BomLine, applies waste (`qtyPerUnit * (1 + wastePercent / 100)`), resolves unit costs via the optional `costResolver`, returns per-line breakdown plus rolled-up total. Lines with no cost set `costUnavailable: true` and contribute `0`. |
 | `explodeRequirements(bomId, qty)` | Returns a "shopping list" of materials needed for `qty` units. Duplicates across lines are summed. Does NOT mutate stock. |
 | `canProduce(bomId, qty)` | Calls `explodeRequirements`, then sums `available` stock across every location per component, returns `{ ok: true }` if everything's covered, else `{ ok: false, shortages: [...] }`. |
+| `explode` / `planRequirements` | Multi-level walks; see "Multi-level walks" above. Each method above also takes `{ levels }`. |
 
 ## ProductionService — consume / produce
 
@@ -102,7 +113,7 @@ const { consumed, produced } = await production.runProduction(
 );
 ```
 
-All three methods write through `StockService` and stamp every emitted `StockMovement` with `sourceType: 'ProductionOrder'` + the production order id so audit queries can roll them up later.
+All three methods write through `StockService` and stamp every emitted `StockMovement` with `sourceType: 'ProductionOrder'` (override with the `sourceType` option, as `ProductionRunService` does) + the production order id so audit queries can roll them up later.
 
 ### Joint atomicity — `runProduction` vs the two-call form
 
@@ -155,7 +166,7 @@ The companion handlers for `contract:created` (reserve) and `fulfillment:shipped
 
 ## Tests
 
-`src/__tests__/assembly-suite.ts` runs on SQLite (`assembly.test.ts`) and on PostgreSQL (`assembly.optional.test.ts`, skipped without `DATABASE_URL`; `pnpm test:postgres` and the PostgreSQL CI lane run it on a transaction-scoped handle). Component tests under `src/svelte/__tests__` use jsdom and assert axe.
+`multilevel-suite.ts` (rolled back on PostgreSQL) and `production-run-suite.ts` (base handle, per-test tenant, for real concurrent transactions) follow the same SQLite / `*.optional.test.ts` pattern. `src/__tests__/assembly-suite.ts` runs on SQLite (`assembly.test.ts`) and on PostgreSQL (`assembly.optional.test.ts`, skipped without `DATABASE_URL`; `pnpm test:postgres` and the PostgreSQL CI lane run it on a transaction-scoped handle). Component tests under `src/svelte/__tests__` use jsdom and assert axe.
 
 ## Gotchas
 
@@ -165,7 +176,7 @@ The companion handlers for `contract:created` (reserve) and `fulfillment:shipped
 - **`consumeMaterials` propagates `InsufficientStockError`.** If a line would drive `available` below zero, the underlying `StockService.adjust` throws. Pre-flight with `canProduce` before posting if you want to avoid partial-failure mid-run.
 - **`consumeMaterials` is atomic across BOM lines.** All per-line deductions and their audit rows run inside a single `stockService.withTransaction(...)` scope (powered by `@happyvertical/sql >= 0.74.0`'s native `db.transaction()`). An `InsufficientStockError` on line N+1 rolls back lines 1..N so production-order posting never leaves materials half-consumed. The recommended pre-flight (`BomService.canProduce(orderId, qty)`) is still useful when you'd rather know upfront than discover the shortfall mid-run, but a missed pre-flight no longer corrupts state.
 - **`consumeMaterials` + `produceFinishedGoods` are NOT jointly atomic.** Each opens its own transaction. A failure on the produce leg leaves materials deducted with no finished SKU receipt to balance it. Use `runProduction(order, { consume, produce })` when you need both legs to commit or roll back together.
-- **Cross-package references are plain strings.** `productId`, `componentSkuId`, `bomId` (within this package) — all plain string ids, never `@foreignKey()`. The package does depend on `smrt-products` (for `Assembly` and the resolve helper), but the bill schema does not couple to the catalog's table layout.
+- **Cross-package references are plain strings.** `BillOfMaterials.productId`, `BomLine.componentSkuId` and `BomLine.bomId` are plain string ids (changing them to UUID references needs a migration window); the newer models (`RoutingStep`, `ProductionRun`, `ProductionRunCompletion`) reference this package's own models with `@foreignKey`. The package does depend on `smrt-products` (for `Assembly` and the resolve helper), but the bill schema does not couple to the catalog's table layout.
 - **`Assembly` fields are columns, not `Meta<T>`.** Unlike `Material`, its own fields are ordinary columns this package adds to `products` (filterable over REST). The PostgreSQL suite asserts they land there.
 - **`AssemblyCollection` lists exact `Assembly` rows.** An application subtype (e.g. one adding a customer) has its own `_meta_type`; read it through its own collection or `ProductCollection` (`resolveComponent` uses `instanceof Assembly`, so subtypes resolve as assemblies).
 - **`conflictColumns` include `tenant_id`** on both models. NULL-matching semantics are handled by `@happyvertical/sql >= 0.74.0`; two saves with the same `(product_id, version, NULL)` tuple merge in place.
@@ -180,6 +191,7 @@ Every emitted `StockMovement` carries `sourceType: 'ProductionOrder'` plus `sour
 |---|---|---|
 | `production_consume` | `ProductionService.consumeMaterials` | One per BOM line per consume call |
 | `production_produce` | `ProductionService.produceFinishedGoods` | One per produce call |
+| either, with `sourceType: 'ProductionRunCompletion'` | `ProductionRunService.recordCompletion` | Only when the caller passes `consume` / `produce` |
 
 These join cleanly with the standard inventory reason codes (`receipt`, `reservation`, `release`, `fulfillment`, `transfer_out`, `transfer_in`, `adjustment`) defined in `@happyvertical/smrt-inventory`.
 
@@ -190,7 +202,6 @@ These join cleanly with the standard inventory reason codes (`receipt`, `reserva
 | `@happyvertical/smrt-core` | SmrtObject / SmrtCollection / DispatchBus |
 | `@happyvertical/smrt-inventory` | StockService, stock levels, movements (the `Sku` model itself lives in `@happyvertical/smrt-products`; inventory tracks stock motion against the id) |
 | `@happyvertical/smrt-products` | `Product` (the `Assembly` STI base), `Material`, `Sku` for the resolve helper and cycle check |
-| `@happyvertical/smrt-fields` | `ObjectForm` and field-policy column visibility for the Svelte components |
 | `@happyvertical/smrt-ui` / `smrt-types` | Svelte controls, i18n, module UI slots |
 | `@happyvertical/smrt-tenancy` | Optional tenant scoping |
 | `@happyvertical/sql` | Database adapter |

package/README.md

@@ -202,6 +202,54 @@ if (!check.ok) {
 }
 ```
 
+### Walk sub-assemblies
+
+Every `BomService` method reads one level by default. Pass `{ levels }` (a number of bill levels, or `'all'`) to open each sub-assembly that has an active bill. Waste compounds down the levels; units stay as each line declares them.
+
+```typescript
+const service = await BomService.create({ db });
+
+// Gross: every line with its level and path, plus the rolled-up totals.
+const explosion = await service.explode(frameBom.id!, 10, { levels: 'all' });
+// explosion.lines:  [{ level: 1, name: 'Side panel', totalQty: 20, expanded: true, ... },
+//                    { level: 2, name: 'Steel tube', totalQty: 44, uom: 'm', ... }, ...]
+// explosion.totals: [{ componentSkuId: tubeSku.id, totalQty: 44, uom: 'm' }]
+
+// Net of stock: what is available, what is short, and what building the
+// shortfall of each sub-assembly takes. Facts only; you decide build or buy.
+const plan = await service.planRequirements(frameBom.id!, 10, { levels: 'all' });
+// plan.lines:     [{ name: 'Side panel', totalQty: 20, available: 5, short: 15, expanded: true }, ...]
+// plan.shortages: [{ componentSkuId: tubeSku.id, requested: 33, available: 0, level: 2, path: [...] }]
+
+await service.canProduce(frameBom.id!, 10, { levels: 'all' }); // shortages at their own level
+await service.computeMaterialCost(frameBom.id!, { levels: 'all' }); // sub-assemblies costed from their bills
+await service.computeLabourEstimate(frameBom.id!, { levels: 'all' }); // adds sub-assembly routings
+```
+
+A walk stops at materials, bought items, assemblies without an active bill and the `levels` limit. It refuses a structure deeper than `MAX_EXPLOSION_DEPTH` (32) levels or larger than `MAX_EXPLOSION_LINES`, and a loop already present in stored data fails with `BomStructureCycleError` naming it.
+
+### Record a production run
+
+A `ProductionRun` is a build of a target quantity against one bill, reported as it happens.
+
+```typescript
+import { ProductionRunService } from '@happyvertical/smrt-manufacturing';
+
+const runs = await ProductionRunService.create({ db });
+const run = await runs.createRun({ productId: frame.id!, targetQty: 25 }); // pins the active bill
+
+await runs.recordCompletion(run.id!, { qty: 12 }); // 25 to build, 12 done; no stock moves
+
+// Optionally consume the bill and receive the finished units in the same transaction.
+await runs.recordCompletion(run.id!, {
+  qty: 13,
+  consume: { locationId: factory.id! },
+  produce: { locationId: factory.id!, finishedSkuId: frameSku.id! },
+}); // the run is now done
+```
+
+`start`, `finish` (done short of the target), `cancel` and `setTarget` move the run through `planned`, `in_progress`, `done` and `cancelled`. Concurrent reports all count and never pass the target. Quantities are decimals kept to six places and summed exactly, so `0.1 + 0.2` completes a target of `0.3`; a run accepts quantities up to `MAX_QUANTITY` (999,999,999).
+
 ### Execute consume / produce against a production order
 
 The `ProductionOrder` row itself lives in `@happyvertical/smrt-commerce` as a `Contract` STI subtype. This package mutates the inventory ledger on its behalf.
@@ -294,17 +342,23 @@ Per-handler toggles (`installProductionPosted`, `installProductionCompleted`) le
     AssemblyForm,
     AssemblyList,
     BomEditor,
+    ProductionRunList,
+    RequirementsTree,
+    toRequirementTotals,
+    toRequirementTree,
   } from '@happyvertical/smrt-manufacturing/svelte';
 
-  let { assemblies, policy, fields, lines, components } = $props();
+  let { assemblies, policy, assembly, operations, lines, components, runs, plan } = $props();
 </script>
 
 <AssemblyList {assemblies} {policy} onselect={(id) => goto(`/assemblies/${id}`)} />
-<AssemblyForm {fields} {policy} onsubmit={save} />
+<AssemblyForm {assembly} {operations} hiddenFields={['price']} onsubmit={save} />
 <BomEditor {lines} {components} onadd={addLine} loadBill={loadLines} error={saveError} />
+<ProductionRunList {runs} oncomplete={(runId, qty) => report(runId, qty)} />
+<RequirementsTree lines={toRequirementTree(plan)} totals={toRequirementTotals(plan)} />
 ```
 
-`AssemblyList` and `AssemblyForm` follow the consumer's field policy for `@happyvertical/smrt-manufacturing:Assembly` (a hidden price is not shown). Build rows with `toAssemblyView` and editor lines with `toBomEditorLines(await assemblyService.getBillStructure(bomId))`. A sub-assembly line in `BomEditor` says whether it has its own bill and expands read-only through `loadBill`.
+`AssemblyList` takes the resolved field `policy` for Assembly and drops the columns it hides (a hidden price is not shown). `AssemblyForm` is a plain form on smrt-ui controls: name, description, category, part reference, price (typed in major units, checked against the `currency` prop's minor-unit exponent, handed over as integer minor units; a field the reader leaves untouched keeps its stored value exactly), estimated labour (whole minutes, zero or more), a default-operation picker over the `operations` you pass (pass the active ones; a retired or unlisted current operation stays selected, marked, and can be cleared) and tags. Pass the `assembly` being edited (omit to add), and map the reader's field policy onto `hiddenFields` (not rendered) and `readonlyFields` (shown, not editable); both carry their initial value through `onsubmit` unchanged, so save only what the reader may write. `onsubmit` receives checked values and the form never persists. Build rows with `toAssemblyView` and editor lines with `toBomEditorLines(await assemblyService.getBillStructure(bomId))`. A sub-assembly line in `BomEditor` says whether it has its own bill and expands read-only through `loadBill`. `ProductionRunList` shows each run's progress and status and, with `oncomplete`, a field to report finished units (rows from `toProductionRunView`). `RequirementsTree` shows an `explode` or `planRequirements` result by level, with available and short per line for a plan.
 
 ## API
 
@@ -317,6 +371,8 @@ Per-handler toggles (`installProductionPosted`, `installProductionCompleted`) le
 | `BomLine` | One component on a BOM. `effectiveQtyPerUnit()` returns the qty including waste. |
 | `Operation` | A kind of work: `code` (unique per tenant), `name`, `category`, `isActive` (retired operations stay on history, never deleted), optional `requiredQualificationId` (plain string id of a `smrt-human-resources` qualification). |
 | `RoutingStep` | One operation in a BOM's optional routing: `bomId`, `operationId`, `sequence` (1..n), `estimatedMinutes`, `notes`. |
+| `ProductionRun` | A build against one bill: `bomId`, `targetQty`, `completedQty`, `status` (`planned` / `in_progress` / `done` / `cancelled`). Written through `ProductionRunService`. |
+| `ProductionRunCompletion` | One dated report of finished units on a run: `runId`, `qty`, `completedAt`. |
 
 ### Collections
 
@@ -327,6 +383,8 @@ Per-handler toggles (`installProductionPosted`, `installProductionCompleted`) le
 | `BomLineCollection` | `findByBom`, `findByComponent` |
 | `OperationCollection` | `findByCode`, `listOperations({ includeRetired? })` |
 | `RoutingStepCollection` | `findByBom` (in step order), `findByOperation` |
+| `ProductionRunCollection` | `findByBom`, `findByStatus` |
+| `ProductionRunCompletionCollection` | `findByRun` (in completion order) |
 
 ### Services
 
@@ -335,7 +393,10 @@ Per-handler toggles (`installProductionPosted`, `installProductionCompleted`) le
 | `AssemblyService` | `resolveComponent`, `findActiveBom`, `isAssembly`, `getBillStructure`, `findCycle`, `assertLineAcyclic`, `assertBillAcyclic`. Pass `{ tenantId }` to read one tenant's structure. |
 | `createAssemblyService({ db })` | Convenience factory. |
 | `BomCycleError` | A `ValidationError` naming the `path` by which a save would make a product contain itself. |
-| `BomService` | Cost rollup, requirements explosion, can-produce check. |
+| `BomService` | Cost rollup, requirements explosion, can-produce check; `{ levels }` walks sub-assemblies. `explode` (gross lines and totals) and `planRequirements` (net of stock). |
+| `BomStructureCycleError`, `BomExplosionLimitError` | A walk met a loop in stored data, or exceeded `MAX_EXPLOSION_DEPTH` / `MAX_EXPLOSION_LINES`. |
+| `ProductionRunService` / `createProductionRunService({ db })` | `createRun`, `get`, `listCompletions`, `start`, `recordCompletion`, `finish`, `cancel`, `setTarget`. |
+| `ProductionRunNotFoundError`, `ProductionRunStateError`, `ProductionRunOverCompletionError`, `InvalidProductionRunInputError` | Production run errors. |
 | `createBomService({ db, costResolver?, rateResolver? })` | Convenience factory. `computeLabourEstimate(bomId)` rolls up routing minutes and, with a `rateResolver`, cost. |
 | `OperationService` / `createOperationService({ db })` | `define`, `get`, `list`, `rename`, `update`, `retire`, `reinstate`. |
 | `RoutingService` / `createRoutingService({ db })` | `list(bomId)`, `replaceRouting(bomId, steps)`. |
@@ -359,6 +420,11 @@ Per-handler toggles (`installProductionPosted`, `installProductionCompleted`) le
 | `MaterialRequirement` | Entry returned by `explodeRequirements`. |
 | `MaterialShortage` | Entry returned by `canProduce` when stock is insufficient. |
 | `CanProduceResult` | `{ ok: true; shortages: [] } \| { ok: false; shortages: [...] }` |
+| `ExplosionLevels`, `ExplosionOptions` | `levels`: a number of bill levels or `'all'`. |
+| `Explosion`, `ExplodedLine`, `ExplosionPathEntry` | Return shape of `explode`. |
+| `RequirementsPlan`, `PlannedLine` | Return shape of `planRequirements`. |
+| `SubAssemblyLabour` | One sub-assembly in a multi-level `LabourEstimate`. |
+| `CreateProductionRunInput`, `RecordCompletionInput`, `RecordCompletionResult` | Production run inputs and results. |
 | `ComponentCostResolver` | Async (or sync) callback returning unit cost or `null`. |
 | `OperationRateResolver` | Async (or sync) callback returning an operation's hourly rate or `null`. |
 | `LabourEstimate`, `RoutingStepEstimate` | Return shape of `computeLabourEstimate`. |
@@ -371,7 +437,6 @@ Per-handler toggles (`installProductionPosted`, `installProductionCompleted`) le
 | `@happyvertical/smrt-core` | SmrtObject / SmrtCollection / DispatchBus |
 | `@happyvertical/smrt-inventory` | StockService (consume / produce target) |
 | `@happyvertical/smrt-products` | `Product` (base of `Assembly`), `Material`, `Sku` |
-| `@happyvertical/smrt-fields` | `ObjectForm` and field-policy columns for the Svelte components |
 | `@happyvertical/smrt-ui` | Svelte controls and i18n |
 | `@happyvertical/smrt-tenancy` | Optional tenant scoping |
 | `@happyvertical/smrt-ui` / `@happyvertical/smrt-types` | Operation list and form (`./svelte`), module slots (`./ui`); `svelte` is an optional peer |

package/agents/multilevel-and-runs.md

@@ -0,0 +1,28 @@
+# Multi-level walks and production runs
+
+Detail for `services/structure-walk.ts`, the multi-level forms of `BomService`, and `ProductionRunService`. Orientation and gotchas stay in the package [AGENTS.md](../AGENTS.md).
+
+## Multi-level walks (sub-assemblies)
+
+Every `BomService` method takes `{ levels }` (`1` by default: the single-level behaviour, unchanged; a number up to `MAX_EXPLOSION_DEPTH` = 32; or `'all'`). The walk is `services/structure-walk.ts`, shared by all of them: resolve each line through `AssemblyService.resolveComponent` (in the top bill's tenant), open an assembly's active bill while `levels` allows, stop at materials, bought items, missing components and assemblies without an active bill.
+
+| Method | Multi-level behaviour |
+|---|---|
+| `explode(bomId, qty, { levels })` | Gross: every line depth first with `level`, `path` (bills from the top), `totalQty` (waste compounds: a child is the parent line's quantity times its own effective quantity), `buildable`, `expanded`; `totals` sums the lines not opened per SKU (first unit kept, as before). |
+| `planRequirements(bomId, qty, { levels })` | Net: per line, `available` stock not yet allocated to an earlier line and `short`; a short buildable sub-assembly is opened for the shortfall only. Lines short and not opened are `shortages`, each at its own level. Facts only: no make-or-buy policy. |
+| `explodeRequirements` / `canProduce` | `explode().totals` / the plan's shortages (`level`, `path`, `uom`, `buildable` added). |
+| `computeMaterialCost` | An opened sub-assembly is costed from its bill (`subBomId`, nested `components`); a missing price below marks it. A sub-assembly bill in another currency is not added: its line is priced through the resolver. |
+| `computeLabourEstimate` | Adds each opened sub-assembly's routing times its units per top unit (`subAssemblies`); `steps` stays the top routing. Minutes always count; cost from a bill in another currency does not, and sets `hasMissingRates`. |
+
+Safety: a loop already in stored data (written around the save-time refusal) fails with `BomStructureCycleError` (a `BomCycleError`) naming it; `'all'` past 32 levels or a walk past `MAX_EXPLOSION_LINES` (10,000, counted per use of a shared sub-assembly) fails with `BomExplosionLimitError`. Stock in a plan is summed across locations, as in `canProduce`, counting only the top bill's tenant's rows and global ones (like the lines the walk reads), whatever tenant context is active.
+
+## Production runs
+
+`ProductionRunService` (`createRun({ bomId } | { productId }, targetQty)`, `start`, `recordCompletion`, `finish`, `cancel`, `setTarget`, `get`, `listCompletions`). Every write is one transaction that saves the run row first; the revision-guarded save locks it, and a concurrent writer's conflict reruns its whole transaction (up to 10 attempts), so concurrent completions all count and never pass the target. The service refuses an adapter without `transaction()`; it never falls back to step-by-step writes.
+
+- Tenant: every structure read goes through `src/tenant-scope.ts`: list reads run in `withTenantGlobalRead` for the owning tenant (its rows plus global rows; a tenant context alone would hide global rows, no context would show every tenant's) and keep own-or-global rows. Routing and operations in `computeLabourEstimate`, and the top bill itself under a tenant context, are read the same way. `createRun` reads the active tenant's bills and global ones (no context: global bills only, by `productId` or `bomId`). The run takes its bill's tenant; a completion takes the run's; stock legs run inside `withTenant(run.tenantId)`, so the bill's lines and the levels read and written are that tenant's whatever the caller's context. `ProductionService` consumes only a bill's own tenant's lines and global ones (a global bill: global lines only), for every caller; a global run's stock legs run in the caller's context.
+- A completion moves no stock unless asked. With `consume` / `produce` it calls `ProductionService` (`runProduction` for both) on the transaction's stock service, stamping movements `sourceType: 'ProductionRunCompletion'` with the completion id; a shortfall rolls the completion back. Consumption is the run's bill's own lines: a sub-assembly is taken from stock, and building it is its own run.
+- Quantities are kept to `QUANTITY_DECIMALS` (6) places, never compared with a tolerance. A run's target, completed quantity and each report are summed and compared as whole millionths, exactly; a run accepts quantities up to `MAX_QUANTITY` (999,999,999, so every value has at most 15 significant digits and survives a double exactly) and refuses one that rounds to zero. A plan's `short` is rounded with `roundQuantity`.
+- Reaching the target marks the run `done`; `finish` closes it short; `cancel` keeps its completions; `setTarget` cannot go below what is done.
+- Why not commerce `ProductionOrder`: that is a `Contract` (terms, money, customer or vendor, a contract status flow), owned by `smrt-commerce`, which this package does not depend on. A run is the shop-floor record of building; one order may need several runs, and make-to-stock needs none. An application that has both links them.
+- Deliberately absent (nothing here would use them): a link to an order, who did the work, a location on the run (passed per call, as in `ProductionService`).

package/dist/collections/ProductionRunCollection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ProductionRunCollection — query helpers for {@link ProductionRun} rows.
+ *
+ * @packageDocumentation
+ */
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { ProductionRun, type ProductionRunStatus } from '../models/ProductionRun.js';
+export declare class ProductionRunCollection extends SmrtCollection<ProductionRun> {
+    static readonly _itemClass: typeof ProductionRun;
+    /** Runs against one bill, newest first. */
+    findByBom(bomId: string): Promise<ProductionRun[]>;
+    /** Runs in one status, oldest first (a work queue). */
+    findByStatus(status: ProductionRunStatus): Promise<ProductionRun[]>;
+}
+//# sourceMappingURL=ProductionRunCollection.d.ts.map

package/dist/collections/ProductionRunCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProductionRunCollection.d.ts","sourceRoot":"","sources":["../../src/collections/ProductionRunCollection.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EACL,aAAa,EACb,KAAK,mBAAmB,EACzB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,uBAAwB,SAAQ,cAAc,CAAC,aAAa,CAAC;IACxE,MAAM,CAAC,QAAQ,CAAC,UAAU,uBAAiB;IAE3C,2CAA2C;IACrC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAIxD,uDAAuD;IACjD,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;CAG1E"}

package/dist/collections/ProductionRunCompletionCollection.d.ts

@@ -0,0 +1,14 @@
+/**
+ * ProductionRunCompletionCollection — query helpers for
+ * {@link ProductionRunCompletion} rows.
+ *
+ * @packageDocumentation
+ */
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { ProductionRunCompletion } from '../models/ProductionRunCompletion.js';
+export declare class ProductionRunCompletionCollection extends SmrtCollection<ProductionRunCompletion> {
+    static readonly _itemClass: typeof ProductionRunCompletion;
+    /** A run's completions in the order they happened. */
+    findByRun(runId: string): Promise<ProductionRunCompletion[]>;
+}
+//# sourceMappingURL=ProductionRunCompletionCollection.d.ts.map

package/dist/collections/ProductionRunCompletionCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProductionRunCompletionCollection.d.ts","sourceRoot":"","sources":["../../src/collections/ProductionRunCompletionCollection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAE/E,qBAAa,iCAAkC,SAAQ,cAAc,CAAC,uBAAuB,CAAC;IAC5F,MAAM,CAAC,QAAQ,CAAC,UAAU,iCAA2B;IAErD,sDAAsD;IAChD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;CAMnE"}

package/dist/collections/index.d.ts

@@ -13,5 +13,7 @@ export { AssemblyCollection } from './AssemblyCollection.js';
 export { BillOfMaterialsCollection } from './BillOfMaterialsCollection.js';
 export { BomLineCollection } from './BomLineCollection.js';
 export { OperationCollection } from './OperationCollection.js';
+export { ProductionRunCollection } from './ProductionRunCollection.js';
+export { ProductionRunCompletionCollection } from './ProductionRunCompletionCollection.js';
 export { RoutingStepCollection } from './RoutingStepCollection.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/collections/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collections/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,yBAAyB,CAAC;AAEjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/collections/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,yBAAyB,CAAC;AAEjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,iCAAiC,EAAE,MAAM,wCAAwC,CAAC;AAC3F,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.d.ts

@@ -20,13 +20,19 @@
  * - {@link Operation} — a kind of work (cut, weld, inspect); a managed list.
  * - {@link RoutingStep} — an operation in a BOM's optional routing, with an
  *   estimated duration.
+ * - {@link ProductionRun} — a build of a target quantity against one bill,
+ *   with dated {@link ProductionRunCompletion}s ("25 to build, 12 done").
  *
  * **Services**
  *
  * - {@link AssemblyService} — resolve a component SKU to an assembly (and
  *   its active bill), a material, or a bought item; refuse cycles.
  * - {@link BomService} — cost rollup, requirements explosion,
- *   "can we make this?" stock availability check.
+ *   "can we make this?" stock availability check; one level by default, or
+ *   through sub-assemblies with `{ levels }`.
+ * - {@link ProductionRunService} — create runs and report completions as
+ *   they happen, optionally consuming and producing stock in the same
+ *   transaction.
  * - {@link ProductionService} — operational bridge from a production
  *   order to actual `StockMovement` rows via the inventory
  *   {@link StockService}.
@@ -36,9 +42,11 @@
  * @packageDocumentation
  */
 import './__smrt-register__.js';
-export { AssemblyCollection, BillOfMaterialsCollection, BomLineCollection, OperationCollection, RoutingStepCollection, } from './collections/index.js';
-export { Assembly, type AssemblyOptions, BillOfMaterials, type BillOfMaterialsOptions, BomLine, type BomLineOptions, Operation, type OperationOptions, RoutingStep, type RoutingStepOptions, } from './models/index.js';
+export { AssemblyCollection, BillOfMaterialsCollection, BomLineCollection, OperationCollection, ProductionRunCollection, ProductionRunCompletionCollection, RoutingStepCollection, } from './collections/index.js';
+export { Assembly, type AssemblyOptions, BillOfMaterials, type BillOfMaterialsOptions, BomLine, type BomLineOptions, Operation, type OperationOptions, PRODUCTION_RUN_STATUSES, ProductionRun, ProductionRunCompletion, type ProductionRunCompletionOptions, type ProductionRunOptions, type ProductionRunStatus, RoutingStep, type RoutingStepOptions, } from './models/index.js';
 export { type DefineOperationInput, DuplicateOperationCodeError, InvalidOperationInputError, type LabourEstimate, OperationNotFoundError, type OperationRateResolver, OperationRetiredError, type RoutingStepEstimate, type RoutingStepInput, } from './operation-types.js';
-export { AssemblyService, type AssemblyServiceOptions, type BillStructure, type BillStructureLine, BomCycleError, type BomCyclePathEntry, BomService, type BomServiceOptions, type ComponentCostResolver, type ComponentKind, type ConsumeMaterialsOptions, type ConsumeResult, createAssemblyService, createBomService, createOperationService, createProductionService, createRoutingService, type InstalledManufacturingDispatchHandlers, type InstallManufacturingDispatchHandlersOptions, installManufacturingDispatchHandlers, OperationService, type OperationServiceOptions, type ProduceFinishedGoodsOptions, type ProduceResult, type ProductionOrderCompletedPayload, type ProductionOrderPostedPayload, type ProductionOrderRef, ProductionService, type ProductionServiceOptions, type ResolveComponentOptions, type ResolvedComponent, RoutingService, type RoutingServiceOptions, } from './services/index.js';
-export { type BomCostRollup, type BomLineCost, BomNotFoundError, type BomStatus, type CanProduceResult, type MaterialRequirement, type MaterialShortage, NoActiveBomForProductError, } from './types.js';
+export { type CompletionConsumeOptions, type CompletionProduceOptions, type CreateProductionRunInput, InvalidProductionRunInputError, ProductionRunNotFoundError, ProductionRunOverCompletionError, ProductionRunStateError, type RecordCompletionInput, type RecordCompletionResult, } from './production-run-types.js';
+export { MAX_QUANTITY, QUANTITY_DECIMALS, roundQuantity, } from './quantity.js';
+export { AssemblyService, type AssemblyServiceOptions, type BillStructure, type BillStructureLine, BomCycleError, type BomCyclePathEntry, BomService, type BomServiceOptions, BomStructureCycleError, type ComponentCostResolver, type ComponentKind, type ConsumeMaterialsOptions, type ConsumeResult, createAssemblyService, createBomService, createOperationService, createProductionRunService, createProductionService, createRoutingService, type InstalledManufacturingDispatchHandlers, type InstallManufacturingDispatchHandlersOptions, installManufacturingDispatchHandlers, OperationService, type OperationServiceOptions, type ProduceFinishedGoodsOptions, type ProduceResult, type ProductionOrderCompletedPayload, type ProductionOrderPostedPayload, type ProductionOrderRef, ProductionRunService, type ProductionRunServiceOptions, ProductionService, type ProductionServiceOptions, type ResolveComponentOptions, type ResolvedComponent, RoutingService, type RoutingServiceOptions, } from './services/index.js';
+export { type BomCostRollup, BomExplosionLimitError, type BomLineCost, BomNotFoundError, type BomStatus, type CanProduceResult, type ExplodedLine, type Explosion, type ExplosionLevels, type ExplosionOptions, type ExplosionPathEntry, MAX_EXPLOSION_DEPTH, MAX_EXPLOSION_LINES, type MaterialRequirement, type MaterialShortage, NoActiveBomForProductError, type PlannedLine, type RequirementsPlan, type SubAssemblyLabour, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAMH,OAAO,wBAAwB,CAAC;AAKhC,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EACL,QAAQ,EACR,KAAK,eAAe,EACpB,eAAe,EACf,KAAK,sBAAsB,EAC3B,OAAO,EACP,KAAK,cAAc,EACnB,SAAS,EACT,KAAK,gBAAgB,EACrB,WAAW,EACX,KAAK,kBAAkB,GACxB,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EACL,KAAK,oBAAoB,EACzB,2BAA2B,EAC3B,0BAA0B,EAC1B,KAAK,cAAc,EACnB,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EACL,eAAe,EACf,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,aAAa,EACb,KAAK,iBAAiB,EACtB,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,EACtB,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,sCAAsC,EAC3C,KAAK,2CAA2C,EAChD,oCAAoC,EACpC,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,aAAa,EAClB,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,gBAAgB,EAChB,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,0BAA0B,GAC3B,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAMH,OAAO,wBAAwB,CAAC;AAKhC,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,EACvB,iCAAiC,EACjC,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EACL,QAAQ,EACR,KAAK,eAAe,EACpB,eAAe,EACf,KAAK,sBAAsB,EAC3B,OAAO,EACP,KAAK,cAAc,EACnB,SAAS,EACT,KAAK,gBAAgB,EACrB,uBAAuB,EACvB,aAAa,EACb,uBAAuB,EACvB,KAAK,8BAA8B,EACnC,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,WAAW,EACX,KAAK,kBAAkB,GACxB,MAAM,mBAAmB,CAAC;AAI3B,OAAO,EACL,KAAK,oBAAoB,EACzB,2BAA2B,EAC3B,0BAA0B,EAC1B,KAAK,cAAc,EACnB,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,sBAAsB,CAAC;AAI9B,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAC7B,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,GAC5B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,aAAa,GACd,MAAM,eAAe,CAAC;AAIvB,OAAO,EACL,eAAe,EACf,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,aAAa,EACb,KAAK,iBAAiB,EACtB,UAAU,EACV,KAAK,iBAAiB,EACtB,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,qBAAqB,EACrB,gBAAgB,EAChB,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,sCAAsC,EAC3C,KAAK,2CAA2C,EAChD,oCAAoC,EACpC,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,aAAa,EAClB,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,oBAAoB,EACpB,KAAK,2BAA2B,EAChC,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EACL,KAAK,aAAa,EAClB,sBAAsB,EACtB,KAAK,WAAW,EAChB,gBAAgB,EAChB,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,0BAA0B,EAC1B,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,GACvB,MAAM,YAAY,CAAC"}