@happyvertical/smrt-manufacturing 0.53.4 → 0.53.6

package/dist/quantity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantity.d.ts","sourceRoot":"","sources":["../src/quantity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAInC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,YAAc,CAAC;AAExC;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,uDAAuD;AACvD,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEzD"}

package/dist/services/AssemblyService.d.ts

@@ -0,0 +1,222 @@
+/**
+ * AssemblyService — the link between a bill line and the thing it names.
+ *
+ * A {@link BomLine} points at a component SKU. That SKU belongs to a
+ * `Product` row in `@happyvertical/smrt-products`, and the row's subtype
+ * decides what the line means:
+ *
+ * | Component SKU belongs to | Kind | Meaning |
+ * |---|---|---|
+ * | an {@link Assembly} | `assembly` | a sub-assembly; it is built from its own active bill, if it has one |
+ * | a `Material` | `material` | a consumed input; the leaf of the structure |
+ * | any other `Product` | `bought` | an item that is bought, not built here |
+ * | nothing (unknown SKU or product) | `missing` | the line points at a record that does not exist |
+ *
+ * {@link AssemblyService.resolveComponent} answers that question for one
+ * SKU, and also returns the assembly's active bill. It is the step a
+ * multi-level explosion repeats: resolve each line's component, recurse into
+ * every `assembly` that has an `activeBom`, stop at everything else.
+ *
+ * The service also owns the **cycle refusal**: an assembly may not contain
+ * itself, directly or through sub-assemblies. {@link BomLine} and
+ * {@link BillOfMaterials} call {@link AssemblyService.assertLineAcyclic} and
+ * {@link AssemblyService.assertBillAcyclic} before every save, so the
+ * generated REST routes refuse a cycle too.
+ *
+ * @packageDocumentation
+ */
+import { type DatabaseConfig, ValidationError } from '@happyvertical/smrt-core';
+import { ProductCollection, SkuCollection } from '@happyvertical/smrt-products/collections';
+import { type Product, type Sku } from '@happyvertical/smrt-products/models';
+import { BillOfMaterialsCollection } from '../collections/BillOfMaterialsCollection.js';
+import { BomLineCollection } from '../collections/BomLineCollection.js';
+import { Assembly } from '../models/Assembly.js';
+import type { BillOfMaterials } from '../models/BillOfMaterials.js';
+import type { BomLine } from '../models/BomLine.js';
+/**
+ * What a component SKU is, as far as building goes. See the table in the
+ * {@link AssemblyService} module documentation.
+ */
+export type ComponentKind = 'assembly' | 'material' | 'bought' | 'missing';
+/**
+ * The answer to "what is this component SKU?" returned by
+ * {@link AssemblyService.resolveComponent}.
+ */
+export interface ResolvedComponent {
+    /** The component SKU id that was resolved. */
+    skuId: string;
+    /** What the SKU is; see {@link ComponentKind}. */
+    kind: ComponentKind;
+    /** The SKU row, or `null` when no SKU has this id. */
+    sku: Sku | null;
+    /**
+     * The product the SKU belongs to (an `Assembly`, a `Material` or a plain
+     * `Product`), or `null` when the SKU or its product does not exist.
+     */
+    product: Product | null;
+    /** The assembly, when {@link kind} is `assembly`; otherwise `null`. */
+    assembly: Assembly | null;
+    /**
+     * The assembly's active bill (the highest active version), or `null` for
+     * an assembly that has no active bill yet and for every other kind.
+     */
+    activeBom: BillOfMaterials | null;
+    /**
+     * `true` only for an assembly with an active bill: the component *can* be
+     * built here. Whether a shortage is built or bought is the application's
+     * decision; this only reports the fact.
+     */
+    buildable: boolean;
+}
+/** One bill line together with the component it resolves to. */
+export interface BillStructureLine {
+    /** The bill line as stored. */
+    line: BomLine;
+    /** The line's component SKU, resolved. */
+    component: ResolvedComponent;
+}
+/**
+ * One level of an assembly's structure, returned by
+ * {@link AssemblyService.getBillStructure}. Sub-assembly lines carry their
+ * own `activeBom`; pass its id back to `getBillStructure` to open the next
+ * level.
+ */
+export interface BillStructure {
+    /** The bill that was read. */
+    bom: BillOfMaterials;
+    /** Its lines in component-SKU order, each resolved. */
+    lines: BillStructureLine[];
+}
+/** One product on a cycle path reported by {@link BomCycleError}. */
+export interface BomCyclePathEntry {
+    /** The product id (an assembly, or the bill's own product). */
+    productId: string;
+    /** The product's name, or its id when it has no name or cannot be read. */
+    name: string;
+}
+/**
+ * Thrown when saving a bill line, or saving a bill as active, would make a
+ * product contain itself. `path` starts and ends with the bill's product,
+ * listing each assembly in between: `Frame → Side panel → Frame`.
+ */
+export declare class BomCycleError extends ValidationError {
+    /** The bill being saved (or the bill of the line being saved). */
+    readonly bomId: string;
+    /** The cycle, from the bill's product back to itself. */
+    readonly path: BomCyclePathEntry[];
+    name: string;
+    constructor(
+    /** The bill being saved (or the bill of the line being saved). */
+    bomId: string, 
+    /** The cycle, from the bill's product back to itself. */
+    path: BomCyclePathEntry[]);
+}
+/** Options for {@link AssemblyService.resolveComponent} and the walks built on it. */
+export interface ResolveComponentOptions {
+    /**
+     * The tenant whose structure is being read. When given (including `null`
+     * for global records), an assembly's active bill is chosen only among
+     * bills with exactly this `tenantId`, and a SKU, product or bill line
+     * belonging to another tenant is treated as missing (global rows stay
+     * visible), whatever tenant context is active. When omitted, the active
+     * tenant context decides what is visible.
+     */
+    tenantId?: string | null;
+}
+/** Options accepted by {@link AssemblyService.create}. */
+export interface AssemblyServiceOptions {
+    /** Database config or live handle shared by every collection. */
+    db: DatabaseConfig;
+}
+/**
+ * Resolves components and refuses cycles. Construct with
+ * {@link AssemblyService.create} or {@link createAssemblyService}.
+ *
+ * @example
+ * ```typescript
+ * const assemblies = await AssemblyService.create({ db });
+ * const component = await assemblies.resolveComponent(line.componentSkuId);
+ * if (component.kind === 'assembly' && component.activeBom) {
+ *   // a sub-assembly that can be built: walk component.activeBom next
+ * }
+ * ```
+ */
+export declare class AssemblyService {
+    /** Every `Product` row, any subtype. */
+    readonly products: ProductCollection;
+    /** The SKU catalog. */
+    readonly skus: SkuCollection;
+    /** Bills of materials. */
+    readonly boms: BillOfMaterialsCollection;
+    /** Bill lines. */
+    readonly lines: BomLineCollection;
+    private constructor();
+    /** Factory — prefer {@link createAssemblyService}. */
+    static create(options: AssemblyServiceOptions): Promise<AssemblyService>;
+    /**
+     * Resolve a component SKU to what it is: an assembly (with its active bill,
+     * or `null` when it has none), a material, a bought item, or missing. Never
+     * throws for an unknown id; it reports `missing` instead.
+     *
+     * This is the documented link a multi-level explosion walks: recurse into
+     * `activeBom` while `kind === 'assembly'`, stop at every other kind. Pass
+     * the parent bill's `tenantId` so a shared assembly resolves to that
+     * tenant's bill, not another tenant's.
+     */
+    resolveComponent(skuId: string, options?: ResolveComponentOptions): Promise<ResolvedComponent>;
+    /**
+     * The highest-version active bill for a product. With `options.tenantId`,
+     * that tenant's own bill, or else a global one; another tenant's never.
+     */
+    findActiveBom(productId: string, options?: ResolveComponentOptions): Promise<BillOfMaterials | null>;
+    /**
+     * One row by id: through the collection's `get` without an explicit
+     * tenant, else as a list read of that tenant's and global rows.
+     */
+    private byId;
+    /** `true` when the SKU belongs to an {@link Assembly}. */
+    isAssembly(skuId: string): Promise<boolean>;
+    /**
+     * Read one bill and resolve every line's component. Sub-assembly lines say
+     * whether they have an active bill of their own (`component.activeBom`);
+     * the caller opens the next level by passing that id back in.
+     *
+     * @throws {BomNotFoundError} when no bill has this id.
+     */
+    getBillStructure(bomId: string): Promise<BillStructure>;
+    /**
+     * Find the path by which adding `componentSkuIds` to a bill for
+     * `productId` would make that product contain itself, or `null` when none
+     * would. The walk follows each sub-assembly's **active** bill only; a
+     * draft or superseded bill is not part of the structure. Pass the bill's
+     * `tenantId` so the walk reads that tenant's structure.
+     */
+    findCycle(productId: string, componentSkuIds: readonly string[], options?: ResolveComponentOptions): Promise<BomCyclePathEntry[] | null>;
+    /**
+     * Refuse a bill line that would make its bill's product contain itself.
+     * A line on a draft bill is checked too, so a cycle is refused when it is
+     * written rather than when the bill is activated. A line whose bill does
+     * not exist is left to the caller.
+     *
+     * @throws {BomCycleError} naming the path.
+     */
+    assertLineAcyclic(line: Pick<BomLine, 'bomId' | 'componentSkuId'>): Promise<void>;
+    /**
+     * Refuse saving a bill as `active` when any of its lines would make its
+     * product contain itself. Bills in any other status are not part of the
+     * structure and pass.
+     *
+     * The lines checked are the bill's own and those of any stored bill with
+     * the same natural key (`productId`, `version`, and the bill's tenant, or
+     * the active tenant when the bill has none yet): saving a new
+     * instance with that key upserts onto the stored bill and activates its
+     * lines, so they are part of what the save makes active.
+     *
+     * @throws {BomCycleError} naming the path.
+     */
+    assertBillAcyclic(bom: Pick<BillOfMaterials, 'id' | 'productId' | 'status' | 'version' | 'tenantId'>): Promise<void>;
+    private resolveCached;
+}
+/** Convenience factory for {@link AssemblyService}. */
+export declare function createAssemblyService(options: AssemblyServiceOptions): Promise<AssemblyService>;
+//# sourceMappingURL=AssemblyService.d.ts.map

