@agoric/zone 0.2.3-dev-ff34bdf.0 → 0.2.3-dev-c4e4693.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/jsconfig.build.json

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

package/jsconfig.json

@@ -1,19 +1,10 @@
 // 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",
-  },
+  "extends": "../../tsconfig.json",
   "include": [
     "*.js",
     "scripts",
-    "src",
-    "test",
+    "src/**/*.js",
+    "test/**/*.js",
   ],
 }

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@agoric/zone",
-  "version": "0.2.3-dev-ff34bdf.0+ff34bdf",
+  "version": "0.2.3-dev-c4e4693.0+c4e4693",
   "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",
+    "prepack": "tsc --build jsconfig.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",
@@ -25,13 +27,13 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/vat-data": "0.5.3-dev-ff34bdf.0+ff34bdf",
-    "@endo/exo": "^0.2.3",
+    "@agoric/base-zone": "0.1.1-dev-c4e4693.0+c4e4693",
+    "@agoric/vat-data": "0.5.3-dev-c4e4693.0+c4e4693",
     "@endo/far": "^0.2.19",
     "@endo/pass-style": "^0.1.4"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-ff34bdf.0+ff34bdf",
+    "@agoric/swingset-liveslots": "0.10.3-dev-c4e4693.0+c4e4693",
     "@endo/patterns": "^0.2.3",
     "ava": "^5.3.0"
   },
@@ -48,5 +50,5 @@
     "timeout": "20m",
     "workerThreads": false
   },
-  "gitHead": "ff34bdfa02979097e93c09badddf53547cd8d721"
+  "gitHead": "c4e469386a2a8c813182dc84cc63c8a660d22ecc"
 }

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":"AA6EO,yCAJI,OAAO,kBAAkB,EAAE,OAAO,mCAEhC,OAAO,GAAG,EAAE,IAAI,CA2C5B"}

package/src/durable.js

@@ -14,9 +14,11 @@ import {
   provideDurableWeakSetStore,
 } from '@agoric/vat-data';
 
-import { makeOnceKit } from './make-once.js';
-import { agoricVatDataKeys as keys } from './keys.js';
-import { isPassable } from './is-passable.js';
+import {
+  agoricVatDataKeys as keys,
+  isPassable,
+  makeOnceKit,
+} from '@agoric/base-zone';
 
 const { Fail } = assert;
 

package/src/exports.d.ts

@@ -0,0 +1,8 @@
+/* eslint-disable import/export */
+
+// Module Types //////////////////////////////////////////////////////
+//
+//   Types exposed from modules.
+//
+
+export type { ExoZone, Stores, Zone } from '@agoric/base-zone/src/exports.js';

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,38 +1,4 @@
-// @jessie-check
+export { makeHeapZone } from '@agoric/base-zone/heap.js';
 
-import { makeExo, defineExoClass, defineExoClassKit } from '@endo/exo';
-
-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 {<T>(key: string, maker: (key: string) => T) => T} makeOnce create or retrieve a singleton object bound to this zone
- * @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,CA8B5B"}

package/src/virtual.js

@@ -11,9 +11,11 @@ import {
   makeScalarBigWeakSetStore,
 } from '@agoric/vat-data';
 
-import { makeOnceKit } from './make-once.js';
-import { agoricVatDataKeys as keys } from './keys.js';
-import { isPassable } from './is-passable.js';
+import {
+  agoricVatDataKeys as keys,
+  isPassable,
+  makeOnceKit,
+} from '@agoric/base-zone';
 
 const emptyRecord = harden({});
 const initEmpty = harden(() => emptyRecord);

package/test/test-exos.js

@@ -6,106 +6,20 @@ import {
   test,
 } from './prepare-test-env-ava.js';
 
-import { M } from '@endo/patterns';
 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';
