@wopr-network/platform-core 0.1.0

package/src/email/verification.ts

@@ -0,0 +1,110 @@
+/**
+ * Email Verification — Token generation, validation, and verification flow.
+ *
+ * Manages the signup verification lifecycle:
+ * 1. Generate signed token on signup
+ * 2. Store token + expiry in the auth database
+ * 3. Verify token when user clicks the link
+ * 4. Mark user as verified, send welcome email, grant credits
+ */
+
+import crypto from "node:crypto";
+import type { Pool } from "pg";
+import type { IEmailVerifier } from "./require-verified.js";
+
+const TOKEN_EXPIRY_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+
+/** Add email verification columns to the better-auth user table. */
+export async function initVerificationSchema(pool: Pool): Promise<void> {
+  // raw SQL: better-auth manages its own schema outside Drizzle
+  await pool.query(`ALTER TABLE "user" ADD COLUMN IF NOT EXISTS email_verified BOOLEAN NOT NULL DEFAULT false`);
+  // raw SQL: better-auth manages its own schema outside Drizzle
+  await pool.query(`ALTER TABLE "user" ADD COLUMN IF NOT EXISTS verification_token TEXT`);
+  // raw SQL: better-auth manages its own schema outside Drizzle
+  await pool.query(`ALTER TABLE "user" ADD COLUMN IF NOT EXISTS verification_expires TEXT`);
+}
+
+// ---------------------------------------------------------------------------
+// Token operations
+// ---------------------------------------------------------------------------
+
+export interface VerificationToken {
+  token: string;
+  expiresAt: string; // ISO-8601
+}
+
+/**
+ * Generate a verification token and store it against a user.
+ */
+export async function generateVerificationToken(pool: Pool, userId: string): Promise<VerificationToken> {
+  const token = crypto.randomBytes(32).toString("hex");
+  const expiresAt = new Date(Date.now() + TOKEN_EXPIRY_MS).toISOString();
+
+  // raw SQL: better-auth manages its own schema outside Drizzle
+  await pool.query(`UPDATE "user" SET verification_token = $1, verification_expires = $2 WHERE id = $3`, [
+    token,
+    expiresAt,
+    userId,
+  ]);
+
+  return { token, expiresAt };
+}
+
+/**
+ * Verify a token: check it exists, hasn't expired, and mark the user as verified.
+ */
+export async function verifyToken(pool: Pool, token: string): Promise<{ userId: string; email: string } | null> {
+  if (!token || token.length !== 64) return null;
+
+  // raw SQL: better-auth manages its own schema outside Drizzle
+  const { rows } = await pool.query(
+    `SELECT id, email, verification_token, verification_expires, email_verified FROM "user" WHERE verification_token = $1`,
+    [token],
+  );
+
+  const row = rows[0];
+  if (!row) return null;
+  if (row.email_verified === true) return null;
+
+  const expiresAt = new Date(row.verification_expires).getTime();
+  if (Date.now() > expiresAt) return null;
+
+  // raw SQL: better-auth manages its own schema outside Drizzle
+  await pool.query(
+    `UPDATE "user" SET email_verified = true, "emailVerified" = true, verification_token = NULL, verification_expires = NULL WHERE id = $1`,
+    [row.id],
+  );
+
+  return { userId: row.id, email: row.email };
+}
+
+/**
+ * Check whether a user has verified their email.
+ */
+export async function isEmailVerified(pool: Pool, userId: string): Promise<boolean> {
+  // raw SQL: better-auth manages its own schema outside Drizzle
+  const { rows } = await pool.query(`SELECT email_verified FROM "user" WHERE id = $1`, [userId]);
+  return rows[0]?.email_verified === true;
+}
+
+/**
+ * Get a user's email by their ID.
+ */
+export async function getUserEmail(pool: Pool, userId: string): Promise<string | null> {
+  // raw SQL: better-auth manages its own schema outside Drizzle
+  const { rows } = await pool.query(`SELECT email FROM "user" WHERE id = $1`, [userId]);
+  return rows[0]?.email ?? null;
+}
+
+/** PostgreSQL-backed implementation of IEmailVerifier for the auth database. */
+export class PgEmailVerifier implements IEmailVerifier {
+  constructor(private readonly pool: Pool) {}
+
+  async isVerified(userId: string): Promise<boolean> {
+    return isEmailVerified(this.pool, userId);
+  }
+}

