@agoric/swingset-vat 0.32.3-dev-ff36f02.0 → 0.32.3-dev-26028d4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-vat",
-  "version": "0.32.3-dev-ff36f02.0+ff36f02",
+  "version": "0.32.3-dev-26028d4.0+26028d4",
   "description": "Vat/Container Launcher",
   "type": "module",
   "main": "src/index.js",
@@ -28,16 +28,16 @@
     "yargs-parser": "^21.1.1"
   },
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-ff36f02.0+ff36f02",
-    "@agoric/internal": "0.3.3-dev-ff36f02.0+ff36f02",
-    "@agoric/store": "0.9.3-dev-ff36f02.0+ff36f02",
-    "@agoric/swing-store": "0.9.2-dev-ff36f02.0+ff36f02",
-    "@agoric/swingset-liveslots": "0.10.3-dev-ff36f02.0+ff36f02",
-    "@agoric/swingset-xsnap-supervisor": "0.10.3-dev-ff36f02.0+ff36f02",
-    "@agoric/time": "0.3.3-dev-ff36f02.0+ff36f02",
-    "@agoric/vat-data": "0.5.3-dev-ff36f02.0+ff36f02",
-    "@agoric/xsnap": "0.14.3-dev-ff36f02.0+ff36f02",
-    "@agoric/xsnap-lockdown": "0.14.1-dev-ff36f02.0+ff36f02",
+    "@agoric/assert": "0.6.1-dev-26028d4.0+26028d4",
+    "@agoric/internal": "0.3.3-dev-26028d4.0+26028d4",
+    "@agoric/store": "0.9.3-dev-26028d4.0+26028d4",
+    "@agoric/swing-store": "0.9.2-dev-26028d4.0+26028d4",
+    "@agoric/swingset-liveslots": "0.10.3-dev-26028d4.0+26028d4",
+    "@agoric/swingset-xsnap-supervisor": "0.10.3-dev-26028d4.0+26028d4",
+    "@agoric/time": "0.3.3-dev-26028d4.0+26028d4",
+    "@agoric/vat-data": "0.5.3-dev-26028d4.0+26028d4",
+    "@agoric/xsnap": "0.14.3-dev-26028d4.0+26028d4",
+    "@agoric/xsnap-lockdown": "0.14.1-dev-26028d4.0+26028d4",
     "@endo/base64": "^0.2.31",
     "@endo/bundle-source": "^2.5.1",
     "@endo/captp": "^3.1.1",
@@ -92,5 +92,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ff36f02c5fb8cc42248bc04d1313127397530de1"
+  "gitHead": "26028d4e8fd81c1cc8d0d6291978d6d8bc684cba"
 }

package/src/controller/controller.js

@@ -16,6 +16,7 @@ import { initSwingStore } from '@agoric/swing-store';
 
 import { checkBundle } from '@endo/check-bundle/lite.js';
 import engineGC from '../lib-nodejs/engine-gc.js';
+import { startSubprocessWorker } from '../lib-nodejs/spawnSubprocessWorker.js';
 import { waitUntilQuiescent } from '../lib-nodejs/waitUntilQuiescent.js';
 import { makeGcAndFinalize } from '../lib-nodejs/gc-and-finalize.js';
 import { kslot } from '../lib/kmarshal.js';
@@ -30,6 +31,7 @@ import {
   makeXsnapBundleData,
 } from './bundle-handler.js';
 import { makeStartXSnap } from './startXSnap.js';
+import { makeStartSubprocessWorkerNode } from './startNodeSubprocess.js';
 
 /** @param {Uint8Array} bytes */
 export function computeSha512(bytes) {
@@ -138,6 +140,9 @@ export async function makeSwingsetController(
     debug: !!env.XSNAP_DEBUG,
     workerTraceRootPath: env.XSNAP_TEST_RECORD,
   });
