@happyvertical/smrt-manufacturing 0.53.4 → 0.53.6

package/AGENTS.md

@@ -1,19 +1,59 @@
 # @happyvertical/smrt-manufacturing
 
-Bills of materials, cost rollup, and production-order operations. 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 works alongside the `ProductionOrder` Contract STI subtype already shipped in `@happyvertical/smrt-commerce`.
+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`.
 
 ## Models
 
 | Model | Purpose |
 |---|---|
+| `Assembly` | The product that is **made**, counterpart to `Material`. Cross-package STI subtype of `smrt-products` `Product` (`productType: 'assembly'`, `_meta_type: '@happyvertical/smrt-manufacturing:Assembly'`) in the shared `products` table. Own columns: `estimatedLabourMinutes` (integer, per unit; a save refuses anything but a whole number of minutes of zero or more), `defaultOperationId` (`@foreignKey(Operation)`, nullable, RESTRICT like `RoutingStep.operationId`: the operation work on it is booked to by default), `partReference` (the organization's drawing/part number). Name, price, tags come from `Product`; part number and stock from its `Sku` and inventory; structure from its bill; documents from `ProductAsset`. Exposure matches `Product` (REST list/get/create/update, MCP list/get), as the issue asks: unlike `Operation`, the assembly row has no service-owned invariant that generated writes could bypass. |
 | `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']`. |
 
-Both models are `@TenantScoped({ mode: 'optional' })` with a nullable `tenantId` so they can be used either tenant-scoped or globally.
+All models are `@TenantScoped({ mode: 'optional' })` with a nullable `tenantId` so they can be used either tenant-scoped or globally.
+
+## Operations, routing and labour estimate
+
+- `OperationService` maintains the list (`define` rejects a duplicate code, including a retired one's; `rename`, `update`, `retire`, `reinstate`). `RoutingService.replaceRouting(bomId, steps)` swaps a bill's whole routing in one transaction and numbers it 1..n; a retired operation may stay on a routing that has it but cannot be newly added.
+- `BomService.computeLabourEstimate(bomId)` returns minutes and, only when the caller supplies `rateResolver` (hourly rate per `Operation`, mirroring `costResolver`), cost. No resolver means minutes only with `rateUnavailable` on each step. A bill with no routing returns an empty estimate; `computeMaterialCost` is unchanged.
+- `Operation` and `RoutingStep` expose generated list/get only; writes go through the services (generated create/update would upsert on a duplicate code or rename the code). `replaceRouting` saves the bill row inside its transaction (row lock) and retries on a revision conflict, so concurrent replacements serialize.
+- Deliberately absent: a default labour rate class (nothing here would use it; the resolver receives the whole `Operation` and can key on `code`/`category`), setup time, scheduling and work-centre capacity, and time recorded against an operation (that stays in `smrt-timesheets` or the application).
+- `./svelte` exports `OperationList` and `OperationForm` (props-driven; hosts persist through `OperationService`). Messages live in `src/svelte/i18n.ts`; component tests use the shared jsdom harness with axe assertions.
+- Tests: `operations-suite.ts` runs on SQLite (`operations.test.ts`) and PostgreSQL (`operations.optional.test.ts`, `pnpm test:postgres`; each test runs in its own tenant because PostgreSQL test data persists).
+
+## Assemblies — nesting lives in the bill
+
+A sub-assembly is a `BomLine` whose component SKU belongs to an `Assembly`; there is no children list on the model. `AssemblyService` is the one link from a line to what it names:
+
+| Method | Behavior |
+|---|---|
+| `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`), 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). `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.
 
-`RoutingStep` (labor cost) is intentionally out of scope for v1 — see issue [#1245](https://github.com/happyvertical/smrt/issues/1245) for the planned follow-up.
 
 ## BomService — planning helpers
 
@@ -42,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
 
@@ -72,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
 
@@ -123,6 +164,10 @@ This subscribes to:
 
 The companion handlers for `contract:created` (reserve) and `fulfillment:shipped` (fulfil) live in `@happyvertical/smrt-inventory` — wire both packages' installers from `smrt.ts` to get the full lifecycle.
 
+## Tests
+
+`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
 
 - **`computeMaterialCost` without a resolver returns `$0`.** That is deliberate — manufacturing does not assume any particular cost source. A real wiring will plug in `@happyvertical/smrt-products` `Material.costPerUnit`, or a rolling average from purchase-order history, or a vendor price book. The `costUnavailable` flag tells UIs to surface "unknown cost" rather than silently rolling up zeros.
