bare-stow 0.1.5 → 0.1.7

package/README.md

@@ -66,6 +66,8 @@ ipc.on('exit', (code) => {
 ipc.destroy()
 ```
 
+For the `bare-sidecar` target, `start()` accepts the options of `bare-sidecar`. The sidecar inherits the standard streams of the host unless `stdio` says otherwise.
+
 ## Protocol
 
 The harness multiplexes a control channel and a user data channel over the underlying binary duplex stream. The `ipc` returned from `start()` is itself a duplex stream carrying the user data; control frames ride alongside it on the same handle. RPC libraries (such as `bare-rpc`) bind to `ipc` just like a raw stream.
@@ -137,7 +139,7 @@ opts = {
 
 - `client`: The RPC library to wire into the harness as a client, given either as a built-in name (`'bare-rpc'`) or as an [RPC provider](#targets-and-rpc-providers) object.
 - `server`: The RPC library to wire into the bundle entry shim as a server, given either as a built-in name (`'bare-rpc'`) or as an [RPC provider](#targets-and-rpc-providers) object.
-- `base`: The base `URL` of the module graph. Defaults to the directory containing `entry`.
+- `base`: The base `URL` of the module graph, which must contain every module in the bundle. Defaults to the closest directory that does.
 - `hosts`: An array of host triples to build for. Must be a subset of the host triples supported by the target; passing a host the target does not support throws. Defaults to all host triples supported by the target.
 - `resolveTarget`: A function mapping a target name to a [target provider](#targets-and-rpc-providers) object, called when `target` is a name not in the built-in registry (which knows `'bare-sidecar'` and `'bare-worker'`).
 - `resolveRPC`: A function mapping an RPC library name to an [RPC provider](#targets-and-rpc-providers) object, called when `client` or `server` is a name not in the built-in registry (which only knows `'bare-rpc'`).

package/bin.js

@@ -22,7 +22,10 @@ const cmd = command(
     '--server <name>',
     'The RPC server to include (bare-rpc, or a bare-stow-rpc-<name> package)'
   ),
-  flag('--base <path>', 'The base path of the bundle'),
+  flag(
+    '--base <path>',
+    'The base path of the bundle (defaults to the closest directory containing every bundled module)'
+  ),
   flag('--out|-o <path>', 'The output path of the harness'),
   flag('--builtins <path>', 'A list of builtin modules'),
   flag('--imports <path>', 'A map of global import overrides'),
@@ -35,7 +38,7 @@ const cmd = command(
       target,
       client,
       server,
-      base = '.',
+      base,
       out,
       builtins,
       imports,
@@ -60,9 +63,7 @@ const cmd = command(
       if ('default' in imports) imports = imports.default
     }
 
-    base = pathToFileURL(base)
-
-    if (!base.pathname.endsWith('/')) base.pathname += '/'
+    if (base) base = pathToFileURL(path.resolve(base) + '/')
 
     for await (const _ of stow(pathToFileURL(entry), target, pathToFileURL(out), {
       client,

package/index.js

@@ -21,7 +21,6 @@ module.exports = async function* stow(entry, target, out, opts = {}) {
 
   entry = new URL(entry)
   out = new URL(out)
-  base = base ? new URL(base) : new URL('./', entry)
 
   // The target may pin a module system; otherwise it follows the output path.
   const module = t.module || (await resolveModule(out))
@@ -36,7 +35,7 @@ module.exports = async function* stow(entry, target, out, opts = {}) {
     hosts = t.hosts
   }
 
-  const shimURL = shim.url(base)
+  const shimURL = shim.url(new URL('./', entry))
 
   // The server only contributes runtime wiring to the shim; the shim is not a
   // typed, host-facing module so it has no declaration artifact.
@@ -63,9 +62,11 @@ module.exports = async function* stow(entry, target, out, opts = {}) {
 
   let writeFile
 
-  if (isOffloadEnabled(t.offload)) writeFile = collectOffloaded(base, out, offloaded)
+  if (isOffloadEnabled(t.offload)) writeFile = collectOffloaded(offloaded)
 
-  const bundle = await pack(
+  // The base of the bundle depends on where its modules live, so the graph is
+  // packed unbased and unmounted once that is known.
+  let bundle = await pack(
     shimURL,
     {
       ...packOpts,
@@ -75,7 +76,6 @@ module.exports = async function* stow(entry, target, out, opts = {}) {
         '.mts': '.mjs',
         '.cts': '.cjs'
       },
-      base,
       hosts,
       linked: t.linked,
       offload: t.offload
@@ -85,6 +85,10 @@ module.exports = async function* stow(entry, target, out, opts = {}) {
     writeFile
   )
 
+  base = resolveBase(base, bundle)
+
+  bundle = rerootOffloaded(bundle.unmount(base), base, out, offloaded)
+
   bundle.id = id(bundle).toString('hex')
 
   // The client contributes both runtime wiring (spliced into the harness) and a
@@ -132,6 +136,44 @@ module.exports = async function* stow(entry, target, out, opts = {}) {
   }
 }
 
+function resolveBase(base, graph) {
+  const modules = [...graph.keys()].map((href) => new URL(href))
+
+  if (base) {
+    base = new URL(base)
+
+    if (!base.pathname.endsWith('/')) base.pathname += '/'
+
+    for (const url of modules) {
+      if (url.protocol === base.protocol && !url.href.startsWith(base.href)) {
+        throw new Error(`Module '${url.href}' is outside base '${base.href}'`)
+      }
+    }
+
+    return base
+  }
+
+  let common = null
+
+  for (const url of modules) {
+    if (url.protocol !== 'file:') continue
+
+    const dir = new URL('./', url)
+
+    if (common === null) common = dir
+
+    while (!dir.href.startsWith(common.href)) {
+      const parent = new URL('../', common)
+
+      if (parent.href === common.href) throw new Error('Modules share no common base')
+
+      common = parent
+    }
+  }
+
+  return common
+}
+
 function isOffloadEnabled(offload) {
   if (offload === true) return true
   if (offload && (offload.addons || offload.assets)) return true
@@ -153,26 +195,83 @@ function wrapReadModule(readModule, shimURL, shimSource) {
   }
 }
 
-function collectOffloaded(base, out, sink) {
+function collectOffloaded(sink) {
+  return function writeFile(url, source) {
+    sink.push({ url, source })
+
+    return null
+  }
+}
+
+// Offloaded files are written next to the harness, so their resolutions are
+// rewritten to point beside the bundle, along with the directories that hold
+// them, as `bare-pack` does for a bundle packed with a base.
+function rerootOffloaded(bundle, base, out, offloaded) {
+  if (offloaded.length === 0) return bundle
+
   const dir = new URL('./', out)
+  const rewrites = new Map()
 
-  return function writeFile(url, source) {
-    let relative
+  for (const file of offloaded) {
+    const relative = offloadedPath(file.url, base)
+
+    let key = '/' + path.posix.relative(base.pathname, file.url.pathname)
+    let value = '/../' + relative
+
+    rewrites.set(key, value)
+
+    for (;;) {
+      key = key.substring(0, key.lastIndexOf('/'))
+
+      if (isTerminator(key)) break
+
+      value = value.substring(0, value.lastIndexOf('/'))
 
-    const nm = url.pathname.indexOf('/node_modules/')
+      if (isTerminator(value)) break
 
-    if (nm >= 0) {
-      relative = url.pathname.slice(nm + 1)
-    } else if (url.pathname.startsWith(base.pathname)) {
-      relative = url.pathname.slice(base.pathname.length)
-    } else {
-      relative = url.pathname.replace(/^\//, '')
+      rewrites.set(key, value)
     }
 
-    sink.push({ url: new URL(relative, dir), source })
+    file.url = new URL(relative, dir)
+  }
 
-    return null
+  const resolutions = {}
+
+  for (const [href, imports] of Object.entries(bundle.resolutions)) {
+    resolutions[href] = rewriteImports(imports, rewrites)
+  }
+
+  bundle.resolutions = resolutions
+
+  return bundle
+}
+
+function offloadedPath(url, base) {
+  const nm = url.pathname.indexOf('/node_modules/')
+
+  if (nm >= 0) return url.pathname.slice(nm + 1)
+
+  if (url.pathname.startsWith(base.pathname)) return url.pathname.slice(base.pathname.length)
+
+  return url.pathname.replace(/^\//, '')
+}
+
+function rewriteImports(imports, rewrites) {
+  if (typeof imports === 'string') return rewrites.get(imports) || imports
+
+  if (typeof imports !== 'object' || imports === null) return imports
+
+  const rewritten = {}
+
+  for (const [condition, value] of Object.entries(imports)) {
+    rewritten[condition] = rewriteImports(value, rewrites)
   }
+
+  return rewritten
+}
+
+function isTerminator(input) {
+  return input === '' || input.endsWith('/') || input.endsWith(':')
 }
 
 async function resolveModule(out) {

package/lib/host.js

@@ -5,17 +5,29 @@ class IPC extends Protocol {
     super(stream)
 
     this._ready = new Promise((resolve, reject) => {
+      const cleanup = () => {
+        this.off('ready', onready).off('error', onerror).off('exit', onexit).off('close', onclose)
+      }
+
       const onready = () => {
-        this.off('ready', onready).off('error', onerror)
+        cleanup()
         resolve()
       }
 
       const onerror = (err) => {
-        this.off('ready', onready).off('error', onerror)
+        cleanup()
         reject(err)
       }
 
-      this.on('ready', onready).on('error', onerror)
+      const onexit = (code) => {
+        // An error frame precedes the exit frame and is emitted on destroy
+        if (this.destroying) return
+        onerror(new Error(`Worker exited with code ${code} before ready`))
+      }
+
+      const onclose = () => onerror(new Error('Worker closed before ready'))
+
+      this.on('ready', onready).on('error', onerror).on('exit', onexit).on('close', onclose)
     })
 
     this._ready.catch(() => {})

package/lib/target/bare-sidecar.js

@@ -33,7 +33,7 @@ import { fileURLToPath } from 'url'
 const bundle = fileURLToPath(new URL(${JSON.stringify(bundleSpecifier)}, import.meta.url))
 
 export async function start(opts = {}) {
-  const sidecar = new Sidecar(bundle, opts)
+  const sidecar = new Sidecar(bundle, { stdio: 'inherit', ...opts })
 
   const ${ipc} = stow.wrap(sidecar)
 ${client ? '\n' + indent(client.source, 2) : ''}
@@ -51,7 +51,7 @@ const bundle = path.join(__dirname, ${JSON.stringify(bundleSpecifier)})
 
 module.exports = {
   async start(opts = {}) {
-    const sidecar = new Sidecar(bundle, opts)
+    const sidecar = new Sidecar(bundle, { stdio: 'inherit', ...opts })
 
     const ${ipc} = stow.wrap(sidecar)
 ${client ? '\n' + indent(client.source, 4) : ''}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-stow",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Module bundling and harness generation for Bare",
   "exports": {
     "./package": "./package.json",
@@ -76,7 +76,7 @@
   },
   "devDependencies": {
     "bare-rpc": "^1.3.2",
-    "bare-sidecar": "^0.5.0",
+    "bare-sidecar": "^0.5.8",
     "bare-worker": "^4.3.0",
     "brittle": "^4.0.2",
     "lunte": "^1.7.0",