@fantastic.dev/better-stripe 0.4.0 → 0.5.0

package/src/client/core/accountLinks.test.ts

@@ -45,7 +45,8 @@ function makeStripe() {
 type MockStripe = ReturnType<typeof makeStripe>;
 
 // Cast helper — the mock only implements the slice of Stripe these functions use.
-const asStripe = (s: MockStripe) => s as unknown as Parameters<typeof createAccountLink>[0];
+const asStripe = (s: MockStripe) =>
+  s as unknown as Parameters<typeof createAccountLink>[0];
 
 describe("createAccountLink", () => {
   it("passes through params and returns the url", async () => {
@@ -94,7 +95,6 @@ describe("createV2AccountLink", () => {
       use_case: {
         type: "account_onboarding",
         account_onboarding: {
-          configurations: ["merchant"],
           refresh_url: "https://refresh",
           return_url: "https://return",
         },
@@ -122,7 +122,6 @@ describe("createV2AccountLink", () => {
       use_case: {
         type: "account_update",
         account_update: {
-          configurations: ["recipient"],
           refresh_url: "https://refresh",
           return_url: "https://return",
         },
@@ -130,7 +129,7 @@ describe("createV2AccountLink", () => {
     });
   });
 
-  it("defaults configurations to an empty array for account_update too", async () => {
+  it("omits configurations for account_update", async () => {
     const stripe = makeStripe();
     stripe.v2.core.accountLinks.create.mockResolvedValue({
       url: "https://v2",
@@ -145,10 +144,10 @@ describe("createV2AccountLink", () => {
     });
 
     const arg = stripe.v2.core.accountLinks.create.mock.calls[0][0];
-    expect(arg.use_case.account_update.configurations).toEqual([]);
+    expect(arg.use_case.account_update).not.toHaveProperty("configurations");
   });
 
-  it("defaults configurations to an empty array when omitted", async () => {
+  it("omits configurations for account_onboarding", async () => {
     const stripe = makeStripe();
     stripe.v2.core.accountLinks.create.mockResolvedValue({
       url: "https://v2",
@@ -163,7 +162,9 @@ describe("createV2AccountLink", () => {
     });
 
     const arg = stripe.v2.core.accountLinks.create.mock.calls[0][0];
-    expect(arg.use_case.account_onboarding.configurations).toEqual([]);
+    expect(arg.use_case.account_onboarding).not.toHaveProperty(
+      "configurations",
+    );
   });
 });
 
@@ -283,9 +284,11 @@ describe("getAccountLinkWithStatus", () => {
     expect(result).toEqual({ url: "https://onboard", linkType: "onboarding" });
     // login link must NOT be used while requirements are outstanding
     expect(stripe.accounts.createLoginLink).not.toHaveBeenCalled();
-    // applied_configurations should flow into the onboarding link
+    // Stripe 23 collects requirements without a configurations parameter.
     const arg = stripe.v2.core.accountLinks.create.mock.calls[0][0];
-    expect(arg.use_case.account_onboarding.configurations).toEqual(["merchant"]);
+    expect(arg.use_case.account_onboarding).not.toHaveProperty(
+      "configurations",
+    );
   });
 
   it("returns a login link for an express dashboard account with no requirements", async () => {
@@ -352,15 +355,19 @@ describe("getAccountLinkWithStatus", () => {
 
     expect(result.linkType).toBe("onboarding");
     const arg = stripe.v2.core.accountLinks.create.mock.calls[0][0];
-    // applied_configurations absent → defaults to []
-    expect(arg.use_case.account_onboarding.configurations).toEqual([]);
+    // No configurations parameter is sent.
+    expect(arg.use_case.account_onboarding).not.toHaveProperty(
+      "configurations",
+    );
   });
 });
 
 describe("createDisputeSession (BTS-30)", () => {
   it("creates an account session with the disputes components for the seller", async () => {
     const stripe = makeStripe();
-    stripe.accountSessions.create.mockResolvedValue({ client_secret: "acs_secret" });
+    stripe.accountSessions.create.mockResolvedValue({
+      client_secret: "acs_secret",
+    });
 
     const result = await createDisputeSession(asStripe(stripe), {} as RunCtx, {
       stripeAccountId: "acct_seller",
@@ -375,4 +382,4 @@ describe("createDisputeSession (BTS-30)", () => {
     });
     expect(result).toEqual({ clientSecret: "acs_secret" });
   });
-})
+});

package/src/client/core/accountLinks.ts

@@ -2,10 +2,7 @@ import type Stripe from "stripe";
 
 import { throwStripeError } from "../errors.js";
 import type { RunCtx } from "../helpers.js";
-import type {
-  V2AccountLinkCreateParams,
-  V2AppliedConfiguration,
-} from "../stripe-types.js";
+import type { V2AccountLinkCreateParams } from "../stripe-types.js";
 import type { AccountLinkWithStatus } from "../types.js";
 
 // =============================================================================
@@ -39,6 +36,7 @@ export async function createV2AccountLink(
     type: "account_onboarding" | "account_update";
     refreshUrl: string;
     returnUrl: string;
+    /** @deprecated Endive collects requirements without configurations. Ignored. */
     configurations?: string[];
   },
 ) {
@@ -47,8 +45,6 @@ export async function createV2AccountLink(
       ? {
           type: "account_update",
           account_update: {
-            configurations: (opts.configurations ??
-              []) as V2AppliedConfiguration[],
             refresh_url: opts.refreshUrl,
             return_url: opts.returnUrl,
           },
@@ -56,8 +52,6 @@ export async function createV2AccountLink(
       : {
           type: "account_onboarding",
           account_onboarding: {
-            configurations: (opts.configurations ??
-              []) as V2AppliedConfiguration[],
             refresh_url: opts.refreshUrl,
             return_url: opts.returnUrl,
           },
@@ -154,11 +148,9 @@ export async function getAccountLinkWithStatus(
   });
 
   const getOnboardingLink = async (): Promise<AccountLinkWithStatus> => {
-    const configs = account.applied_configurations ?? [];
     const link = await createV2AccountLink(stripe, ctx, {
       stripeAccountId: opts.stripeAccountId,
       type: "account_onboarding",
-      configurations: configs,
       refreshUrl: opts.refreshUrl,
       returnUrl: opts.returnUrl,
     });

package/src/client/core/accountStatus.test.ts

@@ -28,6 +28,73 @@ function makeEntry(
 }
 
 describe("deriveAccountStatus", () => {
+  it.each(["rejected", "restricted"] as const)(
+    "maps an Endive %s capability to restricted even when the config is applied",
+    (status) => {
+      expect(
+        deriveAccountStatus({
+          configuration: {
+            merchant: {
+              applied: true,
+              capabilities: { card_payments: { status } },
+            } as V2AccountConfigMerchant,
+          },
+        }).onboardingStatus,
+      ).toBe("restricted");
+    },
+  );
+
+  it("keeps pending nested capabilities in progress", () => {
+    expect(
+      deriveAccountStatus({
+        configuration: {
+          merchant: {
+            applied: true,
+            capabilities: {
+              stripe_balance: { payouts: { status: "pending" } },
+            },
+          } as V2AccountConfigMerchant,
+        },
+      }).onboardingStatus,
+    ).toBe("in_progress");
+  });
+
+  it("prioritizes rejected capabilities over requirements awaiting Stripe", () => {
+    expect(
+      deriveAccountStatus({
+        requirements: {
+          entries: [
+            makeEntry("identity_document", { awaiting_action_from: "stripe" }),
+          ],
+        },
+        configuration: {
+          merchant: {
+            applied: true,
+            capabilities: { card_payments: { status: "rejected" } },
+          } as V2AccountConfigMerchant,
+        },
+      }),
+    ).toMatchObject({
+      onboardingStatus: "restricted",
+      missingRequirements: ["identity_document"],
+    });
+  });
+
+  it("permits active capabilities and ignores unsupported optional methods", () => {
+    expect(
+      deriveAccountStatus({
+        configuration: {
+          merchant: {
+            applied: true,
+            capabilities: {
+              card_payments: { status: "active" },
+              ach_debit_payments: { status: "unsupported" },
+            },
+          } as V2AccountConfigMerchant,
+        },
+      }).onboardingStatus,
+    ).toBe("complete");
+  });
   it("returns pending when no requirements and no config", () => {
     const status = deriveAccountStatus({});
     expect(status.onboardingStatus).toBe("pending");

package/src/client/core/accountStatus.ts

@@ -1,10 +1,7 @@
 import type Stripe from "stripe";
 
 export type BetterStripeOnboardingStatus =
-  | "pending"
-  | "in_progress"
-  | "complete"
-  | "restricted";
+  "pending" | "in_progress" | "complete" | "restricted";
 
 /**
  * Accepts a V2 Account (or partial shape with configuration/requirements).
@@ -14,6 +11,14 @@ type StripeAccountLike = Pick<
   "configuration" | "requirements"
 >;
 
+/** Capability groups such as stripe_balance nest their leaf statuses. */
+function capabilityStatuses(value: unknown): string[] {
+  if (!value || typeof value !== "object") return [];
+  const record = value as Record<string, unknown>;
+  if (typeof record.status === "string") return [record.status];
+  return Object.values(record).flatMap(capabilityStatuses);
+}
+
 export function deriveAccountStatus(account: StripeAccountLike): {
   onboardingStatus: BetterStripeOnboardingStatus;
   missingRequirements: string[];
@@ -53,6 +58,25 @@ export function deriveAccountStatus(account: StripeAccountLike): {
     };
   }
 
+  const configuration = account.configuration;
+  const configs = [
+    configuration?.customer,
+    configuration?.merchant,
+    configuration?.recipient,
+  ].filter(Boolean);
+  const statuses = configs.flatMap((cfg) =>
+    capabilityStatuses(cfg?.capabilities),
+  );
+
+  // An applied configuration does not imply that its capabilities are active.
+  // Endive adds rejected to the V2 capability status enum. A blocked capability
+  // takes precedence over requirements still awaiting Stripe verification.
+  if (
+    statuses.some((status) => status === "restricted" || status === "rejected")
+  ) {
+    return { onboardingStatus: "restricted", missingRequirements };
+  }
+
   if (missingRequirements.length > 0) {
     return {
       onboardingStatus: "in_progress",
@@ -60,7 +84,6 @@ export function deriveAccountStatus(account: StripeAccountLike): {
     };
   }
 
-  const configuration = account.configuration;
   if (!configuration) {
     return {
       onboardingStatus: "pending",
@@ -68,13 +91,6 @@ export function deriveAccountStatus(account: StripeAccountLike): {
     };
   }
 
-  // V2 configurations use `applied: boolean` to indicate active state
-  const configs = [
-    configuration.customer,
-    configuration.merchant,
-    configuration.recipient,
-  ].filter(Boolean);
-
   if (configs.length === 0) {
     return {
       onboardingStatus: "pending",
@@ -85,7 +101,8 @@ export function deriveAccountStatus(account: StripeAccountLike): {
   const allApplied = configs.every((cfg) => cfg?.applied === true);
 
   return {
-    onboardingStatus: allApplied ? "complete" : "in_progress",
+    onboardingStatus:
+      allApplied && !statuses.includes("pending") ? "complete" : "in_progress",
     missingRequirements,
   };
 }

package/src/client/helpers.test.ts

@@ -4,8 +4,8 @@ import { STRIPE_API_VERSION } from "./constants.js";
 import { epochToIso, getStripeClient, runMutationOrThrow } from "./helpers.js";
 
 describe("STRIPE_API_VERSION", () => {
-  it("is a dahlia API version", () => {
-    expect(STRIPE_API_VERSION).toMatch(/\.dahlia$/);
+  it("matches the installed SDK API version", () => {
+    expect(STRIPE_API_VERSION).toBe("2026-09-30.endive");
   });
 });
 

package/src/client/index.ts

@@ -679,15 +679,20 @@ export class BetterStripe {
     },
   ) {
     const { fee, ...rest } = opts;
-    return checkoutImpl.createCheckoutSession(this.stripe(), this.component, ctx, {
-      ...rest,
-      // Fees apply to destination or split sales; resolve override → default.
-      feeConfig:
-        opts.destinationAccountId || opts.split?.length
-          ? this.resolveFee(fee)
-          : undefined,
-      defaultStatementDescriptorSuffix: this._statementDescriptorSuffix,
-    });
+    return checkoutImpl.createCheckoutSession(
+      this.stripe(),
+      this.component,
+      ctx,
+      {
+        ...rest,
+        // Fees apply to destination or split sales; resolve override → default.
+        feeConfig:
+          opts.destinationAccountId || opts.split?.length
+            ? this.resolveFee(fee)
+            : undefined,
+        defaultStatementDescriptorSuffix: this._statementDescriptorSuffix,
+      },
+    );
   }
 
   async getCheckoutSession(
@@ -760,20 +765,27 @@ export class BetterStripe {
       split?: SplitRecipient[];
       fee?: FeeOverride;
       trialDays?: number;
+      /** Attached payment method to use for this subscription. */
+      defaultPaymentMethod?: string;
       metadata?: Record<string, string>;
       /** Stripe idempotency key for retry-safe subscription creation. */
       idempotencyKey?: string;
     },
   ) {
     const { fee, ...rest } = opts;
-    return subscriptionsImpl.createSubscription(this.stripe(), this.component, ctx, {
-      ...rest,
-      feeConfig:
-        opts.destinationAccountId || opts.split?.length
-          ? this.resolveFee(fee)
-          : undefined,
-      defaultStatementDescriptorSuffix: this._statementDescriptorSuffix,
-    });
+    return subscriptionsImpl.createSubscription(
+      this.stripe(),
+      this.component,
+      ctx,
+      {
+        ...rest,
+        feeConfig:
+          opts.destinationAccountId || opts.split?.length
+            ? this.resolveFee(fee)
+            : undefined,
+        defaultStatementDescriptorSuffix: this._statementDescriptorSuffix,
+      },
+    );
   }
 
   async getSubscription(
@@ -1083,6 +1095,7 @@ export class BetterStripe {
       type: "account_onboarding" | "account_update";
       refreshUrl: string;
       returnUrl: string;
+      /** @deprecated Endive collects requirements without configurations. Ignored. */
       configurations?: string[];
     },
   ) {
@@ -1169,7 +1182,12 @@ export class BetterStripe {
       operationId?: string;
     },
   ) {
-    return transfersImpl.reverseTransfers(this.stripe(), this.component, ctx, opts);
+    return transfersImpl.reverseTransfers(
+      this.stripe(),
+      this.component,
+      ctx,
+      opts,
+    );
   }
 
   /**
@@ -1799,44 +1817,31 @@ export class BetterStripe {
       ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined
     > = {
       afterAccountUpdated: hooks?.onAccountUpdated as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterCheckoutCompleted: hooks?.onCheckoutCompleted as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterSubscriptionUpdated: hooks?.onSubscriptionUpdated as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterSubscriptionCanceled: hooks?.onSubscriptionCanceled as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterTrialEnding: hooks?.onTrialEnding as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterInvoicePaid: hooks?.onInvoicePaid as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterInvoicePaymentFailed: hooks?.onInvoicePaymentFailed as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterPaymentSucceeded: hooks?.onPaymentSucceeded as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterPaymentFailed: hooks?.onPaymentFailed as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterPayoutCompleted: hooks?.onPayoutCompleted as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterRefundCreated: hooks?.onRefundCreated as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterDisputeCreated: hooks?.onDisputeCreated as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
       afterDisputeClosed: hooks?.onDisputeClosed as
-        | ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>)
-        | undefined,
+        ((ctx: AsyncHookCtx, doc: unknown) => Promise<void>) | undefined,
     };
 
     const syncWebhook = internalMutationGeneric({

package/src/client/stripe-version.test.ts

@@ -0,0 +1,47 @@
+import Stripe from "stripe";
+import { describe, expect, it } from "vitest";
+
+import { getStripe } from "../component/lib/stripeFactory.js";
+import { STRIPE_API_VERSION } from "./constants.js";
+import { getStripeClient } from "./helpers.js";
+
+describe("Stripe version pin", () => {
+  it("matches the supported stripe-node API, including the full endive suffix", () => {
+    expect(STRIPE_API_VERSION).toBe("2026-09-30.endive");
+    expect(Stripe.API_VERSION).toBe(STRIPE_API_VERSION);
+  });
+
+  it.each([getStripeClient, getStripe])(
+    "pins outgoing API requests from each factory",
+    async (factory) => {
+      const stripe = factory("sk_test_version_transport_only");
+      let version: string | undefined;
+      // Factories deliberately expose no transport override. Replace only the
+      // SDK's transport slot, leaving its request serializer/headers untouched.
+      const transportSlot = stripe as unknown as {
+        _setApiField: (field: string, value: unknown) => void;
+      };
+      transportSlot._setApiField("httpClient", {
+        getClientName: () => "test",
+        makeRequest: async (
+          ...[, , , , headers]: Parameters<
+            ReturnType<typeof Stripe.createNodeHttpClient>["makeRequest"]
+          >
+        ) => {
+          version = String(headers["Stripe-Version"]);
+          return {
+            getStatusCode: () => 200,
+            getHeaders: () => ({}),
+            getRawResponse: () => ({}),
+            toJSON: async () => ({ id: "prod_local", object: "product" }),
+            toStream: () => {
+              throw new Error("Unexpected stream");
+            },
+          };
+        },
+      });
+      await stripe.products.retrieve("prod_local");
+      expect(version).toBe(STRIPE_API_VERSION);
+    },
+  );
+});

package/src/client/types/documents.ts

@@ -178,6 +178,7 @@ export type StripeComponentSubscription = {
   currentPeriodStart?: string;
   currentPeriodEnd?: string;
   cancelAtPeriodEnd: boolean;
+  isCollectionPaused?: boolean;
   canceledAt?: string;
   isTrialing: boolean;
   trialStart?: string;

package/src/client/types/events.ts

@@ -26,7 +26,8 @@ export type V2ThinEvent = {
   created: string;
   livemode?: boolean;
   related_object?: {
-    id: string;
+    /** Singleton related objects may omit their id (stripe-node 23). */
+    id?: string;
     type: string;
     url: string;
   };

package/src/client/types/options.ts

@@ -79,6 +79,13 @@ export type RegisterRoutesConfig = {
   webhookSecretV2?: string;
   onEvent?: StripeEventHandler<StripeWebhookEvent>;
   events?: StripeEventHandlers;
+  /**
+   * Select verified V1 events whose onEvent/event hooks must succeed before
+   * delivery is acknowledged. Failures return 500 and permit redelivery;
+   * an in-flight delivery returns 503. Hooks must be idempotent by event.id.
+   * V2 events and scheduled asyncWebhook hooks retain best-effort behavior.
+   */
+  retryOnHookError?: (event: StripeWebhookEvent) => boolean;
   /**
    * Function references to the app's exported `webhookHandlers()` pair,
    * e.g. `webhooks: internal.stripe` (no cast needed). When provided,

package/src/client/webhooks/handler.ts

@@ -179,6 +179,13 @@ export async function handleWebhookRequest(
     );
   }
 
+  let requiresHookSuccess: boolean;
+  try {
+    requiresHookSuccess = config?.retryOnHookError?.(event) ?? false;
+  } catch (error) {
+    console.error("[better-stripe] retryOnHookError selector failed:", error);
+    return jsonResponse({ error: "Webhook retry policy failed" }, 500);
+  }
   // --- Atomic webhook dedup via event ledger ---
   const eventId = event.id;
   console.info(
@@ -195,6 +202,9 @@ export async function handleWebhookRequest(
       },
     );
     if (dedupStatus !== "inserted") {
+      if (requiresHookSuccess && dedupStatus === "processing") {
+        return jsonResponse({ error: "Event processing in progress" }, 503);
+      }
       console.info(`[better-stripe]   ↳ deduplicated (already processed)`);
       return jsonResponse({ success: true, deduplicated: true }, 200);
     }
@@ -204,6 +214,8 @@ export async function handleWebhookRequest(
       `[better-stripe] Webhook ledger insert failed for ${eventId}:`,
       error,
     );
+    if (requiresHookSuccess)
+      return jsonResponse({ error: "Webhook ledger unavailable" }, 500);
   }
 
   // --- Process event (sync) ---
@@ -226,6 +238,29 @@ export async function handleWebhookRequest(
     return jsonResponse({ error: "Sync processing failed" }, 500);
   }
 
+  if (requiresHookSuccess) {
+    try {
+      await runHooks(ctx, config, event, true);
+    } catch (error) {
+      console.error(
+        `[better-stripe] Required hook failed for ${event.type}:`,
+        error,
+      );
+      try {
+        await ctx.runMutation(
+          componentRef(component, "webhooks/mutations/markWebhookEventFailed"),
+          {
+            stripeEventId: eventId,
+            error: error instanceof Error ? error.message : String(error),
+          },
+        );
+      } catch {
+        // A stale processing row is recoverable on a later delivery.
+      }
+      return jsonResponse({ error: "Application fulfillment failed" }, 500);
+    }
+  }
+
   // --- Mark processed ---
   try {
     await ctx.runMutation(
@@ -235,6 +270,8 @@ export async function handleWebhookRequest(
       },
     );
   } catch {
+    if (requiresHookSuccess)
+      return jsonResponse({ error: "Webhook completion unavailable" }, 500);
     /* ledger update best-effort */
   }
 
@@ -244,7 +281,7 @@ export async function handleWebhookRequest(
 
   // --- Run async hooks (errors must not crash the handler) ---
   try {
-    await runHooks(ctx, config, event);
+    if (!requiresHookSuccess) await runHooks(ctx, config, event);
   } catch (error) {
     console.error(
       `[better-stripe] Hook runner error for ${event.type}:`,

package/src/client/webhooks/hooks.ts

@@ -14,11 +14,13 @@ export async function runHooks(
   ctx: WebhookActionCtx,
   config: RegisterRoutesConfig | undefined,
   event: StripeWebhookEvent,
+  shouldThrow = false,
 ): Promise<void> {
   if (config?.onEvent) {
     try {
       await config.onEvent(ctx, event);
     } catch (error) {
+      if (shouldThrow) throw error;
       console.error(
         `[better-stripe] onEvent hook error for ${event.type}:`,
         error,
@@ -31,6 +33,7 @@ export async function runHooks(
     try {
       await handler(ctx, event);
     } catch (error) {
+      if (shouldThrow) throw error;
       console.error(
         `[better-stripe] Event hook error for ${event.type}:`,
         error,