@@ -131,9 +176,11 @@ 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()`. Keeps the dependency graph DAG-shaped and lets each upstream package evolve independently.
+- **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.
-- **Lazy table creation.** Like everything else in SMRT, the `manufacturing_boms` and `manufacturing_bom_lines` tables are created on first DB op via `syncSchema`. Safe for SSR.
+- **Lazy table creation.** Like everything else in SMRT, the `manufacturing_boms` and `manufacturing_bom_lines` tables are created on first DB op via `syncSchema`. Safe for SSR. A `BomLine` save now reads `product_skus` and `products` for the cycle check.
 - **Cross-industry constraint.** This package's vocabulary stays generic. Apparel-specific concepts (`Style`, `Makeup`, `Colorway`, `tech-pack`, fashion `Season`) and their analogues in furniture / automotive / CPG live in the relevant template package, never here. PRs that introduce industry vocabulary should be rejected.
 
 ## Source attribution
@@ -144,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`.
 
@@ -153,5 +201,8 @@ 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

@@ -8,10 +8,68 @@ Bills of materials, cost rollup, and production-order operations for the s-m-r-t
 pnpm add @happyvertical/smrt-manufacturing
 ```
 
-This package depends on `@happyvertical/smrt-inventory` (peer-installed via your workspace) for stock operations.
+This package depends on `@happyvertical/smrt-inventory` for stock operations and on `@happyvertical/smrt-products` for the catalog: `Assembly` is a `Product` subtype, and bill lines point at `Sku` ids.
 
 ## Usage
 
+### Define an assembly and its bill
+
+An `Assembly` is a product that is made, the counterpart to `Material`. It lives in the shared `products` table (`productType: 'assembly'`) and adds three fields of its own: `estimatedLabourMinutes`, `defaultOperationId` and `partReference`. Its part number and stock come from its `Sku`; what it is made of comes from its bill. A sub-assembly is simply a bill line whose SKU belongs to another assembly.
+
+```typescript
+import { SkuCollection } from '@happyvertical/smrt-products/collections';
+import {
+  AssemblyCollection,
+  BillOfMaterialsCollection,
+  BomLineCollection,
+} from '@happyvertical/smrt-manufacturing';
+
+const assemblies = await AssemblyCollection.create({ db });
+const skus = await SkuCollection.create({ db });
+const boms = await BillOfMaterialsCollection.create({ db });
+const lines = await BomLineCollection.create({ db });
+
+const panel = await assemblies.create({ name: 'Side panel', partReference: 'DWG-200' });
+const panelSku = await skus.create({ productId: panel.id!, code: 'SP-100' });
+
+const frame = await assemblies.create({
+  name: 'Frame',
+  partReference: 'DWG-100',
+  estimatedLabourMinutes: 95,
+});
+const frameBom = await boms.create({ productId: frame.id!, version: 1, status: 'active' });
+
+// Two side panels per frame: a sub-assembly line.
+await lines.create({ bomId: frameBom.id!, componentSkuId: panelSku.id!, qtyPerUnit: 2 });
+```
+
+### Resolve a component, and refused cycles
+
+```typescript
+import { AssemblyService, BomCycleError } from '@happyvertical/smrt-manufacturing';
+
+const assemblyService = await AssemblyService.create({ db });
+
+const component = await assemblyService.resolveComponent(panelSku.id!);
+// component.kind: 'assembly' | 'material' | 'bought' | 'missing'
+// component.activeBom: the sub-assembly's active bill, or null when it has none
+// component.buildable: true only for an assembly with an active bill
+
+const frameSku = await skus.create({ productId: frame.id!, code: 'FR-100' });
+const panelBom = await boms.create({ productId: panel.id!, version: 1, status: 'active' });
+try {
+  // The frame contains the panel, so the panel may not contain the frame.
+  await lines.create({ bomId: panelBom.id!, componentSkuId: frameSku.id!, qtyPerUnit: 1 });
+} catch (error) {
+  if (error instanceof BomCycleError) {
+    console.log(error.message);
+    // Refused: "Side panel" would contain itself: Side panel → Frame → Side panel
+  }
+}
+```
+
+Every `BomLine` save, and every save of an `active` bill, runs this check, so the generated REST routes refuse a cycle too. Only active bills of sub-assemblies count; a draft or superseded bill is not part of the structure.
+
 ### Define a BOM with components
 
 ```typescript
