@agoric/base-zone 0.1.1-u20.0 → 0.1.1-u21.0.1

package/CHANGELOG.md

@@ -3,13 +3,15 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-### 0.1.1-u20.0 (2025-04-16)
+### 0.1.1-u21.0 (2025-06-19)
 
 
 ### Features
 
 * **base-zone:** add `zone.watchPromise` ([9ce80d0](https://github.com/Agoric/agoric-sdk/commit/9ce80d06c0a56471d2da9f372b0b2d93d31d159a))
 * **base-zone:** alt revocable api using amplifier ([#8977](https://github.com/Agoric/agoric-sdk/issues/8977)) ([5cdf6e3](https://github.com/Agoric/agoric-sdk/commit/5cdf6e3a8b4fbb5cb8e276e6efeec65d9c3d6623))
+* **base-zone:** attenuator as simplified revocable ([#11314](https://github.com/Agoric/agoric-sdk/issues/11314)) ([c962ba0](https://github.com/Agoric/agoric-sdk/commit/c962ba0771022947027b9bd76339a3ab21406b20))
+* **base-zone:** expose `makeRevocableKit` for pure Exos ([b0b2af0](https://github.com/Agoric/agoric-sdk/commit/b0b2af0a7b5f8402abf836e126a9d7d758fed7dc))
 * **base-zone:** new package ([b7bc677](https://github.com/Agoric/agoric-sdk/commit/b7bc677238eee5969ac0a95dc066434ef676216e))
 * **types:** generic zone.mapStore ([a9b055d](https://github.com/Agoric/agoric-sdk/commit/a9b055dcab34b9c9b136dd430e1e2251d80c5039))
 * **watchUtils:** handle non-storables ([8c27c67](https://github.com/Agoric/agoric-sdk/commit/8c27c6725ba7ef4b71d3ab0ccfdbddd755bcd926))
@@ -18,3 +20,4 @@ See [Conventional Commits](https://conventionalcommits.org) for commit guideline
 ### Bug Fixes
 
 * **base-zone,zone:** import `isPassable` from @endo/pass-style ([#9230](https://github.com/Agoric/agoric-sdk/issues/9230)) ([fbd8633](https://github.com/Agoric/agoric-sdk/commit/fbd8633ae9f8420a589dd9bc32925418f2dde060))
+* **base-zone:** Oops. Forgot to export `prepareAttenuatorMaker` ([#11315](https://github.com/Agoric/agoric-sdk/issues/11315)) ([af493a9](https://github.com/Agoric/agoric-sdk/commit/af493a9026387fc69cbfd57486f00fd33608594d)), closes [#11314](https://github.com/Agoric/agoric-sdk/issues/11314) [#11314](https://github.com/Agoric/agoric-sdk/issues/11314)

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@agoric/base-zone",
-  "version": "0.1.1-u20.0",
+  "version": "0.1.1-u21.0.1",
   "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",
+    "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",
-    "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,7 +27,7 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/store": "^0.9.3-u20.0",
+    "@agoric/store": "0.9.3-u21.0.1",
     "@endo/common": "^1.2.10",
     "@endo/errors": "^1.2.10",
     "@endo/exo": "^1.5.9",
@@ -44,7 +44,7 @@
     "access": "public"
   },
   "engines": {
-    "node": "^18.12 || ^20.9"
+    "node": "^20.9 || ^22.11"
   },
   "ava": {
     "files": [
@@ -59,5 +59,5 @@
   "typeCoverage": {
     "atLeast": 91.4
   },
-  "gitHead": "8e4207fa19dabf76c1f91f8779b5b5b93570ecea"
+  "gitHead": "16519b2de1eb2afda2b4ec866f55eadd4bb18223"
 }

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,10 +1,13 @@
-export function prepareRevocableMakerKit<U = any>(zone: import("@agoric/base-zone").Zone, uKindName: string, uMethodNames: (string | symbol)[], options?: RevocableKitOptions): RevocableMakerKit<U>;
+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: (underlying: U) => U;
+    makeRevocable: MakeRevocable<U>;
+    makeRevocableKit: MakeRevocableKit<U>;
 };
 export type RevokerFacet = {
     revoke: () => boolean;
@@ -14,7 +17,7 @@ export type RevocableKit<U = any> = {
     /**
      *   Forwards to the underlying exo object, until revoked
      */
-    revocable: U;
+    revocable: Partial<U>;
 };
 export type RevocableKitThis<U = any> = {
     facets: RevocableKit<U>;
@@ -33,11 +36,11 @@ export type RevocableKitOptions<U = 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":"AAqEO,yCAVO,CAAC,cACJ,OAAO,mBAAmB,EAAE,IAAI,aAChC,MAAM,gBAEN,CAAC,MAAM,GAAC,MAAM,CAAC,EAAE,YAGjB,mBAAmB,GACjB,iBAAiB,CAAC,CAAC,CAAC,CAyGhC;8BArKa,CAAC;YAED,CAAC,SAAS,EAAE,CAAC,KAAK,OAAO;;;;mBACzB,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC;;;YAMpB,MAAM,OAAO;;yBAIb,CAAC;aAED,YAAY;;;;eACZ,CAAC;;6BAKD,CAAC;YAED,YAAY,CAAC,CAAC,CAAC;WACf;QAAE,UAAU,EAAE,CAAC,CAAA;KAAE;;gCAIjB,CAAC;;;;;;;;;;;;;;;;kDAcH,gBAAgB,CAAC,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,15 +1,35 @@
-import { Fail, q } from '@endo/errors';
-import { fromUniqueEntries } from '@endo/common/from-unique-entries.js';
 import { M } from '@endo/patterns';
+import { wrapperMethods } from './prepare-attenuator.js';
 
 /** @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 {(underlying: U) => U} makeRevocable
+ * @property {MakeRevocable<U>} makeRevocable
  *   Forwards to the underlying exo object, until revoked
+ * @property {MakeRevocableKit<U>} makeRevocableKit
  */
 
 /**
@@ -21,7 +41,7 @@ import { M } from '@endo/patterns';
  * @template [U=any]
  * @typedef {object} RevocableKit
  * @property {RevokerFacet} revoker
- * @property {U} revocable
+ * @property {Partial<U>} revocable
  *   Forwards to the underlying exo object, until revoked
  */
 
@@ -39,14 +59,14 @@ import { M } from '@endo/patterns';
  *   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
@@ -61,10 +81,10 @@ import { M } from '@endo/patterns';
  * @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]
+ * @param {RevocableKitOptions<U>} [options]
  * @returns {RevocableMakerKit<U>}
  */
 export const prepareRevocableMakerKit = (
@@ -75,22 +95,16 @@ export const prepareRevocableMakerKit = (
 ) => {
   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`;
@@ -101,9 +115,7 @@ export const prepareRevocableMakerKit = (
   const makeRevocableKit = zone.exoClassKit(
     revocableKindName,
     RevocableIKit,
-    underlying => ({
-      underlying,
-    }),
+    underlying => ({ underlying }),
     {
       revoker: {
         revoke() {
@@ -115,30 +127,10 @@ export const prepareRevocableMakerKit = (
           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;
       },
@@ -146,12 +138,9 @@ export const prepareRevocableMakerKit = (
   );
 
   /**
-   * @param {U} underlying
-   * @returns {U}
+   * @type {MakeRevocable}
    */
-  const makeRevocable = underlying =>
-    // @ts-expect-error some confusion about UU vs Guarded<U> I think
-    makeRevocableKit(underlying).revocable;
+  const makeRevocable = underlying => makeRevocableKit(underlying).revocable;
 
   /**
    * @param {U} revocable
@@ -169,6 +158,8 @@ export const prepareRevocableMakerKit = (
   return harden({
     revoke,
     makeRevocable,
+    /** @type {MakeRevocableKit} */
+    makeRevocableKit,
   });
 };
 harden(prepareRevocableMakerKit);

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/tsconfig.build.tsbuildinfo

@@ -1 +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-revocable.js","./src/types.js","./src/watch-promise.js"],"version":"5.8.2"}
+{"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.8.3"}

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