@agoric/vow 0.1.1-dev-c5284e4.0

package/src/E.js

@@ -0,0 +1,448 @@
+// @ts-check
+import { trackTurns } from './track-turns.js';
+import { makeMessageBreakpointTester } from './message-breakpoints.js';
+
+const { details: X, quote: q, Fail } = assert;
+const { assign, create } = Object;
+
+const onSend = makeMessageBreakpointTester('ENDO_SEND_BREAKPOINTS');
+
+/** @typedef {(...args: any[]) => any} Callable */
+
+/** @type {ProxyHandler<any>} */
+const baseFreezableProxyHandler = {
+  set(_target, _prop, _value) {
+    return false;
+  },
+  isExtensible(_target) {
+    return false;
+  },
+  setPrototypeOf(_target, _value) {
+    return false;
+  },
+  deleteProperty(_target, _prop) {
+    return false;
+  },
+};
+
+// E Proxy handlers pretend that any property exists on the target and returns
+// a function for their value. While this function is "bound" by context, it is
+// meant to be called as a method. For that reason, the returned function
+// includes a check that the `this` argument corresponds to the initial
+// receiver when the function was retrieved.
+// E Proxy handlers also forward direct calls to the target in case the remote
+// is a function instead of an object. No such receiver checks are necessary in
+// that case.
+
+/**
+ * A Proxy handler for E(x).
+ *
+ * @param {any} recipient Any value passed to E(x)
+ * @param {import('@endo/eventual-send').HandledPromiseConstructor} HandledPromise
+ * @param {(x: any) => Promise<any>} unwrap
+ * @returns {ProxyHandler<any>} the Proxy handler
+ */
+const makeEProxyHandler = (recipient, HandledPromise, unwrap) =>
+  harden({
+    ...baseFreezableProxyHandler,
+    get: (_target, propertyKey, receiver) => {
+      return harden(
+        {
+          /**
+           * This function purposely checks the `this` value (see above)
+           * In order to be `this` sensitive it is defined using concise method
+           * syntax rather than as an arrow function. To ensure the function
+           * is not constructable, it also avoids the `function` syntax.
+           * @param  {...any[]} args
+           */
+          [propertyKey](...args) {
+            if (this !== receiver) {
+              // Reject the async function call
+              return HandledPromise.reject(
+                assert.error(
+                  X`Unexpected receiver for "${q(propertyKey)}" method of E(${q(
+                    recipient,
+                  )})`,
+                ),
+              );
+            }
+
+            if (onSend && onSend.shouldBreakpoint(recipient, propertyKey)) {
+              // eslint-disable-next-line no-debugger
+              debugger; // LOOK UP THE STACK
+              // Stopped at a breakpoint on eventual-send of a method-call message,
+              // so that you can walk back on the stack to see how we came to
+              // make this eventual-send
+            }
+            return unwrap(
+              HandledPromise.applyMethod(unwrap(recipient), propertyKey, args),
+            );
+          },
+          // @ts-expect-error https://github.com/microsoft/TypeScript/issues/50319
+        }[propertyKey],
+      );
+    },
+    apply: (_target, _thisArg, argArray = []) => {
+      if (onSend && onSend.shouldBreakpoint(recipient, undefined)) {
+        // eslint-disable-next-line no-debugger
+        debugger; // LOOK UP THE STACK
+        // Stopped at a breakpoint on eventual-send of a function-call message,
+        // so that you can walk back on the stack to see how we came to
+        // make this eventual-send
+      }
+      return unwrap(HandledPromise.applyFunction(unwrap(recipient), argArray));
+    },
+    has: (_target, _p) => {
+      // We just pretend everything exists.
+      return true;
+    },
+  });
+
+/**
+ * A Proxy handler for E.sendOnly(x)
+ * It is a variant on the E(x) Proxy handler.
+ *
+ * @param {any} recipient Any value passed to E.sendOnly(x)
+ * @param {import('@endo/eventual-send').HandledPromiseConstructor} HandledPromise
+ * @param {(x: any) => Promise<any>} unwrap
+ * @returns {ProxyHandler<any>} the Proxy handler
+ */
+const makeESendOnlyProxyHandler = (recipient, HandledPromise, unwrap) =>
+  harden({
+    ...baseFreezableProxyHandler,
+    get: (_target, propertyKey, receiver) => {
+      return harden(
+        {
+          /**
+           * This function purposely checks the `this` value (see above)
+           * In order to be `this` sensitive it is defined using concise method
+           * syntax rather than as an arrow function. To ensure the function
+           * is not constructable, it also avoids the `function` syntax.
+           * @param  {...any[]} args
+           */
+          [propertyKey](...args) {
+            // Throw since the function returns nothing
+            this === receiver ||
+              Fail`Unexpected receiver for "${q(
+                propertyKey,
+              )}" method of E.sendOnly(${q(recipient)})`;
+            if (onSend && onSend.shouldBreakpoint(recipient, propertyKey)) {
+              // eslint-disable-next-line no-debugger
+              debugger; // LOOK UP THE STACK
+              // Stopped at a breakpoint on eventual-send of a method-call message,
+              // so that you can walk back on the stack to see how we came to
+              // make this eventual-send
+            }
+            HandledPromise.applyMethodSendOnly(
+              unwrap(recipient),
+              propertyKey,
+              args,
+            );
+            return undefined;
+          },
+          // @ts-expect-error https://github.com/microsoft/TypeScript/issues/50319
+        }[propertyKey],
+      );
+    },
+    apply: (_target, _thisArg, argsArray = []) => {
+      if (onSend && onSend.shouldBreakpoint(recipient, undefined)) {
+        // eslint-disable-next-line no-debugger
+        debugger; // LOOK UP THE STACK
+        // Stopped at a breakpoint on eventual-send of a function-call message,
+        // so that you can walk back on the stack to see how we came to
+        // make this eventual-send
+      }
+      HandledPromise.applyFunctionSendOnly(unwrap(recipient), argsArray);
+      return undefined;
+    },
+    has: (_target, _p) => {
+      // We just pretend that everything exists.
+      return true;
+    },
+  });
+
+/**
+ * A Proxy handler for E.get(x)
+ * It is a variant on the E(x) Proxy handler.
+ *
+ * @param {any} x Any value passed to E.get(x)
+ * @param {import('@endo/eventual-send').HandledPromiseConstructor} HandledPromise
+ * @param {(x: any) => Promise<any>} unwrap
+ * @returns {ProxyHandler<any>} the Proxy handler
+ */
+const makeEGetProxyHandler = (x, HandledPromise, unwrap) =>
+  harden({
+    ...baseFreezableProxyHandler,
+    has: (_target, _prop) => true,
+    get: (_target, prop) => HandledPromise.get(unwrap(x), prop),
+  });
+
+/** @param {any} x */
+const resolve = x => HandledPromise.resolve(x);
+
+/**
+ * @template [A={}]
+ * @template {(x: any) => Promise<any>} [U=(x: any) => Promise<any>]
+ * @param {import('@endo/eventual-send').HandledPromiseConstructor} HandledPromise
+ * @param {object} [powers]
+ * @param {U} [powers.unwrap]
+ * @param {A} [powers.additional]
+ */
+const makeE = (
+  HandledPromise,
+  {
+    additional = /** @type {A} */ ({}),
+    unwrap = /** @type {U} */ (resolve),
+  } = {},
+) => {
+  return harden(
+    assign(
+      /**
+       * E(x) returns a proxy on which you can call arbitrary methods. Each of these
+       * method calls returns a promise. The method will be invoked on whatever
+       * 'x' designates (or resolves to) in a future turn, not this one.
+       *
+       * @template T
+       * @param {T} x target for method/function call
+       * @returns {ECallableOrMethods<RemoteFunctions<T>>} method/function call proxy
+       */
+      x =>
+        harden(
+          new Proxy(() => {}, makeEProxyHandler(x, HandledPromise, unwrap)),
+        ),
+      {
+        /**
+         * E.get(x) returns a proxy on which you can get arbitrary properties.
+         * Each of these properties returns a promise for the property.  The promise
+         * value will be the property fetched from whatever 'x' designates (or
+         * resolves to) in a future turn, not this one.
+         *
+         * @template T
+         * @param {T} x target for property get
+         * @returns {EGetters<LocalRecord<T>>} property get proxy
+         * @readonly
+         */
+        get: x =>
+          harden(
+            new Proxy(
+              create(null),
+              makeEGetProxyHandler(x, HandledPromise, unwrap),
+            ),
+          ),
+
+        /**
+         * E.resolve(x) converts x to a handled promise. It is
+         * shorthand for HandledPromise.resolve(x)
+         *
+         * @template T
+         * @param {T} x value to convert to a handled promise
+         * @returns {Promise<Awaited<T>>} handled promise for x
+         * @readonly
+         */
+        resolve: x => resolve(unwrap(x)),
+
+        /**
+         * E.sendOnly returns a proxy similar to E, but for which the results
+         * are ignored (undefined is returned).
+         *
+         * @template T
+         * @param {T} x target for method/function call
+         * @returns {ESendOnlyCallableOrMethods<RemoteFunctions<T>>} method/function call proxy
+         * @readonly
+         */
+        sendOnly: x =>
+          harden(
+            new Proxy(
+              () => {},
+              makeESendOnlyProxyHandler(x, HandledPromise, unwrap),
+            ),
+          ),
+
+        /**
+         * E.when(x, res, rej) is equivalent to
+         * unwrapped(x).then(onfulfilled, onrejected)
+         *
+         * @template T
+         * @template [TResult1=Unwrap<T>]
+         * @template [TResult2=never]
+         * @param {ERef<T>} x value to convert to a handled promise
+         * @param {(value: Unwrap<T>) => ERef<TResult1>} [onfulfilled]
+         * @param {(reason: any) => ERef<TResult2>} [onrejected]
+         * @returns {Promise<TResult1 | TResult2>}
+         * @readonly
+         */
+        when: (x, onfulfilled, onrejected) => {
+          const unwrapped = resolve(unwrap(x));
+          if (onfulfilled == null && onrejected == null) {
+            return unwrapped;
+          }
+          return unwrapped.then(
+            ...trackTurns(/** @type {const} */ ([onfulfilled, onrejected])),
+          );
+        },
+      },
+      additional,
+    ),
+  );
+};
+
+export default makeE;
+
+/** @typedef {ReturnType<makeE>} EProxy */
+
+/**
+ * `DataOnly<T>` means to return a record type `T2` consisting only of
+ * properties that are *not* functions.
+ *
+ * @template T The type to be filtered.
+ * @typedef {Omit<T, FilteredKeys<T, Callable>>} DataOnly
+ */
+
+/**
+ * @see {@link https://github.com/microsoft/TypeScript/issues/31394}
+ * @template T
+ * @typedef {PromiseLike<T> | T} ERef
+ */
+
+/**
+ * @template {Callable} T
+ * @typedef {(
+ *   ReturnType<T> extends PromiseLike<infer U>                       // if function returns a promise
+ *     ? T                                                            // return the function
+ *     : (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>  // make it return a promise
+ * )} ECallable
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *   readonly [P in keyof T]: T[P] extends Callable
+ *     ? ECallable<T[P]>
+ *     : never;
+ * }} EMethods
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *   readonly [P in keyof T]: T[P] extends PromiseLike<infer U>
+ *     ? T[P]
+ *     : Promise<Awaited<T[P]>>;
+ * }} EGetters
+ */
+
+/**
+ * @template {Callable} T
+ * @typedef {(...args: Parameters<T>) => Promise<void>} ESendOnlyCallable
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *   readonly [P in keyof T]: T[P] extends Callable
+ *     ? ESendOnlyCallable<T[P]>
+ *     : never;
+ * }} ESendOnlyMethods
+ */
+
+/**
+ * @template T
+ * @typedef {(
+ *   T extends Callable
+ *     ? ESendOnlyCallable<T> & ESendOnlyMethods<Required<T>>
+ *     : ESendOnlyMethods<Required<T>>
+ * )} ESendOnlyCallableOrMethods
+ */
+
+/**
+ * @template T
+ * @typedef {(
+ *   T extends Callable
+ *     ? ECallable<T> & EMethods<Required<T>>
+ *     : EMethods<Required<T>>
+ * )} ECallableOrMethods
+ */
+
+/**
+ * Return a union of property names/symbols/numbers P for which the record element T[P]'s type extends U.
+ *
+ * Given const x = { a: 123, b: 'hello', c: 42, 49: () => {}, 53: 67 },
+ *
+ * FilteredKeys<typeof x, number> is the type 'a' | 'c' | 53.
+ * FilteredKeys<typeof x, string> is the type 'b'.
+ * FilteredKeys<typeof x, 42 | 67> is the type 'c' | 53.
+ * FilteredKeys<typeof x, boolean> is the type never.
+ *
+ * @template T
+ * @template U
+ * @typedef {{ [P in keyof T]: T[P] extends U ? P : never; }[keyof T]} FilteredKeys
+ */
+
+/**
+ * `PickCallable<T>` means to return a single root callable or a record type
+ * consisting only of properties that are functions.
+ *
+ * @template T
+ * @typedef {(
+ *   T extends Callable
+ *     ? (...args: Parameters<T>) => ReturnType<T>                     // a root callable, no methods
+ *     : Pick<T, FilteredKeys<T, Callable>>          // any callable methods
+ * )} PickCallable
+ */
+
+/**
+ * `RemoteFunctions<T>` means to return the functions and properties that are remotely callable.
+ *
+ * @template T
+ * @typedef {(
+ *   T extends import('@endo/eventual-send').RemotableBrand<infer L, infer R>     // if a given T is some remote interface R
+ *     ? PickCallable<R>                                              // then return the callable properties of R
+ *     : Awaited<T> extends import('@endo/eventual-send').RemotableBrand<infer L, infer R> // otherwise, if the final resolution of T is some remote interface R
+ *     ? PickCallable<R>                                              // then return the callable properties of R
+ *     : Awaited<T> extends import('./types').Vow<infer U>
+ *     ? RemoteFunctions<U>                                           // then extract the remotable functions of U
+ *     : T extends PromiseLike<infer U>                               // otherwise, if T is a promise
+ *     ? Awaited<T>                                                   // then return resolved value T
+ *     : T                                                            // otherwise, return T
+ * )} RemoteFunctions
+ */
+
+/**
+ * @template T
+ * @typedef {T extends PromiseLike<infer U> ? Unwrap<U> :
+ *   T extends import('./types').Vow<infer U> ? Unwrap<U> :
+ *   T} Unwrap
+ */
+
+/**
+ * @template T
+ * @typedef {(
+ *   T extends import('@endo/eventual-send').RemotableBrand<infer L, infer R>
+ *     ? L
+ *     : Awaited<T> extends import('@endo/eventual-send').RemotableBrand<infer L, infer R>
+ *     ? L
+ *     : Awaited<T> extends import('./types').Vow<infer U>
+ *     ? LocalRecord<U>
+ *     : T extends PromiseLike<infer U>
+ *     ? Awaited<T>
+ *     : T
+ * )} LocalRecord
+ */
+
+/**
+ * Type for an object that must only be invoked with E.  It supports a given
+ * interface but declares all the functions as asyncable.
+ *
+ * @template T
+ * @typedef {(
+ *   T extends Callable
+ *     ? (...args: Parameters<T>) => ERef<Awaited<EOnly<ReturnType<T>>>>
+ *     : T extends Record<PropertyKey, Callable>
+ *     ? {
+ *         [K in keyof T]: T[K] extends Callable
+ *           ? (...args: Parameters<T[K]>) => ERef<Awaited<EOnly<ReturnType<T[K]>>>>
+ *           : T[K];
+ *       }
+ *     : T
+ * )} EOnly
+ */

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./tools.js";
+export * from "./types.js";
+export { default as makeE } from "./E.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

