@agoric/async-flow 0.1.1-upgrade-16-dev-d45b478.0 → 0.1.1-upgrade-17-dev-3b97a9f.0

package/src/types.js

@@ -1,164 +1 @@
-/**
- * @import {PromiseKit} from '@endo/promise-kit'
- * @import {Passable} from '@endo/pass-style'
- * @import {Zone} from '@agoric/base-zone'
- * @import {Vow, VowTools} from '@agoric/vow'
- * @import {LogStore} from './log-store.js'
- * @import {Bijection} from './bijection.js'
- * @import {ReplayMembrane} from './replay-membrane.js'
- */
-
-/**
- * @typedef {'Running' |
- *           'Sleeping' |
- *           'Replaying' |
- *           'Failed' |
- *           'Done'
- * } FlowState
- */
-
-/**
- * @template {Passable} [T=Passable]
- * @typedef {T} Guest
- */
-
-/**
- * @template {Passable} [T=Passable]
- * @typedef {T} Host
- */
-
-/**
- * A HostVow must be durably storable. It corresponds to an
- * ephemeral guest promise.
- *
- * @template {Passable} [T=Passable]
- * @typedef {Host<Vow<T>>} HostVow
- */
-
-/**
- * @typedef {(...activationArgs: Guest[]) => Guest<Promise>} GuestAsyncFunc
- */
-
-/**
- * @typedef {(...activationArgs: Host[]) => HostVow} HostAsyncFuncWrapper
- */
-
-/**
- * @typedef {object} PreparationOptions
- * @property {VowTools} [vowTools]
- * @property {() => LogStore} [makeLogStore]
- * @property {() => Bijection} [makeBijection]
- */
-
-/**
- * @typedef {'return'|'throw'} OutcomeKind
- */
-
-/**
- * @typedef {{kind: 'return', result: any}
- *         | {kind: 'throw',  problem: any}
- * } Outcome
- */
-
-/**
- * @template {WeakKey} [S=WeakKey]
- * @template {any} [V=any]
- * @typedef {object} Ephemera
- * @property {(self: S) => V} for
- * @property {(self: S) => void} resetFor
- */
-
-/**
- * This is the typedef for the membrane log entries we currently implement.
- * See comment below for the commented-out typedef for the full
- * membrane log entry, which we do not yet support.
- *
- * @typedef {[ // ///////////////// From Host to Guest /////////////////////////
- *     op: 'doFulfill',
- *     vow: HostVow,
- *     fulfillment: Host,
- *   ] | [
- *     op: 'doReject',
- *     vow: HostVow,
- *     reason: Host,
- *   ] | [
- *     op: 'doReturn',
- *     callIndex: number,
- *     result: Host,
- *   ] | [
- *     op: 'doThrow',
- *     callIndex: number,
- *     problem: Host,
- *   ] | [ // ///////////////////// From Guest to Host /////////////////////////
- *     op: 'checkCall',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ]} LogEntry
- */
-
-/**
- * This would be the typedef for the full membrane log, if we supported
- * - the guest sending guest-promises and guest-remotables to the host
- * - the guest using `E` to eventual-send to guest wrappers of host
- *   vows and remotables.
- *
- * at-typedef {[ // ///////////////// From Host to Guest ///////////////////////
- *     op: 'doFulfill',
- *     vow: HostVow,
- *     fulfillment: Host,
- *   ] | [
- *     op: 'doReject',
- *     vow: HostVow,
- *     reason: Host,
- *   ] | [
- *     op: 'doCall',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'doSend',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'doReturn',
- *     callIndex: number,
- *     result: Host,
- *   ] | [
- *     op: 'doThrow',
- *     callIndex: number,
- *     problem: Host,
- *   ] | [ // ///////////////////// From Guest to Host /////////////////////////
- *     op: 'checkFulfill',
- *     vow: HostVow,
- *     fulfillment: Host,
- *   ] | [
- *     op: 'checkReject',
- *     vow: HostVow,
- *     reason: Host,
- *   ] | [
- *     op: 'checkCall',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'checkSend',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'checkReturn',
- *     callIndex: number,
- *     result: Host,
- *   ] | [
- *     op: 'checkThrow',
- *     callIndex: number,
- *     problem: Host,
- *   ]} LogEntry
- */
+export const empty = 'Empty JS file to correspond with its .d.ts twin';