package/dist/services/AssemblyService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssemblyService.d.ts","sourceRoot":"","sources":["../../src/services/AssemblyService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACL,KAAK,cAAc,EAEnB,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,iBAAiB,EACjB,aAAa,EACd,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAEL,KAAK,OAAO,EACZ,KAAK,GAAG,EACT,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AACxF,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAIpD;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE3E;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,IAAI,EAAE,aAAa,CAAC;IACpB,sDAAsD;IACtD,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;IAChB;;;OAGG;IACH,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,uEAAuE;IACvE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC1B;;;OAGG;IACH,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;IAClC;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,+BAA+B;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,0CAA0C;IAC1C,SAAS,EAAE,iBAAiB,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,8BAA8B;IAC9B,GAAG,EAAE,eAAe,CAAC;IACrB,uDAAuD;IACvD,KAAK,EAAE,iBAAiB,EAAE,CAAC;CAC5B;AAED,qEAAqE;AACrE,MAAM,WAAW,iBAAiB;IAChC,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,eAAe;IAI9C,kEAAkE;aAClD,KAAK,EAAE,MAAM;IAC7B,yDAAyD;aACzC,IAAI,EAAE,iBAAiB,EAAE;IANlC,IAAI,SAAmB;;IAG9B,kEAAkE;IAClD,KAAK,EAAE,MAAM;IAC7B,yDAAyD;IACzC,IAAI,EAAE,iBAAiB,EAAE;CAW5C;AAED,sFAAsF;AACtF,MAAM,WAAW,uBAAuB;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,0DAA0D;AAC1D,MAAM,WAAW,sBAAsB;IACrC,iEAAiE;IACjE,EAAE,EAAE,cAAc,CAAC;CACpB;AA0BD;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAe;IAExB,wCAAwC;aACxB,QAAQ,EAAE,iBAAiB;IAC3C,uBAAuB;aACP,IAAI,EAAE,aAAa;IACnC,0BAA0B;aACV,IAAI,EAAE,yBAAyB;IAC/C,kBAAkB;aACF,KAAK,EAAE,iBAAiB;IAR1C,OAAO;IAWP,sDAAsD;WACzC,MAAM,CACjB,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,eAAe,CAAC;IAc3B;;;;;;;;;OASG;IACG,gBAAgB,CACpB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,iBAAiB,CAAC;IA6C7B;;;OAGG;IACG,aAAa,CACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAgBlC;;;OAGG;YACW,IAAI;IAgBlB,0DAA0D;IACpD,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIjD;;;;;;OAMG;IACG,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAkB7D;;;;;;OAMG;IACG,SAAS,CACb,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC;IAyCtC;;;;;;;OAOG;IACG,iBAAiB,CACrB,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,gBAAgB,CAAC,GAC9C,OAAO,CAAC,IAAI,CAAC;IAUhB;;;;;;;;;;;;OAYG;IACG,iBAAiB,CACrB,GAAG,EAAE,IAAI,CACP,eAAe,EACf,IAAI,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CACvD,GACA,OAAO,CAAC,IAAI,CAAC;IA+BhB,OAAO,CAAC,aAAa;CAYtB;AAED,uDAAuD;AACvD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,eAAe,CAAC,CAE1B"}

