@agoric/swingset-liveslots 0.10.3-other-dev-8f8782b.0 → 0.10.3-other-dev-fbe72e7.0.fbe72e7

package/tools/prepare-strict-test-env.d.ts

@@ -0,0 +1,37 @@
+export function annihilate(options?: Omit<ReincarnateOptions, "fakeVomKit" | "fakeStore">): {
+    relaxDurabilityRules?: boolean | undefined;
+    fakeStore: Map<string, string>;
+    weak?: boolean | undefined;
+    cacheSize?: number | undefined;
+    fakeVomKit: import("./setup-vat-data.js").FakeVomKit;
+};
+export function getBaggage(): Baggage;
+export function nextLife(fromIncarnation?: ReincarnateOptions): {
+    relaxDurabilityRules?: boolean | undefined;
+    fakeStore: Map<string, string>;
+    weak?: boolean | undefined;
+    cacheSize?: number | undefined;
+    fakeVomKit: import("./setup-vat-data.js").FakeVomKit;
+};
+export function startLife<B extends (baggage: Baggage) => Promise<any> | any>(build: B, run?: (tools: Awaited<ReturnType<B>>) => Promise<void> | void, { fromIncarnation, cleanStart }?: {
+    fromIncarnation?: {
+        relaxDurabilityRules?: boolean | undefined;
+        fakeStore: Map<string, string>;
+        weak?: boolean | undefined;
+        cacheSize?: number | undefined;
+        fakeVomKit: import("./setup-vat-data.js").FakeVomKit;
+    } | undefined;
+    cleanStart?: boolean | undefined;
+}): Promise<{
+    relaxDurabilityRules?: boolean | undefined;
+    fakeStore: Map<string, string>;
+    weak?: boolean | undefined;
+    cacheSize?: number | undefined;
+    fakeVomKit: import("./setup-vat-data.js").FakeVomKit;
+}>;
+import { flushIncarnation } from './setup-vat-data.js';
+import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
+import type { ReincarnateOptions } from './setup-vat-data.js';
+import type { Baggage } from '@agoric/swingset-liveslots';
+export { flushIncarnation, eventLoopIteration as nextCrank };
+//# sourceMappingURL=prepare-strict-test-env.d.ts.map

package/tools/prepare-strict-test-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-strict-test-env.d.ts","sourceRoot":"","sources":["prepare-strict-test-env.js"],"names":[],"mappings":"AAiCO,qCADK,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,WAAW,CAAC;;;;;;EAO/D;AAGM,8BADO,OAAO,CAGpB;AAKM,2CAFI,kBAAkB;;;;;;EAM5B;AAUM,0BAPiD,CAAC,SAA5C,CAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,GAAI,SAC5C,CAAC,QACD,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,oCAE/D;IAAqC,eAAe;;;;;;;IAC1B,UAAU;CAAC;;;;;;GA2DvC;iCA5G6C,qBAAqB;mCAIhC,uCAAuC;wCASnC,qBAAqB;6BADhC,4BAA4B"}

package/tools/prepare-strict-test-env.js

