@happyvertical/smrt-manufacturing 0.51.32 → 0.51.34

package/dist/services/ProductionService.d.ts

@@ -0,0 +1,322 @@
+/**
+ * ProductionService — the operational bridge from a production order to
+ * actual stock-mutating consume/produce events.
+ *
+ * Production orders themselves live in `@happyvertical/smrt-commerce` as a
+ * `Contract` STI subtype. This service does NOT modify those rows; it
+ * simply reads the order's `productId`, looks up the active BOM, and
+ * writes the right stock movements through {@link StockService}.
+ *
+ * Three methods:
+ *
+ * - {@link consumeMaterials} — for each BOM line, deduct
+ *   `qtyPerUnit * (1 + wastePercent / 100) * runQty` from `available` at
+ *   the production location. Stamps every movement with
+ *   `sourceType: 'ProductionOrder'` + the production order id so audit
+ *   queries can roll them up later. Atomic across BOM lines (one tx).
+ * - {@link produceFinishedGoods} — receive `runQty` of the finished
+ *   product's SKU into `available` at the production location. The caller
+ *   supplies the SKU id (the production order references a *product*, not
+ *   a *SKU*; in practice the production-order-level "what we are making"
+ *   gets resolved to a specific SKU per variant on the line items).
+ * - {@link runProduction} — consume materials AND receive finished
+ *   goods in one transaction. Use this when consume + produce should be
+ *   jointly atomic (e.g. a make-to-stock workflow where the factory step
+ *   is invisible). Calling `consumeMaterials` then `produceFinishedGoods`
+ *   separately is NOT jointly atomic — each opens its own transaction
+ *   and a failure between them can leave materials deducted with no
+ *   finished SKU receipt to balance it.
+ *
+ * ## Location convention (explicit-arg design)
+ *
+ * The original design considered carrying `originLocationId` on a per-
+ * package mixin of `ProductionOrder`, but that adds a meta field to a
+ * model owned by a sibling package. The cleaner design — and the one
+ * shipped here — keeps the location explicit on the call:
+ *
+ * ```typescript
+ * await production.consumeMaterials(order, { locationId, qty });
+ * await production.produceFinishedGoods(order, { locationId, qty, finishedSkuId });
+ * ```
+ *
+ * Callers that want a "default factory" convention can stash the
+ * `locationId` on their own production-order helper or wrap this service
+ * with a thin domain-level façade.
+ *
+ * @packageDocumentation
+ */
+import type { DatabaseConfig } from '@happyvertical/smrt-core';
+import type { StockMovementReason, StockService } from '@happyvertical/smrt-inventory';
+import { BillOfMaterialsCollection } from '../collections/BillOfMaterialsCollection.js';
+import { BomLineCollection } from '../collections/BomLineCollection.js';
+import type { BomLine } from '../models/BomLine.js';
+/**
+ * Minimal shape of a production order this service needs. We deliberately
+ * accept this structural type rather than importing the `ProductionOrder`
+ * class from `@happyvertical/smrt-commerce` — that would either pull a
+ * dep on commerce into manufacturing or force commerce to extend a
+ * manufacturing interface. Plain duck typing keeps the dependency arrow
+ * pointing the way the architecture asks for (manufacturing builds on
+ * inventory; commerce stays orthogonal).
+ */
+export interface ProductionOrderRef {
+    /** Production order row id. Used for `sourceId` on every movement. */
+    id?: string | null;
+    /**
+     * Plain string reference to the upstream product the order is asked to
+     * produce. Used to look up the active BOM for the consume step.
+     */
+    productId?: string;
+    /**
+     * Optional explicit BOM id. When set, {@link consumeMaterials} uses this
+     * row even if the product has a different `active` BOM — useful when an
+     * order was kicked off against a specific revision.
+     */
+    bomId?: string;
+}
+/**
+ * Per-call options for {@link ProductionService.consumeMaterials}.
+ */
+export interface ConsumeMaterialsOptions {
+    /**
+     * Inventory location id (warehouse / factory) where the materials are
+     * pulled from. Required because the production order itself does not
+     * carry a stocking location — see "Location convention" in the module
+     * doc.
+     */
+    locationId: string;
+    /**
+     * Run quantity — how many finished units the BOM is being multiplied
+     * by. Each BOM line's `effectiveQtyPerUnit()` is multiplied by this
+     * number before being deducted from `available` stock.
+     */
+    qty: number;
+    /**
+     * Optional override of the reason code stamped on each
+     * {@link StockMovement}. Defaults to `'production_consume'`.
+     */
+    reasonCode?: StockMovementReason;
+    /**
+     * Optional free-form note attached to every emitted movement.
+     */
+    note?: string;
+}
+/**
+ * Per-call options for {@link ProductionService.produceFinishedGoods}.
+ */
+export interface ProduceFinishedGoodsOptions {
+    /**
+     * Inventory location id (warehouse / factory) where the finished goods
+     * land. Required for the same reason as {@link ConsumeMaterialsOptions.locationId}.
+     */
+    locationId: string;
+    /**
+     * Quantity of finished goods produced. Always positive.
+     */
+    qty: number;
+    /**
+     * The SKU id of the finished product to receive into `available`. The
+     * production order references a `productId` (a `Product` from
+     * `@happyvertical/smrt-products`), but a product typically has multiple
+     * SKUs (one per variant). The caller decides which concrete SKU each
+     * line of the run produces.
+     */
+    finishedSkuId: string;
+    /**
+     * Optional override of the reason code stamped on the
+     * {@link StockMovement}. Defaults to `'production_produce'`.
+     */
+    reasonCode?: StockMovementReason;
+    /**
+     * Optional free-form note attached to the emitted movement.
+     */
+    note?: string;
+}
+/**
+ * Options accepted by {@link ProductionService.create}.
+ *
+ * Either pass a `db` for the service to construct its own
+ * collections + {@link StockService}, or share a pre-built `stockService`
+ * across subsystems.
+ */
+export type ProductionServiceOptions = {
+    db: DatabaseConfig;
+    stockService?: StockService;
+} | {
+    stockService: StockService;
+    db?: DatabaseConfig;
+};
+/**
+ * A single emitted stock movement, returned by
+ * {@link ProductionService.consumeMaterials} so callers can audit / log
+ * the impact of a production run without re-querying.
+ */
+export interface ConsumeResult {
+    /** Component SKU id whose stock was deducted. */
+    componentSkuId: string;
+    /** Quantity deducted (already inflated for waste). */
+    qty: number;
+    /** Location the stock was deducted from. */
+    locationId: string;
+}
+/**
+ * Result of {@link ProductionService.produceFinishedGoods}.
+ */
+export interface ProduceResult {
+    /** Finished SKU id whose stock increased. */
+    finishedSkuId: string;
+    /** Quantity received. */
+    qty: number;
+    /** Location the stock was received into. */
+    locationId: string;
+}
+/**
+ * Result of {@link ProductionService.runProduction} — the consume + produce
+ * pair, run inside one transaction.
+ */
+export interface RunProductionResult {
+    consumed: ConsumeResult[];
+    produced: ProduceResult;
+}
+/**
+ * Operational bridge between a production order and the inventory ledger.
+ */
+export declare class ProductionService {
+    /**
+     * BOM collection bound to the OUTER (non-tx) database. Used for
+     * pre-flight reads in `prepareConsume()` — those run before the
+     * stock-service transaction opens, by design (read-then-tx keeps
+     * the transaction window narrow and rollback only covers actual
+     * mutations). DO NOT add BOM writes that depend on the stock-tx
+     * rolling them back together — this collection is not tx-scoped
+     * and writes here would commit independently. If joint BOM-plus-
+     * stock mutations are ever needed, build tx-scoped BOM collections
+     * inside the `stockService.withTransaction` callback (mirror the
+     * pattern in StockService.withTransaction itself).
+     */
+    readonly boms: BillOfMaterialsCollection;
+    /**
+     * BomLine collection bound to the OUTER database. Same caveat as
+     * {@link boms} — pre-flight reads only.
+     */
+    readonly lines: BomLineCollection;
+    readonly stockService: StockService;
+    private constructor();
+    /** Factory — prefer {@link createProductionService}. */
+    static create(options: ProductionServiceOptions): Promise<ProductionService>;
+    /**
+     * Walk every BOM line for the production order's BOM and deduct
+     * `effectiveQtyPerUnit() * qty` from `available` at `locationId`. Each
+     * deduction goes through {@link StockService.adjust} with `sourceType:
+     * 'ProductionOrder'` and `sourceId: order.id`. Returns the list of
+     * movements emitted so callers can log / surface them.
+     *
+     * **Atomic across lines**: all per-line deductions and their audit
+     * movements run inside a single `stockService.withTransaction(...)`
+     * scope. An `InsufficientStockError` on line N+1 rolls back lines 1..N
+     * so production-order posting never leaves materials half-consumed.
+     * Pre-flight with {@link BomService.canProduce} when you'd rather know
+     * upfront than discover the shortfall mid-run.
+     *
+     * Throws {@link NoActiveBomForProductError} if no BOM id is supplied
+     * on the order *and* no active BOM exists for the order's `productId`.
+     * Throws {@link BomNotFoundError} if `order.bomId` is supplied but
+     * doesn't resolve. Throws plain `Error` on missing `locationId`,
+     * non-positive `qty`, or when both `order.bomId` and `order.productId`
+     * are absent (a programmer error — neither input identifies a BOM).
+     * Re-throws `InsufficientStockError` from `StockService.adjust` if a
+     * line would drive `available` below zero.
+     */
+    consumeMaterials(order: ProductionOrderRef, options: ConsumeMaterialsOptions): Promise<ConsumeResult[]>;
+    /**
+     * Receive `qty` of the finished SKU into `available` at `locationId`.
+     * Goes through {@link StockService.receive} with `sourceType:
+     * 'ProductionOrder'` and `sourceId: order.id`. Returns a single
+     * {@link ProduceResult} describing what landed.
+     *
+     * Throws plain `Error` on missing required arguments or non-positive
+     * `qty`.
+     */
+    produceFinishedGoods(order: ProductionOrderRef, options: ProduceFinishedGoodsOptions): Promise<ProduceResult>;
+    /**
+     * Atomically consume materials AND receive finished goods for one
+     * production run.
+     *
+     * Both calls share a single `stockService.withTransaction(...)` scope:
+     *
+     * - Materials are deducted line-by-line via {@link StockService.adjust}.
+     * - Finished goods are received via {@link StockService.receive}.
+     * - If ANY step throws — a BOM-line shortage, the produce-leg adapter
+     *   failing, a tenancy mismatch surfaced by an interceptor — every
+     *   write in the transaction rolls back. The materials are restored
+     *   and the finished SKU's `available` row is unchanged. Callers
+     *   never observe "materials deducted but finished goods missing".
+     *
+     * Use this when consume + produce should be one indivisible event —
+     * e.g. a make-to-stock workflow posting `production_order:completed`
+     * where the shop floor step is invisible to the ledger.
+     *
+     * The two-call form (call {@link consumeMaterials} then {@link
+     * produceFinishedGoods} separately) is still appropriate when the
+     * factory step is a real wall-clock gap that other observers need to
+     * see — work-in-progress dashboards, partial-run reporting, etc.
+     *
+     * Throws the same errors as the individual methods: missing args
+     * (plain `Error`), unresolvable BOM ({@link BomNotFoundError} /
+     * {@link NoActiveBomForProductError}), or `InsufficientStockError`
+     * if a line would drive `available` below zero.
+     */
+    runProduction(order: ProductionOrderRef, options: {
+        consume: ConsumeMaterialsOptions;
+        produce: ProduceFinishedGoodsOptions;
+    }): Promise<RunProductionResult>;
+    /**
+     * Validate consume args, resolve the BOM + lines, and pre-compute the
+     * mutation attribution. Anything that can throw without a tx open
+     * happens here so the transaction we open later doesn't have to roll
+     * back over a validation miss.
+     */
+    private prepareConsume;
+    /**
+     * Execute the consume leg against a caller-supplied tx-bound
+     * {@link StockService}. Public entry points (`consumeMaterials`,
+     * `runProduction`) open the tx and call through here. Each per-line
+     * `tx.adjust(...)` shares the same transaction so a shortfall on
+     * line N+1 rolls back lines 1..N.
+     */
+    private consumeMaterialsWith;
+    /**
+     * Execute the produce leg against a caller-supplied tx-bound
+     * {@link StockService}. Public entry points (`produceFinishedGoods`,
+     * `runProduction`) open the tx and call through here.
+     */
+    private produceFinishedGoodsWith;
+    /**
+     * Resolve the BOM for a production order. Order of preference:
+     *
+     * 1. Explicit `order.bomId` if supplied — the caller pinned a specific
+     *    revision; we honor that pin or fail. We deliberately do NOT fall
+     *    back to the active BOM when `order.bomId` is stale or mistyped,
+     *    because silently switching recipes would have the production run
+     *    consume materials against a different BOM than the order locked.
+     * 2. The active BOM for `order.productId`.
+     *
+     * Throws {@link BomNotFoundError} when an explicit `order.bomId` is
+     * supplied but doesn't resolve to a row.
+     *
+     * Throws {@link NoActiveBomForProductError} when no `bomId` was supplied
+     * and the product has no active BOM.
+     *
+     * Throws plain `Error` when neither `order.bomId` nor `order.productId`
+     * is supplied — there's nothing to resolve against, so we surface that
+     * as a programmer error with a distinct message rather than overload
+     * `NoActiveBomForProductError` with an empty product id.
+     */
+    private resolveBom;
+}
+/**
+ * Convenience factory. Returns a fully-initialized {@link ProductionService}.
+ */
+export declare function createProductionService(options: ProductionServiceOptions): Promise<ProductionService>;
+export type { BomLine };
+//# sourceMappingURL=ProductionService.d.ts.map

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

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

