@agoric/zone 0.2.3-other-dev-8f8782b.0 → 0.2.3-other-dev-fbe72e7.0.fbe72e7

package/CHANGELOG.md

@@ -3,14 +3,6 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-### [0.2.3-u11.0](https://github.com/Agoric/agoric-sdk/compare/@agoric/zone@0.2.2...@agoric/zone@0.2.3-u11.0) (2023-08-24)
-
-**Note:** Version bump only for package @agoric/zone
-
-
-
-
-
 ### [0.2.2](https://github.com/Agoric/agoric-sdk/compare/@agoric/zone@0.2.1...@agoric/zone@0.2.2) (2023-06-02)
 
 **Note:** Version bump only for package @agoric/zone

package/README.md

@@ -12,18 +12,18 @@ An example of making a Zone-aware vat might look something like this:
 
 ```js
 import { makeDurableZone } from '@agoric/zone/durable.js';
-import { zoneFrobulator } from 'frob-package';
-import { zoneWidget } from 'widget-package';
+import { prepareFrobulator } from 'frob-package';
+import { prepareWidget } from 'widget-package';
 
 export const buildRootObject = (vatPowers, _args, baggage) => {
   const zone = makeDurableZone(baggage);
 
   // Ensure that Widgets cannot interfere with Frobs.
-  const makeWidget = zoneWidget(zone.subZone('Widgets'));
+  const makeWidget = prepareWidget(zone.subZone('Widgets'));
 
   // Create a collection of frobulators.
   const frobZone = zone.subZone('Frobs');
-  const makeFrobulator = zoneFrobulator(frobZone);
+  const makeFrobulator = prepareFrobulator(frobZone);
   const widgetToFrob = frobZone.mapStore('widgetToFrob');
 
   return Far('WidgetFrobulator', {

package/durable.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/durable.js";
+//# sourceMappingURL=durable.d.ts.map

package/durable.d.ts.map

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

package/heap.d.ts

@@ -0,0 +1,2 @@
+export * from "@agoric/base-zone/heap.js";
+//# sourceMappingURL=heap.d.ts.map

package/heap.d.ts.map

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

package/heap.js

@@ -1,3 +1,3 @@
 // @jessie-check
 
-export * from './src/heap.js';
+export * from '@agoric/base-zone/heap.js';

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@agoric/zone",
-  "version": "0.2.3-other-dev-8f8782b.0+8f8782b",
+  "version": "0.2.3-other-dev-fbe72e7.0.fbe72e7",
   "description": "Allocation zone abstraction for objects on the heap, persistent stores, etc.",
   "type": "module",
   "repository": "https://github.com/Agoric/agoric-sdk",
   "main": "./src/index.js",
   "scripts": {
     "build": "exit 0",
-    "test": "true || ava",
-    "test:c8": "true || c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
+    "prepack": "yarn run -T tsc --build tsconfig.build.json",
+    "postpack": "git clean -f '*.d.*ts*' '*.tsbuildinfo'",
+    "test": "ava",
+    "test:c8": "c8 --all ${C8_OPTIONS:-} ava",
     "test:xs": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
-    "lint": "run-s --continue-on-error lint:*",
-    "lint:types": "tsc -p jsconfig.json",
-    "lint:eslint": "eslint ."
+    "lint": "yarn run -T run-s --continue-on-error 'lint:*'",
+    "lint:types": "yarn run -T tsc",
+    "lint:eslint": "yarn run -T eslint ."
   },
   "exports": {
     ".": "./src/index.js",
@@ -25,22 +27,35 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/store": "0.9.3-other-dev-8f8782b.0+8f8782b",
-    "@agoric/vat-data": "0.5.3-other-dev-8f8782b.0+8f8782b",
-    "@endo/far": "0.2.18"
+    "@agoric/base-zone": "0.1.1-other-dev-fbe72e7.0.fbe72e7",
+    "@agoric/vat-data": "0.5.3-other-dev-fbe72e7.0.fbe72e7",
+    "@endo/errors": "^1.2.13",
+    "@endo/far": "^1.1.14",
+    "@endo/pass-style": "^1.6.3"
+  },
+  "devDependencies": {
+    "@agoric/swingset-vat": "0.32.3-other-dev-fbe72e7.0.fbe72e7",
+    "@endo/patterns": "^1.7.0",
+    "ava": "^5.3.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": ">=14.15.0"
+    "node": "^20.9 || ^22.11"
   },
   "ava": {
     "files": [
-      "test/**/test-*.js"
+      "test/**/*.test.*"
+    ],
+    "require": [
+      "@endo/init/debug.js"
     ],
     "timeout": "20m",
     "workerThreads": false
   },
-  "gitHead": "8f8782bc52393e9d4fc82523ecf31cab429b11b3"
+  "typeCoverage": {
+    "atLeast": 94
+  },
+  "gitHead": "fbe72e72107f9997f788674e668c660d92ec4492"
 }

package/src/durable.d.ts

@@ -0,0 +1,3 @@
+export function makeDurableZone(baggage: import("@agoric/vat-data").Baggage, baseLabel?: string): Zone;
+import type { Zone } from './index.js';
+//# sourceMappingURL=durable.d.ts.map

package/src/durable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable.d.ts","sourceRoot":"","sources":["durable.js"],"names":[],"mappings":"AA6EO,yCAJI,OAAO,kBAAkB,EAAE,OAAO,cAClC,MAAM,GACJ,IAAI,CA+ChB;0BApGsB,YAAY"}

package/src/durable.js

@@ -1,5 +1,9 @@
+// @ts-check
 // @jessie-check
 
+import { Fail } from '@endo/errors';
+import { Far, isPassable } from '@endo/pass-style';
+
 import {
   canBeDurable,
   makeScalarMapStore,
@@ -10,35 +14,48 @@ import {
   provideDurableSetStore,
   provideDurableWeakMapStore,
   provideDurableWeakSetStore,
-  M,
+  watchPromise,
 } from '@agoric/vat-data';
 
-import { Far } from '@endo/far';
+import { agoricVatDataKeys as keys, makeOnceKit } from '@agoric/base-zone';
+
+/**
+ * @import {Zone} from './index.js';
+ */
 
-const { Fail } = assert;
+/**
+ * A variant of `canBeDurable` that returns `false` instead of ever throwing.
+ *
+ * @param {unknown} specimen
+ * @returns {boolean}
+ */
+const isStorable = specimen => isPassable(specimen) && canBeDurable(specimen);
+harden(isStorable);
 
 /**
  * @param {() => import('@agoric/vat-data').Baggage} getBaggage
  */
 const attachDurableStores = getBaggage => {
-  /** @type {import('.').Zone['mapStore']} */
-  const mapStore = (label, options) =>
-    provideDurableMapStore(getBaggage(), label, options);
-  /** @type {import('.').Zone['setStore']} */
+  /** @type {Zone['mapStore']} */
+  const mapStore = (label, options) => {
+    const baggage = getBaggage();
+    const ret = provideDurableMapStore(baggage, label, options);
+    return ret;
+  };
+  /** @type {Zone['setStore']} */
   const setStore = (label, options) =>
     provideDurableSetStore(getBaggage(), label, options);
-  /** @type {import('.').Zone['weakSetStore']} */
+  /** @type {Zone['weakSetStore']} */
   const weakSetStore = (label, options) =>
     provideDurableWeakSetStore(getBaggage(), label, options);
-  /** @type {import('.').Zone['weakMapStore']} */
+  /** @type {Zone['weakMapStore']} */
   const weakMapStore = (label, options) =>
     provideDurableWeakMapStore(getBaggage(), label, options);
 
-  /** @type {import('.').Stores} */
+  /** @type {import('./index.js').Stores} */
   return Far('durableStores', {
-    // eslint-disable-next-line no-use-before-define
     detached: () => detachedDurableStores,
-    isStorable: canBeDurable,
+    isStorable,
     mapStore,
     setStore,
     weakMapStore,
@@ -46,8 +63,8 @@ const attachDurableStores = getBaggage => {
   });
 };
 
-/** @type {import('.').Stores} */
-export const detachedDurableStores = attachDurableStores(() =>
+/** @type {import('./index.js').Stores} */
+const detachedDurableStores = attachDurableStores(() =>
   makeScalarMapStore('detached'),
 );
 
@@ -55,33 +72,53 @@ export const detachedDurableStores = attachDurableStores(() =>
  * Create a zone whose objects persist between Agoric vat upgrades.
  *
  * @param {import('@agoric/vat-data').Baggage} baggage
- * @returns {import('.').Zone}
+ * @param {string} [baseLabel]
+ * @returns {Zone}
  */
-export const makeDurableZone = baggage => {
+export const makeDurableZone = (baggage, baseLabel = 'durableZone') => {
   baggage || Fail`baggage required`;
-  /** @type {import('.').Zone['exoClass']} */
+
+  const attachedStores = attachDurableStores(() => baggage);
+
+  const { makeOnce, wrapProvider } = makeOnceKit(
+    baseLabel,
+    attachedStores,
+    baggage,
+  );
+
+  /** @type {Zone['exoClass']} */
   const exoClass = (...args) => prepareExoClass(baggage, ...args);
-  /** @type {import('.').Zone['exoClassKit']} */
+  /** @type {Zone['exoClassKit']} */
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- happens only integrating with Endo master
+  // @ts-ignore FIXME in Endo
   const exoClassKit = (...args) => prepareExoClassKit(baggage, ...args);
-  /** @type {import('.').Zone['exo']} */
+  /** @type {Zone['exo']} */
   const exo = (...args) => prepareExo(baggage, ...args);
 
-  const attachedStores = attachDurableStores(() => baggage);
+  const subZoneStore = wrapProvider(attachedStores.mapStore, keys.zone);
 
-  /** @type {import('.').Zone['subZone']} */
+  /** @type {Zone['subZone']} */
   const subZone = (label, options = {}) => {
-    const subBaggage = provideDurableMapStore(baggage, label, options);
-    return makeDurableZone(subBaggage);
+    /** @type {import('@agoric/swingset-liveslots').Baggage} */
+    const subBaggage = subZoneStore(label, options);
+    return makeDurableZone(subBaggage, `${baseLabel}.${label}`);
   };
 
   return Far('durableZone', {
-    exo,
-    exoClass,
-    exoClassKit,
+    exo: wrapProvider(exo, keys.exo),
+    exoClass: wrapProvider(exoClass, keys.exoClass),
+    exoClassKit: wrapProvider(exoClassKit, keys.exoClassKit),
     subZone,
-    ...attachedStores,
+
+    makeOnce,
+    watchPromise,
+    detached: attachedStores.detached,
+    isStorable: attachedStores.isStorable,
+
+    mapStore: wrapProvider(attachedStores.mapStore, keys.store),
+    setStore: wrapProvider(attachedStores.setStore, keys.store),
+    weakMapStore: wrapProvider(attachedStores.weakMapStore, keys.store),
+    weakSetStore: wrapProvider(attachedStores.weakSetStore, keys.store),
   });
 };
 harden(makeDurableZone);
-
-export { M };

package/src/exports.d.ts

@@ -0,0 +1,6 @@
+// Module Types //////////////////////////////////////////////////////
+//
+//   Types exposed from modules.
+//
+
+export type * from '@agoric/base-zone';

package/src/exports.js

@@ -0,0 +1,2 @@
+// Just a dummy to use exports.d.ts and satisfy runtime imports.
+export {};

package/src/index.d.ts

@@ -0,0 +1,3 @@
+export { makeHeapZone } from "@agoric/base-zone/heap.js";
+export * from "./exports.js";
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

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

package/src/index.js

@@ -1,37 +1,4 @@
-// @jessie-check
+export { makeHeapZone } from '@agoric/base-zone/heap.js';
 
-import { makeExo, defineExoClass, defineExoClassKit } from '@agoric/store';
-
-export * from './heap.js';
-
-// References to allow the below typeofs to succeed.
-makeExo;
-defineExoClass;
-defineExoClassKit;
-
-/**
- * @typedef {ExoZone & Stores} Zone A bag of methods for creating defensible objects and
- * collections with the same allocation semantics (ephemeral, persistent, etc)
- */
-
-/**
- * @typedef {object} ExoZone
- * @property {typeof makeExo} exo create a singleton exo-object instance bound to this zone
- * @property {typeof defineExoClass} exoClass create a maker function that can be used to create exo-objects bound to this zone
- * @property {typeof defineExoClassKit} exoClassKit create a "kit" maker function that can be used to create a record of exo-objects sharing the same state
- * @property {(label: string, options?: StoreOptions) => Zone} subZone create a new Zone that can be passed to untrusted consumers without exposing the storage of the parent zone
- */
-
-/**
- * @typedef {object} Stores
- * @property {() => Stores} detached obtain store providers which are detached (the stores are anonymous rather than bound to `label` in the zone)
- * @property {(specimen: unknown) => boolean} isStorable return true if the specimen can be stored in the zone, whether as exo-object state or in a store
- * @property {<K,V>(label: string, options?: StoreOptions) => MapStore<K, V>} mapStore provide a Map-like store named `label` in the zone
- * @property {<K>(label: string, options?: StoreOptions) => SetStore<K>} setStore provide a Set-like store named `label` in the zone
- * @property {<K,V>(
- *   label: string, options?: StoreOptions) => WeakMapStore<K, V>
- * } weakMapStore provide a WeakMap-like store named `label` in the zone
- * @property {<K>(
- *   label: string, options?: StoreOptions) => WeakSetStore<K>
- * } weakSetStore provide a WeakSet-like store named `label` in the zone
- */
+// eslint-disable-next-line import/export
+export * from './exports.js';

package/src/virtual.d.ts

@@ -0,0 +1,2 @@
+export function makeVirtualZone(baseLabel?: string): import(".").Zone;
+//# sourceMappingURL=virtual.d.ts.map

package/src/virtual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtual.d.ts","sourceRoot":"","sources":["virtual.js"],"names":[],"mappings":"AAiEO,4CAHI,MAAM,GACJ,OAAO,GAAG,EAAE,IAAI,CA+B5B"}

package/src/virtual.js

@@ -1,17 +1,21 @@
+// @ts-check
 // @jessie-check
 
+import { Far, isPassable } from '@endo/pass-style';
 import {
-  canBeDurable,
   defineVirtualExoClass,
   defineVirtualExoClassKit,
   makeScalarBigMapStore,
   makeScalarBigSetStore,
   makeScalarBigWeakMapStore,
   makeScalarBigWeakSetStore,
-  M,
 } from '@agoric/vat-data';
 
-import { Far } from '@endo/far';
+import {
+  agoricVatDataKeys as keys,
+  makeOnceKit,
+  watchPromise,
+} from '@agoric/base-zone';
 
 const emptyRecord = harden({});
 const initEmpty = harden(() => emptyRecord);
@@ -22,7 +26,7 @@ const initEmpty = harden(() => emptyRecord);
  *
  * @type {import('.').Zone['exo']}
  */
-const defineVirtualExo = (
+const makeVirtualExo = (
   label,
   interfaceGuard,
   methods,
@@ -43,9 +47,9 @@ const defineVirtualExo = (
 };
 
 /** @type {import('.').Stores} */
-export const detachedVirtualStores = Far('virtualStores', {
+const detachedVirtualStores = Far('virtualStores', {
   detached: () => detachedVirtualStores,
-  isStorable: canBeDurable,
+  isStorable: isPassable,
   mapStore: makeScalarBigMapStore,
   setStore: makeScalarBigSetStore,
   weakMapStore: makeScalarBigWeakMapStore,
@@ -56,15 +60,36 @@ export const detachedVirtualStores = Far('virtualStores', {
  * A zone that utilizes external storage to reduce the memory footprint of the
  * current vat.
  *
- * @type {import('.').Zone}
+ * @param {string} [baseLabel]
+ * @returns {import('.').Zone}
  */
-export const virtualZone = Far('virtualZone', {
-  exo: defineVirtualExo,
-  exoClass: defineVirtualExoClass,
-  exoClassKit: defineVirtualExoClassKit,
-  subZone: (_label, _options = {}) => virtualZone,
+export const makeVirtualZone = (baseLabel = 'virtualZone') => {
+  const { makeOnce, wrapProvider } = makeOnceKit(
+    baseLabel,
+    detachedVirtualStores,
+  );
 
-  ...detachedVirtualStores,
-});
+  /**
+   * @param {string} label
+   * @param {any} _options
+   */
+  const makeSubZone = (label, _options) =>
+    makeVirtualZone(`${baseLabel}.${label}`);
 
-export { M };
+  return Far('virtualZone', {
+    exo: wrapProvider(makeVirtualExo, keys.exo),
+    exoClass: wrapProvider(defineVirtualExoClass, keys.exoClass),
+    exoClassKit: wrapProvider(defineVirtualExoClassKit, keys.exoClassKit),
+    subZone: wrapProvider(makeSubZone),
+
+    makeOnce,
+    watchPromise,
+    detached: detachedVirtualStores.detached,
+    isStorable: detachedVirtualStores.isStorable,
+
+    mapStore: wrapProvider(detachedVirtualStores.mapStore),
+    setStore: wrapProvider(detachedVirtualStores.setStore),
+    weakMapStore: wrapProvider(detachedVirtualStores.weakMapStore),
+    weakSetStore: wrapProvider(detachedVirtualStores.weakSetStore),
+  });
+};

package/test/exos.test.js

@@ -0,0 +1,203 @@
+import { M } from '@endo/patterns';
+import {
+  annihilate,
+  getBaggage,
+  nextLife,
+  test,
+} from '@agoric/swingset-vat/tools/prepare-strict-test-env-ava.js';
+
+import * as vatData from '@agoric/vat-data';
+
+import { agoricVatDataKeys as keys } from '@agoric/base-zone';
+import {
+  agoricVatDataCompatibleKeys,
+  testFirstZoneIncarnation,
+  testSecondZoneIncarnation,
+  testGreeter,
+} from '@agoric/base-zone/tools/testers.js';
+import * as g from '@agoric/base-zone/tools/greeter.js';
+
+import { makeDurableZone } from '../durable.js';
+import { makeHeapZone } from '../heap.js';
+import { makeVirtualZone } from '../virtual.js';
+
+/**
+ * @param {import('ava').Assertions} t
+ * @param {MapStore} baggage
+ */
+const testFirstVatDataIncarnation = (t, baggage) => {
+  const subBaggage = vatData.provideDurableMapStore(baggage, 'sub');
+
+  const myThis = Object.freeze({ state: { nick: 'Singly' } });
+  const singly = vatData.prepareExo(subBaggage, 'a', g.GreeterWithAdminI, {
+    ...g.bindAllMethodsTo(g.greetFacet, myThis),
+    ...g.bindAllMethodsTo(g.adminFacet, myThis),
+  });
+  testGreeter(t, 'Singly', singly);
+
+  const makeGreeter = vatData.prepareExoClass(
+    subBaggage,
+    'Greeter',
+    g.GreeterWithAdminI,
+    nick => ({ nick }),
+    {
+      ...g.greetFacet,
+      ...g.adminFacet,
+    },
+  );
+  const classy = makeGreeter('Classy');
+  testGreeter(t, 'Classy', classy);
+
+  const makeGreeterKit = vatData.prepareExoClassKit(
+    subBaggage,
+    'GreeterKit',
+    { greeter: g.GreeterI, admin: g.GreeterAdminI },
+    nick => ({ nick }),
+    {
+      greeter: g.greetFacet,
+      admin: g.adminFacet,
+    },
+  );
+  const { greeter: kitty, admin: kittyAdmin } = makeGreeterKit('Kitty');
+  testGreeter(t, 'Kitty', kitty, kittyAdmin);
+
+  const mappish = vatData.provideDurableMapStore(subBaggage, 'mappish');
+  mappish.init('singly', singly);
+  mappish.init('classy', classy);
+  mappish.init('kitty', kitty);
+  mappish.init('kittyAdmin', kittyAdmin);
+
+  vatData.provideDurableMapStore(subBaggage, 'subsub');
+};
+
+test('heapZone', t => {
+  const zone = makeHeapZone();
+  testFirstZoneIncarnation(t, zone);
+});
+
+test.serial('virtualZone', t => {
+  annihilate();
+  const zone = makeVirtualZone();
+  testFirstZoneIncarnation(t, zone);
+});
+
+test.serial('durableZone', t => {
+  annihilate();
+
+  const expectedKeys = [
+    ...keys.exo('a'),
+    ...keys.exoClass('Greeter'),
+    ...keys.exoClassKit('GreeterKit'),
+    ...keys.store('mappish'),
+    ...keys.zone('subsub'),
+  ].sort();
+  t.deepEqual(agoricVatDataCompatibleKeys, expectedKeys);
+
+  nextLife();
+  const baggage1 = getBaggage();
+  testFirstZoneIncarnation(t, makeDurableZone(baggage1));
+  t.deepEqual(
+    [...baggage1.get('sub').keys()].sort(),
+    agoricVatDataCompatibleKeys,
+  );
+
+  nextLife();
+  const baggage2 = getBaggage();
+  t.deepEqual(
+    [...baggage2.get('sub').keys()].sort(),
+    agoricVatDataCompatibleKeys,
+  );
+  testSecondZoneIncarnation(t, makeDurableZone(baggage2));
+});
+
+test.serial('vatData migrate to durableZone', t => {
+  annihilate();
+
+  const baggage1 = getBaggage();
+  testFirstVatDataIncarnation(t, baggage1);
+  t.deepEqual(
+    [...baggage1.get('sub').keys()].sort(),
+    agoricVatDataCompatibleKeys,
+  );
+
+  nextLife();
+  const baggage2 = getBaggage();
+  testSecondZoneIncarnation(t, makeDurableZone(baggage2));
+});
+
+test.serial('exoClass stateShape expansion', t => {
+  annihilate();
+
+  // See ../../swingset-liveslots/test/virtual-objects/state-shape.test.js
+  const stateShapeMismatch = { message: /stateShape mismatch/ };
+  const HolderI = M.interface('Holder', {
+    get: M.call().rest(M.arrayOf(M.string())).returns(M.record()),
+    set: M.call(M.record()).returns(),
+  });
+  const initHolder = fields => ({ ...fields });
+  const holderMethods = {
+    get(...fields) {
+      const { state } = this;
+      // We require fields to be explicit because they are currently defined on
+      // the state *prototype*.
+      return Object.fromEntries(
+        fields.flatMap(key => (key in state ? [[key, state[key]]] : [])),
+      );
+    },
+    set(fields) {
+      Object.assign(this.state, fields);
+    },
+  };
+  const prepareHolder = (zone, stateShape) =>
+    zone.exoClass('Holder', HolderI, initHolder, holderMethods, { stateShape });
+
+  const fields = ['foo', 'bar', 'baz']; // but "baz" is not initially present
+  const baggage1 = getBaggage();
+  const zone1 = makeDurableZone(baggage1);
+  const makeHolder1 = prepareHolder(zone1, {
+    foo: M.number(),
+    bar: M.number(),
+  });
+  const holder1 = makeHolder1({ foo: 0, bar: 1 });
+  t.deepEqual(holder1.get(...fields), { foo: 0, bar: 1 });
+  holder1.set({ foo: 2, bar: 2 });
+  t.deepEqual(holder1.get(...fields), { foo: 2, bar: 2 });
+  t.throws(() => makeHolder1({ foo: 0, bar: 1, baz: 2 }));
+  t.throws(() => makeHolder1({ foo: 0, bar: 'string' }));
+
+  nextLife();
+  t.throws(
+    () =>
+      prepareHolder(makeDurableZone(getBaggage()), {
+        foo: M.string(),
+        bar: M.number(),
+      }),
+    stateShapeMismatch,
+    'backwards-incompatible stateShape change',
+  );
+
+  nextLife();
+  t.throws(
+    () =>
+      prepareHolder(makeDurableZone(getBaggage()), {
+        foo: M.or(M.number(), M.string()),
+        bar: M.number(),
+        baz: M.or(undefined, M.number()),
+      }),
+    stateShapeMismatch,
+    'stateShape field value expansion (needs #7407)',
+  );
+
+  nextLife();
+  const baggage2 = getBaggage();
+  const zone2 = makeDurableZone(baggage2);
+  const makeHolder2 = prepareHolder(zone2, {
+    foo: M.number(),
+    bar: M.number(),
+    baz: M.or(undefined, M.number()),
+  });
+  const holder2 = makeHolder2({ foo: 0, bar: 1, baz: 2 });
+  t.deepEqual(holder2.get(...fields), { foo: 0, bar: 1, baz: 2 });
+  holder2.set({ foo: 2, bar: 2, baz: undefined });
+  t.deepEqual(holder2.get(...fields), { foo: 2, bar: 2, baz: undefined });
+});

package/test/make-once.test.js

@@ -0,0 +1,66 @@
+import {
+  annihilate,
+  getBaggage,
+  nextLife,
+  test,
+} from '@agoric/swingset-vat/tools/prepare-strict-test-env-ava.js';
+
+import { makeDurableZone } from '../durable.js';
+import { makeHeapZone } from '../heap.js';
+import { makeVirtualZone } from '../virtual.js';
+
+/** @import {Zone} from '../src/index.js' */
+
+/**
+ * @param {import('ava').Assertions} t
+ * @param {Zone} rootZone
+ */
+const testOnce = (t, rootZone) => {
+  const subZone = rootZone.subZone('sub');
+  const a = subZone.makeOnce('a', () => 'A');
+  t.is(a, 'A');
+  t.throws(() => subZone.makeOnce('a', () => 'A'), {
+    message: /has already been used/,
+  });
+  const nonPassable = harden({
+    hello() {
+      return 'world';
+    },
+  });
+  t.is(rootZone.isStorable(nonPassable), false);
+  t.is(subZone.isStorable(123), true);
+  t.throws(() => rootZone.makeOnce('nonPassable', () => nonPassable), {
+    message: /is not storable/,
+  });
+};
+
+test('heapZone', t => {
+  testOnce(t, makeHeapZone());
+});
+
+test.serial('virtualZone', t => {
+  testOnce(t, makeVirtualZone());
+});
+
+test.serial('durableZone', t => {
+  annihilate();
+  const rootBaggage = getBaggage();
+  const rootDurableZone = makeDurableZone(rootBaggage);
+  testOnce(t, rootDurableZone);
+
+  // Do we actually want to refuse to use the same baggage twice?
+  const secondDurableZone = makeDurableZone(rootBaggage);
+  testOnce(t, secondDurableZone);
+  const subDurableZone = makeDurableZone(rootBaggage).subZone('sub');
+  t.is(
+    subDurableZone.makeOnce('a', () => 'B'),
+    'A',
+  );
+  t.throws(() => subDurableZone.makeOnce('a', () => 'B'), {
+    message: /has already been used/,
+  });
+
+  nextLife();
+  const thirdDurableZone = makeDurableZone(getBaggage());
+  testOnce(t, thirdDurableZone);
+});

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+    "extends": [
+        "./tsconfig.json",
+        "../../tsconfig-build-options.json"
+    ],
+    "exclude": [
+        "scripts",
+        "test",
+        "**/exports.js",
+    ]
+}

package/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./durable.js","./heap.js","./virtual.js","./src/durable.js","./src/index.js","./src/virtual.js"],"version":"5.9.2"}

package/tsconfig.json

@@ -0,0 +1,11 @@
+// This file can contain .js-specific Typescript compiler config.
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {},
+  "include": [
+    "*.js",
+    "scripts",
+    "src/**/*.js",
+    "test/**/*.js",
+  ],
+}

package/typedoc.json

@@ -0,0 +1,8 @@
+{
+    "extends": [
+        "../../typedoc.base.json"
+    ],
+    "entryPoints": [
+        "src/index.js",
+    ]
+}

package/virtual.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/virtual.js";
+//# sourceMappingURL=virtual.d.ts.map

package/virtual.d.ts.map

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

package/jsconfig.json

@@ -1,19 +0,0 @@
-// This file can contain .js-specific Typescript compiler config.
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "esnext",
-    "checkJs": true,
-    "noEmit": true,
-    "downlevelIteration": true,
-    "strictNullChecks": true,
-    "noImplicitThis": true,
-    "moduleResolution": "node",
-  },
-  "include": [
-    "*.js",
-    "scripts",
-    "src",
-    "test",
-  ],
-}

package/src/heap.js

@@ -1,42 +0,0 @@
-// @jessie-check
-
-import {
-  makeExo,
-  defineExoClass,
-  defineExoClassKit,
-  makeScalarMapStore,
-  makeScalarSetStore,
-  makeScalarWeakMapStore,
-  makeScalarWeakSetStore,
-  M,
-} from '@agoric/store';
-
-import { Far } from '@endo/far';
-
-/**
- * @type {import('.').Stores}
- */
-const heapStores = Far('heapStores', {
-  detached: () => heapStores,
-  isStorable: _specimen => true,
-
-  setStore: makeScalarSetStore,
-  mapStore: makeScalarMapStore,
-  weakMapStore: makeScalarWeakMapStore,
-  weakSetStore: makeScalarWeakSetStore,
-});
-
-/**
- * A heap (in-memory) zone that uses the default exo and store implementations.
- *
- * @type {import('.').Zone}
- */
-export const heapZone = Far('heapZone', {
-  exoClass: defineExoClass,
-  exoClassKit: defineExoClassKit,
-  exo: makeExo,
-  subZone: (_label, _options) => heapZone,
-  ...heapStores,
-});
-
-export { M };