@@ -0,0 +1,6 @@
+// @ts-check
+export * from './tools.js';
+export { default as makeE } from './E.js';
+
+// eslint-disable-next-line import/export
+export * from './types.js';

package/src/message-breakpoints.d.ts

@@ -0,0 +1,44 @@
+export function makeMessageBreakpointTester(optionName: string): MessageBreakpointTester | undefined;
+/**
+ * A star `'*'` matches any recipient. Otherwise, the string is
+ * matched against the value of a recipient's `@@toStringTag`
+ * after stripping out any leading `'Alleged: '` or `'DebugName: '`
+ * prefix. For objects defined with `Far` this is the first argument,
+ * known as the `farName`. For exos, this is the tag.
+ */
+export type MatchStringTag = string | '*';
+/**
+ * A star `'*'` matches any method name. Otherwise, the string is
+ * matched against the method name. Currently, this is only an exact match.
+ * However, beware that we may introduce a string syntax for
+ * symbol method names.
+ */
+export type MatchMethodName = string | '*';
+/**
+ * A star `'*'` will always breakpoint. Otherwise, the string
+ * must be a non-negative integer. Once that is zero, always breakpoint.
+ * Otherwise decrement by one each time it matches until it reaches zero.
+ * In other words, the countdown represents the number of
+ * breakpoint occurrences to skip before actually breakpointing.
+ */
+export type MatchCountdown = number | '*';
+/**
+ * This is the external JSON representation, in which
+ * - the outer property name is the class-like tag or '*',
+ * - the inner property name is the method name or '*',
+ * - the value is a non-negative integer countdown or '*'.
+ */
+export type MessageBreakpoints = Record<MatchStringTag, Record<MatchMethodName, MatchCountdown>>;
+/**
+ * This is the internal JSON representation, in which
+ * - the outer property name is the method name or '*',
+ * - the inner property name is the class-like tag or '*',
+ * - the value is a non-negative integer countdown or '*'.
+ */
+export type BreakpointTable = Record<MatchMethodName, Record<MatchStringTag, MatchCountdown>>;
+export type MessageBreakpointTester = {
+    getBreakpoints: () => MessageBreakpoints;
+    setBreakpoints: (newBreakpoints?: MessageBreakpoints) => void;
+    shouldBreakpoint: (recipient: object, methodName: string | symbol | undefined) => boolean;
+};
+//# sourceMappingURL=message-breakpoints.d.ts.map

