@classytic/flow 0.1.4

package/dist/reservation-status-ZfuTaWG0.mjs

@@ -0,0 +1,22 @@
+//#region src/domain/enums/group-type.ts
+const GroupType = {
+	receipt: "receipt",
+	transfer: "transfer",
+	shipment: "shipment",
+	return: "return",
+	adjustment: "adjustment",
+	pick_wave: "pick_wave",
+	count_reconciliation: "count_reconciliation"
+};
+//#endregion
+//#region src/domain/enums/reservation-status.ts
+const ReservationStatus = {
+	active: "active",
+	partially_consumed: "partially_consumed",
+	consumed: "consumed",
+	released: "released",
+	expired: "expired",
+	cancelled: "cancelled"
+};
+//#endregion
+export { GroupType as n, ReservationStatus as t };

package/dist/reservation.port-l9NFQ0si.d.mts

@@ -0,0 +1,85 @@
+import { a as ReservationStatus } from "./index-CulWO137.mjs";
+import { t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/entities/inventory-node.d.ts
+interface Address {
+  street?: string;
+  city?: string;
+  state?: string;
+  postalCode?: string;
+  country?: string;
+  coordinates?: {
+    lat: number;
+    lng: number;
+  };
+}
+interface InventoryNode {
+  _id: string;
+  organizationId: string;
+  code: string;
+  name: string;
+  type: string;
+  status: 'active' | 'inactive';
+  timezone?: string;
+  currency?: string;
+  address?: Address;
+  capabilities?: string[];
+  isDefault?: boolean;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/entities/reservation.d.ts
+interface Reservation {
+  _id: string;
+  organizationId: string;
+  reservationType: 'soft' | 'hard';
+  ownerType: string;
+  ownerId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  quantity: number;
+  quantityConsumed?: number;
+  status: ReservationStatus;
+  expiresAt?: Date;
+  allocationPolicy?: string;
+  createdBy?: string;
+  createdAt?: Date;
+  releasedAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/ports/node.port.d.ts
+interface NodePort {
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<InventoryNode | null>;
+  findDefault(ctx: FlowContext, session?: TransactionSession): Promise<InventoryNode | null>;
+  list(ctx: FlowContext, session?: TransactionSession): Promise<InventoryNode[]>;
+  create(input: Omit<InventoryNode, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<InventoryNode>;
+  update(id: string, updates: Partial<InventoryNode>, ctx: FlowContext, session?: TransactionSession): Promise<InventoryNode>;
+}
+//#endregion
+//#region src/domain/ports/reservation.port.d.ts
+interface CreateReservationInput {
+  organizationId: string;
+  reservationType: 'soft' | 'hard';
+  ownerType: string;
+  ownerId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  quantity: number;
+  expiresAt?: Date;
+  allocationPolicy?: string;
+}
+interface ReservationPort {
+  create(input: CreateReservationInput, session?: TransactionSession): Promise<Reservation>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<Reservation | null>;
+  findByOwner(ownerType: string, ownerId: string, ctx: FlowContext, session?: TransactionSession): Promise<Reservation[]>;
+  updateStatus(id: string, status: ReservationStatus, updates: Partial<Reservation>, session?: TransactionSession): Promise<Reservation>;
+  findExpired(asOf: Date, ctx: FlowContext, session?: TransactionSession): Promise<Reservation[]>;
+}
+//#endregion
+export { Address as a, Reservation as i, ReservationPort as n, InventoryNode as o, NodePort as r, CreateReservationInput as t };

package/dist/reservations/index.d.mts

@@ -0,0 +1,2 @@
+import { a as FefoStrategy, i as allocateFromSorted, n as LifoStrategy, o as ExactLotStrategy, r as FifoStrategy, t as NearestStrategy } from "../index-Bia4m8d2.mjs";
+export { ExactLotStrategy, FefoStrategy, FifoStrategy, LifoStrategy, NearestStrategy, allocateFromSorted };

package/dist/reservations/index.mjs

@@ -0,0 +1,2 @@
+import { a as FifoStrategy, i as FefoStrategy, n as ExactLotStrategy, o as allocateFromSorted, r as LifoStrategy, t as NearestStrategy } from "../reservations-Cg4wN0QB.mjs";
+export { ExactLotStrategy, FefoStrategy, FifoStrategy, LifoStrategy, NearestStrategy, allocateFromSorted };

package/dist/reservations-Cg4wN0QB.mjs

@@ -0,0 +1,112 @@
+//#region src/reservations/fifo.strategy.ts
+/**
+* FIFO allocation — consume oldest stock first (by inDate).
+* Default strategy for most operations.
+*/
+var FifoStrategy = class {
+	name = "fifo";
+	resolve(_skuRef, quantity, candidates) {
+		return allocateFromSorted([...candidates].sort((a, b) => new Date(a.inDate).getTime() - new Date(b.inDate).getTime()), quantity);
+	}
+};
+/**
+* Shared allocation logic — iterates sorted candidates and picks until quantity is met.
+* Used by all strategies after sorting.
+*/
+function allocateFromSorted(sorted, quantity) {
+	const allocations = [];
+	let remaining = quantity;
+	for (const q of sorted) {
+		if (remaining <= 0) break;
+		const available = q.quantityOnHand - q.quantityReserved;
+		if (available <= 0) continue;
+		const take = Math.min(available, remaining);
+		allocations.push({
+			quantId: q._id,
+			locationId: q.locationId,
+			lotId: q.lotId,
+			quantity: take
+		});
+		remaining -= take;
+	}
+	return {
+		fulfilled: remaining <= 0,
+		allocations,
+		shortfall: Math.max(0, remaining)
+	};
+}
+//#endregion
+//#region src/reservations/fefo.strategy.ts
+/**
+* FEFO allocation — consume nearest-expiry stock first.
+* Requires quants to carry lot expiry info. Quants without expiry sort last.
+*
+* Used for perishable goods: food, pharma, cosmetics.
+*/
+var FefoStrategy = class {
+	name = "fefo";
+	constructor(minShelfLifeDays) {
+		this.minShelfLifeDays = minShelfLifeDays;
+	}
+	resolve(_skuRef, quantity, candidates) {
+		let eligible = candidates;
+		if (this.minShelfLifeDays != null) {
+			const threshold = new Date(Date.now() + this.minShelfLifeDays * 864e5);
+			eligible = candidates.filter((q) => !q.lotExpiresAt || new Date(q.lotExpiresAt).getTime() > threshold.getTime());
+		}
+		return allocateFromSorted([...eligible].sort((a, b) => {
+			return (a.lotExpiresAt ? new Date(a.lotExpiresAt).getTime() : Number.POSITIVE_INFINITY) - (b.lotExpiresAt ? new Date(b.lotExpiresAt).getTime() : Number.POSITIVE_INFINITY);
+		}), quantity);
+	}
+};
+//#endregion
+//#region src/reservations/lifo.strategy.ts
+/**
+* LIFO allocation — consume newest stock first (by inDate DESC).
+* Useful when freshness matters less and you want to keep oldest stock for auditing.
+*/
+var LifoStrategy = class {
+	name = "lifo";
+	resolve(_skuRef, quantity, candidates) {
+		return allocateFromSorted([...candidates].sort((a, b) => new Date(b.inDate).getTime() - new Date(a.inDate).getTime()), quantity);
+	}
+};
+//#endregion
+//#region src/reservations/exact-lot.strategy.ts
+/**
+* Exact-lot allocation — only allocate from a specific lot.
+* Used when a customer or regulation requires a specific batch.
+*/
+var ExactLotStrategy = class {
+	name = "exact_lot";
+	constructor(targetLotId) {
+		this.targetLotId = targetLotId;
+	}
+	resolve(_skuRef, quantity, candidates) {
+		const filtered = candidates.filter((q) => q.lotId === this.targetLotId);
+		if (filtered.length === 0) return {
+			fulfilled: false,
+			allocations: [],
+			shortfall: quantity
+		};
+		return allocateFromSorted([...filtered].sort((a, b) => new Date(a.inDate).getTime() - new Date(b.inDate).getTime()), quantity);
+	}
+};
+//#endregion
+//#region src/reservations/nearest.strategy.ts
+/**
+* Nearest allocation — consume stock closest to pick face (by location sortOrder ASC).
+* Minimizes warehouse travel distance.
+*
+* Requires quants to carry locationSortOrder (set by repository join or denormalized).
+*/
+var NearestStrategy = class {
+	name = "nearest";
+	resolve(_skuRef, quantity, candidates) {
+		return allocateFromSorted([...candidates].sort((a, b) => {
+			return (a.locationSortOrder ?? Number.MAX_SAFE_INTEGER) - (b.locationSortOrder ?? Number.MAX_SAFE_INTEGER);
+		}), quantity);
+	}
+};
+//#endregion
+export { FifoStrategy as a, FefoStrategy as i, ExactLotStrategy as n, allocateFromSorted as o, LifoStrategy as r, NearestStrategy as t };

package/dist/routing/index.d.mts

@@ -0,0 +1,362 @@
+import { n as MovePort, r as StockMove } from "../move.port-Qg1CYp7h.mjs";
+import { t as FlowContext } from "../index-DFF0GJ4J.mjs";
+import { n as Location, t as LocationPort } from "../location.port-CValXIpb.mjs";
+import { n as StockQuant } from "../stock-quant-CZhgvTu7.mjs";
+import { r as QuantPort } from "../quant.port-BBa66PBT.mjs";
+import { n as AllocationResult } from "../allocation-policy-my_HfzdV.mjs";
+import { n as PutawayPolicy, t as RemovalPolicy } from "../removal-policy-BItBB8FD.mjs";
+
+//#region src/routing/cross-dock.engine.d.ts
+/**
+ * Per-destination cross-dock assignment.
+ * Each assignment maps exact quantities to exact shipping destinations.
+ */
+interface CrossDockAssignment {
+  destinationLocationId: string;
+  quantity: number;
+  moveIds: string[];
+}
+/**
+ * Cross-dock evaluation result with multi-destination routing.
+ */
+interface CrossDockResult {
+  hasDemand: boolean;
+  demandQuantity: number;
+  crossDockQuantity: number;
+  remainingToStorage: number;
+  /** Per-destination assignments (replaces single crossDockDestination) */
+  assignments: CrossDockAssignment[];
+  /** @deprecated Use assignments[0].destinationLocationId — kept for backward compat */
+  crossDockDestination: string | null;
+  waitingMoveIds: string[];
+}
+/**
+ * Cross-Dock Engine
+ *
+ * Evaluates whether incoming stock should bypass storage and route directly
+ * to shipping destinations. Supports multi-destination routing:
+ *
+ *   Normal:     Receive → Storage → Pick → Pack → Ship
+ *   Cross-dock: Receive → Ship-Dock-1 (15 units for Order A)
+ *                       → Ship-Dock-2 (10 units for Order B)
+ *                       → Storage (remaining 5 units)
+ */
+declare class CrossDockEngine {
+  private movePort;
+  constructor(movePort: MovePort, _quantPort: QuantPort);
+  evaluate(skuRef: string, incomingQuantity: number, _nodeId: string, ctx: FlowContext): Promise<CrossDockResult>;
+}
+//#endregion
+//#region src/routing/putaway.engine.d.ts
+/**
+ * Putaway engine — resolves where received goods should be stored.
+ * Tries registered strategies in priority order, then falls back to default.
+ */
+declare class PutawayEngine {
+  private defaultLocationResolver;
+  private strategies;
+  constructor(_locationPort: LocationPort, defaultLocationResolver: (nodeId: string, ctx: FlowContext) => Promise<string | null>);
+  registerStrategy(strategy: PutawayPolicy): void;
+  resolve(skuRef: string, quantity: number, nodeId: string, context: {
+    lotId?: string;
+    vendorRef?: string;
+    skuCategory?: string;
+  }, ctx: FlowContext): Promise<{
+    locationId: string;
+  }>;
+}
+//#endregion
+//#region src/routing/removal.engine.d.ts
+/**
+ * Removal engine — delegates stock removal decisions to a RemovalPolicy.
+ */
+declare class RemovalEngine {
+  private defaultPolicy;
+  constructor(defaultPolicy: RemovalPolicy);
+  resolve(skuRef: string, quantity: number, candidates: StockQuant[]): AllocationResult;
+}
+//#endregion
+//#region src/routing/route-expander.d.ts
+interface RouteStep {
+  sourceLocationType: string;
+  destinationLocationType: string;
+  operationType: string;
+}
+interface RouteTemplate {
+  name: string;
+  steps: RouteStep[];
+}
+interface RouteConfig {
+  receptionSteps: 1 | 2 | 3;
+  deliverySteps: 1 | 2 | 3;
+  customRoutes?: RouteTemplate[];
+}
+interface ExpandedRoute {
+  steps: Array<{
+    sourceLocationId: string;
+    destinationLocationId: string;
+    operationType: string;
+    sequence: number;
+  }>;
+}
+/**
+ * Interface for resolving location types to actual location IDs.
+ * Consumer provides this — typically queries Location by (nodeId, type).
+ */
+interface LocationResolver {
+  resolveByType(nodeId: string, locationType: string): Promise<string>;
+}
+declare class RouteExpander {
+  private config;
+  private customRoutes;
+  constructor(config?: RouteConfig);
+  /**
+   * Register a custom route template.
+   */
+  registerRoute(route: RouteTemplate): void;
+  /**
+   * Expand a high-level operation into planned move steps.
+   * Resolves location types to actual location IDs using the LocationResolver.
+   *
+   * Route matching priority (6-level resolution):
+   * 1. Demand-specific routes (options.routeId) — highest
+   * 2. Packaging/UoM routes
+   * 3. SKU-specific routes
+   * 4. SKU category routes
+   * 5. Node/warehouse routes
+   * 6. Operation type default route — lowest
+   */
+  expand(operationType: 'receipt' | 'shipment' | 'transfer', nodeId: string, locations: LocationResolver, options?: {
+    skuRef?: string;
+    routeId?: string;
+  }): Promise<ExpandedRoute>;
+  /**
+   * Get the default route template based on operation type and configured step count.
+   *
+   * Complexity modes:
+   * - One-step: ship (small shop)
+   * - Two-step: pick → ship (standard warehouse)
+   * - Three-step: pick → pack → ship (e-commerce fulfillment)
+   *
+   * Cross-dock (transfer): receive → ship (bypass storage)
+   */
+  getDefaultTemplate(operationType: 'receipt' | 'shipment' | 'transfer'): RouteStep[];
+  /**
+   * Auto-generated reception routes per warehouse:
+   *   one_step:    [vendor → stock]
+   *   two_steps:   [vendor → input, input → stock]
+   *   three_steps: [vendor → input, input → qc, qc → stock]
+   */
+  private getReceptionTemplate;
+  /**
+   * Auto-generated delivery routes per warehouse:
+   *   one_step:    [stock → customer]
+   *   two_steps:   [stock → shipping, shipping → customer]
+   *   three_steps: [stock → packing, packing → shipping, shipping → customer]
+   */
+  private getDeliveryTemplate;
+  /**
+   * Resolve location type references to actual location IDs.
+   */
+  private resolveSteps;
+}
+//#endregion
+//#region src/routing/strategies/abc-velocity.strategy.d.ts
+type VelocityClass = 'A' | 'B' | 'C';
+interface AbcZoneMapping {
+  A: string;
+  B: string;
+  C: string;
+}
+/**
+ * ABC-velocity putaway strategy.
+ * Classifies SKUs by velocity (A/B/C) and routes to appropriate zones.
+ * A-items go near dock (low sortOrder), C-items go far back.
+ */
+declare class AbcVelocityStrategy implements PutawayPolicy {
+  private velocityClassifier;
+  private zoneMappings;
+  readonly name = "abc_velocity";
+  constructor(velocityClassifier: (skuRef: string) => VelocityClass, zoneMappings: AbcZoneMapping);
+  resolve(skuRef: string, _quantity: number, _nodeId: string, _context: {
+    lotId?: string;
+    vendorRef?: string;
+    skuCategory?: string;
+  }): Promise<{
+    locationId: string;
+  } | null>;
+}
+//#endregion
+//#region src/routing/strategies/category-zone.strategy.d.ts
+/**
+ * Category-zone putaway strategy.
+ * Routes goods to zones based on their SKU category.
+ */
+declare class CategoryZoneStrategy implements PutawayPolicy {
+  private categoryZoneMap;
+  readonly name = "category_zone";
+  constructor(categoryZoneMap: Map<string, string>);
+  resolve(_skuRef: string, _quantity: number, _nodeId: string, context: {
+    lotId?: string;
+    vendorRef?: string;
+    skuCategory?: string;
+  }): Promise<{
+    locationId: string;
+  } | null>;
+}
+//#endregion
+//#region src/routing/strategies/closest-to-pick.strategy.d.ts
+/**
+ * Closest-to-pick putaway strategy.
+ * Selects the storage location with the lowest sortOrder (closest to pick face)
+ * that has remaining capacity.
+ */
+declare class ClosestToPickStrategy implements PutawayPolicy {
+  private locationPort;
+  private ctx;
+  readonly name = "closest_to_pick";
+  constructor(locationPort: LocationPort, ctx: FlowContext);
+  resolve(_skuRef: string, quantity: number, nodeId: string, _context: {
+    lotId?: string;
+    vendorRef?: string;
+    skuCategory?: string;
+  }): Promise<{
+    locationId: string;
+  } | null>;
+}
+//#endregion
+//#region src/routing/strategies/empty-bin.strategy.d.ts
+/**
+ * Empty-bin putaway strategy.
+ * Finds the first storage location in the node that has zero quants.
+ */
+declare class EmptyBinStrategy implements PutawayPolicy {
+  private locationPort;
+  private quantPort;
+  private ctx;
+  readonly name = "empty_bin";
+  constructor(locationPort: LocationPort, quantPort: QuantPort, ctx: FlowContext);
+  resolve(_skuRef: string, _quantity: number, nodeId: string, _context: {
+    lotId?: string;
+    vendorRef?: string;
+    skuCategory?: string;
+  }): Promise<{
+    locationId: string;
+  } | null>;
+}
+//#endregion
+//#region src/routing/strategies/fixed-location.strategy.d.ts
+/**
+ * Fixed-location putaway strategy.
+ * Maps specific SKUs to predetermined storage locations.
+ */
+declare class FixedLocationStrategy implements PutawayPolicy {
+  private skuLocationMap;
+  readonly name = "fixed_location";
+  constructor(skuLocationMap: Map<string, string>);
+  resolve(skuRef: string, _quantity: number, _nodeId: string, _context: {
+    lotId?: string;
+    vendorRef?: string;
+    skuCategory?: string;
+  }): Promise<{
+    locationId: string;
+  } | null>;
+}
+//#endregion
+//#region src/routing/wave.engine.d.ts
+interface ConsolidatedPick {
+  skuRef: string;
+  locationId: string;
+  totalQuantity: number;
+  moveIds: string[];
+  sortKey: string;
+}
+interface WaveSummary {
+  totalMoves: number;
+  totalQuantity: number;
+  uniqueLocations: number;
+  uniqueSkus: number;
+}
+/** Cart constraint for sub-wave batching */
+interface CartConstraints {
+  maxWeight?: number;
+  maxVolume?: number;
+  maxItems?: number;
+}
+/** A single cart-load (sub-wave) */
+interface CartBatch {
+  picks: ConsolidatedPick[];
+  totalWeight: number;
+  totalVolume: number;
+  totalItems: number;
+}
+/**
+ * Wave Engine — production-grade pick-path optimization.
+ *
+ * Two sorting modes:
+ * 1. **sortOrder** (simple) — single integer, works for small warehouses
+ * 2. **coordinates** (3D) — zone/aisle/bay/level/bin tuple, serpentine path for large fulfillment centers
+ *
+ * Also supports:
+ * - Location consolidation (merge picks for same SKU at same bin)
+ * - Weight/volume/item batching (split into cart-sized sub-waves with pick splitting)
+ * - Wave summary for display
+ */
+declare class WaveEngine {
+  /**
+   * Sort moves by location for optimal pick path.
+   * Uses 3D coordinates if available, falls back to sortOrder.
+   * Does not mutate input.
+   */
+  optimizePickPath(moves: StockMove[], locationMap?: Map<string, Location>): StockMove[];
+  /**
+   * Consolidate moves for same SKU at same location into single pick lines.
+   */
+  consolidateByLocation(moves: StockMove[], locationMap?: Map<string, Location>): ConsolidatedPick[];
+  /**
+   * Split a consolidated pick list into cart-sized batches.
+   * Each batch respects weight, volume, and item count constraints.
+   * Oversized picks are split across multiple carts — no quantity is lost.
+   */
+  batchIntoCarts(picks: ConsolidatedPick[], constraints: CartConstraints, skuWeights?: Map<string, number>, skuVolumes?: Map<string, number>): CartBatch[];
+  /**
+   * Create a summary of the wave.
+   */
+  createWaveSummary(moves: StockMove[]): WaveSummary;
+  /**
+   * Build a lexicographic sort key from location coordinates or metadata.
+   *
+   * Uses boustrophedon (serpentine/ox-plow) traversal for 3D coordinates:
+   * - Odd aisles: bays ascending  (1→2→3→…)
+   * - Even aisles: bays descending (…→3→2→1)
+   * This eliminates dead-walking back to the front of each aisle.
+   */
+  private buildSortKey;
+  private buildCoordinateSortKey;
+  private buildMetadataSortKey;
+  private padSortOrder;
+  private createEmptyBatch;
+  private addPickToBatch;
+  private wouldExceedConstraints;
+  /**
+   * Flush the current batch, optionally fitting a partial quantity first.
+   * Item-count overflow skips partial fitting (the constraint is on lines, not units).
+   */
+  private flushAndFillPartial;
+  /**
+   * Recalculate remaining quantity for a pick after batches have been flushed.
+   */
+  private recalculateRemaining;
+  /**
+   * Calculate how many units fit in the cart. Returns `wanted` if no
+   * weight/volume constraints apply (item-count-only or unconstrained).
+   */
+  private calculateFittingQuantity;
+  /**
+   * Maximum units that fit in the remaining cart capacity by weight/volume.
+   * Returns 0 if even 1 unit won't fit.
+   */
+  private maxFittingUnits;
+}
+//#endregion
+export { AbcVelocityStrategy, type AbcZoneMapping, CategoryZoneStrategy, ClosestToPickStrategy, type ConsolidatedPick, type CrossDockAssignment, CrossDockEngine, type CrossDockResult, EmptyBinStrategy, type ExpandedRoute, FixedLocationStrategy, type LocationResolver, PutawayEngine, RemovalEngine, type RouteConfig, RouteExpander, type RouteStep, type RouteTemplate, type VelocityClass, WaveEngine, type WaveSummary };