@volter/twin-upstashvector 0.1.0

package/src/upstashvector-budget.ts

@@ -0,0 +1,489 @@
+// UPSTASH VECTOR'S CLIENT-SIDE RATE BUDGET — the pack's DECLARATION (the numbers) plus
+// `guardUpstashVectorClient`, the choke point every live Upstash Vector 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.
+//
+// ── UPSTASH VECTOR PUBLISHES NO PER-SECOND LIMIT, AND THIS DECLARATION SAYS SO ─────────────────
+// This is the OPPOSITE situation to this pack's sibling `upstash`, and the difference decides
+// the number. Upstash Redis publishes a scalar rate (10,000 commands/sec on its billing page), which
+// is what licenses that pack to sit ABOVE the kernel's austere fallback. Upstash **Vector** publishes
+// no requests-per-second figure anywhere — the pricing/limits tables give per-DAY caps and per-request
+// billing, not a rate:
+//   • Pay-As-You-Go bills **per request** ($0.4 per 100K requests, upstash.com/pricing/vector);
+//   • the Free tier caps **queries per DAY** (10,000/day — ~6.9/minute sustained), not per second;
+//   • the published per-plan limits are about SHAPE, not rate: max dimension 1,536 (Free) to 5,000
+//     (Pro), max topK 1,000, metadata 48 KB/vector, data 1 MB/vector, storage 1 GB (Free) to 1 TB.
+// docs/contributing/architecture.md D8 and docs/contributing/adding-a-twin.md are explicit about what to do here: when the vendor
+// publishes no scalar limit, SAY SO in `reason` and stay AT OR UNDER the fallback — never dress a
+// guess up as a vendor fact. So this pack declares exactly the kernel's own austere allowance
+// (60 units / 60s at the default weight of 2 = **30 requests per minute**) and does not claim a
+// vendor number it could not read.
+//
+// ── WHAT THIS CEILING DOES *NOT* PROTECT (§9 round 1 corrected an inversion here) ──────────────
+// An earlier draft of this header and of `reason` claimed the ceiling was "~4x TIGHTER than the
+// free tier's own daily query budget spread evenly, so it cannot be the thing that trips a real
+// account". That was BACKWARDS, and this module's own test encodes the correct direction. The
+// arithmetic: the Free tier allows 10,000 queries per DAY = ~6.94/minute sustained; this ceiling
+// allows 30/minute = 43,200/day. So the budget is ~4.3x LOOSER than the free daily allowance, and
+// sustained pulling AT the ceiling would exhaust a Free index's whole daily quota in about 5.5
+// hours.
+//
+// The honest claim is therefore narrower: this ceiling bounds a BURST (it is a 60-second rolling
+// window, and it refuses fail-closed), and it is the tightest burst that D8 permits without a
+// published vendor rate to cite. It does NOT bound daily spend, because a rolling-minute window
+// structurally cannot — bounding a daily quota would need a day-length window, which the kernel's
+// RateBudget does not model. A caller running a long or repeated sync against a Free index must
+// still watch that quota themselves.
+//
+// ── HOW THE WEIGHTS WERE CHOSEN ───────────────────────────────────────────────────────────────
+// `range` costs 6, three times everything else — the ONE call here whose cost is unbounded in the
+// SIZE OF THE CUSTOMER'S INDEX rather than in what the caller asked for. A vector index is
+// routinely millions of rows and `pullUpstashVectorRange` is the only entrypoint that LOOPS, so it
+// is the one most likely to be pointed at a real index by accident. Tripling its price is what
+// makes the ceiling bite on an index walk (10 pages/minute) long before it bites on the handful of
+// `info`/`listNamespaces` calls a legitimate inspection makes. A heavier weight can only TIGHTEN
+// the allowance, which is the direction that needs no vendor citation.
+//
+// ── 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).
+import {
+  declareRateBudget,
+  rateBudgetPath,
+  rateBudgetWeight,
+  RateBudget,
+  RateBudgetError,
+  type RateBudgetDeclaration,
+  type RateBudgetOptions,
+  type RateBudgetReservation,
+  type RateBudgetSnapshot,
+} from '@volter/world-core';
+import type { UpstashVectorLikeClient } from './upstashvector-connector.ts';
+
+const VENDOR = 'upstashvector';
+
+/** Rolling window, in ms. Spend older than this is pruned. */
+export const UPSTASHVECTOR_BUDGET_WINDOW_MS = 60_000;
+
+/**
+ * Weighted units allowed inside one window — deliberately EQUAL to the kernel's
+ * `DEFAULT_RATE_BUDGET.ceiling`, because Upstash publishes no Vector rate limit to justify more.
+ * See the header.
+ */
+export const UPSTASHVECTOR_BUDGET_CEILING = 60;
+
+/** Seconds. A `Retry-After` above this means the credential is throttled hard — fail loudly. */
+export const UPSTASHVECTOR_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 UPSTASHVECTOR_CALL_WEIGHTS = {
+  /** `range` — an index WALK, whose cost scales with the customer's index, not the request. */
+  range: 6,
+  /** Every other modeled call (info/listNamespaces, and anything unclassified). */
+  other: 2,
+} as const;
+
+/**
+ * The client methods this pack PRICES BY NAME, as dotted paths into the injected client.
+ *
+ * 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 UPSTASHVECTOR_BUDGETED_METHODS = [
+  "info",
+  "listNamespaces",
+  "range",
+  "fetch",
+  "query",
+] as const;
+
+/** THE PACK'S DECLARATION — pure data, the only Upstash-Vector-specific thing in the whole budget. */
+export const UPSTASHVECTOR_RATE_BUDGET: RateBudgetDeclaration = {
+  windowMs: UPSTASHVECTOR_BUDGET_WINDOW_MS,
+  ceiling: UPSTASHVECTOR_BUDGET_CEILING,
+  defaultWeight: UPSTASHVECTOR_CALL_WEIGHTS.other,
+  maxRetryAfterSeconds: UPSTASHVECTOR_BUDGET_MAX_RETRY_AFTER_S,
+  // Ordered: the kernel prices FIRST-MATCH-WINS, so the most expensive tier is listed first.
+  rules: [
+    { match: "(^|\\.)range$", weight: UPSTASHVECTOR_CALL_WEIGHTS.range },
+  ],
+  reason:
+    "Upstash publishes NO requests-per-second limit for Upstash Vector — this was checked and the " +
+    "absence is the finding, not an omission. The published figures are per-DAY caps and per-request " +
+    "billing, not a rate: Pay-As-You-Go bills per request ($0.4 per 100K, upstash.com/pricing/vector), " +
+    "the Free tier caps queries per DAY (10,000/day, ~6.9/minute sustained), and the per-plan limits " +
+    "govern SHAPE rather than rate (max dimension 1,536 Free to 5,000 Pro, max topK 1,000, metadata " +
+    "48 KB/vector, data 1 MB/vector, storage 1 GB Free to 1 TB Pro). Since no scalar rate is " +
+    "documented, this declaration stays AT the kernel's austere fallback rather than inventing " +
+    "headroom: 60 units / 60s at the default weight of 2 = 30 requests per minute. WHAT THAT DOES AND " +
+    "DOES NOT PROTECT, stated precisely (an earlier draft of this field had the comparison BACKWARDS " +
+    "and §9 caught it): the Free tier's 10,000 queries/DAY is ~6.94/minute sustained, while this " +
+    "ceiling allows 30/minute = 43,200/day — i.e. ~4.3x LOOSER than the free daily allowance, not " +
+    "tighter, and sustained pulling at the ceiling would exhaust a Free index's daily quota in about " +
+    "5.5 hours. So this bounds a BURST (a 60-second rolling window, fail-closed) and is the tightest " +
+    "burst D8 permits without a published vendor rate to cite; it does NOT bound daily spend, because " +
+    "a rolling-minute window structurally cannot. A caller running a long or repeated sync against a " +
+    "Free index must watch that daily quota themselves. (Contrast the sibling upstash pack, which IS more permissive than the " +
+    "fallback — and is so precisely because Upstash publishes a scalar 10,000 commands/sec for Redis.) " +
+    "range costs 6 because its cost scales with the CUSTOMER'S INDEX rather than the request — a " +
+    "vector index is routinely millions of rows — and it is the one entrypoint that loops; a heavier " +
+    "weight only TIGHTENS the allowance, which needs no vendor citation. Upstash does not publish the " +
+    "HTTP status or body of a Vector throttle response either, and this build had no live index to " +
+    "probe, so nothing here claims one.",
+};
+
+// Declared at module load, so merely importing this module (which `upstashvector-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, UPSTASHVECTOR_RATE_BUDGET);
+
+/** Price one Upstash Vector call by its client method name (e.g. `info`, `range`). */
+export function upstashvectorCallWeight(method: string): number {
+  return rateBudgetWeight(VENDOR, method);
+}
+
+/** Where UpstashVector'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 upstashvectorBudgetPath(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 UpstashVector's budget. The vendor is fixed; everything else may only TIGHTEN. */
+export type UpstashVectorBudgetOptions = Omit<RateBudgetOptions, 'vendor'>;
+
+/**
+ * UpstashVector's budget — the shared kernel guard bound to this vendor's declaration. A real subclass,
+ * not an alias, so `budget instanceof UpstashVectorBudget` 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 UpstashVectorBudget extends RateBudget {
+  constructor(opts: UpstashVectorBudgetOptions = {}) {
+    super({ ...opts, vendor: VENDOR });
+  }
+}
+
+export type { RateBudgetErrorKind as UpstashVectorBudgetErrorKind } from '@volter/world-core';
+export { RateBudgetError as UpstashVectorBudgetError } from '@volter/world-core';
+export type UpstashVectorBudgetReservation = RateBudgetReservation;
+export type UpstashVectorBudgetSnapshot = 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 UpstashVectorBudgetedOptions = {
+  /** An existing budget to share across calls. Omit and one is constructed. Cannot be null. */
+  budget?: UpstashVectorBudget;
+  /** Construction options for the default budget (ledger path, clock). Cannot loosen it. */
+  budgetOptions?: UpstashVectorBudgetOptions;
+};
+
+/** Pull the budget wiring out of a caller's opts bag, so an entrypoint can forward it verbatim. */
+export function upstashvectorBudgetOf(opts: UpstashVectorBudgetedOptions): UpstashVectorBudgetedOptions {
+  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-upstashvector.budget.guarded');
+
+type Guarded = { [GUARDED]?: unknown };
+
+/** Is this client already behind a budget? Returns the budget it is behind, if so. */
+export function upstashvectorClientBudget(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 UpstashVector 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 `UpstashVectorLikeClient` 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 guardUpstashVectorClient(client: UpstashVectorLikeClient, opts: UpstashVectorBudgetedOptions = {}): UpstashVectorLikeClient {
+  // 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 `UpstashVectorBudget` 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
+  // `guardUpstashVectorClient(alreadyGuarded, { budget: impostor })` is refused too rather than silently
+  // ignoring the impostor.
+  if (opts.budget !== undefined && opts.budget !== null && !(opts.budget instanceof UpstashVectorBudget)) {
+    throw new Error('guardUpstashVectorClient: `budget` must be a UpstashVectorBudget — refusing to guard a UpstashVector client with an unverified rate guard');
+  }
+  if (upstashvectorClientBudget(client)) return client;
+  const budget = opts.budget instanceof UpstashVectorBudget
+    ? opts.budget
+    : new UpstashVectorBudget({
+      // 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_VECTOR_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 UpstashVector 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_VECTOR_REST_TOKEN !== undefined ? { token: process.env.UPSTASH_VECTOR_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 UPSTASHVECTOR_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 UPSTASHVECTOR_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 UpstashVectorLikeClient;
+}
+
+/**
+ * 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;
+}