create-ailk 0.20.0 → 0.21.0

package/templates/apps/web/lib/__tests__/deck-page.test.ts

@@ -0,0 +1,244 @@
+/**
+ * The deck-page resolver (#8687 D3, AC-2).
+ *
+ * `deckCandidates` and the `DECK_ROUTES` parity are pure functions over the
+ * real routes map. `resolveDeckPage` and `inputsFor` (captured off the
+ * `setDeckPages` registration call) are exercised with `getMdxSource` and
+ * `next/headers` mocked, in `renderPage-extension.test.tsx`'s idiom.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+import { ROUTES } from "@working-theory/templates/routes";
+
+const mockGetMdxSource = jest.fn();
+const mockSetDeckPages = jest.fn();
+
+jest.mock("@working-theory/page-renderer", () => {
+  const actual = jest.requireActual("@working-theory/page-renderer");
+  return {
+    ...actual,
+    getMdxSource: (...args: unknown[]) => mockGetMdxSource(...args),
+    setDeckPages: (...args: unknown[]) => mockSetDeckPages(...args),
+  };
+});
+
+const mockHeaders = jest.fn();
+jest.mock("next/headers", () => ({ headers: () => mockHeaders() }));
+
+const savedLocales = process.env["NEXT_PUBLIC_ENABLED_LOCALES"];
+
+beforeAll(() => {
+  process.env["NEXT_PUBLIC_ENABLED_LOCALES"] = "en,es";
+});
+afterAll(() => {
+  if (savedLocales === undefined) delete process.env["NEXT_PUBLIC_ENABLED_LOCALES"];
+  else process.env["NEXT_PUBLIC_ENABLED_LOCALES"] = savedLocales;
+});
+
+import { DECK_ROUTES, deckCandidates, resolveDeckPage } from "../deck-page";
+import { siteChrome } from "../site-chrome";
+
+describe("deckCandidates (#8687 D3, AC-2)", () => {
+  const LOCALES = ["en", "es"];
+
+  it("/pricing resolves the route row, then the [slug] fallback", () => {
+    expect(deckCandidates("/pricing", LOCALES)).toEqual([
+      { type: "Pricing", slug: "pricing" },
+      { type: "LandingPage", slug: "pricing" },
+      { type: "BlogList", slug: "pricing" },
+    ]);
+  });
+
+  it("/about (core, always scaffolded) resolves the route row only", () => {
+    expect(deckCandidates("/about", LOCALES)).toEqual([
+      { type: "AboutPage", slug: "about" },
+    ]);
+  });
+
+  it("/es/offer/ (no route match) falls through to [slug] alone", () => {
+    expect(deckCandidates("/es/offer/", LOCALES)).toEqual([
+      { type: "LandingPage", slug: "offer" },
+      { type: "BlogList", slug: "offer" },
+    ]);
+  });
+
+  it("/projects/apollo resolves the detail row's directory type", () => {
+    expect(deckCandidates("/projects/apollo", LOCALES)).toEqual([
+      { type: "Project", slug: "apollo" },
+    ]);
+  });
+
+  it("/careers (gateable, no DECK_ROUTES entry) falls through to [slug]", () => {
+    expect(deckCandidates("/careers", LOCALES)).toEqual([
+      { type: "LandingPage", slug: "careers" },
+      { type: "BlogList", slug: "careers" },
+    ]);
+  });
+
+  it.each(["/", "/software", "/sign-in", "/blog/post", "/edit/LandingPage/x", "/a/b"])(
+    "%s resolves no candidates",
+    (pathname) => {
+      expect(deckCandidates(pathname, LOCALES)).toEqual([]);
+    },
+  );
+});
+
+describe("DECK_ROUTES parity (#8687 D3)", () => {
+  it("contains every routes-map row with seed content whose page.tsx renders sections, minus /", () => {
+    // DECK_ROUTES is a fixed superset, not a per-scaffold exact set: a shape
+    // that doesn't ship one of these routes (e.g. a Free scaffold without
+    // /alternatives) simply has no page.tsx there, so deckCandidates/
+    // resolveDeckPage never get a request for it (harmless). What would be a
+    // real bug is the OTHER direction — an actually-shipped sections route
+    // this build's own tree carries that DECK_ROUTES fails to name.
+    const appRoot = path.join(__dirname, "..", "..", "app", "[locale]");
+    const sectionsRoutes = new Set<string>();
+    for (const row of ROUTES) {
+      if (row.route === "/" || !row.contentPath?.startsWith("content/en/")) continue;
+      const dir = row.route
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => (segment.startsWith(":") ? "[slug]" : segment))
+        .join("/");
+      let pageSource: string;
+      try {
+        pageSource = readFileSync(path.join(appRoot, dir, "page.tsx"), "utf8");
+      } catch {
+        continue;
+      }
+      if (!pageSource.includes('bodyMode: "mdx-body"')) {
+        sectionsRoutes.add(row.route);
+      }
+    }
+    const deckRoutesSet = new Set<string>(DECK_ROUTES);
+    const missing = [...sectionsRoutes].filter((route) => !deckRoutesSet.has(route));
+    expect(missing).toEqual([]);
+  });
+});
+
+describe("resolveDeckPage (#8687 D3, AC-2)", () => {
+  beforeEach(() => {
+    mockGetMdxSource.mockReset();
+  });
+
+  it("returns the first candidate with a source", async () => {
+    mockGetMdxSource.mockImplementation((type: string) =>
+      Promise.resolve(
+        type === "LandingPage"
+          ? null
+          : type === "BlogList"
+            ? { frontmatter: { type: "BlogList", slug: "offer" }, body: "" }
+            : null,
+      ),
+    );
+
+    const result = await resolveDeckPage("/es/offer/", "en");
+
+    expect(result).toEqual({
+      type: "BlogList",
+      slug: "offer",
+      frontmatter: { type: "BlogList", slug: "offer" },
+    });
+  });
+
+  it("returns null when a read throws", async () => {
+    mockGetMdxSource.mockRejectedValue(new Error("read failed"));
+
+    expect(await resolveDeckPage("/pricing", "en")).toBeNull();
+  });
+
+  it("returns null for a path with no candidates, with zero getMdxSource calls (NFR 2)", async () => {
+    expect(await resolveDeckPage("/software", "en")).toBeNull();
+    expect(mockGetMdxSource).not.toHaveBeenCalled();
+  });
+});
+
+describe("the registered inputsFor (#8687 D3, AC-2)", () => {
+  beforeEach(() => {
+    mockGetMdxSource.mockReset();
+    mockHeaders.mockReset();
+  });
+
+  function registeredInputsFor(): (ctx: {
+    type: string;
+    slug: string;
+    locale: string;
+  }) => Promise<unknown> {
+    const call = mockSetDeckPages.mock.calls[mockSetDeckPages.mock.calls.length - 1];
+    return (
+      call?.[0] as {
+        inputsFor: (ctx: { type: string; slug: string; locale: string }) => Promise<unknown>;
+      }
+    ).inputsFor;
+  }
+
+  it("resolves the design's inputs when the resolved page matches and opts in", async () => {
+    mockHeaders.mockResolvedValue(new Map([["x-pathname", "/pricing"]]));
+    mockGetMdxSource.mockImplementation((type: string) =>
+      Promise.resolve(
+        type === "Pricing"
+          ? null
+          : type === "LandingPage"
+            ? { frontmatter: { type: "LandingPage", slug: "pricing", layout: "deck" }, body: "" }
+            : null,
+      ),
+    );
+
+    const result = await registeredInputsFor()({
+      type: "LandingPage",
+      slug: "pricing",
+      locale: "en",
+    });
+
+    // The scaffold's generated site-chrome carries the DESIGN's values — minimalism
+    // presents the deck (deckPresentation true), standard does not — so the expected
+    // inputs are read from it rather than hard-coded to one design.
+    const chrome = siteChrome as typeof siteChrome & {
+      deckGrounds?: unknown;
+      deckPresentation?: true;
+    };
+    expect(result).toEqual({
+      ...(chrome.deckGrounds !== undefined ? { deckGrounds: chrome.deckGrounds } : {}),
+      deckPresentation: chrome.deckPresentation === true,
+    });
+  });
+
+  it("returns null when the resolved page does not match this render", async () => {
+    mockHeaders.mockResolvedValue(new Map([["x-pathname", "/pricing"]]));
+    mockGetMdxSource.mockResolvedValue(
+      { frontmatter: { type: "Pricing", slug: "pricing" }, body: "" },
+    );
+
+    const result = await registeredInputsFor()({
+      type: "Pricing",
+      slug: "pricing",
+      locale: "en",
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it("returns null for a resolved page without the field", async () => {
+    mockHeaders.mockResolvedValue(new Map([["x-pathname", "/pricing"]]));
+    mockGetMdxSource.mockImplementation((type: string) =>
+      Promise.resolve(
+        type === "LandingPage"
+          ? { frontmatter: { type: "LandingPage", slug: "pricing" }, body: "" }
+          : null,
+      ),
+    );
+
+    expect(
+      await registeredInputsFor()({ type: "LandingPage", slug: "pricing", locale: "en" }),
+    ).toBeNull();
+  });
+
+  it("returns null with no x-pathname header", async () => {
+    mockHeaders.mockResolvedValue(new Map());
+
+    expect(
+      await registeredInputsFor()({ type: "LandingPage", slug: "pricing", locale: "en" }),
+    ).toBeNull();
+  });
+});

package/templates/apps/web/lib/__tests__/structured-data.test.tsx

@@ -240,10 +240,12 @@ describe("structured data — every content page builds valid JSON-LD", () => {
     "content/$locale/$typeDir — every page validates as its type",
     async ({ locale, typeDir }) => {
       if (!(SCHEMA_ORG_TYPES as readonly string[]).includes(typeDir)) {
-        // Identity + sub-entity types (Organization, Person, BreadcrumbList,
+        // Identity + sub-entity types (Organization, BreadcrumbList,
         // ContactPoint) hold sub-objects other pages' builders embed — never
         // rendered as pages, and skipped by tools/content-compile the same
-        // way. Anything else is a directory nothing will ever render.
+        // way. Anything else is a directory nothing will ever render. Person
+        // (#8650) is a registered page type (`/about/<slug>`), so it is
+        // covered by the SCHEMA_ORG_TYPES branch above, not this one.
         if (!knownSchemaOrgTypes.has(typeDir)) {
           throw new Error(
             `content/${locale}/${typeDir}: "${typeDir}" is not a registered page type — no route or builder will ever render it (see packages/content-adapters/src/types.ts SCHEMA_ORG_TYPES)`,

package/templates/apps/web/lib/deck-page.ts

@@ -0,0 +1,186 @@
+/**
+ * The deck-page resolver (#8687 D3) — the layout's question ("does the page
+ * at this path opt in?") and `renderPage`'s consult both ask this ONE
+ * resolver, so they always agree. Registers with `@working-theory/page-renderer`
+ * at module load, in `lib/site-identity.ts`'s precedent: `app/[locale]/layout.tsx`
+ * imports this module, and Next.js evaluates a layout module before any page
+ * under it renders.
+ */
+import {
+  getMdxSource as defaultGetMdxSource,
+  optsIntoDeck,
+  setDeckPages,
+  type DeckPageContext,
+  type DeckPageInputs,
+  type SchemaOrgType,
+} from "@working-theory/page-renderer";
+import { ROUTES, type RouteRow } from "@working-theory/templates/routes";
+import { readLocales } from "@working-theory/web-i18n";
+import { headers } from "next/headers";
+import { cache } from "react";
+
+import { normalizeRoutePath } from "./closing-footer-path";
+import { siteChrome, type SiteChrome } from "./site-chrome";
+
+/**
+ * The routes besides `[slug]` whose page can present as a deck: every
+ * routes-map row with seed content whose route renders sections, minus `/`.
+ *
+ * This is a fixed superset across every shape/level a scaffold can ship,
+ * not a per-site exact list: a shape that doesn't carry one of these routes
+ * (e.g. a Free scaffold without `/alternatives`) has no `page.tsx` there, so
+ * `deckCandidates`/`resolveDeckPage` never get a request for that path —
+ * harmless. `apps/web/lib/__tests__/deck-page.test.ts`'s parity case checks
+ * the direction that would be a real bug: that this list names every
+ * sections route THIS build's own tree actually carries.
+ */
+export const DECK_ROUTES = [
+  "/about",
+  "/alternatives",
+  "/contact",
+  "/faq",
+  "/launch-service",
+  "/pricing",
+  "/privacy",
+  "/projects",
+  "/projects/:slug",
+  "/purchase-policy",
+  "/reports",
+  "/terms",
+  "/thanks/:slug",
+  "/working-agreement",
+] as const;
+
+/** The widened type (#7719 D3, #7740 D8): present only when the design sets it. */
+type Chrome = SiteChrome & {
+  deckGrounds?: DeckPageInputs["deckGrounds"];
+  deckPresentation?: true;
+};
+const chrome: Chrome = siteChrome;
+
+function routeSegments(route: string): string[] {
+  return route.split("/").filter((segment) => segment.length > 0);
+}
+
+function matchesRoute(routeDef: string, pathSegments: readonly string[]): boolean {
+  const defSegments = routeSegments(routeDef);
+  if (defSegments.length !== pathSegments.length) return false;
+  return defSegments.every(
+    (segment, i) => segment.startsWith(":") || segment === pathSegments[i],
+  );
+}
+
+/** The type and slug a matched routes-map row resolves to for this request. */
+function resolveTypeAndSlug(
+  row: RouteRow,
+  routeDef: string,
+  pathSegments: readonly string[],
+): { type: SchemaOrgType; slug: string } | null {
+  if (row.contentPath === undefined) return null;
+  const parts = row.contentPath.split("/");
+  const last = parts[parts.length - 1];
+  if (last === undefined) return null;
+  const isFile = last.endsWith(".mdx");
+  const type = isFile ? parts[parts.length - 2] : last;
+  if (type === undefined) return null;
+  const slug = isFile
+    ? last.replace(/\.mdx$/, "")
+    : pathSegments[routeSegments(routeDef).findIndex((segment) => segment.startsWith(":"))];
+  if (slug === undefined) return null;
+  return { type: type as SchemaOrgType, slug };
+}
+
+/** Whether a routes-map row at this exact route is always scaffolded (never absent from a site). */
+function isAlwaysScaffolded(path: string): boolean {
+  const row = ROUTES.find((candidate) => candidate.route === path);
+  return row !== undefined && row.gateable !== true && row.module === "marketing";
+}
+
+/**
+ * The content pages that could serve `pathname`, in the order Next.js tries
+ * them (D3). `/` gives none — the home's deck is its own `layout.home` knob,
+ * never this resolver's.
+ */
+export function deckCandidates(
+  pathname: string,
+  locales: readonly string[],
+): Array<{ type: SchemaOrgType; slug: string }> {
+  const path = normalizeRoutePath(pathname, locales);
+  if (path === "/") return [];
+  const segments = routeSegments(path);
+  const candidates: Array<{ type: SchemaOrgType; slug: string }> = [];
+
+  for (const routeDef of DECK_ROUTES) {
+    if (!matchesRoute(routeDef, segments)) continue;
+    const row = ROUTES.find((candidate) => candidate.route === routeDef);
+    const resolved = row && resolveTypeAndSlug(row, routeDef, segments);
+    if (resolved) candidates.push(resolved);
+    break;
+  }
+
+  // A one-segment path not always scaffolded falls through to `[slug]`,
+  // which serves `LandingPage` then `BlogList` (D3).
+  if (segments.length === 1 && !isAlwaysScaffolded(path)) {
+    const slug = segments[0];
+    if (slug !== undefined) {
+      candidates.push({ type: "LandingPage", slug });
+      candidates.push({ type: "BlogList", slug });
+    }
+  }
+
+  return candidates;
+}
+
+/**
+ * The first candidate with a source, and its frontmatter, or `null`. A read
+ * that throws ends the walk as `null` (NFR 3) — the page's own render
+ * surfaces that error, and the layout keeps its plain shell. Per-request
+ * memoised (React `cache`) — the layout and `renderPage`'s consult ask the
+ * same question for the same request and must share one answer.
+ */
+export const resolveDeckPage = cache(async function resolveDeckPage(
+  pathname: string,
+  locale: string,
+): Promise<{ type: SchemaOrgType; slug: string; frontmatter: Record<string, unknown> } | null> {
+  for (const candidate of deckCandidates(pathname, readLocales())) {
+    let source;
+    try {
+      source = await defaultGetMdxSource(candidate.type, candidate.slug, locale);
+    } catch {
+      return null;
+    }
+    if (source) return { ...candidate, frontmatter: source.frontmatter };
+  }
+  return null;
+});
+
+/** The layout's question: does the page at this path opt in? */
+export async function pageOptsIntoDeck(input: {
+  pathname: string;
+  locale: string;
+}): Promise<boolean> {
+  const resolved = await resolveDeckPage(input.pathname, input.locale);
+  return resolved !== null && optsIntoDeck(resolved.frontmatter);
+}
+
+/** `inputsFor`: only when this render IS the page the request path resolves to and it opts in. */
+async function inputsFor(ctx: DeckPageContext): Promise<DeckPageInputs | null> {
+  const headerStore = await headers();
+  const pathname = headerStore.get("x-pathname") ?? null;
+  if (pathname === null) return null;
+  const resolved = await resolveDeckPage(pathname, ctx.locale);
+  if (
+    resolved === null ||
+    resolved.type !== ctx.type ||
+    resolved.slug !== ctx.slug ||
+    !optsIntoDeck(resolved.frontmatter)
+  ) {
+    return null;
+  }
+  return {
+    ...(chrome.deckGrounds !== undefined ? { deckGrounds: chrome.deckGrounds } : {}),
+    deckPresentation: chrome.deckPresentation === true,
+  };
+}
+
+setDeckPages({ inputsFor });

