@classytic/flow 0.1.4

package/dist/replenishment.service-BT9P-HKM.mjs

@@ -0,0 +1,284 @@
+import { h as ValidationError, u as ProcurementNotApprovedError } from "./domain-errors-D7S9ydNF.mjs";
+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";
+import { n as MoveStatus } from "./move-status-DkaFp2GD.mjs";
+//#region src/services/procurement.service.ts
+var ProcurementService = class {
+	constructor(procurementPort, moveGroupPort, movePort, quantPort, unitOfWork, eventEmitter, idempotency, getNextSequence, virtualLocations) {
+		this.procurementPort = procurementPort;
+		this.moveGroupPort = moveGroupPort;
+		this.movePort = movePort;
+		this.quantPort = quantPort;
+		this.unitOfWork = unitOfWork;
+		this.eventEmitter = eventEmitter;
+		this.idempotency = idempotency;
+		this.getNextSequence = getNextSequence;
+		this.virtualLocations = virtualLocations;
+	}
+	async create(input, ctx) {
+		assertTenantContext(ctx);
+		if (!input.items || input.items.length === 0) throw new ValidationError("Procurement order must have at least one item");
+		const orderNumber = formatDocumentNumber("PO", await this.getNextSequence("PO", ctx.organizationId));
+		return this.procurementPort.create({
+			organizationId: ctx.organizationId,
+			orderNumber,
+			vendorRef: input.vendorRef,
+			destinationNodeId: input.destinationNodeId,
+			destinationLocationId: input.destinationLocationId,
+			status: "draft",
+			items: input.items.map((item) => ({
+				skuRef: item.skuRef,
+				quantity: item.quantity,
+				quantityReceived: 0,
+				unitCost: item.unitCost,
+				expectedAt: item.expectedAt
+			})),
+			expectedAt: input.items[0]?.expectedAt,
+			sourceDemandRefs: input.sourceDemandRefs,
+			createdBy: ctx.actorId,
+			metadata: input.metadata
+		});
+	}
+	async getById(orderId, ctx) {
+		assertTenantContext(ctx);
+		return this.procurementPort.findById(orderId, ctx);
+	}
+	async list(query, ctx) {
+		assertTenantContext(ctx);
+		return this.procurementPort.list(query, ctx);
+	}
+	async approve(orderId, ctx) {
+		assertTenantContext(ctx);
+		const order = await this.requireOrder(orderId, ctx);
+		if (order.status !== "draft") throw new ValidationError(`Cannot approve order in status: ${order.status}`);
+		return this.procurementPort.updateStatus(orderId, "approved", {});
+	}
+	async receive(orderId, 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.executeReceive(orderId, 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.executeReceive(orderId, payload, ctx);
+			await this.idempotency.save(scopedKey, result);
+			return result;
+		}
+		return this.executeReceive(orderId, payload, ctx);
+	}
+	async executeReceive(orderId, payload, ctx) {
+		const order = await this.requireOrder(orderId, ctx);
+		if (![
+			"approved",
+			"ordered",
+			"partially_received"
+		].includes(order.status)) throw new ProcurementNotApprovedError(orderId);
+		for (const line of payload.lines) {
+			if (line.quantityReceived <= 0) throw new ValidationError(`quantityReceived must be positive for ${line.skuRef}`);
+			const orderItem = order.items.find((i) => i.skuRef === line.skuRef);
+			if (orderItem) {
+				if (orderItem.quantityReceived + line.quantityReceived > orderItem.quantity * 1.1) throw new ValidationError(`Over-receipt: ${line.skuRef} would exceed ordered quantity by more than 10%`);
+			}
+		}
+		return await this.unitOfWork.withTransaction(async (session) => {
+			const receivedAt = payload.receivedAt ?? /* @__PURE__ */ new Date();
+			const docNumber = formatDocumentNumber("RCV", await this.getNextSequence("RCV", ctx.organizationId));
+			const moveGroup = await this.moveGroupPort.create({
+				organizationId: ctx.organizationId,
+				groupType: "receipt",
+				documentNumber: docNumber,
+				destinationNodeId: order.destinationNodeId,
+				counterparty: {
+					type: "vendor",
+					id: order.vendorRef
+				},
+				createdBy: ctx.actorId
+			}, session);
+			for (const line of payload.lines) {
+				const orderItem = order.items.find((i) => i.skuRef === line.skuRef);
+				if (!orderItem) continue;
+				const move = await this.movePort.create({
+					moveGroupId: moveGroup._id,
+					operationType: "receipt",
+					skuRef: line.skuRef,
+					sourceLocationId: this.virtualLocations.vendor,
+					destinationLocationId: order.destinationLocationId ?? order.destinationNodeId,
+					quantityPlanned: line.quantityReceived,
+					organizationId: ctx.organizationId,
+					createdBy: ctx.actorId,
+					metadata: {
+						procurementOrderId: orderId,
+						unitCost: line.unitCost ?? orderItem.unitCost
+					}
+				}, session);
+				await this.movePort.updateStatus(move._id, MoveStatus.done, {
+					quantityDone: line.quantityReceived,
+					executedAt: receivedAt
+				}, session);
+				await this.quantPort.upsert({
+					organizationId: ctx.organizationId,
+					skuRef: line.skuRef,
+					locationId: order.destinationLocationId ?? order.destinationNodeId,
+					quantityDelta: line.quantityReceived,
+					inDate: receivedAt,
+					unitCost: line.unitCost ?? orderItem.unitCost
+				}, session);
+			}
+			const updatedItems = order.items.map((item) => {
+				const receiveLine = payload.lines.find((l) => l.skuRef === item.skuRef);
+				return {
+					...item,
+					quantityReceived: item.quantityReceived + (receiveLine?.quantityReceived ?? 0)
+				};
+			});
+			const allReceived = updatedItems.every((item) => item.quantityReceived >= item.quantity);
+			const newStatus = allReceived ? "received" : "partially_received";
+			const updated = await this.procurementPort.updateStatus(orderId, newStatus, {
+				items: updatedItems,
+				receivedAt: allReceived ? receivedAt : void 0
+			}, session);
+			await this.eventEmitter.emit(FlowEvents.PROCUREMENT_RECEIVED, {
+				organizationId: ctx.organizationId,
+				orderId: updated._id,
+				orderNumber: updated.orderNumber,
+				vendorRef: updated.vendorRef,
+				destinationNodeId: updated.destinationNodeId,
+				itemCount: payload.lines.length
+			}, session);
+			return updated;
+		});
+	}
+	async cancel(orderId, ctx) {
+		assertTenantContext(ctx);
+		if ((await this.requireOrder(orderId, ctx)).status === "received") throw new ValidationError("Cannot cancel a fully received procurement order");
+		return this.procurementPort.updateStatus(orderId, "cancelled", {});
+	}
+	async requireOrder(orderId, ctx) {
+		const order = await this.procurementPort.findById(orderId, ctx);
+		if (!order) throw new ValidationError(`Procurement order ${orderId} not found`);
+		return order;
+	}
+};
+//#endregion
+//#region src/services/replenishment.service.ts
+var ReplenishmentService = class {
+	constructor(rulePort, quantPort, movePort, procurementPort, eventEmitter, getNextSequence, runtimeConfig) {
+		this.rulePort = rulePort;
+		this.quantPort = quantPort;
+		this.movePort = movePort;
+		this.procurementPort = procurementPort;
+		this.eventEmitter = eventEmitter;
+		this.getNextSequence = getNextSequence;
+		this.runtimeConfig = runtimeConfig;
+	}
+	async evaluateRules(scope, ctx) {
+		requireStandardMode(this.runtimeConfig, "Replenishment");
+		assertTenantContext(ctx);
+		let rules;
+		if (scope.skuRef) rules = await this.rulePort.findBySkuRef(scope.skuRef, ctx);
+		else if (scope.nodeId) rules = await this.rulePort.findByNode(scope.nodeId, ctx);
+		else rules = await this.rulePort.list(ctx);
+		const triggers = [];
+		for (const rule of rules) {
+			if (!rule.enabled) continue;
+			const availability = await this.quantPort.getAvailability({
+				skuRef: rule.skuRef,
+				locationId: rule.locationId
+			}, ctx);
+			const incoming = (await this.movePort.findMany({
+				organizationId: ctx.organizationId,
+				skuRef: rule.skuRef,
+				destinationLocationId: rule.locationId,
+				status: { $in: [
+					"draft",
+					"planned",
+					"waiting",
+					"ready"
+				] }
+			}, ctx)).reduce((sum, m) => sum + m.quantityPlanned, 0);
+			const outgoing = (await this.movePort.findMany({
+				organizationId: ctx.organizationId,
+				skuRef: rule.skuRef,
+				sourceLocationId: rule.locationId,
+				status: { $in: [
+					"draft",
+					"planned",
+					"waiting",
+					"ready"
+				] }
+			}, ctx)).reduce((sum, m) => sum + m.quantityPlanned, 0);
+			const projected = availability.quantityOnHand + incoming - outgoing;
+			if (projected <= rule.reorderPoint) {
+				let needed = rule.targetLevel - projected;
+				if (rule.minOrderQty && needed < rule.minOrderQty) needed = rule.minOrderQty;
+				if (rule.multipleOf && rule.multipleOf > 1) needed = Math.ceil(needed / rule.multipleOf) * rule.multipleOf;
+				if (rule.maxOrderQty && needed > rule.maxOrderQty) needed = rule.maxOrderQty;
+				triggers.push({
+					ruleId: rule._id,
+					skuRef: rule.skuRef,
+					locationId: rule.locationId ?? rule.scopeRef,
+					currentLevel: projected,
+					reorderPoint: rule.reorderPoint,
+					targetLevel: rule.targetLevel,
+					suggestedQty: needed,
+					preferredSourceType: rule.preferredSourceType,
+					preferredSourceRef: rule.preferredSourceRef
+				});
+			}
+		}
+		return { triggers };
+	}
+	async generateDemand(evaluation, ctx) {
+		assertTenantContext(ctx);
+		const orders = [];
+		const vendorGroups = /* @__PURE__ */ new Map();
+		for (const trigger of evaluation.triggers) {
+			const key = trigger.preferredSourceRef ?? "default_vendor";
+			if (!vendorGroups.has(key)) vendorGroups.set(key, []);
+			vendorGroups.get(key)?.push(trigger);
+		}
+		for (const [vendorRef, triggers] of vendorGroups) {
+			const orderNumber = formatDocumentNumber("PO", await this.getNextSequence("PO", ctx.organizationId));
+			const order = await this.procurementPort.create({
+				organizationId: ctx.organizationId,
+				orderNumber,
+				vendorRef,
+				destinationNodeId: triggers[0].locationId,
+				status: "draft",
+				items: triggers.map((t) => ({
+					skuRef: t.skuRef,
+					quantity: t.suggestedQty,
+					quantityReceived: 0,
+					unitCost: 0
+				})),
+				sourceDemandRefs: triggers.map((t) => t.ruleId),
+				createdBy: ctx.actorId
+			});
+			orders.push(order);
+			for (const trigger of triggers) await this.eventEmitter.emit(FlowEvents.REPLENISHMENT_TRIGGERED, {
+				organizationId: ctx.organizationId,
+				ruleId: trigger.ruleId,
+				skuRef: trigger.skuRef,
+				currentLevel: trigger.currentLevel,
+				reorderPoint: trigger.reorderPoint,
+				suggestedQty: trigger.suggestedQty
+			});
+		}
+		return orders;
+	}
+};
+//#endregion
+export { ProcurementService as n, ReplenishmentService as t };

