@cosmicdrift/kumiko-samples 0.386.0 → 0.388.0

package/packages/bundled-features/src/billing-foundation/web/checkout-consent-dialog.tsx

@@ -1,5 +1,6 @@
 import { useLocale, usePrimitives, useTranslation } from "@cosmicdrift/kumiko-renderer";
 import type { WriteResult } from "@cosmicdrift/kumiko-renderer/headless";
+import { ChoiceCards } from "@cosmicdrift/kumiko-renderer/web";
 import { type ReactNode, useState } from "react";
 import type { BillingPlansResult } from "../types.ts";
 import { resolveConsentLocale } from "./consumer-protection/consent-locale.ts";
@@ -24,8 +25,24 @@ export type CheckoutConsentDialogProps = {
     readonly renewalKey?: string;
     readonly count?: string;
   };
-  readonly consumerProtection: ConsumerProtectionView;
-  readonly onOrder: (consent: CheckoutConsentPayload) => Promise<WriteResult<{ url: string }>>;
+  /** Without it the dialog shows no legal links and no consent checkboxes and orders without a consent. */
+  readonly consumerProtection?: ConsumerProtectionView;
+  /** Several providers to pick from; the parent follows `value` for price and order. */
+  readonly providerChoice?: {
+    readonly options: readonly {
+      readonly value: string;
+      readonly title: string;
+      readonly description?: string;
+      readonly aside?: string;
+    }[];
+    readonly value: string;
+    readonly onChange: (value: string) => void;
+  };
+  /** Provider note under the price line when there is no provider choice. */
+  readonly note?: string;
+  readonly onOrder: (
+    consent: CheckoutConsentPayload | undefined,
+  ) => Promise<WriteResult<{ url: string }>>;
   readonly onConsentTextOutdated: () => void;
 };
 