@@ -71,6 +129,62 @@ console.log(rollup.totalCost, rollup.currency);
 // Walks lines, applies waste, surfaces a per-line breakdown.
 ```
 
+### Operations, routing and estimated labour
+
+An `Operation` is a kind of work (cut, weld, inspect) kept as a managed list per
+tenant. A bill of materials may carry a routing: an ordered list of operations,
+each with an estimated duration in minutes for one unit. A bill with no routing
+works exactly as before.
+
+```typescript
+import {
+  BomService,
+  OperationService,
+  RoutingService,
+} from '@happyvertical/smrt-manufacturing';
+
+const operations = await OperationService.create({ db });
+const cut = await operations.define({ code: 'CUT', name: 'Cutting', category: 'fabrication' });
+const weld = await operations.define({
+  code: 'WELD',
+  name: 'Welding',
+  // Plain id of a smrt-human-resources Qualification; an application reads it
+  // to decide who may start the operation. Not validated here.
+  requiredQualificationId: qualificationId,
+});
+await operations.rename(cut.id!, 'Plasma cutting');
+await operations.retire(weld.id!); // leaves pickers, stays on history
+await operations.reinstate(weld.id!);
+
+const routing = await RoutingService.create({ db });
+await routing.replaceRouting(bom.id!, [
+  { operationId: cut.id!, estimatedMinutes: 30 },
+  { operationId: weld.id!, estimatedMinutes: 90, notes: 'tack first' },
+]);
+
+const service = await BomService.create({
+  db,
+  // Optional, like costResolver: hourly rate for an operation, or null.
+  rateResolver: (operation) => (operation.code === 'WELD' ? 80 : 60),
+});
+const labour = await service.computeLabourEstimate(bom.id!);
+console.log(labour.totalMinutes, labour.totalCost, labour.steps);
+```
+
+`replaceRouting` swaps the whole routing in one transaction (steps are numbered
+1..n in the order given; an empty list removes it). A retired operation can stay
+on a routing that already has it but cannot be newly added. Without a
+`rateResolver` the estimate reports minutes only and flags each step
+`rateUnavailable`.
+
+### Operation list and form
+
+`@happyvertical/smrt-manufacturing/svelte` exports props-driven `OperationList`
+(with optional edit, retire and reinstate actions) and `OperationForm` (add, or
+edit name, category and required qualification; the code is fixed once set).
+They register with `ModuleUIRegistry` on import. Hosts load rows through
+`OperationService` and perform the actions themselves.
+
 ### Plan a production run
 
 ```typescript
@@ -88,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.
@@ -124,7 +286,7 @@ Every emitted `StockMovement` is stamped with `sourceType: 'ProductionOrder'` pl
 
 ### Multi-tenancy
 
