@nimbus-sh/core 0.7.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus-sh/core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Backend-agnostic half of Nimbus — the durable filesystem, the shell, and the OS/process contracts, over a host-supplied SQL port.",
   "keywords": [
     "filesystem",
@@ -55,7 +55,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@nimbus-sh/platform": "^0.2.0",
+    "@nimbus-sh/platform": "^0.3.0",
     "@renovatebot/pep440": "^5.0.0",
     "acorn": "^8.15.0",
     "acorn-walk": "^8.3.5",

package/src/_shared/tarball.ts

@@ -35,7 +35,8 @@ const PACKAGE_MANIFEST = 'package.json';
  * Stream a gzipped npm archive into a package directory. Entry names are
  * already canonical and prefix-stripped by streamTarEntries. Hold only the
  * current entry and the manifest; write the manifest last so a failed install
- * is not mistaken for a complete package on retry. Filesystem failures reject.
+ * is not mistaken for a complete package on retry. A second manifest in one
+ * archive is a malformed package, not an overwrite. Filesystem failures reject.
  */
 export async function writeTarballStream(
   body: ReadableStream<Uint8Array>,
@@ -54,6 +55,9 @@ export async function writeTarballStream(
   );
   for await (const entry of entries) {
     if (entry.name === PACKAGE_MANIFEST) {
+      if (manifest !== null) {
+        throw new Error(`tarball for ${targetDir} carried two ${PACKAGE_MANIFEST} entries`);
+      }
       manifest = entry.data;
       continue;
     }

package/src/runtime/comment-strip.ts

@@ -1,92 +1,239 @@
 /**
- * Minimal byte-aligned comment stripper for prefetch's import detection.
+ * One JavaScript source scanner shared by the two comment-stripping
+ * call sites — prefetch's import detection and the esbuild transform
+ * pipeline's classifiers.
  *
- * Scope: strip `//` line comments and `/* … *\/` block comments by
- * replacing each comment with a single space. Newlines INSIDE the
- * comment are preserved so that line numbers stay aligned with the
- * input (matches the strip-and-classify pattern used by
- * `esbuild-service.ts:stripCommentsAndStrings` for the transform
- * pipeline).
+ * `scanJsSource(src, literals)` walks `src` once and returns a
+ * byte-aligned copy in which `//` and `/* … *\/` comments are blanked
+ * (each comment becomes a space; newlines inside a block comment are
+ * preserved so line numbers still match the input). String, template
+ * and regex literals are what `literals` decides:
  *
- * Why a separate, smaller scanner: prefetch's IMPORT_RE / REQUIRE_RE
- * in `require-resolver.ts:41,87` are detection-only — they extract
- * specifier strings, not shapes. The full string-and-template-literal
- * stripper in `esbuild-service.ts` is overkill for that, and crossing
- * the anti-touch boundary on `esbuild-service.ts` to extend a single
- * shared helper isn't worth it right now.
+ *   - `'blank'`: literal content is replaced too — templates keep their
+ *     `${…}` interpolation expression as code so a depth-tracked caller
+ *     sees `await` etc. inside it. This is the transform pipeline's
+ *     classification view: nothing quoted can read as an `import`.
+ *   - `'keep'`: literals are copied verbatim. This is prefetch's
+ *     import-detection view: IMPORT_RE/REQUIRE_RE must see the
+ *     specifier string, and a `//` or `/*` inside a literal must NOT
+ *     open a comment that swallows a following real import.
  *
- * Empirical justification (esbuild-ast-rewrite wave, P2 measurement):
- *   - Per-file AST-based extraction: ~5 ms warm avg
- *   - 100-file session bootstrap with AST: ~553 ms (over the 500 ms gate)
- *   - Regex with this stripper: ~0.1 ms per file
- *   - Correctness gap closed: chalk `import { // eslint-disable\n   a,\n   b\n} from './utilities.js'` now matches
- *
- * String-literal handling is intentionally OUT of scope. A literal
- * `import x from 'y'` inside a JavaScript string would still produce
- * a false-positive prefetch attempt. The resolver no-ops on misses,
- * so it's a minor wasted-work cost — see IMPORT_RE header comment in
- * `require-resolver.ts:84-86`.
- *
- * Memory: the output is assembled from slices of the input — one per
- * comment-free span — and joined once. It used to be built one character
- * at a time with `out += c`, which every JS engine represents as a rope
- * of one node per append: ~30 bytes of heap per character of output, all
- * of it live until the string is first read. The require walk runs this
- * over every file in the closure, and on typescript's 6.15 MB `lib/_tsc.js`
- * that rope measured 174 MB (V8) / 172 MB (JSC) against a 128 MB isolate —
+ * The output is assembled from input slices and joined once. It used to
+ * be built one character at a time (`stripped += c`), which V8 keeps as
+ * a rope of one node per append — ~30 bytes of heap per character, all
+ * live until the string is first read. On typescript's 6.15 MB
+ * `lib/_tsc.js` that rope measured 174 MB against a 128 MB isolate —
  * the session Durable Object was killed inside `tsc`'s spawn before the
- * facet existed. A span-sliced build holds the input, the output and a
- * short array of slices, and nothing else.
+ * facet existed. Spans hold the input, the output and a short array.
  *
- * TODO(CLN-X): when the `src/runtime/esbuild-service.ts` anti-touch
- * window opens, unify with the canonical
- * `stripCommentsAndStrings(src)` helper there. Both implement the
- * same logical pass over comments; only the string/regex-literal
- * handling differs.
+ * Serialized by name: `generateEsbuildTransformRuntimeSource` embeds
+ * this function's `.toString()` in the transform runtime, so every
+ * constant it reads is declared inside the body.
  */
-const SLASH = 0x2f;
-const STAR = 0x2a;
-const NEWLINE = 0x0a;
+export function scanJsSource(src: string, literals: 'keep' | 'blank'): string {
+  const NEWLINE = 0x0a;
+  // Identifier-suffix detection: `/` after one of these is division;
+  // after anything else (operators, punctuators, keywords, start-of-file)
+  // it opens a regex literal. Word chars + `)` + `]` cover `foo()/x` and
+  // `a[i]/y`; the quote characters cover `'…' /re/` and `` `…` /re/ ``.
+  const DIVISION_AFTER = /[A-Za-z0-9_$\)\]'\"`]/;
 
-export function stripCommentsForImports(src: string): string {
-  const N = src.length;
   const parts: string[] = [];
-  // Start of the comment-free span not yet copied to `parts`.
+  // Start of the span not yet copied to `parts`.
   let spanStart = 0;
   let i = 0;
+  const N = src.length;
+  let lastNonWs = '';
+  const record = (ch: string) => {
+    if (ch !== ' ' && ch !== '\t' && ch !== '\n' && ch !== '\r') lastNonWs = ch;
+  };
+  // The division/regex discriminator needs the last non-ws char the loop
+  // has passed — stepped chars record themselves; spans already landed in
+  // `parts` only need their final char re-derived.
+  const step = () => { record(src[i]); i++; };
+  const copy = (end: number) => {
+    if (end > spanStart) parts.push(src.slice(spanStart, end));
+  };
+  const emit = (ch: string) => { parts.push(ch); };
+
+  // A shebang is the file's first line and never a comment or a regex —
+  // `#!/` at offset 0 is copied whole before the loop sees the `/`.
+  if (src.charCodeAt(0) === 0x23 && src.charCodeAt(1) === 0x21) {
+    i = 2;
+    while (i < N && src.charCodeAt(i) !== NEWLINE) i++;
+    record('!');
+  }
+
   while (i < N) {
-    if (src.charCodeAt(i) !== SLASH) { i++; continue; }
-    const next = src.charCodeAt(i + 1);
-    // Line comment: `//` to end-of-line, replaced by one space. The
-    // newline is not part of the comment and stays in the next span.
-    if (next === SLASH) {
-      parts.push(src.slice(spanStart, i), ' ');
-      i += 2;
-      while (i < N && src.charCodeAt(i) !== NEWLINE) i++;
-      spanStart = i;
+    if (src.charCodeAt(i) === 0x2f /* / */) {
+      const next = src.charCodeAt(i + 1);
+      if (next === 0x2f) {
+        // Line comment: to end-of-line, one space. The newline itself is
+        // not part of the comment and stays in the next span.
+        copy(i);
+        i += 2;
+        while (i < N && src.charCodeAt(i) !== NEWLINE) i++;
+        emit(' ');
+        spanStart = i;
+        continue;
+      }
+      if (next === 0x2a) {
+        // Block comment: replaced by its own newlines plus one space; an
+        // unterminated one runs to the end of input and gets no space.
+        copy(i);
+        i += 2;
+        let newlines = 0;
+        let closed = false;
+        while (i < N) {
+          const bc = src.charCodeAt(i);
+          if (bc === NEWLINE) newlines++;
+          else if (bc === 0x2a && src.charCodeAt(i + 1) === 0x2f) { i += 2; closed = true; break; }
+          i++;
+        }
+        if (newlines > 0) parts.push('\n'.repeat(newlines));
+        if (closed) emit(' ');
+        spanStart = i;
+        continue;
+      }
+      // Regex literal when the previous non-ws char can't end a value.
+      if (!DIVISION_AFTER.test(lastNonWs)) {
+        // A regex needs its closing `/` on the same line; without one the
+        // slash is division (or a lone `/`), and treating the rest of the
+        // line as a literal would drop real code — imports included.
+        let j = i + 1;
+        let closes = false;
+        while (j < N) {
+          const rc = src.charCodeAt(j);
+          if (rc === 0x5c) { j += 2; continue; }
+          if (rc === 0x5b) {
+            j++;
+            while (j < N && src.charCodeAt(j) !== 0x5d) {
+              if (src.charCodeAt(j) === 0x5c) { j += 2; continue; }
+              j++;
+            }
+            if (j < N) j++;
+            continue;
+          }
+          if (rc === 0x2f) { closes = true; break; }
+          if (rc === NEWLINE) break;
+          j++;
+        }
+        if (!closes) { step(); continue; }
+        copy(i);
+        emit(' ');
+        i++;
+        while (i < N) {
+          const rc = src.charCodeAt(i);
+          if (rc === 0x5c) { i += 2; continue; }
+          if (rc === 0x5b) {
+            // Character class: `/` inside it is content.
+            i++;
+            while (i < N && src.charCodeAt(i) !== 0x5d) {
+              if (src.charCodeAt(i) === 0x5c) { i += 2; continue; }
+              i++;
+            }
+            if (i < N) i++;
+            continue;
+          }
+          if (rc === 0x2f) { i++; break; }
+          i++;
+        }
+        // Flags: g, i, m, s, u, y, d.
+        while (i < N && /[gimsuyd]/.test(src[i])) i++;
+        record('/');
+        spanStart = i;
+        continue;
+      }
+      // Division or a lone slash — plain source.
+      step();
       continue;
     }
-    // Block comment: `/*` to `*/`, replaced by its own newlines (so line
-    // numbers stay aligned) and one space. An unterminated one runs to
-    // the end of input and gets no closing space.
-    if (next === STAR) {
-      parts.push(src.slice(spanStart, i));
-      i += 2;
-      let newlines = 0;
-      let closed = false;
+
+    const ch = src[i];
+    if (ch === '"' || ch === "'" || ch === '`') {
+      if (literals === 'keep') {
+        i++;
+        while (i < N) {
+          const cc = src[i];
+          if (cc === '\\') { i += 2; continue; }
+          if (cc === ch) { i++; break; }
+          i++;
+        }
+        // The literal ends a value: a following `/` is division.
+        record(ch);
+        continue;
+      }
+      // blank: the delimiters and content become one space; a template's
+      // `${…}` interpolation keeps its expression as code.
+      copy(i);
+      emit(' ');
+      i++;
       while (i < N) {
-        const c = src.charCodeAt(i);
-        if (c === NEWLINE) newlines++;
-        else if (c === STAR && src.charCodeAt(i + 1) === SLASH) { i += 2; closed = true; break; }
+        const cc = src[i];
+        if (cc === '\\') { i += 2; continue; }
+        if (cc === ch) { i++; break; }
+        if (ch === '`' && cc === '$' && src[i + 1] === '{') {
+          emit('${');
+          i += 2;
+          let depth = 1;
+          while (i < N && depth > 0) {
+            const ic = src[i];
+            // Nested string inside the interpolation: blank its content
+            // so a `}` inside it doesn't drop the depth early.
+            if (ic === '"' || ic === "'" || ic === '`') {
+              const iq = ic;
+              emit(' ');
+              i++;
+              while (i < N) {
+                const icc = src[i];
+                if (icc === '\\') { i += 2; continue; }
+                if (icc === iq) { i++; break; }
+                // A nested template's own ${…} recurses once more —
+                // deeper nesting falls back to brace counting.
+                if (iq === '`' && icc === '$' && src[i + 1] === '{') {
+                  emit('${');
+                  i += 2;
+                  let d2 = 1;
+                  while (i < N && d2 > 0) {
+                    const i2 = src[i];
+                    if (i2 === '{') d2++;
+                    else if (i2 === '}') d2--;
+                    if (d2 > 0) emit(i2);
+                    i++;
+                  }
+                  emit('}');
+                  continue;
+                }
+                if (icc === '\n') emit('\n');
+                i++;
+              }
+              continue;
+            }
+            if (ic === '{') depth++;
+            else if (ic === '}') depth--;
+            if (depth > 0) emit(ic);
+            i++;
+          }
+          emit('}');
+          continue;
+        }
+        if (cc === '\n') emit('\n');
         i++;
       }
-      if (newlines > 0) parts.push('\n'.repeat(newlines));
-      if (closed) parts.push(' ');
       spanStart = i;
       continue;
     }
-    i++;
+    step();
   }
-  parts.push(src.slice(spanStart));
+  copy(N);
   return parts.join('');
 }
+
+/**
+ * Strip comments for import/require detection. Literals are kept: the
+ * specifier the regexes extract lives inside a string, and a comment
+ * marker inside a string must not swallow the code that follows it.
+ */
+export function stripCommentsForImports(src: string): string {
+  return scanJsSource(src, 'keep');
+}

package/src/runtime/cpython-runner.ts

@@ -230,6 +230,7 @@ async function cpythonRunFacetFn(
  * that has none does not get a degraded version — it gets none, and says so.
  */
 export type CPythonResidentStart = (spawn: {
+  argv: string[];
   /** VFS path of the interpreter. By path, not by value: it is 10.6 MiB. */
   wasmVfsPath: string;
   startArgs: Record<string, unknown>;
@@ -474,7 +475,7 @@ export function makeCPythonRunnerFactory(deps: {
         const command = [binName, ...argv].map((part) =>
           (/^[A-Za-z0-9_./:=@+-]+$/.test(part) ? part : JSON.stringify(part))).join(' ');
         const spawnResult = await deps.startResident(
-          { wasmVfsPath: wasmVfs, startArgs: facetArgs, cwd, command });
+          { wasmVfsPath: wasmVfs, startArgs: facetArgs, cwd, command, argv: [binName, ...argv] });
         if (spawnResult.stdout) ctx.stdout.write(spawnResult.stdout);
         if (spawnResult.stderr) ctx.stderr.write(spawnResult.stderr);
         return spawnResult.exitCode;

package/src/runtime/esbuild-service.ts

@@ -29,6 +29,7 @@ import {
   nodeProp,
   parseJavaScriptModule,
 } from './javascript-ast.js';
+import { scanJsSource } from './comment-strip.js';
 
 /**
  * Bundler version tag. BUMP THIS whenever bundling semantics change —
@@ -203,167 +204,14 @@ function hasEsmExports(src: string): boolean {
 }
 
 /**
- * Strip `//` and `/* * /` comments and string / template literals from
- * source, replacing each with a single space. The result is byte-aligned
- * with the input on a per-line basis (newlines are preserved), so error
- * line numbers from downstream parsers still align with the original.
- * Shared by the import/export classifiers. Pure function — no caching needed
- * for the small entry points that reach the true-TLA fallback.
+ * Strip `//` and `/* *\/` comments and string / template literals from
+ * source for the import/export classifiers — one scanner shared with
+ * prefetch's import detection in `comment-strip.ts`. The result is
+ * byte-aligned with the input per line (comment and literal newlines are
+ * preserved), so error line numbers still match the original.
  */
 function stripCommentsAndStrings(src: string): string {
-  let stripped = '';
-  let i = 0;
-  const N = src.length;
-  // Track the last non-whitespace non-comment output character so we
-  // can disambiguate `/` as division (after identifier/literal/`)`/`]`)
-  // vs regex-literal opener (after operator / punctuator / keyword /
-  // start-of-file). Pre-fix the stripper had no regex awareness, so
-  // patterns like `var X = /^(?:'…)/` contained an unmatched `'` that
-  // bit it as a string opener that didn't close until many lines
-  // later — corrupting the import/export classifiers. Real-world bite:
-  // sv-utils@0.0.3 index.mjs has dozens of these regex literals.
-  let lastNonWsChar = '';
-  const recordOut = (ch: string) => {
-    if (ch !== ' ' && ch !== '\t' && ch !== '\n' && ch !== '\r') {
-      lastNonWsChar = ch;
-    }
-  };
-  // Identifier-suffix detection on lastNonWsChar: any of these means
-  // `/` is division. Anything else means `/` opens a regex.
-  // Includes ascii word chars + `)` `]` to cover `foo()/x` `a[i]/y`.
-  const DIVISION_AFTER = /[A-Za-z0-9_$\)\]]/;
-  while (i < N) {
-    const c = src[i];
-    if (c === '/' && src[i + 1] === '/') {
-      while (i < N && src[i] !== '\n') i++;
-      stripped += ' ';
-      continue;
-    }
-    if (c === '/' && src[i + 1] === '*') {
-      i += 2;
-      while (i < N && !(src[i] === '*' && src[i + 1] === '/')) {
-        // Preserve newlines so line numbers stay aligned.
-        if (src[i] === '\n') stripped += '\n';
-        i++;
-      }
-      i += 2;
-      stripped += ' ';
-      continue;
-    }
-    // Regex literal: `/` not followed by `/` or `*` (already handled
-    // above), AND preceded by something that makes regex valid here.
-    // The classifier looks at lastNonWsChar — for `(`, `,`, `=`, `;`,
-    // `{`, `[`, `:`, `!`, `&`, `|`, `?`, operators, or start-of-file,
-    // a slash is a regex opener.
-    if (c === '/' && !DIVISION_AFTER.test(lastNonWsChar)) {
-      stripped += ' ';
-      i++;
-      while (i < N) {
-        const rc = src[i];
-        if (rc === '\\') { i += 2; continue; }
-        // Regex character class [...]: `/` inside it is content.
-        if (rc === '[') {
-          i++;
-          while (i < N && src[i] !== ']') {
-            if (src[i] === '\\') { i += 2; continue; }
-            if (src[i] === '\n') { stripped += '\n'; }
-            i++;
-          }
-          if (i < N) i++; // consume ']'
-          continue;
-        }
-        if (rc === '/') { i++; break; }
-        if (rc === '\n') {
-          // Regex literals can't span newlines. If we hit one without
-          // finding the closing `/`, this was probably NOT a regex —
-          // bail out gracefully (rare in practice; better than getting
-          // stuck in a wrong state).
-          break;
-        }
-        i++;
-      }
-      // Skip regex flags (g, i, m, s, u, y, d).
-      while (i < N && /[gimsuyd]/.test(src[i])) i++;
-      recordOut('/');
-      continue;
-    }
-    if (c === '"' || c === "'" || c === '`') {
-      const q = c;
-      stripped += ' ';
-      i++;
-      while (i < N) {
-        const cc = src[i];
-        if (cc === '\\') { i += 2; continue; }
-        if (cc === q) { i++; break; }
-        // Template interpolation: ${...} — preserve the inner
-        // expression as raw code so the caller's depth-tracker can
-        // see `await` etc. inside it. Strip the wrapping `${`/`}`
-        // (those don't affect brace-depth from the caller's POV).
-        //
-        // CRITICAL: inside the interpolation expression, we must
-        // recognise NESTED strings (`'}'`, `"}"`, `` `${...}` ``) so
-        // their internal `}` characters don't decrement the depth
-        // counter — otherwise we exit the interpolation early and
-        // start consuming code as string content, eventually parsing
-        // the rest of the file as one massive unclosed string. This
-        // bit sv-utils/dist/index.mjs: multi-line backticks with
-        // `${url.replace('}', '_')}`-style interpolations corrupted
-        // line classification downstream. Recursive-by-loop here.
-        if (q === '`' && cc === '$' && src[i + 1] === '{') {
-          stripped += '${';
-          i += 2;
-          let depth = 1;
-          while (i < N && depth > 0) {
-            const ic = src[i];
-            // Nested string inside interpolation: skip its content.
-            if (ic === '"' || ic === "'" || ic === '`') {
-              const iq = ic;
-              stripped += ' ';
-              i++;
-              while (i < N) {
-                const icc = src[i];
-                if (icc === '\\') { i += 2; continue; }
-                if (icc === iq) { i++; break; }
-                // Nested template inside interpolation can also have its
-                // own ${...} — recurse once more (the practical depth
-                // observed in real code never exceeds 2; deeper nesting
-                // falls back to brace counting which is a best-effort).
-                if (iq === '`' && icc === '$' && src[i + 1] === '{') {
-                  stripped += '${'; i += 2;
-                  let d2 = 1;
-                  while (i < N && d2 > 0) {
-                    const i2 = src[i];
-                    if (i2 === '{') d2++;
-                    else if (i2 === '}') d2--;
-                    if (d2 > 0) stripped += i2;
-                    i++;
-                  }
-                  stripped += '}';
-                  continue;
-                }
-                if (icc === '\n') stripped += '\n';
-                i++;
-              }
-              continue;
-            }
-            if (ic === '{') depth++;
-            else if (ic === '}') depth--;
-            if (depth > 0) stripped += ic;
-            i++;
-          }
-          stripped += '}';
-          continue;
-        }
-        if (cc === '\n') stripped += '\n';
-        i++;
-      }
-      continue;
-    }
-    stripped += c;
-    recordOut(c);
-    i++;
-  }
-  return stripped;
+  return scanJsSource(src, 'blank');
 }
 
 /**
@@ -1245,6 +1093,9 @@ async function transformWithEsbuild(
 /** Source needed by the slim Worker Loader transform isolate. */
 export function generateEsbuildTransformRuntimeSource(): string {
   return [
+    // scanJsSource is self-contained — its constants live in the body —
+    // so this serialized copy carries the whole scanner.
+    scanJsSource.toString(),
     stripCommentsAndStrings.toString(),
     hasEsmImports.toString(),
     hasEsmExports.toString(),

package/src/runtime/ruby-runner.ts

@@ -260,6 +260,7 @@ export function makeRubyRunnerFactory(deps: {
           startArgs: toRubyCallArgs(facetArgs),
           cwd,
           command: formatRubyCommand(binName, argv),
+          argv: [binName, ...argv],
         });
       } else {
         result = await dispatchRubyFacet(deps.facets, vfs, facetArgs, ctx.pid);
@@ -619,6 +620,7 @@ export interface RubyFacetResult {
  * no degraded version — it gets none, and says so.
  */
 export type RubyResidentStart = (spawn: {
+  argv: string[];
   /** VFS path of the interpreter. By path, not by value: it is 34.3 MiB. */
   wasmVfsPath: string;
   startArgs: RubyFacetCallArgs;

package/src/substrate/lifo/commands/system/npm.ts

@@ -289,12 +289,9 @@ async function installSinglePackage(
 
 	const info = await fetchPackageInfo(npmRegistry, name, version, signal);
 
-	const written = await fetchAndStreamPackage(info.dist.tarball, targetDir, vfs, signal);
-	if (written.files === 0 || !vfs.exists(join(targetDir, 'package.json'))) {
-		throw new Error(
-			`${name}: extraction wrote ${written.files} files and left no package.json in ${targetDir}`,
-		);
-	}
+	// writeTarballStream throws when the archive carried no manifest and writes
+	// package.json last, so a return here is a complete package on disk.
+	await fetchAndStreamPackage(info.dist.tarball, targetDir, vfs, signal);
 
 	let installed = 1;
 

package/src/workspace/nimbus-workspace.ts

@@ -60,8 +60,12 @@ export interface NimbusWorkspaceOptions {
    * Every atomic write in the filesystem rests on this being a real
    * transaction. An implementation that merely calls the callback converts
    * each one into a torn write that reports success.
+   *
+   * `NimbusWorkspace.create` is a first-write-wins composition root beside
+   * `worker/index.ts` and `loom/actor.ts`: when `ctxExports` is absent the
+   * host's ctx `exports` bag is adopted as the isolate's.
    */
-  readonly transactions?: TransactionHost;
+  readonly transactions?: TransactionHost & { readonly exports?: CtxExports };
   /**
    * The filesystem already open over `sql`, for a host that has one.
    *
@@ -195,8 +199,7 @@ export class NimbusWorkspace {
 
   static async create(options: NimbusWorkspaceOptions): Promise<NimbusWorkspace> {
     if (options.fabric) composeFabric(options.fabric);
-    const exports = options.ctxExports
-      ?? (options.transactions as (TransactionHost & { exports?: CtxExports }) | undefined)?.exports;
+    const exports = options.ctxExports ?? options.transactions?.exports;
     if (exports) adoptCtxExports(exports);
     const vfs = options.vfs ?? openFilesystem(options);
     const mounts = options.mounts ?? DEFAULT_MOUNT_POINTS;