@volter/twin-algolia 0.1.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@volter/twin-algolia",
+  "version": "0.1.0",
+  "description": "Local Algolia twin for the hosted-search surface: index list/delete/clear, record CRUD (add-auto-objectID/add-replace/get/partial/delete/batch), browse-adjacent record listing, a REAL search engine (tokenize + Damerau-Levenshtein typo tolerance + a faithful-subset ranking + REAL filter/facetFilters evaluation + exact facet-count aggregation + customRanking tie-breaks + basic bidirectional synonym expansion), settings get/set, multi-index, and a host-tolerant router, built on @volter/world-core.",
+  "author": "Volter (https://github.com/volter-ai)",
+  "license": "Apache-2.0",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE",
+    "!**/*.test.ts",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/volter-ai/twin.git",
+    "directory": "packages/twin/algolia"
+  },
+  "homepage": "https://github.com/volter-ai/twin/tree/main/packages/twin/algolia#readme",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "bin": {
+    "world-algolia": "dist/src/cli.js"
+  },
+  "scripts": {
+    "test": "bun test src/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "build": "node ../../../scripts/publish/build.mjs",
+    "prepack": "node ../../../scripts/publish/prepare-publish.mjs prepack",
+    "postpack": "node ../../../scripts/publish/prepare-publish.mjs postpack"
+  },
+  "peerDependencies": {
+    "@volter/world-core": "2.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.20",
+    "@types/node": "^24.0.0",
+    "@volter/world-core": "2.0.0",
+    "@volter/world-tooling": "0.1.0",
+    "algoliasearch": "4.27.0",
+    "typescript": "^5.9.0"
+  },
+  "engines": {
+    "node": ">=22.3"
+  }
+}

package/src/algolia-budget.ts

