@omnicross/core 0.1.2 → 0.1.3

package/dist/ports/usage-event-store.d.cts

@@ -1,4 +1,4 @@
-import { UsageEventInput, UsageDateRange, UsageTotals, ModelUsageRow, ApiKeyUsageRow, MessageUsageRow, SessionCacheStats } from '@omnicross/contracts/usage-stats-types';
+import { UsageEventInput, UsageDateRange, UsageTotals, ModelUsageRow, ApiKeyUsageRow, UsageTimeBucket, UsageTimeSeriesBucket, MessageUsageRow, SessionCacheStats } from '@omnicross/contracts/usage-stats-types';
 
 /**
  * `UsageEventStore` — core-owned port for usage-event persistence + aggregation.
@@ -20,6 +20,31 @@ interface UsageEventStore {
     getByModel(range: UsageDateRange): Promise<ModelUsageRow[]>;
     /** Per-API-key breakdown over a date range. */
     getByApiKey(range: UsageDateRange): Promise<ApiKeyUsageRow[]>;
+    /**
+     * ONE scan of a single key's events (`ts < endTs`, EXCLUSIVE) summing its
+     * `costUsd` into all three windows at once: `totalUsd` (whole history),
+     * `dailyUsd` (`ts >= dayStartTs`) and `weeklyUsd` (`ts >= weekStartTs`). Used by
+     * the outbound key-policy spend tracker to LAZILY seed a key on first use (once
+     * per newly-seen key, NOT per request — a single pass, not three). A key with
+     * no attributed events yields all zeros.
+     */
+    getSpendByKey(query: {
+        apiKeyId: string;
+        dayStartTs: number;
+        weekStartTs: number;
+        endTs: number;
+    }): Promise<{
+        totalUsd: number;
+        dailyUsd: number;
+        weeklyUsd: number;
+    }>;
+    /**
+     * Time-series aggregation over `range`, bucketed at `bucket` granularity using
+     * the store host's LOCAL-time boundaries. EVERY bucket in the range is
+     * returned (empty ones zero-filled), ascending by `bucketStartTs`; an empty
+     * range (`startTs >= endTs`) returns `[]`.
+     */
+    getTimeSeries(range: UsageDateRange, bucket: UsageTimeBucket): Promise<UsageTimeSeriesBucket[]>;
     /** Message-level rows for one session. */
     getMessagesForSession(sessionId: string): Promise<MessageUsageRow[]>;
     /** Cumulative cache hit/miss stats for one session. */

package/dist/ports/usage-event-store.d.ts

@@ -1,4 +1,4 @@
-import { UsageEventInput, UsageDateRange, UsageTotals, ModelUsageRow, ApiKeyUsageRow, MessageUsageRow, SessionCacheStats } from '@omnicross/contracts/usage-stats-types';
+import { UsageEventInput, UsageDateRange, UsageTotals, ModelUsageRow, ApiKeyUsageRow, UsageTimeBucket, UsageTimeSeriesBucket, MessageUsageRow, SessionCacheStats } from '@omnicross/contracts/usage-stats-types';
 
 /**
  * `UsageEventStore` — core-owned port for usage-event persistence + aggregation.
@@ -20,6 +20,31 @@ interface UsageEventStore {
     getByModel(range: UsageDateRange): Promise<ModelUsageRow[]>;
     /** Per-API-key breakdown over a date range. */
     getByApiKey(range: UsageDateRange): Promise<ApiKeyUsageRow[]>;
+    /**
+     * ONE scan of a single key's events (`ts < endTs`, EXCLUSIVE) summing its
+     * `costUsd` into all three windows at once: `totalUsd` (whole history),
+     * `dailyUsd` (`ts >= dayStartTs`) and `weeklyUsd` (`ts >= weekStartTs`). Used by
+     * the outbound key-policy spend tracker to LAZILY seed a key on first use (once
+     * per newly-seen key, NOT per request — a single pass, not three). A key with
+     * no attributed events yields all zeros.
+     */
+    getSpendByKey(query: {
+        apiKeyId: string;
+        dayStartTs: number;
+        weekStartTs: number;
+        endTs: number;
+    }): Promise<{
+        totalUsd: number;
+        dailyUsd: number;
+        weeklyUsd: number;
+    }>;
+    /**
+     * Time-series aggregation over `range`, bucketed at `bucket` granularity using
+     * the store host's LOCAL-time boundaries. EVERY bucket in the range is
+     * returned (empty ones zero-filled), ascending by `bucketStartTs`; an empty
+     * range (`startTs >= endTs`) returns `[]`.
+     */
+    getTimeSeries(range: UsageDateRange, bucket: UsageTimeBucket): Promise<UsageTimeSeriesBucket[]>;
     /** Message-level rows for one session. */
     getMessagesForSession(sessionId: string): Promise<MessageUsageRow[]>;
     /** Cumulative cache hit/miss stats for one session. */

