create-ailk 0.29.1 → 0.31.0

package/templates/apps/web/app/[locale]/contact/site-contact-lines.ts

@@ -8,7 +8,9 @@
  *      read through the typed `SiteIdentitySchema` (#7824), so an invalid
  *      identity or address gives no line rather than a half-trusted one;
  *   2. the published contact email (`readSiteContactEmail`, the address
- *      `/contact` shows), as a `mailto:` link.
+ *      `/contact` shows), as a `mailto:` link;
+ *   3. a site's own `footer.locality` (#10550 D2), passed in by the layout,
+ *      which replaces line 1 when it is non-blank.
  *
  * Either line is left out when the site has none, so a site shows zero, one
  * or two lines. The same local `_site.mdx` frontmatter read as its sibling
@@ -54,11 +56,11 @@ function readLocalityLine(): string | undefined {
   return parts.length > 0 ? parts.join(", ") : undefined;
 }
 
-export function readSiteContactLines(): SiteContactLine[] {
+export function readSiteContactLines(locality?: string): SiteContactLine[] {
   try {
     const lines: SiteContactLine[] = [];
-    const locality = readLocalityLine();
-    if (locality !== undefined) lines.push({ label: locality });
+    const localityLine = nonEmpty(locality) ?? readLocalityLine();
+    if (localityLine !== undefined) lines.push({ label: localityLine });
     const email = readSiteContactEmail();
     if (email !== undefined) lines.push({ label: email, href: `mailto:${email}` });
     return lines;

package/templates/apps/web/app/[locale]/events/[slug]/page.tsx

@@ -1,5 +1,7 @@
 // Event detail page. Reads the Event MDX for the given slug, renders via
 // renderPage, and emits a JSON-LD <script>. Unknown slugs 404 through renderPage.
+// An Event under a program (`parent`) lives at /<program>/<event> (#10552), so
+// this URL answers a 308 there.
 import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
 import {
   getMdxSource as loadMdxSource,
@@ -7,6 +9,7 @@ import {
   renderPageMetadata,
 } from "@working-theory/page-renderer";
 import type { Metadata } from "next";
+import { permanentRedirect } from "next/navigation";
 import type { ReactElement } from "react";
 
 interface Props {
@@ -29,7 +32,16 @@ export default async function Page({
   // A page that composes `sections[]` renders them (JSON-LD is built from
   // the same sections); a prose page renders its MDX body — the rule
   // /vs/[slug] applies (#10122).
-  const source = await (getMdxSource ?? loadMdxSource)("Event", slug, locale);
+  const load = getMdxSource ?? loadMdxSource;
+  const source = await load("Event", slug, locale);
+  const parent = source?.frontmatter.parent;
+  // Only to a program the program route serves (a LandingPage at /<parent>),
+  // so a mistyped `parent` never turns this URL into a dead redirect.
+  if (parent !== undefined && (await load("LandingPage", parent, locale)) !== null) {
+    const defaultLocale = process.env.NEXT_PUBLIC_DEFAULT_LOCALE ?? "en";
+    const prefix = locale === defaultLocale ? "" : `/${locale}`;
+    permanentRedirect(`${prefix}/${parent}/${slug}`);
+  }
   const composed =
     source !== null &&
     Array.isArray((source.frontmatter as { sections?: unknown[] }).sections) &&

package/templates/apps/web/app/[locale]/events/__tests__/program-event.test.tsx

@@ -0,0 +1,120 @@
+/**
+ * #10552 AC-6 — an Event under a program has one URL, `/<program>/<event>`:
+ * `/events/<event>` answers a 308 there, and the /events hub's card links it
+ * directly. An Event with no `parent` keeps `/events/<event>` on both.
+ *
+ * Its own suite: `hub-children.test.tsx` mocks `@working-theory/page-renderer`
+ * whole, so the hub's real cards are not rendered there.
+ */
+import React from "react";
+import { render } from "@testing-library/react";
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+  permanentRedirect: jest.fn((url: string) => {
+    throw new Error(`NEXT_REDIRECT ${url}`);
+  }),
+}));
+
+import { permanentRedirect } from "next/navigation";
+
+import EventsPage from "../page";
+import EventSlugPage from "../[slug]/page";
+
+const mockRedirect = permanentRedirect as jest.MockedFunction<typeof permanentRedirect>;
+
+const event = (slug: string, parent?: string) => ({
+  frontmatter: {
+    type: "Event" as const,
+    slug,
+    title: `Title for ${slug}`,
+    description: `Description for ${slug}.`,
+    ...(parent !== undefined && { parent }),
+  },
+  body: `# Title for ${slug}\n\nBody.`,
+});
+
+const eventsList = {
+  frontmatter: { type: "EventsList" as const, slug: "events", title: "Events", description: "Events." },
+  body: "# Events\n\nBody.",
+};
+
+const events: Record<string, ReturnType<typeof event>> = {
+  "golf-tournament": event("golf-tournament", "younglife"),
+  "annual-summit": event("annual-summit"),
+  "typo-gala": event("typo-gala", "no-such-program"),
+};
+
+const younglife = {
+  frontmatter: { type: "LandingPage" as const, slug: "younglife", title: "Young Life", description: "YL." },
+  body: "",
+};
+
+const getMdxSource = jest.fn(async (type: string, slug: string) =>
+  type === "Event"
+    ? (events[slug] ?? null)
+    : type === "EventsList"
+      ? eventsList
+      : type === "LandingPage" && slug === "younglife"
+        ? younglife
+        : null,
+);
+
+describe("/events/<event> for an Event under a program (#10552 D3)", () => {
+  const savedDefault = process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+  beforeEach(() => {
+    mockRedirect.mockClear();
+    delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+  });
+  afterAll(() => {
+    if (savedDefault === undefined) delete process.env.NEXT_PUBLIC_DEFAULT_LOCALE;
+    else process.env.NEXT_PUBLIC_DEFAULT_LOCALE = savedDefault;
+  });
+
+  it.each([
+    ["en", "/younglife/golf-tournament"],
+    ["es", "/es/younglife/golf-tournament"],
+  ])("answers a 308 to the program URL at %s", async (locale, target) => {
+    await expect(
+      EventSlugPage({ params: Promise.resolve({ locale, slug: "golf-tournament" }), getMdxSource }),
+    ).rejects.toThrow(`NEXT_REDIRECT ${target}`);
+    expect(mockRedirect).toHaveBeenCalledWith(target);
+  });
+
+  it("does not redirect when the parent names no program page", async () => {
+    render(
+      await EventSlugPage({ params: Promise.resolve({ locale: "en", slug: "typo-gala" }), getMdxSource }),
+    );
+    expect(mockRedirect).not.toHaveBeenCalled();
+  });
+
+  it("renders an Event with no parent, with no redirect", async () => {
+    const { container } = render(
+      await EventSlugPage({
+        params: Promise.resolve({ locale: "en", slug: "annual-summit" }),
+        getMdxSource,
+      }),
+    );
+    expect(mockRedirect).not.toHaveBeenCalled();
+    expect(container.querySelector("script[type='application/ld+json']")).not.toBeNull();
+  });
+});
+
+describe("the /events hub's card for an Event under a program (#10552 D5)", () => {
+  it("links the program URL, and /events/<slug> for an Event with no parent", async () => {
+    const { container } = render(
+      await EventsPage({
+        params: Promise.resolve({ locale: "en" }),
+        getMdxSlugs: async () => ["golf-tournament", "annual-summit"],
+        getMdxSource,
+      }),
+    );
+    const hrefs = Array.from(container.querySelectorAll("a")).map((a) => a.getAttribute("href"));
+    expect(hrefs).toContain("/younglife/golf-tournament");
+    expect(hrefs).not.toContain("/events/golf-tournament");
+    expect(hrefs).toContain("/events/annual-summit");
+  });
+});

package/templates/apps/web/app/[locale]/events/page.tsx

@@ -12,6 +12,7 @@ import type { Metadata } from "next";
 import type { ReactElement } from "react";
 
 import { type HubConfig, hubPageInput } from "../../../lib/hub-children";
+import { pagePathFor } from "../../../src/lib/routes";
 
 interface Props {
   params: Promise<{ locale: string }>;
@@ -27,6 +28,16 @@ const HUB: HubConfig = {
   linkLabel: "View the event",
   sectionId: "event-cards",
   body: "mdx-body",
+  // #10552 D5 — an Event under a program links its program URL; the rest is
+  // the default card, byte for byte.
+  card: ({ slug, frontmatter }) => {
+    const fm = frontmatter as { title?: string; description?: string; parent?: string };
+    return {
+      title: fm.title ?? slug,
+      description: fm.description ?? "",
+      link: { label: HUB.linkLabel, href: pagePathFor({ type: "Event", slug, parent: fm.parent }) },
+    };
+  },
 };
 
 export async function generateMetadata({

package/templates/apps/web/app/[locale]/flows/[slug]/FlowStepperClient.tsx

@@ -35,6 +35,13 @@
  * a `thankYou` block, so without this widening the callback would never be
  * supplied on a recommending flow at all.
  *
+ * Per-tier completion redirect (#10616 D4): when a `scoring.tiers[]` entry
+ * carries a `thankYou` slug, the client scores the walk's own answers
+ * (`resolveTierThankYouSlug`) and navigates to the scored tier's
+ * `/thanks/<slug>` AHEAD of the results permalink and the `thankYou` block;
+ * a tier with no slug, or a flow with none, continues exactly as before. The
+ * answers are read to score, never written into the href.
+ *
  * Account link (#8771 D5): when the walk completes on an `invite` magnet (the
  * step response's `next`), the client asks `accountInviteLinkAction` for the
  * sign-in link with the email the visitor gave already filled in, then shows
@@ -92,6 +99,7 @@ import type {
   FlowEndingOutcome,
   FlowState,
   FlowStepDeliverable,
+  WaitlistAnswers,
 } from "@working-theory/validation";
 import {
   deriveFlags,
@@ -107,6 +115,7 @@ import {
   pruneHiddenState,
   resolveLocalizedString,
   resolveThankYouSlug,
+  resolveTierThankYouSlug,
   selectFlowEndingOutcome,
   SITE_CONSENT_CONFIG_DEFAULTS,
   visitorNameOf,
@@ -202,12 +211,21 @@ function segmentationQuestionNames(config: FlowConfig): Set<string> {
 /**
  * #8840 D9 — the answers the ending is chosen from, assembled as the
  * permalink path assembles them: the visible steps' answers flattened, then
- * the hidden segmentation steps' `whenHidden` answers.
+ * the hidden segmentation steps' `whenHidden` answers. Narrowed to the
+ * evaluator's string / string[] shape (#10616), which is all any reader keeps.
  */
-function walkAnswers(config: FlowConfig, state: FlowState): Record<string, unknown> {
+function walkAnswers(config: FlowConfig, state: FlowState): WaitlistAnswers {
   const flags = deriveFlags(config, state);
   const flat = flattenState(pruneHiddenState(config, state, flags));
-  return Object.assign(flat, hiddenAnswers(config, state, flags));
+  const answers: WaitlistAnswers = {};
+  for (const [name, value] of Object.entries(
+    Object.assign(flat, hiddenAnswers(config, state, flags)),
+  )) {
+    if (typeof value === "string" || Array.isArray(value)) {
+      answers[name] = value as string | string[];
+    }
+  }
+  return answers;
 }
 
 export function FlowStepperClient({
@@ -225,6 +243,10 @@ export function FlowStepperClient({
   // client never routes to.
   const isRecommending =
     config.mode === "recommending" && config.offers !== undefined;
+  // #10616 D4 — a flow whose scoring maps at least one tier to a thank-you
+  // page: completion may redirect there, so `onCompleted` is passed.
+  const hasTierThankYou =
+    config.scoring?.tiers.some((tier) => tier.thankYou !== undefined) === true;
 
   // #4770 D1 — the client's own accumulated answers, written from the
   // RESOLVED result of onSubmitStep (never the inbound payload) so a
@@ -427,6 +449,18 @@ export function FlowStepperClient({
     segment?: string;
     aeoScore?: AeoScoreResult;
   }): void {
+    // #10616 D4 — a scored tier's thank-you page wins over the permalink and
+    // the `thankYou` block. Scored from the walk's answers as the server's
+    // completion payload assembles them; no flags are passed (the server
+    // scores with none).
+    if (hasTierThankYou) {
+      const tierSlug = resolveTierThankYouSlug(config, walkAnswers(config, answersRef.current));
+      if (tierSlug !== undefined) {
+        goToThanks(tierSlug);
+        return;
+      }
+    }
+
     if (isRecommending) {
       // D1 (hidden-step pruning) — apply the shipped visibility resolver to
       // the accumulated state before encoding, so an abandoned branch's
@@ -481,7 +515,12 @@ export function FlowStepperClient({
     }
 
     if (!thankYou) return;
-    const thankYouSlug = resolveThankYouSlug(thankYou, result.segment);
+    goToThanks(resolveThankYouSlug(thankYou, result.segment));
+  }
+
+  // The thank-you redirect's tail, shared by the `thankYou` block and a
+  // scored tier's slug (#10616 D4): the invite hand-off, then the push.
+  function goToThanks(thankYouSlug: string): void {
     // #8771 D5 — hand the link to /thanks through the per-tab sessionStorage,
     // never the URL; with no link, clear an earlier walk's so it never shows
     // on this page. A storage that throws gives no link.
@@ -587,7 +626,7 @@ export function FlowStepperClient({
       locale={locale}
       messages={messages}
       onSubmitStep={handleSubmitStep}
-      {...(!endingWins && (thankYou !== undefined || isRecommending)
+      {...(!endingWins && (thankYou !== undefined || isRecommending || hasTierThankYou)
         ? { onCompleted: handleCompleted }
         : {})}
       {...(completedAction !== undefined ? { completedAction } : {})}

package/templates/apps/web/app/[locale]/flows/[slug]/__tests__/FlowStepperClient.thanks-by-tier.test.tsx

@@ -0,0 +1,306 @@
+// oss: false
+/**
+ * Tests for FlowStepperClient's per-tier thank-you redirect on a scored
+ * recommending flow (#10616 D4).
+ *
+ * A SEPARATE file from the six existing `FlowStepperClient.*.test.tsx`
+ * suites, which stay UNEDITED as the AC-4 regression floor. It mocks
+ * `FlowStepper` the way `FlowStepperClient.permalink.test.tsx` does — a stub
+ * that captures the `onSubmitStep`/`onCompleted` props — because this file's
+ * scope is the client's own completion wiring, not the stepper.
+ *
+ * AC-3(b) — a finished walk whose scored tier carries a `thankYou` slug
+ *   pushes exactly `/<locale>/thanks/<slug>`, ahead of the results
+ *   permalink; the URL carries no submitted value, no segmentation answer
+ *   and no session id; an unknown locale falls back to the default.
+ * AC-3(a) — the client scores with EMPTY flags (the server's input), so a
+ *   flag-gated tier never wins even when the walk's own `flags` would set it.
+ * AC-3(c) — a flow with tier slugs but no `thankYou` and no `offers` still
+ *   receives `onCompleted`.
+ * AC-4 — a tier with no slug pushes today's permalink; a `thankYou`-only
+ *   flow pushes `thankYou.default`; an `ending` still wins (no `onCompleted`).
+ */
+import { render } from "@testing-library/react";
+import type { FlowConfig } from "@working-theory/validation";
+import { decodePermalink } from "@working-theory/validation";
+import type { ReactElement } from "react";
+
+const mockPush = jest.fn();
+jest.mock("next/navigation", () => ({
+  useRouter: () => ({ push: mockPush }),
+}));
+
+jest.mock("next-intl", () => ({
+  useTranslations: () => (key: string) => key,
+  useMessages: () => ({}),
+}));
+
+// FlowStepperClient binds onSubmitStep directly to this Server Action, and
+// the boundary under test here is the onCompleted -> router.push wiring, not
+// the action itself (covered by flow.actions.test.ts) — mirrors the sibling
+// suites' identical narrow-scope justification.
+// eslint-disable-next-line no-restricted-syntax -- see comment above
+jest.mock("../flow.actions", () => ({
+  submitFlowStepAction: jest.fn(),
+}));
+
+interface MockFlowStepperProps {
+  onSubmitStep: (payload: {
+    stepKey: string;
+    values: Record<string, unknown>;
+    locale?: string;
+  }) => Promise<{
+    ok: boolean;
+    kind?: string;
+    response?: { completed: boolean; segment?: string };
+  }>;
+  onCompleted?: (result: { segment?: string }) => void;
+}
+
+let captured: MockFlowStepperProps | undefined;
+
+jest.mock("@working-theory/ui-signal-collectors", () => ({
+  FlowStepper: (props: MockFlowStepperProps) => {
+    captured = props;
+    return require("react").createElement("div", {
+      "data-testid": "mock-flow-stepper",
+    }) as ReactElement;
+  },
+}));
+
+import { submitFlowStepAction } from "../flow.actions";
+import { FlowStepperClient } from "../FlowStepperClient";
+
+const mockSubmitFlowStepAction = submitFlowStepAction as jest.MockedFunction<
+  typeof submitFlowStepAction
+>;
+
+const SLUG = "founder-diagnostic";
+const SESSION_ID = "sess-1a2b3c";
+
+type Scoring = NonNullable<FlowConfig["scoring"]>;
+
+const PATH_A_ANSWERS = { revenue: "1m-plus", timing: "now" };
+const PATH_B_ANSWERS = { revenue: "under-500k", timing: "exploring" };
+const PII_PAYLOAD = {
+  email: "jane@example.com",
+  name: "Jane Doe",
+  phone: "555-123-4567",
+  message: "Please reach out about the enterprise plan as soon as possible",
+};
+
+/**
+ * path_a: revenue in the top bands AND timing not "exploring" — a rule over
+ * two answers, which `thankYou.bySegment` cannot express; path_b is the
+ * default. Each tier carries its own ThankYouPage slug.
+ */
+function tierScoring(): Scoring {
+  return {
+    version: 1,
+    points: [
+      {
+        name: "revenue_points",
+        question: "revenue",
+        kind: "optionWeights",
+        weights: { "under-500k": 0, "500k-1m": 1, "1m-plus": 2 },
+      },
+    ],
+    scores: { total: { sum: ["revenue_points"] } },
+    tiers: [
+      {
+        key: "path_a",
+        when: {
+          allOf: [
+            { answer: "revenue", in: ["500k-1m", "1m-plus"] },
+            { not: { answer: "timing", eq: "exploring" } },
+          ],
+        },
+        thankYou: "path-a-thanks",
+      },
+      { key: "path_b", when: { answer: "timing", eq: "exploring" }, thankYou: "path-b-thanks" },
+    ],
+    default: "path_b",
+  };
+}
+
+/** A recommending flow — `offers` plus the scoring above — whose field step
+ * submits an email, a name, a phone number and free text. */
+function scoredFlowConfig(overrides: Partial<FlowConfig> = {}): FlowConfig {
+  return {
+    slug: SLUG,
+    defaultLocale: "en",
+    mode: "recommending",
+    steps: [
+      {
+        key: "fit",
+        type: "segmentation",
+        copy: { title: { en: "Fit" } },
+        questions: [
+          {
+            name: "revenue",
+            options: [
+              { value: "under-500k", label: { en: "Under $500K" } },
+              { value: "500k-1m", label: { en: "$500K–$1M" } },
+              { value: "1m-plus", label: { en: "$1M+" } },
+            ],
+          },
+          {
+            name: "timing",
+            options: [
+              { value: "now", label: { en: "Now" } },
+              { value: "exploring", label: { en: "Just exploring" } },
+            ],
+          },
+        ],
+      },
+      {
+        key: "contact",
+        type: "field",
+        copy: { title: { en: "Contact" } },
+        fields: [
+          { name: "email", inputType: "email", required: true, copy: { label: { en: "Email" } } },
+          { name: "name", inputType: "text", required: true, copy: { label: { en: "Name" } } },
+          { name: "phone", inputType: "tel", copy: { label: { en: "Phone" } } },
+          { name: "message", inputType: "textarea", copy: { label: { en: "Message" } } },
+        ],
+      },
+    ],
+    offers: [
+      {
+        key: "call",
+        copy: { name: { en: "A call" } },
+        price: { kind: "label", label: { en: "Free" } },
+        rules: [{ when: { answer: "revenue", eq: "1m-plus" }, reason: { en: "Ready" } }],
+      },
+    ],
+    scoring: tierScoring(),
+    ...overrides,
+  } as FlowConfig;
+}
+
+/** Render the client, submit the segmentation step then the PII-laden field
+ * step (the second completing the walk), and fire `onCompleted`. */
+async function completeWalk(
+  config: FlowConfig,
+  answers: Record<string, string>,
+  locale = "en",
+): Promise<void> {
+  mockSubmitFlowStepAction
+    .mockResolvedValueOnce({
+      ok: true,
+      response: { sessionId: SESSION_ID, landed: "fit", nextStepKey: "contact", completed: false },
+    })
+    .mockResolvedValueOnce({
+      ok: true,
+      response: { sessionId: SESSION_ID, landed: "contact", nextStepKey: null, completed: true },
+    });
+
+  render(<FlowStepperClient config={config} locale={locale} slug={SLUG} />);
+
+  await captured!.onSubmitStep({ stepKey: "fit", values: answers, locale });
+  await captured!.onSubmitStep({ stepKey: "contact", values: PII_PAYLOAD, locale });
+  captured!.onCompleted?.({});
+}
+
+function pushedUrl(): string {
+  expect(mockPush).toHaveBeenCalledTimes(1);
+  return mockPush.mock.calls[0]?.[0] as string;
+}
+
+beforeEach(() => {
+  mockPush.mockClear();
+  mockSubmitFlowStepAction.mockClear();
+  captured = undefined;
+  window.sessionStorage.clear();
+});
+
+describe("FlowStepperClient — a scored tier's thank-you page replaces the permalink (#10616 AC-3(b))", () => {
+  it("path-A answers push exactly /en/thanks/path-a-thanks", async () => {
+    await completeWalk(scoredFlowConfig(), PATH_A_ANSWERS);
+    expect(pushedUrl()).toBe("/en/thanks/path-a-thanks");
+  });
+
+  it("path-B answers push exactly /en/thanks/path-b-thanks", async () => {
+    await completeWalk(scoredFlowConfig(), PATH_B_ANSWERS);
+    expect(pushedUrl()).toBe("/en/thanks/path-b-thanks");
+  });
+
+  it("the pushed URL carries no submitted value, no segmentation answer and no session id", async () => {
+    await completeWalk(scoredFlowConfig(), PATH_A_ANSWERS);
+    // The PII reached onSubmitStep (the wiring forwards real form data) —
+    // the assertion is that none of it reaches the push.
+    expect(mockSubmitFlowStepAction).toHaveBeenCalledWith(
+      SLUG,
+      expect.objectContaining({ values: PII_PAYLOAD }),
+    );
+    const url = pushedUrl();
+    expect(url).toMatch(/^\/[A-Za-z-]+\/thanks\/[a-z0-9-]+$/);
+    for (const value of [
+      ...Object.values(PII_PAYLOAD),
+      ...Object.values(PATH_A_ANSWERS),
+      SESSION_ID,
+    ]) {
+      expect(url).not.toContain(value);
+    }
+  });
+
+  it("an unknown [locale] falls back to the default locale before interpolation", async () => {
+    await completeWalk(scoredFlowConfig(), PATH_A_ANSWERS, "xx");
+    expect(pushedUrl()).toBe("/en/thanks/path-a-thanks");
+  });
+});
+
+describe("FlowStepperClient — the client scores with the server's empty flags (#10616 AC-3(a))", () => {
+  it("a flag-gated first tier never wins, even when the walk's own flags would set it", async () => {
+    const scoring = tierScoring();
+    scoring.tiers = [
+      { key: "flagged", when: { flag: "pre_launch" }, thankYou: "flagged-thanks" },
+      { key: "path_b", when: { answer: "timing", eq: "exploring" }, thankYou: "path-b-thanks" },
+    ];
+    const config = scoredFlowConfig({
+      flags: [{ name: "pre_launch", when: { answer: "timing", eq: "now" } }],
+      scoring,
+    });
+    await completeWalk(config, PATH_A_ANSWERS);
+    expect(pushedUrl()).toBe("/en/thanks/path-b-thanks");
+  });
+});
+
+describe("FlowStepperClient — onCompleted is supplied for a flow with tier slugs alone (#10616 AC-3(c))", () => {
+  it("mode recommending with scoring, no offers and no thankYou still receives onCompleted", () => {
+    const { offers: _offers, ...noOffers } = scoredFlowConfig();
+    render(<FlowStepperClient config={noOffers as FlowConfig} locale="en" slug={SLUG} />);
+    expect(captured?.onCompleted).toBeDefined();
+  });
+});
+
+describe("FlowStepperClient — no mapping is today's behavior (#10616 AC-4)", () => {
+  it("(a) a tier with no slug pushes the results permalink, decodable to the segmentation answers", async () => {
+    const scoring = tierScoring();
+    delete scoring.tiers[1]!.thankYou;
+    await completeWalk(scoredFlowConfig({ scoring }), PATH_B_ANSWERS);
+
+    const match = pushedUrl().match(new RegExp(`^/en/flows/${SLUG}/results/(.+)$`));
+    expect(match).not.toBeNull();
+    const decoded = decodePermalink(match![1]!);
+    expect(decoded.ok).toBe(true);
+    if (!decoded.ok) return;
+    expect(decoded.value.flowSlug).toBe(SLUG);
+    expect(decoded.value.answers).toEqual(PATH_B_ANSWERS);
+  });
+
+  it("(b) a thankYou-only flow with no scoring pushes thankYou.default", async () => {
+    const { mode: _mode, offers: _offers, scoring: _scoring, ...plain } = scoredFlowConfig();
+    const config = { ...plain, thankYou: { default: "flow-thanks" } } as FlowConfig;
+    await completeWalk(config, PATH_A_ANSWERS);
+    expect(pushedUrl()).toBe("/en/thanks/flow-thanks");
+  });
+
+  it("(c) a flow with an ending and tier slugs is passed no onCompleted", () => {
+    const config = scoredFlowConfig({
+      ending: { default: { kind: "screen", headline: { en: "Thanks" } } },
+    } as Partial<FlowConfig>);
+    render(<FlowStepperClient config={config} locale="en" slug={SLUG} />);
+    expect(captured?.onCompleted).toBeUndefined();
+  });
+});