package/dist/services/BomService.d.ts

@@ -9,6 +9,14 @@
  * - "What do I need to buy / pull to make N units?" via {@link explodeRequirements}
  * - "Do I have enough on hand?" via {@link canProduce}
  *
+ * Every method reads one level of the bill by default. Pass `{ levels }` to
+ * walk sub-assemblies too: a line whose component SKU belongs to an
+ * `Assembly` with an active bill is opened, to the given depth or (`'all'`)
+ * down to materials and bought items. {@link explode} returns that walk line
+ * by line with the rolled-up totals, and {@link planRequirements} nets it
+ * against stock: how much of each sub-assembly is available, how much is
+ * short, and what building the shortfall takes.
+ *
  * Construct via {@link BomService.create} — the static factory wires up
  * the BOM, BOM-line, and inventory collections so a single `db` (or a
  * pre-built {@link StockService}) drives everything.
@@ -22,12 +30,16 @@
  *
  * @packageDocumentation
  */
-import type { DatabaseConfig } from '@happyvertical/smrt-core';
+import { type DatabaseConfig } from '@happyvertical/smrt-core';
 import { type StockService } from '@happyvertical/smrt-inventory';
 import { BillOfMaterialsCollection } from '../collections/BillOfMaterialsCollection.js';
 import { BomLineCollection } from '../collections/BomLineCollection.js';
