@wopr-network/platform-core 1.0.10 → 1.1.0

package/dist/monetization/adapters/types.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Provider adapter interface — the contract every hosted adapter implements.
+ *
+ * An adapter wraps a wholesale AI provider (Replicate, RunPod, etc.) and returns
+ * the raw result plus the wholesale cost. The socket layer handles margin,
+ * metering, and billing — adapters never touch those concerns.
+ */
+import type { Credit } from "@wopr-network/platform-core/credits";
+/** The result every adapter returns: the provider's output + wholesale cost */
+export interface AdapterResult<T = unknown> {
+    /** The provider's response payload */
+    result: T;
+    /** Wholesale cost in Credits (what we paid the provider, converted from USD) */
+    cost: Credit;
+    /** User-facing charge in Credits (cost + margin). Present when the adapter computes margin. */
+    charge?: Credit;
+}
+/** A capability the adapter supports (extensible as we add more) */
+export type AdapterCapability = "transcription" | "image-generation" | "embeddings" | "text-generation" | "tts";
+/** Input for a transcription request */
+export interface TranscriptionInput {
+    /** URL of the audio file to transcribe */
+    audioUrl: string;
+    /** Optional language hint (ISO 639-1) */
+    language?: string;
+}
+/** Output from a transcription request */
+export interface TranscriptionOutput {
+    /** The transcribed text */
+    text: string;
+    /** Detected language (ISO 639-1) */
+    detectedLanguage: string;
+    /** Duration of the audio in seconds */
+    durationSeconds: number;
+}
+/** Input for an image generation request */
+export interface ImageGenerationInput {
+    /** The prompt describing the desired image */
+    prompt: string;
+    /** Optional negative prompt */
+    negativePrompt?: string;
+    /** Image width in pixels */
+    width?: number;
+    /** Image height in pixels */
+    height?: number;
+    /** Number of images to generate (default: 1) */
+    count?: number;
+}
+/** Output from an image generation request */
+export interface ImageGenerationOutput {
+    /** URLs or base64 data of generated images */
+    images: string[];
+    /** Model used for generation */
+    model: string;
+}
+/** Input for a text generation request */
+export interface TextGenerationInput {
+    /** The prompt or messages */
+    prompt: string;
+    /** Full conversation history (preferred over prompt when available) */
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    /** Model to use */
+    model?: string;
+    /** Max tokens to generate */
+    maxTokens?: number;
+    /** Temperature (0-1) */
+    temperature?: number;
+}
+/** Output from a text generation request */
+export interface TextGenerationOutput {
+    /** Generated text */
+    text: string;
+    /** Model used */
+    model: string;
+    /** Token counts for cost calculation */
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+/** Input for a text-to-speech request */
+export interface TTSInput {
+    /** The text to synthesize */
+    text: string;
+    /** Voice identifier */
+    voice?: string;
+    /** Output audio format (e.g. "mp3", "wav") */
+    format?: string;
+    /** Playback speed multiplier */
+    speed?: number;
+}
+/** Output from a text-to-speech request */
+export interface TTSOutput {
+    /** URL of the generated audio */
+    audioUrl: string;
+    /** Duration of the generated audio in seconds */
+    durationSeconds: number;
+    /** Audio format used */
+    format: string;
+    /** Number of characters synthesized */
+    characterCount: number;
+}
+/** Input for an embeddings request */
+export interface EmbeddingsInput {
+    /** Text or texts to embed */
+    input: string | string[];
+    /** Model to use for embeddings */
+    model?: string;
+    /** Output embedding dimensions */
+    dimensions?: number;
+}
+/** Output from an embeddings request */
+export interface EmbeddingsOutput {
+    /** The embedding vectors */
+    embeddings: number[][];
+    /** Model used */
+    model: string;
+    /** Total tokens consumed */
+    totalTokens: number;
+}
+/**
+ * Provider adapter interface.
+ *
+ * Each hosted provider (Replicate, RunPod, etc.) implements this interface
+ * for every capability it supports. The adapter is the invisible layer between
+ * the socket and the wholesale provider.
+ */
+export interface ProviderAdapter {
+    /** Human-readable provider name */
+    readonly name: string;
+    /** Which capabilities this adapter supports */
+    readonly capabilities: ReadonlyArray<AdapterCapability>;
+    /** Whether this adapter targets self-hosted infrastructure (default: false) */
+    readonly selfHosted?: boolean;
+    /** Transcribe audio — returns result + wholesale cost */
+    transcribe?(input: TranscriptionInput): Promise<AdapterResult<TranscriptionOutput>>;
+    /** Generate images from a text prompt — returns result + wholesale cost */
+    generateImage?(input: ImageGenerationInput): Promise<AdapterResult<ImageGenerationOutput>>;
+    /** Generate text from a prompt — returns result + wholesale cost */
+    generateText?(input: TextGenerationInput): Promise<AdapterResult<TextGenerationOutput>>;
+    /** Synthesize speech from text — returns result + wholesale cost */
+    synthesizeSpeech?(input: TTSInput): Promise<AdapterResult<TTSOutput>>;
+    /** Generate embeddings — returns result + wholesale cost */
+    embed?(input: EmbeddingsInput): Promise<AdapterResult<EmbeddingsOutput>>;
+}
+/**
+ * Meter event emitted after a successful adapter call.
+ * The metering layer (WOP-299) consumes these to report usage to Stripe.
+ */
+export interface MeterEvent {
+    /** Which adapter produced this event */
+    adapter: string;
+    /** Which capability was used */
+    capability: AdapterCapability;
+    /** Wholesale cost in Credits (what we paid) */
+    cost: Credit;
+    /** Charge to the user in Credits (cost + margin) */
+    charge: Credit;
+    /** ISO-8601 timestamp */
+    timestamp: string;
+    /** Opaque user/tenant identifier */
+    tenantId: string;
+}
+/**
+ * Apply a margin multiplier to a wholesale cost.
+ *
+ * This is the core of the socket billing pattern (WOP-298): the adapter returns
+ * wholesale cost, withMargin() computes the user-facing charge.
+ *
+ * Supports tier-specific markup percentages (WOP-357):
+ * - Free tier: 20% markup
+ * - Pro tier: 10% markup
+ * - Enterprise tier: 5-8% markup
+ *
+ * @param cost - Wholesale cost as Credit
+ * @param marginMultiplier - Can be:
+ *                          - A multiplier >= 1.0 (e.g., 1.3 for 30% margin, 2.0 for 2x - default 1.3)
+ *                          - A percentage 3-100 (e.g., 20 for 20% markup, 10 for 10% - WOP-357)
+ */
+export declare function withMargin(cost: Credit, marginMultiplier?: number): Credit;

package/dist/monetization/adapters/types.js

@@ -0,0 +1,32 @@
+/**
+ * Provider adapter interface — the contract every hosted adapter implements.
+ *
+ * An adapter wraps a wholesale AI provider (Replicate, RunPod, etc.) and returns
+ * the raw result plus the wholesale cost. The socket layer handles margin,
+ * metering, and billing — adapters never touch those concerns.
+ */
+/**
+ * Apply a margin multiplier to a wholesale cost.
+ *
+ * This is the core of the socket billing pattern (WOP-298): the adapter returns
+ * wholesale cost, withMargin() computes the user-facing charge.
+ *
+ * Supports tier-specific markup percentages (WOP-357):
+ * - Free tier: 20% markup
+ * - Pro tier: 10% markup
+ * - Enterprise tier: 5-8% markup
+ *
+ * @param cost - Wholesale cost as Credit
+ * @param marginMultiplier - Can be:
+ *                          - A multiplier >= 1.0 (e.g., 1.3 for 30% margin, 2.0 for 2x - default 1.3)
+ *                          - A percentage 3-100 (e.g., 20 for 20% markup, 10 for 10% - WOP-357)
+ */
+export function withMargin(cost, marginMultiplier = 1.3) {
+    let multiplier = marginMultiplier;
+    // If value is >= 3, treat as percentage (e.g., 20 for 20%, 10 for 10%)
+    // If value is >= 1 but < 3, treat as multiplier (e.g., 1.3 = 30%, 2.0 = 2x)
+    if (marginMultiplier >= 3 && marginMultiplier <= 100) {
+        multiplier = 1 + marginMultiplier / 100;
+    }
+    return cost.multiply(multiplier);
+}

package/dist/monetization/adapters/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/monetization/adapters/types.test.js

@@ -0,0 +1,327 @@
+import { Credit } from "@wopr-network/platform-core/credits";
+import { describe, expect, it } from "vitest";
+import { withMargin } from "./types.js";
+describe("ImageGenerationInput/Output types", () => {
+    it("accepts a minimal image generation input", () => {
+        const input = { prompt: "a cat in space" };
+        expect(input.prompt).toBe("a cat in space");
+        expect(input.negativePrompt).toBeUndefined();
+        expect(input.width).toBeUndefined();
+        expect(input.height).toBeUndefined();
+        expect(input.count).toBeUndefined();
+    });
+    it("accepts a fully specified image generation input", () => {
+        const input = {
+            prompt: "a cat in space",
+            negativePrompt: "blurry",
+            width: 1024,
+            height: 768,
+            count: 4,
+        };
+        expect(input.prompt).toBe("a cat in space");
+        expect(input.negativePrompt).toBe("blurry");
+        expect(input.width).toBe(1024);
+        expect(input.height).toBe(768);
+        expect(input.count).toBe(4);
+    });
+    it("creates a valid image generation output", () => {
+        const output = {
+            images: ["https://example.com/img1.png", "https://example.com/img2.png"],
+            model: "sdxl-turbo",
+        };
+        expect(output.images).toHaveLength(2);
+        expect(output.model).toBe("sdxl-turbo");
+    });
+});
+describe("TextGenerationInput/Output types", () => {
+    it("accepts a minimal text generation input", () => {
+        const input = { prompt: "Hello world" };
+        expect(input.prompt).toBe("Hello world");
+        expect(input.model).toBeUndefined();
+        expect(input.maxTokens).toBeUndefined();
+        expect(input.temperature).toBeUndefined();
+    });
+    it("accepts a fully specified text generation input", () => {
+        const input = {
+            prompt: "Explain quantum computing",
+            model: "llama-3-70b",
+            maxTokens: 2048,
+            temperature: 0.7,
+        };
+        expect(input.prompt).toBe("Explain quantum computing");
+        expect(input.model).toBe("llama-3-70b");
+        expect(input.maxTokens).toBe(2048);
+        expect(input.temperature).toBe(0.7);
+    });
+    it("creates a valid text generation output", () => {
+        const output = {
+            text: "Quantum computing uses qubits...",
+            model: "llama-3-70b",
+            usage: { inputTokens: 10, outputTokens: 50 },
+        };
+        expect(output.text).toBe("Quantum computing uses qubits...");
+        expect(output.model).toBe("llama-3-70b");
+        expect(output.usage.inputTokens).toBe(10);
+        expect(output.usage.outputTokens).toBe(50);
+    });
+});
+describe("ProviderAdapter with new capabilities", () => {
+    it("supports image-generation capability", () => {
+        const adapter = {
+            name: "test-image-adapter",
+            capabilities: ["image-generation"],
+            async generateImage(_input) {
+                return {
+                    result: { images: ["data:image/png;base64,..."], model: "test-model" },
+                    cost: Credit.fromDollars(0.02),
+                };
+            },
+        };
+        expect(adapter.name).toBe("test-image-adapter");
+        expect(adapter.capabilities).toContain("image-generation");
+        expect(typeof adapter.generateImage).toBe("function");
+    });
+    it("supports text-generation capability", () => {
+        const adapter = {
+            name: "test-text-adapter",
+            capabilities: ["text-generation"],
+            async generateText(_input) {
+                return {
+                    result: {
+                        text: "Generated text",
+                        model: "test-model",
+                        usage: { inputTokens: 5, outputTokens: 20 },
+                    },
+                    cost: Credit.fromDollars(0.001),
+                };
+            },
+        };
+        expect(adapter.name).toBe("test-text-adapter");
+        expect(adapter.capabilities).toContain("text-generation");
+        expect(typeof adapter.generateText).toBe("function");
+    });
+    it("supports multiple capabilities on one adapter", () => {
+        const adapter = {
+            name: "multi-adapter",
+            capabilities: ["transcription", "image-generation", "text-generation"],
+            async transcribe() {
+                return {
+                    result: { text: "", detectedLanguage: "en", durationSeconds: 0 },
+                    cost: Credit.ZERO,
+                };
+            },
+            async generateImage() {
+                return { result: { images: [], model: "m" }, cost: Credit.ZERO };
+            },
+            async generateText() {
+                return {
+                    result: { text: "", model: "m", usage: { inputTokens: 0, outputTokens: 0 } },
+                    cost: Credit.ZERO,
+                };
+            },
+        };
+        expect(adapter.capabilities).toHaveLength(3);
+        expect(typeof adapter.transcribe).toBe("function");
+        expect(typeof adapter.generateImage).toBe("function");
+        expect(typeof adapter.generateText).toBe("function");
+    });
+    it("generateImage returns AdapterResult with cost and optional charge", async () => {
+        const adapter = {
+            name: "cost-test",
+            capabilities: ["image-generation"],
+            async generateImage() {
+                const cost = Credit.fromDollars(0.05);
+                return {
+                    result: { images: ["img1.png"], model: "sdxl" },
+                    cost,
+                    charge: withMargin(cost),
+                };
+            },
+        };
+        const result = (await adapter.generateImage?.({
+            prompt: "test",
+        }));
+        expect(result.cost.toDollars()).toBeCloseTo(0.05, 6);
+        expect(result.charge?.toDollars()).toBeCloseTo(0.065, 6);
+    });
+    it("generateText returns AdapterResult with cost and optional charge", async () => {
+        const adapter = {
+            name: "cost-test",
+            capabilities: ["text-generation"],
+            async generateText() {
+                const cost = Credit.fromDollars(0.003);
+                return {
+                    result: {
+                        text: "hello",
+                        model: "llama-3",
+                        usage: { inputTokens: 10, outputTokens: 5 },
+                    },
+                    cost,
+                    charge: withMargin(cost),
+                };
+            },
+        };
+        const result = (await adapter.generateText?.({
+            prompt: "test",
+        }));
+        expect(result.cost.toDollars()).toBeCloseTo(0.003, 6);
+        expect(result.charge?.toDollars()).toBeCloseTo(0.0039, 6);
+    });
+});
+describe("TTSInput/Output types", () => {
+    it("accepts a minimal TTS input", () => {
+        const input = { text: "Hello world" };
+        expect(input.text).toBe("Hello world");
+        expect(input.voice).toBeUndefined();
+        expect(input.format).toBeUndefined();
+        expect(input.speed).toBeUndefined();
+    });
+    it("accepts a fully specified TTS input", () => {
+        const input = {
+            text: "Hello world",
+            voice: "alloy",
+            format: "mp3",
+            speed: 1.5,
+        };
+        expect(input.text).toBe("Hello world");
+        expect(input.voice).toBe("alloy");
+        expect(input.format).toBe("mp3");
+        expect(input.speed).toBe(1.5);
+    });
+    it("creates a valid TTS output", () => {
+        const output = {
+            audioUrl: "https://example.com/audio.mp3",
+            durationSeconds: 3.5,
+            format: "mp3",
+            characterCount: 11,
+        };
+        expect(output.audioUrl).toBe("https://example.com/audio.mp3");
+        expect(output.durationSeconds).toBe(3.5);
+        expect(output.format).toBe("mp3");
+        expect(output.characterCount).toBe(11);
+    });
+});
+describe("EmbeddingsInput/Output types", () => {
+    it("accepts a single string input", () => {
+        const input = { input: "Hello world" };
+        expect(input.input).toBe("Hello world");
+        expect(input.model).toBeUndefined();
+        expect(input.dimensions).toBeUndefined();
+    });
+    it("accepts an array of strings input", () => {
+        const input = { input: ["Hello", "World"] };
+        expect(input.input).toHaveLength(2);
+    });
+    it("accepts a fully specified embeddings input", () => {
+        const input = {
+            input: "Hello world",
+            model: "text-embedding-3-small",
+            dimensions: 256,
+        };
+        expect(input.input).toBe("Hello world");
+        expect(input.model).toBe("text-embedding-3-small");
+        expect(input.dimensions).toBe(256);
+    });
+    it("creates a valid embeddings output", () => {
+        const output = {
+            embeddings: [
+                [0.1, 0.2, 0.3],
+                [0.4, 0.5, 0.6],
+            ],
+            model: "text-embedding-3-small",
+            totalTokens: 8,
+        };
+        expect(output.embeddings).toHaveLength(2);
+        expect(output.embeddings[0]).toEqual([0.1, 0.2, 0.3]);
+        expect(output.model).toBe("text-embedding-3-small");
+        expect(output.totalTokens).toBe(8);
+    });
+});
+describe("ProviderAdapter with TTS and embeddings capabilities", () => {
+    it("supports tts capability", () => {
+        const adapter = {
+            name: "test-tts-adapter",
+            capabilities: ["tts"],
+            async synthesizeSpeech(_input) {
+                return {
+                    result: { audioUrl: "https://example.com/audio.mp3", durationSeconds: 3, format: "mp3", characterCount: 11 },
+                    cost: Credit.fromDollars(0.005),
+                };
+            },
+        };
+        expect(adapter.name).toBe("test-tts-adapter");
+        expect(adapter.capabilities).toContain("tts");
+        expect(typeof adapter.synthesizeSpeech).toBe("function");
+    });
+    it("supports embeddings capability", () => {
+        const adapter = {
+            name: "test-embed-adapter",
+            capabilities: ["embeddings"],
+            async embed(_input) {
+                return {
+                    result: { embeddings: [[0.1, 0.2]], model: "test-model", totalTokens: 4 },
+                    cost: Credit.fromDollars(0.0001),
+                };
+            },
+        };
+        expect(adapter.name).toBe("test-embed-adapter");
+        expect(adapter.capabilities).toContain("embeddings");
+        expect(typeof adapter.embed).toBe("function");
+    });
+    it("synthesizeSpeech returns AdapterResult with cost and optional charge", async () => {
+        const adapter = {
+            name: "cost-test",
+            capabilities: ["tts"],
+            async synthesizeSpeech() {
+                const cost = Credit.fromDollars(0.01);
+                return {
+                    result: { audioUrl: "https://example.com/audio.mp3", durationSeconds: 5, format: "mp3", characterCount: 50 },
+                    cost,
+                    charge: withMargin(cost),
+                };
+            },
+        };
+        const result = (await adapter.synthesizeSpeech?.({
+            text: "test",
+        }));
+        expect(result.cost.toDollars()).toBeCloseTo(0.01, 6);
+        expect(result.charge?.toDollars()).toBeCloseTo(0.013, 6);
+    });
+    it("embed returns AdapterResult with cost and optional charge", async () => {
+        const adapter = {
+            name: "cost-test",
+            capabilities: ["embeddings"],
+            async embed() {
+                const cost = Credit.fromDollars(0.0002);
+                return {
+                    result: { embeddings: [[0.1, 0.2, 0.3]], model: "test-model", totalTokens: 10 },
+                    cost,
+                    charge: withMargin(cost),
+                };
+            },
+        };
+        const result = (await adapter.embed?.({
+            input: "test",
+        }));
+        expect(result.cost.toDollars()).toBeCloseTo(0.0002, 6);
+        expect(result.charge?.toDollars()).toBeCloseTo(0.00026, 6);
+    });
+});
+describe("AdapterCapability includes new capabilities", () => {
+    it("image-generation is a valid capability", () => {
+        const cap = "image-generation";
+        expect(cap).toBe("image-generation");
+    });
+    it("text-generation is a valid capability", () => {
+        const cap = "text-generation";
+        expect(cap).toBe("text-generation");
+    });
+    it("tts is a valid capability", () => {
+        const cap = "tts";
+        expect(cap).toBe("tts");
+    });
+    it("embeddings is a valid capability", () => {
+        const cap = "embeddings";
+        expect(cap).toBe("embeddings");
+    });
+});

package/dist/monetization/addons/addon-catalog.d.ts

@@ -0,0 +1,10 @@
+import { Credit } from "@wopr-network/platform-core/credits";
+export declare const ADDON_KEYS: readonly ["gpu_acceleration", "priority_queue", "extra_storage", "custom_domain"];
+export type AddonKey = (typeof ADDON_KEYS)[number];
+export interface AddonDefinition {
+    key: AddonKey;
+    label: string;
+    dailyCost: Credit;
+    description: string;
+}
+export declare const ADDON_CATALOG: Record<AddonKey, AddonDefinition>;

package/dist/monetization/addons/addon-catalog.js

@@ -0,0 +1,28 @@
+import { Credit } from "@wopr-network/platform-core/credits";
+export const ADDON_KEYS = ["gpu_acceleration", "priority_queue", "extra_storage", "custom_domain"];
+export const ADDON_CATALOG = {
+    gpu_acceleration: {
+        key: "gpu_acceleration",
+        label: "GPU Acceleration",
+        dailyCost: Credit.fromCents(50),
+        description: "GPU-backed inference for faster, higher-quality responses",
+    },
+    priority_queue: {
+        key: "priority_queue",
+        label: "Priority Queue",
+        dailyCost: Credit.fromCents(20),
+        description: "Skip the queue for faster response times",
+    },
+    extra_storage: {
+        key: "extra_storage",
+        label: "Extra Storage",
+        dailyCost: Credit.fromCents(10),
+        description: "Additional bot data storage beyond your tier limit",
+    },
+    custom_domain: {
+        key: "custom_domain",
+        label: "Custom Domain",
+        dailyCost: Credit.fromCents(5),
+        description: "Use your own domain for bot URLs",
+    },
+};

package/dist/monetization/addons/addon-catalog.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/monetization/addons/addon-catalog.test.js

@@ -0,0 +1,33 @@
+import { Credit } from "@wopr-network/platform-core/credits";
+import { describe, expect, it } from "vitest";
+import { ADDON_CATALOG, ADDON_KEYS } from "./addon-catalog.js";
+describe("addon-catalog", () => {
+    it("ADDON_KEYS contains all expected keys", () => {
+        expect(ADDON_KEYS).toEqual(["gpu_acceleration", "priority_queue", "extra_storage", "custom_domain"]);
+    });
+    it("every ADDON_KEYS entry has a matching ADDON_CATALOG definition", () => {
+        for (const key of ADDON_KEYS) {
+            const def = ADDON_CATALOG[key];
+            expect(def).not.toBeUndefined();
+            expect(def.key).toBe(key);
+            expect(def.label).toBeTruthy();
+            expect(def.description).toBeTruthy();
+            expect(def.dailyCost).toBeInstanceOf(Credit);
+        }
+    });
+    it("gpu_acceleration costs 50 cents/day", () => {
+        expect(ADDON_CATALOG.gpu_acceleration.dailyCost.equals(Credit.fromCents(50))).toBe(true);
+    });
+    it("priority_queue costs 20 cents/day", () => {
+        expect(ADDON_CATALOG.priority_queue.dailyCost.equals(Credit.fromCents(20))).toBe(true);
+    });
+    it("extra_storage costs 10 cents/day", () => {
+        expect(ADDON_CATALOG.extra_storage.dailyCost.equals(Credit.fromCents(10))).toBe(true);
+    });
+    it("custom_domain costs 5 cents/day", () => {
+        expect(ADDON_CATALOG.custom_domain.dailyCost.equals(Credit.fromCents(5))).toBe(true);
+    });
+    it("looking up an unknown key returns undefined", () => {
+        expect(ADDON_CATALOG["nonexistent"]).toBeUndefined();
+    });
+});

package/dist/monetization/addons/addon-cron.d.ts

@@ -0,0 +1,7 @@
+import { Credit } from "@wopr-network/platform-core/credits";
+import type { ITenantAddonRepository } from "./addon-repository.js";
+/**
+ * Build a `getAddonCosts` callback for the runtime cron.
+ * Sums daily costs of all enabled add-ons for a tenant.
+ */
+export declare function buildAddonCosts(addonRepo: ITenantAddonRepository): (tenantId: string) => Promise<Credit>;

package/dist/monetization/addons/addon-cron.js

@@ -0,0 +1,19 @@
+import { Credit } from "@wopr-network/platform-core/credits";
+import { ADDON_CATALOG } from "./addon-catalog.js";
+/**
+ * Build a `getAddonCosts` callback for the runtime cron.
+ * Sums daily costs of all enabled add-ons for a tenant.
+ */
+export function buildAddonCosts(addonRepo) {
+    return async (tenantId) => {
+        const addons = await addonRepo.list(tenantId);
+        let total = Credit.ZERO;
+        for (const addon of addons) {
+            const def = ADDON_CATALOG[addon.addonKey];
+            if (def) {
+                total = total.add(def.dailyCost);
+            }
+        }
+        return total;
+    };
+}

package/dist/monetization/addons/addon-cron.test.d.ts

@@ -0,0 +1 @@
+export {};