package/src/message-breakpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-breakpoints.d.ts","sourceRoot":"","sources":["message-breakpoints.js"],"names":[],"mappings":"AA0FO,wDAHI,MAAM,GACJ,uBAAuB,GAAG,SAAS,CA0F/C;;;;;;;;6BA1KY,MAAM,GAAG,GAAG;;;;;;;8BAQZ,MAAM,GAAG,GAAG;;;;;;;;6BAOZ,MAAM,GAAG,GAAG;;;;;;;iCAcZ,OAAO,cAAc,EAAE,OAAO,eAAe,EAAE,cAAc,CAAC,CAAC;;;;;;;8BAS/D,OAAO,eAAe,EAAE,OAAO,cAAc,EAAE,cAAc,CAAC,CAAC;;oBAK9D,MAAM,kBAAkB;sCACN,kBAAkB,KAAK,IAAI;kCAE3C,MAAM,cACL,MAAM,GAAG,MAAM,GAAG,SAAS,KACpC,OAAO"}

package/src/message-breakpoints.js

@@ -0,0 +1,180 @@
+// @ts-check
+import { getEnvironmentOption } from '@endo/env-options';
+
+const { quote: q, Fail } = assert;
+
+const { hasOwn, freeze, entries } = Object;
+
+/**
+ * @typedef {string | '*'} MatchStringTag
+ *   A star `'*'` matches any recipient. Otherwise, the string is
+ *   matched against the value of a recipient's `@@toStringTag`
+ *   after stripping out any leading `'Alleged: '` or `'DebugName: '`
+ *   prefix. For objects defined with `Far` this is the first argument,
+ *   known as the `farName`. For exos, this is the tag.
+ */
+/**
+ * @typedef {string | '*'} MatchMethodName
+ *   A star `'*'` matches any method name. Otherwise, the string is
+ *   matched against the method name. Currently, this is only an exact match.
+ *   However, beware that we may introduce a string syntax for
+ *   symbol method names.
+ */
+/**
+ * @typedef {number | '*'} MatchCountdown
+ *   A star `'*'` will always breakpoint. Otherwise, the string
+ *   must be a non-negative integer. Once that is zero, always breakpoint.
+ *   Otherwise decrement by one each time it matches until it reaches zero.
+ *   In other words, the countdown represents the number of
+ *   breakpoint occurrences to skip before actually breakpointing.
+ */
+
+/**
+ * This is the external JSON representation, in which
+ * - the outer property name is the class-like tag or '*',
+ * - the inner property name is the method name or '*',
+ * - the value is a non-negative integer countdown or '*'.
+ *
+ * @typedef {Record<MatchStringTag, Record<MatchMethodName, MatchCountdown>>} MessageBreakpoints
+ */
+
+/**
+ * This is the internal JSON representation, in which
+ * - the outer property name is the method name or '*',
+ * - the inner property name is the class-like tag or '*',
+ * - the value is a non-negative integer countdown or '*'.
+ *
+ * @typedef {Record<MatchMethodName, Record<MatchStringTag, MatchCountdown>>} BreakpointTable
+ */
+
+/**
+ * @typedef {object} MessageBreakpointTester
+ * @property {() => MessageBreakpoints} getBreakpoints
+ * @property {(newBreakpoints?: MessageBreakpoints) => void} setBreakpoints
+ * @property {(
+ *   recipient: object,
+ *   methodName: string | symbol | undefined
+ * ) => boolean} shouldBreakpoint
+ */
+
+/**
+ * @param {any} val
+ * @returns {val is Record<string, any>}
+ */
+const isJSONRecord = val =>
+  typeof val === 'object' && val !== null && !Array.isArray(val);
+
+/**
+ * Return `tag` after stripping off any `'Alleged: '` or `'DebugName: '`
+ * prefix if present.
+ * ```js
+ * simplifyTag('Alleged: moola issuer') === 'moola issuer'
+ * ```
+ * If there are multiple such prefixes, only the outer one is removed.
+ *
+ * @param {string} tag
+ * @returns {string}
+ */
+const simplifyTag = tag => {
+  for (const prefix of ['Alleged: ', 'DebugName: ']) {
+    if (tag.startsWith(prefix)) {
+      return tag.slice(prefix.length);
+    }
+  }
+  return tag;
+};
+
+/**
+ * @param {string} optionName
+ * @returns {MessageBreakpointTester | undefined}
+ */
+export const makeMessageBreakpointTester = optionName => {
+  let breakpoints = JSON.parse(getEnvironmentOption(optionName, 'null'));
+
+  if (breakpoints === null) {
+    return undefined;
+  }
+
+  /** @type {BreakpointTable} */
+  let breakpointsTable;
+
+  const getBreakpoints = () => breakpoints;
+  freeze(getBreakpoints);
+
+  const setBreakpoints = (newBreakpoints = breakpoints) => {
+    isJSONRecord(newBreakpoints) ||
+      Fail`Expected ${q(optionName)} option to be a JSON breakpoints record`;
+
+    /** @type {BreakpointTable} */
+    // @ts-expect-error confused by __proto__
+    const newBreakpointsTable = { __proto__: null };
+
+    for (const [tag, methodBPs] of entries(newBreakpoints)) {
+      tag === simplifyTag(tag) ||
+        Fail`Just use simple tag ${q(simplifyTag(tag))} rather than ${q(tag)}`;
+      isJSONRecord(methodBPs) ||
+        Fail`Expected ${q(optionName)} option's ${q(
+          tag,
+        )} to be a JSON methods breakpoints record`;
+      for (const [methodName, count] of entries(methodBPs)) {
+        count === '*' ||
+          (typeof count === 'number' &&
+            Number.isSafeInteger(count) &&
+            count >= 0) ||
+          Fail`Expected ${q(optionName)} option's ${q(tag)}.${q(
+            methodName,
+          )} to be "*" or a non-negative integer`;
+
+        const classBPs = hasOwn(newBreakpointsTable, methodName)
+          ? newBreakpointsTable[methodName]
+          : (newBreakpointsTable[methodName] = {
+              // @ts-expect-error confused by __proto__
+              __proto__: null,
+            });
+        classBPs[tag] = count;
+      }
+    }
+    breakpoints = newBreakpoints;
+    breakpointsTable = newBreakpointsTable;
+  };
+  freeze(setBreakpoints);
+
+  const shouldBreakpoint = (recipient, methodName) => {
+    if (methodName === undefined || methodName === null) {
+      // TODO enable function breakpointing
+      return false;
+    }
+    const classBPs = breakpointsTable[methodName] || breakpointsTable['*'];
+    if (classBPs === undefined) {
+      return false;
+    }
+    let tag = simplifyTag(recipient[Symbol.toStringTag]);
+    let count = classBPs[tag];
+    if (count === undefined) {
+      tag = '*';
+      count = classBPs[tag];
+      if (count === undefined) {
+        return false;
+      }
+    }
+    if (count === '*') {
+      return true;
+    }
+    if (count === 0) {
+      return true;
+    }
+    assert(typeof count === 'number' && count >= 1);
+    classBPs[tag] = count - 1;
+    return false;
+  };
+  freeze(shouldBreakpoint);
+
+  const breakpointTester = freeze({
+    getBreakpoints,
+    setBreakpoints,
+    shouldBreakpoint,
+  });
+  breakpointTester.setBreakpoints();
+  return breakpointTester;
+};
+freeze(makeMessageBreakpointTester);