@agoric/async-flow 0.1.1-upgrade-17-dev-a1453b2.0 → 0.1.1-upgrade-18-dev-d7c994b.0

package/CHANGELOG.md

@@ -1,21 +1 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-### 0.1.1-u17.0 (2024-09-17)
-
-
-### Features
-
-* **async-flow:** asyncFlow ([#9097](https://github.com/Agoric/agoric-sdk/issues/9097)) ([16095c5](https://github.com/Agoric/agoric-sdk/commit/16095c5076043133aff0f25721131be2ca1ef5af)), closes [#9302](https://github.com/Agoric/agoric-sdk/issues/9302) [#9125](https://github.com/Agoric/agoric-sdk/issues/9125) [#9126](https://github.com/Agoric/agoric-sdk/issues/9126) [#9153](https://github.com/Agoric/agoric-sdk/issues/9153) [#9154](https://github.com/Agoric/agoric-sdk/issues/9154) [#9280](https://github.com/Agoric/agoric-sdk/issues/9280) [#9126](https://github.com/Agoric/agoric-sdk/issues/9126)
-* **async-flow:** endowments ([#9566](https://github.com/Agoric/agoric-sdk/issues/9566)) ([4390d8c](https://github.com/Agoric/agoric-sdk/commit/4390d8c21fd8ac80a9c83f55d38c52e3f98faa1e)), closes [Error#1](https://github.com/Agoric/Error/issues/1) [Error#1](https://github.com/Agoric/Error/issues/1)
-* **async-flow:** error on guest E use ([#9443](https://github.com/Agoric/agoric-sdk/issues/9443)) ([e193e66](https://github.com/Agoric/agoric-sdk/commit/e193e66fc578b1c00eda5f5ab6599f1cfbdc542f)), closes [#9299](https://github.com/Agoric/agoric-sdk/issues/9299) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322)
-* **asyncFlow:** Stopgap E support ([#9519](https://github.com/Agoric/agoric-sdk/issues/9519)) ([4adf64f](https://github.com/Agoric/agoric-sdk/commit/4adf64fd53a1a3c68ca52728710830201c9a4418)), closes [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9299](https://github.com/Agoric/agoric-sdk/issues/9299) [#9443](https://github.com/Agoric/agoric-sdk/issues/9443) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9299](https://github.com/Agoric/agoric-sdk/issues/9299) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322) [#9322](https://github.com/Agoric/agoric-sdk/issues/9322)
-* error on membrane promise ([94dfab1](https://github.com/Agoric/agoric-sdk/commit/94dfab1cfd960aada452753b1482ed797bc2da13))
-* **types:** HostOf, GuestOf ([35380af](https://github.com/Agoric/agoric-sdk/commit/35380af4bbda51be2a9cd047f9c4992791090e94))
-* **types:** infer orchestrate() return ([67665a8](https://github.com/Agoric/agoric-sdk/commit/67665a89cb162c350389e52fd812c895d42f37fb))
-
-
-
 # Change Log

package/docs/async-flow-states.md

@@ -10,6 +10,7 @@
 
 - ***Replaying***. To start ***Replaying***, the activation first translates the saved activation arguments from host to guest, invokes the guest function, and starts the membrane replaying from its durable log. The replay is finished when the last log entry has been replayed. Once replaying is finished, the activation has caught up and transitions back to ***Running***.
 
-- ***Failed***. If during the ***Replaying*** state the guest activation fails to exactly reproduce its previously logged behavior, it goes into the inactive ***Failed*** state, with a diagnostic explaining how the replay failed, so it can be repaired by another future upgrade. As of the next reincarnation, the failure status is cleared and it starts ***Replaying*** again, hoping not to fail this time. If replay failed because the guest async function did not reproduce its previous behavior, then the upgrade needs to replace the function with one which does. If the replay failed because of a failure of the `asyncFlow` mechanism, whether a bug or merely hitting a case that is not yet implemented, then the upgrade needs to replace the relevant part of `asyncFlow`'s mechanism.
+- ***Failed***. If the guest activation misbehaves during the ***Replaying*** state (by failing to exactly produce its previously logged behavior) or during the ***Running*** state (by an invalid or unsupported interaction with the `asyncFlow` mechanism), it goes into the inactive ***Failed*** state, with a diagnostic explaining how the replay failed, so it can be repaired by another future upgrade. As of the next reincarnation, the failure status is cleared and it starts ***Replaying***, then ***Running*** again, hoping not to fail this time. If replay or running failed because the previous guest async function misbehaved, then to make progress, an upgrade needs to replace the function with one which behaves correctly. If a ***Replaying*** or ***Running*** guest failed because of a failure of the `asyncFlow` mechanism, whether a bug or merely hitting a case that is not yet implemented, then an upgrade needs to replace the relevant part of the `asyncFlow`'s mechanism.
 
 - ***Done***. The guest async function invocation returned a promise for its eventual outcome. Once that promise settles, we assume that the job of the guest activation is done. It then goes into a durably ***Done*** state, dropping all its bookkeeping beyond just remembering the corresponding settled outcome vow, and that it is ***Done***. The replay logs and membrane state of this activation are dropped, to be garbage collected.
+  

package/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./src/async-flow.js";
-export * from "./src/types.js";
-export { makeSharedStateRecord } from "./src/endowments.js";
+export * from "./src/types-index.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,3 +1,2 @@
 export * from './src/async-flow.js';
-export * from './src/types.js';
-export { makeSharedStateRecord } from './src/endowments.js';
+export * from './src/types-index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/async-flow",
-  "version": "0.1.1-upgrade-17-dev-a1453b2.0+a1453b2",
+  "version": "0.1.1-upgrade-18-dev-d7c994b.0+d7c994b",
   "description": "Upgrade async functions at await points by replay",
   "type": "module",
   "repository": "https://github.com/Agoric/agoric-sdk",
@@ -8,7 +8,7 @@
   "scripts": {
     "build": "exit 0",
     "prepack": "tsc --build tsconfig.build.json",
-    "postpack": "git clean -f '*.d.ts*'",
+    "postpack": "git clean -f '*.d.ts*' '*.tsbuildinfo'",
     "test": "ava",
     "test:c8": "c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
     "test:xs": "exit 0",
@@ -24,23 +24,22 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-upgrade-17-dev-a1453b2.0+a1453b2",
-    "@agoric/internal": "0.4.0-upgrade-17-dev-a1453b2.0+a1453b2",
-    "@agoric/store": "0.9.3-upgrade-17-dev-a1453b2.0+a1453b2",
-    "@agoric/vow": "0.2.0-upgrade-17-dev-a1453b2.0+a1453b2",
-    "@endo/common": "^1.2.5",
-    "@endo/errors": "^1.2.5",
-    "@endo/eventual-send": "^1.2.5",
-    "@endo/marshal": "^1.5.3",
-    "@endo/pass-style": "^1.4.3",
-    "@endo/patterns": "^1.4.3",
-    "@endo/promise-kit": "^1.1.5"
+    "@agoric/base-zone": "0.1.1-upgrade-18-dev-d7c994b.0+d7c994b",
+    "@agoric/internal": "0.3.3-upgrade-18-dev-d7c994b.0+d7c994b",
+    "@agoric/store": "0.9.3-upgrade-18-dev-d7c994b.0+d7c994b",
+    "@agoric/vow": "0.1.1-upgrade-18-dev-d7c994b.0+d7c994b",
+    "@endo/common": "^1.2.7",
+    "@endo/errors": "^1.2.7",
+    "@endo/eventual-send": "^1.2.7",
+    "@endo/marshal": "^1.6.1",
+    "@endo/pass-style": "^1.4.6",
+    "@endo/patterns": "^1.4.6",
+    "@endo/promise-kit": "^1.1.7"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-upgrade-17-dev-a1453b2.0+a1453b2",
-    "@agoric/zone": "0.3.0-upgrade-17-dev-a1453b2.0+a1453b2",
-    "@endo/env-options": "^1.1.6",
-    "@endo/ses-ava": "^1.2.5",
+    "@agoric/swingset-vat": "0.32.3-upgrade-18-dev-d7c994b.0+d7c994b",
+    "@agoric/zone": "0.2.3-upgrade-18-dev-d7c994b.0+d7c994b",
+    "@endo/env-options": "^1.1.7",
     "ava": "^5.3.0",
     "tsd": "^0.31.1"
   },
@@ -61,7 +60,7 @@
     "workerThreads": false
   },
   "typeCoverage": {
-    "atLeast": 77.1
+    "atLeast": 76.93
   },
-  "gitHead": "a1453b2877b017a7f5b43a92364067d001901953"
+  "gitHead": "d7c994b8d33c0cd22b257f3e33b579588ab6c6d8"
 }

package/src/async-flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async-flow.d.ts","sourceRoot":"","sources":["async-flow.js"],"names":[],"mappings":"AAgDO,iDAHI,IAAI;gCA6CF,IAAI,OACJ,MAAM,kBACN,cAAc;qBACC,OAAO;;;YA4BzB;;eAEG;4BADU,SAAS;YAkCtB;;;;;eAKG;;;;;;;;;;;;;;;;;gBAmRmB,CAAC,SAAlB,cAAgB,QAClB,IAAI,OACJ,MAAM,aACN,CAAC;qBACc,OAAO;sBACpB,OAAO,CAAC,CAAC;;;;;;;;EAsDvB;6BAIY,UAAU,aAtcZ,IAAI;gCA6CF,IAAI,OACJ,MAAM,kBACN,cAAc;qBACC,OAAO;;;YA4BzB;;eAEG;4BADU,SAAS;YAkCtB;;;;;eAKG;;;;;;;;;;;;;;;;;gBAmRmB,CAAC,SAAlB,cAAgB,QAClB,IAAI,OACJ,MAAM,aACN,CAAC;qBACc,OAAO;sBACpB,OAAO,CAAC,CAAC;;;;;;;;EA0DsB;6BAIjC,cAAc,CAAC,gBAAgB,CAAC;+BAIhC,UAAU,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC;2BAIjD,UAAU,CAAC,gBAAgB,CAAC;wBAI5B,YAAY,CAAC,MAAM,CAAC;0BArfV,mBAAmB;wCACoD,iBAAiB;oCAAjB,iBAAiB;+BAAjB,iBAAiB;4BAAjB,iBAAiB"}
+{"version":3,"file":"async-flow.d.ts","sourceRoot":"","sources":["async-flow.js"],"names":[],"mappings":"AAgDO,iDAHI,IAAI;gCAgDF,IAAI,OACJ,MAAM,kBACN,cAAc;qBACC,OAAO;;;YA4BzB;;eAEG;4BADU,SAAS;YAkCtB;;;;;eAKG;;;;;;;;;;;;;;;;;gBA4TmB,CAAC,SAAlB,cAAgB,QAClB,IAAI,OACJ,MAAM,aACN,CAAC;qBACc,OAAO;sBACpB,OAAO,CAAC,CAAC;;;;;;;;EAsDvB;6BAIY,UAAU,aAlfZ,IAAI;gCAgDF,IAAI,OACJ,MAAM,kBACN,cAAc;qBACC,OAAO;;;YA4BzB;;eAEG;4BADU,SAAS;YAkCtB;;;;;eAKG;;;;;;;;;;;;;;;;;gBA4TmB,CAAC,SAAlB,cAAgB,QAClB,IAAI,OACJ,MAAM,aACN,CAAC;qBACc,OAAO;sBACpB,OAAO,CAAC,CAAC;;;;;;;;EA0DsB;6BAIjC,cAAc,CAAC,gBAAgB,CAAC;+BAIhC,UAAU,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC;2BAIjD,UAAU,CAAC,gBAAgB,CAAC;wBAI5B,YAAY,CAAC,MAAM,CAAC;0BAjiBV,mBAAmB;wCACoD,iBAAiB;oCAAjB,iBAAiB;+BAAjB,iBAAiB;4BAAjB,iBAAiB"}

package/src/async-flow.js

@@ -11,7 +11,7 @@ import { prepareEndowmentTools } from './endowments.js';
 import { LogEntryShape, FlowStateShape } from './type-guards.js';
 
 /**
- * @import {WeakMapStore} from '@agoric/store'
+ * @import {WeakMapStore, MapStore} from '@agoric/store'
  * @import {Zone} from '@agoric/base-zone'
  * @import {FlowState, GuestAsyncFunc, HostAsyncFuncWrapper, HostOf, PreparationOptions} from '../src/types.js'
  * @import {ReplayMembrane} from '../src/replay-membrane.js'
@@ -55,6 +55,9 @@ export const prepareAsyncFlowTools = (outerZone, outerOptions = {}) => {
       { vowTools },
     ),
     makeBijection = prepareBijection(outerZone, unwrap),
+    panicHandler = err => {
+      throw err;
+    },
   } = outerOptions;
   const { watch, makeVowKit } = vowTools;
 
@@ -67,7 +70,7 @@ export const prepareAsyncFlowTools = (outerZone, outerOptions = {}) => {
     keyShape: M.remotable('flow'), // flowState !== 'Done'
   });
 
-  /** @type WeakMapStore<AsyncFlow, ReplayMembrane> */
+  /** @type {WeakMapStore<AsyncFlow, ReplayMembrane>} */
   const membraneMap = makeScalarWeakMapStore('membraneFor', {
     keyShape: M.remotable('flow'),
     valueShape: M.remotable('membrane'),
@@ -247,6 +250,12 @@ export const prepareAsyncFlowTools = (outerZone, outerOptions = {}) => {
               guestResultP,
               gFulfillment => {
                 if (bijection.hasGuest(guestResultP)) {
+                  !log.isReplaying() ||
+                    panic(
+                      makeError(
+                        X`guest fulfilled with ${gFulfillment} before finishing replay`,
+                      ),
+                    );
                   outcomeKit.resolver.resolve(
                     membrane.guestToHost(gFulfillment),
                   );
@@ -262,11 +271,46 @@ export const prepareAsyncFlowTools = (outerZone, outerOptions = {}) => {
                 // in the `guestResultP` being absent from the bijection,
                 // so this leave the outcome vow unsettled, as it must.
                 if (bijection.hasGuest(guestResultP)) {
+                  !log.isReplaying() ||
+                    panic(
+                      makeError(
+                        X`guest rejected with ${guestReason} before finishing replay`,
+                      ),
+                    );
                   outcomeKit.resolver.reject(membrane.guestToHost(guestReason));
                   admin.complete();
                 }
               },
-            );
+            )
+              .then(
+                () => {
+                  if (flow.getFlowState() === 'Failed') {
+                    // If the flow fails, we need to trigger the panic handler with
+                    // the failure.
+                    throw flow.getOptFatalProblem();
+                  }
+                },
+                maybePanicReason => {
+                  if (flow.getFlowState() === 'Failed') {
+                    const err = flow.getOptFatalProblem();
+                    // TODO: Annotate maybePanicReason robustly with err if it
+                    // is indeed not the same as one we already threw from
+                    // panic.
+                    throw err;
+                  }
+
+                  // Definitely not a reason from an existing panic, so raise a new panic.
+                  const err = makeError(
+                    X`internal: unexpected error in guest completion handling ${maybePanicReason}`,
+                  );
+                  try {
+                    panic(err);
+                  } catch (_e) {
+                    throw err;
+                  }
+                },
+              )
+              .catch(panicHandler);
           },
           wake() {
             const { facets } = this;

package/src/endowments.d.ts

@@ -1,7 +1,6 @@
 export function forwardingMethods(rem: any): {
     [k: string]: any;
 };
-export function makeSharedStateRecord<K extends string | number | symbol, R extends Record<K, any>>(dataRecord: R): R;
 export function prepareEndowmentTools(outerZone: Zone, outerOptions?: PreparationOptions | undefined): {
     prepareEndowment: (zone: Zone, tag: string, e: unknown) => any;
     unwrap: (wrapped: any, guestWrapped: any) => any;

package/src/endowments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"endowments.d.ts","sourceRoot":"","sources":["endowments.js"],"names":[],"mappings":"AA4CO;;EASN;AAaM,sCALmC,CAAC,SAA5B,MAAM,GAAG,MAAM,GAAG,MAAQ,EACX,CAAC,SAAjB,MAAM,CAAC,CAAC,EAAE,GAAG,CAAE,cAClB,CAAC,GACC,CAAC,CAqBX;AAMI,iDAHI,IAAI;6BA6GF,IAAI,OACJ,MAAM,KACN,OAAO;;EAyFnB;4BA9QY,SAAS,GAAG,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO;6BAkR1E,UAAU,aA5MZ,IAAI;6BA6GF,IAAI,OACJ,MAAM,KACN,OAAO;;EA6F0B;0BAxRvB,mBAAmB;wCAEL,iBAAiB"}
+{"version":3,"file":"endowments.d.ts","sourceRoot":"","sources":["endowments.js"],"names":[],"mappings":"AAiDO;;EASN;AAMM,iDAHI,IAAI;6BA4GF,IAAI,OACJ,MAAM,KACN,OAAO;;EAyFnB;4BA7OY,SAAS,GAAG,UAAU,GAAG,KAAK,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO;6BAiP1E,UAAU,aA3MZ,IAAI;6BA4GF,IAAI,OACJ,MAAM,KACN,OAAO;;EA6F0B;0BAvPvB,mBAAmB;wCAEL,iBAAiB"}

package/src/endowments.js

@@ -1,7 +1,12 @@
 import { Fail } from '@endo/errors';
 import { E } from '@endo/eventual-send';
 import { isPromise } from '@endo/promise-kit';
-import { isRemotable, isPassable, GET_METHOD_NAMES } from '@endo/pass-style';
+import {
+  isRemotable,
+  isPassable,
+  GET_METHOD_NAMES,
+  Far,
+} from '@endo/pass-style';
 import { M, objectMap } from '@endo/patterns';
 import { prepareVowTools, toPassableCap } from '@agoric/vow';
 import { isVow } from '@agoric/vow/src/vow-utils.js';
@@ -53,38 +58,6 @@ export const forwardingMethods = rem => {
   return fromEntries(keys.map(makeMethodEntry));
 };
 
-/**
- * Given a possibly mutable (and therefore unhardened) record, return a
- * corresponding state record that acts identically for normal
- * gets and sets, but is implemented using accessors, so it will be recognized
- * as a state record.
- *
- * @template { string | number | symbol } K
- * @template {Record<K, any>} R
- * @param {R} dataRecord
- * @returns {R}
- */
-export const makeSharedStateRecord = dataRecord =>
-  harden(
-    create(
-      objectPrototype,
-      fromEntries(
-        ownKeys(dataRecord).flatMap(key =>
-          entries(
-            getOwnPropertyDescriptors({
-              get [key]() {
-                return dataRecord[key];
-              },
-              set [key](newValue) {
-                dataRecord[key] = newValue;
-              },
-            }),
-          ),
-        ),
-      ),
-    ),
-  );
-
 /**
  * @param {Zone} outerZone
  * @param {PreparationOptions} [outerOptions]
@@ -95,8 +68,7 @@ export const prepareEndowmentTools = (outerZone, outerOptions = {}) => {
 
   const functionUnwrapper = outerZone.exo('FunctionUnwrapper', UnwrapperI, {
     unwrap(guestWrapped) {
-      const unwrapped = (...args) => guestWrapped.apply(args);
-      return harden(unwrapped);
+      return Far('UnwrappedFunction', (...args) => guestWrapped.apply(args));
     },
   });
 

package/src/equate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equate.d.ts","sourceRoot":"","sources":["equate.js"],"names":[],"mappings":"AAQO,iFAiHN"}
+{"version":3,"file":"equate.d.ts","sourceRoot":"","sources":["equate.js"],"names":[],"mappings":"AAQO,iFAyHN"}

package/src/equate.js

@@ -31,7 +31,14 @@ export const makeEquate = bijection => {
         Fail`unequal ${g} vs ${h}`;
       return;
     }
-    if (bijection.has(g, h)) {
+    if (bijection.hasGuest(g) && bijection.guestToHost(g) === h) {
+      // Note that this can be true even when
+      // `bijection.hostToGuest(h) !== g`
+      // but only when the two guests represent the same host, as
+      // happens with unwrapping. That why we do this one-way test
+      // rather than the two way `bijection.has` test.
+      // Even in this one-way case, we have still satisfied
+      // the equate, so return.
       return;
     }
     const gPassStyle = passStyleOf(g);
@@ -41,7 +48,8 @@ export const makeEquate = bijection => {
       // TODO when we do, delete the `throw Fail` line and uncomment
       // the two lines below it.
       // We *do* support passing a guest wrapper of a hostVow back
-      // to the host, but that would be cause by `bijection.has` above.
+      // to the host, but that would be caught by `bijection.guestToHost`
+      // test above.
       throw Fail`guest promises not yet passable`;
       // `init` does not yet do enough checking anyway. For this case,
       // we should ensure that h is a host wrapper of a guest promise,
@@ -92,10 +100,10 @@ export const makeEquate = bijection => {
       case 'remotable': {
         // Note that we can send a guest wrapping of a host remotable
         // back to the host,
-        // but that should have already been taken care of by the
-        // `bijection.has` above.
+        // but that should have already been caught by the
+        // `bijection.guestToHost` above.
         throw Fail`cannot yet send guest remotables to host ${g} vs ${h}`;
-        // `init` does not yet do enough checking anyway. For this case,
+        // `unwrapInit` does not yet do enough checking anyway. For this case,
         // we should ensure that h is a host wrapper of a guest remotable,
         // which is a wrapping we don't yet support.
         // bijection.unwrapInit(g, h);
@@ -104,10 +112,10 @@ export const makeEquate = bijection => {
       case 'promise': {
         // Note that we can send a guest wrapping of a host promise
         // (or vow) back to the host,
-        // but that should have already been taken care of by the
-        // `bijection.has` above.
+        // but that should have already been caught by the
+        // `bijection.guestToHost` above.
         throw Fail`cannot yet send guest promises to host ${g} vs ${h}`;
-        // `init` does not yet do enough checking anyway. For this case,
+        // `unwrapInit` does not yet do enough checking anyway. For this case,
         // we should ensure that h is a host wrapper of a guest promise,
         // which is a wrapping we don't yet support.
         // bijection.unwrapInit(g, h);

package/src/log-store.d.ts

@@ -1,24 +1,61 @@
+export function nextGeneration(zone: Zone): number;
 export function prepareLogStore(zone: Zone): () => import("@endo/exo").Guarded<{
     reset(): void;
     dispose(): void;
+    getUnfilteredIndex(): number;
     getIndex(): number;
     getLength(): number;
     isReplaying(): boolean;
+    /**
+     * @returns {LogEntry}
+     */
     peekEntry(): LogEntry;
+    /**
+     * @returns {LogEntry}
+     */
+    nextUnfilteredEntry(): LogEntry;
+    /**
+     * @returns {LogEntry}
+     */
     nextEntry(): LogEntry;
-    pushEntry(entry: any): number;
+    /**
+     * @param {LogEntry} latestEntry
+     */
+    pushEntry(latestEntry: LogEntry): number;
+    /**
+     * @returns {LogEntry[]}
+     */
+    dumpUnfiltered(): LogEntry[];
     dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSendOnly", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSend", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
     promiseReplayDone(): Promise<undefined>;
 }>;
 export type LogStore = ReturnType<ReturnType<(zone: Zone) => () => import("@endo/exo").Guarded<{
     reset(): void;
     dispose(): void;
+    getUnfilteredIndex(): number;
     getIndex(): number;
     getLength(): number;
     isReplaying(): boolean;
+    /**
+     * @returns {LogEntry}
+     */
     peekEntry(): LogEntry;
+    /**
+     * @returns {LogEntry}
+     */
+    nextUnfilteredEntry(): LogEntry;
+    /**
+     * @returns {LogEntry}
+     */
     nextEntry(): LogEntry;
-    pushEntry(entry: any): number;
+    /**
+     * @param {LogEntry} latestEntry
+     */
+    pushEntry(latestEntry: LogEntry): number;
+    /**
+     * @returns {LogEntry[]}
+     */
+    dumpUnfiltered(): LogEntry[];
     dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSendOnly", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSend", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
     promiseReplayDone(): Promise<undefined>;
 }>>>;

package/src/log-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-store.d.ts","sourceRoot":"","sources":["log-store.js"],"names":[],"mappings":"AA+BO,sCAFI,IAAI;;;;;;;;;;;GAuId;uBAGY,UAAU,CAAC,UAAU,QA1IvB,IAAI;;;;;;;;;;;GA0IoC,CAAC;0BA/J7B,mBAAmB;8BAEL,YAAY"}
+{"version":3,"file":"log-store.d.ts","sourceRoot":"","sources":["log-store.js"],"names":[],"mappings":"AAmCO,qCAHI,IAAI,GACF,MAAM,CAgBlB;AAOM,sCAFI,IAAI;;;;;;;IAoGT;;OAEG;iBADU,QAAQ;IAcrB;;OAEG;2BADU,QAAQ;IAgBrB;;OAEG;iBADU,QAAQ;IAWrB;;OAEG;2BADQ,QAAQ;IAuCnB;;OAEG;sBADU,QAAQ,EAAE;;;GAwB5B;uBAGY,UAAU,CAAC,UAAU,QApNvB,IAAI;;;;;;;IAoGT;;OAEG;iBADU,QAAQ;IAcrB;;OAEG;2BADU,QAAQ;IAgBrB;;OAEG;iBADU,QAAQ;IAWrB;;OAEG;2BADQ,QAAQ;IAuCnB;;OAEG;sBADU,QAAQ,EAAE;;;GA2BsB,CAAC;0BAlQ7B,mBAAmB;8BAEL,YAAY"}

package/src/log-store.js

@@ -14,31 +14,76 @@ import { makeEphemera } from './ephemera.js';
 const LogStoreI = M.interface('LogStore', {
   reset: M.call().returns(),
   dispose: M.call().returns(),
+  getUnfilteredIndex: M.call().returns(M.number()),
   getIndex: M.call().returns(M.number()),
   getLength: M.call().returns(M.number()),
   isReplaying: M.call().returns(M.boolean()),
   peekEntry: M.call().returns(LogEntryShape),
   nextEntry: M.call().returns(LogEntryShape),
+  nextUnfilteredEntry: M.call().returns(LogEntryShape),
   pushEntry: M.call(LogEntryShape).returns(M.number()),
+  dumpUnfiltered: M.call().returns(M.arrayOf(LogEntryShape)),
   dump: M.call().returns(M.arrayOf(LogEntryShape)),
   promiseReplayDone: M.call().returns(M.promise()),
 });
 
+/**
+ * Get a generation number to use in `startGeneration` log entries.
+ *
+ * @param {Zone} zone
+ * @returns {number}
+ */
+export const nextGeneration = zone => {
+  /** @type {MapStore<'generation', number>} */
+  const logStoreMetadata = zone.mapStore('LogStoreMetadata');
+  const generationKey = 'generation';
+
+  if (!logStoreMetadata.has(generationKey)) {
+    const firstGen = 0;
+    logStoreMetadata.init(generationKey, firstGen);
+    return firstGen;
+  }
+
+  const nextGen = logStoreMetadata.get(generationKey) + 1;
+  logStoreMetadata.set(generationKey, nextGen);
+  return nextGen;
+};
+
 /**
  * A growable, replayable, sequence of `LogEntry`s.
  *
  * @param {Zone} zone
  */
 export const prepareLogStore = zone => {
+  /**
+   * Ensure that any new or reset LogStore instance that (for a given
+   * incarnation) pushes at least one entry will insert these entries first,
+   * even if the log is reset, replayed, and pushed to in the same incarnation.
+   * @type {LogEntry[]}
+   */
+  const initialPush = harden([['startGeneration', nextGeneration(zone)]]);
+
+  /**
+   * A predicate to indicate whether the entry is normally visible to the
+   * LogStore user, or is a more internal entry that only is visible via the
+   * Unfiltered methods.
+   * @param {LogEntry} entry
+   */
+  const entryIsVisible = entry => entry[0] !== 'startGeneration';
+
   /**
    * @type {Ephemera<LogStore, {
-   *           index: number
-   *           replayDoneKit: PromiseKit<undefined>
+   *           index: number;
+   *           unfilteredIndex: number;
+   *           initialPush: LogEntry[] | undefined;
+   *           replayDoneKit: PromiseKit<undefined>;
    *        }>}
    */
   const tmp = makeEphemera(log => {
     const result = {
       index: 0,
+      unfilteredIndex: 0,
+      initialPush,
       replayDoneKit: makePromiseKit(),
     };
     if (log.getLength() === 0) {
@@ -82,6 +127,12 @@ export const prepareLogStore = zone => {
         tmp.resetFor(self);
         mapStore.clear();
       },
+      getUnfilteredIndex() {
+        const { self } = this;
+        const eph = tmp.for(self);
+
+        return eph.unfilteredIndex;
+      },
       getIndex() {
         const { self } = this;
         const eph = tmp.for(self);
@@ -99,52 +150,96 @@ export const prepareLogStore = zone => {
         const { mapStore } = state;
         const eph = tmp.for(self);
 
-        return eph.index < mapStore.getSize();
+        return eph.unfilteredIndex < mapStore.getSize();
       },
+      /**
+       * @returns {LogEntry}
+       */
       peekEntry() {
         const { state, self } = this;
         const { mapStore } = state;
         const eph = tmp.for(self);
 
         self.isReplaying() ||
-          Fail`No longer replaying: ${q(eph.index)} vs ${q(
+          Fail`No longer replaying: ${q(eph.unfilteredIndex)} vs ${q(
             mapStore.getSize(),
           )}`;
-        const result = mapStore.get(eph.index);
+        const result = mapStore.get(eph.unfilteredIndex);
         return result;
       },
-      nextEntry() {
+      /**
+       * @returns {LogEntry}
+       */
+      nextUnfilteredEntry() {
         const { self } = this;
         const eph = tmp.for(self);
 
         const result = self.peekEntry();
-        eph.index += 1;
+        eph.unfilteredIndex += 1;
+        if (entryIsVisible(result)) {
+          eph.index += 1;
+        }
         if (!self.isReplaying()) {
           eph.replayDoneKit.resolve(undefined);
         }
         return result;
       },
-      pushEntry(entry) {
+      /**
+       * @returns {LogEntry}
+       */
+      nextEntry() {
+        const { self } = this;
+        let result = self.nextUnfilteredEntry();
+        while (!entryIsVisible(result)) {
+          self.isReplaying() || Fail`Unexpected entry at log tail: ${result}`;
+          result = self.nextUnfilteredEntry();
+        }
+        return result;
+      },
+      /**
+       * @param {LogEntry} latestEntry
+       */
+      pushEntry(latestEntry) {
         const { state, self } = this;
+
         const { mapStore } = state;
         const eph = tmp.for(self);
 
         !self.isReplaying() ||
-          Fail`still replaying: ${q(eph.index)} vs ${q(mapStore.getSize())}`;
-        eph.index === mapStore.getSize() ||
-          Fail`internal: index confusion ${q(eph.index)} vs ${q(
-            mapStore.getSize(),
-          )}`;
-        mapStore.init(eph.index, entry);
-        eph.index += 1;
-        eph.index === mapStore.getSize() ||
-          Fail`internal: index confusion ${q(eph.index)} vs ${q(
-            mapStore.getSize(),
-          )}`;
-        // console.log('LOG ENTRY ', eph.index - 1, entry);
-        return eph.index;
+          Fail`still replaying: ${q(eph.unfilteredIndex)} vs ${q(mapStore.getSize())}`;
+
+        const pushOne = entry => {
+          eph.unfilteredIndex === mapStore.getSize() ||
+            Fail`internal: unfilteredIndex confusion ${q(eph.unfilteredIndex)} vs ${q(
+              mapStore.getSize(),
+            )}`;
+          mapStore.init(eph.unfilteredIndex, entry);
+          eph.unfilteredIndex += 1;
+          if (entryIsVisible(entry)) {
+            eph.index += 1;
+          }
+          eph.unfilteredIndex === mapStore.getSize() ||
+            Fail`internal: unfilteredIndex confusion ${q(eph.unfilteredIndex)} vs ${q(
+              mapStore.getSize(),
+            )}`;
+        };
+
+        if (eph.initialPush) {
+          const initialEntries = eph.initialPush;
+          eph.initialPush = undefined;
+          for (const initialEntry of initialEntries) {
+            pushOne(initialEntry);
+          }
+        }
+        pushOne(latestEntry);
+
+        // console.log('LOG ENTRY ', eph.unfilteredIndex - 1, entry);
+        return eph.unfilteredIndex;
       },
-      dump() {
+      /**
+       * @returns {LogEntry[]}
+       */
+      dumpUnfiltered() {
         const { state } = this;
         const { mapStore } = state;
         const len = mapStore.getSize();
@@ -154,6 +249,10 @@ export const prepareLogStore = zone => {
         }
         return harden(result);
       },
+      dump() {
+        const { self } = this;
+        return harden(self.dumpUnfiltered().filter(entryIsVisible));
+      },
       promiseReplayDone() {
         const { self } = this;
         const eph = tmp.for(self);