create-ailk 0.1.1 → 0.3.0

package/templates/apps/api/src/routes/project-listings/__tests__/site-key.test.ts

@@ -1,3 +1,6 @@
+// Not marked oss: false (D-48/#5366 escalation) — tests the
+// always-shipping project-listings anonymous surface; see
+// routes/project-listings/me.ts's header comment.
 /**
  * @file site-key.test.ts
  *
@@ -28,6 +31,13 @@ jest.mock("../../../lib/prisma.js");
 
 jest.mock("@working-theory/email", () => ({
   sendLeadNotification: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-test" }),
+  // #5406 — `start` now reaches the resume email. Declared here for the reason
+  // docs/lessons/project-listings/04 records: a mock factory that omits an
+  // export the code under test calls leaves it `undefined` at the callsite.
+  // These suites configure no `resumeEmail`, so the send short-circuits before
+  // this is reached; it is declared so a future fixture that DOES configure
+  // one fails on its assertion rather than on a missing mock.
+  sendListingResumeEmail: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-resume" }),
 }));
 
 jest.mock("@working-theory/license", () => ({
@@ -109,6 +119,17 @@ function installStore(): void {
     },
   );
 
+  // #5275 — the grant write `start` makes after the row. Append-only; it only
+  // needs to resolve here (drafts.test.ts asserts on what it is called with).
+  (prisma.consentGrant.createMany as jest.Mock).mockImplementation(
+    ({ data }: { data: Row[] }) => Promise.resolve({ count: data.length }),
+  );
+
+  // #5275 — `start` writes the row and its grant in one interactive
+  // transaction; the mock hands the same store-backed client through.
+  (prisma.$transaction as jest.Mock).mockImplementation(
+    async (fn: (tx: typeof prisma) => Promise<unknown>) => fn(prisma),
+  );
   (prisma.projectListing.create as jest.Mock).mockImplementation(({ data }: { data: Row }) => {
     const now = new Date();
     const row: Row = {
@@ -125,6 +146,13 @@ function installStore(): void {
       anythingElse: null,
       address: null,
       questions: null,
+      // #5407 — a row written before the columns existed, and a freshly
+      // started draft on a site that asks for one name line: parts null,
+      // no phone, no verification stamp.
+      founderFirstName: null,
+      founderLastName: null,
+      founderPhone: null,
+      emailVerifiedAt: null,
       founderCompany: null,
       leadId: null,
       headline: null,
@@ -175,6 +203,13 @@ function seedActiveListing(siteId: string, slug: string): void {
     address: "1 Founder Way",
     founderName: "Some Founder",
     founderEmail: "founder@example.com",
+    // #5407 — a row written before the columns existed, and a freshly
+    // started draft on a site that asks for one name line: parts null,
+    // no phone, no verification stamp.
+    founderFirstName: null,
+    founderLastName: null,
+    founderPhone: null,
+    emailVerifiedAt: null,
     founderCompany: null,
     questions: null,
     logoMarkUrl: null,

package/templates/apps/api/src/routes/project-listings/__tests__/structured-address.test.ts

@@ -0,0 +1,484 @@
+// Not marked oss: false (D-48/#5366 escalation) — tests the
+// always-shipping project-listings anonymous surface; see
+// routes/project-listings/me.ts's header comment.
+/**
+ * @file structured-address.test.ts
+ *
+ * THE ACCEPTANCE GATE for the structured founder address (#5279).
+ *
+ * The application collected a whole business address in ONE free-text box.
+ * It now renders a fieldset, and the payload field `address` became a UNION:
+ * the legacy display STRING or the structured PARTS. The row keeps `address`
+ * as the single-line DISPLAY string and gains six nullable part columns
+ * beside it, which the server writes — and composes the display line from —
+ * in `draftUpdateData`.
+ *
+ * Two properties carry this change, and both look fine when broken, which is
+ * why they each get a test that fails when they are:
+ *
+ *   1. The parts arrive as PARTS. A patch carrying the structured object must
+ *      land six DISTINCT column values, not one concatenated string in
+ *      `address` with the columns left null. A service that quietly stringified
+ *      the object would produce a row that reads correctly on the listing page
+ *      and has silently thrown away the split the fieldset exists to capture.
+ *
+ *   2. A legacy free-text address round-trips CHARACTER-FOR-CHARACTER with its
+ *      parts null. Nothing may ever split an existing `address` into parts:
+ *      address parsing guesses, and a wrong guess silently corrupts the party
+ *      identification the listing's privacy notice points at (#5036 D6), with
+ *      nothing on the row to mark it as invented. A null part is honest; a
+ *      guessed one is not.
+ *
+ * Same harness as `configured-application.test.ts` and `drafts.test.ts`: real
+ * routes, real services, mocked `lib/prisma.js` over a small in-memory row
+ * store, `routeLead` running for real against a per-test temp path.
+ */
+
+// eslint-disable-next-line no-restricted-syntax -- prisma is a DB boundary; __mocks__/prisma.ts activates the auto-mock
+jest.mock("../../../lib/prisma.js");
+
+jest.mock("@working-theory/email", () => ({
+  sendLeadNotification: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-test" }),
+  // #5406 — `start` now reaches the resume email. Declared here for the reason
+  // docs/lessons/project-listings/04 records: a mock factory that omits an
+  // export the code under test calls leaves it `undefined` at the callsite.
+  // These suites configure no `resumeEmail`, so the send short-circuits before
+  // this is reached; it is declared so a future fixture that DOES configure
+  // one fails on its assertion rather than on a missing mock.
+  sendListingResumeEmail: jest.fn().mockResolvedValue({ ok: true, messageId: "msg-resume" }),
+}));
+
+jest.mock("@working-theory/license", () => ({
+  checkLicense: jest.fn().mockResolvedValue({
+    tier: "free",
+    plan: null,
+    features: [],
+    expiresAt: null,
+    revoked: false,
+  }),
+}));
+
+import Fastify from "fastify";
+import type { FastifyInstance } from "fastify";
+
+import { setupLeadFileEnv } from "../../../__tests__/factories/lead-fixture";
+import { prisma } from "../../../lib/prisma.js";
+import { patchProjectListingDraftRoute } from "../patch-draft.js";
+import { startProjectListingRoute } from "../start.js";
+import { submitProjectListingRoute } from "../submit.js";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+const SITE_ID = "site-1";
+const SITE_KEY = "pk-site-1";
+
+const opt = (value: string, label: string) => ({ value, label });
+
+const VALID_QUESTIONS = {
+  q2: {
+    prompt: "Why are you here?",
+    options: [opt("scale", "Scaling my team"), opt("just-curious", "Just curious")],
+  },
+  q3: { prompt: "Stage?", options: [opt("a", "A"), opt("b", "B"), opt("c", "C")] },
+  q4: { prompt: "Team size?", options: [opt("a", "A"), opt("b", "B"), opt("c", "C")] },
+  q5: {
+    prompt: "Urgency?",
+    options: [opt("urgent", "Now"), opt("planning", "Soon"), opt("exploring", "Someday")],
+  },
+  q6: {
+    prompt: "Pain?",
+    options: [
+      opt("low", "Low"),
+      opt("medium", "Medium"),
+      opt("high", "High"),
+      opt("critical", "Critical"),
+    ],
+  },
+  q7: { prompt: "Anything else?" },
+  extras: [],
+};
+
+const START_PAYLOAD = {
+  siteKey: SITE_KEY,
+  founderName: "Ada Founder",
+  founderEmail: "ada@example.com",
+  consent: true,
+};
+
+/** Everything the ten steps after step one collect, minus the address. */
+const APPLICATION_WITHOUT_ADDRESS = {
+  name: "My Project",
+  headline: "Ten words or fewer for the tile title here",
+  oneLiner: "A short sentence describing what the project does for its people.",
+  problem: "The problem is real and this describes it.",
+  product: "wireframes",
+  commitment: "part-time",
+  teamComposition: "co-founders",
+  faqs: [
+    { question: "Q one?", answer: "A one." },
+    { question: "Q two?", answer: "A two." },
+    { question: "Q three?", answer: "A three." },
+  ],
+  questions: VALID_QUESTIONS,
+};
+
+/** What `AddressFieldset` posts — six controls under six fixed keys. */
+const ADDRESS_PARTS = {
+  addressLine1: "221B Baker Street",
+  addressLine2: "Flat B",
+  city: "London",
+  region: "Greater London",
+  postalCode: "NW1 6XE",
+  country: "GB",
+};
+
+/**
+ * The display line the SERVER must compose from `ADDRESS_PARTS` — the parts
+ * in reading order, joined with ", ". Written out literally rather than by
+ * calling `composeAddressLine`, so a change to the joiner fails this test
+ * instead of travelling through it.
+ */
+const COMPOSED_ADDRESS_LINE =
+  "221B Baker Street, Flat B, London, Greater London, NW1 6XE, GB";
+
+/**
+ * An address a founder typed into the ONE free-text box, before #5279. It is
+ * not in the composed order, its parts are not separable by any rule, and
+ * nothing may ever try: it is here to be returned unchanged.
+ */
+const LEGACY_ADDRESS_LINE =
+  "221B Baker Street, Marylebone, London NW1 6XE, United Kingdom";
+
+// ─── The in-memory row store the Prisma mock is backed by ───────────────────
+
+type Row = Record<string, unknown>;
+
+let rows: Row[];
+let nextId: number;
+
+function matches(row: Row, where: Record<string, unknown>): boolean {
+  return Object.entries(where).every(([key, value]) => {
+    if (key === "OR") {
+      return (value as Record<string, unknown>[]).some((clause) => matches(row, clause));
+    }
+    if (value !== null && typeof value === "object" && !(value instanceof Date)) {
+      const clause = value as Record<string, unknown>;
+      if ("in" in clause) return (clause["in"] as unknown[]).includes(row[key]);
+      if ("not" in clause) return row[key] !== clause["not"];
+      if ("gt" in clause) return (row[key] as Date) > (clause["gt"] as Date);
+      if ("startsWith" in clause) {
+        return (
+          typeof row[key] === "string" &&
+          (row[key] as string).startsWith(clause["startsWith"] as string)
+        );
+      }
+    }
+    return row[key] === value;
+  });
+}
+
+function installStore(): void {
+  rows = [];
+  nextId = 1;
+
+  (prisma.lead.create as jest.Mock).mockImplementation(() =>
+    Promise.resolve({ id: `lead_00000000-0000-7000-8000-00000000000${nextId}` }),
+  );
+
+  (prisma.siteListingConfig.findUnique as jest.Mock).mockImplementation(
+    ({ where }: { where: { siteId?: string; publicKey?: string } }) => {
+      if (where.publicKey !== undefined) {
+        return Promise.resolve(where.publicKey === SITE_KEY ? { siteId: SITE_ID } : null);
+      }
+      // No config row — the platform defaults, which collect `address`.
+      return Promise.resolve(null);
+    },
+  );
+
+  // #5275 — the grant write `start` makes after the row. Append-only; it only
+  // needs to resolve here (drafts.test.ts asserts on what it is called with).
+  (prisma.consentGrant.createMany as jest.Mock).mockImplementation(
+    ({ data }: { data: Row[] }) => Promise.resolve({ count: data.length }),
+  );
+
+  // #5275 — `start` writes the row and its grant in one interactive
+  // transaction; the mock hands the same store-backed client through.
+  (prisma.$transaction as jest.Mock).mockImplementation(
+    async (fn: (tx: typeof prisma) => Promise<unknown>) => fn(prisma),
+  );
+
+  (prisma.projectListing.create as jest.Mock).mockImplementation(({ data }: { data: Row }) => {
+    const now = new Date();
+    const row: Row = {
+      id: `prjl_00000000-0000-7000-8000-00000000000${nextId++}`,
+      slug: null,
+      name: null,
+      oneLiner: null,
+      problem: null,
+      url: null,
+      product: null,
+      commitment: null,
+      teamComposition: null,
+      faqs: null,
+      anythingElse: null,
+      address: null,
+      // #5279 — a freshly-started draft has no parts, exactly like every row
+      // written before the columns existed.
+      addressLine1: null,
+      addressLine2: null,
+      addressCity: null,
+      addressRegion: null,
+      addressPostalCode: null,
+      addressCountry: null,
+      questions: null,
+      // #5407 — a row written before the columns existed, and a freshly
+      // started draft on a site that asks for one name line: parts null,
+      // no phone, no verification stamp.
+      founderFirstName: null,
+      founderLastName: null,
+      founderPhone: null,
+      emailVerifiedAt: null,
+      founderCompany: null,
+      leadId: null,
+      headline: null,
+      logoMarkUrl: null,
+      logoWordmarkUrl: null,
+      featured: false,
+      decidedAt: null,
+      decidedBy: null,
+      issueUrl: null,
+      experimentKey: null,
+      windowEndsAt: null,
+      createdAt: now,
+      updatedAt: now,
+      ...data,
+    };
+    rows.push(row);
+    return Promise.resolve(row);
+  });
+
+  (prisma.projectListing.findFirst as jest.Mock).mockImplementation(
+    ({ where }: { where: Record<string, unknown> }) =>
+      Promise.resolve(rows.find((row) => matches(row, where)) ?? null),
+  );
+
+  (prisma.projectListing.findMany as jest.Mock).mockImplementation(
+    ({ where }: { where: Record<string, unknown> }) =>
+      Promise.resolve(rows.filter((row) => matches(row, where))),
+  );
+
+  (prisma.projectListing.update as jest.Mock).mockImplementation(
+    ({ where, data }: { where: Record<string, unknown>; data: Row }) => {
+      const row = rows.find((r) => matches(r, where));
+      Object.assign(row!, data, { updatedAt: new Date() });
+      return Promise.resolve(row);
+    },
+  );
+
+  (prisma.projectListing.updateMany as jest.Mock).mockImplementation(
+    ({ where, data }: { where: Record<string, unknown>; data: Row }) => {
+      const matched = rows.filter((r) => matches(r, where));
+      matched.forEach((r) => Object.assign(r, data, { updatedAt: new Date() }));
+      return Promise.resolve({ count: matched.length });
+    },
+  );
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+const bearer = (token: string) => ({ authorization: `Bearer ${token}` });
+
+async function buildApp(): Promise<FastifyInstance> {
+  const app = Fastify();
+  await app.register(startProjectListingRoute);
+  await app.register(patchProjectListingDraftRoute);
+  await app.register(submitProjectListingRoute);
+  await app.ready();
+  return app;
+}
+
+async function startDraft(
+  app: FastifyInstance,
+): Promise<{ id: string; resumeToken: string }> {
+  const res = await app.inject({
+    method: "POST",
+    url: "/v1/project-listings",
+    payload: START_PAYLOAD,
+  });
+  expect(res.statusCode).toBe(201);
+  return (res.json() as { data: { id: string; resumeToken: string } }).data;
+}
+
+const patch = (
+  app: FastifyInstance,
+  draft: { id: string; resumeToken: string },
+  payload: Record<string, unknown>,
+) =>
+  app.inject({
+    method: "PATCH",
+    url: `/v1/project-listings/drafts/${draft.id}`,
+    headers: bearer(draft.resumeToken),
+    payload,
+  });
+
+const submit = (app: FastifyInstance, draft: { id: string; resumeToken: string }) =>
+  app.inject({
+    method: "POST",
+    url: `/v1/project-listings/drafts/${draft.id}/submit`,
+    headers: bearer(draft.resumeToken),
+  });
+
+const storedRow = (id: string): Row => {
+  const row = rows.find((r) => r["id"] === id);
+  expect(row).toBeDefined();
+  return row!;
+};
+
+const draftBody = (res: { json: () => unknown }) =>
+  (res.json() as { data: Record<string, unknown> }).data;
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("the structured founder address (#5279)", () => {
+  setupLeadFileEnv("project-listing-structured-address");
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    installStore();
+    app = await buildApp();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  describe("the parts arrive as PARTS, and the server composes the display line", () => {
+    it("stores six DISTINCT column values, not one concatenated string", async () => {
+      const draft = await startDraft(app);
+
+      const res = await patch(app, draft, { address: ADDRESS_PARTS });
+
+      expect(res.statusCode).toBe(200);
+
+      // The column-level half. Each part is in its OWN column — a service that
+      // stringified the object would leave every one of these null and this
+      // test is the thing that notices.
+      const row = storedRow(draft.id);
+      expect(row["addressLine1"]).toBe("221B Baker Street");
+      expect(row["addressLine2"]).toBe("Flat B");
+      expect(row["addressCity"]).toBe("London");
+      expect(row["addressRegion"]).toBe("Greater London");
+      expect(row["addressPostalCode"]).toBe("NW1 6XE");
+      expect(row["addressCountry"]).toBe("GB");
+
+      // The display half. `address` is DERIVED here and only here — the parts
+      // in reading order, joined with ", ".
+      expect(row["address"]).toBe(COMPOSED_ADDRESS_LINE);
+    });
+
+    it("answers the save with the composed line AND the parts, separably", async () => {
+      const draft = await startDraft(app);
+
+      const body = draftBody(await patch(app, draft, { address: ADDRESS_PARTS }));
+
+      expect(body["address"]).toBe(COMPOSED_ADDRESS_LINE);
+      expect(body["addressParts"]).toEqual(ADDRESS_PARTS);
+    });
+
+    it("omits the blank addressLine2 from both the columns and the composed line", async () => {
+      const draft = await startDraft(app);
+      const { addressLine2: _line2, ...withoutLine2 } = ADDRESS_PARTS;
+
+      const body = draftBody(await patch(app, draft, { address: withoutLine2 }));
+
+      expect(storedRow(draft.id)["addressLine2"]).toBeNull();
+      expect(body["address"]).toBe("221B Baker Street, London, Greater London, NW1 6XE, GB");
+      expect(body["addressParts"]).toEqual(withoutLine2);
+    });
+
+    it("a composed address submits, and reaches the row as the display line", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, { ...APPLICATION_WITHOUT_ADDRESS, address: ADDRESS_PARTS });
+
+      const res = await submit(app, draft);
+
+      expect(res.statusCode).toBe(200);
+      expect(storedRow(draft.id)["address"]).toBe(COMPOSED_ADDRESS_LINE);
+      expect(storedRow(draft.id)["addressCountry"]).toBe("GB");
+    });
+
+    it("refuses parts that are not a whole address, rather than storing half of one", async () => {
+      const draft = await startDraft(app);
+      const { city: _city, ...incomplete } = ADDRESS_PARTS;
+
+      const res = await patch(app, draft, { address: incomplete });
+
+      expect(res.statusCode).toBe(400);
+      expect(storedRow(draft.id)["addressLine1"]).toBeNull();
+      expect(storedRow(draft.id)["address"]).toBeNull();
+    });
+  });
+
+  describe("a legacy free-text address round-trips unchanged, with its parts null", () => {
+    // The load-bearing guard. Nothing may split an existing `address` into
+    // parts — a wrong split silently corrupts the party identification the
+    // listing's privacy notice points at, and a null part is honest where a
+    // guessed one is not.
+    it("comes back CHARACTER-FOR-CHARACTER from a save, with addressParts null", async () => {
+      const draft = await startDraft(app);
+
+      const body = draftBody(await patch(app, draft, { address: LEGACY_ADDRESS_LINE }));
+
+      expect(body["address"]).toBe(LEGACY_ADDRESS_LINE);
+      expect(body["addressParts"]).toBeNull();
+    });
+
+    it("leaves EVERY part column untouched — a plain string writes none of them", async () => {
+      const draft = await startDraft(app);
+
+      await patch(app, draft, { address: LEGACY_ADDRESS_LINE });
+
+      const row = storedRow(draft.id);
+      expect(row["address"]).toBe(LEGACY_ADDRESS_LINE);
+      for (const column of [
+        "addressLine1",
+        "addressLine2",
+        "addressCity",
+        "addressRegion",
+        "addressPostalCode",
+        "addressCountry",
+      ]) {
+        expect(row[column]).toBeNull();
+      }
+    });
+
+    it("submits exactly as it did before #5279, and the stored line is unchanged", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, {
+        ...APPLICATION_WITHOUT_ADDRESS,
+        address: LEGACY_ADDRESS_LINE,
+      });
+
+      const res = await submit(app, draft);
+
+      expect(res.statusCode).toBe(200);
+      expect(storedRow(draft.id)["address"]).toBe(LEGACY_ADDRESS_LINE);
+      expect(storedRow(draft.id)["addressLine1"]).toBeNull();
+    });
+
+    // A row written before #5279 holds a line and six nulls. Overwriting the
+    // line with a NEW line must not start inventing parts for it either.
+    it("re-patching a legacy line with another legacy line still writes no parts", async () => {
+      const draft = await startDraft(app);
+      await patch(app, draft, { address: LEGACY_ADDRESS_LINE });
+
+      await patch(app, draft, { address: "1 Example Street, Exampleton, EX1 2AM" });
+
+      const row = storedRow(draft.id);
+      expect(row["address"]).toBe("1 Example Street, Exampleton, EX1 2AM");
+      expect(row["addressCity"]).toBeNull();
+      expect(row["addressCountry"]).toBeNull();
+    });
+  });
+});

