@wopr-network/platform-core 1.39.2 → 1.39.4

package/dist/credits/credit.js

@@ -91,15 +91,27 @@ export class Credit {
     }
     /** Add another Credit, returning a new Credit. */
     add(other) {
-        return new Credit(this.raw + other.raw);
+        const result = this.raw + other.raw;
+        if (!Number.isSafeInteger(result)) {
+            throw new RangeError(`Credit.add overflow: ${this.raw} + ${other.raw} = ${result}`);
+        }
+        return new Credit(result);
     }
     /** Subtract another Credit, returning a new Credit (may be negative). */
     subtract(other) {
-        return new Credit(this.raw - other.raw);
+        const result = this.raw - other.raw;
+        if (!Number.isSafeInteger(result)) {
+            throw new RangeError(`Credit.subtract overflow: ${this.raw} - ${other.raw} = ${result}`);
+        }
+        return new Credit(result);
     }
     /** Multiply by a factor, rounding to nearest raw unit. */
     multiply(factor) {
-        return new Credit(Math.round(this.raw * factor));
+        const result = Math.round(this.raw * factor);
+        if (!Number.isSafeInteger(result)) {
+            throw new RangeError(`Credit.multiply overflow: ${this.raw} * ${factor} = ${result}`);
+        }
+        return new Credit(result);
     }
     /** True if this credit is negative. */
     isNegative() {

package/dist/credits/credit.test.js

@@ -103,6 +103,38 @@ describe("Credit", () => {
         it("multiply by zero gives zero", () => {
             expect(Credit.fromDollars(5).multiply(0).isZero()).toBe(true);
         });
+        it("add throws RangeError on positive overflow", () => {
+            const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+            const b = Credit.fromRaw(1);
+            expect(() => a.add(b)).toThrow(RangeError);
+        });
+        it("subtract throws RangeError on negative overflow", () => {
+            const a = Credit.fromRaw(-Number.MAX_SAFE_INTEGER);
+            const b = Credit.fromRaw(1);
+            expect(() => a.subtract(b)).toThrow(RangeError);
+        });
+        it("multiply throws RangeError on overflow", () => {
+            const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+            expect(() => a.multiply(2)).toThrow(RangeError);
+        });
+        it("multiply throws RangeError on Infinity factor", () => {
+            const a = Credit.fromRaw(1);
+            expect(() => a.multiply(Infinity)).toThrow(RangeError);
+        });
+        it("multiply throws RangeError on NaN factor", () => {
+            const a = Credit.fromRaw(1);
+            expect(() => a.multiply(NaN)).toThrow(RangeError);
+        });
+        it("add does not throw for values within safe range", () => {
+            const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER - 1);
+            const b = Credit.fromRaw(1);
+            expect(a.add(b).toRaw()).toBe(Number.MAX_SAFE_INTEGER);
+        });
+        it("subtract does not throw for values within safe range", () => {
+            const a = Credit.fromRaw(-(Number.MAX_SAFE_INTEGER - 1));
+            const b = Credit.fromRaw(1);
+            expect(a.subtract(b).toRaw()).toBe(-Number.MAX_SAFE_INTEGER);
+        });
     });
     describe("comparison", () => {
         it("isNegative returns true for negative", () => {

package/dist/monetization/credits/runtime-cron.js

@@ -59,69 +59,95 @@ export async function runRuntimeDeductions(cfg) {
     for (const { tenantId, balance } of tenants) {
         try {
             const runtimeRef = `runtime:${cfg.date}:${tenantId}`;
-            if (await cfg.ledger.hasReferenceId(runtimeRef)) {
-                result.skipped.push(tenantId);
-                continue;
-            }
+            const runtimeAlreadyBilled = await cfg.ledger.hasReferenceId(runtimeRef);
             const botCount = await cfg.getActiveBotCount(tenantId);
-            if (botCount <= 0)
+            if (botCount <= 0) {
+                if (runtimeAlreadyBilled)
+                    result.skipped.push(tenantId);
                 continue;
+            }
             const totalCost = DAILY_BOT_COST.multiply(botCount);
-            if (!balance.lessThan(totalCost)) {
-                // Full deduction
-                await cfg.ledger.debit(tenantId, totalCost, "bot_runtime", {
-                    description: `Daily runtime: ${botCount} bot(s) x $${DAILY_BOT_COST.toDollars().toFixed(2)}`,
-                    referenceId: runtimeRef,
-                });
-                // Debit resource tier surcharges (if any)
-                if (cfg.getResourceTierCosts) {
+            let didBillAnything = false;
+            // Bill runtime debit (skipped if already billed on a previous run)
+            if (!runtimeAlreadyBilled) {
+                if (!balance.lessThan(totalCost)) {
+                    // Full deduction
+                    await cfg.ledger.debit(tenantId, totalCost, "bot_runtime", {
+                        description: `Daily runtime: ${botCount} bot(s) x $${DAILY_BOT_COST.toDollars().toFixed(2)}`,
+                        referenceId: runtimeRef,
+                    });
+                }
+                else {
+                    // Partial deduction — balance insufficient to cover full cost; debit what's available and suspend
+                    if (balance.greaterThan(Credit.ZERO)) {
+                        await cfg.ledger.debit(tenantId, balance, "bot_runtime", {
+                            description: `Partial daily runtime (balance exhausted): ${botCount} bot(s)`,
+                            referenceId: runtimeRef,
+                        });
+                    }
+                    if (!result.suspended.includes(tenantId)) {
+                        result.suspended.push(tenantId);
+                        if (cfg.onSuspend)
+                            await cfg.onSuspend(tenantId);
+                    }
+                }
+                didBillAnything = true;
+            }
+            // Debit resource tier surcharges (if any) — independent idempotency
+            if (cfg.getResourceTierCosts) {
+                const tierRef = `runtime-tier:${cfg.date}:${tenantId}`;
+                if (!(await cfg.ledger.hasReferenceId(tierRef))) {
                     const tierCost = await cfg.getResourceTierCosts(tenantId);
                     if (!tierCost.isZero()) {
                         const balanceAfterRuntime = await cfg.ledger.balance(tenantId);
                         if (!balanceAfterRuntime.lessThan(tierCost)) {
                             await cfg.ledger.debit(tenantId, tierCost, "resource_upgrade", {
                                 description: "Daily resource tier surcharge",
-                                referenceId: `runtime-tier:${cfg.date}:${tenantId}`,
+                                referenceId: tierRef,
                             });
                         }
                         else if (balanceAfterRuntime.greaterThan(Credit.ZERO)) {
                             await cfg.ledger.debit(tenantId, balanceAfterRuntime, "resource_upgrade", {
                                 description: "Partial resource tier surcharge (balance exhausted)",
-                                referenceId: `runtime-tier:${cfg.date}:${tenantId}`,
+                                referenceId: tierRef,
                             });
                         }
+                        didBillAnything = true;
                     }
                 }
-                const newBalance = await cfg.ledger.balance(tenantId);
-                // Fire onLowBalance if balance crossed below threshold from above
-                if (newBalance.greaterThan(Credit.ZERO) &&
-                    !newBalance.greaterThan(LOW_BALANCE_THRESHOLD) &&
-                    balance.greaterThan(LOW_BALANCE_THRESHOLD) &&
-                    cfg.onLowBalance) {
-                    await cfg.onLowBalance(tenantId, newBalance);
-                }
-                // Fire onCreditsExhausted if balance just hit 0
-                if (!newBalance.greaterThan(Credit.ZERO) && balance.greaterThan(Credit.ZERO) && cfg.onCreditsExhausted) {
-                    await cfg.onCreditsExhausted(tenantId);
-                }
-                // Suspend tenant when balance hits zero after full deduction (zero-crossing guard)
-                if (!newBalance.greaterThan(Credit.ZERO) &&
-                    balance.greaterThan(Credit.ZERO) &&
-                    !result.suspended.includes(tenantId)) {
-                    result.suspended.push(tenantId);
-                    if (cfg.onSuspend) {
-                        await cfg.onSuspend(tenantId);
-                    }
+            }
+            const newBalance = await cfg.ledger.balance(tenantId);
+            // Fire onLowBalance if balance crossed below threshold from above
+            if (newBalance.greaterThan(Credit.ZERO) &&
+                !newBalance.greaterThan(LOW_BALANCE_THRESHOLD) &&
+                balance.greaterThan(LOW_BALANCE_THRESHOLD) &&
+                cfg.onLowBalance) {
+                await cfg.onLowBalance(tenantId, newBalance);
+            }
+            // Fire onCreditsExhausted if balance just hit 0
+            if (!newBalance.greaterThan(Credit.ZERO) && balance.greaterThan(Credit.ZERO) && cfg.onCreditsExhausted) {
+                await cfg.onCreditsExhausted(tenantId);
+            }
+            // Suspend tenant when balance hits zero (zero-crossing guard)
+            if (!newBalance.greaterThan(Credit.ZERO) &&
+                balance.greaterThan(Credit.ZERO) &&
+                !result.suspended.includes(tenantId)) {
+                result.suspended.push(tenantId);
+                if (cfg.onSuspend) {
+                    await cfg.onSuspend(tenantId);
                 }
-                // Debit storage tier surcharges (if any)
-                if (cfg.getStorageTierCosts) {
+            }
+            // Debit storage tier surcharges (if any) — independent idempotency
+            if (cfg.getStorageTierCosts) {
+                const storageRef = `runtime-storage:${cfg.date}:${tenantId}`;
+                if (!(await cfg.ledger.hasReferenceId(storageRef))) {
                     const storageCost = await cfg.getStorageTierCosts(tenantId);
                     if (!storageCost.isZero()) {
                         const currentBalance = await cfg.ledger.balance(tenantId);
                         if (!currentBalance.lessThan(storageCost)) {
                             await cfg.ledger.debit(tenantId, storageCost, "storage_upgrade", {
                                 description: "Daily storage tier surcharge",
-                                referenceId: `runtime-storage:${cfg.date}:${tenantId}`,
+                                referenceId: storageRef,
                             });
                         }
                         else {
@@ -129,7 +155,7 @@ export async function runRuntimeDeductions(cfg) {
                             if (currentBalance.greaterThan(Credit.ZERO)) {
                                 await cfg.ledger.debit(tenantId, currentBalance, "storage_upgrade", {
                                     description: "Partial storage tier surcharge (balance exhausted)",
-                                    referenceId: `runtime-storage:${cfg.date}:${tenantId}`,
+                                    referenceId: storageRef,
                                 });
                             }
                             if (!result.suspended.includes(tenantId)) {
@@ -138,17 +164,21 @@ export async function runRuntimeDeductions(cfg) {
                                     await cfg.onSuspend(tenantId);
                             }
                         }
+                        didBillAnything = true;
                     }
                 }
-                // Debit infrastructure add-on costs (if any)
-                if (cfg.getAddonCosts) {
+            }
+            // Debit infrastructure add-on costs (if any) — independent idempotency
+            if (cfg.getAddonCosts) {
+                const addonRef = `runtime-addon:${cfg.date}:${tenantId}`;
+                if (!(await cfg.ledger.hasReferenceId(addonRef))) {
                     const addonCost = await cfg.getAddonCosts(tenantId);
                     if (!addonCost.isZero()) {
                         const currentBalance = await cfg.ledger.balance(tenantId);
                         if (!currentBalance.lessThan(addonCost)) {
                             await cfg.ledger.debit(tenantId, addonCost, "addon", {
                                 description: "Daily infrastructure add-on charges",
-                                referenceId: `runtime-addon:${cfg.date}:${tenantId}`,
+                                referenceId: addonRef,
                             });
                         }
                         else {
@@ -156,7 +186,7 @@ export async function runRuntimeDeductions(cfg) {
                             if (currentBalance.greaterThan(Credit.ZERO)) {
                                 await cfg.ledger.debit(tenantId, currentBalance, "addon", {
                                     description: "Partial add-on charges (balance exhausted)",
-                                    referenceId: `runtime-addon:${cfg.date}:${tenantId}`,
+                                    referenceId: addonRef,
                                 });
                             }
                             if (!result.suspended.includes(tenantId)) {
@@ -165,26 +195,16 @@ export async function runRuntimeDeductions(cfg) {
                                     await cfg.onSuspend(tenantId);
                             }
                         }
+                        didBillAnything = true;
                     }
                 }
             }
+            if (didBillAnything) {
+                result.processed++;
+            }
             else {
-                // Partial deduction — debit remaining balance, then suspend
-                if (balance.greaterThan(Credit.ZERO)) {
-                    await cfg.ledger.debit(tenantId, balance, "bot_runtime", {
-                        description: `Partial daily runtime (balance exhausted): ${botCount} bot(s)`,
-                        referenceId: runtimeRef,
-                    });
-                }
-                if (cfg.onCreditsExhausted) {
-                    await cfg.onCreditsExhausted(tenantId);
-                }
-                result.suspended.push(tenantId);
-                if (cfg.onSuspend) {
-                    await cfg.onSuspend(tenantId);
-                }
+                result.skipped.push(tenantId);
             }
-            result.processed++;
         }
         catch (err) {
             if (err instanceof InsufficientBalanceError) {

package/dist/monetization/credits/runtime-cron.test.js

@@ -314,4 +314,110 @@ describe("runRuntimeDeductions", () => {
         // Balance unchanged after second run
         expect((await ledger.balance("tenant-1")).toCents()).toBe(500 - 17);
     });
+    it("bills surcharges on retry when runtime was already billed (crash recovery)", async () => {
+        // Setup: tenant with enough balance for runtime + tier + storage + addon
+        await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+        const cfg = {
+            ledger,
+            date: "2025-07-01",
+            getActiveBotCount: async () => 1,
+            getResourceTierCosts: async () => Credit.fromCents(10),
+            getStorageTierCosts: async () => Credit.fromCents(8),
+            getAddonCosts: async () => Credit.fromCents(5),
+        };
+        // First run — bills everything
+        const first = await runRuntimeDeductions(cfg);
+        expect(first.processed).toBe(1);
+        // 1000 - 17 (runtime) - 10 (tier) - 8 (storage) - 5 (addon) = 960
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+        // Second run — all already billed, should skip
+        const second = await runRuntimeDeductions(cfg);
+        expect(second.skipped).toContain("tenant-1");
+        expect(second.processed).toBe(0);
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+    });
+    it("bills remaining surcharges when runtime was billed but surcharges were not (simulated crash)", async () => {
+        // Setup: tenant with enough balance
+        await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+        // Simulate crash: manually debit only the runtime charge (as if the cron crashed after this)
+        await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
+            description: "Daily runtime: 1 bot(s) x $0.17",
+            referenceId: `runtime:2025-07-02:tenant-1`,
+        });
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(983); // 1000 - 17
+        // Retry run — runtime already billed, but surcharges should still be billed
+        const result = await runRuntimeDeductions({
+            ledger,
+            date: "2025-07-02",
+            getActiveBotCount: async () => 1,
+            getResourceTierCosts: async () => Credit.fromCents(10),
+            getStorageTierCosts: async () => Credit.fromCents(8),
+            getAddonCosts: async () => Credit.fromCents(5),
+        });
+        expect(result.processed).toBe(1);
+        expect(result.skipped).not.toContain("tenant-1");
+        // 983 - 10 (tier) - 8 (storage) - 5 (addon) = 960
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+    });
+    it("bills only missing surcharges when some were already committed (simulated partial crash)", async () => {
+        await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+        // Simulate: runtime + tier already billed, storage + addon not yet
+        await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
+            description: "Daily runtime: 1 bot(s) x $0.17",
+            referenceId: `runtime:2025-07-03:tenant-1`,
+        });
+        await ledger.debit("tenant-1", Credit.fromCents(10), "resource_upgrade", {
+            description: "Daily resource tier surcharge",
+            referenceId: `runtime-tier:2025-07-03:tenant-1`,
+        });
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(973); // 1000 - 17 - 10
+        const result = await runRuntimeDeductions({
+            ledger,
+            date: "2025-07-03",
+            getActiveBotCount: async () => 1,
+            getResourceTierCosts: async () => Credit.fromCents(10),
+            getStorageTierCosts: async () => Credit.fromCents(8),
+            getAddonCosts: async () => Credit.fromCents(5),
+        });
+        expect(result.processed).toBe(1);
+        // 973 - 8 (storage) - 5 (addon) = 960
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+    });
+    it("does not double-debit runtime on retry after partial deduction + crash", async () => {
+        await ledger.credit("tenant-1", Credit.fromCents(10), "purchase", { description: "top-up" });
+        // Simulate: partial runtime debit already committed (balance was 10, cost was 17)
+        await ledger.debit("tenant-1", Credit.fromCents(10), "bot_runtime", {
+            description: "Partial daily runtime (balance exhausted): 1 bot(s)",
+            referenceId: `runtime:2025-07-04:tenant-1`,
+            allowNegative: true,
+        });
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(0);
+        // Retry — runtime already billed, balance is 0, nothing should happen
+        const result = await runRuntimeDeductions({
+            ledger,
+            date: "2025-07-04",
+            getActiveBotCount: async () => 1,
+        });
+        // Tenant still has 0 balance (tenantsWithBalance returns only positive), so won't be processed
+        expect(result.processed).toBe(0);
+        expect((await ledger.balance("tenant-1")).toCents()).toBe(0);
+    });
+    it("trial balance remains balanced after crash-recovery billing", async () => {
+        await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+        // Simulate crash: only runtime billed
+        await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
+            description: "Daily runtime: 1 bot(s) x $0.17",
+            referenceId: `runtime:2025-07-05:tenant-1`,
+        });
+        // Retry — surcharges billed
+        await runRuntimeDeductions({
+            ledger,
+            date: "2025-07-05",
+            getActiveBotCount: async () => 1,
+            getResourceTierCosts: async () => Credit.fromCents(10),
+            getStorageTierCosts: async () => Credit.fromCents(8),
+        });
+        const tb = await ledger.trialBalance();
+        expect(tb.balanced).toBe(true);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.39.2",
+  "version": "1.39.4",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/credits/credit.test.ts

@@ -124,6 +124,45 @@ describe("Credit", () => {
     it("multiply by zero gives zero", () => {
       expect(Credit.fromDollars(5).multiply(0).isZero()).toBe(true);
     });
+
+    it("add throws RangeError on positive overflow", () => {
+      const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+      const b = Credit.fromRaw(1);
+      expect(() => a.add(b)).toThrow(RangeError);
+    });
+
+    it("subtract throws RangeError on negative overflow", () => {
+      const a = Credit.fromRaw(-Number.MAX_SAFE_INTEGER);
+      const b = Credit.fromRaw(1);
+      expect(() => a.subtract(b)).toThrow(RangeError);
+    });
+
+    it("multiply throws RangeError on overflow", () => {
+      const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+      expect(() => a.multiply(2)).toThrow(RangeError);
+    });
+
+    it("multiply throws RangeError on Infinity factor", () => {
+      const a = Credit.fromRaw(1);
+      expect(() => a.multiply(Infinity)).toThrow(RangeError);
+    });
+
+    it("multiply throws RangeError on NaN factor", () => {
+      const a = Credit.fromRaw(1);
+      expect(() => a.multiply(NaN)).toThrow(RangeError);
+    });
+
+    it("add does not throw for values within safe range", () => {
+      const a = Credit.fromRaw(Number.MAX_SAFE_INTEGER - 1);
+      const b = Credit.fromRaw(1);
+      expect(a.add(b).toRaw()).toBe(Number.MAX_SAFE_INTEGER);
+    });
+
+    it("subtract does not throw for values within safe range", () => {
+      const a = Credit.fromRaw(-(Number.MAX_SAFE_INTEGER - 1));
+      const b = Credit.fromRaw(1);
+      expect(a.subtract(b).toRaw()).toBe(-Number.MAX_SAFE_INTEGER);
+    });
   });
 
   describe("comparison", () => {

package/src/credits/credit.ts

@@ -101,17 +101,29 @@ export class Credit {
 
   /** Add another Credit, returning a new Credit. */
   add(other: Credit): Credit {
-    return new Credit(this.raw + other.raw);
+    const result = this.raw + other.raw;
+    if (!Number.isSafeInteger(result)) {
+      throw new RangeError(`Credit.add overflow: ${this.raw} + ${other.raw} = ${result}`);
+    }
+    return new Credit(result);
   }
 
   /** Subtract another Credit, returning a new Credit (may be negative). */
   subtract(other: Credit): Credit {
-    return new Credit(this.raw - other.raw);
+    const result = this.raw - other.raw;
+    if (!Number.isSafeInteger(result)) {
+      throw new RangeError(`Credit.subtract overflow: ${this.raw} - ${other.raw} = ${result}`);
+    }
+    return new Credit(result);
   }
 
   /** Multiply by a factor, rounding to nearest raw unit. */
   multiply(factor: number): Credit {
-    return new Credit(Math.round(this.raw * factor));
+    const result = Math.round(this.raw * factor);
+    if (!Number.isSafeInteger(result)) {
+      throw new RangeError(`Credit.multiply overflow: ${this.raw} * ${factor} = ${result}`);
+    }
+    return new Credit(result);
   }
 
   /** True if this credit is negative. */

package/src/monetization/credits/runtime-cron.test.ts

@@ -356,4 +356,130 @@ describe("runRuntimeDeductions", () => {
     // Balance unchanged after second run
     expect((await ledger.balance("tenant-1")).toCents()).toBe(500 - 17);
   });
+
+  it("bills surcharges on retry when runtime was already billed (crash recovery)", async () => {
+    // Setup: tenant with enough balance for runtime + tier + storage + addon
+    await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+
+    const cfg = {
+      ledger,
+      date: "2025-07-01",
+      getActiveBotCount: async () => 1,
+      getResourceTierCosts: async () => Credit.fromCents(10),
+      getStorageTierCosts: async () => Credit.fromCents(8),
+      getAddonCosts: async () => Credit.fromCents(5),
+    };
+
+    // First run — bills everything
+    const first = await runRuntimeDeductions(cfg);
+    expect(first.processed).toBe(1);
+    // 1000 - 17 (runtime) - 10 (tier) - 8 (storage) - 5 (addon) = 960
+    expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+
+    // Second run — all already billed, should skip
+    const second = await runRuntimeDeductions(cfg);
+    expect(second.skipped).toContain("tenant-1");
+    expect(second.processed).toBe(0);
+    expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+  });
+
+  it("bills remaining surcharges when runtime was billed but surcharges were not (simulated crash)", async () => {
+    // Setup: tenant with enough balance
+    await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+
+    // Simulate crash: manually debit only the runtime charge (as if the cron crashed after this)
+    await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
+      description: "Daily runtime: 1 bot(s) x $0.17",
+      referenceId: `runtime:2025-07-02:tenant-1`,
+    });
+    expect((await ledger.balance("tenant-1")).toCents()).toBe(983); // 1000 - 17
+
+    // Retry run — runtime already billed, but surcharges should still be billed
+    const result = await runRuntimeDeductions({
+      ledger,
+      date: "2025-07-02",
+      getActiveBotCount: async () => 1,
+      getResourceTierCosts: async () => Credit.fromCents(10),
+      getStorageTierCosts: async () => Credit.fromCents(8),
+      getAddonCosts: async () => Credit.fromCents(5),
+    });
+
+    expect(result.processed).toBe(1);
+    expect(result.skipped).not.toContain("tenant-1");
+    // 983 - 10 (tier) - 8 (storage) - 5 (addon) = 960
+    expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+  });
+
+  it("bills only missing surcharges when some were already committed (simulated partial crash)", async () => {
+    await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+
+    // Simulate: runtime + tier already billed, storage + addon not yet
+    await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
+      description: "Daily runtime: 1 bot(s) x $0.17",
+      referenceId: `runtime:2025-07-03:tenant-1`,
+    });
+    await ledger.debit("tenant-1", Credit.fromCents(10), "resource_upgrade", {
+      description: "Daily resource tier surcharge",
+      referenceId: `runtime-tier:2025-07-03:tenant-1`,
+    });
+    expect((await ledger.balance("tenant-1")).toCents()).toBe(973); // 1000 - 17 - 10
+
+    const result = await runRuntimeDeductions({
+      ledger,
+      date: "2025-07-03",
+      getActiveBotCount: async () => 1,
+      getResourceTierCosts: async () => Credit.fromCents(10),
+      getStorageTierCosts: async () => Credit.fromCents(8),
+      getAddonCosts: async () => Credit.fromCents(5),
+    });
+
+    expect(result.processed).toBe(1);
+    // 973 - 8 (storage) - 5 (addon) = 960
+    expect((await ledger.balance("tenant-1")).toCents()).toBe(960);
+  });
+
+  it("does not double-debit runtime on retry after partial deduction + crash", async () => {
+    await ledger.credit("tenant-1", Credit.fromCents(10), "purchase", { description: "top-up" });
+
+    // Simulate: partial runtime debit already committed (balance was 10, cost was 17)
+    await ledger.debit("tenant-1", Credit.fromCents(10), "bot_runtime", {
+      description: "Partial daily runtime (balance exhausted): 1 bot(s)",
+      referenceId: `runtime:2025-07-04:tenant-1`,
+      allowNegative: true,
+    });
+    expect((await ledger.balance("tenant-1")).toCents()).toBe(0);
+
+    // Retry — runtime already billed, balance is 0, nothing should happen
+    const result = await runRuntimeDeductions({
+      ledger,
+      date: "2025-07-04",
+      getActiveBotCount: async () => 1,
+    });
+
+    // Tenant still has 0 balance (tenantsWithBalance returns only positive), so won't be processed
+    expect(result.processed).toBe(0);
+    expect((await ledger.balance("tenant-1")).toCents()).toBe(0);
+  });
+
+  it("trial balance remains balanced after crash-recovery billing", async () => {
+    await ledger.credit("tenant-1", Credit.fromCents(1000), "purchase", { description: "top-up" });
+
+    // Simulate crash: only runtime billed
+    await ledger.debit("tenant-1", DAILY_BOT_COST, "bot_runtime", {
+      description: "Daily runtime: 1 bot(s) x $0.17",
+      referenceId: `runtime:2025-07-05:tenant-1`,
+    });
+
+    // Retry — surcharges billed
+    await runRuntimeDeductions({
+      ledger,
+      date: "2025-07-05",
+      getActiveBotCount: async () => 1,
+      getResourceTierCosts: async () => Credit.fromCents(10),
+      getStorageTierCosts: async () => Credit.fromCents(8),
+    });
+
+    const tb = await ledger.trialBalance();
+    expect(tb.balanced).toBe(true);
+  });
 });

package/src/monetization/credits/runtime-cron.ts

@@ -110,87 +110,111 @@ export async function runRuntimeDeductions(cfg: RuntimeCronConfig): Promise<Runt
   for (const { tenantId, balance } of tenants) {
     try {
       const runtimeRef = `runtime:${cfg.date}:${tenantId}`;
-      if (await cfg.ledger.hasReferenceId(runtimeRef)) {
-        result.skipped.push(tenantId);
-        continue;
-      }
+      const runtimeAlreadyBilled = await cfg.ledger.hasReferenceId(runtimeRef);
 
       const botCount = await cfg.getActiveBotCount(tenantId);
-      if (botCount <= 0) continue;
+      if (botCount <= 0) {
+        if (runtimeAlreadyBilled) result.skipped.push(tenantId);
+        continue;
+      }
 
       const totalCost = DAILY_BOT_COST.multiply(botCount);
+      let didBillAnything = false;
 
-      if (!balance.lessThan(totalCost)) {
-        // Full deduction
-        await cfg.ledger.debit(tenantId, totalCost, "bot_runtime", {
-          description: `Daily runtime: ${botCount} bot(s) x $${DAILY_BOT_COST.toDollars().toFixed(2)}`,
-          referenceId: runtimeRef,
-        });
+      // Bill runtime debit (skipped if already billed on a previous run)
+      if (!runtimeAlreadyBilled) {
+        if (!balance.lessThan(totalCost)) {
+          // Full deduction
+          await cfg.ledger.debit(tenantId, totalCost, "bot_runtime", {
+            description: `Daily runtime: ${botCount} bot(s) x $${DAILY_BOT_COST.toDollars().toFixed(2)}`,
+            referenceId: runtimeRef,
+          });
+        } else {
+          // Partial deduction — balance insufficient to cover full cost; debit what's available and suspend
+          if (balance.greaterThan(Credit.ZERO)) {
+            await cfg.ledger.debit(tenantId, balance, "bot_runtime", {
+              description: `Partial daily runtime (balance exhausted): ${botCount} bot(s)`,
+              referenceId: runtimeRef,
+            });
+          }
+          if (!result.suspended.includes(tenantId)) {
+            result.suspended.push(tenantId);
+            if (cfg.onSuspend) await cfg.onSuspend(tenantId);
+          }
+        }
+        didBillAnything = true;
+      }
 
-        // Debit resource tier surcharges (if any)
-        if (cfg.getResourceTierCosts) {
+      // Debit resource tier surcharges (if any) — independent idempotency
+      if (cfg.getResourceTierCosts) {
+        const tierRef = `runtime-tier:${cfg.date}:${tenantId}`;
+        if (!(await cfg.ledger.hasReferenceId(tierRef))) {
           const tierCost = await cfg.getResourceTierCosts(tenantId);
           if (!tierCost.isZero()) {
             const balanceAfterRuntime = await cfg.ledger.balance(tenantId);
             if (!balanceAfterRuntime.lessThan(tierCost)) {
               await cfg.ledger.debit(tenantId, tierCost, "resource_upgrade", {
                 description: "Daily resource tier surcharge",
-                referenceId: `runtime-tier:${cfg.date}:${tenantId}`,
+                referenceId: tierRef,
               });
             } else if (balanceAfterRuntime.greaterThan(Credit.ZERO)) {
               await cfg.ledger.debit(tenantId, balanceAfterRuntime, "resource_upgrade", {
                 description: "Partial resource tier surcharge (balance exhausted)",
-                referenceId: `runtime-tier:${cfg.date}:${tenantId}`,
+                referenceId: tierRef,
               });
             }
+            didBillAnything = true;
           }
         }
+      }
 
-        const newBalance = await cfg.ledger.balance(tenantId);
+      const newBalance = await cfg.ledger.balance(tenantId);
 
-        // Fire onLowBalance if balance crossed below threshold from above
-        if (
-          newBalance.greaterThan(Credit.ZERO) &&
-          !newBalance.greaterThan(LOW_BALANCE_THRESHOLD) &&
-          balance.greaterThan(LOW_BALANCE_THRESHOLD) &&
-          cfg.onLowBalance
-        ) {
-          await cfg.onLowBalance(tenantId, newBalance);
-        }
+      // Fire onLowBalance if balance crossed below threshold from above
+      if (
+        newBalance.greaterThan(Credit.ZERO) &&
+        !newBalance.greaterThan(LOW_BALANCE_THRESHOLD) &&
+        balance.greaterThan(LOW_BALANCE_THRESHOLD) &&
+        cfg.onLowBalance
+      ) {
+        await cfg.onLowBalance(tenantId, newBalance);
+      }
 
-        // Fire onCreditsExhausted if balance just hit 0
-        if (!newBalance.greaterThan(Credit.ZERO) && balance.greaterThan(Credit.ZERO) && cfg.onCreditsExhausted) {
-          await cfg.onCreditsExhausted(tenantId);
-        }
+      // Fire onCreditsExhausted if balance just hit 0
+      if (!newBalance.greaterThan(Credit.ZERO) && balance.greaterThan(Credit.ZERO) && cfg.onCreditsExhausted) {
+        await cfg.onCreditsExhausted(tenantId);
+      }
 
-        // Suspend tenant when balance hits zero after full deduction (zero-crossing guard)
-        if (
-          !newBalance.greaterThan(Credit.ZERO) &&
-          balance.greaterThan(Credit.ZERO) &&
-          !result.suspended.includes(tenantId)
-        ) {
-          result.suspended.push(tenantId);
-          if (cfg.onSuspend) {
-            await cfg.onSuspend(tenantId);
-          }
+      // Suspend tenant when balance hits zero (zero-crossing guard)
+      if (
+        !newBalance.greaterThan(Credit.ZERO) &&
+        balance.greaterThan(Credit.ZERO) &&
+        !result.suspended.includes(tenantId)
+      ) {
+        result.suspended.push(tenantId);
+        if (cfg.onSuspend) {
+          await cfg.onSuspend(tenantId);
         }
+      }
 
-        // Debit storage tier surcharges (if any)
-        if (cfg.getStorageTierCosts) {
+      // Debit storage tier surcharges (if any) — independent idempotency
+      if (cfg.getStorageTierCosts) {
+        const storageRef = `runtime-storage:${cfg.date}:${tenantId}`;
+        if (!(await cfg.ledger.hasReferenceId(storageRef))) {
           const storageCost = await cfg.getStorageTierCosts(tenantId);
           if (!storageCost.isZero()) {
             const currentBalance = await cfg.ledger.balance(tenantId);
             if (!currentBalance.lessThan(storageCost)) {
               await cfg.ledger.debit(tenantId, storageCost, "storage_upgrade", {
                 description: "Daily storage tier surcharge",
-                referenceId: `runtime-storage:${cfg.date}:${tenantId}`,
+                referenceId: storageRef,
               });
             } else {
               // Partial debit — take what's left, then suspend
               if (currentBalance.greaterThan(Credit.ZERO)) {
                 await cfg.ledger.debit(tenantId, currentBalance, "storage_upgrade", {
                   description: "Partial storage tier surcharge (balance exhausted)",
-                  referenceId: `runtime-storage:${cfg.date}:${tenantId}`,
+                  referenceId: storageRef,
                 });
               }
               if (!result.suspended.includes(tenantId)) {
@@ -198,25 +222,29 @@ export async function runRuntimeDeductions(cfg: RuntimeCronConfig): Promise<Runt
                 if (cfg.onSuspend) await cfg.onSuspend(tenantId);
               }
             }
+            didBillAnything = true;
           }
         }
+      }
 
-        // Debit infrastructure add-on costs (if any)
-        if (cfg.getAddonCosts) {
+      // Debit infrastructure add-on costs (if any) — independent idempotency
+      if (cfg.getAddonCosts) {
+        const addonRef = `runtime-addon:${cfg.date}:${tenantId}`;
+        if (!(await cfg.ledger.hasReferenceId(addonRef))) {
           const addonCost = await cfg.getAddonCosts(tenantId);
           if (!addonCost.isZero()) {
             const currentBalance = await cfg.ledger.balance(tenantId);
             if (!currentBalance.lessThan(addonCost)) {
               await cfg.ledger.debit(tenantId, addonCost, "addon", {
                 description: "Daily infrastructure add-on charges",
-                referenceId: `runtime-addon:${cfg.date}:${tenantId}`,
+                referenceId: addonRef,
               });
             } else {
               // Partial debit — take what's left, then suspend
               if (currentBalance.greaterThan(Credit.ZERO)) {
                 await cfg.ledger.debit(tenantId, currentBalance, "addon", {
                   description: "Partial add-on charges (balance exhausted)",
-                  referenceId: `runtime-addon:${cfg.date}:${tenantId}`,
+                  referenceId: addonRef,
                 });
               }
               if (!result.suspended.includes(tenantId)) {
@@ -224,28 +252,16 @@ export async function runRuntimeDeductions(cfg: RuntimeCronConfig): Promise<Runt
                 if (cfg.onSuspend) await cfg.onSuspend(tenantId);
               }
             }
+            didBillAnything = true;
           }
         }
-      } else {
-        // Partial deduction — debit remaining balance, then suspend
-        if (balance.greaterThan(Credit.ZERO)) {
-          await cfg.ledger.debit(tenantId, balance, "bot_runtime", {
-            description: `Partial daily runtime (balance exhausted): ${botCount} bot(s)`,
-            referenceId: runtimeRef,
-          });
-        }
-
-        if (cfg.onCreditsExhausted) {
-          await cfg.onCreditsExhausted(tenantId);
-        }
-
-        result.suspended.push(tenantId);
-        if (cfg.onSuspend) {
-          await cfg.onSuspend(tenantId);
-        }
       }
 
-      result.processed++;
+      if (didBillAnything) {
+        result.processed++;
+      } else {
+        result.skipped.push(tenantId);
+      }
     } catch (err) {
       if (err instanceof InsufficientBalanceError) {
         result.suspended.push(tenantId);

package/vitest.config.ts

@@ -1,6 +1,15 @@
+import { resolve } from "node:path";
 import { defineConfig } from "vitest/config";
 
 export default defineConfig({
+  resolve: {
+    alias: {
+      "@wopr-network/platform-core/billing": resolve(__dirname, "src/billing/index.ts"),
+      "@wopr-network/platform-core/credits": resolve(__dirname, "src/credits/index.ts"),
+      "@wopr-network/platform-core/email": resolve(__dirname, "src/email/index.ts"),
+      "@wopr-network/platform-core/metering": resolve(__dirname, "src/metering/index.ts"),
+    },
+  },
   test: {
     testTimeout: 30000,
     hookTimeout: 30000,