@@ -0,0 +1,124 @@
+/**
+ * Prepare Agoric SwingSet vat global strict environment for testing.
+ *
+ * Installs Hardened JS (and does lockdown), plus adds mocks for virtual objects
+ * and stores.
+ *
+ * Exports tools for simulating upgrades.
+ */
+
+import '@agoric/internal/src/install-ses-debug.js';
+
+// eslint-disable-next-line import/order
+import { reincarnate, flushIncarnation } from './setup-vat-data.js';
+
+import { makePromiseKit } from '@endo/promise-kit';
+import { Fail } from '@endo/errors';
+import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
+import { makeUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
+
+export { flushIncarnation };
+export { eventLoopIteration as nextCrank };
+
+/**
+ * @import { PromiseKit } from '@endo/promise-kit'
+ * @import { Baggage } from '@agoric/swingset-liveslots'
+ * @import { ReincarnateOptions } from './setup-vat-data.js'
+ */
+
+/** @type {ReincarnateOptions} */
+let incarnation;
+let incarnationNumber = 0;
+
+/** @param {Omit<ReincarnateOptions, 'fakeVomKit' | 'fakeStore'>} [options] */
+export const annihilate = (options = {}) => {
+  // @ts-expect-error fakeStore and fakeVomKit don't exist on type, but drop them if they do at runtime
+  const { fakeStore: _fs, fakeVomKit: _fvk, ...opts } = options;
+  incarnation = reincarnate({ relaxDurabilityRules: false, ...opts });
+  incarnationNumber = 0;
+  return incarnation;
+};
+
+/** @returns {Baggage} */
+export const getBaggage = () => {
+  return incarnation.fakeVomKit.cm.provideBaggage();
+};
+
+/**
+ * @param {ReincarnateOptions} [fromIncarnation]
+ */
+export const nextLife = (fromIncarnation = incarnation) => {
+  incarnation = reincarnate(fromIncarnation);
+  incarnationNumber += 1;
+  return incarnation;
+};
+
+/**
+ * @template {(baggage: Baggage) => Promise<any> | any} B
+ * @param {B} build
+ * @param {(tools: Awaited<ReturnType<B>>) => Promise<void> | void} [run]
+ * @param {object} [options]
+ * @param {ReincarnateOptions} [options.fromIncarnation]
+ * @param {boolean} [options.cleanStart]
+ */
+export const startLife = async (
+  build,
+  run,
+  { fromIncarnation, cleanStart } = {},
+) => {
+  await eventLoopIteration();
+  if (cleanStart) annihilate();
+  const oldIncarnationNumber = incarnationNumber;
+  const oldIncarnation = incarnation;
+  const disconnectionObject = makeUpgradeDisconnection(
+    'vat upgraded',
+    oldIncarnationNumber,
+  );
+  const { fakeVomKit } = nextLife(fromIncarnation);
+  /** @type {Map<string, PromiseKit<any>>} */
+  const previouslyWatchedPromises = new Map();
+  let buildTools;
+  try {
+    buildTools = await build(getBaggage());
+    fakeVomKit.wpm.loadWatchedPromiseTable(vref => {
+      // See revivePromise in liveslots.js
+      const { getValForSlot, valToSlot, setValForSlot } = fakeVomKit.fakeStuff;
+      // Assume all promises were decided by the previous incarnation
+      !getValForSlot(vref) || Fail`Attempting to revive known promise ${vref}`;
+      const pk = makePromiseKit();
+      previouslyWatchedPromises.set(vref, pk);
+      const val = pk.promise;
+      valToSlot.set(val, vref);
+      setValForSlot(vref, val);
+      return val;
+    });
+
+    fakeVomKit.vom.insistAllDurableKindsReconnected();
+
+    await eventLoopIteration();
+    // End of start crank
+  } catch (err) {
+    // Rollback upgrade
+    incarnation = oldIncarnation;
+    incarnationNumber = oldIncarnationNumber;
+    throw err;
+  }
+
+  // Simulate a dispatch of previously decided promise rejections
+  // In real swingset this could happen after some deliveries
+  for (const { reject } of previouslyWatchedPromises.values()) {
+    reject(disconnectionObject);
+  }
+  await eventLoopIteration();
+  // End of resolution dispatch crank
+
+  if (run) {
+    await run(buildTools);
+    await eventLoopIteration();
+  }
+
+  return incarnation;
+};
+
+// Setup the initial incarnation
+annihilate();

package/tools/prepare-test-env.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prepare-test-env.d.ts.map

package/tools/prepare-test-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-test-env.d.ts","sourceRoot":"","sources":["prepare-test-env.js"],"names":[],"mappings":""}

package/tools/prepare-test-env.js

@@ -0,0 +1,13 @@
+/**
+ * Prepare Agoric SwingSet vat global environment for testing.
+ *
+ * Installs Hardened JS (and does lockdown), plus adds mocks for virtual objects
+ * and stores.
+ */
+
+import '@agoric/internal/src/install-ses-debug.js';
+
+import { reincarnate } from './setup-vat-data.js';
+
+// Install the VatData globals.
+reincarnate();

package/tools/setup-vat-data.d.ts

@@ -0,0 +1,9 @@
+export function flushIncarnation(options?: Partial<ReincarnateOptions>): Omit<ReincarnateOptions, "fakeVomKit">;
+export function reincarnate(options?: Partial<ReincarnateOptions>): ReincarnateOptions;
+export type FakeVomKit = ReturnType<typeof makeFakeVirtualStuff>;
+export type ReincarnateOptions = import("@agoric/internal").Simplify<Omit<NonNullable<Parameters<typeof makeFakeVirtualStuff>[0]>, "WeakMap" | "WeakSet"> & {
+    fakeVomKit: FakeVomKit;
+    fakeStore: Map<string, string>;
+}>;
+import { makeFakeVirtualStuff } from './fakeVirtualSupport.js';
+//# sourceMappingURL=setup-vat-data.d.ts.map

package/tools/setup-vat-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-vat-data.d.ts","sourceRoot":"","sources":["setup-vat-data.js"],"names":[],"mappings":"AA2DO,2CAHI,OAAO,CAAC,kBAAkB,CAAC,GACzB,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAelD;AAOM,sCAHI,OAAO,CAAC,kBAAkB,CAAC,GACzB,kBAAkB,CAiB9B;yBAjFa,UAAU,CAAC,OAAO,oBAAoB,CAAC;iCAmCxC,OAAO,kBAAkB,EAAE,QAAQ,CAC3C,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC,GACxF;IAAM,UAAU,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAC3D;qCA1CiC,yBAAyB"}

package/tools/setup-vat-data.js

@@ -0,0 +1,95 @@
+/* global globalThis */
+
+// This file produces the globalThis.VatData property outside of a
+// running SwingSet so that it can be used by '@agoric/vat-data'
+// (which only *consumes* `globalThis.VatData`) in code under test. It
+// also populates the passStyleOf symbol-named property.
+
+import { passStyleOf } from '@endo/pass-style';
+import { PassStyleOfEndowmentSymbol } from '@endo/pass-style/endow.js';
+import { makeFakeVirtualStuff } from './fakeVirtualSupport.js';
+
+const { WeakMap, WeakSet } = globalThis;
+
+/** @typedef {ReturnType<typeof makeFakeVirtualStuff>} FakeVomKit */
+
+/** @type {FakeVomKit} */
+let fakeVomKit;
+
+globalThis.VatData = harden({
+  // @ts-expect-error spread argument for non-rest parameter
+  defineKind: (...args) => fakeVomKit.vom.defineKind(...args),
+  // @ts-expect-error spread argument for non-rest parameter
+  defineKindMulti: (...args) => fakeVomKit.vom.defineKindMulti(...args),
+  // @ts-expect-error spread argument for non-rest parameter
+  defineDurableKind: (...args) => fakeVomKit.vom.defineDurableKind(...args),
+  defineDurableKindMulti: (...args) =>
+    // @ts-expect-error spread argument for non-rest parameter
+    fakeVomKit.vom.defineDurableKindMulti(...args),
+  makeKindHandle: tag => fakeVomKit.vom.makeKindHandle(tag),
+  canBeDurable: (...args) => fakeVomKit.vom.canBeDurable(...args),
+  providePromiseWatcher: (...args) =>
+    // @ts-expect-error spread argument for non-rest parameter
+    fakeVomKit.wpm.providePromiseWatcher(...args),
+  watchPromise: (p, watcher, ...args) =>
+    fakeVomKit.wpm.watchPromise(p, watcher, ...args),
+  makeScalarBigMapStore: (...args) =>
+    fakeVomKit.cm.makeScalarBigMapStore(...args),
+  makeScalarBigWeakMapStore: (...args) =>
+    fakeVomKit.cm.makeScalarBigWeakMapStore(...args),
+  makeScalarBigSetStore: (...args) =>
+    fakeVomKit.cm.makeScalarBigSetStore(...args),
+  makeScalarBigWeakSetStore: (...args) =>
+    fakeVomKit.cm.makeScalarBigWeakSetStore(...args),
+});
+
+globalThis[PassStyleOfEndowmentSymbol] = passStyleOf;
+
+/**
+ * @typedef {import("@agoric/internal").Simplify<
+ *   Omit<NonNullable<Parameters<typeof makeFakeVirtualStuff>[0]>, 'WeakMap' | 'WeakSet'> &
+ *   { fakeVomKit: FakeVomKit; fakeStore: Map<string, string> }
+ * >} ReincarnateOptions
+ */
+
+/**
+ *
+ * @param {Partial<ReincarnateOptions>} options
+ * @returns {Omit<ReincarnateOptions, 'fakeVomKit'>}
+ */
+export const flushIncarnation = (options = {}) => {
+  const { fakeVomKit: fvk = fakeVomKit, ...fakeStuffOptions } = options;
+
+  if (fvk) {
+    fvk.vom.flushStateCache();
+    fvk.cm.flushSchemaCache();
+    fvk.vrm.flushIDCounters();
+  }
+
+  // Clone previous fakeStore (if any) to avoid mutations from previous incarnation
+  const fakeStore = new Map(options.fakeStore);
+
+  return { ...fakeStuffOptions, fakeStore };
+};
+
+/**
+ *
+ * @param {Partial<ReincarnateOptions>} options
+ * @returns {ReincarnateOptions}
+ */
+export const reincarnate = (options = {}) => {
+  const clonedIncarnation = flushIncarnation(options);
+
+  fakeVomKit = makeFakeVirtualStuff({
+    ...clonedIncarnation,
+    WeakMap,
+    WeakSet,
+  });
+
+  // @ts-expect-error toStringTag set imperatively so it doesn't show up in the type
+  globalThis.WeakMap = fakeVomKit.vom.VirtualObjectAwareWeakMap;
+  // @ts-expect-error ditto
+  globalThis.WeakSet = fakeVomKit.vom.VirtualObjectAwareWeakSet;
+
+  return { ...clonedIncarnation, fakeVomKit };
+};

package/tools/vo-test-harness.d.ts

@@ -0,0 +1,33 @@
+export function runVOTest(t: any, prepare: any, makeTestObject: any, testTestObject: any): Promise<void>;
+export function makeSpy(t: import("ava").ExecutionContext): {
+    fail: (msg: any) => void;
+    falsy: (check: any, msg: any) => void;
+    failureMessage: string;
+    falsyMessage: string;
+    context: unknown;
+    title: string;
+    passed: boolean;
+    log: import("ava").LogFn;
+    plan: import("ava").PlanFn;
+    teardown: import("ava").TeardownFn;
+    timeout: import("ava").TimeoutFn;
+    try: import("ava").TryFn<unknown>;
+    assert: import("ava").AssertAssertion;
+    deepEqual: import("ava").DeepEqualAssertion;
+    like: import("ava").LikeAssertion;
+    false: import("ava").FalseAssertion;
+    is: import("ava").IsAssertion;
+    not: import("ava").NotAssertion;
+    notDeepEqual: import("ava").NotDeepEqualAssertion;
+    notRegex: import("ava").NotRegexAssertion;
+    notThrows: import("ava").NotThrowsAssertion;
+    notThrowsAsync: import("ava").NotThrowsAsyncAssertion;
+    pass: import("ava").PassAssertion;
+    regex: import("ava").RegexAssertion;
+    snapshot: import("ava").SnapshotAssertion;
+    throws: import("ava").ThrowsAssertion;
+    throwsAsync: import("ava").ThrowsAsyncAssertion;
+    true: import("ava").TrueAssertion;
+    truthy: import("ava").TruthyAssertion;
+};
+//# sourceMappingURL=vo-test-harness.d.ts.map

package/tools/vo-test-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vo-test-harness.d.ts","sourceRoot":"","sources":["vo-test-harness.js"],"names":[],"mappings":"AA8FA,yGAqEC;AAxJM,2BAFI,OAAO,KAAK,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBxC"}

package/tools/vo-test-harness.js

@@ -0,0 +1,164 @@
+import { Far } from '@endo/marshal';
+import { setupTestLiveslots } from '../test/liveslots-helpers.js';
+
+// This file contains a test harness for virtual objects. runVOTest()
+// is to to help verify that a VO can be garbage collected and then
+// reloaded from persistent storage while maintaining functionality.
+
+/**
+ * A spy wrapping Ava's t for tests that are testing the harness itself.
+ * @param {import('ava').ExecutionContext} t
+ */
+export const makeSpy = t => {
+  const tSpy = {
+    ...t,
+    fail: msg => {
+      tSpy.failureMessage = msg;
+    },
+    // In Ava 6, assertions throw?
+    falsy: (check, msg) => {
+      if (!check) return;
+      tSpy.falsyMessage = msg;
+    },
+    failureMessage: '',
+    falsyMessage: '',
+  };
+  return tSpy;
+};
+
+// Testing VO swapping with runVOTest:
+//
+// Step 1: import the necessary harness paraphernalia
+//
+//   import { test, runVOTest } from '@agoric/swingset-vat/tools/vo-test-harness.js';
+//
+// `test` is the regular Ava test object that you'd normally import from
+// `@agoric/swingset-vat/tools/prepare-test-env-ava.js`.  The test harness will
+// import it for you, since it needs to set up some test things itself.
+//
+// Step 2: write three functions that you will pass to the test harness
+//
+// `prepare(VatData)` should perform any necessary environmental setup that the
+// virtual object kind under test will require.  In particular, this includes
+// executing any necessary `defineKind` or `defineDurableKind` calls to
+// establish the VO itself.  The `VatData` parameter is a regular `VatData`
+// object that can be used to obtain functions like `defineKind`.
+//
+// `makeTestObject()` should create and return an instance of the VO to be tested.
+//
+// `testTestObject(obj, phase)` should execute whatever actual testing and test
+// assertions you care to perform to verify your VO kind.  `obj` will be a
+// reference to an in-memory representative of the virtual object being tested
+// and `phase` will be a string, either 'before' or 'after', indicating whether
+// this instance of the object is before or after having been swapped out of
+// memory and then reloaded.  A correctly functioning VO should, among other
+// things, behave exactly the same in both cases.
+//
+// Step 3: write an Ava test that invokes the test harness
+//
+// The outer portion of this should be a conventional Ava test written in the
+// conventional way, e.g.:
+//
+// test('test name', async t => {
+//   ...your test here...
+// });
+//
+// The body of your test most likely will enclose the three functions described
+// above, since your `testTestObject` function (and possibly the others,
+// depending on how you code things) will need access to the `t` object in order
+// to execute test assertions.  Then, from inside your test invoke:
+//
+//   await runVOTest(t, prepare, makeTestObject, testTestObject);
+//
+// This will:
+//   1 - execute the `prepare` function
+//   2 - create a test object instance via `makeTestObject`
+//   3 - run `testTestObject` on the test object (this is the 'before' phase)
+//   4 - drop all in-memory references to the test object and force a GC pass
+//   5 - run `testTestObject` on the test object *again* (this is the 'after' phase)
+//
+// The key thing that the test harness provides for you is step 4, which
+// packages up some awkward boilerplate that's a bit of mysterious if you're not
+// already pretty familiar with how the VO GC mechanism works (or perhaps even
+// if you are).
+//
+// Note: It is critical that none of your own code retain any in-memory
+// references to the test object beyond step 3.  However, another key service
+// that the test harness provides is to detect if you did this and if so fail
+// the test.  One use of the test harness is to verify that you aren't
+// accidentally holding such references when you didn't mean to.
+//
+// The SwingSet test `vo-test-harness/test-vo-test-harness.js` is a test of the
+// VO test harness itself, but can be used as a simple example of how to set
+// things up.
+
+export async function runVOTest(t, prepare, makeTestObject, testTestObject) {
+  function buildRootObject(vatPowers) {
+    const { VatData } = vatPowers;
+    const { defineKind } = VatData;
+
+    const freeChecker = new WeakSet();
+
+    const makeSlug = defineKind('slug', label => ({ label }), {
+      getLabel: ({ state }) => state.label,
+    });
+    const cacheDisplacer = makeSlug('cacheDisplacer');
+
+    const makeHolder = defineKind('holder', (held = null) => ({ held }), {
+      setValue: ({ state }, value) => {
+        state.held = value;
+      },
+      getValue: ({ state }) => state.held,
+    });
+    const holder = makeHolder();
+
+    let held = null;
+
+    prepare(VatData);
+
+    function displaceCache() {
+      return cacheDisplacer.getLabel();
+    }
+
+    return Far('root', {
+      makeAndHold() {
+        held = makeTestObject();
+        freeChecker.add(held);
+        displaceCache();
+      },
+      storeHeld() {
+        holder.setValue(held);
+        displaceCache();
+      },
+      dropHeld() {
+        held = null;
+        displaceCache();
+      },
+      fetchAndHold() {
+        held = holder.getValue();
+        t.falsy(
+          freeChecker.has(held),
+          'somebody continues to hold test object',
+        );
+        displaceCache();
+      },
+      testHeld(phase) {
+        testTestObject(held, phase);
+      },
+    });
+  }
+
+  const { dispatchMessage } = await setupTestLiveslots(
+    t,
+    buildRootObject,
+    'bob',
+    { forceGC: true, skipLogging: true },
+  );
+
+  await dispatchMessage('makeAndHold');
+  await dispatchMessage('testHeld', 'before');
+  await dispatchMessage('storeHeld');
+  await dispatchMessage('dropHeld');
+  await dispatchMessage('fetchAndHold');
+  await dispatchMessage('testHeld', 'after');
+}

package/CHANGELOG.md

@@ -1,61 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-### [0.10.3-u11.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/swingset-liveslots@0.10.2...@agoric/swingset-liveslots@0.10.3-u11.0) (2023-08-24)
-
-**Note:** Version bump only for package @agoric/swingset-liveslots
-
-
-
-
-
-### [0.10.2](https://github.com/Agoric/agoric-sdk/compare/@agoric/swingset-liveslots@0.10.1...@agoric/swingset-liveslots@0.10.2) (2023-06-02)
-
-**Note:** Version bump only for package @agoric/swingset-liveslots
-
-
-
-
-
-### [0.10.1](https://github.com/Agoric/agoric-sdk/compare/@agoric/swingset-liveslots@0.10.0...@agoric/swingset-liveslots@0.10.1) (2023-05-24)
-
-**Note:** Version bump only for package @agoric/swingset-liveslots
-
-
-
-
-
-## 0.10.0 (2023-05-19)
-
-
-### Features
-
-* better diagnostic for failed reanimate ([c0c9c94](https://github.com/Agoric/agoric-sdk/commit/c0c9c9433648d520aa2bcdbadbbfe877831567c7)), closes [Error#1](https://github.com/Agoric/Error/issues/1)
-* **swingset-liveslots:** label virtual instances ([4191eb6](https://github.com/Agoric/agoric-sdk/commit/4191eb62d0e64048c3c715e5f71a53a747267350))
-* add APIs for tracking/debugging undesired object retention (aka "leaks") ([0a7221b](https://github.com/Agoric/agoric-sdk/commit/0a7221b3c04f3b2894c30346fa2ea6fb0130c046)), closes [#7318](https://github.com/Agoric/agoric-sdk/issues/7318)
-* move liveslots and specific tests to a new package ([0921a89](https://github.com/Agoric/agoric-sdk/commit/0921a8903b72cfefdf05a5906bcfb826cac1cc2f)), closes [#6596](https://github.com/Agoric/agoric-sdk/issues/6596)
-
-
-### Bug Fixes
-
-* **liveslots:** allow new Kind upgrade to add new facets ([6bc6694](https://github.com/Agoric/agoric-sdk/commit/6bc6694968e6d2f529e7c91ec1efb11fdff2e2d3)), closes [#7437](https://github.com/Agoric/agoric-sdk/issues/7437)
-* **liveslots:** retain WeakRefs to voAware collections ([3935723](https://github.com/Agoric/agoric-sdk/commit/393572396781afd17691e1366abeba696228a24e)), closes [#7371](https://github.com/Agoric/agoric-sdk/issues/7371)
-* **swingset-liveslots:** prevent VOM infinite loop if `globalThis.WeakSet` etc are replaced ([d7b35e2](https://github.com/Agoric/agoric-sdk/commit/d7b35e28715a715ef510f2717e0040fa017caab4))
-* adding dup entries to virtual sets is OK ([c81d367](https://github.com/Agoric/agoric-sdk/commit/c81d3677d8085eb4debe5baa416816ff94d582cf)), closes [#7234](https://github.com/Agoric/agoric-sdk/issues/7234)
-* code updates for new marshal ([292f971](https://github.com/Agoric/agoric-sdk/commit/292f971769db69e61782f96638c2f687c3f95ac2))
-* **SwingSet:** Don't send stopVat during upgrade ([5cc47d2](https://github.com/Agoric/agoric-sdk/commit/5cc47d2d8892690f8c1653630b41dd64cc42d73b)), closes [#6650](https://github.com/Agoric/agoric-sdk/issues/6650)
-* **types:** return value of deleter ([457f576](https://github.com/Agoric/agoric-sdk/commit/457f5765b9fc0a693e6eb5e6644ddf4af3b791db))
-* move many type definitions from swingset to liveslots ([727143d](https://github.com/Agoric/agoric-sdk/commit/727143d5562498e2e3013c34304f229b4dd11da5))
-* move rejectAllPromises from stopVat to kernels-side upgradeVat ([d79623f](https://github.com/Agoric/agoric-sdk/commit/d79623f3fb3b87653dba1c71eb1153711c9d962c)), closes [#6694](https://github.com/Agoric/agoric-sdk/issues/6694)
-* Move upgrade-time abandonExports responsibility into the kernel ([66ac657](https://github.com/Agoric/agoric-sdk/commit/66ac657d51d3d1be61ee4a6e9a621a664086ee57)), closes [#6696](https://github.com/Agoric/agoric-sdk/issues/6696)
-* only the exo api change ([5cf3bf1](https://github.com/Agoric/agoric-sdk/commit/5cf3bf10a71dd02094365a66e87032e5d17d004f))
-* **liveslots:** use Map for vrefStatus, not object ([1456e2a](https://github.com/Agoric/agoric-sdk/commit/1456e2ae006bb1c702383cedda5e5c407968840e))
-* **swingset:** move a bunch of types from swingset to swingset-liveslots ([14f9bb0](https://github.com/Agoric/agoric-sdk/commit/14f9bb00c82c085dc647f23b6c90b26e6a0a6dfd))
-* **swingset-liveslots:** Move promise rejection responsibility into the kernel ([dd29ff3](https://github.com/Agoric/agoric-sdk/commit/dd29ff35c5dc72efbbf7087849182aa7f04b2bb1)), closes [#6694](https://github.com/Agoric/agoric-sdk/issues/6694)
-* add 'v'/'d' virtual/durable annotations to vrefs ([b859e92](https://github.com/Agoric/agoric-sdk/commit/b859e92fe041415d6e34250f672a10ad927aa33e)), closes [#6695](https://github.com/Agoric/agoric-sdk/issues/6695)
-* update description of "FINALIZED" state ([809f366](https://github.com/Agoric/agoric-sdk/commit/809f3660c083467e76deb1487015cb24205a801d))
-* without assertKeyPattern ([#7035](https://github.com/Agoric/agoric-sdk/issues/7035)) ([c9fcd7f](https://github.com/Agoric/agoric-sdk/commit/c9fcd7f82757732435cd96f3377e4fbfb6586ce7))
-* **swingset-liveslots:** copy helper files to new liveslots package ([be7229f](https://github.com/Agoric/agoric-sdk/commit/be7229f7217c1ecc523069a57945a372f4a1e00e))
-* **swingset-liveslots:** update imports of helper files ([0b4b38a](https://github.com/Agoric/agoric-sdk/commit/0b4b38a1f9efbb3e1e860172b0b802548d18ae2e))

package/test/kmarshal.js

@@ -1,79 +0,0 @@
-import { Far, makeMarshal, passStyleOf } from '@endo/marshal';
-import { assert } from '@agoric/assert';
-
-// Simple wrapper for serializing and unserializing marshalled values inside the
-// kernel, where we don't actually want to use clists nor actually allocate real
-// objects, but instead to stay entirely within the domain of krefs.  This is
-// used to enable syntactic manipulation of serialized values while remaining
-// agnostic about the internal details of the serialization encoding.
-
-const refMap = new WeakMap();
-
-export const kslot = (kref, iface) => {
-  assert.typeof(kref, 'string');
-  if (iface && iface.startsWith('Alleged: ')) {
-    // Encoder prepends "Alleged: " to iface string, but the decoder doesn't strip it
-    // Unclear whether it's the decoder or me who is wrong
-    iface = iface.slice(9);
-  }
-  if (
-    kref.startsWith('p') ||
-    kref.startsWith('kp') ||
-    kref.startsWith('lp') ||
-    kref.startsWith('rp')
-  ) {
-    // TODO: temporary hack because smallcaps encodes promise references
-    // differently from remotable object references, and the current version of
-    // the smallcaps decoder annoyingly insists that if the encoded body string
-    // says a slot is a promise, then convertSlotToVal had better by damn return
-    // an actual Promise, even if, as in the intended use case here, we neither
-    // want nor need a promise, nor the overhead of a map to keep track of it
-    // with.  This behavior is in service of defense against a hypothesized
-    // security issue whose exact nature has largely been forgotton in the
-    // months since it was first encountered.  MarkM is currently researching
-    // what the problem was thought to have been, to see if it is real and to
-    // understand it if so.  This will eventually result in either changes to
-    // the smallcaps encoding or to the marshal setup API to support the purely
-    // manipulative use case.  In the meantime, this ugliness...
-    const p = new Promise(() => undefined);
-    refMap.set(p, kref);
-    return harden(p);
-  } else {
-    const o = Far(iface, {
-      iface: () => iface,
-      getKref: () => `${kref}`,
-    });
-    return o;
-  }
-};
-
-export const krefOf = obj => {
-  const fromMap = refMap.get(obj);
-  if (fromMap) {
-    return fromMap;
-  }
-  // When krefOf() is called as part of kmarshal.serialize, marshal
-  // will only give it things that are 'remotable' (Promises and the
-  // Far objects created by kslot()).  When krefOf() is called by
-  // kernel code (as part of extractSingleSlot() or the vat-comms
-  // equivalent), it ought to throw if 'obj' is not one of the Far
-  // objects created by our kslot().
-  assert.equal(passStyleOf(obj), 'remotable', obj);
-  const getKref = obj.getKref;
-  assert.typeof(getKref, 'function');
-  return getKref();
-};
-
-const kmarshal = makeMarshal(krefOf, kslot, {
-  serializeBodyFormat: 'smallcaps',
-  errorTagging: 'off',
-});
-
-export const kser = value => kmarshal.serialize(harden(value));
-
-export const kunser = serializedValue => kmarshal.unserialize(serializedValue);
-
-export function makeError(message) {
-  assert.typeof(message, 'string');
-  return kser(Error(message));
-}