@psavelis/enterprise-blockchain 0.1.0 → 1.1.1

package/dist/stark-settlement/infrastructure/persistence/ledger-store.js

@@ -0,0 +1,238 @@
+/**
+ * In-Memory Ledger Store
+ *
+ * Implements LedgerPersistencePort for testing and demos.
+ * Stores all data in memory with no persistence.
+ *
+ * @see domain/ports.ts for interface definition
+ */
+/**
+ * In-memory implementation of the ledger persistence port.
+ */
+export class InMemoryLedgerStore {
+    accounts = new Map();
+    accountsByAddress = new Map(); // address:asset -> accountId
+    transactions = new Map();
+    transactionsByIdempotencyKey = new Map();
+    baseProofs = new Map();
+    tier1Proofs = new Map();
+    tier2Proofs = new Map();
+    aggregatedBaseProofIds = new Set();
+    aggregatedTier1ProofIds = new Set();
+    // ─── Accounts ───────────────────────────────────────────────────────────
+    async createAccount(account) {
+        if (this.accounts.has(account.id)) {
+            throw new Error(`Account ${account.id} already exists`);
+        }
+        const addressKey = `${account.externalAddress}:${account.assetType}`;
+        if (this.accountsByAddress.has(addressKey)) {
+            throw new Error(`Account for ${account.externalAddress}:${account.assetType} already exists`);
+        }
+        this.accounts.set(account.id, account);
+        this.accountsByAddress.set(addressKey, account.id);
+    }
+    async getAccount(accountId) {
+        return this.accounts.get(accountId) ?? null;
+    }
+    async getAccountByAddress(externalAddress, assetType) {
+        const addressKey = `${externalAddress}:${assetType}`;
+        const accountId = this.accountsByAddress.get(addressKey);
+        if (!accountId)
+            return null;
+        return this.accounts.get(accountId) ?? null;
+    }
+    async updateAccountBalance(accountId, delta, newProofRoot) {
+        const account = this.accounts.get(accountId);
+        if (!account) {
+            throw new Error(`Account ${accountId} not found`);
+        }
+        const newBalance = account.balance + delta;
+        if (newBalance < 0n) {
+            throw new Error(`Insufficient balance: ${account.balance} + ${delta} = ${newBalance}`);
+        }
+        const updatedAccount = {
+            ...account,
+            balance: newBalance,
+            lastProofRoot: newProofRoot,
+            updatedAt: Date.now(),
+        };
+        this.accounts.set(accountId, updatedAccount);
+    }
+    async getAccountsByAssetType(assetType) {
+        const accounts = [];
+        for (const account of this.accounts.values()) {
+            if (account.assetType === assetType) {
+                accounts.push(account);
+            }
+        }
+        return accounts;
+    }
+    // ─── Transactions ───────────────────────────────────────────────────────
+    async appendTransaction(tx) {
+        if (this.transactions.has(tx.txId)) {
+            throw new Error(`Transaction ${tx.txId} already exists`);
+        }
+        this.transactions.set(tx.txId, tx);
+        // Index by idempotency key
+        const existingTxIds = this.transactionsByIdempotencyKey.get(tx.idempotencyKey) ?? [];
+        this.transactionsByIdempotencyKey.set(tx.idempotencyKey, [
+            ...existingTxIds,
+            tx.txId,
+        ]);
+    }
+    async getTransaction(txId) {
+        return this.transactions.get(txId) ?? null;
+    }
+    async getTransactionsByIdempotencyKey(idempotencyKey) {
+        const txIds = this.transactionsByIdempotencyKey.get(idempotencyKey) ?? [];
+        const transactions = [];
+        for (const txId of txIds) {
+            const tx = this.transactions.get(txId);
+            if (tx)
+                transactions.push(tx);
+        }
+        return transactions;
+    }
+    async getPendingTransactions(limit) {
+        if (limit <= 0)
+            return [];
+        const pending = [];
+        for (const tx of this.transactions.values()) {
+            if (tx.status === "pending") {
+                pending.push(tx);
+                if (pending.length >= limit)
+                    break;
+            }
+        }
+        // Sort by createdAt for deterministic ordering
+        return pending.sort((a, b) => a.createdAt - b.createdAt);
+    }
+    async updateTransactionStatus(txId, status) {
+        const tx = this.transactions.get(txId);
+        if (!tx) {
+            throw new Error(`Transaction ${txId} not found`);
+        }
+        const updatedTx = {
+            ...tx,
+            status,
+            updatedAt: Date.now(),
+        };
+        this.transactions.set(txId, updatedTx);
+    }
+    // ─── Base Proofs ────────────────────────────────────────────────────────
+    async saveBaseProof(proof) {
+        if (this.baseProofs.has(proof.proofId)) {
+            throw new Error(`Base proof ${proof.proofId} already exists`);
+        }
+        this.baseProofs.set(proof.proofId, proof);
+    }
+    async getBaseProof(proofId) {
+        return this.baseProofs.get(proofId) ?? null;
+    }
+    async getUnaggregatedBaseProofs(limit) {
+        if (limit <= 0)
+            return [];
+        const proofs = [];
+        for (const proof of this.baseProofs.values()) {
+            if (!this.aggregatedBaseProofIds.has(proof.proofId)) {
+                proofs.push(proof);
+                if (proofs.length >= limit)
+                    break;
+            }
+        }
+        // Sort by createdAt for deterministic ordering
+        return proofs.sort((a, b) => a.createdAt - b.createdAt);
+    }
+    /**
+     * Mark base proofs as aggregated (internal method for aggregator).
+     */
+    markBaseProofsAggregated(proofIds) {
+        for (const proofId of proofIds) {
+            this.aggregatedBaseProofIds.add(proofId);
+        }
+    }
+    // ─── Tier-1 Proofs ──────────────────────────────────────────────────────
+    async saveTier1Proof(proof) {
+        if (this.tier1Proofs.has(proof.proofId)) {
+            throw new Error(`Tier-1 proof ${proof.proofId} already exists`);
+        }
+        this.tier1Proofs.set(proof.proofId, proof);
+        // Mark base proofs as aggregated
+        this.markBaseProofsAggregated(proof.baseProofIds);
+    }
+    async getTier1Proof(proofId) {
+        return this.tier1Proofs.get(proofId) ?? null;
+    }
+    async getUnaggregatedTier1Proofs(limit) {
+        if (limit <= 0)
+            return [];
+        const proofs = [];
+        for (const proof of this.tier1Proofs.values()) {
+            if (!this.aggregatedTier1ProofIds.has(proof.proofId)) {
+                proofs.push(proof);
+                if (proofs.length >= limit)
+                    break;
+            }
+        }
+        // Sort by createdAt for deterministic ordering
+        return proofs.sort((a, b) => a.createdAt - b.createdAt);
+    }
+    /**
+     * Mark Tier-1 proofs as aggregated (internal method for aggregator).
+     */
+    markTier1ProofsAggregated(proofIds) {
+        for (const proofId of proofIds) {
+            this.aggregatedTier1ProofIds.add(proofId);
+        }
+    }
+    // ─── Tier-2 Proofs ──────────────────────────────────────────────────────
+    async saveTier2Proof(proof) {
+        if (this.tier2Proofs.has(proof.blockProofId)) {
+            throw new Error(`Tier-2 proof ${proof.blockProofId} already exists`);
+        }
+        this.tier2Proofs.set(proof.blockProofId, proof);
+        // Mark Tier-1 proofs as aggregated
+        this.markTier1ProofsAggregated(proof.tier1ProofIds);
+    }
+    async getTier2Proof(blockProofId) {
+        return this.tier2Proofs.get(blockProofId) ?? null;
+    }
+    async getLatestBlockProof() {
+        let latest = null;
+        for (const proof of this.tier2Proofs.values()) {
+            if (!latest || proof.blockNumber > latest.blockNumber) {
+                latest = proof;
+            }
+        }
+        return latest;
+    }
+    // ─── Utilities ──────────────────────────────────────────────────────────
+    /**
+     * Get statistics about the store (for debugging/monitoring).
+     */
+    getStats() {
+        return {
+            accounts: this.accounts.size,
+            transactions: this.transactions.size,
+            baseProofs: this.baseProofs.size,
+            tier1Proofs: this.tier1Proofs.size,
+            tier2Proofs: this.tier2Proofs.size,
+            aggregatedBaseProofs: this.aggregatedBaseProofIds.size,
+            aggregatedTier1Proofs: this.aggregatedTier1ProofIds.size,
+        };
+    }
+    /**
+     * Clear all data (for testing).
+     */
+    clear() {
+        this.accounts.clear();
+        this.accountsByAddress.clear();
+        this.transactions.clear();
+        this.transactionsByIdempotencyKey.clear();
+        this.baseProofs.clear();
+        this.tier1Proofs.clear();
+        this.tier2Proofs.clear();
+        this.aggregatedBaseProofIds.clear();
+        this.aggregatedTier1ProofIds.clear();
+    }
+}

