@agoric/zone 0.2.2 → 0.2.3-calypso-dev-84eb287.0

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,18 +1,20 @@
 {
   "name": "@agoric/zone",
-  "version": "0.2.2",
+  "version": "0.2.3-calypso-dev-84eb287.0+84eb287",
   "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": "tsc --build tsconfig.build.json",
+    "postpack": "git clean -f '*.d.ts*'",
+    "test": "ava",
+    "test:c8": "c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
     "test:xs": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
     "lint": "run-s --continue-on-error lint:*",
-    "lint:types": "tsc -p jsconfig.json",
+    "lint:types": "tsc",
     "lint:eslint": "eslint ."
   },
   "exports": {
@@ -25,22 +27,34 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/store": "^0.9.2",
-    "@agoric/vat-data": "^0.5.2",
-    "@endo/far": "^0.2.18"
+    "@agoric/base-zone": "0.1.1-calypso-dev-84eb287.0+84eb287",
+    "@agoric/vat-data": "0.5.3-calypso-dev-84eb287.0+84eb287",
+    "@endo/far": "^1.1.2",
+    "@endo/pass-style": "^1.4.0"
+  },
+  "devDependencies": {
+    "@agoric/swingset-liveslots": "0.10.3-calypso-dev-84eb287.0+84eb287",
+    "@endo/patterns": "^1.4.0",
+    "ava": "^5.3.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": ">=14.15.0"
+    "node": "^18.12 || ^20.9"
   },
   "ava": {
     "files": [
-      "test/**/test-*.js"
+      "test/**/*.test.*"
+    ],
+    "require": [
+      "@endo/init/debug.js"
     ],
     "timeout": "20m",
     "workerThreads": false
   },
-  "gitHead": "b66bf7c881ae462fcb617cd6e8d41b5c40ec58ef"
+  "typeCoverage": {
+    "atLeast": 96.68
+  },
+  "gitHead": "84eb287915c8255d68e845a9b6e10c790f0d54cb"
 }

package/src/durable.d.ts

@@ -0,0 +1,2 @@
+export function makeDurableZone(baggage: import("@agoric/vat-data").Baggage, baseLabel?: string | undefined): import(".").Zone;
+//# 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":"AA0EO,yCAJI,OAAO,kBAAkB,EAAE,OAAO,mCAEhC,OAAO,GAAG,EAAE,IAAI,CA+C5B"}

package/src/durable.js

@@ -1,5 +1,7 @@
+// @ts-check
 // @jessie-check
 
+import { Far, isPassable } from '@endo/pass-style';
 import {
   canBeDurable,
   makeScalarMapStore,
@@ -10,20 +12,32 @@ import {
   provideDurableSetStore,
   provideDurableWeakMapStore,
   provideDurableWeakSetStore,
-  M,
+  watchPromise,
 } from '@agoric/vat-data';
 
-import { Far } from '@endo/far';
+import { agoricVatDataKeys as keys, makeOnceKit } from '@agoric/base-zone';
 
 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);
+  const mapStore = (label, options) => {
+    const baggage = getBaggage();
+    const ret = provideDurableMapStore(baggage, label, options);
+    return ret;
+  };
   /** @type {import('.').Zone['setStore']} */
   const setStore = (label, options) =>
     provideDurableSetStore(getBaggage(), label, options);
@@ -38,7 +52,7 @@ const attachDurableStores = getBaggage => {
   return Far('durableStores', {
     // eslint-disable-next-line no-use-before-define
     detached: () => detachedDurableStores,
-    isStorable: canBeDurable,
+    isStorable,
     mapStore,
     setStore,
     weakMapStore,
@@ -47,7 +61,7 @@ const attachDurableStores = getBaggage => {
 };
 
 /** @type {import('.').Stores} */
-export const detachedDurableStores = attachDurableStores(() =>
+const detachedDurableStores = attachDurableStores(() =>
   makeScalarMapStore('detached'),
 );
 
@@ -55,33 +69,53 @@ export const detachedDurableStores = attachDurableStores(() =>
  * Create a zone whose objects persist between Agoric vat upgrades.
  *
  * @param {import('@agoric/vat-data').Baggage} baggage
+ * @param {string} [baseLabel]
  * @returns {import('.').Zone}
  */
-export const makeDurableZone = baggage => {
+export const makeDurableZone = (baggage, baseLabel = 'durableZone') => {
   baggage || Fail`baggage required`;
+
+  const attachedStores = attachDurableStores(() => baggage);
+
+  const { makeOnce, wrapProvider } = makeOnceKit(
+    baseLabel,
+    attachedStores,
+    baggage,
+  );
+
   /** @type {import('.').Zone['exoClass']} */
   const exoClass = (...args) => prepareExoClass(baggage, ...args);
   /** @type {import('.').Zone['exoClassKit']} */
+  // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- happens only integrating with Endo master
+  // @ts-ignore FIXME in Endo
   const exoClassKit = (...args) => prepareExoClassKit(baggage, ...args);
   /** @type {import('.').Zone['exo']} */
   const exo = (...args) => prepareExo(baggage, ...args);
 
-  const attachedStores = attachDurableStores(() => baggage);
+  const subZoneStore = wrapProvider(attachedStores.mapStore, keys.zone);
 
   /** @type {import('.').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 | undefined): 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,iEAFM,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,126 @@
+// eslint-disable-next-line import/order
+import {
+  annihilate,
+  getBaggage,
+  nextLife,
+  test,
+} from './prepare-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));
+});

package/test/make-once.test.js

@@ -0,0 +1,66 @@
+import {
+  annihilate,
+  getBaggage,
+  nextLife,
+  test,
+} from './prepare-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/test/prepare-test-env-ava.js

@@ -0,0 +1,21 @@
+import '@agoric/swingset-liveslots/tools/prepare-test-env.js';
+import { reincarnate } from '@agoric/swingset-liveslots/tools/setup-vat-data.js';
+
+import test from 'ava';
+
+export { test };
+
+/** @type {ReturnType<typeof reincarnate>} */
+let incarnation;
+
+export const annihilate = () => {
+  incarnation = reincarnate({ relaxDurabilityRules: false });
+};
+
+export const getBaggage = () => {
+  return incarnation.fakeVomKit.cm.provideBaggage();
+};
+
+export const nextLife = () => {
+  incarnation = reincarnate(incarnation);
+};

package/tsconfig.build.json

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

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 };