package/test/async-flow-crank.test.js

@@ -16,6 +16,12 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Ephemera} from './types.js';
+ */
+
 const neverSettlesP = new Promise(() => {});
 
 /**

package/test/async-flow-early-completion.test.js

@@ -18,6 +18,8 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
 /**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Vow, VowTools} from '@agoric/vow'
  * @import {AsyncFlow} from '../src/async-flow.js'
  */
 

package/test/async-flow-no-this.js

@@ -9,6 +9,12 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Vow, VowTools} from '@agoric/vow'
+ * @import {AsyncFlow} from '../src/async-flow.js'
+ */
+
 const { apply } = Reflect;
 
 /**

package/test/async-flow.test.js

@@ -21,6 +21,9 @@ import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
 /**
  * @import {AsyncFlow} from '../src/async-flow.js'
+ * @import {Vow, VowTools} from '@agoric/vow'
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
  */
 
 /**
@@ -239,7 +242,7 @@ const testGoodReplay = async (t, zone) => {
       // same question. different answer
       t.is(prod2, 42);
       t.log('about to await p3');
-      await p3;
+      t.is(await p3.catch(r => r), 'done');
       t.log('p3 settled');
     },
   };
@@ -291,7 +294,7 @@ const testGoodReplay = async (t, zone) => {
   ]);
 
   // @ts-expect-error TS doesn't know it is a resolver
-  r3.resolve('done');
+  r3.reject('done');
   await eventLoopIteration();
 
   t.is(await when(outcomeV), undefined);

package/test/bad-host.test.js

@@ -17,6 +17,11 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
 const nonPassableFunc = () => 'non-passable-function';
 harden(nonPassableFunc);
 const guestCreatedPromise = harden(Promise.resolve('guest-created'));

package/test/bijection.test.js

@@ -15,6 +15,12 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareBijection } from '../src/bijection.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Ephemera} from './types.js';
+ */
+
 /**
  * @param {any} t
  * @param {Zone} zone
@@ -45,7 +51,7 @@ const testBijection = (t, zone) => {
   t.false(bij.hasGuest(h1));
   t.false(bij.hasHost(g1));
 
-  bij.init(g1, h1);
+  bij.unwrapInit(g1, h1);
 
   t.true(bij.has(g1, h1));
   t.is(toPassableCap(bij.guestToHost(g1)), toPassableCap(h1));
@@ -55,11 +61,11 @@ const testBijection = (t, zone) => {
   t.false(bij.hasGuest(h1));
   t.false(bij.hasHost(g1));
 
-  t.throws(() => bij.init(g1, h2), {
+  t.throws(() => bij.unwrapInit(g1, h2), {
     message:
       'guestToHost key already bound: "[Alleged: g1]" -> "[Alleged: h1]" vs "[Alleged: h2]"',
   });
-  t.throws(() => bij.init(g2, h1), {
+  t.throws(() => bij.unwrapInit(g2, h1), {
     message:
       'hostToGuest key already bound: "[Alleged: h1]" -> "[Alleged: g1]" vs "[Alleged: g2]"',
   });
@@ -68,11 +74,11 @@ const testBijection = (t, zone) => {
       'internal: g->h "[Alleged: g1]" -> "[Alleged: h2]" vs "[Alleged: h1]"',
   });
   t.false(bij.has(g2, h2));
-  bij.init(g2, h2);
+  bij.unwrapInit(g2, h2);
   t.true(bij.has(g2, h2));
 
   t.false(bij.has(g3, h3));
-  bij.init(g3, h3);
+  bij.unwrapInit(g3, h3);
   t.true(bij.has(g3, h3));
   t.false(bij.has(h3, g3));
 };
@@ -111,7 +117,7 @@ test('test heap bijection reset', t => {
   const g1 = Far('g1', {});
 
   t.false(bij.has(g1, h1));
-  bij.init(g1, h1);
+  bij.unwrapInit(g1, h1);
   t.true(bij.has(g1, h1));
   bij.reset();
   t.false(bij.has(g1, h1));

package/test/convert.test.js

@@ -18,6 +18,11 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 import { makeConvertKit } from '../src/convert.js';
 import { prepareBijection } from '../src/bijection.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
 /**
  * @param {any} t
  * @param {Zone} zone

package/test/endowments.test.js

@@ -0,0 +1,157 @@
+// eslint-disable-next-line import/order
+import {
+  test,
+  getBaggage,
+  annihilate,
+  nextLife,
+} from './prepare-test-env-ava.js';
+
+import { Far, getInterfaceOf, isPassable, passStyleOf } from '@endo/pass-style';
+import { prepareVowTools } from '@agoric/vow';
+import { isVow } from '@agoric/vow/src/vow-utils.js';
+import { makeHeapZone } from '@agoric/zone/heap.js';
+import { makeVirtualZone } from '@agoric/zone/virtual.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+
+import { forwardingMethods, prepareEndowmentTools } from '../src/endowments.js';
+import { makeConvertKit } from '../src/convert.js';
+import { prepareBijection } from '../src/bijection.js';
+
+const { ownKeys } = Reflect;
+
+const testEndowmentPlay = async (t, zone, gen, isDurable) => {
+  const vowTools = prepareVowTools(zone);
+  const { when } = vowTools;
+  const { prepareEndowment, unwrap } = prepareEndowmentTools(zone, {
+    vowTools,
+  });
+
+  const endowment = harden({
+    promise: Promise.resolve(`${gen} promise`),
+    storable: {
+      emptyRecord: {},
+      primitive: 'foo',
+      null: null,
+      undefined,
+      exo: zone.exo('AnExo', undefined, {
+        name() {
+          return `${gen} exo`;
+        },
+      }),
+      error: URIError(`${gen} error`),
+    },
+    far: Far('AFar', {
+      name: () => `${gen} far`,
+    }),
+    function() {
+      return `${gen} function`;
+    },
+    array: [() => `${gen} f1`, () => `${gen} f2`],
+    state: {
+      // So the concrete keys differ by gen
+      get [`${gen}_foo`]() {
+        return `${gen} foo`;
+      },
+      get [`${gen}_bar`]() {
+        return `${gen} bar`;
+      },
+    },
+  });
+
+  const wrapped = prepareEndowment(zone, 't1', endowment);
+
+  t.is(passStyleOf(wrapped), 'copyRecord');
+  t.is(passStyleOf(wrapped.promise), 'tagged');
+  t.true(isVow(wrapped.promise));
+  t.is(endowment.storable, wrapped.storable);
+  t.deepEqual(ownKeys(endowment), ownKeys(wrapped));
+  t.deepEqual(ownKeys(endowment.storable), ownKeys(wrapped.storable));
+  t.is(passStyleOf(wrapped.storable), 'copyRecord');
+  t.is(wrapped.storable.exo.name(), `${gen} exo`);
+  if (isDurable) {
+    t.not(endowment.far, wrapped.far); // since not durably storable
+  } else {
+    t.is(endowment.far, wrapped.far); // storable in heap, virtual
+  }
+  t.is(passStyleOf(wrapped.far), 'remotable');
+  t.is(wrapped.far.name(), `${gen} far`);
+  t.is(passStyleOf(wrapped.function), 'remotable');
+  t.is(wrapped.function.apply([]), `${gen} function`);
+  t.is(passStyleOf(wrapped.array), 'copyArray');
+  t.is(passStyleOf(wrapped.array[0]), 'remotable');
+  t.is(wrapped.array[0].apply([]), `${gen} f1`);
+  t.is(passStyleOf(wrapped.state), 'remotable');
+  t.is(endowment.state[`${gen}_foo`], `${gen} foo`);
+  t.is(wrapped.state.get(`${gen}_foo`), `${gen} foo`);
+
+  const makeBijection = prepareBijection(zone, unwrap);
+  const bij = zone.makeOnce('bij', makeBijection);
+
+  const makeGuestForHostRemotable = hRem => {
+    const iface = getInterfaceOf(hRem);
+    return Far(`${iface} guest wrapper`, forwardingMethods(hRem));
+  };
+
+  const makeGuestForHostVow = hVow => {
+    return when(hVow);
+  };
+
+  const {
+    // guestToHost,
+    hostToGuest,
+  } = makeConvertKit(bij, makeGuestForHostRemotable, makeGuestForHostVow);
+
+  const unwrapped = hostToGuest(wrapped);
+
+  t.false(isPassable(unwrapped));
+  t.is(passStyleOf(unwrapped.promise), 'promise');
+  t.is(await unwrapped.promise, `${gen} promise`);
+  t.not(wrapped.storable, unwrapped.storable);
+  t.is(passStyleOf(unwrapped.storable), 'copyRecord');
+  t.deepEqual(ownKeys(wrapped), ownKeys(unwrapped));
+  t.deepEqual(ownKeys(wrapped.storable), ownKeys(unwrapped.storable));
+  t.not(wrapped.storable.exo, unwrapped.storable.exo);
+  t.is(unwrapped.storable.exo.name(), `${gen} exo`);
+  t.is(passStyleOf(unwrapped.far), 'remotable');
+  t.is(unwrapped.far.name(), `${gen} far`);
+  t.false(isPassable(unwrapped.function));
+  t.is(typeof unwrapped.function, 'function');
+  t.is(unwrapped.function(), `${gen} function`);
+  t.is(unwrapped.array[0](), `${gen} f1`);
+  t.false(isPassable(unwrapped.state));
+  t.is(typeof unwrapped.state, 'object');
+  t.is(unwrapped.state[`${gen}_foo`], `${gen} foo`);
+};
+
+const testEndowmentBadReplay = async (_t, _zone, _gen, _isDurable) => {
+  // FIXME TODO This upgrade should fail since it doesn't re-prepare
+  // everything. Only after that's fixed does it make sense to
+  // expand this to test insufficient re-preparation.
+};
+
+await test.serial('test heap endowments', async t => {
+  const zone = makeHeapZone('heapRoot');
+  return testEndowmentPlay(t, zone, 'first', false);
+});
+
+test.serial('test virtual endowments', async t => {
+  annihilate();
+  const zone = makeVirtualZone('virtualRoot');
+  return testEndowmentPlay(t, zone, 'first', false);
+});
+
+test.serial('test durable endowments', async t => {
+  annihilate();
+
+  nextLife();
+  const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testEndowmentPlay(t, zone1, 'first', true);
+
+  nextLife();
+  const zone2 = makeDurableZone(getBaggage(), 'durableRoot');
+  await testEndowmentBadReplay(t, zone2, '2nd', true);
+
+  nextLife();
+  const zone3 = makeDurableZone(getBaggage(), 'durableRoot');
+  return testEndowmentPlay(t, zone3, '3rd', true);
+});

package/test/equate.test.js

@@ -18,6 +18,10 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 import { prepareBijection } from '../src/bijection.js';
 import { makeEquate } from '../src/equate.js';
 
+/**
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
 /**
  * @param {any} t
  * @param {Zone} zone
@@ -50,7 +54,7 @@ const testEquate = (t, zone, showOnConsole = false) => {
     message:
       'cannot yet send guest remotables to host "[Alleged: g1]" vs "[Alleged: h1]"',
   });
-  bij.init(g1, h1);
+  bij.unwrapInit(g1, h1);
   t.notThrows(() => equate(g1, h1));
   t.throws(() => equate(g1, h2), {
     message: 'internal: g->h "[Alleged: g1]" -> "[Vow]" vs "[Alleged: h1]"',
@@ -58,7 +62,7 @@ const testEquate = (t, zone, showOnConsole = false) => {
   t.throws(() => equate(g2, h1), {
     message: 'internal: unexpected h->g "[Alleged: h1]" -> "[Alleged: g1]"',
   });
-  bij.init(g2, h2);
+  bij.unwrapInit(g2, h2);
   equate(g2, h2);
 
   t.throws(() => equate(g1, h2), {

package/test/log-store.test.js

@@ -14,6 +14,14 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareLogStore } from '../src/log-store.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Vow, VowTools} from '@agoric/vow'
+ * @import {LogStore} from '../src/log-store.js';
+ * @import {Bijection} from '../src/bijection.js';
+ */
+
 /**
  * @param {any} t
  * @param {Zone} zone
@@ -88,7 +96,7 @@ const testLogStoreReplay = async (t, zone) => {
   t.is(await log.promiseReplayDone(), undefined);
 };
 
-await test('test heap log-store', async t => {
+await test.serial('test heap log-store', async t => {
   const zone = makeHeapZone('heapRoot');
   return testLogStorePlay(t, zone);
 });