package/src/index.ts

@@ -0,0 +1,51 @@
+// Database
+export type { PlatformDb, PlatformSchema } from "./db/index.js";
+export { createDb, schema } from "./db/index.js";
+
+// Admin
+export * from "./admin/index.js";
+
+// Auth
+export * from "./auth/index.js";
+
+// Billing (selective — ITenantCustomerRepository/TenantCustomerRow also in credits)
+export {
+  PaymentMethodOwnershipError,
+  noOpReplayGuard,
+  DrizzleWebhookSeenRepository,
+  type SavedPaymentMethod,
+  type CheckoutOpts,
+  type CheckoutSession,
+  type ChargeOpts,
+  type ChargeResult,
+  type SetupResult,
+  type PortalOpts,
+  type WebhookResult,
+  type IPaymentProcessor,
+  type Invoice,
+  type IWebhookSeenRepository,
+} from "./billing/index.js";
+
+// Config
+export { config, billingConfigSchema, type PlatformConfig } from "./config/index.js";
+
+// Credits
+export * from "./credits/index.js";
+
+// Email
+export * from "./email/index.js";
+
+// Metering
+export * from "./metering/index.js";
+
+// Middleware
+export * from "./middleware/index.js";
+
+// Security
+export * from "./security/index.js";
+
+// Tenancy
+export * from "./tenancy/index.js";
+
+// tRPC
+export * from "./trpc/index.js";

package/src/metering/aggregator.test.ts