package/dist/ports.d.cts

@@ -5,7 +5,7 @@ export { ProviderConfigSource } from './ports/provider-config-source.cjs';
 export { UsageEventStore } from './ports/usage-event-store.cjs';
 export { WebSearchBackend } from './ports/web-search-backend.cjs';
 export { UsageRecorderImport as UsageSink } from './provider-proxy/types.cjs';
-export { OutboundKeyDb as OutboundCredentialStore } from './outbound-api/types.cjs';
+export { O as OutboundCredentialStore } from './types-aBFFXoBz.cjs';
 import '@omnicross/contracts/pricing-types';
 import '@omnicross/contracts/llm-config';
 import './transformer/types.cjs';
@@ -20,4 +20,10 @@ import './completion/ApiKeyPoolService.cjs';
 import './pipeline/AuthSource.cjs';
 import './pipeline/SubscriptionAuthSource.cjs';
 import './pipeline/SubscriptionAuthStrategy.cjs';
+import '@omnicross/contracts/account-tokens-types';
+import '@omnicross/contracts/audit-types';
+import '@omnicross/contracts/billing-types';
+import '@omnicross/contracts/health-logging-types';
+import '@omnicross/contracts/voucher-types';
+import '@omnicross/contracts/webhook-types';
 import './ProviderProxy-CnMQYN59.cjs';

package/dist/ports.d.ts

@@ -5,7 +5,7 @@ export { ProviderConfigSource } from './ports/provider-config-source.js';
 export { UsageEventStore } from './ports/usage-event-store.js';
 export { WebSearchBackend } from './ports/web-search-backend.js';
 export { UsageRecorderImport as UsageSink } from './provider-proxy/types.js';
-export { OutboundKeyDb as OutboundCredentialStore } from './outbound-api/types.js';
+export { O as OutboundCredentialStore } from './types-6OUY_xfA.js';
 import '@omnicross/contracts/pricing-types';
 import '@omnicross/contracts/llm-config';
 import './transformer/types.js';
@@ -20,4 +20,10 @@ import './completion/ApiKeyPoolService.js';
 import './pipeline/AuthSource.js';
 import './pipeline/SubscriptionAuthSource.js';
 import './pipeline/SubscriptionAuthStrategy.js';
+import '@omnicross/contracts/account-tokens-types';
+import '@omnicross/contracts/audit-types';
+import '@omnicross/contracts/billing-types';
+import '@omnicross/contracts/health-logging-types';
+import '@omnicross/contracts/voucher-types';
+import '@omnicross/contracts/webhook-types';
 import './ProviderProxy-C-xqrkKi.js';

package/dist/provider-proxy/ProviderProxy.cjs

@@ -1,40 +1,47 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
 
-var _chunkSN3YWBX7cjs = require('../chunk-SN3YWBX7.cjs');
-require('../chunk-SPVWWUHX.cjs');
+var _chunk2FMI2B6Vcjs = require('../chunk-2FMI2B6V.cjs');
 require('../chunk-HQP3K7PU.cjs');
 require('../chunk-FZ46M34D.cjs');
 require('../chunk-46ZIFWYG.cjs');
-require('../chunk-GBHYAGX3.cjs');
 require('../chunk-3OPYJG76.cjs');
-require('../chunk-UYPEN5XE.cjs');
-require('../chunk-7YN22L2H.cjs');
-require('../chunk-2DCNB7DF.cjs');
+require('../chunk-FFALUUZZ.cjs');
 require('../chunk-C72S6TTV.cjs');
 require('../chunk-DWKQZ2SK.cjs');
 require('../chunk-4VAVYUZS.cjs');
+require('../chunk-7YN22L2H.cjs');
+require('../chunk-2DCNB7DF.cjs');
 require('../chunk-EYZYXJTJ.cjs');
 require('../chunk-YMFAJFQT.cjs');
