@agoric/base-zone 0.1.1-orchestration-dev-096c4e8.0 → 0.1.1-other-dev-fbe72e7.0.fbe72e7

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@agoric/base-zone",
-  "version": "0.1.1-orchestration-dev-096c4e8.0+096c4e8",
+  "version": "0.1.1-other-dev-fbe72e7.0.fbe72e7",
   "description": "Allocation zone abstraction library and heap implementation",
   "type": "module",
   "repository": "https://github.com/Agoric/agoric-sdk",
   "main": "./src/index.js",
   "scripts": {
     "build": "exit 0",
-    "prepack": "tsc --build tsconfig.build.json",
-    "postpack": "git clean -f '*.d.ts*'",
+    "prepack": "yarn run -T tsc --build tsconfig.build.json",
+    "postpack": "git clean -f '*.d.*ts*' '*.tsbuildinfo'",
     "test": "ava",
-    "test:c8": "c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
+    "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",
-    "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",
@@ -27,27 +27,28 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/store": "0.9.3-orchestration-dev-096c4e8.0+096c4e8",
-    "@endo/common": "^1.1.0",
-    "@endo/exo": "^1.2.1",
-    "@endo/far": "^1.0.4",
-    "@endo/pass-style": "^1.2.0",
-    "@endo/patterns": "^1.2.0"
+    "@agoric/store": "0.9.3-other-dev-fbe72e7.0.fbe72e7",
+    "@endo/common": "^1.2.13",
+    "@endo/errors": "^1.2.13",
+    "@endo/exo": "^1.5.12",
+    "@endo/far": "^1.1.14",
+    "@endo/pass-style": "^1.6.3",
+    "@endo/patterns": "^1.7.0"
   },
   "devDependencies": {
-    "@endo/init": "^1.0.4",
-    "@endo/ses-ava": "^1.1.2",
+    "@endo/init": "^1.1.12",
+    "@endo/ses-ava": "^1.3.2",
     "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"
@@ -56,7 +57,7 @@
     "workerThreads": false
   },
   "typeCoverage": {
-    "atLeast": 89.25
+    "atLeast": 93.22
   },
-  "gitHead": "096c4e8fce80e9a509b0e1a30fda11736c4570e1"
+  "gitHead": "fbe72e72107f9997f788674e668c660d92ec4492"
 }

package/src/exports.d.ts

@@ -5,5 +5,4 @@
 //   Types exposed from modules.
 //
 
-// @ts-expect-error TS1383: Only named exports may use 'export type'.
 export type * from './types.js';

package/src/heap.d.ts

@@ -1,2 +1,2 @@
-export function makeHeapZone(baseLabel?: string | undefined): import('./types.js').Zone;
+export function makeHeapZone(baseLabel?: string): import("./types.js").Zone;
 //# sourceMappingURL=heap.d.ts.map

package/src/heap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heap.d.ts","sourceRoot":"","sources":["heap.js"],"names":[],"mappings":"AAmCO,8DAFM,OAAO,YAAY,EAAE,IAAI,CA2BrC"}
+{"version":3,"file":"heap.d.ts","sourceRoot":"","sources":["heap.js"],"names":[],"mappings":"AAmCO,yCAHI,MAAM,GACJ,OAAO,YAAY,EAAE,IAAI,CA4BrC"}

package/src/heap.js

@@ -1,7 +1,7 @@
 // @ts-check
 // @jessie-check
 