package/dist/services/dispatch-handlers.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Opt-in DispatchBus subscribers that bridge upstream production-order
+ * signals to {@link ProductionService}.
+ *
+ * **Off by default.** The package never auto-subscribes — consumer apps
+ * call {@link installManufacturingDispatchHandlers} from their `smrt.ts`
+ * wiring once they have decided they want a `production_order:posted`
+ * emit to consume materials and produce finished goods automatically.
+ *
+ * Two paired toggles let consumers wire only the legs they want:
+ *
+ * - `installProductionPosted` (default `true`) — on `production_order:posted`,
+ *   call {@link ProductionService.consumeMaterials} once.
+ * - `installProductionCompleted` (default `false`) — on `production_order:completed`,
+ *   call {@link ProductionService.produceFinishedGoods} once. Off by default
+ *   because not every shop emits a separate "completed" event; lots of
+ *   workflows expect consume + produce to happen atomically when the
+ *   order is posted. Set both flags to `true` to get the split lifecycle.
+ *
+ * @packageDocumentation
+ */
+import type { DatabaseConfig, DispatchBus } from '@happyvertical/smrt-core';
+import type { StockService } from '@happyvertical/smrt-inventory';
+import { type ProductionService } from './ProductionService.js';
+/**
+ * Shape of a `production_order:posted` payload this handler expects.
+ *
+ * The producer (typically the application's smrt.ts wiring once a
+ * `ProductionOrder` row transitions to the posted state) packs one
+ * payload per posted order. The handler consumes materials for every
+ * unit declared by `qty`, attributed to `('ProductionOrder', productionOrderId)`
+ * on each emitted {@link StockMovement}.
+ */
+export interface ProductionOrderPostedPayload {
+    /** Production order row id. Used for `sourceId` on every movement. */
+    productionOrderId: string;
+    /**
+     * Plain string reference to the upstream product the order is asked to
+     * produce. Used to resolve the active BOM at consume time.
+     */
+    productId: string;
+    /**
+     * Inventory location id (factory / warehouse) where materials are
+     * pulled from.
+     */
+    locationId: string;
+    /**
+     * Run quantity. Each BOM line's effective qty is multiplied by this
+     * before being deducted from `available`.
+     */
+    qty: number;
+    /**
+     * Optional explicit BOM id, e.g. when the order locked itself to a
+     * specific BOM revision when it was created. Falls back to the active
+     * BOM for `productId` if omitted.
+     */
+    bomId?: string;
+    /**
+     * Optional finished SKU id. When provided AND the
+     * `installProductionPosted` handler is wired to also produce in one
+     * shot (which only happens when `installProductionCompleted` is false
+     * and `producedOnPosted` is true), this is the SKU to receive into
+     * `available`.
+     */
+    finishedSkuId?: string;
+}
+/**
+ * Shape of a `production_order:completed` payload this handler expects.
+ *
+ * Typically emitted when the factory signs off the run and finished
+ * goods are physically available to ship. Only used when callers opt in
+ * via `installProductionCompleted`.
+ */
+export interface ProductionOrderCompletedPayload {
+    /** Production order row id. Used for `sourceId` on the receipt movement. */
+    productionOrderId: string;
+    /**
+     * SKU id of the finished product to receive into `available`. Required.
+     */
+    finishedSkuId: string;
+    /** Inventory location id where the finished goods land. */
+    locationId: string;
+    /** Quantity received. */
+    qty: number;
+}
+/**
+ * Options accepted by {@link installManufacturingDispatchHandlers}.
+ *
+ * Provide either a pre-built {@link ProductionService} (when sharing
+ * across subsystems) or a `db` / `stockService` for the helper to
+ * construct one on first use.
+ */
+export type InstallManufacturingDispatchHandlersOptions = {
+    /** Bus to subscribe on. Typically the app-wide DispatchBus. */
+    dispatchBus: DispatchBus;
+    /**
+     * When `true` (default), install the `production_order:posted` handler.
+     */
+    installProductionPosted?: boolean;
+    /**
+     * When `true` (default `false`), install the
+     * `production_order:completed` handler. Off by default because many
+     * workflows want consume+produce to happen on `posted`; opt in to the
+     * split lifecycle when your shop emits a separate completion event.
+     */
+    installProductionCompleted?: boolean;
+    /**
+     * When `true` (default `false`) AND `installProductionCompleted` is
+     * false, the `production_order:posted` handler also calls
+     * {@link ProductionService.produceFinishedGoods} after consume —
+     * handy for "make-to-stock instantly" workflows where the factory
+     * step is invisible.
+     *
+     * Ignored when `installProductionCompleted` is `true` (in that case
+     * production is the completed-handler's job).
+     */
+    producedOnPosted?: boolean;
+} & ({
+    productionService: ProductionService;
+    db?: DatabaseConfig;
+    stockService?: StockService;
+} | {
+    stockService: StockService;
+    db?: DatabaseConfig;
+    productionService?: undefined;
+} | {
+    db: DatabaseConfig;
+    stockService?: undefined;
+    productionService?: undefined;
+});
+/**
+ * Result handle returned by {@link installManufacturingDispatchHandlers}.
+ * Call `dispose()` to detach the subscribers (mainly useful in tests and
+ * on graceful shutdown).
+ */
+export interface InstalledManufacturingDispatchHandlers {
+    /** Resolved ProductionService — useful for follow-up writes in the same scope. */
+    productionService: ProductionService;
+    /** Detach every installed subscriber. Idempotent. */
+    dispose(): void;
+}
+/**
+ * Subscribe production-order handlers to the given DispatchBus.
+ *
+ * @example
+ * ```typescript
+ * import { createDispatchBus } from '@happyvertical/smrt-core';
+ * import { installManufacturingDispatchHandlers } from '@happyvertical/smrt-manufacturing';
+ *
+ * const bus = await createDispatchBus({ db });
+ * const handlers = await installManufacturingDispatchHandlers({
+ *   dispatchBus: bus,
+ *   db,
+ *   producedOnPosted: true, // consume + produce in one shot
+ * });
+ * ```
+ */
+export declare function installManufacturingDispatchHandlers(options: InstallManufacturingDispatchHandlersOptions): Promise<InstalledManufacturingDispatchHandlers>;
+//# sourceMappingURL=dispatch-handlers.d.ts.map

