@classytic/flow 0.1.4

package/dist/counting.service-BiQXqorv.mjs

@@ -0,0 +1,232 @@
+import { t as assertTenantContext } from "./tenant-guard-6Ne-BILP.mjs";
+import { t as FlowEvents } from "./event-types-BSqQOvXv.mjs";
+import { a as formatDocumentNumber, i as requireStandardMode } from "./runtime-config-C0ggPkiK.mjs";
+//#region src/services/counting.service.ts
+var CountingService = class {
+	constructor(countPort, quantPort, movePort, moveGroupPort, unitOfWork, eventEmitter, getNextSequence, runtimeConfig, virtualLocations) {
+		this.countPort = countPort;
+		this.quantPort = quantPort;
+		this.movePort = movePort;
+		this.moveGroupPort = moveGroupPort;
+		this.unitOfWork = unitOfWork;
+		this.eventEmitter = eventEmitter;
+		this.getNextSequence = getNextSequence;
+		this.runtimeConfig = runtimeConfig;
+		this.virtualLocations = virtualLocations;
+	}
+	async createSession(input, ctx) {
+		requireStandardMode(this.runtimeConfig, "Cycle counting");
+		assertTenantContext(ctx);
+		return this.unitOfWork.withTransaction(async (session) => {
+			const countNumber = formatDocumentNumber("CNT", await this.getNextSequence("CNT", ctx.organizationId));
+			const count = await this.countPort.create({
+				organizationId: ctx.organizationId,
+				countNumber,
+				countType: input.countType,
+				scope: input.scope,
+				status: "draft",
+				freezePolicy: input.freezePolicy ?? "none",
+				createdBy: ctx.actorId
+			}, session);
+			if (input.scope.locationId || input.scope.skuRefs && input.scope.skuRefs.length > 0) {
+				const filter = { organizationId: ctx.organizationId };
+				if (input.scope.locationId) filter.locationId = input.scope.locationId;
+				if (input.scope.skuRefs && input.scope.skuRefs.length > 0) filter.skuRef = { $in: input.scope.skuRefs };
+				const quants = await this.quantPort.findMany(filter, ctx, session);
+				if (quants.length > 0) {
+					const lines = quants.map((q) => ({
+						organizationId: ctx.organizationId,
+						countId: count._id,
+						skuRef: q.skuRef,
+						locationId: q.locationId,
+						lotId: q.lotId,
+						expectedQuantity: q.quantityOnHand,
+						countedQuantity: 0,
+						variance: -q.quantityOnHand
+					}));
+					await this.countPort.submitLines(count._id, lines, session);
+				}
+			}
+			return count;
+		});
+	}
+	async getById(countId, ctx) {
+		assertTenantContext(ctx);
+		return this.countPort.findById(countId, ctx);
+	}
+	async submitLines(countId, lines, ctx) {
+		assertTenantContext(ctx);
+		const count = await this.requireCount(countId, ctx);
+		const countLines = [];
+		for (const line of lines) {
+			const expectedQuantity = (await this.quantPort.getAvailability({
+				skuRef: line.skuRef,
+				locationId: line.locationId
+			}, ctx)).quantityOnHand;
+			const variance = line.countedQuantity - expectedQuantity;
+			countLines.push({
+				organizationId: ctx.organizationId,
+				countId,
+				skuRef: line.skuRef,
+				locationId: line.locationId,
+				lotId: line.lotId,
+				serialCode: line.serialCode,
+				expectedQuantity,
+				countedQuantity: line.countedQuantity,
+				variance,
+				varianceReason: line.varianceReason
+			});
+		}
+		const createdLines = await this.countPort.submitLines(countId, countLines);
+		await this.countPort.updateStatus(countId, "submitted", { submittedAt: /* @__PURE__ */ new Date() });
+		await this.eventEmitter.emit(FlowEvents.COUNT_STARTED, {
+			organizationId: ctx.organizationId,
+			countId,
+			countNumber: count.countNumber,
+			countType: count.countType,
+			lineCount: createdLines.length
+		});
+		return createdLines;
+	}
+	async calculateVariance(countId, ctx) {
+		assertTenantContext(ctx);
+		await this.requireCount(countId, ctx);
+		const lines = await this.countPort.getLines(countId, ctx);
+		const varianceLines = lines.filter((l) => l.variance !== 0);
+		return {
+			countId,
+			totalLines: lines.length,
+			matchedLines: lines.length - varianceLines.length,
+			varianceLines: varianceLines.length,
+			lines: lines.map((l) => ({
+				skuRef: l.skuRef,
+				locationId: l.locationId,
+				expected: l.expectedQuantity,
+				counted: l.countedQuantity,
+				variance: l.variance,
+				variancePercent: l.expectedQuantity !== 0 ? l.variance / l.expectedQuantity * 100 : l.countedQuantity !== 0 ? 100 : 0
+			}))
+		};
+	}
+	async reconcile(countId, options, ctx) {
+		assertTenantContext(ctx);
+		await this.requireCount(countId, ctx);
+		return this.unitOfWork.withTransaction(async (session) => {
+			const lines = await this.countPort.getLines(countId, ctx, session);
+			const varianceLines = lines.filter((l) => l.variance !== 0);
+			const docNumber = formatDocumentNumber("CNT", await this.getNextSequence("CNT", ctx.organizationId));
+			const moveGroup = await this.moveGroupPort.create({
+				organizationId: ctx.organizationId,
+				groupType: "count_reconciliation",
+				documentNumber: docNumber,
+				createdBy: ctx.actorId,
+				metadata: { countId }
+			}, session);
+			const adjustmentMoves = [];
+			let autoApproved = 0;
+			let needsManualReview = 0;
+			for (const line of varianceLines) {
+				let sourceLocationId;
+				let destinationLocationId;
+				if (line.variance > 0) {
+					sourceLocationId = this.virtualLocations.adjustment;
+					destinationLocationId = line.locationId;
+				} else {
+					sourceLocationId = line.locationId;
+					destinationLocationId = this.virtualLocations.adjustment;
+				}
+				const absVariance = Math.abs(line.variance);
+				const isAutoApproved = options.autoApproveThreshold !== void 0 && absVariance <= options.autoApproveThreshold;
+				if (isAutoApproved) autoApproved++;
+				else needsManualReview++;
+				const move = await this.movePort.create({
+					moveGroupId: moveGroup._id,
+					operationType: "count",
+					skuRef: line.skuRef,
+					sourceLocationId,
+					destinationLocationId,
+					quantityPlanned: absVariance,
+					organizationId: ctx.organizationId,
+					createdBy: ctx.actorId,
+					referenceType: "count",
+					referenceId: countId,
+					metadata: {
+						countLineId: line._id,
+						variance: line.variance,
+						expectedQuantity: line.expectedQuantity,
+						countedQuantity: line.countedQuantity,
+						varianceReason: line.varianceReason,
+						autoApproved: isAutoApproved
+					}
+				}, session);
+				adjustmentMoves.push(move);
+			}
+			await this.countPort.updateStatus(countId, "reconciled", { reconciledAt: /* @__PURE__ */ new Date() }, session);
+			await this.eventEmitter.emit(FlowEvents.COUNT_RECONCILED, {
+				organizationId: ctx.organizationId,
+				countId,
+				totalLines: lines.length,
+				varianceLines: varianceLines.length,
+				autoApproved,
+				needsManualReview,
+				moveGroupId: moveGroup._id,
+				documentNumber: moveGroup.documentNumber
+			}, session);
+			return {
+				countId,
+				totalLines: lines.length,
+				varianceLines: varianceLines.length,
+				autoApproved,
+				needsManualReview,
+				adjustmentMoves
+			};
+		});
+	}
+	async postReconciliationMoves(countId, ctx) {
+		assertTenantContext(ctx);
+		const count = await this.requireCount(countId, ctx);
+		const moves = await this.movePort.findMany({
+			referenceType: "count",
+			referenceId: countId,
+			organizationId: ctx.organizationId
+		}, ctx);
+		await this.unitOfWork.withTransaction(async (session) => {
+			for (const move of moves) {
+				if (move.status === "done" || move.status === "cancelled") continue;
+				const executedAt = /* @__PURE__ */ new Date();
+				await this.movePort.updateStatus(move._id, "done", {
+					quantityDone: move.quantityPlanned,
+					executedAt
+				}, session);
+				await this.quantPort.upsert({
+					organizationId: ctx.organizationId,
+					skuRef: move.skuRef,
+					locationId: move.sourceLocationId,
+					quantityDelta: -move.quantityPlanned,
+					inDate: executedAt
+				}, session);
+				await this.quantPort.upsert({
+					organizationId: ctx.organizationId,
+					skuRef: move.skuRef,
+					locationId: move.destinationLocationId,
+					quantityDelta: move.quantityPlanned,
+					inDate: executedAt
+				}, session);
+			}
+			await this.countPort.updateStatus(countId, "approved", { approvedBy: ctx.actorId }, session);
+			await this.eventEmitter.emit(FlowEvents.ADJUSTMENT_POSTED, {
+				organizationId: ctx.organizationId,
+				countId,
+				countNumber: count.countNumber,
+				movesPosted: moves.filter((m) => m.status !== "done" && m.status !== "cancelled").length
+			}, session);
+		});
+	}
+	async requireCount(countId, ctx) {
+		const count = await this.countPort.findById(countId, ctx);
+		if (!count) throw new Error(`Inventory count ${countId} not found`);
+		return count;
+	}
+};
+//#endregion
+export { CountingService as t };

