@reventlessdev/reventless-seed 1.0.0-alpha.20 → 1.0.0-alpha.22

package/lib/ocaml/Seed_Prompt.res

@@ -63,12 +63,16 @@ let envValue = (key: string): option<string> =>
   | _ => None
   }
 
+/** Whether an interactive prompt is possible at all. Callers that can carry on
+    without an answer ask this first; a prompt nobody can answer is worse than a
+    default, because it turns a workable run into a hang or a throw. */
+let hasTty = (): bool => NodeProcess.stdin->NodeProcess.isTTY->Option.getOr(false)
+
 let requireTty = (): unit =>
-  if !(NodeProcess.stdin->NodeProcess.isTTY->Option.getOr(false)) {
+  if !hasTty() {
     throw(
       Failed(
-        "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++
-        "env vars to run non-interactively.",
+        "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++ "env vars to run non-interactively.",
       ),
     )
   }
@@ -125,12 +129,7 @@ let isAffirmative = (answer: string): bool =>
  * `defaultIndex` makes Enter a valid answer, selecting that 0-based option;
  * without one every reply must name a choice.
  */
-let select = async (
-  ~title: string,
-  ~options: array<(string, 'a)>,
-  ~env=?,
-  ~defaultIndex=?,
-): 'a =>
+let select = async (~title: string, ~options: array<(string, 'a)>, ~env=?, ~defaultIndex=?): 'a =>
   switch options {
   | [(_, only)] => only
   | _ =>
@@ -163,9 +162,7 @@ let select = async (
       | _ => ""
       }
       let rec pick = async (): 'a => {
-        let answer = await ask(
-          `\nSelect [1-${(options->Array.length)->Int.toString}]${hint}: `,
-        )
+        let answer = await ask(`\nSelect [1-${options->Array.length->Int.toString}]${hint}: `)
         switch (answer, fallback) {
         | ("", Some((_, value))) => value
         | _ =>
@@ -183,11 +180,31 @@ let select = async (
     }
   }
 
+/**
+ * The account a run authenticated as, alongside every account the platform's
+ * accounts file declares.
+ *
+ * `accounts` is `[]` whenever no file was read — the
+ * `REVENTLESS_DEMO_USER`/`REVENTLESS_DEMO_PASSWORD` path bypasses it entirely,
+ * and so does typing both halves — so a consumer must handle empty rather than
+ * assume the file was there. `caller` is always populated, but carries no
+ * `groups` and no `userId` on those paths: nothing read them off a file.
+ */
+type resolved = {caller: Seed_Users.user, accounts: array<Seed_Users.user>}
+
+let typedUser = (~username: string, ~password: string): Seed_Users.user => {
+  username,
+  password,
+  groups: [],
+  userId: None,
+  demoOwner: None,
+}
+
 // Typing both halves is the fallback, not the first offer: it is what happens
 // when the platform keeps no accounts file. `envUser` is threaded in so a
 // `REVENTLESS_DEMO_USER` that named nobody in the file still skips the username
 // prompt rather than asking for a name that was already given.
-let askCredentials = async (~localDefaults: bool, ~envUser: option<string>): (string, string) => {
+let askCredentials = async (~localDefaults: bool, ~envUser: option<string>): Seed_Users.user => {
   let username = switch envUser {
   | Some(u) => u
   | None =>
@@ -202,7 +219,7 @@ let askCredentials = async (~localDefaults: bool, ~envUser: option<string>): (st
     let entered = await askHidden(localDefaults ? "Password [admin]: " : "Password: ")
     entered == "" && localDefaults ? "admin" : entered
   }
-  (username, password)
+  typedUser(~username, ~password)
 }
 
 // The accounts file the platform already keeps (`.reventless/users.yaml`, or
@@ -212,7 +229,12 @@ let askCredentials = async (~localDefaults: bool, ~envUser: option<string>): (st
 // A named `REVENTLESS_DEMO_USER` picks its entry directly; otherwise the file's
 // accounts are offered in the order it defines them, first as the default.
 // `None` means the file has nothing to offer and the caller should ask.
-let fromUsersFile = async (~envUser: option<string>): option<(string, string)> =>
+//
+// The whole list travels back with the chosen account, not just the credentials
+// it supplied: the file is also the only place a demo owner's id can be looked
+// up, and reading it once to pick a login and never again is what let a data set
+// seed rows under ids nobody on the platform holds.
+let fromUsersFile = async (~envUser: option<string>): option<resolved> =>
   switch Seed_Users.load(~path=?envValue("SEED_USERS_FILE")) {
   | None => None
   | Some((path, users)) =>
@@ -233,7 +255,7 @@ let fromUsersFile = async (~envUser: option<string>): option<(string, string)> =
     // operator checks when owner-scoped rows turn up under the wrong account.
     chosen->Option.map(u => {
       Console.log(`Logging in as ${u.username} (from ${path})`)
-      (u.username, u.password)
+      {caller: u, accounts: users}
     })
   }
 
@@ -245,19 +267,22 @@ let fromUsersFile = async (~envUser: option<string>): option<(string, string)> =
  * `.reventless/users.yaml` supplies the accounts to choose from, and only a
  * platform without one falls back to typing both halves — where, with
  * `localDefaults`, empty input means `admin`/`admin`.
+ *
+ * Returns the resolved account rather than a pair, and the accounts file
+ * alongside it when there was one — see `resolved`.
  */
-let credentials = async (~localDefaults: bool=false): (string, string) => {
+let credentials = async (~localDefaults: bool=false): resolved => {
   let envUser = envValue("REVENTLESS_DEMO_USER")
-  let (username, password) = switch (envUser, envValue("REVENTLESS_DEMO_PASSWORD")) {
-  | (Some(u), Some(p)) => (u, p)
+  let resolved = switch (envUser, envValue("REVENTLESS_DEMO_PASSWORD")) {
+  | (Some(username), Some(password)) => {caller: typedUser(~username, ~password), accounts: []}
   | _ =>
     switch await fromUsersFile(~envUser) {
-    | Some(pair) => pair
-    | None => await askCredentials(~localDefaults, ~envUser)
+    | Some(resolved) => resolved
+    | None => {caller: await askCredentials(~localDefaults, ~envUser), accounts: []}
     }
   }
-  if username == "" || password == "" {
+  if resolved.caller.username == "" || resolved.caller.password == "" {
     throw(Failed("username and password are required."))
   }
-  (username, password)
+  resolved
 }

package/lib/ocaml/Seed_PromptTest.res

@@ -15,22 +15,18 @@ open JestGlobals
 
 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)
-    )
+    ["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)
-    )
+    ["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)
+    [" y", "y ", "  yes  "]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(true),
     )
   })
 
@@ -38,14 +34,14 @@ describe("Seed_Prompt.isAffirmative:", () => {
   // 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)
+    ["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)
+    ["", "  ", "0", "true", "yep", "y.", "yesplease", "affirmative"]->Array.forEach(
+      v => expect(Seed_Prompt.isAffirmative(v))->Expect.toBe(false),
     )
   })
 

package/lib/ocaml/Seed_Random.res

@@ -10,13 +10,15 @@ type t = {mutable state: int}
 
 let make = (~seed: int): t => {state: seed}
 
-
 /** mulberry32 — small, fast, and stable across JS engines and Node versions. */
 let float = (r: t): float => {
   r.state = (r.state + 0x6d2b79f5)->Int.bitwiseOr(0)
   let a = r.state
   let b = imul(a->Int.bitwiseXor(a->Int.shiftRightUnsigned(15)), a->Int.bitwiseOr(1))
-  let c = b->Int.bitwiseXor(b + imul(b->Int.bitwiseXor(b->Int.shiftRightUnsigned(7)), b->Int.bitwiseOr(61)))
+  let c =
+    b->Int.bitwiseXor(
+      b + imul(b->Int.bitwiseXor(b->Int.shiftRightUnsigned(7)), b->Int.bitwiseOr(61)),
+    )
   let bits = c->Int.bitwiseXor(c->Int.shiftRightUnsigned(14))
   // `bits` is a signed 32-bit result; fold the sign bit back in to get the
   // unsigned value a `>>> 0` would produce.

package/lib/ocaml/Seed_RandomTest.res

@@ -16,36 +16,45 @@ describe("Seed_Random:", () => {
   }
 
   describe("reproducibility — the reason this module exists:", () => {
-    testSync("the same seed replays the same sequence", () =>
-      expect(take(~seed=42, ~n=25))->toEqual(take(~seed=42, ~n=25))
+    testSync(
+      "the same seed replays the same sequence",
+      () => expect(take(~seed=42, ~n=25))->toEqual(take(~seed=42, ~n=25)),
     )
 
     // Without this, a generator that returned a constant would satisfy the
     // case above and nothing else in the suite would catch it.
-    testSync("different seeds diverge", () =>
-      expect(take(~seed=42, ~n=25) == take(~seed=43, ~n=25))->toBe(false)
+    testSync(
+      "different seeds diverge",
+      () => expect(take(~seed=42, ~n=25) == take(~seed=43, ~n=25))->toBe(false),
     )
 
-    testSync("a fresh generator does not continue the previous one", () => {
-      let r = Seed_Random.make(~seed=7)
-      let first = Seed_Random.float(r)
-      let _ = Seed_Random.float(r)
-      expect(Seed_Random.float(Seed_Random.make(~seed=7)))->toEqual(first)
-    })
+    testSync(
+      "a fresh generator does not continue the previous one",
+      () => {
+        let r = Seed_Random.make(~seed=7)
+        let first = Seed_Random.float(r)
+        let _ = Seed_Random.float(r)
+        expect(Seed_Random.float(Seed_Random.make(~seed=7)))->toEqual(first)
+      },
+    )
   })
 
   describe("float stays a unit interval:", () => {
     // mulberry32's last step is a signed 32-bit value folded back to unsigned.
     // Get that fold wrong and roughly half the draws come out negative, which
     // every consumer below (int, pick, sampleWeighted) silently mis-scales.
-    testSync("every draw is in [0, 1)", () =>
-      expect(take(~seed=99, ~n=500)->Array.every(f => f >= 0.0 && f < 1.0))->toBe(true)
+    testSync(
+      "every draw is in [0, 1)",
+      () => expect(take(~seed=99, ~n=500)->Array.every(f => f >= 0.0 && f < 1.0))->toBe(true),
     )
 
-    testSync("and the draws are not all the same value", () => {
-      let draws = take(~seed=99, ~n=100)
-      expect(draws->Array.some(f => f != draws->Array.getUnsafe(0)))->toBe(true)
-    })
+    testSync(
+      "and the draws are not all the same value",
+      () => {
+        let draws = take(~seed=99, ~n=100)
+        expect(draws->Array.some(f => f != draws->Array.getUnsafe(0)))->toBe(true)
+      },
+    )
   })
 
   describe("int is inclusive on both ends, as documented:", () => {
@@ -54,40 +63,50 @@ describe("Seed_Random:", () => {
       Array.make(~length=n, 0)->Array.map(_ => Seed_Random.int(r, ~min, ~max))
     }
 
-    testSync("never escapes the range", () =>
-      expect(draws(~min=3, ~max=7, ~n=500)->Array.every(i => i >= 3 && i <= 7))->toBe(true)
+    testSync(
+      "never escapes the range",
+      () => expect(draws(~min=3, ~max=7, ~n=500)->Array.every(i => i >= 3 && i <= 7))->toBe(true),
     )
 
     // The documented contract is "inclusive on both ends"; an off-by-one in the
     // `max - min + 1` scaling shows up as a bound that is never drawn.
-    testSync("reaches both bounds", () => {
-      let d = draws(~min=3, ~max=7, ~n=500)
-      expect((d->Array.includes(3), d->Array.includes(7)))->toEqual((true, true))
-    })
+    testSync(
+      "reaches both bounds",
+      () => {
+        let d = draws(~min=3, ~max=7, ~n=500)
+        expect((d->Array.includes(3), d->Array.includes(7)))->toEqual((true, true))
+      },
+    )
 
-    testSync("a single-value range is that value", () =>
-      expect(draws(~min=4, ~max=4, ~n=10)->Array.every(i => i == 4))->toBe(true)
+    testSync(
+      "a single-value range is that value",
+      () => expect(draws(~min=4, ~max=4, ~n=10)->Array.every(i => i == 4))->toBe(true),
     )
   })
 
   describe("pick:", () => {
-    testSync("returns None for an empty array", () =>
-      expect(Seed_Random.make(~seed=1)->Seed_Random.pick([]))->toEqual(None)
+    testSync(
+      "returns None for an empty array",
+      () => expect(Seed_Random.make(~seed=1)->Seed_Random.pick([]))->toEqual(None),
     )
 
-    testSync("always lands on a member", () => {
-      let r = Seed_Random.make(~seed=2)
-      let xs = ["a", "b", "c", "d"]
-      let hits = Array.make(~length=200, "")->Array.map(_ =>
-        r->Seed_Random.pickOr(~fallback="MISS", xs)
-      )
-      expect(hits->Array.every(h => xs->Array.includes(h)))->toBe(true)
-    })
+    testSync(
+      "always lands on a member",
+      () => {
+        let r = Seed_Random.make(~seed=2)
+        let xs = ["a", "b", "c", "d"]
+        let hits =
+          Array.make(~length=200, "")->Array.map(_ => r->Seed_Random.pickOr(~fallback="MISS", xs))
+        expect(hits->Array.every(h => xs->Array.includes(h)))->toBe(true)
+      },
+    )
 
-    testSync("pickOr falls back only when there is nothing to pick", () =>
-      expect(Seed_Random.make(~seed=3)->Seed_Random.pickOr(~fallback="fallback", []))->toBe(
-        "fallback",
-      )
+    testSync(
+      "pickOr falls back only when there is nothing to pick",
+      () =>
+        expect(Seed_Random.make(~seed=3)->Seed_Random.pickOr(~fallback="fallback", []))->toBe(
+          "fallback",
+        ),
     )
   })
 
@@ -96,65 +115,86 @@ describe("Seed_Random:", () => {
 
     // The documented shuffle use: equal weights, count = length. If sampling
     // ever replaced instead of removing, duplicates would appear here.
-    testSync("count = length yields a permutation, not a multiset", () => {
-      let xs = ["a", "b", "c", "d", "e"]
-      let out = Seed_Random.make(~seed=11)->Seed_Random.sampleWeighted(equal(xs), ~count=5)
-      let sorted = out->Array.toSorted(String.compare)
-      expect((out->Array.length, sorted))->toEqual((5, ["a", "b", "c", "d", "e"]))
-    })
-
-    testSync("count < length returns exactly count distinct items", () => {
-      let xs = ["a", "b", "c", "d", "e"]
-      let out = Seed_Random.make(~seed=12)->Seed_Random.sampleWeighted(equal(xs), ~count=3)
-      let distinct = Set.fromArray(out)->Set.size
-      expect((out->Array.length, distinct))->toEqual((3, 3))
-    })
-
-    testSync("count > length clamps to the pool", () =>
-      expect(
-        Seed_Random.make(~seed=13)
-        ->Seed_Random.sampleWeighted(equal(["a", "b"]), ~count=99)
-        ->Array.length,
-      )->toBe(2)
-    )
-
-    testSync("a zero-weight entry is never chosen while others remain", () => {
-      let out =
-        Seed_Random.make(~seed=14)->Seed_Random.sampleWeighted(
-          [("never", 0.0), ("a", 1.0), ("b", 1.0)],
-          ~count=2,
-        )
-      expect(out->Array.includes("never"))->toBe(false)
-    })
-
-    testSync("is reproducible for a given seed", () => {
-      let run = () =>
-        Seed_Random.make(~seed=15)->Seed_Random.sampleWeighted(
-          equal(["a", "b", "c", "d", "e", "f"]),
-          ~count=4,
-        )
-      expect(run())->toEqual(run())
-    })
+    testSync(
+      "count = length yields a permutation, not a multiset",
+      () => {
+        let xs = ["a", "b", "c", "d", "e"]
+        let out = Seed_Random.make(~seed=11)->Seed_Random.sampleWeighted(equal(xs), ~count=5)
+        let sorted = out->Array.toSorted(String.compare)
+        expect((out->Array.length, sorted))->toEqual((5, ["a", "b", "c", "d", "e"]))
+      },
+    )
+
+    testSync(
+      "count < length returns exactly count distinct items",
+      () => {
+        let xs = ["a", "b", "c", "d", "e"]
+        let out = Seed_Random.make(~seed=12)->Seed_Random.sampleWeighted(equal(xs), ~count=3)
+        let distinct = Set.fromArray(out)->Set.size
+        expect((out->Array.length, distinct))->toEqual((3, 3))
+      },
+    )
+
+    testSync(
+      "count > length clamps to the pool",
+      () =>
+        expect(
+          Seed_Random.make(~seed=13)
+          ->Seed_Random.sampleWeighted(equal(["a", "b"]), ~count=99)
+          ->Array.length,
+        )->toBe(2),
+    )
+
+    testSync(
+      "a zero-weight entry is never chosen while others remain",
+      () => {
+        let out =
+          Seed_Random.make(~seed=14)->Seed_Random.sampleWeighted(
+            [("never", 0.0), ("a", 1.0), ("b", 1.0)],
+            ~count=2,
+          )
+        expect(out->Array.includes("never"))->toBe(false)
+      },
+    )
+
+    testSync(
+      "is reproducible for a given seed",
+      () => {
+        let run = () =>
+          Seed_Random.make(~seed=15)->Seed_Random.sampleWeighted(
+            equal(["a", "b", "c", "d", "e", "f"]),
+            ~count=4,
+          )
+        expect(run())->toEqual(run())
+      },
+    )
   })
 
   describe("zipfWeights skews toward the head:", () => {
     let weights = Seed_Random.zipfWeights(["a", "b", "c", "d", "e"], ~exponent=1.1)
 
-    testSync("keeps every item, in order", () =>
-      expect(weights->Array.map(((item, _)) => item))->toEqual(["a", "b", "c", "d", "e"])
+    testSync(
+      "keeps every item, in order",
+      () => expect(weights->Array.map(((item, _)) => item))->toEqual(["a", "b", "c", "d", "e"]),
     )
 
-    testSync("weight decreases monotonically with rank", () => {
-      let ws = weights->Array.map(((_, w)) => w)
-      let decreasing =
-        ws->Array.everyWithIndex((w, i) => i == 0 || w < ws->Array.getUnsafe(i - 1))
-      expect(decreasing)->toBe(true)
-    })
+    testSync(
+      "weight decreases monotonically with rank",
+      () => {
+        let ws = weights->Array.map(((_, w)) => w)
+        let decreasing =
+          ws->Array.everyWithIndex((w, i) => i == 0 || w < ws->Array.getUnsafe(i - 1))
+        expect(decreasing)->toBe(true)
+      },
+    )
 
-    testSync("the leader is clear — first outweighs last several times over", () => {
-      let first = weights->Array.get(0)->Option.mapOr(0.0, ((_, w)) => w)
-      let last = weights->Array.get(4)->Option.mapOr(0.0, ((_, w)) => w)
-      expect(first > last *. 3.0)->toBe(true)
-    })
+    testSync(
+      "the leader is clear — first outweighs last several times over",
+      () => {
+        let first = weights->Array.get(0)->Option.mapOr(0.0, ((_, w)) => w)
+        let last = weights->Array.get(4)->Option.mapOr(0.0, ((_, w)) => w)
+        expect(first > last *. 3.0)->toBe(true)
+      },
+    )
   })
 })

package/lib/ocaml/Seed_Runner.res

@@ -2,7 +2,6 @@
 
 open Seed_Types
 
-
 let envOr = (key: string, fallback: string): string =>
   NodeProcess.env->Dict.get(key)->Option.getOr(fallback)
 
@@ -58,14 +57,12 @@ let verifyViews = async (client: Seed_Client.t, ~views: array<view>): dict<int>
     Console.log(`  ${count->Int.toString->String.padStart(4, " ")}  ${name}${note}`)
   })
 
-  let empty =
-    views
-    ->Array.filterMap(v =>
-      switch v {
-      | Seeded(name) if counts->Dict.get(name)->Option.getOr(0) == 0 => Some(name)
-      | _ => None
-      }
-    )
+  let empty = views->Array.filterMap(v =>
+    switch v {
+    | Seeded(name) if counts->Dict.get(name)->Option.getOr(0) == 0 => Some(name)
+    | _ => None
+    }
+  )
   if empty->Array.length > 0 {
     throw(Failed(`these views are still empty after seeding: ${empty->Array.join(", ")}`))
   }
@@ -138,9 +135,7 @@ let run = async (main: unit => promise<unit>): unit =>
     Console.error("")
     Console.error("Seeding aborted with an unexpected error:")
     Console.error("")
-    Console.error(
-      exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"),
-    )
+    Console.error(exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"))
     NodeProcess.exit(1)
   }
 

package/lib/ocaml/Seed_Upload.res

@@ -64,7 +64,9 @@ let uploadAsset = async (
   // GraphQL string literals: JSON-quote the argument values (JSON string escaping is a
   // superset-safe subset of GraphQL's for these ASCII-ish inputs).
   let q = s => JSON.stringify(JSON.Encode.string(s))
-  let query = `mutation { r: Upload_Presign(store: ${q(store)}, fileName: ${q(fileName)}, contentType: ${q(contentType)}) { uploadUrl storageRef } }`
+  let query = `mutation { r: Upload_Presign(store: ${q(store)}, fileName: ${q(
+      fileName,
+    )}, contentType: ${q(contentType)}) { uploadUrl storageRef } }`
 
   let presign = try Ok(await Seed_Client.gql(client, ~query, ~label="Upload_Presign")) catch {
   | Seed_Types.Failed(m) => Error(m)
@@ -89,7 +91,7 @@ let uploadAsset = async (
       | Ok(putRes) if putRes->responseOk => Ok(storageRef)
       | Ok(putRes) =>
         let detail = await putRes->responseText
-        Error(`upload PUT failed with HTTP ${(putRes->responseStatus)->Int.toString}: ${detail}`)
+        Error(`upload PUT failed with HTTP ${putRes->responseStatus->Int.toString}: ${detail}`)
       }
     | _ => Error("Upload_Presign response missing uploadUrl/storageRef")
     }

package/lib/ocaml/Seed_Users.res

@@ -11,8 +11,21 @@
 
 @module("yaml") external parseYaml: string => JSON.t = "parse"
 
-/** One account: what to log in as, and what to send with it. */
-type user = {username: string, password: string, groups: array<string>}
+/**
+ * One account: what to log in as, what to send with it, and — when the file
+ * records one — the id the platform stamps on rows this account writes.
+ *
+ * `userId` is optional because absence is normal on both platforms: a local file
+ * may omit it and let the auth adapter default it to the username, and a
+ * hand-maintained AWS file records subs the pool minted, so it can lag.
+ */
+type user = {
+  username: string,
+  password: string,
+  groups: array<string>,
+  userId: option<string>,
+  demoOwner: option<string>,
+}
 
 let asString = (json: JSON.t): option<string> =>
   switch json {
@@ -32,7 +45,13 @@ let userOf = (json: JSON.t): option<user> =>
       | Some(JSON.Array(items)) => items->Array.filterMap(asString)
       | _ => []
       }
-      Some({username, password, groups})
+      Some({
+        username,
+        password,
+        groups,
+        userId: obj->Dict.get("userId")->Option.flatMap(asString),
+        demoOwner: obj->Dict.get("demoOwner")->Option.flatMap(asString),
+      })
     | _ => None
     }
   | _ => None
@@ -75,6 +94,14 @@ let load = (~path: option<string>=?): option<(string, array<user>)> => {
   users->Array.length == 0 ? None : Some((file, users))
 }
 
+/** The account that plays `name` in a demo: the one whose `demoOwner` says so,
+    else the one named `name` — which is how a file without the field reads. */
+let playing = (users: array<user>, name: string): option<user> =>
+  switch users->Array.find(u => u.demoOwner == Some(name)) {
+  | Some(_) as declared => declared
+  | None => users->Array.find(u => u.username == name)
+  }
+
 /** Menu label: the username, plus whatever groups the file records for it. */
 let label = (u: user): string =>
   u.groups->Array.length == 0 ? u.username : `${u.username}  [${u.groups->Array.join(", ")}]`