@bivelio/savings-layer 0.4.33 → 0.4.35

package/dist/index.d.ts

@@ -48,11 +48,11 @@ interface CostModel {
     cachedInputPer1k?: number;
 }
 /** Oldest provider counter a repeat can be valued against: one billing period. */
-declare const REFERENCE_MAX_AGE_MS: number;
+declare const REFERENCE_MAX_AGE_MS$1: number;
 /** Share of the counted output credited to a repeat: only under deterministic sampling, on a catalog model that does not reason and honors it, when the call that ran carried no hidden reasoning. */
-declare const REFERENCE_OUTPUT_SHARE = 0.95;
+declare const REFERENCE_OUTPUT_SHARE$1 = 0.95;
 /** Input tokens deducted per piece the layer inserted in the call that ran: a message, the wrapper around a native output schema, or half of the empty parameters given to a tool that had none. */
-declare const REFERENCE_MESSAGE_ALLOWANCE = 8;
+declare const REFERENCE_MESSAGE_ALLOWANCE$1 = 8;
 /**
  * Why an avoided call (a cache or coalesced hit) could not be valued by
  * reference, and so stays `estimated`.
@@ -102,7 +102,7 @@ interface ReferenceCredit {
     /** Fraction of the standard price applied: 1, or the discounted tier the call ran on or this request declared. */
     tierFactor: number;
 }