package/dist/counting.service-CpAxU2G0.d.mts

@@ -0,0 +1,74 @@
+import { n as VirtualLocationMap } from "./virtual-locations-B9zXqPdi.mjs";
+import { a as CountLine, i as InventoryCount, t as CountPort } from "./count.port-BRqwGbi3.mjs";
+import { n as MovePort, r as StockMove } from "./move.port-Qg1CYp7h.mjs";
+import { t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { n as MoveGroupPort } from "./move-group.port-DHGoQA3d.mjs";
+import { n as UnitOfWork } from "./unit-of-work.port-CWEkrDKu.mjs";
+import { t as EventEmitterPort } from "./event-emitter.port-BFh2pasY.mjs";
+import { r as QuantPort } from "./quant.port-BBa66PBT.mjs";
+import { t as RuntimeConfig } from "./runtime-config-CQLtPPqY.mjs";
+
+//#region src/services/counting.service.d.ts
+interface CreateCountInput {
+  countType: 'full' | 'cycle' | 'spot';
+  scope: {
+    nodeId?: string;
+    locationId?: string;
+    skuRefs?: string[];
+  };
+  freezePolicy?: 'hard_freeze' | 'soft_freeze' | 'none';
+}
+interface CountLineInput {
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  serialCode?: string;
+  countedQuantity: number;
+  varianceReason?: string;
+}
+interface VarianceReport {
+  countId: string;
+  totalLines: number;
+  matchedLines: number;
+  varianceLines: number;
+  lines: Array<{
+    skuRef: string;
+    locationId: string;
+    expected: number;
+    counted: number;
+    variance: number;
+    variancePercent: number;
+  }>;
+}
+interface ReconcileOptions {
+  autoApproveThreshold?: number;
+}
+interface ReconcileResult {
+  countId: string;
+  totalLines: number;
+  varianceLines: number;
+  autoApproved: number;
+  needsManualReview: number;
+  adjustmentMoves: StockMove[];
+}
+declare class CountingService {
+  private countPort;
+  private quantPort;
+  private movePort;
+  private moveGroupPort;
+  private unitOfWork;
+  private eventEmitter;
+  private getNextSequence;
+  private runtimeConfig;
+  private virtualLocations;
+  constructor(countPort: CountPort, quantPort: QuantPort, movePort: MovePort, moveGroupPort: MoveGroupPort, unitOfWork: UnitOfWork, eventEmitter: EventEmitterPort, getNextSequence: (prefix: string, organizationId: string) => Promise<number>, runtimeConfig: RuntimeConfig, virtualLocations: VirtualLocationMap);
+  createSession(input: CreateCountInput, ctx: FlowContext): Promise<InventoryCount>;
+  getById(countId: string, ctx: FlowContext): Promise<InventoryCount | null>;
+  submitLines(countId: string, lines: CountLineInput[], ctx: FlowContext): Promise<CountLine[]>;
+  calculateVariance(countId: string, ctx: FlowContext): Promise<VarianceReport>;
+  reconcile(countId: string, options: ReconcileOptions, ctx: FlowContext): Promise<ReconcileResult>;
+  postReconciliationMoves(countId: string, ctx: FlowContext): Promise<void>;
+  private requireCount;
+}
+//#endregion
+export { ReconcileResult as a, ReconcileOptions as i, CountingService as n, VarianceReport as o, CreateCountInput as r, CountLineInput as t };

package/dist/domain/contracts/index.d.mts

@@ -0,0 +1,3 @@
+import { t as AuthContext } from "../../index-DsE7lZdO.mjs";
+import { n as CatalogBridge, r as SkuDetails, t as AvailabilityUpdate } from "../../catalog-bridge-K8bdkncJ.mjs";
+export { AuthContext, AvailabilityUpdate, CatalogBridge, SkuDetails };

package/dist/domain/contracts/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/domain/enums/index.d.mts

@@ -0,0 +1,2 @@
+import { a as ReservationStatus, c as VIRTUAL_LOCATION_TYPES, d as MOVE_STATUS_TRANSITIONS, f as MoveStatus, i as StockStatus, l as GroupType, n as TrackingMode, o as LocationType, p as isValidMoveTransition, r as SELLABLE_STATUSES, s as STOCKABLE_LOCATION_TYPES, t as ValuationMethod, u as OperationType } from "../../index-CulWO137.mjs";
+export { GroupType, LocationType, MOVE_STATUS_TRANSITIONS, MoveStatus, OperationType, ReservationStatus, SELLABLE_STATUSES, STOCKABLE_LOCATION_TYPES, StockStatus, TrackingMode, VIRTUAL_LOCATION_TYPES, ValuationMethod, isValidMoveTransition };

package/dist/domain/enums/index.mjs

@@ -0,0 +1,4 @@
+import { n as MoveStatus, r as isValidMoveTransition, t as MOVE_STATUS_TRANSITIONS } from "../../move-status-DkaFp2GD.mjs";
+import { n as GroupType, t as ReservationStatus } from "../../reservation-status-ZfuTaWG0.mjs";
+import { a as OperationType, c as VIRTUAL_LOCATION_TYPES, i as StockStatus, n as TrackingMode, o as LocationType, r as SELLABLE_STATUSES, s as STOCKABLE_LOCATION_TYPES, t as ValuationMethod } from "../../enums-C3_z6aHC.mjs";
+export { GroupType, LocationType, MOVE_STATUS_TRANSITIONS, MoveStatus, OperationType, ReservationStatus, SELLABLE_STATUSES, STOCKABLE_LOCATION_TYPES, StockStatus, TrackingMode, VIRTUAL_LOCATION_TYPES, ValuationMethod, isValidMoveTransition };

package/dist/domain/index.d.mts

@@ -0,0 +1,24 @@
+import { i as resolveVirtualLocations, n as VirtualLocationMap, r as buildVirtualSourceTypes, t as DEFAULT_VIRTUAL_LOCATIONS } from "../virtual-locations-B9zXqPdi.mjs";
+import { a as CountLine, i as InventoryCount, n as CountScope, r as CountStatus, t as CountPort } from "../count.port-BRqwGbi3.mjs";
+import { a as ReservationStatus, c as VIRTUAL_LOCATION_TYPES, d as MOVE_STATUS_TRANSITIONS, f as MoveStatus, i as StockStatus, l as GroupType, n as TrackingMode, o as LocationType, p as isValidMoveTransition, r as SELLABLE_STATUSES, s as STOCKABLE_LOCATION_TYPES, t as ValuationMethod, u as OperationType } from "../index-CulWO137.mjs";
+import { a as TrackingAssignment, i as assertMoveTransition, n as MovePort, r as StockMove, t as CreateMoveInput } from "../move.port-Qg1CYp7h.mjs";
+import { n as CostLayer, t as CostLayerPort } from "../cost-layer.port-iH9pvZqB.mjs";
+import { a as Address, i as Reservation, n as ReservationPort, o as InventoryNode, r as NodePort, t as CreateReservationInput } from "../reservation.port-l9NFQ0si.mjs";
+import { n as Location, t as LocationPort } from "../location.port-CValXIpb.mjs";
+import { a as ProcurementOrder, i as ProcurementItem, n as ProcurementPort, o as ProcurementStatus, r as ReplenishmentRule, t as ReplenishmentRulePort } from "../replenishment-rule.port-DnEYtbyD.mjs";
+import { n as StockLot, t as LotPort } from "../lot.port-ChsmvZqs.mjs";
+import { a as StockMoveGroup, i as MoveGroupStatus, n as MoveGroupPort, r as MOVE_GROUP_STATUS_TRANSITIONS, t as CreateMoveGroupInput } from "../move-group.port-DHGoQA3d.mjs";
+import { t as StockPackage } from "../stock-package-BIarxbDS.mjs";
+import { n as StockQuant, t as QuantIdentity } from "../stock-quant-CZhgvTu7.mjs";
+import { n as UnitOfWork, t as TransactionSession } from "../unit-of-work.port-CWEkrDKu.mjs";
+import { t as EventEmitterPort } from "../event-emitter.port-BFh2pasY.mjs";
+import { i as QuantUpdate, n as AvailabilityQuery, r as QuantPort, t as Availability } from "../quant.port-BBa66PBT.mjs";
+import { t as AuthContext } from "../index-DsE7lZdO.mjs";
+import { n as CatalogBridge, r as SkuDetails, t as AvailabilityUpdate } from "../catalog-bridge-K8bdkncJ.mjs";
+import { C as ReservationNotFoundError, D as FlowError, E as ValidationError, S as QuantMismatchError, T as StockFrozenError, _ as MoveAlreadyPostedError, a as SkuRef, b as NodeNotFoundError, c as ReservationExpiredError, d as InsufficientStockError, f as ConcurrencyConflictError, g as LotRequiredError, h as LocationNotStockableError, i as convertToBase, l as LocationCapacityExceededError, m as LocationNotFoundError, n as UoMQuantity, o as Quantity, p as DuplicateReservationError, r as convertFromBase, s as TenantIsolationError, t as UoMConversion, u as InvalidTransitionError, v as MoveGroupNotFoundError, w as SerialQuantityError, x as ProcurementNotApprovedError, y as NegativeStockError } from "../index-C_aEnozN.mjs";
+import { n as AllocationResult, t as AllocationPolicy } from "../allocation-policy-my_HfzdV.mjs";
+import { n as PutawayPolicy, t as RemovalPolicy } from "../removal-policy-BItBB8FD.mjs";
+import { t as ValuationPolicy } from "../valuation-policy-Dco8c9Vw.mjs";
+import { t as IdempotencyPort } from "../idempotency.port-CTC70JON.mjs";
+import { n as ScanResolution, t as GS1Resolution } from "../scan-token-CNM9QVLY.mjs";
+export { Address, AllocationPolicy, AllocationResult, AuthContext, Availability, AvailabilityQuery, AvailabilityUpdate, CatalogBridge, ConcurrencyConflictError, CostLayer, CostLayerPort, CountLine, CountPort, CountScope, CountStatus, CreateMoveGroupInput, CreateMoveInput, CreateReservationInput, DEFAULT_VIRTUAL_LOCATIONS, DuplicateReservationError, EventEmitterPort, FlowError, GS1Resolution, GroupType, IdempotencyPort, InsufficientStockError, InvalidTransitionError, InventoryCount, InventoryNode, Location, LocationCapacityExceededError, LocationNotFoundError, LocationNotStockableError, LocationPort, LocationType, LotPort, LotRequiredError, MOVE_GROUP_STATUS_TRANSITIONS, MOVE_STATUS_TRANSITIONS, MoveAlreadyPostedError, MoveGroupNotFoundError, MoveGroupPort, MoveGroupStatus, MovePort, MoveStatus, NegativeStockError, NodeNotFoundError, NodePort, OperationType, ProcurementItem, ProcurementNotApprovedError, ProcurementOrder, ProcurementPort, ProcurementStatus, PutawayPolicy, QuantIdentity, QuantMismatchError, QuantPort, QuantUpdate, Quantity, RemovalPolicy, ReplenishmentRule, ReplenishmentRulePort, Reservation, ReservationExpiredError, ReservationNotFoundError, ReservationPort, ReservationStatus, SELLABLE_STATUSES, STOCKABLE_LOCATION_TYPES, ScanResolution, SerialQuantityError, SkuDetails, SkuRef, StockFrozenError, StockLot, StockMove, StockMoveGroup, StockPackage, StockQuant, StockStatus, TenantIsolationError, TrackingAssignment, TrackingMode, TransactionSession, UnitOfWork, UoMConversion, UoMQuantity, VIRTUAL_LOCATION_TYPES, ValidationError, ValuationMethod, ValuationPolicy, VirtualLocationMap, assertMoveTransition, buildVirtualSourceTypes, convertFromBase, convertToBase, isValidMoveTransition, resolveVirtualLocations };

package/dist/domain/index.mjs

@@ -0,0 +1,10 @@
+import { a as DEFAULT_VIRTUAL_LOCATIONS, i as InvalidTransitionError, n as assertMoveTransition, o as buildVirtualSourceTypes, r as ReservationExpiredError, s as resolveVirtualLocations, t as MOVE_GROUP_STATUS_TRANSITIONS } from "../stock-move-group-C0DqUfPY.mjs";
+import { t as FlowError } from "../base-MWBqRFM2.mjs";
+import { a as LotRequiredError, c as NegativeStockError, d as QuantMismatchError, f as ReservationNotFoundError, h as ValidationError, i as LocationNotStockableError, l as NodeNotFoundError, m as StockFrozenError, n as DuplicateReservationError, o as MoveAlreadyPostedError, p as SerialQuantityError, r as LocationNotFoundError, s as MoveGroupNotFoundError, t as ConcurrencyConflictError, u as ProcurementNotApprovedError } from "../domain-errors-D7S9ydNF.mjs";
+import { t as InsufficientStockError } from "../insufficient-stock.error-Dyr4BYaV.mjs";
+import { a as LocationCapacityExceededError, i as Quantity, n as convertToBase, r as SkuRef, t as convertFromBase } from "../domain-D5cpMpR0.mjs";
+import { t as TenantIsolationError } from "../tenant-isolation.error-D3OcKUdx.mjs";
+import { n as MoveStatus, r as isValidMoveTransition, t as MOVE_STATUS_TRANSITIONS } from "../move-status-DkaFp2GD.mjs";
+import { n as GroupType, t as ReservationStatus } from "../reservation-status-ZfuTaWG0.mjs";
+import { a as OperationType, c as VIRTUAL_LOCATION_TYPES, i as StockStatus, n as TrackingMode, o as LocationType, r as SELLABLE_STATUSES, s as STOCKABLE_LOCATION_TYPES, t as ValuationMethod } from "../enums-C3_z6aHC.mjs";
+export { ConcurrencyConflictError, DEFAULT_VIRTUAL_LOCATIONS, DuplicateReservationError, FlowError, GroupType, InsufficientStockError, InvalidTransitionError, LocationCapacityExceededError, LocationNotFoundError, LocationNotStockableError, LocationType, LotRequiredError, MOVE_GROUP_STATUS_TRANSITIONS, MOVE_STATUS_TRANSITIONS, MoveAlreadyPostedError, MoveGroupNotFoundError, MoveStatus, NegativeStockError, NodeNotFoundError, OperationType, ProcurementNotApprovedError, QuantMismatchError, Quantity, ReservationExpiredError, ReservationNotFoundError, ReservationStatus, SELLABLE_STATUSES, STOCKABLE_LOCATION_TYPES, SerialQuantityError, SkuRef, StockFrozenError, StockStatus, TenantIsolationError, TrackingMode, VIRTUAL_LOCATION_TYPES, ValidationError, ValuationMethod, assertMoveTransition, buildVirtualSourceTypes, convertFromBase, convertToBase, isValidMoveTransition, resolveVirtualLocations };

package/dist/domain/policies/index.d.mts

@@ -0,0 +1,4 @@
+import { n as AllocationResult, t as AllocationPolicy } from "../../allocation-policy-my_HfzdV.mjs";
+import { n as PutawayPolicy, t as RemovalPolicy } from "../../removal-policy-BItBB8FD.mjs";
+import { t as ValuationPolicy } from "../../valuation-policy-Dco8c9Vw.mjs";
+export { AllocationPolicy, AllocationResult, PutawayPolicy, RemovalPolicy, ValuationPolicy };

package/dist/domain/policies/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/domain-D5cpMpR0.mjs

@@ -0,0 +1,96 @@
+import { t as FlowError } from "./base-MWBqRFM2.mjs";
+import { h as ValidationError } from "./domain-errors-D7S9ydNF.mjs";
+//#region src/domain/errors/location-capacity-exceeded.error.ts
+var LocationCapacityExceededError = class extends FlowError {
+	code = "LOCATION_CAPACITY_EXCEEDED";
+	httpStatus = 422;
+	constructor(locationId, capacity, requested) {
+		super(`Location ${locationId} capacity exceeded: capacity ${capacity}, requested ${requested}`);
+		this.locationId = locationId;
+		this.capacity = capacity;
+		this.requested = requested;
+	}
+};
+//#endregion
+//#region src/domain/value-objects/quantity.ts
+/**
+* Non-negative quantity value object.
+* Used for planned/done quantities on moves and availability.
+*/
+var Quantity = class Quantity {
+	constructor(value) {
+		this.value = value;
+	}
+	static create(value) {
+		if (!Number.isFinite(value)) throw new ValidationError("Quantity must be a finite number");
+		if (value < 0) throw new ValidationError(`Quantity must be non-negative, got ${value}`);
+		return new Quantity(value);
+	}
+	static zero() {
+		return new Quantity(0);
+	}
+	add(other) {
+		return new Quantity(this.value + other.value);
+	}
+	subtract(other) {
+		const result = this.value - other.value;
+		if (result < 0) throw new ValidationError(`Quantity subtraction would result in negative: ${this.value} - ${other.value}`);
+		return new Quantity(result);
+	}
+	isZero() {
+		return this.value === 0;
+	}
+	isGreaterThan(other) {
+		return this.value > other.value;
+	}
+	isGreaterThanOrEqual(other) {
+		return this.value >= other.value;
+	}
+	equals(other) {
+		return this.value === other.value;
+	}
+	toString() {
+		return String(this.value);
+	}
+};
+//#endregion
+//#region src/domain/value-objects/sku-ref.ts
+/**
+* Product/variant reference — opaque string identifier linking to the external catalog.
+* Flow never owns the product definition; it references via skuRef.
+*/
+var SkuRef = class SkuRef {
+	constructor(value) {
+		this.value = value;
+	}
+	static create(value) {
+		if (!value || value.trim().length === 0) throw new ValidationError("skuRef must be a non-empty string");
+		return new SkuRef(value.trim());
+	}
+	equals(other) {
+		return this.value === other.value;
+	}
+	toString() {
+		return this.value;
+	}
+};
+//#endregion
+//#region src/domain/value-objects/uom-quantity.ts
+/**
+* Convert quantity from one UoM to base UoM.
+*/
+function convertToBase(quantity, conversion) {
+	if (quantity < 0) throw new ValidationError("Quantity must be non-negative");
+	if (conversion.factor <= 0) throw new ValidationError("UoM conversion factor must be positive");
+	return quantity * conversion.factor;
+}
+/**
+* Convert quantity from base UoM to target UoM.
+*/
+function convertFromBase(quantity, conversion) {
+	if (quantity < 0) throw new ValidationError("Quantity must be non-negative");
+	if (conversion.factor === 0) throw new ValidationError("UoM conversion factor cannot be zero");
+	return quantity / conversion.factor;
+}
+//#endregion
+export { LocationCapacityExceededError as a, Quantity as i, convertToBase as n, SkuRef as r, convertFromBase as t };

package/dist/domain-errors-D7S9ydNF.mjs

@@ -0,0 +1,133 @@
+import { t as FlowError } from "./base-MWBqRFM2.mjs";
+//#region src/domain/errors/domain-errors.ts
+var DuplicateReservationError = class extends FlowError {
+	code = "DUPLICATE_RESERVATION";
+	httpStatus = 409;
+	constructor(ownerType, ownerId, skuRef) {
+		super(`Duplicate reservation for ${ownerType}/${ownerId} on ${skuRef}`);
+		this.ownerType = ownerType;
+		this.ownerId = ownerId;
+		this.skuRef = skuRef;
+	}
+};
+var LocationNotStockableError = class extends FlowError {
+	code = "LOCATION_NOT_STOCKABLE";
+	httpStatus = 422;
+	constructor(locationId, locationType) {
+		super(`Location ${locationId} (type: ${locationType}) does not hold physical stock`);
+		this.locationId = locationId;
+		this.locationType = locationType;
+	}
+};
+var NegativeStockError = class extends FlowError {
+	code = "NEGATIVE_STOCK";
+	httpStatus = 422;
+	constructor(skuRef, locationId, currentQty, requestedQty) {
+		super(`Operation would result in negative stock for ${skuRef} at ${locationId}: current ${currentQty}, requested ${requestedQty}`);
+		this.skuRef = skuRef;
+		this.locationId = locationId;
+		this.currentQty = currentQty;
+		this.requestedQty = requestedQty;
+	}
+};
+var MoveAlreadyPostedError = class extends FlowError {
+	code = "MOVE_ALREADY_POSTED";
+	httpStatus = 409;
+	constructor(moveId) {
+		super(`Move ${moveId} is already posted (done); mutations are not allowed`);
+		this.moveId = moveId;
+	}
+};
+var ConcurrencyConflictError = class extends FlowError {
+	code = "CONCURRENCY_CONFLICT";
+	httpStatus = 409;
+	constructor(message = "Optimistic concurrency check failed; retry the operation") {
+		super(message);
+	}
+};
+var QuantMismatchError = class extends FlowError {
+	code = "QUANT_MISMATCH";
+	httpStatus = 500;
+	constructor(skuRef, locationId, expected, actual) {
+		super(`Quant balance mismatch for ${skuRef} at ${locationId}: expected ${expected}, actual ${actual}`);
+		this.skuRef = skuRef;
+		this.locationId = locationId;
+		this.expected = expected;
+		this.actual = actual;
+	}
+};
+var LotRequiredError = class extends FlowError {
+	code = "LOT_REQUIRED";
+	httpStatus = 422;
+	constructor(skuRef) {
+		super(`SKU ${skuRef} requires lot/serial assignment but none was provided`);
+		this.skuRef = skuRef;
+	}
+};
+var SerialQuantityError = class extends FlowError {
+	code = "SERIAL_QUANTITY";
+	httpStatus = 422;
+	constructor(serialCode) {
+		super(`Serial-tracked item ${serialCode} must have quantity exactly 1`);
+		this.serialCode = serialCode;
+	}
+};
+var StockFrozenError = class extends FlowError {
+	code = "STOCK_FROZEN";
+	httpStatus = 423;
+	constructor(locationId, reason) {
+		super(`Stock at ${locationId} is frozen: ${reason}`);
+		this.locationId = locationId;
+		this.reason = reason;
+	}
+};
+var ProcurementNotApprovedError = class extends FlowError {
+	code = "PROCUREMENT_NOT_APPROVED";
+	httpStatus = 422;
+	constructor(orderId) {
+		super(`Cannot receive against procurement order ${orderId}: not approved/ordered`);
+		this.orderId = orderId;
+	}
+};
+var NodeNotFoundError = class extends FlowError {
+	code = "NODE_NOT_FOUND";
+	httpStatus = 404;
+	constructor(nodeId) {
+		super(`Inventory node ${nodeId} not found`);
+		this.nodeId = nodeId;
+	}
+};
+var LocationNotFoundError = class extends FlowError {
+	code = "LOCATION_NOT_FOUND";
+	httpStatus = 404;
+	constructor(locationId) {
+		super(`Location ${locationId} not found`);
+		this.locationId = locationId;
+	}
+};
+var MoveGroupNotFoundError = class extends FlowError {
+	code = "MOVE_GROUP_NOT_FOUND";
+	httpStatus = 404;
+	constructor(groupId) {
+		super(`Move group ${groupId} not found`);
+		this.groupId = groupId;
+	}
+};
+var ReservationNotFoundError = class extends FlowError {
+	code = "RESERVATION_NOT_FOUND";
+	httpStatus = 404;
+	constructor(reservationId) {
+		super(`Reservation ${reservationId} not found`);
+		this.reservationId = reservationId;
+	}
+};
+var ValidationError = class extends FlowError {
+	code = "VALIDATION_ERROR";
+	httpStatus = 400;
+	constructor(message, fields) {
+		super(message);
+		this.fields = fields;
+	}
+};
+//#endregion
+export { LotRequiredError as a, NegativeStockError as c, QuantMismatchError as d, ReservationNotFoundError as f, ValidationError as h, LocationNotStockableError as i, NodeNotFoundError as l, StockFrozenError as m, DuplicateReservationError as n, MoveAlreadyPostedError as o, SerialQuantityError as p, LocationNotFoundError as r, MoveGroupNotFoundError as s, ConcurrencyConflictError as t, ProcurementNotApprovedError as u };