@cosmicdrift/kumiko-samples 0.387.0 → 0.389.0

package/packages/bundled-features/src/shared/mail-template-body.ts

@@ -11,8 +11,14 @@ export function mailTextWithSlotsHtml(text: string): string {
   );
 }
 
-export function mailParagraph(text: string): string {
-  return `<p>${mailTextWithSlotsHtml(text)}</p>`;
+type MailParagraphOptions = { readonly showIf?: string };
+
+function paragraphOpenTag(options: MailParagraphOptions | undefined): string {
+  return options?.showIf === undefined ? "<p>" : `<p data-if="${escapeHtmlAttr(options.showIf)}">`;
+}
+
+export function mailParagraph(text: string, options?: MailParagraphOptions): string {
+  return `${paragraphOpenTag(options)}${mailTextWithSlotsHtml(text)}</p>`;
 }
 
 export function mailHeading(text: string): string {
@@ -27,8 +33,9 @@ export function mailParagraphWithLink(
   text: string,
   linkLabel: string,
   linkVariable: string,
+  options?: MailParagraphOptions,
 ): string {
-  return `<p>${mailTextWithSlotsHtml(text)} <a href="{{${escapeHtmlAttr(linkVariable)}}}">${escapeHtml(linkLabel)}</a></p>`;
+  return `${paragraphOpenTag(options)}${mailTextWithSlotsHtml(text)} <a href="{{${escapeHtmlAttr(linkVariable)}}}">${escapeHtml(linkLabel)}</a></p>`;
 }
 
 // One table row per list entry; the cell shows the entry's `field`.

package/packages/bundled-features/src/shared/purge-files-reaching-subject.ts

@@ -112,6 +112,29 @@ function fieldsResolvingToSubject(
   });
 }
 
+// A user owning many records must not load them all at once; the id cursor keeps each page
+// bounded while rows purged in place stay out of the way.
+export const PURGE_CANDIDATE_PAGE_SIZE = 200;
+
+async function* candidateRowsPaged(
+  db: DbRunner,
+  table: FileEntity["table"],
+  where: WhereObject,
+): AsyncGenerator<Record<string, unknown>> {
+  let cursor: unknown;
+  for (;;) {
+    const pageWhere: WhereObject = cursor === undefined ? where : { ...where, id: { gt: cursor } };
+    const page = await selectMany<Record<string, unknown>>(db, table, pageWhere, {
+      orderBy: { col: "id", direction: "asc" },
+      limit: PURGE_CANDIDATE_PAGE_SIZE,
+    });
+    yield* page;
+    // skip: a short page is the last one
+    if (page.length < PURGE_CANDIDATE_PAGE_SIZE) return;
+    cursor = page[page.length - 1]?.["id"];
+  }
+}
+
 const fileRefExecutor = createEventStoreExecutor(fileRefsTable, fileRefEntity, {
   entityName: "fileRef",
 });
