@reventlessdev/reventless-seed 1.0.0-alpha.5 → 1.0.0-alpha.7

package/lib/ocaml/Seed_Runner.res

@@ -2,11 +2,9 @@
 
 open Seed_Types
 
-@scope("process") @val external exit: int => unit = "exit"
-@scope("process") @val external env: dict<string> = "env"
 
 let envOr = (key: string, fallback: string): string =>
-  env->Dict.get(key)->Option.getOr(fallback)
+  NodeProcess.env->Dict.get(key)->Option.getOr(fallback)
 
 /** One line of progress per phase, so a slow run never looks hung. */
 let report = (line: string): unit => Console.log(`  ${line}`)
@@ -127,7 +125,7 @@ let run = async (main: unit => promise<unit>): unit =>
     // Exit cleanly: HTTP keep-alive sockets (and, on the interactive path, the
     // readline/stdin handle) can otherwise keep the event loop alive so the CLI
     // appears to hang after a successful run.
-    exit(0)
+    NodeProcess.exit(0)
   } catch {
   | Failed(message) =>
     Console.error("")
@@ -135,7 +133,7 @@ let run = async (main: unit => promise<unit>): unit =>
     Console.error("fresh store once the cause below is fixed.")
     Console.error("")
     Console.error(message)
-    exit(1)
+    NodeProcess.exit(1)
   | exn =>
     Console.error("")
     Console.error("Seeding aborted with an unexpected error:")
@@ -143,7 +141,7 @@ let run = async (main: unit => promise<unit>): unit =>
     Console.error(
       exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"),
     )
-    exit(1)
+    NodeProcess.exit(1)
   }
 
 /**
@@ -172,7 +170,7 @@ let abortStartup = (message: string): unit => {
   Console.error("Seeding did not start — nothing was written. Fix the cause below and re-run.")
   Console.error("")
   Console.error(message)
-  exit(1)
+  NodeProcess.exit(1)
 }
 
 /**

package/lib/ocaml/Seed_Upload.res

@@ -1,32 +1,26 @@
-// Seed-time asset upload against the framework's presign-shaped upload contract.
+// Seed-time asset upload against the framework's upload contract (route B).
 //
-// One code path for both providers: the AWS `Upload_Presign_S3` Function URL and
-// the local dev upload route expose the SAME shape — POST `{fileName,contentType}`
-// → `{uploadUrl, storageRef}`, then PUT the bytes to `uploadUrl`. `uploadAsset`
-// resolves `Ok(storageRef)` — the same same-origin `/{prefix}/{key}` ref a command
-// stores and the UI renders.
+// Minting is a GraphQL mutation on the domain API — `Upload_Presign(store, fileName,
+// contentType)` — authenticated by the same bearer the seed already uses for commands
+// (no separate endpoint, no anonymous surface). `uploadAsset` issues it through the
+// shared `Seed_Client`, then PUTs the bytes to the returned `uploadUrl` and resolves
+// `Ok(storageRef)` — the same `/{prefix}/{key}` ref a command stores and the UI renders.
 //
-// The seed runs under Node, so the returned `uploadUrl` is resolved to an
-// absolute URL against the endpoint's origin: AWS returns an absolute presigned
-// S3 URL (unchanged), while the local route returns a same-origin relative
-// `/{prefix}/{key}` that Node's `fetch` cannot PUT to until it is made absolute.
-//
-// `uploadAsset` is the transport and takes a resolved endpoint. *Which* endpoint
-// an asset uses — a deployment now publishes one per declared store — is
-// `endpointFor` below, kept separate so the decision is testable without a
-// running presign service.
+// The seed runs under Node, so a relative `uploadUrl` (the local dev server returns a
+// same-origin `/{prefix}/{key}`) is resolved to an absolute URL against the client's
+// endpoint origin before the PUT; AWS returns an absolute presigned S3 URL (used as-is).
+// The PUT itself is unauthenticated — presigned on AWS, open on the local route.
 
 type fetchInit = {method: string, headers: dict<string>, body: string}
 type response
 
 @val external fetch: (string, fetchInit) => promise<response> = "fetch"
-@send external responseJson: response => promise<JSON.t> = "json"
 @send external responseText: response => promise<string> = "text"
 @get external responseOk: response => bool = "ok"
 @get external responseStatus: response => int = "status"
 
-// Resolve a possibly-relative URL against a base (WHATWG URL semantics: an
-// absolute `input` ignores `base`, a relative one is resolved against it).
+// Resolve a possibly-relative URL against a base (WHATWG URL semantics: an absolute
+// `input` ignores `base`, a relative one is resolved against it).
 type url
 @new external makeUrl: (string, string) => url = "URL"
 @get external urlHref: url => string = "href"
@@ -43,105 +37,50 @@ let asString = (json: JSON.t): option<string> =>
   | _ => None
   }
 
-/**
- * Which endpoint an asset destined for `store` uploads through:
- *
- *   declares a store with a matching endpoint  → that store's endpoint
- *   declares a store with no matching endpoint → the legacy single service
- *   declares no store                          → the legacy single service
- *   neither available                          → `None`
- *
- * `store` is the qualified `{plugin}.{store}` the platform keys its per-store
- * presign endpoints by. The two middle rows are what keep a deployment predating
- * per-store endpoints — and the local dev server, which serves one upload route
- * — working unchanged.
- *
- * These are the same four rows the AutoUI renderer resolves an upload field by.
- * Resolving one declaration by two different rules is how an asset lands in
- * another plugin's bucket with a 2xx and a plausible-looking ref, so a missing
- * key falls back to the legacy service rather than to some other store.
- */
-let endpointFor = (
-  ~store: option<string>=?,
-  ~uploadEndpoint: string,
-  ~uploadEndpoints: dict<string>,
-): option<string> => {
-  let legacy = uploadEndpoint == "" ? None : Some(uploadEndpoint)
-  switch store {
-  | Some(s) => uploadEndpoints->Dict.get(s)->Option.orElse(legacy)
-  | None => legacy
-  }
-}
-
-/**
- * Why `endpointFor` resolved nothing — the message a data set reports when its
- * upload phase skips.
- *
- * "no upload endpoint" states a fact about the *deployment*; when the deployment
- * publishes endpoints the caller could not match, the fact is about the *client*
- * and that phrasing sends a reader to the bucket, the presign service and the
- * IAM policy, all of which are correct. So the three cases are distinguished and
- * the unmatched one names both the store it wanted and the keys it saw.
- */
-let unresolvedReason = (~store: option<string>=?, ~uploadEndpoints: dict<string>): string => {
-  let available = uploadEndpoints->Dict.keysToArray
-  switch (Seed_Prompt.envValue("SEED_SKIP_UPLOADS"), store, available) {
-  | (Some(_), _, _) => "SEED_SKIP_UPLOADS is set"
-  | (None, _, []) => "this deployment publishes no upload endpoint"
-  | (None, Some(s), keys) =>
-    `this deployment publishes upload endpoints for ${keys->Array.join(", ")}, none for "${s}"`
-  | (None, None, keys) =>
-    `this deployment publishes only per-store upload endpoints (${keys->Array.join(
-        ", ",
-      )}) and this upload names no store`
-  }
-}
+// Whether this run should skip uploads entirely. `SEED_SKIP_UPLOADS` seeds domain data
+// fast, or skips a broken/absent upload path without editing the data set.
+let uploadsSkipped = (): bool => Seed_Prompt.envValue("SEED_SKIP_UPLOADS")->Option.isSome
 