@@ -0,0 +1,239 @@
+import crypto from "node:crypto";
+import type { PGlite } from "@electric-sql/pglite";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { PlatformDb } from "../db/index.js";
+import { meterEvents, usageSummaries } from "../db/schema/meter-events.js";
+import { createTestDb } from "../test/db.js";
+import { Credit } from "../credits/credit.js";
+import { DrizzleMeterAggregator } from "./aggregator.js";
+import { DrizzleUsageSummaryRepository } from "./drizzle-usage-summary-repository.js";
+
+const WINDOW_MS = 60_000; // 1-minute windows
+
+describe("DrizzleMeterAggregator edge cases", () => {
+  let db: PlatformDb;
+  let pool: PGlite;
+  let aggregator: DrizzleMeterAggregator;
+
+  beforeEach(async () => {
+    const testDb = await createTestDb();
+    db = testDb.db;
+    pool = testDb.pool;
+    aggregator = new DrizzleMeterAggregator(new DrizzleUsageSummaryRepository(db), { windowMs: WINDOW_MS });
+  });
+
+  afterEach(async () => {
+    aggregator.stop();
+    await pool.close();
+  });
+
+  async function insertEvent(overrides: {
+    tenant?: string;
+    cost?: number;
+    charge?: number;
+    capability?: string;
+    provider?: string;
+    timestamp: number;
+    id?: string;
+  }) {
+    await db.insert(meterEvents).values({
+      id: overrides.id ?? crypto.randomUUID(),
+      tenant: overrides.tenant ?? "tenant-1",
+      cost: overrides.cost ?? Credit.fromDollars(0.001).toRaw(),
+      charge: overrides.charge ?? Credit.fromDollars(0.002).toRaw(),
+      capability: overrides.capability ?? "embeddings",
+      provider: overrides.provider ?? "openai",
+      timestamp: overrides.timestamp,
+    });
+  }
+
+  it("sums events correctly within a single completed window", async () => {
+    const baseTime = 0;
+    await insertEvent({ timestamp: baseTime + 10_000, cost: 1_000_000, charge: 2_000_000 });
+    await insertEvent({ timestamp: baseTime + 20_000, cost: 3_000_000, charge: 4_000_000 });
+    await insertEvent({ timestamp: baseTime + 30_000, cost: 5_000_000, charge: 6_000_000 });
+
+    const inserted = await aggregator.aggregate(WINDOW_MS + 1);
+
+    expect(inserted).toBe(1);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+    expect(real).toHaveLength(1);
+    expect(real[0].tenant).toBe("tenant-1");
+    expect(real[0].eventCount).toBe(3);
+    expect(real[0].totalCost).toBe(9_000_000);
+    expect(real[0].totalCharge).toBe(12_000_000);
+    expect(real[0].windowStart).toBe(0);
+    expect(real[0].windowEnd).toBe(WINDOW_MS);
+  });
+
+  it("returns zero and inserts sentinel when no events exist", async () => {
+    const inserted = await aggregator.aggregate(WINDOW_MS + 1);
+
+    expect(inserted).toBe(0);
+
+    const summaries = await db.select().from(usageSummaries);
+    expect(summaries).toHaveLength(1);
+    expect(summaries[0].tenant).toBe("__sentinel__");
+    expect(summaries[0].eventCount).toBe(0);
+  });
+
+  it("rejects duplicate event IDs via primary key constraint", async () => {
+    const eventId = crypto.randomUUID();
+    await insertEvent({ timestamp: 10_000, id: eventId });
+
+    await expect(insertEvent({ timestamp: 10_000, id: eventId })).rejects.toThrow();
+
+    const inserted = await aggregator.aggregate(WINDOW_MS + 1);
+    expect(inserted).toBe(1);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+    expect(real).toHaveLength(1);
+    expect(real[0].eventCount).toBe(1);
+  });
+
+  it("handles very large cost totals without overflow", async () => {
+    const largeCost = 1_000_000_000_000;
+    const largeCharge = 2_000_000_000_000;
+
+    for (let i = 0; i < 5; i++) {
+      await insertEvent({ timestamp: 10_000 + i * 1000, cost: largeCost, charge: largeCharge });
+    }
+
+    const inserted = await aggregator.aggregate(WINDOW_MS + 1);
+    expect(inserted).toBe(1);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+    expect(real).toHaveLength(1);
+    expect(real[0].totalCost).toBe(5_000_000_000_000);
+    expect(real[0].totalCharge).toBe(10_000_000_000_000);
+    expect(real[0].eventCount).toBe(5);
+  });
+
+  it("isolates aggregation per tenant", async () => {
+    await insertEvent({ tenant: "tenant-A", timestamp: 10_000, cost: 1_000_000, charge: 2_000_000 });
+    await insertEvent({ tenant: "tenant-A", timestamp: 20_000, cost: 3_000_000, charge: 4_000_000 });
+    await insertEvent({ tenant: "tenant-B", timestamp: 15_000, cost: 5_000_000, charge: 6_000_000 });
+
+    const inserted = await aggregator.aggregate(WINDOW_MS + 1);
+    expect(inserted).toBe(2);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+    expect(real).toHaveLength(2);
+
+    const tenantA = real.find((s) => s.tenant === "tenant-A");
+    expect(tenantA).toEqual(
+      expect.objectContaining({
+        tenant: "tenant-A",
+        eventCount: 2,
+        totalCost: 4_000_000,
+        totalCharge: 6_000_000,
+      }),
+    );
+    const tenantB = real.find((s) => s.tenant === "tenant-B");
+    expect(tenantB).toEqual(
+      expect.objectContaining({
+        tenant: "tenant-B",
+        eventCount: 1,
+        totalCost: 5_000_000,
+        totalCharge: 6_000_000,
+      }),
+    );
+  });
+
+  it("includes events at window start, excludes events at window end", async () => {
+    await insertEvent({ timestamp: 0, cost: 1_000_000, charge: 1_000_000 });
+    await insertEvent({ timestamp: 59_999, cost: 2_000_000, charge: 2_000_000 });
+    await insertEvent({ timestamp: 60_000, cost: 100_000_000, charge: 100_000_000 });
+
+    const inserted = await aggregator.aggregate(2 * WINDOW_MS + 1);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+
+    const window0 = real.find((s) => s.windowStart === 0);
+    expect(window0).toEqual(
+      expect.objectContaining({
+        windowStart: 0,
+        eventCount: 2,
+        totalCost: 3_000_000,
+      }),
+    );
+
+    const window1 = real.find((s) => s.windowStart === 60_000);
+    expect(window1).toEqual(
+      expect.objectContaining({
+        windowStart: 60_000,
+        eventCount: 1,
+        totalCost: 100_000_000,
+      }),
+    );
+
+    // window0: 1 tenant/capability/provider group = 1 row
+    // window1: 1 tenant/capability/provider group = 1 row
+    expect(inserted).toBe(2);
+  });
+
+  it("aggregates zero-cost events correctly", async () => {
+    await insertEvent({ timestamp: 10_000, cost: 0, charge: 0 });
+    await insertEvent({ timestamp: 20_000, cost: 0, charge: 0 });
+
+    const inserted = await aggregator.aggregate(WINDOW_MS + 1);
+    expect(inserted).toBe(1);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+    expect(real).toHaveLength(1);
+    expect(real[0].totalCost).toBe(0);
+    expect(real[0].totalCharge).toBe(0);
+    expect(real[0].eventCount).toBe(2);
+  });
+
+  it("handles a single event exactly at window boundary", async () => {
+    // Event at timestamp 0 (window start) — should be in window [0, WINDOW_MS)
+    await insertEvent({ timestamp: 0, cost: 1_000_000, charge: 2_000_000 });
+
+    const inserted = await aggregator.aggregate(WINDOW_MS + 1);
+    expect(inserted).toBe(1);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+    expect(real).toHaveLength(1);
+    expect(real[0].eventCount).toBe(1);
+    expect(real[0].totalCost).toBe(1_000_000);
+  });
+
+  it("handles event one unit before window end", async () => {
+    // Event at WINDOW_MS - 1 should be included in first window
+    await insertEvent({ timestamp: WINDOW_MS - 1, cost: 500_000, charge: 600_000 });
+
+    const inserted = await aggregator.aggregate(WINDOW_MS + 1);
+    expect(inserted).toBe(1);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+    expect(real).toHaveLength(1);
+    expect(real[0].windowStart).toBe(0);
+    expect(real[0].eventCount).toBe(1);
+    expect(real[0].totalCost).toBe(500_000);
+  });
+
+  it("handles event exactly at window end (goes to next window)", async () => {
+    // Event at exactly WINDOW_MS should be in window [WINDOW_MS, 2*WINDOW_MS)
+    await insertEvent({ timestamp: WINDOW_MS, cost: 700_000, charge: 800_000 });
+
+    await aggregator.aggregate(2 * WINDOW_MS + 1);
+
+    const summaries = await db.select().from(usageSummaries);
+    const real = summaries.filter((s) => s.tenant !== "__sentinel__");
+    // Should be in second window, not first
+    expect(real).toHaveLength(1);
+    expect(real[0].windowStart).toBe(WINDOW_MS);
+    expect(real[0].eventCount).toBe(1);
+    expect(real[0].totalCost).toBe(700_000);
+  });
+});