-Both `BillOfMaterials` and `BomLine` use `@TenantScoped({ mode: 'optional' })` with a nullable `tenantId`. Wrap mutations in `withTenant()` from `@happyvertical/smrt-tenancy` to scope queries automatically.
+`Assembly`, `BillOfMaterials` and `BomLine` use `@TenantScoped({ mode: 'optional' })` with a nullable `tenantId`. Wrap mutations in `withTenant()` from `@happyvertical/smrt-tenancy` to scope queries automatically.
 
 ```typescript
 import { withTenant } from '@happyvertical/smrt-tenancy';
@@ -170,28 +332,75 @@ await bus.emit('production_order:posted', {
 
 Per-handler toggles (`installProductionPosted`, `installProductionCompleted`) let consumers pick exactly the legs they want. The companion `contract:created` and `fulfillment:shipped` handlers live in `@happyvertical/smrt-inventory`.
 
+### Svelte components
+
+`@happyvertical/smrt-manufacturing/svelte` ships props-driven components; the host loads data and saves it.
+
+```svelte
+<script lang="ts">
+  import {
+    AssemblyForm,
+    AssemblyList,
+    BomEditor,
+    ProductionRunList,
+    RequirementsTree,
+    toRequirementTotals,
+    toRequirementTree,
+  } from '@happyvertical/smrt-manufacturing/svelte';
+
+  let { assemblies, policy, fields, lines, components, runs, plan } = $props();
+</script>
+
+<AssemblyList {assemblies} {policy} onselect={(id) => goto(`/assemblies/${id}`)} />
+<AssemblyForm {fields} {policy} 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`. `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
 
 ### Models
 
 | Export | Description |
 |---|---|
+| `Assembly` | A product that is made: `Product` STI subtype with `estimatedLabourMinutes`, `defaultOperationId`, `partReference`. |
 | `BillOfMaterials` | Recipe for one finished product. Versioned with a `draft` / `active` / `superseded` lifecycle. |
 | `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
 
 | Export | Description |
 |---|---|
+| `AssemblyCollection` | Assembly rows of the shared `products` table. |
 | `BillOfMaterialsCollection` | `findByProduct`, `findActiveForProduct`, `findByStatus` |
 | `BomLineCollection` | `findByBom`, `findByComponent` |
+| `OperationCollection` | `findByCode`, `listOperations({ includeRetired? })` |
+| `RoutingStepCollection` | `findByBom` (in step order), `findByOperation` |
+| `ProductionRunCollection` | `findByBom`, `findByStatus` |
+| `ProductionRunCompletionCollection` | `findByRun` (in completion order) |
 
 ### Services
 
 | Export | Description |
 |---|---|
-| `BomService` | Cost rollup, requirements explosion, can-produce check. |
-| `createBomService({ db, costResolver? })` | Convenience factory. |
+| `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; `{ 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)`. |
+| `OperationNotFoundError`, `DuplicateOperationCodeError`, `OperationRetiredError`, `InvalidOperationInputError` | Operation and routing errors. |
 | `ProductionService` | Operational consume / produce against a production order. |
 | `createProductionService({ db })` | Convenience factory. |
 | `installManufacturingDispatchHandlers({ dispatchBus, db })` | Opt-in bus wiring. |
@@ -203,12 +412,23 @@ Per-handler toggles (`installProductionPosted`, `installProductionCompleted`) le
 | Export | Description |
 |---|---|
 | `BomStatus` | `'draft' \| 'active' \| 'superseded'` |
+| `ComponentKind` | `'assembly' \| 'material' \| 'bought' \| 'missing'` |
+| `ResolvedComponent` | Return shape of `resolveComponent`. |
+| `BillStructure` | Return shape of `getBillStructure`. |
 | `BomCostRollup` | Return shape of `computeMaterialCost`. |
 | `BomLineCost` | Per-line entry inside a `BomCostRollup`. |
 | `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`. |
