@uniflowed/test 0.0.0-alpha.18 → 0.0.0-alpha.20

package/internal/namespace.js

@@ -50,8 +50,11 @@ const stubbedGlobals: Map<string, { readonly owned: boolean, readonly value: mix
 /**
  * Read the process environment, whichever host this is.
  *
- * Node, Deno and Bun all expose `process.env`; Deno also has `Deno.env`, and
- * reaching for `process` first keeps one code path across the three.
+ * Node and Bun expose `process` as a global; **Deno does not**, and has the
+ * same object under `node:process`. `../worker.js` installs it on the global
+ * before anything here runs, which is what keeps this one code path across the
+ * three — and is why the `null` branch below is still reachable, for a host
+ * that is neither.
  */
 function environment(): { [string]: string } | null {
   const host = globalThis as $FlowFixMe;

package/internal/output.js

@@ -241,6 +241,19 @@ function writer(
  * Installed once, for the life of the worker: a worker runs many files, and
  * restoring the real methods between them would leave a window in which a
  * straggling `setTimeout` from the previous file writes into the protocol.
+ *
+ * # A page has no stream to take
+ *
+ * `uf test --browser` runs this same capture inside a page
+ * (`./browser/page.js`), and there the whole premise of the returned value is
+ * absent: there is no `process.stdout`, so there is nothing for a test to
+ * write into by accident, and the protocol's channel is a separate HTTP
+ * request rather than a stream anything else can reach. So the two `write`
+ * methods are only replaced when there are two `write` methods, and the
+ * "raw stream" handed back is a no-op nobody has a use for.
+ *
+ * Deliberately not a `typeof process` check at each use: the question is asked
+ * once, here, because the answer cannot change under a running host.
  */
 export function install(to: OutputSink): (chunk: string) => void {
   const global = host();
@@ -248,11 +261,14 @@ export function install(to: OutputSink): (chunk: string) => void {
   if (already != null) {
     return already;
   }
-  const stdout = global.process.stdout;
-  const real = stdout.write;
-  const protocol = (chunk: string) => {
-    real.call(stdout, chunk);
-  };
+  const stdout = global.process?.stdout;
+  const real = stdout?.write;
+  const protocol =
+    real == null
+      ? (_chunk: string) => {}
+      : (chunk: string) => {
+          real.call(stdout, chunk);
+        };
   raw = protocol;
   sink = to;
   for (const method of Object.keys(CONSOLE_STREAMS)) {
@@ -271,8 +287,10 @@ export function install(to: OutputSink): (chunk: string) => void {
     capture("stderr", `${userFrames(error.stack) ?? `Trace: ${error.message}`}\n`);
   };
 
-  global.process.stdout.write = writer("stdout");
-  global.process.stderr.write = writer("stderr");
+  if (global.process?.stdout != null) {
+    global.process.stdout.write = writer("stdout");
+    global.process.stderr.write = writer("stderr");
+  }
   return protocol;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/test",
-  "version": "0.0.0-alpha.18",
+  "version": "0.0.0-alpha.20",
   "description": "The test API and worker for `uf test`: describe/it, a full matcher set, and the process uf fans test files out to.",
   "type": "module",
   "license": "MIT",
@@ -14,16 +14,19 @@
     ".": "./index.js",
     "./in-source": "./in-source.js",
     "./worker": "./worker.js",
+    "./browser-worker": "./browser-worker.js",
     "./package.json": "./package.json"
   },
   "files": [
+    "browser-worker.js",
     "in-source.js",
     "index.js",
     "internal",
-    "worker.js"
+    "worker.js",
+    "!*.test.js"
   ],
   "dependencies": {
-    "@uniflowed/host": "0.0.0-alpha.18"
+    "@uniflowed/host": "0.0.0-alpha.20"
   },
   "peerDependencies": {
     "axe-core": ">=4"

package/worker.js

@@ -49,6 +49,7 @@
 
 import * as output from "./internal/output.js";
 import { AsyncLocalStorage } from "node:async_hooks";
+import process from "node:process";
 import { writeChangedSnapshots } from "./internal/snapshot.js";
 import { createInterface } from "node:readline";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -57,6 +58,27 @@ import { installInSourceTests } from "./in-source.js";
 import { restoreSharedState } from "./internal/isolation.js";
 import { run } from "./internal/run.js";
 
+// `process` is imported rather than read off the global, and then put *on*
+// the global, because one host in three does not have it there.
+//
+// Deno exposes the whole object as `node:process` and nothing as
+// `globalThis.process` — `crates/uf_cli/tests/deno_host.rs` starts a real one
+// and asserts both halves. Every module this worker reaches that wants the
+// process reaches for the global: `internal/output.js` replaces
+// `process.stdout.write` so a test's printing cannot land in the middle of the
+// protocol, `internal/namespace.js` reads `process.env` for `stubEnv`, and
+// `internal/axe.js` reads `UF_AXE` from it. Threading an import through all
+// three would put a `node:` specifier into modules a browser build resolves,
+// for a difference no other host has.
+//
+// So the entry point installs it, once, before anything below runs. `??=`
+// rather than `=`: on Node and Bun the global is already the real object and
+// this must not replace it with a second view of the same thing.
+//
+// It is a shim of the host, in the one file that is a process entry point, and
+// it stops here — nothing else in `@uniflowed/test` may do this.
+globalThis.process ??= process;
+
 /** What `uf` sends for one file. */
 type Request = {|
   readonly file: string,