@farm.js/autumn 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,1303 @@
+import { Autumn as AutumnSDK } from "autumn-js";
+import { Webhook as StandardWebhook, WebhookVerificationError as StandardWebhookVerificationError, } from "standardwebhooks";
+import { defineIntegration, integrationRoute, } from "@farm.js/core";
+import { integrationConfig, normalizeWebhookConfig, resolveAppPath, toAbsoluteUrl, } from "@farm.js/integration-utils";
+import { createAutumnClientApi, } from "./client.js";
+export { autumnClient } from "./client.js";
+const pendingAutumnMeterProjection = new Map();
+function createAutumnApi(input) {
+    return createAutumnClientApi(input);
+}
+function normalizeProducts(products) {
+    return Object.entries(products ?? {}).map(([id, product]) => {
+        const autumnPlanId = product.autumn?.planId ?? product.autumnPlanId;
+        if (!autumnPlanId) {
+            throw new Error(`Autumn billing product "${id}" requires autumn.planId (or autumnPlanId).`);
+        }
+        return {
+            ...product,
+            autumnPlanId,
+            id,
+            public: product.public ?? true,
+        };
+    });
+}
+function toCatalogProduct(product, plans) {
+    return {
+        id: product.id,
+        autumnPlanId: product.autumnPlanId,
+        name: product.name ?? product.id,
+        description: product.description ?? null,
+        kind: product.kind,
+        planId: product.planId ?? null,
+        trialDays: product.planId ? (plans[product.planId]?.trial?.days ?? null) : null,
+        public: product.public,
+        currency: product.currency ?? null,
+        unitAmount: product.unitAmount ?? null,
+        interval: product.interval ?? null,
+        intervalCount: product.intervalCount ?? null,
+        meterPrices: [],
+        metadata: product.metadata ?? {},
+    };
+}
+function normalizeAutumnInterval(value) {
+    switch (value) {
+        case "day":
+        case "week":
+        case "month":
+        case "year":
+            return value;
+        default:
+            return null;
+    }
+}
+function formatCatalogMoney(amount, currency) {
+    return new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: (currency ?? "usd").toUpperCase(),
+        maximumFractionDigits: amount % 100 === 0 ? 0 : 2,
+    }).format(amount / 100);
+}
+function formatCatalogUnitAmount(value, currency) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return value;
+    }
+    return new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: (currency ?? "usd").toUpperCase(),
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 6,
+    }).format(parsed);
+}
+function projectMeterUsage(input) {
+    switch (input.aggregation) {
+        case "count":
+            return input.currentUsed + 1;
+        case "last":
+            return input.quantity;
+        default:
+            return input.currentUsed + input.quantity;
+    }
+}
+function toCentsFromDollars(amount) {
+    return typeof amount === "number" && Number.isFinite(amount) ? Math.round(amount * 100) : null;
+}
+function toDecimalStringFromDollars(amount) {
+    return typeof amount === "number" && Number.isFinite(amount) ? amount.toFixed(6) : null;
+}
+function priceCapAmount(price) {
+    if (!price || typeof price.maxPurchase !== "number" || price.maxPurchase <= 0) {
+        return null;
+    }
+    if (typeof price.amount !== "number" || price.amount <= 0) {
+        return null;
+    }
+    const billingUnits = typeof price.billingUnits === "number" && price.billingUnits > 0 ? price.billingUnits : 1;
+    const cappedBuckets = Math.ceil(price.maxPurchase / billingUnits);
+    return Math.round(cappedBuckets * price.amount * 100);
+}
+function resolveEffectiveLimit(planLimit, granted) {
+    if (typeof planLimit === "number" && typeof granted === "number") {
+        return Math.max(planLimit, granted);
+    }
+    if (typeof planLimit === "number") {
+        return planLimit;
+    }
+    if (typeof granted === "number") {
+        return granted;
+    }
+    return null;
+}
+function summarizeAutumnCatalogMeterPrice(input) {
+    if (!input.unitAmountDecimal) {
+        return null;
+    }
+    const parts = [];
+    if (typeof input.includedUnits === "number" && input.includedUnits > 0) {
+        parts.push(`${input.includedUnits.toLocaleString()} included`);
+    }
+    const unitLabel = typeof input.billingUnits === "number" && input.billingUnits > 1
+        ? `${input.billingUnits.toLocaleString()} ${input.unit ?? "units"}`
+        : (input.unit ?? "unit");
+    parts.push(`${formatCatalogUnitAmount(input.unitAmountDecimal, input.currency)}/${unitLabel}`);
+    if (typeof input.capAmount === "number") {
+        parts.push(`capped at ${formatCatalogMoney(input.capAmount, input.currency)}`);
+    }
+    return parts.join(", ");
+}
+function resolveMeterFeatureId(meter) {
+    return meter?.featureId?.trim() ? meter.featureId : null;
+}
+async function listPlansById(sdk) {
+    const response = await sdk.plans.list();
+    const byId = new Map();
+    for (const summary of response.list ?? []) {
+        const plan = await sdk.plans.get({
+            planId: summary.id,
+        });
+        byId.set(plan.id, plan);
+    }
+    return byId;
+}
+function findPlanMeterPrice(plan, featureId) {
+    for (const item of plan?.items ?? []) {
+        if (item.featureId !== featureId || !item.price) {
+            continue;
+        }
+        return { item, price: item.price };
+    }
+    return null;
+}
+function toAutumnProductItem(item) {
+    return {
+        featureId: item.featureId,
+        included: item.included ?? undefined,
+        unlimited: item.unlimited ?? undefined,
+        reset: item.reset ?? undefined,
+        price: item.price
+            ? {
+                amount: item.price.amount ?? undefined,
+                interval: normalizeAutumnInterval(item.price.interval ?? null) ?? "month",
+                intervalCount: item.price.intervalCount ?? undefined,
+                billingUnits: item.price.billingUnits ?? undefined,
+                billingMethod: item.price.billingMethod,
+                maxPurchase: item.price.maxPurchase ?? undefined,
+            }
+            : undefined,
+        rollover: item.rollover
+            ? {
+                max: item.rollover.max ?? undefined,
+                maxPercentage: item.rollover.maxPercentage ?? undefined,
+                expiryDurationType: item.rollover.expiryDurationType,
+                expiryDurationLength: item.rollover.expiryDurationLength ?? undefined,
+            }
+            : undefined,
+    };
+}
+function mergeAutumnProductItems(livePlan, product) {
+    const merged = new Map();
+    for (const item of livePlan?.items ?? []) {
+        merged.set(item.featureId, toAutumnProductItem(item));
+    }
+    for (const item of product?.autumn?.items ?? []) {
+        const previous = merged.get(item.featureId);
+        merged.set(item.featureId, {
+            ...previous,
+            ...item,
+            reset: item.reset ?? previous?.reset,
+            price: item.price ?? previous?.price,
+            proration: item.proration ?? previous?.proration,
+            rollover: item.rollover ?? previous?.rollover,
+        });
+    }
+    return [...merged.values()];
+}
+function findConfiguredMeterPrice(input) {
+    for (const item of mergeAutumnProductItems(input.livePlan, input.product)) {
+        if (item.featureId !== input.featureId || !item.price) {
+            continue;
+        }
+        return {
+            item,
+            price: item.price,
+        };
+    }
+    return null;
+}
+async function enrichCatalogProduct(sdk, product, plans, meters, livePlansById) {
+    const base = toCatalogProduct(product, plans);
+    const livePlan = livePlansById.get(product.autumnPlanId) ?? null;
+    if (!livePlan) {
+        return base;
+    }
+    const meterPrices = [];
+    for (const [key, meter] of Object.entries(meters ?? {})) {
+        const featureId = resolveMeterFeatureId(meter);
+        if (!featureId) {
+            continue;
+        }
+        const matched = findConfiguredMeterPrice({
+            livePlan,
+            product,
+            featureId,
+        });
+        if (!matched) {
+            continue;
+        }
+        const unitAmountDecimal = toDecimalStringFromDollars(matched.price.amount ?? null);
+        const capAmount = priceCapAmount(matched.price);
+        meterPrices.push({
+            key,
+            eventName: meter.eventName ?? featureId,
+            featureId,
+            unit: meter.unit ?? null,
+            currency: product.currency ?? "usd",
+            unitAmountDecimal,
+            capAmount,
+            billingUnits: matched.price.billingUnits ?? null,
+            includedUnits: matched.item.included ?? null,
+            maxPurchaseUnits: matched.price.maxPurchase ?? null,
+            summary: summarizeAutumnCatalogMeterPrice({
+                unitAmountDecimal,
+                unit: meter.unit ?? null,
+                capAmount,
+                includedUnits: matched.item.included ?? null,
+                billingUnits: matched.price.billingUnits ?? null,
+                currency: product.currency ?? "usd",
+            }),
+        });
+    }
+    return {
+        ...base,
+        name: livePlan.name || base.name,
+        description: livePlan.description ?? base.description,
+        trialDays: livePlan.freeTrial?.durationType === "day" ? livePlan.freeTrial.durationLength : null,
+        currency: base.currency ?? "usd",
+        unitAmount: toCentsFromDollars(livePlan.price?.amount) ?? base.unitAmount,
+        interval: normalizeAutumnInterval(livePlan.price?.interval ?? null) ?? base.interval,
+        intervalCount: livePlan.price?.intervalCount ?? base.intervalCount,
+        meterPrices,
+    };
+}
+function getOwnerExternalCustomerId(owner, billing, tools) {
+    if (billing.resolveExternalCustomerId) {
+        return billing.resolveExternalCustomerId(owner, tools);
+    }
+    const normalizedId = owner.id
+        .trim()
+        .replace(/[^a-zA-Z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return `${owner.kind}_${normalizedId || "unknown"}`;
+}
+function resolveAutumnPlanLimitReference(value, defaultKey) {
+    if (!value || value === "plan_limit" || typeof value === "number") {
+        return null;
+    }
+    if (typeof value === "string") {
+        const match = /^plans\.([^.]+)\.limits?\.([^.]+)$/.exec(value);
+        if (!match) {
+            return null;
+        }
+        return {
+            planId: match[1],
+            key: match[2],
+        };
+    }
+    if (typeof value.planId === "string" && value.planId.trim()) {
+        return {
+            planId: value.planId,
+            key: typeof value.key === "string" && value.key.trim() ? value.key : defaultKey,
+        };
+    }
+    return null;
+}
+function resolveSoftLimit(plans, planId, key, includedLimit, guard) {
+    if (!guard?.softLimit) {
+        return null;
+    }
+    if (guard.softLimit === "plan_limit") {
+        return includedLimit;
+    }
+    const reference = resolveAutumnPlanLimitReference(guard.softLimit, key);
+    if (reference) {
+        const referencedLimit = plans[reference.planId]?.limits?.[reference.key ?? key] ?? null;
+        return typeof referencedLimit === "number" ? referencedLimit : null;
+    }
+    return typeof guard.softLimit === "number" ? guard.softLimit : null;
+}
+function resolveHardLimit(planId, includedLimit, guard) {
+    if (!guard) {
+        return null;
+    }
+    if (typeof guard.hardLimitByPlan?.[planId] === "number") {
+        return guard.hardLimitByPlan[planId];
+    }
+    if (typeof guard.hardLimit === "number") {
+        return guard.hardLimit;
+    }
+    if (typeof includedLimit === "number" && typeof guard.hardOverageByPlan?.[planId] === "number") {
+        return includedLimit + guard.hardOverageByPlan[planId];
+    }
+    if (typeof includedLimit === "number" && typeof guard.hardOverage === "number") {
+        return includedLimit + guard.hardOverage;
+    }
+    return null;
+}
+function projectionKey(input) {
+    return `${input.externalCustomerId}:${input.featureId}:${input.currentPeriodEnd ?? "none"}`;
+}
+function getProjectedUsage(input) {
+    const key = projectionKey(input);
+    const projected = pendingAutumnMeterProjection.get(key);
+    if (projected == null) {
+        return input.currentPeriodUsed;
+    }
+    if (input.currentPeriodUsed >= projected) {
+        pendingAutumnMeterProjection.delete(key);
+        return input.currentPeriodUsed;
+    }
+    return projected;
+}
+function setProjectedUsage(input) {
+    pendingAutumnMeterProjection.set(projectionKey(input), input.projectedUsage);
+}
+function normalizeAutumnStatus(customer, subscription) {
+    if (!customer || !subscription) {
+        return "free";
+    }
+    if (subscription.pastDue) {
+        return "past_due";
+    }
+    if (subscription.canceledAt != null) {
+        return "canceled";
+    }
+    if (subscription.trialEndsAt != null && subscription.trialEndsAt > Date.now()) {
+        return "trialing";
+    }
+    if (subscription.status === "scheduled") {
+        return "scheduled";
+    }
+    return "active";
+}
+function resolveActiveProduct(customer, products) {
+    const byPlanId = new Map(products.map((product) => [product.autumnPlanId, product]));
+    const matchedSubscription = [...(customer?.subscriptions ?? [])]
+        .filter((entry) => byPlanId.has(entry.planId))
+        .sort((left, right) => right.startedAt - left.startedAt)[0];
+    if (matchedSubscription) {
+        return {
+            product: byPlanId.get(matchedSubscription.planId) ?? null,
+            subscription: matchedSubscription,
+            purchase: null,
+            status: normalizeAutumnStatus(customer, matchedSubscription),
+        };
+    }
+    const matchedPurchase = [...(customer?.purchases ?? [])]
+        .filter((entry) => byPlanId.has(entry.planId))
+        .sort((left, right) => right.startedAt - left.startedAt)[0];
+    if (matchedPurchase) {
+        return {
+            product: byPlanId.get(matchedPurchase.planId) ?? null,
+            subscription: null,
+            purchase: matchedPurchase,
+            status: "active",
+        };
+    }
+    return {
+        product: null,
+        subscription: null,
+        purchase: null,
+        status: "free",
+    };
+}
+function currentPeriodStart(subscription) {
+    return subscription?.currentPeriodStart != null
+        ? new Date(subscription.currentPeriodStart).toISOString()
+        : null;
+}
+function currentPeriodEnd(subscription) {
+    return subscription?.currentPeriodEnd != null
+        ? new Date(subscription.currentPeriodEnd).toISOString()
+        : null;
+}
+function trialEndsAt(subscription) {
+    return subscription?.trialEndsAt != null
+        ? new Date(subscription.trialEndsAt).toISOString()
+        : null;
+}
+function computeMeterState(input) {
+    if (!input.featureFound) {
+        return {
+            state: "meter_missing",
+            warning: "The configured Autumn feature is not active for this customer yet.",
+        };
+    }
+    if (input.guard?.blockOnPastDue && input.subscriptionStatus === "past_due") {
+        return {
+            state: "blocked_past_due",
+            warning: "Usage reporting is blocked while the Autumn subscription is past due.",
+        };
+    }
+    if (typeof input.hardLimit === "number" && input.currentUsed >= input.hardLimit) {
+        return {
+            state: "hard_limit_reached",
+            warning: "The configured metered hard cap has been reached for the current billing period.",
+        };
+    }
+    if (typeof input.softLimit === "number" && input.currentUsed >= input.softLimit) {
+        return {
+            state: "soft_limit_reached",
+            warning: typeof input.includedLimit === "number"
+                ? "Included usage has been exhausted. Additional usage is billable."
+                : "The configured soft limit has been reached.",
+        };
+    }
+    return {
+        state: "ok",
+        warning: null,
+    };
+}
+function resolveUsageValue(input) {
+    if (input.billing.usage) {
+        return input.billing.usage.resolve(input.owner, input.key, input.tools);
+    }
+    const featureId = resolveMeterFeatureId(input.billing.meters?.[input.key] ?? null);
+    if (!featureId) {
+        return null;
+    }
+    return input.customer?.balances?.[featureId]?.usage ?? null;
+}
+function estimateUsageChargeFromBalance(input) {
+    const balanceBreakdown = input.balance?.breakdown?.find((entry) => entry.price);
+    const matched = balanceBreakdown?.price
+        ? {
+            item: null,
+            price: balanceBreakdown.price,
+        }
+        : findPlanMeterPrice(input.livePlan, input.featureId);
+    if (!matched) {
+        return {
+            chargeSource: "catalog_rate",
+            unitAmountDecimal: null,
+            capAmount: null,
+            billingUnits: null,
+            estimatedMeterChargeAmount: null,
+        };
+    }
+    const billingUnits = typeof matched.price.billingUnits === "number" && matched.price.billingUnits > 0
+        ? matched.price.billingUnits
+        : 1;
+    const unitAmount = matched.price.amount ?? null;
+    const unitAmountDecimal = toDecimalStringFromDollars(unitAmount);
+    const capAmount = priceCapAmount(matched.price);
+    const balance = input.balance;
+    const overageUnits = balance && balance.overageAllowed ? Math.max(balance.usage - balance.granted, 0) : 0;
+    const billableBuckets = Math.ceil(overageUnits / billingUnits);
+    const uncapped = typeof unitAmount === "number" && unitAmount > 0
+        ? Math.round(billableBuckets * unitAmount * 100)
+        : null;
+    return {
+        chargeSource: balanceBreakdown?.price ? "balance" : "catalog_rate",
+        unitAmountDecimal,
+        capAmount,
+        billingUnits,
+        estimatedMeterChargeAmount: uncapped == null || capAmount == null ? uncapped : Math.min(uncapped, capAmount),
+    };
+}
+function isPrepaidFeatureQuantity(input) {
+    const matched = findConfiguredMeterPrice({
+        livePlan: input.livePlan,
+        product: input.product,
+        featureId: input.featureId,
+    });
+    return matched?.price.billingMethod === "prepaid";
+}
+function toCurrentChargeLine(input) {
+    return {
+        key: input.key,
+        kind: input.kind,
+        label: input.label,
+        amount: input.amount ?? null,
+        currency: input.currency,
+        quantity: input.quantity ?? null,
+        includedUnits: input.includedUnits ?? null,
+        overageUnits: input.overageUnits ?? null,
+        billedBuckets: input.billedBuckets ?? null,
+        billingUnits: input.billingUnits ?? null,
+        unitAmountDecimal: input.unitAmountDecimal ?? null,
+    };
+}
+async function requireOwner(ctx, billing, autumn) {
+    const tools = { ctx, autumn };
+    const owner = await billing.resolveOwner(ctx);
+    if (!owner) {
+        throw new Error("Autumn billing owner could not be resolved for this request.");
+    }
+    const externalCustomerId = await getOwnerExternalCustomerId(owner, billing, tools);
+    const customer = await autumn.customers.getOrCreate({
+        customerId: externalCustomerId,
+        name: owner.name,
+        email: owner.email,
+        fingerprint: owner.fingerprint,
+        metadata: owner.metadata,
+    });
+    return {
+        owner,
+        externalCustomerId,
+        customer,
+        tools,
+    };
+}
+function webhookHeadersToStandardHeaders(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key.toLowerCase()] = value;
+    });
+    if (result["svix-id"] && !result["webhook-id"]) {
+        result["webhook-id"] = result["svix-id"];
+    }
+    if (result["svix-signature"] && !result["webhook-signature"]) {
+        result["webhook-signature"] = result["svix-signature"];
+    }
+    if (result["svix-timestamp"] && !result["webhook-timestamp"]) {
+        result["webhook-timestamp"] = result["svix-timestamp"];
+    }
+    return result;
+}
+function createStandardWebhook(secret) {
+    return new StandardWebhook(Buffer.from(secret, "utf-8").toString("base64"));
+}
+export function autumn(input) {
+    const secretKey = input.secretKey ?? process.env.AUTUMN_SECRET_KEY ?? "";
+    const appBaseUrl = input.appBaseUrl ?? process.env.APP_BASE_URL ?? undefined;
+    const webhookSecret = process.env.AUTUMN_WEBHOOK_SECRET ?? undefined;
+    if (!input.instance && !secretKey) {
+        throw new Error("Autumn integration requires AUTUMN_SECRET_KEY or an Autumn instance.");
+    }
+    const billing = input.billing;
+    const productsPath = (input.productsPath ?? "/billing/products");
+    const statusPath = (input.statusPath ?? "/billing/status");
+    const currentChargesPath = (input.currentChargesPath ??
+        "/billing/current-charges");
+    const invoicesPath = (input.invoicesPath ?? "/billing/invoices");
+    const featuresPath = (input.featuresPath ?? "/billing/features");
+    const limitsPath = (input.limitsPath ?? "/billing/limits");
+    const usagePath = (input.usagePath ?? "/billing/usage");
+    const meterUsagePath = (input.meterUsagePath ??
+        "/billing/meter-usage");
+    const reportUsagePath = (input.reportUsagePath ??
+        "/billing/report-usage");
+    const checkPath = (input.checkPath ?? "/billing/check");
+    const checkoutPath = (input.checkoutPath ?? "/billing/checkout");
+    const portalPath = (input.portalPath ?? "/billing/portal");
+    const webhookDefinitions = normalizeWebhookConfig({
+        webhooks: input.webhooks,
+        defaultName: "default",
+        defaultPath: "/billing/webhook",
+        defaultSecret: webhookSecret,
+    });
+    const plans = billing.plans ?? {};
+    const products = normalizeProducts(billing.products);
+    for (const [key, meter] of Object.entries(billing.meters ?? {})) {
+        if (!resolveMeterFeatureId(meter)) {
+            throw new Error(`Autumn billing meter "${key}" requires a featureId.`);
+        }
+    }
+    const sdk = input.instance ??
+        new AutumnSDK({
+            secretKey,
+            serverURL: input.serverURL,
+        });
+    const webhookRoutes = webhookDefinitions.map((definition) => integrationRoute.post(definition.path, {
+        responseFormat: "json",
+        rawBody: true,
+        async handler(request, context) {
+            const rawBody = await request.text();
+            const webhookContext = {
+                request,
+                route: context,
+                rawBody,
+                headers: request.headers,
+                webhook: {
+                    name: definition.name,
+                    path: definition.path,
+                },
+            };
+            try {
+                if (!definition.secret) {
+                    throw new Error("Autumn webhook secret is required to verify webhook events.");
+                }
+                const verifier = createStandardWebhook(definition.secret);
+                const payload = verifier.verify(rawBody, webhookHeadersToStandardHeaders(request.headers));
+                const eventId = request.headers.get("svix-id") ??
+                    request.headers.get("webhook-id") ??
+                    `${payload.type}:${Date.now()}`;
+                const event = {
+                    provider: "autumn",
+                    id: eventId,
+                    type: payload.type,
+                    data: payload.data,
+                    raw: payload,
+                };
+                await definition.onEvent?.(event, webhookContext);
+                return Response.json({
+                    received: true,
+                    provider: "autumn",
+                    webhook: definition.name,
+                    eventId: event.id,
+                    type: event.type,
+                });
+            }
+            catch (error) {
+                const override = await definition.onError?.(error, webhookContext);
+                if (override) {
+                    return override;
+                }
+                return Response.json({
+                    error: error instanceof Error ? error.message : "Autumn webhook verification failed.",
+                }, {
+                    status: error instanceof StandardWebhookVerificationError ? 403 : 400,
+                });
+            }
+        },
+    }));
+    return defineIntegration({
+        category: "payment",
+        type: "autumn",
+        instance: {
+            products: products.map((product) => ({
+                id: product.id,
+                autumnPlanId: product.autumnPlanId,
+                kind: product.kind,
+                planId: product.planId ?? null,
+            })),
+        },
+        config: integrationConfig({
+            label: "Autumn integration",
+            env: {
+                secretKey: "AUTUMN_SECRET_KEY",
+                appBaseUrl: "APP_BASE_URL",
+                webhookSecret: "AUTUMN_WEBHOOK_SECRET",
+            },
+            input: {
+                secretKey,
+                serverURL: input.serverURL,
+                appBaseUrl,
+                webhookSecret,
+            },
+            required: input.instance ? [] : ["secretKey"],
+        }),
+        api: createAutumnApi({
+            productsPath,
+            statusPath,
+            currentChargesPath,
+            invoicesPath,
+            featuresPath,
+            limitsPath,
+            usagePath,
+            meterUsagePath,
+            reportUsagePath,
+            checkPath,
+            checkoutPath,
+            portalPath,
+        }),
+        log: input.log,
+        routes: [
+            integrationRoute.get(productsPath, {
+                responseFormat: "json",
+                async handler() {
+                    let livePlansById;
+                    try {
+                        livePlansById = await listPlansById(sdk);
+                    }
+                    catch {
+                        return Response.json(products
+                            .filter((product) => product.public)
+                            .map((product) => toCatalogProduct(product, plans)));
+                    }
+                    return Response.json(await Promise.all(products
+                        .filter((product) => product.public)
+                        .map((product) => enrichCatalogProduct(sdk, product, plans, billing.meters, livePlansById))));
+                },
+            }),
+            integrationRoute.get(statusPath, {
+                responseFormat: "json",
+                async handler(_request, ctx) {
+                    const owner = await billing.resolveOwner(ctx);
+                    if (!owner) {
+                        const plan = plans.free ?? {};
+                        return Response.json({
+                            owner: null,
+                            externalCustomerId: null,
+                            customerId: null,
+                            planId: "free",
+                            productId: null,
+                            status: "free",
+                            subscriptionId: null,
+                            currentPeriodStart: null,
+                            currentPeriodEnd: null,
+                            cancelAtPeriodEnd: false,
+                            trialEndsAt: null,
+                            features: plan.features ?? {},
+                            limits: plan.limits ?? {},
+                            entitlements: plan.entitlements ?? {},
+                        });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const active = resolveActiveProduct(resolved.customer, products);
+                    const planId = active.product?.planId ?? "free";
+                    const plan = plans[planId] ?? {};
+                    return Response.json({
+                        owner: resolved.owner,
+                        externalCustomerId: resolved.externalCustomerId,
+                        customerId: resolved.customer.id,
+                        planId,
+                        productId: active.product?.id ?? null,
+                        status: active.status,
+                        subscriptionId: active.subscription?.id ?? null,
+                        currentPeriodStart: currentPeriodStart(active.subscription),
+                        currentPeriodEnd: currentPeriodEnd(active.subscription),
+                        cancelAtPeriodEnd: active.subscription?.expiresAt != null &&
+                            (active.subscription.canceledAt == null ||
+                                active.subscription.canceledAt > Date.now()),
+                        trialEndsAt: trialEndsAt(active.subscription),
+                        features: plan.features ?? {},
+                        limits: plan.limits ?? {},
+                        entitlements: plan.entitlements ?? {},
+                    });
+                },
+            }),
+            integrationRoute.get(currentChargesPath, {
+                responseFormat: "json",
+                async handler(_request, ctx) {
+                    const owner = await billing.resolveOwner(ctx);
+                    if (!owner) {
+                        return Response.json({
+                            owner: null,
+                            externalCustomerId: null,
+                            customerId: null,
+                            planId: "free",
+                            productId: null,
+                            subscriptionId: null,
+                            currency: "usd",
+                            currentPeriodStart: null,
+                            currentPeriodEnd: null,
+                            baseSubscriptionAmount: null,
+                            pendingMeterChargeAmount: 0,
+                            estimatedTotalAmount: null,
+                            lineItems: [],
+                        });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const active = resolveActiveProduct(resolved.customer, products);
+                    const planId = active.product?.planId ?? "free";
+                    const plan = plans[planId] ?? {};
+                    const livePlan = active.product?.autumnPlanId
+                        ? await sdk.plans.get({ planId: active.product.autumnPlanId })
+                        : null;
+                    const currency = active.product?.currency ?? "usd";
+                    const baseSubscriptionAmount = toCentsFromDollars(livePlan?.price?.amount ?? null);
+                    const lineItems = [];
+                    if (baseSubscriptionAmount != null) {
+                        lineItems.push(toCurrentChargeLine({
+                            key: null,
+                            kind: "base_subscription",
+                            label: active.product?.name ?? "Base subscription",
+                            amount: baseSubscriptionAmount,
+                            currency,
+                        }));
+                    }
+                    let pendingMeterChargeAmount = 0;
+                    let sawMeterLine = false;
+                    for (const [key, meter] of Object.entries(billing.meters ?? {})) {
+                        const featureId = resolveMeterFeatureId(meter);
+                        if (!featureId) {
+                            continue;
+                        }
+                        const balance = resolved.customer.balances?.[featureId] ?? null;
+                        if (!balance) {
+                            continue;
+                        }
+                        const usedUnits = getProjectedUsage({
+                            externalCustomerId: resolved.externalCustomerId,
+                            featureId,
+                            currentPeriodEnd: currentPeriodEnd(active.subscription),
+                            currentPeriodUsed: balance.usage ?? 0,
+                        });
+                        const includedUnits = plan.limits?.[key] ?? balance.granted ?? null;
+                        const overageUnits = typeof includedUnits === "number" ? Math.max(usedUnits - includedUnits, 0) : null;
+                        const estimate = estimateUsageChargeFromBalance({
+                            balance,
+                            livePlan,
+                            featureId,
+                        });
+                        const billedBuckets = typeof overageUnits === "number" &&
+                            typeof estimate.billingUnits === "number" &&
+                            estimate.billingUnits > 0
+                            ? Math.ceil(overageUnits / estimate.billingUnits)
+                            : 0;
+                        sawMeterLine = true;
+                        pendingMeterChargeAmount += estimate.estimatedMeterChargeAmount ?? 0;
+                        lineItems.push(toCurrentChargeLine({
+                            key,
+                            kind: "metered_usage",
+                            label: `${meter.unit ?? key} overage`,
+                            amount: estimate.estimatedMeterChargeAmount ?? 0,
+                            currency,
+                            quantity: usedUnits,
+                            includedUnits,
+                            overageUnits,
+                            billedBuckets,
+                            billingUnits: estimate.billingUnits,
+                            unitAmountDecimal: estimate.unitAmountDecimal,
+                        }));
+                    }
+                    return Response.json({
+                        owner: resolved.owner,
+                        externalCustomerId: resolved.externalCustomerId,
+                        customerId: resolved.customer.id,
+                        planId,
+                        productId: active.product?.id ?? null,
+                        subscriptionId: active.subscription?.id ?? null,
+                        currency,
+                        currentPeriodStart: currentPeriodStart(active.subscription),
+                        currentPeriodEnd: currentPeriodEnd(active.subscription),
+                        baseSubscriptionAmount,
+                        pendingMeterChargeAmount: sawMeterLine ? pendingMeterChargeAmount : null,
+                        estimatedTotalAmount: (baseSubscriptionAmount ?? 0) + (sawMeterLine ? pendingMeterChargeAmount : 0),
+                        lineItems,
+                    });
+                },
+            }),
+            integrationRoute.get(invoicesPath, {
+                responseFormat: "json",
+                async handler(_request, ctx) {
+                    const owner = await billing.resolveOwner(ctx);
+                    if (!owner) {
+                        return Response.json({
+                            owner: null,
+                            externalCustomerId: null,
+                            customerId: null,
+                            invoices: [],
+                        });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const expandedCustomer = await sdk.customers.getOrCreate({
+                        customerId: resolved.externalCustomerId,
+                        name: resolved.owner.name,
+                        email: resolved.owner.email,
+                        fingerprint: resolved.owner.fingerprint,
+                        metadata: resolved.owner.metadata,
+                        expand: ["invoices"],
+                    });
+                    const invoices = (expandedCustomer.invoices ?? [])
+                        .map((invoice) => ({
+                        stripeInvoiceId: invoice.stripeId,
+                        planIds: invoice.planIds ?? [],
+                        status: invoice.status,
+                        totalAmount: toCentsFromDollars(invoice.total) ?? 0,
+                        currency: invoice.currency ?? "usd",
+                        createdAt: new Date(invoice.createdAt).toISOString(),
+                        hostedInvoiceUrl: invoice.hostedInvoiceUrl ?? null,
+                    }))
+                        .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+                    return Response.json({
+                        owner: resolved.owner,
+                        externalCustomerId: resolved.externalCustomerId,
+                        customerId: expandedCustomer.id,
+                        invoices,
+                    });
+                },
+            }),
+            integrationRoute.get(featuresPath, {
+                responseFormat: "json",
+                async handler(_request, ctx) {
+                    const owner = await billing.resolveOwner(ctx);
+                    if (!owner) {
+                        const plan = plans.free ?? {};
+                        return Response.json({
+                            planId: "free",
+                            features: plan.features ?? {},
+                        });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const active = resolveActiveProduct(resolved.customer, products);
+                    const planId = active.product?.planId ?? "free";
+                    const plan = plans[planId] ?? {};
+                    return Response.json({
+                        planId,
+                        features: plan.features ?? {},
+                    });
+                },
+            }),
+            integrationRoute.get(limitsPath, {
+                responseFormat: "json",
+                async handler(_request, ctx) {
+                    const owner = await billing.resolveOwner(ctx);
+                    if (!owner) {
+                        const plan = plans.free ?? {};
+                        return Response.json({
+                            planId: "free",
+                            limits: plan.limits ?? {},
+                        });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const active = resolveActiveProduct(resolved.customer, products);
+                    const planId = active.product?.planId ?? "free";
+                    const plan = plans[planId] ?? {};
+                    return Response.json({
+                        planId,
+                        limits: plan.limits ?? {},
+                    });
+                },
+            }),
+            integrationRoute.post(usagePath, {
+                responseFormat: "json",
+                async handler(request, ctx) {
+                    const body = (await request.json().catch(() => ({})));
+                    if (!body.key) {
+                        return new Response("A billing usage key is required.", { status: 400 });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const active = resolveActiveProduct(resolved.customer, products);
+                    const planId = active.product?.planId ?? "free";
+                    const plan = plans[planId] ?? {};
+                    const featureId = resolveMeterFeatureId(billing.meters?.[body.key] ?? null);
+                    const granted = featureId && resolved.customer.balances?.[featureId]
+                        ? (resolved.customer.balances[featureId].granted ?? null)
+                        : null;
+                    const used = await resolveUsageValue({
+                        owner: resolved.owner,
+                        key: body.key,
+                        tools: resolved.tools,
+                        billing,
+                        customer: resolved.customer,
+                    });
+                    const limit = resolveEffectiveLimit(plan.limits?.[body.key] ?? null, granted);
+                    const remaining = typeof used === "number" && typeof limit === "number"
+                        ? Math.max(limit - used, 0)
+                        : null;
+                    return Response.json({
+                        planId,
+                        key: body.key,
+                        used,
+                        limit,
+                        remaining,
+                    });
+                },
+            }),
+            integrationRoute.post(meterUsagePath, {
+                responseFormat: "json",
+                async handler(request, ctx) {
+                    const body = (await request.json().catch(() => ({})));
+                    if (!body.key) {
+                        return new Response("An Autumn meter key is required.", { status: 400 });
+                    }
+                    const meter = billing.meters?.[body.key];
+                    if (!meter) {
+                        return new Response(`Unknown Autumn meter "${body.key}".`, { status: 404 });
+                    }
+                    const featureId = resolveMeterFeatureId(meter);
+                    if (!featureId) {
+                        return new Response(`Autumn meter "${body.key}" is missing a featureId.`, {
+                            status: 500,
+                        });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const active = resolveActiveProduct(resolved.customer, products);
+                    const planId = active.product?.planId ?? "free";
+                    const plan = plans[planId] ?? {};
+                    const balance = resolved.customer.balances?.[featureId] ?? null;
+                    const livePlan = active.product?.autumnPlanId
+                        ? await sdk.plans.get({ planId: active.product.autumnPlanId })
+                        : null;
+                    const currentUsed = getProjectedUsage({
+                        externalCustomerId: resolved.externalCustomerId,
+                        featureId,
+                        currentPeriodEnd: currentPeriodEnd(active.subscription),
+                        currentPeriodUsed: balance?.usage ?? 0,
+                    });
+                    const estimate = estimateUsageChargeFromBalance({
+                        balance,
+                        livePlan,
+                        featureId,
+                    });
+                    const baseSubscriptionAmount = toCentsFromDollars(livePlan?.price?.amount ?? null);
+                    const includedLimit = plan.limits?.[body.key] ?? balance?.granted ?? null;
+                    const softLimit = resolveSoftLimit(plans, planId, body.key, includedLimit, meter.guard);
+                    const hardLimit = resolveHardLimit(planId, includedLimit, meter.guard);
+                    const state = computeMeterState({
+                        currentUsed,
+                        subscriptionStatus: active.status,
+                        includedLimit,
+                        softLimit,
+                        hardLimit,
+                        guard: meter.guard,
+                        featureFound: balance != null,
+                    });
+                    return Response.json({
+                        planId,
+                        productId: active.product?.id ?? null,
+                        key: body.key,
+                        eventName: meter.eventName ?? featureId,
+                        meterId: featureId,
+                        meterName: livePlan?.items.find((item) => item.featureId === featureId)?.feature?.name ??
+                            featureId,
+                        unit: meter.unit ??
+                            livePlan?.items.find((item) => item.featureId === featureId)?.feature?.display
+                                ?.plural ??
+                            null,
+                        aggregation: meter.aggregation,
+                        quantityMetadataKey: null,
+                        activeMeterIds: balance ? [featureId] : [],
+                        customerId: resolved.customer.id,
+                        subscriptionId: active.subscription?.id ?? null,
+                        subscriptionStatus: active.status,
+                        currentPeriodStart: currentPeriodStart(active.subscription),
+                        currentPeriodEnd: currentPeriodEnd(active.subscription),
+                        currentPeriodUsed: currentUsed,
+                        creditedUnits: balance?.granted ?? null,
+                        balance: balance?.remaining ?? null,
+                        currency: active.product?.currency ?? "usd",
+                        baseSubscriptionAmount,
+                        meterUnitAmount: estimate.unitAmountDecimal,
+                        meterCapAmount: estimate.capAmount,
+                        billingUnits: estimate.billingUnits,
+                        chargeSource: estimate.chargeSource,
+                        estimatedMeterChargeAmount: estimate.estimatedMeterChargeAmount,
+                        estimatedCombinedAmount: baseSubscriptionAmount != null && estimate.estimatedMeterChargeAmount != null
+                            ? baseSubscriptionAmount + estimate.estimatedMeterChargeAmount
+                            : baseSubscriptionAmount,
+                        includedLimit,
+                        softLimit,
+                        hardLimit,
+                        remainingIncluded: typeof includedLimit === "number" ? Math.max(includedLimit - currentUsed, 0) : null,
+                        remainingHard: typeof hardLimit === "number" ? Math.max(hardLimit - currentUsed, 0) : null,
+                        state: state.state,
+                        warning: state.warning,
+                    });
+                },
+            }),
+            integrationRoute.post(reportUsagePath, {
+                responseFormat: "json",
+                async handler(request, ctx) {
+                    const body = (await request.json().catch(() => ({})));
+                    if (!body.key) {
+                        return new Response("An Autumn meter key is required.", { status: 400 });
+                    }
+                    if (typeof body.quantity !== "number" || !Number.isFinite(body.quantity)) {
+                        return new Response("A numeric quantity is required.", { status: 400 });
+                    }
+                    const meter = billing.meters?.[body.key];
+                    if (!meter) {
+                        return new Response(`Unknown Autumn meter "${body.key}".`, { status: 404 });
+                    }
+                    const featureId = resolveMeterFeatureId(meter);
+                    if (!featureId) {
+                        return new Response(`Autumn meter "${body.key}" is missing a featureId.`, {
+                            status: 500,
+                        });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const active = resolveActiveProduct(resolved.customer, products);
+                    const planId = active.product?.planId ?? "free";
+                    const plan = plans[planId] ?? {};
+                    const livePlan = active.product?.autumnPlanId
+                        ? await sdk.plans.get({ planId: active.product.autumnPlanId })
+                        : null;
+                    const currentUsed = getProjectedUsage({
+                        externalCustomerId: resolved.externalCustomerId,
+                        featureId,
+                        currentPeriodEnd: currentPeriodEnd(active.subscription),
+                        currentPeriodUsed: resolved.customer.balances?.[featureId]?.usage ?? 0,
+                    });
+                    const includedLimit = plan.limits?.[body.key] ?? resolved.customer.balances?.[featureId]?.granted ?? null;
+                    const softLimit = resolveSoftLimit(plans, planId, body.key, includedLimit, meter.guard);
+                    const hardLimit = resolveHardLimit(planId, includedLimit, meter.guard);
+                    const projectedCurrentPeriodUsed = projectMeterUsage({
+                        aggregation: meter.aggregation,
+                        currentUsed,
+                        quantity: body.quantity,
+                    });
+                    if (typeof hardLimit === "number" && projectedCurrentPeriodUsed > hardLimit) {
+                        return Response.json({
+                            key: body.key,
+                            quantity: body.quantity,
+                            customerId: resolved.customer.id,
+                            eventName: meter.eventName ?? featureId,
+                            eventIdentifier: body.idempotencyKey,
+                            occurredAt: body.occurredAt ?? new Date().toISOString(),
+                            currentPeriodUsed: currentUsed,
+                            projectedCurrentPeriodUsed,
+                            softLimit,
+                            hardLimit,
+                            state: "hard_limit_reached",
+                            warning: "The configured metered hard cap has been reached for the current billing period. Reported usage is blocked until the next cycle or a plan change.",
+                        });
+                    }
+                    if (isPrepaidFeatureQuantity({ livePlan, product: active.product, featureId })) {
+                        if (!active.product?.autumnPlanId) {
+                            return new Response("Autumn prepaid quantity updates require an active subscription product.", { status: 409 });
+                        }
+                        const customizedItems = mergeAutumnProductItems(livePlan, active.product);
+                        await sdk.billing.update({
+                            customerId: resolved.customer.id ?? resolved.externalCustomerId,
+                            planId: active.product.autumnPlanId,
+                            featureQuantities: [
+                                {
+                                    featureId,
+                                    quantity: body.quantity,
+                                },
+                            ],
+                            customize: customizedItems.length > 0
+                                ? {
+                                    items: customizedItems,
+                                }
+                                : undefined,
+                            prorationBehavior: "prorate_immediately",
+                            redirectMode: "never",
+                        });
+                    }
+                    else {
+                        // Autumn's current SDK/runtime track path is inconsistent across the published
+                        // types/docs and the actual endpoint behavior. Update the balance usage directly so
+                        // the example remains functional and type-safe for metered demos.
+                        await sdk.balances.update({
+                            customerId: resolved.customer.id ?? resolved.externalCustomerId,
+                            featureId,
+                            usage: projectedCurrentPeriodUsed,
+                        });
+                    }
+                    const nextUsed = projectedCurrentPeriodUsed;
+                    setProjectedUsage({
+                        externalCustomerId: resolved.externalCustomerId,
+                        featureId,
+                        currentPeriodEnd: currentPeriodEnd(active.subscription),
+                        projectedUsage: nextUsed,
+                    });
+                    await billing.hooks?.onUsageReported?.({
+                        owner: resolved.owner,
+                        key: body.key,
+                        quantity: body.quantity,
+                        idempotencyKey: body.idempotencyKey,
+                        occurredAt: body.occurredAt ?? new Date().toISOString(),
+                        eventName: meter.eventName ?? featureId,
+                        customerId: resolved.customer.id,
+                        projectedCurrentPeriodUsed: nextUsed,
+                    }, resolved.tools);
+                    return Response.json({
+                        key: body.key,
+                        quantity: body.quantity,
+                        customerId: resolved.customer.id,
+                        eventName: meter.eventName ?? featureId,
+                        eventIdentifier: body.idempotencyKey,
+                        occurredAt: body.occurredAt ?? new Date().toISOString(),
+                        currentPeriodUsed: currentUsed,
+                        projectedCurrentPeriodUsed: nextUsed,
+                        softLimit,
+                        hardLimit,
+                        state: typeof hardLimit === "number" && nextUsed >= hardLimit
+                            ? "hard_limit_reached"
+                            : typeof softLimit === "number" && nextUsed >= softLimit
+                                ? "soft_limit_reached"
+                                : "ok",
+                        warning: typeof hardLimit === "number" && nextUsed >= hardLimit
+                            ? "The configured metered hard cap has been reached for the current billing period."
+                            : typeof softLimit === "number" && nextUsed >= softLimit
+                                ? "Included usage has been exhausted. Additional usage is billable."
+                                : null,
+                    });
+                },
+            }),
+            integrationRoute.post(checkPath, {
+                responseFormat: "json",
+                async handler(request, ctx) {
+                    const body = (await request.json().catch(() => ({})));
+                    if (!body.key) {
+                        return new Response("An Autumn meter key is required.", { status: 400 });
+                    }
+                    const meter = billing.meters?.[body.key];
+                    if (!meter) {
+                        return new Response(`Unknown Autumn meter "${body.key}".`, { status: 404 });
+                    }
+                    const featureId = resolveMeterFeatureId(meter);
+                    if (!featureId) {
+                        return new Response(`Autumn meter "${body.key}" is missing a featureId.`, {
+                            status: 500,
+                        });
+                    }
+                    const amount = typeof body.amount === "number" && Number.isFinite(body.amount) && body.amount > 0
+                        ? body.amount
+                        : 1;
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const active = resolveActiveProduct(resolved.customer, products);
+                    const planId = active.product?.planId ?? "free";
+                    const plan = plans[planId] ?? {};
+                    const checked = (await sdk.check({
+                        customerId: resolved.customer.id ?? resolved.externalCustomerId,
+                        featureId,
+                        requiredBalance: amount,
+                    }));
+                    const used = checked.balance?.usage ?? null;
+                    const limit = resolveEffectiveLimit(plan.limits?.[body.key] ?? null, checked.balance?.granted ?? null);
+                    const remaining = checked.balance?.remaining ?? null;
+                    return Response.json({
+                        planId,
+                        key: body.key,
+                        amount,
+                        used,
+                        limit,
+                        remaining,
+                        allowed: checked.allowed,
+                    });
+                },
+            }),
+            integrationRoute.post(checkoutPath, {
+                responseFormat: "json",
+                async handler(request, ctx) {
+                    const body = (await request.json().catch(() => ({})));
+                    if (!body.productId) {
+                        return new Response("A billing productId is required.", { status: 400 });
+                    }
+                    const product = products.find((entry) => entry.id === body.productId);
+                    if (!product) {
+                        return new Response(`Unknown Autumn billing product "${body.productId}".`, {
+                            status: 404,
+                        });
+                    }
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const successPath = resolveAppPath(body.successPath, "Autumn checkout successPath");
+                    const successUrl = successPath
+                        ? toAbsoluteUrl(successPath, ctx.request, appBaseUrl).toString()
+                        : undefined;
+                    const livePlan = await sdk.plans.get({ planId: product.autumnPlanId });
+                    const customizedItems = mergeAutumnProductItems(livePlan, product);
+                    const attached = (await sdk.billing.attach({
+                        customerId: resolved.customer.id ?? resolved.externalCustomerId,
+                        planId: product.autumnPlanId,
+                        redirectMode: "always",
+                        successUrl,
+                        metadata: body.metadata,
+                        customize: customizedItems.length > 0
+                            ? {
+                                items: customizedItems,
+                            }
+                            : undefined,
+                        featureQuantities: Object.entries(product.autumn?.featureQuantities ?? {}).map(([featureId, quantity]) => ({
+                            featureId,
+                            quantity,
+                        })),
+                    }));
+                    return Response.json({
+                        productId: product.id,
+                        planId: product.planId ?? null,
+                        customerId: attached.customerId,
+                        redirectTo: attached.paymentUrl ?? successUrl ?? appBaseUrl ?? "/",
+                        requiredActionCode: attached.requiredAction?.code ?? null,
+                    });
+                },
+            }),
+            integrationRoute.post(portalPath, {
+                responseFormat: "json",
+                async handler(request, ctx) {
+                    const body = (await request.json().catch(() => ({})));
+                    const resolved = await requireOwner(ctx, billing, sdk);
+                    const returnPath = resolveAppPath(body.returnTo, "Autumn portal returnTo");
+                    const returnUrl = returnPath
+                        ? toAbsoluteUrl(returnPath, ctx.request, appBaseUrl).toString()
+                        : appBaseUrl;
+                    const portal = await sdk.billing.openCustomerPortal({
+                        customerId: resolved.customer.id ?? resolved.externalCustomerId,
+                        returnUrl,
+                    });
+                    return Response.json({
+                        customerId: portal.customerId,
+                        redirectTo: portal.url,
+                    });
+                },
+            }),
+            ...webhookRoutes,
+        ],
+    });
+}