-// A `fetch` that reports an unreachable endpoint as `Error` instead of throwing,
-// so the two-step upload can thread failures without exceptions.
+// A `fetch` that reports an unreachable endpoint as `Error` instead of throwing.
 let tryFetch = async (url: string, init: fetchInit): result<response, string> =>
   try Ok(await fetch(url, init)) catch {
   | _ => Error(`cannot reach ${url}`)
   }
 
 /**
- * Uploads `bytes` under `fileName`/`contentType` through `uploadEndpoint` and
+ * Uploads `bytes` under `fileName`/`contentType` into `store` (the qualified
+ * `{plugin}.{store}` the asset's field declares, e.g. `"Catalog.productImages"`) and
  * resolves `Ok(storageRef)` (the stored `/{prefix}/{key}` ref), or `Error(msg)`
- * describing the step that failed. `authToken`, when supplied, is sent as a
- * Bearer on the presign request (the endpoint decides whether it is required;
- * the PUT itself is unauthenticated — presigned on AWS, open locally).
+ * describing the step that failed. Mints through the domain API's `Upload_Presign`
+ * mutation on `client`, then PUTs the bytes to the returned `uploadUrl`.
  */
 let uploadAsset = async (
-  ~uploadEndpoint: string,
+  ~client: Seed_Client.t,
+  ~store: string,
   ~bytes: string,
   ~fileName: string,
   ~contentType: string,
-  ~authToken: option<string>=?,
 ): result<string, string> => {
-  let presignHeaders = Dict.fromArray([("content-type", "application/json")])
-  authToken->Option.forEach(t => presignHeaders->Dict.set("authorization", `Bearer ${t}`))
-  let presignBody = JSON.stringify(
-    JSON.Encode.object(
-      Dict.fromArray([
-        ("fileName", JSON.Encode.string(fileName)),
-        ("contentType", JSON.Encode.string(contentType)),
-      ]),
-    ),
-  )
+  // 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 presign = try Ok(await Seed_Client.gql(client, ~query, ~label="Upload_Presign")) catch {
+  | Seed_Types.Failed(m) => Error(m)
+  | _ => Error("Upload_Presign: unexpected error")
+  }
 
