throttleai 0.1.0

package/dist/adapters/tools.js

@@ -0,0 +1,49 @@
+import {
+  classifyOutcome
+} from "../chunk-YHOXYRXL.js";
+
+// src/adapters/tools.ts
+function wrapTool(fn, options) {
+  const {
+    governor,
+    toolId,
+    actorId = "default",
+    priority = "background",
+    costWeight = 1
+  } = options;
+  return async (...args) => {
+    const decision = governor.acquire({
+      actorId,
+      action: `tool.${toolId}`,
+      priority,
+      estimate: { weight: costWeight }
+    });
+    if (!decision.granted) {
+      return {
+        ok: false,
+        decision
+      };
+    }
+    const start = Date.now();
+    try {
+      const result = await fn(...args);
+      const latencyMs = Date.now() - start;
+      governor.release(decision.leaseId, {
+        outcome: "success",
+        latencyMs
+      });
+      return { ok: true, result, latencyMs };
+    } catch (err) {
+      governor.release(decision.leaseId, {
+        outcome: "error",
+        latencyMs: Date.now() - start
+      });
+      throw err;
+    }
+  };
+}
+export {
+  classifyOutcome,
+  wrapTool
+};
+//# sourceMappingURL=tools.js.map

package/dist/adapters/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/tools.ts"],"sourcesContent":["/**\n * ThrottleAI tool adapter — wraps any async function (embeddings, rerankers, etc).\n *\n * Unifies throttling across model calls + tool calls so you can control\n * the total throughput of your AI pipeline, not just the LLM calls.\n *\n * @module throttleai/adapters/tools\n */\n\nexport type {\n  AdapterGovernor,\n  AdapterOptions,\n  AdapterResult,\n  AdapterGranted,\n  AdapterDenied,\n} from \"./types.js\";\n\nexport { classifyOutcome } from \"./types.js\";\n\nimport type { Priority, AcquireDecision } from \"../types.js\";\nimport type { AdapterGovernor, AdapterResult } from \"./types.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Options for wrapping a tool function. */\nexport interface WrapToolOptions {\n  /** Governor instance. */\n  governor: AdapterGovernor;\n  /** Tool identifier used as the action string (e.g., \"embed\", \"rerank\"). */\n  toolId: string;\n  /** Actor ID (default: \"default\"). */\n  actorId?: string;\n  /** Priority (default: \"background\"). Tools default to background. */\n  priority?: Priority;\n  /** Concurrency weight for this tool (default: 1). Heavy tools consume more capacity. */\n  costWeight?: number;\n}\n\n// ---------------------------------------------------------------------------\n// wrapTool\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap any async function with governor throttling.\n *\n * Acquires a lease (with configurable weight), runs the function,\n * and releases with outcome + latency. Useful for embeddings,\n * rerankers, vector DB calls, file operations, etc.\n *\n * ```ts\n * import { createGovernor, presets } from \"throttleai\";\n * import { wrapTool } from \"throttleai/adapters/tools\";\n *\n * const gov = createGovernor(presets.balanced());\n *\n * const embed = wrapTool(\n *   (text: string) => embeddingModel.embed(text),\n *   { governor: gov, toolId: \"embed\", costWeight: 1 },\n * );\n *\n * const rerank = wrapTool(\n *   (docs: string[]) => reranker.rerank(docs),\n *   { governor: gov, toolId: \"rerank\", costWeight: 2 },\n * );\n *\n * const embedResult = await embed(\"hello world\");\n * if (embedResult.ok) console.log(embedResult.result);\n * ```\n */\nexport function wrapTool<TArgs extends unknown[], TResult>(\n  fn: (...args: TArgs) => Promise<TResult>,\n  options: WrapToolOptions,\n): (...args: TArgs) => Promise<AdapterResult<TResult>> {\n  const {\n    governor,\n    toolId,\n    actorId = \"default\",\n    priority = \"background\",\n    costWeight = 1,\n  } = options;\n\n  return async (...args) => {\n    const decision = governor.acquire({\n      actorId,\n      action: `tool.${toolId}`,\n      priority,\n      estimate: { weight: costWeight },\n    });\n\n    if (!decision.granted) {\n      return {\n        ok: false,\n        decision: decision as AcquireDecision & { granted: false },\n      };\n    }\n\n    const start = Date.now();\n\n    try {\n      const result = await fn(...args);\n      const latencyMs = Date.now() - start;\n\n      governor.release(decision.leaseId, {\n        outcome: \"success\",\n        latencyMs,\n      });\n\n      return { ok: true, result, latencyMs };\n    } catch (err) {\n      governor.release(decision.leaseId, {\n        outcome: \"error\",\n        latencyMs: Date.now() - start,\n      });\n      throw err;\n    }\n  };\n}\n"],"mappings":";;;;;AAuEO,SAAS,SACd,IACA,SACqD;AACrD,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,UAAU;AAAA,IACV,WAAW;AAAA,IACX,aAAa;AAAA,EACf,IAAI;AAEJ,SAAO,UAAU,SAAS;AACxB,UAAM,WAAW,SAAS,QAAQ;AAAA,MAChC;AAAA,MACA,QAAQ,QAAQ,MAAM;AAAA,MACtB;AAAA,MACA,UAAU,EAAE,QAAQ,WAAW;AAAA,IACjC,CAAC;AAED,QAAI,CAAC,SAAS,SAAS;AACrB,aAAO;AAAA,QACL,IAAI;AAAA,QACJ;AAAA,MACF;AAAA,IACF;AAEA,UAAM,QAAQ,KAAK,IAAI;AAEvB,QAAI;AACF,YAAM,SAAS,MAAM,GAAG,GAAG,IAAI;AAC/B,YAAM,YAAY,KAAK,IAAI,IAAI;AAE/B,eAAS,QAAQ,SAAS,SAAS;AAAA,QACjC,SAAS;AAAA,QACT;AAAA,MACF,CAAC;AAED,aAAO,EAAE,IAAI,MAAM,QAAQ,UAAU;AAAA,IACvC,SAAS,KAAK;AACZ,eAAS,QAAQ,SAAS,SAAS;AAAA,QACjC,SAAS;AAAA,QACT,WAAW,KAAK,IAAI,IAAI;AAAA,MAC1B,CAAC;AACD,YAAM;AAAA,IACR;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-YHOXYRXL.js