+| `DefineOperationInput`, `RoutingStepInput` | Inputs to `define` and `replaceRouting`. |
 
 ## Dependencies
 
@@ -216,7 +436,11 @@ 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 |
 | `@happyvertical/sql` | Database adapter |
 
 ## License

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/AssemblyCollection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AssemblyCollection — collection for {@link Assembly} rows.
+ *
+ * Assemblies share the `products` table with every other `Product` subtype;
+ * the STI framework filters this collection to assembly rows by
+ * `_meta_type`, so `list()` and `get()` only ever return assemblies.
+ *
+ * @packageDocumentation
+ */
+import { ProductCollection } from '@happyvertical/smrt-products/collections';
+import { Assembly } from '../models/Assembly.js';
+export declare class AssemblyCollection extends ProductCollection {
+    static readonly _itemClass: typeof Assembly;
+}
+//# sourceMappingURL=AssemblyCollection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AssemblyCollection.d.ts","sourceRoot":"","sources":["../../src/collections/AssemblyCollection.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAC7E,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,qBAAa,kBAAmB,SAAQ,iBAAiB;IACvD,gBAAyB,UAAU,kBAAY;CAChD"}

package/dist/collections/OperationCollection.d.ts

@@ -0,0 +1,20 @@
+/**
+ * OperationCollection — query helpers for {@link Operation} rows.
+ *
+ * @packageDocumentation
+ */
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { Operation } from '../models/Operation.js';
+export declare class OperationCollection extends SmrtCollection<Operation> {
+    static readonly _itemClass: typeof Operation;
+    /** Return the operation with the given code, or `null`. */
+    findByCode(code: string): Promise<Operation | null>;
+    /**
+     * Return operations ordered by category then code. Retired operations are
+     * left out unless `includeRetired` is set, so the default is a picker list.
+     */
+    listOperations(options?: {
+        includeRetired?: boolean;
+    }): Promise<Operation[]>;
+}
+//# sourceMappingURL=OperationCollection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OperationCollection.d.ts","sourceRoot":"","sources":["../../src/collections/OperationCollection.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,qBAAa,mBAAoB,SAAQ,cAAc,CAAC,SAAS,CAAC;IAChE,MAAM,CAAC,QAAQ,CAAC,UAAU,mBAAa;IAEvC,2DAA2D;IACrD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAKzD;;;OAGG;IACG,cAAc,CAClB,OAAO,GAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GACzC,OAAO,CAAC,SAAS,EAAE,CAAC;CAMxB"}

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/RoutingStepCollection.d.ts

@@ -0,0 +1,15 @@
+/**
+ * RoutingStepCollection — query helpers for {@link RoutingStep} rows.
+ *
+ * @packageDocumentation
+ */
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { RoutingStep } from '../models/RoutingStep.js';
+export declare class RoutingStepCollection extends SmrtCollection<RoutingStep> {
+    static readonly _itemClass: typeof RoutingStep;
+    /** Return the routing of a bill in step order; empty when it has none. */
+    findByBom(bomId: string): Promise<RoutingStep[]>;
+    /** Return every step that uses the given operation, across bills. */
+    findByOperation(operationId: string): Promise<RoutingStep[]>;
+}
+//# sourceMappingURL=RoutingStepCollection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RoutingStepCollection.d.ts","sourceRoot":"","sources":["../../src/collections/RoutingStepCollection.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,qBAAa,qBAAsB,SAAQ,cAAc,CAAC,WAAW,CAAC;IACpE,MAAM,CAAC,QAAQ,CAAC,UAAU,qBAAe;IAEzC,0EAA0E;IACpE,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAItD,qEAAqE;IAC/D,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;CAGnE"}

package/dist/collections/index.d.ts

@@ -9,6 +9,11 @@
  * @packageDocumentation
  */
 import '../__smrt-register__.js';
+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,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,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"}