bare-stow 0.2.0 → 0.3.1

package/README.md

@@ -69,11 +69,29 @@ The bundle imports `bare-stow-runtime`, and the RPC library if a `server` is req
 
 `start()` accepts `timeout`, how long to wait in milliseconds for the bundle to signal ready, and `grace`, how long a terminating bundle gets to run `stop()` and exit before it's killed. `timeout` defaults to waiting indefinitely and `grace` to 5 seconds. On Windows, a sidecar is killed along with its host, so `stop()` only runs when the host terminates it.
 
+For `bare-sidecar` and `bare-worker`, the harness also exports `connect()`, which takes a sidecar or worker that the host started itself, such as one running a development entry with arguments, and resolves like `start()`. It accepts the same options, except those of the sidecar or worker. As the entry doesn't go through `stow()`, it attaches to the IPC itself, as described in <https://github.com/holepunchto/bare-stow-runtime>:
+
+```js
+import runtime from 'bare-stow-runtime/process'
+
+const ipc = runtime.attach(Bare.IPC)
+
+ipc.run(() => import('./core.js'), ipc)
+```
+
+```js
+const sidecar = new Sidecar('./dev.js', ['--verbose'], { stdio: 'inherit' })
+
+const { ipc } = await harness.connect(sidecar)
+```
+
+`stow()` and `link()` read the module graph from disk by default. To read it from elsewhere, such as modules that aren't written to disk, pass `readModule`, `listPrefix`, and `resolveModule`. Generated files are still written to disk. A `readModule` that changes the type of a module also passes `aliases`, as for <https://github.com/holepunchto/bare-pack>, such as `{ '.mjs': '.js' }` to have ES modules converted to CommonJS loaded as such. They're merged over the aliases that `bare-stow` uses for TypeScript.
+
 ## Targets
 
 - `bare-sidecar` runs the bundle in a separate process using <https://github.com/holepunchto/bare-sidecar>, with the `javascript`, `python`, and `swift` languages on desktop. In JavaScript and Python, `start()` also accepts the options of `bare-sidecar`.
 - `bare-worker` runs the bundle in a thread of a Bare host using <https://github.com/holepunchto/bare-worker>, with the `javascript` language.
-- `bare-kit` runs the bundle in a worklet using <https://github.com/holepunchto/bare-kit>, with the `swift` language on macOS and iOS and the `kotlin` language on Android. `start()` also accepts the options of the worklet and returns it alongside `ipc`, and in Kotlin takes the Android `Context` first. Native addons are linked with <https://github.com/holepunchto/bare-link> and declared in the manifest, and assets are written next to the bundle. With the target option `linking` set to `'app'`, both are left to `link()` instead.
+- `bare-kit` runs the bundle in a worklet using <https://github.com/holepunchto/bare-kit>, with the `swift` language on macOS and iOS and the `kotlin` language on Android and the JVM. `start()` also accepts the options of the worklet and returns it alongside `ipc`, and on Android takes the `Context` first. In Kotlin, the worklet is closed once it exits, so it needs no closing of its own, and in Swift it's released with its last reference. Native addons are linked with <https://github.com/holepunchto/bare-link> and declared in the manifest, and assets are written next to the bundle. With the target option `linking` set to `'app'`, both are left to `link()` instead. On the JVM, addons and assets are written next to the bundle as files, which `start()` extracts along with the bundle to a temporary directory, so `linking` must be `'package'`.
 
 ## Linking
 
@@ -101,7 +119,7 @@ The language lays out the package and the target adds what loads the addons. For
 The harness is generated in one of these languages, selected with `language` and configured with `languageOptions`:
 
 - `javascript` writes an npm package. The `module` option is either `'esm'`, the default, or `'cjs'`.