package/dist/stark-settlement/infrastructure/persistence/offset-store.d.ts

@@ -0,0 +1,30 @@
+/**
+ * In-Memory Offset Store
+ *
+ * Implements OffsetTrackingPort for exactly-once consumption.
+ * Tracks the last committed offset per consumer per asset type.
+ *
+ * @see domain/ports.ts for interface definition
+ */
+import type { AssetType } from "../../domain/entities.js";
+import type { OffsetTrackingPort } from "../../domain/ports.js";
+/**
+ * In-memory implementation of the offset tracking port.
+ */
+export declare class InMemoryOffsetStore implements OffsetTrackingPort {
+    private readonly offsets;
+    private static readonly INITIAL_OFFSET;
+    private makeKey;
+    getOffset(consumerId: string, assetType: AssetType): Promise<bigint>;
+    commitOffset(consumerId: string, assetType: AssetType, offset: bigint): Promise<void>;
+    getConsumerOffsets(assetType: AssetType): Promise<ReadonlyMap<string, bigint>>;
+    /**
+     * Get all offsets (for debugging).
+     */
+    getAllOffsets(): ReadonlyMap<string, bigint>;
+    /**
+     * Clear all offsets (for testing).
+     */
+    clear(): void;
+}
+//# sourceMappingURL=offset-store.d.ts.map