-  switch await tryFetch(uploadEndpoint, {method: "POST", headers: presignHeaders, body: presignBody}) {
-  | Error(m) => Error(`presign: ${m} — is the platform running?`)
-  | Ok(presignRes) if !(presignRes->responseOk) =>
-    let detail = await presignRes->responseText
-    Error(`presign failed with HTTP ${(presignRes->responseStatus)->Int.toString}: ${detail}`)
-  | Ok(presignRes) =>
-    let json = await presignRes->responseJson
+  switch presign {
+  | Error(m) => Error(`presign: ${m}`)
+  | Ok(data) =>
+    let r = data->field("r")->Option.getOr(JSON.Encode.null)
     switch (
-      json->field("uploadUrl")->Option.flatMap(asString),
-      json->field("storageRef")->Option.flatMap(asString),
+      r->field("uploadUrl")->Option.flatMap(asString),
+      r->field("storageRef")->Option.flatMap(asString),
     ) {
     | (Some(uploadUrl), Some(storageRef)) =>
-      let putUrl = urlHref(makeUrl(uploadUrl, uploadEndpoint))
+      let putUrl = urlHref(makeUrl(uploadUrl, Seed_Client.endpoint(client)))
       switch await tryFetch(
         putUrl,
         {method: "PUT", headers: Dict.fromArray([("content-type", contentType)]), body: bytes},
@@ -152,7 +91,7 @@ let uploadAsset = async (
         let detail = await putRes->responseText
         Error(`upload PUT failed with HTTP ${(putRes->responseStatus)->Int.toString}: ${detail}`)
       }
-    | _ => Error("presign response missing uploadUrl/storageRef")
+    | _ => Error("Upload_Presign response missing uploadUrl/storageRef")
     }
   }
 }

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@reventlessdev/reventless-seed",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.7",
   "description": "Reusable harness for seeding a Reventless platform through its public GraphQL command API",
   "license": "Apache-2.0",
+  "dependencies": {
+    "@reventlessdev/rescript-node": "2.0.0-alpha.0"
+  },
   "devDependencies": {
     "rescript": "12.3.0",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9"
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/rescript.json

@@ -20,6 +20,7 @@
     }
   ],
   "dependencies": [
+    "@reventlessdev/rescript-node",
     "@reventlessdev/rescript-jest"
   ],
   "compiler-flags": [],

package/src/Seed.res