-require('../chunk-XBSYYZIY.cjs');
+require('../chunk-3QOSDDNI.cjs');
+require('../chunk-GBHYAGX3.cjs');
+require('../chunk-RPII3E6Z.cjs');
+require('../chunk-6RPZADX3.cjs');
+require('../chunk-QWBWGODS.cjs');
+require('../chunk-NYUNU75A.cjs');
+require('../chunk-VQY5W4YW.cjs');
+require('../chunk-Y6OM7EV7.cjs');
+require('../chunk-SVNDB62D.cjs');
 require('../chunk-R3HK6R4B.cjs');
+require('../chunk-AEOZIDEB.cjs');
+require('../chunk-L74VDN4A.cjs');
 require('../chunk-KUU2RNG6.cjs');
-require('../chunk-LKZJEL6E.cjs');
+require('../chunk-Q27JY5RG.cjs');
 require('../chunk-QXD4MV2X.cjs');
-require('../chunk-NYUNU75A.cjs');
-require('../chunk-N3V2J5ZO.cjs');
-require('../chunk-SVNDB62D.cjs');
 require('../chunk-A2YMUCBT.cjs');
-require('../chunk-G2FUJNA2.cjs');
+require('../chunk-SVXC36MU.cjs');
 require('../chunk-QBZJ7P2T.cjs');
+require('../chunk-4IH4EL7M.cjs');
 require('../chunk-SUEGJ75D.cjs');
+require('../chunk-S6JGLF3G.cjs');
 require('../chunk-RSJ3TWJQ.cjs');
 require('../chunk-YGXJGRFI.cjs');
 require('../chunk-NZYN7C3P.cjs');
-require('../chunk-V5KPWNYX.cjs');
-require('../chunk-6VIXXLMX.cjs');
+require('../chunk-JMJBSACD.cjs');
 require('../chunk-GMMT7RVN.cjs');
+require('../chunk-UNEFIWXI.cjs');
 
 
 
-exports.ProviderProxy = _chunkSN3YWBX7cjs.ProviderProxy; exports.isLoopbackAddress = _chunkSN3YWBX7cjs.isLoopbackAddress;
+exports.ProviderProxy = _chunk2FMI2B6Vcjs.ProviderProxy; exports.isLoopbackAddress = _chunk2FMI2B6Vcjs.isLoopbackAddress;

package/dist/provider-proxy/ProviderProxy.js

@@ -1,39 +1,46 @@
 import {
   ProviderProxy,
   isLoopbackAddress
-} from "../chunk-2FEVTJWG.js";
-import "../chunk-QOCNX236.js";
+} from "../chunk-4DECIFU7.js";
 import "../chunk-VVEHS2LI.js";
 import "../chunk-46RLHI7D.js";
 import "../chunk-G2UTNSGU.js";
-import "../chunk-MZNPGW5Q.js";
 import "../chunk-DK4A7DLE.js";
-import "../chunk-O466Y272.js";
-import "../chunk-C7PSERMH.js";
-import "../chunk-5HTVET6E.js";
+import "../chunk-MQNDWYPN.js";
 import "../chunk-Z7LUNECE.js";
 import "../chunk-ZJZAOKI7.js";
 import "../chunk-FTQ7IQUC.js";
+import "../chunk-C7PSERMH.js";
+import "../chunk-5HTVET6E.js";
 import "../chunk-7VU7V2E4.js";
 import "../chunk-ZLX3KGXX.js";
-import "../chunk-MNYKI4CI.js";
+import "../chunk-CWM2ZDU5.js";
+import "../chunk-MZNPGW5Q.js";
+import "../chunk-XTEI64OU.js";
+import "../chunk-XX6NQJMA.js";
+import "../chunk-IAXWICZU.js";
+import "../chunk-5ERIZW3D.js";
+import "../chunk-5ENKBSWO.js";
+import "../chunk-N5QFKSDO.js";
+import "../chunk-AVYJ4YBN.js";
 import "../chunk-DRWHTIIZ.js";
+import "../chunk-WNY4WMRF.js";
+import "../chunk-TKJMZBAH.js";
 import "../chunk-JO5NLTLY.js";
-import "../chunk-PXUJF5HS.js";
+import "../chunk-ZY6KU6P3.js";
 import "../chunk-JWC6APFQ.js";
-import "../chunk-5ERIZW3D.js";
-import "../chunk-74TMJA7Z.js";
-import "../chunk-AVYJ4YBN.js";
 import "../chunk-H5JUT3KV.js";
-import "../chunk-3MEACFK3.js";
+import "../chunk-CZHZGRU7.js";
 import "../chunk-AQ5TNQB7.js";
+import "../chunk-XEKD23J5.js";
 import "../chunk-5ZQBEOMD.js";