@@ -0,0 +1,462 @@
+// Algolia's CLIENT-SIDE RATE BUDGET — the pack's DECLARATION (the numbers) plus `guardAlgoliaClient`,
+// the choke point every live Algolia 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 ALGOLIA NEEDS ONE ───────────────────────────────────────────────────────────
+// Algolia does NOT publish a scalar rate limit for the endpoints this connector uses.
+// The published limits table (algolia.com/doc/guides/scaling/algolia-service-limits) covers ADJACENT
+// APIs only — Connectors Push and Observability at 2000 calls/min/IP, "all other" Connectors
+// endpoints at 200/min/IP, the Analytics API at 100 calls/min/app, DocSearch at 3 queries/second —
+// and the Search REST reference has no rate-limit or 429 section at all. Per-plan max QPS is
+// plan-derived and explicitly "reach out to Support to find out"; `maxQueriesPerIPPerHour` is a
+// CUSTOMER-SET restriction whose default is 0 (meaning no limit), so it is not a vendor limit either.
+// Algolia additionally documents that `browse` is EXCLUDED from search-QPS accounting — which means
+// the endpoint this connector leans on hardest is the one with the least published ceiling of all.
+// That combination — no number to aim at, plus an unmetered fan-out endpoint — is exactly when a
+// conservative client-side ceiling matters most.
+//
+// ── HOW THE CEILING WAS CHOSEN ──────────────────────────────────────────────────────────────
+// NO DOCUMENTED SCALAR LIMIT was found for search/browse/listIndices, so this budget does NOT
+// claim one. It is pinned to the kernel's own conservative fallback (DEFAULT_RATE_BUDGET: 60 weighted
+// units per 60s at a default weight of 2, i.e. 30 calls/minute) — identical in call count, strictly
+// TIGHTER on the browse aggregation. Nothing here is more permissive than what an undeclared vendor
+// already gets; the value the declaration adds is the per-endpoint pricing below, plus a `reason`
+// that records honestly that the number is prudence and not vendor fact.
+//
+// ── 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 the vendor's own 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). A tighter window would not
+// close the gap, it would only turn every legitimate multi-page pull into a cascade of refusals.
+//
+// ── HOW THE WEIGHTS WERE CHOSEN (and what is a judgement call) ──────────────────────────────
+// `listRecords` costs 4, twice everything else. This is a JUDGEMENT CALL, not a published cost:
+// Algolia charges per operation, not per browse. It is priced up because it is this connector's only
+// UNBOUNDED endpoint — a real implementation loops `listIndices()` then browses every index's objects
+// and flattens the result, so one innocent call fans out into as many requests as the account has
+// indexes times pages. Doubling its price halves the depth at which a runaway browse is stopped while
+// barely touching a normal pull, which is one `listIndices` plus one aggregation. Called out here
+// rather than dressed up as vendor fact.
+import {
+  declareRateBudget,
+  rateBudgetPath,
+  rateBudgetWeight,
+  RateBudget,
+  RateBudgetError,
+  type RateBudgetDeclaration,
+  type RateBudgetOptions,
+  type RateBudgetReservation,
+  type RateBudgetSnapshot,
+} from '@volter/world-core';
+import type { AlgoliaLikeClient } from './algolia-connector.ts';
+
+const VENDOR = 'algolia';
+
+/** Rolling window, in ms. Spend older than this is pruned. */
+export const ALGOLIA_BUDGET_WINDOW_MS = 60_000;
+
+/** Weighted units allowed inside one window. See the header for where this number comes from. */
+export const ALGOLIA_BUDGET_CEILING = 60;
+
+/** Seconds. A `Retry-After` above this means the credential is throttled hard — fail loudly. */
+export const ALGOLIA_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 ALGOLIA_CALL_WEIGHTS = {
+  /** `listRecords` — the cross-index browse aggregation, the unbounded fan-out. */
+  browse: 4,
+  /** Every other modeled call (`listIndices`, 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 ALGOLIA_BUDGETED_METHODS = [
+  'listIndices',
+  'listRecords',
+] as const;
+
+/** THE PACK'S DECLARATION — pure data, the only Algolia-specific thing in the whole budget. */
+export const ALGOLIA_RATE_BUDGET: RateBudgetDeclaration = {
+  windowMs: ALGOLIA_BUDGET_WINDOW_MS,
+  ceiling: ALGOLIA_BUDGET_CEILING,
+  defaultWeight: ALGOLIA_CALL_WEIGHTS.other,
+  maxRetryAfterSeconds: ALGOLIA_BUDGET_MAX_RETRY_AFTER_S,
+  // Ordered: the kernel prices FIRST-MATCH-WINS, so the tightest tier is listed first.
+  rules: [
+    { match: "(^|\\.)listRecords$", weight: ALGOLIA_CALL_WEIGHTS.browse },
+  ],
+  reason:
+    "Algolia publishes NO scalar rate limit for the Search API, browse, or listIndices — the documented " +
+    "limits table covers only the Connectors (2000/min/IP push, 200/min/IP other), Analytics (100/min/app) " +
+    "and DocSearch (3 q/s) surfaces, per-plan max QPS is \"contact Support\", and browse is explicitly " +
+    "EXCLUDED from search-QPS accounting. With no published figure to aim at, this ceiling is pinned to the " +
+    "kernel's conservative fallback (60 units / 60s at weight 2 = 30 calls/min) rather than invented: it is " +
+    "no more permissive than an undeclared vendor already gets. listRecords costs 4 because it is the " +
+    "cross-index browse aggregation a pagination bug turns into hundreds of calls — a judgement call, not a " +
+    "published cost. Algolia does not document Retry-After; the 429/exhaustion cooldown is the backstop.",
+};
+
+// Declared at module load, so merely importing this module (which `algolia-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, ALGOLIA_RATE_BUDGET);
+
+/** Price one Algolia call by its client method key (a dotted path, e.g. `listIndices`). */
+export function algoliaCallWeight(method: string): number {
+  return rateBudgetWeight(VENDOR, method);
+}
+
+/** Where Algolia'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 algoliaBudgetPath(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 Algolia's budget. The vendor is fixed; everything else may only TIGHTEN. */
+export type AlgoliaBudgetOptions = Omit<RateBudgetOptions, 'vendor'>;
+
+/**
+ * Algolia's budget — the shared kernel guard bound to this vendor's declaration. A real subclass,
+ * not an alias, so `budget instanceof AlgoliaBudget` 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 AlgoliaBudget extends RateBudget {
+  constructor(opts: AlgoliaBudgetOptions = {}) {
+    super({ ...opts, vendor: VENDOR });
+  }
+}
+
+export type { RateBudgetErrorKind as AlgoliaBudgetErrorKind } from '@volter/world-core';
+export { RateBudgetError as AlgoliaBudgetError } from '@volter/world-core';
+export type AlgoliaBudgetReservation = RateBudgetReservation;
+export type AlgoliaBudgetSnapshot = 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 AlgoliaBudgetedOptions = {
+  /** An existing budget to share across calls. Omit and one is constructed. Cannot be null. */
+  budget?: AlgoliaBudget;
+  /** Construction options for the default budget (ledger path, clock). Cannot loosen it. */
+  budgetOptions?: AlgoliaBudgetOptions;
+};
+
+/** Pull the budget wiring out of a caller's opts bag, so an entrypoint can forward it verbatim. */
+export function algoliaBudgetOf(opts: AlgoliaBudgetedOptions): AlgoliaBudgetedOptions {
+  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-algolia.budget.guarded');
+
+type Guarded = { [GUARDED]?: unknown };
+
+/** Is this client already behind a budget? Returns the budget it is behind, if so. */
+export function algoliaClientBudget(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 Algolia 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 `AlgoliaLikeClient` 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 guardAlgoliaClient(client: AlgoliaLikeClient, opts: AlgoliaBudgetedOptions = {}): AlgoliaLikeClient {
+  // 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 `AlgoliaBudget` 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
+  // `guardAlgoliaClient(alreadyGuarded, { budget: impostor })` is refused too rather than silently
+  // ignoring the impostor.
+  if (opts.budget !== undefined && opts.budget !== null && !(opts.budget instanceof AlgoliaBudget)) {
+    throw new Error('guardAlgoliaClient: `budget` must be a AlgoliaBudget — refusing to guard a Algolia client with an unverified rate guard');
+  }
+  if (algoliaClientBudget(client)) return client;
+  const budget = opts.budget instanceof AlgoliaBudget
+    ? opts.budget
+    : new AlgoliaBudget({
+      // 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
+      // `ALGOLIA_API_KEY` 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 Algolia 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.ALGOLIA_API_KEY !== undefined ? { token: process.env.ALGOLIA_API_KEY } : {}),
+      ...(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 ALGOLIA_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 ALGOLIA_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 AlgoliaLikeClient;
+}
+
+/**
+ * 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;
+}