+import { OperationCollection } from '../collections/OperationCollection.js';
+import { RoutingStepCollection } from '../collections/RoutingStepCollection.js';
 import type { BomLine } from '../models/BomLine.js';
-import { type BomCostRollup, type CanProduceResult, type MaterialRequirement } from '../types.js';
+import type { LabourEstimate, OperationRateResolver } from '../operation-types.js';
+import { type BomCostRollup, type CanProduceResult, type Explosion, type ExplosionOptions, type MaterialRequirement, type RequirementsPlan } from '../types.js';
+import { AssemblyService } from './AssemblyService.js';
 /**
  * Callback signature for resolving the unit cost of a component SKU.
  *
@@ -68,6 +80,12 @@ export type BomServiceOptions = {
      * costs default to `0` and per-line `costUnavailable` is set.
      */
     costResolver?: ComponentCostResolver;
+    /**
+     * Optional resolver that returns the hourly labour rate for an operation,
+     * used by {@link BomService.computeLabourEstimate}. When omitted, the
+     * estimate reports minutes only and flags every step `rateUnavailable`.
+     */
+    rateResolver?: OperationRateResolver;
 } & ({
     db: DatabaseConfig;
     stockService?: StockService;
@@ -92,6 +110,11 @@ export declare class BomService {
     readonly lines: BomLineCollection;
     readonly stockService: StockService;
     private readonly costResolver;
+    readonly routingSteps: RoutingStepCollection;
+    readonly operations: OperationCollection;
+    private readonly rateResolver;
+    /** Resolves components for the multi-level walks. */
+    readonly assemblies: AssemblyService;
     private constructor();
     /** Factory — prefer {@link createBomService}. */
     static create(options: BomServiceOptions): Promise<BomService>;
@@ -106,8 +129,32 @@ export declare class BomService {
      * set `costUnavailable: true` on their breakdown row; the aggregate
      * `hasMissingCosts` flag mirrors this so callers can surface a UI
      * warning.
+     *
+     * With `{ levels }` above 1, a sub-assembly line whose bill the walk opens
+     * is costed from that bill instead of the resolver: its `unitCost` is the
+     * bill's rolled-up material cost per unit, its `components` hold that
+     * bill's lines, and a missing cost anywhere below marks it and
+     * `hasMissingCosts` (its known part still counts, so the total is a lower
+     * bound). Other lines, including sub-assemblies with no active bill, use
+     * the resolver as before.
+     */
+    computeMaterialCost(bomId: string, options?: ExplosionOptions): Promise<BomCostRollup>;
+    /**
+     * Roll up the estimated labour to build one unit from the bill's routing:
+     * total minutes, plus cost when a `rateResolver` was supplied (hourly rate
+     * times minutes, per step). A bill with no routing returns an empty
+     * estimate with zero totals, so callers can add it to the material cost
+     * unconditionally. Retired operations still count: the routing names them.
+     *
+     * With `{ levels }` above 1, every sub-assembly the walk opens adds its own
+     * bill's routing, multiplied by the units of it one unit needs (waste
+     * included); see {@link LabourEstimate.subAssemblies}.
+     *
+     * Throws {@link BomNotFoundError} when the BOM does not exist.
      */
-    computeMaterialCost(bomId: string): Promise<BomCostRollup>;
+    computeLabourEstimate(bomId: string, options?: ExplosionOptions): Promise<LabourEstimate>;
+    /** One bill's own routing estimate, per unit of its product. */
+    private labourFor;
     /**
      * Return a "shopping list" of materials needed to produce `qty` units of
      * the parent product against the given BOM. Lines that reference the
@@ -118,10 +165,14 @@ export declare class BomService {
      * {@link ProductionService.consumeMaterials} when you're ready to write
      * stock movements.
      *
+     * With `{ levels }` above 1, sub-assemblies with an active bill are
+     * replaced by what their bills need, waste compounding down the levels;
+     * this is {@link explode}'s `totals`.
+     *
      * Throws {@link BomNotFoundError} when the BOM does not exist; throws a
      * plain `Error` when `qty` is not a positive finite number.
      */
-    explodeRequirements(bomId: string, qty: number): Promise<MaterialRequirement[]>;
+    explodeRequirements(bomId: string, qty: number, options?: ExplosionOptions): Promise<MaterialRequirement[]>;
     /**
      * Check whether the requirements for producing `qty` units against the
      * given BOM are currently satisfied by available stock. Returns
@@ -134,14 +185,66 @@ export declare class BomService {
      * "where do we pull from?" is left to the caller of
      * {@link ProductionService.consumeMaterials}).
      *
+     * With `{ levels }` above 1 the check is {@link planRequirements}: a
+     * sub-assembly that is short and has an active bill is opened for its
+     * shortfall, and each shortage is reported on the line where it occurs,
+     * with its `level` and `path`. Stock is allocated as the walk goes, so a
+     * component used in two places is not counted twice.
+     *
      * Throws {@link BomNotFoundError} when the BOM does not exist.
      */
-    canProduce(bomId: string, qty: number): Promise<CanProduceResult>;
+    canProduce(bomId: string, qty: number, options?: ExplosionOptions): Promise<CanProduceResult>;
+    /**
+     * Walk the bill for `qty` units and return every line, depth first, with
+     * its level, the path of bills above it and its quantity for the run, plus
+     * the rolled-up `totals`. Gross requirements: stock is not read.
+     *
+     * `levels` (default `1`) says how far to open sub-assemblies; see
+     * {@link ExplosionLevels}. Waste compounds: a sub-assembly line's quantity
+     * includes its own waste, and its bill's lines are multiplied by it.
+     *
+     * Throws {@link BomNotFoundError}, `BomStructureCycleError` when stored
+     * data already has a product containing itself, `BomExplosionLimitError`
+     * past the depth or line limits, and a plain `Error` for a bad `qty` or
+     * `levels`.
+     */
+    explode(bomId: string, qty: number, options?: ExplosionOptions): Promise<Explosion>;
+    /**
+     * Net the walk against stock: for each line, the available stock (all
+     * locations) not yet allocated to an earlier line and how much is short.
+     * A sub-assembly that is short and has an active bill is opened for the
+     * shortfall only, so its lines say what building that shortfall takes;
+     * one covered by stock is not opened. Lines that are short and cannot be
+     * opened are the `shortages`, each at its own level.
+     *
+     * These are facts, not a decision: the application decides whether a
+     * short sub-assembly is built or bought. Does not mutate stock.
+     *
+     * Throws as {@link explode} does.
+     */
+    planRequirements(bomId: string, qty: number, options?: ExplosionOptions): Promise<RequirementsPlan>;
     /**
      * Fetch a BOM by id or throw {@link BomNotFoundError}. Centralises the
      * "missing BOM" error path so callers don't have to repeat the check.
      */
+    /**
+     * A bill's lines: its own tenant's and global ones, whatever tenant
+     * context is active (a context alone would hide a global bill's lines).
+     */
+    private linesOf;
     private requireBom;
+    /**
+     * Available stock of a SKU across locations, counting only the top bill's
+     * tenant's rows and global ones, whatever tenant context is active (the
+     * walk reads its structure the same way).
+     */
+    private availableInTenant;
+    /** {@link computeMaterialCost} with `levels` above 1. */
+    private computeMultiLevelCost;
+    /** {@link computeLabourEstimate} with `levels` above 1. */
+    private computeMultiLevelLabour;
+    /** Run the {@link OperationRateResolver}; `null` when there is no rate. */
+    private resolveRate;
     /**
      * Run the supplied {@link ComponentCostResolver} for the given component
      * SKU. Returns `null` when no resolver is registered or when the

package/dist/services/BomService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BomService.d.ts","sourceRoot":"","sources":["../../src/services/BomService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AACxF,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EACL,KAAK,aAAa,EAGlB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EAEzB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAClC,cAAc,EAAE,MAAM,KACnB,OAAO,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,YAAY,CAAC,EAAE,qBAAqB,CAAC;CACtC,GAAG,CACA;IAAE,EAAE,EAAE,cAAc,CAAC;IAAC,YAAY,CAAC,EAAE,YAAY,CAAA;CAAE,GACnD;IAAE,YAAY,EAAE,YAAY,CAAC;IAAC,EAAE,CAAC,EAAE,cAAc,CAAA;CAAE,CACtD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;aAEH,IAAI,EAAE,yBAAyB;aAC/B,KAAK,EAAE,iBAAiB;aACxB,YAAY,EAAE,YAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJ/B,OAAO;IAOP,iDAAiD;WACpC,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC;IAepE;;;;;;;;;;;OAWG;IACG,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAwChE;;;;;;;;;;;;OAYG;IACG,mBAAmB,CACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,mBAAmB,EAAE,CAAC;IA0BjC;;;;;;;;;;;;;OAaG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAuCvE;;;OAGG;YACW,UAAU;IAOxB;;;;OAIG;YACW,WAAW;CAO1B;AA8BD;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,UAAU,CAAC,CAErB;AAID,YAAY,EAAE,OAAO,EAAE,CAAC"}
+{"version":3,"file":"BomService.d.ts","sourceRoot":"","sources":["../../src/services/BomService.ts"],"names":[],"mappings":"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"}

package/dist/services/OperationService.d.ts

@@ -0,0 +1,48 @@
+/**
+ * OperationService — maintain the managed list of {@link Operation} rows:
+ * define, rename, change category or required qualification, retire and
+ * reinstate. Operations are never deleted.
+ *
+ * @packageDocumentation
+ */
+import type { DatabaseConfig } from '@happyvertical/smrt-core';
+import { OperationCollection } from '../collections/OperationCollection.js';
+import type { Operation } from '../models/Operation.js';
+import { type DefineOperationInput } from '../operation-types.js';
+/** Options accepted by {@link OperationService.create}. */
+export interface OperationServiceOptions {
+    db: DatabaseConfig;
+}
+export declare class OperationService {
+    readonly operations: OperationCollection;
+    private constructor();
+    /** Factory — prefer {@link createOperationService}. */
+    static create(options: OperationServiceOptions): Promise<OperationService>;
+    /**
+     * Add an operation. The code is trimmed and must be unique per tenant;
+     * throws {@link DuplicateOperationCodeError} when it is taken (retired
+     * operations keep their code).
+     */
+    define(input: DefineOperationInput): Promise<Operation>;
+    /** Fetch an operation or throw {@link OperationNotFoundError}. */
+    get(id: string): Promise<Operation>;
+    /** List operations; retired ones only with `includeRetired`. */
+    list(options?: {
+        includeRetired?: boolean;
+    }): Promise<Operation[]>;
+    /** Change the display name. The code does not change. */
+    rename(id: string, name: string): Promise<Operation>;
+    /** Change category and/or required qualification; an empty string clears. */
+    update(id: string, changes: {
+        category?: string;
+        requiredQualificationId?: string;
+    }): Promise<Operation>;
+    /** Retire: stays on history and routings, leaves pickers. Idempotent. */
+    retire(id: string): Promise<Operation>;
+    /** Reinstate a retired operation. Idempotent. */
+    reinstate(id: string): Promise<Operation>;
+    private setActive;
+}
+/** Convenience factory. */
+export declare function createOperationService(options: OperationServiceOptions): Promise<OperationService>;
+//# sourceMappingURL=OperationService.d.ts.map

package/dist/services/OperationService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationService.d.ts","sourceRoot":"","sources":["../../src/services/OperationService.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EACL,KAAK,oBAAoB,EAI1B,MAAM,uBAAuB,CAAC;AAE/B,2DAA2D;AAC3D,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,cAAc,CAAC;CACpB;AAED,qBAAa,gBAAgB;aACS,UAAU,EAAE,mBAAmB;IAAnE,OAAO;IAEP,uDAAuD;WAC1C,MAAM,CACjB,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,gBAAgB,CAAC;IAM5B;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,SAAS,CAAC;IA2B7D,kEAAkE;IAC5D,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAMzC,gEAAgE;IAC1D,IAAI,CAAC,OAAO,GAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAI5E,yDAAyD;IACnD,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAU1D,6EAA6E;IACvE,MAAM,CACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,uBAAuB,CAAC,EAAE,MAAM,CAAA;KAAE,GAC/D,OAAO,CAAC,SAAS,CAAC;IAWrB,yEAAyE;IACnE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAI5C,iDAAiD;IAC3C,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;YAIjC,SAAS;CAQxB;AAED,2BAA2B;AAC3B,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,gBAAgB,CAAC,CAE3B"}

package/dist/services/ProductionRunService.d.ts

@@ -0,0 +1,123 @@
+/**
+ * ProductionRunService — create production runs and report work on them as
+ * it happens: "25 to build, 12 done".
+ *
+ * Every write runs in one database transaction that first saves the run
+ * row. That save is revision-guarded, so it takes the row's lock and a
+ * concurrent writer's save fails with a revision conflict; the loser's whole
+ * transaction is retried against the committed run. Two people reporting
+ * completions at once therefore both count, and a run never goes past its
+ * target.
+ *
+ * Recording a completion moves no stock unless the caller asks. With
+ * `consume` and/or `produce`, it uses the {@link ProductionService} paths
+ * inside the same transaction as the completion, so a stock shortfall rolls
+ * the completion back too.
+ *
+ * @packageDocumentation
+ */
+import { type DatabaseConfig } from '@happyvertical/smrt-core';
+import { type StockService } from '@happyvertical/smrt-inventory';
+import { BillOfMaterialsCollection } from '../collections/BillOfMaterialsCollection.js';
+import { ProductionRunCollection } from '../collections/ProductionRunCollection.js';
+import { ProductionRunCompletionCollection } from '../collections/ProductionRunCompletionCollection.js';
+import type { ProductionRun } from '../models/ProductionRun.js';
+import type { ProductionRunCompletion } from '../models/ProductionRunCompletion.js';
+import { type CreateProductionRunInput, type RecordCompletionInput, type RecordCompletionResult } from '../production-run-types.js';
+/**
+ * Options accepted by {@link ProductionRunService.create}. With a
+ * `stockService`, its database is used for everything, so a completion and
+ * its stock movements share one transaction.
+ */
+export type ProductionRunServiceOptions = {
+    db: DatabaseConfig;
+    stockService?: undefined;
+} | {
+    stockService: StockService;
+    db?: undefined;
+};
+/**
+ * Creates runs and records their progress. Construct with
+ * {@link ProductionRunService.create} or {@link createProductionRunService}.
+ *
+ * @example
+ * ```typescript
+ * const runs = await ProductionRunService.create({ db });
+ * const run = await runs.createRun({ productId: frame.id, targetQty: 25 });
+ * await runs.recordCompletion(run.id!, { qty: 12 });
+ * // run: 25 to build, 12 done, in_progress
+ * ```
+ */
+export declare class ProductionRunService {
+    /** The stock service whose database every collection here shares. */
+    readonly stockService: StockService;
+    /** Production runs (reads; writes go through this service). */
+    readonly runs: ProductionRunCollection;
+    /** Completions (reads; writes go through this service). */
+    readonly completions: ProductionRunCompletionCollection;
+    /** Bills, to pin a run's bill. */
+    readonly boms: BillOfMaterialsCollection;
+    private constructor();
+    /** Factory — prefer {@link createProductionRunService}. */
+    static create(options: ProductionRunServiceOptions): Promise<ProductionRunService>;
+    /**
+     * Create a `planned` run of `targetQty` units, pinned to `bomId`, or to the
+     * active bill of `productId`.
+     *
+     * @throws {InvalidProductionRunInputError} for a target that is not a
+     *   positive number, or when neither `bomId` nor `productId` is given.
+     * @throws {BomNotFoundError} when `bomId` does not exist.
+     * @throws {NoActiveBomForProductError} when `productId` has no active bill.
+     */
+    createRun(input: CreateProductionRunInput): Promise<ProductionRun>;
+    /** The run, or `null` when no run has this id. */
+    get(runId: string): Promise<ProductionRun | null>;
+    /** A run's completions in the order they happened. */
+    listCompletions(runId: string): Promise<ProductionRunCompletion[]>;
+    /** Mark a `planned` run `in_progress`. */
+    start(runId: string): Promise<ProductionRun>;
+    /** Mark an open run `done`, short of its target if work stopped early. */
+    finish(runId: string): Promise<ProductionRun>;
+    /** Cancel an open run. Completions already reported stay. */
+    cancel(runId: string): Promise<ProductionRun>;
+    /**
+     * Change an open run's target. It may not go below what is already done;
+     * setting it to exactly that finishes the run.
+     *
+     * @throws {InvalidProductionRunInputError} for a target that is not a
+     *   positive number or is below the completed quantity.
+     */
+    setTarget(runId: string, targetQty: number): Promise<ProductionRun>;
+    /**
+     * Report `qty` finished units on an open run: records a dated completion,
+     * adds it to `completedQty`, moves a `planned` run to `in_progress`, and
+     * marks the run `done` when the target is reached. With `consume` and/or
+     * `produce`, also writes the stock movements through
+     * {@link ProductionService}, stamped `sourceType: 'ProductionRunCompletion'`
+     * with the completion id. Everything runs in one transaction.
+     *
+     * Consumption takes the run's bill's own lines for `qty` units: a
+     * sub-assembly on the bill is taken from stock as a component. Building
+     * that sub-assembly is its own run.
+     *
+     * @throws {ProductionRunNotFoundError}
+     * @throws {ProductionRunStateError} when the run is `done` or `cancelled`.
+     * @throws {ProductionRunOverCompletionError} when `qty` is more than the
+     *   run has left.
+     * @throws {InvalidProductionRunInputError} for a bad `qty` or date.
+     * @throws `InsufficientStockError` from inventory when consuming would
+     *   drive stock below zero; nothing is recorded then.
+     */
+    recordCompletion(runId: string, input: RecordCompletionInput): Promise<RecordCompletionResult>;
+    /** Apply `apply` to an open run and save it, in one transaction. */
+    private change;
+    private load;
+    /**
+     * Run `work` in one transaction on collections bound to it, rerunning the
+     * whole transaction when it lost a revision race on the run row.
+     */
+    private inTransaction;
+}
+/** Convenience factory for {@link ProductionRunService}. */
+export declare function createProductionRunService(options: ProductionRunServiceOptions): Promise<ProductionRunService>;
+//# sourceMappingURL=ProductionRunService.d.ts.map

package/dist/services/ProductionRunService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProductionRunService.d.ts","sourceRoot":"","sources":["../../src/services/ProductionRunService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,cAAc,EAAmB,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAEL,KAAK,YAAY,EAClB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AACxF,OAAO,EAAE,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AACpF,OAAO,EAAE,iCAAiC,EAAE,MAAM,qDAAqD,CAAC;AAExG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AACpF,OAAO,EACL,KAAK,wBAAwB,EAK7B,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,4BAA4B,CAAC;AAepC;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GACnC;IAAE,EAAE,EAAE,cAAc,CAAC;IAAC,YAAY,CAAC,EAAE,SAAS,CAAA;CAAE,GAChD;IAAE,YAAY,EAAE,YAAY,CAAC;IAAC,EAAE,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC;AAmBnD;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAoB;IAE7B,qEAAqE;aACrD,YAAY,EAAE,YAAY;IAC1C,+DAA+D;aAC/C,IAAI,EAAE,uBAAuB;IAC7C,2DAA2D;aAC3C,WAAW,EAAE,iCAAiC;IAC9D,kCAAkC;aAClB,IAAI,EAAE,yBAAyB;IARjD,OAAO;IAWP,2DAA2D;WAC9C,MAAM,CACjB,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,oBAAoB,CAAC;IA8BhC;;;;;;;;OAQG;IACG,SAAS,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,aAAa,CAAC;IA+CxE,kDAAkD;IAC5C,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAKvD,sDAAsD;IAChD,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC;IAKxE,0CAA0C;IACpC,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAQlD,0EAA0E;IACpE,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAMnD,6DAA6D;IACvD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAMnD;;;;;;OAMG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAezE;;;;;;;;;;;;;;;;;;;OAmBG;IACG,gBAAgB,CACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC,sBAAsB,CAAC;IAgFlC,oEAAoE;IACpE,OAAO,CAAC,MAAM;YAeA,IAAI;IAWlB;;;OAGG;IACH,OAAO,CAAC,aAAa;CActB;AAsCD,4DAA4D;AAC5D,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAE/B"}

package/dist/services/ProductionService.d.ts

@@ -100,6 +100,12 @@ export interface ConsumeMaterialsOptions {
      * Optional free-form note attached to every emitted movement.
      */
     note?: string;
+    /**
+     * Optional override of the `sourceType` stamped on each movement, with
+     * the order's `id` as `sourceId`. Defaults to `'ProductionOrder'`;
+     * `ProductionRunService` passes `'ProductionRunCompletion'`.
+     */
+    sourceType?: string;
 }
 /**
  * Per-call options for {@link ProductionService.produceFinishedGoods}.
@@ -131,6 +137,11 @@ export interface ProduceFinishedGoodsOptions {
      * Optional free-form note attached to the emitted movement.
      */
     note?: string;
+    /**
+     * Optional override of the `sourceType` stamped on the movement. Defaults
+     * to `'ProductionOrder'`; see {@link ConsumeMaterialsOptions.sourceType}.
+     */
+    sourceType?: string;
 }
 /**
  * Options accepted by {@link ProductionService.create}.

package/dist/services/ProductionService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProductionService.d.ts","sourceRoot":"","sources":["../../src/services/ProductionService.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ProductionService.d.ts","sourceRoot":"","sources":["../../src/services/ProductionService.ts"],"names":[],"mappings":"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"}