@krizaka/credits 0.1.2 → 0.1.4

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   checkSettings,
   planDraws,
   skipFirst
-} from "./chunk-34Y2HXOB.js";
+} from "./chunk-FPQSMNV2.js";
 import {
   BUCKET,
   CREDITS_CODE,
@@ -16,7 +16,7 @@ import {
   ENTRY_TYPE,
   HOLD_STATUS,
   ON_EXHAUSTED
-} from "./chunk-WDHQ7QHY.js";
+} from "./chunk-NKDQNDSD.js";
 
 // src/credits.ts
 import { randomUUID } from "crypto";
@@ -70,9 +70,42 @@ var num = (v) => Number(v);
 var numOrNull = (v) => v === null ? null : Number(v);
 var date = (v) => new Date(v);
 var dateOrNull = (v) => v === null ? null : new Date(v);
-var toGrant = (r) => ({ id: r.id, accountId: r.account_id, bucket: r.bucket, amount: num(r.amount), capPerDay: numOrNull(r.cap_per_day), capPerMonth: numOrNull(r.cap_per_month), expiresAt: dateOrNull(r.expires_at), onExhausted: r.on_exhausted, source: r.source, createdAt: date(r.created_at) });
-var toEntry = (r) => ({ id: r.id, accountId: r.account_id, grantId: r.grant_id, type: r.type, amount: num(r.amount), reason: r.reason, operation: r.operation, idempotencyKey: r.idempotency_key, reverses: r.reverses, holdId: r.hold_id, at: date(r.at) });
-var toHold = (r) => ({ id: r.id, accountId: r.account_id, amount: num(r.amount), expiresAt: date(r.expires_at), status: r.status, settledAmount: numOrNull(r.settled_amount), createdAt: date(r.created_at), closedAt: dateOrNull(r.closed_at), operation: r.operation });
+var toGrant = (r) => ({
+  id: r.id,
+  accountId: r.account_id,
+  bucket: r.bucket,
+  amount: num(r.amount),
+  capPerDay: numOrNull(r.cap_per_day),
+  capPerMonth: numOrNull(r.cap_per_month),
+  expiresAt: dateOrNull(r.expires_at),
+  onExhausted: r.on_exhausted,
+  source: r.source,
+  createdAt: date(r.created_at)
+});
+var toEntry = (r) => ({
+  id: r.id,
+  accountId: r.account_id,
+  grantId: r.grant_id,
+  type: r.type,
+  amount: num(r.amount),
+  reason: r.reason,
+  operation: r.operation,
+  idempotencyKey: r.idempotency_key,
+  reverses: r.reverses,
+  holdId: r.hold_id,
+  at: date(r.at)
+});
+var toHold = (r) => ({
+  id: r.id,
+  accountId: r.account_id,
+  amount: num(r.amount),
+  expiresAt: date(r.expires_at),
+  status: r.status,
+  settledAmount: numOrNull(r.settled_amount),
+  createdAt: date(r.created_at),
+  closedAt: dateOrNull(r.closed_at),
+  operation: r.operation
+});
 function dbCreditStore(query, schema = "credits") {
   const s = ident(schema);
   const grant = `${s}."grant"`;
@@ -83,7 +116,21 @@ function dbCreditStore(query, schema = "credits") {
       await query("SELECT pg_advisory_xact_lock(hashtextextended('krizaka.credits:' || $1::text, 0))", [accountId]);
     },
     async insertGrant(g) {
-      await query(`INSERT INTO ${grant} (id, account_id, bucket, amount, cap_per_day, cap_per_month, expires_at, on_exhausted, source, created_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`, [g.id, g.accountId, g.bucket, g.amount, g.capPerDay, g.capPerMonth, g.expiresAt, g.onExhausted, g.source, g.createdAt]);
+      await query(
+        `INSERT INTO ${grant} (id, account_id, bucket, amount, cap_per_day, cap_per_month, expires_at, on_exhausted, source, created_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+        [
+          g.id,
+          g.accountId,
+          g.bucket,
+          g.amount,
+          g.capPerDay,
+          g.capPerMonth,
+          g.expiresAt,
+          g.onExhausted,
+          g.source,
+          g.createdAt
+        ]
+      );
     },
     async grantById(id) {
       const [row] = await query(`SELECT * FROM ${grant} WHERE id = $1`, [id]);
@@ -101,21 +148,50 @@ function dbCreditStore(query, schema = "credits") {
           GROUP BY g.id`,
         [accountId, calendar.timeZone, calendar.day, calendar.month]
       );
-      return rows.map((r) => ({ grant: toGrant(r), remaining: num(r.remaining), usedToday: num(r.used_today), usedThisMonth: num(r.used_month), closed: r.closed }));
+      return rows.map((r) => ({
+        grant: toGrant(r),
+        remaining: num(r.remaining),
+        usedToday: num(r.used_today),
+        usedThisMonth: num(r.used_month),
+        closed: r.closed
+      }));
     },
     async insertEntries(entries) {
       for (const e of entries) {
-        await query(`INSERT INTO ${entry} (id, account_id, grant_id, type, amount, reason, operation, idempotency_key, reverses, hold_id, at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, [e.id, e.accountId, e.grantId, e.type, e.amount, e.reason, e.operation, e.idempotencyKey, e.reverses, e.holdId, e.at]);
+        await query(
+          `INSERT INTO ${entry} (id, account_id, grant_id, type, amount, reason, operation, idempotency_key, reverses, hold_id, at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`,
+          [
+            e.id,
+            e.accountId,
+            e.grantId,
+            e.type,
+            e.amount,
+            e.reason,
+            e.operation,
+            e.idempotencyKey,
+            e.reverses,
+            e.holdId,
+            e.at
+          ]
+        );
       }
     },
     async entriesOf(operation) {
-      return (await query(`SELECT * FROM ${entry} WHERE operation = $1 ORDER BY seq`, [operation])).map(toEntry);
+      return (await query(`SELECT * FROM ${entry} WHERE operation = $1 ORDER BY seq`, [operation])).map(
+        toEntry
+      );
     },
     async history(accountId, { limit, before }) {
-      return (await query(`SELECT * FROM ${entry} WHERE account_id = $1 AND ($2::timestamptz IS NULL OR at < $2) ORDER BY seq DESC LIMIT $3`, [accountId, before ?? null, limit])).map(toEntry);
+      return (await query(
+        `SELECT * FROM ${entry} WHERE account_id = $1 AND ($2::timestamptz IS NULL OR at < $2) ORDER BY seq DESC LIMIT $3`,
+        [accountId, before ?? null, limit]
+      )).map(toEntry);
     },
     async insertHold(h) {
-      await query(`INSERT INTO ${hold} (id, account_id, amount, expires_at, status, settled_amount, created_at, closed_at, operation) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, [h.id, h.accountId, h.amount, h.expiresAt, h.status, h.settledAmount, h.createdAt, h.closedAt, h.operation]);
+      await query(
+        `INSERT INTO ${hold} (id, account_id, amount, expires_at, status, settled_amount, created_at, closed_at, operation) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+        [h.id, h.accountId, h.amount, h.expiresAt, h.status, h.settledAmount, h.createdAt, h.closedAt, h.operation]
+      );
     },
     async holdById(id) {
       const [row] = await query(`SELECT * FROM ${hold} WHERE id = $1`, [id]);
@@ -126,11 +202,19 @@ function dbCreditStore(query, schema = "credits") {
       return row ? toHold(row) : null;
     },
     async heldAmount(accountId, now, exceptHoldId) {
-      const [row] = await query(`SELECT COALESCE(SUM(amount), 0) AS held FROM ${hold} WHERE account_id = $1 AND status = 'active' AND expires_at > $2 AND ($3::uuid IS NULL OR id <> $3)`, [accountId, now, exceptHoldId ?? null]);
+      const [row] = await query(
+        `SELECT COALESCE(SUM(amount), 0) AS held FROM ${hold} WHERE account_id = $1 AND status = 'active' AND expires_at > $2 AND ($3::uuid IS NULL OR id <> $3)`,
+        [accountId, now, exceptHoldId ?? null]
+      );
       return num(row?.held ?? 0);
     },
     async closeHold(id, status, settledAmount, at) {
-      await query(`UPDATE ${hold} SET status = $2, settled_amount = $3, closed_at = $4 WHERE id = $1`, [id, status, settledAmount, at]);
+      await query(`UPDATE ${hold} SET status = $2, settled_amount = $3, closed_at = $4 WHERE id = $1`, [
+        id,
+        status,
+        settledAmount,
+        at
+      ]);
     },
     async lapsedWithCredits(now, limit) {
       const rows = await query(
@@ -171,19 +255,38 @@ function createCredits(deps) {
   });
   const replayOf = async (store, operation, accountId) => {
     const lines = await store.entriesOf(operation);
-    if (lines.some((l) => l.accountId !== accountId)) throw new CreditsError(CREDITS_CODE.keyReused, "This idempotency key was used for another account");
+    if (lines.some((l) => l.accountId !== accountId))
+      throw new CreditsError(CREDITS_CODE.keyReused, "This idempotency key was used for another account");
     return lines;
   };
   const announce = async (tx, type, seed, payload) => {
     await deps.outbox?.append(tx, { topic: CREDITS_TOPIC, type, payload, id: uuidOf(seed) });
   };
-  const grantPayload = (g) => ({ accountId: g.accountId, grantId: g.id, bucket: g.bucket, amount: g.amount, expiresAt: g.expiresAt?.toISOString() ?? null, capPerDay: g.capPerDay, capPerMonth: g.capPerMonth, onExhausted: g.onExhausted, source: g.source });
+  const grantPayload = (g) => ({
+    accountId: g.accountId,
+    grantId: g.id,
+    bucket: g.bucket,
+    amount: g.amount,
+    expiresAt: g.expiresAt?.toISOString() ?? null,
+    capPerDay: g.capPerDay,
+    capPerMonth: g.capPerMonth,
+    onExhausted: g.onExhausted,
+    source: g.source
+  });
   const announceExhausted = (tx, states, draws) => Promise.all(
     draws.flatMap((d) => {
       const s = states.find((x) => x.grant.id === d.grantId);
       if (!s || s.remaining - d.amount > 0) return [];
       const g = s.grant;
-      return [announce(tx, CREDIT_EVENT.exhausted, `exhausted:${g.id}`, { accountId: g.accountId, grantId: g.id, bucket: g.bucket, onExhausted: g.onExhausted, source: g.source })];
+      return [
+        announce(tx, CREDIT_EVENT.exhausted, `exhausted:${g.id}`, {
+          accountId: g.accountId,
+          grantId: g.id,
+          bucket: g.bucket,
+          onExhausted: g.onExhausted,
+          source: g.source
+        })
+      ];
     })
   );
   async function create(tx, kind, input) {
@@ -209,7 +312,20 @@ function createCredits(deps) {
       createdAt: now
     };
     await store.insertGrant(grant);
-    await store.insertEntries([entry({ accountId: grant.accountId, grantId: grant.id, type: granted ? ENTRY_TYPE.grant : ENTRY_TYPE.purchase, amount: input.amount, reason: input.source, operation }, 0, now)]);
+    await store.insertEntries([
+      entry(
+        {
+          accountId: grant.accountId,
+          grantId: grant.id,
+          type: granted ? ENTRY_TYPE.grant : ENTRY_TYPE.purchase,
+          amount: input.amount,
+          reason: input.source,
+          operation
+        },
+        0,
+        now
+      )
+    ]);
     await announce(tx, CREDIT_EVENT.granted, `granted:${grant.id}`, grantPayload(grant));
     return { grantId: grant.id, replayed: false };
   }
@@ -222,7 +338,23 @@ function createCredits(deps) {
     const plan = planDraws(states, held + args.amount, now);
     if (!plan.ok) throw new CreditsError(plan.code, REFUSAL_TEXT[plan.code] ?? plan.code);
     const draws = skipFirst(plan.draws, held);
-    await store.insertEntries(draws.map((d, i) => entry({ accountId: args.accountId, grantId: d.grantId, type: ENTRY_TYPE.debit, amount: -d.amount, reason: args.reason, operation: args.operation, ...args.holdId ? { holdId: args.holdId } : {} }, i, now)));
+    await store.insertEntries(
+      draws.map(
+        (d, i) => entry(
+          {
+            accountId: args.accountId,
+            grantId: d.grantId,
+            type: ENTRY_TYPE.debit,
+            amount: -d.amount,
+            reason: args.reason,
+            operation: args.operation,
+            ...args.holdId ? { holdId: args.holdId } : {}
+          },
+          i,
+          now
+        )
+      )
+    );
     await announceExhausted(tx, states, draws);
     return draws;
   }
@@ -235,7 +367,20 @@ function createCredits(deps) {
     const now = deps.clock.now();
     const state = (await statesOf(store, found.accountId, now, timeZone)).find((s) => s.grant.id === grantId);
     if (state.closed) return { expired: 0 };
-    await store.insertEntries([entry({ accountId: found.accountId, grantId, type: ENTRY_TYPE.expiry, amount: -state.remaining, reason: "expiry", operation: `expire.${grantId}` }, 0, now)]);
+    await store.insertEntries([
+      entry(
+        {
+          accountId: found.accountId,
+          grantId,
+          type: ENTRY_TYPE.expiry,
+          amount: -state.remaining,
+          reason: "expiry",
+          operation: `expire.${grantId}`
+        },
+        0,
+        now
+      )
+    ]);
     return { expired: state.remaining };
   }
   return {
@@ -244,13 +389,22 @@ function createCredits(deps) {
     async consume(tx, input) {
       checkAmount(input.amount, "a consumption");
       checkKey(input.idempotencyKey);
-      if (!input.reason || input.reason.length > MAX_REASON) throw new CreditsError(CREDITS_CODE.badGrant, `A reason is 1 to ${MAX_REASON} characters`);
+      if (!input.reason || input.reason.length > MAX_REASON)
+        throw new CreditsError(CREDITS_CODE.badGrant, `A reason is 1 to ${MAX_REASON} characters`);
       const store = storeFor(tx);
       await store.lock(input.accountId);
       const operation = `consume.${input.idempotencyKey}`;
       const before = await replayOf(store, operation, input.accountId);
       if (before.length > 0) return { draws: drawsOf(before), replayed: true };
-      return { draws: await spend(tx, store, { accountId: input.accountId, amount: input.amount, reason: input.reason, operation }), replayed: false };
+      return {
+        draws: await spend(tx, store, {
+          accountId: input.accountId,
+          amount: input.amount,
+          reason: input.reason,
+          operation
+        }),
+        replayed: false
+      };
     },
     async hold(tx, input) {
       checkAmount(input.amount, "a hold");
@@ -263,14 +417,25 @@ function createCredits(deps) {
       const operation = `hold.${input.idempotencyKey}`;
       const known = await store.holdByOperation(operation);
       if (known) {
-        if (known.accountId !== input.accountId) throw new CreditsError(CREDITS_CODE.keyReused, "This idempotency key was used for another account");
+        if (known.accountId !== input.accountId)
+          throw new CreditsError(CREDITS_CODE.keyReused, "This idempotency key was used for another account");
         return { holdId: known.id, expiresAt: known.expiresAt, replayed: true };
       }
       const now = deps.clock.now();
       const held = await store.heldAmount(input.accountId, now);
       const plan = planDraws(await statesOf(store, input.accountId, now, s.timeZone), held + input.amount, now);
       if (!plan.ok) throw new CreditsError(plan.code, REFUSAL_TEXT[plan.code] ?? plan.code);
-      const hold = { id: newId(), accountId: input.accountId, amount: input.amount, expiresAt: addSeconds(now, ttl), status: HOLD_STATUS.active, settledAmount: null, createdAt: now, closedAt: null, operation };
+      const hold = {
+        id: newId(),
+        accountId: input.accountId,
+        amount: input.amount,
+        expiresAt: addSeconds(now, ttl),
+        status: HOLD_STATUS.active,
+        settledAmount: null,
+        createdAt: now,
+        closedAt: null,
+        operation
+      };
       await store.insertHold(hold);
       return { holdId: hold.id, expiresAt: hold.expiresAt, replayed: false };
     },
@@ -281,12 +446,25 @@ function createCredits(deps) {
       await store.lock(found.accountId);
       const hold = await store.holdById(holdId);
       const operation = `settle.${holdId}`;
-      if (hold.status === HOLD_STATUS.settled) return { draws: drawsOf(await store.entriesOf(operation)), replayed: true };
-      if (hold.status === HOLD_STATUS.released) throw new CreditsError(CREDITS_CODE.holdClosed, "This hold was released");
+      if (hold.status === HOLD_STATUS.settled)
+        return { draws: drawsOf(await store.entriesOf(operation)), replayed: true };
+      if (hold.status === HOLD_STATUS.released)
+        throw new CreditsError(CREDITS_CODE.holdClosed, "This hold was released");
       const amount = options.amount ?? hold.amount;
-      if (!Number.isSafeInteger(amount) || amount < 0 || amount > hold.amount) throw new CreditsError(CREDITS_CODE.badAmount, `A hold of ${hold.amount} settles for 0 to ${hold.amount}, got ${amount}`);
+      if (!Number.isSafeInteger(amount) || amount < 0 || amount > hold.amount)
+        throw new CreditsError(
+          CREDITS_CODE.badAmount,
+          `A hold of ${hold.amount} settles for 0 to ${hold.amount}, got ${amount}`
+        );
       const now = deps.clock.now();
-      const draws = amount === 0 ? [] : await spend(tx, store, { accountId: hold.accountId, amount, reason: options.reason ?? `hold:${holdId}`, operation, holdId, exceptHoldId: holdId });
+      const draws = amount === 0 ? [] : await spend(tx, store, {
+        accountId: hold.accountId,
+        amount,
+        reason: options.reason ?? `hold:${holdId}`,
+        operation,
+        holdId,
+        exceptHoldId: holdId
+      });
       await store.closeHold(holdId, amount === 0 ? HOLD_STATUS.released : HOLD_STATUS.settled, amount, now);
       return { draws, replayed: false };
     },
@@ -302,17 +480,36 @@ function createCredits(deps) {
     },
     async refund(tx, input) {
       const original = input.consumed !== void 0 ? `consume.${checkKey(input.consumed)}` : input.settledHold !== void 0 ? `settle.${input.settledHold}` : null;
-      if (!original) throw new CreditsError(CREDITS_CODE.badKey, "Name what to refund: a consumed key or a settled hold");
-      if (!input.reason || input.reason.length > MAX_REASON) throw new CreditsError(CREDITS_CODE.badGrant, `A reason is 1 to ${MAX_REASON} characters`);
+      if (!original)
+        throw new CreditsError(CREDITS_CODE.badKey, "Name what to refund: a consumed key or a settled hold");
+      if (!input.reason || input.reason.length > MAX_REASON)
+        throw new CreditsError(CREDITS_CODE.badGrant, `A reason is 1 to ${MAX_REASON} characters`);
       const store = storeFor(tx);
       await store.lock(input.accountId);
       const operation = `refund.${original}`;
       const done = await replayOf(store, operation, input.accountId);
       if (done.length > 0) return { refunded: sum(done.map((l) => l.amount)), replayed: true };
       const spent = (await replayOf(store, original, input.accountId)).filter((l) => l.type === ENTRY_TYPE.debit);
-      if (spent.length === 0) throw new CreditsError(CREDITS_CODE.nothingToRefund, "Nothing was spent under this key for this account");
+      if (spent.length === 0)
+        throw new CreditsError(CREDITS_CODE.nothingToRefund, "Nothing was spent under this key for this account");
       const now = deps.clock.now();
-      await store.insertEntries(spent.map((l, i) => entry({ accountId: l.accountId, grantId: l.grantId, type: ENTRY_TYPE.refund, amount: -l.amount, reason: input.reason, operation, reverses: original }, i, now)));
+      await store.insertEntries(
+        spent.map(
+          (l, i) => entry(
+            {
+              accountId: l.accountId,
+              grantId: l.grantId,
+              type: ENTRY_TYPE.refund,
+              amount: -l.amount,
+              reason: input.reason,
+              operation,
+              reverses: original
+            },
+            i,
+            now
+          )
+        )
+      );
       return { refunded: sum(spent.map((l) => -l.amount)), replayed: false };
     },
     expire,
@@ -325,8 +522,10 @@ function createCredits(deps) {
     },
     async adjust(tx, input) {
       checkKey(input.idempotencyKey);
-      if (!Number.isSafeInteger(input.amount) || input.amount === 0) throw new CreditsError(CREDITS_CODE.badAmount, "An adjustment is a non-zero integer");
-      if (!input.reason || input.reason.length > MAX_REASON) throw new CreditsError(CREDITS_CODE.badGrant, `A reason is 1 to ${MAX_REASON} characters`);
+      if (!Number.isSafeInteger(input.amount) || input.amount === 0)
+        throw new CreditsError(CREDITS_CODE.badAmount, "An adjustment is a non-zero integer");
+      if (!input.reason || input.reason.length > MAX_REASON)
+        throw new CreditsError(CREDITS_CODE.badGrant, `A reason is 1 to ${MAX_REASON} characters`);
       const store = storeFor(tx);
       await store.lock(input.accountId);
       const operation = `adjust.${input.idempotencyKey}`;
@@ -335,15 +534,31 @@ function createCredits(deps) {
       const now = deps.clock.now();
       const state = (await statesOf(store, input.accountId, now, timeZone)).find((s) => s.grant.id === input.grantId);
       if (!state) throw new CreditsError(CREDITS_CODE.unknownGrant, `No grant ${input.grantId} for this account`);
-      if (state.remaining + input.amount < 0) throw new CreditsError(CREDITS_CODE.badAmount, "An adjustment never takes a pot below zero");
-      await store.insertEntries([entry({ accountId: input.accountId, grantId: input.grantId, type: ENTRY_TYPE.adjustment, amount: input.amount, reason: input.reason, operation }, 0, now)]);
+      if (state.remaining + input.amount < 0)
+        throw new CreditsError(CREDITS_CODE.badAmount, "An adjustment never takes a pot below zero");
+      await store.insertEntries([
+        entry(
+          {
+            accountId: input.accountId,
+            grantId: input.grantId,
+            type: ENTRY_TYPE.adjustment,
+            amount: input.amount,
+            reason: input.reason,
+            operation
+          },
+          0,
+          now
+        )
+      ]);
       return { replayed: false };
     },
     async balance(query, accountId) {
       const store = storeFor(query);
       const { timeZone } = await settings();
       const now = deps.clock.now();
-      const live = (await statesOf(store, accountId, now, timeZone)).filter((s) => !s.closed && (s.grant.expiresAt === null || s.grant.expiresAt > now) && s.remaining > 0);
+      const live = (await statesOf(store, accountId, now, timeZone)).filter(
+        (s) => !s.closed && (s.grant.expiresAt === null || s.grant.expiresAt > now) && s.remaining > 0
+      );
       const of = (bucket) => sum(live.filter((s) => s.grant.bucket === bucket).map((s) => s.remaining));
       const total = of(BUCKET.granted) + of(BUCKET.purchased);
       const held = await store.heldAmount(accountId, now);
@@ -353,10 +568,22 @@ function createCredits(deps) {
         purchased: of(BUCKET.purchased),
         held,
         available: Math.max(0, total - held),
-        grants: live.map((s) => ({ id: s.grant.id, bucket: s.grant.bucket, remaining: s.remaining, expiresAt: s.grant.expiresAt, source: s.grant.source, capPerDay: s.grant.capPerDay, capPerMonth: s.grant.capPerMonth, onExhausted: s.grant.onExhausted }))
+        grants: live.map((s) => ({
+          id: s.grant.id,
+          bucket: s.grant.bucket,
+          remaining: s.remaining,
+          expiresAt: s.grant.expiresAt,
+          source: s.grant.source,
+          capPerDay: s.grant.capPerDay,
+          capPerMonth: s.grant.capPerMonth,
+          onExhausted: s.grant.onExhausted
+        }))
       };
     },
-    history: (query, accountId, options = {}) => storeFor(query).history(accountId, { limit: Math.min(options.limit ?? DEFAULT_HISTORY, MAX_HISTORY), ...options.before ? { before: options.before } : {} })
+    history: (query, accountId, options = {}) => storeFor(query).history(accountId, {
+      limit: Math.min(options.limit ?? DEFAULT_HISTORY, MAX_HISTORY),
+      ...options.before ? { before: options.before } : {}
+    })
   };
 }
 var REFUSAL_TEXT = {
@@ -399,7 +626,8 @@ function memoryCreditStore() {
     },
     async insertEntries(batch) {
       for (const e of batch) {
-        if (entries.some((x) => x.idempotencyKey === e.idempotencyKey)) throw new Error(`duplicate idempotency key ${e.idempotencyKey}`);
+        if (entries.some((x) => x.idempotencyKey === e.idempotencyKey))
+          throw new Error(`duplicate idempotency key ${e.idempotencyKey}`);
       }
       entries.push(...batch.map((e) => ({ ...e })));
     },
@@ -421,7 +649,9 @@ function memoryCreditStore() {
       return h ? { ...h } : null;
     },
     async heldAmount(accountId, now, exceptHoldId) {
-      return [...holds.values()].filter((h) => h.accountId === accountId && h.status === HOLD_STATUS.active && isAfter(h.expiresAt, now) && h.id !== exceptHoldId).reduce((a, h) => a + h.amount, 0);
+      return [...holds.values()].filter(
+        (h) => h.accountId === accountId && h.status === HOLD_STATUS.active && isAfter(h.expiresAt, now) && h.id !== exceptHoldId
+      ).reduce((a, h) => a + h.amount, 0);
     },
     async closeHold(id, status, settledAmount, at) {
       const h = holds.get(id);