@classytic/flow 0.1.4

package/dist/routing/index.mjs

@@ -0,0 +1,582 @@
+//#region src/routing/cross-dock.engine.ts
+/**
+* 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)
+*/
+var CrossDockEngine = class {
+	constructor(movePort, _quantPort) {
+		this.movePort = movePort;
+	}
+	async evaluate(skuRef, incomingQuantity, _nodeId, ctx) {
+		const allMoves = await this.movePort.findMany({
+			skuRef,
+			operationType: "shipment"
+		}, ctx);
+		const waitingStatuses = new Set([
+			"draft",
+			"planned",
+			"ready",
+			"waiting"
+		]);
+		const waitingMoves = allMoves.filter((m) => waitingStatuses.has(m.status) && m.quantityPlanned > (m.quantityDone ?? 0)).sort((a, b) => new Date(a.createdAt ?? 0).getTime() - new Date(b.createdAt ?? 0).getTime());
+		if (waitingMoves.length === 0) return {
+			hasDemand: false,
+			demandQuantity: 0,
+			crossDockQuantity: 0,
+			remainingToStorage: incomingQuantity,
+			assignments: [],
+			crossDockDestination: null,
+			waitingMoveIds: []
+		};
+		const assignmentMap = /* @__PURE__ */ new Map();
+		let remaining = incomingQuantity;
+		const allWaitingIds = [];
+		for (const move of waitingMoves) {
+			if (remaining <= 0) break;
+			const needed = move.quantityPlanned - (move.quantityDone ?? 0);
+			const assigned = Math.min(needed, remaining);
+			remaining -= assigned;
+			allWaitingIds.push(move._id);
+			const dest = move.destinationLocationId;
+			const existing = assignmentMap.get(dest);
+			if (existing) {
+				existing.quantity += assigned;
+				existing.moveIds.push(move._id);
+			} else assignmentMap.set(dest, {
+				destinationLocationId: dest,
+				quantity: assigned,
+				moveIds: [move._id]
+			});
+		}
+		const assignments = [...assignmentMap.values()];
+		const crossDockQuantity = incomingQuantity - remaining;
+		return {
+			hasDemand: true,
+			demandQuantity: waitingMoves.reduce((sum, m) => sum + (m.quantityPlanned - (m.quantityDone ?? 0)), 0),
+			crossDockQuantity,
+			remainingToStorage: remaining,
+			assignments,
+			crossDockDestination: assignments[0]?.destinationLocationId ?? null,
+			waitingMoveIds: allWaitingIds
+		};
+	}
+};
+//#endregion
+//#region src/routing/putaway.engine.ts
+/**
+* Putaway engine — resolves where received goods should be stored.
+* Tries registered strategies in priority order, then falls back to default.
+*/
+var PutawayEngine = class {
+	strategies = [];
+	constructor(_locationPort, defaultLocationResolver) {
+		this.defaultLocationResolver = defaultLocationResolver;
+	}
+	registerStrategy(strategy) {
+		this.strategies.push(strategy);
+	}
+	async resolve(skuRef, quantity, nodeId, context, ctx) {
+		for (const strategy of this.strategies) {
+			const result = await strategy.resolve(skuRef, quantity, nodeId, context);
+			if (result) return result;
+		}
+		const defaultLoc = await this.defaultLocationResolver(nodeId, ctx);
+		if (defaultLoc) return { locationId: defaultLoc };
+		throw new Error(`No putaway location resolved for ${skuRef} at node ${nodeId}`);
+	}
+};
+//#endregion
+//#region src/routing/removal.engine.ts
+/**
+* Removal engine — delegates stock removal decisions to a RemovalPolicy.
+*/
+var RemovalEngine = class {
+	constructor(defaultPolicy) {
+		this.defaultPolicy = defaultPolicy;
+	}
+	resolve(skuRef, quantity, candidates) {
+		return this.defaultPolicy.resolve(skuRef, quantity, candidates);
+	}
+};
+//#endregion
+//#region src/routing/route-expander.ts
+var RouteExpander = class {
+	customRoutes = [];
+	constructor(config = {
+		receptionSteps: 1,
+		deliverySteps: 1
+	}) {
+		this.config = config;
+		this.customRoutes = config.customRoutes ?? [];
+	}
+	/**
+	* Register a custom route template.
+	*/
+	registerRoute(route) {
+		this.customRoutes.push(route);
+	}
+	/**
+	* 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
+	*/
+	async expand(operationType, nodeId, locations, options) {
+		if (options?.routeId) {
+			const custom = this.customRoutes.find((r) => r.name === options.routeId);
+			if (custom) return this.resolveSteps(custom.steps, nodeId, locations);
+		}
+		const template = this.getDefaultTemplate(operationType);
+		return this.resolveSteps(template, nodeId, locations);
+	}
+	/**
+	* 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) {
+		switch (operationType) {
+			case "receipt": return this.getReceptionTemplate();
+			case "shipment": return this.getDeliveryTemplate();
+			case "transfer": return [{
+				sourceLocationType: "storage",
+				destinationLocationType: "storage",
+				operationType: "transfer"
+			}];
+			default: return [{
+				sourceLocationType: "storage",
+				destinationLocationType: "storage",
+				operationType
+			}];
+		}
+	}
+	/**
+	* Auto-generated reception routes per warehouse:
+	*   one_step:    [vendor → stock]
+	*   two_steps:   [vendor → input, input → stock]
+	*   three_steps: [vendor → input, input → qc, qc → stock]
+	*/
+	getReceptionTemplate() {
+		switch (this.config.receptionSteps) {
+			case 1: return [{
+				sourceLocationType: "vendor",
+				destinationLocationType: "storage",
+				operationType: "receipt"
+			}];
+			case 2: return [{
+				sourceLocationType: "vendor",
+				destinationLocationType: "receiving",
+				operationType: "receipt"
+			}, {
+				sourceLocationType: "receiving",
+				destinationLocationType: "storage",
+				operationType: "transfer"
+			}];
+			case 3: return [
+				{
+					sourceLocationType: "vendor",
+					destinationLocationType: "receiving",
+					operationType: "receipt"
+				},
+				{
+					sourceLocationType: "receiving",
+					destinationLocationType: "quality_hold",
+					operationType: "transfer"
+				},
+				{
+					sourceLocationType: "quality_hold",
+					destinationLocationType: "storage",
+					operationType: "transfer"
+				}
+			];
+			default: return [{
+				sourceLocationType: "vendor",
+				destinationLocationType: "storage",
+				operationType: "receipt"
+			}];
+		}
+	}
+	/**
+	* Auto-generated delivery routes per warehouse:
+	*   one_step:    [stock → customer]
+	*   two_steps:   [stock → shipping, shipping → customer]
+	*   three_steps: [stock → packing, packing → shipping, shipping → customer]
+	*/
+	getDeliveryTemplate() {
+		switch (this.config.deliverySteps) {
+			case 1: return [{
+				sourceLocationType: "storage",
+				destinationLocationType: "customer",
+				operationType: "shipment"
+			}];
+			case 2: return [{
+				sourceLocationType: "storage",
+				destinationLocationType: "shipping",
+				operationType: "shipment"
+			}, {
+				sourceLocationType: "shipping",
+				destinationLocationType: "customer",
+				operationType: "shipment"
+			}];
+			case 3: return [
+				{
+					sourceLocationType: "storage",
+					destinationLocationType: "packing",
+					operationType: "shipment"
+				},
+				{
+					sourceLocationType: "packing",
+					destinationLocationType: "shipping",
+					operationType: "shipment"
+				},
+				{
+					sourceLocationType: "shipping",
+					destinationLocationType: "customer",
+					operationType: "shipment"
+				}
+			];
+			default: return [{
+				sourceLocationType: "storage",
+				destinationLocationType: "customer",
+				operationType: "shipment"
+			}];
+		}
+	}
+	/**
+	* Resolve location type references to actual location IDs.
+	*/
+	async resolveSteps(steps, nodeId, resolver) {
+		const resolved = [];
+		for (let i = 0; i < steps.length; i++) {
+			const step = steps[i];
+			const sourceId = await resolver.resolveByType(nodeId, step.sourceLocationType);
+			const destId = await resolver.resolveByType(nodeId, step.destinationLocationType);
+			resolved.push({
+				sourceLocationId: sourceId,
+				destinationLocationId: destId,
+				operationType: step.operationType,
+				sequence: i + 1
+			});
+		}
+		return { steps: resolved };
+	}
+};
+//#endregion
+//#region src/routing/strategies/abc-velocity.strategy.ts
+/**
+* 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.
+*/
+var AbcVelocityStrategy = class {
+	name = "abc_velocity";
+	constructor(velocityClassifier, zoneMappings) {
+		this.velocityClassifier = velocityClassifier;
+		this.zoneMappings = zoneMappings;
+	}
+	async resolve(skuRef, _quantity, _nodeId, _context) {
+		const velocityClass = this.velocityClassifier(skuRef);
+		const locationId = this.zoneMappings[velocityClass];
+		return locationId ? { locationId } : null;
+	}
+};
+//#endregion
+//#region src/routing/strategies/category-zone.strategy.ts
+/**
+* Category-zone putaway strategy.
+* Routes goods to zones based on their SKU category.
+*/
+var CategoryZoneStrategy = class {
+	name = "category_zone";
+	constructor(categoryZoneMap) {
+		this.categoryZoneMap = categoryZoneMap;
+	}
+	async resolve(_skuRef, _quantity, _nodeId, context) {
+		if (!context.skuCategory) return null;
+		const locationId = this.categoryZoneMap.get(context.skuCategory);
+		return locationId ? { locationId } : null;
+	}
+};
+//#endregion
+//#region src/routing/strategies/closest-to-pick.strategy.ts
+/**
+* Closest-to-pick putaway strategy.
+* Selects the storage location with the lowest sortOrder (closest to pick face)
+* that has remaining capacity.
+*/
+var ClosestToPickStrategy = class {
+	name = "closest_to_pick";
+	constructor(locationPort, ctx) {
+		this.locationPort = locationPort;
+		this.ctx = ctx;
+	}
+	async resolve(_skuRef, quantity, nodeId, _context) {
+		const storageLocs = (await this.locationPort.findByNode(nodeId, this.ctx)).filter((loc) => loc.type === "storage" && loc.status === "active");
+		for (const loc of storageLocs) {
+			if (loc.capacity !== void 0 && quantity > loc.capacity) continue;
+			return { locationId: loc._id };
+		}
+		return null;
+	}
+};
+//#endregion
+//#region src/routing/strategies/empty-bin.strategy.ts
+/**
+* Empty-bin putaway strategy.
+* Finds the first storage location in the node that has zero quants.
+*/
+var EmptyBinStrategy = class {
+	name = "empty_bin";
+	constructor(locationPort, quantPort, ctx) {
+		this.locationPort = locationPort;
+		this.quantPort = quantPort;
+		this.ctx = ctx;
+	}
+	async resolve(_skuRef, _quantity, nodeId, _context) {
+		const storageLocs = (await this.locationPort.findByNode(nodeId, this.ctx)).filter((loc) => loc.type === "storage" && loc.status === "active");
+		for (const loc of storageLocs) if ((await this.quantPort.getAvailability({ locationId: loc._id }, this.ctx)).quantityOnHand === 0) return { locationId: loc._id };
+		return null;
+	}
+};
+//#endregion
+//#region src/routing/strategies/fixed-location.strategy.ts
+/**
+* Fixed-location putaway strategy.
+* Maps specific SKUs to predetermined storage locations.
+*/
+var FixedLocationStrategy = class {
+	name = "fixed_location";
+	constructor(skuLocationMap) {
+		this.skuLocationMap = skuLocationMap;
+	}
+	async resolve(skuRef, _quantity, _nodeId, _context) {
+		const locationId = this.skuLocationMap.get(skuRef);
+		return locationId ? { locationId } : null;
+	}
+};
+//#endregion
+//#region src/routing/wave.engine.ts
+const DEFAULT_ZONE = "ZZ";
+const DEFAULT_BIN = "ZZ";
+const DEFAULT_AISLE = 999;
+const DEFAULT_BAY = 999;
+const DEFAULT_LEVEL = 9;
+const BAY_INVERSION_BASE = 1e3;
+/**
+* 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
+*/
+var WaveEngine = class {
+	/**
+	* Sort moves by location for optimal pick path.
+	* Uses 3D coordinates if available, falls back to sortOrder.
+	* Does not mutate input.
+	*/
+	optimizePickPath(moves, locationMap) {
+		return [...moves].sort((a, b) => {
+			const sortKeyA = this.buildSortKey(a, locationMap);
+			const sortKeyB = this.buildSortKey(b, locationMap);
+			return sortKeyA.localeCompare(sortKeyB);
+		});
+	}
+	/**
+	* Consolidate moves for same SKU at same location into single pick lines.
+	*/
+	consolidateByLocation(moves, locationMap) {
+		const picksByKey = /* @__PURE__ */ new Map();
+		for (const move of moves) {
+			const key = `${move.skuRef}::${move.sourceLocationId}`;
+			const existing = picksByKey.get(key);
+			if (existing) {
+				existing.totalQuantity += move.quantityPlanned;
+				existing.moveIds.push(move._id);
+			} else picksByKey.set(key, {
+				skuRef: move.skuRef,
+				locationId: move.sourceLocationId,
+				totalQuantity: move.quantityPlanned,
+				moveIds: [move._id],
+				sortKey: this.buildSortKey(move, locationMap)
+			});
+		}
+		return [...picksByKey.values()].sort((a, b) => a.sortKey.localeCompare(b.sortKey));
+	}
+	/**
+	* 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, constraints, skuWeights, skuVolumes) {
+		const batches = [];
+		let currentBatch = this.createEmptyBatch();
+		for (const pick of picks) {
+			const unitWeight = skuWeights?.get(pick.skuRef) ?? 0;
+			const unitVolume = skuVolumes?.get(pick.skuRef) ?? 0;
+			let remainingQuantity = pick.totalQuantity;
+			while (remainingQuantity > 0) {
+				if (this.wouldExceedConstraints(remainingQuantity, unitWeight, unitVolume, currentBatch, constraints)) {
+					if (currentBatch.picks.length > 0) {
+						currentBatch = this.flushAndFillPartial(pick, remainingQuantity, unitWeight, unitVolume, currentBatch, constraints, batches);
+						remainingQuantity = this.recalculateRemaining(pick, batches, currentBatch);
+						continue;
+					}
+				}
+				const quantityForThisBatch = this.calculateFittingQuantity(remainingQuantity, unitWeight, unitVolume, currentBatch, constraints);
+				this.addPickToBatch(currentBatch, pick, quantityForThisBatch, unitWeight, unitVolume);
+				remainingQuantity -= quantityForThisBatch;
+				if (remainingQuantity > 0) {
+					batches.push(currentBatch);
+					currentBatch = this.createEmptyBatch();
+				}
+			}
+		}
+		if (currentBatch.picks.length > 0) batches.push(currentBatch);
+		return batches;
+	}
+	/**
+	* Create a summary of the wave.
+	*/
+	createWaveSummary(moves) {
+		const locations = /* @__PURE__ */ new Set();
+		const skus = /* @__PURE__ */ new Set();
+		let totalQuantity = 0;
+		for (const move of moves) {
+			locations.add(move.sourceLocationId);
+			skus.add(move.skuRef);
+			totalQuantity += move.quantityPlanned;
+		}
+		return {
+			totalMoves: moves.length,
+			totalQuantity,
+			uniqueLocations: locations.size,
+			uniqueSkus: skus.size
+		};
+	}
+	/**
+	* 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.
+	*/
+	buildSortKey(move, locationMap) {
+		if (locationMap) {
+			const location = locationMap.get(move.sourceLocationId);
+			if (location?.coordinates) return this.buildCoordinateSortKey(location.coordinates);
+			if (location?.sortOrder !== void 0) return this.padSortOrder(location.sortOrder);
+		}
+		return this.buildMetadataSortKey(move);
+	}
+	buildCoordinateSortKey(coords) {
+		const aisle = coords.aisle ?? DEFAULT_AISLE;
+		const bay = coords.bay ?? DEFAULT_BAY;
+		const effectiveBay = aisle % 2 === 0 ? BAY_INVERSION_BASE - bay : bay;
+		return [
+			coords.zone ?? DEFAULT_ZONE,
+			String(aisle).padStart(3, "0"),
+			String(effectiveBay).padStart(3, "0"),
+			String(coords.level ?? DEFAULT_LEVEL).padStart(1, "0"),
+			coords.bin ?? DEFAULT_BIN
+		].join("-");
+	}
+	buildMetadataSortKey(move) {
+		const sortOrder = move.metadata?.locationSortOrder ?? Number.MAX_SAFE_INTEGER;
+		return this.padSortOrder(sortOrder);
+	}
+	padSortOrder(value) {
+		return String(value).padStart(10, "0");
+	}
+	createEmptyBatch() {
+		return {
+			picks: [],
+			totalWeight: 0,
+			totalVolume: 0,
+			totalItems: 0
+		};
+	}
+	addPickToBatch(batch, pick, quantity, unitWeight, unitVolume) {
+		batch.picks.push({
+			...pick,
+			totalQuantity: quantity
+		});
+		batch.totalWeight += unitWeight * quantity;
+		batch.totalVolume += unitVolume * quantity;
+		batch.totalItems += 1;
+	}
+	wouldExceedConstraints(quantity, unitWeight, unitVolume, batch, constraints) {
+		const totalWeight = unitWeight * quantity;
+		const totalVolume = unitVolume * quantity;
+		return !!(constraints.maxWeight && batch.totalWeight + totalWeight > constraints.maxWeight || constraints.maxVolume && batch.totalVolume + totalVolume > constraints.maxVolume || constraints.maxItems && batch.totalItems + 1 > constraints.maxItems);
+	}
+	/**
+	* Flush the current batch, optionally fitting a partial quantity first.
+	* Item-count overflow skips partial fitting (the constraint is on lines, not units).
+	*/
+	flushAndFillPartial(pick, remainingQuantity, unitWeight, unitVolume, currentBatch, constraints, batches) {
+		if (!!!(constraints.maxItems && currentBatch.totalItems + 1 > constraints.maxItems)) {
+			const partialQuantity = this.maxFittingUnits(remainingQuantity, unitWeight, unitVolume, currentBatch, constraints);
+			if (partialQuantity > 0) this.addPickToBatch(currentBatch, pick, partialQuantity, unitWeight, unitVolume);
+		}
+		batches.push(currentBatch);
+		return this.createEmptyBatch();
+	}
+	/**
+	* Recalculate remaining quantity for a pick after batches have been flushed.
+	*/
+	recalculateRemaining(pick, batches, currentBatch) {
+		const alreadyBatched = [...batches, currentBatch].reduce((sum, batch) => sum + batch.picks.filter((p) => p.skuRef === pick.skuRef && p.locationId === pick.locationId).reduce((s, p) => s + p.totalQuantity, 0), 0);
+		return pick.totalQuantity - alreadyBatched;
+	}
+	/**
+	* Calculate how many units fit in the cart. Returns `wanted` if no
+	* weight/volume constraints apply (item-count-only or unconstrained).
+	*/
+	calculateFittingQuantity(wanted, unitWeight, unitVolume, batch, constraints) {
+		const maxByPhysics = this.maxFittingUnits(wanted, unitWeight, unitVolume, batch, constraints);
+		return maxByPhysics > 0 ? maxByPhysics : wanted;
+	}
+	/**
+	* Maximum units that fit in the remaining cart capacity by weight/volume.
+	* Returns 0 if even 1 unit won't fit.
+	*/
+	maxFittingUnits(wanted, unitWeight, unitVolume, batch, constraints) {
+		let max = wanted;
+		if (constraints.maxWeight && unitWeight > 0) {
+			const capacityLeft = constraints.maxWeight - batch.totalWeight;
+			max = Math.min(max, Math.floor(capacityLeft / unitWeight));
+		}
+		if (constraints.maxVolume && unitVolume > 0) {
+			const capacityLeft = constraints.maxVolume - batch.totalVolume;
+			max = Math.min(max, Math.floor(capacityLeft / unitVolume));
+		}
+		return Math.max(0, max);
+	}
+};
+//#endregion
+export { AbcVelocityStrategy, CategoryZoneStrategy, ClosestToPickStrategy, CrossDockEngine, EmptyBinStrategy, FixedLocationStrategy, PutawayEngine, RemovalEngine, RouteExpander, WaveEngine };