-import { Far } from '@endo/far';
+import { Far, isPassable } from '@endo/pass-style';
 import { makeExo, defineExoClass, defineExoClassKit } from '@endo/exo';
 import {
   makeScalarMapStore,
@@ -12,7 +12,7 @@ import {
 
 import { makeOnceKit } from './make-once.js';
 import { agoricVatDataKeys as keys } from './keys.js';
-import { isPassable } from './is-passable.js';
+import { watchPromise } from './watch-promise.js';
 
 /**
  * @type {import('./types.js').Stores}
@@ -50,6 +50,7 @@ export const makeHeapZone = (baseLabel = 'heapZone') => {
     subZone: wrapProvider(makeSubZone),
 
     makeOnce,
+    watchPromise,
     detached: detachedHeapStores.detached,
     isStorable: detachedHeapStores.isStorable,
 

package/src/index.d.ts

@@ -2,4 +2,5 @@ export * from "./exports.js";
 export * from "./make-once.js";
 export * from "./keys.js";
 export * from "./is-passable.js";
+export * from "./watch-promise.js";
 //# sourceMappingURL=index.d.ts.map

package/src/index.js

@@ -1,5 +1,7 @@
 // @jessie-check
 
+/// <reference types="@agoric/store/exported.js" />
+
 // eslint-disable-next-line import/export
 export * from './exports.js';
 
@@ -7,3 +9,4 @@ export * from './exports.js';
 export * from './make-once.js';
 export * from './keys.js';
 export * from './is-passable.js';
+export * from './watch-promise.js';

package/src/is-passable.d.ts

@@ -1,2 +1,3 @@
-export function isPassable(specimen: any): specimen is any;
+export function isPassable(specimen: any): specimen is Passable;
+import type { Passable } from '@endo/pass-style';
 //# sourceMappingURL=is-passable.d.ts.map

package/src/is-passable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-passable.d.ts","sourceRoot":"","sources":["is-passable.js"],"names":[],"mappings":"AAcO,qCAHI,GAAG,mBAWb"}
+{"version":3,"file":"is-passable.d.ts","sourceRoot":"","sources":["is-passable.js"],"names":[],"mappings":"AAWO,qCAHI,GAAG,GACD,QAAQ,IAAI,QAAQ,CAE6B;8BARnC,kBAAkB"}

package/src/is-passable.js

@@ -1,23 +1,12 @@
-import { passStyleOf } from '@endo/pass-style';
+import { isPassable as realIsPassable } 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
- *
+ * @import {Passable} from '@endo/pass-style';
+ */
+
+/**
+ * @deprecated Import `isPassable` directly from `@endo/pass-style`
  * @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;
-  }
-};
+export const isPassable = specimen => realIsPassable(specimen);

package/src/keys.d.ts

@@ -3,5 +3,5 @@
  *
  * @type {import('./types.js').KeyMakers}
  */
-export const agoricVatDataKeys: import('./types.js').KeyMakers;
+export const agoricVatDataKeys: import("./types.js").KeyMakers;
 //# sourceMappingURL=keys.d.ts.map

package/src/make-once.d.ts

@@ -1,5 +1,5 @@
-export function makeOnceKit(debugName: string, stores: import('./types.js').Stores, backingStore?: any): {
+export function makeOnceKit(debugName: string, stores: import("./types.js").Stores, backingStore?: import("@agoric/swingset-liveslots").MapStore<string, any>): {
     makeOnce: <V>(key: string, maker: (key: string) => V) => V;
-    wrapProvider: <T extends (key: string, ...rest: unknown[]) => any>(provider: T, labelToKeys?: ((label: string) => string[]) | undefined) => T;
+    wrapProvider: <T extends (key: string, ...rest: any[]) => any>(provider: T, labelToKeys?: (label: string) => string[]) => T;
 };
 //# sourceMappingURL=make-once.d.ts.map

package/src/make-once.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make-once.d.ts","sourceRoot":"","sources":["make-once.js"],"names":[],"mappings":"AAYO,uCAJI,MAAM,UACN,OAAO,YAAY,EAAE,MAAM;uBA0DzB,MAAM,eACA,MAAM;mCA/BH,MAAM,WAAW,OAAO,EAAE,KAAK,GAAG,sCAEnC,MAAM,KAAK,MAAM,EAAE;EA6CvC"}
+{"version":3,"file":"make-once.d.ts","sourceRoot":"","sources":["make-once.js"],"names":[],"mappings":"AAYO,uCAJI,MAAM,UACN,OAAO,YAAY,EAAE,MAAM,iBAC3B,OAAO,4BAA4B,EAAE,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC;eAwDtD,CAAC,OACH,MAAM,SACN,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,KAChB,CAAC;mBAhCsC,CAAC,SAAxC,CAAE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAI,YACxC,CAAC,gBACD,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EAAE,KACzB,CAAC;EA4Cf"}

package/src/make-once.js

@@ -1,5 +1,5 @@
 // @ts-check
-const { Fail } = assert;
+import { Fail } from '@endo/errors';
 
 /** @param {string} label */
 const defaultLabelToKeys = label => harden([label]);
@@ -35,7 +35,7 @@ export const makeOnceKit = (debugName, stores, backingStore = undefined) => {
    * 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
+   * @template {(key: string, ...rest: any[]) => any} T
    * @param {T} provider
    * @param {(label: string) => string[]} [labelToKeys]
    * @returns {T}

package/src/prepare-attenuator.d.ts

@@ -0,0 +1,31 @@
+export function wrapperMethods(wrapperKindName: string, uMethodNames: PropertyKey[], extraMethods?: Record<PropertyKey, (...args: any[]) => any>): {
+    [x: string]: ((...args: any[]) => any) | ((...args: any[]) => any);
+};
+export function prepareAttenuatorMaker<U = any>(zone: import("@agoric/base-zone").Zone, uKindName: string, uMethodNames: (keyof U)[], options?: AttenuatorOptions<U>): MakeAttenuator;
+export function attenuateOne<U extends unknown>(underlying: U, uMethodNames: (keyof U)[], options?: AttenuatorOptions<U>): Partial<U>;
+export type MakeAttenuator<U = any> = (underlying: U) => Partial<U>;
+export type AttenuatorThis<U = any> = {
+    self: Partial<U>;
+    state: {
+        underlying: U;
+    };
+};
+export type AttenuatorOptions<U = any> = {
+    /**
+     * The `interfaceName` of the underlying interface guard.
+     * Defaults to the `uKindName`.
+     */
+    uInterfaceName?: string | undefined;
+    /**
+     * For guarding the `extraMethods`, if you include them below. These appear
+     * only on the synthesized interface guard for the attenuator, and
+     * do not necessarily correspond to any method of the underlying.
+     */
+    extraMethodGuards?: Record<PropertyKey, import("@endo/patterns").MethodGuard> | undefined;
+    /**
+     * Extra methods adding behavior only to the attenuator, and
+     * do not necessarily correspond to any methods of the underlying.
+     */
+    extraMethods?: Record<PropertyKey, (this: AttenuatorThis<U>, ...args: any[]) => any> | undefined;
+};
+//# sourceMappingURL=prepare-attenuator.d.ts.map

package/src/prepare-attenuator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-attenuator.d.ts","sourceRoot":"","sources":["prepare-attenuator.js"],"names":[],"mappings":"AA2BO,gDAJI,MAAM,gBACN,WAAW,EAAE,iBACb,MAAM,CAAC,WAAW,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;4BAAd,GAAG,EAAE,KAAK,GAAG;EA6BlD;AAoDG,uCAVO,CAAC,cACJ,OAAO,mBAAmB,EAAE,IAAI,aAChC,MAAM,gBAEN,CAAC,MAAM,CAAC,CAAC,EAAE,YAGX,iBAAiB,CAAC,CAAC,CAAC,GAClB,cAAc,CA8B1B;AAqBM,6BANY,CAAC,8BACT,CAAC,gBACD,CAAC,MAAM,CAAC,CAAC,EAAE,YACX,iBAAiB,CAAC,CAAC,CAAC,GAClB,OAAO,CAAC,CAAC,CAAC,CAetB;2BA9Ga,CAAC,uBAEJ,CAAC,KACC,OAAO,CAAC,CAAC,CAAC;2BAIT,CAAC;UAED,OAAO,CAAC,CAAC,CAAC;WACV;QAAE,UAAU,EAAE,CAAC,CAAA;KAAE;;8BAIjB,CAAC;;;;;;;;;;;;;;;;8CAcH,cAAc,CAAC,CAAC,CAAC,WAAW,GAAG,EAAE,KAAK,GAAG"}

package/src/prepare-attenuator.js

@@ -0,0 +1,170 @@
+import { Fail, q } from '@endo/errors';
+import { fromUniqueEntries } from '@endo/common/from-unique-entries.js';
+import { M } from '@endo/patterns';
+import { makeHeapZone } from './heap.js';
+
+// This attenuator implementation is just a simplification of the
+// revocable kit implementation in prepare-revocable.js. The revocable kit
+// provides both attenuation and revocation, since we can have both for the
+// price of just one level of indirection. But if you don't need revocation,
+// the revocable kit has more API complexity than you need.
+//
+// We could have built `prepareAttenuatorMaker` as a trivial wrapper around
+// `prepareRevocableMakerKit`. But then we'd have the weird artifact that the
+// `extraMethods` would see a `{ state, facets: { revocable, revoker }}` context
+// rather than a `{ state, self }` context. So instead, we copied and edited it
+// down. Please co-maintain these two modules.
+
+// Because the attenuator just uses an exo class rather than a class kit,
+// it cannot support the privilege separation of a distinct revoker facet.
+// But it can still support `selfRevoke` as a separate `extraMethod`, as shown
+// in a testcase at `prepare-attenuator.test.js`
+
+/**
+ * @param {string} wrapperKindName
+ * @param {PropertyKey[]} uMethodNames
+ * @param {Record<PropertyKey, (...args: any[]) => any>} [extraMethods]
+ */
+export const wrapperMethods = (
+  wrapperKindName,
+  uMethodNames,
+  extraMethods = {},
+) =>
+  harden({
+    ...fromUniqueEntries(
+      uMethodNames.map(name => [
+        name,
+        {
+          // Use concise method syntax for exo methods
+          [name](...args) {
+            // @ts-expect-error normal exo-this typing confusion
+            const { underlying } = this.state;
+
+            // Because attenuators still support someone adding `selfRevoke`
+            // as an `extraMethod`, this test is still useful. See the
+            // testcase in `prepare-attenuator.test.js`.
+            underlying !== undefined || Fail`${q(wrapperKindName)} revoked`;
+
+            return underlying[name](...args);
+          },
+          // @ts-expect-error using possible symbol as index type
+        }[name],
+      ]),
+    ),
+    ...extraMethods,
+  });
+harden(wrapperMethods);
+
+/**
+ * @template [U=any]
+ * @callback MakeAttenuator
+ * @param {U} underlying
+ * @returns {Partial<U>}
+ */
+
+/**
+ * @template [U=any]
+ * @typedef {object} AttenuatorThis
+ * @property {Partial<U>} self
+ * @property {{ underlying: U }} state
+ */
+
+/**
+ * @template [U=any]
+ * @typedef {object} AttenuatorOptions
+ * @property {string} [uInterfaceName]
+ *   The `interfaceName` of the underlying interface guard.
+ *   Defaults to the `uKindName`.
+ * @property {Record<
+ *   PropertyKey,
+ *   import('@endo/patterns').MethodGuard
+ * >} [extraMethodGuards]
+ * For guarding the `extraMethods`, if you include them below. These appear
+ * only on the synthesized interface guard for the attenuator, and
+ * do not necessarily correspond to any method of the underlying.
+ * @property {Record<
+ *   PropertyKey,
+ *   (this: AttenuatorThis<U>, ...args: any[]) => any
+ * >} [extraMethods]
+ * Extra methods adding behavior only to the attenuator, and
+ * do not necessarily correspond to any methods of the underlying.
+ */
+
+/**
+ * Make an exo class for wrapping an underlying exo class,
+ * where the wrapper is an attenuator of the underlying.
+ *
+ * @template [U=any]
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {string} uKindName
+ *   The `kindName` of the underlying exo class
+ * @param {(keyof U)[]} uMethodNames
+ *   The method names of the underlying exo class that should be represented
+ *   by transparently-forwarding methods of the attenuator.
+ * @param {AttenuatorOptions<U>} [options]
+ * @returns {MakeAttenuator}
+ */
+export const prepareAttenuatorMaker = (
+  zone,
+  uKindName,
+  uMethodNames,
+  options = {},
+) => {
+  const {
+    uInterfaceName = uKindName,
+    extraMethodGuards = {},
+    extraMethods = {},
+  } = options;
+  const AttenuatorI = M.interface(
+    `${uInterfaceName}_attenuator`,
+    extraMethodGuards,
+    { defaultGuards: 'raw' },
+  );
+
+  const attenuatorKindName = `${uKindName}_attenuator`;
+
+  return zone.exoClass(
+    attenuatorKindName,
+    AttenuatorI,
+    underlying => ({ underlying }),
+    wrapperMethods(attenuatorKindName, uMethodNames, extraMethods),
+    {
+      stateShape: { underlying: M.opt(M.remotable('underlying')) },
+    },
+  );
+};
+harden(prepareAttenuatorMaker);
+
+// cf. https://endojs.github.io/endo/functions/_endo_pass_style.Remotable.html
+const RemotablePrefixRE = /^(Alleged: |DebugName: )/;
+
+/**
+ * A convenience above `prepareAttenuatorMaker` for doing a singleton
+ * ephemeral attenuator, i.e., a new attenuator instance (and hidden class)
+ * that is allocated in the heap zone, and therefore ephemeral. The underlying
+ * can be durable or not, with no conflict with the attenuator being
+ * ephemeral. The price of this convenience is the allocation of the hidden
+ * class and wrapper methods per `attenuateOne` call, i.e., per attenuator
+ * instance.
+ *
+ * @template {any} U
+ * @param {U} underlying
+ * @param {(keyof U)[]} uMethodNames
+ * @param {AttenuatorOptions<U>} [options]
+ * @returns {Partial<U>}
+ */
+export const attenuateOne = (underlying, uMethodNames, options = undefined) => {
+  const heapZone = makeHeapZone();
+  const uKindName = (underlying[Symbol.toStringTag] || 'Underlying').replace(
+    RemotablePrefixRE,
+    '',
+  );
+  const makeAttenuator = prepareAttenuatorMaker(
+    heapZone,
+    uKindName,
+    uMethodNames,
+    options,
+  );
+  return makeAttenuator(underlying);
+};
+harden(attenuateOne);

package/src/prepare-revocable.d.ts

@@ -1,13 +1,23 @@
-export function prepareRevocableKit<U extends unknown = any>(zone: import('@agoric/base-zone').Zone, uKindName: string, uMethodNames: (string | symbol)[], options?: RevocableKitOptions<any> | undefined): (underlying: U) => RevocableKit<U>;
-export type Revoker = {
+export function prepareRevocableMakerKit<U = any>(zone: import("@agoric/base-zone").Zone, uKindName: string, uMethodNames: PropertyKey[], options?: RevocableKitOptions<U>): RevocableMakerKit<U>;
+export type MakeRevocable<U = any> = (underlying: U) => Partial<U>;
+export type MakeRevocableKit<U = any> = (underlying: U) => RevocableKit<U>;
+export type RevocableMakerKit<U = any> = {
+    revoke: (revocable: U) => boolean;
+    /**
+     *   Forwards to the underlying exo object, until revoked
+     */
+    makeRevocable: MakeRevocable<U>;
+    makeRevocableKit: MakeRevocableKit<U>;
+};
+export type RevokerFacet = {
     revoke: () => boolean;
 };
-export type RevocableKit<U extends unknown = any> = {
-    revoker: Revoker;
+export type RevocableKit<U = any> = {
+    revoker: RevokerFacet;
     /**
      *   Forwards to the underlying exo object, until revoked
      */
-    revocable: U;
+    revocable: Partial<U>;
 };
 export type RevocableKitThis<U = any> = {
     facets: RevocableKit<U>;
@@ -15,7 +25,7 @@ export type RevocableKitThis<U = any> = {
         underlying: U;
     };
 };
-export type RevocableKitOptions<U extends unknown = any> = {
+export type RevocableKitOptions<U = any> = {
     /**
      * The `interfaceName` of the underlying interface guard.
      * Defaults to the `uKindName`.
@@ -26,11 +36,11 @@ export type RevocableKitOptions<U extends unknown = any> = {
      * only on the synthesized interface guard for the revocable caretaker, and
      * do not necessarily correspond to any method of the underlying.
      */
-    extraMethodGuards?: Record<string | symbol, import("@endo/patterns").MethodGuard> | undefined;
+    extraMethodGuards?: Record<PropertyKey, import("@endo/patterns").MethodGuard> | undefined;
     /**
      * Extra methods adding behavior only to the revocable caretaker, and
      * do not necessarily correspond to any methods of the underlying.
      */
-    extraMethods?: Record<string | symbol, (this: RevocableKitThis<U>, ...args: any[]) => any> | undefined;
+    extraMethods?: Record<PropertyKey, (this: RevocableKitThis<U>, ...args: any[]) => any> | undefined;
 };
 //# sourceMappingURL=prepare-revocable.d.ts.map

package/src/prepare-revocable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepare-revocable.d.ts","sourceRoot":"","sources":["prepare-revocable.js"],"names":[],"mappings":"AA6DO,mEATI,OAAO,mBAAmB,EAAE,IAAI,aAChC,MAAM,gBAEN,CAAC,MAAM,GAAC,MAAM,CAAC,EAAE,sFAiF3B;;YAjIa,MAAM,OAAO;;;aAMb,OAAO;;;;eACP,CAAC;;;YAOD,aAAa,CAAC,CAAC;WACf;QAAE,UAAU,EAAE,CAAC,CAAA;KAAE;;;;;;;;;;;;;;;;;;kDAkBnB,iBAAiB,CAAC,CAAC,WAAW,GAAG,EAAE,KAAK,GAAG"}
+{"version":3,"file":"prepare-revocable.d.ts","sourceRoot":"","sources":["prepare-revocable.js"],"names":[],"mappings":"AAyFO,yCAVO,CAAC,cACJ,OAAO,mBAAmB,EAAE,IAAI,aAChC,MAAM,gBAEN,WAAW,EAAE,YAGb,mBAAmB,CAAC,CAAC,CAAC,GACpB,iBAAiB,CAAC,CAAC,CAAC,CA4EhC;0BAvJa,CAAC,uBAEJ,CAAC,KACC,OAAO,CAAC,CAAC,CAAC;6BAIT,CAAC,uBAEJ,CAAC,KACC,YAAY,CAAC,CAAC,CAAC;8BAId,CAAC;YAED,CAAC,SAAS,EAAE,CAAC,KAAK,OAAO;;;;mBACzB,aAAa,CAAC,CAAC,CAAC;sBAEhB,gBAAgB,CAAC,CAAC,CAAC;;;YAKnB,MAAM,OAAO;;yBAIb,CAAC;aAED,YAAY;;;;eACZ,OAAO,CAAC,CAAC,CAAC;;6BAKV,CAAC;YAED,YAAY,CAAC,CAAC,CAAC;WACf;QAAE,UAAU,EAAE,CAAC,CAAA;KAAE;;gCAIjB,CAAC;;;;;;;;;;;;;;;;8CAcH,gBAAgB,CAAC,CAAC,CAAC,WAAW,GAAG,EAAE,KAAK,GAAG"}

package/src/prepare-revocable.js

@@ -1,18 +1,47 @@
 import { M } from '@endo/patterns';
-import { fromUniqueEntries } from '@endo/common/from-unique-entries.js';
+import { wrapperMethods } from './prepare-attenuator.js';
 
-const { Fail, quote: q } = assert;
+/** @import {Amplify} from '@endo/exo'; */
+
+// This revocable kit implementation provides for both attenuation and
+// revocation, since both can be provided at the cost of one level of
+// indirection. But if you just need attenuation without revocation, better to
+// use the attenuator implementation in prepare-attenuator.js.
+// Please co-maintain these two modules.
+
+/**
+ * @template [U=any]
+ * @callback MakeRevocable
+ * @param {U} underlying
+ * @returns {Partial<U>}
+ */
+
+/**
+ * @template [U=any]
+ * @callback MakeRevocableKit
+ * @param {U} underlying
+ * @returns {RevocableKit<U>}
+ */
+
+/**
+ * @template [U=any]
+ * @typedef {object} RevocableMakerKit
+ * @property {(revocable: U) => boolean} revoke
+ * @property {MakeRevocable<U>} makeRevocable
+ *   Forwards to the underlying exo object, until revoked
+ * @property {MakeRevocableKit<U>} makeRevocableKit
+ */
 
 /**
- * @typedef {object} Revoker
+ * @typedef {object} RevokerFacet
  * @property {() => boolean} revoke
  */
 
 /**
- * @template {any} [U=any]
+ * @template [U=any]
  * @typedef {object} RevocableKit
- * @property {Revoker} revoker
- * @property {U} revocable
+ * @property {RevokerFacet} revoker
+ * @property {Partial<U>} revocable
  *   Forwards to the underlying exo object, until revoked
  */
 
@@ -24,20 +53,20 @@ const { Fail, quote: q } = assert;
  */
 
 /**
- * @template {any} [U=any]
+ * @template [U=any]
  * @typedef {object} RevocableKitOptions
  * @property {string} [uInterfaceName]
  *   The `interfaceName` of the underlying interface guard.
  *   Defaults to the `uKindName`.
  * @property {Record<
- *   string|symbol,
+ *   PropertyKey,
  *   import('@endo/patterns').MethodGuard
  * >} [extraMethodGuards]
  * For guarding the `extraMethods`, if you include them below. These appear
  * only on the synthesized interface guard for the revocable caretaker, and
  * do not necessarily correspond to any method of the underlying.
  * @property {Record<
- *   string|symbol,
+ *   PropertyKey,
  *   (this: RevocableKitThis<U>, ...args: any[]) => any
  * >} [extraMethods]
  * Extra methods adding behavior only to the revocable caretaker, and
@@ -48,18 +77,17 @@ const { Fail, quote: q } = assert;
  * Make an exo class kit for wrapping an underlying exo class,
  * where the wrapper is a revocable forwarder.
  *
- * @deprecated Change to `prepareRevocableMakerKit` once #8977 happens
- * @template {any} [U=any]
+ * @template [U=any]
  * @param {import('@agoric/base-zone').Zone} zone
  * @param {string} uKindName
  *   The `kindName` of the underlying exo class
- * @param {(string|symbol)[]} uMethodNames
+ * @param {PropertyKey[]} uMethodNames
  *   The method names of the underlying exo class that should be represented
  *   by transparently-forwarding methods of the revocable caretaker.
- * @param {RevocableKitOptions} [options]
- * @returns {(underlying: U) => RevocableKit<U>}
+ * @param {RevocableKitOptions<U>} [options]
+ * @returns {RevocableMakerKit<U>}
  */
-export const prepareRevocableKit = (
+export const prepareRevocableMakerKit = (
   zone,
   uKindName,
   uMethodNames,
@@ -67,32 +95,27 @@ export const prepareRevocableKit = (
 ) => {
   const {
     uInterfaceName = uKindName,
-    extraMethodGuards = undefined,
-    extraMethods = undefined,
+    extraMethodGuards = {},
+    extraMethods = {},
   } = options;
   const RevocableIKit = harden({
     revoker: M.interface(`${uInterfaceName}_revoker`, {
       revoke: M.call().returns(M.boolean()),
     }),
-    revocable: M.interface(
-      `${uInterfaceName}_revocable`,
-      {
-        ...extraMethodGuards,
-      },
-      {
-        defaultGuards: 'raw',
-      },
-    ),
+    revocable: M.interface(`${uInterfaceName}_revocable`, extraMethodGuards, {
+      defaultGuards: 'raw',
+    }),
   });
 
   const revocableKindName = `${uKindName}_caretaker`;
 
+  /** @type {Amplify<any>} */
+  let amplifier;
+
   const makeRevocableKit = zone.exoClassKit(
     revocableKindName,
     RevocableIKit,
-    underlying => ({
-      underlying,
-    }),
+    underlying => ({ underlying }),
     {
       revoker: {
         revoke() {
@@ -104,35 +127,39 @@ export const prepareRevocableKit = (
           return true;
         },
       },
-      revocable: {
-        ...fromUniqueEntries(
-          uMethodNames.map(name => [
-            name,
-            {
-              // Use concise method syntax for exo methods
-              [name](...args) {
-                // @ts-expect-error normal exo-this typing confusion
-                const { underlying } = this.state;
-                underlying !== undefined ||
-                  Fail`${q(revocableKindName)} revoked`;
-                return underlying[name](...args);
-              },
-              // @ts-expect-error using possible symbol as index type
-            }[name],
-          ]),
-        ),
-        ...extraMethods,
-      },
+      revocable: wrapperMethods(revocableKindName, uMethodNames, extraMethods),
     },
     {
-      stateShape: {
-        underlying: M.opt(M.remotable('underlying')),
+      stateShape: { underlying: M.opt(M.remotable('underlying')) },
+      receiveAmplifier: amp => {
+        amplifier = amp;
       },
     },
   );
 
-  // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
-  // @ts-ignore parameter confusion
-  return makeRevocableKit;
+  /**
+   * @type {MakeRevocable}
+   */
+  const makeRevocable = underlying => makeRevocableKit(underlying).revocable;
+
+  /**
+   * @param {U} revocable
+   * @returns {boolean}
+   */
+  const revoke = revocable => {
+    /** @type {RevocableKit<U>} */
+    const facets = amplifier(revocable);
+    if (facets === undefined) {
+      return false;
+    }
+    return facets.revoker.revoke();
+  };
+
+  return harden({
+    revoke,
+    makeRevocable,
+    /** @type {MakeRevocableKit} */
+    makeRevocableKit,
+  });
 };
-harden(prepareRevocableKit);
+harden(prepareRevocableMakerKit);

package/src/types.d.ts

@@ -1,11 +1,5 @@
-export type KeyCategories = 'exoClass' | 'exoClassKit' | 'exo' | 'store' | 'zone';
-export type KeyMakers = {
-    exoClass: (label: string) => string[];
-    exoClassKit: (label: string) => string[];
-    exo: (label: string) => string[];
-    store: (label: string) => string[];
-    zone: (label: string) => string[];
-};
+export type KeyCategories = "exoClass" | "exoClassKit" | "exo" | "store" | "zone";
+export type KeyMakers = Record<KeyCategories, (label: string) => string[]>;
 /**
  * A bag of methods for creating defensible objects and
  * collections with the same allocation semantics (ephemeral, persistent, etc)
@@ -32,6 +26,10 @@ export type ExoZone = {
      * create a new Zone that can be passed to untrusted consumers without exposing the storage of the parent zone
      */
     subZone: (label: string, options?: StoreOptions) => Zone;
+    /**
+     * register a promise watcher created by this zone
+     */
+    watchPromise: typeof watchPromise;
 };
 export type Stores = {
     /**
@@ -49,17 +47,23 @@ export type Stores = {
     /**
      * provide a Set-like store named `label` in the zone
      */
-    setStore: <K_1>(label: string, options?: StoreOptions) => SetStore<K_1>;
+    setStore: <K>(label: string, options?: StoreOptions) => SetStore<K>;
     /**
      * provide a WeakMap-like store named `label` in the zone
      */
-    weakMapStore: <K_2, V_1>(label: string, options?: StoreOptions) => WeakMapStore<K_2, V_1>;
+    weakMapStore: <K, V>(label: string, options?: StoreOptions) => WeakMapStore<K, V>;
     /**
      * provide a WeakSet-like store named `label` in the zone
      */
-    weakSetStore: <K_3>(label: string, options?: StoreOptions) => WeakSetStore<K_3>;
+    weakSetStore: <K>(label: string, options?: StoreOptions) => WeakSetStore<K>;
 };
 import { makeExo } from '@endo/exo';
 import { defineExoClass } from '@endo/exo';
 import { defineExoClassKit } from '@endo/exo';
+import type { StoreOptions } from '@agoric/store';
+import { watchPromise } from './watch-promise.js';
+import type { MapStore } from '@agoric/store';
+import type { SetStore } from '@agoric/store';
+import type { WeakMapStore } from '@agoric/store';
+import type { WeakSetStore } from '@agoric/store';
 //# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"4BAGc,UAAU,GAAG,aAAa,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM;;sBACvB,MAAM,KAAK,MAAM,EAAE;yBAAnB,MAAM,KAAK,MAAM,EAAE;iBAAnB,MAAM,KAAK,MAAM,EAAE;mBAAnB,MAAM,KAAK,MAAM,EAAE;kBAAnB,MAAM,KAAK,MAAM,EAAE;;;;;;mBAGlD,OAAO,GAAG,MAAM;;;;;SAMf,cAAc;;;;cACd,qBAAqB;;;;iBACrB,wBAAwB;;;;uBACf,MAAM,eAAe,MAAM;;;;qBAC5B,MAAM,YAAY,YAAY,KAAK,IAAI;;;;;;cAK/C,MAAM,MAAM;;;;2BACD,OAAO,KAAK,OAAO;;;;4BACjB,MAAM,YAAY,YAAY;;;;2BAChC,MAAM,YAAY,YAAY;;;;oCAE3C,MAAM,YAAY,YAAY;;;;+BAG9B,MAAM,YAAY,YAAY;;wBA7BiB,WAAW;+BAAX,WAAW;kCAAX,WAAW"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"4BAcc,UAAU,GAAG,aAAa,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM;wBACrD,MAAM,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;;;;;mBAGnD,OAAO,GAAG,MAAM;;;;;SAMf,OAAO,OAAO;;;;cACd,OAAO,cAAc;;;;iBACrB,OAAO,iBAAiB;;;;cACxB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,KAAK,CAAC;;;;aAChD,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,IAAI;;;;kBAC/C,OAAO,YAAY;;;;;;cAKnB,MAAM,MAAM;;;;gBACZ,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO;;;;cAC9B,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,SAAS,CAAC,EAAE,CAAC,CAAC;;;;cAC/D,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,SAAS,CAAC,CAAC;;;;kBACzD,CAAC,CAAC,EAAE,CAAC,EACd,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,aAAa,CAAC,EAAE,CAAC,CAAC;;;;kBAEnD,CAAC,CAAC,EACX,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,aAAa,CAAC,CAAC;;wBAzCH,WAAW;+BAAX,WAAW;kCAAX,WAAW;kCAQS,eAAe;6BANjE,oBAAoB;8BAM8B,eAAe;8BAAf,eAAe;kCAAf,eAAe;kCAAf,eAAe"}

package/src/types.js

@@ -1,5 +1,16 @@
 // eslint-disable-next-line no-unused-vars
 import { makeExo, defineExoClass, defineExoClassKit } from '@endo/exo';
+// eslint-disable-next-line no-unused-vars
+import { watchPromise } from './watch-promise.js';
+
+// Ensure this is a module.
+export {};
+
+/**
+ * @import {MapStore, SetStore, StoreOptions, WeakMapStore, WeakSetStore} from '@agoric/store';
+ * @import {Key} from '@endo/patterns';
+ * @import {Passable} from '@endo/pass-style';
+ */
 
 /** @typedef {'exoClass' | 'exoClassKit' | 'exo' | 'store' | 'zone'} KeyCategories */
 /** @typedef {Record<KeyCategories, (label: string) => string[]>} KeyMakers */
@@ -16,15 +27,16 @@ import { makeExo, defineExoClass, defineExoClassKit } from '@endo/exo';
  * @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
+ * @property {typeof watchPromise} watchPromise register a promise watcher created by this 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, 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>(
+ * @property {<K, V>(
  *   label: string, options?: StoreOptions) => WeakMapStore<K, V>
  * } weakMapStore provide a WeakMap-like store named `label` in the zone
  * @property {<K>(

package/src/watch-promise.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A PromiseWatcher method guard callable with or more arguments, returning void.
+ */
+export const PromiseWatcherHandler: import("@endo/patterns").MethodGuard;
+/**
+ * A PromiseWatcher interface that has both onFulfilled and onRejected handlers.
+ */
+export const PromiseWatcherI: import("@endo/patterns").InterfaceGuard<{
+    onFulfilled: import("@endo/patterns").MethodGuard;
+    onRejected: import("@endo/patterns").MethodGuard;
+}>;
+/**
+ * A PromiseWatcher interface that has only an onFulfilled handler.
+ */
+export const PromiseWatcherFulfilledI: import("@endo/patterns").InterfaceGuard<{
+    onFulfilled: import("@endo/patterns").MethodGuard;
+}>;
+/**
+ * A PromiseWatcher interface that has only an onRejected handler.
+ */
+export const PromiseWatcherRejectedI: import("@endo/patterns").InterfaceGuard<{
+    onRejected: import("@endo/patterns").MethodGuard;
+}>;
+export function watchPromise(p: Promise<any>, watcher: PromiseWatcher, ...watcherArgs: unknown[]): void;
+export type PromiseWatcher = {
+    onFulfilled?: ((fulfilment: unknown, ...args: unknown[]) => void) | undefined;
+    onRejected?: ((reason: unknown, ...args: unknown[]) => void) | undefined;
+};
+//# sourceMappingURL=watch-promise.d.ts.map

package/src/watch-promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-promise.d.ts","sourceRoot":"","sources":["watch-promise.js"],"names":[],"mappings":"AAOA;;GAEG;AACH,yEAA6E;AAE7E;;GAEG;AACH;;;GAGG;AAEH;;GAEG;AACH;;GAEG;AAEH;;GAEG;AACH;;GAEG;AAuCI,gCALI,OAAO,CAAC,GAAG,CAAC,WACZ,cAAc,kBACX,OAAO,EAAA,GACR,IAAI,CAUhB;;gCA3C0B,OAAO,WAAW,OAAO,EAAE,KAAK,IAAI;2BACxC,OAAO,WAAW,OAAO,EAAE,KAAK,IAAI"}

package/src/watch-promise.js

@@ -0,0 +1,81 @@
+// @ts-check
+import { Fail } from '@endo/errors';
+import { M } from '@endo/patterns';
+import { E } from '@endo/far';
+
+const { apply } = Reflect;
+
+/**
+ * A PromiseWatcher method guard callable with or more arguments, returning void.
+ */
+export const PromiseWatcherHandler = M.call(M.raw()).rest(M.raw()).returns();
+
+/**
+ * A PromiseWatcher interface that has both onFulfilled and onRejected handlers.
+ */
+export const PromiseWatcherI = M.interface('PromiseWatcher', {
+  onFulfilled: PromiseWatcherHandler,
+  onRejected: PromiseWatcherHandler,
+});
+
+/**
+ * A PromiseWatcher interface that has only an onFulfilled handler.
+ */
+export const PromiseWatcherFulfilledI = M.interface('PromiseWatcherFulfilled', {
+  onFulfilled: PromiseWatcherHandler,
+});
+
+/**
+ * A PromiseWatcher interface that has only an onRejected handler.
+ */
+export const PromiseWatcherRejectedI = M.interface('PromiseWatcherRejected', {
+  onRejected: PromiseWatcherHandler,
+});
+
+/**
+ * @typedef {object} PromiseWatcher
+ * @property {(fulfilment: unknown, ...args: unknown[]) => void} [onFulfilled]
+ * @property {(reason: unknown, ...args: unknown[]) => void} [onRejected]
+ */
+
+/**
+ * Adapt a promise watcher method to E.when.
+ * @param {Record<PropertyKey, (...args: unknown[]) => unknown>} that
+ * @param {PropertyKey} prop
+ * @param {unknown[]} postArgs
+ */
+const callMeMaybe = (that, prop, postArgs) => {
+  const fn = that[prop];
+  if (!fn) {
+    return undefined;
+  }
+  assert.typeof(fn, 'function');
+  /**
+   * @param {unknown} arg value or reason
+   */
+  const wrapped = arg => {
+    // Don't return a value, to prevent E.when from subscribing to a resulting
+    // promise.
+    apply(fn, that, [arg, ...postArgs]);
+  };
+  return wrapped;
+};
+
+/**
+ * Shim the promise watcher behaviour when VatData.watchPromise is not available.
+ *
+ * @param {Promise<any>} p
+ * @param {PromiseWatcher} watcher
+ * @param {...unknown} watcherArgs
+ * @returns {void}
+ */
+export const watchPromise = (p, watcher, ...watcherArgs) => {
+  Promise.resolve(p) === p || Fail`watchPromise only watches promises`;
+  const onFulfilled = callMeMaybe(watcher, 'onFulfilled', watcherArgs);
+  const onRejected = callMeMaybe(watcher, 'onRejected', watcherArgs);
+  onFulfilled ||
+    onRejected ||
+    Fail`promise watcher must implement at least one handler method`;
+  void E.when(p, onFulfilled, onRejected);
+};
+harden(watchPromise);

package/test/{test-exos.js → exos.test.js}

@@ -1,4 +1,3 @@
-// eslint-disable-next-line import/order
 import { test } from './prepare-test-env-ava.js';
 
 import { makeHeapZone } from '../heap.js';

package/test/prepare-attenuator.test.js

@@ -0,0 +1,110 @@
+// Modeled on test-heap-classes.js
+
+import { test } from './prepare-test-env-ava.js';
+
+// eslint-disable-next-line import/order
+import { M } from '@endo/patterns';
+import { makeHeapZone } from '../src/heap.js';
+import { prepareAttenuatorMaker } from '../src/prepare-attenuator.js';
+
+const CounterI = M.interface('Counter', {
+  incr: M.call()
+    // TODO M.number() should not be needed to get a better error message
+    .optional(M.and(M.number(), M.gte(0)))
+    .returns(M.number()),
+  decr: M.call()
+    // TODO M.number() should not be needed to get a better error message
+    .optional(M.and(M.number(), M.gte(0)))
+    .returns(M.number()),
+});
+
+test('test attenuate defineVirtualExoClass', t => {
+  const zone = makeHeapZone('rootZone');
+
+  const makeUnderlyingCounter = zone.exoClass(
+    'Counter',
+    CounterI,
+    /** @param {number} [x] */
+    (x = 0) => ({ x }),
+    {
+      incr(y = 1) {
+        const { state } = this;
+        state.x += y;
+        return state.x;
+      },
+      decr(y = 1) {
+        const { state } = this;
+        state.x -= y;
+        return state.x;
+      },
+    },
+  );
+
+  const makeUpAttenuator = prepareAttenuatorMaker(zone, 'UpCounter', ['incr']);
+
+  const makeUpCounter = x => makeUpAttenuator(makeUnderlyingCounter(x));
+
+  const upCounter = makeUpCounter(3);
+  t.is(upCounter.incr(5), 8);
+  t.throws(() => upCounter.decr(1), {
+    message: 'upCounter.decr is not a function',
+  });
+});
+
+test('test revoke defineVirtualExoClassKit', t => {
+  const zone = makeHeapZone('rootZone');
+
+  const makeUnderlyingCounter = zone.exoClass(
+    'Counter',
+    CounterI,
+    /** @param {number} [x] */
+    (x = 0) => ({ x }),
+    {
+      incr(y = 1) {
+        const { state } = this;
+        state.x += y;
+        return state.x;
+      },
+      decr(y = 1) {
+        const { state } = this;
+        state.x -= y;
+        return state.x;
+      },
+    },
+  );
+
+  const makeDownAttenuator = prepareAttenuatorMaker(
+    zone,
+    'DownCounter',
+    ['decr'],
+    {
+      extraMethodGuards: {
+        selfRevoke: M.call().returns(M.boolean()),
+      },
+      extraMethods: {
+        selfRevoke() {
+          const { state } = this;
+          if (state.underlying === undefined) {
+            return false;
+          }
+          // @ts-expect-error Setting this to `undefined` is purposely outside
+          // the type system.
+          state.underlying = undefined;
+          return true;
+        },
+      },
+    },
+  );
+
+  const makeDownCounter = x => makeDownAttenuator(makeUnderlyingCounter(x));
+
+  const downCounter = makeDownCounter(3);
+  t.throws(() => downCounter.incr(1), {
+    message: 'downCounter.incr is not a function',
+  });
+  t.is(downCounter.decr(), 2);
+  t.is(downCounter.selfRevoke(), true);
+  t.throws(() => downCounter.decr(3), {
+    message: '"DownCounter_attenuator" revoked',
+  });
+});

package/test/{test-prepare-revocable.js → prepare-revocable.test.js}

@@ -5,7 +5,7 @@ import { test } from './prepare-test-env-ava.js';
 // eslint-disable-next-line import/order
 import { M } from '@endo/patterns';
 import { makeHeapZone } from '../src/heap.js';
-import { prepareRevocableKit } from '../src/prepare-revocable.js';
+import { prepareRevocableMakerKit } from '../src/prepare-revocable.js';
 
 const UpCounterI = M.interface('UpCounter', {
   incr: M.call()
@@ -38,16 +38,17 @@ test('test revoke defineVirtualExoClass', t => {
     },
   );
 
-  const makeRevocableUpCounterKit = prepareRevocableKit(zone, 'UpCounter', [
-    'incr',
-  ]);
+  const { revoke, makeRevocable } = prepareRevocableMakerKit(
+    zone,
+    'UpCounter',
+    ['incr'],
+  );
 
-  const makeUpCounterKit = x =>
-    makeRevocableUpCounterKit(makeUnderlyingUpCounter(x));
+  const makeUpCounter = x => makeRevocable(makeUnderlyingUpCounter(x));
 
-  const { revoker, revocable: upCounter } = makeUpCounterKit(3);
+  const upCounter = makeUpCounter(3);
   t.is(upCounter.incr(5), 8);
-  t.is(revoker.revoke(), true);
+  t.is(revoke(upCounter), true);
   t.throws(() => upCounter.incr(1), {
     message: '"UpCounter_caretaker" revoked',
   });
@@ -79,7 +80,7 @@ test('test revoke defineVirtualExoClassKit', t => {
     },
   );
 
-  const makeRevocableUpCounterKit = prepareRevocableKit(
+  const { revoke, makeRevocable } = prepareRevocableMakerKit(
     zone,
     'UpCounter',
     ['incr'],
@@ -89,8 +90,12 @@ test('test revoke defineVirtualExoClassKit', t => {
       },
       extraMethods: {
         selfRevoke() {
-          const { revoker } = this.facets;
-          return revoker.revoke();
+          // Could directly use the revoker facet instead, but this
+          // should now be considered more of an internal detail that
+          // we should deemphasize. This tests the code pattern we wish
+          // to encourage.
+          const { revocable } = this.facets;
+          return revoke(revocable);
         },
       },
     },
@@ -98,8 +103,7 @@ test('test revoke defineVirtualExoClassKit', t => {
 
   const makeCounterKit = x => {
     const { up: upCounter, down: downCounter } = makeUnderlyingCounterKit(x);
-    const { revocable: revocableUpCounter } =
-      makeRevocableUpCounterKit(upCounter);
+    const revocableUpCounter = makeRevocable(upCounter);
     return harden({
       up: revocableUpCounter,
       down: downCounter,

package/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./heap.js","./zone-helpers.js","./src/heap.js","./src/index.js","./src/is-passable.js","./src/keys.js","./src/make-once.js","./src/prepare-attenuator.js","./src/prepare-revocable.js","./src/types.js","./src/watch-promise.js"],"version":"5.9.2"}

package/tsconfig.json

@@ -1,9 +1,7 @@
 // This file can contain .js-specific Typescript compiler config.
 {
   "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "maxNodeModuleJsDepth": 2,
-  },
+  "compilerOptions": {},
   "include": [
     "*.js",
     "scripts",

package/zone-helpers.d.ts

@@ -1,2 +1,3 @@
 export * from "./src/prepare-revocable.js";
+export * from "./src/prepare-attenuator.js";
 //# sourceMappingURL=zone-helpers.d.ts.map

package/zone-helpers.js

@@ -1 +1,2 @@
 export * from './src/prepare-revocable.js';
+export * from './src/prepare-attenuator.js';