@reventlessdev/reventless-seed 1.0.0-alpha.14 → 1.0.0-alpha.15

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 1.0.0-alpha.15 (2026-08-16)
+
+### Bug Fixes
+
+* **seed:** let seed:reset take the yes it asks for ([1f646f6](https://github.com/ReventlessDev/reventless-core/commit/1f646f6ce13a4238e92b7047ee31650ccc4de4f3))
+* **seed:** report the retirements the projection has actually applied ([91bc877](https://github.com/ReventlessDev/reventless-core/commit/91bc877d90fc69dab76ff0fb9aae9ea989107aed))
+
+
 # 1.0.0-alpha.14 (2026-08-15)
 
 **Note:** Version bump only for package @reventlessdev/reventless-seed

package/lib/bs/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1786755877868)
-#Done(1786755877903)
+#Start(1786876637985)
+#Done(1786876638019)

package/lib/bs/ReventlessSeed.mlmap

@@ -3,6 +3,7 @@ Seed
 Seed_Client
 Seed_Connect
 Seed_Prompt
+Seed_PromptTest
 Seed_Random
 Seed_RandomTest
 Seed_Runner

package/lib/bs/compiler-info.json

@@ -4,5 +4,5 @@
   "bsc_hash": "75e3a59c95cc953608fd3dd6ea6ed68141bba4414a20a52f114261b8a48385fa",
   "rescript_config_hash": "25cfff836d200084949fdfdfec2f6875901bfee1f04d84634eca252ef1ca1ef1",
   "runtime_path": "/home/runner/work/reventless-core/reventless-core/node_modules/@rescript/runtime",
-  "generated_at": "1786755877906"
+  "generated_at": "1786876638021"
 }

package/lib/bs/src/Seed_Client.res

@@ -179,18 +179,27 @@ let sendAll = async (t: t, mutations: array<mutation>): unit =>
  * Walks a Relay-style connection to the end. Connections page at 50 by default,
  * so any count taken from a single request silently truncates.
  */
-let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string): array<
-  JSON.t,
-> => {
+// `~args` is spliced into the connection's argument list — `"includeRetired: true"`
+// is the case it exists for, and the only way to read rows the resolvers withhold
+// by default. Literal GraphQL rather than a typed argument list because a seed
+// writes the query it means; the alternative is a builder that has to grow a case
+// per argument the platform adds.
+let queryAllNodes = async (
+  t: t,
+  ~field as fieldName: string,
+  ~selection: string,
+  ~args: string="",
+): array<JSON.t> => {
   let nodes = []
   let after = ref(None)
   let more = ref(true)
+  let extra = args == "" ? "" : `, ${args}`
   while more.contents {
     let cursor = switch after.contents {
     | Some(c) => `, after: ${quote(c)}`
     | None => ""
     }
-    let query = `{ ${fieldName}(first: 100${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
+    let query = `{ ${fieldName}(first: 100${extra}${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
     let data = await gql(t, ~query, ~label=fieldName)
     let connection = data->field(fieldName)->Option.getOr(JSON.Encode.null)
     switch connection->field("edges") {
@@ -237,6 +246,7 @@ let queryAllNodesUntil = async (
   t: t,
   ~field: string,
   ~selection: string,
+  ~args: string="",
   ~satisfied: array<JSON.t> => bool,
   ~onTimeout: array<JSON.t> => string,
   ~timeoutMs: int=60000,
@@ -244,7 +254,7 @@ let queryAllNodesUntil = async (
   let deadline = nowMs() +. Int.toFloat(timeoutMs)
   let result = ref(None)
   while result.contents == None {
-    let nodes = await queryAllNodes(t, ~field, ~selection)
+    let nodes = await queryAllNodes(t, ~field, ~selection, ~args)
     if satisfied(nodes) {
       result := Some(nodes)
     } else if nowMs() > deadline {

package/lib/bs/src/Seed_Client.res.mjs

@@ -175,14 +175,16 @@ async function sendAll(t, mutations) {
   }
 }
 
-async function queryAllNodes(t, fieldName, selection) {
+async function queryAllNodes(t, fieldName, selection, argsOpt) {
+  let args = argsOpt !== undefined ? argsOpt : "";
   let nodes = [];
   let after;
   let more = true;
+  let extra = args === "" ? "" : `, ` + args;
   while (more) {
     let c = after;
     let cursor = c !== undefined ? `, after: ` + Seed_Types$ReventlessSeed.quote(c) : "";
-    let query = `{ ` + fieldName + `(first: 100` + cursor + `) { edges { node { ` + selection + ` } } pageInfo { hasNextPage endCursor } } }`;
+    let query = `{ ` + fieldName + `(first: 100` + extra + cursor + `) { edges { node { ` + selection + ` } } pageInfo { hasNextPage endCursor } } }`;
     let data = await gql(t, query, fieldName);
     let connection = Stdlib_Option.getOr(field(data, fieldName), null);
     let match = field(connection, "edges");
@@ -209,15 +211,16 @@ async function queryAllNodes(t, fieldName, selection) {
 }
 
 async function countNodes(t, field) {
-  return (await queryAllNodes(t, field, "id")).length;
+  return (await queryAllNodes(t, field, "id", undefined)).length;
 }
 
-async function queryAllNodesUntil(t, field, selection, satisfied, onTimeout, timeoutMsOpt) {
+async function queryAllNodesUntil(t, field, selection, argsOpt, satisfied, onTimeout, timeoutMsOpt) {
+  let args = argsOpt !== undefined ? argsOpt : "";
   let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
   let deadline = Date.now() + timeoutMs;
   let result;
   while (result === undefined) {
-    let nodes = await queryAllNodes(t, field, selection);
+    let nodes = await queryAllNodes(t, field, selection, args);
     if (satisfied(nodes)) {
       result = nodes;
     } else {

package/lib/bs/src/Seed_Prompt.res

@@ -97,6 +97,24 @@ let askHidden = (query: string): promise<string> =>
     muted := true
   })
 
+/**
+ * Whether an answer means yes — the one vocabulary, for the typed reply and the
+ * env var that stands in for it alike.
+ *
+ * It exists because those two drifted: a `[y/N]` prompt took `y`, and the env
+ * var beside it took only `1` or `yes`, so the obvious `SEED_RESET_CONFIRM=y`
+ * silently fell through to the interactive branch — which, on the CI runs the
+ * variable exists for, has no TTY and throws. Two spellings of one question are
+ * one spelling too many; callers ask this instead of comparing strings.
+ *
+ * Trimmed and case-folded, so `Yes`/` y ` answer the same as `y`.
+ */
+let isAffirmative = (answer: string): bool =>
+  switch answer->String.trim->String.toLowerCase {
+  | "y" | "yes" | "1" => true
+  | _ => false
+  }
+
 /**
  * Chooses one of `options` (a label paired with the value it selects).
  *

package/lib/bs/src/Seed_Prompt.res.mjs

@@ -82,6 +82,18 @@ function askHidden(query) {
   });
 }
 
+function isAffirmative(answer) {
+  let match = answer.trim().toLowerCase();
+  switch (match) {
+    case "1" :
+    case "y" :
+    case "yes" :
+      return true;
+    default:
+      return false;
+  }
+}
+
 async function select(title, options, env) {
   if (options.length === 1) {
     return options[0][1];
@@ -166,6 +178,7 @@ export {
   requireTty,
   ask,
   askHidden,
+  isAffirmative,
   select,
   credentials,
 }

package/lib/bs/tests/Seed_PromptTest.res

@@ -0,0 +1,59 @@
+open JestGlobals
+
+// `isAffirmative` is the one vocabulary for "yes", shared by a typed `[y/N]`
+// reply and by the env var that stands in for it on a run with no terminal.
+//
+// It exists because those two drifted: the prompt took `y`, the env var took
+// only the literals `1` and `yes`, and every other value — `y` included, and an
+// explicit `no` with it — fell through to the interactive branch, which throws
+// when there is no TTY. So the variable that exists to make the tool
+// non-interactive had two spellings that worked and a crash for the rest.
+//
+// The suite is written around the shape of that bug rather than around the
+// function: what must confirm, what must decline, and — the case that actually
+// broke CI — that declining is a normal answer and not a fall-through.
+
+describe("Seed_Prompt.isAffirmative:", () => {
+  testSync("takes the three spellings of yes", () => {
+    ["y", "yes", "1"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  // A prompt that prints `[y/N]` invites a capital as readily as a lowercase
+  // one, and an env var set by hand is written however the hand felt.
+  testSync("ignores case, so Y and YES answer as y does", () => {
+    ["Y", "Yes", "YES"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  testSync("ignores surrounding space", () => {
+    [" y", "y ", "  yes  "]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  // The half that matters most: every one of these is an ANSWER, and the caller
+  // reads it as "no". None may be mistaken for "nothing was said", which is what
+  // sent the old code to a prompt it could not open.
+  testSync("declines every spelling of no, capital N included", () => {
+    ["n", "N", "no", "No", "NO"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false)
+    )
+  })
+
+  testSync("declines anything it does not recognise", () => {
+    ["", "  ", "0", "true", "yep", "y.", "yesplease", "affirmative"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false)
+    )
+  })
+
+  // `true` is deliberately absent from the vocabulary above. Named here so that
+  // adding it is a decision someone takes against a failing test rather than a
+  // kindness someone slips in: the prompt this stands in for asks `[y/N]`, and a
+  // reply nobody would type at that prompt should not work around it either.
+  testSync("does not quietly grow a fourth spelling", () => {
+    expect(Seed_Prompt.isAffirmative("true"))->Expect.toBe(false)
+  })
+})

package/lib/bs/tests/Seed_PromptTest.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Seed_Prompt$ReventlessSeed from "../src/Seed_Prompt.res.mjs";
+
+globalThis.describe("Seed_Prompt.isAffirmative:", () => {
+  globalThis.test("takes the three spellings of yes", () => {
+    [
+      "y",
+      "yes",
+      "1"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("ignores case, so Y and YES answer as y does", () => {
+    [
+      "Y",
+      "Yes",
+      "YES"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("ignores surrounding space", () => {
+    [
+      " y",
+      "y ",
+      "  yes  "
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("declines every spelling of no, capital N included", () => {
+    [
+      "n",
+      "N",
+      "no",
+      "No",
+      "NO"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(false);
+    });
+  });
+  globalThis.test("declines anything it does not recognise", () => {
+    [
+      "",
+      "  ",
+      "0",
+      "true",
+      "yep",
+      "y.",
+      "yesplease",
+      "affirmative"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(false);
+    });
+  });
+  globalThis.test("does not quietly grow a fourth spelling", () => {
+    globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative("true")).toBe(false);
+  });
+});
+
+/*  Not a pure module */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1786755877868)
-#Done(1786755877903)
+#Start(1786876637985)
+#Done(1786876638019)

package/lib/ocaml/ReventlessSeed.mlmap

@@ -3,6 +3,7 @@ Seed
 Seed_Client
 Seed_Connect
 Seed_Prompt
+Seed_PromptTest
 Seed_Random
 Seed_RandomTest
 Seed_Runner

package/lib/ocaml/Seed_Client.res

@@ -179,18 +179,27 @@ let sendAll = async (t: t, mutations: array<mutation>): unit =>
  * Walks a Relay-style connection to the end. Connections page at 50 by default,
  * so any count taken from a single request silently truncates.
  */
-let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string): array<
-  JSON.t,
-> => {
+// `~args` is spliced into the connection's argument list — `"includeRetired: true"`
+// is the case it exists for, and the only way to read rows the resolvers withhold
+// by default. Literal GraphQL rather than a typed argument list because a seed
+// writes the query it means; the alternative is a builder that has to grow a case
+// per argument the platform adds.
+let queryAllNodes = async (
+  t: t,
+  ~field as fieldName: string,
+  ~selection: string,
+  ~args: string="",
+): array<JSON.t> => {
   let nodes = []
   let after = ref(None)
   let more = ref(true)
+  let extra = args == "" ? "" : `, ${args}`
   while more.contents {
     let cursor = switch after.contents {
     | Some(c) => `, after: ${quote(c)}`
     | None => ""
     }
-    let query = `{ ${fieldName}(first: 100${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
+    let query = `{ ${fieldName}(first: 100${extra}${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
     let data = await gql(t, ~query, ~label=fieldName)
     let connection = data->field(fieldName)->Option.getOr(JSON.Encode.null)
     switch connection->field("edges") {
@@ -237,6 +246,7 @@ let queryAllNodesUntil = async (
   t: t,
   ~field: string,
   ~selection: string,
+  ~args: string="",
   ~satisfied: array<JSON.t> => bool,
   ~onTimeout: array<JSON.t> => string,
   ~timeoutMs: int=60000,
@@ -244,7 +254,7 @@ let queryAllNodesUntil = async (
   let deadline = nowMs() +. Int.toFloat(timeoutMs)
   let result = ref(None)
   while result.contents == None {
-    let nodes = await queryAllNodes(t, ~field, ~selection)
+    let nodes = await queryAllNodes(t, ~field, ~selection, ~args)
     if satisfied(nodes) {
       result := Some(nodes)
     } else if nowMs() > deadline {

package/lib/ocaml/Seed_Prompt.res

@@ -97,6 +97,24 @@ let askHidden = (query: string): promise<string> =>
     muted := true
   })
 
+/**
+ * Whether an answer means yes — the one vocabulary, for the typed reply and the
+ * env var that stands in for it alike.
+ *
+ * It exists because those two drifted: a `[y/N]` prompt took `y`, and the env
+ * var beside it took only `1` or `yes`, so the obvious `SEED_RESET_CONFIRM=y`
+ * silently fell through to the interactive branch — which, on the CI runs the
+ * variable exists for, has no TTY and throws. Two spellings of one question are
+ * one spelling too many; callers ask this instead of comparing strings.
+ *
+ * Trimmed and case-folded, so `Yes`/` y ` answer the same as `y`.
+ */
+let isAffirmative = (answer: string): bool =>
+  switch answer->String.trim->String.toLowerCase {
+  | "y" | "yes" | "1" => true
+  | _ => false
+  }
+
 /**
  * Chooses one of `options` (a label paired with the value it selects).
  *

package/lib/ocaml/Seed_PromptTest.res

@@ -0,0 +1,59 @@
+open JestGlobals
+
+// `isAffirmative` is the one vocabulary for "yes", shared by a typed `[y/N]`
+// reply and by the env var that stands in for it on a run with no terminal.
+//
+// It exists because those two drifted: the prompt took `y`, the env var took
+// only the literals `1` and `yes`, and every other value — `y` included, and an
+// explicit `no` with it — fell through to the interactive branch, which throws
+// when there is no TTY. So the variable that exists to make the tool
+// non-interactive had two spellings that worked and a crash for the rest.
+//
+// The suite is written around the shape of that bug rather than around the
+// function: what must confirm, what must decline, and — the case that actually
+// broke CI — that declining is a normal answer and not a fall-through.
+
+describe("Seed_Prompt.isAffirmative:", () => {
+  testSync("takes the three spellings of yes", () => {
+    ["y", "yes", "1"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  // A prompt that prints `[y/N]` invites a capital as readily as a lowercase
+  // one, and an env var set by hand is written however the hand felt.
+  testSync("ignores case, so Y and YES answer as y does", () => {
+    ["Y", "Yes", "YES"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  testSync("ignores surrounding space", () => {
+    [" y", "y ", "  yes  "]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  // The half that matters most: every one of these is an ANSWER, and the caller
+  // reads it as "no". None may be mistaken for "nothing was said", which is what
+  // sent the old code to a prompt it could not open.
+  testSync("declines every spelling of no, capital N included", () => {
+    ["n", "N", "no", "No", "NO"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false)
+    )
+  })
+
+  testSync("declines anything it does not recognise", () => {
+    ["", "  ", "0", "true", "yep", "y.", "yesplease", "affirmative"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false)
+    )
+  })
+
+  // `true` is deliberately absent from the vocabulary above. Named here so that
+  // adding it is a decision someone takes against a failing test rather than a
+  // kindness someone slips in: the prompt this stands in for asks `[y/N]`, and a
+  // reply nobody would type at that prompt should not work around it either.
+  testSync("does not quietly grow a fourth spelling", () => {
+    expect(Seed_Prompt.isAffirmative("true"))->Expect.toBe(false)
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-seed",
-  "version": "1.0.0-alpha.14",
+  "version": "1.0.0-alpha.15",
   "description": "Reusable harness for seeding a Reventless platform through its public GraphQL command API",
   "license": "Apache-2.0",
   "dependencies": {

package/src/Seed_Client.res

@@ -179,18 +179,27 @@ let sendAll = async (t: t, mutations: array<mutation>): unit =>
  * Walks a Relay-style connection to the end. Connections page at 50 by default,
  * so any count taken from a single request silently truncates.
  */
-let queryAllNodes = async (t: t, ~field as fieldName: string, ~selection: string): array<
-  JSON.t,
-> => {
+// `~args` is spliced into the connection's argument list — `"includeRetired: true"`
+// is the case it exists for, and the only way to read rows the resolvers withhold
+// by default. Literal GraphQL rather than a typed argument list because a seed
+// writes the query it means; the alternative is a builder that has to grow a case
+// per argument the platform adds.
+let queryAllNodes = async (
+  t: t,
+  ~field as fieldName: string,
+  ~selection: string,
+  ~args: string="",
+): array<JSON.t> => {
   let nodes = []
   let after = ref(None)
   let more = ref(true)
+  let extra = args == "" ? "" : `, ${args}`
   while more.contents {
     let cursor = switch after.contents {
     | Some(c) => `, after: ${quote(c)}`
     | None => ""
     }
-    let query = `{ ${fieldName}(first: 100${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
+    let query = `{ ${fieldName}(first: 100${extra}${cursor}) { edges { node { ${selection} } } pageInfo { hasNextPage endCursor } } }`
     let data = await gql(t, ~query, ~label=fieldName)
     let connection = data->field(fieldName)->Option.getOr(JSON.Encode.null)
     switch connection->field("edges") {
@@ -237,6 +246,7 @@ let queryAllNodesUntil = async (
   t: t,
   ~field: string,
   ~selection: string,
+  ~args: string="",
   ~satisfied: array<JSON.t> => bool,
   ~onTimeout: array<JSON.t> => string,
   ~timeoutMs: int=60000,
@@ -244,7 +254,7 @@ let queryAllNodesUntil = async (
   let deadline = nowMs() +. Int.toFloat(timeoutMs)
   let result = ref(None)
   while result.contents == None {
-    let nodes = await queryAllNodes(t, ~field, ~selection)
+    let nodes = await queryAllNodes(t, ~field, ~selection, ~args)
     if satisfied(nodes) {
       result := Some(nodes)
     } else if nowMs() > deadline {

package/src/Seed_Client.res.mjs

@@ -175,14 +175,16 @@ async function sendAll(t, mutations) {
   }
 }
 
-async function queryAllNodes(t, fieldName, selection) {
+async function queryAllNodes(t, fieldName, selection, argsOpt) {
+  let args = argsOpt !== undefined ? argsOpt : "";
   let nodes = [];
   let after;
   let more = true;
+  let extra = args === "" ? "" : `, ` + args;
   while (more) {
     let c = after;
     let cursor = c !== undefined ? `, after: ` + Seed_Types$ReventlessSeed.quote(c) : "";
-    let query = `{ ` + fieldName + `(first: 100` + cursor + `) { edges { node { ` + selection + ` } } pageInfo { hasNextPage endCursor } } }`;
+    let query = `{ ` + fieldName + `(first: 100` + extra + cursor + `) { edges { node { ` + selection + ` } } pageInfo { hasNextPage endCursor } } }`;
     let data = await gql(t, query, fieldName);
     let connection = Stdlib_Option.getOr(field(data, fieldName), null);
     let match = field(connection, "edges");
@@ -209,15 +211,16 @@ async function queryAllNodes(t, fieldName, selection) {
 }
 
 async function countNodes(t, field) {
-  return (await queryAllNodes(t, field, "id")).length;
+  return (await queryAllNodes(t, field, "id", undefined)).length;
 }
 
-async function queryAllNodesUntil(t, field, selection, satisfied, onTimeout, timeoutMsOpt) {
+async function queryAllNodesUntil(t, field, selection, argsOpt, satisfied, onTimeout, timeoutMsOpt) {
+  let args = argsOpt !== undefined ? argsOpt : "";
   let timeoutMs = timeoutMsOpt !== undefined ? timeoutMsOpt : 60000;
   let deadline = Date.now() + timeoutMs;
   let result;
   while (result === undefined) {
-    let nodes = await queryAllNodes(t, field, selection);
+    let nodes = await queryAllNodes(t, field, selection, args);
     if (satisfied(nodes)) {
       result = nodes;
     } else {

package/src/Seed_Prompt.res

@@ -97,6 +97,24 @@ let askHidden = (query: string): promise<string> =>
     muted := true
   })
 
+/**
+ * Whether an answer means yes — the one vocabulary, for the typed reply and the
+ * env var that stands in for it alike.
+ *
+ * It exists because those two drifted: a `[y/N]` prompt took `y`, and the env
+ * var beside it took only `1` or `yes`, so the obvious `SEED_RESET_CONFIRM=y`
+ * silently fell through to the interactive branch — which, on the CI runs the
+ * variable exists for, has no TTY and throws. Two spellings of one question are
+ * one spelling too many; callers ask this instead of comparing strings.
+ *
+ * Trimmed and case-folded, so `Yes`/` y ` answer the same as `y`.
+ */
+let isAffirmative = (answer: string): bool =>
+  switch answer->String.trim->String.toLowerCase {
+  | "y" | "yes" | "1" => true
+  | _ => false
+  }
+
 /**
  * Chooses one of `options` (a label paired with the value it selects).
  *

package/src/Seed_Prompt.res.mjs

@@ -82,6 +82,18 @@ function askHidden(query) {
   });
 }
 
+function isAffirmative(answer) {
+  let match = answer.trim().toLowerCase();
+  switch (match) {
+    case "1" :
+    case "y" :
+    case "yes" :
+      return true;
+    default:
+      return false;
+  }
+}
+
 async function select(title, options, env) {
   if (options.length === 1) {
     return options[0][1];
@@ -166,6 +178,7 @@ export {
   requireTty,
   ask,
   askHidden,
+  isAffirmative,
   select,
   credentials,
 }

package/tests/Seed_PromptTest.res

@@ -0,0 +1,59 @@
+open JestGlobals
+
+// `isAffirmative` is the one vocabulary for "yes", shared by a typed `[y/N]`
+// reply and by the env var that stands in for it on a run with no terminal.
+//
+// It exists because those two drifted: the prompt took `y`, the env var took
+// only the literals `1` and `yes`, and every other value — `y` included, and an
+// explicit `no` with it — fell through to the interactive branch, which throws
+// when there is no TTY. So the variable that exists to make the tool
+// non-interactive had two spellings that worked and a crash for the rest.
+//
+// The suite is written around the shape of that bug rather than around the
+// function: what must confirm, what must decline, and — the case that actually
+// broke CI — that declining is a normal answer and not a fall-through.
+
+describe("Seed_Prompt.isAffirmative:", () => {
+  testSync("takes the three spellings of yes", () => {
+    ["y", "yes", "1"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  // A prompt that prints `[y/N]` invites a capital as readily as a lowercase
+  // one, and an env var set by hand is written however the hand felt.
+  testSync("ignores case, so Y and YES answer as y does", () => {
+    ["Y", "Yes", "YES"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  testSync("ignores surrounding space", () => {
+    [" y", "y ", "  yes  "]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true)
+    )
+  })
+
+  // The half that matters most: every one of these is an ANSWER, and the caller
+  // reads it as "no". None may be mistaken for "nothing was said", which is what
+  // sent the old code to a prompt it could not open.
+  testSync("declines every spelling of no, capital N included", () => {
+    ["n", "N", "no", "No", "NO"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false)
+    )
+  })
+
+  testSync("declines anything it does not recognise", () => {
+    ["", "  ", "0", "true", "yep", "y.", "yesplease", "affirmative"]->Array.forEach(v =>
+      expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false)
+    )
+  })
+
+  // `true` is deliberately absent from the vocabulary above. Named here so that
+  // adding it is a decision someone takes against a failing test rather than a
+  // kindness someone slips in: the prompt this stands in for asks `[y/N]`, and a
+  // reply nobody would type at that prompt should not work around it either.
+  testSync("does not quietly grow a fourth spelling", () => {
+    expect(Seed_Prompt.isAffirmative("true"))->Expect.toBe(false)
+  })
+})

package/tests/Seed_PromptTest.res.mjs

@@ -0,0 +1,63 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Seed_Prompt$ReventlessSeed from "../src/Seed_Prompt.res.mjs";
+
+globalThis.describe("Seed_Prompt.isAffirmative:", () => {
+  globalThis.test("takes the three spellings of yes", () => {
+    [
+      "y",
+      "yes",
+      "1"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("ignores case, so Y and YES answer as y does", () => {
+    [
+      "Y",
+      "Yes",
+      "YES"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("ignores surrounding space", () => {
+    [
+      " y",
+      "y ",
+      "  yes  "
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(true);
+    });
+  });
+  globalThis.test("declines every spelling of no, capital N included", () => {
+    [
+      "n",
+      "N",
+      "no",
+      "No",
+      "NO"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(false);
+    });
+  });
+  globalThis.test("declines anything it does not recognise", () => {
+    [
+      "",
+      "  ",
+      "0",
+      "true",
+      "yep",
+      "y.",
+      "yesplease",
+      "affirmative"
+    ].forEach(v => {
+      globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative(v)).toBe(false);
+    });
+  });
+  globalThis.test("does not quietly grow a fourth spelling", () => {
+    globalThis.expect(Seed_Prompt$ReventlessSeed.isAffirmative("true")).toBe(false);
+  });
+});
+
+/*  Not a pure module */