package/dist/runtime-config-C0ggPkiK.mjs

@@ -0,0 +1,40 @@
+//#region src/utils/document-number.ts
+/**
+* Format a document number from its constituent parts.
+*
+* @param prefix - Document type prefix (e.g. 'CHN', 'PO').
+* @param sequence - Monotonically increasing sequence obtained from the counters collection.
+* @param date - Optional date used for the YYYYMM segment (defaults to now).
+* @returns A formatted document number, e.g. `PO-202603-0001`.
+*/
+function formatDocumentNumber(prefix, sequence, date = /* @__PURE__ */ new Date()) {
+	return `${prefix}-${date.getFullYear()}${String(date.getMonth() + 1).padStart(2, "0")}-${String(sequence).padStart(4, "0")}`;
+}
+//#endregion
+//#region src/services/runtime-config.ts
+/**
+* Create a frozen RuntimeConfig instance.
+* Used by createServices() to produce an instance-scoped config.
+*/
+function createRuntimeConfig(mode, routing, valuation) {
+	return Object.freeze({
+		mode,
+		routing: Object.freeze({ ...routing }),
+		valuation: Object.freeze({ ...valuation })
+	});
+}
+/**
+* Feature gates — pure functions that take a config instance.
+* No global state; callers pass the config they own.
+*/
+function requireStandardMode(config, feature) {
+	if (config.mode === "simple") throw new Error(`${feature} requires 'standard' or 'enterprise' mode (current: 'simple')`);
+}
+function requireEnterpriseMode(config, feature) {
+	if (config.mode !== "enterprise") throw new Error(`${feature} requires 'enterprise' mode (current: '${config.mode}')`);
+}
+function isRoutingEnabled(config, feature) {
+	return config.mode === "enterprise" && config.routing[feature];
+}
+//#endregion
+export { formatDocumentNumber as a, requireStandardMode as i, isRoutingEnabled as n, requireEnterpriseMode as r, createRuntimeConfig as t };

