@volter/twin-upstash 0.1.0

package/src/upstash-budget.ts

@@ -0,0 +1,486 @@
+// UPSTASH REDIS'S CLIENT-SIDE RATE BUDGET — the pack's DECLARATION (the numbers) plus
+// `guardUpstashRedisClient`, the choke point every live Upstash Redis call goes through. The
+// MECHANISM — the durable token-keyed ledger, the rolling window, reserve-under-lock, the
+// `Retry-After`/429 cooldown, fail-CLOSED on a corrupt ledger — lives ONCE in the vendor-agnostic
+// kernel (`@volter/world-core` → `rateBudget.ts`). Read that module's header for the full rationale AND
+// for the honest list of what the guard does NOT guarantee (an injected clock or ledger path still
+// defeats it — it guards carelessness, not malice). This module is modeled on notion-budget.ts, the
+// reference injected-client decorator.
+//
+// ── WHY UPSTASH REDIS NEEDS ONE, AND WHY THE OBVIOUS NUMBER IS THE WRONG ONE ───────────────────
+// Upstash publishes a real scalar, and it is enormous. Its billing page's "All plans and limits"
+// table (upstash.com/docs/redis/overall/billing) gives **10,000 commands/sec** on Free, Pay-As-You-Go
+// and every Fixed plan up to 50 GB (16,000 on the two largest). Taken at face value that would
+// license 600,000 calls a minute, which is not a guard — it is the absence of one.
+//
+// The number that actually binds a connector loop is the QUOTA, not the rate:
+//   • Free tier: **500,000 commands per month** (same table). That is ~11.6 commands/minute
+//     sustained. At the vendor's own 10,000/sec ceiling a runaway loop exhausts a month of free
+//     quota in FIFTY SECONDS.
+//   • Pay-As-You-Go bills **per command**, and the docs are explicit that "one command is one
+//     billable request" and that "each command inside a pipeline or transaction is still billed
+//     individually" — so a 500-key pull is 500 billable commands, not one.
+// So the risk this budget exists to bound is SPEND and QUOTA EXHAUSTION, not throttling. Upstash
+// does document throttle errors (`ERR max daily request limit exceeded`, `ERR max requests limit
+// exceeded`) but publishes NO figure for either, and the grounding pass could not trigger them, so
+// their HTTP status is UNVERIFIED and nothing here claims otherwise.
+//
+// ── HOW THE CEILING WAS CHOSEN ────────────────────────────────────────────────────────────────
+// 600 weighted units / 60s at the default weight of 2 = **300 commands per minute**. That is:
+//   • 2,000x TIGHTER than the documented 10,000/sec rate limit — so it can never be the thing that
+//     trips the vendor's own limiter, and it is not "more permissive than a documented limit";
+//   • loose enough that a legitimate pull of a few hundred named keys completes in one window
+//     instead of degenerating into a cascade of refusals;
+//   • tight enough that exhausting the free tier's whole monthly quota would take ~28 hours of
+//     continuous looping rather than under a minute.
+// It IS more permissive than the kernel's austere `DEFAULT_RATE_BUDGET` (60 units/60s), and the
+// justification is the published table above — a documented limit three orders of magnitude higher,
+// against a per-command API where a single logical "pull one hash" is several commands. Without
+// that headroom the fallback would refuse an ordinary twenty-key pull.
+//
+// ── WHAT THIS DOES NOT DO: PACE ───────────────────────────────────────────────────────────────
+// It bounds the 60s AVERAGE; it does NOT bound the instantaneous rate. The window has no spacing,
+// so a tight `await` loop can legitimately fire the whole allowance in a fraction of a second. In
+// that shape a vendor 429 can arrive BEFORE this ceiling does, and the backstop is then the
+// COOLDOWN: the guard reads the back-off off the thrown error (or the response's exhaustion
+// headers) and refuses every later call without touching the vendor. So the honest claim is
+// "bounds the 60s average, and converts the vendor's first 429 into a hard stop" — never "refuses
+// before the vendor ever 429s". Pacing is the CALLER's job; this module REFUSES, it never sleeps
+// (see the kernel header: it is deliberately not a scheduler).
+//
+// ── HOW THE WEIGHTS WERE CHOSEN (and what is a judgement call) ────────────────────────────────
+// `scan` costs 8, four times everything else. Documented half: `SCAN` is the one call here whose
+// cost is unbounded in the SIZE OF THE CUSTOMER'S KEYSPACE rather than in what the caller asked
+// for — Upstash's own docs warn against enumerating a production database — and each page is a
+// separate billable command. Judgement half: `pullUpstashRedisScan` is the only entrypoint that
+// loops without the caller naming what it wants, so it is the one most likely to be pointed at a
+// real database by accident. Quadrupling its price is what makes the ceiling bite on a keyspace
+// walk long before it bites on a named-key pull.
+import {
+  declareRateBudget,
+  rateBudgetPath,
+  rateBudgetWeight,
+  RateBudget,
+  RateBudgetError,
+  type RateBudgetDeclaration,
+  type RateBudgetOptions,
+  type RateBudgetReservation,
+  type RateBudgetSnapshot,
+} from '@volter/world-core';
+import type { UpstashRedisLikeClient } from './upstash-connector.ts';
+
+const VENDOR = 'upstash';
+
+/** Rolling window, in ms. Spend older than this is pruned. */
+export const UPSTASH_BUDGET_WINDOW_MS = 60_000;
+
+/** Weighted units allowed inside one window. See the header for where this number comes from. */
+export const UPSTASH_BUDGET_CEILING = 600;
+
+/** Seconds. A `Retry-After` above this means the credential is throttled hard — fail loudly. */
+export const UPSTASH_BUDGET_MAX_RETRY_AFTER_S = 300;
+
+/** Per-call cost, keyed by the client method the guard is about to invoke. See the header. */
+export const UPSTASH_CALL_WEIGHTS = {
+  /** `scan` — a keyspace WALK, whose cost scales with the customer's database, not the request. */
+  scan: 8,
+  /** Every other modeled call (get/type/ttl/hgetall/smembers/lrange/zrange, and anything unclassified). */
+  other: 2,
+} as const;
+
+/**
+ * The client methods this pack PRICES BY NAME, as dotted paths into the injected client.
+ *
+ * Two kinds of entry: (a) every method this connector actually calls, and (b) an endpoint the
+ * VENDOR documents in a distinct tier which a consumer can reach through the guarded client even
+ * though this connector never calls it (see the weights section of the header). Used to build the
+ * guarded surface — and, in the pack's own suite, the counting fake.
+ *
+ * NOT a closed list, and not a claim about the injected client's shape. A path the real client does
+ * not have is SKIPPED (this connector's members are optional; inventing one would turn "observe
+ * nothing" into "call something that isn't there"), and a method absent from this list is still
+ * PRICED at `defaultWeight` when a caller reaches for it — an unmodeled endpoint must never be
+ * free, and dropping one would be worse than free because it would be invisible.
+ */
+export const UPSTASH_BUDGETED_METHODS = [
+  "get",
+  "type",
+  "ttl",
+  "hgetall",
+  "smembers",
+  "lrange",
+  "zrange",
+  "scan",
+] as const;
+
+/** THE PACK'S DECLARATION — pure data, the only Upstash-specific thing in the whole budget. */
+export const UPSTASH_RATE_BUDGET: RateBudgetDeclaration = {
+  windowMs: UPSTASH_BUDGET_WINDOW_MS,
+  ceiling: UPSTASH_BUDGET_CEILING,
+  defaultWeight: UPSTASH_CALL_WEIGHTS.other,
+  maxRetryAfterSeconds: UPSTASH_BUDGET_MAX_RETRY_AFTER_S,
+  // Ordered: the kernel prices FIRST-MATCH-WINS, so the most expensive tier is listed first.
+  rules: [
+    { match: "(^|\\.)scan$", weight: UPSTASH_CALL_WEIGHTS.scan },
+  ],
+  reason:
+    "Upstash PUBLISHES a scalar and it is enormous: the \"All plans and limits\" table at " +
+    "upstash.com/docs/redis/overall/billing gives 10,000 commands/sec on Free, Pay-As-You-Go and every Fixed " +
+    "plan up to 50 GB (16,000 on the two largest). Taking that at face value would license 600,000 calls a " +
+    "minute, which is not a guard. The limit that actually binds a connector loop is the QUOTA: the free tier " +
+    "allows 500,000 commands per MONTH (~11.6/min sustained) and Pay-As-You-Go bills per command, with the docs " +
+    "explicit that \"one command is one billable request\" and that each command inside a pipeline or " +
+    "transaction is billed individually. So this ceiling (600 units / 60s at weight 2 = 300 commands/min) is " +
+    "chosen against SPEND, not throttling: 2,000x tighter than the documented 10,000/sec so it can never be " +
+    "what trips the vendor's own limiter, loose enough for a few-hundred-key pull to finish in one window, and " +
+    "tight enough that burning the whole free monthly quota would take ~28 hours of looping instead of 50 " +
+    "seconds. It is more permissive than the kernel fallback (60 units/60s) and the published table three " +
+    "orders of magnitude higher is the justification. scan costs 8 because its cost scales with the CUSTOMER'S " +
+    "keyspace rather than the request, and it is the one entrypoint that loops without the caller naming what " +
+    "it wants. Upstash also documents throttle errors (ERR max daily request limit exceeded, ERR max requests " +
+    "limit exceeded) but publishes NO figure for either and the grounding pass could not trigger them, so their " +
+    "status and thresholds are UNVERIFIED and nothing here claims a number for them.",
+};
+
+// Declared at module load, so merely importing this module (which `upstash-connector.ts` does) is
+// enough to arm the real ceiling. A budget constructed BEFORE this runs falls back to the kernel's
+// DEFAULT_RATE_BUDGET — which is tighter in call COUNT but prices every call at 2, so for a vendor
+// with an expensive endpoint the fallback is CHEAPER there, not safer. `RateBudget` reads its policy
+// LIVE precisely so this declaration takes effect the moment it lands, and constructing through the
+// subclass below (whose module IS this one) makes the ordering a non-issue in practice.
+declareRateBudget(VENDOR, UPSTASH_RATE_BUDGET);
+
+/** Price one Upstash Redis call by its client method name (e.g. `get`, `scan`). */
+export function upstashCallWeight(method: string): number {
+  return rateBudgetWeight(VENDOR, method);
+}
+
+/** Where UpstashRedis's ledger lives. Token-keyed and cwd-independent by default (the vendor limits per
+ *  credential, so a cwd-scoped ledger would hand the same credential a fresh allowance in every
+ *  checkout, worktree and CI matrix leg); pass `root` to opt into world-scoped accounting. */
+export function upstashBudgetPath(opts: { root?: string; token?: string } | string = {}): string {
+  const o = typeof opts === 'string' ? { root: opts } : opts;
+  // VENDOR spread LAST: a loosely-typed `{ vendor: 'other', … }` slipping through (TypeScript's
+  // excess-property check only catches object literals) must not redirect this pack's ledger to
+  // another vendor's file.
+  return rateBudgetPath({ ...o, vendor: VENDOR });
+}
+
+/** Construction options for UpstashRedis's budget. The vendor is fixed; everything else may only TIGHTEN. */
+export type UpstashRedisBudgetOptions = Omit<RateBudgetOptions, 'vendor'>;
+
+/**
+ * UpstashRedis's budget — the shared kernel guard bound to this vendor's declaration. A real subclass,
+ * not an alias, so `budget instanceof UpstashRedisBudget` means "a budget that accounts against this
+ * vendor's ledger under this vendor's ceiling": another vendor's `RateBudget` (with its own,
+ * possibly larger, ceiling) is NOT assignable where one of these is required.
+ */
+export class UpstashRedisBudget extends RateBudget {
+  constructor(opts: UpstashRedisBudgetOptions = {}) {
+    super({ ...opts, vendor: VENDOR });
+  }
+}
+
+export type { RateBudgetErrorKind as UpstashRedisBudgetErrorKind } from '@volter/world-core';
+export { RateBudgetError as UpstashRedisBudgetError } from '@volter/world-core';
+export type UpstashRedisBudgetReservation = RateBudgetReservation;
+export type UpstashRedisBudgetSnapshot = RateBudgetSnapshot;
+
+/** What every budgeted connector entrypoint accepts. There is deliberately no option that turns the
+ *  guard OFF — only ones that say WHICH ledger and clock to account against. */
+export type UpstashRedisBudgetedOptions = {
+  /** An existing budget to share across calls. Omit and one is constructed. Cannot be null. */
+  budget?: UpstashRedisBudget;
+  /** Construction options for the default budget (ledger path, clock). Cannot loosen it. */
+  budgetOptions?: UpstashRedisBudgetOptions;
+};
+
+/** Pull the budget wiring out of a caller's opts bag, so an entrypoint can forward it verbatim. */
+export function upstashBudgetOf(opts: UpstashRedisBudgetedOptions): UpstashRedisBudgetedOptions {
+  return {
+    ...(opts.budget !== undefined ? { budget: opts.budget } : {}),
+    ...(opts.budgetOptions !== undefined ? { budgetOptions: opts.budgetOptions } : {}),
+  };
+}
+
+// ── the choke point ─────────────────────────────────────────────────────────────────────────
+
+/**
+ * Marks a client this module has already wrapped, so guarding twice cannot charge twice.
+ *
+ * A MODULE-PRIVATE `Symbol()`, deliberately not `Symbol.for()`: a global-registry symbol is
+ * reachable BY NAME, so any caller could stamp `client[Symbol.for(…)] = anything` on a RAW client and
+ * the guard would hand it straight back UNGUARDED — a one-line bypass of the whole budget. With a
+ * private symbol the only way to be branded is to have been wrapped by this function. The cost is
+ * that two copies of this module in one dependency tree would each wrap (double-charging a call);
+ * that is the SAFE direction, and over-charging is the tradeoff this module takes everywhere else.
+ */
+const GUARDED: unique symbol = Symbol('@volter/twin-upstash.budget.guarded');
+
+type Guarded = { [GUARDED]?: unknown };
+
+/** Is this client already behind a budget? Returns the budget it is behind, if so. */
+export function upstashClientBudget(client: unknown): RateBudget | undefined {
+  const mark = (client as Guarded | null)?.[GUARDED];
+  // Belt and braces: only a REAL budget counts as "already guarded". A non-RateBudget value here
+  // could only come from a forged brand, and the answer to a forgery is to wrap anyway.
+  return mark instanceof RateBudget ? mark : undefined;
+}
+
+/** Charge a call keyed by `method`, invoke it, settle. Returns whatever the call returned. */
+type Charge = (method: string, invoke: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown;
+
+/**
+ * Wrap an INJECTED UpstashRedis client so EVERY call it makes is charged against the shared budget
+ * BEFORE the request goes out. This pack's connector never constructs the transport itself (the
+ * consumer injects a client that satisfies `UpstashRedisLikeClient` structurally), so the guard is a
+ * DECORATOR rather than a factory — which is exactly why every connector entrypoint applies it
+ * UNCONDITIONALLY instead of trusting the caller to have done it.
+ *
+ * IDEMPOTENT: wrapping an already-guarded client returns it unchanged, so a caller who forgot is
+ * protected and a caller who wrapped deliberately is not double-charged.
+ *
+ * A method that THROWS is still inspected: an SDK typically RAISES on a 429 rather than returning
+ * it, and that error's back-off is exactly the signal that must become a persisted cooldown. Losing
+ * it would leave the ledger cheerfully spending into a throttled credential. The original error is
+ * always re-raised afterwards — the budget never swallows a vendor failure — EXCEPT when the
+ * back-off is beyond the cap, where the budget's own louder "stop calling" error takes precedence.
+ */
+export function guardUpstashRedisClient(client: UpstashRedisLikeClient, opts: UpstashRedisBudgetedOptions = {}): UpstashRedisLikeClient {
+  // There is no value a caller can pass to end up with an UNGUARDED client. `null`/`undefined` (or
+  // omitting it) build the default budget; anything that is not a REAL `UpstashRedisBudget` is refused
+  // loudly rather than trusted — a duck-typed stand-in with a no-op `checkBudget` would otherwise be
+  // the one clean way around the guard. Validated BEFORE the already-guarded early return, so
+  // `guardUpstashRedisClient(alreadyGuarded, { budget: impostor })` is refused too rather than silently
+  // ignoring the impostor.
+  if (opts.budget !== undefined && opts.budget !== null && !(opts.budget instanceof UpstashRedisBudget)) {
+    throw new Error('guardUpstashRedisClient: `budget` must be a UpstashRedisBudget — refusing to guard a UpstashRedis client with an unverified rate guard');
+  }
+  if (upstashClientBudget(client)) return client;
+  const budget = opts.budget instanceof UpstashRedisBudget
+    ? opts.budget
+    : new UpstashRedisBudget({
+      // The default ledger is keyed by a hash of the credential — the vendor limits per credential,
+      // so a cwd-scoped ledger would hand it a fresh allowance per worktree/CI leg.
+      //
+      // HONESTLY: this pack does NOT hold the credential — the consumer's injected client does — so
+      // `UPSTASH_REDIS_REST_TOKEN` is a BEST-EFFORT stand-in for it, not the real thing. If that env var names a
+      // different account than the injected client, spend is booked against the wrong ledger; if it
+      // is unset, every unattributed UpstashRedis credential on the machine shares one (over-tight,
+      // which is the safe direction). A caller who knows the credential should say so:
+      // `budgetOptions: { token }` overrides this, and does so deliberately last in the spread.
+      ...(process.env.UPSTASH_REDIS_REST_TOKEN !== undefined ? { token: process.env.UPSTASH_REDIS_REST_TOKEN } : {}),
+      ...(opts.budgetOptions ?? {}),
+    });
+
+  /** Settle a reservation from whatever the call produced. May THROW (a back-off past the cap). */
+  const settle = (weight: number, reservation: RateBudgetReservation, v: unknown): void => {
+    const status = responseStatus(v);
+    const headers = responseHeaders(v);
+    if (status !== undefined || headers !== undefined) budget.recordCall(weight, headers, { status, reservation });
+    else budget.recordCall(weight, undefined, { reservation });
+  };
+
+  /**
+   * Settle once the call RESOLVED: the vendor has answered. recordCall arms any cooldown before
+   * it throws (a back-off beyond the cap), so that refusal is swallowed and the answer kept — a
+   * write the vendor accepted is never reported failed and performed again on retry. A resolved
+   * answer that carries a non-2xx status still lets the louder refusal win.
+   */
+  const settleAnswered = (weight: number, reservation: RateBudgetReservation, v: unknown): void => {
+    try {
+      settle(weight, reservation, v);
+    } catch (e) {
+      const status = responseStatus(v);
+      if (!(e instanceof RateBudgetError) || (status !== undefined && (status < 200 || status >= 300))) throw e;
+    }
+  };
+
+  /**
+   * Charge, call, settle — for a MODELED method, whose interface declares it `async`. Refusing
+   * REJECTS rather than throwing synchronously, so `client.x().catch(…)` behaves exactly as it does
+   * on an unguarded client. `checkBudget` RESERVES under lock, so nothing after its line runs when
+   * the budget refuses: the request is never made.
+   */
+  const chargeAsync = (method: string, invoke: (...args: unknown[]) => unknown) =>
+    async (...args: unknown[]): Promise<unknown> => {
+      const weight = budget.weightFor(method);
+      const reservation = budget.checkBudget(weight);
+      try {
+        const res = await invoke(...args);
+        settleAnswered(weight, reservation, res);
+        return res;
+      } catch (e) {
+        settle(weight, reservation, e); // may throw its own louder refusal, which wins
+        throw e;
+      }
+    };
+
+  /**
+   * Charge, call, settle — for an UNMODELED member reached through the passthrough Proxy, where the
+   * shape is unknown.
+   *
+   * Deliberately NOT `async`. Some vendor SDKs (twilio-shaped ones) build requests through
+   * SYNCHRONOUS chained accessors — `client.a.b('sid').c.create()` — where the intermediate calls
+   * return a resource context, not a promise. An `async` wrapper would turn every one of those into
+   * a `Promise` and `.c` would come back `undefined`: the guard would BREAK the client instead of
+   * guarding it. So a non-thenable return is treated as an accessor — still charged (we cannot know
+   * before calling, and over-charging is the safe direction) and wrapped, so the eventual async leaf
+   * is charged too rather than escaping the budget. The cost of the sync shape is that a REFUSAL on
+   * this path throws synchronously instead of rejecting; that is the honest signal for an accessor,
+   * and the modeled surface above (every method this connector actually calls) does not have it.
+   */
+  const charge: Charge = (method, invoke) => (...args) => {
+    const weight = budget.weightFor(method);
+    const reservation = budget.checkBudget(weight);
+    let out: unknown;
+    try {
+      out = invoke(...args);
+    } catch (e) {
+      settle(weight, reservation, e); // may throw its own louder refusal, which wins
+      throw e;
+    }
+    if (!isThenable(out)) {
+      settle(weight, reservation, undefined);
+      return out !== null && (typeof out === 'object' || typeof out === 'function')
+        ? proxyThrough({}, out as object, method, charge)
+        : out;
+    }
+    return out.then(
+      (res) => { settleAnswered(weight, reservation, res); return res; },
+      (e: unknown) => { settle(weight, reservation, e); throw e; },
+    );
+  };
+
+  // Build the charged surface from UPSTASH_BUDGETED_METHODS (see its docstring for why an absent path is
+  // SKIPPED rather than stubbed).
+  const guarded: Record<string, unknown> & Guarded = {};
+  for (const path of UPSTASH_BUDGETED_METHODS) {
+    const segs = path.split('.');
+    const leaf = segs[segs.length - 1]!;
+    let owner: Record<string, unknown> | undefined = client as unknown as Record<string, unknown>;
+    for (const seg of segs.slice(0, -1)) owner = owner?.[seg] as Record<string, unknown> | undefined;
+    if (typeof owner?.[leaf] !== 'function') continue;
+    const realOwner = owner;
+    let node: Record<string, unknown> = guarded;
+    for (const seg of segs.slice(0, -1)) node = (node[seg] ??= {}) as Record<string, unknown>;
+    // The method is resolved at CALL time, not here, so a client whose method is swapped later is
+    // still charged for whatever it actually runs.
+    node[leaf] = chargeAsync(path, (...args) => (realOwner[leaf] as (...a: unknown[]) => unknown).apply(realOwner, args));
+  }
+  Object.defineProperty(guarded, GUARDED, { value: budget, enumerable: false });
+
+  // The surface above is what this connector calls. A real client has MORE — and a consumer who
+  // needs any of it must not be forced to keep the RAW client alongside, because every call through
+  // that would be unbudgeted. So the guarded object is a Proxy: known members come from the map
+  // above, anything else is taken from the real client and PRICED at `defaultWeight`.
+  return proxyThrough(guarded, client as object, '', charge) as UpstashRedisLikeClient;
+}
+
+/**
+ * Members JavaScript itself asks for. Wrapping any of these turns the object into something that
+ * looks thenable / mis-reports its own identity, which breaks `await`, `instanceof` and logging —
+ * so they always come from the target untouched, never priced.
+ */
+const NEVER_WRAP = new Set(['then', 'catch', 'finally', 'constructor', 'prototype', 'toJSON', 'toString', 'valueOf', 'inspect']);
+
+/** Does this look like a promise? (Only a thenable gets the settle-on-resolution treatment.) */
+function isThenable(v: unknown): v is Promise<unknown> {
+  return v !== null && (typeof v === 'object' || typeof v === 'function') && typeof (v as { then?: unknown }).then === 'function';
+}
+
+/**
+ * Symbols that name an ITERATION PROTOCOL. Reaching for one of these on a vendor object is how a
+ * paginator is driven (`for await (const page of client.things.list())`), i.e. it is the doorway to
+ * an unbounded sequence of REQUESTS — exactly what this budget exists to bound — so they are charged
+ * and their result is kept behind the proxy. Every other symbol (`Symbol.toStringTag`,
+ * `nodejs.util.inspect.custom`, …) is metadata rather than a request and passes through untouched.
+ */
+const ITERATOR_SYMBOLS = new Set<symbol>([Symbol.asyncIterator, Symbol.iterator]);
+
+/**
+ * Serve `known` where it has the member; otherwise price a passthrough to `real`. Applied
+ * recursively, so a namespace member this pack never modeled is charged at `defaultWeight` rather
+ * than coming back `undefined`.
+ *
+ * CALLABLE NAMESPACES (§9 finding): a member can be BOTH a function and a namespace — twilio's
+ * `client.messages` is called as `client.messages(sid)` to get one message's context AND read as
+ * `client.messages.list()`. An earlier version returned the modeled node as a plain object whenever
+ * this pack modeled any child of it, which silently DROPPED the call signature and every unmodeled
+ * sibling — the module's own docstring calls a dropped member "worse than free, because it is
+ * invisible", and that is what it was doing. So when `real` is callable the proxy target is a
+ * function and an `apply` trap charges the call, while `known` stays the source of modeled members.
+ */
+function proxyThrough(known: object, real: object, prefix: string, charge: Charge, owner?: object): object {
+  const callable = typeof real === 'function';
+  // The target must itself be callable for the `apply` trap to exist at all. `known` stays the
+  // source of modeled members, read explicitly below rather than through the target.
+  const target: object = callable ? function proxied() { /* every call goes through the trap */ } : known;
+  return new Proxy(target, {
+    apply(_t, _thisArg, args: unknown[]) {
+      // Calling the namespace is itself a request-builder hop: charge it, and keep the result
+      // behind the proxy (charge() re-proxies a non-thenable) so the eventual leaf is charged too.
+      // `owner` is the object the function was read from — dropping it would silently break every
+      // method that relies on `this`.
+      return charge(prefix || 'call', (...a) => (real as (...x: unknown[]) => unknown).apply(owner, a))(...args);
+    },
+    get(_t, prop, receiver) {
+      if (typeof prop === 'symbol') {
+        const ownSym = Reflect.get(known, prop, receiver);
+        if (ownSym !== undefined) return ownSym; // the GUARDED brand, and anything we model
+        const fromSym = (real as Record<symbol, unknown> | null)?.[prop];
+        if (ITERATOR_SYMBOLS.has(prop) && typeof fromSym === 'function') {
+          return charge(`${prefix}[${prop.description ?? 'iterator'}]`, (...args) => (fromSym as (...a: unknown[]) => unknown).apply(real, args));
+        }
+        return fromSym;
+      }
+      const name = String(prop);
+      if (NEVER_WRAP.has(name)) return Reflect.get(known, prop, receiver);
+      const key = prefix ? `${prefix}.${name}` : name;
+      const own = Reflect.get(known, prop, receiver);
+      const from = (real as Record<string, unknown> | null)?.[name];
+      // A member we model: the charged wrapper (a function) or a namespace we must keep descending
+      // into, so an unmodeled sibling is still priced rather than dropped.
+      if (typeof own === 'function') return own;
+      if (own && typeof own === 'object') {
+        // `from` may be an object OR a CALLABLE namespace — both keep descending, which is what
+        // preserves `client.messages(sid)` alongside the modeled `client.messages.list()`.
+        return from && (typeof from === 'object' || typeof from === 'function')
+          ? proxyThrough(own, from, key, charge, real)
+          : own;
+      }
+      if (own !== undefined) return own;
+      // A member only the real client has. Functions go through proxyThrough too, so one that also
+      // carries members (a callable namespace) keeps both its call signature and its siblings.
+      if (typeof from === 'function') return proxyThrough({}, from, key, charge, real);
+      if (from && typeof from === 'object') return proxyThrough({}, from, key, charge, real);
+      return from;
+    },
+    has(_t, prop) {
+      return Reflect.has(known, prop) || (real !== null && Reflect.has(real, prop));
+    },
+  });
+}
+
+/** The HTTP status a value carries, if it looks like one (an SDK error, or a raw response). */
+function responseStatus(v: unknown): number | undefined {
+  const s = (v as { status?: unknown } | null)?.status;
+  return typeof s === 'number' && Number.isFinite(s) ? s : undefined;
+}
+
+/**
+ * Response/error headers as a plain lower-cased record, or `undefined` when there are none. Accepts
+ * a `Headers` instance, a `Map`, or a plain object — an SDK's error type changes shape across
+ * versions and none of the three is worth depending on.
+ */
+function responseHeaders(v: unknown): Record<string, string> | undefined {
+  const h = (v as { headers?: unknown } | null)?.headers;
+  if (!h || typeof h !== 'object') return undefined;
+  const out: Record<string, string> = {};
+  if (typeof (h as Headers).forEach === 'function') {
+    (h as Headers).forEach((value: string, key: string) => { out[String(key).toLowerCase()] = String(value); });
+  } else {
+    for (const [k, value] of Object.entries(h as Record<string, unknown>)) out[k.toLowerCase()] = String(value);
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}