Initial commit

2026-07-12 08:15:46 +00:00
commit ee0fec0691
1397 changed files with 127242 additions and 0 deletions
--- a/packages/marketing-pages/src/contracts/pages-repository.contract.ts
+++ b/packages/marketing-pages/src/contracts/pages-repository.contract.ts
@@ -0,0 +1,122 @@
+import { it, expect, beforeEach, describe } from "vitest";
+import { defineContractSuite } from "@repo/core-testing/contract";
+import type { IPagesRepository } from "../application/repositories/pages.repository.interface";
+import type { Page } from "../entities/models/page";
+
+const SEED_DATE = new Date("2026-01-01T00:00:00.000Z");
+
+/**
+ * Known fixtures that every implementation's `buildSubject` must pre-seed.
+ * Exported so that test files can pass them to `MockPagesRepository` or the
+ * Payload stub without duplicating definitions.
+ */
+export const CONTRACT_PAGES_SEED: Page[] = [
+  {
+    id: "cp-1",
+    title: "About",
+    slug: "about",
+    hero: { heading: "About us" },
+    layout: [],
+    status: "published",
+    publishedAt: SEED_DATE,
+    seo: { title: "About — Site" },
+    createdAt: SEED_DATE,
+    updatedAt: SEED_DATE,
+  },
+  {
+    id: "cp-2",
+    title: "Draft Page",
+    slug: "draft-page",
+    hero: { heading: "Draft" },
+    layout: [],
+    status: "draft",
+    publishedAt: null,
+    seo: { title: "Draft — Site" },
+    createdAt: SEED_DATE,
+    updatedAt: SEED_DATE,
+  },
+];
+
+/**
+ * Contract for IPagesRepository.
+ *
+ * IPagesRepository is read-only (no createPage). Each `buildSubject`
+ * must return a repo pre-loaded with CONTRACT_PAGES_SEED (two pages:
+ * one published with slug "about", one draft with slug "draft-page").
+ */
+export const pagesRepositoryContract = defineContractSuite<IPagesRepository>(
+  "IPagesRepository",
+  ({ buildSubject, getTracer }) => {
+    let repo: IPagesRepository;
+
+    beforeEach(async () => {
+      repo = await buildSubject();
+    });
+
+    // --- getPageBySlug ---
+
+    it("getPageBySlug returns the published page by slug", async () => {
+      const result = await repo.getPageBySlug("about");
+      expect(result).toBeDefined();
+      expect(result?.slug).toBe("about");
+      expect(result?.status).toBe("published");
+      expect(result?.id).toBeDefined();
+    });
+
+    it("getPageBySlug returns undefined for an unknown slug", async () => {
+      expect(await repo.getPageBySlug("no-such-page")).toBeUndefined();
+    });
+
+    // --- getPages ---
+
+    it("getPages with no filter returns all seeded pages", async () => {
+      const list = await repo.getPages();
+      expect(list).toHaveLength(2);
+      for (const page of list) {
+        expect(page.id).toBeDefined();
+        expect(page.slug).toBeDefined();
+        expect(["draft", "published"]).toContain(page.status);
+      }
+    });
+
+    it("getPages({ status: 'published' }) returns only published pages", async () => {
+      const published = await repo.getPages({ status: "published" });
+      expect(published).toHaveLength(1);
+      for (const page of published) {
+        expect(page.status).toBe("published");
+      }
+    });
+
+    it("getPages({ status: 'draft' }) returns only draft pages", async () => {
+      const drafts = await repo.getPages({ status: "draft" });
+      expect(drafts).toHaveLength(1);
+      for (const page of drafts) {
+        expect(page.status).toBe("draft");
+      }
+    });
+
+    describe("span emission", () => {
+      it("getPageBySlug emits pages.getPageBySlug span with slug attribute", async () => {
+        if (!getTracer) return;
+        const tracer = getTracer();
+        tracer.reset();
+        await repo.getPageBySlug("about");
+        const span = tracer.findSpan("pages.getPageBySlug");
+        expect(span).toBeDefined();
+        expect(span!.op).toBe("repository");
+        expect(span!.attributes.slug).toBe("about");
+      });
+
+      it("getPages emits pages.getPages span with op=repository", async () => {
+        if (!getTracer) return;
+        const tracer = getTracer();
+        tracer.reset();
+        await repo.getPages({ status: "published" });
+        const span = tracer.findSpan("pages.getPages");
+        expect(span).toBeDefined();
+        expect(span!.op).toBe("repository");
+        expect(span!.attributes.status).toBe("published");
+      });
+    });
+  },
+);
--- a/packages/marketing-pages/src/contracts/site-settings-repository.contract.ts
+++ b/packages/marketing-pages/src/contracts/site-settings-repository.contract.ts
@@ -0,0 +1,50 @@
+import { it, expect, beforeEach, describe } from "vitest";
+import { defineContractSuite } from "@repo/core-testing/contract";
+import type { ISiteSettingsRepository } from "../application/repositories/site-settings.repository.interface";
+
+/**
+ * Contract for ISiteSettingsRepository.
+ *
+ * SiteSettings is a singleton (Payload Global). The interface exposes
+ * only getSiteSettings(). The contract verifies the shape of the return value.
+ */
+export const siteSettingsRepositoryContract =
+  defineContractSuite<ISiteSettingsRepository>(
+    "ISiteSettingsRepository",
+    ({ buildSubject, getTracer }) => {
+      let repo: ISiteSettingsRepository;
+
+      beforeEach(async () => {
+        repo = await buildSubject();
+      });
+
+      // --- getSiteSettings ---
+
+      it("getSiteSettings returns an object with a non-empty siteName", async () => {
+        const settings = await repo.getSiteSettings();
+        expect(settings).toBeDefined();
+        expect(typeof settings.siteName).toBe("string");
+        expect(settings.siteName.length).toBeGreaterThan(0);
+      });
+
+      it("getSiteSettings siteDescription is string or undefined", async () => {
+        const settings = await repo.getSiteSettings();
+        expect(
+          settings.siteDescription === undefined ||
+            typeof settings.siteDescription === "string",
+        ).toBe(true);
+      });
+
+      describe("span emission", () => {
+        it("getSiteSettings emits site-settings.getSiteSettings span with op=repository", async () => {
+          if (!getTracer) return;
+          const tracer = getTracer();
+          tracer.reset();
+          await repo.getSiteSettings();
+          const span = tracer.findSpan("site-settings.getSiteSettings");
+          expect(span).toBeDefined();
+          expect(span!.op).toBe("repository");
+        });
+      });
+    },
+  );
--- a/packages/marketing-pages/src/factories/index.ts
+++ b/packages/marketing-pages/src/factories/index.ts
@@ -0,0 +1,2 @@
+export { pageFactory } from "./page.factory";
+export { siteSettingsFactory } from "./site-settings.factory";
--- a/packages/marketing-pages/src/factories/page.factory.test.ts
+++ b/packages/marketing-pages/src/factories/page.factory.test.ts
@@ -0,0 +1,29 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { pageFactory } from "@/__factories__/page.factory";
+
+describe("pageFactory", () => {
+  beforeEach(() => pageFactory.reset());
+
+  it("returns a Page with stable defaults", () => {
+    const p = pageFactory.build();
+    expect(p.id).toBe("page-1");
+    expect(p.title).toBe("Page 1");
+    expect(p.slug).toBe("page-1");
+    expect(p.status).toBe("draft");
+    expect(p.createdAt).toEqual(new Date("2026-01-01T00:00:00Z"));
+  });
+
+  it("applies overrides", () => {
+    const p = pageFactory.build({ status: "published", title: "About" });
+    expect(p.status).toBe("published");
+    expect(p.title).toBe("About");
+    expect(p.id).toBe("page-1");
+  });
+
+  it("increments sequence per build", () => {
+    const a = pageFactory.build();
+    const b = pageFactory.build();
+    expect(a.id).toBe("page-1");
+    expect(b.id).toBe("page-2");
+  });
+});
--- a/packages/marketing-pages/src/factories/page.factory.ts
+++ b/packages/marketing-pages/src/factories/page.factory.ts
@@ -0,0 +1,19 @@
+import { defineFactory } from "@repo/core-testing/factory";
+import type { Page } from "../entities/models/page";
+
+export const pageFactory = defineFactory<Page>(({ sequence }) => ({
+  id: `page-${sequence}`,
+  title: `Page ${sequence}`,
+  slug: `page-${sequence}`,
+  hero: {
+    heading: `Hero ${sequence}`,
+  },
+  layout: [],
+  status: "draft",
+  publishedAt: null,
+  seo: {
+    title: `Page ${sequence} | Site`,
+  },
+  createdAt: new Date("2026-01-01T00:00:00Z"),
+  updatedAt: new Date("2026-01-01T00:00:00Z"),
+}));
--- a/packages/marketing-pages/src/factories/site-settings.factory.test.ts
+++ b/packages/marketing-pages/src/factories/site-settings.factory.test.ts
@@ -0,0 +1,23 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { siteSettingsFactory } from "@/__factories__/site-settings.factory";
+
+describe("siteSettingsFactory", () => {
+  beforeEach(() => siteSettingsFactory.reset());
+
+  it("returns SiteSettings with stable defaults", () => {
+    const s = siteSettingsFactory.build();
+    expect(s.siteName).toBe("Site 1");
+  });
+
+  it("applies overrides", () => {
+    const s = siteSettingsFactory.build({ siteName: "My Brand" });
+    expect(s.siteName).toBe("My Brand");
+  });
+
+  it("increments sequence per build (siteName reflects it)", () => {
+    const a = siteSettingsFactory.build();
+    const b = siteSettingsFactory.build();
+    expect(a.siteName).toBe("Site 1");
+    expect(b.siteName).toBe("Site 2");
+  });
+});
--- a/packages/marketing-pages/src/factories/site-settings.factory.ts
+++ b/packages/marketing-pages/src/factories/site-settings.factory.ts
@@ -0,0 +1,8 @@
+import { defineFactory } from "@repo/core-testing/factory";
+import type { SiteSettings } from "../entities/models/site-settings";
+
+export const siteSettingsFactory = defineFactory<SiteSettings>(
+  ({ sequence }) => ({
+    siteName: `Site ${sequence}`,
+  }),
+);
--- a/packages/marketing-pages/src/seeds/dev.ts
+++ b/packages/marketing-pages/src/seeds/dev.ts
@@ -0,0 +1,55 @@
+import { pageFactory } from "../__factories__/page.factory";
+import { siteSettingsFactory } from "../__factories__/site-settings.factory";
+import type { Page } from "../entities/models/page";
+import type { SiteSettings } from "../entities/models/site-settings";
+
+/**
+ * Realistic marketing-pages seed for dev mode + storybook stories.
+ *
+ * Built from `pageFactory` / `siteSettingsFactory` so factory defaults take
+ * care of boring fields and we only override what makes the data look like a
+ * real site.
+ *
+ * Lazily produced so importing this module is side-effect-free — the
+ * factory's sequence counter only advances when a binder calls
+ * `buildDevPages()` / `buildDevSiteSettings()`.
+ */
+export function buildDevPages(): Page[] {
+  const SEED_DATE = new Date("2026-01-01T00:00:00.000Z");
+  return [
+    pageFactory.build({
+      id: "home",
+      slug: "home",
+      title: "Home",
+      hero: { heading: "Welcome to our site" },
+      status: "published",
+      publishedAt: SEED_DATE,
+      seo: { title: "Home | My App" },
+    }),
+    pageFactory.build({
+      id: "about",
+      slug: "about",
+      title: "About Us",
+      hero: { heading: "Our story" },
+      status: "published",
+      publishedAt: SEED_DATE,
+      seo: { title: "About | My App" },
+    }),
+    pageFactory.build({
+      id: "pricing",
+      slug: "pricing",
+      title: "Pricing",
+      hero: { heading: "Simple, transparent pricing" },
+      status: "published",
+      publishedAt: SEED_DATE,
+      seo: { title: "Pricing | My App" },
+    }),
+  ];
+}
+
+export function buildDevSiteSettings(): SiteSettings {
+  return siteSettingsFactory.build({
+    siteName: "My App",
+    siteDescription: "A vertical-feature monorepo template",
+  });
+}
--- a/packages/marketing-pages/src/application/repositories/pages.repository.interface.ts
+++ b/packages/marketing-pages/src/application/repositories/pages.repository.interface.ts
@@ -0,0 +1,10 @@
+import type { Page } from "../../entities/models/page";
+
+export interface IPagesRepository {
+  getPageBySlug(slug: string): Promise<Page | undefined>;
+  getPages(options?: {
+    status?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<Page[]>;
+}
--- a/packages/marketing-pages/src/application/repositories/site-settings.repository.interface.ts
+++ b/packages/marketing-pages/src/application/repositories/site-settings.repository.interface.ts
@@ -0,0 +1,5 @@
+import type { SiteSettings } from "../../entities/models/site-settings";
+
+export interface ISiteSettingsRepository {
+  getSiteSettings(): Promise<SiteSettings>;
+}
--- a/packages/marketing-pages/src/application/services/mailer.service.interface.ts
+++ b/packages/marketing-pages/src/application/services/mailer.service.interface.ts
@@ -0,0 +1,3 @@
+export interface IMailerService {
+  sendWelcome(userId: string, email: string): Promise<void>;
+}
--- a/packages/marketing-pages/src/application/use-cases/get-page-by-slug.use-case.test.ts
+++ b/packages/marketing-pages/src/application/use-cases/get-page-by-slug.use-case.test.ts
@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import { ZodError } from "zod";
+import { getPageBySlugUseCase } from "@/application/use-cases/get-page-by-slug.use-case";
+import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
+
+describe("getPageBySlugUseCase", () => {
+  it("returns the page when found", async () => {
+    const repo = new MockPagesRepository();
+    const useCase = getPageBySlugUseCase(repo);
+    const result = await useCase({ slug: "about" });
+    expect(result?.slug).toBe("about");
+  });
+
+  it("returns undefined when not found", async () => {
+    const repo = new MockPagesRepository();
+    const useCase = getPageBySlugUseCase(repo);
+    const result = await useCase({ slug: "missing-page" });
+    expect(result).toBeUndefined();
+  });
+
+  it("throws ZodError when repository returns malformed page data", async () => {
+    const repo = new MockPagesRepository([
+      {
+        id: "p-bad",
+        title: "",
+        slug: "bad-page",
+        hero: { heading: "" },
+        layout: [],
+        status: "published",
+        publishedAt: null,
+        seo: { title: "" },
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      } as never,
+    ]);
+    const useCase = getPageBySlugUseCase(repo);
+    await expect(useCase({ slug: "bad-page" })).rejects.toBeInstanceOf(
+      ZodError,
+    );
+  });
+});
--- a/packages/marketing-pages/src/application/use-cases/get-page-by-slug.use-case.ts
+++ b/packages/marketing-pages/src/application/use-cases/get-page-by-slug.use-case.ts
@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+import { pageSchema } from "../../entities/models/page";
+import type { IPagesRepository } from "../repositories/pages.repository.interface";
+
+// ── Input ────────────────────────────────────────────────────────────────
+export const getPageBySlugInputSchema = z.object({ slug: z.string().min(1) }).strict();
+export type GetPageBySlugInput = z.infer<typeof getPageBySlugInputSchema>;
+
+// ── Output ───────────────────────────────────────────────────────────────
+export const getPageBySlugOutputSchema = pageSchema;
+export type GetPageBySlugOutput = z.infer<typeof getPageBySlugOutputSchema>;
+
+// ── Use case ─────────────────────────────────────────────────────────────
+export type IGetPageBySlugUseCase = ReturnType<typeof getPageBySlugUseCase>;
+
+export const getPageBySlugUseCase =
+  (pagesRepository: IPagesRepository) =>
+  async (input: GetPageBySlugInput): Promise<GetPageBySlugOutput | undefined> => {
+    const page = await pagesRepository.getPageBySlug(input.slug);
+    if (!page) return undefined;
+    return getPageBySlugOutputSchema.parse(page);
+  };
--- a/packages/marketing-pages/src/application/use-cases/get-site-settings.use-case.test.ts
+++ b/packages/marketing-pages/src/application/use-cases/get-site-settings.use-case.test.ts
@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { ZodError } from "zod";
+import { getSiteSettingsUseCase } from "@/application/use-cases/get-site-settings.use-case";
+import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
+
+describe("getSiteSettingsUseCase", () => {
+  it("returns the seeded site settings", async () => {
+    const repo = new MockSiteSettingsRepository();
+    const useCase = getSiteSettingsUseCase(repo);
+    const result = await useCase({});
+    expect(result.siteName).toBe("My App");
+  });
+
+  it("throws ZodError when repository returns malformed site settings", async () => {
+    const malformedRepo = {
+      getSiteSettings: async () => ({ siteName: "" }),
+    };
+    const useCase = getSiteSettingsUseCase(malformedRepo);
+    await expect(useCase({})).rejects.toBeInstanceOf(ZodError);
+  });
+});
--- a/packages/marketing-pages/src/application/use-cases/get-site-settings.use-case.ts
+++ b/packages/marketing-pages/src/application/use-cases/get-site-settings.use-case.ts
@@ -0,0 +1,22 @@
+import { z } from "zod";
+
+import { siteSettingsSchema } from "../../entities/models/site-settings";
+import type { ISiteSettingsRepository } from "../repositories/site-settings.repository.interface";
+
+// ── Input ────────────────────────────────────────────────────────────────
+export const getSiteSettingsInputSchema = z.object({}).strict();
+export type GetSiteSettingsInput = z.infer<typeof getSiteSettingsInputSchema>;
+
+// ── Output ───────────────────────────────────────────────────────────────
+export const getSiteSettingsOutputSchema = siteSettingsSchema;
+export type GetSiteSettingsOutput = z.infer<typeof getSiteSettingsOutputSchema>;
+
+// ── Use case ─────────────────────────────────────────────────────────────
+export type IGetSiteSettingsUseCase = ReturnType<typeof getSiteSettingsUseCase>;
+
+export const getSiteSettingsUseCase =
+  (siteSettingsRepository: ISiteSettingsRepository) =>
+  async (_input: GetSiteSettingsInput): Promise<GetSiteSettingsOutput> => {
+    const result = await siteSettingsRepository.getSiteSettings();
+    return getSiteSettingsOutputSchema.parse(result);
+  };
--- a/packages/marketing-pages/src/di/bind-dev-seed.test.ts
+++ b/packages/marketing-pages/src/di/bind-dev-seed.test.ts
@@ -0,0 +1,102 @@
+import "reflect-metadata";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { NoopTracer, NoopLogger } from "@repo/core-shared/instrumentation";
+import { RecordingEventBus, RecordingJobQueue } from "@repo/core-testing/instrumentation";
+import { bindDevSeedMarketingPages } from "@/di/bind-dev-seed";
+import { marketingPagesContainer } from "@/di/container";
+import { MARKETING_PAGES_SYMBOLS } from "@/di/symbols";
+import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
+import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
+import type { IPagesRepository } from "@/application/repositories/pages.repository.interface";
+import type { ISiteSettingsRepository } from "@/application/repositories/site-settings.repository.interface";
+
+const noop = { tracer: new NoopTracer(), logger: new NoopLogger() };
+
+describe("bindDevSeedMarketingPages", () => {
+  // Each test starts from default mock bindings and tears down afterwards so
+  // the global marketingPagesContainer state stays clean for siblings.
+  beforeEach(() => {
+    if (marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.IPagesRepository)) {
+      marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.IPagesRepository);
+    }
+    marketingPagesContainer
+      .bind<IPagesRepository>(MARKETING_PAGES_SYMBOLS.IPagesRepository)
+      .to(MockPagesRepository);
+
+    if (
+      marketingPagesContainer.isBound(
+        MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+      )
+    ) {
+      marketingPagesContainer.unbind(
+        MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+      );
+    }
+    marketingPagesContainer
+      .bind<ISiteSettingsRepository>(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository)
+      .to(MockSiteSettingsRepository);
+  });
+
+  afterEach(() => {
+    if (marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.IPagesRepository)) {
+      marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.IPagesRepository);
+    }
+    marketingPagesContainer
+      .bind<IPagesRepository>(MARKETING_PAGES_SYMBOLS.IPagesRepository)
+      .to(MockPagesRepository);
+
+    if (
+      marketingPagesContainer.isBound(
+        MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+      )
+    ) {
+      marketingPagesContainer.unbind(
+        MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+      );
+    }
+    marketingPagesContainer
+      .bind<ISiteSettingsRepository>(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository)
+      .to(MockSiteSettingsRepository);
+  });
+
+  it("populates the pages repository with the dev pages", async () => {
+    await bindDevSeedMarketingPages({ ...noop, bus: new RecordingEventBus(), queue: new RecordingJobQueue() });
+
+    const repo = marketingPagesContainer.get<IPagesRepository>(
+      MARKETING_PAGES_SYMBOLS.IPagesRepository,
+    );
+    const pages = await repo.getPages();
+
+    expect(pages.length).toBeGreaterThan(0);
+  });
+
+  it("seeds site settings with a non-default site name", async () => {
+    await bindDevSeedMarketingPages({ ...noop, bus: new RecordingEventBus(), queue: new RecordingJobQueue() });
+
+    const settingsRepo = marketingPagesContainer.get<ISiteSettingsRepository>(
+      MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+    );
+    const settings = await settingsRepo.getSiteSettings();
+
+    expect(settings.siteName).toBe("My App");
+    expect(settings.siteDescription).toBeDefined();
+  });
+
+  it("is idempotent — calling twice rebuilds fresh populated repos", async () => {
+    await bindDevSeedMarketingPages({ ...noop, bus: new RecordingEventBus(), queue: new RecordingJobQueue() });
+    const before = marketingPagesContainer.get<IPagesRepository>(
+      MARKETING_PAGES_SYMBOLS.IPagesRepository,
+    );
+    const beforeCount = (await before.getPages()).length;
+
+    await bindDevSeedMarketingPages({ ...noop, bus: new RecordingEventBus(), queue: new RecordingJobQueue() });
+    const after = marketingPagesContainer.get<IPagesRepository>(
+      MARKETING_PAGES_SYMBOLS.IPagesRepository,
+    );
+    const afterCount = (await after.getPages()).length;
+
+    expect(afterCount).toBe(beforeCount);
+    // It's a fresh instance — not the previous one.
+    expect(after).not.toBe(before);
+  });
+});
--- a/packages/marketing-pages/src/di/bind-dev-seed.ts
+++ b/packages/marketing-pages/src/di/bind-dev-seed.ts
@@ -0,0 +1,268 @@
+import {
+  withSpan,
+  withCapture,
+  INSTRUMENTATION_SYMBOLS,
+  type ITracer,
+  type ILogger,
+} from "@repo/core-shared/instrumentation";
+import type { BindContext } from "@repo/core-shared/di";
+import {
+  assertFeatureConformance,
+  wireUseCase,
+} from "@repo/core-shared/conformance";
+import { marketingPagesManifest } from "../feature.manifest";
+import { marketingPagesContainer } from "./container";
+import { MARKETING_PAGES_SYMBOLS } from "./symbols";
+import { MockPagesRepository } from "../infrastructure/repositories/pages.repository.mock";
+import { buildDevPages, buildDevSiteSettings } from "../__seeds__/dev";
+import { getSiteSettingsUseCase } from "../application/use-cases/get-site-settings.use-case";
+import { getPageBySlugUseCase } from "../application/use-cases/get-page-by-slug.use-case";
+import { getSiteSettingsController } from "../interface-adapters/controllers/get-site-settings.controller";
+import { getPageBySlugController } from "../interface-adapters/controllers/get-page-by-slug.controller";
+import type { IPagesRepository } from "../application/repositories/pages.repository.interface";
+import type { ISiteSettingsRepository } from "../application/repositories/site-settings.repository.interface";
+import { userSignedUpEvent } from "@repo/auth";
+import { onAuthUserSignedUpHandler } from "../events/handlers/on-auth-user-signed-up.handler";
+import {
+  sendWelcomeEmailJob,
+  type ISendWelcomeEmailJob,
+  type SendWelcomeEmailInput,
+} from "../jobs/send-welcome-email.job";
+import { RecordingMailerService } from "../infrastructure/services/recording-mailer.service";
+import type { IMailerService } from "../application/services/mailer.service.interface";
+
+/**
+ * Replace the default empty mocks with populated ones for dev mode + storybook.
+ *
+ * Call this from app boot when `USE_DEV_SEED=true`, mutually exclusive with
+ * `bindProductionMarketingPages(config)`. Tests must NOT call this — they
+ * construct mocks directly and seed via factories per-test.
+ *
+ * Idempotent: safe to call multiple times; each call rebuilds fresh populated
+ * repos and rebinds both symbols.
+ */
+export async function bindDevSeedMarketingPages(
+  ctx: BindContext,
+): Promise<void> {
+  const { tracer, logger, bus, queue, realtime, realtimeRegistry } = ctx;
+
+  // Bind shared instrumentation into feature container
+  if (marketingPagesContainer.isBound(INSTRUMENTATION_SYMBOLS.TRACER)) {
+    marketingPagesContainer.unbind(INSTRUMENTATION_SYMBOLS.TRACER);
+  }
+  if (marketingPagesContainer.isBound(INSTRUMENTATION_SYMBOLS.LOGGER)) {
+    marketingPagesContainer.unbind(INSTRUMENTATION_SYMBOLS.LOGGER);
+  }
+  marketingPagesContainer
+    .bind<ITracer>(INSTRUMENTATION_SYMBOLS.TRACER)
+    .toConstantValue(tracer);
+  marketingPagesContainer
+    .bind<ILogger>(INSTRUMENTATION_SYMBOLS.LOGGER)
+    .toConstantValue(logger);
+
+  // Pages repository — MockPagesRepository accepts an initial array.
+  if (
+    marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.IPagesRepository)
+  ) {
+    marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.IPagesRepository);
+  }
+  const pagesRepo = new MockPagesRepository(buildDevPages(), tracer, logger);
+  marketingPagesContainer
+    .bind<IPagesRepository>(MARKETING_PAGES_SYMBOLS.IPagesRepository)
+    .toConstantValue(pagesRepo);
+
+  // Site settings repository
+  if (
+    marketingPagesContainer.isBound(
+      MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+    )
+  ) {
+    marketingPagesContainer.unbind(
+      MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+    );
+  }
+  const settings = buildDevSiteSettings();
+  // Inline constant so dev seed returns exactly the seeded value (not the mock's default)
+  const siteSettingsRepo: ISiteSettingsRepository = {
+    getSiteSettings: async () => settings,
+  };
+  marketingPagesContainer
+    .bind<ISiteSettingsRepository>(
+      MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+    )
+    .toConstantValue(siteSettingsRepo);
+
+  // Use cases
+  const wrappedGetSiteSettings = wireUseCase({
+    container: marketingPagesContainer,
+    symbol: MARKETING_PAGES_SYMBOLS.IGetSiteSettingsUseCase,
+    factory: getSiteSettingsUseCase,
+    deps: [siteSettingsRepo],
+    feature: "marketing-pages",
+    layer: "use-case",
+    name: "getSiteSettings",
+    tracer,
+    logger,
+  });
+  const wrappedGetPageBySlug = wireUseCase({
+    container: marketingPagesContainer,
+    symbol: MARKETING_PAGES_SYMBOLS.IGetPageBySlugUseCase,
+    factory: getPageBySlugUseCase,
+    deps: [pagesRepo],
+    feature: "marketing-pages",
+    layer: "use-case",
+    name: "getPageBySlug",
+    tracer,
+    logger,
+  });
+
+  for (const sym of [
+    MARKETING_PAGES_SYMBOLS.IGetSiteSettingsController,
+    MARKETING_PAGES_SYMBOLS.IGetPageBySlugController,
+  ]) {
+    if (marketingPagesContainer.isBound(sym))
+      marketingPagesContainer.unbind(sym);
+  }
+
+  marketingPagesContainer
+    .bind(MARKETING_PAGES_SYMBOLS.IGetSiteSettingsController)
+    .toConstantValue(
+      withSpan(
+        tracer,
+        { name: "marketing-pages.getSiteSettings", op: "controller" },
+        withCapture(
+          logger,
+          {
+            feature: "marketing-pages",
+            layer: "controller",
+            name: "marketing-pages.getSiteSettings",
+          },
+          getSiteSettingsController(wrappedGetSiteSettings),
+        ),
+      ),
+    );
+  marketingPagesContainer
+    .bind(MARKETING_PAGES_SYMBOLS.IGetPageBySlugController)
+    .toConstantValue(
+      withSpan(
+        tracer,
+        { name: "marketing-pages.getPageBySlug", op: "controller" },
+        withCapture(
+          logger,
+          {
+            feature: "marketing-pages",
+            layer: "controller",
+            name: "marketing-pages.getPageBySlug",
+          },
+          getPageBySlugController(wrappedGetPageBySlug),
+        ),
+      ),
+    );
+  // Bind the dev-seed mailer (recording so e2e tests can inspect calls).
+  if (marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.IMailerService)) {
+    marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.IMailerService);
+  }
+  const mailer = new RecordingMailerService();
+  marketingPagesContainer
+    .bind<IMailerService>(MARKETING_PAGES_SYMBOLS.IMailerService)
+    .toConstantValue(mailer);
+
+  // <gen:event-handlers>
+  // onAuthUserSignedUpHandler subscription — generated, edit the handler file (not this block) for behavior.
+  // bus is optional: when @repo/core-events is not scaffolded, ctx.bus is undefined and the handler is not bound.
+  // queue (IJobQueue) is in core-shared and always provided; the inner if (queue) below is belt-and-suspenders.
+  if (queue) {
+    const wrappedAuthUserSignedUp = withSpan(
+      tracer,
+      {
+        name: "marketing-pages.onAuthUserSignedUpHandler",
+        op: "event-handler",
+      },
+      withCapture(
+        logger,
+        {
+          feature: "marketing-pages",
+          layer: "event-handler",
+          name: "marketing-pages.onAuthUserSignedUpHandler",
+        },
+        onAuthUserSignedUpHandler(queue),
+      ),
+    );
+    if (
+      marketingPagesContainer.isBound(
+        MARKETING_PAGES_SYMBOLS.IOnAuthUserSignedUpHandler,
+      )
+    ) {
+      marketingPagesContainer.unbind(
+        MARKETING_PAGES_SYMBOLS.IOnAuthUserSignedUpHandler,
+      );
+    }
+    marketingPagesContainer
+      .bind(MARKETING_PAGES_SYMBOLS.IOnAuthUserSignedUpHandler)
+      .toConstantValue(wrappedAuthUserSignedUp);
+    bus?.subscribe(
+      userSignedUpEvent,
+      "marketing-pages",
+      wrappedAuthUserSignedUp,
+    );
+  }
+  // <gen:jobs>
+  const wrappedSendWelcomeEmail = withSpan(
+    tracer,
+    { name: "marketing-pages.sendWelcomeEmail", op: "job" },
+    withCapture(
+      logger,
+      {
+        feature: "marketing-pages",
+        layer: "job",
+        name: "marketing-pages.sendWelcomeEmail",
+      },
+      sendWelcomeEmailJob(mailer),
+    ),
+  );
+  if (
+    marketingPagesContainer.isBound(
+      MARKETING_PAGES_SYMBOLS.ISendWelcomeEmailJob,
+    )
+  ) {
+    marketingPagesContainer.unbind(
+      MARKETING_PAGES_SYMBOLS.ISendWelcomeEmailJob,
+    );
+  }
+  marketingPagesContainer
+    .bind(MARKETING_PAGES_SYMBOLS.ISendWelcomeEmailJob)
+    .toConstantValue(wrappedSendWelcomeEmail);
+
+  // Register the dev-seed in-memory queue handler so enqueue() actually fires
+  // the wrapped job. Production binding skips this — the Payload task does it.
+  if (
+    queue &&
+    "register" in queue &&
+    typeof (queue as { register?: unknown }).register === "function"
+  ) {
+    (
+      queue as {
+        register: (slug: string, h: (input: unknown) => Promise<void>) => void;
+      }
+    ).register("marketing-pages.send-welcome-email", async (input) => {
+      const wrapped = marketingPagesContainer.get<ISendWelcomeEmailJob>(
+        MARKETING_PAGES_SYMBOLS.ISendWelcomeEmailJob,
+      );
+      await wrapped(input as SendWelcomeEmailInput);
+    });
+  }
+  void realtime;
+  void realtimeRegistry;
+  // <gen:realtime-handlers>
+
+  // Boot-time conformance check (dev-seed mode).
+  assertFeatureConformance(
+    marketingPagesContainer,
+    marketingPagesManifest,
+    {
+      getPageBySlug: MARKETING_PAGES_SYMBOLS.IGetPageBySlugUseCase,
+      getSiteSettings: MARKETING_PAGES_SYMBOLS.IGetSiteSettingsUseCase,
+    },
+    ctx,
+  );
+}
--- a/packages/marketing-pages/src/di/bind-production.smoke.test.ts
+++ b/packages/marketing-pages/src/di/bind-production.smoke.test.ts
@@ -0,0 +1,17 @@
+import "reflect-metadata";
+import { describe, expect, it } from "vitest";
+import type { SanitizedConfig } from "payload";
+import { NoopTracer, NoopLogger } from "@repo/core-shared/instrumentation";
+import { bindProductionMarketingPages } from "@/di/bind-production";
+
+describe("bindProductionMarketingPages — boot-time conformance", () => {
+  it("binds every manifest use case through withSpan + withCapture", () => {
+    expect(() =>
+      bindProductionMarketingPages({
+        config: {} as SanitizedConfig,
+        tracer: new NoopTracer(),
+        logger: new NoopLogger(),
+      }),
+    ).not.toThrow();
+  });
+});
--- a/packages/marketing-pages/src/di/bind-production.ts
+++ b/packages/marketing-pages/src/di/bind-production.ts
@@ -0,0 +1,227 @@
+import {
+  withSpan,
+  withCapture,
+  INSTRUMENTATION_SYMBOLS,
+  type ITracer,
+  type ILogger,
+} from "@repo/core-shared/instrumentation";
+import type { BindProductionContext } from "@repo/core-shared/di";
+import {
+  assertFeatureConformance,
+  wireUseCase,
+} from "@repo/core-shared/conformance";
+import { marketingPagesContainer } from "./container";
+import { MARKETING_PAGES_SYMBOLS } from "./symbols";
+import { marketingPagesManifest } from "../feature.manifest";
+import { PagesRepository } from "../infrastructure/repositories/pages.repository";
+import { SiteSettingsRepository } from "../infrastructure/repositories/site-settings.repository";
+import { getSiteSettingsUseCase } from "../application/use-cases/get-site-settings.use-case";
+import { getPageBySlugUseCase } from "../application/use-cases/get-page-by-slug.use-case";
+import { getSiteSettingsController } from "../interface-adapters/controllers/get-site-settings.controller";
+import { getPageBySlugController } from "../interface-adapters/controllers/get-page-by-slug.controller";
+import { userSignedUpEvent } from "@repo/auth";
+import { onAuthUserSignedUpHandler } from "../events/handlers/on-auth-user-signed-up.handler";
+import { sendWelcomeEmailJob } from "../jobs/send-welcome-email.job";
+import { RecordingMailerService } from "../infrastructure/services/recording-mailer.service";
+import type { IMailerService } from "../application/services/mailer.service.interface";
+
+export function bindProductionMarketingPages(ctx: BindProductionContext): void {
+  const { config, tracer, logger, bus, queue, realtime, realtimeRegistry } =
+    ctx;
+
+  // Bind shared instrumentation into feature container
+  if (marketingPagesContainer.isBound(INSTRUMENTATION_SYMBOLS.TRACER)) {
+    marketingPagesContainer.unbind(INSTRUMENTATION_SYMBOLS.TRACER);
+  }
+  if (marketingPagesContainer.isBound(INSTRUMENTATION_SYMBOLS.LOGGER)) {
+    marketingPagesContainer.unbind(INSTRUMENTATION_SYMBOLS.LOGGER);
+  }
+  marketingPagesContainer
+    .bind<ITracer>(INSTRUMENTATION_SYMBOLS.TRACER)
+    .toConstantValue(tracer);
+  marketingPagesContainer
+    .bind<ILogger>(INSTRUMENTATION_SYMBOLS.LOGGER)
+    .toConstantValue(logger);
+
+  // Real repositories
+  if (
+    marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.IPagesRepository)
+  ) {
+    marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.IPagesRepository);
+  }
+  const pagesRepo = new PagesRepository(config, tracer, logger);
+  marketingPagesContainer
+    .bind(MARKETING_PAGES_SYMBOLS.IPagesRepository)
+    .toConstantValue(pagesRepo);
+
+  if (
+    marketingPagesContainer.isBound(
+      MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+    )
+  ) {
+    marketingPagesContainer.unbind(
+      MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+    );
+  }
+  const siteSettingsRepo = new SiteSettingsRepository(config, tracer, logger);
+  marketingPagesContainer
+    .bind(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository)
+    .toConstantValue(siteSettingsRepo);
+
+  // Use cases
+  const wrappedGetSiteSettings = wireUseCase({
+    container: marketingPagesContainer,
+    symbol: MARKETING_PAGES_SYMBOLS.IGetSiteSettingsUseCase,
+    factory: getSiteSettingsUseCase,
+    deps: [siteSettingsRepo],
+    feature: "marketing-pages",
+    layer: "use-case",
+    name: "getSiteSettings",
+    tracer,
+    logger,
+  });
+  const wrappedGetPageBySlug = wireUseCase({
+    container: marketingPagesContainer,
+    symbol: MARKETING_PAGES_SYMBOLS.IGetPageBySlugUseCase,
+    factory: getPageBySlugUseCase,
+    deps: [pagesRepo],
+    feature: "marketing-pages",
+    layer: "use-case",
+    name: "getPageBySlug",
+    tracer,
+    logger,
+  });
+
+  // Controllers — wrapped with span at bind time
+  for (const sym of [
+    MARKETING_PAGES_SYMBOLS.IGetSiteSettingsController,
+    MARKETING_PAGES_SYMBOLS.IGetPageBySlugController,
+  ]) {
+    if (marketingPagesContainer.isBound(sym))
+      marketingPagesContainer.unbind(sym);
+  }
+  marketingPagesContainer
+    .bind(MARKETING_PAGES_SYMBOLS.IGetSiteSettingsController)
+    .toConstantValue(
+      withSpan(
+        tracer,
+        { name: "marketing-pages.getSiteSettings", op: "controller" },
+        withCapture(
+          logger,
+          {
+            feature: "marketing-pages",
+            layer: "controller",
+            name: "marketing-pages.getSiteSettings",
+          },
+          getSiteSettingsController(wrappedGetSiteSettings),
+        ),
+      ),
+    );
+  marketingPagesContainer
+    .bind(MARKETING_PAGES_SYMBOLS.IGetPageBySlugController)
+    .toConstantValue(
+      withSpan(
+        tracer,
+        { name: "marketing-pages.getPageBySlug", op: "controller" },
+        withCapture(
+          logger,
+          {
+            feature: "marketing-pages",
+            layer: "controller",
+            name: "marketing-pages.getPageBySlug",
+          },
+          getPageBySlugController(wrappedGetPageBySlug),
+        ),
+      ),
+    );
+  // Bind the production mailer. Until a real SMTP/SES adapter ships, this is
+  // a placeholder RecordingMailerService — production wiring is structurally
+  // identical to dev-seed but the impl is the seam where a real mailer plugs in.
+  if (marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.IMailerService)) {
+    marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.IMailerService);
+  }
+  const mailer = new RecordingMailerService();
+  marketingPagesContainer
+    .bind<IMailerService>(MARKETING_PAGES_SYMBOLS.IMailerService)
+    .toConstantValue(mailer);
+
+  // <gen:event-handlers>
+  // onAuthUserSignedUpHandler subscription — generated, edit the handler file (not this block) for behavior.
+  // bus is optional: when @repo/core-events is not scaffolded, ctx.bus is undefined and the handler is not bound.
+  // queue (IJobQueue) is in core-shared and always provided; the inner if (queue) below is belt-and-suspenders.
+  if (queue) {
+    const wrappedAuthUserSignedUp = withSpan(
+      tracer,
+      {
+        name: "marketing-pages.onAuthUserSignedUpHandler",
+        op: "event-handler",
+      },
+      withCapture(
+        logger,
+        {
+          feature: "marketing-pages",
+          layer: "event-handler",
+          name: "marketing-pages.onAuthUserSignedUpHandler",
+        },
+        onAuthUserSignedUpHandler(queue),
+      ),
+    );
+    if (
+      marketingPagesContainer.isBound(
+        MARKETING_PAGES_SYMBOLS.IOnAuthUserSignedUpHandler,
+      )
+    ) {
+      marketingPagesContainer.unbind(
+        MARKETING_PAGES_SYMBOLS.IOnAuthUserSignedUpHandler,
+      );
+    }
+    marketingPagesContainer
+      .bind(MARKETING_PAGES_SYMBOLS.IOnAuthUserSignedUpHandler)
+      .toConstantValue(wrappedAuthUserSignedUp);
+    bus?.subscribe(
+      userSignedUpEvent,
+      "marketing-pages",
+      wrappedAuthUserSignedUp,
+    );
+  }
+  // <gen:jobs>
+  const wrappedSendWelcomeEmail = withSpan(
+    tracer,
+    { name: "marketing-pages.sendWelcomeEmail", op: "job" },
+    withCapture(
+      logger,
+      {
+        feature: "marketing-pages",
+        layer: "job",
+        name: "marketing-pages.sendWelcomeEmail",
+      },
+      sendWelcomeEmailJob(mailer),
+    ),
+  );
+  if (
+    marketingPagesContainer.isBound(
+      MARKETING_PAGES_SYMBOLS.ISendWelcomeEmailJob,
+    )
+  ) {
+    marketingPagesContainer.unbind(
+      MARKETING_PAGES_SYMBOLS.ISendWelcomeEmailJob,
+    );
+  }
+  marketingPagesContainer
+    .bind(MARKETING_PAGES_SYMBOLS.ISendWelcomeEmailJob)
+    .toConstantValue(wrappedSendWelcomeEmail);
+  void realtime;
+  void realtimeRegistry;
+  // <gen:realtime-handlers>
+
+  // Boot-time conformance check.
+  assertFeatureConformance(
+    marketingPagesContainer,
+    marketingPagesManifest,
+    {
+      getPageBySlug: MARKETING_PAGES_SYMBOLS.IGetPageBySlugUseCase,
+      getSiteSettings: MARKETING_PAGES_SYMBOLS.IGetSiteSettingsUseCase,
+    },
+    ctx,
+  );
+}
--- a/packages/marketing-pages/src/di/container.test.ts
+++ b/packages/marketing-pages/src/di/container.test.ts
@@ -0,0 +1,33 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { marketingPagesContainer } from "./container";
+import { MARKETING_PAGES_SYMBOLS } from "./symbols";
+import { MarketingPagesModule } from "./module";
+import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
+import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
+import type { IPagesRepository } from "@/application/repositories/pages.repository.interface";
+import type { ISiteSettingsRepository } from "@/application/repositories/site-settings.repository.interface";
+
+describe("marketingPagesContainer", () => {
+  beforeEach(() => {
+    marketingPagesContainer.unbindAll();
+    marketingPagesContainer.load(MarketingPagesModule);
+  });
+
+  afterEach(() => {
+    marketingPagesContainer.unbindAll();
+  });
+
+  it("resolves IPagesRepository to MockPagesRepository", () => {
+    const repo = marketingPagesContainer.get<IPagesRepository>(
+      MARKETING_PAGES_SYMBOLS.IPagesRepository,
+    );
+    expect(repo).toBeInstanceOf(MockPagesRepository);
+  });
+
+  it("resolves ISiteSettingsRepository to MockSiteSettingsRepository", () => {
+    const repo = marketingPagesContainer.get<ISiteSettingsRepository>(
+      MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+    );
+    expect(repo).toBeInstanceOf(MockSiteSettingsRepository);
+  });
+});
--- a/packages/marketing-pages/src/di/container.ts
+++ b/packages/marketing-pages/src/di/container.ts
@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import { Container } from "inversify";
+import { MarketingPagesModule } from "./module";
+
+export const marketingPagesContainer = new Container({
+  defaultScope: "Singleton",
+});
+marketingPagesContainer.load(MarketingPagesModule);
--- a/packages/marketing-pages/src/di/module.ts
+++ b/packages/marketing-pages/src/di/module.ts
@@ -0,0 +1,68 @@
+import { ContainerModule, type interfaces } from "inversify";
+
+import type { IPagesRepository } from "../application/repositories/pages.repository.interface";
+import type { ISiteSettingsRepository } from "../application/repositories/site-settings.repository.interface";
+import { MockPagesRepository } from "../infrastructure/repositories/pages.repository.mock";
+import { MockSiteSettingsRepository } from "../infrastructure/repositories/site-settings.repository.mock";
+import {
+  getPageBySlugUseCase,
+  type IGetPageBySlugUseCase,
+} from "../application/use-cases/get-page-by-slug.use-case";
+import {
+  getSiteSettingsUseCase,
+  type IGetSiteSettingsUseCase,
+} from "../application/use-cases/get-site-settings.use-case";
+import {
+  getPageBySlugController,
+  type IGetPageBySlugController,
+} from "../interface-adapters/controllers/get-page-by-slug.controller";
+import {
+  getSiteSettingsController,
+  type IGetSiteSettingsController,
+} from "../interface-adapters/controllers/get-site-settings.controller";
+import { MARKETING_PAGES_SYMBOLS } from "./symbols";
+
+export const MarketingPagesModule = new ContainerModule(
+  (bind: interfaces.Bind) => {
+    bind<IPagesRepository>(MARKETING_PAGES_SYMBOLS.IPagesRepository).to(
+      MockPagesRepository,
+    );
+    bind<ISiteSettingsRepository>(
+      MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+    ).to(MockSiteSettingsRepository);
+
+    bind<IGetPageBySlugUseCase>(MARKETING_PAGES_SYMBOLS.IGetPageBySlugUseCase).toDynamicValue(
+      (ctx) =>
+        getPageBySlugUseCase(
+          ctx.container.get<IPagesRepository>(MARKETING_PAGES_SYMBOLS.IPagesRepository),
+        ),
+    );
+
+    bind<IGetSiteSettingsUseCase>(MARKETING_PAGES_SYMBOLS.IGetSiteSettingsUseCase).toDynamicValue(
+      (ctx) =>
+        getSiteSettingsUseCase(
+          ctx.container.get<ISiteSettingsRepository>(
+            MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository,
+          ),
+        ),
+    );
+
+    bind<IGetPageBySlugController>(
+      MARKETING_PAGES_SYMBOLS.IGetPageBySlugController,
+    ).toDynamicValue((ctx) =>
+      getPageBySlugController(
+        ctx.container.get<IGetPageBySlugUseCase>(MARKETING_PAGES_SYMBOLS.IGetPageBySlugUseCase),
+      ),
+    );
+
+    bind<IGetSiteSettingsController>(
+      MARKETING_PAGES_SYMBOLS.IGetSiteSettingsController,
+    ).toDynamicValue((ctx) =>
+      getSiteSettingsController(
+        ctx.container.get<IGetSiteSettingsUseCase>(
+          MARKETING_PAGES_SYMBOLS.IGetSiteSettingsUseCase,
+        ),
+      ),
+    );
+  },
+);
--- a/packages/marketing-pages/src/di/symbols.ts
+++ b/packages/marketing-pages/src/di/symbols.ts
@@ -0,0 +1,16 @@
+export const MARKETING_PAGES_SYMBOLS = {
+  IPagesRepository: Symbol.for("marketing-pages:IPagesRepository"),
+  ISiteSettingsRepository: Symbol.for("marketing-pages:ISiteSettingsRepository"),
+  IMailerService: Symbol.for("@repo/marketing-pages/IMailerService"),
+  // Use cases
+  IGetPageBySlugUseCase: Symbol.for("marketing-pages:IGetPageBySlugUseCase"),
+  IGetSiteSettingsUseCase: Symbol.for("marketing-pages:IGetSiteSettingsUseCase"),
+  // Controllers
+  IGetPageBySlugController: Symbol.for("marketing-pages:IGetPageBySlugController"),
+  IGetSiteSettingsController: Symbol.for("marketing-pages:IGetSiteSettingsController"),
+  // <gen:event-handler-symbols>
+  IOnAuthUserSignedUpHandler: Symbol.for("@repo/marketing-pages/onAuthUserSignedUp"),
+  // <gen:job-symbols>
+  ISendWelcomeEmailJob: Symbol.for("@repo/marketing-pages/sendWelcomeEmailJob"),
+  // <gen:realtime-handler-symbols>
+} as const;
--- a/packages/marketing-pages/src/entities/errors/common.ts
+++ b/packages/marketing-pages/src/entities/errors/common.ts
@@ -0,0 +1,6 @@
+export class InputParseError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "InputParseError";
+  }
+}
--- a/packages/marketing-pages/src/entities/errors/errors.test.ts
+++ b/packages/marketing-pages/src/entities/errors/errors.test.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { PageNotFoundError } from "./page";
+import { InputParseError } from "./common";
+
+describe("PageNotFoundError", () => {
+  it("uses the default message when none is given", () => {
+    const err = new PageNotFoundError();
+    expect(err).toBeInstanceOf(Error);
+    expect(err.message).toBe("Page not found");
+  });
+
+  it("uses a custom message when provided", () => {
+    const err = new PageNotFoundError("could not find page /about");
+    expect(err.message).toBe("could not find page /about");
+  });
+});
+
+describe("InputParseError", () => {
+  it("is an instance of Error with the given message", () => {
+    const err = new InputParseError("invalid input");
+    expect(err).toBeInstanceOf(Error);
+    expect(err.message).toBe("invalid input");
+  });
+});
--- a/packages/marketing-pages/src/entities/errors/page.ts
+++ b/packages/marketing-pages/src/entities/errors/page.ts
@@ -0,0 +1,6 @@
+export class PageNotFoundError extends Error {
+  constructor(message = "Page not found", options?: ErrorOptions) {
+    super(message, options);
+    this.name = "PageNotFoundError";
+  }
+}
--- a/packages/marketing-pages/src/entities/models/page.test.ts
+++ b/packages/marketing-pages/src/entities/models/page.test.ts
@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { pageSchema, pageStatusSchema } from "./page";
+
+describe("pageSchema", () => {
+  it("accepts a minimal valid page", () => {
+    const result = pageSchema.parse({
+      id: "p1",
+      title: "About",
+      slug: "about",
+      hero: { heading: "About us" },
+      layout: [],
+      seo: { title: "About — My App" },
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+    expect(result.status).toBe("draft");
+    expect(result.publishedAt).toBeNull();
+  });
+
+  it("accepts a published page with publishedAt", () => {
+    const result = pageSchema.parse({
+      id: "p1",
+      title: "About",
+      slug: "about",
+      hero: { heading: "About us" },
+      layout: [],
+      status: "published",
+      publishedAt: new Date(),
+      seo: { title: "About" },
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+    expect(result.status).toBe("published");
+    expect(result.publishedAt).toBeInstanceOf(Date);
+  });
+
+  it("rejects empty title", () => {
+    expect(() =>
+      pageSchema.parse({
+        id: "p1",
+        title: "",
+        slug: "about",
+        hero: { heading: "h" },
+        layout: [],
+        seo: { title: "x" },
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }),
+    ).toThrow();
+  });
+});
+
+describe("pageStatusSchema", () => {
+  it("accepts draft and published", () => {
+    expect(pageStatusSchema.parse("draft")).toBe("draft");
+    expect(pageStatusSchema.parse("published")).toBe("published");
+  });
+});
--- a/packages/marketing-pages/src/entities/models/page.ts
+++ b/packages/marketing-pages/src/entities/models/page.ts
@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+export const pageStatusSchema = z.enum(["draft", "published"]);
+
+export const heroSchema = z.object({
+  heading: z.string().min(1).max(255),
+  subheading: z.string().optional(),
+  imageId: z.string().optional(),
+});
+
+export const pageSchema = z.object({
+  id: z.string(),
+  title: z.string().min(1).max(255),
+  slug: z.string().min(1).max(255),
+  hero: heroSchema,
+  layout: z.array(z.unknown()),
+  status: pageStatusSchema.default("draft"),
+  publishedAt: z.date().nullable().default(null),
+  seo: z.object({
+    title: z.string().min(1),
+    description: z.string().optional(),
+  }),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export type Page = z.infer<typeof pageSchema>;
+export type PageStatus = z.infer<typeof pageStatusSchema>;
+export type Hero = z.infer<typeof heroSchema>;
--- a/packages/marketing-pages/src/entities/models/site-settings.test.ts
+++ b/packages/marketing-pages/src/entities/models/site-settings.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { siteSettingsSchema } from "./site-settings";
+
+describe("siteSettingsSchema", () => {
+  it("accepts a valid site settings object", () => {
+    const result = siteSettingsSchema.parse({
+      siteName: "My Site",
+      siteDescription: "A great site",
+    });
+    expect(result.siteName).toBe("My Site");
+    expect(result.siteDescription).toBe("A great site");
+  });
+
+  it("accepts site settings without a description", () => {
+    const result = siteSettingsSchema.parse({ siteName: "My Site" });
+    expect(result.siteName).toBe("My Site");
+    expect(result.siteDescription).toBeUndefined();
+  });
+
+  it("rejects an empty siteName", () => {
+    expect(() => siteSettingsSchema.parse({ siteName: "" })).toThrow();
+  });
+});
--- a/packages/marketing-pages/src/entities/models/site-settings.ts
+++ b/packages/marketing-pages/src/entities/models/site-settings.ts
@@ -0,0 +1,8 @@
+import { z } from "zod";
+
+export const siteSettingsSchema = z.object({
+  siteName: z.string().min(1),
+  siteDescription: z.string().optional(),
+});
+
+export type SiteSettings = z.infer<typeof siteSettingsSchema>;
--- a/packages/marketing-pages/src/events/handlers/on-auth-user-signed-up.handler.test.ts
+++ b/packages/marketing-pages/src/events/handlers/on-auth-user-signed-up.handler.test.ts
@@ -0,0 +1,25 @@
+// packages/marketing-pages/src/events/handlers/on-auth-user-signed-up.handler.test.ts
+import { describe, it, expect } from "vitest";
+import { RecordingJobQueue } from "@repo/core-testing/instrumentation";
+import { onAuthUserSignedUpHandler } from "@/events/handlers/on-auth-user-signed-up.handler";
+
+describe("onAuthUserSignedUpHandler", () => {
+  it("enqueues marketing-pages.send-welcome-email with userId + email", async () => {
+    const queue = new RecordingJobQueue();
+    const handler = onAuthUserSignedUpHandler(queue);
+
+    await handler({
+      userId: "u-42",
+      email: "alice@example.com",
+      signedUpAt: "2026-05-08T12:00:00.000Z",
+    });
+
+    expect(queue.enqueued).toHaveLength(1);
+    expect(queue.enqueued[0]).toEqual(
+      expect.objectContaining({
+        taskSlug: "marketing-pages.send-welcome-email",
+        input: { userId: "u-42", email: "alice@example.com" },
+      }),
+    );
+  });
+});
--- a/packages/marketing-pages/src/events/handlers/on-auth-user-signed-up.handler.ts
+++ b/packages/marketing-pages/src/events/handlers/on-auth-user-signed-up.handler.ts
@@ -0,0 +1,16 @@
+// packages/marketing-pages/src/events/handlers/on-auth-user-signed-up.handler.ts
+import type { UserSignedUpEvent } from "@repo/auth";
+import type { IJobQueue } from "@repo/core-shared/jobs";
+
+export type IOnAuthUserSignedUpHandler = ReturnType<
+  typeof onAuthUserSignedUpHandler
+>;
+
+export const onAuthUserSignedUpHandler =
+  (queue: IJobQueue) =>
+  async (event: UserSignedUpEvent): Promise<void> => {
+    await queue.enqueue("marketing-pages.send-welcome-email", {
+      userId: event.userId,
+      email: event.email,
+    });
+  };
--- a/packages/marketing-pages/src/feature.manifest.ts
+++ b/packages/marketing-pages/src/feature.manifest.ts
@@ -0,0 +1,41 @@
+import { defineFeature } from "@repo/core-shared/conformance";
+
+/**
+ * The marketing-pages feature's conformance manifest.
+ */
+export const marketingPagesManifest = defineFeature({
+  name: "marketing-pages",
+  requiredCores: [],
+  useCases: {
+    getPageBySlug: { mutates: false, audits: [], publishes: [], consumes: [] },
+    getSiteSettings: {
+      mutates: false,
+      audits: [],
+      publishes: [],
+      consumes: [],
+    },
+  },
+  realtimeChannels: [],
+  jobs: [],
+  coverage: {
+    bands: {
+      baseline: { statements: 80, branches: 75, functions: 80, lines: 80 },
+      entities: { statements: 100, branches: 100, functions: 100, lines: 100 },
+      "use-cases": {
+        statements: 100,
+        branches: 95,
+        functions: 100,
+        lines: 100,
+      },
+      controllers: {
+        statements: 100,
+        branches: 95,
+        functions: 100,
+        lines: 100,
+      },
+    },
+    mutationTargets: ["entities", "use-cases"],
+  },
+} as const);
+
+export type MarketingPagesManifest = typeof marketingPagesManifest;
--- a/packages/marketing-pages/src/index.ts
+++ b/packages/marketing-pages/src/index.ts
@@ -0,0 +1,32 @@
+export type { Page, PageStatus, Hero } from "./entities/models/page";
+export type { SiteSettings } from "./entities/models/site-settings";
+export type { MarketingPagesRouter } from "./integrations/api/router";
+export { PageNotFoundError } from "./entities/errors/page";
+export { InputParseError } from "./entities/errors/common";
+
+// Use case schemas + types
+export {
+  getPageBySlugInputSchema,
+  getPageBySlugOutputSchema,
+  type GetPageBySlugInput,
+  type GetPageBySlugOutput,
+  type IGetPageBySlugUseCase,
+} from "./application/use-cases/get-page-by-slug.use-case";
+export {
+  getSiteSettingsInputSchema,
+  getSiteSettingsOutputSchema,
+  type GetSiteSettingsInput,
+  type GetSiteSettingsOutput,
+  type IGetSiteSettingsUseCase,
+} from "./application/use-cases/get-site-settings.use-case";
+
+// Controller type aliases
+export type { IGetPageBySlugController } from "./interface-adapters/controllers/get-page-by-slug.controller";
+export type { IGetSiteSettingsController } from "./interface-adapters/controllers/get-site-settings.controller";
+
+// <gen:events>
+// <gen:realtime-channels>
+export {
+  marketingPagesManifest,
+  type MarketingPagesManifest,
+} from "./feature.manifest";
--- a/packages/marketing-pages/src/infrastructure/repositories/pages.repository.mock.test.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/pages.repository.mock.test.ts
@@ -0,0 +1,17 @@
+import { describe } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
+import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
+import {
+  pagesRepositoryContract,
+  CONTRACT_PAGES_SEED,
+} from "@/__contracts__/pages-repository.contract";
+
+describe("MockPagesRepository", () => {
+  const tracer = new RecordingTracer();
+  // Pre-seed with the contract fixtures so the contract assertions find what
+  // they expect (an "about" published page and a "draft-page" draft page).
+  pagesRepositoryContract.run(
+    () => new MockPagesRepository(CONTRACT_PAGES_SEED, tracer),
+    { tracer: () => tracer },
+  );
+});
--- a/packages/marketing-pages/src/infrastructure/repositories/pages.repository.mock.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/pages.repository.mock.ts
@@ -0,0 +1,86 @@
+import "reflect-metadata";
+import { injectable } from "inversify";
+import {
+  NoopTracer,
+  NoopLogger,
+  type ITracer,
+  type ILogger,
+} from "@repo/core-shared/instrumentation";
+
+import type { IPagesRepository } from "../../application/repositories/pages.repository.interface";
+import type { Page } from "../../entities/models/page";
+
+const SEED_DATE = new Date("2026-01-01T00:00:00.000Z");
+
+const DEFAULT_SEED: Page[] = [
+  {
+    id: "p1",
+    title: "About",
+    slug: "about",
+    hero: { heading: "About us" },
+    layout: [],
+    status: "published",
+    publishedAt: SEED_DATE,
+    seo: { title: "About — My App" },
+    createdAt: SEED_DATE,
+    updatedAt: SEED_DATE,
+  },
+];
+
+@injectable()
+export class MockPagesRepository implements IPagesRepository {
+  private _pages: Page[];
+  private tracer: ITracer;
+  private logger: ILogger;
+
+  constructor(
+    initialPages: Page[] = DEFAULT_SEED,
+    tracer: ITracer = new NoopTracer(),
+    logger: ILogger = new NoopLogger(),
+  ) {
+    this._pages = [...initialPages];
+    this.tracer = tracer;
+    this.logger = logger;
+    void this.logger; // currently unused; reserved for future mock-thrown captures
+  }
+
+  async getPageBySlug(slug: string): Promise<Page | undefined> {
+    return this.tracer.startSpan(
+      { name: "pages.getPageBySlug", op: "repository", attributes: { slug } },
+      async (span) => {
+        const found = this._pages.find((p) => p.slug === slug);
+        span.setAttribute("found", Boolean(found));
+        return found;
+      },
+    );
+  }
+
+  async getPages(options?: {
+    status?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<Page[]> {
+    return this.tracer.startSpan(
+      {
+        name: "pages.getPages",
+        op: "repository",
+        attributes: {
+          status: options?.status ?? null,
+          limit: options?.limit ?? null,
+          offset: options?.offset ?? null,
+        },
+      },
+      async (span) => {
+        let result = [...this._pages];
+        if (options?.status) {
+          result = result.filter((p) => p.status === options.status);
+        }
+        const offset = options?.offset ?? 0;
+        const limit = options?.limit ?? 50;
+        const page = result.slice(offset, offset + limit);
+        span.setAttribute("count", page.length);
+        return page;
+      },
+    );
+  }
+}
--- a/packages/marketing-pages/src/infrastructure/repositories/pages.repository.span.test.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/pages.repository.span.test.ts
@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+import {
+  RecordingTracer,
+  RecordingLogger,
+} from "@repo/core-testing/instrumentation";
+import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
+
+// Mock repo also wraps in spans.
+describe("MockPagesRepository emits spans", () => {
+  it("getPageBySlug emits one span with op='repository'", async () => {
+    const tracer = new RecordingTracer();
+    const logger = new RecordingLogger();
+    const repo = new MockPagesRepository([], tracer, logger);
+    await repo.getPageBySlug("about");
+    expect(tracer.spans).toHaveLength(1);
+    expect(tracer.spans[0]).toMatchObject({
+      name: "pages.getPageBySlug",
+      op: "repository",
+    });
+    expect(tracer.spans[0]!.attributes.slug).toBe("about");
+    expect(tracer.spans[0]!.attributes.found).toBe(false);
+  });
+
+  it("getPages emits a span with count attribute", async () => {
+    const tracer = new RecordingTracer();
+    const repo = new MockPagesRepository(undefined, tracer);
+    await repo.getPages({ limit: 10 });
+    expect(tracer.findSpan("pages.getPages")).toBeDefined();
+    expect(tracer.findSpan("pages.getPages")!.attributes.limit).toBe(10);
+    expect(
+      tracer.findSpan("pages.getPages")!.attributes.count,
+    ).toBeGreaterThanOrEqual(0);
+  });
+});
--- a/packages/marketing-pages/src/infrastructure/repositories/pages.repository.test.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/pages.repository.test.ts
@@ -0,0 +1,88 @@
+import { describe, vi } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
+import { PagesRepository } from "@/infrastructure/repositories/pages.repository";
+import {
+  pagesRepositoryContract,
+  CONTRACT_PAGES_SEED,
+} from "@/__contracts__/pages-repository.contract";
+import { stubPayloadConfig } from "@repo/core-testing/payload/stub-config";
+import type { Page } from "@/entities/models/page";
+
+// ---------------------------------------------------------------------------
+// In-memory Payload stub for pages (read-only collection)
+// ---------------------------------------------------------------------------
+
+function buildPayloadPagesStub(seed: Page[]) {
+  const store = new Map<string, Record<string, unknown>>(
+    seed.map((p) => [
+      p.id,
+      {
+        id: p.id,
+        title: p.title,
+        slug: p.slug,
+        hero: p.hero
+          ? {
+              heading: p.hero.heading,
+              subheading: p.hero.subheading,
+            }
+          : null,
+        layout: p.layout,
+        status: p.status,
+        publishedAt: p.publishedAt ? p.publishedAt.toISOString() : null,
+        seo: p.seo ? { title: p.seo.title, description: p.seo.description } : null,
+        createdAt: p.createdAt.toISOString(),
+        updatedAt: p.updatedAt.toISOString(),
+      },
+    ]),
+  );
+
+  return {
+    find: vi.fn(
+      async ({
+        where,
+        limit,
+      }: {
+        collection: string;
+        where?: { slug?: { equals: string }; status?: { equals: string } };
+        limit?: number;
+        page?: number;
+        overrideAccess?: boolean;
+      }) => {
+        let docs = Array.from(store.values());
+        if (where?.slug) {
+          docs = docs.filter((d) => d.slug === where.slug?.equals);
+        }
+        if (where?.status) {
+          docs = docs.filter((d) => d.status === where.status?.equals);
+        }
+        if (limit !== undefined) {
+          docs = docs.slice(0, limit);
+        }
+        return { docs };
+      },
+    ),
+  };
+}
+
+vi.mock("payload", () => ({
+  getPayload: vi.fn(),
+}));
+
+// ---------------------------------------------------------------------------
+// Contract suite
+// ---------------------------------------------------------------------------
+
+describe("PagesRepository", () => {
+  describe("contract", () => {
+    const tracer = new RecordingTracer();
+    pagesRepositoryContract.run(
+      async () => {
+        const stub = buildPayloadPagesStub(CONTRACT_PAGES_SEED);
+        const { getPayload } = await import("payload");
+        (getPayload as ReturnType<typeof vi.fn>).mockResolvedValue(stub);
+        return new PagesRepository(stubPayloadConfig, tracer);
+      },
+      { tracer: () => tracer },
+    );
+  });
+});
--- a/packages/marketing-pages/src/infrastructure/repositories/pages.repository.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/pages.repository.ts
@@ -0,0 +1,150 @@
+import "reflect-metadata";
+import { injectable } from "inversify";
+import { getPayload } from "payload";
+import type { SanitizedConfig } from "payload";
+import {
+  NoopTracer,
+  NoopLogger,
+  type ITracer,
+  type ILogger,
+} from "@repo/core-shared/instrumentation";
+
+import type { IPagesRepository } from "../../application/repositories/pages.repository.interface";
+import type { Page } from "../../entities/models/page";
+
+type PayloadPageDoc = {
+  id: string | number;
+  title?: string | null;
+  slug?: string | null;
+  hero?:
+    | {
+        heading?: string | null;
+        subheading?: string | null;
+        image?: string | number | { id: string | number } | null;
+      }
+    | null;
+  layout?: unknown[] | null;
+  status?: string | null;
+  publishedAt?: string | null;
+  seo?: { title?: string | null; description?: string | null } | null;
+  createdAt?: string | null;
+  updatedAt?: string | null;
+};
+
+function mapDoc(doc: PayloadPageDoc): Page {
+  const imageId =
+    doc.hero && typeof doc.hero.image === "object" && doc.hero.image !== null
+      ? String(doc.hero.image.id)
+      : doc.hero?.image != null
+        ? String(doc.hero.image)
+        : undefined;
+
+  return {
+    id: String(doc.id),
+    title: doc.title ?? "",
+    slug: doc.slug ?? "",
+    hero: {
+      heading: doc.hero?.heading ?? "",
+      subheading: doc.hero?.subheading ?? undefined,
+      imageId,
+    },
+    layout: doc.layout ?? [],
+    status: doc.status === "published" ? "published" : "draft",
+    publishedAt: doc.publishedAt ? new Date(doc.publishedAt) : null,
+    seo: {
+      title: doc.seo?.title ?? "",
+      description: doc.seo?.description ?? undefined,
+    },
+    createdAt: doc.createdAt ? new Date(doc.createdAt) : new Date(0),
+    updatedAt: doc.updatedAt ? new Date(doc.updatedAt) : new Date(0),
+  };
+}
+
+const FEATURE = "marketing-pages" as const;
+const REPO = "pages" as const;
+
+@injectable()
+export class PagesRepository implements IPagesRepository {
+  private config: SanitizedConfig;
+  private tracer: ITracer;
+  private logger: ILogger;
+
+  constructor(
+    config: SanitizedConfig,
+    tracer: ITracer = new NoopTracer(),
+    logger: ILogger = new NoopLogger(),
+  ) {
+    this.config = config;
+    this.tracer = tracer;
+    this.logger = logger;
+  }
+
+  async getPageBySlug(slug: string): Promise<Page | undefined> {
+    return this.tracer.startSpan(
+      { name: "pages.getPageBySlug", op: "repository", attributes: { slug } },
+      async (span) => {
+        try {
+          const payload = await getPayload({ config: this.config });
+          const result = await payload.find({
+            collection: "pages",
+            where: { slug: { equals: slug } },
+            limit: 1,
+            overrideAccess: true,
+          });
+          const doc = result.docs[0] as PayloadPageDoc | undefined;
+          span.setAttribute("found", Boolean(doc));
+          return doc ? mapDoc(doc) : undefined;
+        } catch (err) {
+          this.logger.captureException(err, {
+            tags: { feature: FEATURE, repo: REPO, method: "getPageBySlug" },
+          });
+          span.setStatus("error", err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+      },
+    );
+  }
+
+  async getPages(options?: {
+    status?: string;
+    limit?: number;
+    offset?: number;
+  }): Promise<Page[]> {
+    return this.tracer.startSpan(
+      {
+        name: "pages.getPages",
+        op: "repository",
+        attributes: {
+          status: options?.status ?? null,
+          limit: options?.limit ?? null,
+          offset: options?.offset ?? null,
+        },
+      },
+      async (span) => {
+        try {
+          const payload = await getPayload({ config: this.config });
+          const where: Record<string, { equals: string }> = {};
+          if (options?.status) where.status = { equals: options.status };
+          const result = await payload.find({
+            collection: "pages",
+            where: where as never,
+            limit: options?.limit ?? 50,
+            page: options?.offset
+              ? Math.floor(options.offset / (options.limit ?? 50)) + 1
+              : 1,
+            overrideAccess: true,
+          });
+          const pages = result.docs.map((d) => mapDoc(d as PayloadPageDoc));
+          span.setAttribute("count", pages.length);
+          return pages;
+        } catch (err) {
+          this.logger.captureException(err, {
+            tags: { feature: FEATURE, repo: REPO, method: "getPages" },
+          });
+          span.setStatus("error", err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+      },
+    );
+  }
+}
--- a/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.mock.test.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.mock.test.ts
@@ -0,0 +1,12 @@
+import { describe } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
+import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
+import { siteSettingsRepositoryContract } from "@/__contracts__/site-settings-repository.contract";
+
+describe("MockSiteSettingsRepository", () => {
+  const tracer = new RecordingTracer();
+  siteSettingsRepositoryContract.run(
+    () => new MockSiteSettingsRepository(tracer),
+    { tracer: () => tracer },
+  );
+});
--- a/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.mock.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.mock.ts
@@ -0,0 +1,39 @@
+import "reflect-metadata";
+import { injectable } from "inversify";
+import {
+  NoopTracer,
+  NoopLogger,
+  type ITracer,
+  type ILogger,
+} from "@repo/core-shared/instrumentation";
+
+import type { ISiteSettingsRepository } from "../../application/repositories/site-settings.repository.interface";
+import type { SiteSettings } from "../../entities/models/site-settings";
+
+@injectable()
+export class MockSiteSettingsRepository implements ISiteSettingsRepository {
+  private tracer: ITracer;
+  private logger: ILogger;
+
+  constructor(
+    tracer: ITracer = new NoopTracer(),
+    logger: ILogger = new NoopLogger(),
+  ) {
+    this.tracer = tracer;
+    this.logger = logger;
+    void this.logger; // currently unused; reserved for future mock-thrown captures
+  }
+
+  async getSiteSettings(): Promise<SiteSettings> {
+    return this.tracer.startSpan(
+      { name: "site-settings.getSiteSettings", op: "repository", attributes: {} },
+      async (span) => {
+        span.setAttribute("found", true);
+        return {
+          siteName: "My App",
+          siteDescription: "A vertical-feature monorepo template",
+        };
+      },
+    );
+  }
+}
--- a/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.span.test.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.span.test.ts
@@ -0,0 +1,22 @@
+import { describe, it, expect } from "vitest";
+import {
+  RecordingTracer,
+  RecordingLogger,
+} from "@repo/core-testing/instrumentation";
+import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
+
+// Mock repo also wraps in spans.
+describe("MockSiteSettingsRepository emits spans", () => {
+  it("getSiteSettings emits one span with op='repository'", async () => {
+    const tracer = new RecordingTracer();
+    const logger = new RecordingLogger();
+    const repo = new MockSiteSettingsRepository(tracer, logger);
+    await repo.getSiteSettings();
+    expect(tracer.spans).toHaveLength(1);
+    expect(tracer.spans[0]).toMatchObject({
+      name: "site-settings.getSiteSettings",
+      op: "repository",
+    });
+    expect(tracer.spans[0]!.attributes.found).toBe(true);
+  });
+});
--- a/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.test.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.test.ts
@@ -0,0 +1,45 @@
+import { describe, vi } from "vitest";
+import { RecordingTracer } from "@repo/core-testing/instrumentation";
+import { SiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository";
+import { siteSettingsRepositoryContract } from "@/__contracts__/site-settings-repository.contract";
+import { stubPayloadConfig } from "@repo/core-testing/payload/stub-config";
+
+// ---------------------------------------------------------------------------
+// In-memory Payload stub for site-settings (Global)
+// ---------------------------------------------------------------------------
+
+function buildSiteSettingsStub() {
+  const globalData: Record<string, unknown> = {
+    siteName: "Contract Site",
+    siteDescription: "A site for contract testing",
+  };
+
+  return {
+    findGlobal: vi.fn(async () => {
+      return { ...globalData };
+    }),
+  };
+}
+
+vi.mock("payload", () => ({
+  getPayload: vi.fn(),
+}));
+
+// ---------------------------------------------------------------------------
+// Contract suite
+// ---------------------------------------------------------------------------
+
+describe("SiteSettingsRepository", () => {
+  describe("contract", () => {
+    const tracer = new RecordingTracer();
+    siteSettingsRepositoryContract.run(
+      async () => {
+        const stub = buildSiteSettingsStub();
+        const { getPayload } = await import("payload");
+        (getPayload as ReturnType<typeof vi.fn>).mockResolvedValue(stub);
+        return new SiteSettingsRepository(stubPayloadConfig, tracer);
+      },
+      { tracer: () => tracer },
+    );
+  });
+});
--- a/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.ts
+++ b/packages/marketing-pages/src/infrastructure/repositories/site-settings.repository.ts
@@ -0,0 +1,64 @@
+import "reflect-metadata";
+import { injectable } from "inversify";
+import { getPayload } from "payload";
+import type { SanitizedConfig } from "payload";
+import {
+  NoopTracer,
+  NoopLogger,
+  type ITracer,
+  type ILogger,
+} from "@repo/core-shared/instrumentation";
+
+import type { ISiteSettingsRepository } from "../../application/repositories/site-settings.repository.interface";
+import type { SiteSettings } from "../../entities/models/site-settings";
+
+type PayloadSiteSettings = {
+  siteName?: string | null;
+  siteDescription?: string | null;
+};
+
+const FEATURE = "marketing-pages" as const;
+const REPO = "site-settings" as const;
+
+@injectable()
+export class SiteSettingsRepository implements ISiteSettingsRepository {
+  private config: SanitizedConfig;
+  private tracer: ITracer;
+  private logger: ILogger;
+
+  constructor(
+    config: SanitizedConfig,
+    tracer: ITracer = new NoopTracer(),
+    logger: ILogger = new NoopLogger(),
+  ) {
+    this.config = config;
+    this.tracer = tracer;
+    this.logger = logger;
+  }
+
+  async getSiteSettings(): Promise<SiteSettings> {
+    return this.tracer.startSpan(
+      { name: "site-settings.getSiteSettings", op: "repository", attributes: {} },
+      async (span) => {
+        try {
+          const payload = await getPayload({ config: this.config });
+          const doc = (await payload.findGlobal({
+            slug: "site-settings",
+            overrideAccess: true,
+          })) as PayloadSiteSettings;
+          span.setAttribute("found", true);
+          return {
+            siteName: doc.siteName ?? "My App",
+            siteDescription: doc.siteDescription ?? undefined,
+          };
+        } catch (err) {
+          this.logger.captureException(err, {
+            tags: { feature: FEATURE, repo: REPO, method: "getSiteSettings" },
+          });
+          span.setStatus("error", err instanceof Error ? err.message : String(err));
+          throw err;
+        }
+      },
+    );
+  }
+}
--- a/packages/marketing-pages/src/infrastructure/services/recording-mailer.service.test.ts
+++ b/packages/marketing-pages/src/infrastructure/services/recording-mailer.service.test.ts
@@ -0,0 +1,20 @@
+import { describe, it, expect } from "vitest";
+import { RecordingMailerService } from "@/infrastructure/services/recording-mailer.service";
+
+describe("RecordingMailerService", () => {
+  it("records welcome calls", async () => {
+    const mailer = new RecordingMailerService();
+    await mailer.sendWelcome("u1", "u1@example.com");
+    expect(mailer.sent).toEqual([{ userId: "u1", email: "u1@example.com" }]);
+  });
+
+  it("preserves call order across multiple sends", async () => {
+    const mailer = new RecordingMailerService();
+    await mailer.sendWelcome("u1", "a@x");
+    await mailer.sendWelcome("u2", "b@x");
+    expect(mailer.sent).toEqual([
+      { userId: "u1", email: "a@x" },
+      { userId: "u2", email: "b@x" },
+    ]);
+  });
+});
--- a/packages/marketing-pages/src/infrastructure/services/recording-mailer.service.ts
+++ b/packages/marketing-pages/src/infrastructure/services/recording-mailer.service.ts
@@ -0,0 +1,9 @@
+import type { IMailerService } from "../../application/services/mailer.service.interface";
+
+export class RecordingMailerService implements IMailerService {
+  readonly sent: { userId: string; email: string }[] = [];
+
+  async sendWelcome(userId: string, email: string): Promise<void> {
+    this.sent.push({ userId, email });
+  }
+}
--- a/packages/marketing-pages/src/integrations/api/procedures.ts
+++ b/packages/marketing-pages/src/integrations/api/procedures.ts
@@ -0,0 +1,12 @@
+import { t } from "@repo/core-shared/trpc/init";
+import { defineErrorMiddleware } from "@repo/core-shared/trpc/define-error-middleware";
+
+import { PageNotFoundError } from "../../entities/errors/page";
+import { InputParseError } from "../../entities/errors/common";
+
+export const marketingPagesProcedure = t.procedure.use(
+  defineErrorMiddleware([
+    [InputParseError, "BAD_REQUEST"],
+    [PageNotFoundError, "NOT_FOUND"],
+  ]),
+);
--- a/packages/marketing-pages/src/integrations/api/router.test.ts
+++ b/packages/marketing-pages/src/integrations/api/router.test.ts
@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { TRPCError } from "@trpc/server";
+import { marketingPagesContainer } from "@/di/container";
+import { MarketingPagesModule } from "@/di/module";
+import { marketingPagesRouter } from "@/integrations/api/router";
+
+describe("marketingPagesRouter", () => {
+  beforeEach(() => {
+    marketingPagesContainer.unbindAll();
+    marketingPagesContainer.load(MarketingPagesModule);
+  });
+
+  afterEach(() => {
+    marketingPagesContainer.unbindAll();
+  });
+
+  it("exposes pageBySlug + siteSettings procedures", () => {
+    const names = Object.keys(marketingPagesRouter._def.procedures);
+    expect(names).toContain("pageBySlug");
+    expect(names).toContain("siteSettings");
+  });
+
+  it("pageBySlug returns the seeded About page", async () => {
+    const caller = marketingPagesRouter.createCaller({});
+    const result = await caller.pageBySlug({ slug: "about" });
+    expect(result?.title).toBe("About");
+  });
+
+  it("siteSettings returns site name", async () => {
+    const caller = marketingPagesRouter.createCaller({});
+    const result = await caller.siteSettings({});
+    expect(result.siteName).toBe("My App");
+  });
+});
+
+describe("marketingPagesRouter error mapping", () => {
+  beforeEach(() => {
+    marketingPagesContainer.unbindAll();
+    marketingPagesContainer.load(MarketingPagesModule);
+  });
+
+  afterEach(() => {
+    marketingPagesContainer.unbindAll();
+  });
+
+  it("translates zod parse failure → BAD_REQUEST on pageBySlug", async () => {
+    const caller = marketingPagesRouter.createCaller({});
+    try {
+      await caller.pageBySlug({} as unknown as { slug: string });
+      throw new Error("expected throw");
+    } catch (e) {
+      expect(e).toBeInstanceOf(TRPCError);
+      expect((e as TRPCError).code).toBe("BAD_REQUEST");
+    }
+  });
+
+  it("returns undefined (not NOT_FOUND) for missing slug since use case returns undefined", async () => {
+    const caller = marketingPagesRouter.createCaller({});
+    const result = await caller.pageBySlug({ slug: "does-not-exist" });
+    expect(result).toBeUndefined();
+  });
+});
--- a/packages/marketing-pages/src/integrations/api/router.ts
+++ b/packages/marketing-pages/src/integrations/api/router.ts
@@ -0,0 +1,34 @@
+import { router } from "@repo/core-shared/trpc/init";
+
+import { marketingPagesContainer } from "../../di/container";
+import { MARKETING_PAGES_SYMBOLS } from "../../di/symbols";
+
+import { getPageBySlugInputSchema } from "../../application/use-cases/get-page-by-slug.use-case";
+import { getSiteSettingsInputSchema } from "../../application/use-cases/get-site-settings.use-case";
+
+import type { IGetPageBySlugController } from "../../interface-adapters/controllers/get-page-by-slug.controller";
+import type { IGetSiteSettingsController } from "../../interface-adapters/controllers/get-site-settings.controller";
+
+import { marketingPagesProcedure } from "./procedures";
+
+export const marketingPagesRouter = router({
+  pageBySlug: marketingPagesProcedure
+    .input(getPageBySlugInputSchema)
+    .query(({ input }) => {
+      const ctrl = marketingPagesContainer.get<IGetPageBySlugController>(
+        MARKETING_PAGES_SYMBOLS.IGetPageBySlugController,
+      );
+      return ctrl(input);
+    }),
+
+  siteSettings: marketingPagesProcedure
+    .input(getSiteSettingsInputSchema)
+    .query(({ input }) => {
+      const ctrl = marketingPagesContainer.get<IGetSiteSettingsController>(
+        MARKETING_PAGES_SYMBOLS.IGetSiteSettingsController,
+      );
+      return ctrl(input);
+    }),
+});
+
+export type MarketingPagesRouter = typeof marketingPagesRouter;
--- a/packages/marketing-pages/src/integrations/cms/collections/pages.ts
+++ b/packages/marketing-pages/src/integrations/cms/collections/pages.ts
@@ -0,0 +1,81 @@
+import type { CollectionConfig } from "payload";
+import { cta, seoFields, slugifyIfMissing } from "@repo/core-shared/payload";
+
+export const pages: CollectionConfig = {
+  slug: "pages",
+  custom: {
+    retention: {
+      purgeSchedule: "monthly",
+      postDeletion: {
+        duration: "P90D",
+        trigger: "after-deletion",
+        action: "hard-delete",
+      },
+    },
+  },
+  admin: {
+    useAsTitle: "title",
+    defaultColumns: ["title", "status", "updatedAt"],
+  },
+  hooks: {
+    beforeChange: [slugifyIfMissing],
+  },
+  versions: {
+    drafts: true,
+  },
+  fields: [
+    {
+      name: "title",
+      type: "text",
+      required: true,
+      maxLength: 255,
+    },
+    {
+      name: "slug",
+      type: "text",
+      unique: true,
+      admin: {
+        position: "sidebar",
+        description: "Auto-generated from title if left empty",
+      },
+    },
+    {
+      name: "hero",
+      type: "group",
+      fields: [
+        { name: "heading", type: "text", required: true },
+        { name: "subheading", type: "textarea" },
+        {
+          name: "image",
+          type: "upload",
+          relationTo: "media",
+        },
+      ],
+    },
+    {
+      name: "layout",
+      type: "blocks",
+      blocks: [cta],
+    },
+    {
+      name: "status",
+      type: "select",
+      options: [
+        { label: "Draft", value: "draft" },
+        { label: "Published", value: "published" },
+      ],
+      defaultValue: "draft",
+      required: true,
+      admin: { position: "sidebar" },
+    },
+    {
+      name: "publishedAt",
+      type: "date",
+      admin: {
+        position: "sidebar",
+        date: { pickerAppearance: "dayAndTime" },
+      },
+    },
+    seoFields,
+  ],
+};
--- a/packages/marketing-pages/src/integrations/cms/globals/site-settings.ts
+++ b/packages/marketing-pages/src/integrations/cms/globals/site-settings.ts
@@ -0,0 +1,30 @@
+import type { GlobalConfig } from "payload";
+
+export const siteSettings: GlobalConfig = {
+  slug: "site-settings",
+  custom: {
+    retention: {
+      purgeSchedule: "monthly",
+      postDeletion: {
+        duration: "P90D",
+        trigger: "after-deletion",
+        action: "hard-delete",
+      },
+    },
+  },
+  admin: {
+    group: "Settings",
+  },
+  fields: [
+    {
+      name: "siteName",
+      type: "text",
+      required: true,
+      defaultValue: "My App",
+    },
+    {
+      name: "siteDescription",
+      type: "textarea",
+    },
+  ],
+};
--- a/packages/marketing-pages/src/integrations/cms/index.ts
+++ b/packages/marketing-pages/src/integrations/cms/index.ts
@@ -0,0 +1,5 @@
+export { pages } from "./collections/pages";
+export { siteSettings } from "./globals/site-settings";
+// <gen:job-tasks>
+export { sendWelcomeEmailTask } from "./jobs/send-welcome-email.task";
+export { onAuthUserSignedUpEventTask } from "./jobs/__events-auth-user-signed-up.task";
--- a/packages/marketing-pages/src/integrations/cms/jobs/__events-auth-user-signed-up.task.ts
+++ b/packages/marketing-pages/src/integrations/cms/jobs/__events-auth-user-signed-up.task.ts
@@ -0,0 +1,26 @@
+// packages/marketing-pages/src/integrations/cms/jobs/__events-auth-user-signed-up.task.ts
+// Generated by `gen event consume`. The PayloadJobsEventBus enqueues this task
+// when auth publishes `auth.user.signed-up`. The handler
+// resolves the consumer's wrapped event handler from the per-feature container
+// and invokes it with the typed payload.
+import type { TaskConfig } from "payload";
+import { marketingPagesContainer } from "../../../di/container";
+import { MARKETING_PAGES_SYMBOLS } from "../../../di/symbols";
+import type { IOnAuthUserSignedUpHandler } from "../../../events/handlers/on-auth-user-signed-up.handler";
+import type { UserSignedUpEvent } from "@repo/auth";
+
+export const onAuthUserSignedUpEventTask: TaskConfig<{
+  input: UserSignedUpEvent;
+  output: object;
+}> = {
+  slug: "__events.auth.user.signed-up.marketing-pages",
+  inputSchema: [],
+  retries: { attempts: 3, backoff: { type: "exponential", delay: 1000 } },
+  handler: async ({ input }) => {
+    const handler = marketingPagesContainer.get<IOnAuthUserSignedUpHandler>(
+      MARKETING_PAGES_SYMBOLS.IOnAuthUserSignedUpHandler,
+    );
+    await handler(input);
+    return { output: {} };
+  },
+};
--- a/packages/marketing-pages/src/integrations/cms/jobs/send-welcome-email.task.ts
+++ b/packages/marketing-pages/src/integrations/cms/jobs/send-welcome-email.task.ts
@@ -0,0 +1,22 @@
+// packages/marketing-pages/src/integrations/cms/jobs/send-welcome-email.task.ts
+import type { TaskConfig } from "payload";
+import { marketingPagesContainer } from "../../../di/container";
+import { MARKETING_PAGES_SYMBOLS } from "../../../di/symbols";
+import type { ISendWelcomeEmailJob } from "../../../jobs/send-welcome-email.job";
+import type { SendWelcomeEmailInput } from "../../../jobs/send-welcome-email.job";
+
+export const sendWelcomeEmailTask: TaskConfig<{
+  input: SendWelcomeEmailInput;
+  output: object;
+}> = {
+  slug: "marketing-pages.send-welcome-email",
+  inputSchema: [],
+  retries: { attempts: 3, backoff: { type: "exponential", delay: 1000 } },
+  handler: async ({ input }) => {
+    const job = marketingPagesContainer.get<ISendWelcomeEmailJob>(
+      MARKETING_PAGES_SYMBOLS.ISendWelcomeEmailJob,
+    );
+    await job(input);
+    return { output: {} };
+  },
+};
--- a/packages/marketing-pages/src/interface-adapters/controllers/get-page-by-slug.controller.test.ts
+++ b/packages/marketing-pages/src/interface-adapters/controllers/get-page-by-slug.controller.test.ts
@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { getPageBySlugController } from "@/interface-adapters/controllers/get-page-by-slug.controller";
+import { getPageBySlugUseCase } from "@/application/use-cases/get-page-by-slug.use-case";
+import { MockPagesRepository } from "@/infrastructure/repositories/pages.repository.mock";
+import { InputParseError } from "@/entities/errors/common";
+
+describe("getPageBySlugController", () => {
+  it("returns the page when found", async () => {
+    const repo = new MockPagesRepository();
+    const useCase = getPageBySlugUseCase(repo);
+    const controller = getPageBySlugController(useCase);
+
+    const result = await controller({ slug: "about" });
+    expect(result?.slug).toBe("about");
+  });
+
+  it("throws InputParseError on missing slug", async () => {
+    const repo = new MockPagesRepository();
+    const useCase = getPageBySlugUseCase(repo);
+    const controller = getPageBySlugController(useCase);
+
+    await expect(
+      controller({}),
+    ).rejects.toBeInstanceOf(InputParseError);
+  });
+
+  it("returns undefined when slug not found", async () => {
+    const repo = new MockPagesRepository();
+    const useCase = getPageBySlugUseCase(repo);
+    const controller = getPageBySlugController(useCase);
+
+    const result = await controller({ slug: "nonexistent" });
+    expect(result).toBeUndefined();
+  });
+});
--- a/packages/marketing-pages/src/interface-adapters/controllers/get-page-by-slug.controller.ts
+++ b/packages/marketing-pages/src/interface-adapters/controllers/get-page-by-slug.controller.ts
@@ -0,0 +1,24 @@
+import { InputParseError } from "../../entities/errors/common";
+import {
+  getPageBySlugInputSchema,
+  type GetPageBySlugOutput,
+  type IGetPageBySlugUseCase,
+} from "../../application/use-cases/get-page-by-slug.use-case";
+
+function presenter(value: GetPageBySlugOutput) {
+  return value;
+}
+
+export type IGetPageBySlugController = ReturnType<typeof getPageBySlugController>;
+
+export const getPageBySlugController =
+  (getPageBySlugUseCase: IGetPageBySlugUseCase) =>
+  async (input: unknown): Promise<ReturnType<typeof presenter> | undefined> => {
+    const parsed = getPageBySlugInputSchema.safeParse(input);
+    if (!parsed.success) {
+      throw new InputParseError("Invalid get-page-by-slug input", { cause: parsed.error });
+    }
+    const result = await getPageBySlugUseCase(parsed.data);
+    if (result === undefined) return undefined;
+    return presenter(result);
+  };
--- a/packages/marketing-pages/src/interface-adapters/controllers/get-site-settings.controller.test.ts
+++ b/packages/marketing-pages/src/interface-adapters/controllers/get-site-settings.controller.test.ts
@@ -0,0 +1,26 @@
+import { describe, it, expect } from "vitest";
+import { getSiteSettingsController } from "@/interface-adapters/controllers/get-site-settings.controller";
+import { getSiteSettingsUseCase } from "@/application/use-cases/get-site-settings.use-case";
+import { MockSiteSettingsRepository } from "@/infrastructure/repositories/site-settings.repository.mock";
+import { InputParseError } from "@/entities/errors/common";
+
+describe("getSiteSettingsController", () => {
+  it("returns site settings", async () => {
+    const repo = new MockSiteSettingsRepository();
+    const useCase = getSiteSettingsUseCase(repo);
+    const controller = getSiteSettingsController(useCase);
+
+    const result = await controller({});
+    expect(result.siteName).toBe("My App");
+  });
+
+  it("throws InputParseError on unknown fields (strict schema)", async () => {
+    const repo = new MockSiteSettingsRepository();
+    const useCase = getSiteSettingsUseCase(repo);
+    const controller = getSiteSettingsController(useCase);
+
+    await expect(controller({ unknownField: 1 })).rejects.toThrow(
+      InputParseError,
+    );
+  });
+});
--- a/packages/marketing-pages/src/interface-adapters/controllers/get-site-settings.controller.ts
+++ b/packages/marketing-pages/src/interface-adapters/controllers/get-site-settings.controller.ts
@@ -0,0 +1,23 @@
+import { InputParseError } from "../../entities/errors/common";
+import {
+  getSiteSettingsInputSchema,
+  type GetSiteSettingsOutput,
+  type IGetSiteSettingsUseCase,
+} from "../../application/use-cases/get-site-settings.use-case";
+
+function presenter(value: GetSiteSettingsOutput) {
+  return value;
+}
+
+export type IGetSiteSettingsController = ReturnType<typeof getSiteSettingsController>;
+
+export const getSiteSettingsController =
+  (getSiteSettingsUseCase: IGetSiteSettingsUseCase) =>
+  async (input: unknown): Promise<ReturnType<typeof presenter>> => {
+    const parsed = getSiteSettingsInputSchema.safeParse(input);
+    if (!parsed.success) {
+      throw new InputParseError("Invalid get-site-settings input", { cause: parsed.error });
+    }
+    const result = await getSiteSettingsUseCase(parsed.data);
+    return presenter(result);
+  };
--- a/packages/marketing-pages/src/jobs/send-welcome-email.job.test.ts
+++ b/packages/marketing-pages/src/jobs/send-welcome-email.job.test.ts
@@ -0,0 +1,37 @@
+// packages/marketing-pages/src/jobs/send-welcome-email.job.test.ts
+import { describe, it, expect } from "vitest";
+import { sendWelcomeEmailJob, sendWelcomeEmailInputSchema } from "@/jobs/send-welcome-email.job";
+import { RecordingMailerService } from "@/infrastructure/services/recording-mailer.service";
+
+describe("sendWelcomeEmailJob", () => {
+  it("rejects unknown input fields", async () => {
+    const mailer = new RecordingMailerService();
+    const job = sendWelcomeEmailJob(mailer);
+    await expect(job({ unexpectedField: 1 } as never)).rejects.toThrow();
+  });
+
+  it("rejects input missing required fields", async () => {
+    const mailer = new RecordingMailerService();
+    const job = sendWelcomeEmailJob(mailer);
+    await expect(job({ userId: "u1" } as never)).rejects.toThrow();
+  });
+
+  it("rejects invalid email", async () => {
+    const mailer = new RecordingMailerService();
+    const job = sendWelcomeEmailJob(mailer);
+    await expect(
+      job({ userId: "u1", email: "not-an-email" }),
+    ).rejects.toThrow();
+  });
+
+  it("sends a welcome email via the mailer on valid input", async () => {
+    const mailer = new RecordingMailerService();
+    const job = sendWelcomeEmailJob(mailer);
+    await job({ userId: "u1", email: "u1@example.com" });
+    expect(mailer.sent).toEqual([{ userId: "u1", email: "u1@example.com" }]);
+  });
+
+  it("references its input schema", () => {
+    expect(sendWelcomeEmailInputSchema).toBeDefined();
+  });
+});
--- a/packages/marketing-pages/src/jobs/send-welcome-email.job.ts
+++ b/packages/marketing-pages/src/jobs/send-welcome-email.job.ts
@@ -0,0 +1,20 @@
+// packages/marketing-pages/src/jobs/send-welcome-email.job.ts
+import { z } from "zod";
+import type { IMailerService } from "../application/services/mailer.service.interface";
+
+export const sendWelcomeEmailInputSchema = z
+  .object({
+    userId: z.string(),
+    email: z.string().email(),
+  })
+  .strict();
+
+export type SendWelcomeEmailInput = z.infer<typeof sendWelcomeEmailInputSchema>;
+export type ISendWelcomeEmailJob = ReturnType<typeof sendWelcomeEmailJob>;
+
+export const sendWelcomeEmailJob =
+  (mailer: IMailerService) =>
+  async (input: SendWelcomeEmailInput): Promise<void> => {
+    sendWelcomeEmailInputSchema.parse(input);
+    await mailer.sendWelcome(input.userId, input.email);
+  };
--- a/packages/marketing-pages/src/ui/components/page-content.client.tsx
+++ b/packages/marketing-pages/src/ui/components/page-content.client.tsx
@@ -0,0 +1,25 @@
+"use client";
+
+import { usePageBySlug } from "../hooks/use-page-by-slug";
+import { PageHero } from "./page-hero";
+
+export type PageContentProps = {
+  slug: string;
+};
+
+export function PageContent({ slug }: PageContentProps) {
+  const { data: page } = usePageBySlug(slug);
+
+  if (!page) return null;
+
+  return (
+    <article className="mx-auto max-w-3xl">
+      <PageHero hero={page.hero} />
+      <div className="prose text-foreground">
+        <pre className="whitespace-pre-wrap text-sm">
+          {JSON.stringify(page.layout, null, 2)}
+        </pre>
+      </div>
+    </article>
+  );
+}
--- a/packages/marketing-pages/src/ui/components/page-content.server.tsx
+++ b/packages/marketing-pages/src/ui/components/page-content.server.tsx
@@ -0,0 +1,35 @@
+import { dehydrate, HydrationBoundary } from "@tanstack/react-query";
+import { getQueryClient } from "@repo/core-trpc";
+import { marketingPagesContainer } from "../../di/container";
+import { MARKETING_PAGES_SYMBOLS } from "../../di/symbols";
+import type { IGetPageBySlugController } from "../../interface-adapters/controllers/get-page-by-slug.controller";
+import { PageContent as PageContentClient } from "./page-content.client";
+
+export async function PageContent({ slug }: { slug: string }) {
+  const controller = marketingPagesContainer.get<IGetPageBySlugController>(
+    MARKETING_PAGES_SYMBOLS.IGetPageBySlugController,
+  );
+  const page = await controller({ slug });
+  const queryClient = getQueryClient();
+  queryClient.setQueryData(
+    ["marketingPages", "pageBySlug", { input: { slug } }],
+    page,
+  );
+
+  if (!page) {
+    return (
+      <main className="mx-auto max-w-3xl px-6 py-8">
+        <h1 className="text-3xl font-bold text-foreground">Not found</h1>
+        <p className="mt-2 text-muted-foreground">
+          This page hasn&apos;t been published yet.
+        </p>
+      </main>
+    );
+  }
+
+  return (
+    <HydrationBoundary state={dehydrate(queryClient)}>
+      <PageContentClient slug={slug} />
+    </HydrationBoundary>
+  );
+}
--- a/packages/marketing-pages/src/ui/components/page-hero.tsx
+++ b/packages/marketing-pages/src/ui/components/page-hero.tsx
@@ -0,0 +1,16 @@
+import type { Hero } from "../../entities/models/page";
+
+export type PageHeroProps = {
+  hero: Hero;
+};
+
+export function PageHero({ hero }: PageHeroProps) {
+  return (
+    <header className="mb-8">
+      <h1 className="text-3xl font-bold text-foreground">{hero.heading}</h1>
+      {hero.subheading ? (
+        <p className="mt-2 text-lg text-muted-foreground">{hero.subheading}</p>
+      ) : null}
+    </header>
+  );
+}
--- a/packages/marketing-pages/src/ui/hooks/use-page-by-slug.ts
+++ b/packages/marketing-pages/src/ui/hooks/use-page-by-slug.ts
@@ -0,0 +1,12 @@
+"use client";
+
+import { useSuspenseQuery } from "@tanstack/react-query";
+import { useTRPC } from "@repo/core-trpc";
+import type { Page } from "../../entities/models/page";
+
+export function usePageBySlug(slug: string) {
+  const trpc = useTRPC();
+  return useSuspenseQuery(
+    trpc.marketingPages.pageBySlug.queryOptions({ slug }),
+  ) as { data: Page | null };
+}
--- a/packages/marketing-pages/src/ui/hooks/use-site-settings.ts
+++ b/packages/marketing-pages/src/ui/hooks/use-site-settings.ts
@@ -0,0 +1,12 @@
+"use client";
+
+import { useSuspenseQuery } from "@tanstack/react-query";
+import { useTRPC } from "@repo/core-trpc";
+import type { SiteSettings } from "../../entities/models/site-settings";
+
+export function useSiteSettings() {
+  const trpc = useTRPC();
+  return useSuspenseQuery(
+    trpc.marketingPages.siteSettings.queryOptions({}),
+  ) as { data: SiteSettings };
+}
--- a/packages/marketing-pages/src/ui/index.ts
+++ b/packages/marketing-pages/src/ui/index.ts
@@ -0,0 +1,5 @@
+export { pageBySlugQuery, siteSettingsQuery } from "./query";
+export { usePageBySlug } from "./hooks/use-page-by-slug";
+export { useSiteSettings } from "./hooks/use-site-settings";
+export { PageHero, type PageHeroProps } from "./components/page-hero";
+export { PageContent } from "./components/page-content.server";
--- a/packages/marketing-pages/src/ui/query.ts
+++ b/packages/marketing-pages/src/ui/query.ts
@@ -0,0 +1,14 @@
+type TrpcClient = {
+  marketingPages: {
+    pageBySlug: { queryOptions: (input: { slug: string }) => unknown };
+    siteSettings: { queryOptions: () => unknown };
+  };
+};
+
+export function pageBySlugQuery(client: TrpcClient, slug: string) {
+  return client.marketingPages.pageBySlug.queryOptions({ slug });
+}
+
+export function siteSettingsQuery(client: TrpcClient) {
+  return client.marketingPages.siteSettings.queryOptions();
+}