-declare class SavingsLedger {
+declare class SavingsLedger$1 {
     avoidedLlm: number;
     baselineLlm: number;
     actualLlm: number;
@@ -339,7 +339,7 @@ declare function precioDeLista$1(model: string, at?: Date | number): CostModel |
  * on the customer's machine. `test/version-declarada.test.ts` ties this
  * constant to package.json so the two can never drift.
  */
-declare const BV_SALA_VERSION = "0.4.33";
+declare const BV_SALA_VERSION = "0.4.35";
 
 /**
  * Environment-agnostic UUID generation.
@@ -349,7 +349,7 @@ declare const BV_SALA_VERSION = "0.4.33";
  * Deno and edge runtimes) and fall back to a v4-shaped id when it is absent, so
  * BV-SALA runs everywhere without a `node:crypto` import that breaks bundlers.
  */
-declare function randomId(): string;
+declare function randomId$1(): string;
 
 /** How the layer served a request that is eligible for a verification check. */
 type VerificationStratum = 
@@ -1418,8 +1418,21 @@ interface QualityRepairCheck {
 interface QualityTruncationCheck {
     /** True when the provider reported `finishReason: "length"`. A truncated answer is never cached. */
     truncated: boolean;
-    /** The stop reason exactly as the provider named it; absent when it reported none. */
+    /**
+     * Why the provider stopped, as `SavingsResult.finishReason` reports it;
+     * absent when it reported none.
+     *
+     * In 0.5 this becomes the same CLOSED set as `SavingsResult.finishReason` —
+     * `"stop"`, `"length"`, `"tool_calls"`, `"content_filter"` or `"other"` — and
+     * the provider's own value moves to {@link finishReasonDetail}. Compare
+     * against those five values only; see the 0.5 migration guide.
+     */
     finishReason?: string;
+    /**
+     * The provider's own reason behind `finishReason`, when it gave one: the same
+     * value as `SavingsResult.finishReasonDetail` for the answer that was served.
+     */
+    finishReasonDetail?: string;
     /**
      * Whether you set the limit (`maxOutputTokens` on the request or on
      * `response`). When false, any
@@ -2092,7 +2105,7 @@ declare class InMemoryExactCache implements ExactCache {
  * requests that mean the same thing must canonicalize identically, and two
  * requests that differ in any way that could change the answer must not.
  */
-interface CanonicalRequest {
+interface CanonicalRequest$1 {
     model: string;
     modelFamily: string;
     messages: ChatMessage[];
@@ -2157,10 +2170,10 @@ interface CanonicalRequest {
  * thousands separators, times, dates, units, negations, math operators and any
  * combining mark outside the Latin alphabet.
  */
-declare function normalizeText(text: string): string;
-declare function sha256(input: string): string;
+declare function normalizeText$1(text: string): string;
+declare function sha256$1(input: string): string;
 /** Stable JSON stringify with sorted keys so hashes are order-independent. */
-declare function stableStringify(value: unknown): string;
+declare function stableStringify$1(value: unknown): string;
 /**
  * The version-and-size-independent family of a model id.
  *
@@ -2168,8 +2181,8 @@ declare function stableStringify(value: unknown): string;
  * ANSWER, which is not always the one the caller named. Deriving the family a
  * second time somewhere else is how two rulers start to disagree.
  */
-declare function modelFamilyOf(model: string): string;
-declare function canonicalize(request: SavingsRequest): CanonicalRequest;
+declare function modelFamilyOf$1(model: string): string;
+declare function canonicalize$1(request: SavingsRequest): CanonicalRequest$1;
 
 /**
  * Thrown by `importCalibration` / `exportCalibration` when a calibration state
@@ -2323,7 +2336,7 @@ interface SemanticCalibrationStatus {
     nextTestAt?: number;
 }
 /** Default {@link AnswerJudge}: the stored answer counts as right only if it is the same answer. */
-declare function sameAnswer(stored: CachedAnswer, fresh: CachedAnswer): boolean;
+declare function sameAnswer$1(stored: CachedAnswer, fresh: CachedAnswer): boolean;
 /**
  * Certifies an acceptance floor from labels you already have (your own traffic,
  * or a labeled set scored with your embedder), with the same test the cache
@@ -2504,13 +2517,13 @@ interface SemanticCacheOptions {
      */
     calibration?: SemanticCalibrationOptions;
 }
-declare function cosine(a: number[], b: number[]): number;
-declare function numericTokens(s: string): string[];
-declare function multisetEqual(a: string[], b: string[]): boolean;
-declare function words(s: string): string[];
-declare function negationCount(tokens: string[]): number;
+declare function cosine$1(a: number[], b: number[]): number;
+declare function numericTokens$1(s: string): string[];
+declare function multisetEqual$1(a: string[], b: string[]): boolean;
+declare function words$1(s: string): string[];
+declare function negationCount$1(tokens: string[]): number;
 /** True when two normalized queries agree on the facts an embedding tends to blur. */
-declare function keyTokensMatch(a: string, b: string): boolean;
+declare function keyTokensMatch$1(a: string, b: string): boolean;
 /**
  * In-memory reference implementation. A production build would back this with a
  * real vector store and metadata filters pushed down
@@ -2544,7 +2557,7 @@ declare class InMemorySemanticCache {
      * and labels nothing: without {@link lookup} and {@link observe} (the layer
      * calls both) the calibration never gets a label and never certifies.
      */
-    find(c: CanonicalRequest): Promise<SemanticHit | null>;
+    find(c: CanonicalRequest$1): Promise<SemanticHit | null>;
     /**
      * The best candidate that passes every hard filter, the similarity floor and
      * the fact guard. With `conAceptacion`, also the confidence floor (the path
@@ -2559,7 +2572,7 @@ declare class InMemorySemanticCache {
      * `agentic` picks the traffic segment: calibrations are kept apart for
      * single-shot and agentic requests.
      */
-    lookup(c: CanonicalRequest, opts?: {
+    lookup(c: CanonicalRequest$1, opts?: {
         agentic?: boolean;
     }): Promise<SemanticLookup>;
     /**
@@ -2607,7 +2620,7 @@ declare class InMemorySemanticCache {
     importCalibration(state: SemanticCalibrationState | string | unknown): void;
     private identidad;
     private estadoDe;
-    store(c: CanonicalRequest, answer: CachedAnswer): Promise<void>;
+    store(c: CanonicalRequest$1, answer: CachedAnswer): Promise<void>;
     /** Drop every record for a knowledge epoch (invalidation on re-index). */
     invalidateEpoch(knowledgeEpoch: string): number;
     get size(): number;
@@ -2710,12 +2723,12 @@ interface ResolverResult {
 }
 interface DeterministicResolver {
     readonly name: string;
-    try(c: CanonicalRequest): ResolverResult | null;
+    try(c: CanonicalRequest$1): ResolverResult | null;
 }
 declare class ResolverRegistry {
     private readonly resolvers;
     register(resolver: DeterministicResolver): this;
-    try(c: CanonicalRequest): ResolverResult | null;
+    try(c: CanonicalRequest$1): ResolverResult | null;
     get size(): number;
 }
 /**
@@ -2725,7 +2738,7 @@ declare class ResolverRegistry {
  */
 declare const arithmeticResolver: DeterministicResolver;
 /** Shunting-yard evaluation of a numeric expression. Returns null on any parse issue. */
-declare function evalArithmetic(expr: string): number | null;
+declare function evalArithmetic$1(expr: string): number | null;
 /** A registry seeded with the built-in safe resolvers. */
 declare function createDefaultResolvers(): ResolverRegistry;
 
@@ -2766,7 +2779,7 @@ declare class ExecutionRouter {
         classifier?: LocalClassifier;
         maxRounds?: number;
     });
-    classify(c: CanonicalRequest): RouteDecision;
+    classify(c: CanonicalRequest$1): RouteDecision;
 }
 
 /**
@@ -2999,7 +3012,7 @@ interface ConstraintPlan {
  * backend which *claims* support actually enforces every constraint — declared
  * support and empirical coverage are not the same thing.
  */
-declare function resolveConstraintBackend(model: string, schema: JsonSchema, backends: ConstraintBackend[]): ConstraintPlan;
+declare function resolveConstraintBackend$1(model: string, schema: JsonSchema, backends: ConstraintBackend[]): ConstraintPlan;
 /** A permissive backend used when the provider validates structured output natively. */
 declare function providerNativeBackend(isSupported?: (model: string, schema: JsonSchema) => boolean): ConstraintBackend;
 
@@ -3061,7 +3074,7 @@ interface CompressionPolicyInput {
  * Here we model the token side; latency/quality penalties are folded into
  * `compressorCostTokens` and `minimumNetTokens` by the caller.
  */
-declare function shouldCompress(input: CompressionPolicyInput): {
+declare function shouldCompress$1(input: CompressionPolicyInput): {
     compress: boolean;
     reason: string;
 };
@@ -3072,7 +3085,7 @@ declare function shouldCompress(input: CompressionPolicyInput): {
  * back to the ORIGINAL text — a compressor that drops a negation or a number is
  * worse than no compressor at all.
  */
-declare function withProtectedSpans(inner: Compressor): Compressor;
+declare function withProtectedSpans$1(inner: Compressor): Compressor;
 /** No-op compressor: the safe default until a real compressor sidecar is wired in. */
 declare const noopCompressor: Compressor;
 /**
@@ -3233,13 +3246,13 @@ interface RetrievalOutcome {
     keptCount: number;
 }
 /** Remove exact and near-duplicate docs by normalized text / hash. */
-declare function dedupe(docs: EvidenceDoc[]): EvidenceDoc[];
+declare function dedupe$1(docs: EvidenceDoc[]): EvidenceDoc[];
 /**
  * Adaptive-k: choose how many documents to keep based on the score distribution
  * rather than a fixed cutoff. When the top document dominates, keep fewer; when
  * scores are flat, keep up to the cap. This directly trims input tokens.
  */
-declare function adaptiveK(docs: EvidenceDoc[], opts?: {
+declare function adaptiveK$1(docs: EvidenceDoc[], opts?: {
     maxDocuments: number;
     minDocuments?: number;
 }): EvidenceDoc[];
@@ -3247,7 +3260,7 @@ declare function adaptiveK(docs: EvidenceDoc[], opts?: {
  * Execute a retrieval plan. NO_RETRIEVAL / TOOL_ACTION classes retrieve nothing.
  * Otherwise: retrieve -> dedupe -> rerank -> adaptive-k, bounded by maxRounds.
  */
-declare function executeRetrievalPlan(plan: RetrievalPlan, deps: {
+declare function executeRetrievalPlan$1(plan: RetrievalPlan, deps: {
     retriever?: Retriever;
     reranker?: Reranker;
 }): Promise<RetrievalOutcome>;
@@ -3617,10 +3630,10 @@ interface Provider {
  * `licenseKey: "   "` (an empty environment variable, a blank secret file) used
  * to tell the customer their key "does not verify" — there was no key.
  */
-type LicenseStatus = "active" | "grace" | "expired" | "invalid" | "revoked" | "stale" | "none";
+type LicenseStatus$1 = "active" | "grace" | "expired" | "invalid" | "revoked" | "stale" | "none";
 /** Decoded license token body (mirror of `@bivelio/protocol`'s LicensePayload,
  *  declared locally so the SDK stays free of a control-plane dependency). */
-interface LicenseTokenPayload {
+interface LicenseTokenPayload$1 {
     jti: string;
     org_id: string;
     plan: string;
@@ -3634,14 +3647,14 @@ interface LicenseTokenPayload {
     measure_expires_at?: number;
     measure_grace_days?: number;
 }
-interface ResolvedLicense {
-    status: LicenseStatus;
-    payload?: LicenseTokenPayload;
+interface ResolvedLicense$1 {
+    status: LicenseStatus$1;
+    payload?: LicenseTokenPayload$1;
     reason?: string;
 }
-declare const EMBEDDED_PUBLIC_KEY: string;
+declare const EMBEDDED_PUBLIC_KEY$1: string;
 /** Result of verifying a compact `head.body.sig` token's signature. */
-interface CompactVerification {
+interface CompactVerification$1 {
     /** True only if the signature is valid for the given public key. */
     ok: boolean;
     /** Decoded header (present when `ok`), e.g. `{ alg, typ, v }`. */
@@ -3664,7 +3677,7 @@ interface LicenseKeyset {
     defaultKid: string;
 }
 /** Narrow a verification key to a {@link LicenseKeyset} (vs a bare SPKI PEM string). */
-declare function isKeyset(k: string | LicenseKeyset): k is LicenseKeyset;
+declare function isKeyset$1(k: string | LicenseKeyset): k is LicenseKeyset;
 /**
  * Normalize a license key the way it arrives from the real world — ONCE, at the
  * entry point, never inside the verifier.
@@ -3689,7 +3702,7 @@ declare function isKeyset(k: string | LicenseKeyset): k is LicenseKeyset;
  * Anything INSIDE the key is left alone: an interior space is not wrapping, it
  * is a broken key, and {@link licenseKeyShape} reports it as `malformed`.
  */
-declare function normalizeLicenseKey(raw: string): string;
+declare function normalizeLicenseKey$1(raw: string): string;
 /**
  * The SHAPE of an already-normalized key, so the error message can tell apart
  * three problems that used to get the same text:
@@ -3704,9 +3717,9 @@ declare function normalizeLicenseKey(raw: string): string;
  * It is the SAME shape rule {@link verifyCompactSignature} enforces, so that "has
  * the shape" and "verification was attempted" mean the same thing.
  */
-type LicenseKeyShape = "empty" | "malformed" | "token";
+type LicenseKeyShape$1 = "empty" | "malformed" | "token";
 /** Classify a normalized key. See {@link LicenseKeyShape}. */
-declare function licenseKeyShape(normalizedKey: string): LicenseKeyShape;
+declare function licenseKeyShape$1(normalizedKey: string): LicenseKeyShape$1;
 /**
  * Verify the Ed25519 signature of any BV-SALA compact token
  * (`base64url(header).base64url(body).base64url(sig)`, sig over `${head}.${body}`)
@@ -3723,11 +3736,11 @@ declare function licenseKeyShape(normalizedKey: string): LicenseKeyShape;
  * the same answer to the same input, always; a caller that wants to tolerate
  * wrapping normalizes BEFORE calling.
  */
-declare function verifyCompactSignature(token: string, publicKey: string | LicenseKeyset): CompactVerification;
+declare function verifyCompactSignature$1(token: string, publicKey: string | LicenseKeyset): CompactVerification$1;
 /** Verify a token's signature and decode its payload. Does not check expiry. */
-declare function verifyLicenseToken(token: string, publicKey: string | LicenseKeyset): {
+declare function verifyLicenseToken$1(token: string, publicKey: string | LicenseKeyset): {
     signatureValid: boolean;
-    payload?: LicenseTokenPayload;
+    payload?: LicenseTokenPayload$1;
     reason?: string;
 };
 /**
@@ -3740,11 +3753,11 @@ declare function verifyLicenseToken(token: string, publicKey: string | LicenseKe
  *   expires_at < now <= +grace_days      → grace (still entitled)
  *   now > expires_at + grace_days        → expired
  */
-declare function deriveStatus(payload: {
+declare function deriveStatus$1(payload: {
     jti: string;
     expires_at: number;
     grace_days: number;
-}, nowSeconds: number, revoked?: ReadonlySet<string>): LicenseStatus;
+}, nowSeconds: number, revoked?: ReadonlySet<string>): LicenseStatus$1;
 /**
  * Verify + apply the grace policy → a resolved status. Mirrors what the issuing
  * control plane resolves for the same token. Bad signature / malformed
@@ -3753,10 +3766,10 @@ declare function deriveStatus(payload: {
  * A public entry point, so it normalizes like the others (gate and refresher):
  * the same key must resolve the same whichever way it comes in.
  */
-declare function resolveLicense(token: string, publicKey: string | LicenseKeyset, opts?: {
+declare function resolveLicense$1(token: string, publicKey: string | LicenseKeyset, opts?: {
     nowSeconds?: number;
     revoked?: ReadonlySet<string>;
-}): ResolvedLicense;
+}): ResolvedLicense$1;
 
 /**
  * Everything the pipeline depends on. All fields except `provider` and
@@ -3796,7 +3809,8 @@ interface SavingsLayerConfig {
     /**
      * @deprecated Renamed {@link semanticCacheStore} in 0.4.33, so that the store
      * and the per-request switch (`savings.semanticCache`) no longer share a name.
-     * It still works, with a one-time warning (silenced by `silenceWarnings`);
+     * It still works, with a one-time warning (silenced by `silenceWarnings` or
+     * `BVSALA_SILENCE_DEPRECATIONS=1`);
      * when both are given, `semanticCacheStore` wins. Removed in 0.5: see the 0.5
      * migration guide.
      */
@@ -3930,7 +3944,9 @@ interface SavingsLayerConfig {
      * build-embedded BiVelio key.
      *
      * @deprecated Has no effect in the published package, which always verifies
-     * against the embedded BiVelio key. Removed from the public type in 0.5.
+     * against the embedded BiVelio key; passing it there logs a one-time warning
+     * (silenced by `silenceWarnings` or `BVSALA_SILENCE_DEPRECATIONS=1`). Removed
+     * from the public type in 0.5: delete it from your config.
      */
     licensePublicKey?: string | LicenseKeyset;
     /**
@@ -4062,7 +4078,7 @@ interface SavingsLayerConfig {
      * requires a valid `licenseKey`. It is not a way to run the product for free.
      *
      * @deprecated No effect in the published package. Removed from the public type
-     * in 0.5.
+     * in 0.5: delete it from your config.
      */
     devUnlicensed?: boolean;
     /** Per-model cost models; falls back to `defaultCostModel`. */
@@ -4527,7 +4543,7 @@ declare const registrarTokenizadorExacto: typeof registerExactTokenizer;
  * `modelFamily` is derived from whichever id is used, for the same reason: it is
  * part of the identity of whoever answers.
  */
-declare function buildExactKey(c: CanonicalRequest, opciones?: {
+declare function buildExactKey$1(c: CanonicalRequest$1, opciones?: {
     servedModel?: string;
 }): string;
 /**
@@ -4567,7 +4583,7 @@ declare function buildExactKey(c: CanonicalRequest, opciones?: {
  * A caller who never set `savings.deferrable` must not be made to wait for one
  * who did.
  */
-declare function buildInflightKey(c: CanonicalRequest, opciones?: {
+declare function buildInflightKey$1(c: CanonicalRequest$1, opciones?: {
     servedModel?: string;
     deferrable?: boolean;
     toolDiscovery?: boolean;
@@ -4634,7 +4650,7 @@ interface Policy {
     sensitiveTopic: "self-harm" | "mental-health-crisis" | "medical-emergency" | null;
     reasons: string[];
 }
-declare function evaluatePolicy(c: CanonicalRequest): Policy;
+declare function evaluatePolicy$1(c: CanonicalRequest$1): Policy;
 
 /**
  * A LOCAL EMBEDDING FUNCTION — no network, no API key, no per-call cost.
@@ -4734,7 +4750,7 @@ declare function mergeDelta(state: ConversationState, delta: MemoryDelta): Conve
  * relevant, non-empty state is serialized, then the last `rawTurns` messages,
  * then the current message.
  */
-declare function projectContext(opts: {
+declare function projectContext$1(opts: {
     state: ConversationState;
     history: ChatMessage[];
     current: ChatMessage;
@@ -4772,7 +4788,7 @@ interface CompactRowsOptions {
 }
 declare function encodeCompactRows(value: unknown, options?: CompactRowsOptions): string;
 /** Return shared column names iff every element is a flat, scalar-valued object with identical keys. */
-declare function uniformColumns(arr: unknown[]): string[] | null;
+declare function uniformColumns$1(arr: unknown[]): string[] | null;
 /**
  * The instruction a model needs to read the compact encoder. Kept short on purpose — this text
  * is the per-request overhead the selector must amortize before it wins.
@@ -4984,7 +5000,7 @@ interface OpenAICompatibleOptions {
  * incumple la segunda y el proveedor responde 400. No es un fallo del cliente:
  * es una restricción de OpenAI que JSON Schema no tiene.
  */
-declare function isStrictCompatible(schema: unknown): boolean;
+declare function isStrictCompatible$1(schema: unknown): boolean;
 /**
  * Decides the id that travels on the wire. Explicit option wins; otherwise the
  * endpoint decides: OpenAI/Azure and Google's own Gemini API get the bare id,
@@ -5246,7 +5262,7 @@ declare class GoogleProvider implements Provider {
  * Every stage records why it did what it did, so a SavingsReport can be audited
  * and so ablations can attribute savings to a specific module.
  */
-declare class TraceCollector {
+declare class TraceCollector$1 {
     private readonly events;
     private readonly start;
     private readonly now;
@@ -5280,14 +5296,14 @@ declare class LicenseError extends Error {
 }
 
 /** Decoded revocation-list body (mirror of @bivelio/protocol's RevocationListPayload). */
-interface RevocationListBody {
+interface RevocationListBody$1 {
     v: number;
     asOf: number;
     seq: number;
     revoked: string[];
     iss?: string;
 }
-interface RevocationListVerification {
+interface RevocationListVerification$1 {
     /** True only if signature + typ + monotonic-seq + skew all pass. */
     ok: boolean;
     /** List revision (monotonic). -1 when not ok. */
@@ -5306,11 +5322,11 @@ interface RevocationListVerification {
  * ANY failure returns `ok:false` with an empty set; the poller then keeps its
  * sticky last-known-good (fail-open), never dropping known revocations.
  */
-declare function verifyRevocationList(token: string, publicKey: string | LicenseKeyset, opts?: {
+declare function verifyRevocationList$1(token: string, publicKey: string | LicenseKeyset, opts?: {
     minSeq?: number;
     nowSeconds?: number;
     maxSkewSeconds?: number;
-}): RevocationListVerification;
+}): RevocationListVerification$1;
 /**
  * The SDK's live, sticky, monotonic view of the revocation set. It only ever
  * GROWS (a jti, once seen revoked, stays revoked for the process lifetime) and
@@ -5318,7 +5334,7 @@ declare function verifyRevocationList(token: string, publicKey: string | License
  * list can never un-revoke a license. The live gate reads {@link snapshot} on
  * every request; the poller feeds it via {@link apply}.
  */
-declare class RevocationSnapshot {
+declare class RevocationSnapshot$1 {
     private _seq;
     private _asOf;
     private _lastContactAt;
@@ -5346,9 +5362,9 @@ declare class RevocationSnapshot {
 }
 
 /** A resolved gate that also exposes overall status + a refresh horizon. */
-interface ResolvedGate extends LicenseGate {
+interface ResolvedGate$1 extends LicenseGate {
     isActive(): boolean;
-    status(): LicenseStatus;
+    status(): LicenseStatus$1;
     /**
      * Why the key does not open, when it does not; `undefined` when it verified.
      * Under `status() === "invalid"` it tells a key that does NOT EVEN HAVE THE
@@ -5375,8 +5391,8 @@ interface ResolvedGate extends LicenseGate {
  * The offline path passes a fresh, never-updated snapshot (live clock, zero
  * network); the online path passes a snapshot a {@link RevocationPoller} feeds.
  */
-declare function liveGateFromKey(licenseKey: string, publicKey: string | LicenseKeyset, opts: {
-    revocation: RevocationSnapshot;
+declare function liveGateFromKey$1(licenseKey: string, publicKey: string | LicenseKeyset, opts: {
+    revocation: RevocationSnapshot$1;
     now?: () => number;
     /** Online staleness ceiling, seconds. If the gate goes this long without a
      *  confirmed authorized heartbeat, it stops granting (closes the block-egress
@@ -5384,7 +5400,7 @@ declare function liveGateFromKey(licenseKey: string, publicKey: string | License
     maxStalenessSeconds?: number;
     /** Freshness anchor (unix seconds); defaults to construction time (boot). */
     startedAt?: number;
-}): ResolvedGate;
+}): ResolvedGate$1;
 
 /**
  * Build the SDK's structural {@link import("../contracts/types.js").LicenseGate}
@@ -5399,9 +5415,9 @@ declare function liveGateFromKey(licenseKey: string, publicKey: string | License
  * Online revocation is added by pairing {@link liveGateFromKey} with a
  * poller-fed snapshot, which `createSavingsLayer` wires up for you.
  */
-declare function gateFromKey(licenseKey: string, publicKey: string | LicenseKeyset, now?: () => number): ResolvedGate;
+declare function gateFromKey$1(licenseKey: string, publicKey: string | LicenseKeyset, now?: () => number): ResolvedGate$1;
 
-type RevocationPollEvent = {
+type RevocationPollEvent$1 = {
     type: "applied";
     seq: number;
     size: number;
@@ -5417,14 +5433,14 @@ type RevocationPollEvent = {
 } | {
     type: "no-fetch";
 };
-interface RevocationPollerOptions {
+interface RevocationPollerOptions$1 {
     /** Absolute URL of GET /licenses/revocations. */
     url: string;
     /** SPKI PEM (or a kid-addressed {@link LicenseKeyset}) used to verify the signed
      *  list — the same key/keyset that verifies license tokens. */
     publicKeyPem: string | LicenseKeyset;
     /** The sticky snapshot to feed. */
-    snapshot: RevocationSnapshot;
+    snapshot: RevocationSnapshot$1;
     /** Anchor cadence to the license refresh horizon (unix seconds). */
     getRefreshAfter?: () => number | undefined;
     /** Injectable clock (unix seconds). */
@@ -5440,7 +5456,7 @@ interface RevocationPollerOptions {
     /** Injectable RNG in [0,1) for jitter. Default Math.random. */
     random?: () => number;
     /** Optional observer (telemetry/tests). */
-    onEvent?: (e: RevocationPollEvent) => void;
+    onEvent?: (e: RevocationPollEvent$1) => void;
     /**
      * Silencia los avisos por consola. Por defecto están ENCENDIDOS, y ese defecto
      * es la corrección: el sondeo es fail-open, así que un call-home roto no rompe
@@ -5462,7 +5478,7 @@ interface RevocationPollerOptions {
  * failure it backs off exponentially (a revocation can't land during an outage
  * anyway), capped, still jittered, never below the floor.
  */
-declare function computeNextDelay(opts: {
+declare function computeNextDelay$1(opts: {
     refreshAfter?: number;
     nowSeconds: number;
     consecutiveFailures: number;
@@ -5472,7 +5488,7 @@ declare function computeNextDelay(opts: {
     jitterRatio: number;
     random?: () => number;
 }): number;
-declare class RevocationPoller {
+declare class RevocationPoller$1 {
     private readonly opts;
     private timer;
     private controller;
@@ -5483,7 +5499,7 @@ declare class RevocationPoller {
     private lastEtag;
     /** 304 seguidos; al llegar al tope se fuerza una descarga firmada. */
     private consecutive304;
-    constructor(opts: RevocationPollerOptions);
+    constructor(opts: RevocationPollerOptions$1);
     private now;
     private resolveFetch;
     /**
@@ -5517,7 +5533,7 @@ declare class RevocationPoller {
     stop(): void;
 }
 
-interface UsageEmitterOptions {
+interface UsageEmitterOptions$1 {
     /** Full ingest URL, e.g. `https://savings.bivelio.com/api/metering/usage`. */
     url: string;
     /** Service-account key (`bvk_…`) sent as a Bearer token; the server derives the org from it. */
@@ -5568,7 +5584,7 @@ interface UsageEmitterOptions {
  * neither block nor crash the customer's request path. The buffer is hard-capped
  * so a sustained outage can never grow memory without bound.
  */
-declare class UsageEmitter {
+declare class UsageEmitter$1 {
     private readonly options;
     private readonly now;
     private readonly flushIntervalMs;
@@ -5586,7 +5602,7 @@ declare class UsageEmitter {
      * only confuse whoever reads the logs.
      */
     private fallosSeguidos;
-    constructor(options: UsageEmitterOptions);
+    constructor(options: UsageEmitterOptions$1);
     /** Set the resolved seat identity (derivation is async; records emitted before
      *  it resolves are stamped at flush time, so none are lost). */
     setSeat(seatId: string | undefined, ci: boolean): void;
@@ -5627,17 +5643,17 @@ declare class UsageEmitter {
 }
 
 /** True when running in a CI / ephemeral environment. */
-declare function detectCi(): boolean;
+declare function detectCi$1(): boolean;
 /**
  * Derive the machine seat id for a service-account key. Resolves to `undefined`
  * when no machine fingerprint is available (e.g. a browser) — the caller then
  * reports no seatId and the server counts the request under an "unknown" seat.
  * The id (`m-<32 hex>`) matches the control plane's identity charset.
  */
-declare function deriveSeatId(serviceAccountKey: string): Promise<string | undefined>;
+declare function deriveSeatId$1(serviceAccountKey: string): Promise<string | undefined>;
 
 /** Fully-resolved, non-optional dependency set the pipeline runs against. */
-interface ResolvedDeps {
+interface ResolvedDeps$1 {
     exactCache: ExactCache;
     semanticCache: InMemorySemanticCache | undefined;
     singleflight: Singleflight;
@@ -5653,9 +5669,9 @@ interface ResolvedDeps {
  * in-memory, dependency-free implementation, so `createSavingsLayer({ provider,
  * tokenizer })` is a working layer, and each piece can be replaced à la carte.
  */
-declare function resolveDependencies(config: SavingsLayerConfig): ResolvedDeps;
+declare function resolveDependencies$1(config: SavingsLayerConfig): ResolvedDeps$1;
 
-declare const DEFAULT_MAX_STALENESS_SECONDS: number;
+declare const DEFAULT_MAX_STALENESS_SECONDS$1: number;
 /** The public handle returned by {@link createSavingsLayer}. */
 interface SavingsLayer {
     generate<T = unknown>(request: SavingsRequest): Promise<SavingsResult<T>>;
@@ -6116,6 +6132,143 @@ declare function toCsv(rows: readonly Readonly<Record<string, CsvValue>>[], opti
     columns?: readonly string[];
 }): string;
 
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+type CanonicalRequest = CanonicalRequest$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const canonicalize: typeof canonicalize$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const modelFamilyOf: typeof modelFamilyOf$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const normalizeText: typeof normalizeText$1;
+/** @deprecated Internal helper, removed from the public API in 0.5. Use `createHash("sha256").update(text).digest("hex")` from `node:crypto`. */
+declare const sha256: typeof sha256$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const stableStringify: typeof stableStringify$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const buildExactKey: typeof buildExactKey$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const buildInflightKey: typeof buildInflightKey$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type CompactVerification = CompactVerification$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const EMBEDDED_PUBLIC_KEY: typeof EMBEDDED_PUBLIC_KEY$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type LicenseKeyShape = LicenseKeyShape$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type LicenseStatus = LicenseStatus$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type LicenseTokenPayload = LicenseTokenPayload$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type ResolvedGate = ResolvedGate$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type ResolvedLicense = ResolvedLicense$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationListBody = RevocationListBody$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationListVerification = RevocationListVerification$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationPollEvent = RevocationPollEvent$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const RevocationPoller: typeof RevocationPoller$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationPoller = RevocationPoller$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationPollerOptions = RevocationPollerOptions$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const RevocationSnapshot: typeof RevocationSnapshot$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationSnapshot = RevocationSnapshot$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const computeNextDelay: typeof computeNextDelay$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const deriveStatus: typeof deriveStatus$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const gateFromKey: typeof gateFromKey$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const isKeyset: typeof isKeyset$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const licenseKeyShape: typeof licenseKeyShape$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const liveGateFromKey: typeof liveGateFromKey$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const normalizeLicenseKey: typeof normalizeLicenseKey$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const resolveLicense: typeof resolveLicense$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const verifyCompactSignature: typeof verifyCompactSignature$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const verifyLicenseToken: typeof verifyLicenseToken$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const verifyRevocationList: typeof verifyRevocationList$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const UsageEmitter: typeof UsageEmitter$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type UsageEmitter = UsageEmitter$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type UsageEmitterOptions = UsageEmitterOptions$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const deriveSeatId: typeof deriveSeatId$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const detectCi: typeof detectCi$1;
+/** @deprecated Internal constant, removed from the public API in 0.5. The default is documented on `licenseRevocation.maxStalenessSeconds`; set that option to change it. */
+declare const DEFAULT_MAX_STALENESS_SECONDS: typeof DEFAULT_MAX_STALENESS_SECONDS$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+type ResolvedDeps = ResolvedDeps$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const resolveDependencies: typeof resolveDependencies$1;
+/** @deprecated Internal constant of the reference-commission rule, removed from the public API in 0.5: no replacement (the rule is described in the documentation, not frozen as API). */
+declare const REFERENCE_MAX_AGE_MS: typeof REFERENCE_MAX_AGE_MS$1;
+/** @deprecated Internal constant of the reference-commission rule, removed from the public API in 0.5: no replacement (the rule is described in the documentation, not frozen as API). */
+declare const REFERENCE_MESSAGE_ALLOWANCE: typeof REFERENCE_MESSAGE_ALLOWANCE$1;
+/** @deprecated Internal constant of the reference-commission rule, removed from the public API in 0.5: no replacement (the rule is described in the documentation, not frozen as API). */
+declare const REFERENCE_OUTPUT_SHARE: typeof REFERENCE_OUTPUT_SHARE$1;
+/** @deprecated Internal ledger of the pipeline, removed from the public API in 0.5. Read the four ledgers from the `SavingsReport` each call returns. */
+declare const SavingsLedger: typeof SavingsLedger$1;
+/** @deprecated Internal ledger of the pipeline, removed from the public API in 0.5. Read the four ledgers from the `SavingsReport` each call returns. */
+type SavingsLedger = SavingsLedger$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5. Read the stage traces from `report.traces`. */
+declare const TraceCollector: typeof TraceCollector$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5. Read the stage traces from `report.traces`. */
+type TraceCollector = TraceCollector$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const adaptiveK: typeof adaptiveK$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const dedupe: typeof dedupe$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const executeRetrievalPlan: typeof executeRetrievalPlan$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const cosine: typeof cosine$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const keyTokensMatch: typeof keyTokensMatch$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const multisetEqual: typeof multisetEqual$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const negationCount: typeof negationCount$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const numericTokens: typeof numericTokens$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const words: typeof words$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const sameAnswer: typeof sameAnswer$1;
+/** @deprecated Internal helper, removed from the public API in 0.5. Arithmetic questions are still answered locally by `arithmeticResolver` / `createDefaultResolvers()`. */
+declare const evalArithmetic: typeof evalArithmetic$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const evaluatePolicy: typeof evaluatePolicy$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const isStrictCompatible: typeof isStrictCompatible$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const projectContext: typeof projectContext$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const resolveConstraintBackend: typeof resolveConstraintBackend$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const shouldCompress: typeof shouldCompress$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const withProtectedSpans: typeof withProtectedSpans$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const uniformColumns: typeof uniformColumns$1;
+/** @deprecated Internal helper, removed from the public API in 0.5. Use `crypto.randomUUID()`. */
+declare const randomId: typeof randomId$1;
+
 /**
  * bivelio-savings-layer (BV-SALA)
  * ---------------------------------------------------------------------------