package/dist/stark-settlement/infrastructure/persistence/offset-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offset-store.d.ts","sourceRoot":"","sources":["../../../../src/stark-settlement/infrastructure/persistence/offset-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;GAEG;AACH,qBAAa,mBAAoB,YAAW,kBAAkB;IAG5D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAO;IAE7C,OAAO,CAAC,OAAO;IAIT,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC;IAKpE,YAAY,CAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,IAAI,CAAC;IAeV,kBAAkB,CACtB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAgBvC;;OAEG;IACH,aAAa,IAAI,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC;IAI5C;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd"}

package/dist/stark-settlement/infrastructure/persistence/offset-store.js

@@ -0,0 +1,57 @@
+/**
+ * In-Memory Offset Store
+ *
+ * Implements OffsetTrackingPort for exactly-once consumption.
+ * Tracks the last committed offset per consumer per asset type.
+ *
+ * @see domain/ports.ts for interface definition
+ */
+/**
+ * In-memory implementation of the offset tracking port.
+ */
+export class InMemoryOffsetStore {
+    // Key: "consumerId:assetType", Value: last committed offset
+    // Initial value is -1n so that offset 0n can be committed (0n > -1n)
+    offsets = new Map();
+    static INITIAL_OFFSET = -1n;
+    makeKey(consumerId, assetType) {
+        return `${consumerId}:${assetType}`;
+    }
+    async getOffset(consumerId, assetType) {
+        const key = this.makeKey(consumerId, assetType);
+        return this.offsets.get(key) ?? InMemoryOffsetStore.INITIAL_OFFSET;
+    }
+    async commitOffset(consumerId, assetType, offset) {
+        const key = this.makeKey(consumerId, assetType);
+        const currentOffset = this.offsets.get(key) ?? InMemoryOffsetStore.INITIAL_OFFSET;
+        // Offset must be monotonically increasing (strictly greater than current)
+        if (offset <= currentOffset) {
+            throw new Error(`Cannot commit offset ${offset}: current offset is ${currentOffset}`);
+        }
+        this.offsets.set(key, offset);
+    }
+    async getConsumerOffsets(assetType) {
+        const result = new Map();
+        const suffix = `:${assetType}`;
+        for (const [key, offset] of this.offsets) {
+            if (key.endsWith(suffix)) {
+                const consumerId = key.slice(0, -suffix.length);
+                result.set(consumerId, offset);
+            }
+        }
+        return result;
+    }
+    // ─── Utilities ──────────────────────────────────────────────────────────
+    /**
+     * Get all offsets (for debugging).
+     */
+    getAllOffsets() {
+        return new Map(this.offsets);
+    }
+    /**
+     * Clear all offsets (for testing).
+     */
+    clear() {
+        this.offsets.clear();
+    }
+}

package/dist/stark-settlement/infrastructure/persistence/outbox-store.d.ts

