@fonoster/common 0.27.0 → 0.31.0

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/usage/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+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);
+}

package/dist/usage/usageId.d.ts

@@ -0,0 +1,6 @@
+import { UsageLine } from "./types";
+/**
+ * The id of a usage line (design D7): derived from what it measures, so reporting the same usage
+ * twice yields the same id. `scope` is the callRef, the eval step key, or workspaceRef + day.
+ */
+export declare function usageId(scope: string, line: Pick<UsageLine, "meter" | "provider" | "model" | "keySource">): string;

package/dist/usage/usageId.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usageId = usageId;
+/**
+ * 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 node_crypto_1 = require("node:crypto");
+const ALPHABET = "abcdefghijklmnopqrstuvwxyz234567";
+function base32(bytes) {
+    var _a;
+    const bits = Array.from(bytes, (b) => b.toString(2).padStart(8, "0")).join("");
+    return ((_a = bits.match(/.{1,5}/g)) !== null && _a !== void 0 ? _a : [])
+        .map((chunk) => ALPHABET[parseInt(chunk.padEnd(5, "0"), 2)])
+        .join("");
+}
+/**
+ * The id of a usage line (design D7): derived from what it measures, so reporting the same usage
+ * twice yields the same id. `scope` is the callRef, the eval step key, or workspaceRef + day.
+ */
+function usageId(scope, line) {
+    var _a, _b, _c;
+    const key = [
+        scope,
+        line.meter,
+        (_a = line.provider) !== null && _a !== void 0 ? _a : "",
+        (_b = line.model) !== null && _b !== void 0 ? _b : "",
+        (_c = line.keySource) !== null && _c !== void 0 ? _c : ""
+    ].join("|");
+    return ("usg_" + base32((0, node_crypto_1.createHash)("sha256").update(key).digest()).slice(0, 26));
+}

package/dist/utils/{findIntegrationsCredentials.js → WriteBehind.d.ts}

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findIntegrationsCredentials = findIntegrationsCredentials;
 /**
  * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/fonoster
@@ -19,11 +16,17 @@ exports.findIntegrationsCredentials = findIntegrationsCredentials;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function findIntegrationsCredentials(integrations, engine) {
-    var _a;
-    const integration = (_a = integrations.find((i) => i.productRef === engine)) === null || _a === void 0 ? void 0 : _a.credentials;
-    if (!integration) {
-        throw new Error(`Integration ${engine} not found`);
-    }
-    return integration;
+/**
+ * Runs database writes one after another, in the order they were queued, behind a synchronous
+ * store interface (the registry and webhook stores are synchronous; see P-B1 in
+ * add-provider-registry/build-log.md). `flush()` waits for every queued write and throws the
+ * first failure.
+ */
+export declare class WriteBehind {
+    private readonly onError?;
+    private tail;
+    private failure?;
+    constructor(onError?: (e: unknown) => void);
+    push(write: () => Promise<unknown>): void;
+    flush(): Promise<void>;
 }