package/dist/services/dispatch-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-handlers.d.ts","sourceRoot":"","sources":["../../src/services/dispatch-handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EAGZ,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,wBAAwB,CAAC;AAIhC;;;;;;;;GAQG;AACH,MAAM,WAAW,4BAA4B;IAC3C,sEAAsE;IACtE,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,+BAA+B;IAC9C,4EAA4E;IAC5E,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,yBAAyB;IACzB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;GAMG;AACH,MAAM,MAAM,2CAA2C,GAAG;IACxD,+DAA+D;IAC/D,WAAW,EAAE,WAAW,CAAC;IACzB;;OAEG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC;;;;;OAKG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,CACA;IACE,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,EAAE,CAAC,EAAE,cAAc,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,GACD;IACE,YAAY,EAAE,YAAY,CAAC;IAC3B,EAAE,CAAC,EAAE,cAAc,CAAC;IACpB,iBAAiB,CAAC,EAAE,SAAS,CAAC;CAC/B,GACD;IACE,EAAE,EAAE,cAAc,CAAC;IACnB,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB,iBAAiB,CAAC,EAAE,SAAS,CAAC;CAC/B,CACJ,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,sCAAsC;IACrD,kFAAkF;IAClF,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,qDAAqD;IACrD,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,oCAAoC,CACxD,OAAO,EAAE,2CAA2C,GACnD,OAAO,CAAC,sCAAsC,CAAC,CAiDjD"}