+import "../chunk-BO4RFWBR.js";
 import "../chunk-Z7Y2NPHY.js";
 import "../chunk-S4WBV25P.js";
 import "../chunk-CDHS2QDC.js";
-import "../chunk-745DV5FL.js";
-import "../chunk-E3WHL7CO.js";
+import "../chunk-Y7FO65VT.js";
 import "../chunk-FMOBD2OQ.js";
+import "../chunk-HUZZZ3JL.js";
 export {
   ProviderProxy,
   isLoopbackAddress

package/dist/provider-proxy/identity/SubscriptionIdentityStore.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkRPII3E6Zcjs = require('../../chunk-RPII3E6Z.cjs');
+require('../../chunk-6RPZADX3.cjs');
+
+
+
+
+
+
+exports.CC_HEADER_TTL_MS = _chunkRPII3E6Zcjs.CC_HEADER_TTL_MS; exports.SubscriptionIdentityStore = _chunkRPII3E6Zcjs.SubscriptionIdentityStore; exports.__resetSharedIdentityStoreForTests = _chunkRPII3E6Zcjs.__resetSharedIdentityStoreForTests; exports.getSharedIdentityStore = _chunkRPII3E6Zcjs.getSharedIdentityStore; exports.setSharedIdentityStore = _chunkRPII3E6Zcjs.setSharedIdentityStore;

package/dist/provider-proxy/identity/SubscriptionIdentityStore.d.cts

@@ -0,0 +1,121 @@
+/**
+ * SubscriptionIdentityStore — the per-account client-identity capture/freeze/replay
+ * store for claude-subscription outbound traffic (subscription-client-fingerprint
+ * #7, design D1/D4/D5/D7).
+ *
+ * Shaped like the existing in-memory `SubscriptionAccountHealth` tracker: an
+ * in-memory `Map`, an injectable `now` clock, NO external deps. It is keyed by an
+ * opaque `providerId + '\0' + accountId` string — core never learns "account"
+ * semantics (exactly the health-tracker precedent), and there is NO
+ * `@omnicross/subscriptions` import. It carries NO token/secret: the capture
+ * whitelist + `sanitizeFrozenHeaders` exclude `authorization`/`x-api-key`/`cookie`
+ * at BOTH ingress and store-normalize.
+ *
+ * Freeze/replay model (D4 — never fabricate):
+ *  - The FIRST captured fingerprint set for an account is FROZEN; every later
+ *    outbound request for that account REPLAYS that frozen set → a stable
+ *    per-account identity. Stainless headers are frozen-stable forever; the
+ *    non-stainless (CC) headers refresh on a 7-day TTL from a newer real
+ *    observation (P2, `refreshNonStainless`).
+ *  - Values are ONLY ever REAL captured client values — nothing here invents a
+ *    `x-stainless-*`. An un-captured account replays NOTHING (the caller then
+ *    applies at most the operator UA baseline).
+ *
+ * Persistence (P2, D5): OPTIONAL. When a persistence port is installed
+ * (`setPersistence`), a first-seen freeze / TTL refresh is written through to the
+ * account entry (additive NON-secret metadata) so the identity survives restart;
+ * at boot the daemon `seed()`s the store from the persisted entries. In-memory-only
+ * (no port) is the P1 default — a real client re-captures after restart.
+ *
+ * @module provider-proxy/identity/SubscriptionIdentityStore
+ */
+/** A frozen per-account client identity (the captured fingerprint headers). */
+interface FrozenIdentity {
+    /** The captured fingerprint headers (lowercased keys; token/secret excluded). */
+    headers: Record<string, string>;
+    /** Epoch ms of the freeze (or last TTL refresh). */
+    capturedAt: number;
+}
+/**
+ * Write-through persistence port (P2, D5). The store calls `persist` on a
+ * first-seen freeze / TTL refresh; the daemon implementation writes the identity
+ * onto the account entry. Fire-and-forget — the store swallows any throw so the
+ * hot path is never affected. Core defines the port; the daemon supplies it (the
+ * `setUpstreamProxyResolver` / `setWebhookSink` precedent — no daemon import).
+ */
+interface IdentityPersistencePort {
+    persist(providerId: string, accountId: string, identity: FrozenIdentity): void;
+}
+/** The CC-header (non-stainless) refresh TTL — 7 days (design D6/P2). */
+declare const CC_HEADER_TTL_MS: number;
+/** Constructor knobs (all optional). */
+interface SubscriptionIdentityStoreOptions {
+    /** Injectable clock (ms). Default `Date.now`. */
+    now?: () => number;
+    /** Whether capture/replay engages. Default `false` (byte-identical outbound). */
+    enabled?: boolean;
+    /** Operator UA baseline applied ONLY when nothing was captured (piece 4). */
+    ua?: string;
+    /** The CC-header refresh TTL (ms). Default {@link CC_HEADER_TTL_MS}. */
+    ccHeaderTtlMs?: number;
+}
+declare class SubscriptionIdentityStore {
+    private readonly identities;
+    private readonly now;
+    private enabled;
+    private ua;
+    private ccHeaderTtlMs;
+    private persistence;
+    constructor(opts?: SubscriptionIdentityStoreOptions);
+    /** Whether capture/replay is engaged (config flag). */
+    isEnabled(): boolean;
+    /** The operator UA baseline (piece 4), or undefined when unset. */
+    uaBaseline(): string | undefined;
+    /**
+     * Re-apply config to the LIVE shared instance (bootstrap, mirroring the health
+     * tracker's `configure`). Only defined fields override; `ua: null` clears the
+     * baseline.
+     */
+    configure(opts: {
+        enabled?: boolean;
+        ua?: string | null;
+    }): void;
+    /** Install (or clear) the write-through persistence port (P2). */
+    setPersistence(port: IdentityPersistencePort | null): void;
+    /**
+     * Boot seed (P2, D5): install a PERSISTED identity for an account, but NEVER
+     * over a live in-memory capture (a re-captured identity from this session wins).
+     * A no-op for an empty/absent identity. Does NOT write back through the port.
+     */
+    seed(providerId: string, accountId: string, identity: FrozenIdentity | undefined): void;
+    /**
+     * Capture a real client's fingerprint headers for an account. First-seen ⇒
+     * FREEZE the whole (sanitized) bag. Already-frozen ⇒ within the TTL, no change
+     * (stable identity); past the TTL, refresh the NON-stainless headers from the
+     * new observation while keeping stainless frozen-stable (P2). An empty/absent
+     * account id or an empty sanitized bag is a no-op (so an account with no
+     * fingerprint headers never freezes an empty identity → the caller falls back
+     * to the UA baseline). Fires the persistence port on a freeze/refresh.
+     */
+    capture(providerId: string, accountId: string, incoming: Record<string, string>, now?: number): void;
+    /**
+     * The frozen identity headers for an account, or `undefined` when none is
+     * frozen (or the frozen set is empty). Returns a COPY (the caller merges it into
+     * a mutable outbound header bag).
+     */
+    replay(providerId: string, accountId: string): Record<string, string> | undefined;
+    /** Whether an identity is frozen for an account (admin coarse status — D7). */
+    hasIdentity(providerId: string, accountId: string): boolean;
+    /** The freeze/refresh time for an account's identity (admin coarse status). */
+    capturedAt(providerId: string, accountId: string): number | undefined;
+    private emitPersist;
+    private key;
+}
+/** The shared identity store; lazily constructs a default (disabled) instance. */
+declare function getSharedIdentityStore(): SubscriptionIdentityStore;
+/** Install a specific store at bootstrap (idempotent; last write wins). */
+declare function setSharedIdentityStore(instance: SubscriptionIdentityStore): void;
+/** Reset the shared singleton (tests / teardown only). */
+declare function __resetSharedIdentityStoreForTests(): void;
+
+export { CC_HEADER_TTL_MS, type FrozenIdentity, type IdentityPersistencePort, SubscriptionIdentityStore, type SubscriptionIdentityStoreOptions, __resetSharedIdentityStoreForTests, getSharedIdentityStore, setSharedIdentityStore };

package/dist/provider-proxy/identity/SubscriptionIdentityStore.d.ts

@@ -0,0 +1,121 @@
+/**
+ * SubscriptionIdentityStore — the per-account client-identity capture/freeze/replay
+ * store for claude-subscription outbound traffic (subscription-client-fingerprint
+ * #7, design D1/D4/D5/D7).
+ *
+ * Shaped like the existing in-memory `SubscriptionAccountHealth` tracker: an
+ * in-memory `Map`, an injectable `now` clock, NO external deps. It is keyed by an
+ * opaque `providerId + '\0' + accountId` string — core never learns "account"
+ * semantics (exactly the health-tracker precedent), and there is NO
+ * `@omnicross/subscriptions` import. It carries NO token/secret: the capture
+ * whitelist + `sanitizeFrozenHeaders` exclude `authorization`/`x-api-key`/`cookie`
+ * at BOTH ingress and store-normalize.
+ *
+ * Freeze/replay model (D4 — never fabricate):
+ *  - The FIRST captured fingerprint set for an account is FROZEN; every later
+ *    outbound request for that account REPLAYS that frozen set → a stable
+ *    per-account identity. Stainless headers are frozen-stable forever; the
+ *    non-stainless (CC) headers refresh on a 7-day TTL from a newer real
+ *    observation (P2, `refreshNonStainless`).
+ *  - Values are ONLY ever REAL captured client values — nothing here invents a
+ *    `x-stainless-*`. An un-captured account replays NOTHING (the caller then
+ *    applies at most the operator UA baseline).
+ *
+ * Persistence (P2, D5): OPTIONAL. When a persistence port is installed
+ * (`setPersistence`), a first-seen freeze / TTL refresh is written through to the
+ * account entry (additive NON-secret metadata) so the identity survives restart;
+ * at boot the daemon `seed()`s the store from the persisted entries. In-memory-only
+ * (no port) is the P1 default — a real client re-captures after restart.
+ *
+ * @module provider-proxy/identity/SubscriptionIdentityStore
+ */
+/** A frozen per-account client identity (the captured fingerprint headers). */
+interface FrozenIdentity {
+    /** The captured fingerprint headers (lowercased keys; token/secret excluded). */
+    headers: Record<string, string>;
+    /** Epoch ms of the freeze (or last TTL refresh). */
+    capturedAt: number;
+}
+/**
+ * Write-through persistence port (P2, D5). The store calls `persist` on a
+ * first-seen freeze / TTL refresh; the daemon implementation writes the identity
+ * onto the account entry. Fire-and-forget — the store swallows any throw so the
+ * hot path is never affected. Core defines the port; the daemon supplies it (the
+ * `setUpstreamProxyResolver` / `setWebhookSink` precedent — no daemon import).
+ */
+interface IdentityPersistencePort {
+    persist(providerId: string, accountId: string, identity: FrozenIdentity): void;
+}
+/** The CC-header (non-stainless) refresh TTL — 7 days (design D6/P2). */
+declare const CC_HEADER_TTL_MS: number;
+/** Constructor knobs (all optional). */
+interface SubscriptionIdentityStoreOptions {
+    /** Injectable clock (ms). Default `Date.now`. */
+    now?: () => number;
+    /** Whether capture/replay engages. Default `false` (byte-identical outbound). */
+    enabled?: boolean;
+    /** Operator UA baseline applied ONLY when nothing was captured (piece 4). */
+    ua?: string;
+    /** The CC-header refresh TTL (ms). Default {@link CC_HEADER_TTL_MS}. */
+    ccHeaderTtlMs?: number;
+}
+declare class SubscriptionIdentityStore {
+    private readonly identities;
+    private readonly now;
+    private enabled;
+    private ua;
+    private ccHeaderTtlMs;
+    private persistence;
+    constructor(opts?: SubscriptionIdentityStoreOptions);
+    /** Whether capture/replay is engaged (config flag). */
+    isEnabled(): boolean;
+    /** The operator UA baseline (piece 4), or undefined when unset. */
+    uaBaseline(): string | undefined;
+    /**
+     * Re-apply config to the LIVE shared instance (bootstrap, mirroring the health
+     * tracker's `configure`). Only defined fields override; `ua: null` clears the
+     * baseline.
+     */
+    configure(opts: {
+        enabled?: boolean;
+        ua?: string | null;
+    }): void;
+    /** Install (or clear) the write-through persistence port (P2). */
+    setPersistence(port: IdentityPersistencePort | null): void;
+    /**
+     * Boot seed (P2, D5): install a PERSISTED identity for an account, but NEVER
+     * over a live in-memory capture (a re-captured identity from this session wins).
+     * A no-op for an empty/absent identity. Does NOT write back through the port.
+     */
+    seed(providerId: string, accountId: string, identity: FrozenIdentity | undefined): void;
+    /**
+     * Capture a real client's fingerprint headers for an account. First-seen ⇒
+     * FREEZE the whole (sanitized) bag. Already-frozen ⇒ within the TTL, no change
+     * (stable identity); past the TTL, refresh the NON-stainless headers from the
+     * new observation while keeping stainless frozen-stable (P2). An empty/absent
+     * account id or an empty sanitized bag is a no-op (so an account with no
+     * fingerprint headers never freezes an empty identity → the caller falls back
+     * to the UA baseline). Fires the persistence port on a freeze/refresh.
+     */
+    capture(providerId: string, accountId: string, incoming: Record<string, string>, now?: number): void;
+    /**
+     * The frozen identity headers for an account, or `undefined` when none is
+     * frozen (or the frozen set is empty). Returns a COPY (the caller merges it into
+     * a mutable outbound header bag).
+     */
+    replay(providerId: string, accountId: string): Record<string, string> | undefined;
+    /** Whether an identity is frozen for an account (admin coarse status — D7). */
+    hasIdentity(providerId: string, accountId: string): boolean;
+    /** The freeze/refresh time for an account's identity (admin coarse status). */
+    capturedAt(providerId: string, accountId: string): number | undefined;
+    private emitPersist;
+    private key;
+}
+/** The shared identity store; lazily constructs a default (disabled) instance. */
+declare function getSharedIdentityStore(): SubscriptionIdentityStore;
+/** Install a specific store at bootstrap (idempotent; last write wins). */
+declare function setSharedIdentityStore(instance: SubscriptionIdentityStore): void;
+/** Reset the shared singleton (tests / teardown only). */
+declare function __resetSharedIdentityStoreForTests(): void;
+
+export { CC_HEADER_TTL_MS, type FrozenIdentity, type IdentityPersistencePort, SubscriptionIdentityStore, type SubscriptionIdentityStoreOptions, __resetSharedIdentityStoreForTests, getSharedIdentityStore, setSharedIdentityStore };

package/dist/provider-proxy/identity/SubscriptionIdentityStore.js

@@ -0,0 +1,15 @@
+import {
+  CC_HEADER_TTL_MS,
+  SubscriptionIdentityStore,
+  __resetSharedIdentityStoreForTests,
+  getSharedIdentityStore,
+  setSharedIdentityStore
+} from "../../chunk-XTEI64OU.js";
+import "../../chunk-XX6NQJMA.js";
+export {
+  CC_HEADER_TTL_MS,
+  SubscriptionIdentityStore,
+  __resetSharedIdentityStoreForTests,
+  getSharedIdentityStore,
+  setSharedIdentityStore
+};

package/dist/provider-proxy/identity/fingerprintHeaders.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+var _chunk6RPZADX3cjs = require('../../chunk-6RPZADX3.cjs');
+
+
+
+
+
+
+
+
+
+exports.STAINLESS_PREFIX = _chunk6RPZADX3cjs.STAINLESS_PREFIX; exports.applyFingerprint = _chunk6RPZADX3cjs.applyFingerprint; exports.captureCallerIdentity = _chunk6RPZADX3cjs.captureCallerIdentity; exports.extractFingerprintHeaders = _chunk6RPZADX3cjs.extractFingerprintHeaders; exports.isStainless = _chunk6RPZADX3cjs.isStainless; exports.mergeFrozenIdentity = _chunk6RPZADX3cjs.mergeFrozenIdentity; exports.refreshNonStainless = _chunk6RPZADX3cjs.refreshNonStainless; exports.sanitizeFrozenHeaders = _chunk6RPZADX3cjs.sanitizeFrozenHeaders;

package/dist/provider-proxy/identity/fingerprintHeaders.d.cts

@@ -0,0 +1,89 @@
+import { SubscriptionIdentityStore } from './SubscriptionIdentityStore.cjs';
+
+/**
+ * fingerprintHeaders — the PURE half of subscription client-fingerprint replay
+ * (subscription-client-fingerprint #7, design D2/D3/D4/D7).
+ *
+ * Holds ONLY pure functions (no state, no store): the capture WHITELIST
+ * (`extractFingerprintHeaders`), the store-normalizer (`sanitizeFrozenHeaders`),
+ * the TTL refresh split (`refreshNonStainless`), the outbound merge
+ * (`mergeFrozenIdentity`), and the one composition entrypoint the relay calls
+ * (`applyFingerprint`, which takes the store INSTANCE as a parameter so this file
+ * never imports the store at runtime — no cycle).
+ *
+ * SAFETY CORE (non-negotiable):
+ *  - The capture whitelist is POSITIVE (`x-stainless-*` + a small set of
+ *    Claude-Code / Anthropic-SDK header names) AND has an explicit EXCLUSION of
+ *    `authorization` / `x-api-key` / `cookie` (the token/secret) — belt AND
+ *    suspenders, so widening the whitelist can never leak auth.
+ *  - The outbound merge NEVER overwrites `authorization` / `content-type`
+ *    (the auth strategy owns auth; content-type is fixed) and never overwrites a
+ *    header the outbound build already set (case-insensitive).
+ *  - Values are only ever REAL captured client headers — nothing here fabricates
+ *    a `x-stainless-*` value. The only synthesizable piece is the operator-set UA
+ *    baseline, applied in `applyFingerprint` ONLY when NOTHING was captured.
+ *
+ * @module provider-proxy/identity/fingerprintHeaders
+ */
+
+/** Header-name prefix that marks a stainless (SDK-runtime) fingerprint header. */
+declare const STAINLESS_PREFIX = "x-stainless-";
+/** Whether a header name (any case) is a stainless fingerprint header. */
+declare function isStainless(name: string): boolean;
+/**
+ * Capture: extract the WHITELISTED fingerprint headers from an incoming client
+ * request's header bag (`http.IncomingHttpHeaders`-shaped). Array values (rare —
+ * duplicate headers) are joined with `, `. Keys are lowercased. The auth/secret
+ * exclusion is applied FIRST so it wins over any whitelist entry. Never throws.
+ */
+declare function extractFingerprintHeaders(reqHeaders: Record<string, string | string[] | undefined>): Record<string, string>;
+/**
+ * Ingress capture gate (subscription-client-fingerprint #7): extract the caller's
+ * fingerprint headers ONLY when replay is enabled — returns `undefined` when
+ * disabled so the ingress does NO extraction work on the default/BYO path (and
+ * threads nothing to the relay). Behavior when enabled is identical to calling
+ * `extractFingerprintHeaders` directly.
+ */
+declare function captureCallerIdentity(store: SubscriptionIdentityStore, reqHeaders: Record<string, string | string[] | undefined>): Record<string, string> | undefined;
+/**
+ * Store-normalize a header bag before freezing/seeding: lowercase keys, drop
+ * empty/non-string values, and HARD-EXCLUDE the auth/secret + protected-outbound
+ * sets. This is the second line of defense (after the capture whitelist) so a
+ * persisted/seeded identity can never carry a token even if a bad bag was handed
+ * in. Idempotent.
+ */
+declare function sanitizeFrozenHeaders(headers: Record<string, string>): Record<string, string>;
+/**
+ * TTL refresh split (P2, piece 2): produce the refreshed frozen set when a newer
+ * real capture is observed after the CC-header TTL. The STAINLESS set stays
+ * frozen-stable (only the original values survive — a real client keeps a stable
+ * stainless identity); the NON-stainless headers (user-agent / anthropic-beta /
+ * x-app / …) are refreshed from the newer observation, falling back to the frozen
+ * value when the new bag omits one. New stainless headers in the incoming bag are
+ * IGNORED (stainless never grows/changes after the first freeze).
+ */
+declare function refreshNonStainless(frozen: Record<string, string>, incoming: Record<string, string>): Record<string, string>;
+/**
+ * Merge a frozen identity into the outbound `headers` in place. NEVER overwrites
+ * `authorization` / `content-type`, and never overwrites a header already present
+ * (case-insensitive) — so a header the auth strategy or the relay already set
+ * always wins. The identity keys are already lowercased (`sanitizeFrozenHeaders`).
+ */
+declare function mergeFrozenIdentity(headers: Record<string, string>, identity: Record<string, string>): void;
+/**
+ * The ONE composition entrypoint the claude same-format relay calls, AFTER
+ * `applyHeaders` reported the selected account and BEFORE `fetchUpstream`.
+ *
+ * Disabled (default) OR no account id ⇒ a strict no-op — the `headers` object is
+ * left BYTE-IDENTICAL (the zero-regression guarantee). When enabled:
+ *  1. capture the caller's real fingerprint headers for this account (first-seen
+ *     freeze; P2 TTL refresh) — per-account, keyed by the reported account id;
+ *  2. replay the frozen identity for the account into `headers` (never
+ *     overwriting auth/content-type). On the FIRST request this is the client's
+ *     own just-captured headers (honest); later requests replay the frozen set;
+ *  3. if NOTHING is captured for the account, apply ONLY the operator-configured
+ *     UA baseline (never a fabricated stainless value).
+ */
+declare function applyFingerprint(store: SubscriptionIdentityStore, headers: Record<string, string>, providerId: string, accountId: string | undefined, callerIdentity: Record<string, string> | undefined, now?: number): void;
+
+export { STAINLESS_PREFIX, applyFingerprint, captureCallerIdentity, extractFingerprintHeaders, isStainless, mergeFrozenIdentity, refreshNonStainless, sanitizeFrozenHeaders };