@mevdragon/vidfarm-devcli 0.2.8 → 0.2.10

package/dist/src/registry.js

@@ -1,14 +1,10 @@
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
 import { database } from "./db.js";
-import { template0000Definition } from "../templates/vidfarm_template_0000/src/template.js";
 import { loadTemplateFromModule } from "./services/template-loader.js";
-import { TemplateCertificationService } from "./services/template-certification.js";
 class TemplateRegistry {
-    localTemplates = new Map([[
-            template0000Definition.id,
-            template0000Definition
-        ]]);
+    localTemplates = new Map();
     runtimeTemplates = new Map();
-    certification = new TemplateCertificationService();
     initialized = false;
     initPromise = null;
     async ensureInitialized() {
@@ -19,22 +15,24 @@ class TemplateRegistry {
             return this.initPromise;
         }
         this.initPromise = (async () => {
-            for (const template of this.localTemplates.values()) {
-                const skillPath = template.skillPath;
-                if (!skillPath) {
-                    throw new Error(`Local template ${template.id} is missing skillPath.`);
+            await this.loadLocalTemplates();
+            const visibleReleaseByTemplateId = new Map();
+            for (const release of database.listTemplateReleases()) {
+                if (release.status !== "approved" && release.status !== "active") {
+                    continue;
                 }
-                const report = await this.certification.certify({ template, skillPath });
-                if (!report.passed) {
-                    throw new Error(`Local template ${template.id} failed certification.`);
+                const current = visibleReleaseByTemplateId.get(release.templateId);
+                if (!current || getReleaseTimestamp(release) > getReleaseTimestamp(current)) {
+                    visibleReleaseByTemplateId.set(release.templateId, release);
                 }
             }
-            for (const release of database.getActiveTemplateReleases()) {
+            for (const release of visibleReleaseByTemplateId.values()) {
                 const template = await loadTemplateFromModule(release.modulePath);
-                this.runtimeTemplates.set(release.templateId, {
+                const runtimeTemplate = {
                     ...template,
                     skillPath: release.skillPath
-                });
+                };
+                this.runtimeTemplates.set(release.templateId, runtimeTemplate);
             }
             this.initialized = true;
             this.initPromise = null;
@@ -57,8 +55,29 @@ class TemplateRegistry {
     registerRuntimeTemplate(template) {
         this.runtimeTemplates.set(template.id, template);
     }
+    async loadLocalTemplates() {
+        this.localTemplates.clear();
+        for (const modulePath of discoverLocalTemplateModulePaths(process.cwd())) {
+            const template = await loadTemplateFromModule(modulePath);
+            this.localTemplates.set(template.id, template);
+        }
+    }
     findTemplate(templateKey, source) {
         return source.get(templateKey) ?? [...source.values()].find((template) => template.slugId === templateKey) ?? null;
     }
 }
+function getReleaseTimestamp(release) {
+    return Date.parse(release.activatedAt ?? release.updatedAt ?? release.createdAt);
+}
+function discoverLocalTemplateModulePaths(rootDir) {
+    const templatesDir = path.resolve(rootDir, "templates");
+    if (!existsSync(templatesDir)) {
+        return [];
+    }
+    return readdirSync(templatesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith("vidfarm_template_"))
+        .map((entry) => path.join(templatesDir, entry.name, "src", "template.ts"))
+        .filter((modulePath) => existsSync(modulePath))
+        .sort((a, b) => a.localeCompare(b));
+}
 export const templateRegistry = new TemplateRegistry();

package/dist/src/runtime.js

@@ -2,6 +2,7 @@ import { serve } from "@hono/node-server";
 import app from "./app.js";
 import { config } from "./config.js";
 import { templateRegistry } from "./registry.js";
+import { apiCallHistoryStore } from "./services/api-call-history.js";
 import { jobLogStore } from "./services/job-logs.js";
 import { Worker } from "./worker.js";
 export async function startRuntime() {
@@ -10,12 +11,16 @@ export async function startRuntime() {
     worker.start();
     const server = serve({
         fetch: app.fetch,
-        port: config.PORT
+        port: config.PORT,
+        serverOptions: {
+            maxHeaderSize: 64 * 1024
+        }
     }, (info) => {
         console.log(`[vidfarm] listening on http://localhost:${info.port}`);
     });
     const shutdown = async () => {
         worker.stop();
+        await apiCallHistoryStore.shutdown();
         await jobLogStore.shutdown();
         server.close();
     };

package/dist/src/services/api-call-history.js

@@ -0,0 +1,245 @@
+import { StorageService } from "./storage.js";
+const API_CALL_HISTORY_PREFIX = "api-call-history";
+const CHUNK_INTERVAL_MS = 60_000;
+const CHUNK_MAX_BYTES = 1024 * 1024;
+const FLUSH_INTERVAL_MS = 5_000;
+export class ApiCallHistoryStore {
+    storage = new StorageService();
+    activeChunks = new Map();
+    flushTimer = setInterval(() => {
+        void this.flushExpiredChunks();
+    }, FLUSH_INTERVAL_MS);
+    constructor() {
+        this.flushTimer.unref();
+    }
+    addEntry(entry) {
+        const normalized = {
+            ...entry,
+            createdAt: entry.createdAt ?? new Date().toISOString()
+        };
+        const minuteStartMs = floorToMinute(Date.parse(normalized.createdAt));
+        const activePrefix = this.activeChunkPrefix(normalized.customerId, minuteStartMs);
+        const current = this.findLatestChunk(activePrefix);
+        const entryBytes = serializedEntrySize(normalized);
+        const chunk = current && current.sizeBytes + entryBytes <= CHUNK_MAX_BYTES
+            ? current
+            : this.createChunk(normalized.customerId, minuteStartMs, current ? current.sequence + 1 : 0);
+        chunk.entries.push(normalized);
+        chunk.sizeBytes += entryBytes;
+        chunk.dirty = true;
+        if (chunk.sizeBytes >= CHUNK_MAX_BYTES) {
+            void this.persistChunk(chunk, true);
+        }
+    }
+    async listEntries(input) {
+        const persisted = await this.readPersistedEntries(input);
+        const buffered = this.readBufferedEntries(input);
+        const merged = dedupeAndSort([...persisted, ...buffered]).reverse();
+        const filtered = input.cursor
+            ? merged.filter((entry) => (Date.parse(entry.createdAt) < Date.parse(input.cursor.createdAt)
+                || (entry.createdAt === input.cursor.createdAt && entry.id < input.cursor.id)))
+            : merged;
+        if (input.limit === undefined) {
+            return filtered;
+        }
+        const limit = Math.max(1, Math.min(input.limit, 501));
+        return filtered.slice(0, limit);
+    }
+    async renameTracer(input) {
+        const fromTracer = input.fromTracer.trim();
+        const toTracer = input.toTracer.trim();
+        if (!fromTracer || !toTracer || fromTracer === toTracer) {
+            return { updated: 0 };
+        }
+        let updated = 0;
+        for (const chunk of this.activeChunks.values()) {
+            if (chunk.customerId !== input.customerId) {
+                continue;
+            }
+            let chunkChanged = false;
+            for (const entry of chunk.entries) {
+                if (entry.tracer === fromTracer && withinRange(entry.createdAt, input.startTime, input.endTime)) {
+                    entry.tracer = toTracer;
+                    updated += 1;
+                    chunkChanged = true;
+                }
+            }
+            if (chunkChanged) {
+                chunk.dirty = true;
+                chunk.sizeBytes = chunk.entries.reduce((sum, entry) => sum + serializedEntrySize(entry), 0);
+                await this.persistChunk(chunk, false);
+            }
+        }
+        const keys = await this.listRelevantKeys(input);
+        await Promise.all(keys.map(async (key) => {
+            const content = await this.storage.readText(key);
+            const entries = parseChunk(content);
+            let changed = false;
+            for (const entry of entries) {
+                if (entry.customerId === input.customerId
+                    && entry.tracer === fromTracer
+                    && withinRange(entry.createdAt, input.startTime, input.endTime)) {
+                    entry.tracer = toTracer;
+                    updated += 1;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                const body = `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
+                await this.storage.putText(key, body, "application/x-ndjson; charset=utf-8");
+            }
+        }));
+        return { updated };
+    }
+    async shutdown() {
+        clearInterval(this.flushTimer);
+        await Promise.all([...this.activeChunks.values()].map((chunk) => this.persistChunk(chunk, true)));
+    }
+    async readPersistedEntries(input) {
+        const keys = await this.listRelevantKeys(input);
+        const entries = await Promise.all(keys.map(async (key) => parseChunk(await this.storage.readText(key))));
+        return entries
+            .flat()
+            .filter((entry) => entry.customerId === input.customerId)
+            .filter((entry) => withinRange(entry.createdAt, input.startTime, input.endTime));
+    }
+    readBufferedEntries(input) {
+        const buffered = [];
+        for (const chunk of this.activeChunks.values()) {
+            if (chunk.customerId !== input.customerId) {
+                continue;
+            }
+            for (const entry of chunk.entries.slice(chunk.lastPersistedEntryCount)) {
+                if (withinRange(entry.createdAt, input.startTime, input.endTime)) {
+                    buffered.push(entry);
+                }
+            }
+        }
+        return buffered;
+    }
+    async listRelevantKeys(input) {
+        const minuteStarts = this.minuteStartsForQuery(input.startTime, input.endTime);
+        if (minuteStarts === null) {
+            return this.storage.listKeys(`${API_CALL_HISTORY_PREFIX}/customer_id=${input.customerId}/`);
+        }
+        const nested = await Promise.all(minuteStarts.map((minuteStartMs) => (this.storage.listKeys(this.minutePrefix(input.customerId, minuteStartMs)))));
+        return nested.flat();
+    }
+    minuteStartsForQuery(startTime, endTime) {
+        if (!startTime && !endTime) {
+            return null;
+        }
+        const startMs = floorToMinute(Date.parse(startTime ?? endTime ?? new Date().toISOString()));
+        const endMs = floorToMinute(Date.parse(endTime ?? startTime ?? new Date().toISOString()));
+        const minMs = Math.min(startMs, endMs);
+        const maxMs = Math.max(startMs, endMs);
+        const minuteStarts = [];
+        for (let cursor = minMs; cursor <= maxMs; cursor += 60_000) {
+            minuteStarts.push(cursor);
+        }
+        return minuteStarts;
+    }
+    async flushExpiredChunks() {
+        const now = Date.now();
+        await Promise.all([...this.activeChunks.values()].map(async (chunk) => {
+            const intervalElapsed = now >= chunk.minuteStartMs + CHUNK_INTERVAL_MS;
+            if (intervalElapsed || chunk.sizeBytes >= CHUNK_MAX_BYTES) {
+                await this.persistChunk(chunk, true);
+                return;
+            }
+            if (chunk.dirty) {
+                await this.persistChunk(chunk, false);
+            }
+        }));
+    }
+    createChunk(customerId, minuteStartMs, sequence) {
+        const chunk = {
+            customerId,
+            minuteStartMs,
+            sequence,
+            entries: [],
+            sizeBytes: 0,
+            lastPersistedEntryCount: 0,
+            dirty: false
+        };
+        this.activeChunks.set(this.chunkKeyForMap(customerId, minuteStartMs, sequence), chunk);
+        return chunk;
+    }
+    findLatestChunk(activePrefix) {
+        const matching = [...this.activeChunks.entries()]
+            .filter(([key]) => key.startsWith(activePrefix))
+            .map(([, chunk]) => chunk)
+            .sort((a, b) => a.sequence - b.sequence);
+        return matching.at(-1) ?? null;
+    }
+    activeChunkPrefix(customerId, minuteStartMs) {
+        return `${customerId}:${minuteStartMs}:`;
+    }
+    chunkKeyForMap(customerId, minuteStartMs, sequence) {
+        return `${this.activeChunkPrefix(customerId, minuteStartMs)}${sequence}`;
+    }
+    async persistChunk(chunk, finalize) {
+        if (!chunk.entries.length) {
+            if (finalize) {
+                this.activeChunks.delete(this.chunkKeyForMap(chunk.customerId, chunk.minuteStartMs, chunk.sequence));
+            }
+            return;
+        }
+        const key = this.objectKeyForChunk(chunk);
+        const body = `${chunk.entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
+        await this.storage.putText(key, body, "application/x-ndjson; charset=utf-8");
+        chunk.lastPersistedEntryCount = chunk.entries.length;
+        chunk.dirty = false;
+        if (finalize) {
+            this.activeChunks.delete(this.chunkKeyForMap(chunk.customerId, chunk.minuteStartMs, chunk.sequence));
+        }
+    }
+    objectKeyForChunk(chunk) {
+        const startTs = Math.floor(chunk.entries[0] ? Date.parse(chunk.entries[0].createdAt) / 1000 : chunk.minuteStartMs / 1000);
+        const endTs = Math.floor(chunk.entries.at(-1) ? Date.parse(chunk.entries.at(-1).createdAt) / 1000 : chunk.minuteStartMs / 1000);
+        return `${this.minutePrefix(chunk.customerId, chunk.minuteStartMs)}chunk-${startTs}-${endTs}-${String(chunk.sequence).padStart(4, "0")}.ndjson`;
+    }
+    minutePrefix(customerId, minuteStartMs) {
+        return `${API_CALL_HISTORY_PREFIX}/customer_id=${customerId}/minute=${Math.floor(minuteStartMs / 1000)}/`;
+    }
+}
+export const apiCallHistoryStore = new ApiCallHistoryStore();
+function serializedEntrySize(entry) {
+    return Buffer.byteLength(`${JSON.stringify(entry)}\n`, "utf8");
+}
+function floorToMinute(timestampMs) {
+    return Math.floor(timestampMs / 60_000) * 60_000;
+}
+function parseChunk(content) {
+    if (!content) {
+        return [];
+    }
+    return content
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        const parsed = JSON.parse(line);
+        return {
+            ...parsed,
+            jobId: typeof parsed.jobId === "string" && parsed.jobId.trim() ? parsed.jobId.trim() : null
+        };
+    });
+}
+function dedupeAndSort(entries) {
+    const deduped = new Map();
+    for (const entry of entries) {
+        deduped.set(entry.id, entry);
+    }
+    return [...deduped.values()].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
+}
+function withinRange(createdAt, startTime, endTime) {
+    const value = Date.parse(createdAt);
+    if (startTime && value < Date.parse(startTime)) {
+        return false;
+    }
+    if (endTime && value > Date.parse(endTime)) {
+        return false;
+    }
+    return true;
+}

package/dist/src/services/auth.js

@@ -14,7 +14,7 @@ export class AuthService {
             expiresAt: addSeconds(new Date(), 600)
         });
         if (config.RESEND_API_KEY) {
-            await fetch("https://api.resend.com/emails", {
+            const response = await fetch("https://api.resend.com/emails", {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json",
@@ -27,9 +27,20 @@ export class AuthService {
                     text: `Your login code is ${code}. It expires in 10 minutes.`
                 })
             });
+            if (!response.ok) {
+                const body = await response.text();
+                throw new Error(`Unable to send OTP email (${response.status}): ${body || "empty response body"}`);
+            }
+            return {
+                delivery: "email"
+            };
         }
         else {
             console.log(`[vidfarm] OTP for ${email}: ${code}`);
+            return {
+                delivery: "console",
+                code: config.isProduction ? undefined : code
+            };
         }
     }
     verifyOtp(email, code, name) {
@@ -55,7 +66,8 @@ export class AuthService {
             name: name ?? existing?.name ?? null,
             defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
             isDeveloper: existing?.isDeveloper || config.adminEmails.includes(normalizedEmail),
-            isPaidPlan: existing?.isPaidPlan ?? false
+            isPaidPlan: existing?.isPaidPlan ?? false,
+            planTier: existing?.planTier ?? "starter"
         });
         const rawApiKey = `vf_${createId("key")}`;
         database.insertApiKey({
@@ -86,9 +98,12 @@ export class AuthService {
             defaultWebhookUrl: row.default_webhook_url ? String(row.default_webhook_url) : null,
             isDeveloper: Boolean(row.is_developer),
             isPaidPlan: Boolean(row.is_paid_plan),
+            planTier: normalizePlanTier(row.plan_tier),
             about: row.about ? String(row.about) : null,
             groupchatUrl: row.groupchat_url ? String(row.groupchat_url) : null,
-            flockposterApiKey: row.flockposter_api_key ? String(row.flockposter_api_key) : null
+            flockposterApiKey: row.flockposter_api_key ? String(row.flockposter_api_key) : null,
+            createdAt: String(row.created_at),
+            updatedAt: String(row.updated_at)
         };
     }
     verifyOtpForBrowserLogin(email, code, name) {
@@ -134,7 +149,14 @@ export class AuthService {
             defaultWebhookUrl: existing?.defaultWebhookUrl ?? null,
             isDeveloper: existing?.isDeveloper || config.adminEmails.includes(normalizedEmail),
             isPaidPlan: true,
+            planTier: input.planTier ?? existing?.planTier ?? "starter",
             passwordHash: hashPassword(input.password)
         });
     }
 }
+function normalizePlanTier(value) {
+    if (value === "starter" || value === "agency" || value === "standard") {
+        return value;
+    }
+    return "starter";
+}

package/dist/src/services/billing.js

@@ -1,16 +1,255 @@
+import { createHash } from "node:crypto";
 import { database } from "../db.js";
 import { createId } from "../lib/ids.js";
+import { config } from "../config.js";
+const BILLING_COST_EVENTS_PATH = "/v1/cost-events";
+const BILLING_WALLET_FUNDING_INTENTS_PATH = "/v1/wallet-funding-intents";
+const BILLING_WALLET_FUNDING_CONFIRMED_PATH = "/v1/wallet-funding-confirmed";
+const PAID_SIGNUP_BONUS_GRANT_TYPE = "paid_signup_bonus";
+const PAID_SIGNUP_BONUS_USD = 5;
 export class BillingService {
+    async getWalletSummary(customerId) {
+        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
+            throw new Error("Billing service is not configured.");
+        }
+        const response = await fetch(new URL(`/v1/wallets/${encodeURIComponent(customerId)}`, config.VIDFARM_BILLING_URL), {
+            headers: {
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            }
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Billing wallet lookup failed (${response.status}): ${body || response.statusText}`);
+        }
+        const payload = await response.json();
+        return {
+            currency: typeof payload.currency === "string" ? payload.currency : "USD",
+            balanceUsd: Number(payload.balance_usd ?? 0),
+            balanceMicrosUsd: Number(payload.balance_micros_usd ?? 0)
+        };
+    }
+    async getJobBillingSummary(input) {
+        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
+            return {
+                currency: "USD",
+                eventCount: 0,
+                totalBaseCostUsd: 0,
+                totalChargeUsd: 0,
+                unavailableReason: "Billing service is not configured."
+            };
+        }
+        const url = new URL(`/v1/jobs/${encodeURIComponent(input.jobId)}/billing`, config.VIDFARM_BILLING_URL);
+        url.searchParams.set("customer_id", input.customerId);
+        if (input.templateId) {
+            url.searchParams.set("template_id", input.templateId);
+        }
+        const response = await fetch(url, {
+            headers: {
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            }
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Billing job summary lookup failed (${response.status}): ${body || response.statusText}`);
+        }
+        const payload = await response.json();
+        return {
+            currency: typeof payload.currency === "string" ? payload.currency : "USD",
+            eventCount: Number(payload.event_count ?? 0),
+            totalBaseCostUsd: Number(payload.total_base_cost_usd ?? 0),
+            totalChargeUsd: Number(payload.total_charge_usd ?? 0),
+            unavailableReason: null
+        };
+    }
     async record(input) {
-        database.insertBillingEvent({
-            id: createId("bill"),
-            customerId: input.customerId,
-            jobId: input.jobId,
-            templateId: input.templateId,
-            type: input.type,
-            costUsd: input.costUsd,
-            chargeUsd: input.chargeUsd,
-            metadata: input.metadata
+        const normalizedCostCenterSlug = resolveCostCenterSlug(input);
+        const normalizedIdempotencyKey = resolveIdempotencyKey(input, normalizedCostCenterSlug);
+        const remoteEventCostCenterSlug = normalizedCostCenterSlug ?? null;
+        if (!remoteEventCostCenterSlug) {
+            return;
+        }
+        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
+            throw new Error(`Billing URL/secret missing for cost center ${remoteEventCostCenterSlug}.`);
+        }
+        const response = await fetch(new URL(BILLING_COST_EVENTS_PATH, config.VIDFARM_BILLING_URL), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            },
+            body: JSON.stringify({
+                idempotency_key: normalizedIdempotencyKey ?? `${remoteEventCostCenterSlug}:${input.jobId}:${input.templateId}:${input.type}`,
+                customer_id: input.customerId,
+                job_id: input.jobId,
+                tracer: input.tracer,
+                cost_center_slug: remoteEventCostCenterSlug,
+                base_cost_usd: input.costUsd,
+                metadata: {
+                    ...input.metadata,
+                    template_id: input.templateId,
+                    local_charge_usd: input.chargeUsd
+                },
+                occurred_at_ms: input.occurredAtMs ?? Date.now()
+            })
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Billing service rejected cost event (${response.status}): ${body || response.statusText}`);
+        }
+        await response.json().catch(() => ({}));
+    }
+    async grantPaidSignupBonus(customerId, metadata) {
+        const customer = database.getCustomerById(customerId);
+        if (!customer) {
+            throw new Error("Customer not found.");
+        }
+        if (!customer.isPaidPlan) {
+            return { granted: false, reason: "customer_not_paid" };
+        }
+        if (database.hasCustomerCreditGrant(customerId, PAID_SIGNUP_BONUS_GRANT_TYPE)) {
+            return { granted: false, reason: "already_granted" };
+        }
+        if (!config.VIDFARM_BILLING_URL || !config.VIDFARM_BILLING_SECRET) {
+            throw new Error("Billing service is not configured.");
+        }
+        const clientReferenceId = buildPaidSignupBonusClientReferenceId(customerId);
+        const stripeEventId = `${PAID_SIGNUP_BONUS_GRANT_TYPE}:${customerId}`;
+        const intentResponse = await fetch(new URL(BILLING_WALLET_FUNDING_INTENTS_PATH, config.VIDFARM_BILLING_URL), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            },
+            body: JSON.stringify({
+                customer_id: customerId,
+                client_reference_id: clientReferenceId,
+                occurred_at_ms: Date.now(),
+                metadata: {
+                    ...(metadata ?? {}),
+                    grant_type: PAID_SIGNUP_BONUS_GRANT_TYPE
+                }
+            })
+        });
+        if (!intentResponse.ok) {
+            const body = await intentResponse.text().catch(() => "");
+            if (!/TransactionCanceledException|ConditionalCheckFailed|duplicate/i.test(body)) {
+                throw new Error(`Billing service rejected wallet funding intent (${intentResponse.status}): ${body || intentResponse.statusText}`);
+            }
+        }
+        const response = await fetch(new URL(BILLING_WALLET_FUNDING_CONFIRMED_PATH, config.VIDFARM_BILLING_URL), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-vidfarm-billing-secret": config.VIDFARM_BILLING_SECRET
+            },
+            body: JSON.stringify({
+                client_reference_id: clientReferenceId,
+                amount_usd: PAID_SIGNUP_BONUS_USD,
+                stripe_event_id: stripeEventId,
+                occurred_at_ms: Date.now(),
+                metadata: {
+                    ...(metadata ?? {}),
+                    grant_type: PAID_SIGNUP_BONUS_GRANT_TYPE
+                }
+            })
         });
+        if (!response.ok) {
+            const body = await response.text().catch(() => "");
+            throw new Error(`Billing service rejected signup wallet funding (${response.status}): ${body || response.statusText}`);
+        }
+        try {
+            database.insertCustomerCreditGrant({
+                id: createId("grant"),
+                customerId,
+                grantType: PAID_SIGNUP_BONUS_GRANT_TYPE,
+                amountUsd: PAID_SIGNUP_BONUS_USD,
+                metadata: metadata ?? {}
+            });
+        }
+        catch (error) {
+            if (!isUniqueConstraintError(error)) {
+                throw error;
+            }
+        }
+        return {
+            granted: true,
+            reason: "granted",
+            amountUsd: PAID_SIGNUP_BONUS_USD,
+            grantType: PAID_SIGNUP_BONUS_GRANT_TYPE
+        };
+    }
+}
+function resolveCostCenterSlug(input) {
+    if (input.costCenterSlug?.trim()) {
+        const explicitSlug = input.costCenterSlug.trim();
+        return explicitSlug === "remotion_lambda" ? explicitSlug : null;
+    }
+    if (input.type === "render" && input.metadata?.mode === "lambda") {
+        return "remotion_lambda";
     }
+    return null;
+}
+function resolveIdempotencyKey(input, costCenterSlug) {
+    if (input.idempotencyKey?.trim()) {
+        return input.idempotencyKey.trim();
+    }
+    const renderId = typeof input.metadata?.render_id === "string"
+        ? input.metadata.render_id
+        : typeof input.metadata?.renderId === "string"
+            ? input.metadata.renderId
+            : null;
+    if (costCenterSlug === "remotion_lambda" && renderId) {
+        return `remotion_lambda:${renderId}`;
+    }
+    return buildBillingEventFingerprint(input, costCenterSlug);
+}
+function buildBillingEventFingerprint(input, costCenterSlug) {
+    const fingerprintPayload = {
+        customerId: input.customerId,
+        jobId: input.jobId,
+        templateId: input.templateId,
+        tracer: input.tracer ?? null,
+        type: input.type,
+        costCenterSlug,
+        costUsd: roundUsd(input.costUsd),
+        chargeUsd: input.chargeUsd == null ? null : roundUsd(input.chargeUsd),
+        occurredAtMs: input.occurredAtMs ?? null,
+        metadata: sortJsonValue(input.metadata ?? {})
+    };
+    const digest = createHash("sha256")
+        .update(JSON.stringify(fingerprintPayload))
+        .digest("hex")
+        .slice(0, 24);
+    return `${costCenterSlug ?? input.type}:${input.jobId}:${digest}`;
+}
+function sortJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortJsonValue);
+    }
+    if (value && typeof value === "object") {
+        return Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .reduce((acc, [key, nestedValue]) => {
+            acc[key] = sortJsonValue(nestedValue);
+            return acc;
+        }, {});
+    }
+    return value;
+}
+function roundUsd(value) {
+    return Number(value.toFixed(6));
+}
+function isUniqueConstraintError(error) {
+    return Boolean(error instanceof Error && /unique constraint/i.test(error.message));
+}
+function buildPaidSignupBonusClientReferenceId(customerId) {
+    const digest = createHash("sha256").update(`${PAID_SIGNUP_BONUS_GRANT_TYPE}:${customerId}`).digest("hex");
+    const part1 = digest.slice(0, 8);
+    const part2 = digest.slice(8, 12);
+    const part3 = `4${digest.slice(13, 16)}`;
+    const variantNibble = (8 + (Number.parseInt(digest.slice(16, 17), 16) % 4)).toString(16);
+    const part4 = `${variantNibble}${digest.slice(17, 20)}`;
+    const part5 = digest.slice(20, 32);
+    return `vidfarm_wallet_topup_${part1}-${part2}-${part3}-${part4}-${part5}`;
 }
+export { PAID_SIGNUP_BONUS_GRANT_TYPE, PAID_SIGNUP_BONUS_USD, resolveCostCenterSlug, resolveIdempotencyKey };