@@ -0,0 +1,11 @@
+// src/adapters/types.ts
+function classifyOutcome(error, statusCode) {
+  if (error) return "error";
+  if (statusCode !== void 0 && statusCode >= 400) return "error";
+  return "success";
+}
+
+export {
+  classifyOutcome
+};
+//# sourceMappingURL=chunk-YHOXYRXL.js.map

package/dist/chunk-YHOXYRXL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/types.ts"],"sourcesContent":["/**\n * Shared types for all ThrottleAI adapters.\n *\n * Adapters live in separate entrypoints so bundlers can tree-shake them.\n * Core ThrottleAI never imports from adapters.\n */\n\nimport type { Governor } from \"../governor.js\";\nimport type { Priority, LeaseOutcome, AcquireDecision } from \"../types.js\";\n\n// ---------------------------------------------------------------------------\n// Adapter context — what every adapter needs\n// ---------------------------------------------------------------------------\n\n/** Minimal governor interface that adapters depend on. */\nexport interface AdapterGovernor {\n  acquire: Governor[\"acquire\"];\n  release: Governor[\"release\"];\n}\n\n/** Options common to all adapters. */\nexport interface AdapterOptions {\n  /** Governor instance to use for throttling. */\n  governor: AdapterGovernor;\n  /** Actor ID for the request (default: \"default\"). */\n  actorId?: string;\n  /** Priority for the request (default: \"interactive\"). */\n  priority?: Priority;\n}\n\n// ---------------------------------------------------------------------------\n// Adapter result — consistent deny shape across all adapters\n// ---------------------------------------------------------------------------\n\n/** Successful adapter result. */\nexport interface AdapterGranted<T> {\n  ok: true;\n  result: T;\n  latencyMs: number;\n}\n\n/** Denied adapter result — consistent shape across all adapters. */\nexport interface AdapterDenied {\n  ok: false;\n  decision: AcquireDecision & { granted: false };\n}\n\n/** Union result from any adapter. */\nexport type AdapterResult<T> = AdapterGranted<T> | AdapterDenied;\n\n// ---------------------------------------------------------------------------\n// Usage extraction — optional hook for adapters to report actual tokens\n// ---------------------------------------------------------------------------\n\n/** Token usage as reported by a provider response. */\nexport interface ProviderUsage {\n  promptTokens?: number;\n  outputTokens?: number;\n}\n\n/** Classify the outcome of an operation. */\nexport function classifyOutcome(\n  error: unknown,\n  statusCode?: number,\n): LeaseOutcome {\n  if (error) return \"error\";\n  if (statusCode !== undefined && statusCode >= 400) return \"error\";\n  return \"success\";\n}\n"],"mappings":";AA6DO,SAAS,gBACd,OACA,YACc;AACd,MAAI,MAAO,QAAO;AAClB,MAAI,eAAe,UAAa,cAAc,IAAK,QAAO;AAC1D,SAAO;AACT;","names":[]}

