@agoric/async-flow 0.1.1-upgrade-17-dev-ec448b0.0 → 0.1.1-upgrade-18-dev-ef001c0.0

package/src/types.ts

@@ -0,0 +1,213 @@
+/* eslint-disable no-use-before-define */
+import type { Passable } from '@endo/pass-style';
+import type { Vow, VowTools } from '@agoric/vow';
+import type { LogStore } from './log-store.js';
+import type { Bijection } from './bijection.js';
+import type { EndowmentTools } from './endowments.js';
+
+export type FlowState =
+  | 'Running'
+  | 'Sleeping'
+  | 'Replaying'
+  | 'Failed'
+  | 'Done';
+
+/**
+ * `T` defaults to `any`, not `Passable`, because unwrapped guests include
+ * non-passables, like unwrapped functions and unwrapped state records.
+ * (Unwrapped functions could be made into Remotables,
+ * but since they still could not be made durable, in this context
+ * it'd be pointless.)
+ */
+export type Guest<T extends unknown = any> = T;
+export type Host<T extends Passable = Passable> = T;
+
+/**
+ * A HostVow must be durably storable. It corresponds to an
+ * ephemeral guest promise.
+ */
+export type HostVow<T extends Passable = Passable> = Host<Vow<T>>;
+
+export type GuestAsyncFunc = (
+  ...activationArgs: Guest[]
+) => Guest<Promise<any>>;
+
+export type HostAsyncFuncWrapper = (
+  ...activationArgs: Host<any>[]
+) => HostVow<any>;
+
+/**
+ * The function from the host as it will be available in the guest.
+ *
+ * Specifically, Vow return values are converted to Promises.
+ */
+export type GuestOf<F extends HostAsyncFuncWrapper> = F extends (
+  ...args: infer A
+) => Vow<infer R>
+  ? (...args: A) => Promise<R>
+  : F;
+
+// from https://github.com/sindresorhus/type-fest/blob/main/source/simplify.d.ts
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+/**
+ * Convert an entire Guest interface into what the host will implement.
+ */
+export type HostInterface<T> = {
+  [K in keyof T]: T[K] extends CallableFunction
+    ? HostOf<T[K]>
+    : T[K] extends Record<string, any>
+      ? Simplify<HostInterface<T[K]>>
+      : T[K];
+};
+
+/**
+ * Convert an entire Host interface into what the Guest will receive.
+ */
+export type GuestInterface<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => Vow<infer R>
+    ? (...args: Parameters<T[K]>) => Promise<R>
+    : T[K] extends HostAsyncFuncWrapper
+      ? GuestOf<T[K]>
+      : T[K] extends (...args: any[]) => infer R
+        ? T[K]
+        : T[K] extends object
+          ? GuestInterface<T[K]>
+          : T[K];
+};
+
+/**
+ * The function the host must provide to match an interface the guest expects.
+ *
+ * Specifically, Promise return values are converted to Vows.
+ */
+export type HostOf<F extends CallableFunction> = F extends (
+  ...args: infer A
+) => infer R
+  ? R extends Promise<infer T>
+    ? (...args: A) => Vow<T extends Passable ? T : HostInterface<T>>
+    : (...args: A) => HostInterface<R>
+  : F;
+
+export type HostArgs<GA extends any[]> = { [K in keyof GA]: HostOf<GA[K]> };
+
+export type PreparationOptions = {
+  vowTools?: VowTools;
+  makeLogStore?: (() => LogStore) | undefined;
+  makeBijection?: (() => Bijection) | undefined;
+  endowmentTools?: EndowmentTools;
+  panicHandler?: (e: any) => void;
+};
+export type OutcomeKind = 'return' | 'throw';
+
+export type Outcome =
+  | {
+      kind: 'return';
+      result: any;
+    }
+  | {
+      kind: 'throw';
+      problem: any;
+    };
+
+export type Ephemera<S extends WeakKey = WeakKey, V extends unknown = any> = {
+  for: (self: S) => V;
+  resetFor: (self: S) => void;
+};
+
+/**
+ * This is the type alias for the membrane log entries we currently implement.
+ *
+ * @see {FutureLogEntry} below for the full membrane log entry, which we do not
+ * yet support.
+ */
+export type LogEntry =
+  | [op: 'startGeneration', generation: number]
+  // ///////////////// 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,
+    ]
+  | [
+      op: 'checkSendOnly',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ]
+  | [
+      op: 'checkSend',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ];
+
+/**
+ * This would be the type alias 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 the host
+ *   vows and remotables.
+ */
+export type FutureLogEntry =
+  | [op: 'startGeneration', generation: number]
+  // ///////////////// 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: 'doSendOnly',
+      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: 'checkSendOnly',
+      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];