package/templates/apps/api/src/routes/project-listings/index.ts

@@ -6,7 +6,10 @@
  *   POST  /v1/project-listings                      — anonymous start (leadsScope)
  *   PATCH /v1/project-listings/drafts/:id           — anonymous save-as-you-go, token-gated
  *   POST  /v1/project-listings/drafts/:id/submit    — anonymous submit, token-gated
+ *   POST  /v1/project-listings/drafts/:id/verify-email — anonymous, token- AND
+ *                                                     nonce-gated (#5407)
  *   GET   /v1/project-listings/public               — anonymous page-render read (leadsScope)
+ *   GET   /v1/project-listings/me                   — the founder's OWN listings (authScope)
  *   GET   /v1/project-listings                      — tenant-scoped dashboard list
  *   GET   /v1/project-listings/:id                  — tenant-scoped single read
  *   PATCH /v1/project-listings/:id                  — tenant-scoped decision + featured flag
@@ -19,6 +22,13 @@
  * anonymous token-gated PATCH and the operator's tenant-guarded PATCH apart
  * at the router — they differ in segment count, so neither shadows the other.
  *
+ * `/me` (#5295) sits between the two scopes: `authScope` only, no tenant guard.
+ * A founder is not a workspace member, so the guard's default-deny answers 403
+ * for their own submission — and the fix is this ADDITIVE route, joined on the
+ * owner link, rather than a relaxed `PROJECT_LISTING_ROLES`. Its static `/me`
+ * segment takes router precedence over the parametric `/:id` below, exactly as
+ * the already-shipped static `/public` does.
+ *
  * API<->MCP parity: no MCP twin. The anonymous set mirrors the leads routes'
  * own identity-blind posture (an applying founder has no account, and the
  * resume token is a per-draft capability rather than an identity); the
@@ -27,15 +37,30 @@
  */
 import type { FastifyPluginAsync } from "fastify";
 
+import { loadSlice } from "../../lib/slice-load.js";
+
+import { projectListingMeRoute as meRoute } from "./me.js";
 import { patchProjectListingDraftRoute } from "./patch-draft.js";
 import { publicProjectListingsRoute } from "./public.js";
 import { startProjectListingRoute } from "./start.js";
 import { submitProjectListingRoute } from "./submit.js";
+import { verifyProjectListingDraftEmailRoute } from "./verify-email.js";
 
 export const projectListingStartRoute = startProjectListingRoute;
 export const projectListingDraftPatchRoute = patchProjectListingDraftRoute;
 export const projectListingSubmitRoute = submitProjectListingRoute;
 export const projectListingPublicRoute = publicProjectListingsRoute;
+/**
+ * The resume link's verification write (#5407). Static, not a slice: it is
+ * part of the free anonymous surface, exactly like the three routes above.
+ */
+export const projectListingVerifyEmailRoute = verifyProjectListingDraftEmailRoute;
+/**
+ * The founder's own listings read (#5295). Static, not a slice: it depends on
+ * the owner link alone, so it is registered — and works — on a build with no
+ * multi-tenant module, the same as `flowCheckoutRoutes`.
+ */
+export const projectListingMeRoute = meRoute;
 
 /**
  * Tenant-scoped handlers, as { specifier, exportName }, reached at REGISTRATION
@@ -47,50 +72,67 @@ export const projectListingPublicRoute = publicProjectListingsRoute;
  * purpose, which is why the boundary is drawn here at the registration
  * call-site rather than by splitting the directory.
  *
- * The specifier is read from this table rather than written inline because
- * `tsc` resolves a string-literal `import("...")` EXPRESSION whether or not the
- * branch runs, and would report TS2307 on the stripped tree. The plugin body
+ * The specifier is kept off the `import()` call site because `tsc` resolves a
+ * string-literal `import("...")` EXPRESSION whether or not the branch runs, and
+ * would report TS2307 on the stripped tree. It is held in a module-level
+ * constant rather than read out of the table per iteration (#5304): the table
+ * form was invisible to the deploy-time file tracer too, so these files were
+ * compiled and never shipped, and the constant form is the one shape `tsc`
+ * refuses to resolve and `@vercel/nft` still traces. `specifier` stays on each
+ * row for the drift message and reads the same constant as `load`. The plugin body
  * only executes when `server.ts` registers it, which it does inside
  * `isModuleEnabled('multi-tenant')` — so nothing here runs on an OSS build.
  *
  * The export name is unchanged so `server.ts` needs no edit: it still reaches
  * `projectListingTenantRoutes` from this module.
  */
+const LIST_HANDLER = "./list.js";
+const GET_HANDLER = "./get.js";
+const PATCH_HANDLER = "./patch.js";
+const PATCH_COPY_HANDLER = "./patch-copy.js";
+
 const TENANT_HANDLERS: ReadonlyArray<{
   method: "get" | "patch";
   url: string;
   specifier: string;
   exportName: string;
+  load: () => Promise<unknown>;
 }> = [
   {
     method: "get",
     url: "/v1/project-listings",
-    specifier: "./list.js",
+    specifier: LIST_HANDLER,
     exportName: "listProjectListingsHandler",
+    load: () => import(LIST_HANDLER),
   },
   {
     method: "get",
     url: "/v1/project-listings/:id",
-    specifier: "./get.js",
+    specifier: GET_HANDLER,
     exportName: "getProjectListingHandler",
+    load: () => import(GET_HANDLER),
   },
   {
     method: "patch",
     url: "/v1/project-listings/:id",
-    specifier: "./patch.js",
+    specifier: PATCH_HANDLER,
     exportName: "patchProjectListingHandler",
+    load: () => import(PATCH_HANDLER),
   },
   {
     method: "patch",
     url: "/v1/project-listings/:id/copy",
-    specifier: "./patch-copy.js",
+    specifier: PATCH_COPY_HANDLER,
     exportName: "patchProjectListingCopyHandler",
+    load: () => import(PATCH_COPY_HANDLER),
   },
 ];
 
-export const projectListingTenantRoutes: FastifyPluginAsync = async (fastify) => {
-  for (const { method, url, specifier, exportName } of TENANT_HANDLERS) {
-    const mod = (await import(specifier)) as Record<
+export const projectListingTenantRoutes: FastifyPluginAsync = async (
+  fastify,
+) => {
+  for (const { method, url, specifier, exportName, load } of TENANT_HANDLERS) {
+    const mod = (await loadSlice(specifier, load)) as Record<
       string,
       Parameters<typeof fastify.get>[1] | undefined
     >;