@agoric/swingset-liveslots 0.10.3-other-dev-3eb1a1d.0 → 0.10.3-other-dev-fbe72e7.0.fbe72e7

package/src/virtualObjectManager.js

@@ -7,6 +7,7 @@ import { assertPattern, mustMatch } from '@agoric/store';
 import { defendPrototype, defendPrototypeKit } from '@endo/exo/tools.js';
 import { Far, passStyleOf } from '@endo/marshal';
 import { Nat } from '@endo/nat';
+import { kindOf } from '@endo/patterns';
 import { parseVatSlot, makeBaseRef } from './parseVatSlots.js';
 import { enumerateKeysWithPrefix } from './vatstore-iterators.js';
 import { makeCache } from './cache.js';
@@ -20,6 +21,8 @@ import {
  * @import {DefineKindOptions} from '@agoric/swingset-liveslots'
  * @import {ClassContextProvider, KitContextProvider} from '@endo/exo'
  * @import {ToCapData, FromCapData} from '@endo/marshal';
+ * @import {Pattern} from '@endo/patterns';
+ * @import {SwingSetCapData} from './types.js';
  */
 
 const {
@@ -241,12 +244,47 @@ const insistDurableCapdata = (vrm, what, capdata, valueFor) => {
   }
 };
 
-const insistSameCapData = (oldCD, newCD) => {
-  // NOTE: this assumes both were marshalled with the same format
-  // (e.g. smallcaps vs pre-smallcaps). To somewhat tolerate new
-  // formats, we'd need to `serialize(unserialize(oldCD))`.
+const isUndefinedPatt = patt =>
+  patt === undefined ||
+  (kindOf(patt) === 'match:kind' && patt.payload === 'undefined');
+
+/**
+ * Assert that a new stateShape either matches the old, or only differs in the
+ * addition of new clearly-optional top-level fields as conveyed by an
+ * [Endo `M.or`]{@link https://endojs.github.io/endo/interfaces/_endo_patterns.PatternMatchers.html#or}
+ * Pattern with at least one `undefined` alternative.
+ *
+ * @param {SwingSetCapData} oldCD
+ * @param {SwingSetCapData} newCD
+ * @param {{ newShape: Record<string, Pattern>, serialize: ToCapData<string>, unserialize: FromCapData<string> }} powers
+ */
+const insistCompatibleShapeCapData = (
+  oldCD,
+  newCD,
+  { newShape, serialize, unserialize },
+) => {
   if (oldCD.body !== newCD.body) {
-    Fail`durable Kind stateShape mismatch (body)`;
+    // Allow introduction of any clearly-optional new field at top level.
+    const oldShape =
+      unserialize(oldCD) ||
+      Fail`durable Kind stateShape mismatch (no old shape)`;
+    passStyleOf(oldShape) === 'copyRecord' ||
+      Fail`durable Kind stateShape mismatch (invalid old shape)`;
+    assertPattern(oldShape);
+    for (const [name, oldPatt] of Object.entries(oldShape)) {
+      // Assert presence and CapData shape, but save slots for their own clause.
+      (Object.hasOwn(newShape, name) &&
+        serialize(newShape[name]).body === serialize(oldPatt).body) ||
+        Fail`durable Kind stateShape mismatch (body ${name})`;
+    }
+    for (const [name, newPatt] of Object.entries(newShape)) {
+      if (Object.hasOwn(oldShape, name)) continue;
+      kindOf(newPatt) === 'match:or' ||
+        Fail`durable Kind stateShape mismatch (body new field ${name})`;
+      // @ts-expect-error A "match:or" pattern has a `payload` array of Patterns
+      newPatt.payload.some(patt => isUndefinedPatt(patt)) ||
+        Fail`durable Kind stateShape mismatch (body ${name})`;
+    }
   }
   if (oldCD.slots.length !== newCD.slots.length) {
     Fail`durable Kind stateShape mismatch (slots.length)`;
@@ -532,7 +570,7 @@ export const makeVirtualObjectManager = (
    *  tag: string,
    *  unfaceted?: boolean,
    *  facets?: string[],
-   *  stateShapeCapData?: import('./types.js').SwingSetCapData
+   *  stateShapeCapData?: SwingSetCapData
    * }} DurableKindDescriptor
    */
 
@@ -803,7 +841,11 @@ export const makeVirtualObjectManager = (
 
       const oldStateShapeSlots = oldShapeCD ? oldShapeCD.slots : [];
       if (oldShapeCD && !allowStateShapeChanges) {
-        insistSameCapData(oldShapeCD, newShapeCD);
+        insistCompatibleShapeCapData(oldShapeCD, newShapeCD, {
+          newShape: /** @type {Record<string, Pattern>} */ (stateShape),
+          serialize,
+          unserialize,
+        });
       }
       const newStateShapeSlots = newShapeCD.slots;
       vrm.updateReferenceCounts(oldStateShapeSlots, newStateShapeSlots);
@@ -859,9 +901,11 @@ export const makeVirtualObjectManager = (
           const baseRef = getBaseRef(this);
           const record = dataCache.get(baseRef);
           assert(record !== undefined);
-          const { valueMap, capdatas } = record;
+          const { capdatas, valueMap } = record;
           if (!valueMap.has(prop)) {
-            const value = harden(unserialize(capdatas[prop]));
+            const value = hasOwn(capdatas, prop)
+              ? harden(unserialize(capdatas[prop]))
+              : undefined;
             checkStatePropertyValue(value, prop);
             valueMap.set(prop, value);
           }
@@ -877,12 +921,19 @@ export const makeVirtualObjectManager = (
           }
           const record = dataCache.get(baseRef); // mutable
           assert(record !== undefined);
-          const oldSlots = record.capdatas[prop].slots;
+          const { capdatas, valueMap } = record;
+          const oldSlots = hasOwn(capdatas, prop) ? capdatas[prop].slots : [];
           const newSlots = capdata.slots;
           vrm.updateReferenceCounts(oldSlots, newSlots);
-          record.capdatas[prop] = capdata; // modify in place ..
-          record.valueMap.set(prop, value);
-          dataCache.set(baseRef, record); // .. but mark as dirty
+          // modify in place, but mark as dirty
+          defineProperty(capdatas, prop, {
+            value: capdata,
+            writable: true,
+            enumerable: true,
+            configurable: false,
+          });
+          valueMap.set(prop, value);
+          dataCache.set(baseRef, record);
         },
         enumerable: true,
         configurable: false,
@@ -1073,7 +1124,12 @@ export const makeVirtualObjectManager = (
         }
         // eslint-disable-next-line github/array-foreach
         valueCD.slots.forEach(vrm.addReachableVref);
-        capdatas[prop] = valueCD;
+        defineProperty(capdatas, prop, {
+          value: valueCD,
+          writable: true,
+          enumerable: true,
+          configurable: false,
+        });
         valueMap.set(prop, value);
       }
       // dataCache contents remain mutable: state setter modifies in-place

package/src/virtualReferences.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @param {*} syscall  Vat's syscall object, used to access the vatstore operations.
+ * @param {(val: object) => string | undefined} getSlotForVal  A function that returns the
+ *   object ID (vref) for a given object, if any.  their corresponding export
+ *   IDs
+ * @param {(slot: string) => object} requiredValForSlot  A function that
+ *   converts an object ID (vref) to an object.
+ * @param {*} FinalizationRegistry  Powerful JavaScript intrinsic normally denied
+ *   by SES
+ * @param {*} WeakRef  Powerful JavaScript intrinsic normally denied
+ *   by SES
+ * @param {*} addToPossiblyDeadSet  Function to record objects whose deaths
+ *   should be reinvestigated
+ * @param {*} addToPossiblyRetiredSet  Function to record dead objects whose
+ *   retirement should be reinvestigated
+ * @param {boolean} relaxDurabilityRules True IFF the associated swingset is
+ *   running with relaxed durability rules
+ */
+export function makeVirtualReferenceManager(syscall: any, getSlotForVal: (val: object) => string | undefined, requiredValForSlot: (slot: string) => object, FinalizationRegistry: any, WeakRef: any, addToPossiblyDeadSet: any, addToPossiblyRetiredSet: any, relaxDurabilityRules: boolean): {
+    registerDroppedCollection: (target: any, descriptor: any) => void;
+    isDurable: (vref: string) => boolean;
+    isDurableKind: (kindID: string) => boolean;
+    registerKind: (kindID: string, reanimator?: (string: any, boolean: any) => object, deleter?: (string: any) => boolean, durable?: boolean) => void;
+    rememberFacetNames: (kindID: string, facetNames: string[] | null) => void;
+    getFacet: (kindID: any, facets: any, facetIndex: any) => any;
+    getFacetNames: (kindID: any) => any;
+    reanimate: (baseRef: string) => any;
+    addReachableVref: (vref: any) => void;
+    removeReachableVref: (vref: any) => boolean;
+    updateReferenceCounts: (beforeSlots: any, afterSlots: any) => void;
+    getReachablePromiseRefCount: (p: any) => number;
+    addRecognizableValue: (value: any, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+    removeRecognizableVref: (vref: string, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+    removeRecognizableValue: (value: any, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+    vrefKey: (value: any) => string | undefined;
+    isPresenceReachable: (vref: string) => boolean;
+    isVrefRecognizable: (vref: any) => boolean;
+    setExportStatus: (vref: any, exportStatus: any) => void;
+    isVirtualObjectReachable: (baseRef: string) => boolean;
+    deleteVirtualObject: (baseRef: string) => [boolean, string[]];
+    ceaseRecognition: (vref: string) => boolean;
+    setDeleteCollectionEntry: (fn: any) => void;
+    getRetentionStats: () => {
+        remotableRefCounts: number;
+        vrefRecognizers: number;
+        kindInfoTable: number;
+    };
+    initializeIDCounters: () => void;
+    allocateNextID: (name: any) => number;
+    flushIDCounters: () => void;
+    testHooks: {
+        getReachableRefCount: (vref: any) => number | undefined;
+        countCollectionsForWeakKey: (vref: any) => number;
+        getDroppedCollectionRegistry: () => any;
+        remotableRefCounts: Map<any, number>;
+        vrefRecognizers: Map<string, Set<Map<string, any> | Set<string>>>;
+        kindInfoTable: Map<any, any>;
+    };
+};
+export type VirtualReferenceManager = ReturnType<typeof makeVirtualReferenceManager>;
+//# sourceMappingURL=virtualReferences.d.ts.map

package/src/virtualReferences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtualReferences.d.ts","sourceRoot":"","sources":["virtualReferences.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDAjBW,GAAC,iBACD,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,sBAGnC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,wBAExB,GAAC,WAED,GAAC,wBAED,GAAC,2BAED,GAAC,wBAED,OAAO;;sBAqQL,MAAM,KAEJ,OAAO;4BAfT,MAAM,KAEJ,OAAO;2BA9CT,MAAM,eACN,CAAC,MAAM,KAAA,EAAE,OAAO,KAAA,KAAK,MAAM,YAC3B,CAAC,MAAM,KAAA,KAAK,OAAO,YACnB,OAAO;iCASP,MAAM,cACN,MAAM,EAAE,GAAC,IAAI;;;yBA8Eb,MAAM;;;;;kCAmPN,GAAC,cACD,MAAM,mCAAW,wBACjB,OAAO;mCA2BP,MAAM,cACN,MAAM,mCAAW,wBACjB,OAAO;qCAgCP,GAAC,cACD,MAAM,mCAAW,wBACjB,OAAO;;gCAvIP,MAAM,KAEJ,OAAO;;;wCAzaT,MAAM,KAEJ,OAAO;mCAoBT,MAAM,KAEJ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;6BAwiBrB,MAAM,KAEJ,OAAO;;;;;;;;;;;;;;;;;;EA+LrB;sCACa,UAAU,CAAC,OAAO,2BAA2B,CAAC"}

package/src/vpid-tracking.md

@@ -0,0 +1,92 @@
+# Promise/VPID Management in Liveslots
+
+Kernels and vats communicate about promises by referring to their VPIDs: vat(-centric) promise IDs. These are strings like `p+12` and `p-23`. Like VOIDs (object IDs), the plus/minus sign indicates which side of the boundary allocated the number (`p+12` and `o+12` are allocated by the vat, `p-13` and `o-13` are allocated by the kernel). But where the object ID sign also indicates which side "owns" the object (i.e. where the behavior lives), the promise ID sign is generally irrelevant.
+
+Instead, we care about which side holds the resolution authority for a promise (referred to as being its **decider**). This is not indicated by the VPID sign, and in fact is not necessarily static. Liveslots does not currently have any mechanism to allow one promise to be forwarded to another, but if it acquires this some day, then the decider of a promise could shift from kernel to vat to kernel again before it finally gets resolved. And there *are* sequences that allow a vat to receive a reference to a promise in method arguments before receiving a message whose result promise uses that same VPID (e.g., `p1 = p2~.foo(); x~.bar(p1)`, then someone resolves `p2` to `x`. Consider also tildot-free code like `{ promise: p1, resolve: resolveP1 } = makePromiseKit(); p2 = E(p1).push('queued'); await E(observer).push(p2); resolveP1(observer);` with an observer whose `push` returns a prompt response). In such cases, the decider is initially the kernel but that authority is transferred to a vat later.
+
+Each Promise starts out in the "unresolved" state, then later transitions irrevocably to the "resolved" state. Liveslots frequently (but not always) pays attention to this transition by calling `then` to attach fulfillment/rejection settlement callbacks. To handle resolution cycles, liveslots remembers the resolution of old promises in a `WeakMap` for as long as the Promise exists. Consequently, for liveslots' purposes, every Promise is either resolved (a callback has fired and liveslots remembers the settlement), or unresolved (liveslots has not yet seen a resolution that settles it).
+
+There are roughly four ways that liveslots might become aware of a promise:
+
+* serialization: a Promise instance is serialized, either for the arguments of an outbound `syscall.send` or `syscall.resolve`, the argument of `watchPromise()`, or to be stored into virtualized data (e.g. `bigMapStore.set(key, promise)`, or assignment to a property of a virtual object)
+* creation for outbound result: liveslots allocates a VPID for the `result` of an outbound `syscall.send`, and creates a new Promise instance to give back to userspace
+* deserialization: the arguments of an inbound `dispatch.deliver` or `dispatch.notify` are deserialized, and a new Promise instance is created
+* inbound result: the kernel-allocated `result` VPID of an inbound `dispatch.deliver` is associated with the Promise we get back from `HandledPromise.applyMethod`
+
+A Promise may be associated with a VPID even though the kernel does not know about it (i.e. the VPID is not in the kernel's c-list for that vat). This can occur when a Promise is stored into virtual data without also being sent to (or received from) the kernel, although note that every Promise associated with a durable promise watcher _is_ sent to the kernel so it can be rejected during vat upgrade. A Promise can also be resolved but still referenced in vdata and forgotten by the kernel (the kernel's knowledge is temporary; it retires VPIDs from c-lists upon `syscall.resolve` or `dispatch.notify` as appropriate). So a VPID might start out stored only in vdata, then get sent to the kernel, then get resolved, leaving it solely in vdata once more.
+
+Each unresolved VPID has a decider: either the kernel or a vat. It can remain unresolved for arbitrarily long, but becomes resolved by the first of the following events:
+
+* if liveslots learns about local resolution of the corresponding Promise by userspace, then liveslots will perform a `syscall.resolve()` (prompting 'notify' deliveries to other subscribed vats)
+* if liveslots learns about resolution by inbound notify, then liveslots will unregister it as necessary and inform userspace of the resolution
+* if the vat is terminated, the kernel internally rejects all remaining vat-decided KPIDs without involving the vat
+* if the vat is upgraded, each of those terminate-associated rejections is followed by a 'notify' delivery to the new incarnation
+
+Liveslots tracks promises in the following data structures:
+
+* `slotToVal` / `valToSlot` : these manage *registration*, the mapping from VPID to Promise and vice versa. These also register objects (Presences, Remotables, and Representatives) to/from VOIDs, and device nodes.
+  * to support GC of objects, `slotToVal.get(vref)` is a WeakRef, and `valToSlot` is a WeakMap
+  * liveslots uses independent strong references to maintain object/promise lifetimes
+* `exportedVPIDs`: a `Map<VPID, Promise>`: all Promises currently known to the kernel and decided by the vat
+* `importedVPIDs`: a `Map<VPID, PromiseKit>`: all Promises currently known to the kernel and decided by the kernel
+* `remotableRefCounts`: a `Map<Object|Promise, Number>`: all Promises (and Remotables) referenced by virtual data
+
+The kernel's c-list for a vat contains all VPIDs in `exportedVPIDs` and `importedVPIDs`. The vat is the decider for `exportedVPIDs`, while the kernel is the decider for `importedVPIDs`. For every VPID in `exportedVPIDs`, we've used `then` on the Promise instance to arrange for a `syscall.resolve` when it settles (becomes fulfilled or rejected). For every VPID key of the `importedVPIDs` Map, the corresponding value is a `[resolve, reject]` "**pRec**", so one of the functions can be called during `dispatch.notify`. Every VPID in `slotToVal` is either in `exportedVPIDs` but not `importedVPIDs`, `importedVPIDs` but not `exportedVPIDs`, or neither.
+
+If a VPID in `importedVPIDs` is resolved (by the kernel, via `dispatch.notify`), the VPID is removed from `importedVPIDs`. If a VPID in `exportedVPIDs` is resolved (by the vat, i.e. liveslots observes invocation of a previously-added settlement callback), liveslots invokes `syscall.resolve` and removes the VPID from `exportedVPIDs`. The c-list for a vat will not contain a VPID for any resolved promise.
+
+The `slotToVal`/`valToSlot` registration must remain until all of the following are true:
+
+* the kernel is no longer aware of the VPID
+* the Promise is not present in any virtual data
+* the promise is not being watched by a `promiseWatcher`.
+
+If the registration were to be lost while any of the above conditions were still true, a replacement Promise might be created while the original was still around, causing confusion.
+
+## Maintaining Strong References
+
+Remember that the `slotToVal` registration uses a WeakRef, so being registered there does not keep the Promise object alive.
+ 
+`exportedVPIDs` and `importedVPIDs` keep their Promise alive in their value. vdata keeps it alive through the key of `remotableRefCounts`. `promiseWatcher` uses an internal `ScalarBigMapStore` to keep the Promise alive.
+
+## Promise/VPID Management Algorithm
+
+* When a Promise is first serialized (it appears in `convertValToSlot`), a VPID is assigned and the VPID/Promise mapping is registered in `valToSlot`/`slotToVal`
+  * at this point, there is not yet a strong reference to the Promise
+* When a VPID appears in the serialized arguments of `syscall.send` or `syscall.resolve`:
+  * if the VPID already exists in `exportedVPIDs` or `importedVPIDs`: do nothing
+  * else: use `followForKernel` to add the VPID to `exportedVPIDs` and attach `.then(onFulfill, onReject)` callbacks that will map fulfillment/rejection to `syscall.resolve()`
+* When a `followForKernel` settlement callback is executed:
+  * do `syscall.resolve()`
+  * remove from `exportedVPIDs`
+  * if `remotableRefCounts` reports 0 references: unregister from `valToSlot`/`slotToVal`
+* When the kernel delivers a `dispatch.notify`:
+  * retrieve the `[resolve, reject]` pRec from `importedVPIDs`
+  * invoke the appropriate function with the deserialized argument
+  * if `remotableRefCounts` reports 0 references: unregister from `valToSlot`/`slotToVal`
+* When the vdata refcount for a VPID drops to zero:
+  * if the VPID still exists in `exportedVPIDs` or `importedVPIDs`: do nothing
+  * else: unregister from `valToSlot`/`slotToVal`
+* When a new VPID is deserialized (it appears in `convertSlotToVal`), this must be the arguments of a delivery (not vdata)
+  * use `makePipelinablePromise` to create a HandledPromise for the VPID
+  * add the Promise and its `resolve`/`reject` pair to `importedVPIDs`
+  * register the Promise in `valToSlot`/`slotToVal`
+  * use `syscall.subscribe` to request a `dispatch.notify` delivery when the kernel resolves this promise
+* When a VPID appears as the `result` of an outbound `syscall.send`: (_note overlap with the preceding_)
+  * use `allocateVPID` to allocate a new VPID
+  * use `makePipelinablePromise` to create a HandledPromise for the VPID
+  * add the Promise and its `resolve`/`reject` pair to `importedVPIDs`
+  * register the Promise in `valToSlot`/`slotToVal`
+  * use `syscall.subscribe` to request a `dispatch.notify` delivery when the kernel resolves this promise
+* When a VPID appears as the `result` of an inbound `dispatch.deliver`, the vat is responsible for deciding it:
+  * construct a promise `res` to capture the userspace-provided result
+  * if the VPID is present in `importedVPIDs`: retrieve the `[resolve, reject]` pRec and use `resolve(res)` to forward eventual settlement of `res` to settlement of the previously-imported promise, then remove the VPID from `importedVPIDs`
+  * else: register marshaller association between the VPID and `res`
+  * in either case, use `followForKernel` to add the VPID to `exportedVPIDs` and attach `.then(onFulfill, onReject)` callbacks that will map fulfillment/rejection to `syscall.resolve()`
+
+
+If the serialization is for storage in virtual data, the act of storing the VPID will add the Promise to `remotableRefCounts`, which maintains a strong reference for as long as the VPID is held. When it is removed from virtual data (or the object/collection is deleted), the refcount will be decremented. When the refcount drops to zero, we perform the `exportedVPIDs`/`importedVPIDs` check and then maybe unregister the promise.
+
+If the serialization is for the arguments of an outbound `syscall.send` or `syscall.resolve` (or `syscall.callNow`, or `syscall.exit`), the VPID will be added to `exportedVPIDs`.
+
+If the *un*serialization occurred when processing the arguments of an *in*bound `dispatch.deliver` or `dispatch.notify`, the VPID (and the "promise kit" trio of Promise, `resolve`, and `reject`) will be stored in `importedVPIDs`.

package/src/watchedPromises.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @template V
+ * @template {any[]} [A=unknown[]]
+ * @typedef {[watcher: import('./types.js').PromiseWatcher<V, A>, ...args: A]} PromiseWatcherTuple
+ */
+/**
+ * @param {object} options
+ * @param {*} options.syscall
+ * @param {import('./virtualReferences.js').VirtualReferenceManager} options.vrm
+ * @param {import('./virtualObjectManager.js').VirtualObjectManager} options.vom
+ * @param {*} options.collectionManager
+ * @param {import('@endo/marshal').ConvertValToSlot<any>} options.convertValToSlot
+ * @param {import('@endo/marshal').ConvertSlotToVal<any>} options.convertSlotToVal
+ * @param {(vref: any) => boolean} options.maybeExportPromise
+ */
+export function makeWatchedPromiseManager({ syscall, vrm, vom, collectionManager, convertValToSlot, convertSlotToVal, maybeExportPromise, }: {
+    syscall: any;
+    vrm: import("./virtualReferences.js").VirtualReferenceManager;
+    vom: import("./virtualObjectManager.js").VirtualObjectManager;
+    collectionManager: any;
+    convertValToSlot: import("@endo/marshal").ConvertValToSlot<any>;
+    convertSlotToVal: import("@endo/marshal").ConvertSlotToVal<any>;
+    maybeExportPromise: (vref: any) => boolean;
+}): {
+    preparePromiseWatcherTables: () => void;
+    loadWatchedPromiseTable: (revivePromise: (vref: any) => Promise<any>) => void;
+    providePromiseWatcher: <V, A extends any[]>(kindHandle: import("./vatDataTypes.js").DurableKindHandle, fulfillHandler?: (value: V, ...args: A) => void, rejectHandler?: (reason: any, ...args: A) => void) => import("./types.js").PromiseWatcher<V, A>;
+    watchPromise: <P extends Promise<any>, A extends any[]>(p: P, watcher: import("./types.js").PromiseWatcher<Awaited<P>, A>, ...args: A) => void;
+};
+export type PromiseWatcherTuple<V, A extends any[] = unknown[]> = [watcher: import("./types.js").PromiseWatcher<V, A>, ...args: A];
+//# sourceMappingURL=watchedPromises.d.ts.map

package/src/watchedPromises.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchedPromises.d.ts","sourceRoot":"","sources":["watchedPromises.js"],"names":[],"mappings":"AASA;;;;GAIG;AAEH;;;;;;;;;GASG;AACH,6IARG;IAAmB,OAAO,EAAlB,GAAC;IACiE,GAAG,EAArE,OAAO,wBAAwB,EAAE,uBAAuB;IACU,GAAG,EAArE,OAAO,2BAA2B,EAAE,oBAAoB;IAC7C,iBAAiB,EAA5B,GAAC;IACsD,gBAAgB,EAAvE,OAAO,eAAe,EAAE,gBAAgB,CAAC,GAAG,CAAC;IACU,gBAAgB,EAAvE,OAAO,eAAe,EAAE,gBAAgB,CAAC,GAAG,CAAC;IACb,kBAAkB,EAAlD,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO;CAChC;;6CA+GY,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,KACzB,IAAI;4BAiBJ,CAAC,EACO,CAAC,SAAR,GAAG,EAAG,cACT,OAAO,mBAAmB,EAAE,iBAAiB,mBAC7C,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,kBAC9B,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,KAC/B,OAAO,YAAY,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC;mBAmC3C,CAAC,SAAS,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,SAAS,GAAG,EAAE,KAAK,CAAC,WAAW,OAAO,YAAY,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,KAAK,IAAI;EAoE3I;gCA3PY,CAAC,EACQ,CAAC,SAAT,GAAG,EAAG,gBACP,CAAC,OAAO,EAAE,OAAO,YAAY,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC"}

package/src/watchedPromises.js

@@ -36,13 +36,12 @@ export function makeWatchedPromiseManager({
   const { defineDurableKind } = vom;
 
   /**
-   * virtual Store (not durable) mapping vpid to Promise objects, to
-   * maintain the slotToVal registration until resolution. Without
-   * this, slotToVal would forget local Promises that aren't exported.
+   * Track promises watched in `buildRootObject` so `loadWatchedPromiseTable`
+   * can differentiate them from promises watched in a previous incarnation.
    *
-   * @type {MapStore<string, Promise<unknown>>}
+   * @type {Set<string> | null}
    */
-  let promiseRegistrations;
+  let buildRootObjectWatchedPromiseRefs;
 
   /**
    * watched promises by vpid: each entry is an array of watches on the
@@ -60,7 +59,7 @@ export function makeWatchedPromiseManager({
   let promiseWatcherByKindTable;
 
   function preparePromiseWatcherTables() {
-    promiseRegistrations = makeScalarBigMapStore('promiseRegistrations');
+    buildRootObjectWatchedPromiseRefs = new Set();
     let watcherTableID = syscall.vatstoreGet('watcherTableID');
     if (watcherTableID) {
       promiseWatcherByKindTable = convertSlotToVal(watcherTableID);
@@ -105,7 +104,7 @@ export function makeWatchedPromiseManager({
     function settle(value, wasFulfilled) {
       const watches = watchedPromiseTable.get(vpid);
       watchedPromiseTable.delete(vpid);
-      promiseRegistrations.delete(vpid);
+      buildRootObjectWatchedPromiseRefs?.delete(vpid);
       for (const watch of watches) {
         const [watcher, ...args] = watch;
         void Promise.resolve().then(() => {
@@ -139,16 +138,16 @@ export function makeWatchedPromiseManager({
    */
   function loadWatchedPromiseTable(revivePromise) {
     for (const vpid of watchedPromiseTable.keys()) {
-      if (promiseRegistrations.has(vpid)) {
+      if (buildRootObjectWatchedPromiseRefs?.has(vpid)) {
         // We're only interested in reconnecting the promises from the previous
         // incarnation. Any promise watched during buildRootObject would have
         // already created a registration.
         continue;
       }
       const p = revivePromise(vpid);
-      promiseRegistrations.init(vpid, p);
       pseudoThen(p, vpid);
     }
+    buildRootObjectWatchedPromiseRefs = null;
   }
 
   /**
@@ -235,13 +234,21 @@ export function makeWatchedPromiseManager({
       } else {
         watchedPromiseTable.init(vpid, harden([[watcher, ...args]]));
 
+        buildRootObjectWatchedPromiseRefs?.add(vpid);
+
+        // To avoid triggering
+        // https://github.com/Agoric/agoric-sdk/issues/10757 and
+        // preventing slotToVal cleanup, the `pseudoThen()` should
+        // precede `maybeExportPromise()`. This isn't foolproof, but
+        // does mitigate in advance of a proper fix. See #10756 for
+        // details of this particular mitigation, and #10757 for the
+        // deeper bug.
+        pseudoThen(p, vpid);
+
         // Ensure that this vat's promises are rejected at termination.
         if (maybeExportPromise(vpid)) {
           syscall.subscribe(vpid);
         }
-
-        promiseRegistrations.init(vpid, p);
-        pseudoThen(p, vpid);
       }
     });
   }

package/test/collections.test.js

@@ -326,7 +326,7 @@ test('constrain map key shape', t => {
   t.throws(
     () => noStrings.init('foo', 'string not ok?'),
     m(
-      'invalid key type for collection "map key no strings": "foo" - Must fail negated pattern: "[match:string]"',
+      /^invalid key type for collection "map key no strings": "foo" - Must fail negated pattern: (.*)$/,
     ),
   );
   t.is(noStrings.get(47), 'number ok');
@@ -335,7 +335,14 @@ test('constrain map key shape', t => {
   t.throws(
     () => noStrings.get('foo'),
     m(
-      'invalid key type for collection "map key no strings": "foo" - Must fail negated pattern: "[match:string]"',
+      // TODO https://github.com/Agoric/agoric-sdk/issues/11605
+      // This is a golden error message test. We're currently in transition
+      // from having pattern error messages quote nested patterns using
+      // `q` to quoting them using `qp`. In order to tolerate both during
+      // this transition at reasonable cost, this golden error message
+      // pattern accepts anything in the position of the quoted nested
+      // pattern.
+      /^invalid key type for collection "map key no strings": "foo" - Must fail negated pattern: (.*)$/,
     ),
   );
 
@@ -397,7 +404,14 @@ test('constrain map value shape', t => {
   t.throws(
     () => noStrings.init('skey', 'string not ok?'),
     m(
-      'invalid value type for collection "map value no strings": "string not ok?" - Must fail negated pattern: "[match:string]"',
+      // TODO https://github.com/Agoric/agoric-sdk/issues/11605
+      // This is a golden error message test. We're currently in transition
+      // from having pattern error messages quote nested patterns using
+      // `q` to quoting them using `qp`. In order to tolerate both during
+      // this transition at reasonable cost, this golden error message
+      // pattern accepts anything in the position of the quoted nested
+      // pattern.
+      /^invalid value type for collection "map value no strings": "string not ok\?" - Must fail negated pattern: (.*)$/,
     ),
   );
   t.is(noStrings.get('nkey'), 47);
@@ -458,7 +472,14 @@ test('constrain set key shape', t => {
   t.throws(
     () => noStrings.add('foo?'),
     m(
-      'invalid key type for collection "no strings set": "foo?" - Must fail negated pattern: "[match:string]"',
+      // TODO https://github.com/Agoric/agoric-sdk/issues/11605
+      // This is a golden error message test. We're currently in transition
+      // from having pattern error messages quote nested patterns using
+      // `q` to quoting them using `qp`. In order to tolerate both during
+      // this transition at reasonable cost, this golden error message
+      // pattern accepts anything in the position of the quoted nested
+      // pattern.
+      /^invalid key type for collection "no strings set": "foo\?" - Must fail negated pattern: (.*)$/,
     ),
   );
   t.truthy(noStrings.has(47));

package/test/dummyMeterControl.d.ts

@@ -0,0 +1,2 @@
+export function makeDummyMeterControl(): import("../src/types.js").MeterControl;
+//# sourceMappingURL=dummyMeterControl.d.ts.map

package/test/dummyMeterControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dummyMeterControl.d.ts","sourceRoot":"","sources":["dummyMeterControl.js"],"names":[],"mappings":"AAEA,gFAmDC"}

package/test/engine-gc.d.ts

@@ -0,0 +1,3 @@
+export default engineGC;
+declare const engineGC: GCFunction;
+//# sourceMappingURL=engine-gc.d.ts.map

package/test/engine-gc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-gc.d.ts","sourceRoot":"","sources":["engine-gc.js"],"names":[],"mappings":";AAoBA,mCAAwB"}

package/test/gc-and-finalize.d.ts

@@ -0,0 +1,5 @@
+export function makeGcAndFinalize(gcPower: any): () => Promise<void>;
+export function watchCollected(target: any): Promise<true> & {
+    result: boolean;
+};
+//# sourceMappingURL=gc-and-finalize.d.ts.map

package/test/gc-and-finalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gc-and-finalize.d.ts","sourceRoot":"","sources":["gc-and-finalize.js"],"names":[],"mappings":"AAkEA,qEAwBC;AAwBD;YAbsD,OAAO;EAkB5D"}

package/test/gc-helpers.js

@@ -9,8 +9,8 @@ import { parseVatSlot } from '../src/parseVatSlots.js';
 let aWeakMapStore;
 let aWeakSetStore;
 
-export const mainHolderIdx = 5;
-export const mainHeldIdx = 6;
+export const mainHolderIdx = 4;
+export const mainHeldIdx = 5;
 
 export function buildRootObject(vatPowers) {
   const { VatData } = vatPowers;