@agoric/internal 0.4.0 → 0.4.1-upgrade-23-dev-bd79330.0.bd79330

package/src/lib-nodejs/ava-unhandled-rejection.js

@@ -1,54 +1,186 @@
 // @ts-check
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 
 import engineGC from './engine-gc.js';
 import { makeGcAndFinalize } from './gc-and-finalize.js';
 
 /**
- * @import {ExecutionContext, Macro, TestFn} from 'ava';
+ * @import {ExecutionContext, ImplementationFn, Macro, MacroDeclarationOptions,TestFn} from 'ava';
  */
 
-export const AVA_EXPECT_UNHANDLED_REJECTIONS =
+/** Not an official AVA feature, so prefix with `AGORIC_` */
+export const AGORIC_AVA_EXPECT_UNHANDLED_REJECTIONS =
   'AGORIC_AVA_EXPECT_UNHANDLED_REJECTIONS';
+/** Backwards compatibility... */
+export const AVA_EXPECT_UNHANDLED_REJECTIONS =
+  AGORIC_AVA_EXPECT_UNHANDLED_REJECTIONS;
+
+const delayTurn = () => new Promise(resolve => setImmediate(resolve));
+const settleUnhandled = async () => {
+  await delayTurn();
+  await delayTurn();
+};
+
+const stripListeners = event => {
+  const listeners = process.listeners(event);
+  for (const listener of listeners) {
+    process.off(event, listener);
+  }
+  return () => {
+    for (const listener of listeners) {
+      process.on(event, listener);
+    }
+  };
+};
+
+const makeUnhandledTracker = () => {
+  let unhandled = 0;
+  let seenUnhandled = 0;
+  const pending = new Set();
+  const handledLate = new Set();
+  const tokenByPromise = new WeakMap();
+  // Finalization callbacks run on the main thread; `pending` is only mutated
+  // here and after the flushes in countUnhandled, so no extra synchronization
+  // is required.
+  const registry = new FinalizationRegistry(token => {
+    if (pending.delete(token)) {
+      // Don't count promises that were handled late.
+      if (!handledLate.delete(token)) {
+        unhandled += 1;
+      }
+    }
+  });
 
-export const SUBTEST_PREFIX = '(unhandled rejection subprocess): ';
+  const onUnhandled = (_reason, promise) => {
+    seenUnhandled += 1;
+    const token = Symbol('unhandledRejection');
+    tokenByPromise.set(promise, token);
+    pending.add(token);
+    registry.register(promise, token, token);
+  };
+
+  const onHandledLate = promise => {
+    const token = tokenByPromise.get(promise);
+    tokenByPromise.delete(promise);
+    // Mark this token as handled late so it won't be counted when the
+    // finalizer runs. We remove it from `pending` to exclude it from
+    // the pending count, and track it in `handledLate` to avoid counting
+    // it when GC'd.
+    if (token && pending.delete(token)) {
+      handledLate.add(token);
+    }
+  };
+
+  const snapshot = () => ({ unhandled, pending: pending.size, seenUnhandled });
+
+  return {
+    onUnhandled,
+    onHandledLate,
+    snapshot,
+  };
+};
 
 /**
+ * Count unhandled rejections for the given work by running it after removing
+ * any existing listeners (like AVA's) and waiting for GC/finalization.
+ *
+ * @param {() => any | Promise<any>} work
+ * @param {object} powers
+ * @param {() => Promise<void>} powers.gcAndFinalize
+ */
+export const countUnhandled = async (work, { gcAndFinalize }) => {
+  await null; // for Jessie
+  const tracker = makeUnhandledTracker();
+  const restoreUnhandled = stripListeners('unhandledRejection');
+  const restoreHandled = stripListeners('rejectionHandled');
+  const flushUnhandled = async () => {
+    await settleUnhandled();
+    await gcAndFinalize();
+  };
+  process.on('unhandledRejection', tracker.onUnhandled);
+  process.on('rejectionHandled', tracker.onHandledLate);
+  try {
+    await work();
+  } finally {
+    // Two passes through settle+GC help ensure finalizers run before we snapshot
+    // the unhandled state across Node/XS runtimes, even when callbacks queue
+    // additional macrotasks. This count happens after the flushes so finalizer
+    // timing cannot race the snapshot.
+    await flushUnhandled();
+    await flushUnhandled();
+    await settleUnhandled();
+    process.off('unhandledRejection', tracker.onUnhandled);
+    process.off('rejectionHandled', tracker.onHandledLate);
+    restoreUnhandled();
+    restoreHandled();
+  }
+  return tracker.snapshot();
+};
+
+/**
+ * @deprecated Use `makeExpectUnhandledRejectionMacro` instead, which uses the
+ * test's first argument title instead of an explicit `name`, and can
+ * optionally wrap an inner `Macro`.
+ *
  * @template C
  * @param {object} powers
  * @param {TestFn<C>} powers.test
+ * @param {boolean} [powers.sameWorker]
  * @param {string} powers.importMetaUrl
- * @returns {(
- *   expectedUnhandled: number,
- * ) => Macro<[name: string, impl: (t: ExecutionContext<C>) => any], C>}
+ * @returns {( expectedUnhandled: number) => Macro<[name: string, impl: (t:
+ *   ExecutionContext<C>) => any], C>}
  */