package/templates/apps/web/messages/en.json

@@ -73,12 +73,19 @@
   },
   "about": {
     "heading": "About",
-    "emptyState": "About page content coming soon."
+    "emptyState": "About page content coming soon.",
+    "viewProfile": "View profile"
   },
   "blog": {
     "heading": "Blog",
     "emptyState": "No posts yet. Drop MDX files into",
-    "emptyStateTrailing": "to populate this list."
+    "emptyStateTrailing": "to populate this list.",
+    "allTopics": "All",
+    "topicsNav": "Blog topics",
+    "latestPosts": "Latest posts",
+    "previousPosts": "Previous posts",
+    "readMore": "Read more",
+    "sidebar": "More from this site"
   },
   "docs": {
     "heading": "Docs",
@@ -118,7 +125,8 @@
     "sending": "Sending…",
     "sendMessage": "Send message",
     "successMessage": "Thank you for reaching out! We will be in touch shortly.",
-    "consentStatement": "I accept the [Terms](terms).",
+    "consentStatement": "I accept the [Terms](terms), [Privacy Policy](privacy), and [Working Agreement](working_agreement).",
+    "consentRequired": "Please accept the terms to send your message.",
     "genericError": "Something went wrong, please try again.",
     "unavailableHeading": "Get in touch",
     "unavailableBody": "Email us at {email} and we'll reply.",
@@ -317,9 +325,8 @@
     "emptyState": "Resources listing coming soon."
   },
   "schedule": {
-    "title": "Book a call",
+    "heading": "Book time with me",
     "description": "Pick a time that works for you.",
-    "eyebrow": "Book a call",
     "headline": "Pick a time that works",
     "confirmed": {
       "title": "You're booked",
@@ -352,6 +359,10 @@
     "heading": "Terms of Service",
     "emptyState": "Terms of service content coming soon."
   },
+  "workingAgreement": {
+    "heading": "Working Agreement",
+    "emptyState": "Working agreement content coming soon."
+  },
   "testimonials": {
     "heading": "Testimonials",
     "emptyState": "Testimonials coming soon."

package/templates/database/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @working-theory/database
 
+## 0.42.0
+
+### Patch Changes
+
+- [#8740](https://github.com/Working-Theory-Labs/ai-launch-kit-internal/pull/8740) [`d1461bf`](https://github.com/Working-Theory-Labs/ai-launch-kit-internal/commit/d1461bff10a69aa4cf05627e393bd1902c358b00) Thanks [@samuelhenry](https://github.com/samuelhenry)! - The database seed writes the default workspace's Contact form magnet ([#8661](https://github.com/working-theory-labs/ai-launch-kit-internal/issues/8661)): one live contact-kind magnet at slug `contact`, insert-only, so `/contact` reads it on a freshly seeded site.
+
+- Updated dependencies [[`cb2f3a5`](https://github.com/Working-Theory-Labs/ai-launch-kit-internal/commit/cb2f3a50c38fe77b92aa52d1462d3d11a5981981), [`425e253`](https://github.com/Working-Theory-Labs/ai-launch-kit-internal/commit/425e2538dfd22dfb6f0b6439d473fa2aafcbb883), [`da9253b`](https://github.com/Working-Theory-Labs/ai-launch-kit-internal/commit/da9253bb6f8c792e7e75cfe1c1a7bba5ca569e26), [`df1b8e4`](https://github.com/Working-Theory-Labs/ai-launch-kit-internal/commit/df1b8e485f9cdd1885925430b7aaa186ffdf6ac1), [`d4e0598`](https://github.com/Working-Theory-Labs/ai-launch-kit-internal/commit/d4e0598c7659d9349bd56ba184e4ab941e3fde62)]:
+  - @working-theory/validation@0.42.0
+
 ## 0.41.0
 
 ### Minor Changes

package/templates/database/__tests__/seed.test.ts

@@ -11,6 +11,8 @@
  */
 
 import {
+  CONTACT_FORM_FLOW_SLUG,
+  contactFormFlowConfig,
   REQUEST_QUOTE_FLOW_SLUG,
   REQUEST_QUOTE_FLOW_TITLE,
   requestQuoteFlowConfig,
@@ -107,8 +109,8 @@ describe("provisionDefaultWorkspace — the request-quote magnet (#8168 D8, C4,
 
     await provisionDefaultWorkspace(prisma);
 
-    expect(flowDefinitionUpsert).toHaveBeenCalledTimes(1);
-    expect(flowDefinitionUpsert).toHaveBeenCalledWith({
+    expect(flowDefinitionUpsert).toHaveBeenCalledTimes(2);
+    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(1, {
       where: {
         siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: REQUEST_QUOTE_FLOW_SLUG },
       },
@@ -138,3 +140,38 @@ describe("provisionDefaultWorkspace — the request-quote magnet (#8168 D8, C4,
     expect(flowDefinitionUpsert).not.toHaveBeenCalled();
   });
 });
+
+describe("provisionDefaultWorkspace — the Contact form magnet (#8661 D3, AC-1)", () => {
+  it("upserts the default workspace's live Contact form, insert-if-absent", async () => {
+    const { prisma, flowDefinitionUpsert } = makeStubPrisma(0);
+
+    await provisionDefaultWorkspace(prisma);
+
+    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(2, {
+      where: {
+        siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: CONTACT_FORM_FLOW_SLUG },
+      },
+      create: {
+        siteId: DEFAULT_WORKSPACE_ID,
+        workspaceId: DEFAULT_WORKSPACE_ID,
+        slug: "contact",
+        config: contactFormFlowConfig,
+        kind: "contact",
+        title: "Contact form",
+        status: "live",
+        customersEnabled: false,
+        landingPage: "/contact",
+      },
+      // Empty: a re-run never overwrites the owner's edits.
+      update: {},
+    });
+  });
+
+  it("makes no flowDefinition call when a workspace already exists", async () => {
+    const { prisma, flowDefinitionUpsert } = makeStubPrisma(1);
+
+    await provisionDefaultWorkspace(prisma);
+
+    expect(flowDefinitionUpsert).not.toHaveBeenCalled();
+  });
+});

package/templates/database/jest.config.cjs

@@ -1,5 +1,6 @@
 module.exports = {
   preset: "ts-jest",
+  globalSetup: require.resolve("../tools/jest/pin-timezone.cjs"),
   testEnvironment: "node",
   roots: ["<rootDir>"],
   testMatch: ["**/__tests__/**/*.test.ts"],

package/templates/database/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@working-theory/database",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"

package/templates/database/seed.ts

@@ -26,6 +26,10 @@ import "dotenv/config";
 import { basename } from "node:path";
 
 import {
+  CONTACT_FORM_FLOW_SLUG,
+  CONTACT_FORM_FLOW_TITLE,
+  CONTACT_FORM_LANDING_PAGE,
+  contactFormFlowConfig,
   REQUEST_QUOTE_FLOW_SLUG,
   REQUEST_QUOTE_FLOW_TITLE,
   requestQuoteFlowConfig,
@@ -74,6 +78,10 @@ export type DefaultWorkspacePrismaClient = Pick<
  * backfill finds no workspace and seeds nothing; this is where the default
  * workspace's magnet comes from. Insert-if-absent: an `upsert` with an empty
  * `update`, so an existing `(site_id, slug)` row is never overwritten.
+ *
+ * #8661 D3 — and its live Contact form magnet, the same way. An existing
+ * deployment (a workspace already present) gets its row from the seed-presets
+ * CLI instead.
  */
 export async function provisionDefaultWorkspace(
   prisma: DefaultWorkspacePrismaClient,
@@ -129,6 +137,27 @@ export async function provisionDefaultWorkspace(
     update: {},
   });
 
+  await prisma.flowDefinition.upsert({
+    where: {
+      siteId_slug: {
+        siteId: DEFAULT_WORKSPACE_ID,
+        slug: CONTACT_FORM_FLOW_SLUG,
+      },
+    },
+    create: {
+      siteId: DEFAULT_WORKSPACE_ID,
+      workspaceId: DEFAULT_WORKSPACE_ID,
+      slug: CONTACT_FORM_FLOW_SLUG,
+      config: contactFormFlowConfig,
+      kind: "contact",
+      title: CONTACT_FORM_FLOW_TITLE,
+      status: "live",
+      customersEnabled: false,
+      landingPage: CONTACT_FORM_LANDING_PAGE,
+    },
+    update: {},
+  });
+
   return { created: true };
 }
 

package/templates/tools/jest/pin-timezone.cjs

@@ -0,0 +1,34 @@
+"use strict";
+/* global process */
+
+/**
+ * Shared Jest `globalSetup` — pins every jest run in the workspace to one
+ * timezone (#8657).
+ *
+ * Jest otherwise inherits the developer's `TZ`, so a test that renders a date
+ * in local time (`formatDate`, `toLocaleDateString`, `getDate()`) passes in CI,
+ * which runs in UTC, and fails on a laptop that does not: the #8578 shape,
+ * where UTC-midnight consent fixtures rendered the previous day on an MDT
+ * machine and failed 11 release-check rows.
+ *
+ * WHY `globalSetup` AND NOT `setupFiles`: a setup file runs inside the test
+ * sandbox, whose `process.env` is jest's copy of the real one, so assigning
+ * `TZ` there never reaches the process clock. `globalSetup` runs in jest's
+ * parent process before any worker is spawned: the workers inherit the pinned
+ * `TZ`, and Node re-reads an assigned `process.env.TZ` at once, so an in-band
+ * run (`--runInBand`, a single test file) is pinned in place too.
+ *
+ * Every committed `jest.config.cjs` loads this file; the guard is
+ * `tests/architecture/jest-timezone-pin.test.ts`, and the value is documented
+ * in CONVENTIONS.md § Testing. A test that needs another zone formats with an
+ * explicit `timeZone` option rather than changing `TZ`. The create-ailk
+ * scaffold ships this file at the same path (`SNAPSHOT_FILES` in
+ * packages/create-ailk/scripts/build-templates.mjs), so its copied configs
+ * load it unchanged.
+ */
+const PINNED_TZ = "UTC";
+
+module.exports = async function pinTimezone() {
+  process.env.TZ = PINNED_TZ;
+};
+module.exports.PINNED_TZ = PINNED_TZ;