@sema-ai/registry-core 0.10.3

package/dist/fleet.d.ts

@@ -0,0 +1,479 @@
+/**
+ * @sema-ai/registry-core/fleet — the PURE scheduling/fleet contract for the sema-center control plane
+ * (design: cc-parity CONTROL-PLANE-SCHEDULING-DESIGN.md, clay 拍 2026-07-04 — "one contract, three orchestrators").
+ *
+ * Seven domains (rolling update / discovery / traffic / failover / LB / quota / token governance) are ONE
+ * data-plane lifecycle contract reused by three deployment forms — whoever HOLDS the engine handle orchestrates,
+ * but all three read THESE shapes:
+ *   - TOC shell (engineLifecycleManager): health readiness + upgrade classification + local blue-green demo
+ *   - TOB (user k8s / fixed baseurl):     preStop→drain semantics + readiness probe = !draining
+ *   - center (orchestrator reconciler):   instance discovery table + /api/dispatch gateway + rolling primitive
+ *
+ * 🔴 Contract discipline (same rules as scheduler-store):
+ *   - ABSTRACT: types + zod wire shapes + PURE decision functions. ZERO IO, ZERO node:* — browser-safe barrel.
+ *   - FINAL-STATE: shapes codify what is SHIPPED on the wire (server 1.96.0 drain: /health `version`/`draining`/
+ *     `drainingSince`, billable submit 503+Retry-After) — no transitional aliases, breaking changes over shims
+ *     (clay 拍: no temporary compatibility design; the target is long-term stability).
+ *   - EXTENSIBLE: enums + optional fields externalize decisions (add an LB strategy = add an enum value,
+ *     the skeleton does not move).
+ */
+import { z } from "zod";
+/** Lifecycle of a draining instance. `running`→`draining` on the stop signal; `drained` once in-flight hits
+ *  zero (clean) or the grace deadline forces the issue. Exit always follows `drained`. */
+export declare const DRAIN_PHASES: readonly ["running", "draining", "drained"];
+export type DrainPhase = (typeof DRAIN_PHASES)[number];
+/** Shipped default (server 1.96.0): generous by design — the only unrecoverable loss on restart is the
+ *  interactive turn currently streaming, so we wait long rather than cut short. Deployments override via
+ *  DRAIN_GRACE_MS; center overrides per-worker through the worker spec. */
+export declare const DEFAULT_DRAIN_GRACE_MS = 600000;
+/** Hard floor — a grace below this is treated as this (protects against a fat-fingered 0). */
+export declare const DRAIN_GRACE_FLOOR_MS = 10000;
+/** `Retry-After` (seconds) on the 503 a draining instance returns for NEW billable submissions. Read paths,
+ *  steer/cancel/respond stay open — only new work is refused. */
+export declare const DRAIN_RETRY_AFTER_SECONDS = 15;
+/** What a draining decision needs to know — all times are epoch ms supplied by the caller (pure fn, no clock). */
+export interface DrainSnapshot {
+    /** when the stop signal flipped `draining` on */
+    startedMs: number;
+    nowMs: number;
+    /** configured grace (DRAIN_GRACE_MS / worker-spec override); floored at DRAIN_GRACE_FLOOR_MS */
+    graceMs: number;
+    /** in-flight billable legs (inflight runs ∪ steerable runs) */
+    inflight: number;
+}
+export type DrainVerdict = "wait" | "exit_clean" | "exit_forced";
+/** The drain state machine's single decision point: keep waiting, exit clean (drained), or force the exit
+ *  (grace exhausted with legs still in flight — durable legs resume cross-instance via resumeFromRunId). */
+export declare function drainVerdict(s: DrainSnapshot): DrainVerdict;
+/** The `/health` self-description every orchestrator reads (shipped shape, server 1.96.0). Liveness and
+ *  readiness are deliberately SPLIT: `status` stays ok while draining (the process is alive); routability is
+ *  `isReadyForTraffic`. Unknown fields pass through — health is a self-description, not a closed record. */
+export declare const InstanceHealth: z.ZodObject<{
+    instanceId: z.ZodString;
+    /** build self-description — "did the restart actually land new code" (upgrade classification) */
+    version: z.ZodString;
+    /** absent = not draining */
+    draining: z.ZodOptional<z.ZodBoolean>;
+    /** epoch ms, present iff draining */
+    drainingSince: z.ZodOptional<z.ZodNumber>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    instanceId: z.ZodString;
+    /** build self-description — "did the restart actually land new code" (upgrade classification) */
+    version: z.ZodString;
+    /** absent = not draining */
+    draining: z.ZodOptional<z.ZodBoolean>;
+    /** epoch ms, present iff draining */
+    drainingSince: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    instanceId: z.ZodString;
+    /** build self-description — "did the restart actually land new code" (upgrade classification) */
+    version: z.ZodString;
+    /** absent = not draining */
+    draining: z.ZodOptional<z.ZodBoolean>;
+    /** epoch ms, present iff draining */
+    drainingSince: z.ZodOptional<z.ZodNumber>;
+}, z.ZodTypeAny, "passthrough">>;
+export type InstanceHealth = z.infer<typeof InstanceHealth>;
+/** Readiness = the routability predicate (k8s readiness probe, gateway health filter, shell seam switch). */
+export declare function isReadyForTraffic(h: Pick<InstanceHealth, "draining">): boolean;
+/** Heartbeat cadence the announcement declares (center judges staleness against the DECLARED cadence, so a
+ *  slow-heartbeat worker is not falsely reaped). */
+export declare const DEFAULT_HEARTBEAT_MS = 30000;
+/** An instance is stale once silent for this many missed heartbeats (aligned with the reconciler's own
+ *  stale window: 2× cadence, not a fixed wall-clock). */
+export declare const STALE_HEARTBEAT_MULTIPLIER = 2;
+/** Register/heartbeat upsert (worker → center, D2: worker-active). ONE shape for both — registration is the
+ *  first heartbeat; every heartbeat re-announces the full row (idempotent upsert, no drift between a
+ *  "register" and a "renew" schema). `draining:true` is the instance SELF-removing from the routable set the
+ *  moment the stop signal lands — faster than any observer. */
+export declare const InstanceAnnouncement: z.ZodObject<{
+    instanceId: z.ZodString;
+    /** worker (deployment) this instance belongs to — the dispatch key */
+    worker: z.ZodString;
+    /** reachable base URL for the deployment form: k8s pod IP:port / docker net alias / 127.0.0.1:<engine.port> */
+    address: z.ZodString;
+    version: z.ZodString;
+    /** self-declared: bootDone && !draining */
+    ready: z.ZodBoolean;
+    draining: z.ZodDefault<z.ZodBoolean>;
+    heartbeatMs: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    draining: boolean;
+    instanceId: string;
+    version: string;
+    worker: string;
+    address: string;
+    ready: boolean;
+    heartbeatMs: number;
+}, {
+    instanceId: string;
+    version: string;
+    worker: string;
+    address: string;
+    ready: boolean;
+    draining?: boolean | undefined;
+    heartbeatMs?: number | undefined;
+}>;
+export type InstanceAnnouncement = z.infer<typeof InstanceAnnouncement>;
+/** Explicit goodbye (stop signal handler) — removes the row immediately instead of waiting out staleness. */
+export declare const InstanceDeregistration: z.ZodObject<{
+    instanceId: z.ZodString;
+    worker: z.ZodString;
+    reason: z.ZodOptional<z.ZodEnum<["draining", "shutdown", "superseded"]>>;
+}, "strip", z.ZodTypeAny, {
+    instanceId: string;
+    worker: string;
+    reason?: "draining" | "shutdown" | "superseded" | undefined;
+}, {
+    instanceId: string;
+    worker: string;
+    reason?: "draining" | "shutdown" | "superseded" | undefined;
+}>;
+export type InstanceDeregistration = z.infer<typeof InstanceDeregistration>;
+/** The stored discovery-table row = last announcement + center-side bookkeeping. `observedReady` is the
+ *  reconciler's observation (phase Running) — the SECOND source; absent where no reconciler exists (TOC/TOB). */
+export declare const InstanceRegistration: z.ZodObject<{
+    instanceId: z.ZodString;
+    /** worker (deployment) this instance belongs to — the dispatch key */
+    worker: z.ZodString;
+    /** reachable base URL for the deployment form: k8s pod IP:port / docker net alias / 127.0.0.1:<engine.port> */
+    address: z.ZodString;
+    version: z.ZodString;
+    /** self-declared: bootDone && !draining */
+    ready: z.ZodBoolean;
+    draining: z.ZodDefault<z.ZodBoolean>;
+    heartbeatMs: z.ZodDefault<z.ZodNumber>;
+} & {
+    registeredMs: z.ZodNumber;
+    lastSeenMs: z.ZodNumber;
+    observedReady: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    draining: boolean;
+    instanceId: string;
+    version: string;
+    worker: string;
+    address: string;
+    ready: boolean;
+    heartbeatMs: number;
+    registeredMs: number;
+    lastSeenMs: number;
+    observedReady?: boolean | undefined;
+}, {
+    instanceId: string;
+    version: string;
+    worker: string;
+    address: string;
+    ready: boolean;
+    registeredMs: number;
+    lastSeenMs: number;
+    draining?: boolean | undefined;
+    heartbeatMs?: number | undefined;
+    observedReady?: boolean | undefined;
+}>;
+export type InstanceRegistration = z.infer<typeof InstanceRegistration>;
+/** Silent past the declared cadence × multiplier ⇒ stale (auto-removed from the routable set). */
+export declare function isInstanceStale(r: Pick<InstanceRegistration, "lastSeenMs" | "heartbeatMs">, nowMs: number): boolean;
+/** Health fusion: routable ⇔ self-declared ready ∧ not draining ∧ not stale ∧ observer does not veto.
+ *  Two sources merge as an AND — EITHER source's "not ready" removes the instance (fail-closed). */
+export declare function isRoutable(r: InstanceRegistration, nowMs: number): boolean;
+export declare function routableInstances(rs: InstanceRegistration[], nowMs: number): InstanceRegistration[];
+export declare const DISPATCH_STRATEGIES: readonly ["round-robin", "least-inflight", "consistent-hash"];
+export type DispatchStrategy = (typeof DISPATCH_STRATEGIES)[number];
+/** Per-worker dispatch policy (center-configured; the gateway is OPTIONAL — D3: TOC/self-maintained TOB go
+ *  direct, sema-managed fleets route through /api/dispatch). Strategy is an enum on purpose: a new LB
+ *  algorithm is a new value, not a new skeleton. */
+export declare const DispatchPolicy: z.ZodObject<{
+    strategy: z.ZodDefault<z.ZodEnum<["round-robin", "least-inflight", "consistent-hash"]>>;
+    /** live-steer legs must return to their instance (cross-replica live-steer is 409 by design) — when true,
+     *  a request carrying an affinity key pins via consistent hash regardless of `strategy`. If the pinned
+     *  instance dies, the run resumes elsewhere via resumeFromRunId (affinity avoids the gap; resume bounds it). */
+    sessionAffinity: z.ZodDefault<z.ZodBoolean>;
+    /** gateway-level concurrency gate (per worker) */
+    maxInflight: z.ZodOptional<z.ZodNumber>;
+    /** per-actor fairness gate */
+    perActorMaxInflight: z.ZodOptional<z.ZodNumber>;
+    /** cost clamp applied to submissions passing the gateway */
+    maxCostUsd: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "round-robin" | "least-inflight" | "consistent-hash";
+    sessionAffinity: boolean;
+    maxInflight?: number | undefined;
+    perActorMaxInflight?: number | undefined;
+    maxCostUsd?: number | undefined;
+}, {
+    strategy?: "round-robin" | "least-inflight" | "consistent-hash" | undefined;
+    sessionAffinity?: boolean | undefined;
+    maxInflight?: number | undefined;
+    perActorMaxInflight?: number | undefined;
+    maxCostUsd?: number | undefined;
+}>;
+export type DispatchPolicy = z.infer<typeof DispatchPolicy>;
+/** 🔴 Submit idempotency — the precondition that makes failover re-routing SAFE: a new-run submission MUST
+ *  carry the client-minted durable taskId, and the server dedupes on it. Without this, "landed but the
+ *  response was lost" re-routes into a duplicate run. Re-route freely: reads (always) and submissions
+ *  (iff keyed). In-flight interactive turns are NEVER auto-retried (tool side effects are not idempotent). */
+export declare const SUBMIT_IDEMPOTENCY_KEY = "taskId";
+export interface DispatchCandidate {
+    instanceId: string;
+    /** current in-flight count, for least-inflight (absent = 0) */
+    inflight?: number;
+}
+/**
+ * The single instance-selection decision, PURE and deterministic:
+ *   - candidates are sorted by instanceId first ⇒ the pick is stable under input reordering;
+ *   - `affinityKey` (+ sessionAffinity or consistent-hash strategy) ⇒ stable hash pick — same key, same
+ *     instance, for as long as the candidate set holds (live-steer affinity);
+ *   - round-robin consumes `cursor` (caller-held monotonic counter);
+ *   - least-inflight breaks ties by lowest instanceId.
+ * Returns null on an empty candidate set (caller surfaces "no routable instance").
+ */
+export declare function pickInstance(policy: DispatchPolicy, candidates: DispatchCandidate[], opts?: {
+    cursor?: number;
+    affinityKey?: string;
+}): DispatchCandidate | null;
+/** A pre-authorized slice of a principal's global budget, granted by center to ONE worker: the worker deducts
+ *  locally (no per-call round-trip), renews when running low, and center reconciles reported consumption
+ *  against the grant after the fact — the roaming/CDN pattern.
+ *
+ *  0.6.1 双轴 slice(EXPERT-REDESIGN §4-2/§4-6,黑板 [542] service 回执"发布即接单"):slice = **{weightedTokens,
+ *  costMicroUsd}** 双轴,带 TTL 不变。token 轴单位=**加权 tokens**(配额轴,ModelEntry.quotaWeight 的
+ *  weight-at-burn 折算——与 UsageEntry.weightedTokens 同一时点同口径,扣减与聚合两路径不歪)。判定语义在
+ *  类型层定死:**任一轴耗尽 = 拒绝**({@link leaseExhausted} deny-wins)、**任一轴达 80% = 提前续租**
+ *  ({@link shouldRenewLease})。$ 轴名 `costMicroUsd` 沿用 0.5 既定名不改(service $ 单轴已 SHIPPED)。
+ *  0.7.1(BREAKING,黑板 [551] 回执收账):0.5 轴名 `tokens` 的 preprocess shim 已撤——service 1.150.0
+ *  已切 typed 双轴,legacy 别名成死分支;老形状租约 parse 后 tokens 键被 strip(= 该轴不受此租约治理)。 */
+export declare const QuotaLease: z.ZodObject<{
+    leaseId: z.ZodString;
+    principal: z.ZodString;
+    worker: z.ZodString;
+    /** granted dimensions — either or both; a dimension absent = not governed by this lease.
+     *  `weightedTokens` = 加权 tokens(配额轴)。 */
+    grant: z.ZodObject<{
+        weightedTokens: z.ZodOptional<z.ZodNumber>;
+        costMicroUsd: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        weightedTokens?: number | undefined;
+        costMicroUsd?: number | undefined;
+    }, {
+        weightedTokens?: number | undefined;
+        costMicroUsd?: number | undefined;
+    }>;
+    consumed: z.ZodDefault<z.ZodObject<{
+        weightedTokens: z.ZodDefault<z.ZodNumber>;
+        costMicroUsd: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        weightedTokens: number;
+        costMicroUsd: number;
+    }, {
+        weightedTokens?: number | undefined;
+        costMicroUsd?: number | undefined;
+    }>>;
+    issuedMs: z.ZodNumber;
+    expiresMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    worker: string;
+    leaseId: string;
+    principal: string;
+    grant: {
+        weightedTokens?: number | undefined;
+        costMicroUsd?: number | undefined;
+    };
+    consumed: {
+        weightedTokens: number;
+        costMicroUsd: number;
+    };
+    issuedMs: number;
+    expiresMs: number;
+}, {
+    worker: string;
+    leaseId: string;
+    principal: string;
+    grant: {
+        weightedTokens?: number | undefined;
+        costMicroUsd?: number | undefined;
+    };
+    issuedMs: number;
+    expiresMs: number;
+    consumed?: {
+        weightedTokens?: number | undefined;
+        costMicroUsd?: number | undefined;
+    } | undefined;
+}>;
+export type QuotaLease = z.infer<typeof QuotaLease>;
+/** Remaining per granted dimension; null = the dimension is not governed by this lease. Never negative. */
+export declare function leaseRemaining(l: QuotaLease): {
+    weightedTokens: number | null;
+    costMicroUsd: number | null;
+};
+/** Exhausted ⇔ ANY governed dimension is used up (deny-wins across the two axes — 任一轴耗尽即拒), or the
+ *  lease expired. */
+export declare function leaseExhausted(l: QuotaLease, nowMs: number): boolean;
+/** Renew EARLY — at `renewAtFraction` of ANY governed dimension (default 80% — 任一轴达 80% 即提前续租) or
+ *  of the lease lifetime — so the refresh round-trip overlaps remaining headroom instead of blocking a call
+ *  at zero. */
+export declare function shouldRenewLease(l: QuotaLease, nowMs: number, opts?: {
+    renewAtFraction?: number;
+}): boolean;
+/** Reconciliation (center side): consumption is MONOTONE — the reconciled row takes the max of what center
+ *  believed and what the worker reported (a lost report can only under-count, never roll back).
+ *  0.7.1:legacy `tokens` report alias removed with the QuotaLease shim(同一收账点,[551] 回执). */
+export declare function reconcileLease(l: QuotaLease, reported: {
+    weightedTokens?: number;
+    costMicroUsd?: number;
+}): QuotaLease;
+/** One principal×model line in a report window (mirrors the worker's modelUsageTracker accumulation). */
+export declare const UsageEntry: z.ZodObject<{
+    principal: z.ZodString;
+    model: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    costMicroUsd: z.ZodNumber;
+    runs: z.ZodOptional<z.ZodNumber>;
+    /** 加权 tokens(配额轴计账值,EXPERT-REDESIGN §4-1):=(input+output)×记账时的 quotaWeight,
+     *  **weight-at-burn 持久化**——倍率 publish 只影响此后记账,不回算窗口内历史(余量/恢复时间不跳变)。
+     *  0.6.0 additive optional:旧 worker 不报 → 聚合按 quotaWeight=1 兜底折算。 */
+    weightedTokens: z.ZodOptional<z.ZodNumber>;
+    /** 记账时固化的该模型 quotaWeight(审计口径,与 weightedTokens 同时点)——lease 扣减与 registry 聚合两
+     *  路径按同一时点折算(同口径,§11-1)。 */
+    quotaWeightAtUse: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    principal: string;
+    costMicroUsd: number;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    weightedTokens?: number | undefined;
+    runs?: number | undefined;
+    quotaWeightAtUse?: number | undefined;
+}, {
+    principal: string;
+    costMicroUsd: number;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    weightedTokens?: number | undefined;
+    runs?: number | undefined;
+    quotaWeightAtUse?: number | undefined;
+}>;
+export type UsageEntry = z.infer<typeof UsageEntry>;
+/** Periodic batch (worker → center POST). Windows are half-open [start, end) so adjacent batches never
+ *  double-count a boundary instant. */
+export declare const UsageReport: z.ZodObject<{
+    worker: z.ZodString;
+    instanceId: z.ZodString;
+    windowStartMs: z.ZodNumber;
+    windowEndMs: z.ZodNumber;
+    entries: z.ZodArray<z.ZodObject<{
+        principal: z.ZodString;
+        model: z.ZodString;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        costMicroUsd: z.ZodNumber;
+        runs: z.ZodOptional<z.ZodNumber>;
+        /** 加权 tokens(配额轴计账值,EXPERT-REDESIGN §4-1):=(input+output)×记账时的 quotaWeight,
+         *  **weight-at-burn 持久化**——倍率 publish 只影响此后记账,不回算窗口内历史(余量/恢复时间不跳变)。
+         *  0.6.0 additive optional:旧 worker 不报 → 聚合按 quotaWeight=1 兜底折算。 */
+        weightedTokens: z.ZodOptional<z.ZodNumber>;
+        /** 记账时固化的该模型 quotaWeight(审计口径,与 weightedTokens 同时点)——lease 扣减与 registry 聚合两
+         *  路径按同一时点折算(同口径,§11-1)。 */
+        quotaWeightAtUse: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        principal: string;
+        costMicroUsd: number;
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        weightedTokens?: number | undefined;
+        runs?: number | undefined;
+        quotaWeightAtUse?: number | undefined;
+    }, {
+        principal: string;
+        costMicroUsd: number;
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        weightedTokens?: number | undefined;
+        runs?: number | undefined;
+        quotaWeightAtUse?: number | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    instanceId: string;
+    entries: {
+        principal: string;
+        costMicroUsd: number;
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        weightedTokens?: number | undefined;
+        runs?: number | undefined;
+        quotaWeightAtUse?: number | undefined;
+    }[];
+    worker: string;
+    windowStartMs: number;
+    windowEndMs: number;
+}, {
+    instanceId: string;
+    entries: {
+        principal: string;
+        costMicroUsd: number;
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        weightedTokens?: number | undefined;
+        runs?: number | undefined;
+        quotaWeightAtUse?: number | undefined;
+    }[];
+    worker: string;
+    windowStartMs: number;
+    windowEndMs: number;
+}>;
+export type UsageReport = z.infer<typeof UsageReport>;
+/** 额度清零事件(EXPERT-REDESIGN §4-4,契约随 E1 冻结、E4 消费):申请刷新获批即写一条;5h/周双窗聚合
+ *  **只计最后一次 reset 之后**的 usage 报文(usage_report 是计费审计事实,全量留存,绝不删)。拒绝逻辑/
+ *  恢复时间/用量卡读数全部感知 reset;批准生效延迟 ≤ 一次租约 TTL(旧租约续租时放行)。 */
+export declare const QuotaResetEvent: z.ZodObject<{
+    id: z.ZodString;
+    principal: z.ZodString;
+    /** 清零生效时刻(ISO)——双窗聚合的下边界。 */
+    reset_at: z.ZodString;
+    /** 批准人(console username)。 */
+    decided_by: z.ZodString;
+    /** 关联的 quota_refresh_request id;admin 直接清零(无申请)时可缺。 */
+    request_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    principal: string;
+    id: string;
+    reset_at: string;
+    decided_by: string;
+    request_id?: string | undefined;
+}, {
+    principal: string;
+    id: string;
+    reset_at: string;
+    decided_by: string;
+    request_id?: string | undefined;
+}>;
+export type QuotaResetEvent = z.infer<typeof QuotaResetEvent>;
+export interface AggregatedPrincipalUsage {
+    inputTokens: number;
+    outputTokens: number;
+    costMicroUsd: number;
+    runs: number;
+    /** 加权 tokens 总量(配额轴,§4-1/§11-1):兑现 UsageEntry doc 的聚合承诺——entry 带 weightedTokens 用
+     *  原值;旧 worker 不报 → 按 quotaWeightAtUse(缺省 1)兜底折算 (input+output)×weight。与 lease 扣减同
+     *  口径,E4 双窗读数直接复用(E1 评审 opus MINOR:doc/impl 自相矛盾修复)。quotaWeightAtUse 是审计
+     *  时点值,不聚合。 */
+    weightedTokens: number;
+    byModel: Record<string, {
+        inputTokens: number;
+        outputTokens: number;
+        costMicroUsd: number;
+        runs: number;
+        weightedTokens: number;
+    }>;
+}
+/** Center-side fold: per-principal totals ACROSS workers/instances (the "one user, many workers, one bill"
+ *  view). Pure — storage/dedup of replayed batches is the caller's concern (key batches by
+ *  worker+instanceId+windowStartMs). */
+export declare function aggregateUsage(reports: UsageReport[]): Record<string, AggregatedPrincipalUsage>;
+//# sourceMappingURL=fleet.d.ts.map

package/dist/fleet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleet.d.ts","sourceRoot":"","sources":["../src/fleet.ts"],"names":[],"mappings":"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"}