-export const makeExpectUnhandledRejection = ({ test, importMetaUrl }) => {
+export const makeExpectUnhandledRejection = ({
+  test,
+  sameWorker = false,
+  importMetaUrl,
+}) => {
   const self = fileURLToPath(importMetaUrl);
   const gcAndFinalize = makeGcAndFinalize(engineGC);
 
-  if (process.env[AVA_EXPECT_UNHANDLED_REJECTIONS]) {
-    return _expectedUnhandled =>
+  if (sameWorker || process.env[AVA_EXPECT_UNHANDLED_REJECTIONS]) {
+    let mutex = Promise.resolve();
+    return expectedUnhandled =>
       test.macro({
-        title: (_, name, _impl) => SUBTEST_PREFIX + name,
+        title: (_providedTitle = '', name, _impl) => name,
         exec: async (t, _name, impl) => {
-          await null;
-          try {
-            const result = await impl(t);
-            return result;
-          } finally {
-            await gcAndFinalize();
+          const rawExpected =
+            (sameWorker
+              ? undefined
+              : process.env[AVA_EXPECT_UNHANDLED_REJECTIONS]) ||
+            expectedUnhandled;
+          const expected = Number(rawExpected);
+          if (!Number.isSafeInteger(expected) || expected < 0) {
+            t.fail(
+              `expected unhandled rejection count to be a natural number, got ${rawExpected}`,
+            );
           }
+          const nextP = mutex.then(async () => {
+            const { unhandled, pending, seenUnhandled } = await countUnhandled(
+              () => impl(t),
+              { gcAndFinalize },
+            );
+            const totalUnhandled = unhandled + pending;
+            if (totalUnhandled !== expected) {
+              t.fail(
+                `expected ${expected} unhandled promise rejections, got ${totalUnhandled} (of ${seenUnhandled} seen, ${pending} pending finalization)`,
+              );
+            }
+          });
+          mutex = nextP.catch(() => {}); // don't let a failure block the next test
+          await nextP;
         },
       });
   }
 
   return expectedUnhandled =>
     test.macro({
-      title: (_, name, _impl) => name,
+      title: (_providedTitle = '', name, _impl) =>
+        `${name} (unhandled: ${expectedUnhandled})`,
       exec: async (t, name, _impl) =>
         new Promise((resolve, reject) => {
-          const ps = spawn('ava', [self, '-m', SUBTEST_PREFIX + name], {
+          const ps = spawn('ava', [self, '--match', name], {
             env: {
               ...process.env,
               [AVA_EXPECT_UNHANDLED_REJECTIONS]: `${expectedUnhandled}`,
@@ -64,3 +196,62 @@ export const makeExpectUnhandledRejection = ({ test, importMetaUrl }) => {
         }),
     });
 };
+
+/**
+ * @template [C=unknown]
+ * @param {object} powers
+ * @param {TestFn<C>} powers.test
+ * @param {boolean} [powers.sameWorker] defaults to require in-process execution
+ * @param {string} powers.importMetaUrl
+ */
+export const makeExpectUnhandledRejectionMacro = ({
+  test,
+  sameWorker = true,
+  importMetaUrl,
+}) => {
+  const expectUnhandledRejection = makeExpectUnhandledRejection({
+    test,
+    sameWorker,
+    importMetaUrl,
+  });
+  /**
+   * @template {any[]} [A=[ImplementationFn<any[], any>, ...any[]]]
+   * @param {number} numUnhandled
+   * @param {Macro<A, C>} [innerMacro]
+   * @returns {Macro<A, C>}
+   */
+  return (numUnhandled, innerMacro) => {
+    const expector = expectUnhandledRejection(numUnhandled);
+
+    /**
+     * @param {ExecutionContext<C>} _t
+     * @param {A} args
+     * @returns {(t: ExecutionContext<C>) => any}
+     */
+    const makeImpl = (_t, args) =>
+      innerMacro
+        ? async t => innerMacro.exec(t, ...args)
+        : t => (0, args[0])(t, ...args);
+
+    /** @type {string} */
+    return test.macro(
+      /** @type {MacroDeclarationOptions<A, C>} */ ({
+        title(providedTitle = '', ...args) {
+          let expectorName =
+            innerMacro?.title?.(providedTitle, ...args) ?? providedTitle;
+          const impl = () => {};
+          if (process.env[AVA_EXPECT_UNHANDLED_REJECTIONS]) {
+            expectorName =
+              expector.title?.(expectorName, expectorName, impl) ??
+              expectorName;
+          }
+          return expectorName;
+        },
+        async exec(t, ...args) {
+          const impl = makeImpl(t, args);
+          return expector.exec(t, t.title, impl);
+        },
+      }),
+    );
+  };
+};

package/src/lib-nodejs/engine-gc.js

@@ -1,5 +1,5 @@
-import v8 from 'v8';
-import vm from 'vm';
+import v8 from 'node:v8';
+import vm from 'node:vm';
 
 /* global globalThis */
 let bestGC = globalThis.gc;

package/src/lib-nodejs/spawnSubprocessWorker.d.ts

@@ -10,6 +10,4 @@ export function startSubprocessWorker(execPath: any, procArgs?: any[], { netstri
     terminate: () => void;
     done: Promise<any>;
 };
-export type IOType = import("child_process").IOType;
-export type Writable = import("stream").Writable;
 //# sourceMappingURL=spawnSubprocessWorker.d.ts.map

package/src/lib-nodejs/spawnSubprocessWorker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawnSubprocessWorker.d.ts","sourceRoot":"","sources":["spawnSubprocessWorker.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;EA0DC;qBApEa,OAAO,eAAe,EAAE,MAAM;uBAC9B,OAAO,QAAQ,EAAE,QAAQ"}
+{"version":3,"file":"spawnSubprocessWorker.d.ts","sourceRoot":"","sources":["spawnSubprocessWorker.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;EA0DC"}

package/src/lib-nodejs/spawnSubprocessWorker.js

@@ -1,5 +1,5 @@
 // this file is loaded by the controller, in the start compartment
-import { spawn } from 'child_process';
+import { spawn } from 'node:child_process';
 import { makePromiseKit } from '@endo/promise-kit';
 import { NonNullish } from '../errors.js';
 import { arrayEncoderStream, arrayDecoderStream } from './worker-protocol.js';
@@ -8,19 +8,20 @@ import {
   netstringDecoderStream,
 } from '../netstring.js';
 
+/**
+ * @import {IOType} from 'child_process'
+ * @import {Writable} from 'stream'
+ */
+
 // Start a subprocess from a given executable, and arrange a bidirectional
 // message channel with a "supervisor" within that process. Return a {
 // toChild, fromChild } pair of Streams which accept/emit hardened Arrays of
 // JSON-serializable data.
 
-// eslint-disable-next-line no-unused-vars
-function parentLog(first, ...args) {
-  // console.error(`--parent: ${first}`, ...args);
+function parentLog(_first, ..._args) {
+  // console.error(`--parent: ${_first}`, ..._args);
 }
 
-/** @typedef {import('child_process').IOType} IOType */
-/** @typedef {import('stream').Writable} Writable */
-
 // we send on fd3, and receive on fd4. We pass fd1/2 (stdout/err) through, so
 // console log/err from the child shows up normally. We don't use Node's
 // built-in serialization feature ('ipc') because the child process won't

package/src/lib-nodejs/waitUntilQuiescent.d.ts

@@ -1,2 +1,5 @@
+/**
+ * @import {PromiseKit} from '@endo/promise-kit';
+ */
 export function waitUntilQuiescent(): Promise<void>;
 //# sourceMappingURL=waitUntilQuiescent.d.ts.map

package/src/lib-nodejs/waitUntilQuiescent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"waitUntilQuiescent.d.ts","sourceRoot":"","sources":["waitUntilQuiescent.js"],"names":[],"mappings":"AAMA,oDAWC"}
+{"version":3,"file":"waitUntilQuiescent.d.ts","sourceRoot":"","sources":["waitUntilQuiescent.js"],"names":[],"mappings":"AAGA;;GAEG;AAKH,oDAWC"}

package/src/lib-nodejs/waitUntilQuiescent.js

@@ -1,6 +1,10 @@
 /* global setImmediate */
 import { makePromiseKit } from '@endo/promise-kit';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit';
+ */
+
 // This can only be imported from the Start Compartment, where 'setImmediate'
 // is available.
 
@@ -11,7 +15,7 @@ export function waitUntilQuiescent() {
   // lower-priority than the Promise queue on browsers and Node 11, but on
   // Node 10 it is higher. So this trick requires Node 11.
   // https://jsblog.insiderattack.net/new-changes-to-timers-and-microtasks-from-node-v11-0-0-and-above-68d112743eb3
-  /** @type {import('@endo/promise-kit').PromiseKit<void>} */
+  /** @type {PromiseKit<void>} */
   const { promise: queueEmptyP, resolve } = makePromiseKit();
   setImmediate(() => resolve());
   return queueEmptyP;

package/src/lib-nodejs/worker-protocol.d.ts

@@ -1,4 +1,4 @@
 export function arrayEncoderStream(): Transform;
 export function arrayDecoderStream(): Transform;
-import { Transform } from 'stream';
+import { Transform } from 'node:stream';
 //# sourceMappingURL=worker-protocol.d.ts.map

package/src/lib-nodejs/worker-protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker-protocol.d.ts","sourceRoot":"","sources":["worker-protocol.js"],"names":[],"mappings":"AAMA,gDAqBC;AAED,gDAwBC;0BApDyB,QAAQ"}
+{"version":3,"file":"worker-protocol.d.ts","sourceRoot":"","sources":["worker-protocol.js"],"names":[],"mappings":"AAMA,gDAqBC;AAED,gDAwBC;0BApDyB,aAAa"}

package/src/lib-nodejs/worker-protocol.js

@@ -1,5 +1,5 @@
 /* eslint-env node */
-import { Transform } from 'stream';
+import { Transform } from 'node:stream';
 
 // Transform objects which convert from hardened Arrays of JSON-serializable
 // data into Buffers suitable for netstring conversion.
@@ -7,11 +7,11 @@ import { Transform } from 'stream';
 export function arrayEncoderStream() {
   /**
    * @param {any} object
-   * @param {BufferEncoding} encoding
+   * @param {BufferEncoding} _encoding
    * @param {any} callback
    * @this {{ push: (b: Buffer) => void }}
    */
-  function transform(object, encoding, callback) {
+  function transform(object, _encoding, callback) {
     if (!Array.isArray(object)) {
       throw Error('stream requires Arrays');
     }
@@ -30,11 +30,11 @@ export function arrayEncoderStream() {
 export function arrayDecoderStream() {
   /**
    * @param {Buffer} buf
-   * @param {BufferEncoding} encoding
+   * @param {BufferEncoding} _encoding
    * @param {any} callback
    * @this {{ push: (b: Buffer) => void }}
    */
-  function transform(buf, encoding, callback) {
+  function transform(buf, _encoding, callback) {
     let err;
     try {
       if (!Buffer.isBuffer(buf)) {

package/src/magic-cookie-test-only.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"magic-cookie-test-only.d.ts","sourceRoot":"","sources":["magic-cookie-test-only.js"],"names":[],"mappings":"AAQO,0CAEN"}
+{"version":3,"file":"magic-cookie-test-only.d.ts","sourceRoot":"","sources":["magic-cookie-test-only.js"],"names":[],"mappings":"AAMO,0CAEN"}

package/src/magic-cookie-test-only.js

@@ -1,5 +1,3 @@
-// @jessie-check
-
 const cookie = harden({});
 
 /**

package/src/marshal/board-client-utils.d.ts

@@ -0,0 +1,19 @@
+export function makeBoardRemote<BoardId = string | null>({ boardId, iface }: {
+    boardId: BoardId;
+    iface?: string;
+}): BoardRemote<BoardId>;
+export function slotToBoardRemote<BoardId = string>(boardId: BoardId, iface: string): BoardRemote<BoardId>;
+export function boardSlottingMarshaller<BoardId = string | null>(slotToVal?: (slot: BoardId, iface: string) => any): Omit<Marshal<BoardId>, "serialize" | "unserialize">;
+export function unmarshalFromVstorage(data: Map<string, string>, key: string, fromCapData: FromCapData<string>, index: number): any;
+export function makeHistoryReviver(entries: [string, string][], slotToVal?: (slot: string, iface?: string) => any): {
+    getItem: (key: string) => any;
+    children: (prefix: string) => string[];
+    has: (k: string) => boolean;
+};
+export type BoardRemote<BoardId = string | null> = {
+    getBoardId: () => BoardId;
+} & RemotableObject;
+import type { Marshal } from '@endo/marshal';
+import type { FromCapData } from '@endo/marshal';
+import type { RemotableObject } from '@endo/pass-style';
+//# sourceMappingURL=board-client-utils.d.ts.map

package/src/marshal/board-client-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"board-client-utils.d.ts","sourceRoot":"","sources":["board-client-utils.js"],"names":[],"mappings":"AAsBO,gCAJO,OAAO,sCACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAClC,WAAW,CAAC,OAAO,CAAC,CAKhC;AAOM,kCAJO,OAAO,oBACV,OAAO,SACP,MAAM,wBAGoB;AAsB9B,wCAJO,OAAO,8BACV,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,GACnC,IAAI,CAAC,QAAQ,OAAO,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,CAU/D;AAYM,4CAPI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,OACnB,MAAM,eACN,YAAY,MAAM,CAAC,SACnB,MAAM,GAEJ,GAAG,CAwBf;AASM,4CAHI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,cAClB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,GAAG;mBAQlC,MAAM;uBAEN,MAAM;aAYN,MAAM;EAInB;wBArHa,OAAO,oBACR;IAAE,UAAU,EAAE,MAAM,OAAO,CAAA;CAAE,GAAG,eAAe;6BALM,eAAe;iCAAf,eAAe;qCAD/C,kBAAkB"}

package/src/{marshal.js → marshal/board-client-utils.js}

@@ -2,24 +2,23 @@
 import { Fail } from '@endo/errors';
 import { Far } from '@endo/far';
 import { makeMarshal } from '@endo/marshal';
-import { M } from '@endo/patterns';
-import { isStreamCell } from './lib-chainStorage.js';
+import { isStreamCell } from '../lib-chainStorage.js';
+import { assertCapData } from './cap-data.js';
 
 /**
- * @import {CapData} from '@endo/marshal';
- * @import {TypedPattern} from './types.js';
+ * @import {RemotableObject} from '@endo/pass-style';
+ * @import {CapData, FromCapData, ConvertValToSlot, Marshal} from '@endo/marshal';
  */
 
 /**
- * Should be a union with Remotable, but that's `any`, making this type
- * meaningless
- *
- * @typedef {{ getBoardId: () => string | null }} BoardRemote
+ * @template [BoardId=(string | null)]
+ * @typedef {{ getBoardId: () => BoardId } & RemotableObject} BoardRemote
  */
 
 /**
- * @param {{ boardId: string | null; iface?: string }} slotInfo
- * @returns {BoardRemote}
+ * @template [BoardId=(string | null)]
+ * @param {{ boardId: BoardId; iface?: string }} slotInfo
+ * @returns {BoardRemote<BoardId>}
  */
 export const makeBoardRemote = ({ boardId, iface }) => {
   const nonalleged = iface ? iface.replace(/^Alleged: /, '') : '';
@@ -27,13 +26,17 @@ export const makeBoardRemote = ({ boardId, iface }) => {
 };
 
 /**
- * @param {string} boardId
+ * @template [BoardId=string]
+ * @param {BoardId} boardId
  * @param {string} iface
  */
 export const slotToBoardRemote = (boardId, iface) =>
   makeBoardRemote({ boardId, iface });
 
-/** @param {BoardRemote | object} val */
+/**
+ * @param {BoardRemote<any> | object} val
+ * @returns {val extends BoardRemote<infer BoardId> ? BoardId : never}
+ */
 const boardValToSlot = val => {
   if ('getBoardId' in val) {
     return val.getBoardId();
@@ -46,47 +49,26 @@ const boardValToSlot = val => {
  * allows the caller to pick their slots. The deserializer is configurable: the
  * default cannot handle Remotable-bearing data.
  *
- * @param {(slot: string, iface: string) => any} [slotToVal]
- * @returns {Omit<
- *   import('@endo/marshal').Marshal<string | null>,
- *   'serialize' | 'unserialize'
- * >}
+ * @template [BoardId=(string | null)]
+ * @param {(slot: BoardId, iface: string) => any} [slotToVal]
+ * @returns {Omit<Marshal<BoardId>, 'serialize' | 'unserialize'>}
  */
 export const boardSlottingMarshaller = (slotToVal = undefined) => {
-  return makeMarshal(boardValToSlot, slotToVal, {
-    serializeBodyFormat: 'smallcaps',
-  });
-};
-
-// TODO move CapDataShape to Endo
-/**
- * @type {TypedPattern<CapData<any>>}
- */
-export const CapDataShape = { body: M.string(), slots: M.array() };
-harden(CapDataShape);
-
-/**
- * Assert that this is CapData
- *
- * @param {unknown} data
- * @returns {asserts data is CapData<unknown>}
- */
-export const assertCapData = data => {
-  assert.typeof(data, 'object');
-  assert(data);
-  typeof data.body === 'string' || Fail`data has non-string .body ${data.body}`;
-  Array.isArray(data.slots) || Fail`data has non-Array slots ${data.slots}`;
+  return makeMarshal(
+    /** @type {ConvertValToSlot<BoardId>} */ (boardValToSlot),
+    slotToVal,
+    {
+      serializeBodyFormat: 'smallcaps',
+    },
+  );
 };
-harden(assertCapData);
 
 /**
  * Read and unmarshal a value from a map representation of vstorage data
  *
  * @param {Map<string, string>} data
  * @param {string} key
- * @param {ReturnType<
- *   typeof import('@endo/marshal').makeMarshal
- * >['fromCapData']} fromCapData
+ * @param {FromCapData<string>} fromCapData
  * @param {number} index index of the desired value in a deserialized stream
  *   cell
  * @returns {any}
@@ -107,7 +89,7 @@ export const unmarshalFromVstorage = (data, key, fromCapData, index) => {
   const marshalled = values.at(index);
   assert.typeof(marshalled, 'string');
 
-  /** @type {import('@endo/marshal').CapData<string>} */
+  /** @type {CapData<string>} */
   const capData = harden(JSON.parse(marshalled));
   assertCapData(capData);
 
@@ -147,10 +129,3 @@ export const makeHistoryReviver = (entries, slotToVal = undefined) => {
 
   return harden({ getItem, children, has });
 };
-
-/** @param {import('@endo/marshal').CapData<unknown>} cap */
-const rejectOCap = cap => Fail`${cap} is not pure data`;
-export const pureDataMarshaller = makeMarshal(rejectOCap, rejectOCap, {
-  serializeBodyFormat: 'smallcaps',
-});
-harden(pureDataMarshaller);

package/src/marshal/cap-data.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @import {CapData} from '@endo/marshal';
+ */
+/**
+ * Assert that this is CapData
+ *
+ * @type {(data: unknown) => asserts data is CapData<unknown>}
+ */
+export const assertCapData: (data: unknown) => asserts data is CapData<unknown>;
+import type { CapData } from '@endo/marshal';
+//# sourceMappingURL=cap-data.d.ts.map

package/src/marshal/cap-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cap-data.d.ts","sourceRoot":"","sources":["cap-data.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;GAIG;AACH,4BAFU,CAAC,IAAI,EAAE,OAAO,KAAK,QAAQ,IAAI,IAAI,QAAQ,OAAO,CAAC,CAO3D;6BAbwB,eAAe"}

package/src/marshal/cap-data.js

@@ -0,0 +1,19 @@
+// @ts-check
+import { Fail } from '@endo/errors';
+
+/**
+ * @import {CapData} from '@endo/marshal';
+ */
+
+/**
+ * Assert that this is CapData
+ *
+ * @type {(data: unknown) => asserts data is CapData<unknown>}
+ */
+export const assertCapData = data => {
+  assert.typeof(data, 'object');
+  assert(data);
+  typeof data.body === 'string' || Fail`data has non-string .body ${data.body}`;
+  Array.isArray(data.slots) || Fail`data has non-Array slots ${data.slots}`;
+};
+harden(assertCapData);

package/src/marshal/inaccessible-val.d.ts

@@ -0,0 +1,2 @@
+export function makeInaccessibleVal(iface: string | undefined): any;
+//# sourceMappingURL=inaccessible-val.d.ts.map

package/src/marshal/inaccessible-val.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inaccessible-val.d.ts","sourceRoot":"","sources":["inaccessible-val.js"],"names":[],"mappings":"AASO,2CAHI,MAAM,GAAG,SAAS,GAChB,GAAG,CAOf"}

package/src/marshal/inaccessible-val.js

@@ -0,0 +1,15 @@
+// @ts-check
+import { Far } from '@endo/far';
+
+const ifaceAllegedPrefix = 'Alleged: ';
+const ifaceInaccessiblePrefix = 'SEVERED: ';
+/**
+ * @param {string | undefined} iface
+ * @returns {any}
+ */
+export const makeInaccessibleVal = iface => {
+  if (typeof iface === 'string' && iface.startsWith(ifaceAllegedPrefix)) {
+    iface = iface.slice(ifaceAllegedPrefix.length);
+  }
+  return Far(`${ifaceInaccessiblePrefix}${iface}`, {});
+};

package/src/marshal/pure-data.d.ts

@@ -0,0 +1,8 @@
+export const pureDataMarshaller: {
+    toCapData: import("@endo/marshal").ToCapData<CapData<unknown>>;
+    fromCapData: import("@endo/marshal").FromCapData<CapData<unknown>>;
+    serialize: import("@endo/marshal").ToCapData<CapData<unknown>>;
+    unserialize: import("@endo/marshal").FromCapData<CapData<unknown>>;
+};
+import type { CapData } from '@endo/marshal';
+//# sourceMappingURL=pure-data.d.ts.map

package/src/marshal/pure-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-data.d.ts","sourceRoot":"","sources":["pure-data.js"],"names":[],"mappings":"AAUA;;;;;EAEG;6BAPuB,eAAe"}

package/src/marshal/pure-data.js

@@ -0,0 +1,14 @@
+// @ts-check
+import { Fail } from '@endo/errors';
+import { makeMarshal } from '@endo/marshal';
+
+/**
+ * @import {CapData} from '@endo/marshal';
+ */
+
+/** @param {CapData<unknown>} cap */
+const rejectOCap = cap => Fail`${cap} is not pure data`;
+export const pureDataMarshaller = makeMarshal(rejectOCap, rejectOCap, {
+  serializeBodyFormat: 'smallcaps',
+});
+harden(pureDataMarshaller);