@fonoster/common 0.30.0 → 0.31.0

package/dist/sessions/index.js

@@ -21,21 +21,24 @@ exports.openSessions = openSessions;
 exports.watchSessions = watchSessions;
 exports.getSession = getSession;
 /**
- * The session registry (add-platform 2.3, add-media-node 3.2, decision D3): one NATS JetStream KV
+ * The session registry (add-platform 2.3, add-roomr 3.2, decision D3): one NATS JetStream KV
  * bucket shared by every service. Keys are `<kind>.<id>`:
  *
- *   nodes.<nodeId>        media node: { nodeId, rooms, draining, at }      (written by the node)
- *   rooms.<roomRef>       media node: { roomRef, nodeId, at }              (written by the node)
- *   calls.<callRef>       gateway:    { callRef, gatewayRef, nodeId, roomRef, direction, at }
- *                                     + once answered: { appRef, from, to, startedAt }
- *   gateways.<gatewayRef> gateway:    { gatewayRef, calls, at }
+ *   calls.<callRef>       appbridge:    { callRef, bridgeRef, nodeId, roomRef, direction, at }
+ *                                     + once answered: { appRef, workspaceRef, from, to, startedAt }
+ *   appbridges.<bridgeRef> retired: AppBridge no longer writes it (redesign-roomr 15.3)
+ *   placements.<callRef>  apiserver:  { callRef, nodeRef, controlAddr, roomRef?, at }
+ *                                     while an outbound call is being placed (CreateCall)
  *
- * The control plane reads `calls` and `gateways`: a call whose entry and whose gateway's entry
- * both stop being rewritten lost its gateway mid-call, and gets `call.ended` (`appbridge-lost`).
+ * Roomr nodes write nothing here (core NATS only: heartbeat and events); the control plane learns
+ * nodes from their heartbeats.
+ *
+ * The control plane reads `calls` (billing counts active calls from them). A call that loses its
+ * AppBridge mid-call is reported by its node's `call.ended` with cause `app_gone` (redesign-roomr
+ * 15.4), not by expired `appbridges` entries.
  *
  * Entries are leases: the bucket keeps a value for SESSIONS_TTL_MS after its last write, owners
- * rewrite theirs every SESSIONS_REFRESH_MS, and a crashed owner's entries expire on their own. The
- * Go node uses the same bucket, TTL and key rules (go/medianode/internal/registry).
+ * rewrite theirs every SESSIONS_REFRESH_MS, and a crashed owner's entries expire on their own.
  */
 exports.SESSIONS_BUCKET = "fonoster_sessions";
 exports.SESSIONS_TTL_MS = 15000;