package/dist/governor-MVaCesqM.d.cts

@@ -0,0 +1,206 @@
+interface ConcurrencyConfig {
+    /** Maximum number of in-flight leases. */
+    maxInFlight: number;
+    /** Slots reserved for interactive priority (default 0). */
+    interactiveReserve?: number;
+}
+interface RateConfig {
+    /** Maximum requests allowed within the rolling window. */
+    requestsPerMinute?: number;
+    /** Maximum tokens allowed within the rolling window. */
+    tokensPerMinute?: number;
+    /** Rolling window size in ms (default 60 000). */
+    windowMs?: number;
+}
+interface FairnessConfig {
+    /** Fraction of maxInFlight weight an actor can hold before soft-cap (default 0.6). */
+    softCapRatio?: number;
+    /** How long a denied actor gets priority boost in ms (default 5 000). */
+    starvationWindowMs?: number;
+}
+interface AdaptiveConfig {
+    /** EMA smoothing factor (0–1, default 0.2). Higher = more responsive. */
+    alpha?: number;
+    /** Target deny rate (0–1, default 0.05). Above this → reduce concurrency. */
+    targetDenyRate?: number;
+    /** Latency increase ratio that triggers reduction (default 1.5). */
+    latencyThreshold?: number;
+    /** How often to recalculate in ms (default 5 000). */
+    adjustIntervalMs?: number;
+    /** Minimum effective concurrency (default 1). */
+    minConcurrency?: number;
+}
+interface GovernorConfig {
+    concurrency?: ConcurrencyConfig;
+    rate?: RateConfig;
+    /** Fairness settings. Set to `true` for defaults, or pass a config object. Only active when concurrency is configured. */
+    fairness?: boolean | FairnessConfig;
+    /** Adaptive concurrency tuning. Set to `true` for defaults, or pass a config. Only active when concurrency is configured. */
+    adaptive?: boolean | AdaptiveConfig;
+    /** Lease time-to-live in ms (default 60 000). */
+    leaseTtlMs?: number;
+    /** How often the reaper sweeps expired leases in ms (default 5 000). */
+    reaperIntervalMs?: number;
+    /** Optional event handler. Receives structured events for acquire/deny/release/expire. No logging by default. */
+    onEvent?: GovernorEventHandler;
+    /**
+     * Enable strict mode for development.
+     *
+     * When `true`:
+     * - Double release throws an error
+     * - Releasing an unknown lease ID throws an error
+     * - Long-held leases (>80% of TTL) emit a "warn" event via onEvent
+     */
+    strict?: boolean;
+}
+type Priority = "interactive" | "background";
+type DenyReason = "concurrency" | "rate" | "budget" | "policy";
+type LeaseOutcome = "success" | "error" | "timeout" | "cancelled";
+interface TokenEstimate {
+    promptTokens?: number;
+    maxOutputTokens?: number;
+    /** Concurrency weight for this call (default 1). Heavy calls consume more capacity. */
+    weight?: number;
+}
+interface AcquireRequest {
+    actorId: string;
+    action: string;
+    estimate?: TokenEstimate;
+    idempotencyKey?: string;
+    priority?: Priority;
+}
+interface Constraints {
+    maxOutputTokens?: number;
+}
+/** Structured hint about the limits that caused a denial. */
+interface LimitsHint {
+    /** Current in-flight weight (concurrency denials). */
+    inFlight?: number;
+    /** Maximum allowed in-flight weight (concurrency denials). */
+    maxInFlight?: number;
+    /** Current request count in window (rate denials). */
+    rateUsed?: number;
+    /** Rate limit (rate denials). */
+    rateLimit?: number;
+}
+type AcquireDecision = {
+    granted: true;
+    leaseId: string;
+    expiresAt: number;
+    constraints?: Constraints;
+} | {
+    granted: false;
+    reason: DenyReason;
+    retryAfterMs: number;
+    recommendation: string;
+    /** Structured hint about the limits that caused the denial. */
+    limitsHint?: LimitsHint;
+};
+interface ReleaseReport {
+    outcome: LeaseOutcome;
+    usage?: {
+        promptTokens?: number;
+        outputTokens?: number;
+    };
+    actualCostCents?: number;
+    /** Actual latency of the operation in ms. Used by adaptive tuning. */
+    latencyMs?: number;
+}
+interface GovernorSnapshot {
+    /** Timestamp when the snapshot was taken. */
+    timestamp: number;
+    /** Number of active leases. */
+    activeLeases: number;
+    concurrency: {
+        /** Current in-flight weight (sum of all active lease weights). */
+        inFlightWeight: number;
+        /** Current in-flight count (number of active leases). */
+        inFlightCount: number;
+        /** Available weight capacity. */
+        available: number;
+        /** Configured max in-flight weight. */
+        max: number;
+        /** Effective max (may be lower when adaptive is active). */
+        effectiveMax: number;
+        /** @deprecated Use `inFlightWeight` instead. */
+        active: number;
+    } | null;
+    requestRate: {
+        current: number;
+        limit: number;
+    } | null;
+    tokenRate: {
+        current: number;
+        limit: number;
+    } | null;
+    fairness: boolean;
+    adaptive: boolean;
+    /** Most recent deny event, if any. */
+    lastDeny: {
+        reason: DenyReason;
+        timestamp: number;
+        actorId?: string;
+    } | null;
+}
+type GovernorEventType = "acquire" | "deny" | "release" | "expire" | "warn";
+interface GovernorEvent {
+    type: GovernorEventType;
+    timestamp: number;
+    leaseId?: string;
+    actorId?: string;
+    action?: string;
+    reason?: DenyReason;
+    retryAfterMs?: number;
+    /** Recommendation string (only for "deny" events). */
+    recommendation?: string;
+    weight?: number;
+    outcome?: LeaseOutcome;
+    /** Warning message (only for "warn" events). */
+    message?: string;
+}
+type GovernorEventHandler = (event: GovernorEvent) => void;
+
+declare class Governor {
+    private readonly _store;
+    private readonly _concurrency;
+    private readonly _rate;
+    private readonly _tokenRate;
+    private readonly _fairness;
+    private readonly _adaptive;
+    private readonly _ttlMs;
+    private readonly _onEvent;
+    private readonly _strict;
+    /** Track recently-released lease IDs in strict mode (to detect double release). */
+    private readonly _releasedIds;
+    /** Max size of _releasedIds before pruning (prevent unbounded growth). */
+    private static readonly _RELEASED_CACHE_SIZE;
+    /** Track the most recent deny for snapshot(). */
+    private _lastDeny;
+    constructor(config: GovernorConfig);
+    acquire(request: AcquireRequest): AcquireDecision;
+    release(leaseId: string, report?: ReleaseReport): void;
+    get activeLeases(): number;
+    /** Current in-flight weight (or count when all weights are 1). */
+    get concurrencyActive(): number;
+    /** Available weight capacity. */
+    get concurrencyAvailable(): number;
+    /** Effective concurrency limit (may be lower than configured max when adaptive is active). */
+    get concurrencyEffectiveMax(): number;
+    get rateCount(): number;
+    get rateLimit(): number;
+    /** Current tokens consumed in the active window. */
+    get tokenRateCount(): number;
+    /** Token-rate limit. */
+    get tokenRateLimit(): number;
+    /** Return a read-only snapshot of current governor state. */
+    snapshot(): GovernorSnapshot;
+    dispose(): void;
+    private _rollbackConcurrency;
+    /** Estimate total tokens from the request's estimate. */
+    private _estimateTokens;
+    private _onExpired;
+    private _recordDeny;
+    private _emit;
+}
+
+export { type AcquireDecision as A, type ConcurrencyConfig as C, type DenyReason as D, type FairnessConfig as F, type GovernorConfig as G, type LeaseOutcome as L, type Priority as P, type RateConfig as R, type TokenEstimate as T, Governor as a, type AcquireRequest as b, type GovernorEvent as c, type GovernorSnapshot as d, type AdaptiveConfig as e, type Constraints as f, type GovernorEventHandler as g, type GovernorEventType as h, type LimitsHint as i, type ReleaseReport as j };

