@happyvertical/smrt-manufacturing 0.53.4 → 0.53.6

package/dist/svelte/types.js

@@ -0,0 +1,249 @@
+/**
+ * Serializable view types and pure helpers for the manufacturing components.
+ *
+ * Components take plain view objects (not model instances) so hosts can pass
+ * data across the server/client boundary.
+ */
+import { M } from './i18n.js';
+function textOf(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+/** Map an operation's state onto `StatusBadge` default color-scheme keys. */
+export function operationStatusBadgeKey(isActive) {
+    return isActive ? 'active' : 'inactive';
+}
+/** Trim a form draft and check the required fields: code and name. */
+export function validateOperationForm(draft) {
+    const code = textOf(draft.code);
+    const name = textOf(draft.name);
+    const invalid = [];
+    if (!code)
+        invalid.push('code');
+    if (!name)
+        invalid.push('name');
+    if (invalid.length > 0)
+        return { ok: false, invalid };
+    return {
+        ok: true,
+        values: {
+            code,
+            name,
+            category: textOf(draft.category),
+            requiredQualificationId: textOf(draft.requiredQualificationId),
+        },
+    };
+}
+/**
+ * Build an {@link AssemblyView} from an `Assembly` plus the facts the list
+ * shows that live on its neighbours: its SKU codes and its active bill.
+ */
+export function toAssemblyView(assembly, related = {}) {
+    return {
+        id: assembly.id ?? '',
+        name: assembly.name,
+        partReference: assembly.partReference ?? '',
+        skuCodes: [...(related.skuCodes ?? [])],
+        price: Number(assembly.price ?? 0),
+        estimatedLabourMinutes: Number(assembly.estimatedLabourMinutes ?? 0),
+        activeBomVersion: related.activeBomVersion ?? null,
+    };
+}
+/** Adapt one resolved bill line for {@link BomEditor}. */
+export function toBomEditorLine(entry) {
+    const { line, component } = entry;
+    const skuCode = component.sku?.code ?? '';
+    return {
+        id: line.id ?? '',
+        componentSkuId: line.componentSkuId,
+        componentName: component.product?.name || skuCode || line.componentSkuId,
+        skuCode,
+        kind: component.kind,
+        qtyPerUnit: Number(line.qtyPerUnit ?? 0),
+        uom: line.uom,
+        wastePercent: Number(line.wastePercent ?? 0),
+        notes: line.notes ?? '',
+        subBomId: component.activeBom?.id ?? null,
+    };
+}
+/**
+ * Adapt a whole bill from `AssemblyService.getBillStructure` for
+ * {@link BomEditor}, keeping its line order.
+ */
+export function toBomEditorLines(structure) {
+    return structure.lines.map(toBomEditorLine);
+}
+function toNumber(raw) {
+    if (typeof raw === 'number')
+        return raw;
+    const trimmed = raw.trim();
+    return trimmed === '' ? Number.NaN : Number(trimmed);
+}
+/**
+ * Check one line's input: a component must be chosen, the quantity must be a
+ * number greater than zero, the unit must not be empty, and the waste percent
+ * must be a number of zero or more (empty counts as zero).
+ */
+export function validateBomLineInput(input) {
+    const invalid = [];
+    const componentSkuId = input.componentSkuId.trim();
+    const qtyPerUnit = toNumber(input.qtyPerUnit);
+    const uom = input.uom.trim();
+    const wasteRaw = typeof input.wastePercent === 'string' && input.wastePercent.trim() === ''
+        ? 0
+        : toNumber(input.wastePercent);
+    if (!componentSkuId)
+        invalid.push('componentSkuId');
+    if (!Number.isFinite(qtyPerUnit) || qtyPerUnit <= 0)
+        invalid.push('qtyPerUnit');
+    if (!uom)
+        invalid.push('uom');
+    if (!Number.isFinite(wasteRaw) || wasteRaw < 0)
+        invalid.push('wastePercent');
+    if (invalid.length > 0)
+        return { ok: false, invalid };
+    return {
+        ok: true,
+        value: { componentSkuId, qtyPerUnit, uom, wastePercent: wasteRaw },
+    };
+}
+/** The message key naming a {@link ComponentKind} in words. */
+export function componentKindLabelKey(kind) {
+    switch (kind) {
+        case 'assembly':
+            return M['manufacturing.kind.assembly'];
+        case 'material':
+            return M['manufacturing.kind.material'];
+        case 'bought':
+            return M['manufacturing.kind.bought'];
+        default:
+            return M['manufacturing.kind.missing'];
+    }
+}
+/** Split a labour estimate into whole hours and the remaining minutes. */
+export function splitLabourMinutes(minutes) {
+    const whole = Math.max(0, Math.round(minutes));
+    return { hours: Math.floor(whole / 60), minutes: whole % 60 };
+}
+/** Adapt a `ProductionRun` to a {@link ProductionRunView}, with the host's label. */
+export function toProductionRunView(run, label) {
+    return {
+        id: run.id,
+        label,
+        targetQty: Number(run.targetQty),
+        completedQty: Number(run.completedQty),
+        status: run.status,
+    };
+}
+/** The message key naming a run status in words. */
+export function productionRunStatusLabelKey(status) {
+    switch (status) {
+        case 'planned':
+            return M['manufacturing.production_run_status.planned'];
+        case 'in_progress':
+            return M['manufacturing.production_run_status.in_progress'];
+        case 'done':
+            return M['manufacturing.production_run_status.done'];
+        default:
+            return M['manufacturing.production_run_status.cancelled'];
+    }
+}
+/** The `StatusBadge` tone for a run status. */
+export function productionRunStatusTone(status) {
+    switch (status) {
+        case 'in_progress':
+            return 'info';
+        case 'done':
+            return 'success';
+        case 'cancelled':
+            return 'warning';
+        default:
+            return 'neutral';
+    }
+}
+/** `true` while a run can still take completions. */
+export function isProductionRunOpen(status) {
+    return status === 'planned' || status === 'in_progress';
+}
+/**
+ * Check a typed completion quantity against what the run has left (the
+ * service checks again under its lock).
+ */
+export function validateCompletionQty(raw, run) {
+    const text = raw.trim();
+    const qty = text === '' ? Number.NaN : Number(text);
+    if (!Number.isFinite(qty) || qty <= 0)
+        return { ok: false, reason: 'invalid' };
+    // Whole millionths compared exactly, as ProductionRunService does
+    // (QUANTITY_DECIMALS = 6, MAX_QUANTITY = 999,999,999).
+    const millionths = (value) => Number(value.toFixed(6).replace('.', ''));
+    const rounded = Number(qty.toFixed(6));
+    if (rounded <= 0 || rounded > 999_999_999)
+        return { ok: false, reason: 'invalid' };
+    const remaining = millionths(run.targetQty) - millionths(run.completedQty);
+    if (millionths(rounded) > remaining)
+        return { ok: false, reason: 'too_many' };
+    return { ok: true, qty: rounded };
+}
+function isPlanned(line) {
+    return 'short' in line;
+}
+/**
+ * Nest the depth-first lines of an {@link Explosion} or a
+ * {@link RequirementsPlan} for `RequirementsTree`.
+ */
+export function toRequirementTree(source) {
+    const roots = [];
+    const open = [];
+    for (const line of source.lines) {
+        const view = {
+            key: [...line.path.map((entry) => entry.bomId), line.lineId].join('/'),
+            level: line.level,
+            name: line.name,
+            skuCode: line.skuCode,
+            kind: line.kind,
+            required: line.totalQty,
+            uom: line.uom,
+            available: isPlanned(line) ? line.available : null,
+            short: isPlanned(line) ? line.short : null,
+            buildable: line.buildable,
+            children: [],
+        };
+        open.length = Math.min(open.length, line.level - 1);
+        const parent = open[line.level - 2];
+        if (line.level > 1 && parent)
+            parent.children.push(view);
+        else
+            roots.push(view);
+        open[line.level - 1] = view;
+    }
+    return roots;
+}
+/**
+ * The totals of an {@link Explosion} or a {@link RequirementsPlan}: every line
+ * not opened, summed per component SKU (first unit kept).
+ */
+export function toRequirementTotals(source) {
+    const totals = new Map();
+    for (const line of source.lines) {
+        if (line.expanded)
+            continue;
+        const short = isPlanned(line) ? line.short : null;
+        const existing = totals.get(line.componentSkuId);
+        if (existing) {
+            existing.required += line.totalQty;
+            if (existing.short !== null && short !== null)
+                existing.short += short;
+        }
+        else {
+            totals.set(line.componentSkuId, {
+                componentSkuId: line.componentSkuId,
+                name: line.name,
+                skuCode: line.skuCode,
+                required: line.totalQty,
+                uom: line.uom,
+                short,
+            });
+        }
+    }
+    return Array.from(totals.values());
+}

package/dist/tenant-scope.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reading a structure in its owner's tenant: the owner's rows and global
+ * ones, whatever tenant context is active.
+ *
+ * Under a tenant context the tenancy interceptor narrows every read to that
+ * tenant, which hides global rows (a shared material, a global bill, global
+ * stock); without a context it narrows nothing, which shows every tenant's
+ * rows. Neither is a bill's structure. {@link readOwnAndGlobal} runs list
+ * reads through `withTenantGlobalRead` (tenant rows plus global rows, refused
+ * for a tenant the active context may not read), and callers keep
+ * {@link isOwnOrGlobal} rows, which also covers tenancy being disabled.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Run `read` so its list reads return `owner`'s rows and global ones. For a
+ * global owner (`null`), reads see the active tenant's rows and global ones,
+ * and callers keep the global rows.
+ */
+export declare function readOwnAndGlobal<T>(owner: string | null, read: () => Promise<T>): Promise<T>;
+/** `true` for a global row or one of `owner`'s rows. */
+export declare function isOwnOrGlobal(row: {
+    tenantId?: string | null;
+}, owner: string | null): boolean;
+//# sourceMappingURL=tenant-scope.d.ts.map

package/dist/tenant-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant-scope.d.ts","sourceRoot":"","sources":["../src/tenant-scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACrB,OAAO,CAAC,CAAC,CAAC,CAGZ;AAED,wDAAwD;AACxD,wBAAgB,aAAa,CAC3B,GAAG,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACjC,KAAK,EAAE,MAAM,GAAG,IAAI,GACnB,OAAO,CAGT"}

package/dist/types.d.ts

@@ -7,6 +7,8 @@
  *
  * @packageDocumentation
  */
+import type { LabourEstimate } from './operation-types.js';
+import type { ComponentKind } from './services/AssemblyService.js';
 /**
  * Lifecycle state of a {@link BillOfMaterials}.
  *
@@ -50,6 +52,13 @@ export interface BomLineCost {
      * flag lets UIs warn the user that the cost rollup is incomplete.
      */
     costUnavailable: boolean;
+    /**
+     * Multi-level only: the active bill this sub-assembly line was rolled up
+     * from. `unitCost` is then that bill's material cost per unit.
+     */
+    subBomId?: string;
+    /** Multi-level only: the sub-assembly bill's own lines, rolled up the same way. */
+    components?: BomLineCost[];
 }
 /**
  * Aggregate cost rollup returned by {@link BomService.computeMaterialCost}.
@@ -64,8 +73,9 @@ export interface BomCostRollup {
     /** Per-line breakdown. Empty array when the BOM has no lines. */
     lineBreakdown: BomLineCost[];
     /**
-     * `true` when at least one line's unit cost could not be resolved.
-     * Callers should treat `totalCost` as a lower bound in that case.
+     * `true` when at least one line's unit cost could not be resolved, at any
+     * level walked. Callers should treat `totalCost` as a lower bound in that
+     * case.
      */
     hasMissingCosts: boolean;
 }