+  const startSubprocessWorkerNode = makeStartSubprocessWorkerNode(
+    startSubprocessWorker,
+  );
 
   function writeSlogObject(obj) {
     if (!slogSender) {
@@ -211,6 +216,7 @@ export async function makeSwingsetController(
     debugPrefix,
     vatEndowments,
     makeConsole,
+    startSubprocessWorkerNode,
     startXSnap,
     slogCallbacks,
     writeSlogObject,

package/src/controller/initializeKernel.js

@@ -86,6 +86,7 @@ export async function initializeKernel(config, kernelStorage, options = {}) {
         'useTranscript',
         'critical',
         'reapInterval',
+        'nodeOptions',
       ]);
       const vatID = kernelKeeper.allocateVatIDForNameIfNeeded(name);
       logStartup(`assigned VatID ${vatID} for genesis vat ${name}`);

package/src/controller/startNodeSubprocess.js

@@ -0,0 +1,17 @@
+import process from 'process';
+
+export function makeStartSubprocessWorkerNode(startSubprocessWorker) {
+  // launch a worker in a subprocess (which runs Node.js)
+  function startSubprocessWorkerNode(nameDisplayArg, nodeOptions) {
+    const supervisorCodePath = new URL(
+      '../supervisors/subprocess-node/supervisor-subprocess-node.js',
+      import.meta.url,
+    ).pathname;
+    const args = nodeOptions ? [...nodeOptions] : [];
+    args.push(supervisorCodePath);
+    args.push(nameDisplayArg);
+    return startSubprocessWorker(process.execPath, args);
+  }
+
+  return startSubprocessWorkerNode;
+}

package/src/kernel/kernel.js

@@ -92,6 +92,7 @@ export default function buildKernel(
     vatEndowments,
     slogCallbacks = {},
     makeConsole,
+    startSubprocessWorkerNode,
     startXSnap,
     writeSlogObject,
     WeakRef,
@@ -1428,6 +1429,7 @@ export default function buildKernel(
     allVatPowers,
     kernelKeeper,
     vatEndowments,
+    startSubprocessWorkerNode,
     startXSnap,
     gcTools,
     kernelSlog,

package/src/kernel/state/kernelKeeper.js

@@ -335,7 +335,7 @@ export default function makeKernelKeeper(kernelStorage, kernelSlog) {
    */
 
   function insistManagerType(mt) {
-    assert(['local', 'xsnap', 'xs-worker'].includes(mt));
+    assert(['local', 'node-subprocess', 'xsnap', 'xs-worker'].includes(mt));
   }
 
   function getDefaultManagerType() {

package/src/kernel/vat-loader/manager-factory.js

@@ -1,12 +1,14 @@
 import { assert, Fail } from '@agoric/assert';
 import { assertKnownOptions } from '../../lib/assertOptions.js';
 import { makeLocalVatManagerFactory } from './manager-local.js';
+import { makeNodeSubprocessFactory } from './manager-subprocess-node.js';
 import { makeXsSubprocessFactory } from './manager-subprocess-xsnap.js';
 
 export function makeVatManagerFactory({
   allVatPowers,
   kernelKeeper,
   vatEndowments,
+  startSubprocessWorkerNode,
   startXSnap,
   gcTools,
   kernelSlog,
@@ -17,6 +19,13 @@ export function makeVatManagerFactory({
     gcTools,
   });
 
+  const nodeSubprocessFactory = makeNodeSubprocessFactory({
+    startSubprocessWorker: startSubprocessWorkerNode,
+    kernelKeeper,
+    kernelSlog,
+    testLog: allVatPowers.testLog,
+  });
+
   const xsWorkerFactory = makeXsSubprocessFactory({
     startXSnap,
     kernelKeeper,
@@ -92,6 +101,15 @@ export function makeVatManagerFactory({
       );
     }
 
+    if (type === 'node-subprocess') {
+      return nodeSubprocessFactory.createFromBundle(
+        vatID,
+        managerOptions.bundle,
+        managerOptions,
+        liveSlotsOptions,
+      );
+    }
+
     if (type === 'xsnap') {
       assert(managerOptions.bundle, 'xsnap requires Bundle');
       return xsWorkerFactory.createFromBundle(

package/src/kernel/vat-loader/manager-subprocess-node.js

@@ -0,0 +1,118 @@
+// import { spawn } from 'child_process'; // not from Compartment
+
+import { assert, Fail } from '@agoric/assert';
+import { E } from '@endo/eventual-send';
+import { makePromiseKit } from '@endo/promise-kit';
+import { makeManagerKit } from './manager-helper.js';
+
+// start a "Worker" (Node's tool for starting new threads) and load a bundle
+// into it
+
+// eslint-disable-next-line no-unused-vars
+function parentLog(first, ...args) {
+  // console.error(`--parent: ${first}`, ...args);
+}
+
+export function makeNodeSubprocessFactory(tools) {
+  const { startSubprocessWorker, testLog } = tools;
+
+  function createFromBundle(vatID, bundle, managerOptions, liveSlotsOptions) {
+    assert(!managerOptions.enableSetup, 'not supported at all');
+    assert(
+      managerOptions.useTranscript,
+      'node-subprocess: useTranscript=false not supported',
+    );
+    const { name, workerOptions } = managerOptions;
+    const { nodeOptions } = workerOptions;
+
+    !nodeOptions ||
+      Array.isArray(nodeOptions) ||
+      Fail`nodeOptions must be an array`;
+
+    // Node worker subprocess adds `nameDisplayArg` as a dummy argument so that
+    // 'ps'shows which worker is for which vat
+    const nameDisplayArg = `${vatID}:${name !== undefined ? name : ''}`;
+
+    const mk = makeManagerKit();
+
+    // start the worker and establish a connection
+    const { fromChild, toChild, terminate, done } = startSubprocessWorker(
+      nameDisplayArg,
+      nodeOptions,
+    );
+
+    function sendToWorker(msg) {
+      assert(Array.isArray(msg));
+      toChild.write(msg);
+    }
+
+    // TODO: make the worker responsible for checking themselves: we send
+    // both the delivery and the expected syscalls, and the supervisor
+    // compares what the bundle does with what it was told to expect.
+    // Modulo flow control, we just stream transcript entries at the
+    // worker and eventually get back an "ok" or an error. When we do
+    // that, doSyscall won't even see replayed syscalls from the worker.
+
+    const { promise: dispatchReadyP, resolve: dispatchIsReady } =
+      makePromiseKit();
+    let waiting;
+
+    /**
+     * @param {import('@agoric/swingset-liveslots').VatDeliveryObject} delivery
+     * @returns {Promise<import('@agoric/swingset-liveslots').VatDeliveryResult>}
+     */
+    function deliverToWorker(delivery) {
+      parentLog(`sending delivery`, delivery);
+      !waiting || Fail`already waiting for delivery`;
+      const pr = makePromiseKit();
+      waiting = pr.resolve;
+      sendToWorker(['deliver', delivery]);
+      return pr.promise;
+    }
+    mk.setDeliverToWorker(deliverToWorker);
+
+    function handleUpstream([type, ...args]) {
+      parentLog(`received`, type);
+      if (type === 'setUplinkAck') {
+        parentLog(`upload ready`);
+      } else if (type === 'gotBundle') {
+        parentLog(`bundle loaded`);
+      } else if (type === 'dispatchReady') {
+        parentLog(`dispatch() ready`);
+        // wait10ms().then(dispatchIsReady); // stall to let logs get printed
+        dispatchIsReady(undefined);
+      } else if (type === 'syscall') {
+        parentLog(`syscall`, args);
+        const [vatSyscallObject] = args;
+        const vsr = mk.syscallFromWorker(vatSyscallObject);
+        sendToWorker(vsr);
+      } else if (type === 'testLog') {
+        testLog(...args);
+      } else if (type === 'deliverDone') {
+        parentLog(`deliverDone`);
+        if (waiting) {
+          const resolve = waiting;
+          waiting = null;
+          const [vatDeliveryResults] = args;
+          resolve(vatDeliveryResults);
+        }
+      } else {
+        parentLog(`unrecognized uplink message ${type}`);
+      }
+    }
+
+    fromChild.on('data', handleUpstream);
+
+    parentLog(`instructing worker to load bundle..`);
+    sendToWorker(['setBundle', vatID, bundle, liveSlotsOptions]);
+
+    function shutdown() {
+      terminate();
+      return E.when(done, _ => undefined);
+    }
+    const manager = mk.getManager(shutdown);
+    return dispatchReadyP.then(() => manager);
+  }
+
+  return harden({ createFromBundle });
+}

package/src/kernel/vat-loader/manager-subprocess-xsnap.js

@@ -132,16 +132,16 @@ export function makeXsSubprocessFactory({
       kernelSlog.write({ type: 'heap-snapshot-load', vatID, ...snapshotInfo });
     }
 
-    // `startXSnap` adds `argName` as a dummy argument so that 'ps'
+    // `startXSnap` adds `nameDisplayArg` as a dummy argument so that 'ps'
     // shows which worker is for which vat, but is careful to prevent
     // a shell-escape attack
-    const argName = `${vatID}:${vatName !== undefined ? vatName : ''}`;
+    const nameDisplayArg = `${vatID}:${vatName !== undefined ? vatName : ''}`;
 
     /** @type {ReturnType<typeof makeRevokableHandleCommandKit> | undefined} */
     let handleCommandKit = makeRevokableHandleCommandKit(handleUpstream);
 
     // start the worker and establish a connection
-    let worker = await startXSnap(argName, {
+    let worker = await startXSnap(nameDisplayArg, {
       bundleIDs,
       handleCommand: handleCommandKit.handleCommand,
       metered,
@@ -256,7 +256,7 @@ export function makeXsSubprocessFactory({
       let snapshotResults;
       const closeP = worker.close();
       [worker, snapshotResults] = await Promise.all([
-        startXSnap(argName, {
+        startXSnap(nameDisplayArg, {
           bundleIDs,
           handleCommand: handleCommandKit.handleCommand,
           metered,

package/src/lib/recordVatOptions.js

@@ -14,13 +14,18 @@ export const makeVatOptionRecorder = (kernelKeeper, bundleHandler) => {
       critical = false,
       meterID = undefined,
       managerType = kernelKeeper.getDefaultManagerType(),
+      nodeOptions = undefined,
       ...leftover
     } = options;
     const unused = Object.keys(leftover);
     if (unused.length) {
       Fail`OptionRecorder: ${vatID} unused options ${unused.join(',')}`;
     }
-    const workerOptions = await makeWorkerOptions(managerType, bundleHandler);
+    const workerOptions = await makeWorkerOptions(
+      managerType,
+      bundleHandler,
+      nodeOptions,
+    );
     /** @type { import('../types-internal.js').RecordedVatOptions } */
     const vatOptions = harden({
       workerOptions,

package/src/lib/workerOptions.js

@@ -1,17 +1,29 @@
+import { Fail } from '@agoric/assert';
+
 /**
  * @param {string} managerType
  * @param {import("../controller/bundle-handler").BundleHandler} bundleHandler
+ * @param {string[]} [nodeOptions]
  * @returns {Promise<import("../types-internal").WorkerOptions>}
  */
-export async function makeWorkerOptions(managerType, bundleHandler) {
+export async function makeWorkerOptions(
+  managerType,
+  bundleHandler,
+  nodeOptions,
+) {
   await null;
+  if (nodeOptions && managerType !== 'node-subprocess') {
+    Fail`nodeOptions requires managerType 'node-subprocess'`;
+  }
   if (managerType === 'local') {
     return harden({ type: 'local' });
   } else if (managerType === 'xsnap' || managerType === 'xs-worker') {
     const bundleIDs = await bundleHandler.getCurrentBundleIDs();
     return harden({ type: 'xsnap', bundleIDs });
+  } else if (managerType === 'node-subprocess') {
+    return harden({ type: 'node-subprocess', nodeOptions });
   }
-  throw Error(`unknown managerType '${managerType}'`);
+  throw Fail`unknown managerType '${managerType}'`;
 }
 
 /**
@@ -27,9 +39,11 @@ export async function updateWorkerOptions(
   await null;
   if (type === 'local') {
     return origWorkerOptions;
+  } else if (type === 'node-subprocess') {
+    return origWorkerOptions;
   } else if (type === 'xsnap') {
     const bundleIDs = await bundleHandler.getCurrentBundleIDs();
     return harden({ ...origWorkerOptions, bundleIDs });
   }
-  throw Error(`unknown worker type '${type}'`);
+  throw Fail`unknown worker type '${type}'`;
 }

package/src/lib-nodejs/spawnSubprocessWorker.js

@@ -0,0 +1,87 @@
+// this file is loaded by the controller, in the start compartment
+import { spawn } from 'child_process';
+import { makePromiseKit } from '@endo/promise-kit';
+import { NonNullish } from '@agoric/assert';
+import { arrayEncoderStream, arrayDecoderStream } from './worker-protocol.js';
+import {
+  netstringEncoderStream,
+  netstringDecoderStream,
+} from '../lib/netstring.js';
+
+// Start a subprocess from a given executable, and arrange a bidirectional
+// message channel with a "supervisor" within that process. Return a {
+// toChild, fromChild } pair of Streams which accept/emit hardened Arrays of
+// JSON-serializable data.
+
+// eslint-disable-next-line no-unused-vars
+function parentLog(first, ...args) {
+  // console.error(`--parent: ${first}`, ...args);
+}
+
+/** @typedef { import('child_process').IOType } IOType */
+/** @typedef { import('stream').Writable } Writable */
+
+// we send on fd3, and receive on fd4. We pass fd1/2 (stdout/err) through, so
+// console log/err from the child shows up normally. We don't use Node's
+// built-in serialization feature ('ipc') because the child process won't
+// always be Node.
+/** @type { IOType[] } */
+const stdio = harden(['inherit', 'inherit', 'inherit', 'pipe', 'pipe']);
+
+export function startSubprocessWorker(
+  execPath,
+  procArgs = [],
+  { netstringMaxChunkSize = undefined } = {},
+) {
+  const proc = spawn(execPath, procArgs, { stdio });
+
+  const toChild = arrayEncoderStream();
+  toChild
+    .pipe(netstringEncoderStream())
+    .pipe(/** @type {Writable} */ (proc.stdio[3]));
+  // proc.stdio[4].setEncoding('utf-8');
+  const fromChild = NonNullish(proc.stdio[4])
+    .pipe(netstringDecoderStream(netstringMaxChunkSize))
+    .pipe(arrayDecoderStream());
+
+  // fromChild.addListener('data', data => parentLog(`fd4 data`, data));
+  // toChild.write('hello child');
+
+  const pk = makePromiseKit();
+
+  proc.once('exit', code => {
+    parentLog('child exit', code);
+    pk.resolve(code);
+  });
+  proc.once('error', e => {
+    parentLog('child error', e);
+    pk.reject(e);
+  });
+  parentLog(`waiting on child`);
+
+  function terminate() {
+    proc.kill();
+  }
+
+  // the Transform objects don't like being hardened, so we wrap the methods
+  // that get used
+  /* @type {typeof fromChild} */
+  const wrappedFromChild = {
+    on: (...args) =>
+      fromChild.on(.../** @type {Parameters<typeof fromChild['on']>} */ (args)),
+  };
+  /* @type {typeof toChild} */
+  const wrappedToChild = {
+    write: (...args) =>
+      toChild.write(
+        .../** @type {Parameters<typeof toChild['write']>} */ (args),
+      ),
+  };
+
+  return harden({
+    fromChild: wrappedFromChild,
+    toChild: wrappedToChild,
+    terminate,
+    done: pk.promise,
+  });
+}

package/src/supervisors/subprocess-node/supervisor-subprocess-node.js

@@ -0,0 +1,204 @@
+/* global WeakRef, FinalizationRegistry */
+
+// this file is loaded at the start of a new subprocess
+import '@endo/init';
+
+import anylogger from 'anylogger';
+import fs from 'fs';
+import { Buffer } from 'buffer';
+
+import { assert, details as X, Fail } from '@agoric/assert';
+import { importBundle } from '@endo/import-bundle';
+import { makeMarshal } from '@endo/marshal';
+import {
+  makeLiveSlots,
+  insistVatDeliveryObject,
+  insistVatSyscallResult,
+} from '@agoric/swingset-liveslots';
+import engineGC from '../../lib-nodejs/engine-gc.js';
+import { makeGcAndFinalize } from '../../lib-nodejs/gc-and-finalize.js';
+import { makeDummyMeterControl } from '../../kernel/dummyMeterControl.js';
+import { encode, decode } from '../../lib/netstring.js';
+import { waitUntilQuiescent } from '../../lib-nodejs/waitUntilQuiescent.js';
+import {
+  makeSupervisorDispatch,
+  makeSupervisorSyscall,
+  makeVatConsole,
+} from '../supervisor-helper.js';
+
+// eslint-disable-next-line no-unused-vars
+function workerLog(first, ...args) {
+  // console.error(`---worker: ${first}`, ...args);
+}
+
+workerLog(`supervisor started`);
+
+function makeNetstringReader({ fd, encoding }) {
+  const input = Buffer.alloc(32 * 1024);
+  let buffered = Buffer.alloc(0);
+  let decoded = [];
+
+  const readMore = () => {
+    assert(!decoded.length);
+    // we could be smarter about read lengths (parse the the netstring
+    // header and do a blocking read of the entire payload), but the
+    // efficiency gain is not huge
+    const bytesRead = fs.readSync(fd, input); // blocking read
+    if (!bytesRead) {
+      throw Error('read pipe closed');
+    }
+    const more = input.subarray(0, bytesRead);
+    buffered = Buffer.concat([buffered, more]);
+    const { leftover, payloads } = decode(buffered);
+    buffered = leftover;
+    decoded = payloads;
+  };
+
+  return harden({
+    read: () => {
+      for (;;) {
+        if (decoded.length) {
+          const ns = decoded.shift();
+          return JSON.parse(ns.toString(encoding));
+        }
+        readMore(); // blocks
+      }
+    },
+  });
+}
+
+let dispatch;
+
+function writeToParent(command) {
+  let buf = encode(Buffer.from(JSON.stringify(command)));
+  while (buf.length) {
+    const bytesWritten = fs.writeSync(4, buf);
+    if (!bytesWritten) {
+      throw Error('write pipe closed');
+    }
+    buf = buf.subarray(bytesWritten);
+  }
+}
+const toParent = { write: writeToParent };
+const fromParent = makeNetstringReader({ fd: 3, encoding: 'utf-8' });
+
+function sendUplink(msg) {
+  msg instanceof Array || Fail`msg must be an Array`;
+  toParent.write(msg);
+}
+
+function handleStart(_margs) {
+  // TODO: parent should send ['start', vatID]
+  workerLog(`got start`);
+  sendUplink(['gotStart']);
+}
+
+function handleSetBundle(margs) {
+  const [vatID, bundle, liveSlotsOptions] = margs;
+
+  function testLog(...args) {
+    sendUplink(['testLog', ...args]);
+  }
+
+  // syscallToManager can throw or return OK/ERR
+  function syscallToManager(vatSyscallObject) {
+    sendUplink(['syscall', vatSyscallObject]);
+    const result = fromParent.read();
+    workerLog(' ... syscall result:', result);
+    insistVatSyscallResult(result);
+    return result;
+  }
+  // this 'syscall' throws or returns data
+  const syscall = makeSupervisorSyscall(syscallToManager);
+  const vatPowers = {
+    makeMarshal,
+    testLog,
+  };
+
+  const gcTools = harden({
+    WeakRef,
+    FinalizationRegistry,
+    waitUntilQuiescent,
+    gcAndFinalize: makeGcAndFinalize(engineGC),
+    meterControl: makeDummyMeterControl(),
+  });
+
+  const makeLogMaker = tag => {
+    const logger = anylogger(tag);
+    const makeLog = level => {
+      const log = logger[level];
+      assert.typeof(log, 'function', X`logger[${level}] must be a function`);
+      return (...args) => {
+        log(...args);
+      };
+    };
+    return makeLog;
+  };
+
+  // Enable or disable the console accordingly.
+  const workerEndowments = {
+    console: makeVatConsole(makeLogMaker(`SwingSet:vat:${vatID}`)),
+    assert,
+  };
+
+  async function buildVatNamespace(lsEndowments, inescapableGlobalProperties) {
+    const vatNS = await importBundle(bundle, {
+      endowments: { ...workerEndowments, ...lsEndowments },
+      inescapableGlobalProperties,
+    });
+    workerLog(`got vatNS:`, Object.keys(vatNS).join(','));
+    return vatNS;
+  }
+
+  const ls = makeLiveSlots(
+    syscall,
+    vatID,
+    vatPowers,
+    liveSlotsOptions,
+    gcTools,
+    makeVatConsole(makeLogMaker(`SwingSet:ls:${vatID}`)),
+    buildVatNamespace,
+  );
+
+  sendUplink(['gotBundle']);
+  assert(ls.dispatch);
+  dispatch = makeSupervisorDispatch(ls.dispatch);
+  workerLog(`created dispatch()`);
+  sendUplink(['dispatchReady']);
+}
+
+async function handleDeliver(margs) {
+  if (!dispatch) {
+    throw Error(`error: deliver before dispatchReady`);
+  }
+  const [vatDeliveryObject] = margs;
+  harden(vatDeliveryObject);
+  insistVatDeliveryObject(vatDeliveryObject);
+  const vatDeliveryResults = await dispatch(vatDeliveryObject);
+  sendUplink(['deliverDone', vatDeliveryResults]);
+}
+
+async function handleCommand(command) {
+  const [type, ...margs] = command;
+  workerLog(`received`, type);
+  switch (type) {
+    case 'start':
+      return handleStart(margs);
+    case 'setBundle':
+      return handleSetBundle(margs);
+    case 'deliver':
+      return handleDeliver(margs);
+    default:
+      throw Error(`unrecognized downlink message ${type}`);
+  }
+}
+
+async function loop() {
+  await 47; // I can wait for anything, so I choose 47.  It's the most ideal number.
+  for (;;) {
+    const command = fromParent.read();
+    await handleCommand(command);
+  }
+}
+
+loop().catch(err => console.log(`error in loop`, err));

package/src/typeGuards.js

@@ -1,12 +1,17 @@
 // @jessie-check
 import { M } from '@agoric/store';
 
-export const ManagerType = M.or('xsnap', 'xs-worker', 'local');
+export const ManagerType = M.or(
+  'xsnap',
+  'xs-worker',
+  'node-subprocess',
+  'local',
+);
 
 const Bundle = M.splitRecord({ moduleType: M.string() });
 
 const SwingsetConfigOptions = harden({
-  creationOptions: M.splitRecord({}, { critial: M.boolean() }),
+  creationOptions: M.splitRecord({}, { critical: M.boolean() }),
   parameters: M.recordOf(M.string(), M.any()),
 });
 

package/src/types-external.js

@@ -17,7 +17,7 @@ export {};
  * @typedef { { moduleFormat: 'nestedEvaluate', source: string, sourceMap?: string } } NestedEvaluateBundle
  * @typedef { EndoZipBase64Bundle | GetExportBundle | NestedEvaluateBundle } Bundle
  *
- * @typedef { 'local' | 'xsnap' | 'xs-worker' } ManagerType
+ * @typedef { 'local' | 'node-subprocess' | 'xsnap' | 'xs-worker' } ManagerType
  */
 
 /**
@@ -308,7 +308,8 @@ export {};
  * config.vats[name].creationOptions: StaticVatOptions
  *
  * @typedef { { enableDisavow?: boolean } } OptEnableDisavow
- * @typedef { BaseVatOptions & OptManagerType & OptEnableDisavow } StaticVatOptions
+ * @typedef { { nodeOptions?: string[] } } OptNodeOptions
+ * @typedef { BaseVatOptions & OptManagerType & OptEnableDisavow & OptNodeOptions } StaticVatOptions
  *
  * @typedef { { vatParameters?: object, upgradeMessage?: string } } VatUpgradeOptions
  * @typedef { { incarnationNumber: number } } VatUpgradeResults

package/src/types-internal.js

@@ -1,15 +1,16 @@
 export {};
 
 /**
- * The internal data that controls which worker we use (and how we use
- * it) is stored in a WorkerOptions record, which comes in "local" and
- * "xsnap" flavors.
+ * The internal data that controls which worker we use (and how we use it) is
+ * stored in a WorkerOptions record, which comes in "local", "node-subprocess",
+ * and "xsnap" flavors.
  *
  * @typedef { { type: 'local' } } LocalWorkerOptions
  * @typedef { { type: 'xsnap', bundleIDs: BundleID[] } } XSnapWorkerOptions
+ * @typedef { { type: 'node-subprocess', nodeOptions?: string[] } } NodeSubprocessWorkerOptions
  *  bundleIDs indicate the SES lockdown and supervisor/liveslots bundles to
  *  evaluate into a new xsnap worker
- * @typedef { LocalWorkerOptions | XSnapWorkerOptions } WorkerOptions
+ * @typedef { LocalWorkerOptions | XSnapWorkerOptions | NodeSubprocessWorkerOptions } WorkerOptions
  *
  * @typedef { string } VatID
  * @typedef { string } MeterID

package/src/vats/vat-admin/vat-vat-admin.js

@@ -19,7 +19,7 @@ import {
 
 const { quote: q, Fail } = assert;
 
-const managerTypes = ['local', 'xsnap', 'xs-worker']; // xs-worker is alias
+const managerTypes = ['local', 'node-subprocess', 'xsnap', 'xs-worker']; // xs-worker is alias
 
 function producePRR() {
   const { promise, resolve, reject } = makePromiseKit();
@@ -339,6 +339,7 @@ export function buildRootObject(vatPowers, _vatParameters, baggage) {
       name,
       meter, // stripped out and converted
       managerType, // TODO: not sure we want vats to be able to control this
+      nodeOptions, // TODO: ditto
       vatParameters, // stripped out and re-added
       enableSetup,
       enablePipelining,
@@ -367,6 +368,9 @@ export function buildRootObject(vatPowers, _vatParameters, baggage) {
       managerTypes.includes(managerType) ||
         Fail`CreateVatOptions: bad managerType ${managerType}`;
     }
+    if (managerType !== 'node-subprocess' && nodeOptions) {
+      Fail`CreateVatOptions: nodeOptions requires managerType='node-subprocess'`;
+    }
     assertType('enableSetup', enableSetup, 'boolean');
     assertType('enablePipelining', enablePipelining, 'boolean');
     assertType('useTranscript', useTranscript, 'boolean');