-- `kotlin` writes an Android library module. The `package` option names the package of the generated code and is required. The dependencies are published to JitPack (<https://jitpack.io>), so add it to the repositories of the application.
+- `kotlin` writes a Gradle module. The `package` option names the package of the generated code and is required. The `platform` option is either `'android'`, the default, for an Android library module, or `'jvm'` for a Kotlin/JVM library module on Linux, macOS, and Windows. The dependencies are published to JitPack (<https://jitpack.io>), so add it to the repositories of the application.
 - `python` writes a Python package.
 - `swift` writes a Swift package.
 

package/index.d.ts

@@ -31,6 +31,11 @@ interface Layout {
   addons?: URL
   /** The directory the assets of linked bundles are linked into, or unset if unsupported. */
   resources?: URL
+  /**
+   * Whether the files written next to the bundle are listed in `<bundle>.files`, one `/<path>` per
+   * line, for a harness that extracts them along with the bundle.
+   */
+  listing?: boolean
 }
 
 /** The context passed to a language's `manifest()`. */
@@ -68,6 +73,8 @@ interface JavaScriptOptions {
 interface KotlinOptions {
   /** The package of the generated code, such as `'com.example.core'`, which is also its namespace. */
   package: string
+  /** The platform of the module, either `'android'`, the default, or `'jvm'`. */
+  platform: 'android' | 'jvm'
 }
 
 type LanguageName = 'javascript' | 'kotlin' | 'python' | 'swift'
@@ -269,7 +276,7 @@ interface RPC {
 }
 
 /** Options for `stow()`. */
-interface StowOptions extends Omit<PackOptions, 'offload' | 'linked' | 'resolve' | 'aliases'> {
+interface StowOptions extends Omit<PackOptions, 'offload' | 'linked' | 'resolve'> {
   /** The language of the harness (or its name). Defaults to `javascript`. */
   language?: Language | LanguageName
   /** The options given to the language, such as `{ module: 'cjs' }` for `javascript`. */
@@ -295,6 +302,15 @@ interface StowOptions extends Omit<PackOptions, 'offload' | 'linked' | 'resolve'
    * @param name - The language name to resolve to a `Language`.
    */
   resolveLanguage?(name: string): Language
+  /**
+   * Read the source of the module at `url`, or `null` if there is none, such as to stow modules
+   * that aren't written to disk. Defaults to reading the file.
+   */
+  readModule?: (url: URL) => Promise<Uint8Array | string | null>
+  /** List the files under the prefix `url`. Defaults to listing the directory. */
+  listPrefix?: (url: URL) => AsyncIterable<URL>
+  /** Resolve the module at `url`. Defaults to its real path, following symbolic links. */
+  resolveModule?: (url: URL) => Promise<URL>
 }
 
 /** Options for `stow.link()`, which shape the graphs as for `stow()`. */
@@ -325,7 +341,7 @@ interface StowArtifact {
  * @returns An async generator that yields each written artifact's `url` as it is produced: any
  * addons linked into the package, the harness and its type declaration, the RPC client and its type
  * declaration, the package manifest, the bundle along with its `base`, and then any assets of a
- * linked bundle and any offloaded addon or asset files.
+ * linked bundle, any offloaded addon or asset files, and the listing of those files.
  * @throws The `target` argument is missing.
  * @throws The `out` argument is missing.
  * @throws A language option is unknown or invalid, or `out` is not valid as a package.

package/index.js

@@ -23,10 +23,13 @@ module.exports = exports = async function* stow(entry, target, out, opts = {}) {
     resolveTarget,
     resolveRPC,
     resolveLanguage,
+    readModule = fs.readModule,
+    listPrefix = fs.listPrefix,
+    resolveModule = fs.resolveModule,
     ...packOpts
   } = opts
 
-  entry = await fs.resolveModule(new URL(entry))
+  entry = await resolveModule(new URL(entry))
   out = new URL(out)
 
   if (!out.pathname.endsWith('/')) out.pathname += '/'
@@ -81,7 +84,11 @@ module.exports = exports = async function* stow(entry, target, out, opts = {}) {
 
   const main = shim(entry, target.isolation, server)
 
-  const readModule = graph.readModule(main.modules)
+  const hooks = {
+    readModule: graph.readModule(main.modules, readModule),
+    listPrefix,
+    resolveModule
+  }
 
   const offloaded = []
 
@@ -96,9 +103,9 @@ module.exports = exports = async function* stow(entry, target, out, opts = {}) {
   let bundle = await pack(
     main.url,
     { ...traversal, linked: target.linked, offload: target.offload },
-    readModule,
-    fs.listPrefix,
-    fs.resolveModule,
+    hooks.readModule,
+    hooks.listPrefix,
+    hooks.resolveModule,
     writeFile
   )
 
@@ -109,7 +116,7 @@ module.exports = exports = async function* stow(entry, target, out, opts = {}) {
   let unpacked = []
 
   if (target.linked) {
-    const result = await assets.unpack(bundle, base, name)
+    const result = await assets.unpack(bundle, base, name, hooks.readModule)
 
     bundle = result.bundle
 
@@ -126,6 +133,8 @@ module.exports = exports = async function* stow(entry, target, out, opts = {}) {
     artifacts.push(new URL(name + '/', bundleURL), new URL(name + '.assets', bundleURL))
   }
 
+  if (layout.listing) artifacts.push(listingURL(bundleURL))
+
   const addons = []
 
   // Targets that leave linking to the application use `link()` instead.
@@ -134,7 +143,7 @@ module.exports = exports = async function* stow(entry, target, out, opts = {}) {
       throw new Error(`Language '${language.name}' does not support linked addons`)
     }
 
-    for await (const url of graph.link([main.url], layout.addons, traversal, readModule)) {
+    for await (const url of graph.link([main.url], layout.addons, traversal, hooks)) {
       addons.push(url)
       yield { url }
     }
@@ -179,6 +188,25 @@ module.exports = exports = async function* stow(entry, target, out, opts = {}) {
     await fs.writeFile(artifact.url, artifact.source)
     yield { url: artifact.url }
   }
+
+  if (layout.listing) {
+    const url = listingURL(bundleURL)
+    const dir = path.posix.dirname(bundleURL.pathname)
+
+    const listing = offloaded.map(
+      (artifact) => '/' + decodeURIComponent(path.posix.relative(dir, artifact.url.pathname)) + '\n'
+    )
+
+    await fs.writeFile(url, listing.join(''))
+    yield { url }
+  }
+}
+
+// Languages that package the bundle where the runtime can't read it, such as
+// in a jar, list the files beside it, one `/<path>` per line, for the harness to
+// extract along with the bundle.
+function listingURL(bundleURL) {
+  return new URL(path.basename(bundleURL.pathname) + '.files', bundleURL)
 }
 
 function resolveBase(base, bundle) {

package/lib/assets.js

@@ -7,11 +7,11 @@ exports.app = 'bare-stow'
 
 // Assets are laid out the way Bare Kit expects: the assets of `<name>.bundle`
 // live in `<name>/`, listed in `<name>.assets` for platforms that extract them.
-exports.unpack = async function (bundle, base, name) {
+exports.unpack = async function (bundle, base, name, readModule) {
   const assets = []
 
   bundle = await unpack(bundle, { files: false, assets: true }, async (key) => {
-    const relative = await exports.path(new URL('.' + key, base))
+    const relative = await exports.path(new URL('.' + key, base), readModule)
 
     assets.push({ path: relative, source: bundle.read(key) })
 
@@ -23,13 +23,13 @@ exports.unpack = async function (bundle, base, name) {
 
 // Assets of dependencies keep their path from `node_modules`, and others their
 // path within their package, so that every bundle places an asset alike.
-exports.path = async function (url) {
+exports.path = async function (url, readModule) {
   const nm = url.pathname.indexOf('/node_modules/')
 
   if (nm >= 0) return url.pathname.slice(nm + 1)
 
   for (let dir = new URL('./', url); ; dir = new URL('../', dir)) {
-    if (await fs.isFile(new URL('package.json', dir))) {
+    if ((await readModule(new URL('package.json', dir))) !== null) {
       return url.pathname.slice(dir.pathname.length)
     }
 

package/lib/graph.js

@@ -2,7 +2,6 @@ const { fileURLToPath, pathToFileURL } = require('url')
 const bareLink = require('bare-link')
 const strip = require('bare-type-stripper')
 const { resolve } = require('bare-module-traverse')
-const fs = require('./fs')
 const targets = require('./target')
 const languages = require('./language')
 const { select } = require('./provider')
@@ -55,17 +54,18 @@ exports.traversal = function traversal(opts, hosts) {
     aliases: {
       '.ts': '.js',
       '.mts': '.mjs',
-      '.cts': '.cjs'
+      '.cts': '.cjs',
+      ...opts.aliases
     },
     hosts
   }
 }
 
-exports.readModule = function readModule(modules) {
+exports.readModule = function readModule(modules, read) {
   return async function (url) {
     if (modules.has(url.href)) return modules.get(url.href)
 
-    const source = await fs.readModule(url)
+    const source = await read(url)
 
     if (source === null) return null
 
@@ -77,16 +77,14 @@ exports.readModule = function readModule(modules) {
 
 // The layout must not depend on the hosts, as Swift packages only accept
 // XCFrameworks. Resources linked outside of the directory are intermediate.
-exports.link = async function* link(entries, dir, traversal, readModule) {
+exports.link = async function* link(entries, dir, traversal, hooks) {
   for await (const resource of bareLink(
     entries.map((url) => fileURLToPath(url)),
     {
       ...traversal,
       out: fileURLToPath(dir),
       alwaysMultiHost: true,
-      readModule,
-      listPrefix: fs.listPrefix,
-      resolveModule: fs.resolveModule
+      ...hooks
     }
   )) {
     const url = pathToFileURL(resource)

package/lib/language/kotlin.js

@@ -3,7 +3,7 @@ const path = require('path')
 exports.name = 'kotlin'
 
 exports.options = function options(given = {}) {
-  const { package: name, ...unknown } = given
+  const { package: name, platform = 'android', ...unknown } = given
 
   for (const option of Object.keys(unknown)) {
     throw new Error(`Unknown option '${option}' for language 'kotlin'`)
@@ -15,19 +15,33 @@ exports.options = function options(given = {}) {
     throw new Error(`'${name}' is not a valid Kotlin package name`)
   }
 
-  return { package: name }
+  if (platform !== 'android' && platform !== 'jvm') {
+    throw new Error(`Option 'platform' must be 'android' or 'jvm', got '${platform}'`)
+  }
+
+  return { package: name, platform }
 }
 
-// The bundle is an asset of the module, under the directory of its package as
-// the assets of every module of the application share one namespace.
+// The bundle is an asset or resource of the module, under the directory of its
+// package as those of every module of the application share one namespace. A
+// JVM module can't read its resources as files, so it lists the files beside
+// the bundle for the harness to extract.
 exports.layout = function layout(out, options) {
   const dir = options.package.replace(/\./g, '/')
 
-  return {
+  const module = {
     harness: new URL(`src/main/kotlin/${dir}/Harness.kt`, out),
-    artifacts: new URL(`src/main/assets/${dir}/`, out),
     name: options.package,
-    manifest: new URL('build.gradle', out),
+    manifest: new URL('build.gradle', out)
+  }
+
+  if (options.platform === 'jvm') {
+    return { ...module, artifacts: new URL(`src/main/resources/${dir}/`, out), listing: true }
+  }
+
+  return {
+    ...module,
+    artifacts: new URL(`src/main/assets/${dir}/`, out),
     addons: new URL('src/main/addons/', out),
     resources: new URL('src/main/assets/', out)
   }
@@ -37,11 +51,14 @@ exports.sibling = function sibling(url, name) {
   return new URL(capitalize(name) + '.kt', url)
 }
 
-// Assets are referenced by their path within the assets of the application.
+// Assets and resources are referenced by their path within those of the
+// application.
 exports.reference = function reference(from, to) {
-  const assets = to.pathname.lastIndexOf('/src/main/assets/')
+  for (const dir of ['/src/main/assets/', '/src/main/resources/']) {
+    const index = to.pathname.lastIndexOf(dir)
 
-  if (assets !== -1) return to.pathname.slice(assets + '/src/main/assets/'.length)
+    if (index !== -1) return to.pathname.slice(index + dir.length)
+  }
 
   return path.posix.relative(path.posix.dirname(from.pathname), to.pathname)
 }
@@ -49,11 +66,24 @@ exports.reference = function reference(from, to) {
 // The dependencies of Kotlin generators map Maven coordinates without a version
 // to the version that the module uses. They are part of the API of the module,
 // as the harness exposes their types.
-exports.manifest = function manifest({ name, dependencies, addons = [] }) {
+exports.manifest = function manifest({ name, dependencies, options = {}, addons = [] }) {
   const apis = Object.entries(dependencies).map(
     ([coordinates, version]) => `  api ${JSON.stringify(coordinates + ':' + version)}`
   )
 
+  if (options.platform === 'jvm') {
+    return `\
+plugins {
+  id "java-library"
+  id "org.jetbrains.kotlin.jvm"
+}
+
+dependencies {
+${apis.join('\n')}
+}
+`
+  }
+
   // Linked addons are native libraries in a directory per ABI, along with the
   // archives of any Java classes they use.
   const libraries = [

package/lib/link.js

@@ -18,10 +18,13 @@ module.exports = async function* link(entries, target, out, opts = {}) {
     resolveTarget,
     resolveRPC,
     resolveLanguage,
+    readModule = fs.readModule,
+    listPrefix = fs.listPrefix,
+    resolveModule = fs.resolveModule,
     ...packOpts
   } = opts
 
-  entries = await Promise.all([].concat(entries).map((entry) => fs.resolveModule(new URL(entry))))
+  entries = await Promise.all([].concat(entries).map((entry) => resolveModule(new URL(entry))))
 
   if (entries.length === 0) throw new Error("'entries' must not be empty")
   out = new URL(out)
@@ -61,7 +64,12 @@ module.exports = async function* link(entries, target, out, opts = {}) {
   const main = shim(entries[0], target.isolation, server)
 
   const traversal = graph.traversal(packOpts, hosts)
-  const readModule = graph.readModule(main.modules)
+
+  const hooks = {
+    readModule: graph.readModule(main.modules, readModule),
+    listPrefix,
+    resolveModule
+  }
 
   const addons = []
 
@@ -69,13 +77,13 @@ module.exports = async function* link(entries, target, out, opts = {}) {
     [main.url, ...entries.slice(1)],
     layout.addons,
     traversal,
-    readModule
+    hooks
   )) {
     addons.push(url)
     yield { url }
   }
 
-  const linked = await collectAssets(entries, traversal, readModule)
+  const linked = await collectAssets(entries, traversal, hooks)
 
   if (linked.length > 0) {
     if (!layout.resources) {
@@ -109,21 +117,21 @@ module.exports = async function* link(entries, target, out, opts = {}) {
   }
 }
 
-async function collectAssets(entries, traversal, readModule) {
+async function collectAssets(entries, traversal, hooks) {
   const collected = new Map()
 
   for (const entry of entries) {
     const bundle = await pack(
       entry,
       { ...traversal, linked: true },
-      readModule,
-      fs.listPrefix,
-      fs.resolveModule
+      hooks.readModule,
+      hooks.listPrefix,
+      hooks.resolveModule
     )
 
     for (const key of bundle.assets) {
       const url = new URL(key)
-      const relative = await assets.path(url)
+      const relative = await assets.path(url, hooks.readModule)
       const source = bundle.read(key)
       const existing = collected.get(relative)
 

package/lib/rpc/bare-rpc.js

@@ -15,21 +15,18 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import to.holepunch.bare.rpc.CommandRouter
 import to.holepunch.bare.rpc.Rpc
+import to.holepunch.bare.rpc.Transport
 import to.holepunch.bare.stow.host.Ipc
 
-typealias Client = Rpc
-
 typealias Handlers = CommandRouter.() -> Unit
 
-internal fun attach(ipc: Ipc, handlers: Handlers): Client {
+internal fun attach(ipc: Ipc, handlers: Handlers): Rpc {
   val router = CommandRouter().apply(handlers)
 
   return Rpc(
-    ipc.data,
-    ipc::write,
+    Transport(ipc.data, ipc::write, ipc::close),
     CoroutineScope(Dispatchers.Default),
-    onEvent = router::dispatch,
-    onRequest = router::dispatch,
+    router,
   )
 }
 `
@@ -37,8 +34,8 @@ internal fun attach(ipc: Ipc, handlers: Handlers): Client {
   return {
     source,
     dependencies: {
-      'com.github.holepunchto.bare-rpc-kotlin:bare-rpc-kotlin': 'v0.4.0',
-      'com.github.holepunchto.bare-stow-host-kotlin:bare-stow-host-kotlin': 'v0.1.1'
+      'com.github.holepunchto.bare-rpc-kotlin:bare-rpc-kotlin': 'v0.5.0',
+      'com.github.holepunchto.bare-stow-host-kotlin:bare-stow-host-kotlin': 'v0.2.1'
     }
   }
 }
@@ -49,80 +46,16 @@ import BareRPC
 import BareStowHost
 import Foundation
 
-public final class Client: @unchecked Sendable {
-  public let rpc: RPC
-
-  private let delegate: Delegate
-
-  fileprivate init(rpc: RPC, delegate: Delegate) {
-    self.rpc = rpc
-    self.delegate = delegate
-  }
-
-  public func request(_ command: UInt, data: Data? = nil) async throws -> Data? {
-    try await rpc.request(command, data: data)
-  }
-
-  public func event(_ command: UInt, data: Data? = nil) async {
-    await rpc.event(command, data: data)
-  }
-}
-
 public typealias Handlers = (CommandRouter) -> Void
 
-func attach(_ ipc: IPC, _ handlers: Handlers?) -> Client {
+extension BareStowHost.IPC: @retroactive BareRPC.Transport {}
+
+func attach(_ ipc: IPC, _ handlers: Handlers?) -> RPC {
   let router = CommandRouter()
 
   handlers?(router)
 
-  let delegate = Delegate(router: router)
-  let rpc = RPC(delegate: delegate)
-
-  Task {
-    for await frame in delegate.frames {
-      try? await ipc.write(frame)
-    }
-  }
-
-  Task {
-    do {
-      for try await data in ipc {
-        await rpc.receive(data)
-      }
-    } catch {}
-
-    delegate.finish()
-  }
-
-  return Client(rpc: rpc, delegate: delegate)
-}
-
-private final class Delegate: RPCDelegate, @unchecked Sendable {
-  let router: CommandRouter
-  let frames: AsyncStream<Data>
-
-  private let continuation: AsyncStream<Data>.Continuation
-
-  init(router: CommandRouter) {
-    self.router = router
-    (frames, continuation) = AsyncStream.makeStream()
-  }
-
-  func rpc(_ rpc: RPC, send data: Data) {
-    continuation.yield(data)
-  }
-
-  func rpc(_ rpc: RPC, didReceiveRequest request: IncomingRequest) async throws {
-    await router.dispatch(request)
-  }
-
-  func rpc(_ rpc: RPC, didReceiveEvent event: IncomingEvent) async {
-    await router.dispatch(event)
-  }
-
-  func finish() {
-    continuation.finish()
-  }
+  return RPC(ipc, handler: router)
 }
 `
 
@@ -131,12 +64,12 @@ private final class Delegate: RPCDelegate, @unchecked Sendable {
     dependencies: {
       'bare-rpc-swift': {
         url: 'https://github.com/holepunchto/bare-rpc-swift',
-        from: '1.1.0',
+        from: '2.0.0',
         products: ['BareRPC']
       },
       'bare-stow-host-swift': {
         url: 'https://github.com/holepunchto/bare-stow-host-swift',
-        from: '0.1.0',
+        from: '0.2.0',
         products: ['BareStowHost']
       }
     }
@@ -150,28 +83,22 @@ from collections.abc import Callable
 from bare_rpc import RPC, CommandRouter
 from bare_stow_host import IPC
 
-Client = RPC
-
 Handlers = Callable[[CommandRouter], None]
 
 
-def attach(ipc: IPC, handlers: Handlers) -> Client:
+def attach(ipc: IPC, handlers: Handlers) -> RPC:
     router = CommandRouter()
 
     handlers(router)
 
-    return RPC(
-        ipc,
-        on_request=router.dispatch_request,
-        on_event=router.dispatch_event,
-    )
+    return RPC(ipc, handler=router)
 `
 
   return {
     source,
     dependencies: {
-      'bare-rpc': '~=0.1.0',
-      'bare-stow-host': '~=0.1.0'
+      'bare-rpc': '~=0.2.0',
+      'bare-stow-host': '~=0.2.0'
     }
   }
 }
@@ -225,5 +152,5 @@ export type Handlers = (router: import('bare-rpc').CommandRouter) => void
 export function attach(ipc: import('bare-stow-host').IPC, handlers: Handlers): import('bare-rpc')
 `
 
-  return { source, types, dependencies: { 'bare-rpc': '^1.3.9' } }
+  return { source, types, dependencies: { 'bare-rpc': '^1.5.0' } }
 }

package/lib/target/bare-kit.js

@@ -1,14 +1,32 @@
+const path = require('path')
 const swift = require('./swift')
 
 exports.name = 'bare-kit'
 exports.isolation = 'thread'
-exports.linked = true
-exports.linking = ({ targetOptions }) => targetOptions.linking
-exports.offload = false
+exports.linked = (context) => !isJvm(context)
+exports.linking = linking
+exports.offload = isJvm
 exports.format = 'bundle'
 exports.encoding = null
 exports.extension = '.bundle'
-exports.hosts = ({ language }) => hosts[language]
+exports.hosts = (context) => (isJvm(context) ? desktop : hosts[context.language])
+
+// On the JVM, the harness extracts the bundle from the resources of its module,
+// so the addons and assets of the bundle are offloaded beside it rather than
+// linked.
+function isJvm({ language, options }) {
+  return language === 'kotlin' && options.platform === 'jvm'
+}
+
+function linking(context) {
+  const { targetOptions } = context
+
+  if (isJvm(context) && targetOptions.linking === 'app') {
+    throw new Error("Option 'linking' must be 'package' for the JVM")
+  }
+
+  return targetOptions.linking
+}
 
 // Applications with several bundles link their addons once with `link()`.
 exports.options = function options(given = {}) {
@@ -27,14 +45,23 @@ exports.options = function options(given = {}) {
 
 const bareKitSwift = {
   url: 'https://github.com/holepunchto/bare-kit-swift',
-  from: '2.0.0',
+  from: '2.2.0',
   products: ['BareKit']
 }
 
 const bareKitKotlin = {
-  'com.github.holepunchto.bare-kit-kotlin:bare-kit-kotlin': 'v0.1.1'
+  'com.github.holepunchto.bare-kit-kotlin:bare-kit-kotlin': 'v0.2.2'
 }
 
+const desktop = [
+  'darwin-arm64',
+  'darwin-x64',
+  'linux-arm64',
+  'linux-x64',
+  'win32-arm64',
+  'win32-x64'
+]
+
 const hosts = {
   kotlin: ['android-arm64', 'android-arm', 'android-x64', 'android-ia32'],
   swift: ['darwin-arm64', 'darwin-x64', 'ios-arm64', 'ios-arm64-simulator', 'ios-x64-simulator']
@@ -62,7 +89,7 @@ exports.languages = {
 
       return swift(context, {
         module: 'BareKit',
-        conformance: 'extension BareKit.IPC: @retroactive Transport {}',
+        conformance: 'extension BareKit.IPC: @retroactive BareStowHost.Transport {}',
         fields: { worklet: 'Worklet' },
         params: ['options: Worklet.Options = Worklet.Options()'],
         setup: `\
@@ -82,36 +109,53 @@ Task { ipc.exited(code: await worklet.wait()) }`,
   }
 }
 
-function kotlin({ bundle, client, resources, options }) {
-  const start = resources
-    ? `worklet.start(${JSON.stringify(resources + '.bundle')}, context.assets.open(${JSON.stringify(bundle)}).use { it.readBytes() })`
-    : `worklet.start(${JSON.stringify(bundle)})`
+function kotlin(context) {
+  const { client, options } = context
+
+  const platform = options.platform === 'jvm' ? jvm(context) : android(context)
+
+  const imports = [
+    ...platform.imports,
+    'kotlin.time.Duration',
+    'kotlinx.coroutines.CoroutineScope',
+    'kotlinx.coroutines.Dispatchers',
+    'kotlinx.coroutines.launch',
+    'to.holepunch.bare.kit.Ipc as WorkletIpc',
+    'to.holepunch.bare.kit.Worklet',
+    'to.holepunch.bare.stow.host.Ipc',
+    ...(client ? ['to.holepunch.bare.rpc.Rpc'] : [])
+  ].sort()
 
   const source = `\
 package ${options.package}
 
-import android.content.Context
-import kotlin.time.Duration
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import to.holepunch.bare.kit.Ipc as WorkletIpc
-import to.holepunch.bare.kit.Worklet
-import to.holepunch.bare.stow.host.Ipc
-
-class Started(val worklet: Worklet, val ipc: Ipc${client ? ', val rpc: Client' : ''})
+${imports.map((name) => 'import ' + name).join('\n')}
 
+class Started(val worklet: Worklet, val ipc: Ipc${client ? ', val rpc: Rpc' : ''})
+${platform.declarations}
 suspend fun start(
-  context: Context,
+${platform.params}\
   options: Worklet.Options = Worklet.Options(),
   timeout: Duration? = null,
   grace: Duration = Ipc.DEFAULT_GRACE,${client ? '\n  handlers: Handlers = {},' : ''}
 ): Started {
-  val worklet = Worklet(context, options)
-
-  val transport = WorkletIpc(worklet)
+  val worklet = ${platform.worklet}
+
+  val transport =
+    try {
+      WorkletIpc(worklet)
+    } catch (error: Throwable) {
+      worklet.close()
+      throw error
+    }
 
-  ${start}
+  try {
+    ${platform.start}
+  } catch (error: Throwable) {
+    transport.close()
+    worklet.close()
+    throw error
+  }
 
   val ipc =
     Ipc(
@@ -126,6 +170,7 @@ suspend fun start(
     ipc.exited(worklet.wait())
 
     transport.close()
+    worklet.close()
   }
 ${client ? '\n  val rpc = attach(ipc, handlers)\n' : ''}
   ipc.ready()
@@ -138,7 +183,56 @@ ${client ? '\n  val rpc = attach(ipc, handlers)\n' : ''}
     source,
     dependencies: {
       ...bareKitKotlin,
-      'com.github.holepunchto.bare-stow-host-kotlin:bare-stow-host-kotlin': 'v0.1.1'
+      'com.github.holepunchto.bare-stow-host-kotlin:bare-stow-host-kotlin': 'v0.2.1'
     }
   }
 }
+
+function android({ bundle, resources }) {
+  return {
+    imports: ['android.content.Context'],
+    declarations: '',
+    params: '  context: Context,\n',
+    worklet: 'Worklet(context, options)',
+    start: resources
+      ? `worklet.start(${JSON.stringify(resources + '.bundle')}, context.assets.open(${JSON.stringify(bundle)}).use { it.readBytes() })`
+      : `worklet.start(${JSON.stringify(bundle)})`
+  }
+}
+
+// The bundle and the files listed beside it are extracted once per process, to
+// a directory of its own that is removed on exit.
+function jvm({ bundle }) {
+  const dir = path.posix.dirname(bundle)
+  const name = '/' + path.posix.basename(bundle)
+
+  return {
+    imports: ['java.io.File', 'java.nio.file.Files', 'kotlinx.coroutines.withContext'],
+    declarations: `
+private val bundle: File by lazy {
+  val dir = Files.createTempDirectory("bare-stow").toFile()
+
+  Runtime.getRuntime().addShutdownHook(Thread { dir.deleteRecursively() })
+
+  val loader = Started::class.java.classLoader
+
+  fun open(name: String) = loader.getResourceAsStream(${JSON.stringify(dir)} + name)!!
+
+  val listed = open(${JSON.stringify(name + '.files')}).bufferedReader().use { it.readLines() }
+
+  for (name in listOf(${JSON.stringify(name)}) + listed) {
+    val file = File(dir, name)
+
+    file.parentFile.mkdirs()
+
+    open(name).use { input -> file.outputStream().use { input.copyTo(it) } }
+  }
+
+  File(dir, ${JSON.stringify(name)})
+}
+`,
+    params: '',
+    worklet: 'Worklet(options)',
+    start: 'worklet.start(withContext(Dispatchers.IO) { bundle }.path)'
+  }
+}

package/lib/target/bare-sidecar.js

@@ -22,12 +22,12 @@ exports.languages = {
     generate(context) {
       return harness(context, {
         name: 'bare-sidecar',
-        version: '^0.5.12',
+        version: '^0.5.15',
         binding: 'Sidecar',
         url: true,
-        setup: `\
-const sidecar = new Sidecar(bundle, { stdio: 'inherit', ...opts })
-
+        handle: 'sidecar',
+        spawn: "new Sidecar(bundle, { stdio: 'inherit', ...opts })",
+        connect: `\
 const ipc = stow.wrap(sidecar, { kill: () => sidecar.kill('SIGKILL'), timeout, grace })
 
 sidecar.on('exit', (code, signal) => ipc.exited(code, signal))`,
@@ -40,10 +40,10 @@ sidecar.on('exit', (code, signal) => ipc.exited(code, signal))`,
     generate(context) {
       return swift(context, {
         module: 'BareSidecar',
-        conformance: 'extension Sidecar: @retroactive Transport {}',
+        conformance: 'extension Sidecar: @retroactive BareStowHost.Transport {}',
+        handle: { name: 'sidecar', type: 'Sidecar' },
+        spawn: 'try await Sidecar.spawn(bundle)',
         setup: `\
-let sidecar = try await Sidecar.spawn(bundle)
-
 let ipc = BareStowHost.IPC(sidecar, kill: { sidecar.kill() }, timeout: timeout, grace: grace)
 
 Task {
@@ -55,7 +55,7 @@ Task {
         dependencies: {
           'bare-sidecar-swift': {
             url: 'https://github.com/holepunchto/bare-sidecar-swift',
-            from: '0.1.0',
+            from: '0.1.3',
             products: ['BareSidecar']
           }
         }
@@ -70,16 +70,16 @@ import asyncio
 from pathlib import Path
 from typing import NamedTuple
 
-from bare_sidecar import spawn
+${client ? 'from bare_rpc import RPC\n' : ''}from bare_sidecar import Sidecar, spawn
 from bare_stow_host import DEFAULT_GRACE, IPC, wrap
-${client ? `\nfrom ${client} import Client, Handlers, attach\n` : ''}
+${client ? `\nfrom ${client} import Handlers, attach\n` : ''}
 bundle = Path(__file__).parent / ${JSON.stringify(bundle)}
 
 _watching = set()
 
 
 class Started(NamedTuple):
-    ipc: IPC${client ? '\n    rpc: Client' : ''}
+    ipc: IPC${client ? '\n    rpc: RPC' : ''}
 
 
 async def start(
@@ -90,6 +90,15 @@ async def start(
 ) -> Started:
     sidecar = await spawn(bundle, **opts)
 
+    return await connect(sidecar, timeout=timeout, grace=grace${client ? ', handlers=handlers' : ''})
+
+
+async def connect(
+    sidecar: Sidecar,
+    *,
+    timeout=None,
+    grace=DEFAULT_GRACE,${client ? '\n    handlers: Handlers = lambda router: None,' : ''}
+) -> Started:
     ipc = wrap(sidecar, kill=sidecar.kill, timeout=timeout, grace=grace)
 
     watching = asyncio.ensure_future(_watch(sidecar, ipc))
@@ -112,8 +121,8 @@ async def _watch(sidecar, ipc):
   return {
     source,
     dependencies: {
-      'bare-sidecar': '~=0.1.0',
-      'bare-stow-host': '~=0.1.0'
+      'bare-sidecar': '~=0.1.3',
+      'bare-stow-host': '~=0.2.0'
     }
   }
 }

package/lib/target/bare-worker.js

@@ -21,11 +21,11 @@ exports.languages = {
     generate(context) {
       return harness(context, {
         name: 'bare-worker',
-        version: '^4.3.0',
+        version: '^4.5.3',
         binding: 'Worker',
-        setup: `\
-const worker = new Worker(bundle, opts)
-
+        handle: 'worker',
+        spawn: 'new Worker(bundle, opts)',
+        connect: `\
 const ipc = stow.wrap(worker.IPC, { kill: () => worker.terminate(), timeout, grace })
 
 worker.IPC.on('end', () => worker.IPC.destroy())

package/lib/target/javascript.js

@@ -1,11 +1,18 @@
 module.exports = function harness(context, target) {
   const { bundle, client, options } = context
-  const { name, version, binding, url = false, setup, types } = target
+  const { name, version, binding, url = false, handle, spawn, connect, types } = target
 
   const esm = options.module === 'esm'
 
+  const params = `{ timeout, grace${client ? ', handlers = () => {}' : ''} } = {}`
+
+  const start = `\
+const ${handle} = ${spawn}
+
+return await connect(${handle}, { timeout, grace${client ? ', handlers' : ''} })`
+
   const body = `\
-${setup}
+${connect}
 ${client ? '\nconst rpc = client.attach(ipc, handlers)\n' : ''}
 await ipc.ready
 
@@ -18,7 +25,11 @@ import stow from 'bare-stow-host'
 ${client ? `import * as client from ${JSON.stringify(client)}\n` : ''}
 const bundle = ${url ? `new URL(import.meta.resolve(${JSON.stringify(bundle)}))` : `import.meta.resolve(${JSON.stringify(bundle)})`}
 
-export async function start({ timeout, grace, ${client ? 'handlers = () => {}, ' : ''}...opts } = {}) {
+export async function start({ timeout, grace, ${client ? 'handlers, ' : ''}...opts } = {}) {
+${indent(start, 2)}
+}
+
+export async function connect(${handle}, ${params}) {
 ${indent(body, 2)}
 }
 `
@@ -28,14 +39,18 @@ const stow = require('bare-stow-host')
 ${client ? `const client = require(${JSON.stringify(client)})\n` : ''}
 const bundle = require.resolve(${JSON.stringify(bundle)})
 
-module.exports = {
-  async start({ timeout, grace, ${client ? 'handlers = () => {}, ' : ''}...opts } = {}) {
-${indent(body, 4)}
-  }
+module.exports = { start, connect }
+
+async function start({ timeout, grace, ${client ? 'handlers, ' : ''}...opts } = {}) {
+${indent(start, 2)}
+}
+
+async function connect(${handle}, ${params}) {
+${indent(body, 2)}
 }
 `
 
-  const handle = client
+  const started = client
     ? `{ ipc: import('bare-stow-host').IPC; rpc: ReturnType<typeof import(${JSON.stringify(client)}).attach> }`
     : `{ ipc: import('bare-stow-host').IPC }`
 
@@ -43,12 +58,14 @@ ${indent(body, 4)}
     source,
     dependencies: {
       [name]: version,
-      'bare-stow-host': '^0.1.0'
+      'bare-stow-host': '^0.2.0'
     },
     types: `\
-export function start(
-  opts?: ${types} & Omit<import('bare-stow-host').IPCOptions, 'kill'>${client ? ` & { handlers?: import(${JSON.stringify(client)}).Handlers }` : ''}
-): Promise<${handle}>
+type ConnectOptions = Omit<import('bare-stow-host').IPCOptions, 'kill'>${client ? ` & { handlers?: import(${JSON.stringify(client)}).Handlers }` : ''}
+
+export function start(opts?: ${types} & ConnectOptions): Promise<${started}>
+
+export function connect(${handle}: import('${name}'), opts?: ConnectOptions): Promise<${started}>
 `
   }
 }

package/lib/target/swift.js

@@ -2,15 +2,62 @@
 // an `IPC` of their own.
 module.exports = function harness(context, target) {
   const { bundle, client } = context
-  const { module, conformance, fields = {}, params = [], setup, dependencies } = target
+  const {
+    module,
+    conformance,
+    fields = {},
+    params = [],
+    handle,
+    spawn,
+    setup,
+    dependencies
+  } = target
 
   const started = { ...fields, ipc: 'BareStowHost.IPC' }
 
-  if (client) started.rpc = 'Client'
+  if (client) started.rpc = 'RPC'
+
+  const options = [
+    'timeout: TimeInterval? = nil',
+    'grace: TimeInterval = BareStowHost.IPC.defaultGrace',
+    ...(client ? ['handlers: Handlers? = nil'] : [])
+  ]
+
+  const forwarded = ['timeout', 'grace', ...(client ? ['handlers'] : [])].map(
+    (name) => `${name}: ${name}`
+  )
+
+  const body = `\
+${setup}
+${client ? '\nlet rpc = attach(ipc, handlers)\n' : ''}
+try await ipc.ready()
+
+return Started(${Object.keys(started)
+    .map((name) => `${name}: ${name}`)
+    .join(', ')})`
+
+  const resource = `let bundle = Bundle.module.url(forResource: ${JSON.stringify(bundle)}, withExtension: nil)!`
+
+  // Targets that spawn the bundle let hosts connect to one they spawned, such
+  // as from another entry.
+  const start = handle
+    ? `\
+${resource}
+
+let ${handle.name} = ${spawn}
+
+return try await connect(${[handle.name, ...forwarded].join(', ')})`
+    : `${resource}\n\n${body}`
+
+  const functions = [func('start', [...params, ...options], start)]
+
+  if (handle) {
+    functions.push(func('connect', [`_ ${handle.name}: ${handle.type}`, ...options], body))
+  }
 
   const source = `\
 import ${module}
-import BareStowHost
+${client ? 'import BareRPC\n' : ''}import BareStowHost
 import Foundation
 
 ${conformance}
@@ -21,26 +68,7 @@ ${Object.entries(started)
   .join('\n')}
 }
 
-public func start(
-${[
-  ...params,
-  'timeout: TimeInterval? = nil',
-  'grace: TimeInterval = BareStowHost.IPC.defaultGrace',
-  ...(client ? ['handlers: Handlers? = nil'] : [])
-]
-  .map((param) => '  ' + param)
-  .join(',\n')}
-) async throws -> Started {
-  let bundle = Bundle.module.url(forResource: ${JSON.stringify(bundle)}, withExtension: nil)!
-
-${setup.replace(/^(?=.)/gm, '  ')}
-${client ? '\n  let rpc = attach(ipc, handlers)\n' : ''}
-  try await ipc.ready()
-
-  return Started(${Object.keys(started)
-    .map((name) => `${name}: ${name}`)
-    .join(', ')})
-}
+${functions.join('\n\n')}
 `
 
   return {
@@ -49,9 +77,25 @@ ${client ? '\n  let rpc = attach(ipc, handlers)\n' : ''}
       ...dependencies,
       'bare-stow-host-swift': {
         url: 'https://github.com/holepunchto/bare-stow-host-swift',
-        from: '0.1.0',
+        from: '0.2.0',
         products: ['BareStowHost']
       }
     }
   }
 }
+
+function func(name, params, body) {
+  return `\
+public func ${name}(
+${params.map((param) => '  ' + param).join(',\n')}
+) async throws -> Started {
+${indent(body)}
+}`
+}
+
+function indent(source) {
+  return source
+    .split('\n')
+    .map((line) => (line.length === 0 ? line : '  ' + line))
+    .join('\n')
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-stow",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Module bundling and harness generation for Bare",
   "exports": {
     "./package": "./package.json",
@@ -54,27 +54,27 @@
   },
   "homepage": "https://github.com/holepunchto/bare-stow#readme",
   "dependencies": {
-    "bare-bundle": "^1.8.3",
-    "bare-bundle-id": "^1.0.0",
-    "bare-fs": "^4.2.1",
-    "bare-link": "^4.1.0",
-    "bare-module-traverse": "^2.2.0",
-    "bare-pack": "^3.0.0",
-    "bare-path": "^3.0.0",
-    "bare-type-stripper": "^0.1.2",
-    "bare-unpack": "^1.1.3",
-    "paparam": "^1.5.0"
+    "bare-bundle": "^1.11.0",
+    "bare-bundle-id": "^1.0.3",
+    "bare-fs": "^4.8.4",
+    "bare-link": "^4.2.0",
+    "bare-module-traverse": "^2.7.4",
+    "bare-pack": "^3.0.2",
+    "bare-path": "^3.1.2",
+    "bare-type-stripper": "^0.1.7",
+    "bare-unpack": "^1.1.4",
+    "paparam": "^1.15.0"
   },
   "devDependencies": {
-    "bare-os": "^3.0.0",
-    "bare-rpc": "^1.3.2",
-    "bare-sidecar": "^0.5.11",
-    "bare-stow-host": "^0.1.0",
+    "bare-os": "^3.9.4",
+    "bare-rpc": "^1.5.0",
+    "bare-sidecar": "^0.5.15",
+    "bare-stow-host": "^0.2.0",
     "bare-stow-runtime": "^0.1.0",
-    "bare-worker": "^4.3.0",
-    "brittle": "^4.0.2",
-    "lunte": "^1.7.0",
-    "prettier": "^3.3.3",
+    "bare-worker": "^4.5.3",
+    "brittle": "^4.5.0",
+    "lunte": "^1.8.6",
+    "prettier": "^3.9.10",
     "prettier-config-holepunch": "^2.0.0",
     "which-runtime": "^1.4.0"
   },