@@ -36,6 +53,8 @@ export function CheckoutConsentDialog({
   planName,
   price,
   consumerProtection,
+  providerChoice,
+  note,
   onOrder,
   onConsentTextOutdated,
 }: CheckoutConsentDialogProps): ReactNode {
@@ -48,18 +67,23 @@ export function CheckoutConsentDialog({
   const [errorText, setErrorText] = useState<string | null>(null);
 
   const consentLocale = resolveConsentLocale(uiLocale);
-  const texts = consumerProtection.consentTexts[consentLocale];
-  const legalLinks = consumerProtection.legalLinks[consentLocale];
+  const texts = consumerProtection?.consentTexts[consentLocale];
+  const legalLinks = consumerProtection?.legalLinks[consentLocale];
+  const consentGiven = consumerProtection === undefined || (earlyPerformance && withdrawalLoss);
 
   async function order(): Promise<void> {
     setSubmitting(true);
     setErrorText(null);
-    const result = await onOrder({
-      earlyPerformanceRequested: true,
-      withdrawalLossAcknowledged: true,
-      consentTextVersion: texts.consentTextVersion,
-      locale: consentLocale,
-    });
+    const result = await onOrder(
+      texts === undefined
+        ? undefined
+        : {
+            earlyPerformanceRequested: true,
+            withdrawalLossAcknowledged: true,
+            consentTextVersion: texts.consentTextVersion,
+            locale: consentLocale,
+          },
+    );
     if (result.isSuccess) return;
     setSubmitting(false);
     setErrorText(t(result.error.i18nKey, result.error.i18nParams));
@@ -78,6 +102,18 @@ export function CheckoutConsentDialog({
       testId="checkout-consent-dialog"
     >
       <div className="flex flex-col gap-4">
+        {providerChoice !== undefined && (
+          <div className="flex flex-col gap-2">
+            <Text variant="muted">{t("billing-foundation.consent.chooseProvider")}</Text>
+            <ChoiceCards
+              value={providerChoice.value}
+              options={providerChoice.options}
+              onChange={providerChoice.onChange}
+              ariaLabel={t("billing-foundation.consent.chooseProvider")}
+              testId="checkout-provider-choice"
+            />
+          </div>
+        )}
         <div className="flex flex-col gap-1" data-testid="checkout-consent-summary">
           <Text>
             {planName} — {price.amount}
@@ -93,38 +129,49 @@ export function CheckoutConsentDialog({
               <Text variant="muted">{t("billing-foundation.consent.cancelAnytime")}</Text>
             </>
           )}
+          {note !== undefined && (
+            <Text variant="muted" testId="checkout-consent-note">
+              {note}
+            </Text>
+          )}
         </div>
-        <div className="flex flex-wrap gap-4">
-          <Link href={legalLinks.terms} target="_blank">
-            {t("billing-foundation.consent.link.terms")}
-          </Link>
-          <Link href={legalLinks.withdrawal} target="_blank">
-            {t("billing-foundation.consent.link.withdrawal")}
-          </Link>
-          <Link href={legalLinks.privacy} target="_blank">
-            {t("billing-foundation.consent.link.privacy")}
-          </Link>
-        </div>
-        <Field id="consent-early-performance" label={texts.earlyPerformance} layout="inline">
-          <Input
-            kind="boolean"
-            id="consent-early-performance"
-            name="consent-early-performance"
-            value={earlyPerformance}
-            onChange={setEarlyPerformance}
-            disabled={submitting}
-          />
-        </Field>
-        <Field id="consent-withdrawal-loss" label={texts.withdrawalLoss} layout="inline">
-          <Input
-            kind="boolean"
-            id="consent-withdrawal-loss"
-            name="consent-withdrawal-loss"
-            value={withdrawalLoss}
-            onChange={setWithdrawalLoss}
-            disabled={submitting}
-          />
-        </Field>
+        {legalLinks !== undefined && (
+          <div className="flex flex-wrap gap-4">
+            <Link href={legalLinks.terms} target="_blank">
+              {t("billing-foundation.consent.link.terms")}
+            </Link>
+            <Link href={legalLinks.withdrawal} target="_blank">
+              {t("billing-foundation.consent.link.withdrawal")}
+            </Link>
+            <Link href={legalLinks.privacy} target="_blank">
+              {t("billing-foundation.consent.link.privacy")}
+            </Link>
+          </div>
+        )}
+        {texts !== undefined && (
+          <>
+            <Field id="consent-early-performance" label={texts.earlyPerformance} layout="inline">
+              <Input
+                kind="boolean"
+                id="consent-early-performance"
+                name="consent-early-performance"
+                value={earlyPerformance}
+                onChange={setEarlyPerformance}
+                disabled={submitting}
+              />
+            </Field>
+            <Field id="consent-withdrawal-loss" label={texts.withdrawalLoss} layout="inline">
+              <Input
+                kind="boolean"
+                id="consent-withdrawal-loss"
+                name="consent-withdrawal-loss"
+                value={withdrawalLoss}
+                onChange={setWithdrawalLoss}
+                disabled={submitting}
+              />
+            </Field>
+          </>
+        )}
         {errorText !== null && (
           <Banner variant="error" testId="checkout-consent-error">
             {errorText}
@@ -140,7 +187,7 @@ export function CheckoutConsentDialog({
             {t("billing-foundation.consent.back")}
           </Button>
           <Button
-            disabled={!earlyPerformance || !withdrawalLoss || submitting}
+            disabled={!consentGiven || submitting}
             loading={submitting}
             onClick={order}
             testId="checkout-consent-order"

package/packages/bundled-features/src/billing-foundation/web/constants.ts

@@ -95,6 +95,10 @@ export const SubscriptionFoundationQueries = {
    *  current tier and per-plan action. Only registered when a `catalog` is
    *  configured. */
   billingPlans: "billing-foundation:query:billing-plans",
+  /** What switching to a tier would cost right now, for providers that switch
+   *  plans in-app (preview + apply). Only registered when a `catalog` is
+   *  configured. */
+  planSwitchPreview: "billing-foundation:query:plan-switch-preview",
   /** System-only probe: does the caller tenant hold a non-terminal
    *  subscription (consumerProtection only). */
   terminableSubscription: "billing-foundation:query:terminable-subscription",

package/packages/bundled-features/src/billing-foundation/web/plan-price.ts

@@ -0,0 +1,55 @@
+import type { BillingPlanView } from "../types.ts";
+
+type Recurrence = {
+  readonly interval: string | null;
+  readonly intervalCount: number | null;
+};
+
+export function intervalKey(price: Recurrence | null): string | undefined {
+  if (price === null || price.interval === null) return undefined;
+  return price.intervalCount !== null && price.intervalCount > 1
+    ? `billing-foundation.plans.everyInterval.${price.interval}`
+    : `billing-foundation.plans.perInterval.${price.interval}`;
+}
+
+export function renewalKey(price: Recurrence | null): string | undefined {
+  if (price === null || price.interval === null) return undefined;
+  return price.intervalCount !== null && price.intervalCount > 1
+    ? `billing-foundation.consent.renewsEvery.${price.interval}`
+    : `billing-foundation.consent.renews.${price.interval}`;
+}
+
+type PlanPrice = NonNullable<BillingPlanView["price"]>;
+
+export function pricesDiffer(prices: readonly PlanPrice[]): boolean {
+  const [first, ...rest] = prices;
+  return (
+    first !== undefined &&
+    rest.some(
+      (price) =>
+        price.unitAmount !== first.unitAmount ||
+        price.currency !== first.currency ||
+        price.interval !== first.interval ||
+        price.intervalCount !== first.intervalCount,
+    )
+  );
+}
+
+/** Price of `tier` at every provider that offers it, in provider order. */
+export function tierPrices(
+  providers: readonly { readonly plans: readonly BillingPlanView[] }[],
+  tier: string,
+): PlanPrice[] {
+  return providers.flatMap((provider) => {
+    const price = provider.plans.find((plan) => plan.tier === tier)?.price;
+    return price ? [price] : [];
+  });
+}
+
+export function cheapestPrice(prices: readonly PlanPrice[]): PlanPrice | undefined {
+  return prices.reduce<PlanPrice | undefined>(
+    (lowest, price) =>
+      lowest === undefined || price.unitAmount < lowest.unitAmount ? price : lowest,
+    undefined,
+  );
+}

package/packages/bundled-features/src/billing-foundation/web/plan-switch-confirm-dialog.tsx

@@ -0,0 +1,224 @@
+import {
+  useLocale,
+  useMutation,
+  usePrimitives,
+  useQuery,
+  useTranslation,
+} from "@cosmicdrift/kumiko-renderer";
+import { formatMoney } from "@cosmicdrift/kumiko-renderer/web";
+import { type ReactNode, useState } from "react";
+import type { BillingPlansResult, PlanSwitchPreview } from "../types.ts";
+import {
+  type CheckoutConsentPayload,
+  CONSENT_TEXT_OUTDATED_CODE,
+} from "./checkout-consent-dialog.tsx";
+import { SubscriptionFoundationHandlers, SubscriptionFoundationQueries } from "./constants.ts";
+import { resolveConsentLocale } from "./consumer-protection/consent-locale.ts";
+import { intervalKey } from "./plan-price.ts";
+
+type ConsumerProtectionView = NonNullable<BillingPlansResult["consumerProtection"]>;
+
+type PlanSwitchPreviewReply = {
+  readonly preview: PlanSwitchPreview;
+  readonly target: {
+    readonly unitAmount: number;
+    readonly currency: string;
+    readonly interval: string | null;
+    readonly intervalCount: number | null;
+  };
+};
+
+export type PlanSwitchConfirmDialogProps = {
+  readonly open: boolean;
+  readonly onOpenChange: (open: boolean) => void;
+  readonly tier: string;
+  readonly fromPlanName: string;
+  readonly toPlanName: string;
+  readonly consumerProtection?: ConsumerProtectionView;
+  readonly onApplied: () => void;
+  readonly onConsentTextOutdated: () => void;
+};
+
+// kumiko-lint-ignore no-custom-primitives Uses usePrimitives().Modal internally, name is a billing domain action, not a primitive reimplementation
+export function PlanSwitchConfirmDialog({
+  open,
+  onOpenChange,
+  tier,
+  fromPlanName,
+  toPlanName,
+  consumerProtection,
+  onApplied,
+  onConsentTextOutdated,
+}: PlanSwitchConfirmDialogProps): ReactNode {
+  const t = useTranslation();
+  const locale = useLocale().locale();
+  const { Modal, Text, Field, Input, Button, Link, Banner } = usePrimitives();
+  const previewQuery = useQuery<PlanSwitchPreviewReply>(
+    SubscriptionFoundationQueries.planSwitchPreview,
+    { tier },
+  );
+  const switchMutation = useMutation<{ readonly applied: true }>(
+    SubscriptionFoundationHandlers.switchPlan,
+  );
+  const [earlyPerformance, setEarlyPerformance] = useState(false);
+  const [withdrawalLoss, setWithdrawalLoss] = useState(false);
+  const [submitting, setSubmitting] = useState(false);
+  const [errorText, setErrorText] = useState<string | null>(null);
+
+  const consentLocale = resolveConsentLocale(locale);
+  const texts = consumerProtection?.consentTexts[consentLocale];
+  const legalLinks = consumerProtection?.legalLinks[consentLocale];
+  const consentGiven = consumerProtection === undefined || (earlyPerformance && withdrawalLoss);
+
+  async function confirm(): Promise<void> {
+    setSubmitting(true);
+    setErrorText(null);
+    const consent: CheckoutConsentPayload | undefined =
+      texts === undefined
+        ? undefined
+        : {
+            earlyPerformanceRequested: true,
+            withdrawalLossAcknowledged: true,
+            consentTextVersion: texts.consentTextVersion,
+            locale: consentLocale,
+          };
+    const result = await switchMutation.mutate({ tier, ...(consent && { consent }) });
+    if (result.isSuccess) {
+      onApplied();
+      return;
+    }
+    setSubmitting(false);
+    setErrorText(t(result.error.i18nKey, result.error.i18nParams));
+    if (result.error.code === CONSENT_TEXT_OUTDATED_CODE) {
+      setEarlyPerformance(false);
+      setWithdrawalLoss(false);
+      onConsentTextOutdated();
+    }
+  }
+
+  const reply = previewQuery.data;
+  const money = (amount: number, currency: string) => formatMoney(amount, currency, locale);
+  const recurringKey = reply === null ? undefined : intervalKey(reply.target);
+  const recurringPrice =
+    reply === null
+      ? ""
+      : `${money(reply.target.unitAmount, reply.target.currency)}${
+          recurringKey === undefined
+            ? ""
+            : ` ${t(recurringKey, { count: new Intl.NumberFormat(locale).format(reply.target.intervalCount ?? 1) })}`
+        }`;
+
+  return (
+    <Modal
+      open={open}
+      onOpenChange={onOpenChange}
+      title={t("billing-foundation.planSwitch.title")}
+      testId="plan-switch-confirm-dialog"
+    >
+      <div className="flex flex-col gap-4">
+        <Text>
+          {t("billing-foundation.planSwitch.summary", { from: fromPlanName, to: toPlanName })}
+        </Text>
+        {previewQuery.error !== null && (
+          <Banner variant="error" testId="plan-switch-preview-error">
+            {t(previewQuery.error.i18nKey, previewQuery.error.i18nParams)}
+          </Banner>
+        )}
+        {previewQuery.loading && reply === null && (
+          <Banner variant="loading" testId="plan-switch-preview-loading">
+            {t("kumiko.widget.loading")}
+          </Banner>
+        )}
+        {reply !== null && (
+          <div className="flex flex-col gap-1" data-testid="plan-switch-summary">
+            <Text>
+              {t("billing-foundation.planSwitch.dueNow", {
+                amount: money(reply.preview.amountDueNow, reply.preview.currency),
+              })}
+              {reply.preview.tax !== null &&
+                ` (${t("billing-foundation.planSwitch.includesTax", {
+                  tax: money(reply.preview.tax, reply.preview.currency),
+                })})`}
+            </Text>
+            <Text variant="muted">
+              {t("billing-foundation.planSwitch.credit", {
+                amount: money(reply.preview.credit, reply.preview.currency),
+              })}
+            </Text>
+            <Text variant="muted">
+              {t("billing-foundation.planSwitch.recurring", {
+                amount: recurringPrice,
+              })}
+            </Text>
+            <Text variant="muted">{t("billing-foundation.planSwitch.effective")}</Text>
+            <Text variant="muted">{t("billing-foundation.planSwitch.pendingNote")}</Text>
+          </div>
+        )}
+        {legalLinks !== undefined && (
+          <div className="flex flex-wrap gap-4">
+            <Link href={legalLinks.terms} target="_blank">
+              {t("billing-foundation.consent.link.terms")}
+            </Link>
+            <Link href={legalLinks.withdrawal} target="_blank">
+              {t("billing-foundation.consent.link.withdrawal")}
+            </Link>
+            <Link href={legalLinks.privacy} target="_blank">
+              {t("billing-foundation.consent.link.privacy")}
+            </Link>
+          </div>
+        )}
+        {texts !== undefined && (
+          <>
+            <Field
+              id="plan-switch-early-performance"
+              label={texts.earlyPerformance}
+              layout="inline"
+            >
+              <Input
+                kind="boolean"
+                id="plan-switch-early-performance"
+                name="plan-switch-early-performance"
+                value={earlyPerformance}
+                onChange={setEarlyPerformance}
+                disabled={submitting}
+              />
+            </Field>
+            <Field id="plan-switch-withdrawal-loss" label={texts.withdrawalLoss} layout="inline">
+              <Input
+                kind="boolean"
+                id="plan-switch-withdrawal-loss"
+                name="plan-switch-withdrawal-loss"
+                value={withdrawalLoss}
+                onChange={setWithdrawalLoss}
+                disabled={submitting}
+              />
+            </Field>
+          </>
+        )}
+        {errorText !== null && (
+          <Banner variant="error" testId="plan-switch-confirm-error">
+            {errorText}
+          </Banner>
+        )}
+        <div className="flex justify-end gap-2">
+          <Button
+            variant="secondary"
+            disabled={submitting}
+            onClick={() => onOpenChange(false)}
+            testId="plan-switch-confirm-cancel"
+          >
+            {t("billing-foundation.consent.back")}
+          </Button>
+          <Button
+            disabled={!consentGiven || reply === null || submitting}
+            loading={submitting}
+            onClick={confirm}
+            testId="plan-switch-confirm-order"
+          >
+            {t("billing-foundation.planSwitch.order")}
+          </Button>
+        </div>
+      </div>
+    </Modal>
+  );
+}

package/packages/bundled-features/src/billing-foundation/webhook-handler.ts

@@ -95,7 +95,7 @@ export function createSubscriptionWebhookRoute(options: SubscriptionWebhookRoute
         return c.json({ ignored: true }, 200);
       }
       const parsed = verified.event;
-      const tenantId = parsed.tenantId as import("@cosmicdrift/kumiko-framework/engine").TenantId;
+      const tenantId = parsed.tenantId;
       if (parsed.kind === BillingEventKinds.payment) {
         const dispatched = await deps.dispatchSystemWrite({
           handlerQn: SubscriptionFoundationHandlers.processPaymentEvent,

package/packages/bundled-features/src/cap-counter/aggregate-id.ts

@@ -1,16 +1,15 @@
 import { v5 as uuidv5 } from "uuid";
 
-// Fixed UUID-namespace für die cap-counter-aggregate-id-Ableitung.
-// Generiert einmalig (2026-05-02), in Stein gemeißelt: ein Wechsel würde
-// jeden existing aggregate-Stream re-keyen → kaputter event-replay,
-// kaputte counter-history, verlorener Audit-Trail. Drift-Pin in
-// __tests__/drift.test.ts pinnt den UUID-Wert.
+// Fixed UUID namespace for deriving cap-counter aggregate IDs.
+// Generated once (2026-05-02) and immutable: changing it would re-key every
+// existing aggregate stream, breaking event replay and counter history and
+// losing the audit trail. The drift test in __tests__/drift.test.ts pins the UUID.
 const CAP_COUNTER_NAMESPACE = "9c1bf2a3-6e4d-4f5b-8a9c-2d3e4f5a6b7c";
 
-// Separater Namespace für Rolling-Window-Counter (Sprint 4). Eigener
-// Namespace damit das aggregate-id NIE mit einem Calendar-Counter
-// kollidiert, selbst wenn jemand "1970-01-01..." als periodStart in
-// den Calendar-Pfad reinpasst. Drift-Pin in __tests__/drift.test.ts.
+// Separate namespace for rolling-window counters. This prevents the aggregate ID
+// from colliding with a calendar counter, even if "1970-01-01..." is passed as
+// periodStart through the calendar path. The drift test in __tests__/drift.test.ts
+// pins the UUID.
 const CAP_COUNTER_ROLLING_NAMESPACE = "8b2ad0c6-1f3e-4f7c-9b8a-3c4d5e6f7a8b";
 
 /**

package/packages/bundled-features/src/cap-counter/cap-reservation.ts

@@ -473,7 +473,11 @@ async function consumeClaimedRow(
     if (!booked.isSuccess) return booked;
     await txDb.updateMany(
       capReservationsTable,
-      { consumedAmount: claimed.consumedAmount + options.units },
+      {
+        consumedAmount: claimed.consumedAmount + options.units,
+        // Keep the tombstone alive past its last consume, else a later consume would start a fresh one and double count.
+        expiresAt: Temporal.Now.instant().add({ minutes: CAP_SETTLED_TOMBSTONE_TTL_MINUTES }),
+      },
       ownRow,
     );
     return booked;

package/packages/bundled-features/src/cap-counter/changes.json

@@ -1,4 +1,22 @@
 [
+  {
+    "version": "0.388.0",
+    "type": "fix",
+    "title": "Consume on a released reservation extends its tombstone",
+    "detail": "Every consume against a released reservation tombstone now pushes its expiry out, so a long-running job that consumes across the sweep can no longer lose the tombstone and have its earlier units counted twice at settle."
+  },
+  {
+    "version": "0.388.0",
+    "type": "fix",
+    "title": "Misconfigured cap period fails on every enforcement",
+    "detail": "A periodEndIso that is unparsable or not after periodStartIso now throws on each enforceCap or reservation call instead of only once the hard cap is reached, so a bad period no longer turns into a 500 at the limit instead of cap_exceeded."
+  },
+  {
+    "version": "0.388.0",
+    "type": "fix",
+    "title": "Stock cap lock covers the counted rows, not the error code",
+    "detail": "withStockCap serializes on the table and where filter that are counted, so two handlers capping the same rows under different codes can no longer both pass the check in parallel and exceed the cap together."
+  },
   {
     "version": "0.378.0",
     "type": "fix",

package/packages/bundled-features/src/cap-counter/constants.ts

@@ -3,20 +3,19 @@ export const CAP_COUNTER_FEATURE = "cap-counter" as const;
 
 export const CAP_COUNTER_LIST_SCREEN_ID = "cap-list" as const;
 
-// Aggregate types — calendar-period-Counter benutzt CRUD-Events der
-// projection-row. Rolling-Window-Counter benutzt einen eigenen
-// aggregate-type mit custom increment-events (no projection — der
-// Read summiert über die letzten N Tage Events). Sind getrennt damit
-// die r.entity-projection nicht auch noch rolling-counter-rows tracken
-// muss.
+// Aggregate types: calendar-period counters use CRUD events for the
+// projection row. Rolling-window counters use a separate aggregate type
+// with custom increment events (no projection—the read sums events from
+// the last N days). They are separate so `r.entity-projection` does not
+// also have to track rolling-counter rows.
 export const CAP_COUNTER_ROLLING_AGGREGATE_TYPE = "cap-counter-rolling" as const;
 
-// Custom event-type für Rolling-Window-Counter. Symmetrisches Paar:
-//   _SHORT  — passt zu `r.defineEvent(short, schema)` im Registrar
-//             (Framework prefixt automatisch zu QN)
-//   _QN     — qualifizierte Form für `ctx.unsafeAppendEvent({type})`
-//             + `events.type`-Spalte + `registry.getEvent(qn)`-Lookup
-// Beide MÜSSEN konsistent sein (drift-pin im feature-test).
+// Custom event types for rolling-window counters. The pair is symmetric:
+//   _SHORT  — matches `r.defineEvent(short, schema)` in the registrar
+//             (the framework automatically prefixes it to the QN)
+//   _QN     — qualified form for `ctx.unsafeAppendEvent({type})`, the
+//             `events.type` column, and `registry.getEvent(qn)` lookups
+// Both MUST stay consistent; the feature test pins against drift.
 export const ROLLING_INCREMENTED_EVENT_SHORT = "rolling-incremented" as const;
 export const ROLLING_INCREMENTED_EVENT_QN = "cap-counter:event:rolling-incremented" as const;