@@ -0,0 +1,45 @@
+/**
+ * In-Memory Outbox Store
+ *
+ * Implements OutboxPort for the settlement queue.
+ * Append-only queue with exactly-once consumption semantics.
+ *
+ * @see domain/ports.ts for interface definition
+ */
+import type { AssetType, OutboxEntry } from "../../domain/entities.js";
+import type { OutboxPort } from "../../domain/ports.js";
+/**
+ * In-memory implementation of the outbox port.
+ */
+export declare class InMemoryOutboxStore implements OutboxPort {
+    private readonly entries;
+    private readonly entriesByAsset;
+    private nextOffset;
+    appendEntry(entry: OutboxEntry): Promise<OutboxEntry>;
+    getPendingEntries(assetType: AssetType, limit: number): Promise<readonly OutboxEntry[]>;
+    getEntry(entryId: string): Promise<OutboxEntry | null>;
+    markProcessing(entryId: string): Promise<void>;
+    markSettled(entryId: string, settlementTxId: string): Promise<void>;
+    markFailed(entryId: string, errorMessage: string): Promise<void>;
+    getRetryableEntries(assetType: AssetType, limit: number): Promise<readonly OutboxEntry[]>;
+    /**
+     * Get statistics about the outbox (for debugging/monitoring).
+     */
+    getStats(): {
+        total: number;
+        pending: number;
+        processing: number;
+        settled: number;
+        failed: number;
+        byAsset: Record<AssetType, number>;
+    };
+    /**
+     * Get the next offset value (for testing).
+     */
+    getNextOffset(): bigint;
+    /**
+     * Clear all entries (for testing).
+     */
+    clear(): void;
+}
+//# sourceMappingURL=outbox-store.d.ts.map

package/dist/stark-settlement/infrastructure/persistence/outbox-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-store.d.ts","sourceRoot":"","sources":["../../../../src/stark-settlement/infrastructure/persistence/outbox-store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD;;GAEG;AACH,qBAAa,mBAAoB,YAAW,UAAU;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAkC;IACjE,OAAO,CAAC,UAAU,CAAM;IAElB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IA4BrD,iBAAiB,CACrB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC;IAkB5B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAItD,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB9C,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBnE,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBhE,mBAAmB,CACvB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC;IAwBlC;;OAEG;IACH,QAAQ,IAAI;QACV,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;KACpC;IAmCD;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,KAAK,IAAI,IAAI;CAKd"}

package/dist/stark-settlement/infrastructure/persistence/outbox-store.js