@@ -83,14 +93,36 @@ export interface MaterialRequirement {
 }
 /**
  * A single shortage discovered by {@link BomService.canProduce}.
+ *
+ * A single-level check (the default) reports one entry per component SKU
+ * with the run's total and the SKU's whole available stock. A multi-level
+ * check (`{ levels }`) reports each shortage on the line where it occurs, so
+ * the same SKU can appear once per place it is used, and adds `level`,
+ * `path`, `uom` and `buildable`.
  */
 export interface MaterialShortage {
     /** Plain string reference to the missing component {@link Sku}. */
     componentSkuId: string;
     /** Total quantity required for the requested production run. */
     requested: number;
-    /** Available stock across all locations (`available` state). */
+    /**
+     * Available stock across all locations (`available` state). In a
+     * multi-level check, the part of it not already allocated to lines planned
+     * earlier in the walk.
+     */
     available: number;
+    /** Multi-level only: the level of the line that is short (1 = the bill's own lines). */
+    level?: number;
+    /** Multi-level only: the bills from the top down to the one the line is on. */
+    path?: ExplosionPathEntry[];
+    /** Multi-level only: the line's unit of measure. */
+    uom?: string;
+    /**
+     * Multi-level only: `true` for a sub-assembly with an active bill that the
+     * walk did not open because the `levels` limit was reached. It is short,
+     * but could be built.
+     */
+    buildable?: boolean;
 }
 /**
  * Result returned by {@link BomService.canProduce}.
@@ -126,4 +158,176 @@ export declare class NoActiveBomForProductError extends Error {
     name: string;
     constructor(productId: string);
 }
+/**
+ * How many bill levels a walk reads. `1` is the bill's own lines only (the
+ * single-level behaviour every method keeps by default); `2` also opens each
+ * sub-assembly's active bill; and so on. `'all'` walks down to materials,
+ * bought items and assemblies without an active bill, up to
+ * {@link MAX_EXPLOSION_DEPTH} levels.
+ */
+export type ExplosionLevels = number | 'all';
+/** Options for the multi-level forms of the {@link BomService} methods. */
+export interface ExplosionOptions {
+    /** How deep to walk. Default `1`. See {@link ExplosionLevels}. */
+    levels?: ExplosionLevels;
+}
+/**
+ * The deepest structure a walk opens. A numeric `levels` above it is refused;
+ * `'all'` on a structure deeper than this fails with
+ * {@link BomExplosionLimitError} rather than running unbounded.
+ */
+export declare const MAX_EXPLOSION_DEPTH = 32;
+/**
+ * The most lines one walk returns. A structure that shares sub-assemblies
+ * widely can multiply out; past this a walk fails with
+ * {@link BomExplosionLimitError}.
+ */
+export declare const MAX_EXPLOSION_LINES = 10000;
+/** One bill on the way down a multi-level walk. */
+export interface ExplosionPathEntry {
+    /** The bill. */
+    bomId: string;
+    /** The product the bill makes. */
+    productId: string;
+    /** The product's name, or its id when it has none or cannot be read. */
+    name: string;
+}
+/**
+ * One bill line in a multi-level walk, in depth-first order: an expanded
+ * sub-assembly is followed by its own bill's lines.
+ */
+export interface ExplodedLine {
+    /** The `BomLine` id. */
+    lineId: string;
+    /** The bill the line is on. */
+    bomId: string;
+    /** 1 for the top bill's own lines, 2 for a sub-assembly's lines, ... */
+    level: number;
+    /** The bills from the top down to the one this line is on (`level` entries). */
+    path: ExplosionPathEntry[];
+    /** The component SKU. */
+    componentSkuId: string;
+    /** What the component is (see `AssemblyService.resolveComponent`). */
+    kind: ComponentKind;
+    /** The component product's name; `''` when it cannot be resolved. */
+    name: string;
+    /** The component SKU's code; `''` when it cannot be resolved. */
+    skuCode: string;
+    /** Quantity per unit of the parent, as on the line (before waste). */
+    qtyPerUnit: number;
+    /** Waste percent on the line. */
+    wastePercent: number;
+    /** Quantity per unit of the parent including this line's waste. */
+    effectiveQtyPerUnit: number;
+    /** The line's own unit of measure; never converted. */
+    uom: string;
+    /**
+     * Quantity needed for the run: the parent's quantity times
+     * `effectiveQtyPerUnit`, so waste compounds down the levels.
+     */
+    totalQty: number;
+    /** `true` for a sub-assembly with an active bill (it can be built here). */
+    buildable: boolean;
+    /** The sub-assembly's active bill id, or `null`. */
+    subBomId: string | null;
+    /** `true` when the sub-assembly's bill was opened: its lines follow this one. */
+    expanded: boolean;
+}
+/** Result of {@link BomService.explode}: the gross multi-level requirements. */
+export interface Explosion {
+    /** The top bill. */
+    bomId: string;
+    /** The product the top bill makes. */
+    productId: string;
+    /** Units of the top product the run makes. */
+    qty: number;
+    /** The `levels` the walk used. */
+    levels: ExplosionLevels;
+    /** Every line walked, depth first. */
+    lines: ExplodedLine[];
+    /**
+     * The rolled-up shopping list: every line that was not expanded (materials,
+     * bought items, missing components, sub-assemblies without an active bill
+     * or past the `levels` limit), summed per component SKU. As in the
+     * single-level form, a SKU listed in two units keeps the first unit.
+     */
+    totals: MaterialRequirement[];
+}
+/**
+ * One line of {@link RequirementsPlan}. `totalQty` is the *net* quantity: the
+ * run's quantity for the top bill's lines, and only a sub-assembly's
+ * shortfall for the lines of its bill.
+ */
+export interface PlannedLine extends ExplodedLine {
+    /**
+     * Available stock of the component (all locations) not already allocated
+     * to lines planned earlier in the walk, so stock used once is not counted
+     * twice.
+     */
+    available: number;
+    /** `totalQty` minus what `available` covers; `0` when covered. */
+    short: number;
+}
+/**
+ * Result of {@link BomService.planRequirements}: facts for deciding what to
+ * build, buy or pull. A sub-assembly that is short and has an active bill is
+ * opened for its shortfall only; whether the application builds or buys it is
+ * the application's decision.
+ */
+export interface RequirementsPlan {
+    /** The top bill. */
+    bomId: string;
+    /** The product the top bill makes. */
+    productId: string;
+    /** Units of the top product the run makes. */
+    qty: number;
+    /** The `levels` the walk used. */
+    levels: ExplosionLevels;
+    /** Every line planned, depth first. */
+    lines: PlannedLine[];
+    /**
+     * Every line that is short and was not opened (a material, a bought item,
+     * a missing component, or a sub-assembly with no active bill or past the
+     * `levels` limit), reported at its own level.
+     */
+    shortages: MaterialShortage[];
+    /** `true` when `shortages` is empty. */
+    ok: boolean;
+}
+/** One sub-assembly's labour in a multi-level {@link LabourEstimate}. */
+export interface SubAssemblyLabour {
+    /** The line naming the sub-assembly. */
+    lineId: string;
+    /** The sub-assembly's component SKU. */
+    componentSkuId: string;
+    /** The sub-assembly's name. */
+    name: string;
+    /** The level of the line naming it (1 = on the top bill). */
+    level: number;
+    /** The bills from the top down to the one the line is on. */
+    path: ExplosionPathEntry[];
+    /**
+     * Units of the sub-assembly per unit of the top product, waste compounded
+     * through every level above.
+     */
+    unitsPerUnit: number;
+    /** The sub-assembly bill's own routing, per unit of the sub-assembly. */
+    estimate: LabourEstimate;
+}
+/**
+ * Thrown when a multi-level walk would exceed {@link MAX_EXPLOSION_DEPTH}
+ * levels (with `levels: 'all'`) or {@link MAX_EXPLOSION_LINES} lines.
+ */
+export declare class BomExplosionLimitError extends Error {
+    /** The bill the walk started from. */
+    readonly bomId: string;
+    /** Which limit was reached. */
+    readonly limit: 'depth' | 'lines';
+    name: string;
+    constructor(
+    /** The bill the walk started from. */
+    bomId: string, 
+    /** Which limit was reached. */
+    limit: 'depth' | 'lines');
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,YAAY,EAAE,MAAM,CAAC;IACrB,kEAAkE;IAClE,YAAY,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,cAAc,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,cAAc,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,EAAE,CAAA;CAAE,GAC3B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,SAAS,EAAE,gBAAgB,EAAE,CAAA;CAAE,CAAC;AAEjD;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;aAGb,KAAK,EAAE,MAAM;IAFhC,IAAI,SAAsB;gBAEP,KAAK,EAAE,MAAM;CAG1C;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;aAGvB,SAAS,EAAE,MAAM;IAFpC,IAAI,SAAgC;gBAEjB,SAAS,EAAE,MAAM;CAM9C"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -15,7 +15,19 @@ var NoActiveBomForProductError = class extends Error {
 	productId;
 	name = "NoActiveBomForProductError";
 };