package/dist/services/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Service exports for `@happyvertical/smrt-manufacturing`.
+ *
+ * @packageDocumentation
+ */
+export { BomService, type BomServiceOptions, type ComponentCostResolver, createBomService, } from './BomService.js';
+export { type InstalledManufacturingDispatchHandlers, type InstallManufacturingDispatchHandlersOptions, installManufacturingDispatchHandlers, type ProductionOrderCompletedPayload, type ProductionOrderPostedPayload, } from './dispatch-handlers.js';
+export { type ConsumeMaterialsOptions, type ConsumeResult, createProductionService, type ProduceFinishedGoodsOptions, type ProduceResult, type ProductionOrderRef, ProductionService, type ProductionServiceOptions, } from './ProductionService.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,UAAU,EACV,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,sCAAsC,EAC3C,KAAK,2CAA2C,EAChD,oCAAoC,EACpC,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,aAAa,EAClB,uBAAuB,EACvB,KAAK,2BAA2B,EAChC,KAAK,aAAa,EAClB,KAAK,kBAAkB,EACvB,iBAAiB,EACjB,KAAK,wBAAwB,GAC9B,MAAM,wBAAwB,CAAC"}

package/dist/smrt-knowledge.json

@@ -3,12 +3,12 @@
   "sensitiveFieldsExcluded": true,
   "generatedAt": "1970-01-01T00:00:00.000Z",
   "packageName": "@happyvertical/smrt-manufacturing",
-  "packageVersion": "0.51.32",
+  "packageVersion": "0.51.34",
   "sourceManifestPath": "dist/manifest.json",
   "agentDocPath": "AGENTS.md",
   "sourceHashes": {
-    "manifest": "d9dd02c19b1a6bfee5b933cce6c9f09c3ca73618fb52210c65260b1233e16991",
-    "packageJson": "c47f3ebdb7961b5c397d36a5f945d9d52651917f7bf27b52e196df4ce1b35447",
+    "manifest": "fdb5cf2122ae64bdea9eec900e45aca70122fd89a87e2590b89fd2562d54d1f7",
+    "packageJson": "51d5869d98fc7de6a54d1a327f63f5940e424ba0f9a4154f6c254f250b12e740",
     "agents": "94d10408c859743730368f932f77e5602ebefb8fe9a8ac3178fa4b211e95ad29"
   },
   "exports": [
@@ -24,7 +24,7 @@
     "@happyvertical/sql": "catalog:",
     "@happyvertical/smrt-vitest": "workspace:*",
     "@types/node": "24.13.6",
-    "typescript": "5.9.3",
+    "typescript": "6.0.3",
     "vite": "8.1.4",
     "vitest": "4.1.10"
   },