package/dist/replenishment.service-HO0sDhB_.d.mts

@@ -0,0 +1,89 @@
+import { n as VirtualLocationMap } from "./virtual-locations-B9zXqPdi.mjs";
+import { n as MovePort } from "./move.port-Qg1CYp7h.mjs";
+import { i as PaginatedResult, r as ListQuery, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { a as ProcurementOrder, n as ProcurementPort, t as ReplenishmentRulePort } from "./replenishment-rule.port-DnEYtbyD.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";
+import { t as IdempotencyPort } from "./idempotency.port-CTC70JON.mjs";
+
+//#region src/services/procurement.service.d.ts
+interface CreateProcurementInput {
+  vendorRef: string;
+  destinationNodeId: string;
+  destinationLocationId?: string;
+  items: Array<{
+    skuRef: string;
+    quantity: number;
+    unitCost: number;
+    expectedAt?: Date;
+  }>;
+  sourceDemandRefs?: string[];
+  metadata?: Record<string, unknown>;
+}
+interface ReceivePayload {
+  lines: Array<{
+    skuRef: string;
+    quantityReceived: number;
+    lotCode?: string;
+    unitCost?: number;
+  }>;
+  receivedAt?: Date;
+}
+declare class ProcurementService {
+  private procurementPort;
+  private moveGroupPort;
+  private movePort;
+  private quantPort;
+  private unitOfWork;
+  private eventEmitter;
+  private idempotency;
+  private getNextSequence;
+  private virtualLocations;
+  constructor(procurementPort: ProcurementPort, moveGroupPort: MoveGroupPort, movePort: MovePort, quantPort: QuantPort, unitOfWork: UnitOfWork, eventEmitter: EventEmitterPort, idempotency: IdempotencyPort | null, getNextSequence: (prefix: string, organizationId: string) => Promise<number>, virtualLocations: VirtualLocationMap);
+  create(input: CreateProcurementInput, ctx: FlowContext): Promise<ProcurementOrder>;
+  getById(orderId: string, ctx: FlowContext): Promise<ProcurementOrder | null>;
+  list(query: ListQuery, ctx: FlowContext): Promise<PaginatedResult<ProcurementOrder>>;
+  approve(orderId: string, ctx: FlowContext): Promise<ProcurementOrder>;
+  receive(orderId: string, payload: ReceivePayload, ctx: FlowContext): Promise<ProcurementOrder>;
+  private executeReceive;
+  cancel(orderId: string, ctx: FlowContext): Promise<ProcurementOrder>;
+  private requireOrder;
+}
+//#endregion
+//#region src/services/replenishment.service.d.ts
+interface ReplenishmentScope {
+  nodeId?: string;
+  skuRef?: string;
+  mode?: 'scheduled' | 'emergency';
+}
+interface ReplenishmentTrigger {
+  ruleId: string;
+  skuRef: string;
+  locationId: string;
+  currentLevel: number;
+  reorderPoint: number;
+  targetLevel: number;
+  suggestedQty: number;
+  preferredSourceType?: string;
+  preferredSourceRef?: string;
+}
+interface ReplenishmentEvaluation {
+  triggers: ReplenishmentTrigger[];
+}
+declare class ReplenishmentService {
+  private rulePort;
+  private quantPort;
+  private movePort;
+  private procurementPort;
+  private eventEmitter;
+  private getNextSequence;
+  private runtimeConfig;
+  constructor(rulePort: ReplenishmentRulePort, quantPort: QuantPort, movePort: MovePort, procurementPort: ProcurementPort, eventEmitter: EventEmitterPort, getNextSequence: (prefix: string, organizationId: string) => Promise<number>, runtimeConfig: RuntimeConfig);
+  evaluateRules(scope: ReplenishmentScope, ctx: FlowContext): Promise<ReplenishmentEvaluation>;
+  generateDemand(evaluation: ReplenishmentEvaluation, ctx: FlowContext): Promise<ProcurementOrder[]>;
+}
+//#endregion
+export { CreateProcurementInput as a, ReplenishmentTrigger as i, ReplenishmentScope as n, ProcurementService as o, ReplenishmentService as r, ReceivePayload as s, ReplenishmentEvaluation as t };

package/dist/reporting/index.d.mts

@@ -0,0 +1,2 @@
+import { a as StockAgingResult, c as AvailabilityMatrixQuery, i as StockAgingReport, l as AvailabilityMatrixResult, n as TurnoverResult, o as HealthMetricsReport, r as AgingBucket, s as StockHealthMetrics, t as TurnoverReport, u as AvailabilityReport } from "../index-BmNm3oNU2.mjs";
+export { AgingBucket, AvailabilityMatrixQuery, AvailabilityMatrixResult, AvailabilityReport, HealthMetricsReport, StockAgingReport, StockAgingResult, StockHealthMetrics, TurnoverReport, TurnoverResult };

package/dist/reporting/index.mjs

@@ -0,0 +1,2 @@
+import { i as AvailabilityReport, n as StockAgingReport, r as HealthMetricsReport, t as TurnoverReport } from "../reporting-CL5ffrKM.mjs";
+export { AvailabilityReport, HealthMetricsReport, StockAgingReport, TurnoverReport };

package/dist/reporting-CL5ffrKM.mjs

@@ -0,0 +1,243 @@
+import { t as assertTenantContext } from "./tenant-guard-6Ne-BILP.mjs";
+//#region src/reporting/availability.ts
+var AvailabilityReport = class {
+	constructor(quantPort, locationPort) {
+		this.quantPort = quantPort;
+		this.locationPort = locationPort;
+	}
+	async getMatrix(query, ctx) {
+		assertTenantContext(ctx);
+		const matrix = [];
+		if (query.nodeIds && query.nodeIds.length > 0) for (const skuRef of query.skuRefs) {
+			const nodes = [];
+			let totalOnHand = 0;
+			let totalAvailable = 0;
+			for (const nodeId of query.nodeIds) {
+				const availability = await this.quantPort.getAvailability({
+					skuRef,
+					nodeId
+				}, ctx);
+				nodes.push({
+					nodeId,
+					onHand: availability.quantityOnHand,
+					reserved: availability.quantityReserved,
+					available: availability.quantityAvailable,
+					incoming: availability.quantityIncoming,
+					outgoing: availability.quantityOutgoing
+				});
+				totalOnHand += availability.quantityOnHand;
+				totalAvailable += availability.quantityAvailable;
+			}
+			matrix.push({
+				skuRef,
+				nodes,
+				totalOnHand,
+				totalAvailable
+			});
+		}
+		else for (const skuRef of query.skuRefs) {
+			const availability = await this.quantPort.getAvailability({ skuRef }, ctx);
+			const nodeGroups = /* @__PURE__ */ new Map();
+			for (const breakdown of availability.breakdowns) {
+				let nodeId = "unknown";
+				if (this.locationPort) {
+					const loc = await this.locationPort.findById(breakdown.locationId, ctx);
+					if (loc) nodeId = loc.nodeId;
+				}
+				const existing = nodeGroups.get(nodeId) ?? {
+					onHand: 0,
+					reserved: 0,
+					available: 0,
+					incoming: 0,
+					outgoing: 0
+				};
+				existing.onHand += breakdown.quantityOnHand;
+				existing.reserved += breakdown.quantityReserved;
+				existing.available += breakdown.quantityAvailable;
+				existing.incoming += breakdown.quantityIncoming ?? 0;
+				existing.outgoing += breakdown.quantityOutgoing ?? 0;
+				nodeGroups.set(nodeId, existing);
+			}
+			if (nodeGroups.size === 0) nodeGroups.set("all", {
+				onHand: availability.quantityOnHand,
+				reserved: availability.quantityReserved,
+				available: availability.quantityAvailable,
+				incoming: availability.quantityIncoming,
+				outgoing: availability.quantityOutgoing
+			});
+			const nodes = [...nodeGroups.entries()].map(([nodeId, data]) => ({
+				nodeId,
+				...data
+			}));
+			matrix.push({
+				skuRef,
+				nodes,
+				totalOnHand: availability.quantityOnHand,
+				totalAvailable: availability.quantityAvailable
+			});
+		}
+		return { matrix };
+	}
+};
+//#endregion
+//#region src/reporting/health-metrics.ts
+var HealthMetricsReport = class {
+	constructor(quantPort, _movePort) {
+		this.quantPort = quantPort;
+	}
+	async generate(ctx) {
+		assertTenantContext(ctx);
+		const withStock = (await this.quantPort.findMany({ organizationId: ctx.organizationId }, ctx)).filter((q) => q.quantityOnHand > 0);
+		const totalOnHand = withStock.reduce((s, q) => s + q.quantityOnHand, 0);
+		const totalValue = withStock.reduce((s, q) => s + q.quantityOnHand * (q.unitCost ?? 0), 0);
+		const uniqueSkus = new Set(withStock.map((q) => q.skuRef));
+		const now = /* @__PURE__ */ new Date();
+		const yearAgo = /* @__PURE__ */ new Date(now.getTime() - 365 * 864e5);
+		const deadStockValue = withStock.filter((q) => {
+			const lastMove = q.lastMovementAt ?? q.inDate;
+			return new Date(lastMove).getTime() < yearAgo.getTime();
+		}).reduce((s, q) => s + q.quantityOnHand * (q.unitCost ?? 0), 0);
+		const thirtyDaysOut = new Date(now.getTime() + 30 * 864e5);
+		const expiryRiskValue = withStock.filter((q) => q.lotExpiresAt && new Date(q.lotExpiresAt).getTime() < thirtyDaysOut.getTime()).reduce((s, q) => s + q.quantityOnHand * (q.unitCost ?? 0), 0);
+		return {
+			turnoverRate: 0,
+			daysOfInventory: 0,
+			stockoutRate: 0,
+			fillRate: 0,
+			deadStockPercentage: totalValue > 0 ? Math.round(deadStockValue / totalValue * 1e4) / 100 : 0,
+			expiryRiskValue: Math.round(expiryRiskValue * 100) / 100,
+			totalSkus: uniqueSkus.size,
+			totalOnHand,
+			totalValue: Math.round(totalValue * 100) / 100
+		};
+	}
+};
+//#endregion
+//#region src/reporting/stock-aging.ts
+const BUCKET_RANGES = [
+	{
+		label: "0-30 days",
+		minDays: 0,
+		maxDays: 30
+	},
+	{
+		label: "31-60 days",
+		minDays: 31,
+		maxDays: 60
+	},
+	{
+		label: "61-90 days",
+		minDays: 61,
+		maxDays: 90
+	},
+	{
+		label: "91-180 days",
+		minDays: 91,
+		maxDays: 180
+	},
+	{
+		label: "181-365 days",
+		minDays: 181,
+		maxDays: 365
+	},
+	{
+		label: "365+ days",
+		minDays: 366,
+		maxDays: Infinity
+	}
+];
+var StockAgingReport = class {
+	constructor(quantPort) {
+		this.quantPort = quantPort;
+	}
+	async generate(ctx, nodeId) {
+		assertTenantContext(ctx);
+		const now = /* @__PURE__ */ new Date();
+		const quants = await this.quantPort.findMany({
+			organizationId: ctx.organizationId,
+			...nodeId ? { nodeId } : {},
+			quantityOnHand: { $gt: 0 }
+		}, ctx);
+		const buckets = BUCKET_RANGES.map((r) => ({
+			...r,
+			quantity: 0,
+			value: 0,
+			skuCount: 0
+		}));
+		const slowMoving = [];
+		const deadStock = [];
+		for (const q of quants) {
+			const lastMove = q.lastMovementAt ?? q.inDate;
+			const ageDays = Math.floor((now.getTime() - new Date(lastMove).getTime()) / 864e5);
+			const value = q.quantityOnHand * (q.unitCost ?? 0);
+			const bucket = buckets.find((b) => ageDays >= b.minDays && ageDays <= b.maxDays);
+			if (bucket) {
+				bucket.quantity += q.quantityOnHand;
+				bucket.value += value;
+				bucket.skuCount++;
+			}
+			if (ageDays > 90) slowMoving.push({
+				skuRef: q.skuRef,
+				locationId: q.locationId,
+				quantity: q.quantityOnHand,
+				ageDays
+			});
+			if (ageDays > 365) deadStock.push({
+				skuRef: q.skuRef,
+				locationId: q.locationId,
+				quantity: q.quantityOnHand,
+				ageDays
+			});
+		}
+		return {
+			asOfDate: now,
+			buckets,
+			slowMoving,
+			deadStock
+		};
+	}
+};
+//#endregion
+//#region src/reporting/turnover.ts
+var TurnoverReport = class {
+	constructor(quantPort, movePort) {
+		this.quantPort = quantPort;
+		this.movePort = movePort;
+	}
+	async generate(periodDays, ctx) {
+		assertTenantContext(ctx);
+		const end = /* @__PURE__ */ new Date();
+		const start = /* @__PURE__ */ new Date(end.getTime() - periodDays * 864e5);
+		const totalCOGS = (await this.movePort.findMany({
+			organizationId: ctx.organizationId,
+			operationType: "shipment",
+			status: "done",
+			executedAt: {
+				$gte: start,
+				$lte: end
+			}
+		}, ctx)).reduce((sum, m) => {
+			const cost = m.metadata?.unitCost ?? 0;
+			return sum + (m.quantityDone ?? 0) * cost;
+		}, 0);
+		const averageInventoryValue = (await this.quantPort.findMany({
+			organizationId: ctx.organizationId,
+			quantityOnHand: { $gt: 0 }
+		}, ctx)).reduce((sum, q) => sum + q.quantityOnHand * (q.unitCost ?? 0), 0);
+		const turnoverRate = averageInventoryValue > 0 ? totalCOGS / averageInventoryValue : 0;
+		const daysOfInventory = turnoverRate > 0 ? 365 / turnoverRate : Infinity;
+		return {
+			period: {
+				start,
+				end
+			},
+			totalCOGS,
+			averageInventoryValue,
+			turnoverRate: Math.round(turnoverRate * 100) / 100,
+			daysOfInventory: Math.round(daysOfInventory),
+			skuBreakdown: []
+		};
+	}
+};
+//#endregion
+export { AvailabilityReport as i, StockAgingReport as n, HealthMetricsReport as r, TurnoverReport as t };

package/dist/repositories/index.d.mts

@@ -0,0 +1,2 @@
+import { _ as CountRepository, a as extractDocs, c as ReservationRepository, d as ProcurementRepository, f as NodeRepository, g as LocationRepository, h as LotRepository, i as asOffsetResult, l as ReplenishmentRuleRepository, m as MoveRepository, n as RepositoryPlugins, o as toOrgId, p as MoveGroupRepository, r as createRepositories, s as toSession, t as FlowRepositories, u as QuantRepository, v as CostLayerRepository } from "../index-C5PciI9P.mjs";
+export { CostLayerRepository, CountRepository, FlowRepositories, LocationRepository, LotRepository, MoveGroupRepository, MoveRepository, NodeRepository, ProcurementRepository, QuantRepository, ReplenishmentRuleRepository, RepositoryPlugins, ReservationRepository, asOffsetResult, createRepositories, extractDocs, toOrgId, toSession };

package/dist/repositories/index.mjs

@@ -0,0 +1,2 @@
+import { a as ProcurementRepository, c as MoveRepository, d as CountRepository, f as CostLayerRepository, g as toSession, h as toOrgId, i as QuantRepository, l as LotRepository, m as extractDocs, n as ReservationRepository, o as NodeRepository, p as asOffsetResult, r as ReplenishmentRuleRepository, s as MoveGroupRepository, t as createRepositories, u as LocationRepository } from "../repositories-nZXJKvLW.mjs";
+export { CostLayerRepository, CountRepository, LocationRepository, LotRepository, MoveGroupRepository, MoveRepository, NodeRepository, ProcurementRepository, QuantRepository, ReplenishmentRuleRepository, ReservationRepository, asOffsetResult, createRepositories, extractDocs, toOrgId, toSession };