-import { agoricVatDataKeys as keys } from '../src/keys.js';
-
-/** @typedef {import('../src/index.js').Zone} Zone */
-
-// CAUTION: Do not modify this list; it exists to ensure that future versions
-// of @agoric/zone are compatible with the baggage created by older versions,
-// including the legacy implementation of @agoric/vat-data.
-const agoricVatDataCompatibleKeys = [
-  'Greeter_kindHandle',
-  'GreeterKit_kindHandle',
-  'a_kindHandle',
-  'a_singleton',
-  'mappish',
-  'subsub',
-].sort();
-
-const bindAllMethodsTo = (obj, that = obj) =>
-  Object.fromEntries(
-    Object.entries(obj).map(([name, fn]) => [name, fn.bind(that)]),
-  );
-
-const greetGuard = M.interface('Greeter', {
-  greet: M.call().optional(M.string()).returns(M.string()),
-});
-const greetFacet = {
-  greet(greeting = 'Hello') {
-    return `${greeting}, ${this.state.nick}`;
-  },
-};
-
-const adminGuard = M.interface('GreeterAdmin', {
-  setNick: M.call(M.string()).returns(),
-});
-const adminFacet = {
-  setNick(nick) {
-    this.state.nick = nick;
-  },
-};
-
-const combinedGuard = M.interface('GreeterWithAdmin', {
-  ...greetGuard.methodGuards,
-  ...adminGuard.methodGuards,
-});
-
-const alreadyExceptionSpec = {
-  message: /has already been used/,
-};
-
-const prepareGreeterSingleton = (zone, label, nick) => {
-  const myThis = Object.freeze({ state: { nick } });
-  return zone.exo(label, combinedGuard, {
-    ...bindAllMethodsTo(greetFacet, myThis),
-    ...bindAllMethodsTo(adminFacet, myThis),
-  });
-};
-
-const prepareGreeter = zone =>
-  zone.exoClass('Greeter', combinedGuard, nick => ({ nick }), {
-    ...greetFacet,
-    ...adminFacet,
-  });
-
-const prepareGreeterKit = zone =>
-  zone.exoClassKit(
-    'GreeterKit',
-    { greeter: greetGuard, admin: adminGuard },
-    nick => ({ nick }),
-    {
-      greeter: greetFacet,
-      admin: adminFacet,
-    },
-  );
-
-const testGreeter = (t, nick, obj, adminObj = obj) => {
-  t.is(obj.greet('Greetings'), `Greetings, ${nick}`);
-  t.is(obj.greet(), `Hello, ${nick}`);
-  adminObj.setNick(`${nick}2`);
-  t.is(obj.greet('Greetings'), `Greetings, ${nick}2`);
-  t.is(obj.greet(), `Hello, ${nick}2`);
-  adminObj.setNick(nick);
-};
-
-/**
- * @template T
- * @param {import('ava').Assertions} t
- * @param {() => T} fn
- * @param {*} spec
- * @returns {T}
- */
-const secondThrows = (t, fn, spec = alreadyExceptionSpec) => {
-  const ret = fn();
-  t.throws(fn, spec);
-  return ret;
-};
 
 /**
  * @param {import('ava').Assertions} t
@@ -115,20 +29,20 @@ const testFirstVatDataIncarnation = (t, baggage) => {
   const subBaggage = vatData.provideDurableMapStore(baggage, 'sub');
 
   const myThis = Object.freeze({ state: { nick: 'Singly' } });
-  const singly = vatData.prepareExo(subBaggage, 'a', combinedGuard, {
-    ...bindAllMethodsTo(greetFacet, myThis),
-    ...bindAllMethodsTo(adminFacet, myThis),
+  const singly = vatData.prepareExo(subBaggage, 'a', g.combinedGuard, {
+    ...g.bindAllMethodsTo(g.greetFacet, myThis),
+    ...g.bindAllMethodsTo(g.adminFacet, myThis),
   });
   testGreeter(t, 'Singly', singly);
 
   const makeGreeter = vatData.prepareExoClass(
     subBaggage,
     'Greeter',
-    combinedGuard,
+    g.combinedGuard,
     nick => ({ nick }),
     {
-      ...greetFacet,
-      ...adminFacet,
+      ...g.greetFacet,
+      ...g.adminFacet,
     },
   );
   const classy = makeGreeter('Classy');
@@ -137,11 +51,11 @@ const testFirstVatDataIncarnation = (t, baggage) => {
   const makeGreeterKit = vatData.prepareExoClassKit(
     subBaggage,
     'GreeterKit',
-    { greeter: greetGuard, admin: adminGuard },
+    { greeter: g.greetGuard, admin: g.adminGuard },
     nick => ({ nick }),
     {
-      greeter: greetFacet,
-      admin: adminFacet,
+      greeter: g.greetFacet,
+      admin: g.adminFacet,
     },
   );
   const { greeter: kitty, admin: kittyAdmin } = makeGreeterKit('Kitty');
@@ -156,62 +70,6 @@ const testFirstVatDataIncarnation = (t, baggage) => {
   vatData.provideDurableMapStore(subBaggage, 'subsub');
 };
 
-/**
- * @param {import('ava').Assertions} t
- * @param {Zone} rootZone
- */
-const testFirstZoneIncarnation = (t, rootZone) => {
-  const subZone = secondThrows(t, () => rootZone.subZone('sub'));
-  const singly = secondThrows(t, () =>
-    prepareGreeterSingleton(subZone, 'a', 'Singly'),
-  );
-  testGreeter(t, 'Singly', singly);
-
-  const makeGreeter = secondThrows(t, () => prepareGreeter(subZone));
-  const classy = makeGreeter('Classy');
-  testGreeter(t, 'Classy', classy);
-
-  const makeGreeterKit = secondThrows(t, () => prepareGreeterKit(subZone));
-
-  const { greeter: kitty, admin: kittyAdmin } = makeGreeterKit('Kitty');
-  testGreeter(t, 'Kitty', kitty, kittyAdmin);
-
-  const mappish = secondThrows(t, () => subZone.mapStore('mappish'));
-  mappish.init('singly', singly);
-  mappish.init('classy', classy);
-  mappish.init('kitty', kitty);
-  mappish.init('kittyAdmin', kittyAdmin);
-
-  secondThrows(t, () => subZone.subZone('subsub'));
-};
-
-/**
- * @param {import('ava').Assertions} t
- * @param {Zone} rootZone
- */
-const testSecondZoneIncarnation = (t, rootZone) => {
-  const subZone = secondThrows(t, () => rootZone.subZone('sub'));
-  const mappish = secondThrows(t, () => subZone.mapStore('mappish'));
-
-  const singlyReload = secondThrows(t, () =>
-    prepareGreeterSingleton(subZone, 'a', 'Singly'),
-  );
-  const makeGreeter = secondThrows(t, () => prepareGreeter(subZone));
-  const makeGreeterKit = secondThrows(t, () => prepareGreeterKit(subZone));
-
-  const singly = mappish.get('singly');
-  t.is(singlyReload, singly);
-  testGreeter(t, 'Singly', singly);
-  testGreeter(t, 'Classy', mappish.get('classy'));
-  testGreeter(t, 'Kitty', mappish.get('kitty'), mappish.get('kittyAdmin'));
-
-  const classy2 = makeGreeter('Classy2');
-  testGreeter(t, 'Classy2', classy2);
-
-  const { greeter: kitty2, admin: kittyAdmin2 } = makeGreeterKit('Kitty2');
-  testGreeter(t, 'Kitty2', kitty2, kittyAdmin2);
-};
-
 test('heapZone', t => {
   const zone = makeHeapZone();
   testFirstZoneIncarnation(t, zone);

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/src/heap.js

@@ -1,62 +0,0 @@
-// @ts-check
-// @jessie-check
-
-import { Far } from '@endo/far';
-import { makeExo, defineExoClass, defineExoClassKit } from '@endo/exo';
-import {
-  makeScalarMapStore,
-  makeScalarSetStore,
-  makeScalarWeakMapStore,
-  makeScalarWeakSetStore,
-} from '@agoric/vat-data';
-
-import { makeOnceKit } from './make-once.js';
-import { agoricVatDataKeys as keys } from './keys.js';
-import { isPassable } from './is-passable.js';
-
-/**
- * @type {import('.').Stores}
- */
-const detachedHeapStores = Far('heapStores', {
-  detached: () => detachedHeapStores,
-  isStorable: isPassable,
-
-  setStore: makeScalarSetStore,
-  mapStore: makeScalarMapStore,
-  weakMapStore: makeScalarWeakMapStore,
-  weakSetStore: makeScalarWeakSetStore,
-});
-
-/**
- * Create a heap (in-memory) zone that uses the default exo and store implementations.
- *
- * @param {string} [baseLabel]
- * @returns {import('.').Zone}
- */
-export const makeHeapZone = (baseLabel = 'heapZone') => {
-  const { makeOnce, wrapProvider } = makeOnceKit(baseLabel, detachedHeapStores);
-
-  /**
-   * @param {string} label
-   * @param {any} _options
-   */
-  const makeSubZone = (label, _options) =>
-    makeHeapZone(`${baseLabel}.${label}`);
-
-  return Far('heapZone', {
-    exo: wrapProvider(makeExo, keys.exo),
-    exoClass: wrapProvider(defineExoClass, keys.exoClass),
-    exoClassKit: wrapProvider(defineExoClassKit, keys.exoClassKit),
-    subZone: wrapProvider(makeSubZone),
-
-    makeOnce,
-    detached: detachedHeapStores.detached,
-    isStorable: detachedHeapStores.isStorable,
-
-    mapStore: wrapProvider(detachedHeapStores.mapStore),
-    setStore: wrapProvider(detachedHeapStores.setStore),
-    weakMapStore: wrapProvider(detachedHeapStores.weakMapStore),
-    weakSetStore: wrapProvider(detachedHeapStores.weakSetStore),
-  });
-};
-harden(makeHeapZone);

package/src/is-passable.js

@@ -1,23 +0,0 @@
-import { passStyleOf } from '@endo/pass-style';
-
-/**
- * Is `specimen` Passable? This returns true iff `passStyleOf(specimen)`
- * returns a string. This returns `false` iff `passStyleOf(specimen)` throws.
- * Under no normal circumstance should `isPassable(specimen)` throw.
- *
- * TODO implement an isPassable that does not rely on try/catch, and
- * move it to @endo/pass-style.
- * This implementation is just a standin until then
- *
- * @param {any} specimen
- * @returns {specimen is Passable}
- */
-export const isPassable = specimen => {
-  try {
-    // In fact, it never returns undefined. It either returns a
-    // string or throws.
-    return passStyleOf(specimen) !== undefined;
-  } catch (_) {
-    return false;
-  }
-};

package/src/keys.js

@@ -1,14 +0,0 @@
-/** @param {string} label */
-const kind = label => `${label}_kindHandle`;
-/** @param {string} label */
-const singleton = label => `${label}_singleton`;
-
-/** @type {Record<'exoClass' | 'exoClassKit' | 'exo' | 'store' | 'zone', (label: string) => string[]>} */
-export const agoricVatDataKeys = {
-  exoClass: label => harden([kind(label)]),
-  exoClassKit: label => harden([kind(label)]),
-  exo: label => harden([kind(label), singleton(label)]),
-  store: label => harden([label]),
-  zone: label => harden([label]),
-};
-harden(agoricVatDataKeys);

package/src/make-once.js

@@ -1,86 +0,0 @@
-// @ts-check
-const { Fail } = assert;
-
-/** @param {string} label */
-const defaultLabelToKeys = label => harden([label]);
-harden(defaultLabelToKeys);
-
-/**
- * @param {string} debugName Only used internally for diagnostics, not available to user code
- * @param {import('.').Stores} stores
- * @param {import('@agoric/swingset-liveslots').MapStore<string, any>} [backingStore]
- */
-export const makeOnceKit = (debugName, stores, backingStore = undefined) => {
-  // We need a detached setStore so that it isn't persisted as part of the zone.
-  // That way, our usedKeys are only tracked for the current incarnation, which
-  // is what we want.  Using `debugName` in the label is good for diagnostics,
-  // and since it is only for a detached store, it should not be visible to the
-  // backing store.
-  const usedKeys = stores.detached().setStore(`${debugName} used keys`);
-
-  /**
-   * @param {string} key
-   */
-  const assertOnlyOnce = key => {
-    typeof key === 'string' || Fail`key ${key} must be a string`;
-    !usedKeys.has(key) ||
-      Fail`key ${key} has already been used in this zone and incarnation`;
-
-    // Mark this key as used.  We make no attempt to recover from invalid makers
-    // or backingStores.
-    usedKeys.add(key);
-  };
-
-  /**
-   * Ensure the wrapped function is only called once per incarnation.  It is
-   * expected to update the backing store directly.
-   *
-   * @template {(key: string, ...rest: unknown[]) => any} T
-   * @param {T} provider
-   * @param {(label: string) => string[]} [labelToKeys]
-   * @returns {T}
-   */
-  const wrapProvider = (provider, labelToKeys = defaultLabelToKeys) => {
-    /** @type {(...args: Parameters<T>) => ReturnType<T>} */
-    const wrapper = (label, ...rest) => {
-      for (const key of labelToKeys(label)) {
-        assertOnlyOnce(key);
-      }
-      return provider(label, ...rest);
-    };
-    return /** @type {T} */ (wrapper);
-  };
-
-  /**
-   * The best way to understand the purpose of `makeOnce` is to first understand
-   * what `makeOnce` does on a durable zone. Used correctly, `makeOnce` should only
-   * be called at most once on any zone,key pair during any vat incarnation.
-   * Given that constraint, if there is already a value bound to that
-   * zone,key pair, it must have been left there by a previous incarnation and
-   * `makeOnce` will simply return it. If not, then `maker(key)` is called to
-   * determine the initial value of that slot, which will normally be preserved
-   * by similar calls to `makeOnce` in future incarnations --- though that will be
-   * up to them.
-   *
-   * Also ensures the maker returns a storable value.
-   *
-   * @template V
-   * @param {string} key The string name of the Zone slot to provide.
-   * @param {(key: string) => V} maker Called to create a fresh value to fill an empty slot.
-   * @returns {V} The value of the key's slot.
-   */
-  const makeOnce = (key, maker) => {
-    assertOnlyOnce(key);
-    if (backingStore && backingStore.has(key)) {
-      return backingStore.get(key);
-    }
-    const value = maker(key);
-    stores.isStorable(value) ||
-      Fail`maker return value ${value} is not storable`;
-    backingStore && backingStore.init(key, value);
-    return value;
-  };
-
-  return harden({ makeOnce, wrapProvider });
-};
-harden(makeOnceKit);