refactor(pass-style): faster isObject

packages/captp/package.json

@@ -61,6 +61,7 @@
     "@endo/eventual-send": "workspace:^",
     "@endo/marshal": "workspace:^",
     "@endo/nat": "workspace:^",
+    "@endo/pass-style": "workspace:^",
     "@endo/promise-kit": "workspace:^"
   },
   "bugs": {

packages/captp/src/finalize.js

@@ -1,5 +1,5 @@
 /* global globalThis */
-import { Far, isObject } from '@endo/marshal';
+import { Far, isPrimitive } from '@endo/pass-style';
 
 // @ts-check
 const { WeakRef, FinalizationRegistry } = globalThis;
@@ -112,7 +112,7 @@ export const makeFinalizingMap = (finalizer, opts) => {
     // Does deref, and thus does guarantee stability of both old and new values
     // until the end of the turn.
     set: (key, ref) => {
-      assert(isObject(ref));
+      assert(!isPrimitive(ref));
       finalizingMap.delete(key);
       const newWR = new WeakRef(ref);
       keyToRef.set(key, newWR);

packages/eventual-send/src/local.js

@@ -10,12 +10,20 @@ const ntypeof = specimen => (specimen === null ? 'null' : typeof specimen);
 const onDelivery = makeMessageBreakpointTester('ENDO_DELIVERY_BREAKPOINTS');
 
 /**
- * TODO Consolidate with `isObject` that's currently in `@endo/marshal`
+ * TODO Consolidate with `isPrimitive` that's currently in `@endo/pass-style`.
+ * Layering constraints make this tricky, which is why we haven't yet figured
+ * out how to do this.
  *
- * @param {any} val
- * @returns {boolean}
+ * @type {(val: unknown) => val is (undefined
+ * | null
+ * | boolean
+ * | number
+ * | bigint
+ * | string
+ * | symbol)}
  */
-const isObject = val => Object(val) === val;
+const isPrimitive = val =>
+  !val || (typeof val !== 'object' && typeof val !== 'function');
 
 /**
  * Prioritize symbols as earlier than strings.
@@ -57,7 +65,7 @@ export const getMethodNames = val => {
         names.add(name);
       }
     }
-    if (!isObject(val)) {
+    if (isPrimitive(val)) {
       break;
     }
     layer = getPrototypeOf(layer);

packages/marshal/src/dot-membrane.js

@@ -2,7 +2,12 @@
 /// <reference types="ses"/>
 
 import { E } from '@endo/eventual-send';
-import { isObject, getInterfaceOf, Far, passStyleOf } from '@endo/pass-style';
+import {
+  isPrimitive,
+  getInterfaceOf,
+  Far,
+  passStyleOf,
+} from '@endo/pass-style';
 import { Fail } from '@endo/errors';
 import { makeMarshal } from './marshal.js';
 
@@ -70,7 +75,7 @@ const makeConverter = (mirrorConverter = undefined) => {
             // gc works more often.
             const mineIf = passBack(yours);
 
-            assert(!isObject(optVerb));
+            assert(isPrimitive(optVerb));
             const myArgs = passBack(harden(yourArgs));
             let myResult;
 

packages/marshal/src/encodeToCapData.js

@@ -10,7 +10,7 @@ import {
   passStyleOf,
   isErrorLike,
   makeTagged,
-  isObject,
+  isPrimitive,
   getTag,
   hasOwnPropertyOf,
   assertPassableSymbol,
@@ -52,7 +52,7 @@ const hasQClass = encoded => hasOwnPropertyOf(encoded, QCLASS);
  * @returns {boolean}
  */
 const qclassMatches = (encoded, qclass) =>
-  isObject(encoded) &&
+  !isPrimitive(encoded) &&
   !isArray(encoded) &&
   hasQClass(encoded) &&
   encoded[QCLASS] === qclass;
@@ -323,7 +323,7 @@ export const makeDecodeFromCapData = (decodeOptions = {}) => {
    * @param {Encoding} jsonEncoded must be hardened
    */
   const decodeFromCapData = jsonEncoded => {
-    if (!isObject(jsonEncoded)) {
+    if (isPrimitive(jsonEncoded)) {
       // primitives pass through
       return jsonEncoded;
     }

packages/marshal/src/marshal-justin.js

@@ -4,7 +4,7 @@ import { q, X, Fail } from '@endo/errors';
 import { Nat } from '@endo/nat';
 import {
   getErrorConstructor,
-  isObject,
+  isPrimitive,
   nameForPassableSymbol,
   passableSymbolForName,
 } from '@endo/pass-style';
@@ -144,7 +144,7 @@ const decodeToJustin = (encoding, shouldIndent = false, slots = []) => {
    * @returns {void}
    */
   const prepare = rawTree => {
-    if (!isObject(rawTree)) {
+    if (isPrimitive(rawTree)) {
       return;
     }
     // Assertions of the above to narrow the type.
@@ -292,7 +292,7 @@ const decodeToJustin = (encoding, shouldIndent = false, slots = []) => {
    * @returns {number}
    */
   const recur = rawTree => {
-    if (!isObject(rawTree)) {
+    if (isPrimitive(rawTree)) {
       // primitives get quoted
       return out.next(quote(rawTree));
     }

packages/module-source/test/fixtures/exportheavy.js

@@ -5,6 +5,7 @@ export { mapIterable, filterIterable } from './src/helpers/iter-helpers.js';
 export {
   PASS_STYLE,
   isObject,
+  isPrimitive,
   assertChecker,
   getTag,
   hasOwnPropertyOf,
@@ -43,7 +44,7 @@ export {
 export * from './src/types.js';
 
 
-const { details: X, Fail } = assert;
+export { X, Fail } from '@endo/errors';
 
 // This is a pathological minimum, but exercised by the unit test.
 export const MIN_DATA_BUFFER_LENGTH = 1;

packages/pass-style/NEWS.md

@@ -1,5 +1,9 @@
 User-visible changes in `@endo/pass-style`:
 
+# Next release
+
+The exported function name `isObject` is ambiguous. It is unclear whether it includes functions or not. (It does.) To avoid this confusion, we're deprecating `isObject` and suggesting to use the new export `isPrimitive` instead, that has the opposite answer. IOW, for all `x`, `isObject(x) === !isPrimitive(x)`
+
 # v1.6.2 (2024-06-17)
 
 - Fixes, without qualification, so that the package initializes on platforms

packages/pass-style/index.js

@@ -2,6 +2,7 @@ export { mapIterable, filterIterable } from './src/iter-helpers.js';
 export {
   PASS_STYLE,
   isObject,
+  isPrimitive,
   assertChecker,
   getTag,
   hasOwnPropertyOf,

packages/pass-style/src/passStyle-helpers.js

@@ -1,10 +1,11 @@
 /// <reference types="ses"/>
 
-/** @import {Checker} from './types.js' */
-/** @import {PassStyle} from './types.js' */
-
 import { X, q } from '@endo/errors';
 
+/**
+ * @import {Checker, PassStyle, JSPrimitive} from './types.js';
+ */
+
 const { isArray } = Array;
 const { prototype: functionPrototype } = Function;
 const {
@@ -30,8 +31,25 @@ export const hasOwnPropertyOf = (obj, prop) =>
   apply(objectHasOwnProperty, obj, [prop]);
 harden(hasOwnPropertyOf);
 
-// TODO try typing this; `=> val is {} too narrow, implies no properties
-export const isObject = val => Object(val) === val;
+/**
+ * @type {(val: unknown) => val is JSPrimitive}
+ */
+export const isPrimitive = val =>
+  // Safer would be `Object(val) !== val` but is too expensive on XS.
+  // So instead we use this adhoc set of type tests. But this is not safe in
+  // the face of possible evolution of the language. Beware!
+  !val || (typeof val !== 'object' && typeof val !== 'function');
+harden(isPrimitive);
+
+/**
+ * @deprecated use `!isPrimitive` instead
+ * @type {(val: unknown) => val is (Function | Record<string | symbol, unknown>)}
+ */
+export const isObject = val =>
+  // Safer would be `Object(val) -== val` but is too expensive on XS.
+  // So instead we use this adhoc set of type tests. But this is not safe in
+  // the face of possible evolution of the language. Beware!
+  !!val && (typeof val === 'object' || typeof val === 'function');
 harden(isObject);
 
 /**
@@ -162,7 +180,7 @@ const makeCheckTagRecord = checkProto => {
    */
   const checkTagRecord = (tagRecord, expectedPassStyle, check) => {
     return (
-      (isObject(tagRecord) ||
+      (!isPrimitive(tagRecord) ||
         (!!check &&
           CX(check)`A non-object cannot be a tagRecord: ${tagRecord}`)) &&
       (isFrozen(tagRecord) ||

packages/pass-style/src/passStyleOf.js

@@ -5,7 +5,7 @@
 import { isPromise } from '@endo/promise-kit';
 import { X, Fail, q, annotateError, makeError } from '@endo/errors';
 import {
-  isObject,
+  isPrimitive,
   isTypedArray,
   PASS_STYLE,
   assertChecker,
@@ -123,7 +123,7 @@ const makePassStyleOf = passStyleHelpers => {
     const inProgress = new Set();
 
     const passStyleOfRecur = inner => {
-      const innerIsObject = isObject(inner);
+      const innerIsObject = !isPrimitive(inner);
       if (innerIsObject) {
         const innerStyle = passStyleMemo.get(inner);
         if (innerStyle) {
@@ -359,11 +359,11 @@ export const toThrowable = specimen => {
   if (isErrorLike(specimen)) {
     return toPassableError(/** @type {Error} */ (specimen));
   }
-  // Note that this step will fail if `specimen` would be a passable container
-  // except that it contains non-passable errors that could be converted.
-  // This will need to be fixed to do the TODO above.
-  const passStyle = passStyleOf(specimen);
-  if (isObject(specimen)) {
+  if (!isPrimitive(specimen)) {
+    // Note that this step will fail if `specimen` would be a passable container
+    // except that it contains non-passable errors that could be converted.
+    // This will need to be fixed to do the TODO above.
+    const passStyle = /** @type {PassStyle} */ (passStyleOf(specimen));
     switch (passStyle) {
       case 'copyArray': {
         const elements = /** @type {CopyArray} */ (specimen);

packages/pass-style/src/remotable.js

@@ -8,7 +8,7 @@ import {
   PASS_STYLE,
   checkTagRecord,
   checkFunctionTagRecord,
-  isObject,
+  isPrimitive,
   getTag,
   CX,
 } from './passStyle-helpers.js';
@@ -70,7 +70,7 @@ harden(assertIface);
  * @returns {boolean}
  */
 const checkRemotableProtoOf = (original, check) => {
-  isObject(original) ||
+  !isPrimitive(original) ||
     Fail`Remotables must be objects or functions: ${original}`;
 
   // A valid remotable object must inherit from a "tag record" -- a
@@ -181,7 +181,7 @@ const checkRemotable = (val, check) => {
  */
 export const getInterfaceOf = val => {
   if (
-    !isObject(val) ||
+    isPrimitive(val) ||
     val[PASS_STYLE] !== 'remotable' ||
     !checkRemotable(val)
   ) {
@@ -202,7 +202,7 @@ export const RemotableHelper = harden({
 
   canBeValid: (candidate, check = undefined) => {
     const validType =
-      (isObject(candidate) ||
+      (!isPrimitive(candidate) ||
         (!!check &&
           CX(check)`cannot serialize non-objects as Remotable ${candidate}`)) &&
       (!isArray(candidate) ||

packages/pass-style/src/types.d.ts

@@ -25,11 +25,24 @@ export type AtomStyle =
   | 'byteArray'
   | 'symbol';
 
+/**
+ * The actual JS primitive types.
+ */
+export type JSPrimitive =
+  | undefined
+  | null
+  | boolean
+  | number
+  | bigint
+  | string
+  | symbol;
+
 /**
  * @deprecated Use `Atom` instead, which is also the ocapn name. Now that
  * ByteArray has been added, this category no longer corresponds to
  * JS primitives, We also expect to move  to a passable-symbol representation
- * as a JS object, not a JS primitive
+ * as a JS object, not a JS primitive. But if you really do mean a JS primitive
+ * only, use `JSPrimitive` instead.
  */
 export type Primitive = Atom;
 

packages/promise-kit/src/memo-race.js

@@ -28,7 +28,21 @@ OTHER DEALINGS IN THE SOFTWARE.
 For more information, please refer to <http://unlicense.org/>
 */
 
-const isObject = value => Object(value) === value;
+/**
+ * TODO Consolidate with `isPrimitive` that's currently in `@endo/pass-style`.
+ * Layering constraints make this tricky, which is why we haven't yet figured
+ * out how to do this.
+ *
+ * @type {(val: unknown) => val is (undefined
+ * | null
+ * | boolean
+ * | number
+ * | bigint
+ * | string
+ * | symbol)}
+ */
+const isPrimitive = val =>
+  !val || (typeof val !== 'object' && typeof val !== 'function');
 
 /**
  * @template [T=any]
@@ -73,7 +87,7 @@ const markSettled = record => {
  * @returns {PromiseMemoRecord}
  */
 const getMemoRecord = value => {
-  if (!isObject(value)) {
+  if (isPrimitive(value)) {
     // If the contender is a primitive, attempting to use it as a key in the
     // weakmap would throw an error. Luckily, it is safe to call
     // `Promise.resolve(contender).then` on a primitive value multiple times

packages/ses/src/commons.js

@@ -272,23 +272,20 @@ export const getConstructorOf = fn =>
   reflectGet(getPrototypeOf(fn), 'constructor');
 
 /**
- * isObject tests whether a value is an object.
- * Today, this is equivalent to:
+ * TODO Consolidate with `isPrimitive` that's currently in `@endo/pass-style`.
+ * Layering constraints make this tricky, which is why we haven't yet figured
+ * out how to do this.
  *
- *   const isObject = value => {
- *     if (value === null) return false;
- *     const type = typeof value;
- *     return type === 'object' || type === 'function';
- *   };
- *
- * But this is not safe in the face of possible evolution of the language, for
- * example new types or semantics of records and tuples.
- * We use this implementation despite the unnecessary allocation implied by
- * attempting to box a primitive.
- *
- * @param {any} value
+ * @type {(val: unknown) => val is (undefined
+ * | null
+ * | boolean
+ * | number
+ * | bigint
+ * | string
+ * | symbol)}
  */
-export const isObject = value => Object(value) === value;
+export const isPrimitive = val =>
+  !val || (typeof val !== 'object' && typeof val !== 'function');
 
 /**
  * isError tests whether an object inherits from the intrinsic