@@ -165,8 +188,7 @@ export async function purgeFilesReachingSubject(args: {
   for (const fileEntity of fileEntities) {
     const seenRowIds = new Set<string>();
     for (const where of candidateWheres(subject, recordTenantId, fileEntity)) {
-      const rows = await selectMany<Record<string, unknown>>(db, fileEntity.table, where);
-      for (const row of rows) {
+      for await (const row of candidateRowsPaged(db, fileEntity.table, where)) {
         const rowId = String(row["id"]);
         const tenantId = parseTenantId(row["tenantId"]);
         // skip: a row without a tenant cannot own tenant-scoped file refs

package/packages/bundled-features/src/shared/run-in-sub-transaction.ts

@@ -1,11 +1,11 @@
 import type { DbRunner } from "@cosmicdrift/kumiko-framework/db";
 
 // Per-unit sub-transaction (one user, one purged row), nesting-aware across both db shapes:
-//   - top-level connection (postgres-js Sql) → `.begin` (BEGIN)
-//   - TransactionSql (inside the dispatcher's outer tx, where every
+//   - top-level connection (Bun.SQL pool) → `.begin` (BEGIN)
+//   - TransactionSQL (inside the dispatcher's outer tx, where every
 //     writeHandler already runs) → `.savepoint` (SAVEPOINT)
-// A TransactionSql has no `.begin`, so the previous unconditional `.begin`
-// threw "is not a function" on every user when invoked through the dispatcher
+// A transaction handle cannot begin another transaction, so the previous unconditional `.begin`
+// threw on every user when invoked through the dispatcher
 // (the cron path) → zero deletions in production, while direct-connection tests
 // stayed green. Selecting the available method makes the sub-tx work in both
 // contexts; on throw the savepoint rolls back just this user (others survive).
@@ -21,7 +21,7 @@ export async function runInSubTransaction<T>(
     savepoint?: (f: (tx: DbRunner) => Promise<T>) => Promise<T>;
   };
   // savepoint-first: empirically (Bun 1.3.14, not re-checked on 1.4.0) the
-  // surfaces are NOT mutually exclusive — a TransactionSql exposes begin AND
+  // surfaces are NOT mutually exclusive — a TransactionSQL exposes begin AND
   // savepoint, only the top-level connection has begin alone. begin-first
   // picked the nested BEGIN inside a tx (the incident class above);
   // savepoint-first hits the savepoint there and falls back to begin top-level.

package/packages/bundled-features/src/step-dispatcher/changes.json

@@ -1,4 +1,16 @@
 [
+  {
+    "version": "0.389.0",
+    "type": "fix",
+    "title": "Mail steps do not retry permanent rejections or throws",
+    "detail": "MailDispatchResult failures take an optional smtpCode; 5xx is permanent and recorded after the first attempt. A throwing mail runner is not retried, since the message may already be sent. A mail runner that wants a retry after a transport error should return a failure without smtpCode instead of throwing."
+  },
+  {
+    "version": "0.388.0",
+    "type": "fix",
+    "title": "Deliver job validates its payload at the trigger",
+    "detail": "The deliver job now declares its payload schema, so a manual trigger with an invalid payload is rejected up front instead of throwing inside the handler and consuming all retries."
+  },
   {
     "version": "0.365.1",
     "type": "fix",

package/packages/bundled-features/src/step-dispatcher/deliver-dispatch-request.ts

@@ -54,9 +54,17 @@ type DeliveryResult =
   | { readonly ok: true; readonly status: number }
   | { readonly ok: false; readonly error: string; readonly retryable: boolean };
 
-// Mail adapter failures carry no status to classify, so every one is retried.
+const SMTP_PERMANENT_REJECTION_MIN = 500;
+const SMTP_PERMANENT_REJECTION_MAX = 599;
+
+// Without an SMTP code the adapter gave nothing to classify, so the failure counts as transient.
 function mailResultAsDelivery(result: MailDispatchResult): DeliveryResult {
-  return result.ok ? result : { ...result, retryable: true };
+  if (result.ok) return result;
+  const isPermanent =
+    result.smtpCode !== undefined &&
+    result.smtpCode >= SMTP_PERMANENT_REJECTION_MIN &&
+    result.smtpCode <= SMTP_PERMANENT_REJECTION_MAX;
+  return { ok: false, error: result.error, retryable: !isPermanent };
 }
 
 export type DeliverDispatchRequestArgs = {
@@ -205,7 +213,13 @@ async function sendDispatch(
       aggregateId: target.aggregateId,
       errorName: err instanceof Error ? err.name : "unknown",
     });
-    return { ok: false, error: DISPATCH_THREW_ERROR, retryable: true };
+    // A mail adapter has no idempotency key: a throw after the provider accepted the message
+    // would send it again, so only the webhook (which carries one) is retried.
+    return {
+      ok: false,
+      error: DISPATCH_THREW_ERROR,
+      retryable: dispatchSpec.stepKind === "webhook.send",
+    };
   }
 }
 

package/packages/bundled-features/src/step-dispatcher/feature.ts

@@ -75,6 +75,7 @@ export function createStepDispatcherFeature(): FeatureDefinition {
         retries: DELIVER_RETRIES,
         backoff: "exponential",
         maxPerTenant: { limit: DELIVER_MAX_PER_TENANT, onLimit: "defer" },
+        schema: deliverJobPayloadSchema,
         escapeHatch: { reason: DELIVER_ESCAPE_HATCH_REASON },
       },
       async (payload, ctx) => {

package/packages/bundled-features/src/step-dispatcher/mail-runner.ts

@@ -15,7 +15,8 @@ export type MailSpec = z.infer<typeof mailSpecSchema>;
 
 export type MailDispatchResult =
   | { readonly ok: true; readonly status: number }
-  | { readonly ok: false; readonly error: string };
+  // smtpCode is the adapter's SMTP reply code; a 5xx is a permanent rejection and is not retried.
+  | { readonly ok: false; readonly error: string; readonly smtpCode?: number };
 
 let mailRunner: (spec: MailSpec) => Promise<MailDispatchResult> = async () => ({
   ok: false,

package/packages/bundled-features/src/subscription-dodo/changes.json

@@ -0,0 +1,14 @@
+[
+  {
+    "version": "0.388.0",
+    "type": "improvement",
+    "title": "New subscription provider for Dodo Payments",
+    "detail": "createSubscriptionDodoFeature() registers the \"dodo\" subscription provider (Merchant of Record). It verifies Standard Webhooks signatures, maps Dodo events to the foundation events, creates hosted checkouts and portal sessions, and switches plans in the app through previewPlanSwitch and applyPlanSwitch. Config keys are api-key, webhook-secret, billing-live and environment. Plan switches need a Product Collection in Dodo."
+  },
+  {
+    "version": "0.388.0",
+    "type": "improvement",
+    "title": "dodoEnvSchema declares the Dodo product id slots",
+    "detail": "dodoEnvSchema({ prices: [\"PRO\"] }) adds one optional DODO_PRODUCT_PRO slot per plan next to the API key and webhook key, and checks the pdt_ prefix. It is the counterpart to stripeEnvSchema."
+  }
+]

package/packages/bundled-features/src/subscription-dodo/client.ts

@@ -0,0 +1,45 @@
+// Thin JSON-over-fetch client for the Dodo Payments REST API. All traffic goes
+// through the injected `send`, which defaults to the SSRF-safe egress in
+// feature.ts and is replaced by a mock in tests.
+
+import { parseJsonOrThrow } from "@cosmicdrift/kumiko-framework/utils";
+
+export type DodoSend = (url: string, init?: RequestInit) => Promise<Response>;
+
+export type DodoRequest = {
+  readonly method: "GET" | "POST" | "PATCH";
+  /** Path segments interpolated into it must already be encodeURIComponent'ed. */
+  readonly path: string;
+  readonly query?: Readonly<Record<string, string>>;
+  readonly body?: unknown;
+};
+
+export type DodoTarget = { readonly baseUrl: string; readonly apiKey: string };
+
+// Never carries the response body or the key: both can hold customer data or secrets.
+export class DodoHttpError extends Error {
+  readonly status: number;
+  constructor(request: DodoRequest, status: number) {
+    super(`subscription-dodo: ${request.method} ${request.path} failed with status ${status}`);
+    this.name = "DodoHttpError";
+    this.status = status;
+  }
+}
+
+export function createDodoHttp(send: DodoSend) {
+  return async (target: DodoTarget, request: DodoRequest): Promise<unknown> => {
+    const query = request.query ? `?${new URLSearchParams(request.query).toString()}` : "";
+    const response = await send(`${target.baseUrl}${request.path}${query}`, {
+      method: request.method,
+      headers: {
+        Authorization: `Bearer ${target.apiKey}`,
+        Accept: "application/json",
+        ...(request.body !== undefined && { "Content-Type": "application/json" }),
+      },
+      ...(request.body !== undefined && { body: JSON.stringify(request.body) }),
+    });
+    if (!response.ok) throw new DodoHttpError(request, response.status);
+    const text = await response.text();
+    return text.length === 0 ? null : parseJsonOrThrow<unknown>(text, "subscription-dodo response");
+  };
+}

package/packages/bundled-features/src/subscription-dodo/constants.ts

@@ -0,0 +1,24 @@
+export const SUBSCRIPTION_DODO_FEATURE = "subscription-dodo" as const;
+
+// Must match the path segment in the webhook URL `/api/subscription/webhook/dodo`.
+export const DODO_PROVIDER_NAME = "dodo" as const;
+
+// Config-key short-names, qualified to `subscription-dodo:config:<name>` at
+// registry-build. api-key + webhook-secret are backing:"secrets".
+export const DODO_API_KEY_CONFIG = "api-key" as const;
+export const DODO_WEBHOOK_SECRET_CONFIG = "webhook-secret" as const;
+export const DODO_BILLING_LIVE_CONFIG = "billingLive" as const;
+export const DODO_ENVIRONMENT_CONFIG = "environment" as const;
+
+// Separate from billingLive on purpose: staging runs Dodo's test API with
+// billingLive on, production flips both.
+export const DodoEnvironments = {
+  test: "test",
+  live: "live",
+} as const;
+export type DodoEnvironment = (typeof DodoEnvironments)[keyof typeof DodoEnvironments];
+
+export const DODO_BASE_URLS: Readonly<Record<DodoEnvironment, string>> = {
+  test: "https://test.dodopayments.com",
+  live: "https://live.dodopayments.com",
+};

package/packages/bundled-features/src/subscription-dodo/feature.ts

@@ -0,0 +1,207 @@
+// kumiko-feature-version: 1
+//
+// subscription-dodo — Dodo Payments (merchant of record) plugin for the
+// billing-foundation plugin API. Credentials, the billing-live master switch and
+// the API environment (test | live) are config keys resolved at call time, like
+// subscription-stripe. `apiKey` / `webhookSecret` options are env→secrets bridge
+// fallbacks.
+
+import type { SubscriptionProviderPlugin } from "@cosmicdrift/kumiko-bundled-features/billing-foundation";
+import {
+  access,
+  createSystemConfig,
+  defineFeature,
+  type FeatureDefinition,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { type FeatureWithEnvSchema, featureWithEnvSchema } from "@cosmicdrift/kumiko-framework/env";
+import { egress } from "@cosmicdrift/kumiko-framework/http";
+import * as z from "zod";
+import type { DodoSend } from "./client.ts";
+import {
+  DODO_API_KEY_CONFIG,
+  DODO_BILLING_LIVE_CONFIG,
+  DODO_ENVIRONMENT_CONFIG,
+  DODO_PROVIDER_NAME,
+  DODO_WEBHOOK_SECRET_CONFIG,
+  DodoEnvironments,
+  SUBSCRIPTION_DODO_FEATURE,
+} from "./constants.ts";
+import {
+  createDodoApplyPlanSwitch,
+  createDodoCancelSubscription,
+  createDodoCheckoutSession,
+  createDodoPortalSession,
+  createDodoPreviewPlanSwitch,
+  createDodoPriceCache,
+  createDodoResumeSubscription,
+  createDodoRetrievePrices,
+  createDodoRetrieveSubscription,
+} from "./plugin-methods.ts";
+import { createDodoRuntimes } from "./runtime.ts";
+import { verifyAndParseDodoWebhook } from "./verify-webhook.ts";
+
+/** Bridge contract: both fields are optional fallbacks for the secrets store. */
+export const subscriptionDodoEnvSchema = z.object({
+  DODO_PAYMENTS_API_KEY: z
+    .string()
+    .min(1)
+    .describe("Dodo Payments API key. Bridge-fallback — prefer the secret.")
+    .meta({ kumiko: { pulumi: { secret: true } } })
+    .optional(),
+  DODO_PAYMENTS_WEBHOOK_KEY: z
+    .string()
+    .min(1)
+    .describe(
+      "Dodo Payments webhook signing key (`whsec_...`). Bridge-fallback — prefer the secret.",
+    )
+    .meta({ kumiko: { pulumi: { secret: true } } })
+    .optional(),
+});
+
+type DodoProductEnvShape<TPrice extends string> = {
+  [Key in `DODO_PRODUCT_${TPrice}`]: z.ZodOptional<z.ZodString>;
+};
+
+/** Dodo env block plus one `DODO_PRODUCT_<NAME>` slot per plan product the app
+ *  maps to a tier, e.g. `dodoEnvSchema({ prices: ["PRO", "TEAM"] })`.
+ *  Shares its bridge fields with `subscriptionDodoEnvSchema`, so spreading
+ *  it into `composeEnvSchema({ extend })` next to the mounted feature is no
+ *  key clash. */
+export function dodoEnvSchema<const TPrice extends string>(options: {
+  readonly prices: readonly TPrice[];
+}) {
+  const productShape = Object.fromEntries(
+    options.prices.map((price) => [
+      `DODO_PRODUCT_${price}`,
+      z
+        .string()
+        .regex(/^pdt_/, `DODO_PRODUCT_${price} must start with 'pdt_'`)
+        .optional()
+        .describe(`Dodo Payments product id (\`pdt_...\`) of the ${price} plan.`),
+    ]),
+    // @cast-boundary schema-walk — Object.fromEntries widens to an index signature; the entries are exactly one optional string per listed price.
+  ) as DodoProductEnvShape<TPrice>;
+  return z.object({ ...subscriptionDodoEnvSchema.shape, ...productShape });
+}
+
+export type SubscriptionDodoOptions = {
+  /** Bridge-fallback API key; the `api-key` config key wins when set. */
+  readonly apiKey?: string;
+  /** Bridge-fallback webhook secret; the `webhook-secret` config key wins when set. */
+  readonly webhookSecret?: string;
+  /** Dodo product id → app tier name. Products absent here drop the event. */
+  readonly priceToTier?: Readonly<Record<string, string>>;
+  /** Product ids a mode:"payment" checkout may target; empty = one-off checkouts closed. */
+  readonly oneOffPriceIds?: readonly string[];
+  /** HTTP transport; defaults to the SSRF-safe external egress. Test seam. */
+  readonly send?: DodoSend;
+};
+
+// Validated once at feature-build time so a typo fails app startup instead of
+// silently widening or narrowing the one-off allowlist at request time.
+function validateOneOffPriceIds(priceIds: readonly string[]): void {
+  const seen = new Set<string>();
+  for (const priceId of priceIds) {
+    if (priceId.length === 0) {
+      throw new Error("subscription-dodo: oneOffPriceIds must not contain an empty string");
+    }
+    if (seen.has(priceId)) {
+      throw new Error(`subscription-dodo: duplicate oneOffPriceIds entry "${priceId}"`);
+    }
+    seen.add(priceId);
+  }
+}
+
+export function createSubscriptionDodoFeature(
+  options: SubscriptionDodoOptions = {},
+): FeatureWithEnvSchema<FeatureDefinition, typeof subscriptionDodoEnvSchema.shape> {
+  validateOneOffPriceIds(options.oneOffPriceIds ?? []);
+  const feature: FeatureDefinition = defineFeature(SUBSCRIPTION_DODO_FEATURE, (r) => {
+    r.describe(
+      'Dodo Payments provider plugin for `billing-foundation`. Dodo acts as merchant of record: it sells to the customer and issues invoice and VAT, so the consumer-protection texts for this provider come from `consumerProtection.providerTexts`. Reads its API key and webhook secret from system config keys with `backing:"secrets"` (envelope-encrypted in the secrets store under the system tenant), plus a `billingLive` master switch and an `environment` key (test | live). `environment` is its own key because Dodo serves test and live mode from different API hosts and a live key must never hit the test host or the other way round; `billingLive` only decides whether checkouts are offered at all. All four are runtime config, so keys rotate and prod goes live without a redeploy, and the `mask` on each derives the sysadmin settings screen and nav. Mount via `createSubscriptionDodoFeature({ priceToTier })`; the optional `apiKey`/`webhookSecret` options are env to secrets bridge fallbacks (`DODO_PAYMENTS_API_KEY`, `DODO_PAYMENTS_WEBHOOK_KEY`). The plugin always mounts; `createCheckoutSession` throws `feature_disabled` unless `billingLive` is true. Webhooks arrive at `/api/subscription/webhook/dodo` and are verified per the Standard Webhooks spec (HMAC-SHA256 over id, timestamp and the raw body, 5 minute tolerance); events for products outside `priceToTier` or without tenant metadata are dropped. Implements hosted checkout, customer portal, cancel and resume, `retrievePrices` (10-minute TTL cache), `retrieveSubscription` for the sync job, and an in-app plan switch: `previewPlanSwitch` shows the proration before the customer confirms, `applyPlanSwitch` changes the plan without a hosted page and waits for the `plan_changed` webhook to move the tier. A plan switch in Dodo requires all plan products to belong to one Product Collection.',
+    );
+    r.uiHints({
+      displayLabel: "Billing · Dodo Payments",
+      category: "billing",
+      recommended: false,
+    });
+    r.requires({ features: ["billing-foundation"] });
+    r.requires({ features: ["config"] });
+    r.requires({ features: ["secrets"] });
+    r.envSchema(subscriptionDodoEnvSchema);
+
+    const configKeys = r.config({
+      keys: {
+        [DODO_API_KEY_CONFIG]: createSystemConfig("text", {
+          backing: "secrets",
+          write: access.systemAdmin,
+          read: access.admin,
+          mask: { title: "subscription-dodo.api-key", icon: "key", order: 1 },
+        }),
+        [DODO_WEBHOOK_SECRET_CONFIG]: createSystemConfig("text", {
+          backing: "secrets",
+          write: access.systemAdmin,
+          read: access.admin,
+          mask: { title: "subscription-dodo.webhook-secret", icon: "shield", order: 2 },
+        }),
+        [DODO_ENVIRONMENT_CONFIG]: createSystemConfig("select", {
+          default: DodoEnvironments.test,
+          options: [DodoEnvironments.test, DodoEnvironments.live],
+          write: access.systemAdmin,
+          read: access.admin,
+          mask: { title: "subscription-dodo.environment", icon: "server", order: 3 },
+        }),
+        [DODO_BILLING_LIVE_CONFIG]: createSystemConfig("boolean", {
+          default: false,
+          write: access.privileged,
+          read: access.admin,
+          mask: { title: "subscription-dodo.billing-live", icon: "rocket", order: 4 },
+        }),
+      },
+    });
+
+    r.translations({
+      keys: {
+        "subscription-dodo.api-key": { en: "Dodo Payments API key" },
+        "subscription-dodo.webhook-secret": { en: "Dodo Payments webhook secret" },
+        "subscription-dodo.environment": { en: "Dodo Payments environment" },
+        "subscription-dodo.billing-live": { en: "Live billing" },
+        "subscription-dodo.settings": { en: "Dodo Payments" },
+        "screen:subscription-dodo-system.title": { en: "Dodo Payments" },
+      },
+    });
+
+    const priceToTier = options.priceToTier ?? {};
+    const runtimes = createDodoRuntimes({
+      apiKeyHandle: configKeys[DODO_API_KEY_CONFIG],
+      webhookSecretHandle: configKeys[DODO_WEBHOOK_SECRET_CONFIG],
+      billingLiveHandle: configKeys[DODO_BILLING_LIVE_CONFIG],
+      environmentHandle: configKeys[DODO_ENVIRONMENT_CONFIG],
+      send: options.send ?? egress({ kind: "external" }),
+      fallback: {
+        ...(options.apiKey !== undefined && { apiKey: options.apiKey }),
+        ...(options.webhookSecret !== undefined && { webhookSecret: options.webhookSecret }),
+      },
+    });
+
+    const plugin: SubscriptionProviderPlugin = {
+      displayName: "Dodo Payments",
+      verifyAndParseWebhook: verifyAndParseDodoWebhook(runtimes.webhook, { priceToTier }),
+      createCheckoutSession: createDodoCheckoutSession(runtimes.ctx),
+      createPortalSession: createDodoPortalSession(runtimes.ctx),
+      cancelSubscription: createDodoCancelSubscription(runtimes.ctx),
+      resumeSubscription: createDodoResumeSubscription(runtimes.ctx),
+      priceToTier,
+      oneOffPriceIds: options.oneOffPriceIds ?? [],
+      isBillingEnabled: runtimes.ctx.isBillingEnabled,
+      retrievePrices: createDodoRetrievePrices(runtimes.ctx, createDodoPriceCache()),
+      retrieveSubscription: createDodoRetrieveSubscription(runtimes.ctx, { priceToTier }),
+      previewPlanSwitch: createDodoPreviewPlanSwitch(runtimes.ctx),
+      applyPlanSwitch: createDodoApplyPlanSwitch(runtimes.ctx),
+    };
+    r.useExtension("subscriptionProvider", DODO_PROVIDER_NAME, plugin);
+
+    return { configKeys };
+  });
+  return featureWithEnvSchema(feature, subscriptionDodoEnvSchema);
+}

package/packages/bundled-features/src/subscription-dodo/index.ts

@@ -0,0 +1,16 @@
+// Public API of the subscription-dodo bundled feature. The webhook verifier,
+// client and plugin methods are internal to feature.ts.
+
+export {
+  DODO_BASE_URLS,
+  DODO_PROVIDER_NAME,
+  type DodoEnvironment,
+  DodoEnvironments,
+  SUBSCRIPTION_DODO_FEATURE,
+} from "./constants.ts";
+export {
+  createSubscriptionDodoFeature,
+  dodoEnvSchema,
+  type SubscriptionDodoOptions,
+  subscriptionDodoEnvSchema,
+} from "./feature.ts";