create-ailk 0.1.0 → 0.2.0

package/templates/database/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Tailwind AI
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/templates/database/README.md

@@ -214,7 +214,9 @@ Customers can extend the schema for custom features:
 ```prisma
 // Example: Add a SavedItem model for wishlists
 model SavedItem {
-  id        String   @id @default(cuid())
+  // New models are born with the prefixed-UUIDv7 scheme (ADR-0031):
+  // add a registry row in @working-theory/ids + a CHECK constraint migration.
+  id        String   @id @default(dbgenerated("('saved_'::text || (uuidv7())::text)")) @db.Text
   userId    String
   itemType  String   // "product", "blog_post"
   itemId    String   // Platform ID

package/templates/database/__tests__/flows-listing-diagnostic.test.ts

@@ -0,0 +1,392 @@
+/**
+ * @file flows-listing-diagnostic.test.ts
+ * @description The shared scoring RULE (#5001 AC2/AC3, reworked by #5036 D4):
+ * a register built from one listing's own questions scores its weakest path
+ * `curious`, its strongest `now`, and a mixed path where the 0–12 total says
+ * it does — evaluated through the real `evaluateWaitlistScoring`, never a
+ * reimplementation of the ladder.
+ *
+ * The load-bearing test here is "a reordered register scores an answer
+ * identically": #5036 D4 moved resolution from option POSITION to option
+ * VALUE, so reordering a founder's Q3/Q4 options and rebuilding the register
+ * leaves an already-stored answer scoring exactly what it always meant. Under
+ * the old `q{n}:{i}of{k}` encoding that assertion was not even expressible.
+ *
+ * The register must also parse against `waitlistScoringSchema` (the grammar
+ * `upsertWaitlistExperiment` validates on every write) AND survive
+ * `waitlistExperimentConfigSchema`'s config-level cross-validation, which is
+ * the only place the "every `optionWeights` key must be a declared option of
+ * the question it names" rule fires
+ * (docs/lessons/2026-09-07-shared-register-needs-a-shared-value-universe.md).
+ * The projection's REAL config is asserted the same way in
+ * `apps/api/src/services/__tests__/project-listing-flow.test.ts`; the minimal
+ * wrapper below exists so a register that could never be persisted fails in
+ * this package rather than one layer away.
+ */
+
+import {
+  evaluateWaitlistScoring,
+  projectListingQuestionsSchema,
+  waitlistExperimentConfigSchema,
+  waitlistScoringSchema,
+  type ProjectListingQuestions,
+} from "@working-theory/validation";
+
+import {
+  buildListingDiagnosticScoring,
+  listingDiagnosticOptionWeights,
+  listingOptionPoints,
+  LISTING_DIAGNOSTIC_Q5_WEIGHTS,
+  LISTING_DIAGNOSTIC_Q6_WEIGHTS,
+} from "../flows/listing-diagnostic";
+
+/**
+ * A listing's template instance: Q3/Q4 at their 4-option maximum with
+ * founder-authored values, Q5's three fixed urgency values, Q6's four fixed
+ * bands. Parsed through the real schema so the fixture cannot drift from the
+ * contract the projection reads.
+ */
+const QUESTIONS: ProjectListingQuestions = projectListingQuestionsSchema.parse({
+  q2: {
+    prompt: "What brings you here?",
+    options: [
+      { value: "shipping-now", label: "I'm shipping something now" },
+      { value: "just-curious", label: "Just curious" },
+    ],
+  },
+  q3: {
+    prompt: "How painful is this problem today?",
+    options: [
+      { value: "none", label: "Not a problem" },
+      { value: "mild", label: "Mildly annoying" },
+      { value: "real", label: "A real drag" },
+      { value: "blocking", label: "It's blocking me" },
+    ],
+  },
+  q4: {
+    prompt: "How close is this to what you need?",
+    options: [
+      { value: "off", label: "Not what I need" },
+      { value: "adjacent", label: "Adjacent" },
+      { value: "close", label: "Close" },
+      { value: "exact", label: "Exactly it" },
+    ],
+  },
+  q5: {
+    prompt: "When would you use this?",
+    options: [
+      { value: "urgent", label: "Right away" },
+      { value: "planning", label: "Next quarter" },
+      { value: "exploring", label: "Just looking" },
+    ],
+  },
+  q6: {
+    prompt: "What would you pay?",
+    options: [
+      { value: "low", label: "Nothing yet" },
+      { value: "medium", label: "A little" },
+      { value: "high", label: "A real budget" },
+      { value: "critical", label: "Whatever it takes" },
+    ],
+  },
+  q7: { prompt: "Anything else we should know?" },
+  extras: [],
+});
+
+const SCORING = buildListingDiagnosticScoring(QUESTIONS);
+
+/** The `optionWeights` map the register declares for one scored question. */
+function weightsOf(
+  scoring: ReturnType<typeof buildListingDiagnosticScoring>,
+  question: string,
+): Record<string, number> {
+  const point = scoring.points.find((p) => p.question === question);
+  if (!point || point.kind !== "optionWeights") {
+    throw new Error(`no optionWeights point for "${question}"`);
+  }
+  return point.weights;
+}
+
+/**
+ * The minimal experiment config that carries a register — enough to fire
+ * `waitlistExperimentConfigSchema`'s weights-key cross-validation, and
+ * nothing more. The question set declares THIS listing's own options, which
+ * is precisely what value-keyed scoring makes possible.
+ */
+function experimentConfigFor(questions: ProjectListingQuestions): unknown {
+  const scored = (["q3", "q4", "q5", "q6"] as const).map((id) => ({
+    id,
+    prompt: { en: questions[id].prompt },
+    answerType: "single" as const,
+    options: questions[id].options.map((o) => ({
+      value: o.value,
+      label: { en: o.label },
+    })),
+  }));
+
+  return {
+    key: "orbit-notes",
+    mode: "qualifying",
+    status: "live",
+    waitlists: [{ key: "listing_orbit_notes", flowSlug: "orbit-notes" }],
+    questionSet: {
+      version: 1,
+      questions: [
+        {
+          id: "email",
+          prompt: { en: "Email" },
+          answerType: "email",
+          mapsTo: "email",
+        },
+        ...scored,
+      ],
+    },
+    scoring: buildListingDiagnosticScoring(questions),
+    tracking: {
+      version: 1,
+      utm: { source: "utm_source", medium: "utm_medium", campaign: "utm_campaign" },
+      waitlists: { listing_orbit_notes: { campaign: "orbit-notes", channels: ["direct"] } },
+    },
+    stripeConfigRef: null,
+  };
+}
+
+describe("listingOptionPoints — the founder's declared order → 0..3", () => {
+  it("spans 0..3 whatever the arity, weakest first", () => {
+    expect([0, 1, 2].map((i) => listingOptionPoints(i, 3))).toEqual([0, 2, 3]);
+    expect([0, 1, 2, 3].map((i) => listingOptionPoints(i, 4))).toEqual([0, 1, 2, 3]);
+  });
+
+  it("yields 0 for a question with no spread to score", () => {
+    expect(listingOptionPoints(0, 1)).toBe(0);
+  });
+});
+
+describe("listingDiagnosticOptionWeights — keyed by value, weighted by order", () => {
+  it("keys the founder's own values and weights them by their declared order", () => {
+    expect(
+      listingDiagnosticOptionWeights([
+        { value: "none" },
+        { value: "mild" },
+        { value: "real" },
+        { value: "blocking" },
+      ]),
+    ).toEqual({ none: 0, mild: 1, real: 2, blocking: 3 });
+  });
+
+  it("still spans 0..3 at three options", () => {
+    expect(
+      listingDiagnosticOptionWeights([{ value: "x" }, { value: "y" }, { value: "z" }]),
+    ).toEqual({ x: 0, y: 2, z: 3 });
+  });
+});
+
+describe("the fixed-value questions", () => {
+  it("scores Q5 STRONGEST-first — `urgent` 3, `exploring` 0", () => {
+    // #4998 pins Q5's values urgency-descending, so the positional rule
+    // scored `urgent` 0 (docs/lessons/2026-09-07-q5-fixed-order-is-
+    // strongest-first.md). Value-keyed weights say what is meant instead.
+    expect(LISTING_DIAGNOSTIC_Q5_WEIGHTS).toEqual({
+      urgent: 3,
+      planning: 2,
+      exploring: 0,
+    });
+  });
+
+  it("keeps Q6 weakest-first — `low` 0, `critical` 3", () => {
+    expect(LISTING_DIAGNOSTIC_Q6_WEIGHTS).toEqual({
+      low: 0,
+      medium: 1,
+      high: 2,
+      critical: 3,
+    });
+  });
+
+  it("leaves the per-question spread at 0..3, so the total stays 0..12", () => {
+    for (const question of ["q3", "q4", "q5", "q6"]) {
+      const values = Object.values(weightsOf(SCORING, question));
+      expect(Math.min(...values)).toBe(0);
+      expect(Math.max(...values)).toBe(3);
+    }
+  });
+});
+
+describe("buildListingDiagnosticScoring — the register", () => {
+  it("parses against waitlistScoringSchema", () => {
+    expect(waitlistScoringSchema.safeParse(SCORING).success).toBe(true);
+  });
+
+  it("parses against waitlistExperimentConfigSchema at the config level", () => {
+    // The weights-key cross-validation only fires here — the question set
+    // declares this listing's OWN options, and the register keys on the same
+    // values, so no value universe is needed.
+    const parsed = waitlistExperimentConfigSchema.safeParse(experimentConfigFor(QUESTIONS));
+    expect(parsed.success).toBe(true);
+  });
+
+  it("scores Q3–Q6 only — Q1/Q2/Q7 and the extras carry no points", () => {
+    expect(SCORING.points.map((p) => p.question)).toEqual(["q3", "q4", "q5", "q6"]);
+  });
+
+  it("keys every weight on the founder's own option values, and nothing else", () => {
+    for (const question of ["q3", "q4", "q5", "q6"] as const) {
+      expect(Object.keys(weightsOf(SCORING, question)).sort()).toEqual(
+        QUESTIONS[question].options.map((o) => o.value).sort(),
+      );
+    }
+  });
+
+  it("gives two listings the same RULE — same shape, same tiers, same fixed weights", () => {
+    const other = buildListingDiagnosticScoring(
+      projectListingQuestionsSchema.parse({
+        ...QUESTIONS,
+        q3: {
+          prompt: "How badly does this hurt?",
+          options: [
+            { value: "x", label: "Not at all" },
+            { value: "y", label: "Somewhat" },
+            { value: "z", label: "Badly" },
+          ],
+        },
+      }),
+    );
+
+    expect(other.points.map((p) => p.name)).toEqual(SCORING.points.map((p) => p.name));
+    expect(other.scores).toEqual(SCORING.scores);
+    expect(other.tiers).toEqual(SCORING.tiers);
+    expect(other.default).toEqual(SCORING.default);
+    // Only the founder-authored questions' KEYS differ.
+    expect(weightsOf(other, "q5")).toEqual(weightsOf(SCORING, "q5"));
+    expect(weightsOf(other, "q6")).toEqual(weightsOf(SCORING, "q6"));
+    expect(weightsOf(other, "q3")).toEqual({ x: 0, y: 2, z: 3 });
+  });
+
+  // ── The three paths (#5001 AC2) ────────────────────────────────────────
+
+  it("scores the WEAKEST path 0 → curious", () => {
+    const result = evaluateWaitlistScoring(SCORING, {
+      q3: "none",
+      q4: "off",
+      q5: "exploring",
+      q6: "low",
+    });
+    expect(result.score).toBe(0);
+    expect(result.tier).toBe("curious");
+  });
+
+  it("scores the STRONGEST path 12 → now", () => {
+    const result = evaluateWaitlistScoring(SCORING, {
+      q3: "blocking",
+      q4: "exact",
+      q5: "urgent",
+      q6: "critical",
+    });
+    expect(result.score).toBe(12);
+    expect(result.tier).toBe("now");
+  });
+
+  it("scores a MIXED path by the sum of its answers", () => {
+    // q3 `real` 2 · q4 `adjacent` 1 · q5 `urgent` 3 · q6 `medium` 1 = 7 →
+    // soon (7–9).
+    const result = evaluateWaitlistScoring(SCORING, {
+      q3: "real",
+      q4: "adjacent",
+      q5: "urgent",
+      q6: "medium",
+    });
+    expect(result.score).toBe(7);
+    expect(result.tier).toBe("soon");
+  });
+
+  it.each([
+    [{ q3: "none", q4: "off", q5: "exploring", q6: "critical" }, 3, "curious"],
+    [{ q3: "mild", q4: "adjacent", q5: "exploring", q6: "high" }, 4, "later"],
+    [{ q3: "real", q4: "close", q5: "exploring", q6: "high" }, 6, "later"],
+    [{ q3: "blocking", q4: "exact", q5: "exploring", q6: "critical" }, 9, "soon"],
+    [{ q3: "blocking", q4: "exact", q5: "planning", q6: "critical" }, 11, "now"],
+  ])("puts total %j (%i) in the %s band", (answers, expectedScore, expectedTier) => {
+    const result = evaluateWaitlistScoring(SCORING, answers as Record<string, string>);
+    expect(result.score).toBe(expectedScore);
+    expect(result.tier).toBe(expectedTier);
+  });
+
+  it("is total — an unanswered diagnostic still lands on a tier", () => {
+    const result = evaluateWaitlistScoring(SCORING, {});
+    expect(result.score).toBe(0);
+    expect(result.tier).toBe("curious");
+  });
+
+  // ── #5036 D4: resolution by value, not position ────────────────────────
+
+  it("a reordered register scores an answer identically", () => {
+    // The founder swaps the two middle Q3 options and the two middle Q4
+    // options — a real edit to the register, which changes what those two
+    // options are worth. The ANSWERED options (`blocking`, the strongest Q3;
+    // `off`, the weakest Q4) keep the strength the founder declared, so the
+    // same stored answer must score exactly what it scored before.
+    //
+    // This test is not expressible under the old `q{n}:{i}of{k}` encoding:
+    // there was no founder value to answer with, and a stored `q3:3of4`
+    // token was a POSITION, so any reorder or insert silently repointed it at
+    // a different option. Resolving by value is what makes the answer survive
+    // an edit to the register.
+    const answers = { q3: "blocking", q4: "off", q5: "urgent", q6: "high" };
+    const before = evaluateWaitlistScoring(SCORING, answers);
+
+    const reordered = buildListingDiagnosticScoring(
+      projectListingQuestionsSchema.parse({
+        ...QUESTIONS,
+        q3: {
+          prompt: QUESTIONS.q3.prompt,
+          options: [
+            { value: "none", label: "Not a problem" },
+            { value: "real", label: "A real drag" },
+            { value: "mild", label: "Mildly annoying" },
+            { value: "blocking", label: "It's blocking me" },
+          ],
+        },
+        q4: {
+          prompt: QUESTIONS.q4.prompt,
+          options: [
+            { value: "off", label: "Not what I need" },
+            { value: "close", label: "Close" },
+            { value: "adjacent", label: "Adjacent" },
+            { value: "exact", label: "Exactly it" },
+          ],
+        },
+      }),
+    );
+    const after = evaluateWaitlistScoring(reordered, answers);
+
+    expect(before.score).toBe(8);
+    expect(after.score).toBe(before.score);
+    expect(after.tier).toBe(before.tier);
+
+    // The reorder is not a no-op: the two moved options really did trade
+    // weights, and the register the answer was resolved against is a
+    // different object than the one it was stored under.
+    expect(weightsOf(reordered, "q3")).not.toEqual(weightsOf(SCORING, "q3"));
+    expect(weightsOf(reordered, "q4")).not.toEqual(weightsOf(SCORING, "q4"));
+    expect(weightsOf(reordered, "q3")).toEqual({ none: 0, real: 1, mild: 2, blocking: 3 });
+  });
+
+  it("still parses at the config level after a reorder", () => {
+    // A reordered register's keys are still exactly the (reordered) options
+    // the question set declares, so the cross-validation holds.
+    const reordered = projectListingQuestionsSchema.parse({
+      ...QUESTIONS,
+      q3: {
+        prompt: QUESTIONS.q3.prompt,
+        options: [
+          { value: "none", label: "Not a problem" },
+          { value: "real", label: "A real drag" },
+          { value: "mild", label: "Mildly annoying" },
+          { value: "blocking", label: "It's blocking me" },
+        ],
+      },
+    });
+    expect(
+      waitlistExperimentConfigSchema.safeParse(experimentConfigFor(reordered)).success,
+    ).toBe(true);
+  });
+});