package/src/metering/aggregator.ts

@@ -0,0 +1,160 @@
+import crypto from "node:crypto";
+import type { IUsageSummaryRepository } from "./drizzle-usage-summary-repository.js";
+import type { UsageSummary } from "./types.js";
+
+export interface IMeterAggregator {
+  aggregate(now?: number): Promise<number>;
+  start(intervalMs?: number): void;
+  stop(): void;
+  querySummaries(tenant: string, opts?: { since?: number; until?: number; limit?: number }): Promise<UsageSummary[]>;
+  getTenantTotal(
+    tenant: string,
+    since: number,
+  ): Promise<{ totalCost: number; totalCharge: number; eventCount: number }>;
+}
+
+/**
+ * Background aggregator that rolls up raw meter events into per-tenant
+ * usage summaries over fixed time windows.
+ *
+ * Designed to run periodically (e.g., every minute). Each run aggregates
+ * events from a completed window that haven't been summarized yet.
+ */
+export class DrizzleMeterAggregator implements IMeterAggregator {
+  private readonly windowMs: number;
+  private timer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private readonly repo: IUsageSummaryRepository,
+    opts: { windowMs?: number } = {},
+  ) {
+    this.windowMs = opts.windowMs ?? 60_000; // 1 minute default
+  }
+
+  /**
+   * Aggregate all events in completed windows up to `now`.
+   * Returns the number of summary rows inserted.
+   */
+  async aggregate(now: number = Date.now()): Promise<number> {
+    let lastEnd = await this.repo.getLastWindowEnd();
+
+    // Calculate the current window boundary. We only aggregate *completed* windows.
+    const currentWindowStart = Math.floor(now / this.windowMs) * this.windowMs;
+
+    if (lastEnd >= currentWindowStart) {
+      // Nothing new to aggregate.
+      return 0;
+    }
+
+    let totalInserted = 0;
+
+    // Process one window at a time to respect fixed time window boundaries.
+    // On first run (lastEnd === 0), align to the first window boundary at or
+    // before currentWindowStart so we don't create thousands of empty sentinels.
+    if (lastEnd === 0) {
+      // Find earliest event to anchor the first window.
+      const earliest = await this.repo.getEarliestEventTimestamp(currentWindowStart);
+      if (earliest != null) {
+        lastEnd = Math.floor(earliest / this.windowMs) * this.windowMs;
+      } else {
+        // No events at all -- insert a single sentinel to mark we've processed up to now.
+        await this.repo.insertSummary({
+          id: crypto.randomUUID(),
+          tenant: "__sentinel__",
+          capability: "__none__",
+          provider: "__none__",
+          eventCount: 0,
+          totalCost: 0,
+          totalCharge: 0,
+          totalDuration: 0,
+          windowStart: 0,
+          windowEnd: currentWindowStart,
+        });
+        return 0;
+      }
+    }
+
+    while (lastEnd < currentWindowStart) {
+      const windowStart = lastEnd;
+      const windowEnd = Math.min(lastEnd + this.windowMs, currentWindowStart);
+
+      // Group events by tenant + capability + provider within this single window.
+      const rows = await this.repo.getAggregatedEvents(windowStart, windowEnd);
+
+      if (rows.length === 0) {
+        // Advance past this empty window by inserting a sentinel with zero counts.
+        await this.repo.insertSummary({
+          id: crypto.randomUUID(),
+          tenant: "__sentinel__",
+          capability: "__none__",
+          provider: "__none__",
+          eventCount: 0,
+          totalCost: 0,
+          totalCharge: 0,
+          totalDuration: 0,
+          windowStart,
+          windowEnd,
+        });
+      } else {
+        await this.repo.insertSummariesBatch(
+          rows.map((s) => ({
+            id: crypto.randomUUID(),
+            tenant: s.tenant,
+            capability: s.capability,
+            provider: s.provider,
+            eventCount: s.eventCount,
+            totalCost: s.totalCost,
+            totalCharge: s.totalCharge,
+            totalDuration: s.totalDuration,
+            windowStart,
+            windowEnd,
+          })),
+        );
+        totalInserted += rows.length;
+      }
+
+      lastEnd = windowEnd;
+    }
+
+    return totalInserted;
+  }
+
+  /** Start periodic aggregation. */
+  start(intervalMs?: number): void {
+    if (this.timer) {
+      return; // Already running -- avoid leaking a second interval timer.
+    }
+    const interval = intervalMs ?? this.windowMs;
+    this.timer = setInterval(() => this.aggregate(), interval);
+    if (this.timer.unref) {
+      this.timer.unref();
+    }
+  }
+
+  /** Stop periodic aggregation. */
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  /** Query usage summaries for a tenant within a time range. */
+  async querySummaries(
+    tenant: string,
+    opts: { since?: number; until?: number; limit?: number } = {},
+  ): Promise<UsageSummary[]> {
+    return this.repo.querySummaries(tenant, opts);
+  }
+
+  /** Get a tenant's total usage across all capabilities since a given time. */
+  async getTenantTotal(
+    tenant: string,
+    since: number,
+  ): Promise<{ totalCost: number; totalCharge: number; eventCount: number }> {
+    return this.repo.getTenantTotal(tenant, since);
+  }
+}
+
+// Backward-compat alias.
+export { DrizzleMeterAggregator as MeterAggregator };

