@omnicross/core 0.1.5 → 0.1.6

package/dist/chunk-DLXZEZWO.cjs

@@ -0,0 +1,285 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/usage/pricing-engine.ts
+
+
+
+var _pricingtypes = require('@omnicross/contracts/pricing-types');
+var PricingEngine = (_class = class {
+  constructor(store, logger, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.store = store;
+    this.logger = logger;
+    this.options = options;
+  }
+  
+  
+  
+  __init() {this.cache = /* @__PURE__ */ new Map()}
+  /**
+   * Secondary index keyed by modelId alone. Used as a fallback when no exact
+   * (providerId, modelId) match exists — usage may be recorded under a
+   * runtime provider alias while pricing rows use the canonical provider id,
+   * so matching by model name lets the price still resolve. First
+   * non-wildcard entry per model wins.
+   */
+  __init2() {this.cacheByModel = /* @__PURE__ */ new Map()}
+  __init3() {this.cacheLoaded = false}
+  /** Coalesce manual and background refreshes to prevent a catalog stampede. */
+  __init4() {this.refreshInFlight = null}
+  // ===== Cache management =====
+  /** Lazy-load and cache the full pricing table. */
+  async ensureCache() {
+    if (this.cacheLoaded) return;
+    const rows = await this.store.getAll();
+    this.cache = new Map(rows.map((r) => [keyOf(r.providerId, r.modelId), r]));
+    this.cacheByModel = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      if (r.providerId === "*" || r.providerId === "openrouter" || r.source === "openrouter") continue;
+      if (!this.cacheByModel.has(r.modelId)) this.cacheByModel.set(r.modelId, r);
+    }
+    this.cacheLoaded = true;
+  }
+  /** Force a cache refresh — call after any write. */
+  async invalidateCache() {
+    this.cacheLoaded = false;
+    await this.ensureCache();
+  }
+  // ===== Read API =====
+  async getAll() {
+    await this.ensureCache();
+    return Array.from(this.cache.values());
+  }
+  /**
+   * Look up a price for (provider, model). Resolution order:
+   *   1. exact (providerId, modelId)
+   *   2. wildcard provider ('*', modelId)
+   *   3. model name alone (any provider) — tolerates a runtime-alias vs
+   *      canonical provider-id mismatch for the same model.
+   */
+  async getEntry(providerId, modelId) {
+    await this.ensureCache();
+    return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(this.cache.get(keyOf(providerId, modelId)), () => ( this.cache.get(keyOf("*", modelId)))), () => ( this.cacheByModel.get(modelId))), () => ( null));
+  }
+  // ===== Cost calculation =====
+  /**
+   * Compute the cost (and cache savings) for a single response.
+   *
+   * Cost formula (USD):
+   *   cost = (input  * inputPrice
+   *         + output * outputPrice
+   *         + cacheRead  * (cacheReadPrice  ?? inputPrice)
+   *         + cacheWrite * (cacheWritePrice ?? inputPrice)
+   *        ) / 1e6
+   *
+   * Cache savings:
+   *   savings = cacheRead * (inputPrice - cacheReadPrice) / 1e6
+   *           — clamped at 0 if cacheReadPrice is null or ≥ inputPrice.
+   */
+  async calculateCost(providerId, modelId, usage) {
+    const entry = await this.getEntry(providerId, modelId);
+    if (!entry) {
+      return { costUsd: 0, costSavedByCacheUsd: 0 };
+    }
+    const ip = entry.inputPricePer1m;
+    const op = entry.outputPricePer1m;
+    const crp = _nullishCoalesce(entry.cacheReadPricePer1m, () => ( ip));
+    const cwp = _nullishCoalesce(entry.cacheWritePricePer1m, () => ( ip));
+    const costUsd = (usage.inputTokens * ip + usage.outputTokens * op + usage.cacheReadTokens * crp + usage.cacheCreationTokens * cwp) / 1e6;
+    const savingsRate = entry.cacheReadPricePer1m == null ? 0 : Math.max(0, ip - crp);
+    const costSavedByCacheUsd = usage.cacheReadTokens * savingsRate / 1e6;
+    return { costUsd, costSavedByCacheUsd };
+  }
+  // ===== Manual upsert (used by inline editors) =====
+  async upsertManual(input) {
+    const updated = await this.store.upsert(
+      input,
+      /* asUserEdit */
+      true
+    );
+    this.cache.set(keyOf(updated.providerId, updated.modelId), updated);
+    if (updated.providerId !== "*" && updated.providerId !== "openrouter" && updated.source !== "openrouter") {
+      this.cacheByModel.set(updated.modelId, updated);
+    }
+    return updated;
+  }
+  // ===== Source refresh =====
+  async fetchLatestFromSource() {
+    if (this.refreshInFlight) return this.refreshInFlight;
+    const refresh = this.refreshSources();
+    this.refreshInFlight = refresh;
+    try {
+      return await refresh;
+    } finally {
+      if (this.refreshInFlight === refresh) this.refreshInFlight = null;
+    }
+  }
+  async refreshSources() {
+    const sourceUrl = _nullishCoalesce(this.options.sourceUrl, () => ( _pricingtypes.DEFAULT_LITELLM_PRICING_URL));
+    const openRouterSourceUrl = _nullishCoalesce(this.options.openRouterSourceUrl, () => ( _pricingtypes.DEFAULT_OPENROUTER_PRICING_URL));
+    const fetchImpl = _nullishCoalesce(this.options.fetchImpl, () => ( fetch));
+    const timeoutMs = _nullishCoalesce(this.options.fetchTimeoutMs, () => ( 1e4));
+    const fetchedAt = Date.now();
+    const [litellm, openrouter] = await Promise.all([
+      fetchCatalog(fetchImpl, sourceUrl, timeoutMs, parseLitellmJson),
+      fetchCatalog(fetchImpl, openRouterSourceUrl, timeoutMs, parseOpenRouterJson)
+    ]);
+    const sources = [
+      sourceResult("litellm", sourceUrl, litellm),
+      sourceResult("openrouter", openRouterSourceUrl, openrouter)
+    ];
+    for (const source of sources) {
+      if (source.status === "failed") {
+        this.logger.warn(`[PricingEngine] ${source.source} pricing-source fetch failed`, {
+          error: source.error
+        });
+      }
+    }
+    if (!litellm.ok && !openrouter.ok) {
+      throw new Error(
+        `Pricing-source fetch failed: LiteLLM (${litellm.error}); OpenRouter (${openrouter.error})`
+      );
+    }
+    const applied = [];
+    const conflicts = [];
+    if (litellm.ok) {
+      const result = await this.store.bulkApplyFromSource(litellm.entries, "litellm");
+      applied.push(...result.applied);
+      conflicts.push(
+        ...result.conflicts.map((c) => ({
+          providerId: c.current.providerId,
+          modelId: c.current.modelId,
+          current: c.current,
+          incoming: c.incoming
+        }))
+      );
+      sources[0].appliedCount = result.applied.length;
+    }
+    if (openrouter.ok) {
+      const current = new Map(
+        (await this.store.getAll()).map((row) => [keyOf(row.providerId, row.modelId), row])
+      );
+      const supplemental = openrouter.entries.filter((incoming) => {
+        const row = current.get(keyOf(incoming.providerId, incoming.modelId));
+        return !row || row.source === "openrouter" || row.source === "builtin";
+      });
+      const result = await this.store.bulkApplyFromSource(supplemental, "openrouter");
+      applied.push(...result.applied);
+      sources[1].appliedCount = result.applied.length;
+    }
+    if (applied.length > 0) await this.invalidateCache();
+    return {
+      applied,
+      conflicts,
+      fetchedAt,
+      sourceUrl,
+      sources
+    };
+  }
+  // ===== Conflict resolution =====
+  async resolveConflicts(decisions, pendingIncoming) {
+    const resolutions = [];
+    for (const d of decisions) {
+      const incoming = pendingIncoming.get(keyOf(d.providerId, d.modelId));
+      if (!incoming) continue;
+      resolutions.push({ incoming, action: d.action });
+    }
+    const result = await this.store.applyResolutions(resolutions);
+    await this.invalidateCache();
+    return result;
+  }
+}, _class);
+var keyOf = (providerId, modelId) => `${providerId}::${modelId}`;
+var PROVIDER_ALIASES = {
+  vertex_ai: "gemini",
+  google: "gemini",
+  bedrock: "anthropic",
+  azure: "openai"
+};
+var parseLitellmJson = (json) => {
+  if (!json || typeof json !== "object" || Array.isArray(json)) {
+    throw new Error("invalid LiteLLM catalog shape");
+  }
+  const out = [];
+  for (const [modelId, entry] of Object.entries(json)) {
+    if (modelId === "sample_spec") continue;
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.input_cost_per_token == null || entry.output_cost_per_token == null) {
+      continue;
+    }
+    const rawProvider = _nullishCoalesce(entry.litellm_provider, () => ( ""));
+    const providerId = _nullishCoalesce(PROVIDER_ALIASES[rawProvider], () => ( rawProvider));
+    if (!providerId) continue;
+    out.push({
+      providerId,
+      modelId,
+      inputPricePer1m: entry.input_cost_per_token * 1e6,
+      outputPricePer1m: entry.output_cost_per_token * 1e6,
+      cacheReadPricePer1m: entry.cache_read_input_token_cost != null ? entry.cache_read_input_token_cost * 1e6 : null,
+      cacheWritePricePer1m: entry.cache_creation_input_token_cost != null ? entry.cache_creation_input_token_cost * 1e6 : null
+    });
+  }
+  return out;
+};
+var parseOpenRouterJson = (json) => {
+  if (!json || !Array.isArray(json.data)) {
+    throw new Error("invalid OpenRouter catalog shape");
+  }
+  const out = [];
+  for (const model of json.data) {
+    const modelId = typeof _optionalChain([model, 'optionalAccess', _ => _.id]) === "string" ? model.id.trim() : "";
+    const input = parseUnitPrice(_optionalChain([model, 'optionalAccess', _2 => _2.pricing, 'optionalAccess', _3 => _3.prompt]));
+    const output = parseUnitPrice(_optionalChain([model, 'optionalAccess', _4 => _4.pricing, 'optionalAccess', _5 => _5.completion]));
+    if (!modelId || input === null || output === null) continue;
+    const cacheRead = parseUnitPrice(_optionalChain([model, 'access', _6 => _6.pricing, 'optionalAccess', _7 => _7.input_cache_read]));
+    const cacheWrite = parseUnitPrice(_optionalChain([model, 'access', _8 => _8.pricing, 'optionalAccess', _9 => _9.input_cache_write]));
+    out.push({
+      providerId: "openrouter",
+      modelId,
+      inputPricePer1m: input * 1e6,
+      outputPricePer1m: output * 1e6,
+      cacheReadPricePer1m: cacheRead === null ? null : cacheRead * 1e6,
+      cacheWritePricePer1m: cacheWrite === null ? null : cacheWrite * 1e6
+    });
+  }
+  return out;
+};
+function parseUnitPrice(value) {
+  if (value === "" || value === null || value === void 0) return null;
+  const parsed = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+async function fetchCatalog(fetchImpl, url, timeoutMs, parse) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  _optionalChain([timer, 'access', _10 => _10.unref, 'optionalCall', _11 => _11()]);
+  try {
+    const response = await fetchImpl(url, { signal: controller.signal });
+    if (!response.ok) throw new Error(`status ${response.status}`);
+    const entries = parse(await response.json());
+    if (entries.length === 0) throw new Error("pricing catalog contained no usable entries");
+    return { ok: true, entries };
+  } catch (error) {
+    const message = controller.signal.aborted ? `timeout after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function sourceResult(source, sourceUrl, attempt) {
+  return attempt.ok ? {
+    source,
+    sourceUrl,
+    status: "applied",
+    parsedCount: attempt.entries.length,
+    appliedCount: 0
+  } : {
+    source,
+    sourceUrl,
+    status: "failed",
+    parsedCount: 0,
+    appliedCount: 0,
+    error: attempt.error
+  };
+}
+
+
+
+exports.PricingEngine = PricingEngine;

package/dist/{chunk-UHGVBFU3.js → chunk-EBLFCNPY.js}

@@ -89,18 +89,6 @@ function validateEndpointModelConfig(config) {
     (kind) => !isNonBlankRef(map[kind])
   );
 }
-function validateServerModelConfig(config) {
-  const errors = [];
-  for (const endpoint of Object.keys(ENDPOINT_MODEL_KINDS)) {
-    const ep = config.endpoints.find((e) => e.endpoint === endpoint);
-    const declared = modelKindsForEndpoint(endpoint);
-    const missingKinds = ep ? validateEndpointModelConfig(ep) : [...declared];
-    if (missingKinds.length > 0 && missingKinds.length < declared.length) {
-      errors.push({ endpoint, missingKinds });
-    }
-  }
-  return errors;
-}
 
 // src/outbound-api/modelPrefixDispatch.ts
 function classifyModelPrefix(model) {
@@ -149,6 +137,34 @@ function endpointSupportsSubscription(endpoint) {
 }
 
 // src/outbound-api/routeResolver.ts
+function bindDelegatedSubscriptionProfile(profile, config) {
+  const preferredAccountId = config.boundAccountId;
+  const preferredAccountGroup = config.boundAccountGroup;
+  const boundAccountFallbackPolicy = config.boundAccountFallbackPolicy;
+  if (!preferredAccountId && !preferredAccountGroup) return profile;
+  const strategy = profile.authStrategy;
+  return {
+    ...profile,
+    authStrategy: {
+      kind: strategy.kind,
+      providerId: strategy.providerId,
+      applyHeaders(headers, hints) {
+        return strategy.applyHeaders(headers, {
+          ...hints,
+          preferredAccountId,
+          preferredAccountGroup,
+          boundAccountFallbackPolicy
+        });
+      },
+      onUnauthorized(sessionKey) {
+        return strategy.onUnauthorized(sessionKey);
+      },
+      describeStatus() {
+        return strategy.describeStatus();
+      }
+    }
+  };
+}
 function parseModelRef(ref) {
   if (!ref) return null;
   const idx = ref.indexOf(",");
@@ -267,6 +283,8 @@ async function resolveRoute(args) {
       apiKey: resolveApiKey(provider.api_key),
       isOfficialProvider,
       passThrough: false,
+      preferredKeyId: config.boundKeyId,
+      boundKeyFallbackPolicy: config.boundKeyFallbackPolicy,
       attribution: { sessionId, apiKeyId: args.apiKeyId ?? null }
     };
   }
@@ -277,6 +295,8 @@ async function resolveRoute(args) {
     ingressFormat,
     authMode: "byo",
     providerId,
+    preferredKeyId: config.boundKeyId,
+    boundKeyFallbackPolicy: config.boundKeyFallbackPolicy,
     // Passthrough gate: the client's ORIGINAL requested id (kind-mapped only).
     requestedModel,
     // Usage attribution: the verified named-key id (undefined for internal traffic).
@@ -321,7 +341,10 @@ async function resolveSubscriptionRoute(args) {
     apiKey: "",
     isOfficialProvider: false,
     passThrough: false,
-    subscriptionProfile: profile,
+    subscriptionProfile: bindDelegatedSubscriptionProfile(profile, config),
+    preferredAccountId: config.boundAccountId,
+    preferredAccountGroup: config.boundAccountGroup,
+    boundAccountFallbackPolicy: config.boundAccountFallbackPolicy,
     attribution: { sessionId, apiKeyId: apiKeyId ?? null }
   };
   const subscriptionConfig = providerId === "opencodego" ? await registry?.getOpenCodeGoConfig?.() : void 0;
@@ -353,6 +376,8 @@ async function resolveSubscriptionRoute(args) {
     subscriptionConfig,
     // Per-request preferred account (provider/subscription duality); undefined ⇒ pool.
     preferredAccountId: config.boundAccountId,
+    preferredAccountGroup: config.boundAccountGroup,
+    boundAccountFallbackPolicy: config.boundAccountFallbackPolicy,
     anthropicSdkHints: hints
   };
   return { ok: true, route, usedRole: effectiveRole };
@@ -373,7 +398,6 @@ export {
   modelKindsForEndpoint,
   detectModelKind,
   validateEndpointModelConfig,
-  validateServerModelConfig,
   classifyModelPrefix,
   resolvePrefixTarget,
   SUBSCRIPTION_PROVIDER_IDS,

package/dist/chunk-EJLH6NFT.cjs

@@ -0,0 +1,166 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/provider-proxy/matchText.ts
+var MATCH_TEXT_PER_MESSAGE_CAP = 8192;
+var MATCH_TEXT_RECENT_MESSAGES = 6;
+function flattenMatchText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const item of value) {
+      const text = flattenMatchText(item);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if (obj.type === "tool_result" && obj.content !== void 0) {
+      return flattenMatchText(obj.content);
+    }
+    if (typeof obj.text === "string") return obj.text;
+  }
+  return "";
+}
+function collectMatchText(anthropicBody) {
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  const slices = [];
+  const sys = flattenMatchText(anthropicBody.system).trim();
+  if (sys) slices.push(sys.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const recent = [];
+  for (let i = messages.length - 1; i >= 0 && recent.length < MATCH_TEXT_RECENT_MESSAGES; i--) {
+    const message = messages[i];
+    if (!message || typeof message !== "object") continue;
+    const role = message.role;
+    if (role !== "user" && role !== "system") continue;
+    const text = flattenMatchText(message.content).trim();
+    if (text) recent.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  for (let i = recent.length - 1; i >= 0; i--) slices.push(recent[i]);
+  return slices;
+}
+function deriveSubscriptionSessionKey(anthropicBody) {
+  const system = flattenMatchText(anthropicBody.system).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  let firstUser = "";
+  for (const message of messages) {
+    if (message && typeof message === "object" && message.role === "user") {
+      firstUser = flattenMatchText(message.content).trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+      break;
+    }
+  }
+  const anchor = `${system}\0${firstUser}`;
+  if (!system && !firstUser) return void 0;
+  return fnv1a(anchor);
+}
+var SESSION_ID_CAP = 1024;
+function deriveGatewaySessionKey(body, headers = {}, options = {}) {
+  const sessionHeader = firstHeaderValue(headers, ["session-id", "session_id", "x-session-id"]);
+  if (sessionHeader) {
+    return { key: fnv1a(sessionHeader), source: "session-header" };
+  }
+  const threadHeader = firstHeaderValue(headers, ["thread-id", "thread_id", "x-thread-id"]);
+  if (threadHeader) {
+    return { key: fnv1a(threadHeader), source: "thread-header" };
+  }
+  const bodySessionId = scalarSessionValue(body.session_id);
+  if (bodySessionId) {
+    return { key: fnv1a(bodySessionId), source: "body-session-id" };
+  }
+  const bodyThreadId = scalarSessionValue(_nullishCoalesce(body.thread_id, () => ( body.threadId)));
+  if (bodyThreadId) {
+    return { key: fnv1a(bodyThreadId), source: "body-thread-id" };
+  }
+  const conversationId = scalarSessionValue(body.conversation_id);
+  if (conversationId) {
+    return { key: fnv1a(conversationId), source: "body-session-id" };
+  }
+  const promptCacheKey = scalarSessionValue(body.prompt_cache_key);
+  if (promptCacheKey) {
+    return { key: fnv1a(promptCacheKey), source: "prompt-cache-key" };
+  }
+  const fingerprint = deriveResponsesContentFingerprint(body);
+  if (fingerprint) {
+    return { key: fnv1a(fingerprint), source: "content-fingerprint" };
+  }
+  const endpoint = _optionalChain([options, 'access', _ => _.endpoint, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]) || "responses";
+  const fallback = _optionalChain([options, 'access', _4 => _4.fallbackKey, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]) || "anonymous";
+  return {
+    key: fnv1a(`${endpoint}\0${fallback}`),
+    source: "api-key-fallback"
+  };
+}
+function firstHeaderValue(headers, names) {
+  const byLower = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(headers)) {
+    if (typeof value === "string" || Array.isArray(value)) {
+      const lower = name.toLowerCase();
+      if (!byLower.has(lower)) byLower.set(lower, value);
+    }
+  }
+  for (const name of names) {
+    const value = byLower.get(name);
+    const values = Array.isArray(value) ? value : [value];
+    for (const item of values) {
+      if (typeof item !== "string") continue;
+      const trimmed = item.trim();
+      if (trimmed) return trimmed.slice(0, SESSION_ID_CAP);
+    }
+  }
+  return void 0;
+}
+function scalarSessionValue(value) {
+  if (typeof value !== "string" && typeof value !== "number") return void 0;
+  const trimmed = String(value).trim();
+  return trimmed ? trimmed.slice(0, SESSION_ID_CAP) : void 0;
+}
+function deriveResponsesContentFingerprint(body) {
+  const stable = [];
+  const instructions = flattenMatchText(body.instructions).trim();
+  if (instructions) stable.push(instructions.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const input = body.input;
+  let firstUser = "";
+  const visitItem = (item) => {
+    if (typeof item === "string") {
+      if (!firstUser) firstUser = item.trim().slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+      return;
+    }
+    if (!item || typeof item !== "object") return;
+    const record = item;
+    const role = typeof record.role === "string" ? record.role.toLowerCase() : "";
+    const content = _nullishCoalesce(_nullishCoalesce(record.content, () => ( record.text)), () => ( record.input));
+    const text = flattenMatchText(content !== void 0 ? content : record).trim();
+    if (!text) return;
+    if (role === "developer" || role === "system") {
+      stable.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+    } else if (role === "user" || !role) {
+      if (!firstUser) firstUser = text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP);
+    }
+  };
+  if (Array.isArray(input)) {
+    for (const item of input) visitItem(item);
+  } else if (input !== void 0) {
+    visitItem(input);
+  }
+  if (stable.length === 0) {
+    const legacySystem = flattenMatchText(body.system).trim();
+    if (legacySystem) stable.push(legacySystem.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  if (stable.length === 0 && !firstUser) return void 0;
+  return `${stable.join("\0")}\0${firstUser}`;
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+
+
+
+
+
+
+
+exports.MATCH_TEXT_PER_MESSAGE_CAP = MATCH_TEXT_PER_MESSAGE_CAP; exports.MATCH_TEXT_RECENT_MESSAGES = MATCH_TEXT_RECENT_MESSAGES; exports.flattenMatchText = flattenMatchText; exports.collectMatchText = collectMatchText; exports.deriveSubscriptionSessionKey = deriveSubscriptionSessionKey; exports.deriveGatewaySessionKey = deriveGatewaySessionKey;