@wopr-network/platform-core 1.23.0 → 1.25.0

package/dist/billing/crypto/btc/watcher.d.ts

@@ -1,3 +1,4 @@
+import type { IWatcherCursorStore } from "../cursor-store.js";
 import type { IPriceOracle } from "../oracle/types.js";
 import type { BitcoindConfig, BtcPaymentEvent } from "./types.js";
 type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
@@ -9,6 +10,8 @@ export interface BtcWatcherOpts {
     onPayment: (event: BtcPaymentEvent) => void | Promise<void>;
     /** Price oracle for BTC/USD conversion. */
     oracle: IPriceOracle;
+    /** Required — BTC has no block cursor, so txid dedup must be persisted. */
+    cursorStore: IWatcherCursorStore;
 }
 export declare class BtcWatcher {
     private readonly rpc;
@@ -16,7 +19,8 @@ export declare class BtcWatcher {
     private readonly onPayment;
     private readonly minConfirmations;
     private readonly oracle;
-    private readonly processedTxids;
+    private readonly cursorStore;
+    private readonly watcherId;
     constructor(opts: BtcWatcherOpts);
     /** Update the set of watched addresses. */
     setWatchedAddresses(addresses: string[]): void;

package/dist/billing/crypto/btc/watcher.js

@@ -4,13 +4,16 @@ export class BtcWatcher {
     onPayment;
     minConfirmations;
     oracle;
-    processedTxids = new Set();
+    cursorStore;
+    watcherId;
     constructor(opts) {
         this.rpc = opts.rpcCall;
         this.addresses = new Set(opts.watchedAddresses);
         this.onPayment = opts.onPayment;
         this.minConfirmations = opts.config.confirmations;
         this.oracle = opts.oracle;
+        this.cursorStore = opts.cursorStore;
+        this.watcherId = `btc:${opts.config.network}`;
     }
     /** Update the set of watched addresses. */
     setWatchedAddresses(addresses) {
@@ -37,7 +40,8 @@ export class BtcWatcher {
             if (!this.addresses.has(entry.address))
                 continue;
             for (const txid of entry.txids) {
-                if (this.processedTxids.has(txid))
+                // Skip already-processed txids (persisted to DB, survives restart)
+                if (await this.cursorStore.hasProcessedTx(this.watcherId, txid))
                     continue;
                 // Get transaction details for the exact amount sent to this address
                 const tx = (await this.rpc("gettransaction", [txid, true]));
@@ -55,8 +59,8 @@ export class BtcWatcher {
                     confirmations: tx.confirmations,
                 };
                 await this.onPayment(event);
-                // Add AFTER successful onPayment to avoid skipping on failure
-                this.processedTxids.add(txid);
+                // Persist AFTER successful onPayment — survives restart, no unbounded memory
+                await this.cursorStore.markProcessedTx(this.watcherId, txid);
             }
         }
     }

package/dist/billing/crypto/cursor-store.d.ts

@@ -0,0 +1,28 @@
+import type { PlatformDb } from "../../db/index.js";
+export interface IWatcherCursorStore {
+    /** Get persisted block cursor for a watcher. */
+    get(watcherId: string): Promise<number | null>;
+    /** Save block cursor after processing a range. */
+    save(watcherId: string, cursorBlock: number): Promise<void>;
+    /** Check if a specific tx has been processed (for watchers without block cursors). */
+    hasProcessedTx(watcherId: string, txId: string): Promise<boolean>;
+    /** Mark a tx as processed (for watchers without block cursors). */
+    markProcessedTx(watcherId: string, txId: string): Promise<void>;
+}
+/**
+ * Persists watcher state to PostgreSQL.
+ *
+ * Two patterns:
+ *   - Block cursor (EVM watchers): save/get cursor block number
+ *   - Processed txids (BTC watcher): hasProcessedTx/markProcessedTx
+ *
+ * Eliminates all in-memory watcher state. Clean restart recovery.
+ */
+export declare class DrizzleWatcherCursorStore implements IWatcherCursorStore {
+    private readonly db;
+    constructor(db: PlatformDb);
+    get(watcherId: string): Promise<number | null>;
+    save(watcherId: string, cursorBlock: number): Promise<void>;
+    hasProcessedTx(watcherId: string, txId: string): Promise<boolean>;
+    markProcessedTx(watcherId: string, txId: string): Promise<void>;
+}

package/dist/billing/crypto/cursor-store.js

@@ -0,0 +1,43 @@
+import { and, eq, sql } from "drizzle-orm";
+import { watcherCursors, watcherProcessed } from "../../db/schema/crypto.js";
+/**
+ * Persists watcher state to PostgreSQL.
+ *
+ * Two patterns:
+ *   - Block cursor (EVM watchers): save/get cursor block number
+ *   - Processed txids (BTC watcher): hasProcessedTx/markProcessedTx
+ *
+ * Eliminates all in-memory watcher state. Clean restart recovery.
+ */
+export class DrizzleWatcherCursorStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(watcherId) {
+        const row = (await this.db
+            .select({ cursorBlock: watcherCursors.cursorBlock })
+            .from(watcherCursors)
+            .where(eq(watcherCursors.watcherId, watcherId)))[0];
+        return row?.cursorBlock ?? null;
+    }
+    async save(watcherId, cursorBlock) {
+        await this.db
+            .insert(watcherCursors)
+            .values({ watcherId, cursorBlock })
+            .onConflictDoUpdate({
+            target: watcherCursors.watcherId,
+            set: { cursorBlock, updatedAt: sql `(now())` },
+        });
+    }
+    async hasProcessedTx(watcherId, txId) {
+        const row = (await this.db
+            .select({ txId: watcherProcessed.txId })
+            .from(watcherProcessed)
+            .where(and(eq(watcherProcessed.watcherId, watcherId), eq(watcherProcessed.txId, txId))))[0];
+        return row !== undefined;
+    }
+    async markProcessedTx(watcherId, txId) {
+        await this.db.insert(watcherProcessed).values({ watcherId, txId }).onConflictDoNothing();
+    }
+}

package/dist/billing/crypto/evm/eth-watcher.d.ts

@@ -1,3 +1,4 @@
+import type { IWatcherCursorStore } from "../cursor-store.js";
 import type { IPriceOracle } from "../oracle/types.js";
 import type { EvmChain } from "./types.js";
 type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
@@ -20,6 +21,7 @@ export interface EthWatcherOpts {
     fromBlock: number;
     onPayment: (event: EthPaymentEvent) => void | Promise<void>;
     watchedAddresses?: string[];
+    cursorStore?: IWatcherCursorStore;
 }
 /**
  * Native ETH transfer watcher.
@@ -28,7 +30,9 @@ export interface EthWatcherOpts {
  * this scans blocks for transactions where `to` matches a watched deposit
  * address and `value > 0`.
  *
- * Uses the price oracle to convert wei → USD cents at detection time.
+ * Processes one block at a time and persists cursor after each block.
+ * On restart, resumes from the last committed cursor — no replay, no
+ * unbounded in-memory state.
  */
 export declare class EthWatcher {
     private _cursor;
@@ -37,16 +41,20 @@ export declare class EthWatcher {
     private readonly oracle;
     private readonly onPayment;
     private readonly confirmations;
+    private readonly cursorStore?;
+    private readonly watcherId;
     private _watchedAddresses;
-    private readonly processedTxids;
     constructor(opts: EthWatcherOpts);
+    /** Load cursor from DB. Call once at startup before first poll. */
+    init(): Promise<void>;
     setWatchedAddresses(addresses: string[]): void;
     get cursor(): number;
     /**
      * Poll for new native ETH transfers to watched addresses.
      *
-     * Scans each confirmed block's transactions. Only processes txs
-     * where `to` is in the watched set and `value > 0`.
+     * Processes one block at a time. After each block is fully processed,
+     * the cursor is persisted to the DB. If onPayment fails mid-block,
+     * the cursor hasn't advanced — the entire block is retried on next poll.
      */
     poll(): Promise<void>;
 }

package/dist/billing/crypto/evm/eth-watcher.js

@@ -7,7 +7,9 @@ import { getChainConfig } from "./config.js";
  * this scans blocks for transactions where `to` matches a watched deposit
  * address and `value > 0`.
  *
- * Uses the price oracle to convert wei → USD cents at detection time.
+ * Processes one block at a time and persists cursor after each block.
+ * On restart, resumes from the last committed cursor — no replay, no
+ * unbounded in-memory state.
  */
 export class EthWatcher {
     _cursor;
@@ -16,8 +18,9 @@ export class EthWatcher {
     oracle;
     onPayment;
     confirmations;
+    cursorStore;
+    watcherId;
     _watchedAddresses;
-    processedTxids = new Set();
     constructor(opts) {
         this.chain = opts.chain;
         this.rpc = opts.rpcCall;
@@ -25,8 +28,18 @@ export class EthWatcher {
         this._cursor = opts.fromBlock;
         this.onPayment = opts.onPayment;
         this.confirmations = getChainConfig(opts.chain).confirmations;
+        this.cursorStore = opts.cursorStore;
+        this.watcherId = `eth:${opts.chain}`;
         this._watchedAddresses = new Set((opts.watchedAddresses ?? []).map((a) => a.toLowerCase()));
     }
+    /** Load cursor from DB. Call once at startup before first poll. */
+    async init() {
+        if (!this.cursorStore)
+            return;
+        const saved = await this.cursorStore.get(this.watcherId);
+        if (saved !== null)
+            this._cursor = saved;
+    }
     setWatchedAddresses(addresses) {
         this._watchedAddresses = new Set(addresses.map((a) => a.toLowerCase()));
     }
@@ -36,8 +49,9 @@ export class EthWatcher {
     /**
      * Poll for new native ETH transfers to watched addresses.
      *
-     * Scans each confirmed block's transactions. Only processes txs
-     * where `to` is in the watched set and `value > 0`.
+     * Processes one block at a time. After each block is fully processed,
+     * the cursor is persisted to the DB. If onPayment fails mid-block,
+     * the cursor hasn't advanced — the entire block is retried on next poll.
      */
     async poll() {
         if (this._watchedAddresses.size === 0)
@@ -61,8 +75,6 @@ export class EthWatcher {
                 const valueWei = BigInt(tx.value);
                 if (valueWei === 0n)
                     continue;
-                if (this.processedTxids.has(tx.hash))
-                    continue;
                 const amountUsdCents = nativeToCents(valueWei, priceCents, 18);
                 const event = {
                     chain: this.chain,
@@ -74,10 +86,12 @@ export class EthWatcher {
                     blockNumber: blockNum,
                 };
                 await this.onPayment(event);
-                // Add to processed AFTER successful onPayment to avoid skipping on failure
-                this.processedTxids.add(tx.hash);
+            }
+            // Block fully processed — persist cursor so we never re-scan it.
+            this._cursor = blockNum + 1;
+            if (this.cursorStore) {
+                await this.cursorStore.save(this.watcherId, this._cursor);
             }
         }
-        this._cursor = confirmed + 1;
     }
 }

package/dist/billing/crypto/evm/watcher.d.ts

@@ -1,3 +1,4 @@
+import type { IWatcherCursorStore } from "../cursor-store.js";
 import type { EvmChain, EvmPaymentEvent, StablecoinToken } from "./types.js";
 type RpcCall = (method: string, params: unknown[]) => Promise<unknown>;
 export interface EvmWatcherOpts {
@@ -8,6 +9,7 @@ export interface EvmWatcherOpts {
     onPayment: (event: EvmPaymentEvent) => void | Promise<void>;
     /** Active deposit addresses to watch. Filters eth_getLogs by topic[2] (to address). */
     watchedAddresses?: string[];
+    cursorStore?: IWatcherCursorStore;
 }
 export declare class EvmWatcher {
     private _cursor;
@@ -18,8 +20,12 @@ export declare class EvmWatcher {
     private readonly confirmations;
     private readonly contractAddress;
     private readonly decimals;
+    private readonly cursorStore?;
+    private readonly watcherId;
     private _watchedAddresses;
     constructor(opts: EvmWatcherOpts);
+    /** Load cursor from DB. Call once at startup before first poll. */
+    init(): Promise<void>;
     /** Update the set of watched deposit addresses (e.g. after a new checkout). */
     setWatchedAddresses(addresses: string[]): void;
     get cursor(): number;

package/dist/billing/crypto/evm/watcher.js

@@ -9,6 +9,8 @@ export class EvmWatcher {
     confirmations;
     contractAddress;
     decimals;
+    cursorStore;
+    watcherId;
     _watchedAddresses;
     constructor(opts) {
         this.chain = opts.chain;
@@ -16,6 +18,8 @@ export class EvmWatcher {
         this.rpc = opts.rpcCall;
         this._cursor = opts.fromBlock;
         this.onPayment = opts.onPayment;
+        this.cursorStore = opts.cursorStore;
+        this.watcherId = `evm:${opts.chain}:${opts.token}`;
         this._watchedAddresses = (opts.watchedAddresses ?? []).map((a) => a.toLowerCase());
         const chainCfg = getChainConfig(opts.chain);
         const tokenCfg = getTokenConfig(opts.token, opts.chain);
@@ -23,6 +27,14 @@ export class EvmWatcher {
         this.contractAddress = tokenCfg.contractAddress.toLowerCase();
         this.decimals = tokenCfg.decimals;
     }
+    /** Load cursor from DB. Call once at startup before first poll. */
+    async init() {
+        if (!this.cursorStore)
+            return;
+        const saved = await this.cursorStore.get(this.watcherId);
+        if (saved !== null)
+            this._cursor = saved;
+    }
     /** Update the set of watched deposit addresses (e.g. after a new checkout). */
     setWatchedAddresses(addresses) {
         this._watchedAddresses = addresses.map((a) => a.toLowerCase());
@@ -53,25 +65,50 @@ export class EvmWatcher {
                 toBlock: `0x${confirmed.toString(16)}`,
             },
         ]));
+        // Group logs by block for incremental cursor checkpointing.
+        // If onPayment fails mid-batch, only the current block is replayed on next poll.
+        const logsByBlock = new Map();
         for (const log of logs) {
-            const to = `0x${log.topics[2].slice(26)}`.toLowerCase();
-            const from = `0x${log.topics[1].slice(26)}`.toLowerCase();
-            const rawAmount = BigInt(log.data);
-            const amountUsdCents = centsFromTokenAmount(rawAmount, this.decimals);
-            const event = {
-                chain: this.chain,
-                token: this.token,
-                from,
-                to,
-                rawAmount: rawAmount.toString(),
-                amountUsdCents,
-                txHash: log.transactionHash,
-                blockNumber: Number.parseInt(log.blockNumber, 16),
-                logIndex: Number.parseInt(log.logIndex, 16),
-            };
-            await this.onPayment(event);
+            const bn = Number.parseInt(log.blockNumber, 16);
+            const arr = logsByBlock.get(bn);
+            if (arr)
+                arr.push(log);
+            else
+                logsByBlock.set(bn, [log]);
+        }
+        // Process blocks in order, checkpoint after each.
+        const blockNums = [...logsByBlock.keys()].sort((a, b) => a - b);
+        for (const blockNum of blockNums) {
+            for (const log of logsByBlock.get(blockNum) ?? []) {
+                const to = `0x${log.topics[2].slice(26)}`.toLowerCase();
+                const from = `0x${log.topics[1].slice(26)}`.toLowerCase();
+                const rawAmount = BigInt(log.data);
+                const amountUsdCents = centsFromTokenAmount(rawAmount, this.decimals);
+                const event = {
+                    chain: this.chain,
+                    token: this.token,
+                    from,
+                    to,
+                    rawAmount: rawAmount.toString(),
+                    amountUsdCents,
+                    txHash: log.transactionHash,
+                    blockNumber: blockNum,
+                    logIndex: Number.parseInt(log.logIndex, 16),
+                };
+                await this.onPayment(event);
+            }
+            this._cursor = blockNum + 1;
+            if (this.cursorStore) {
+                await this.cursorStore.save(this.watcherId, this._cursor);
+            }
+        }
+        // Advance cursor even if no logs were found in the range.
+        if (blockNums.length === 0) {
+            this._cursor = confirmed + 1;
+            if (this.cursorStore) {
+                await this.cursorStore.save(this.watcherId, this._cursor);
+            }
         }
-        this._cursor = confirmed + 1;
     }
 }
 /** Create an RPC caller for a given URL (plain JSON-RPC over fetch). */

package/dist/billing/crypto/index.d.ts

@@ -4,6 +4,8 @@ export { CryptoChargeRepository, DrizzleCryptoChargeRepository } from "./charge-
 export { createCryptoCheckout, MIN_PAYMENT_USD } from "./checkout.js";
 export type { CryptoConfig } from "./client.js";
 export { BTCPayClient, loadCryptoConfig } from "./client.js";
+export type { IWatcherCursorStore } from "./cursor-store.js";
+export { DrizzleWatcherCursorStore } from "./cursor-store.js";
 export * from "./evm/index.js";
 export * from "./oracle/index.js";
 export type { CryptoBillingConfig, CryptoCheckoutOpts, CryptoPaymentState, CryptoWebhookPayload, CryptoWebhookResult, } from "./types.js";

package/dist/billing/crypto/index.js

@@ -2,6 +2,7 @@ export * from "./btc/index.js";
 export { CryptoChargeRepository, DrizzleCryptoChargeRepository } from "./charge-store.js";
 export { createCryptoCheckout, MIN_PAYMENT_USD } from "./checkout.js";
 export { BTCPayClient, loadCryptoConfig } from "./client.js";
+export { DrizzleWatcherCursorStore } from "./cursor-store.js";
 export * from "./evm/index.js";
 export * from "./oracle/index.js";
 export { mapBtcPayEventToStatus } from "./types.js";

package/dist/db/schema/crypto.d.ts

@@ -234,3 +234,124 @@ export declare const cryptoCharges: import("drizzle-orm/pg-core").PgTableWithCol
     };
     dialect: "pg";
 }>;
+/**
+ * Watcher cursor persistence — tracks the last processed block per watcher.
+ * Eliminates in-memory processedTxids and enables clean restart recovery.
+ */
+export declare const watcherCursors: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "watcher_cursors";
+    schema: undefined;
+    columns: {
+        watcherId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "watcher_id";
+            tableName: "watcher_cursors";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        cursorBlock: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cursor_block";
+            tableName: "watcher_cursors";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "watcher_cursors";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+/** Processed transaction IDs for watchers without block cursors (e.g. BTC). */
+export declare const watcherProcessed: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "watcher_processed";
+    schema: undefined;
+    columns: {
+        watcherId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "watcher_id";
+            tableName: "watcher_processed";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        txId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tx_id";
+            tableName: "watcher_processed";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        processedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "processed_at";
+            tableName: "watcher_processed";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/db/schema/crypto.js

@@ -1,5 +1,5 @@
 import { sql } from "drizzle-orm";
-import { index, integer, pgTable, text } from "drizzle-orm/pg-core";
+import { index, integer, pgTable, primaryKey, text } from "drizzle-orm/pg-core";
 /**
  * Crypto payment charges — tracks the lifecycle of each BTCPay invoice.
  * reference_id is the BTCPay invoice ID.
@@ -30,3 +30,18 @@ export const cryptoCharges = pgTable("crypto_charges", {
     // Unique indexes use WHERE IS NOT NULL partial indexes (declared in migration SQL).
     // Enforced via migration: CREATE UNIQUE INDEX.
 ]);
+/**
+ * Watcher cursor persistence — tracks the last processed block per watcher.
+ * Eliminates in-memory processedTxids and enables clean restart recovery.
+ */
+export const watcherCursors = pgTable("watcher_cursors", {
+    watcherId: text("watcher_id").primaryKey(),
+    cursorBlock: integer("cursor_block").notNull(),
+    updatedAt: text("updated_at").notNull().default(sql `(now())`),
+});
+/** Processed transaction IDs for watchers without block cursors (e.g. BTC). */
+export const watcherProcessed = pgTable("watcher_processed", {
+    watcherId: text("watcher_id").notNull(),
+    txId: text("tx_id").notNull(),
+    processedAt: text("processed_at").notNull().default(sql `(now())`),
+}, (table) => [primaryKey({ columns: [table.watcherId, table.txId] })]);

package/dist/fleet/__tests__/init-fleet-updater.test.d.ts

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

package/dist/fleet/__tests__/init-fleet-updater.test.js

@@ -0,0 +1,93 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { initFleetUpdater } from "../init-fleet-updater.js";
+function mockDocker() {
+    return {};
+}
+function mockFleet() {
+    return {};
+}
+function mockStore() {
+    return {
+        list: vi.fn(async () => []),
+        get: vi.fn(async () => undefined),
+        save: vi.fn(async () => { }),
+        delete: vi.fn(async () => { }),
+    };
+}
+function mockRepo(profiles = []) {
+    return {
+        list: vi.fn(async () => profiles),
+        get: vi.fn(async () => null),
+        save: vi.fn(async (p) => p),
+        delete: vi.fn(async () => true),
+    };
+}
+describe("initFleetUpdater", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("returns a handle with all components", async () => {
+        const handle = initFleetUpdater(mockDocker(), mockFleet(), mockStore(), mockRepo());
+        expect(handle.poller).toBeDefined();
+        expect(handle.updater).toBeDefined();
+        expect(handle.orchestrator).toBeDefined();
+        expect(handle.snapshotManager).toBeDefined();
+        expect(handle.stop).toBeTypeOf("function");
+        await handle.stop();
+    });
+    it("wires poller.onUpdateAvailable to orchestrator", async () => {
+        const handle = initFleetUpdater(mockDocker(), mockFleet(), mockStore(), mockRepo());
+        expect(handle.poller.onUpdateAvailable).toBeTypeOf("function");
+        await handle.stop();
+    });
+    it("accepts custom strategy config", async () => {
+        const handle = initFleetUpdater(mockDocker(), mockFleet(), mockStore(), mockRepo(), {
+            strategy: "immediate",
+            snapshotDir: "/tmp/snapshots",
+        });
+        expect(handle.orchestrator).toBeDefined();
+        await handle.stop();
+    });
+    it("accepts callbacks", async () => {
+        const onBotUpdated = vi.fn();
+        const onRolloutComplete = vi.fn();
+        const handle = initFleetUpdater(mockDocker(), mockFleet(), mockStore(), mockRepo(), {
+            onBotUpdated,
+            onRolloutComplete,
+        });
+        expect(handle.orchestrator).toBeDefined();
+        await handle.stop();
+    });
+    it("stop() stops the poller", async () => {
+        const handle = initFleetUpdater(mockDocker(), mockFleet(), mockStore(), mockRepo());
+        const stopSpy = vi.spyOn(handle.poller, "stop");
+        await handle.stop();
+        expect(stopSpy).toHaveBeenCalled();
+    });
+    it("filters manual-policy bots from updatable profiles", async () => {
+        const repo = mockRepo([
+            { id: "b1", updatePolicy: "nightly" },
+            { id: "b2", updatePolicy: "manual" },
+            { id: "b3", updatePolicy: "on-push" },
+        ]);
+        const handle = initFleetUpdater(mockDocker(), mockFleet(), mockStore(), repo, {
+            strategy: "immediate",
+        });
+        const rolloutResult = await handle.orchestrator.rollout();
+        // b2 (manual) should be filtered out, b1 and b3 included
+        expect(rolloutResult.totalBots).toBe(2);
+        await handle.stop();
+    });
+    it("uses profileRepo for updatable profiles, not profileStore", async () => {
+        const store = mockStore();
+        const repo = mockRepo([{ id: "b1", updatePolicy: "nightly" }]);
+        const handle = initFleetUpdater(mockDocker(), mockFleet(), store, repo, {
+            strategy: "immediate",
+        });
+        await handle.orchestrator.rollout();
+        // profileRepo.list() was called for updatable profiles
+        expect(repo.list).toHaveBeenCalled();
+        // profileStore.list() may also be called by ImagePoller — that's expected
+        await handle.stop();
+    });
+});

package/dist/fleet/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./init-fleet-updater.js";
 export * from "./repository-types.js";
 export * from "./rollout-orchestrator.js";
 export * from "./rollout-strategy.js";

package/dist/fleet/index.js

@@ -1,3 +1,4 @@
+export * from "./init-fleet-updater.js";
 export * from "./repository-types.js";
 export * from "./rollout-orchestrator.js";
 export * from "./rollout-strategy.js";