@@ -0,0 +1,171 @@
+/**
+ * In-Memory Outbox Store
+ *
+ * Implements OutboxPort for the settlement queue.
+ * Append-only queue with exactly-once consumption semantics.
+ *
+ * @see domain/ports.ts for interface definition
+ */
+/**
+ * In-memory implementation of the outbox port.
+ */
+export class InMemoryOutboxStore {
+    entries = new Map();
+    entriesByAsset = new Map();
+    nextOffset = 0n;
+    async appendEntry(entry) {
+        if (this.entries.has(entry.entryId)) {
+            throw new Error(`Outbox entry ${entry.entryId} already exists`);
+        }
+        // Always assign offsets in the store to preserve append-order FIFO semantics.
+        // This ensures entries are correctly ordered regardless of what offset value was passed.
+        const offset = this.nextOffset;
+        this.nextOffset += 1n;
+        const entryWithOffset = {
+            ...entry,
+            offset,
+        };
+        this.entries.set(entry.entryId, entryWithOffset);
+        // Index by asset type - mutate existing array to avoid O(n) copies
+        let assetEntries = this.entriesByAsset.get(entry.assetType);
+        if (!assetEntries) {
+            assetEntries = [];
+            this.entriesByAsset.set(entry.assetType, assetEntries);
+        }
+        assetEntries.push(entry.entryId);
+        return entryWithOffset;
+    }
+    async getPendingEntries(assetType, limit) {
+        if (limit <= 0)
+            return [];
+        const entryIds = this.entriesByAsset.get(assetType) ?? [];
+        const pending = [];
+        // entryIds are appended in FIFO order, so no sorting needed
+        for (const entryId of entryIds) {
+            const entry = this.entries.get(entryId);
+            if (entry && entry.status === "pending") {
+                pending.push(entry);
+                if (pending.length >= limit)
+                    break;
+            }
+        }
+        return pending;
+    }
+    async getEntry(entryId) {
+        return this.entries.get(entryId) ?? null;
+    }
+    async markProcessing(entryId) {
+        const entry = this.entries.get(entryId);
+        if (!entry) {
+            throw new Error(`Outbox entry ${entryId} not found`);
+        }
+        if (entry.status !== "pending" && entry.status !== "failed") {
+            throw new Error(`Cannot mark entry ${entryId} as processing: current status is ${entry.status}`);
+        }
+        const updatedEntry = {
+            ...entry,
+            status: "processing",
+        };
+        this.entries.set(entryId, updatedEntry);
+    }
+    async markSettled(entryId, settlementTxId) {
+        const entry = this.entries.get(entryId);
+        if (!entry) {
+            throw new Error(`Outbox entry ${entryId} not found`);
+        }
+        if (entry.status !== "processing") {
+            throw new Error(`Cannot mark entry ${entryId} as settled: current status is ${entry.status}`);
+        }
+        const updatedEntry = {
+            ...entry,
+            status: "settled",
+            settledAt: Date.now(),
+            settlementTxId,
+        };
+        this.entries.set(entryId, updatedEntry);
+    }
+    async markFailed(entryId, errorMessage) {
+        const entry = this.entries.get(entryId);
+        if (!entry) {
+            throw new Error(`Outbox entry ${entryId} not found`);
+        }
+        if (entry.status !== "processing") {
+            throw new Error(`Cannot mark entry ${entryId} as failed: current status is ${entry.status}`);
+        }
+        const updatedEntry = {
+            ...entry,
+            status: "failed",
+            retryCount: entry.retryCount + 1,
+            errorMessage,
+        };
+        this.entries.set(entryId, updatedEntry);
+    }
+    async getRetryableEntries(assetType, limit) {
+        if (limit <= 0)
+            return [];
+        const entryIds = this.entriesByAsset.get(assetType) ?? [];
+        const retryable = [];
+        // entryIds are appended in FIFO order, so no sorting needed
+        for (const entryId of entryIds) {
+            const entry = this.entries.get(entryId);
+            if (entry &&
+                entry.status === "failed" &&
+                entry.retryCount < entry.maxRetries) {
+                retryable.push(entry);
+                if (retryable.length >= limit)
+                    break;
+            }
+        }
+        return retryable;
+    }
+    // ─── Utilities ──────────────────────────────────────────────────────────
+    /**
+     * Get statistics about the outbox (for debugging/monitoring).
+     */
+    getStats() {
+        let pending = 0;
+        let processing = 0;
+        let settled = 0;
+        let failed = 0;
+        const byAsset = { SOL: 0, BTC: 0, USD: 0 };
+        for (const entry of this.entries.values()) {
+            switch (entry.status) {
+                case "pending":
+                    pending++;
+                    break;
+                case "processing":
+                    processing++;
+                    break;
+                case "settled":
+                    settled++;
+                    break;
+                case "failed":
+                    failed++;
+                    break;
+            }
+            byAsset[entry.assetType]++;
+        }
+        return {
+            total: this.entries.size,
+            pending,
+            processing,
+            settled,
+            failed,
+            byAsset,
+        };
+    }
+    /**
+     * Get the next offset value (for testing).
+     */
+    getNextOffset() {
+        return this.nextOffset;
+    }
+    /**
+     * Clear all entries (for testing).
+     */
+    clear() {
+        this.entries.clear();
+        this.entriesByAsset.clear();
+        this.nextOffset = 0n;
+    }
+}

package/dist/traceability/application/recall-assessor.d.ts

@@ -0,0 +1,13 @@
+import type { RecallAssessment, RecallRule } from "../domain/recall.js";
+import type { TraceabilityRepository } from "../domain/ports.js";
+import type { Logger } from "../../shared/logger.js";
+export declare class RecallAssessor {
+    private readonly repo;
+    private readonly logger;
+    constructor(repo: TraceabilityRepository, logger?: Logger);
+    assess(rule: RecallRule): RecallAssessment;
+    private flagLots;
+    private flagBreachedShipments;
+    private propagateImpact;
+}
+//# sourceMappingURL=recall-assessor.d.ts.map

package/dist/traceability/application/recall-assessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recall-assessor.d.ts","sourceRoot":"","sources":["../../../src/traceability/application/recall-assessor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAGrD,qBAAa,cAAc;IAIvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAGb,IAAI,EAAE,sBAAsB,EAC7C,MAAM,CAAC,EAAE,MAAM;IAKjB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,gBAAgB;IA0C1C,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,qBAAqB;IAwB7B,OAAO,CAAC,eAAe;CAYxB"}

