@wopr-network/platform-core 1.0.4 → 1.0.6

package/dist/metering/metering.test.js

@@ -117,14 +117,14 @@ describe("MeterEmitter", () => {
         }
     });
     it("buffers events without writing until flush", async () => {
-        emitter.emit(makeEvent());
+        await emitter.emit(makeEvent());
         expect(emitter.pending).toBe(1);
         const rows = (await db.select({ cnt: sql `COUNT(*)` }).from(meterEvents))[0];
         expect(rows?.cnt).toBe(0);
     });
     it("flush writes buffered events to the database", async () => {
-        emitter.emit(makeEvent());
-        emitter.emit(makeEvent({ tenant: "tenant-2" }));
+        await emitter.emit(makeEvent());
+        await emitter.emit(makeEvent({ tenant: "tenant-2" }));
         const flushed = await emitter.flush();
         expect(flushed).toBe(2);
         expect(emitter.pending).toBe(0);
@@ -142,7 +142,7 @@ describe("MeterEmitter", () => {
             sessionId: "sess-123",
             duration: 5000,
         });
-        emitter.emit(event);
+        await emitter.emit(event);
         await emitter.flush();
         const rows = await emitter.queryEvents("t-abc");
         expect(rows).toHaveLength(1);
@@ -156,15 +156,15 @@ describe("MeterEmitter", () => {
         expect(rows[0].duration).toBe(5000);
     });
     it("handles null optional fields", async () => {
-        emitter.emit(makeEvent({ sessionId: undefined, duration: undefined }));
+        await emitter.emit(makeEvent({ sessionId: undefined, duration: undefined }));
         await emitter.flush();
         const rows = await emitter.queryEvents("tenant-1");
         expect(rows[0].session_id).toBeNull();
         expect(rows[0].duration).toBeNull();
     });
     it("generates unique IDs for each event", async () => {
-        emitter.emit(makeEvent());
-        emitter.emit(makeEvent());
+        await emitter.emit(makeEvent());
+        await emitter.emit(makeEvent());
         await emitter.flush();
         const rows = await emitter.queryEvents("tenant-1");
         expect(rows).toHaveLength(2);
@@ -172,25 +172,25 @@ describe("MeterEmitter", () => {
     });
     it("auto-flushes when batch size is reached", async () => {
         const smallBatch = makeEmitter(db, { flushIntervalMs: 60_000, batchSize: 3 });
-        smallBatch.emit(makeEvent());
-        smallBatch.emit(makeEvent());
+        await smallBatch.emit(makeEvent());
+        await smallBatch.emit(makeEvent());
         // Third event triggers auto-flush.
-        smallBatch.emit(makeEvent());
+        await smallBatch.emit(makeEvent());
         const rows = (await db.select({ cnt: sql `COUNT(*)` }).from(meterEvents))[0];
         expect(rows?.cnt).toBe(3);
         expect(smallBatch.pending).toBe(0);
         smallBatch.close();
     });
     it("close flushes remaining events", async () => {
-        emitter.emit(makeEvent());
-        emitter.emit(makeEvent());
+        await emitter.emit(makeEvent());
+        await emitter.emit(makeEvent());
         emitter.close();
         const rows = (await db.select({ cnt: sql `COUNT(*)` }).from(meterEvents))[0];
         expect(rows?.cnt).toBe(2);
     });
     it("ignores events after close", async () => {
         emitter.close();
-        emitter.emit(makeEvent());
+        await emitter.emit(makeEvent());
         expect(emitter.pending).toBe(0);
     });
     it("re-adds events to buffer on flush failure", async () => {
@@ -202,8 +202,8 @@ describe("MeterEmitter", () => {
             walPath: TEST_WAL_PATH,
             dlqPath: TEST_DLQ_PATH,
         });
-        localEmitter.emit(makeEvent());
-        localEmitter.emit(makeEvent());
+        await localEmitter.emit(makeEvent());
+        await localEmitter.emit(makeEvent());
         expect(localEmitter.pending).toBe(2);
         await localPool.close();
         // Should not throw even though db is closed.
@@ -214,9 +214,9 @@ describe("MeterEmitter", () => {
         localEmitter.close();
     });
     it("queryEvents returns events for a specific tenant", async () => {
-        emitter.emit(makeEvent({ tenant: "t-1" }));
-        emitter.emit(makeEvent({ tenant: "t-2" }));
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-2" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         await emitter.flush();
         const t1Events = await emitter.queryEvents("t-1");
         expect(t1Events).toHaveLength(2);
@@ -248,9 +248,9 @@ describe("MeterEmitter - concurrent multi-provider sessions", () => {
     });
     it("groups multiple providers under one sessionId", async () => {
         const sessionId = "voice-session-1";
-        emitter.emit(makeEvent({ capability: "stt", provider: "deepgram", sessionId }));
-        emitter.emit(makeEvent({ capability: "chat", provider: "openai", sessionId }));
-        emitter.emit(makeEvent({ capability: "tts", provider: "elevenlabs", sessionId }));
+        await emitter.emit(makeEvent({ capability: "stt", provider: "deepgram", sessionId }));
+        await emitter.emit(makeEvent({ capability: "chat", provider: "openai", sessionId }));
+        await emitter.emit(makeEvent({ capability: "tts", provider: "elevenlabs", sessionId }));
         await emitter.flush();
         const rows = await db.select().from(meterEvents).where(eq(meterEvents.sessionId, sessionId));
         expect(rows).toHaveLength(3);
@@ -260,9 +260,9 @@ describe("MeterEmitter - concurrent multi-provider sessions", () => {
         expect(providers).toEqual(["deepgram", "elevenlabs", "openai"]);
     });
     it("handles events from different sessions simultaneously", async () => {
-        emitter.emit(makeEvent({ sessionId: "sess-a", capability: "stt" }));
-        emitter.emit(makeEvent({ sessionId: "sess-b", capability: "stt" }));
-        emitter.emit(makeEvent({ sessionId: "sess-a", capability: "tts" }));
+        await emitter.emit(makeEvent({ sessionId: "sess-a", capability: "stt" }));
+        await emitter.emit(makeEvent({ sessionId: "sess-b", capability: "stt" }));
+        await emitter.emit(makeEvent({ sessionId: "sess-a", capability: "tts" }));
         await emitter.flush();
         const sessA = (await db.select({ cnt: sql `COUNT(*)` }).from(meterEvents).where(eq(meterEvents.sessionId, "sess-a")))[0];
         const sessB = (await db.select({ cnt: sql `COUNT(*)` }).from(meterEvents).where(eq(meterEvents.sessionId, "sess-b")))[0];
@@ -296,13 +296,13 @@ describe("MeterAggregator", () => {
     it("aggregates events from completed windows", async () => {
         // Insert events in a past window.
         const pastWindow = Math.floor(Date.now() / WINDOW) * WINDOW - WINDOW;
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.01),
             charge: Credit.fromDollars(0.02),
             timestamp: pastWindow + 100,
         }));
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.03),
             charge: Credit.fromDollars(0.06),
@@ -319,9 +319,9 @@ describe("MeterAggregator", () => {
     });
     it("groups by tenant, capability, and provider", async () => {
         const pastWindow = Math.floor(Date.now() / WINDOW) * WINDOW - WINDOW;
-        emitter.emit(makeEvent({ tenant: "t-1", capability: "embeddings", provider: "openai", timestamp: pastWindow + 10 }));
-        emitter.emit(makeEvent({ tenant: "t-1", capability: "voice", provider: "deepgram", timestamp: pastWindow + 20 }));
-        emitter.emit(makeEvent({ tenant: "t-2", capability: "embeddings", provider: "openai", timestamp: pastWindow + 30 }));
+        await emitter.emit(makeEvent({ tenant: "t-1", capability: "embeddings", provider: "openai", timestamp: pastWindow + 10 }));
+        await emitter.emit(makeEvent({ tenant: "t-1", capability: "voice", provider: "deepgram", timestamp: pastWindow + 20 }));
+        await emitter.emit(makeEvent({ tenant: "t-2", capability: "embeddings", provider: "openai", timestamp: pastWindow + 30 }));
         await emitter.flush();
         const count = await aggregator.aggregate();
         expect(count).toBe(3); // Three distinct groups.
@@ -332,7 +332,7 @@ describe("MeterAggregator", () => {
     });
     it("does not aggregate the current (incomplete) window", async () => {
         // Insert an event in the *current* window.
-        emitter.emit(makeEvent({ timestamp: Date.now() }));
+        await emitter.emit(makeEvent({ timestamp: Date.now() }));
         await emitter.flush();
         const count = await aggregator.aggregate();
         // If there are no events in prior windows, nothing to aggregate.
@@ -343,7 +343,7 @@ describe("MeterAggregator", () => {
     });
     it("is idempotent - does not double-aggregate", async () => {
         const pastWindow = Math.floor(Date.now() / WINDOW) * WINDOW - WINDOW;
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.01),
             charge: Credit.fromDollars(0.02),
@@ -358,13 +358,13 @@ describe("MeterAggregator", () => {
     });
     it("aggregates duration for session-based capabilities", async () => {
         const pastWindow = Math.floor(Date.now() / WINDOW) * WINDOW - WINDOW;
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             capability: "voice",
             duration: 3000,
             timestamp: pastWindow + 10,
         }));
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             capability: "voice",
             duration: 5000,
@@ -382,13 +382,13 @@ describe("MeterAggregator", () => {
     });
     it("getTenantTotal returns aggregate totals", async () => {
         const pastWindow = Math.floor(Date.now() / WINDOW) * WINDOW - WINDOW;
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.01),
             charge: Credit.fromDollars(0.02),
             timestamp: pastWindow + 10,
         }));
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.05),
             charge: Credit.fromDollars(0.1),
@@ -412,8 +412,8 @@ describe("MeterAggregator", () => {
         const now = Date.now();
         const twoWindowsAgo = Math.floor(now / WINDOW) * WINDOW - 2 * WINDOW;
         const oneWindowAgo = Math.floor(now / WINDOW) * WINDOW - WINDOW;
-        emitter.emit(makeEvent({ tenant: "t-1", timestamp: twoWindowsAgo + 10 }));
-        emitter.emit(makeEvent({ tenant: "t-1", timestamp: oneWindowAgo + 10 }));
+        await emitter.emit(makeEvent({ tenant: "t-1", timestamp: twoWindowsAgo + 10 }));
+        await emitter.emit(makeEvent({ tenant: "t-1", timestamp: oneWindowAgo + 10 }));
         await emitter.flush();
         // Aggregate both windows.
         await aggregator.aggregate(twoWindowsAgo + WINDOW + 1);
@@ -454,7 +454,7 @@ describe("MeterAggregator - edge cases", () => {
         const now = Date.now();
         const threeWindowsAgo = Math.floor(now / WINDOW) * WINDOW - 3 * WINDOW;
         // Place one event 3 windows ago; windows 2-ago and 1-ago are empty.
-        emitter.emit(makeEvent({ tenant: "t-1", timestamp: threeWindowsAgo + 10 }));
+        await emitter.emit(makeEvent({ tenant: "t-1", timestamp: threeWindowsAgo + 10 }));
         await emitter.flush();
         await aggregator.aggregate(now);
         // The event window should produce a real summary.
@@ -473,7 +473,7 @@ describe("MeterAggregator - edge cases", () => {
     it("handles single-event windows correctly", async () => {
         const now = Date.now();
         const pastWindow = Math.floor(now / WINDOW) * WINDOW - WINDOW;
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.123),
             charge: Credit.fromDollars(0.456),
@@ -492,7 +492,7 @@ describe("MeterAggregator - edge cases", () => {
         const now = Date.now();
         const pastWindow = Math.floor(now / WINDOW) * WINDOW - WINDOW;
         // Event at the exact start of the window (timestamp === windowStart).
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.01),
             charge: Credit.fromDollars(0.02),
@@ -511,7 +511,7 @@ describe("MeterAggregator - edge cases", () => {
         const twoWindowsAgo = Math.floor(now / WINDOW) * WINDOW - 2 * WINDOW;
         const oneWindowAgo = twoWindowsAgo + WINDOW;
         // Event at the exact boundary (end of window 2-ago = start of window 1-ago).
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.01),
             charge: Credit.fromDollars(0.02),
@@ -529,14 +529,14 @@ describe("MeterAggregator - edge cases", () => {
         const pastWindow = Math.floor(now / WINDOW) * WINDOW - WINDOW;
         const tenants = ["alpha", "beta", "gamma"];
         for (const t of tenants) {
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 tenant: t,
                 cost: Credit.fromDollars(0.01),
                 charge: Credit.fromDollars(0.02),
                 capability: "chat",
                 timestamp: pastWindow + 10,
             }));
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 tenant: t,
                 cost: Credit.fromDollars(0.03),
                 charge: Credit.fromDollars(0.06),
@@ -560,19 +560,19 @@ describe("MeterAggregator - edge cases", () => {
         const threeWindowsAgo = Math.floor(now / WINDOW) * WINDOW - 3 * WINDOW;
         const twoWindowsAgo = threeWindowsAgo + WINDOW;
         const oneWindowAgo = twoWindowsAgo + WINDOW;
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.01),
             charge: Credit.fromDollars(0.02),
             timestamp: threeWindowsAgo + 100,
         }));
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.03),
             charge: Credit.fromDollars(0.06),
             timestamp: twoWindowsAgo + 100,
         }));
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.05),
             charge: Credit.fromDollars(0.1),
@@ -660,7 +660,7 @@ describe("MeterAggregator - billing accuracy", () => {
         const expectedCostRaw = events.reduce((s, e) => s + e.cost.toRaw(), 0);
         const expectedChargeRaw = events.reduce((s, e) => s + e.charge.toRaw(), 0);
         for (const e of events)
-            emitter.emit(e);
+            await emitter.emit(e);
         await emitter.flush();
         await aggregator.aggregate(now);
         const total = await aggregator.getTenantTotal("billing-test", 0);
@@ -672,21 +672,21 @@ describe("MeterAggregator - billing accuracy", () => {
         const WINDOW = 60_000;
         const now = Date.now();
         const pastWindow = Math.floor(now / WINDOW) * WINDOW - WINDOW;
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.1),
             charge: Credit.fromDollars(0.2),
             capability: "chat",
             timestamp: pastWindow + 10,
         }));
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.05),
             charge: Credit.fromDollars(0.1),
             capability: "embeddings",
             timestamp: pastWindow + 20,
         }));
-        emitter.emit(makeEvent({
+        await emitter.emit(makeEvent({
             tenant: "t-1",
             cost: Credit.fromDollars(0.15),
             charge: Credit.fromDollars(0.3),
@@ -728,7 +728,7 @@ describe("MeterEmitter - edge cases", () => {
     });
     it("handles large batch of events", async () => {
         for (let i = 0; i < 200; i++) {
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 tenant: "bulk-tenant",
                 cost: Credit.fromDollars(0.001),
                 charge: Credit.fromDollars(0.002),
@@ -740,7 +740,7 @@ describe("MeterEmitter - edge cases", () => {
         expect(rows?.cnt).toBe(200);
     });
     it("handles zero-cost events", async () => {
-        emitter.emit(makeEvent({ tenant: "free-tier", cost: Credit.ZERO, charge: Credit.ZERO }));
+        await emitter.emit(makeEvent({ tenant: "free-tier", cost: Credit.ZERO, charge: Credit.ZERO }));
         await emitter.flush();
         const rows = await emitter.queryEvents("free-tier");
         expect(rows).toHaveLength(1);
@@ -749,9 +749,9 @@ describe("MeterEmitter - edge cases", () => {
     });
     it("preserves event ordering within a tenant", async () => {
         const base = 1700000000000;
-        emitter.emit(makeEvent({ tenant: "t-1", timestamp: base + 300 }));
-        emitter.emit(makeEvent({ tenant: "t-1", timestamp: base + 100 }));
-        emitter.emit(makeEvent({ tenant: "t-1", timestamp: base + 200 }));
+        await emitter.emit(makeEvent({ tenant: "t-1", timestamp: base + 300 }));
+        await emitter.emit(makeEvent({ tenant: "t-1", timestamp: base + 100 }));
+        await emitter.emit(makeEvent({ tenant: "t-1", timestamp: base + 200 }));
         await emitter.flush();
         // queryEvents orders by timestamp DESC.
         const rows = await emitter.queryEvents("t-1");
@@ -761,11 +761,11 @@ describe("MeterEmitter - edge cases", () => {
         expect(rows[2].timestamp).toBe(base + 100);
     });
     it("handles multiple flushes without losing events", async () => {
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         await emitter.flush();
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         await emitter.flush();
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         await emitter.flush();
         const rows = (await db.select({ cnt: sql `COUNT(*)` }).from(meterEvents).where(eq(meterEvents.tenant, "t-1")))[0];
         expect(rows?.cnt).toBe(3);
@@ -776,13 +776,13 @@ describe("append-only guarantee", () => {
     it("meter_events table has no UPDATE or DELETE operations in emitter", async () => {
         const { db, pool } = await createTestDb();
         const emitter = makeEmitter(db, { flushIntervalMs: 60_000 });
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         await emitter.flush();
         // Verify the event exists.
         const before = (await db.select({ cnt: sql `COUNT(*)` }).from(meterEvents))[0];
         expect(before?.cnt).toBe(1);
         // Emit more -- never replaces.
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         await emitter.flush();
         const after = (await db.select({ cnt: sql `COUNT(*)` }).from(meterEvents))[0];
         expect(after?.cnt).toBe(2);
@@ -840,7 +840,7 @@ describe("MeterEmitter - fail-closed policy", () => {
         }
     });
     it("writes events to WAL before buffering", async () => {
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         // WAL should exist immediately.
         expect(existsSync(TEST_WAL_PATH)).toBe(true);
         const content = readFileSync(TEST_WAL_PATH, "utf8");
@@ -851,14 +851,14 @@ describe("MeterEmitter - fail-closed policy", () => {
         expect(event.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
     });
     it("clears WAL after successful flush", async () => {
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         expect(existsSync(TEST_WAL_PATH)).toBe(true);
         await emitter.flush();
         // WAL should not exist after successful flush.
         expect(existsSync(TEST_WAL_PATH)).toBe(false);
     });
     it("moves events to DLQ after max retries", async () => {
-        emitter.emit(makeEvent({ tenant: "t-1" }));
+        await emitter.emit(makeEvent({ tenant: "t-1" }));
         // Close the database to force flush failures.
         pool.close();
         // Trigger max retries.
@@ -929,7 +929,7 @@ describe("MeterEmitter - fail-closed policy", () => {
     });
     describe("generic usage fields (WOP-512)", () => {
         it("persists usage, tier, and metadata fields", async () => {
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 tenant: "t-1",
                 capability: "tts",
                 provider: "elevenlabs",
@@ -945,7 +945,7 @@ describe("MeterEmitter - fail-closed policy", () => {
             expect(JSON.parse(rows[0].metadata)).toEqual({ voice: "adam", model: "eleven_v2" });
         });
         it("handles null usage/tier/metadata (backwards compatibility)", async () => {
-            emitter.emit(makeEvent({ tenant: "t-1" }));
+            await emitter.emit(makeEvent({ tenant: "t-1" }));
             await emitter.flush();
             const rows = await emitter.queryEvents("t-1");
             expect(rows[0].usage_units).toBeNull();
@@ -954,25 +954,25 @@ describe("MeterEmitter - fail-closed policy", () => {
             expect(rows[0].metadata).toBeNull();
         });
         it("works with multiple capability types in the same flush", async () => {
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 capability: "tts",
                 provider: "elevenlabs",
                 usage: { units: 500, unitType: "characters" },
                 tier: "branded",
             }));
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 capability: "chat-completions",
                 provider: "openrouter",
                 usage: { units: 1500, unitType: "tokens" },
                 tier: "branded",
             }));
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 capability: "transcription",
                 provider: "self-hosted-whisper",
                 usage: { units: 120, unitType: "seconds" },
                 tier: "wopr",
             }));
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 capability: "image-generation",
                 provider: "replicate",
                 usage: { units: 2, unitType: "images" },
@@ -986,7 +986,7 @@ describe("MeterEmitter - fail-closed policy", () => {
             expect(unitTypes).toEqual(["characters", "images", "seconds", "tokens"]);
         });
         it("BYOK tier records zero cost/charge with tier='byok'", async () => {
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 cost: Credit.ZERO,
                 charge: Credit.ZERO,
                 capability: "chat-completions",
@@ -1005,7 +1005,7 @@ describe("MeterEmitter - fail-closed policy", () => {
             const WINDOW = 60_000; // 1 minute
             const aggregator = new MeterAggregator(new DrizzleUsageSummaryRepository(db), { windowMs: WINDOW });
             const pastWindow = Math.floor(Date.now() / WINDOW) * WINDOW - WINDOW;
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 tenant: "t-1",
                 cost: Credit.fromDollars(0.01),
                 charge: Credit.fromDollars(0.02),
@@ -1013,7 +1013,7 @@ describe("MeterEmitter - fail-closed policy", () => {
                 usage: { units: 100, unitType: "tokens" },
                 tier: "branded",
             }));
-            emitter.emit(makeEvent({
+            await emitter.emit(makeEvent({
                 tenant: "t-1",
                 cost: Credit.fromDollars(0.03),
                 charge: Credit.fromDollars(0.06),
@@ -1034,7 +1034,7 @@ describe("MeterEmitter - fail-closed policy", () => {
                 tier: "wopr",
                 metadata: { foo: "bar" },
             });
-            emitter.emit(event);
+            await emitter.emit(event);
             // WAL should persist new fields
             const walContent = readFileSync(TEST_WAL_PATH, "utf8");
             const walEvent = JSON.parse(walContent.trim());

package/dist/metering/wal.d.ts

@@ -13,14 +13,16 @@ export declare class MeterWAL {
     constructor(walPath: string);
     private ensureDir;
     /**
-     * Append an event to the WAL. appendFileSync is atomic on POSIX (O_APPEND),
-     * so no mutex is needed here. Returns the event with a generated ID.
+     * Append an event to the WAL. Mutex-guarded to prevent TOCTOU races
+     * with remove(), which does a read-filter-rewrite that would clobber
+     * concurrent appends. Uses appendFileSync inside the lock for
+     * fail-closed crash safety (POSIX O_APPEND atomic write).
      */
     append(event: MeterEvent & {
         id?: string;
-    }): MeterEvent & {
+    }): Promise<MeterEvent & {
         id: string;
-    };
+    }>;
     /**
      * Read all events from the WAL. Returns events in the order they were written.
      * Skips malformed lines (defensive against incomplete writes).

package/dist/metering/wal.js

@@ -35,17 +35,21 @@ export class MeterWAL {
         }
     }
     /**
-     * Append an event to the WAL. appendFileSync is atomic on POSIX (O_APPEND),
-     * so no mutex is needed here. Returns the event with a generated ID.
+     * Append an event to the WAL. Mutex-guarded to prevent TOCTOU races
+     * with remove(), which does a read-filter-rewrite that would clobber
+     * concurrent appends. Uses appendFileSync inside the lock for
+     * fail-closed crash safety (POSIX O_APPEND atomic write).
      */
-    append(event) {
-        const eventWithId = {
-            ...event,
-            id: event.id ?? crypto.randomUUID(),
-        };
-        const line = `${JSON.stringify(eventWithId)}\n`;
-        appendFileSync(this.walPath, line, { encoding: "utf8", flag: "a" });
-        return eventWithId;
+    async append(event) {
+        return this.withLock(() => {
+            const eventWithId = {
+                ...event,
+                id: event.id ?? crypto.randomUUID(),
+            };
+            const line = `${JSON.stringify(eventWithId)}\n`;
+            appendFileSync(this.walPath, line, { encoding: "utf8", flag: "a" });
+            return eventWithId;
+        });
     }
     /**
      * Read all events from the WAL. Returns events in the order they were written.

package/dist/metering/wal.test.js

@@ -125,6 +125,27 @@ describe("MeterWAL", () => {
         expect(tenants).not.toContain("t-2");
         expect(events).toHaveLength(2);
     });
+    it("concurrent appends and remove are serialized without data loss", async () => {
+        // Seed 2 events to remove
+        const e1 = await wal.append(makeEvent({ tenant: "seed-1" }));
+        const e2 = await wal.append(makeEvent({ tenant: "seed-2" }));
+        // Fire remove + 3 concurrent appends
+        const removePromise = wal.remove(new Set([e1.id, e2.id]));
+        const a1 = wal.append(makeEvent({ tenant: "new-1" }));
+        const a2 = wal.append(makeEvent({ tenant: "new-2" }));
+        const a3 = wal.append(makeEvent({ tenant: "new-3" }));
+        await Promise.all([removePromise, a1, a2, a3]);
+        const events = wal.readAll();
+        const tenants = events.map((e) => e.tenant);
+        // Seeded events must be gone
+        expect(tenants).not.toContain("seed-1");
+        expect(tenants).not.toContain("seed-2");
+        // All 3 new appends must survive
+        expect(tenants).toContain("new-1");
+        expect(tenants).toContain("new-2");
+        expect(tenants).toContain("new-3");
+        expect(events).toHaveLength(3);
+    });
 });
 describe("MeterDLQ", () => {
     let dlq;

package/dist/security/redirect-allowlist.js

@@ -1,10 +1,29 @@
 const STATIC_ORIGINS = ["https://app.wopr.bot", "https://wopr.network"];
+function parseExtraOrigins() {
+    const raw = process.env.EXTRA_ALLOWED_REDIRECT_ORIGINS;
+    if (!raw)
+        return [];
+    return raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .filter((entry) => {
+        try {
+            new URL(entry);
+            return true;
+        }
+        catch {
+            console.warn(`[redirect-allowlist] Malformed entry in EXTRA_ALLOWED_REDIRECT_ORIGINS, skipping: ${entry}`);
+            return false;
+        }
+    });
+}
 function getAllowedOrigins() {
     return [
         ...STATIC_ORIGINS,
         ...(process.env.NODE_ENV !== "production" ? ["http://localhost:3000", "http://localhost:3001"] : []),
         ...(process.env.PLATFORM_UI_URL ? [process.env.PLATFORM_UI_URL] : []),
-        ...(process.env.NODE_ENV !== "production" ? ["https://example.com"] : []),
+        ...(process.env.NODE_ENV !== "production" ? parseExtraOrigins() : []),
     ];
 }
 /**

package/dist/security/redirect-allowlist.test.js

@@ -34,6 +34,40 @@ describe("assertSafeRedirectUrl", () => {
     it("rejects empty string", () => {
         expect(() => assertSafeRedirectUrl("")).toThrow("Invalid redirect URL");
     });
+    it("rejects https://example.com", () => {
+        expect(() => assertSafeRedirectUrl("https://example.com/callback")).toThrow("Invalid redirect URL");
+    });
+    describe("EXTRA_ALLOWED_REDIRECT_ORIGINS env-driven entries", () => {
+        beforeEach(() => {
+            vi.resetModules();
+        });
+        afterEach(() => {
+            delete process.env.EXTRA_ALLOWED_REDIRECT_ORIGINS;
+            vi.resetModules();
+        });
+        it("allows origins listed in EXTRA_ALLOWED_REDIRECT_ORIGINS", async () => {
+            process.env.EXTRA_ALLOWED_REDIRECT_ORIGINS = "https://staging.wopr.bot";
+            const { assertSafeRedirectUrl: assertSafe } = await import("./redirect-allowlist.js");
+            expect(() => assertSafe("https://staging.wopr.bot/billing")).not.toThrow();
+        });
+        it("allows multiple comma-separated origins", async () => {
+            process.env.EXTRA_ALLOWED_REDIRECT_ORIGINS = "https://staging.wopr.bot,https://preview.wopr.bot";
+            const { assertSafeRedirectUrl: assertSafe } = await import("./redirect-allowlist.js");
+            expect(() => assertSafe("https://staging.wopr.bot/billing")).not.toThrow();
+            expect(() => assertSafe("https://preview.wopr.bot/dashboard")).not.toThrow();
+        });
+        it("ignores empty/whitespace entries in comma-separated list", async () => {
+            process.env.EXTRA_ALLOWED_REDIRECT_ORIGINS = "https://staging.wopr.bot, , ,";
+            const { assertSafeRedirectUrl: assertSafe } = await import("./redirect-allowlist.js");
+            expect(() => assertSafe("https://staging.wopr.bot/billing")).not.toThrow();
+            expect(() => assertSafe("https://evil.com/phishing")).toThrow("Invalid redirect URL");
+        });
+        it("defaults to empty when env var is unset", async () => {
+            delete process.env.EXTRA_ALLOWED_REDIRECT_ORIGINS;
+            const { assertSafeRedirectUrl: assertSafe } = await import("./redirect-allowlist.js");
+            expect(() => assertSafe("https://random.example.org")).toThrow("Invalid redirect URL");
+        });
+    });
     describe("PLATFORM_UI_URL env-driven entry", () => {
         beforeEach(() => {
             process.env.PLATFORM_UI_URL = "https://platform.example.com";

package/package.json

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