@@ -14,13 +14,12 @@ module Connect = Seed_Connect
 
 exception Failed = Seed_Types.Failed
 
-// A live target a data set seeds against: an authenticated client, the
-// deployment's upload endpoints (the legacy single service and the per-store
-// map, either of which may be empty), and a label.
+// A live target a data set seeds against: an authenticated client, whether uploads
+// are skipped this run, and a label. Uploads mint through the domain API's
+// `Upload_Presign` mutation on the client (route B), so no upload endpoint is carried.
 type connection = Seed_Connect.connection = {
   client: Seed_Client.t,
-  uploadEndpoint: string,
-  uploadEndpoints: dict<string>,
+  uploadsSkipped: bool,
   label: string,
 }
 

package/src/Seed_Client.res

@@ -43,6 +43,10 @@ let make = (~config: config): t => {config, token: None}
     Seed.Upload) can authenticate side-channel requests with the same identity. */
 let currentToken = (t: t): option<string> => t.token
 
+/** The GraphQL endpoint this client targets — so `Seed.Upload` can resolve a
+    relative presigned `uploadUrl` against the same origin. */
+let endpoint = (t: t): string => t.config.endpoint
+
 /** Injects a bearer obtained out-of-band (e.g. a Cognito id token), instead of
     minting one via `login`. Provider-agnostic: the harness only cares that the
     token is a valid bearer for `endpoint`. */

package/src/Seed_Client.res.mjs

@@ -21,6 +21,10 @@ function currentToken(t) {
   return t.token;
 }
 
+function endpoint(t) {
+  return t.config.endpoint;
+}
+
 function useToken(t, token) {
   t.token = token;
 }