package/test/_utils.js

@@ -0,0 +1,22 @@
+import { prepareAsyncFlowTools } from '../src/async-flow.js';
+
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {PreparationOptions} from '../src/types.js';
+ */
+
+/**
+ * @param {*} t
+ * @param {Zone} zone
+ * @param {PreparationOptions} [opts]
+ */
+export const prepareTestAsyncFlowTools = (t, zone, opts) => {
+  const {
+    panicHandler = e => {
+      t.log('Panic handler called', e);
+      t.fail('Unexpected panic');
+    },
+  } = opts || {};
+  return prepareAsyncFlowTools(zone, { panicHandler, ...opts });
+};
+harden(prepareTestAsyncFlowTools);

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

@@ -14,12 +14,10 @@ import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
 import { prepareVowTools } from '@agoric/vow';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 
-import { prepareAsyncFlowTools } from '../src/async-flow.js';
+import { prepareTestAsyncFlowTools } from './_utils.js';
 
 /**
- * @import {PromiseKit} from '@endo/promise-kit'
  * @import {Zone} from '@agoric/base-zone'
- * @import {Ephemera} from './types.js';
  */
 
 const neverSettlesP = new Promise(() => {});
@@ -30,7 +28,7 @@ const neverSettlesP = new Promise(() => {});
  */
 const testPlay1 = async (t, zone) => {
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
 
@@ -48,7 +46,7 @@ const testPlay1 = async (t, zone) => {
  */
 const testPlay2 = async (t, zone) => {
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
 
@@ -63,7 +61,7 @@ const testPlay2 = async (t, zone) => {
  */
 const testPlay3 = async (t, zone) => {
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, allWokenP } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, allWokenP } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
 

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

@@ -15,7 +15,7 @@ import { isVow } from '@agoric/vow/src/vow-utils.js';
 import { prepareVowTools } from '@agoric/vow';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 
-import { prepareAsyncFlowTools } from '../src/async-flow.js';
+import { prepareTestAsyncFlowTools } from './_utils.js';
 
 /**
  * @import {Zone} from '@agoric/base-zone';
@@ -59,7 +59,7 @@ const firstLogLen = 7;
 const testFirstPlay = async (t, zone) => {
   t.log('firstPlay started');
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, adminAsyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
   const makeOrchestra = prepareOrchestra(zone);
@@ -134,12 +134,24 @@ const testFirstPlay = async (t, zone) => {
  *
  * @param {any} t
  * @param {Zone} zone
+ * @param {unknown} [rejection]
  */
-const testBadShortReplay = async (t, zone) => {
+const testBadShortReplay = async (t, zone, rejection) => {
   t.log('badShortReplay started');
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, adminAsyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
+    panicHandler: e => {
+      t.throws(
+        () => {
+          throw e;
+        },
+        {
+          message:
+            /^guest (fulfilled with "bad"|rejected with "\[Error: replayProblem\]") before finishing replay$/,
+        },
+      );
+    },
   });
   prepareOrchestra(zone);
   const { when } = vowTools;
@@ -149,8 +161,12 @@ const testBadShortReplay = async (t, zone) => {
 
   const { guestMethod } = {
     async guestMethod(_gOrch7, _g1, _p3) {
-      t.log('  badReplay return early');
-      resolveStep(true);
+      resolveStep(eventLoopIteration()); // resolveStep(true) is too fast.
+      if (rejection) {
+        t.log('  badShortReplay rejecting');
+        throw rejection;
+      }
+      t.log('  badShortReplay return early');
       return 'bad';
     },
   };
@@ -174,7 +190,7 @@ const testBadShortReplay = async (t, zone) => {
   await promiseStep;
 
   const replayProblem = flow.getOptFatalProblem();
-  t.log('  badShortReplay failures', replayProblem);
+  t.log('  badShortReplay replayProblem', replayProblem);
   t.true(replayProblem instanceof Error);
 
   const outcome = when(outcomeV);
@@ -190,7 +206,7 @@ const testBadShortReplay = async (t, zone) => {
   t.log('badShortReplay done');
 };
 
-test.serial.failing('test durable async-flow early completion', async t => {
+test.serial('test durable async-flow early completion', async t => {
   annihilate();
   const zone1 = makeDurableZone(getBaggage(), 'durableRoot');
   await testFirstPlay(t, zone1);
@@ -200,4 +216,8 @@ test.serial.failing('test durable async-flow early completion', async t => {
   nextLife();
   const zone2a = makeDurableZone(getBaggage(), 'durableRoot');
   await testBadShortReplay(t, zone2a);
+
+  nextLife();
+  const zone2b = makeDurableZone(getBaggage(), 'durableRoot');
+  await testBadShortReplay(t, zone2b, Error('replayProblem'));
 });

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

@@ -7,12 +7,10 @@ import { makeHeapZone } from '@agoric/zone/heap.js';
 import { makeVirtualZone } from '@agoric/zone/virtual.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 
-import { prepareAsyncFlowTools } from '../src/async-flow.js';
+import { prepareTestAsyncFlowTools } from './_utils.js';
 
 /**
  * @import {Zone} from '@agoric/base-zone';
- * @import {Vow, VowTools} from '@agoric/vow'
- * @import {AsyncFlow} from '../src/async-flow.js'
  */
 
 const { apply } = Reflect;
@@ -23,7 +21,7 @@ const { apply } = Reflect;
  */
 const testPlay = async (t, zone) => {
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
 

package/test/async-flow.test.js

@@ -17,7 +17,7 @@ import { makeHeapZone } from '@agoric/zone/heap.js';
 import { makeVirtualZone } from '@agoric/zone/virtual.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 
-import { prepareAsyncFlowTools } from '../src/async-flow.js';
+import { prepareTestAsyncFlowTools } from './_utils.js';
 
 /**
  * @import {AsyncFlow} from '../src/async-flow.js'
@@ -62,7 +62,7 @@ const firstLogLen = 7;
 const testFirstPlay = async (t, zone) => {
   t.log('firstPlay started');
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, adminAsyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
   const makeOrchestra = prepareOrchestra(zone);
@@ -139,8 +139,16 @@ const testFirstPlay = async (t, zone) => {
 const testBadReplay = async (t, zone) => {
   t.log('badReplay started');
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, adminAsyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
+    panicHandler: e => {
+      t.throws(
+        () => {
+          throw e;
+        },
+        { message: /^replay 3:/ },
+      );
+    },
   });
   prepareOrchestra(zone);
   const { when } = vowTools;
@@ -206,7 +214,7 @@ const testBadReplay = async (t, zone) => {
 const testGoodReplay = async (t, zone) => {
   t.log('goodReplay started');
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, adminAsyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
   prepareOrchestra(zone, 2); // Note change in new behavior
@@ -310,7 +318,7 @@ const testGoodReplay = async (t, zone) => {
 const testAfterPlay = async (t, zone) => {
   t.log('testAfterPlay started');
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, adminAsyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
   prepareOrchestra(zone);

package/test/bad-host.test.js

@@ -15,7 +15,7 @@ import { makeHeapZone } from '@agoric/zone/heap.js';
 import { makeVirtualZone } from '@agoric/zone/virtual.js';
 import { makeDurableZone } from '@agoric/zone/durable.js';
 
-import { prepareAsyncFlowTools } from '../src/async-flow.js';
+import { prepareTestAsyncFlowTools } from './_utils.js';
 
 /**
  * @import {PromiseKit} from '@endo/promise-kit'
@@ -51,8 +51,16 @@ const prepareBadHost = zone =>
 const testBadHostFirstPlay = async (t, zone) => {
   t.log('badHost firstPlay started');
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, adminAsyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
+    panicHandler: e => {
+      t.throws(
+        () => {
+          throw e;
+        },
+        { message: '[3]: [0]: cannot yet send guest promises "[Promise]"' },
+      );
+    },
   });
   const makeBadHost = prepareBadHost(zone);
   const { makeVowKit } = vowTools;
@@ -103,6 +111,8 @@ const testBadHostFirstPlay = async (t, zone) => {
     // Notice that the bad call was not recorded in the log
   ]);
   t.log('badHost firstPlay done');
+  // Allow panicHandler to be called.
+  await eventLoopIteration();
 };
 
 /**
@@ -112,7 +122,7 @@ const testBadHostFirstPlay = async (t, zone) => {
 const testBadHostReplay1 = async (t, zone) => {
   t.log('badHost replay1 started');
   const vowTools = prepareVowTools(zone);
-  const { asyncFlow, adminAsyncFlow } = prepareAsyncFlowTools(zone, {
+  const { asyncFlow, adminAsyncFlow } = prepareTestAsyncFlowTools(t, zone, {
     vowTools,
   });
   prepareBadHost(zone);

package/test/endowments.test.js

@@ -16,6 +16,7 @@ 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';
+import { makeEquate } from '../src/equate.js';
 
 const { ownKeys } = Reflect;
 
@@ -84,7 +85,16 @@ const testEndowmentPlay = async (t, zone, gen, isDurable) => {
   t.is(endowment.state[`${gen}_foo`], `${gen} foo`);
   t.is(wrapped.state.get(`${gen}_foo`), `${gen} foo`);
 
-  const makeBijection = prepareBijection(zone, unwrap);
+  const guestWrappers = new Map();
+  const unwrapSpy = (hostWrapped, guestWrapped) => {
+    const unwrapped = unwrap(hostWrapped, guestWrapped);
+    if (unwrapped !== guestWrapped) {
+      guestWrappers.set(hostWrapped, guestWrapped);
+    }
+    return unwrapped;
+  };
+
+  const makeBijection = prepareBijection(zone, unwrapSpy);
   const bij = zone.makeOnce('bij', makeBijection);
 
   const makeGuestForHostRemotable = hRem => {
@@ -114,13 +124,23 @@ const testEndowmentPlay = async (t, zone, gen, isDurable) => {
   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(passStyleOf(unwrapped.function), 'remotable');
   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 equate = makeEquate(bij);
+
+  const { state: _1, ...passableUnwrapped } = unwrapped;
+  const { state: _2, ...passableWrapped } = wrapped;
+
+  t.notThrows(() => equate(harden(passableUnwrapped), harden(passableWrapped)));
+  for (const [hostWrapped, guestWrapped] of guestWrappers) {
+    t.notThrows(() => equate(guestWrapped, hostWrapped));
+  }
 };
 
 const testEndowmentBadReplay = async (_t, _zone, _gen, _isDurable) => {

package/test/equate.test.js

@@ -57,24 +57,24 @@ const testEquate = (t, zone, showOnConsole = false) => {
   bij.unwrapInit(g1, h1);
   t.notThrows(() => equate(g1, h1));
   t.throws(() => equate(g1, h2), {
-    message: 'internal: g->h "[Alleged: g1]" -> "[Vow]" vs "[Alleged: h1]"',
+    message: 'unequal passStyles "remotable" vs "tagged"',
   });
   t.throws(() => equate(g2, h1), {
-    message: 'internal: unexpected h->g "[Alleged: h1]" -> "[Alleged: g1]"',
+    message: 'unequal passStyles "promise" vs "remotable"',
   });
   bij.unwrapInit(g2, h2);
   equate(g2, h2);
 
   t.throws(() => equate(g1, h2), {
-    message: 'internal: g->h "[Alleged: g1]" -> "[Vow]" vs "[Alleged: h1]"',
+    message: 'unequal passStyles "remotable" vs "tagged"',
   });
   t.throws(() => equate(g2, h1), {
-    message: 'internal: g->h "[Promise]" -> "[Alleged: h1]" vs "[Vow]"',
+    message: 'unequal passStyles "promise" vs "remotable"',
   });
 
   equate(harden([g1, g2]), harden([h1, h2]));
   t.throws(() => equate(harden([g1, g2]), harden([h1, h1])), {
-    message: '[1]: internal: g->h "[Promise]" -> "[Alleged: h1]" vs "[Vow]"',
+    message: '[1]: unequal passStyles "promise" vs "remotable"',
   });
 
   const gErr1 = harden(makeError(X`error ${'redacted message'}`, URIError));

package/test/exports.test.js

@@ -0,0 +1,8 @@
+/* eslint-disable import/no-extraneous-dependencies -- requiring the package itself to check exports map */
+import test from 'ava';
+
+import * as index from '@agoric/async-flow';
+
+test('index', t => {
+  t.snapshot(Object.keys(index).sort());
+});

package/test/log-store.test.js

@@ -15,11 +15,9 @@ 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 {Vow} from '@agoric/vow'
  * @import {LogStore} from '../src/log-store.js';
- * @import {Bijection} from '../src/bijection.js';
  */
 
 /**
@@ -36,15 +34,23 @@ const testLogStorePlay = async (t, zone) => {
 
   t.is(log.getIndex(), 0);
   t.is(log.getLength(), 0);
-  t.throws(() => log.pushEntry(['bogus']), {
-    message:
-      /^In "pushEntry" method of \(LogStore\): arg 0: \["bogus"\] - Must match one of/,
-  });
+  t.throws(
+    () =>
+      // @ts-expect-error testing invalid input
+      log.pushEntry(['bogus']),
+    {
+      message:
+        /^In "pushEntry" method of \(LogStore\): arg 0: \["bogus"\] - Must match one of/,
+    },
+  );
   t.false(log.isReplaying());
   t.is(await log.promiseReplayDone(), undefined);
 
-  t.is(log.pushEntry(harden(['doFulfill', v1, 'x'])), 1);
-  t.is(log.pushEntry(harden(['doReject', v2, 'y'])), 2);
+  const gen0Entries = [['startGeneration', 0]];
+  const gen0 = i => gen0Entries.length + i;
+
+  t.is(log.pushEntry(harden(['doFulfill', v1, 'x'])), gen0(1));
+  t.is(log.pushEntry(harden(['doReject', v2, 'y'])), gen0(2));
   t.deepEqual(log.dump(), [
     ['doFulfill', v1, 'x'],
     ['doReject', v2, 'y'],
@@ -56,7 +62,8 @@ const testLogStorePlay = async (t, zone) => {
   t.is(toPassableCap(log.dump()[1][1]), toPassableCap(v2));
 
   t.is(log.getIndex(), 2);
-  t.is(log.getLength(), 2);
+  t.is(log.getUnfilteredIndex(), gen0(2));
+  t.is(log.getLength(), gen0(2));
   t.false(log.isReplaying());
   t.is(await log.promiseReplayDone(), undefined);
 };
@@ -75,14 +82,26 @@ const testLogStoreReplay = async (t, zone) => {
   const v1 = /** @type {Vow} */ (zone.makeOnce('v1', () => Fail`need v1`));
   const v2 = /** @type {Vow} */ (zone.makeOnce('v2', () => Fail`need v2`));
 
+  const gen0Entries = [['startGeneration', 0]];
+  const gen0 = i => gen0Entries.length + i;
+  const gen1Entries = [['startGeneration', 1]];
+  const gen1 = i => gen1Entries.length + i;
+
   t.is(log.getIndex(), 0);
-  t.is(log.getLength(), 2);
+  t.is(log.getUnfilteredIndex(), 0);
+  t.is(log.getLength(), gen0(2));
   t.true(log.isReplaying());
 
   t.deepEqual(log.dump(), [
     ['doFulfill', v1, 'x'],
     ['doReject', v2, 'y'],
   ]);
+
+  t.deepEqual(log.dumpUnfiltered(), [
+    ...gen0Entries,
+    ['doFulfill', v1, 'x'],
+    ['doReject', v2, 'y'],
+  ]);
   // Because t.deepEqual is too tolerant
   // @ts-expect-error data dependent typing
   t.is(toPassableCap(log.dump()[0][1]), toPassableCap(v1));
@@ -92,8 +111,24 @@ const testLogStoreReplay = async (t, zone) => {
   t.deepEqual(log.nextEntry(), ['doFulfill', v1, 'x']);
   t.deepEqual(log.nextEntry(), ['doReject', v2, 'y']);
   t.is(log.getIndex(), 2);
+  t.is(log.getUnfilteredIndex(), gen0(2));
   t.false(log.isReplaying());
   t.is(await log.promiseReplayDone(), undefined);
+
+  t.is(log.pushEntry(harden(['doFulfill', v1, 'x2'])), gen1(gen0(3)));
+  t.deepEqual(log.dumpUnfiltered(), [
+    ...gen0Entries,
+    ['doFulfill', v1, 'x'],
+    ['doReject', v2, 'y'],
+    ...gen1Entries,
+    ['doFulfill', v1, 'x2'],
+  ]);
+
+  // Check that a disposed log starts from scratch, but the same generation.
+  log.dispose();
+  t.deepEqual(log.dumpUnfiltered(), []);
+  t.is(log.pushEntry(harden(['doFulfill', v1, 'x3'])), gen1(1));
+  t.deepEqual(log.dumpUnfiltered(), [...gen1Entries, ['doFulfill', v1, 'x3']]);
 };
 
 await test.serial('test heap log-store', async t => {