@happyvertical/smrt-manufacturing 0.53.4 → 0.53.5

package/AGENTS.md

@@ -1,19 +1,49 @@
 # @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, 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.
 
-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). |
+| `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`), 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()`. |
+| `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.
+
+## 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.
 
-`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
 
@@ -123,6 +153,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
+
+`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 +165,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.** `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.
+- **`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
@@ -153,5 +189,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
@@ -124,7 +238,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 +284,62 @@ 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,
+  } from '@happyvertical/smrt-manufacturing/svelte';
+
+  let { assemblies, policy, fields, lines, components } = $props();
+</script>
+
+<AssemblyList {assemblies} {policy} onselect={(id) => goto(`/assemblies/${id}`)} />
+<AssemblyForm {fields} {policy} onsubmit={save} />
+<BomEditor {lines} {components} onadd={addLine} loadBill={loadLines} error={saveError} />
+```
+
+`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`.
+
 ## 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`. |
 
 ### 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` |
 
 ### Services
 
 | Export | Description |
 |---|---|
+| `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. |
-| `createBomService({ db, costResolver? })` | Convenience factory. |
+| `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 +351,18 @@ 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: [...] }` |
 | `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 +370,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/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/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,9 @@
  * @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 { 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,qBAAqB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.d.ts

@@ -9,13 +9,22 @@
  *
  * **Model hierarchy**
  *
+ * - {@link Assembly} — the product that is made: a `Product` STI subtype
+ *   (`productType: 'assembly'`) in the shared `products` table. Nesting
+ *   lives in its bill: a line whose component SKU belongs to another
+ *   assembly is a sub-assembly.
  * - {@link BillOfMaterials} — recipe for one finished product. Multiple
  *   revisions per product via `version` + `status` lifecycle.
  * - {@link BomLine} — one component on a BOM with `qtyPerUnit`, `uom`,
  *   and optional `wastePercent`.
+ * - {@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.
  *
  * **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.
  * - {@link ProductionService} — operational bridge from a production
@@ -27,8 +36,9 @@
  * @packageDocumentation
  */
 import './__smrt-register__.js';
-export { BillOfMaterialsCollection, BomLineCollection, } from './collections/index.js';
-export { BillOfMaterials, type BillOfMaterialsOptions, BomLine, type BomLineOptions, } from './models/index.js';
-export { BomService, type BomServiceOptions, type ComponentCostResolver, type ConsumeMaterialsOptions, type ConsumeResult, createBomService, createProductionService, type InstalledManufacturingDispatchHandlers, type InstallManufacturingDispatchHandlersOptions, installManufacturingDispatchHandlers, type ProduceFinishedGoodsOptions, type ProduceResult, type ProductionOrderCompletedPayload, type ProductionOrderPostedPayload, type ProductionOrderRef, ProductionService, type ProductionServiceOptions, } from './services/index.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 { 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';
 //# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAMH,OAAO,wBAAwB,CAAC;AAKhC,OAAO,EACL,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EACL,eAAe,EACf,KAAK,sBAAsB,EAC3B,OAAO,EACP,KAAK,cAAc,GACpB,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,KAAK,sCAAsC,EAC3C,KAAK,2CAA2C,EAChD,oCAAoC,EACpC,KAAK,2BAA2B,EAChC,KAAK,aAAa,EAClB,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,EACjC,KAAK,kBAAkB,EACvB,iBAAiB,EACjB,KAAK,wBAAwB,GAC9B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}