package/dist/runtime-config-CQLtPPqY.d.mts

@@ -0,0 +1,38 @@
+import { n as FlowMode } from "./index-DFF0GJ4J.mjs";
+
+//#region src/services/runtime-config.d.ts
+/**
+ * Runtime configuration resolved from FlowConfig at engine creation time.
+ * Instance-scoped — each FlowEngine gets its own config object.
+ */
+interface RuntimeConfig {
+  mode: FlowMode;
+  routing: {
+    putaway: boolean;
+    removal: boolean;
+    crossDock: boolean;
+  };
+  valuation: {
+    method: string;
+  };
+}
+/**
+ * Create a frozen RuntimeConfig instance.
+ * Used by createServices() to produce an instance-scoped config.
+ */
+declare function createRuntimeConfig(mode: FlowMode, routing: {
+  putaway: boolean;
+  removal: boolean;
+  crossDock: boolean;
+}, valuation: {
+  method: string;
+}): RuntimeConfig;
+/**
+ * Feature gates — pure functions that take a config instance.
+ * No global state; callers pass the config they own.
+ */
+declare function requireStandardMode(config: RuntimeConfig, feature: string): void;
+declare function requireEnterpriseMode(config: RuntimeConfig, feature: string): void;
+declare function isRoutingEnabled(config: RuntimeConfig, feature: 'putaway' | 'removal' | 'crossDock'): boolean;
+//#endregion
+export { requireStandardMode as a, requireEnterpriseMode as i, createRuntimeConfig as n, isRoutingEnabled as r, RuntimeConfig as t };

package/dist/scan-token-CNM9QVLY.d.mts

@@ -0,0 +1,26 @@
+//#region src/domain/value-objects/scan-token.d.ts
+/**
+ * Resolved scan result — returned by the scan service after resolving a raw token.
+ */
+interface ScanResolution {
+  token: string;
+  resolvedType: 'sku' | 'lot' | 'serial' | 'location' | 'package' | 'document' | 'unknown';
+  resolvedId: string | null;
+  resolvedEntity: Record<string, unknown> | null;
+  action?: 'receive' | 'pick' | 'move' | 'count' | 'verify';
+}
+/**
+ * GS1-128 decomposition — extracts multiple fields from one barcode.
+ */
+interface GS1Resolution {
+  token: string;
+  components: Array<{
+    ai: string;
+    type: 'product' | 'lot' | 'serial' | 'expiry' | 'weight' | 'quantity';
+    value: string | number | Date;
+  }>;
+  resolvedSku: Record<string, unknown> | null;
+  resolvedLot: Record<string, unknown> | null;
+}
+//#endregion
+export { ScanResolution as n, GS1Resolution as t };