package/dist/governor-MVaCesqM.d.ts

@@ -0,0 +1,206 @@
+interface ConcurrencyConfig {
+    /** Maximum number of in-flight leases. */
+    maxInFlight: number;
+    /** Slots reserved for interactive priority (default 0). */
+    interactiveReserve?: number;
+}
+interface RateConfig {
+    /** Maximum requests allowed within the rolling window. */
+    requestsPerMinute?: number;
+    /** Maximum tokens allowed within the rolling window. */
+    tokensPerMinute?: number;
+    /** Rolling window size in ms (default 60 000). */
+    windowMs?: number;
+}
+interface FairnessConfig {
+    /** Fraction of maxInFlight weight an actor can hold before soft-cap (default 0.6). */
+    softCapRatio?: number;
+    /** How long a denied actor gets priority boost in ms (default 5 000). */
+    starvationWindowMs?: number;
+}
+interface AdaptiveConfig {
+    /** EMA smoothing factor (0–1, default 0.2). Higher = more responsive. */
+    alpha?: number;
+    /** Target deny rate (0–1, default 0.05). Above this → reduce concurrency. */
+    targetDenyRate?: number;
+    /** Latency increase ratio that triggers reduction (default 1.5). */
+    latencyThreshold?: number;
+    /** How often to recalculate in ms (default 5 000). */
+    adjustIntervalMs?: number;
+    /** Minimum effective concurrency (default 1). */
+    minConcurrency?: number;
+}
+interface GovernorConfig {
+    concurrency?: ConcurrencyConfig;
+    rate?: RateConfig;
+    /** Fairness settings. Set to `true` for defaults, or pass a config object. Only active when concurrency is configured. */
+    fairness?: boolean | FairnessConfig;
+    /** Adaptive concurrency tuning. Set to `true` for defaults, or pass a config. Only active when concurrency is configured. */
+    adaptive?: boolean | AdaptiveConfig;
+    /** Lease time-to-live in ms (default 60 000). */
+    leaseTtlMs?: number;
+    /** How often the reaper sweeps expired leases in ms (default 5 000). */
+    reaperIntervalMs?: number;
+    /** Optional event handler. Receives structured events for acquire/deny/release/expire. No logging by default. */
+    onEvent?: GovernorEventHandler;
+    /**
+     * Enable strict mode for development.
+     *
+     * When `true`:
+     * - Double release throws an error
+     * - Releasing an unknown lease ID throws an error
+     * - Long-held leases (>80% of TTL) emit a "warn" event via onEvent
+     */
+    strict?: boolean;
+}
+type Priority = "interactive" | "background";
+type DenyReason = "concurrency" | "rate" | "budget" | "policy";
+type LeaseOutcome = "success" | "error" | "timeout" | "cancelled";
+interface TokenEstimate {
+    promptTokens?: number;
+    maxOutputTokens?: number;
+    /** Concurrency weight for this call (default 1). Heavy calls consume more capacity. */
+    weight?: number;
+}
+interface AcquireRequest {
+    actorId: string;
+    action: string;
+    estimate?: TokenEstimate;
+    idempotencyKey?: string;
+    priority?: Priority;
+}
+interface Constraints {
+    maxOutputTokens?: number;
+}
+/** Structured hint about the limits that caused a denial. */
+interface LimitsHint {
+    /** Current in-flight weight (concurrency denials). */
+    inFlight?: number;
+    /** Maximum allowed in-flight weight (concurrency denials). */
+    maxInFlight?: number;
+    /** Current request count in window (rate denials). */
+    rateUsed?: number;
+    /** Rate limit (rate denials). */
+    rateLimit?: number;
+}
+type AcquireDecision = {
+    granted: true;
+    leaseId: string;
+    expiresAt: number;
+    constraints?: Constraints;
+} | {
+    granted: false;
+    reason: DenyReason;
+    retryAfterMs: number;
+    recommendation: string;
+    /** Structured hint about the limits that caused the denial. */
+    limitsHint?: LimitsHint;
+};
+interface ReleaseReport {
+    outcome: LeaseOutcome;
+    usage?: {
+        promptTokens?: number;
+        outputTokens?: number;
+    };
+    actualCostCents?: number;
+    /** Actual latency of the operation in ms. Used by adaptive tuning. */
+    latencyMs?: number;
+}
+interface GovernorSnapshot {
+    /** Timestamp when the snapshot was taken. */
+    timestamp: number;
+    /** Number of active leases. */
+    activeLeases: number;
+    concurrency: {
+        /** Current in-flight weight (sum of all active lease weights). */
+        inFlightWeight: number;
+        /** Current in-flight count (number of active leases). */
+        inFlightCount: number;
+        /** Available weight capacity. */
+        available: number;
+        /** Configured max in-flight weight. */
+        max: number;
+        /** Effective max (may be lower when adaptive is active). */
+        effectiveMax: number;
+        /** @deprecated Use `inFlightWeight` instead. */
+        active: number;
+    } | null;
+    requestRate: {
+        current: number;
+        limit: number;
+    } | null;
+    tokenRate: {
+        current: number;
+        limit: number;
+    } | null;
+    fairness: boolean;
+    adaptive: boolean;
+    /** Most recent deny event, if any. */
+    lastDeny: {
+        reason: DenyReason;
+        timestamp: number;
+        actorId?: string;
+    } | null;
+}
+type GovernorEventType = "acquire" | "deny" | "release" | "expire" | "warn";
+interface GovernorEvent {
+    type: GovernorEventType;
+    timestamp: number;
+    leaseId?: string;
+    actorId?: string;
+    action?: string;
+    reason?: DenyReason;
+    retryAfterMs?: number;
+    /** Recommendation string (only for "deny" events). */
+    recommendation?: string;
+    weight?: number;
+    outcome?: LeaseOutcome;
+    /** Warning message (only for "warn" events). */
+    message?: string;
+}
+type GovernorEventHandler = (event: GovernorEvent) => void;
+
+declare class Governor {
+    private readonly _store;
+    private readonly _concurrency;
+    private readonly _rate;
+    private readonly _tokenRate;
+    private readonly _fairness;
+    private readonly _adaptive;
+    private readonly _ttlMs;
+    private readonly _onEvent;
+    private readonly _strict;
+    /** Track recently-released lease IDs in strict mode (to detect double release). */
+    private readonly _releasedIds;
+    /** Max size of _releasedIds before pruning (prevent unbounded growth). */
+    private static readonly _RELEASED_CACHE_SIZE;
+    /** Track the most recent deny for snapshot(). */
+    private _lastDeny;
+    constructor(config: GovernorConfig);
+    acquire(request: AcquireRequest): AcquireDecision;
+    release(leaseId: string, report?: ReleaseReport): void;
+    get activeLeases(): number;
+    /** Current in-flight weight (or count when all weights are 1). */
+    get concurrencyActive(): number;
+    /** Available weight capacity. */
+    get concurrencyAvailable(): number;
+    /** Effective concurrency limit (may be lower than configured max when adaptive is active). */
+    get concurrencyEffectiveMax(): number;
+    get rateCount(): number;
+    get rateLimit(): number;
+    /** Current tokens consumed in the active window. */
+    get tokenRateCount(): number;
+    /** Token-rate limit. */
+    get tokenRateLimit(): number;
+    /** Return a read-only snapshot of current governor state. */
+    snapshot(): GovernorSnapshot;
+    dispose(): void;
+    private _rollbackConcurrency;
+    /** Estimate total tokens from the request's estimate. */
+    private _estimateTokens;
+    private _onExpired;
+    private _recordDeny;
+    private _emit;
+}
+
+export { type AcquireDecision as A, type ConcurrencyConfig as C, type DenyReason as D, type FairnessConfig as F, type GovernorConfig as G, type LeaseOutcome as L, type Priority as P, type RateConfig as R, type TokenEstimate as T, Governor as a, type AcquireRequest as b, type GovernorEvent as c, type GovernorSnapshot as d, type AdaptiveConfig as e, type Constraints as f, type GovernorEventHandler as g, type GovernorEventType as h, type LimitsHint as i, type ReleaseReport as j };