@cosmicdrift/kumiko-samples 0.387.0 → 0.388.0

package/packages/bundled-features/src/renderer-pdf/render-table-pdf.ts

@@ -7,10 +7,13 @@ import type { PdfPageFormat } from "../template-resolver/index.ts";
 const PDF_TABLE_MAX_ROWS = 10_000;
 const PDF_TABLE_MAX_COLUMNS = 30;
 const PDF_TABLE_MAX_CELL_LENGTH = 5_000;
+const PDF_TABLE_MAX_META_ENTRIES = 500;
+const PDF_TABLE_MAX_TEXT_LENGTH = 20_000;
+const PDF_TABLE_MAX_PAGE_LABEL_LENGTH = 100;
 
 const pdfTableColumnSchema = z
   .object({
-    header: z.string(),
+    header: z.string().max(PDF_TABLE_MAX_TEXT_LENGTH),
     weight: z.number().positive().optional(),
     align: z.enum(["left", "right"]).optional(),
   })
@@ -18,10 +21,18 @@ const pdfTableColumnSchema = z
 
 export const pdfTableDocumentSchema = z
   .object({
-    title: z.string(),
-    subtitle: z.string().optional(),
+    title: z.string().max(PDF_TABLE_MAX_TEXT_LENGTH),
+    subtitle: z.string().max(PDF_TABLE_MAX_TEXT_LENGTH).optional(),
     meta: z
-      .array(z.object({ label: z.string(), value: z.string() }).readonly())
+      .array(
+        z
+          .object({
+            label: z.string().max(PDF_TABLE_MAX_TEXT_LENGTH),
+            value: z.string().max(PDF_TABLE_MAX_TEXT_LENGTH),
+          })
+          .readonly(),
+      )
+      .max(PDF_TABLE_MAX_META_ENTRIES)
       .readonly()
       .optional(),
     columns: z.array(pdfTableColumnSchema).min(1).max(PDF_TABLE_MAX_COLUMNS).readonly(),
@@ -29,10 +40,10 @@ export const pdfTableDocumentSchema = z
       .array(z.array(z.string().max(PDF_TABLE_MAX_CELL_LENGTH)).readonly())
       .max(PDF_TABLE_MAX_ROWS)
       .readonly(),
-    emptyText: z.string().optional(),
-    footerText: z.string().optional(),
+    emptyText: z.string().max(PDF_TABLE_MAX_TEXT_LENGTH).optional(),
+    footerText: z.string().max(PDF_TABLE_MAX_TEXT_LENGTH).optional(),
     // Template with `{page}` and `{pages}`; default `"{page} / {pages}"`.
-    pageLabel: z.string().optional(),
+    pageLabel: z.string().max(PDF_TABLE_MAX_PAGE_LABEL_LENGTH).optional(),
   })
   .readonly();
 
@@ -235,12 +246,18 @@ function resolveTableLayout(
 }
 
 export async function renderTablePdf(
-  doc: PdfTableDocument,
+  untrustedDoc: PdfTableDocument,
   options?: PdfTableOptions,
 ): Promise<PdfTableResult> {
-  if (doc.columns.length === 0) {
-    throw new RendererError("table needs at least one column", "invalid_payload");
+  // Direct callers bypass renderTablePdfRequest, so the size caps are enforced here too.
+  const parsed = pdfTableDocumentSchema.safeParse(untrustedDoc);
+  if (!parsed.success) {
+    throw new RendererError(
+      `table document is invalid: ${parsed.error.message}`,
+      "invalid_payload",
+    );
   }
+  const doc = parsed.data;
   assertRowShape(doc);
 
   const pdf = await PDFDocument.create({ updateMetadata: false });

package/packages/bundled-features/src/sessions/feature.ts

@@ -59,8 +59,10 @@ export type SessionsFeatureOptions = {
   readonly adminAccess?: "admin" | "systemAdmin";
 };
 
-export type BindAutoRevokeOnPasswordChange = (revoker: SessionMassRevoker) => void;
-export type BindRevokeAllOtherSessions = (revoker: SessionAllOthersRevoker) => void;
+// The returned unbind only clears the binding while it is still this revoker, so a stack that
+// stops later cannot unbind a newer stack sharing the same feature instance.
+export type BindAutoRevokeOnPasswordChange = (revoker: SessionMassRevoker) => () => void;
+export type BindRevokeAllOtherSessions = (revoker: SessionAllOthersRevoker) => () => void;
 
 // Reads the late-bind setter off a mounted sessions feature's exports.
 // run{Prod,Dev}App call it once the DB connection is concrete — the feature
@@ -236,6 +238,9 @@ export function createSessionsFeature(options?: SessionsFeatureOptions): Feature
 
       const bindAutoRevokeOnPasswordChange: BindAutoRevokeOnPasswordChange = (revoker) => {
         boundAutoRevoke = revoker;
+        return () => {
+          if (boundAutoRevoke === revoker) boundAutoRevoke = undefined;
+        };
       };
 
       r.translations({ keys: SESSIONS_I18N });

package/packages/bundled-features/src/shared/decrypt-stored-pii.ts

@@ -2,6 +2,7 @@ import { requestContext } from "@cosmicdrift/kumiko-framework/api";
 import {
   configuredPiiSubjectKms,
   decryptPiiFieldValues,
+  PII_ERASED_SENTINEL,
 } from "@cosmicdrift/kumiko-framework/crypto";
 
 // Raw reads (fetchOne/selectMany) return the stored column value — with an
@@ -24,3 +25,12 @@ export async function decryptStoredPii(
   const decrypted = out[field];
   return typeof decrypted === "string" ? decrypted : value;
 }
+
+// Null for an erased subject: the sentinel must never be mailed or shown as an address.
+export async function decryptStoredUserEmail(
+  stored: string,
+  fallbackRequestId: string,
+): Promise<string | null> {
+  const email = await decryptStoredPii(stored, "email", fallbackRequestId);
+  return email === PII_ERASED_SENTINEL ? null : email;
+}

package/packages/bundled-features/src/shared/index.ts

@@ -15,7 +15,7 @@ export {
   classifyStoredEnvelope,
   type StoredEnvelopeClassification,
 } from "./classify-stored-envelope.ts";
-export { decryptStoredPii } from "./decrypt-stored-pii.ts";
+export { decryptStoredPii, decryptStoredUserEmail } from "./decrypt-stored-pii.ts";
 export { encryptForDirectWrite } from "./encrypt-for-direct-write.ts";
 export { entitiesOf } from "./entities-of.ts";
 export { isWithinGracePeriod } from "./grace-period.ts";

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/step-dispatcher/changes.json

@@ -1,4 +1,10 @@
 [
+  {
+    "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/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/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";