@@ -53,7 +56,7 @@ function openSessions(nc_1) {
             return nc.jetstream().views.kv(bucket, {
                 history: 1,
                 ttl: (_a = options.ttlMs) !== null && _a !== void 0 ? _a : exports.SESSIONS_TTL_MS,
-                description: "Fonoster session registry: nodes, rooms, calls, gateways (leases)"
+                description: "Fonoster session registry: nodes, rooms, calls, appbridges (leases)"
             });
         };
         try {
@@ -68,7 +71,7 @@ function openSessions(nc_1) {
     });
 }
 /**
- * An owner's entries, kept alive until deleted (the gateway's calls and its own gateway entry).
+ * An owner's entries, kept alive until deleted (AppBridge's calls and its own appbridge entry).
  * Writes never throw: the registry is best effort and entries are rewritten on the next refresh.
  */
 class SessionLeases {

package/dist/telemetry.d.ts

@@ -45,7 +45,7 @@ export interface Telemetry {
     enabled: boolean;
     /**
      * Starts the span of one call; the returned handle is a no-op when disabled. `parent` (a W3C
-     * traceparent from another service, e.g. the media node) makes it a child in that trace.
+     * traceparent from another service, e.g. the Roomr node) makes it a child in that trace.
      */
     startCall(callRef: string, name: string, attrs?: Attrs, parent?: string): CallSpan;
     /**

package/dist/usage/CallUsage.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { MeterName } from "./meters";
+import { KeySource, UsageLine } from "./types";
+type Key = {
+    meter: MeterName;
+    provider?: string;
+    model?: string;
+    keySource?: KeySource;
+};
+/**
+ * A call's usage, accumulated in memory while it runs (design D1). One entry per meter, provider,
+ * model and key source; seconds are kept exact and rounded up only when lines are taken.
+ */
+export declare class CallUsage {
+    private readonly entries;
+    add(line: UsageLine): void;
+    /** Adds seconds of a meter measured as a duration in milliseconds. */
+    addMillis(key: Key, ms: number): void;
+    lines(): UsageLine[];
+}
+export {};

package/dist/usage/CallUsage.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallUsage = void 0;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const meters_1 = require("./meters");
+const types_1 = require("./types");
+/**
+ * A call's usage, accumulated in memory while it runs (design D1). One entry per meter, provider,
+ * model and key source; seconds are kept exact and rounded up only when lines are taken.
+ */
+class CallUsage {
+    constructor() {
+        this.entries = new Map();
+    }
+    add(line) {
+        var _a, _b, _c;
+        const parsed = (0, types_1.parseUsageLine)(line);
+        const key = [
+            parsed.meter,
+            (_a = parsed.provider) !== null && _a !== void 0 ? _a : "",
+            (_b = parsed.model) !== null && _b !== void 0 ? _b : "",
+            (_c = parsed.keySource) !== null && _c !== void 0 ? _c : ""
+        ].join("|");
+        const entry = this.entries.get(key);
+        if (entry)
+            entry.quantity += parsed.quantity;
+        else
+            this.entries.set(key, {
+                meter: parsed.meter,
+                provider: parsed.provider,
+                model: parsed.model,
+                keySource: parsed.keySource,
+                quantity: parsed.quantity
+            });
+    }
+    /** Adds seconds of a meter measured as a duration in milliseconds. */
+    addMillis(key, ms) {
+        if (ms > 0)
+            this.add(Object.assign(Object.assign({}, key), { quantity: ms / 1000 }));
+    }
+    lines() {
+        return Array.from(this.entries.values())
+            .map((e) => {
+            const quantity = (0, meters_1.meterOf)(e.meter).unit === "second"
+                ? Math.ceil(e.quantity - 1e-9)
+                : Math.round(e.quantity);
+            const line = { meter: e.meter, quantity };
+            if (e.provider)
+                line.provider = e.provider;
+            if (e.model)
+                line.model = e.model;
+            if (e.keySource)
+                line.keySource = e.keySource;
+            return line;
+        })
+            .filter((line) => line.quantity > 0);
+    }
+}
+exports.CallUsage = CallUsage;

package/dist/{utils/types.d.ts → usage/index.d.ts}

@@ -16,8 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ParameterizedQuery } from "@influxdata/influxdb-client";
-type InfluxDBClient = {
-    collectRows(query: ParameterizedQuery): Promise<unknown[]>;
-};
-export { InfluxDBClient };
+export * from "./CallUsage";
+export * from "./meters";
+export * from "./types";
+export * from "./usageId";

package/dist/usage/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./CallUsage"), exports);
+__exportStar(require("./meters"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./usageId"), exports);

package/dist/usage/meters.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/** The unit a meter counts in. */
+export type UsageUnit = "second" | "character" | "token" | "count" | "byte";
+/** How a meter's lines combine: added up, or a point-in-time reading (take the latest). */
+export type UsageAggregation = "sum" | "snapshot";
+/** The component that measures a meter. */
+export type UsageReporter = "appbridge" | "autopilot" | "apiserver";
+export type MeterDefinition = {
+    unit: UsageUnit;
+    aggregation: UsageAggregation;
+    reporter: UsageReporter;
+    /** A third-party vendor does the work, so every line says whose key was used. */
+    vendor: boolean;
+};
+/**
+ * The declared meters (add-usage-metering, usage-metering spec). Usage for any other name is
+ * rejected. Adding a meter is adding an entry here.
+ */
+export declare const METERS: {
+    readonly "call.seconds": {
+        readonly unit: "second";
+        readonly aggregation: "sum";
+        readonly reporter: "appbridge";
+        readonly vendor: false;
+    };
+    readonly "stt.seconds": {
+        readonly unit: "second";
+        readonly aggregation: "sum";
+        readonly reporter: "appbridge";
+        readonly vendor: true;
+    };
+    readonly "tts.characters": {
+        readonly unit: "character";
+        readonly aggregation: "sum";
+        readonly reporter: "appbridge";
+        readonly vendor: true;
+    };
+    readonly "llm.tokens.in": {
+        readonly unit: "token";
+        readonly aggregation: "sum";
+        readonly reporter: "autopilot";
+        readonly vendor: true;
+    };
+    readonly "llm.tokens.out": {
+        readonly unit: "token";
+        readonly aggregation: "sum";
+        readonly reporter: "autopilot";
+        readonly vendor: true;
+    };
+    readonly "llm.tokens.cached": {
+        readonly unit: "token";
+        readonly aggregation: "sum";
+        readonly reporter: "autopilot";
+        readonly vendor: true;
+    };
+    readonly "embedding.tokens": {
+        readonly unit: "token";
+        readonly aggregation: "sum";
+        readonly reporter: "autopilot";
+        readonly vendor: true;
+    };
+    readonly "nc.seconds": {
+        readonly unit: "second";
+        readonly aggregation: "sum";
+        readonly reporter: "appbridge";
+        readonly vendor: true;
+    };
+    readonly "amd.detections": {
+        readonly unit: "count";
+        readonly aggregation: "sum";
+        readonly reporter: "appbridge";
+        readonly vendor: false;
+    };
+    readonly "amd.seconds": {
+        readonly unit: "second";
+        readonly aggregation: "sum";
+        readonly reporter: "appbridge";
+        readonly vendor: false;
+    };
+    readonly "recording.seconds": {
+        readonly unit: "second";
+        readonly aggregation: "sum";
+        readonly reporter: "appbridge";
+        readonly vendor: false;
+    };
+    readonly "storage.bytes": {
+        readonly unit: "byte";
+        readonly aggregation: "snapshot";
+        readonly reporter: "apiserver";
+        readonly vendor: false;
+    };
+};
+export type MeterName = keyof typeof METERS;
+export declare const METER_NAMES: MeterName[];
+export declare function isMeter(name: string): name is MeterName;
+export declare function meterOf(name: MeterName): MeterDefinition;

package/dist/usage/meters.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METER_NAMES = exports.METERS = void 0;
+exports.isMeter = isMeter;
+exports.meterOf = meterOf;
+/**
+ * The declared meters (add-usage-metering, usage-metering spec). Usage for any other name is
+ * rejected. Adding a meter is adding an entry here.
+ */
+exports.METERS = {
+    "call.seconds": {
+        unit: "second",
+        aggregation: "sum",
+        reporter: "appbridge",
+        vendor: false
+    },
+    "stt.seconds": {
+        unit: "second",
+        aggregation: "sum",
+        reporter: "appbridge",
+        vendor: true
+    },
+    "tts.characters": {
+        unit: "character",
+        aggregation: "sum",
+        reporter: "appbridge",
+        vendor: true
+    },
+    "llm.tokens.in": {
+        unit: "token",
+        aggregation: "sum",
+        reporter: "autopilot",
+        vendor: true
+    },
+    "llm.tokens.out": {
+        unit: "token",
+        aggregation: "sum",
+        reporter: "autopilot",
+        vendor: true
+    },
+    "llm.tokens.cached": {
+        unit: "token",
+        aggregation: "sum",
+        reporter: "autopilot",
+        vendor: true
+    },
+    "embedding.tokens": {
+        unit: "token",
+        aggregation: "sum",
+        reporter: "autopilot",
+        vendor: true
+    },
+    "nc.seconds": {
+        unit: "second",
+        aggregation: "sum",
+        reporter: "appbridge",
+        vendor: true
+    },
+    "amd.detections": {
+        unit: "count",
+        aggregation: "sum",
+        reporter: "appbridge",
+        vendor: false
+    },
+    "amd.seconds": {
+        unit: "second",
+        aggregation: "sum",
+        reporter: "appbridge",
+        vendor: false
+    },
+    "recording.seconds": {
+        unit: "second",
+        aggregation: "sum",
+        reporter: "appbridge",
+        vendor: false
+    },
+    "storage.bytes": {
+        unit: "byte",
+        aggregation: "snapshot",
+        reporter: "apiserver",
+        vendor: false
+    }
+};
+exports.METER_NAMES = Object.keys(exports.METERS);
+function isMeter(name) {
+    return Object.prototype.hasOwnProperty.call(exports.METERS, name);
+}
+function meterOf(name) {
+    return exports.METERS[name];
+}

package/dist/usage/types.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from "zod";
+import { MeterName } from "./meters";
+export declare const KEY_SOURCES: readonly ["platform", "workspace"];
+export type KeySource = (typeof KEY_SOURCES)[number];
+export declare const ORIGINS: readonly ["call", "browser_test", "eval", "api"];
+export type UsageOrigin = (typeof ORIGINS)[number];
+export declare const REGION_KINDS: readonly ["public", "private"];
+export type RegionKind = (typeof REGION_KINDS)[number];
+/** One quantity of one meter. Facts only: strict, so no price or billable flag can ride along. */
+export declare const usageLineSchema: z.ZodEffects<z.ZodObject<{
+    meter: z.ZodEffects<z.ZodString, "llm.tokens.in" | "llm.tokens.out" | "llm.tokens.cached" | "embedding.tokens" | "call.seconds" | "stt.seconds" | "tts.characters" | "nc.seconds" | "amd.detections" | "amd.seconds" | "recording.seconds" | "storage.bytes", string>;
+    quantity: z.ZodNumber;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    keySource: z.ZodOptional<z.ZodEnum<["platform", "workspace"]>>;
+}, "strict", z.ZodTypeAny, {
+    model?: string;
+    provider?: string;
+    meter?: "llm.tokens.in" | "llm.tokens.out" | "llm.tokens.cached" | "embedding.tokens" | "call.seconds" | "stt.seconds" | "tts.characters" | "nc.seconds" | "amd.detections" | "amd.seconds" | "recording.seconds" | "storage.bytes";
+    quantity?: number;
+    keySource?: "platform" | "workspace";
+}, {
+    model?: string;
+    provider?: string;
+    meter?: string;
+    quantity?: number;
+    keySource?: "platform" | "workspace";
+}>, {
+    model?: string;
+    provider?: string;
+    meter?: "llm.tokens.in" | "llm.tokens.out" | "llm.tokens.cached" | "embedding.tokens" | "call.seconds" | "stt.seconds" | "tts.characters" | "nc.seconds" | "amd.detections" | "amd.seconds" | "recording.seconds" | "storage.bytes";
+    quantity?: number;
+    keySource?: "platform" | "workspace";
+}, {
+    model?: string;
+    provider?: string;
+    meter?: string;
+    quantity?: number;
+    keySource?: "platform" | "workspace";
+}>;
+/** A usage line with its attribution, as stored and as published on `usage.>`. */
+export declare const usageEventSchema: z.ZodEffects<z.ZodObject<{
+    id: z.ZodString;
+    /** Resolved from the workspace at ingest when the reporter does not know it. */
+    ownerRef: z.ZodOptional<z.ZodString>;
+    workspaceRef: z.ZodString;
+    appRef: z.ZodOptional<z.ZodString>;
+    callRef: z.ZodOptional<z.ZodString>;
+    region: z.ZodString;
+    regionKind: z.ZodEnum<["public", "private"]>;
+    origin: z.ZodEnum<["call", "browser_test", "eval", "api"]>;
+    occurredAt: z.ZodString;
+    meter: z.ZodEffects<z.ZodString, "llm.tokens.in" | "llm.tokens.out" | "llm.tokens.cached" | "embedding.tokens" | "call.seconds" | "stt.seconds" | "tts.characters" | "nc.seconds" | "amd.detections" | "amd.seconds" | "recording.seconds" | "storage.bytes", string>;
+    quantity: z.ZodNumber;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    keySource: z.ZodOptional<z.ZodEnum<["platform", "workspace"]>>;
+}, "strict", z.ZodTypeAny, {
+    model?: string;
+    provider?: string;
+    id?: string;
+    appRef?: string;
+    region?: string;
+    callRef?: string;
+    meter?: "llm.tokens.in" | "llm.tokens.out" | "llm.tokens.cached" | "embedding.tokens" | "call.seconds" | "stt.seconds" | "tts.characters" | "nc.seconds" | "amd.detections" | "amd.seconds" | "recording.seconds" | "storage.bytes";
+    quantity?: number;
+    keySource?: "platform" | "workspace";
+    origin?: "call" | "browser_test" | "eval" | "api";
+    workspaceRef?: string;
+    ownerRef?: string;
+    regionKind?: "public" | "private";
+    occurredAt?: string;
+}, {
+    model?: string;
+    provider?: string;
+    id?: string;
+    appRef?: string;
+    region?: string;
+    callRef?: string;
+    meter?: string;
+    quantity?: number;
+    keySource?: "platform" | "workspace";
+    origin?: "call" | "browser_test" | "eval" | "api";
+    workspaceRef?: string;
+    ownerRef?: string;
+    regionKind?: "public" | "private";
+    occurredAt?: string;
+}>, {
+    model?: string;
+    provider?: string;
+    id?: string;
+    appRef?: string;
+    region?: string;
+    callRef?: string;
+    meter?: "llm.tokens.in" | "llm.tokens.out" | "llm.tokens.cached" | "embedding.tokens" | "call.seconds" | "stt.seconds" | "tts.characters" | "nc.seconds" | "amd.detections" | "amd.seconds" | "recording.seconds" | "storage.bytes";
+    quantity?: number;
+    keySource?: "platform" | "workspace";
+    origin?: "call" | "browser_test" | "eval" | "api";
+    workspaceRef?: string;
+    ownerRef?: string;
+    regionKind?: "public" | "private";
+    occurredAt?: string;
+}, {
+    model?: string;
+    provider?: string;
+    id?: string;
+    appRef?: string;
+    region?: string;
+    callRef?: string;
+    meter?: string;
+    quantity?: number;
+    keySource?: "platform" | "workspace";
+    origin?: "call" | "browser_test" | "eval" | "api";
+    workspaceRef?: string;
+    ownerRef?: string;
+    regionKind?: "public" | "private";
+    occurredAt?: string;
+}>;
+export type UsageLine = {
+    meter: MeterName;
+    quantity: number;
+    provider?: string;
+    model?: string;
+    keySource?: KeySource;
+};
+export type UsageEvent = UsageLine & {
+    id: string;
+    ownerRef?: string;
+    workspaceRef: string;
+    appRef?: string;
+    callRef?: string;
+    region: string;
+    regionKind: RegionKind;
+    origin: UsageOrigin;
+    occurredAt: string;
+};
+/** A usage line or event that failed validation; the message names every problem. */
+export declare class InvalidUsageError extends Error {
+}
+export declare function parseUsageLine(input: unknown): UsageLine;
+export declare function parseUsageEvent(input: unknown): UsageEvent;

package/dist/usage/types.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidUsageError = exports.usageEventSchema = exports.usageLineSchema = exports.REGION_KINDS = exports.ORIGINS = exports.KEY_SOURCES = void 0;
+exports.parseUsageLine = parseUsageLine;
+exports.parseUsageEvent = parseUsageEvent;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const zod_1 = require("zod");
+const meters_1 = require("./meters");
+exports.KEY_SOURCES = ["platform", "workspace"];
+exports.ORIGINS = ["call", "browser_test", "eval", "api"];
+exports.REGION_KINDS = ["public", "private"];
+const lineFields = {
+    meter: zod_1.z
+        .string()
+        .refine(meters_1.isMeter, (m) => ({ message: `undeclared meter "${m}"` })),
+    quantity: zod_1.z.number().finite().nonnegative(),
+    provider: zod_1.z.string().min(1).optional(),
+    model: zod_1.z.string().min(1).optional(),
+    keySource: zod_1.z.enum(exports.KEY_SOURCES).optional()
+};
+function checkKeySource(line, ctx) {
+    if (!line.meter || !(0, meters_1.isMeter)(line.meter))
+        return;
+    const vendor = meters_1.METERS[line.meter].vendor;
+    if (vendor && !line.keySource)
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["keySource"],
+            message: `${line.meter} needs a keySource`
+        });
+    if (!vendor && line.keySource)
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["keySource"],
+            message: `${line.meter} is not a vendor meter and takes no keySource`
+        });
+}
+/** One quantity of one meter. Facts only: strict, so no price or billable flag can ride along. */
+exports.usageLineSchema = zod_1.z
+    .object(lineFields)
+    .strict()
+    .superRefine(checkKeySource);
+/** A usage line with its attribution, as stored and as published on `usage.>`. */
+exports.usageEventSchema = zod_1.z
+    .object(Object.assign(Object.assign({}, lineFields), { id: zod_1.z.string().regex(/^usg_[a-z2-7]{26}$/), 
+    /** Resolved from the workspace at ingest when the reporter does not know it. */
+    ownerRef: zod_1.z.string().min(1).optional(), workspaceRef: zod_1.z.string().min(1), appRef: zod_1.z.string().min(1).optional(), callRef: zod_1.z.string().min(1).optional(), region: zod_1.z.string().min(1), regionKind: zod_1.z.enum(exports.REGION_KINDS), origin: zod_1.z.enum(exports.ORIGINS), occurredAt: zod_1.z.string().datetime() }))
+    .strict()
+    .superRefine(checkKeySource);
+/** A usage line or event that failed validation; the message names every problem. */
+class InvalidUsageError extends Error {
+}
+exports.InvalidUsageError = InvalidUsageError;
+function parseWith(schema, input) {
+    const result = schema.safeParse(input);
+    if (result.success)
+        return result.data;
+    throw new InvalidUsageError(result.error.issues
+        .map((i) => i.path.length ? `${i.path.join(".")}: ${i.message}` : i.message)
+        .join("; "));
+}
+function parseUsageLine(input) {
+    return parseWith(exports.usageLineSchema, input);
+}
+function parseUsageEvent(input) {
+    return parseWith(exports.usageEventSchema, input);
+}