@@ -266,6 +270,7 @@ export {
   sleep,
   make,
   currentToken,
+  endpoint,
   useToken,
   field,
   asString,

package/src/Seed_Connect.res

@@ -9,15 +9,13 @@
 
 open Seed_Types
 
-// `uploadEndpoint` is the legacy single presign service (and the local dev
-// server's one upload route); `uploadEndpoints` maps the qualified
-// `{plugin}.{store}` of each declared store to its own presign endpoint. Both,
-// because a deployment may publish either or both — see `Seed_Upload.endpointFor`
-// for the resolution between them.
+// Under route B the client mints uploads through the domain API's `Upload_Presign`
+// mutation (authenticated by the same bearer as commands), so a connection needs no
+// upload endpoint — just the authenticated client and whether uploads are skipped this
+// run (`SEED_SKIP_UPLOADS`). Which store an asset uploads into is the caller's `~store`.
 type connection = {
   client: Seed_Client.t,
-  uploadEndpoint: string,
-  uploadEndpoints: dict<string>,
+  uploadsSkipped: bool,
   label: string,
 }
 
@@ -29,48 +27,20 @@ type connection = {
 let make = async (
   ~label: string,
   ~endpoint: string,
-  ~uploadEndpoint: string,
-  ~uploadEndpoints: dict<string>=Dict.make(),
   ~login: (~username: string, ~password: string) => promise<string>,
   ~localDefaults: bool=false,
 ): connection => {
-  // `SEED_SKIP_UPLOADS` forces the connection to carry no upload endpoint at
-  // all, so a data set's upload phase no-ops the same way it does when a
-  // deployment serves none. Use it to seed domain data fast, or to skip a
-  // broken/absent upload path without editing the data set. It is the single
-  // knob: an empty `REVENTLESS_UPLOAD_ENDPOINT` env reads as "unset" (falls back
-  // to discovery), so this is the reliable way to disable uploads — which means
-  // it has to clear the per-store map too, or a declared store keeps uploading
-  // through it.
-  let skip = Seed_Prompt.envValue("SEED_SKIP_UPLOADS")->Option.isSome
-  let uploadEndpoint = skip ? "" : uploadEndpoint
-  let uploadEndpoints = skip ? Dict.make() : uploadEndpoints
+  // `SEED_SKIP_UPLOADS` forces the upload phase to no-op — seed domain data fast, or
+  // skip a broken/absent upload path without editing the data set. The data set reads
+  // `connection.uploadsSkipped` and reports the skip.
+  let uploadsSkipped = Seed_Upload.uploadsSkipped()
   let (username, password) = await Seed_Prompt.credentials(~localDefaults)
   let token = await login(~username, ~password)
   let client = Seed_Client.make(~config={endpoint: endpoint})
   client->Seed_Client.useToken(token)
-  {client, uploadEndpoint, uploadEndpoints, label}
+  {client, uploadsSkipped, label}
 }
 
-/**
- * The endpoint an asset destined for `store` uploads through, or the reason
- * there is none — the message to report when the upload phase skips.
- *
- * `store` is the qualified `{plugin}.{store}` the asset's field declares, e.g.
- * `"Catalog.productImages"`. Resolution is `Seed_Upload.endpointFor`; naming a
- * store the deployment does not serve falls back to the legacy single service
- * rather than to another store's endpoint.
- */
-let uploadEndpointFor = (c: connection, ~store: string): result<string, string> =>
-  switch Seed_Upload.endpointFor(
-    ~store,
-    ~uploadEndpoint=c.uploadEndpoint,
-    ~uploadEndpoints=c.uploadEndpoints,
-  ) {
-  | Some(endpoint) => Ok(endpoint)
-  | None => Error(Seed_Upload.unresolvedReason(~store, ~uploadEndpoints=c.uploadEndpoints))
-  }
-
 /**
  * A login function backed by an HTTP login endpoint (the local dev
  * `/__inmemory/login` shape: POST `{username, password}` → `{token}`). Reuses
@@ -98,24 +68,18 @@ let envOr = (key: string, fallback: string): string =>
  * defaults baked in and overridable per endpoint (arg, then env var, then
  * default). Empty input at the credential prompt falls back to `admin`/`admin`.
  *
- * No per-store map: the local dev server serves every store through its one
- * upload route, so a data set naming a store resolves to that route by the
- * "declares a store with no matching endpoint" row.
+ * No upload endpoint: uploads mint through the domain API's `Upload_Presign` mutation
+ * on the same `graphql` endpoint, with the store passed per asset.
  */
-let local = (~graphql=?, ~upload=?, ~login=?, ()): (unit => promise<connection>) => {
+let local = (~graphql=?, ~login=?, ()): (unit => promise<connection>) => {
   let endpoint =
     graphql->Option.getOr(envOr("REVENTLESS_GRAPHQL_ENDPOINT", "http://localhost:4000/graphql"))
-  let uploadEndpoint =
-    upload->Option.getOr(
-      envOr("REVENTLESS_UPLOAD_ENDPOINT", "http://localhost:4000/__inmemory/upload"),
-    )
   let loginEndpoint =
     login->Option.getOr(envOr("REVENTLESS_LOGIN_ENDPOINT", "http://localhost:4000/__inmemory/login"))
   () =>
     make(
       ~label="local",
       ~endpoint,
-      ~uploadEndpoint,
       ~login=viaLoginEndpoint(~loginEndpoint),
       ~localDefaults=true,
     )

package/src/Seed_Connect.res.mjs

@@ -6,12 +6,9 @@ import * as Seed_Client$ReventlessSeed from "./Seed_Client.res.mjs";
 import * as Seed_Prompt$ReventlessSeed from "./Seed_Prompt.res.mjs";
 import * as Seed_Upload$ReventlessSeed from "./Seed_Upload.res.mjs";
 
-async function make(label, endpoint, uploadEndpoint, uploadEndpointsOpt, login, localDefaultsOpt) {
-  let uploadEndpoints = uploadEndpointsOpt !== undefined ? uploadEndpointsOpt : ({});
+async function make(label, endpoint, login, localDefaultsOpt) {
   let localDefaults = localDefaultsOpt !== undefined ? localDefaultsOpt : false;
-  let skip = Stdlib_Option.isSome(Seed_Prompt$ReventlessSeed.envValue("SEED_SKIP_UPLOADS"));
-  let uploadEndpoint$1 = skip ? "" : uploadEndpoint;
-  let uploadEndpoints$1 = skip ? ({}) : uploadEndpoints;
+  let uploadsSkipped = Seed_Upload$ReventlessSeed.uploadsSkipped();
   let match = await Seed_Prompt$ReventlessSeed.credentials(localDefaults);
   let token = await login(match[0], match[1]);
   let client = Seed_Client$ReventlessSeed.make({
@@ -20,27 +17,11 @@ async function make(label, endpoint, uploadEndpoint, uploadEndpointsOpt, login,
   Seed_Client$ReventlessSeed.useToken(client, token);
   return {
     client: client,
-    uploadEndpoint: uploadEndpoint$1,
-    uploadEndpoints: uploadEndpoints$1,
+    uploadsSkipped: uploadsSkipped,
     label: label
   };
 }
 
-function uploadEndpointFor(c, store) {
-  let endpoint = Seed_Upload$ReventlessSeed.endpointFor(store, c.uploadEndpoint, c.uploadEndpoints);
-  if (endpoint !== undefined) {
-    return {
-      TAG: "Ok",
-      _0: endpoint
-    };
-  } else {
-    return {
-      TAG: "Error",
-      _0: Seed_Upload$ReventlessSeed.unresolvedReason(store, c.uploadEndpoints)
-    };
-  }
-}
-
 function viaLoginEndpoint(loginEndpoint) {
   return async (username, password) => {
     let client = Seed_Client$ReventlessSeed.make({
@@ -66,16 +47,14 @@ function envOr(key, fallback) {
   return Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue(key), fallback);
 }
 
-function local(graphql, upload, login, param) {
+function local(graphql, login, param) {
   let endpoint = Stdlib_Option.getOr(graphql, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_GRAPHQL_ENDPOINT"), "http://localhost:4000/graphql"));
-  let uploadEndpoint = Stdlib_Option.getOr(upload, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_UPLOAD_ENDPOINT"), "http://localhost:4000/__inmemory/upload"));
   let loginEndpoint = Stdlib_Option.getOr(login, Stdlib_Option.getOr(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_LOGIN_ENDPOINT"), "http://localhost:4000/__inmemory/login"));
-  return () => make("local", endpoint, uploadEndpoint, undefined, viaLoginEndpoint(loginEndpoint), true);
+  return () => make("local", endpoint, viaLoginEndpoint(loginEndpoint), true);
 }
 
 export {
   make,
-  uploadEndpointFor,
   viaLoginEndpoint,
   envOr,
   local,

package/src/Seed_Prompt.res

@@ -1,7 +1,7 @@
 // One shared readline interface for every interactive prompt in a seed run.
 //
 // The reason this module exists: creating and closing a fresh `readline`
-// interface per prompt leaves stdin paused after the first `close`, so the
+// interface per prompt leaves NodeProcess.stdin paused after the first `close`, so the
 // second prompt (password after username) never fires and the run hangs. A
 // single interface, created lazily and closed exactly once, avoids that — and a
 // `muted` gate on its output lets password entry reuse the same interface
@@ -14,18 +14,8 @@ open Seed_Types
 
 // ── Node bindings ─────────────────────────────────────────────────────────────
 
-type stream
-@val @scope("process") external stdin: stream = "stdin"
-@val @scope("process") external stdout: stream = "stdout"
-@send external writeStream: (stream, string) => unit = "write"
-@get external isTTY: stream => bool = "isTTY"
-@send external pauseStream: stream => unit = "pause"
-@send external unrefStream: stream => unit = "unref"
-
-@scope("process") @val external processEnv: dict<string> = "env"
-
 type rl
-type rlOptions = {input: stream, output: stream, terminal?: bool}
+type rlOptions = {input: NodeProcess.stream, output: NodeProcess.stream, terminal?: bool}
 @module("node:readline") external createInterface: rlOptions => rl = "createInterface"
 @send external question: (rl, string, string => unit) => unit = "question"
 @send external closeRl: rl => unit = "close"
@@ -42,10 +32,10 @@ let iface = (): rl =>
   switch rlRef.contents {
   | Some(rl) => rl
   | None =>
-    let rl = createInterface({input: stdin, output: stdout, terminal: true})
+    let rl = createInterface({input: NodeProcess.stdin, output: NodeProcess.stdout, terminal: true})
     rl->setWriteToOutput(s =>
       if !muted.contents {
-        stdout->writeStream(s)
+        NodeProcess.stdout->NodeProcess.write(s)
       }
     )
     rlRef := Some(rl)
@@ -58,23 +48,23 @@ let close = (): unit =>
     rl->closeRl
     rlRef := None
     // Closing the interface is not enough: a terminal-mode readline leaves
-    // stdin resumed and reffed, which keeps the event loop alive so the CLI
+    // NodeProcess.stdin resumed and reffed, which keeps the event loop alive so the CLI
     // never exits after seeding. Release it explicitly.
-    stdin->pauseStream
-    stdin->unrefStream
+    NodeProcess.stdin->NodeProcess.pause
+    NodeProcess.stdin->NodeProcess.unref
   | None => ()
   }
 
 // ── Env + TTY ─────────────────────────────────────────────────────────────────
 
 let envValue = (key: string): option<string> =>
-  switch processEnv->Dict.get(key) {
+  switch NodeProcess.env->Dict.get(key) {
   | Some(v) if v->String.trim != "" => Some(v->String.trim)
   | _ => None
   }
 
 let requireTty = (): unit =>
-  if !(stdin->isTTY) {
+  if !(NodeProcess.stdin->NodeProcess.isTTY->Option.getOr(false)) {
     throw(
       Failed(
         "no TTY for an interactive prompt — set the documented SEED_* / REVENTLESS_DEMO_* " ++
@@ -101,7 +91,7 @@ let askHidden = (query: string): promise<string> =>
     let rl = iface()
     rl->question(query, answer => {
       muted := false
-      stdout->writeStream("\n")
+      NodeProcess.stdout->NodeProcess.write("\n")
       resolve(answer)
     })
     muted := true

package/src/Seed_Prompt.res.mjs

@@ -53,7 +53,7 @@ function envValue(key) {
 }
 
 function requireTty() {
-  if (process.stdin.isTTY) {
+  if (Stdlib_Option.getOr(process.stdin.isTTY, false)) {
     return;
   }
   throw {

package/src/Seed_Runner.res

@@ -2,11 +2,9 @@
 
 open Seed_Types
 
-@scope("process") @val external exit: int => unit = "exit"
-@scope("process") @val external env: dict<string> = "env"
 
 let envOr = (key: string, fallback: string): string =>
-  env->Dict.get(key)->Option.getOr(fallback)
+  NodeProcess.env->Dict.get(key)->Option.getOr(fallback)
 
 /** One line of progress per phase, so a slow run never looks hung. */
 let report = (line: string): unit => Console.log(`  ${line}`)
@@ -127,7 +125,7 @@ let run = async (main: unit => promise<unit>): unit =>
     // Exit cleanly: HTTP keep-alive sockets (and, on the interactive path, the
     // readline/stdin handle) can otherwise keep the event loop alive so the CLI
     // appears to hang after a successful run.
-    exit(0)
+    NodeProcess.exit(0)
   } catch {
   | Failed(message) =>
     Console.error("")
@@ -135,7 +133,7 @@ let run = async (main: unit => promise<unit>): unit =>
     Console.error("fresh store once the cause below is fixed.")
     Console.error("")
     Console.error(message)
-    exit(1)
+    NodeProcess.exit(1)
   | exn =>
     Console.error("")
     Console.error("Seeding aborted with an unexpected error:")
@@ -143,7 +141,7 @@ let run = async (main: unit => promise<unit>): unit =>
     Console.error(
       exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown"),
     )
-    exit(1)
+    NodeProcess.exit(1)
   }
 
 /**
@@ -172,7 +170,7 @@ let abortStartup = (message: string): unit => {
   Console.error("Seeding did not start — nothing was written. Fix the cause below and re-run.")
   Console.error("")
   Console.error(message)
-  exit(1)
+  NodeProcess.exit(1)
 }
 
 /**