+var MAX_EXPLOSION_DEPTH = 32;
+var MAX_EXPLOSION_LINES = 1e4;
+var BomExplosionLimitError = class extends Error {
+	constructor(bomId, limit) {
+		super(limit === "depth" ? `Bill ${bomId} is nested deeper than 32 levels.` : `Bill ${bomId} explodes to more than ${MAX_EXPLOSION_LINES} lines.`);
+		this.bomId = bomId;
+		this.limit = limit;
+	}
+	bomId;
+	limit;
+	name = "BomExplosionLimitError";
+};
 //#endregion
-export { BomNotFoundError, NoActiveBomForProductError };
+export { BomExplosionLimitError, BomNotFoundError, MAX_EXPLOSION_DEPTH, MAX_EXPLOSION_LINES, NoActiveBomForProductError };
 
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Shared types and error classes for `@happyvertical/smrt-manufacturing`.\n *\n * Strictly industry-neutral. The same vocabulary serves apparel, furniture,\n * automotive, CPG, electronics, food production, custom hardware, and any\n * other vertical that builds finished goods from raw inputs by recipe.\n *\n * @packageDocumentation\n */\n\n/**\n * Lifecycle state of a {@link BillOfMaterials}.\n *\n * - `draft` — under construction; not yet released for production. Cost\n *   rollups can still be computed, but the BOM should not yet be referenced\n *   by a production order.\n * - `active` — currently in use. New production orders should reference the\n *   active BOM for a given product.\n * - `superseded` — an older revision that has been replaced by a newer\n *   `active` BOM. Historical production orders may still reference the\n *   superseded row for audit, but no new orders should pick it up.\n */\nexport type BomStatus = 'draft' | 'active' | 'superseded';\n\n/**\n * Per-line cost breakdown returned by {@link BomService.computeMaterialCost}.\n * Lets callers surface \"here's where the $42 came from\" UIs without\n * recomputing on the client.\n */\nexport interface BomLineCost {\n  /**\n   * Plain string reference to a component SKU id. The `Sku` model\n   * itself lives in `@happyvertical/smrt-products`; inventory only\n   * tracks stock motion against that id.\n   */\n  componentSkuId: string;\n  /** Quantity per produced unit (pre-waste). */\n  qtyPerUnit: number;\n  /** Waste percent applied to this line (`0` if none). */\n  wastePercent: number;\n  /** Effective quantity used per produced unit, including waste. */\n  effectiveQty: number;\n  /** Latest known unit cost, or `0` if unavailable. */\n  unitCost: number;\n  /** Effective unit-cost contribution to the rolled-up total. */\n  lineCost: number;\n  /** Unit of measure as declared on the line (`'yards'`, `'each'`, ...). */\n  uom: string;\n  /**\n   * `true` when the unit cost could not be resolved from upstream\n   * `smrt-products`. The line still contributes `0` to the total; the\n   * flag lets UIs warn the user that the cost rollup is incomplete.\n   */\n  costUnavailable: boolean;\n}\n\n/**\n * Aggregate cost rollup returned by {@link BomService.computeMaterialCost}.\n */\nexport interface BomCostRollup {\n  /** BOM that was rolled up. */\n  bomId: string;\n  /** Total material cost per produced unit. */\n  totalCost: number;\n  /** ISO 4217 currency code. Defaults to `'USD'`. */\n  currency: string;\n  /** Per-line breakdown. Empty array when the BOM has no lines. */\n  lineBreakdown: BomLineCost[];\n  /**\n   * `true` when at least one line's unit cost could not be resolved.\n   * Callers should treat `totalCost` as a lower bound in that case.\n   */\n  hasMissingCosts: boolean;\n}\n\n/**\n * A single entry on a requirements explosion. Multiple BOM lines pointing\n * at the same component SKU are summed.\n */\nexport interface MaterialRequirement {\n  /** Plain string reference to the required component {@link Sku}. */\n  componentSkuId: string;\n  /** Total quantity needed across the full production run (waste included). */\n  totalQty: number;\n  /** Unit of measure carried over from the originating BOM line(s). */\n  uom: string;\n}\n\n/**\n * A single shortage discovered by {@link BomService.canProduce}.\n */\nexport interface MaterialShortage {\n  /** Plain string reference to the missing component {@link Sku}. */\n  componentSkuId: string;\n  /** Total quantity required for the requested production run. */\n  requested: number;\n  /** Available stock across all locations (`available` state). */\n  available: number;\n}\n\n/**\n * Result returned by {@link BomService.canProduce}.\n *\n * `ok: true` means every material requirement is currently covered by\n * available stock; `ok: false` means at least one component is short.\n */\nexport type CanProduceResult =\n  | { ok: true; shortages: [] }\n  | { ok: false; shortages: MaterialShortage[] };\n\n/**\n * Thrown when a service operation needs to resolve a BOM by id but the row\n * does not exist. Carries the requested id so callers can surface a\n * meaningful message.\n */\nexport class BomNotFoundError extends Error {\n  override name = 'BomNotFoundError';\n\n  constructor(public readonly bomId: string) {\n    super(`Bill of Materials not found: ${bomId}`);\n  }\n}\n\n/**\n * Thrown when a production-order operation needs a BOM to plan against but\n * no active BOM is currently registered for the production order's\n * `productId`. The caller should either link a BOM by passing one in\n * explicitly or activate one for the given product.\n */\nexport class NoActiveBomForProductError extends Error {\n  override name = 'NoActiveBomForProductError';\n\n  constructor(public readonly productId: string) {\n    super(\n      `No active Bill of Materials found for product: ${productId}. ` +\n        `Activate a BOM for this product or pass one explicitly.`,\n    );\n  }\n}\n"],"mappings":";AAmHO,IAAM,mBAAN,cAA+B,MAAM;CAG1C,YAA4B,OAAe;EACzC,MAAM,gCAAgC,OAAO;EADnB,KAAA,QAAA;CAE5B;CAF4B;CAFnB,OAAO;AAKlB;AAQO,IAAM,6BAAN,cAAyC,MAAM;CAGpD,YAA4B,WAAmB;EAC7C,MACE,kDAAkD,UAAS,0DAE7D;EAJ0B,KAAA,YAAA;CAK5B;CAL4B;CAFnB,OAAO;AAQlB"}
+{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Shared types and error classes for `@happyvertical/smrt-manufacturing`.\n *\n * Strictly industry-neutral. The same vocabulary serves apparel, furniture,\n * automotive, CPG, electronics, food production, custom hardware, and any\n * other vertical that builds finished goods from raw inputs by recipe.\n *\n * @packageDocumentation\n */\n\nimport type { LabourEstimate } from './operation-types.js';\nimport type { ComponentKind } from './services/AssemblyService.js';\n\n/**\n * Lifecycle state of a {@link BillOfMaterials}.\n *\n * - `draft` — under construction; not yet released for production. Cost\n *   rollups can still be computed, but the BOM should not yet be referenced\n *   by a production order.\n * - `active` — currently in use. New production orders should reference the\n *   active BOM for a given product.\n * - `superseded` — an older revision that has been replaced by a newer\n *   `active` BOM. Historical production orders may still reference the\n *   superseded row for audit, but no new orders should pick it up.\n */\nexport type BomStatus = 'draft' | 'active' | 'superseded';\n\n/**\n * Per-line cost breakdown returned by {@link BomService.computeMaterialCost}.\n * Lets callers surface \"here's where the $42 came from\" UIs without\n * recomputing on the client.\n */\nexport interface BomLineCost {\n  /**\n   * Plain string reference to a component SKU id. The `Sku` model\n   * itself lives in `@happyvertical/smrt-products`; inventory only\n   * tracks stock motion against that id.\n   */\n  componentSkuId: string;\n  /** Quantity per produced unit (pre-waste). */\n  qtyPerUnit: number;\n  /** Waste percent applied to this line (`0` if none). */\n  wastePercent: number;\n  /** Effective quantity used per produced unit, including waste. */\n  effectiveQty: number;\n  /** Latest known unit cost, or `0` if unavailable. */\n  unitCost: number;\n  /** Effective unit-cost contribution to the rolled-up total. */\n  lineCost: number;\n  /** Unit of measure as declared on the line (`'yards'`, `'each'`, ...). */\n  uom: string;\n  /**\n   * `true` when the unit cost could not be resolved from upstream\n   * `smrt-products`. The line still contributes `0` to the total; the\n   * flag lets UIs warn the user that the cost rollup is incomplete.\n   */\n  costUnavailable: boolean;\n  /**\n   * Multi-level only: the active bill this sub-assembly line was rolled up\n   * from. `unitCost` is then that bill's material cost per unit.\n   */\n  subBomId?: string;\n  /** Multi-level only: the sub-assembly bill's own lines, rolled up the same way. */\n  components?: BomLineCost[];\n}\n\n/**\n * Aggregate cost rollup returned by {@link BomService.computeMaterialCost}.\n */\nexport interface BomCostRollup {\n  /** BOM that was rolled up. */\n  bomId: string;\n  /** Total material cost per produced unit. */\n  totalCost: number;\n  /** ISO 4217 currency code. Defaults to `'USD'`. */\n  currency: string;\n  /** Per-line breakdown. Empty array when the BOM has no lines. */\n  lineBreakdown: BomLineCost[];\n  /**\n   * `true` when at least one line's unit cost could not be resolved, at any\n   * level walked. Callers should treat `totalCost` as a lower bound in that\n   * case.\n   */\n  hasMissingCosts: boolean;\n}\n\n/**\n * A single entry on a requirements explosion. Multiple BOM lines pointing\n * at the same component SKU are summed.\n */\nexport interface MaterialRequirement {\n  /** Plain string reference to the required component {@link Sku}. */\n  componentSkuId: string;\n  /** Total quantity needed across the full production run (waste included). */\n  totalQty: number;\n  /** Unit of measure carried over from the originating BOM line(s). */\n  uom: string;\n}\n\n/**\n * A single shortage discovered by {@link BomService.canProduce}.\n *\n * A single-level check (the default) reports one entry per component SKU\n * with the run's total and the SKU's whole available stock. A multi-level\n * check (`{ levels }`) reports each shortage on the line where it occurs, so\n * the same SKU can appear once per place it is used, and adds `level`,\n * `path`, `uom` and `buildable`.\n */\nexport interface MaterialShortage {\n  /** Plain string reference to the missing component {@link Sku}. */\n  componentSkuId: string;\n  /** Total quantity required for the requested production run. */\n  requested: number;\n  /**\n   * Available stock across all locations (`available` state). In a\n   * multi-level check, the part of it not already allocated to lines planned\n   * earlier in the walk.\n   */\n  available: number;\n  /** Multi-level only: the level of the line that is short (1 = the bill's own lines). */\n  level?: number;\n  /** Multi-level only: the bills from the top down to the one the line is on. */\n  path?: ExplosionPathEntry[];\n  /** Multi-level only: the line's unit of measure. */\n  uom?: string;\n  /**\n   * Multi-level only: `true` for a sub-assembly with an active bill that the\n   * walk did not open because the `levels` limit was reached. It is short,\n   * but could be built.\n   */\n  buildable?: boolean;\n}\n\n/**\n * Result returned by {@link BomService.canProduce}.\n *\n * `ok: true` means every material requirement is currently covered by\n * available stock; `ok: false` means at least one component is short.\n */\nexport type CanProduceResult =\n  | { ok: true; shortages: [] }\n  | { ok: false; shortages: MaterialShortage[] };\n\n/**\n * Thrown when a service operation needs to resolve a BOM by id but the row\n * does not exist. Carries the requested id so callers can surface a\n * meaningful message.\n */\nexport class BomNotFoundError extends Error {\n  override name = 'BomNotFoundError';\n\n  constructor(public readonly bomId: string) {\n    super(`Bill of Materials not found: ${bomId}`);\n  }\n}\n\n/**\n * Thrown when a production-order operation needs a BOM to plan against but\n * no active BOM is currently registered for the production order's\n * `productId`. The caller should either link a BOM by passing one in\n * explicitly or activate one for the given product.\n */\nexport class NoActiveBomForProductError extends Error {\n  override name = 'NoActiveBomForProductError';\n\n  constructor(public readonly productId: string) {\n    super(\n      `No active Bill of Materials found for product: ${productId}. ` +\n        `Activate a BOM for this product or pass one explicitly.`,\n    );\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Multi-level walks (sub-assemblies)\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * How many bill levels a walk reads. `1` is the bill's own lines only (the\n * single-level behaviour every method keeps by default); `2` also opens each\n * sub-assembly's active bill; and so on. `'all'` walks down to materials,\n * bought items and assemblies without an active bill, up to\n * {@link MAX_EXPLOSION_DEPTH} levels.\n */\nexport type ExplosionLevels = number | 'all';\n\n/** Options for the multi-level forms of the {@link BomService} methods. */\nexport interface ExplosionOptions {\n  /** How deep to walk. Default `1`. See {@link ExplosionLevels}. */\n  levels?: ExplosionLevels;\n}\n\n/**\n * The deepest structure a walk opens. A numeric `levels` above it is refused;\n * `'all'` on a structure deeper than this fails with\n * {@link BomExplosionLimitError} rather than running unbounded.\n */\nexport const MAX_EXPLOSION_DEPTH = 32;\n\n/**\n * The most lines one walk returns. A structure that shares sub-assemblies\n * widely can multiply out; past this a walk fails with\n * {@link BomExplosionLimitError}.\n */\nexport const MAX_EXPLOSION_LINES = 10_000;\n\n/** One bill on the way down a multi-level walk. */\nexport interface ExplosionPathEntry {\n  /** The bill. */\n  bomId: string;\n  /** The product the bill makes. */\n  productId: string;\n  /** The product's name, or its id when it has none or cannot be read. */\n  name: string;\n}\n\n/**\n * One bill line in a multi-level walk, in depth-first order: an expanded\n * sub-assembly is followed by its own bill's lines.\n */\nexport interface ExplodedLine {\n  /** The `BomLine` id. */\n  lineId: string;\n  /** The bill the line is on. */\n  bomId: string;\n  /** 1 for the top bill's own lines, 2 for a sub-assembly's lines, ... */\n  level: number;\n  /** The bills from the top down to the one this line is on (`level` entries). */\n  path: ExplosionPathEntry[];\n  /** The component SKU. */\n  componentSkuId: string;\n  /** What the component is (see `AssemblyService.resolveComponent`). */\n  kind: ComponentKind;\n  /** The component product's name; `''` when it cannot be resolved. */\n  name: string;\n  /** The component SKU's code; `''` when it cannot be resolved. */\n  skuCode: string;\n  /** Quantity per unit of the parent, as on the line (before waste). */\n  qtyPerUnit: number;\n  /** Waste percent on the line. */\n  wastePercent: number;\n  /** Quantity per unit of the parent including this line's waste. */\n  effectiveQtyPerUnit: number;\n  /** The line's own unit of measure; never converted. */\n  uom: string;\n  /**\n   * Quantity needed for the run: the parent's quantity times\n   * `effectiveQtyPerUnit`, so waste compounds down the levels.\n   */\n  totalQty: number;\n  /** `true` for a sub-assembly with an active bill (it can be built here). */\n  buildable: boolean;\n  /** The sub-assembly's active bill id, or `null`. */\n  subBomId: string | null;\n  /** `true` when the sub-assembly's bill was opened: its lines follow this one. */\n  expanded: boolean;\n}\n\n/** Result of {@link BomService.explode}: the gross multi-level requirements. */\nexport interface Explosion {\n  /** The top bill. */\n  bomId: string;\n  /** The product the top bill makes. */\n  productId: string;\n  /** Units of the top product the run makes. */\n  qty: number;\n  /** The `levels` the walk used. */\n  levels: ExplosionLevels;\n  /** Every line walked, depth first. */\n  lines: ExplodedLine[];\n  /**\n   * The rolled-up shopping list: every line that was not expanded (materials,\n   * bought items, missing components, sub-assemblies without an active bill\n   * or past the `levels` limit), summed per component SKU. As in the\n   * single-level form, a SKU listed in two units keeps the first unit.\n   */\n  totals: MaterialRequirement[];\n}\n\n/**\n * One line of {@link RequirementsPlan}. `totalQty` is the *net* quantity: the\n * run's quantity for the top bill's lines, and only a sub-assembly's\n * shortfall for the lines of its bill.\n */\nexport interface PlannedLine extends ExplodedLine {\n  /**\n   * Available stock of the component (all locations) not already allocated\n   * to lines planned earlier in the walk, so stock used once is not counted\n   * twice.\n   */\n  available: number;\n  /** `totalQty` minus what `available` covers; `0` when covered. */\n  short: number;\n}\n\n/**\n * Result of {@link BomService.planRequirements}: facts for deciding what to\n * build, buy or pull. A sub-assembly that is short and has an active bill is\n * opened for its shortfall only; whether the application builds or buys it is\n * the application's decision.\n */\nexport interface RequirementsPlan {\n  /** The top bill. */\n  bomId: string;\n  /** The product the top bill makes. */\n  productId: string;\n  /** Units of the top product the run makes. */\n  qty: number;\n  /** The `levels` the walk used. */\n  levels: ExplosionLevels;\n  /** Every line planned, depth first. */\n  lines: PlannedLine[];\n  /**\n   * Every line that is short and was not opened (a material, a bought item,\n   * a missing component, or a sub-assembly with no active bill or past the\n   * `levels` limit), reported at its own level.\n   */\n  shortages: MaterialShortage[];\n  /** `true` when `shortages` is empty. */\n  ok: boolean;\n}\n\n/** One sub-assembly's labour in a multi-level {@link LabourEstimate}. */\nexport interface SubAssemblyLabour {\n  /** The line naming the sub-assembly. */\n  lineId: string;\n  /** The sub-assembly's component SKU. */\n  componentSkuId: string;\n  /** The sub-assembly's name. */\n  name: string;\n  /** The level of the line naming it (1 = on the top bill). */\n  level: number;\n  /** The bills from the top down to the one the line is on. */\n  path: ExplosionPathEntry[];\n  /**\n   * Units of the sub-assembly per unit of the top product, waste compounded\n   * through every level above.\n   */\n  unitsPerUnit: number;\n  /** The sub-assembly bill's own routing, per unit of the sub-assembly. */\n  estimate: LabourEstimate;\n}\n\n/**\n * Thrown when a multi-level walk would exceed {@link MAX_EXPLOSION_DEPTH}\n * levels (with `levels: 'all'`) or {@link MAX_EXPLOSION_LINES} lines.\n */\nexport class BomExplosionLimitError extends Error {\n  override name = 'BomExplosionLimitError';\n\n  constructor(\n    /** The bill the walk started from. */\n    public readonly bomId: string,\n    /** Which limit was reached. */\n    public readonly limit: 'depth' | 'lines',\n  ) {\n    super(\n      limit === 'depth'\n        ? `Bill ${bomId} is nested deeper than ${MAX_EXPLOSION_DEPTH} levels.`\n        : `Bill ${bomId} explodes to more than ${MAX_EXPLOSION_LINES} lines.`,\n    );\n  }\n}\n"],"mappings":";AAoJO,IAAM,mBAAN,cAA+B,MAAM;CAG1C,YAA4B,OAAe;EACzC,MAAM,gCAAgC,OAAO;EADnB,KAAA,QAAA;CAE5B;CAF4B;CAFnB,OAAO;AAKlB;AAQO,IAAM,6BAAN,cAAyC,MAAM;CAGpD,YAA4B,WAAmB;EAC7C,MACE,kDAAkD,UAAS,0DAE7D;EAJ0B,KAAA,YAAA;CAK5B;CAL4B;CAFnB,OAAO;AAQlB;AA0BO,IAAM,sBAAsB;AAO5B,IAAM,sBAAsB;AA+I5B,IAAM,yBAAN,cAAqC,MAAM;CAGhD,YAEkB,OAEA,OAChB;EACA,MACE,UAAU,UACN,QAAQ,MAAK,qCACb,QAAQ,MAAK,yBAA0B,oBAAmB,QAChE;EARgB,KAAA,QAAA;EAEA,KAAA,QAAA;CAOlB;CATkB;CAEA;CANT,OAAO;AAclB"}

package/dist/ui.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Manufacturing Module UI Slot Declarations
+ *
+ * UI extension points for the manufacturing module. Components live in the
+ * ./svelte subpath and are props-driven: hosts load records through the
+ * services and pass plain view objects.
+ */
+import type { ModuleUISlot, SmrtModuleMeta } from '@happyvertical/smrt-types';
+/**
+ * Manufacturing module UI slots
+ */
+export declare const MANUFACTURING_UI_SLOTS: Record<string, ModuleUISlot>;
+/**
+ * Manufacturing module metadata
+ */
+export declare const MANUFACTURING_MODULE_META: SmrtModuleMeta;
+//# sourceMappingURL=ui.d.ts.map

package/dist/ui.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui.d.ts","sourceRoot":"","sources":["../src/ui.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAoE/D,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,cAwBvC,CAAC"}