package/dist/traceability/application/recall-assessor.js

@@ -0,0 +1,74 @@
+import { noopLogger } from "../../shared/logger.js";
+export class RecallAssessor {
+    repo;
+    logger;
+    constructor(repo, logger) {
+        this.repo = repo;
+        this.logger = logger ?? noopLogger;
+    }
+    assess(rule) {
+        const start = Date.now();
+        this.logger.info("assessment started", {
+            operation: "RecallAssessor.assess",
+            flaggedLotCount: rule.flaggedLotIds.length,
+            flaggedLotIdsCsv: rule.flaggedLotIds.join(","),
+        });
+        const lotIds = new Set();
+        const shipmentIds = new Set();
+        const destinations = new Set();
+        const reasons = new Set();
+        this.flagLots(rule, lotIds, reasons);
+        this.flagBreachedShipments(rule, lotIds, shipmentIds, destinations, reasons);
+        this.propagateImpact(lotIds, shipmentIds, destinations);
+        const result = {
+            impactedLotIds: [...lotIds].sort(),
+            impactedShipmentIds: [...shipmentIds].sort(),
+            impactedDestinations: [...destinations].sort(),
+            reasons: [...reasons],
+        };
+        this.logger.info("assessment completed", {
+            operation: "RecallAssessor.assess",
+            flaggedLotCount: rule.flaggedLotIds.length,
+            flaggedLotIdsCsv: rule.flaggedLotIds.join(","),
+            result: result.impactedLotIds.length > 0 ? "impacted" : "safe",
+            durationMs: Date.now() - start,
+            impactedLots: result.impactedLotIds.length,
+        });
+        return result;
+    }
+    flagLots(rule, lotIds, reasons) {
+        // Convert arrays to Sets for O(1) lookups instead of O(n) includes()
+        const flaggedLotIdSet = new Set(rule.flaggedLotIds);
+        const suspectSupplierSet = new Set(rule.suspectSuppliers);
+        for (const lot of this.repo.lots.values()) {
+            if (flaggedLotIdSet.has(lot.id)) {
+                lotIds.add(lot.id);
+                reasons.add(`Lot ${lot.id} was explicitly flagged by quality assurance.`);
+            }
+            if (suspectSupplierSet.has(lot.supplier)) {
+                lotIds.add(lot.id);
+                reasons.add(`Supplier ${lot.supplier} was placed under investigation.`);
+            }
+        }
+    }
+    flagBreachedShipments(rule, lotIds, shipmentIds, destinations, reasons) {
+        for (const shipment of this.repo.shipments.values()) {
+            const readings = this.repo.getTelemetry(shipment.id);
+            const breached = readings.some((r) => r.temperatureCelsius > rule.maxTemperatureCelsius);
+            if (breached) {
+                lotIds.add(shipment.lotId);
+                shipmentIds.add(shipment.id);
+                destinations.add(shipment.to);
+                reasons.add(`Shipment ${shipment.id} exceeded ${rule.maxTemperatureCelsius}C cold-chain limits.`);
+            }
+        }
+    }
+    propagateImpact(lotIds, shipmentIds, destinations) {
+        for (const shipment of this.repo.shipments.values()) {
+            if (lotIds.has(shipment.lotId)) {
+                shipmentIds.add(shipment.id);
+                destinations.add(shipment.to);
+            }
+        }
+    }
+}

package/dist/traceability/domain/entities.d.ts

@@ -0,0 +1,23 @@
+export interface ProductLot {
+    readonly id: string;
+    readonly productName: string;
+    readonly supplier: string;
+    readonly originCountry: string;
+    readonly harvestDate: string;
+    readonly expirationDate: string;
+}
+export interface Shipment {
+    readonly id: string;
+    readonly lotId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly departedAt: string;
+    readonly receivedAt?: string;
+}
+export interface TelemetryReading {
+    readonly shipmentId: string;
+    readonly timestamp: string;
+    readonly temperatureCelsius: number;
+    readonly location: string;
+}
+//# sourceMappingURL=entities.d.ts.map

package/dist/traceability/domain/entities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../../../src/traceability/domain/entities.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B"}

package/dist/traceability/domain/entities.js

@@ -0,0 +1 @@
+export {};