@velum-labs/routekit-daemon 1.3.2 → 1.5.0

package/dist/call-attribution-store.js

@@ -1,3 +1,4 @@
+import { attributeModelCosts, lookupModelPricing, routingCacheOutcome } from "@velum-labs/routekit-registry";
 export const DEFAULT_CALL_ATTRIBUTION_LIMIT = 1_000;
 export const DEFAULT_CALL_ATTRIBUTION_TTL_MS = 24 * 60 * 60 * 1_000;
 function record(value) {
@@ -14,12 +15,381 @@ function number(value) {
 function boolean(value) {
     return value === true;
 }
+function routingHop(value) {
+    const hop = record(value);
+    const episodeId = string(hop?.episode_id);
+    const hopIndex = number(hop?.hop_index);
+    const role = string(hop?.role);
+    const model = string(hop?.model);
+    const previousModel = string(hop?.previous_model);
+    const cacheOutcome = string(hop?.cache_outcome);
+    if (episodeId === undefined ||
+        hopIndex === undefined ||
+        (role !== "classifier" &&
+            role !== "candidate" &&
+            role !== "failover" &&
+            role !== "explicit") ||
+        (cacheOutcome !== undefined &&
+            cacheOutcome !== "hit" &&
+            cacheOutcome !== "write" &&
+            cacheOutcome !== "miss_cold" &&
+            cacheOutcome !== "miss_switch")) {
+        return undefined;
+    }
+    return {
+        episodeId,
+        hopIndex,
+        role,
+        ...(model === undefined ? {} : { model }),
+        ...(previousModel === undefined ? {} : { previousModel }),
+        ...(cacheOutcome === undefined ? {} : { cacheOutcome })
+    };
+}
 function stringArray(value) {
     if (!Array.isArray(value))
         return undefined;
     const values = value.map(string);
     return values.every((entry) => entry !== undefined) ? values : undefined;
 }
+function unknownReasons(value) {
+    return stringArray(value);
+}
+function tokenUsage(value) {
+    const usage = record(value);
+    if (usage === undefined)
+        return undefined;
+    const inputTokens = number(usage.input_tokens);
+    const cachedInputTokens = number(usage.cached_input_tokens);
+    const cacheCreationInputTokens = number(usage.cache_creation_input_tokens);
+    const outputTokens = number(usage.output_tokens);
+    const reasoningTokens = number(usage.reasoning_tokens);
+    return {
+        ...(inputTokens === undefined ? {} : { inputTokens }),
+        ...(cachedInputTokens === undefined ? {} : { cachedInputTokens }),
+        ...(cacheCreationInputTokens === undefined ? {} : { cacheCreationInputTokens }),
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        ...(reasoningTokens === undefined ? {} : { reasoningTokens })
+    };
+}
+function subscriptionWindows(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const windows = value.flatMap((candidate) => {
+        const window = record(candidate);
+        const name = string(window?.window);
+        const observedAt = number(window?.observed_at);
+        const source = string(window?.source);
+        const completeness = string(window?.completeness);
+        const confidence = string(window?.confidence);
+        if (window === undefined ||
+            name === undefined ||
+            observedAt === undefined ||
+            (source !== "headers" &&
+                source !== "response" &&
+                source !== "usage" &&
+                source !== "stream") ||
+            (completeness !== "snapshot" && completeness !== "partial") ||
+            (confidence !== "observed" && confidence !== "estimated" && confidence !== "unknown")) {
+            return [];
+        }
+        return [
+            {
+                window: name,
+                ...(number(window.utilization) === undefined
+                    ? {}
+                    : { utilization: number(window.utilization) }),
+                ...(number(window.utilization_before) === undefined
+                    ? {}
+                    : { utilizationBefore: number(window.utilization_before) }),
+                ...(number(window.utilization_after) === undefined
+                    ? {}
+                    : { utilizationAfter: number(window.utilization_after) }),
+                ...(number(window.remaining_capacity) === undefined
+                    ? {}
+                    : { remainingCapacity: number(window.remaining_capacity) }),
+                ...(number(window.estimated_burden) === undefined
+                    ? {}
+                    : { estimatedBurden: number(window.estimated_burden) }),
+                observedAt,
+                ...(number(window.resets_at) === undefined ? {} : { resetsAt: number(window.resets_at) }),
+                ...(number(window.window_seconds) === undefined
+                    ? {}
+                    : { windowSeconds: number(window.window_seconds) }),
+                ...(string(window.limit_name) === undefined
+                    ? {}
+                    : { limitName: string(window.limit_name) }),
+                ...(string(window.status) === undefined ? {} : { status: string(window.status) }),
+                source,
+                completeness,
+                confidence
+            }
+        ];
+    });
+    return windows.length === value.length ? windows : undefined;
+}
+function apiEquivalent(value) {
+    const api = record(value);
+    const status = string(api?.status);
+    if (status === "known") {
+        const amount = number(api?.amount);
+        const currency = string(api?.currency);
+        const comparisonModel = string(api?.comparison_model);
+        const pricingKey = string(api?.pricing_key);
+        const pricingSource = string(api?.pricing_source);
+        const pricingRevision = string(api?.pricing_revision);
+        if (amount === undefined ||
+            currency === undefined ||
+            comparisonModel === undefined ||
+            pricingKey === undefined ||
+            pricingSource === undefined) {
+            return undefined;
+        }
+        return {
+            status,
+            amount,
+            currency,
+            comparisonModel,
+            pricingKey,
+            pricingSource,
+            ...(pricingRevision === undefined ? {} : { pricingRevision })
+        };
+    }
+    if (status === "unknown") {
+        const reasons = unknownReasons(api?.unknown_reasons);
+        if (reasons === undefined)
+            return undefined;
+        const comparisonModel = string(api?.comparison_model);
+        return {
+            status,
+            ...(comparisonModel === undefined ? {} : { comparisonModel }),
+            unknownReasons: reasons
+        };
+    }
+    return undefined;
+}
+function scarcity(value) {
+    const scarcity = record(value);
+    const status = string(scarcity?.status);
+    const confidence = string(scarcity?.confidence);
+    const reasons = unknownReasons(scarcity?.unknown_reasons);
+    if ((status !== "known" && status !== "partial" && status !== "unknown") ||
+        scarcity?.strategy !== "pressure-v1" ||
+        (confidence !== "observed" && confidence !== "estimated" && confidence !== "unknown") ||
+        reasons === undefined ||
+        !Array.isArray(scarcity.windows)) {
+        return undefined;
+    }
+    const windows = scarcity.windows.flatMap((candidate) => {
+        const window = record(candidate);
+        const name = string(window?.window);
+        const windowConfidence = string(window?.confidence);
+        const windowReasons = unknownReasons(window?.unknown_reasons);
+        if (window === undefined ||
+            name === undefined ||
+            (windowConfidence !== "observed" &&
+                windowConfidence !== "estimated" &&
+                windowConfidence !== "unknown") ||
+            windowReasons === undefined) {
+            return [];
+        }
+        return [
+            {
+                window: name,
+                ...(number(window.score) === undefined ? {} : { score: number(window.score) }),
+                ...(number(window.pressure) === undefined ? {} : { pressure: number(window.pressure) }),
+                ...(number(window.expected_demand_before_reset) === undefined
+                    ? {}
+                    : { expectedDemandBeforeReset: number(window.expected_demand_before_reset) }),
+                ...(number(window.remaining_capacity) === undefined
+                    ? {}
+                    : { remainingCapacity: number(window.remaining_capacity) }),
+                ...(number(window.burden) === undefined ? {} : { burden: number(window.burden) }),
+                ...(number(window.resets_at) === undefined ? {} : { resetsAt: number(window.resets_at) }),
+                confidence: windowConfidence,
+                unknownReasons: windowReasons
+            }
+        ];
+    });
+    if (windows.length !== scarcity.windows.length)
+        return undefined;
+    const level = string(scarcity.level);
+    const governingWindow = string(scarcity.governing_window);
+    const scarcityValue = record(scarcity.value);
+    const valueAmount = number(scarcityValue?.amount);
+    const valueCurrency = string(scarcityValue?.currency);
+    return {
+        status,
+        strategy: "pressure-v1",
+        ...(number(scarcity.score) === undefined ? {} : { score: number(scarcity.score) }),
+        ...(level === "low" || level === "medium" || level === "high" ? { level } : {}),
+        confidence,
+        ...(governingWindow === undefined ? {} : { governingWindow }),
+        ...(valueAmount === undefined ||
+            valueCurrency === undefined ||
+            scarcityValue?.basis !== "fallback-displacement"
+            ? {}
+            : {
+                value: {
+                    amount: valueAmount,
+                    currency: valueCurrency,
+                    basis: "fallback-displacement"
+                }
+            }),
+        windows,
+        unknownReasons: reasons
+    };
+}
+function allocation(value) {
+    const allocation = record(value);
+    const status = string(allocation?.status);
+    const reasons = unknownReasons(allocation?.unknown_reasons);
+    const modelFactor = number(allocation?.model_factor);
+    if (reasons === undefined || modelFactor === undefined)
+        return undefined;
+    if (status === "provisional" && allocation?.method === "burden-scarcity-v1") {
+        return {
+            status,
+            ...(number(allocation.amount) === undefined ? {} : { amount: number(allocation.amount) }),
+            ...(string(allocation.currency) === undefined
+                ? {}
+                : { currency: string(allocation.currency) }),
+            ...(number(allocation.raw_weight) === undefined
+                ? {}
+                : { rawWeight: number(allocation.raw_weight) }),
+            ...(number(allocation.observed_burden) === undefined
+                ? {}
+                : { observedBurden: number(allocation.observed_burden) }),
+            modelFactor,
+            ...(number(allocation.temporal_scarcity_factor) === undefined
+                ? {}
+                : { temporalScarcityFactor: number(allocation.temporal_scarcity_factor) }),
+            method: "burden-scarcity-v1",
+            version: 1,
+            unknownReasons: reasons
+        };
+    }
+    if (status === "settled" && allocation?.method === "bounded-provisional-v1") {
+        const amount = number(allocation.amount);
+        const currency = string(allocation.currency);
+        const rawWeight = number(allocation.raw_weight);
+        const observedBurden = number(allocation.observed_burden);
+        const temporalScarcityFactor = number(allocation.temporal_scarcity_factor);
+        const settlementRevision = number(allocation.settlement_revision);
+        const settlementId = string(allocation.settlement_id);
+        if (amount === undefined ||
+            currency === undefined ||
+            rawWeight === undefined ||
+            observedBurden === undefined ||
+            temporalScarcityFactor === undefined ||
+            settlementRevision === undefined ||
+            settlementId === undefined) {
+            return undefined;
+        }
+        return {
+            status,
+            amount,
+            currency,
+            rawWeight,
+            observedBurden,
+            modelFactor,
+            temporalScarcityFactor,
+            method: "bounded-provisional-v1",
+            version: 1,
+            settlementRevision,
+            settlementId,
+            unknownReasons: reasons
+        };
+    }
+    return undefined;
+}
+function providerCash(value) {
+    const cash = record(value);
+    const status = string(cash?.status);
+    if (status === "known") {
+        const amount = number(cash?.amount);
+        const currency = string(cash?.currency);
+        if (amount === undefined || currency === undefined || cash?.source !== "provider") {
+            return undefined;
+        }
+        return { status, amount, currency, source: "provider" };
+    }
+    if (status === "unknown") {
+        const reasons = unknownReasons(cash?.unknown_reasons);
+        return reasons === undefined ? undefined : { status, unknownReasons: reasons };
+    }
+    return undefined;
+}
+function fallbackReference(value) {
+    const fallback = record(value);
+    const displacement = record(fallback?.displacement_value);
+    const route = string(fallback?.route);
+    const amount = number(displacement?.amount);
+    const currency = string(displacement?.currency);
+    if (route === undefined || amount === undefined || currency === undefined)
+        return undefined;
+    return { route, displacementValue: { amount, currency } };
+}
+function subscriptionInspection(value) {
+    const subscription = record(value);
+    const entitlement = record(subscription?.entitlement);
+    const period = record(subscription?.period);
+    const usage = tokenUsage(subscription?.usage);
+    const windows = subscriptionWindows(subscription?.windows);
+    const api = apiEquivalent(subscription?.api_equivalent);
+    const cash = providerCash(subscription?.provider_cash);
+    const scarcityValue = scarcity(subscription?.scarcity);
+    const allocationValue = allocation(subscription?.allocation);
+    const reasons = unknownReasons(subscription?.unknown_reasons);
+    const cacheOutcome = string(subscription?.cache_outcome);
+    const entitlementId = string(entitlement?.entitlement_id);
+    const accountId = string(entitlement?.account_id);
+    const periodId = string(period?.id);
+    const startsAt = number(period?.starts_at);
+    const endsAt = number(period?.ends_at);
+    if (entitlementId === undefined ||
+        accountId === undefined ||
+        periodId === undefined ||
+        startsAt === undefined ||
+        endsAt === undefined ||
+        usage === undefined ||
+        windows === undefined ||
+        api === undefined ||
+        cash === undefined ||
+        scarcityValue === undefined ||
+        allocationValue === undefined ||
+        reasons === undefined) {
+        return undefined;
+    }
+    const attributable = record(period?.attributable_cost);
+    const attributableAmount = number(attributable?.amount);
+    const attributableCurrency = string(attributable?.currency);
+    const fallback = fallbackReference(subscription?.fallback);
+    return {
+        entitlement: { entitlementId, accountId },
+        period: {
+            id: periodId,
+            startsAt,
+            endsAt,
+            ...(attributableAmount === undefined || attributableCurrency === undefined
+                ? {}
+                : { attributableCost: { amount: attributableAmount, currency: attributableCurrency } })
+        },
+        usage,
+        ...(cacheOutcome === "hit" ||
+            cacheOutcome === "write" ||
+            cacheOutcome === "miss_cold" ||
+            cacheOutcome === "miss_switch"
+            ? { cacheOutcome }
+            : {}),
+        providerCash: cash,
+        allocation: allocationValue,
+        apiEquivalent: api,
+        scarcity: scarcityValue,
+        windows,
+        ...(fallback === undefined ? {} : { fallback }),
+        unknownReasons: reasons
+    };
+}
 function compositionalRoutingInspection(value) {
     const routing = record(value);
     if (routing?.version !== 2) {
@@ -174,11 +544,94 @@ export function callInspection(modelCall) {
     const evalRunId = string(evalAttribution?.run_id);
     const evalCaseId = string(evalAttribution?.case_id);
     const estimateUsd = number(metadata?.cost_estimate_usd);
+    const providerCashUsd = number(metadata?.provider_cash_usd);
+    const subscription = subscriptionInspection(metadata?.subscription_valuation);
+    const routingCost = routingHop(metadata?.routing_cost) ?? routingHop(attribution?.routing_cost);
     const attempts = number(attribution?.attempts) ?? 1;
     const retries = number(attribution?.retries) ?? Math.max(0, attempts - 1);
     const accountFailovers = number(attribution?.account_failovers) ?? 0;
+    const costUsage = subscription?.usage ?? {
+        ...(modelCall.usage?.prompt_tokens === undefined
+            ? {}
+            : { inputTokens: modelCall.usage.prompt_tokens }),
+        ...(modelCall.usage?.cached_input_tokens === undefined
+            ? {}
+            : { cachedInputTokens: modelCall.usage.cached_input_tokens }),
+        ...(modelCall.usage?.completion_tokens === undefined
+            ? {}
+            : { outputTokens: modelCall.usage.completion_tokens }),
+        ...(modelCall.usage?.reasoning_tokens === undefined
+            ? {}
+            : { reasoningTokens: modelCall.usage.reasoning_tokens })
+    };
+    const computedCacheOutcome = routingCost?.cacheOutcome ??
+        routingCacheOutcome(costUsage, lookupModelPricing(effectiveModel), effectiveModel, routingCost?.previousModel);
+    const actuals = attributeModelCosts([
+        {
+            episodeId: routingCost?.episodeId ?? modelCall.call_id,
+            hopIndex: routingCost?.hopIndex ?? 0,
+            role: routingCost?.role ?? "explicit",
+            model: effectiveModel,
+            ...(routingCost?.previousModel === undefined
+                ? {}
+                : { previousModel: routingCost.previousModel }),
+            ...(computedCacheOutcome === undefined ? {} : { cacheOutcome: computedCacheOutcome }),
+            usage: costUsage,
+            billingMode: billingMode === "api_key"
+                ? "metered-api"
+                : billingMode === "subscription"
+                    ? "subscription"
+                    : "upstream-managed",
+            ...(providerCashUsd === undefined ? {} : { providerCostUsd: providerCashUsd }),
+            ...(subscription === undefined ? {} : { subscriptionValuation: subscription })
+        }
+    ]);
+    const hopCost = actuals.episodes[0]?.hops[0];
     return {
         callId: modelCall.call_id,
+        episodeId: routingCost?.episodeId ?? modelCall.call_id,
+        hopIndex: routingCost?.hopIndex ?? 0,
+        role: routingCost?.role ?? "explicit",
+        ...(routingCost?.previousModel === undefined
+            ? {}
+            : { previousModel: routingCost.previousModel }),
+        ...(computedCacheOutcome === undefined ? {} : { cacheOutcome: computedCacheOutcome }),
+        episode: {
+            episodeId: routingCost?.episodeId ?? modelCall.call_id,
+            hopCount: 1,
+            models: [effectiveModel],
+            cacheOutcomes: computedCacheOutcome === undefined ? [] : [computedCacheOutcome],
+            ...(actuals.episodes[0]?.cashUsd === undefined
+                ? {}
+                : { cashUsd: actuals.episodes[0].cashUsd }),
+            ...(actuals.episodes[0]?.window === undefined
+                ? {}
+                : { window: actuals.episodes[0].window }),
+            subscriptionUnitCalls: actuals.episodes[0]?.subscriptionUnitCalls ?? 0,
+            ...(actuals.episodes[0]?.apiEquivalentUsd === undefined
+                ? {}
+                : { apiEquivalentUsd: actuals.episodes[0].apiEquivalentUsd }),
+            classifierUsd: actuals.episodes[0]?.classifierUsd ?? 0,
+            ...(actuals.episodes[0]?.classifierWindow === undefined
+                ? {}
+                : { classifierWindow: actuals.episodes[0].classifierWindow }),
+            failoverUsd: actuals.episodes[0]?.failoverUsd ?? 0,
+            ...(actuals.episodes[0]?.failoverWindow === undefined
+                ? {}
+                : { failoverWindow: actuals.episodes[0].failoverWindow }),
+            switchMissTokens: actuals.episodes[0]?.switchMissTokens ?? 0,
+            ...(actuals.episodes[0]?.taxCashUsd === undefined
+                ? {}
+                : { taxCashUsd: actuals.episodes[0].taxCashUsd }),
+            ...(actuals.episodes[0]?.taxWindow === undefined
+                ? {}
+                : { taxWindow: actuals.episodes[0].taxWindow }),
+            ...(actuals.episodes[0]?.taxApiEquivalentUsd === undefined
+                ? {}
+                : { taxApiEquivalentUsd: actuals.episodes[0].taxApiEquivalentUsd }),
+            switchMissPremiumUsd: actuals.episodes[0]?.switchMissPremiumUsd ?? 0,
+            stickyCounterfactuals: actuals.episodes[0]?.stickyCounterfactuals ?? []
+        },
         status: modelCall.status,
         ...(stopReason !== undefined ? { stopReason } : {}),
         ...(requestedModel !== undefined ? { requestedModel } : {}),
@@ -217,7 +670,23 @@ export function callInspection(modelCall) {
         cost: {
             ...(estimateUsd !== undefined ? { estimateUsd } : {}),
             unknownUsage: boolean(metadata?.unknown_usage),
-            unknownCost: boolean(metadata?.unknown_cost)
+            unknownCost: boolean(metadata?.unknown_cost),
+            ...(hopCost?.cashUsd === undefined ? {} : { cashUsd: hopCost.cashUsd }),
+            ...(hopCost?.window === undefined ? {} : { window: hopCost.window }),
+            ...(hopCost?.apiEquivalentUsd === undefined
+                ? {}
+                : { apiEquivalentUsd: hopCost.apiEquivalentUsd }),
+            ...(hopCost?.taxCashUsd === undefined ? {} : { taxCashUsd: hopCost.taxCashUsd }),
+            ...(hopCost?.taxWindow === undefined ? {} : { taxWindow: hopCost.taxWindow }),
+            ...(hopCost?.taxApiEquivalentUsd === undefined
+                ? {}
+                : { taxApiEquivalentUsd: hopCost.taxApiEquivalentUsd }),
+            ...(hopCost?.stickyCounterfactual === undefined
+                ? {}
+                : { stickyCounterfactual: hopCost.stickyCounterfactual }),
+            switchMissPremiumUsd: hopCost?.switchMissPremiumUsd ?? 0,
+            ...(providerCashUsd === undefined ? {} : { providerCashUsd }),
+            ...(subscription === undefined ? {} : { subscription })
         },
         timing: {
             startedAt: modelCall.started_at,
@@ -271,6 +740,7 @@ export class CallAttributionStore {
         this.#prune(now);
         this.#entries.delete(inspection.callId);
         this.#entries.set(inspection.callId, { inspection, insertedAt: now });
+        this.#refreshEpisode(inspection.episodeId);
         while (this.#entries.size > this.#limit) {
             const oldest = this.#entries.keys().next().value;
             if (oldest === undefined)
@@ -279,6 +749,79 @@ export class CallAttributionStore {
             this.#evicted = true;
         }
     }
+    #refreshEpisode(episodeId) {
+        const entries = [...this.#entries.values()]
+            .filter((entry) => entry.inspection.episodeId === episodeId)
+            .sort((left, right) => left.inspection.hopIndex - right.inspection.hopIndex);
+        if (entries.length === 0)
+            return;
+        const actuals = attributeModelCosts(entries.map(({ inspection }) => ({
+            episodeId,
+            hopIndex: inspection.hopIndex,
+            role: inspection.role,
+            model: inspection.effectiveModel,
+            ...(inspection.previousModel === undefined
+                ? {}
+                : { previousModel: inspection.previousModel }),
+            ...(inspection.cacheOutcome === undefined
+                ? {}
+                : { cacheOutcome: inspection.cacheOutcome }),
+            usage: inspection.cost.subscription?.usage ??
+                (inspection.usage === undefined
+                    ? undefined
+                    : {
+                        inputTokens: inspection.usage.prompt_tokens,
+                        cachedInputTokens: inspection.usage.cached_input_tokens,
+                        outputTokens: inspection.usage.completion_tokens,
+                        reasoningTokens: inspection.usage.reasoning_tokens
+                    }),
+            billingMode: inspection.billingMode === "api_key"
+                ? "metered-api"
+                : inspection.billingMode === "subscription"
+                    ? "subscription"
+                    : "upstream-managed",
+            ...(inspection.cost.providerCashUsd === undefined
+                ? {}
+                : { providerCostUsd: inspection.cost.providerCashUsd }),
+            ...(inspection.cost.subscription === undefined
+                ? {}
+                : { subscriptionValuation: inspection.cost.subscription })
+        })));
+        const rollup = actuals.episodes[0];
+        if (rollup === undefined)
+            return;
+        const episode = {
+            episodeId,
+            hopCount: rollup.hopCount,
+            models: rollup.models,
+            cacheOutcomes: rollup.hops.flatMap((hop) => hop.cacheOutcome === undefined ? [] : [hop.cacheOutcome]),
+            ...(rollup.cashUsd === undefined ? {} : { cashUsd: rollup.cashUsd }),
+            ...(rollup.window === undefined ? {} : { window: rollup.window }),
+            subscriptionUnitCalls: rollup.subscriptionUnitCalls,
+            ...(rollup.apiEquivalentUsd === undefined
+                ? {}
+                : { apiEquivalentUsd: rollup.apiEquivalentUsd }),
+            classifierUsd: rollup.classifierUsd,
+            ...(rollup.classifierWindow === undefined
+                ? {}
+                : { classifierWindow: rollup.classifierWindow }),
+            failoverUsd: rollup.failoverUsd,
+            ...(rollup.failoverWindow === undefined
+                ? {}
+                : { failoverWindow: rollup.failoverWindow }),
+            switchMissTokens: rollup.switchMissTokens,
+            ...(rollup.taxCashUsd === undefined ? {} : { taxCashUsd: rollup.taxCashUsd }),
+            ...(rollup.taxWindow === undefined ? {} : { taxWindow: rollup.taxWindow }),
+            ...(rollup.taxApiEquivalentUsd === undefined
+                ? {}
+                : { taxApiEquivalentUsd: rollup.taxApiEquivalentUsd }),
+            switchMissPremiumUsd: rollup.switchMissPremiumUsd,
+            stickyCounterfactuals: rollup.stickyCounterfactuals
+        };
+        for (const entry of entries) {
+            entry.inspection = { ...entry.inspection, episode };
+        }
+    }
     get(callId) {
         this.#prune(this.#now());
         return this.#entries.get(callId)?.inspection;

package/dist/control-dispatch.js

@@ -1,7 +1,6 @@
-import { controlOperation, createRouteKitControlHandler } from "@velum-labs/routekit-control";
+import { controlAuthorization, controlIdempotency, controlMutation, controlOperation, createRouteKitControlHandler, isRouteKitControlMethod } from "@velum-labs/routekit-control";
 import { ControlError } from "@velum-labs/routekit-runtime/control";
 import { durationBucket } from "@velum-labs/routekit-telemetry-core";
-import { createDaemonControlMethodRegistry } from "./application-services.js";
 function captureOperation(options, method, params, outcome, durationMs) {
     const operation = controlOperation(method, params);
     if (operation === undefined)
@@ -13,21 +12,20 @@ function captureOperation(options, method, params, outcome, durationMs) {
         version: options.packageVersion
     });
 }
-function enforceDefinition(registry, runtimeState, method, context) {
-    const definition = registry.definition(method);
-    if (definition.authorization === "ephemeral" && context.principal?.role !== "ephemeral") {
+function enforceDefinition(runtimeState, method, context) {
+    if (controlAuthorization(method) === "ephemeral" && context.principal?.role !== "ephemeral") {
         throw new ControlError({
             code: "unauthorized",
             message: `${method} requires the local service credential`
         });
     }
-    if (definition.idempotency === "required" && context.idempotencyKey === undefined) {
+    if (controlIdempotency(method) === "required" && context.idempotencyKey === undefined) {
         throw new ControlError({
             code: "bad_request",
             message: `${method} requires an idempotency key`
         });
     }
-    if (runtimeState.lifecycle === "paused" && definition.mutation === "mutation") {
+    if (runtimeState.lifecycle === "paused" && controlMutation(method) === "mutation") {
         throw new ControlError({
             code: "unavailable",
             message: "RouteKit daemon is synchronizing a replacement worker"
@@ -35,22 +33,18 @@ function enforceDefinition(registry, runtimeState, method, context) {
     }
 }
 export function createDaemonControlDispatch(options) {
-    const registry = createDaemonControlMethodRegistry(options.handlers);
-    const registeredMethods = new Set(registry.list().map((definition) => definition.method));
-    const routeKitDispatch = createRouteKitControlHandler(registry.handlers(), {
-        registry,
+    const routeKitDispatch = createRouteKitControlHandler(options.handlers, {
         onCommitted: (method, params, durationMs) => captureOperation(options, method, params, "success", durationMs),
         onControlError: (method, params, _code, durationMs) => captureOperation(options, method, params, "error", durationMs)
     });
     return async (rawMethod, params, context) => {
-        if (!registeredMethods.has(rawMethod)) {
+        if (!isRouteKitControlMethod(rawMethod)) {
             return await routeKitDispatch(rawMethod, params, context);
         }
         const method = rawMethod;
-        enforceDefinition(registry, options.runtimeState, method, context);
-        const definition = registry.definition(method);
+        enforceDefinition(options.runtimeState, method, context);
         if (options.executeIdempotent !== undefined &&
-            definition.mutation === "mutation" &&
+            controlMutation(method) === "mutation" &&
             context.idempotencyKey !== undefined) {
             return await options.executeIdempotent({
                 method,

package/dist/daemon-bootstrap-preflight.js

@@ -9,7 +9,7 @@ import { healthyControl, readDaemonRevisions } from "./daemon-state.js";
 export async function prepareDaemonBootstrap(options) {
     const env = options.env ?? process.env;
     const home = options.stateHome ?? routekitHome(env);
-    const configPath = options.configPath ?? globalRouterConfigPath();
+    const configPath = options.configPath ?? globalRouterConfigPath(undefined, env);
     const drainGraceMs = options.drainGraceMs ?? 30_000;
     const store = createServiceRecordStore({ home, product: "routekit" });
     const hosted = options.hosted;

package/dist/daemon-control-handlers.d.ts

@@ -1,6 +1,6 @@
 import type { EffectRouteKitControlHandlers } from "@velum-labs/routekit-control/effect";
 /**
- * Composes owned application services into the daemon control handler map.
+ * Composes owned handler groups into the daemon control handler map.
  * Protocol policy lives in the method table; this function only binds use cases.
  * Daemon-lifetime state is yielded from `daemonLive`.
  */