package/src/metering/dlq.test.ts

@@ -0,0 +1,134 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { Credit } from "../credits/credit.js";
+import { MeterDLQ } from "./dlq.js";
+
+describe("MeterDLQ", () => {
+  let tmpDir: string;
+  let dlqPath: string;
+
+  beforeEach(() => {
+    tmpDir = path.join(os.tmpdir(), `wopr-dlq-test-${Date.now()}`);
+    dlqPath = path.join(tmpDir, "meter-dlq.jsonl");
+  });
+
+  afterEach(() => {
+    if (existsSync(tmpDir)) {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("creates the directory when it does not exist", () => {
+    // tmpDir doesn't exist yet — constructor should create it
+    expect(existsSync(tmpDir)).toBe(false);
+    new MeterDLQ(dlqPath);
+    expect(existsSync(tmpDir)).toBe(true);
+  });
+
+  it("does not throw when directory already exists", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    expect(() => new MeterDLQ(dlqPath)).not.toThrow();
+  });
+
+  it("readAll returns empty array when DLQ file does not exist", () => {
+    new MeterDLQ(dlqPath);
+    expect(existsSync(dlqPath)).toBe(false);
+    const dlq = new MeterDLQ(dlqPath);
+    expect(dlq.readAll()).toEqual([]);
+  });
+
+  it("readAll returns empty array when DLQ file is empty", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(dlqPath, "");
+    const dlq = new MeterDLQ(dlqPath);
+    expect(dlq.readAll()).toEqual([]);
+  });
+
+  it("readAll returns empty array when DLQ file contains only whitespace", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(dlqPath, "\n\n  \n");
+    const dlq = new MeterDLQ(dlqPath);
+    expect(dlq.readAll()).toEqual([]);
+  });
+
+  it("append writes a DLQ entry and readAll returns it", () => {
+    const dlq = new MeterDLQ(dlqPath);
+    const event = {
+      id: "evt-1",
+      tenant: "tenant-1",
+      capability: "tts",
+      provider: "elevenlabs",
+      cost: Credit.fromDollars(0.01),
+      charge: Credit.fromDollars(0.02),
+      timestamp: Date.now(),
+    };
+
+    dlq.append(event, "Stripe API 500", 3);
+
+    const entries = dlq.readAll();
+    expect(entries).toHaveLength(1);
+    expect(entries[0].id).toBe("evt-1");
+    expect(entries[0].dlq_error).toBe("Stripe API 500");
+    expect(entries[0].dlq_retries).toBe(3);
+  });
+
+  it("count returns 0 for empty DLQ", () => {
+    const dlq = new MeterDLQ(dlqPath);
+    expect(dlq.count()).toBe(0);
+  });
+
+  it("count returns correct count after appending", () => {
+    const dlq = new MeterDLQ(dlqPath);
+    const event = {
+      id: "evt-1",
+      tenant: "t1",
+      capability: "tts",
+      provider: "elevenlabs",
+      cost: Credit.fromDollars(0.01),
+      charge: Credit.fromDollars(0.02),
+      timestamp: Date.now(),
+    };
+    dlq.append(event, "err", 1);
+    dlq.append({ ...event, id: "evt-2" }, "err2", 2);
+    expect(dlq.count()).toBe(2);
+  });
+
+  it("count counts malformed lines (no JSON parsing)", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    const goodLine = JSON.stringify({ id: "evt-1", dlq_error: "e", dlq_retries: 1, dlq_timestamp: 0 });
+    writeFileSync(dlqPath, `${goodLine}\nnot-valid-json\n`);
+    const dlq = new MeterDLQ(dlqPath);
+    // count should return 2 (line count), not 1 (parsed count)
+    // This verifies count() does NOT use JSON.parse
+    expect(dlq.count()).toBe(2);
+  });
+
+  it("count returns correct count when file has no trailing newline", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    const line1 = JSON.stringify({ id: "evt-1", dlq_error: "e", dlq_retries: 1, dlq_timestamp: 0 });
+    const line2 = JSON.stringify({ id: "evt-2", dlq_error: "e", dlq_retries: 1, dlq_timestamp: 0 });
+    // Write two entries with no trailing newline
+    writeFileSync(dlqPath, `${line1}\n${line2}`);
+    const dlq = new MeterDLQ(dlqPath);
+    expect(dlq.count()).toBe(2);
+  });
+
+  it("count returns 0 when file is deleted between calls (ENOENT)", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    const dlq = new MeterDLQ(dlqPath);
+    // File doesn't exist at all — should not throw, return 0
+    expect(dlq.count()).toBe(0);
+  });
+
+  it("readAll skips malformed lines", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    const goodLine = JSON.stringify({ id: "evt-1", dlq_error: "e", dlq_retries: 1, dlq_timestamp: 0 });
+    writeFileSync(dlqPath, `${goodLine}\nnot-valid-json\n`);
+    const dlq = new MeterDLQ(dlqPath);
+    const entries = dlq.readAll();
+    expect(entries).toHaveLength(1);
+    expect(entries[0].id).toBe("evt-1");
+  });
+});