A bundle that is not JavaScript is launched and spoken to over MCP on stdio (hq ADR 0187, to-be 38 WP1b)

The runtime imported a bundle into its own process, which only JavaScript can be. Now an entrypoint
that is not a plain JavaScript file — or is one marked executable — is started as a child with the
runtime's environment and asked `tools/list` once and `tools/call` per call; what it lists is
registered exactly as an imported bundle's registrations are, a `<seat>.<verb>` name as the seat's
implementation. So a tools bundle may be in any language, and the mesh's part — the subjects, the
seats, the `tools` answer, a failed bundle named — stays in the runtime and is shared by all of
them. A child that exits mid-call tells the caller so and is started again on its next call.

Proven against a real bus beside the three bundles already there: a Python bundle with no SDK at
all answers its tool and its seat verb; a TypeScript bundle written against the protocol and marked
executable is served through the launcher, shortcut off; a bundle told to exit is relaunched.

test/node-runtime.test.ts

@@ -91,7 +91,7 @@ test("MESH_TOOL_MODULES names modules and their entrypoints; a bare path is the
   assert.deepEqual(servedModulesFrom("", "x"), { serves: [], moduleEntrypoints: [] });
 });
 
-test("the node's runtime serves three modules' bundles on one credential, names the one that fails, and follows a re-issued membership", async (t) => {
+test("the node's runtime serves five modules' bundles on one credential — two of them launched, one broken — and follows a re-issued membership", async (t) => {
   if (!url) return t.skip("MESH_TEST_NATS unset");
   resetTools();
   const mesh = await aMesh();
@@ -100,6 +100,10 @@ test("the node's runtime serves three modules' bundles on one credential, names
   await mesh.issue(membershipOf("alpha", "anchor", { plain: true }));
   await mesh.issue(membershipOf("beta", "anchor", { seats: { "node-shelf": ["list", "clear"] } }));
   await mesh.issue(membershipOf("gamma", "anchor"));
+  // Two more, launched rather than loaded (ADR 0187): delta is Python and holds the node-lamp seat;
+  // epsilon is TypeScript written against the protocol and marked executable.
+  await mesh.issue(membershipOf("delta", "anchor", { seats: { "node-lamp": ["on"] } }));
+  await mesh.issue(membershipOf("epsilon", "anchor"));
   // The node's credential: the runtime module's name, no claims (seats come from the memberships).
   const credential = { url, node: "anchor", module: "node-tools" };
   const nodeTools = await connectNats(credential);
@@ -118,13 +122,15 @@ test("the node's runtime serves three modules' bundles on one credential, names
         { module: "alpha", entrypoints: [fixture("many-alpha.mjs")] },
         { module: "beta", entrypoints: [fixture("many-beta.mjs")] },
         { module: "gamma", entrypoints: [fixture("many-broken.mjs")] },
+        { module: "delta", entrypoints: [fixture("many-delta.py")] },
+        { module: "epsilon", entrypoints: [fixture("many-epsilon.mjs")] },
       ],
     });
     console.log = log;
-    assert.deepEqual(nodeTools.serving().sort(), ["alpha", "beta", "gamma", "node-tools"]);
+    assert.deepEqual(nodeTools.serving().sort(), ["alpha", "beta", "delta", "epsilon", "gamma", "node-tools"]);
     assert.ok(said.some((s) => /the operator's account here is somebody \(home \/home\/somebody\)/.test(s)), said.join("\n"));
     assert.ok(said.some((s) => /gamma's bundle .*many-broken\.mjs failed to load: gamma's bundle cannot find its client; its tools are not served here/.test(s)), said.join("\n"));
-    assert.ok(said.some((s) => /serving 5 tool\(s\) for 3 module\(s\): alpha\.one, alpha\.two, beta\.three, beta\.four, beta\.five; not serving gamma/.test(s)), said.join("\n"));
+    assert.ok(said.some((s) => /serving 8 tool\(s\) for 5 module\(s\): alpha\.one, alpha\.two, beta\.three, beta\.four, beta\.five, delta\.greet, delta\.die, epsilon\.seven; not serving gamma/.test(s)), said.join("\n"));
 
     // Five tools answer, each where its module's membership says: alpha anywhere and here, beta here only.
     assert.deepEqual((await callTool(asker, "alpha.one", {})).result, { alpha: 1 });
@@ -138,6 +144,15 @@ test("the node's runtime serves three modules' bundles on one credential, names
     assert.deepEqual((await callTool(asker, "seat:node-shelf.list@anchor", {})).result, { shelf: ["a", "b"] });
     assert.deepEqual((await callTool(asker, "seat:node-shelf.clear@anchor", {})).result, { cleared: true });
 
+    // A bundle in another language answers the same way, its seat verb among them; so does a
+    // TypeScript bundle served through the protocol rather than imported.
+    assert.deepEqual((await callTool(asker, "delta.greet@anchor", { who: "mesh" })).result, { greeting: "hello mesh", language: "python" });
+    assert.deepEqual((await callTool(asker, "seat:node-lamp.on@anchor", {})).result, { on: true, language: "python" });
+    assert.deepEqual((await callTool(asker, "epsilon.seven@anchor", {})).result, { epsilon: 7, via: "stdio" });
+    // A child that exits mid-call tells the caller so and is started again on the next call.
+    await assert.rejects(callTool(asker, "delta.die@anchor", {}), /delta's bundle exited \(3\)/);
+    assert.deepEqual((await callTool(asker, "delta.greet@anchor", {})).result, { greeting: "hello world", language: "python" });
+
     // A tool that emits does so as its module, not as the runtime.
     const landed = mesh.nextEvent("mesh.mod.*.event.>");
     assert.deepEqual((await callTool(asker, "alpha.two", {})).result, { alpha: 2 });
@@ -152,10 +167,10 @@ test("the node's runtime serves three modules' bundles on one credential, names
 
     // And discovery says so, with the reason, beside the modules that answered.
     const catalogue = await connectNats({ url, module: "mesh-catalog" });
-    await catalogue.handle("catalog_modules", async () => ({ modules: [{ module: "alpha" }, { module: "beta" }, { module: "gamma" }] }));
+    await catalogue.handle("catalog_modules", async () => ({ modules: [{ module: "alpha" }, { module: "beta" }, { module: "gamma" }, { module: "delta" }, { module: "epsilon" }] }));
     try {
       const have = await toolsOn(asker);
-      assert.deepEqual(have.tools.map((x) => `${x.module}.${x.name}`), ["alpha.one", "alpha.two", "beta.five", "beta.four", "beta.three"]);
+      assert.deepEqual(have.tools.map((x) => `${x.module}.${x.name}`), ["alpha.one", "alpha.two", "beta.five", "beta.four", "beta.three", "delta.die", "delta.greet", "epsilon.seven"]);
       assert.deepEqual(have.notAnswering, ["gamma (its tools bundle failed to load: gamma's bundle cannot find its client)", "mesh-controller (seat)"]);
     } finally {
       await catalogue.close();