@classytic/flow 0.1.4

package/dist/services-_lLO4Xbl.mjs

@@ -0,0 +1,1009 @@
+import { 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 { c as NegativeStockError, f as ReservationNotFoundError, h as ValidationError, s as MoveGroupNotFoundError, t as ConcurrencyConflictError } from "./domain-errors-D7S9ydNF.mjs";
+import { t as InsufficientStockError } from "./insufficient-stock.error-Dyr4BYaV.mjs";
+import { t as assertTenantContext } from "./tenant-guard-6Ne-BILP.mjs";
+import { i as AvailabilityReport, n as StockAgingReport, r as HealthMetricsReport, t as TurnoverReport } from "./reporting-CL5ffrKM.mjs";
+import { t as TraceService } from "./trace.service-DE6Eh8_8.mjs";
+import { t as CostLayerService } from "./cost-layer.service-BQ1bs-XN.mjs";
+import { t as FlowEvents } from "./event-types-BSqQOvXv.mjs";
+import { a as formatDocumentNumber, i as requireStandardMode, t as createRuntimeConfig } from "./runtime-config-C0ggPkiK.mjs";
+import { t as CountingService } from "./counting.service-BiQXqorv.mjs";
+import { n as MoveStatus } from "./move-status-DkaFp2GD.mjs";
+import { n as GroupType, t as ReservationStatus } from "./reservation-status-ZfuTaWG0.mjs";
+import { t as PackageService } from "./package.service-4tcAwBbr.mjs";
+import { n as ProcurementService, t as ReplenishmentService } from "./replenishment.service-BT9P-HKM.mjs";
+//#region src/services/allocation.service.ts
+var AllocationService = class {
+	policyRegistry = /* @__PURE__ */ new Map();
+	constructor(quantPort, defaultPolicy) {
+		this.quantPort = quantPort;
+		this.defaultPolicy = defaultPolicy;
+		this.policyRegistry.set(defaultPolicy.name, defaultPolicy);
+	}
+	/**
+	* Register a named allocation policy.
+	* Consumers can register per-node or per-category policies.
+	*/
+	registerPolicy(policy) {
+		this.policyRegistry.set(policy.name, policy);
+	}
+	/**
+	* Get a policy by name. Falls back to default.
+	*/
+	getPolicy(name) {
+		if (!name) return this.defaultPolicy;
+		return this.policyRegistry.get(name) ?? this.defaultPolicy;
+	}
+	async allocate(input, ctx) {
+		assertTenantContext(ctx);
+		if (input.quantity <= 0) throw new ValidationError("quantity must be positive");
+		const availability = await this.quantPort.getAvailability({
+			skuRef: input.skuRef,
+			nodeId: input.nodeId,
+			locationId: input.locationId
+		}, ctx);
+		return this.getPolicy(input.policy).resolve(input.skuRef, input.quantity, availability.breakdowns);
+	}
+	async checkAvailability(items, nodeId, ctx) {
+		assertTenantContext(ctx);
+		const results = [];
+		for (const item of items) {
+			const availability = await this.quantPort.getAvailability({
+				skuRef: item.skuRef,
+				nodeId
+			}, ctx);
+			results.push({
+				skuRef: item.skuRef,
+				requested: item.quantity,
+				available: availability.quantityAvailable,
+				fulfilled: availability.quantityAvailable >= item.quantity
+			});
+		}
+		return {
+			items: results,
+			allFulfilled: results.every((r) => r.fulfilled)
+		};
+	}
+};
+//#endregion
+//#region src/services/move.service.ts
+var MoveService = class {
+	constructor(movePort, postingService, unitOfWork, eventEmitter, idempotency) {
+		this.movePort = movePort;
+		this.postingService = postingService;
+		this.unitOfWork = unitOfWork;
+		this.eventEmitter = eventEmitter;
+		this.idempotency = idempotency;
+	}
+	async create(input, ctx) {
+		assertTenantContext(ctx);
+		if (!input.skuRef) throw new ValidationError("skuRef is required");
+		if (!input.sourceLocationId) throw new ValidationError("sourceLocationId is required");
+		if (!input.destinationLocationId) throw new ValidationError("destinationLocationId is required");
+		if (input.sourceLocationId === input.destinationLocationId) throw new ValidationError("sourceLocationId and destinationLocationId must differ");
+		if (input.quantityPlanned <= 0) throw new ValidationError("quantityPlanned must be positive");
+		const move = await this.movePort.create({
+			...input,
+			organizationId: ctx.organizationId,
+			createdBy: ctx.actorId
+		});
+		await this.eventEmitter.emit(FlowEvents.MOVE_PLANNED, {
+			organizationId: ctx.organizationId,
+			moveId: move._id,
+			moveGroupId: move.moveGroupId,
+			skuRef: move.skuRef,
+			operationType: move.operationType,
+			quantityPlanned: move.quantityPlanned
+		});
+		return move;
+	}
+	async commit(moveId, payload, ctx) {
+		assertTenantContext(ctx);
+		const scopedKey = ctx.idempotencyKey ? `${ctx.organizationId}:${ctx.idempotencyKey}` : null;
+		if (scopedKey && this.idempotency) {
+			if (this.idempotency.claim) {
+				const claimResult = await this.idempotency.claim(scopedKey);
+				if (claimResult.status === "hit") return claimResult.result;
+				if (claimResult.status === "busy") throw new Error(`Concurrent operation in progress for idempotency key: ${ctx.idempotencyKey}`);
+				try {
+					const result = await this.executeCommit(moveId, payload, ctx);
+					await this.idempotency?.complete?.(scopedKey, result);
+					return result;
+				} catch (err) {
+					await this.idempotency?.release?.(scopedKey);
+					throw err;
+				}
+			}
+			const cached = await this.idempotency.check(scopedKey);
+			if (cached.hit) return cached.result;
+			const result = await this.executeCommit(moveId, payload, ctx);
+			await this.idempotency.save(scopedKey, result);
+			return result;
+		}
+		return this.executeCommit(moveId, payload, ctx);
+	}
+	async executeCommit(moveId, payload, ctx) {
+		return (await this.postingService.postMove(moveId, {
+			quantityDone: payload.quantityDone,
+			executedAt: payload.executedAt
+		}, ctx)).move;
+	}
+	async cancel(moveId, ctx) {
+		assertTenantContext(ctx);
+		return this.unitOfWork.withTransaction(async (session) => {
+			const move = await this.movePort.findById(moveId, ctx, session);
+			if (!move) throw new Error(`Move ${moveId} not found`);
+			assertMoveTransition(move, MoveStatus.cancelled);
+			return this.movePort.updateStatus(moveId, MoveStatus.cancelled, { cancelledAt: /* @__PURE__ */ new Date() }, session);
+		});
+	}
+};
+//#endregion
+//#region src/services/move-group.service.ts
+const GROUP_TYPE_PREFIX = {
+	[GroupType.receipt]: "RCV",
+	[GroupType.transfer]: "TRF",
+	[GroupType.shipment]: "SHP",
+	[GroupType.return]: "RET",
+	[GroupType.adjustment]: "ADJ",
+	[GroupType.pick_wave]: "PWV",
+	[GroupType.count_reconciliation]: "CNT"
+};
+var MoveGroupService = class {
+	constructor(moveGroupPort, movePort, quantPort, reservationPort, _locationPort, _nodePort, unitOfWork, eventEmitter, _idempotency, _catalogBridge, getNextSequence, runtimeConfig, virtualLocations, postingService, procurementPort) {
+		this.moveGroupPort = moveGroupPort;
+		this.movePort = movePort;
+		this.quantPort = quantPort;
+		this.reservationPort = reservationPort;
+		this.unitOfWork = unitOfWork;
+		this.eventEmitter = eventEmitter;
+		this.getNextSequence = getNextSequence;
+		this.runtimeConfig = runtimeConfig;
+		this.virtualLocations = virtualLocations;
+		this.postingService = postingService;
+		this.procurementPort = procurementPort;
+	}
+	async create(input, ctx) {
+		assertTenantContext(ctx);
+		if (!input.items || input.items.length === 0) throw new ValidationError("Move group must contain at least one item");
+		const prefix = GROUP_TYPE_PREFIX[input.groupType] ?? "MOV";
+		const documentNumber = formatDocumentNumber(prefix, await this.getNextSequence(prefix, ctx.organizationId));
+		return this.unitOfWork.withTransaction(async (session) => {
+			const group = await this.moveGroupPort.create({
+				organizationId: ctx.organizationId,
+				groupType: input.groupType,
+				documentNumber,
+				sourceNodeId: input.sourceNodeId,
+				destinationNodeId: input.destinationNodeId,
+				priority: input.priority,
+				counterparty: input.counterparty,
+				notes: input.notes,
+				createdBy: ctx.actorId,
+				metadata: input.metadata
+			}, session);
+			for (const item of input.items) await this.movePort.create({
+				...item,
+				moveGroupId: group._id,
+				organizationId: ctx.organizationId,
+				createdBy: ctx.actorId
+			}, session);
+			await this.eventEmitter.emit(FlowEvents.MOVE_GROUP_CREATED, {
+				organizationId: ctx.organizationId,
+				groupId: group._id,
+				groupType: group.groupType,
+				documentNumber: group.documentNumber
+			}, session);
+			return group;
+		});
+	}
+	async createFromProcurement(orderId, ctx) {
+		assertTenantContext(ctx);
+		if (!this.procurementPort) throw new ValidationError("ProcurementPort required for createFromProcurement");
+		const order = await this.procurementPort.findById(orderId, ctx);
+		if (!order) throw new ValidationError(`Procurement order ${orderId} not found`);
+		return this.unitOfWork.withTransaction(async (session) => {
+			const freshOrder = await this.procurementPort?.findById(orderId, ctx, session);
+			if (!freshOrder) throw new ValidationError(`Procurement order ${orderId} not found`);
+			if (order.updatedAt && freshOrder.updatedAt && new Date(order.updatedAt).getTime() !== new Date(freshOrder.updatedAt).getTime()) throw new ConcurrencyConflictError(`Procurement order ${orderId} was modified concurrently`);
+			const prefix = GROUP_TYPE_PREFIX[GroupType.receipt] ?? "RCV";
+			const documentNumber = formatDocumentNumber(prefix, await this.getNextSequence(prefix, ctx.organizationId));
+			const group = await this.moveGroupPort.create({
+				organizationId: ctx.organizationId,
+				groupType: GroupType.receipt,
+				documentNumber,
+				destinationNodeId: freshOrder.destinationNodeId,
+				counterparty: {
+					type: "vendor",
+					id: freshOrder.vendorRef
+				},
+				createdBy: ctx.actorId,
+				metadata: { procurementOrderId: orderId }
+			}, session);
+			for (const item of freshOrder.items) {
+				const remaining = item.quantity - item.quantityReceived;
+				if (remaining <= 0) continue;
+				await this.movePort.create({
+					moveGroupId: group._id,
+					operationType: "receipt",
+					skuRef: item.skuRef,
+					sourceLocationId: this.virtualLocations.vendor,
+					destinationLocationId: freshOrder.destinationLocationId ?? freshOrder.destinationNodeId,
+					quantityPlanned: remaining,
+					organizationId: ctx.organizationId,
+					createdBy: ctx.actorId,
+					metadata: {
+						procurementOrderId: orderId,
+						unitCost: item.unitCost
+					}
+				}, session);
+			}
+			await this.eventEmitter.emit(FlowEvents.MOVE_GROUP_CREATED, {
+				organizationId: ctx.organizationId,
+				groupId: group._id,
+				groupType: group.groupType,
+				documentNumber: group.documentNumber,
+				procurementOrderId: orderId
+			}, session);
+			return group;
+		});
+	}
+	async executeAction(id, action, payload, ctx) {
+		assertTenantContext(ctx);
+		switch (action) {
+			case "confirm": return this.confirmGroup(id, ctx);
+			case "allocate": return this.allocateGroup(id, ctx);
+			case "dispatch": return this.dispatchGroup(id, ctx);
+			case "receive": return this.receiveGroup(id, payload, ctx);
+			case "cancel": return this.cancelGroup(id, ctx);
+			default: throw new Error(`Unknown action: ${action}`);
+		}
+	}
+	async getById(id, ctx) {
+		assertTenantContext(ctx);
+		return this.moveGroupPort.findById(id, ctx);
+	}
+	async list(query, ctx) {
+		assertTenantContext(ctx);
+		return this.moveGroupPort.list(query, ctx);
+	}
+	async confirmGroup(id, ctx) {
+		const group = await this.requireGroup(id, ctx);
+		this.assertGroupTransition(group, "confirmed");
+		const updated = await this.moveGroupPort.updateStatus(id, "confirmed", { confirmedAt: /* @__PURE__ */ new Date() });
+		await this.eventEmitter.emit(FlowEvents.MOVE_GROUP_CONFIRMED, {
+			organizationId: ctx.organizationId,
+			groupId: updated._id,
+			documentNumber: updated.documentNumber
+		});
+		return updated;
+	}
+	async allocateGroup(id, ctx) {
+		requireStandardMode(this.runtimeConfig, "Stock allocation");
+		const group = await this.requireGroup(id, ctx);
+		this.assertGroupTransition(group, "allocated");
+		return this.unitOfWork.withTransaction(async (session) => {
+			const allocatable = (await this.movePort.findByGroupId(id, ctx, session)).filter((m) => m.status !== "done" && m.status !== "cancelled");
+			if (allocatable.length === 0) return this.moveGroupPort.updateStatus(id, "allocated", {}, session);
+			const demandMap = /* @__PURE__ */ new Map();
+			for (const move of allocatable) {
+				const key = `${move.skuRef}::${move.sourceLocationId}`;
+				const existing = demandMap.get(key);
+				if (existing) existing.totalNeeded += move.quantityPlanned;
+				else demandMap.set(key, {
+					skuRef: move.skuRef,
+					locationId: move.sourceLocationId,
+					totalNeeded: move.quantityPlanned
+				});
+			}
+			const availChecks = await Promise.all([...demandMap.entries()].map(async ([key, demand]) => {
+				return {
+					key,
+					demand,
+					available: (await this.quantPort.getAvailability({
+						skuRef: demand.skuRef,
+						locationId: demand.locationId
+					}, ctx, session)).quantityAvailable
+				};
+			}));
+			for (const check of availChecks) if (check.available < check.demand.totalNeeded) throw new InsufficientStockError(check.demand.skuRef, check.demand.totalNeeded, check.available, check.demand.locationId);
+			const reservationInputs = allocatable.map((move) => ({
+				organizationId: ctx.organizationId,
+				reservationType: "hard",
+				ownerType: "move_group",
+				ownerId: id,
+				skuRef: move.skuRef,
+				locationId: move.sourceLocationId,
+				quantity: move.quantityPlanned
+			}));
+			const reservations = [];
+			for (const input of reservationInputs) reservations.push(await this.reservationPort.create(input, session));
+			const quantUpdates = allocatable.map((move) => ({
+				organizationId: ctx.organizationId,
+				skuRef: move.skuRef,
+				locationId: move.sourceLocationId,
+				quantityDelta: 0,
+				reservedDelta: move.quantityPlanned,
+				inDate: /* @__PURE__ */ new Date()
+			}));
+			if (this.quantPort.batchUpsert) await this.quantPort.batchUpsert(quantUpdates, session);
+			else for (const update of quantUpdates) await this.quantPort.upsert(update, session);
+			for (let i = 0; i < allocatable.length; i++) {
+				const move = allocatable[i];
+				const reservation = reservations[i];
+				await this.movePort.updateStatus(move._id, move.status, { reservationIds: [...move.reservationIds ?? [], reservation._id] }, session);
+			}
+			return this.moveGroupPort.updateStatus(id, "allocated", {}, session);
+		});
+	}
+	async dispatchGroup(id, ctx) {
+		const group = await this.requireGroup(id, ctx);
+		this.assertGroupTransition(group, "in_progress");
+		const updated = await this.moveGroupPort.updateStatus(id, "in_progress", {});
+		await this.eventEmitter.emit(FlowEvents.TRANSFER_DISPATCHED, {
+			organizationId: ctx.organizationId,
+			groupId: updated._id,
+			documentNumber: updated.documentNumber
+		});
+		return updated;
+	}
+	async receiveGroup(id, _payload, ctx) {
+		const group = await this.requireGroup(id, ctx);
+		if (group.status === "done" || group.status === "cancelled" || group.status === "draft") this.assertGroupTransition(group, "done");
+		const moves = await this.movePort.findByGroupId(id, ctx);
+		const committableStatuses = [
+			MoveStatus.draft,
+			MoveStatus.planned,
+			MoveStatus.ready,
+			MoveStatus.partially_done
+		];
+		const virtualSources = buildVirtualSourceTypes(this.virtualLocations);
+		let postedCount = 0;
+		const failedMoves = [];
+		for (const move of moves) {
+			if (!committableStatuses.includes(move.status)) continue;
+			const alreadyDone = move.quantityDone ?? 0;
+			const quantityDone = move.status === MoveStatus.partially_done ? move.quantityPlanned - alreadyDone : alreadyDone || move.quantityPlanned;
+			const isVirtualSource = virtualSources.includes(move.sourceLocationId) || group.groupType === GroupType.return || group.groupType === GroupType.receipt;
+			const hasAllocation = (move.reservationIds?.length ?? 0) > 0;
+			try {
+				await this.postingService.postMove(move._id, {
+					quantityDone,
+					executedAt: /* @__PURE__ */ new Date(),
+					forceAllowNegative: isVirtualSource || hasAllocation
+				}, ctx);
+				postedCount++;
+				if (move.reservationIds?.length) for (const resId of move.reservationIds) await this.releaseReservation(resId, quantityDone, ctx);
+			} catch (err) {
+				failedMoves.push({
+					moveId: move._id,
+					error: err.message,
+					cause: err
+				});
+				if (move.reservationIds?.length) for (const resId of move.reservationIds) try {
+					await this.releaseReservation(resId, 0, ctx);
+				} catch {}
+			}
+		}
+		const committableMoves = moves.filter((m) => committableStatuses.includes(m.status));
+		if (postedCount === 0 && failedMoves.length > 0) {
+			if (failedMoves.length === 1 && failedMoves[0].cause) throw failedMoves[0].cause;
+			throw new Error(`All ${failedMoves.length} moves failed during receive: ${failedMoves.map((f) => `${f.moveId}: ${f.error}`).join("; ")}`);
+		}
+		const allDone = postedCount === committableMoves.length;
+		const finalStatus = allDone ? "done" : "partially_done";
+		const result = await this.moveGroupPort.updateStatus(id, finalStatus, {
+			completedAt: allDone ? /* @__PURE__ */ new Date() : void 0,
+			...failedMoves.length > 0 ? { metadata: {
+				...group.metadata,
+				failedMoves
+			} } : {}
+		});
+		await this.eventEmitter.emit(FlowEvents.TRANSFER_RECEIVED, {
+			organizationId: ctx.organizationId,
+			groupId: result._id,
+			documentNumber: result.documentNumber,
+			partial: !allDone,
+			failedMoves: failedMoves.length > 0 ? failedMoves : void 0
+		});
+		return result;
+	}
+	/**
+	* Consume and release a reservation after its move has been fulfilled.
+	* Consumes the fulfilled quantity, then releases the full reserved amount from the quant.
+	*/
+	async releaseReservation(reservationId, quantityFulfilled, ctx) {
+		const reservation = await this.reservationPort.findById(reservationId, ctx);
+		if (!reservation || reservation.status === "released" || reservation.status === "cancelled") return;
+		await this.unitOfWork.withTransaction(async (session) => {
+			const alreadyConsumed = reservation.quantityConsumed ?? 0;
+			const consumable = reservation.quantity - alreadyConsumed;
+			const consumed = Math.min(quantityFulfilled, consumable);
+			const newConsumedTotal = alreadyConsumed + consumed;
+			const isFullyConsumed = newConsumedTotal >= reservation.quantity;
+			if (consumed > 0) await this.reservationPort.updateStatus(reservationId, isFullyConsumed ? ReservationStatus.consumed : ReservationStatus.partially_consumed, { quantityConsumed: newConsumedTotal }, session);
+			const reservedToRelease = reservation.quantity - alreadyConsumed;
+			if (reservedToRelease > 0) await this.quantPort.upsert({
+				organizationId: ctx.organizationId,
+				skuRef: reservation.skuRef,
+				locationId: reservation.locationId,
+				quantityDelta: 0,
+				reservedDelta: -reservedToRelease,
+				inDate: /* @__PURE__ */ new Date()
+			}, session);
+		});
+	}
+	async cancelGroup(id, ctx) {
+		const group = await this.requireGroup(id, ctx);
+		this.assertGroupTransition(group, "cancelled");
+		const result = await this.unitOfWork.withTransaction(async (session) => {
+			const moves = await this.movePort.findByGroupId(id, ctx, session);
+			for (const move of moves) {
+				if (move.status === MoveStatus.done || move.status === MoveStatus.cancelled) continue;
+				if (move.reservationIds?.length) for (const resId of move.reservationIds) {
+					const reservation = await this.reservationPort.findById(resId, ctx, session);
+					if (reservation && reservation.status === "active") {
+						await this.reservationPort.updateStatus(resId, ReservationStatus.released, { releasedAt: /* @__PURE__ */ new Date() }, session);
+						const remaining = reservation.quantity - (reservation.quantityConsumed ?? 0);
+						if (remaining > 0) await this.quantPort.upsert({
+							organizationId: ctx.organizationId,
+							skuRef: reservation.skuRef,
+							locationId: reservation.locationId,
+							quantityDelta: 0,
+							reservedDelta: -remaining,
+							inDate: /* @__PURE__ */ new Date()
+						}, session);
+					}
+				}
+				await this.movePort.updateStatus(move._id, MoveStatus.cancelled, { cancelledAt: /* @__PURE__ */ new Date() }, session);
+			}
+			return this.moveGroupPort.updateStatus(id, "cancelled", { completedAt: /* @__PURE__ */ new Date() }, session);
+		});
+		await this.eventEmitter.emit(FlowEvents.MOVE_GROUP_CANCELLED, {
+			organizationId: ctx.organizationId,
+			groupId: result._id,
+			documentNumber: result.documentNumber
+		});
+		return result;
+	}
+	async requireGroup(id, ctx) {
+		const group = await this.moveGroupPort.findById(id, ctx);
+		if (!group) throw new MoveGroupNotFoundError(id);
+		return group;
+	}
+	assertGroupTransition(group, target) {
+		if (!MOVE_GROUP_STATUS_TRANSITIONS[group.status].includes(target)) throw new InvalidTransitionError("StockMoveGroup", group._id, group.status, target);
+	}
+};
+//#endregion
+//#region src/services/posting.service.ts
+var PostingService = class {
+	constructor(unitOfWork, movePort, quantPort, eventEmitter, locationPort, runtimeConfig) {
+		this.unitOfWork = unitOfWork;
+		this.movePort = movePort;
+		this.quantPort = quantPort;
+		this.eventEmitter = eventEmitter;
+		this.locationPort = locationPort;
+		this.runtimeConfig = runtimeConfig;
+	}
+	async postMove(moveId, payload, ctx) {
+		assertTenantContext(ctx);
+		if (payload.quantityDone <= 0) throw new ValidationError("quantityDone must be positive");
+		return this.unitOfWork.withTransaction(async (session) => {
+			const move = await this.movePort.findById(moveId, ctx, session);
+			if (!move) throw new Error(`Move ${moveId} not found`);
+			assertMoveTransition(move, MoveStatus.done);
+			const { mode } = this.runtimeConfig;
+			if (mode !== "simple" && this.locationPort && !payload.forceAllowNegative) {
+				const sourceLocation = await this.locationPort.findById(move.sourceLocationId, ctx, session);
+				if (sourceLocation && !sourceLocation.allowNegativeStock) {
+					const availability = await this.quantPort.getAvailability({
+						skuRef: move.skuRef,
+						locationId: move.sourceLocationId
+					}, ctx, session);
+					if (availability.quantityAvailable < payload.quantityDone) throw new NegativeStockError(move.skuRef, move.sourceLocationId, availability.quantityAvailable, payload.quantityDone);
+				}
+			}
+			const executedAt = payload.executedAt ?? /* @__PURE__ */ new Date();
+			const updatedMove = await this.movePort.updateStatus(moveId, MoveStatus.done, {
+				quantityDone: payload.quantityDone,
+				executedAt
+			}, session);
+			const sourceQuant = await this.quantPort.upsert({
+				organizationId: ctx.organizationId,
+				skuRef: move.skuRef,
+				locationId: move.sourceLocationId,
+				quantityDelta: -payload.quantityDone,
+				inDate: executedAt
+			}, session);
+			const destinationQuant = await this.quantPort.upsert({
+				organizationId: ctx.organizationId,
+				skuRef: move.skuRef,
+				locationId: move.destinationLocationId,
+				quantityDelta: payload.quantityDone,
+				inDate: executedAt
+			}, session);
+			await this.eventEmitter.emit(FlowEvents.MOVE_DONE, {
+				organizationId: ctx.organizationId,
+				moveId: updatedMove._id,
+				moveGroupId: updatedMove.moveGroupId,
+				skuRef: updatedMove.skuRef,
+				operationType: updatedMove.operationType,
+				quantityDone: payload.quantityDone,
+				sourceLocationId: updatedMove.sourceLocationId,
+				destinationLocationId: updatedMove.destinationLocationId
+			}, session);
+			return {
+				move: updatedMove,
+				sourceQuant,
+				destinationQuant
+			};
+		});
+	}
+};
+//#endregion
+//#region src/services/quant.service.ts
+var QuantService = class {
+	constructor(quantPort, movePort, _eventEmitter, unitOfWork, locationPort) {
+		this.quantPort = quantPort;
+		this.movePort = movePort;
+		this.unitOfWork = unitOfWork;
+		this.locationPort = locationPort;
+	}
+	async getAvailability(query, ctx) {
+		assertTenantContext(ctx);
+		return this.quantPort.getAvailability(query, ctx);
+	}
+	async getProjectedAvailability(query, ctx) {
+		assertTenantContext(ctx);
+		const current = await this.quantPort.getAvailability(query, ctx);
+		let locationIds;
+		if (query.nodeId && this.locationPort) locationIds = (await this.locationPort.findByNode(query.nodeId, ctx)).map((l) => l._id);
+		const pendingStatuses = { $in: [
+			MoveStatus.draft,
+			MoveStatus.planned,
+			MoveStatus.waiting,
+			MoveStatus.ready
+		] };
+		const incomingFilter = {
+			organizationId: ctx.organizationId,
+			status: pendingStatuses
+		};
+		const outgoingFilter = {
+			organizationId: ctx.organizationId,
+			status: pendingStatuses
+		};
+		if (query.skuRef) {
+			incomingFilter.skuRef = query.skuRef;
+			outgoingFilter.skuRef = query.skuRef;
+		}
+		if (query.locationId) {
+			incomingFilter.destinationLocationId = query.locationId;
+			outgoingFilter.sourceLocationId = query.locationId;
+		} else if (locationIds) {
+			incomingFilter.destinationLocationId = { $in: locationIds };
+			outgoingFilter.sourceLocationId = { $in: locationIds };
+		}
+		if (query.lotId) {
+			incomingFilter["trackingAssignments.lotId"] = query.lotId;
+			outgoingFilter["trackingAssignments.lotId"] = query.lotId;
+		}
+		const [incomingMoves, outgoingMoves] = await Promise.all([this.movePort.findMany(incomingFilter, ctx), this.movePort.findMany(outgoingFilter, ctx)]);
+		const projectedIncoming = incomingMoves.reduce((sum, m) => sum + m.quantityPlanned, 0);
+		const projectedOutgoing = outgoingMoves.reduce((sum, m) => sum + m.quantityPlanned, 0);
+		return {
+			...current,
+			projectedIncoming,
+			projectedOutgoing,
+			projectedAvailable: current.quantityAvailable + projectedIncoming - projectedOutgoing
+		};
+	}
+	async rebuildFromMoveHistory(scope, ctx) {
+		assertTenantContext(ctx);
+		const filter = {
+			organizationId: ctx.organizationId,
+			status: MoveStatus.done
+		};
+		if (scope.skuRef) filter.skuRef = scope.skuRef;
+		if (scope.locationId) filter.$or = [{ sourceLocationId: scope.locationId }, { destinationLocationId: scope.locationId }];
+		const doneMoves = await this.movePort.findMany(filter, ctx);
+		return this.unitOfWork.withTransaction(async (session) => {
+			const currentQuants = await this.quantPort.findMany({ organizationId: ctx.organizationId }, ctx, session);
+			const currentMap = /* @__PURE__ */ new Map();
+			for (const q of currentQuants) currentMap.set(`${q.skuRef}::${q.locationId}`, q.quantityOnHand);
+			await this.quantPort.deleteAll(ctx, session);
+			const rebuilt = /* @__PURE__ */ new Map();
+			for (const move of doneMoves) {
+				const quantityDone = move.quantityDone ?? move.quantityPlanned;
+				const srcKey = `${move.skuRef}::${move.sourceLocationId}`;
+				rebuilt.set(srcKey, (rebuilt.get(srcKey) ?? 0) - quantityDone);
+				const destKey = `${move.skuRef}::${move.destinationLocationId}`;
+				rebuilt.set(destKey, (rebuilt.get(destKey) ?? 0) + quantityDone);
+			}
+			let quantsRebuilt = 0;
+			for (const [key, quantity] of rebuilt) {
+				if (quantity === 0) continue;
+				const [skuRef, locationId] = key.split("::");
+				await this.quantPort.upsert({
+					organizationId: ctx.organizationId,
+					skuRef,
+					locationId,
+					quantityDelta: quantity,
+					inDate: /* @__PURE__ */ new Date()
+				}, session);
+				quantsRebuilt++;
+			}
+			const discrepancies = [];
+			const allKeys = new Set([...currentMap.keys(), ...rebuilt.keys()]);
+			for (const key of allKeys) {
+				const previous = currentMap.get(key) ?? 0;
+				const rebuiltQty = rebuilt.get(key) ?? 0;
+				if (previous !== rebuiltQty) {
+					const [skuRef, locationId] = key.split("::");
+					discrepancies.push({
+						skuRef,
+						locationId,
+						previousOnHand: previous,
+						rebuiltOnHand: rebuiltQty,
+						delta: rebuiltQty - previous
+					});
+				}
+			}
+			return {
+				quantsRebuilt,
+				discrepancies
+			};
+		});
+	}
+};
+//#endregion
+//#region src/services/reservation.service.ts
+var ReservationService = class {
+	constructor(reservationPort, quantPort, unitOfWork, eventEmitter, movePort, idempotency) {
+		this.reservationPort = reservationPort;
+		this.quantPort = quantPort;
+		this.unitOfWork = unitOfWork;
+		this.eventEmitter = eventEmitter;
+		this.movePort = movePort;
+		this.idempotency = idempotency;
+	}
+	async reserve(input, ctx) {
+		assertTenantContext(ctx);
+		if (input.quantity <= 0) throw new ValidationError("quantity must be positive");
+		const scopedKey = ctx.idempotencyKey ? `${ctx.organizationId}:${ctx.idempotencyKey}` : null;
+		if (scopedKey && this.idempotency) {
+			if (this.idempotency.claim) {
+				const claimResult = await this.idempotency.claim(scopedKey);
+				if (claimResult.status === "hit") return claimResult.result;
+				if (claimResult.status === "busy") throw new Error(`Concurrent operation in progress for idempotency key: ${ctx.idempotencyKey}`);
+				try {
+					const result = await this.executeReserve(input, ctx);
+					await this.idempotency?.complete?.(scopedKey, result);
+					return result;
+				} catch (err) {
+					await this.idempotency?.release?.(scopedKey);
+					throw err;
+				}
+			}
+			const cached = await this.idempotency.check(scopedKey);
+			if (cached.hit) return cached.result;
+			const result = await this.executeReserve(input, ctx);
+			await this.idempotency.save(scopedKey, result);
+			return result;
+		}
+		return this.executeReserve(input, ctx);
+	}
+	async executeReserve(input, ctx) {
+		return await this.unitOfWork.withTransaction(async (session) => {
+			const availability = await this.quantPort.getAvailability({
+				skuRef: input.skuRef,
+				locationId: input.locationId
+			}, ctx, session);
+			if (availability.quantityAvailable < input.quantity) throw new InsufficientStockError(input.skuRef, input.quantity, availability.quantityAvailable, input.locationId);
+			const reservation = await this.reservationPort.create({
+				organizationId: ctx.organizationId,
+				reservationType: input.reservationType,
+				ownerType: input.ownerType,
+				ownerId: input.ownerId,
+				skuRef: input.skuRef,
+				locationId: input.locationId,
+				lotId: input.lotId,
+				quantity: input.quantity,
+				expiresAt: input.expiresAt,
+				allocationPolicy: input.allocationPolicy
+			}, session);
+			await this.quantPort.upsert({
+				organizationId: ctx.organizationId,
+				skuRef: input.skuRef,
+				locationId: input.locationId,
+				lotId: input.lotId,
+				quantityDelta: 0,
+				reservedDelta: input.quantity,
+				inDate: /* @__PURE__ */ new Date()
+			}, session);
+			await this.eventEmitter.emit(FlowEvents.RESERVATION_CREATED, {
+				organizationId: ctx.organizationId,
+				reservationId: reservation._id,
+				skuRef: input.skuRef,
+				locationId: input.locationId,
+				quantity: input.quantity,
+				ownerType: input.ownerType,
+				ownerId: input.ownerId
+			}, session);
+			return reservation;
+		});
+	}
+	/**
+	* Bulk-reserve for all move lines in a move group.
+	* Creates one reservation per move line, all within a single transaction.
+	*/
+	async reserveForMoveGroup(moveGroupId, ctx) {
+		assertTenantContext(ctx);
+		if (!this.movePort) throw new Error("MovePort required for reserveForMoveGroup");
+		const moves = await this.movePort.findByGroupId(moveGroupId, ctx);
+		return this.unitOfWork.withTransaction(async (session) => {
+			const reservations = [];
+			for (const move of moves) {
+				if (move.status === "done" || move.status === "cancelled") continue;
+				const reservation = await this._reserveInSession({
+					reservationType: "hard",
+					ownerType: "move_group",
+					ownerId: moveGroupId,
+					skuRef: move.skuRef,
+					locationId: move.sourceLocationId,
+					quantity: move.quantityPlanned
+				}, ctx, session);
+				reservations.push(reservation);
+			}
+			return reservations;
+		});
+	}
+	async _reserveInSession(input, ctx, session) {
+		if (input.quantity <= 0) throw new ValidationError("quantity must be positive");
+		const availability = await this.quantPort.getAvailability({
+			skuRef: input.skuRef,
+			locationId: input.locationId
+		}, ctx, session);
+		if (availability.quantityAvailable < input.quantity) throw new InsufficientStockError(input.skuRef, input.quantity, availability.quantityAvailable, input.locationId);
+		const reservation = await this.reservationPort.create({
+			organizationId: ctx.organizationId,
+			reservationType: input.reservationType,
+			ownerType: input.ownerType,
+			ownerId: input.ownerId,
+			skuRef: input.skuRef,
+			locationId: input.locationId,
+			lotId: input.lotId,
+			quantity: input.quantity,
+			expiresAt: input.expiresAt,
+			allocationPolicy: input.allocationPolicy
+		}, session);
+		await this.quantPort.upsert({
+			organizationId: ctx.organizationId,
+			skuRef: input.skuRef,
+			locationId: input.locationId,
+			lotId: input.lotId,
+			quantityDelta: 0,
+			reservedDelta: input.quantity,
+			inDate: /* @__PURE__ */ new Date()
+		}, session);
+		await this.eventEmitter.emit(FlowEvents.RESERVATION_CREATED, {
+			organizationId: ctx.organizationId,
+			reservationId: reservation._id,
+			skuRef: input.skuRef,
+			locationId: input.locationId,
+			quantity: input.quantity,
+			ownerType: input.ownerType,
+			ownerId: input.ownerId
+		}, session);
+		return reservation;
+	}
+	async release(reservationId, ctx) {
+		assertTenantContext(ctx);
+		return this.unitOfWork.withTransaction(async (session) => {
+			const reservation = await this.reservationPort.findById(reservationId, ctx, session);
+			if (!reservation) throw new ReservationNotFoundError(reservationId);
+			if (reservation.status === ReservationStatus.released || reservation.status === ReservationStatus.cancelled) return reservation;
+			const updated = await this.reservationPort.updateStatus(reservationId, ReservationStatus.released, { releasedAt: /* @__PURE__ */ new Date() }, session);
+			const remainingReserved = reservation.quantity - (reservation.quantityConsumed ?? 0);
+			if (remainingReserved > 0) await this.quantPort.upsert({
+				organizationId: ctx.organizationId,
+				skuRef: reservation.skuRef,
+				locationId: reservation.locationId,
+				lotId: reservation.lotId,
+				quantityDelta: 0,
+				reservedDelta: -remainingReserved,
+				inDate: /* @__PURE__ */ new Date()
+			}, session);
+			await this.eventEmitter.emit(FlowEvents.RESERVATION_RELEASED, {
+				organizationId: ctx.organizationId,
+				reservationId: updated._id,
+				skuRef: updated.skuRef,
+				locationId: updated.locationId,
+				quantity: updated.quantity
+			}, session);
+			return updated;
+		});
+	}
+	async consume(reservationId, quantity, ctx) {
+		assertTenantContext(ctx);
+		if (quantity <= 0) throw new ValidationError("consume quantity must be positive");
+		return this.unitOfWork.withTransaction(async (session) => {
+			const reservation = await this.reservationPort.findById(reservationId, ctx, session);
+			if (!reservation) throw new ReservationNotFoundError(reservationId);
+			if (reservation.status === ReservationStatus.expired || reservation.status === ReservationStatus.cancelled || reservation.status === ReservationStatus.released) throw new ReservationExpiredError(reservationId);
+			const alreadyConsumed = reservation.quantityConsumed ?? 0;
+			const maxConsumable = reservation.quantity - alreadyConsumed;
+			if (maxConsumable <= 0) throw new ValidationError(`Reservation ${reservationId} is already fully consumed`);
+			const actualConsumed = Math.min(quantity, maxConsumable);
+			const newTotal = alreadyConsumed + actualConsumed;
+			const isFullyConsumed = newTotal >= reservation.quantity;
+			if (actualConsumed > 0) await this.quantPort.upsert({
+				organizationId: ctx.organizationId,
+				skuRef: reservation.skuRef,
+				locationId: reservation.locationId,
+				lotId: reservation.lotId,
+				quantityDelta: 0,
+				reservedDelta: -actualConsumed,
+				inDate: /* @__PURE__ */ new Date()
+			}, session);
+			const updated = await this.reservationPort.updateStatus(reservationId, isFullyConsumed ? ReservationStatus.consumed : ReservationStatus.partially_consumed, { quantityConsumed: newTotal }, session);
+			await this.eventEmitter.emit(FlowEvents.RESERVATION_CONSUMED, {
+				organizationId: ctx.organizationId,
+				reservationId: updated._id,
+				skuRef: updated.skuRef,
+				locationId: updated.locationId,
+				quantityConsumed: actualConsumed,
+				totalConsumed: newTotal,
+				isFullyConsumed
+			}, session);
+			return updated;
+		});
+	}
+	async expire(reservationId, ctx) {
+		assertTenantContext(ctx);
+		return this.unitOfWork.withTransaction(async (session) => {
+			const reservation = await this.reservationPort.findById(reservationId, ctx, session);
+			if (!reservation) throw new ReservationNotFoundError(reservationId);
+			const updated = await this.reservationPort.updateStatus(reservationId, ReservationStatus.expired, {}, session);
+			const remaining = reservation.quantity - (reservation.quantityConsumed ?? 0);
+			if (remaining > 0) await this.quantPort.upsert({
+				organizationId: ctx.organizationId,
+				skuRef: reservation.skuRef,
+				locationId: reservation.locationId,
+				lotId: reservation.lotId,
+				quantityDelta: 0,
+				reservedDelta: -remaining,
+				inDate: /* @__PURE__ */ new Date()
+			}, session);
+			await this.eventEmitter.emit(FlowEvents.RESERVATION_RELEASED, {
+				organizationId: ctx.organizationId,
+				reservationId: updated._id,
+				skuRef: updated.skuRef,
+				locationId: updated.locationId,
+				quantity: updated.quantity,
+				reason: "expired"
+			}, session);
+			return updated;
+		});
+	}
+	/**
+	* Cleanup job — find and expire all reservations past their expiresAt.
+	* Call this from a cron job or scheduled worker.
+	*/
+	async cleanupExpired(ctx) {
+		assertTenantContext(ctx);
+		const expiredReservations = await this.reservationPort.findExpired(/* @__PURE__ */ new Date(), ctx);
+		if (expiredReservations.length === 0) return { expired: 0 };
+		await this.unitOfWork.withTransaction(async (session) => {
+			for (const reservation of expiredReservations) {
+				await this.reservationPort.updateStatus(reservation._id, ReservationStatus.expired, {}, session);
+				const remaining = reservation.quantity - (reservation.quantityConsumed ?? 0);
+				if (remaining > 0) await this.quantPort.upsert({
+					organizationId: ctx.organizationId,
+					skuRef: reservation.skuRef,
+					locationId: reservation.locationId,
+					lotId: reservation.lotId,
+					quantityDelta: 0,
+					reservedDelta: -remaining,
+					inDate: /* @__PURE__ */ new Date()
+				}, session);
+			}
+		});
+		for (const reservation of expiredReservations) await this.eventEmitter.emit(FlowEvents.RESERVATION_RELEASED, {
+			organizationId: ctx.organizationId,
+			reservationId: reservation._id,
+			skuRef: reservation.skuRef,
+			locationId: reservation.locationId,
+			quantity: reservation.quantity,
+			reason: "expired"
+		});
+		return { expired: expiredReservations.length };
+	}
+};
+//#endregion
+//#region src/services/scan.service.ts
+var ScanService = class {
+	constructor(locationPort, lotPort, catalogBridge) {
+		this.locationPort = locationPort;
+		this.lotPort = lotPort;
+		this.catalogBridge = catalogBridge;
+	}
+	async resolve(token, ctx) {
+		assertTenantContext(ctx);
+		const trimmed = token.trim();
+		const location = await this.locationPort.findByBarcode(trimmed, ctx);
+		if (location) return {
+			token: trimmed,
+			resolvedType: "location",
+			resolvedId: location._id,
+			resolvedEntity: location
+		};
+		const lot = await this.lotPort.findByCode(trimmed, "", ctx);
+		if (lot) return {
+			token: trimmed,
+			resolvedType: "lot",
+			resolvedId: lot._id,
+			resolvedEntity: lot
+		};
+		const serial = await this.lotPort.findBySerial(trimmed, "", ctx);
+		if (serial) return {
+			token: trimmed,
+			resolvedType: "serial",
+			resolvedId: serial._id,
+			resolvedEntity: serial
+		};
+		const skuDetails = await this.catalogBridge.resolveSku(trimmed);
+		if (skuDetails) return {
+			token: trimmed,
+			resolvedType: "sku",
+			resolvedId: skuDetails.skuRef,
+			resolvedEntity: skuDetails
+		};
+		return {
+			token: trimmed,
+			resolvedType: "unknown",
+			resolvedId: null,
+			resolvedEntity: null
+		};
+	}
+};
+//#endregion
+//#region src/services/index.ts
+function createServices(input) {
+	const { repositories, unitOfWork, eventEmitter, idempotency, catalogBridge, allocationPolicy, getNextSequence } = input;
+	const mode = input.mode ?? "standard";
+	const routing = {
+		putaway: input.routing?.putaway ?? false,
+		removal: input.routing?.removal ?? false,
+		crossDock: input.routing?.crossDock ?? false
+	};
+	const valuation = { method: input.valuation?.method ?? "wac" };
+	const runtimeConfig = createRuntimeConfig(mode, routing, valuation);
+	const virtualLocations = input.virtualLocations ?? resolveVirtualLocations();
+	const posting = new PostingService(unitOfWork, repositories.move, repositories.quant, eventEmitter, repositories.location, runtimeConfig);
+	return {
+		move: new MoveService(repositories.move, posting, unitOfWork, eventEmitter, idempotency),
+		moveGroup: new MoveGroupService(repositories.moveGroup, repositories.move, repositories.quant, repositories.reservation, repositories.location, repositories.node, unitOfWork, eventEmitter, idempotency, catalogBridge, getNextSequence, runtimeConfig, virtualLocations, posting, repositories.procurement),
+		quant: new QuantService(repositories.quant, repositories.move, eventEmitter, unitOfWork, repositories.location),
+		posting,
+		reservation: new ReservationService(repositories.reservation, repositories.quant, unitOfWork, eventEmitter, repositories.move, idempotency),
+		allocation: new AllocationService(repositories.quant, allocationPolicy),
+		scan: new ScanService(repositories.location, repositories.lot, catalogBridge),
+		procurement: new ProcurementService(repositories.procurement, repositories.moveGroup, repositories.move, repositories.quant, unitOfWork, eventEmitter, idempotency, getNextSequence, virtualLocations),
+		replenishment: new ReplenishmentService(repositories.replenishmentRule, repositories.quant, repositories.move, repositories.procurement, eventEmitter, getNextSequence, runtimeConfig),
+		counting: new CountingService(repositories.count, repositories.quant, repositories.move, repositories.moveGroup, unitOfWork, eventEmitter, getNextSequence, runtimeConfig, virtualLocations),
+		package: new PackageService(input.packageModel, repositories.quant),
+		costLayer: new CostLayerService(repositories.costLayer, unitOfWork),
+		trace: new TraceService(repositories.lot, repositories.move, repositories.quant),
+		reporting: {
+			stockAging: new StockAgingReport(repositories.quant),
+			turnover: new TurnoverReport(repositories.quant, repositories.move),
+			availability: new AvailabilityReport(repositories.quant, repositories.location),
+			healthMetrics: new HealthMetricsReport(repositories.quant, repositories.move)
+		},
+		mode,
+		routing,
+		valuation
+	};
+}
+//#endregion
+export { PostingService as a, AllocationService as c, QuantService as i, ScanService as n, MoveGroupService as o, ReservationService as r, MoveService as s, createServices as t };