@classytic/flow 0.1.4

package/CHANGELOG.md

@@ -0,0 +1,70 @@
+# Changelog
+
+All notable changes to `@classytic/flow` are documented here.
+
+## [0.1.0] - 2026-03-29
+
+Initial public release.
+
+### Features
+
+- Double-entry inventory engine with location hierarchy
+- Stock quants (materialized read model)
+- Reservation system with expiry and partial consumption
+- FIFO/FEFO/WAC/specific/standard valuation + landed cost allocation
+- Lot and serial traceability with recall support
+- Putaway and removal routing strategies (ABC-velocity, category-zone, closest-to-pick, empty-bin, fixed-location)
+- Route expansion engine (1/2/3-step reception and delivery)
+- Wave picking engine with serpentine (boustrophedon) path optimization
+  - 3D warehouse coordinates: zone/aisle/bay/level/bin
+  - Odd aisles ascending, even aisles descending — eliminates dead-walking
+  - Location consolidation (merge picks for same SKU at same bin)
+  - Weight/volume/item cart batching with oversized pick splitting
+- Cross-dock engine with multi-destination routing
+  - FIFO assignment to waiting outbound orders
+  - Per-destination quantity tracking with remaining-to-storage calculation
+- Procurement order lifecycle (draft → approved → received)
+- Cycle counting with auto-reconciliation and freeze policies
+- Replenishment rules (reorder point, min/max, scheduled)
+- GS1-128 barcode parser with dynamic year rollover
+- Scan resolution chain (GS1 → location → lot → serial → SKU)
+- Multi-tenant support via MongoKit plugins
+- In-process event bus with error isolation
+- Stock packaging with parent/child nesting
+- Config-driven deployment modes (`simple` / `standard` / `enterprise`)
+  - `allocation.defaultPolicy` wired to built-in FifoStrategy/FefoStrategy/LifoStrategy
+  - `mode`, `routing`, `valuation` accessible at runtime via `flow.services.mode`
+
+### Safety & Data Integrity
+
+- Atomic quant upsert via MongoDB aggregation pipeline — `quantityAvailable = quantityOnHand - quantityReserved` computed in a single operation, no race window
+- Negative stock prevention — `postMove()` checks `location.allowNegativeStock` before decrementing; throws `NegativeStockError` if insufficient
+- Canonical posting path — `receiveGroup()` delegates to `PostingService.postMove()` per move, enforcing negative stock guard, move transition validation, and `inventory.move.done` event emission for every move
+- Reservation lifecycle correctness:
+  - `expire()` releases `quantityReserved` from the quant (matches `cleanupExpired()`)
+  - `consume()` validates `quantity > 0`, caps at remaining, throws on overconsumption
+  - `consume()` decrements `quantityReserved` on the quant
+  - Group fulfillment (`receiveGroup`) consumes + releases all move reservations
+  - `releaseReservation` uses correct `consumed` vs `partially_consumed` status and computes `remaining` from pre-update state (no stale reads)
+- Partially done move reconciliation — `receiveGroup()` includes `partially_done` in committable statuses and completes the remaining quantity
+- Input validation — `quantityDone > 0`, `quantity > 0`, non-empty `items[]` enforced at service entry with `ValidationError`
+- Tenant-scoped idempotency keys — all services (reservation, move, procurement) prefix keys with `organizationId:` to prevent cross-org collisions
+- WAC precision — weighted average cost rounded to 4 decimal places; freezes at last known cost when stock goes negative
+- Penny-leak prevention — landed cost post-capitalization uses remainder absorption per item with cross-item correction on the last item
+- Concurrent allocation safety — parallel availability checks + `batchUpsert` for quant reservation locks
+- Event handler error isolation — logged but never propagate to emitter
+- FIFO/FEFO zero-quantity guard — valuation engines return empty result for `quantity <= 0`
+- Move group state machine — explicit status validation in `receiveGroup()` (rejects done/cancelled/draft)
+- Reservation cleanup batching — `cleanupExpired()` processes all expirations in a single transaction
+- Quant `deleteAll()` uses consistent ObjectId filter (matches reads) — `rebuildFromMoveHistory()` correctly clears stale quants
+
+### Dependencies
+
+- `mongoose` (peer, >=9.0.0) — required
+- `@classytic/mongokit` (peer, >=3.0.0) — required, provides repository pattern + plugins
+
+### Test Coverage
+
+- 60 test files, 560 test cases
+- Coverage layers: domain unit, engine unit (mocked), service integration (MongoDB), E2E workflow, concurrency stress, data integrity, algorithm correctness
+- Pure-interface files excluded from coverage denominator

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Classytic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,258 @@
+# @classytic/flow
+
+Production-grade inventory kernel and supply chain engine for MongoDB.
+
+Double-entry inventory, location-based stock tracking, reservations, FIFO/FEFO/WAC valuation, lot/serial traceability, putaway/removal routing, wave picking with serpentine path optimization, cross-dock multi-destination routing, procurement, cycle counting, and replenishment — all as pure domain services with zero framework coupling.
+
+## Quick Start
+
+```typescript
+import { createFlowEngine } from '@classytic/flow';
+import mongoose from 'mongoose';
+
+// 1. Create the engine
+const flow = createFlowEngine({
+  mongoose: mongoose.connection,
+  mode: 'standard',
+  catalog: {
+    resolveSku: async (skuRef) => productService.findBySku(skuRef),
+  },
+});
+
+// 2. Access models
+const { InventoryNode, Location, StockMoveGroup, StockMove, StockQuant, Reservation } = flow.models;
+
+// 3. Context carries tenant + actor — never mixed into domain inputs
+const ctx = { organizationId: 'org_1', actorId: 'user_1' };
+
+// 4. Use services (pure async functions — no HTTP, no framework)
+const availability = await flow.services.quant.getAvailability({
+  skuRef: 'SKU-RED-M',
+  nodeId: 'warehouse_1',
+}, ctx);
+
+// 5. Create and execute a transfer
+const group = await flow.services.moveGroup.create({
+  groupType: 'transfer',
+  sourceNodeId: 'warehouse_1',
+  destinationNodeId: 'store_1',
+  items: [{
+    moveGroupId: '',            // auto-assigned
+    operationType: 'transfer',
+    skuRef: 'SKU-RED-M',
+    sourceLocationId: 'loc_storage_wh1',
+    destinationLocationId: 'loc_storage_store1',
+    quantityPlanned: 50,
+  }],
+}, ctx);
+
+await flow.services.moveGroup.executeAction(group._id, 'confirm', {}, ctx);
+await flow.services.moveGroup.executeAction(group._id, 'dispatch', {}, ctx);
+await flow.services.moveGroup.executeAction(group._id, 'receive', {}, ctx);
+
+// 6. Subscribe to events (bridge to your ledger, notifications, etc.)
+flow.events.on('inventory.move.done', async (payload) => {
+  // payload: { organizationId, moveId, skuRef, quantityDone, ... }
+  await ledger.postInventoryMovement(payload);
+});
+
+// 7. Query active config at runtime
+flow.services.mode;      // 'standard'
+flow.services.routing;   // { putaway: false, removal: false, crossDock: false }
+flow.services.valuation; // { method: 'wac' }
+```
+
+### Simple Mode (single store, basic stock)
+
+Flow scales down to simple apps. You don't need locations, routing, or lots — just stock queries and moves:
+
+```typescript
+const ctx = { organizationId: 'org_1', actorId: 'user_1' };
+
+// Check availability
+const stock = await flow.services.quant.getAvailability({ skuRef: 'SKU-RED-M' }, ctx);
+// → { quantityOnHand: 50, quantityReserved: 5, quantityAvailable: 45, quantityIncoming: 20, quantityOutgoing: 0 }
+
+// Reserve stock for an order
+await flow.services.reservation.reserve({
+  reservationType: 'hard',
+  skuRef: 'SKU-RED-M',
+  locationId: 'loc_default',
+  quantity: 3,
+  ownerType: 'order',
+  ownerId: 'order_123',
+}, ctx);
+```
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **Double-entry inventory** | Every stock change is a move between locations — never direct mutation |
+| **Location hierarchy** | Warehouse > zone > aisle > bin. Virtual locations for vendor, customer, scrap, transit |
+| **Stock quants** | Materialized read model of on-hand, reserved, available, incoming, outgoing |
+| **Reservations** | First-class records with expiry, partial consumption, overconsumption guard, and pluggable allocation |
+| **Valuation** | WAC (default), FIFO, FEFO, specific identification, standard cost, landed cost with penny-leak prevention |
+| **Lot/serial tracking** | Full traceability with expiry, recall support, and FEFO allocation |
+| **Routing engine** | Putaway strategies, removal strategies, route expansion |
+| **Wave picking** | Serpentine (boustrophedon) path optimization with 3D coordinates, weight/volume/item cart batching with oversized pick splitting |
+| **Cross-dock routing** | Multi-destination assignments — incoming stock auto-routed to waiting outbound orders in FIFO order |
+| **Procurement** | Purchase order lifecycle, receiving, vendor management |
+| **Cycle counting** | Full/cycle/blind counts with auto-reconciliation |
+| **Replenishment** | Min/max, reorder point, safety stock, EOQ, multi-echelon |
+| **Scan resolution + GS1-128** | Device-agnostic barcode/QR/RFID → entity resolution. Built-in GS1-128 parser for GTIN, lot, expiry, serial. |
+| **Stock states** | Sellable, damaged, quarantine, hold, returns, expired, in-transit |
+| **UoM conversion** | Each/case/carton/pallet with per-SKU conversion factors |
+| **Packaging** | StockPackage with parent/child nesting (carton → case → pallet), weight calculation |
+| **Stock ownership** | `ownerRef` on quants — owned vs consignment/third-party in same location |
+| **QC workflow** | Quality hold location + inspection route step |
+| **Multi-tenant** | Organization-scoped via MongoKit multi-tenant plugin |
+| **Events** | In-process emitter — bridge to Redis, webhooks, ledger, notifications |
+| **Capability tiers** | `simple` / `standard` / `enterprise` — config-driven feature gating |
+
+## Safety & Data Integrity
+
+Flow enforces invariants at the engine level so consumers don't have to:
+
+| Guard | Behavior |
+|-------|----------|
+| **Atomic quant updates** | `quantityAvailable = quantityOnHand - quantityReserved` computed in a single MongoDB aggregation pipeline — no race window |
+| **Negative stock prevention** | `postMove()` checks `location.allowNegativeStock` before decrementing; throws `NegativeStockError` if insufficient. Virtual sources (returns, receipts) auto-bypass. |
+| **Canonical posting path** | `receiveGroup()` delegates to `PostingService.postMove()` per move — negative stock guard, move transition validation, and `inventory.move.done` events fire for every move |
+| **Reservation lifecycle** | `expire()` and `consume()` both release `quantityReserved` from the quant. `consume()` validates `quantity > 0` and caps at remaining — no overconsumption. Fulfillment releases all reservations. |
+| **Input validation** | `quantityDone > 0`, `quantity > 0`, non-empty `items[]` enforced at service entry |
+| **Tenant-scoped idempotency** | All idempotency keys prefixed with `organizationId:` (reservation, move, procurement) — no cross-tenant collision |
+| **WAC precision** | Weighted average cost rounded to 4 decimal places; freezes at last known cost when stock goes negative |
+| **Penny-leak prevention** | Landed cost post-capitalization uses remainder absorption — COGS + remaining = exactly the allocated cost per item, with cross-item correction on the last item |
+| **Concurrent allocation safety** | Parallel availability check + `batchUpsert` for quant reservation locks within a single transaction |
+| **Event error isolation** | Handler errors logged but never propagate to emitter |
+| **GS1 year rollover** | Dynamic sliding window (±50 years from current year) instead of hardcoded cutoff |
+| **FIFO/FEFO zero-qty guard** | Valuation engines return empty result for `quantity <= 0` |
+| **Partially done moves** | `receiveGroup()` reconciles `partially_done` moves — completes remaining quantity instead of skipping them |
+
+## Subpath Exports
+
+| Import | Contents |
+|--------|----------|
+| `@classytic/flow` | `createFlowEngine()` factory + full API |
+| `@classytic/flow/domain` | Entities, value objects, errors |
+| `@classytic/flow/domain/contracts` | `CatalogBridge`, `AuthContext` interfaces |
+| `@classytic/flow/domain/enums` | `LocationType`, `MoveStatus`, `OperationType`, etc. |
+| `@classytic/flow/domain/policies` | `AllocationPolicy`, `RemovalPolicy`, `ValuationPolicy` |
+| `@classytic/flow/models` | Mongoose schemas |
+| `@classytic/flow/repositories` | Repository factories (MongoKit) |
+| `@classytic/flow/services` | All domain services |
+| `@classytic/flow/valuation` | Cost layers, WAC/FIFO/FEFO engine, landed cost |
+| `@classytic/flow/routing` | Putaway, removal, wave engine, cross-dock engine |
+| `@classytic/flow/reservations` | Allocation strategies and reservation service |
+| `@classytic/flow/procurement` | Procurement order lifecycle |
+| `@classytic/flow/counting` | Inventory count and reconciliation |
+| `@classytic/flow/traceability` | Lot/serial trace queries |
+| `@classytic/flow/scanning` | Scan resolution + GS1-128 parser |
+| `@classytic/flow/packaging` | StockPackage service |
+| `@classytic/flow/reporting` | Read models, metrics, stock aging |
+| `@classytic/flow/events` | Event definitions and emitter |
+| `@classytic/flow/types` | All TypeScript types |
+
+## Configuration
+
+```typescript
+const flow = createFlowEngine({
+  // Required
+  mongoose: connection,
+
+  // Required — how Flow resolves product details
+  catalog: {
+    resolveSku: async (skuRef) => ({ sku: skuRef, displayName: '...', trackingMode: 'none', uom: 'unit' }),
+  },
+
+  // Optional — deployment mode (default: 'standard')
+  mode: 'standard',
+
+  // Optional — multi-tenant (omit for single-tenant)
+  multiTenant: { orgField: 'organizationId' },
+
+  // Optional — valuation method (default: 'wac')
+  valuation: { method: 'wac' },
+
+  // Optional — allocation policy (default: 'fifo') — resolves to built-in FifoStrategy/FefoStrategy/LifoStrategy
+  allocation: { defaultPolicy: 'fifo' },
+
+  // Optional — routing (enterprise mode)
+  routing: { putaway: true, removal: true, crossDock: false },
+
+  // Optional — custom allocation policy (overrides allocation.defaultPolicy)
+  policies: { allocation: myCustomPolicy },
+
+  // Optional — custom event emitter (default: in-process)
+  events: { adapter: myRedisEventBus },
+
+  // Optional — idempotency store
+  idempotency: myRedisIdempotency,
+
+  // Optional — MongoKit plugins per repository
+  plugins: {
+    quant: [cachePlugin({ adapter: redis, ttl: 30 })],
+    move: [auditTrailPlugin()],
+  },
+});
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `mongoose` | `Connection` | required | Mongoose connection |
+| `catalog` | `CatalogBridge` | required | Product/SKU resolution |
+| `mode` | `FlowMode` | `'standard'` | `simple`, `standard`, or `enterprise` |
+| `multiTenant` | `object` | `undefined` | `{ orgField }` for org-scoped isolation |
+| `valuation.method` | `string` | `'wac'` | `wac`, `fifo`, `fefo`, `specific`, `standard` |
+| `allocation.defaultPolicy` | `string` | `'fifo'` | `fifo`, `fefo`, `lifo` — maps to built-in strategy |
+| `routing.putaway` | `boolean` | `false` | Enable putaway strategy engine |
+| `routing.removal` | `boolean` | `false` | Enable removal strategy engine |
+| `routing.crossDock` | `boolean` | `false` | Enable cross-dock multi-destination routing |
+
+## What Flow Returns
+
+```typescript
+const flow = createFlowEngine(config);
+
+flow.models         // All Mongoose models
+flow.repositories   // All MongoKit repositories
+flow.services       // All domain services + active config (mode, routing, valuation)
+flow.events         // In-process event emitter
+flow.registerPolicy // Register custom allocation policies at runtime
+```
+
+## What Flow Does NOT Include
+
+Flow is a pure domain kernel. These are consumer responsibilities:
+
+- **HTTP routes** — use Arc, Express, Fastify, NestJS, Next.js
+- **Durable workflows** — use Streamline, BullMQ, cron
+- **Agent tooling** — wrap `flow.services` in your agent tools or MCP servers
+- **Ledger integration** — subscribe to `flow.events`
+- **Authentication** — pass `AuthContext` to service methods
+
+## Dependencies
+
+| Dependency | Type | Required |
+|------------|------|----------|
+| `mongoose` | peer | Yes (>=9.0.0) |
+| `@classytic/mongokit` | peer | Yes (>=3.0.0) — provides repository pattern, pagination, plugins |
+
+## Reference Docs
+
+| Doc | Description |
+|-----|-------------|
+| [Architecture](docs/architecture.md) | Domain model, clean architecture layers, invariants, capability tiers |
+| [Algorithms](docs/algorithms.md) | Valuation, allocation, routing, replenishment formulas |
+| [Workflows](docs/workflows.md) | Inbound, outbound, transfer, counting, return flows |
+| [Plugins & Adapters](docs/plugins-and-adapters.md) | Scan, events, labels, catalog, policies, workflow adapters |
+| [Integration](docs/integration.md) | MongoKit, Arc, Streamline, framework examples |
+| [API Reference](docs/api-reference.md) | Service methods, entity fields, events, errors |
+| [Test Strategy](docs/test-strategy.md) | Test layers, coverage targets, fixtures |
+| [Migration Plan](docs/migration-plan.md) | Step-by-step guide to integrate Flow into an Arc backend |
+| [Changelog](CHANGELOG.md) | Version history and bug fixes |
+
+## License
+
+MIT

package/dist/allocation-policy-my_HfzdV.d.mts

@@ -0,0 +1,23 @@
+import { n as StockQuant } from "./stock-quant-CZhgvTu7.mjs";
+
+//#region src/domain/policies/allocation-policy.d.ts
+interface AllocationResult {
+  fulfilled: boolean;
+  allocations: Array<{
+    quantId: string;
+    locationId: string;
+    lotId?: string;
+    quantity: number;
+  }>;
+  shortfall: number;
+}
+/**
+ * Allocation policy — decides which quants fulfill a demand.
+ * Consumer can provide custom implementations.
+ */
+interface AllocationPolicy {
+  name: string;
+  resolve(skuRef: string, quantity: number, candidates: StockQuant[]): AllocationResult;
+}
+//#endregion
+export { AllocationResult as n, AllocationPolicy as t };

package/dist/base-MWBqRFM2.mjs

@@ -0,0 +1,16 @@
+//#region src/domain/errors/base.ts
+var FlowError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+	}
+	toJSON() {
+		return {
+			code: this.code,
+			message: this.message,
+			name: this.name
+		};
+	}
+};
+//#endregion
+export { FlowError as t };

package/dist/catalog-bridge-K8bdkncJ.d.mts

@@ -0,0 +1,29 @@
+//#region src/domain/contracts/catalog-bridge.d.ts
+/**
+ * CatalogBridge — required contract.
+ * Consumer implements this to tell Flow how to resolve SKU references.
+ * Flow does not own the product catalog.
+ */
+interface CatalogBridge {
+  resolveSku(skuRef: string): Promise<SkuDetails | null>;
+  syncAvailability?(updates: AvailabilityUpdate[]): Promise<void>;
+}
+interface SkuDetails {
+  skuRef: string;
+  sku: string;
+  displayName: string;
+  trackingMode: 'none' | 'lot' | 'serial';
+  uom: string;
+  weight?: number;
+  volume?: number;
+  barcode?: string[];
+  isActive: boolean;
+}
+interface AvailabilityUpdate {
+  skuRef: string;
+  nodeId: string;
+  available: number;
+  inStock: boolean;
+}
+//#endregion
+export { CatalogBridge as n, SkuDetails as r, AvailabilityUpdate as t };

package/dist/cost-layer.port-iH9pvZqB.d.mts

@@ -0,0 +1,30 @@
+import { a as QueryOptions, t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/entities/cost-layer.d.ts
+interface CostLayer {
+  _id: string;
+  organizationId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  remainingQty: number;
+  unitCost: number;
+  receivedAt: Date;
+  expiresAt?: Date;
+  procurementRef?: string;
+  moveRef: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/ports/cost-layer.port.d.ts
+interface CostLayerPort {
+  create(input: Omit<CostLayer, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<CostLayer>;
+  drain(id: string, quantity: number, ctx: FlowContext, session?: TransactionSession): Promise<CostLayer>;
+  findBySkuRef(skuRef: string, locationId: string, ctx: FlowContext, session?: TransactionSession): Promise<CostLayer[]>;
+  findMany(filter: Record<string, unknown>, ctx: FlowContext, session?: TransactionSession, options?: QueryOptions): Promise<CostLayer[]>;
+  findOrderedForConsumption(skuRef: string, locationId: string, method: 'fifo' | 'fefo', ctx: FlowContext, session?: TransactionSession): Promise<CostLayer[]>;
+}
+//#endregion
+export { CostLayer as n, CostLayerPort as t };

package/dist/cost-layer.service-BQ1bs-XN.mjs

@@ -0,0 +1,86 @@
+import { t as InsufficientStockError } from "./insufficient-stock.error-Dyr4BYaV.mjs";
+import { t as assertTenantContext } from "./tenant-guard-6Ne-BILP.mjs";
+//#region src/valuation/fifo.engine.ts
+var FifoEngine = class {
+	consume(layers, quantity) {
+		if (quantity <= 0) return {
+			consumed: [],
+			totalCost: 0,
+			totalQuantity: 0,
+			remainingUncosted: 0,
+			insufficientLayers: false
+		};
+		const consumed = [];
+		let remaining = quantity;
+		let totalCost = 0;
+		for (const layer of layers) {
+			if (remaining <= 0) break;
+			if (layer.remainingQty <= 0) continue;
+			const take = Math.min(layer.remainingQty, remaining);
+			const cost = take * layer.unitCost;
+			consumed.push({
+				layerId: layer._id,
+				quantity: take,
+				unitCost: layer.unitCost,
+				totalCost: cost
+			});
+			totalCost += cost;
+			remaining -= take;
+		}
+		return {
+			consumed,
+			totalCost,
+			totalQuantity: quantity - remaining,
+			remainingUncosted: remaining,
+			insufficientLayers: remaining > 0
+		};
+	}
+};
+//#endregion
+//#region src/valuation/fefo.engine.ts
+var FefoEngine = class {
+	fifoEngine = new FifoEngine();
+	consume(layers, quantity) {
+		return this.fifoEngine.consume(layers, quantity);
+	}
+};
+//#endregion
+//#region src/valuation/cost-layer.service.ts
+var CostLayerService = class {
+	fifoEngine = new FifoEngine();
+	fefoEngine = new FefoEngine();
+	constructor(costLayerPort, _unitOfWork) {
+		this.costLayerPort = costLayerPort;
+	}
+	async createLayer(input, session) {
+		return this.costLayerPort.create(input, session);
+	}
+	async consumeLayers(skuRef, locationId, quantity, method, ctx, session) {
+		assertTenantContext(ctx);
+		const layers = await this.costLayerPort.findOrderedForConsumption(skuRef, locationId, method, ctx, session);
+		const result = (method === "fefo" ? this.fefoEngine : this.fifoEngine).consume(layers, quantity);
+		if (result.insufficientLayers) throw new InsufficientStockError(skuRef, quantity, quantity - result.remainingUncosted, locationId);
+		for (const entry of result.consumed) await this.costLayerPort.drain(entry.layerId, entry.quantity, ctx, session);
+		return result;
+	}
+	async getValuation(skuRef, locationId, ctx) {
+		assertTenantContext(ctx);
+		const layers = await this.costLayerPort.findBySkuRef(skuRef, locationId, ctx);
+		let totalQuantity = 0;
+		let totalValue = 0;
+		for (const layer of layers) if (layer.remainingQty > 0) {
+			totalQuantity += layer.remainingQty;
+			totalValue += layer.remainingQty * layer.unitCost;
+		}
+		return {
+			skuRef,
+			locationId,
+			totalQuantity,
+			totalValue: Math.round(totalValue * 100) / 100,
+			averageUnitCost: totalQuantity > 0 ? Math.round(totalValue / totalQuantity * 100) / 100 : 0,
+			layerCount: layers.filter((l) => l.remainingQty > 0).length
+		};
+	}
+};
+//#endregion
+export { FefoEngine as n, FifoEngine as r, CostLayerService as t };

package/dist/cost-layer.service-DWmo9dQz.d.mts

@@ -0,0 +1,53 @@
+import { t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { n as CostLayer, t as CostLayerPort } from "./cost-layer.port-iH9pvZqB.mjs";
+import { n as UnitOfWork, t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/valuation/fifo.engine.d.ts
+interface ConsumptionResult {
+  consumed: Array<{
+    layerId: string;
+    quantity: number;
+    unitCost: number;
+    totalCost: number;
+  }>;
+  totalCost: number;
+  totalQuantity: number;
+  remainingUncosted: number;
+  insufficientLayers: boolean;
+}
+declare class FifoEngine {
+  consume(layers: CostLayer[], quantity: number): ConsumptionResult;
+}
+//#endregion
+//#region src/valuation/cost-layer.service.d.ts
+interface CreateCostLayerInput {
+  organizationId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  remainingQty: number;
+  unitCost: number;
+  receivedAt: Date;
+  expiresAt?: Date;
+  procurementRef?: string;
+  moveRef: string;
+}
+interface InventoryValuation {
+  skuRef: string;
+  locationId: string;
+  totalQuantity: number;
+  totalValue: number;
+  averageUnitCost: number;
+  layerCount: number;
+}
+declare class CostLayerService {
+  private costLayerPort;
+  private fifoEngine;
+  private fefoEngine;
+  constructor(costLayerPort: CostLayerPort, _unitOfWork: UnitOfWork);
+  createLayer(input: CreateCostLayerInput, session?: TransactionSession): Promise<CostLayer>;
+  consumeLayers(skuRef: string, locationId: string, quantity: number, method: 'fifo' | 'fefo', ctx: FlowContext, session?: TransactionSession): Promise<ConsumptionResult>;
+  getValuation(skuRef: string, locationId: string, ctx: FlowContext): Promise<InventoryValuation>;
+}
+//#endregion
+export { FifoEngine as a, ConsumptionResult as i, CreateCostLayerInput as n, InventoryValuation as r, CostLayerService as t };

package/dist/count.port-BRqwGbi3.d.mts

@@ -0,0 +1,57 @@
+import { t as FlowContext } from "./index-DFF0GJ4J.mjs";
+import { t as TransactionSession } from "./unit-of-work.port-CWEkrDKu.mjs";
+
+//#region src/domain/entities/count-line.d.ts
+interface CountLine {
+  _id: string;
+  organizationId: string;
+  countId: string;
+  skuRef: string;
+  locationId: string;
+  lotId?: string;
+  serialCode?: string;
+  expectedQuantity: number;
+  countedQuantity: number;
+  variance: number;
+  varianceReason?: string;
+  recountFlag?: boolean;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/entities/inventory-count.d.ts
+type CountStatus = 'draft' | 'in_progress' | 'submitted' | 'reconciled' | 'approved';
+interface CountScope {
+  nodeId?: string;
+  locationId?: string;
+  skuRefs?: string[];
+}
+interface InventoryCount {
+  _id: string;
+  organizationId: string;
+  countNumber: string;
+  countType: 'full' | 'cycle' | 'spot';
+  scope: CountScope;
+  status: CountStatus;
+  freezePolicy: 'hard_freeze' | 'soft_freeze' | 'none';
+  startedAt?: Date;
+  submittedAt?: Date;
+  reconciledAt?: Date;
+  createdBy?: string;
+  modifiedBy?: string;
+  approvedBy?: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+//#endregion
+//#region src/domain/ports/count.port.d.ts
+interface CountPort {
+  create(input: Omit<InventoryCount, '_id' | 'createdAt' | 'updatedAt'>, session?: TransactionSession): Promise<InventoryCount>;
+  findById(id: string, ctx: FlowContext, session?: TransactionSession): Promise<InventoryCount | null>;
+  updateStatus(id: string, status: CountStatus, updates: Partial<InventoryCount>, session?: TransactionSession): Promise<InventoryCount>;
+  submitLines(countId: string, lines: Omit<CountLine, '_id' | 'createdAt' | 'updatedAt'>[], session?: TransactionSession): Promise<CountLine[]>;
+  getLines(countId: string, ctx: FlowContext, session?: TransactionSession): Promise<CountLine[]>;
+}
+//#endregion
+export { CountLine as a, InventoryCount as i, CountScope as n, CountStatus as r, CountPort as t };

package/dist/counting/index.d.mts

@@ -0,0 +1,2 @@
+import { a as ReconcileResult, i as ReconcileOptions, n as CountingService, o as VarianceReport, r as CreateCountInput, t as CountLineInput } from "../counting.service-CpAxU2G0.mjs";
+export { type CountLineInput, CountingService, type CreateCountInput, type ReconcileOptions, type ReconcileResult, type VarianceReport };

package/dist/counting/index.mjs

@@ -0,0 +1,2 @@
+import { t as CountingService } from "../counting.service-BiQXqorv.mjs";
+export { CountingService };