@agoric/internal 0.3.3-u11.0 → 0.3.3-upgrade-16-dev-8879538.0

package/src/netstring.js

@@ -0,0 +1,127 @@
+/* global Buffer */
+import { Fail } from '@agoric/assert';
+
+// adapted from 'netstring-stream', https://github.com/tlivings/netstring-stream/
+import { Transform } from 'stream';
+
+const COLON = 58;
+const COMMA = 44;
+
+/**
+ * @param {Buffer} data
+ * @returns {Buffer} netstring-wrapped
+ */
+export function encode(data) {
+  const prefix = Buffer.from(`${data.length}:`);
+  const suffix = Buffer.from(',');
+  return Buffer.concat([prefix, data, suffix]);
+}
+
+// input is a sequence of strings, output is a byte pipe
+export function netstringEncoderStream() {
+  /**
+   *
+   * @this {{ push: (b: Buffer) => void }}
+   * @param {Buffer} chunk
+   * @param {BufferEncoding} encoding
+   * @param {*} callback
+   */
+  function transform(chunk, encoding, callback) {
+    if (!Buffer.isBuffer(chunk)) {
+      throw Error('stream requires Buffers');
+    }
+    let err;
+    try {
+      this.push(encode(chunk));
+    } catch (e) {
+      err = e;
+    }
+    callback(err);
+  }
+  // (maybe empty) Buffer in, Buffer out. We use writableObjectMode to
+  // indicate that empty input buffers are important
+  return new Transform({ transform, writableObjectMode: true });
+}
+
+/**
+ *
+ * @param {Buffer} data containing zero or more netstrings and maybe some
+ * leftover bytes
+ * @param {number} [optMaxChunkSize]
+ * @returns {{ leftover: Buffer, payloads: Buffer[] }} zero or more decoded Buffers, one per netstring,
+ */
+export function decode(data, optMaxChunkSize) {
+  // TODO: it would be more efficient to accumulate pending data in an array,
+  // rather than doing a concat each time
+  let start = 0;
+  const payloads = [];
+
+  for (;;) {
+    const colon = data.indexOf(COLON, start);
+    if (colon === -1) {
+      break; // still waiting for `${LENGTH}:`
+    }
+    const sizeString = data.toString('utf-8', start, colon);
+    const size = parseInt(sizeString, 10);
+    if (!(size > -1)) {
+      // reject NaN, all negative numbers
+      Fail`unparsable size ${sizeString}, should be integer`;
+    }
+    if (optMaxChunkSize) {
+      size <= optMaxChunkSize ||
+        Fail`size ${size} exceeds limit of ${optMaxChunkSize}`;
+    }
+    if (data.length < colon + 1 + size + 1) {
+      break; // still waiting for `${DATA}.`
+    }
+    data[colon + 1 + size] === COMMA ||
+      Fail`malformed netstring: not terminated by comma`;
+    payloads.push(data.subarray(colon + 1, colon + 1 + size));
+    start = colon + 1 + size + 1;
+  }
+
+  const leftover = data.subarray(start);
+  return { leftover, payloads };
+}
+
+/**
+ *
+ * @param {number} [optMaxChunkSize ]
+ * @returns {Transform}
+ */
+// input is a byte pipe, output is a sequence of Buffers
+export function netstringDecoderStream(optMaxChunkSize) {
+  let buffered = Buffer.from('');
+  /**
+   *
+   * @this {{ push: (b: Buffer) => void }}
+   * @param {Buffer} chunk
+   * @param {BufferEncoding} encoding
+   * @param {*} callback
+   */
+  function transform(chunk, encoding, callback) {
+    if (!Buffer.isBuffer(chunk)) {
+      throw Error('stream requires Buffers');
+    }
+    buffered = Buffer.concat([buffered, chunk]);
+    let err;
+    try {
+      const { leftover, payloads } = decode(buffered, optMaxChunkSize);
+      buffered = leftover;
+      for (let i = 0; i < payloads.length; i += 1) {
+        this.push(payloads[i]);
+      }
+    } catch (e) {
+      err = e;
+    }
+    // we buffer all data internally, to accommodate netstrings larger than
+    // Transform's default buffer size, and callback() indicates that we've
+    // consumed the input
+    callback(err);
+  }
+
+  // Buffer in, Buffer out, except that each output Buffer is precious, even
+  // empty ones, and without readableObjectMode the Stream will discard empty
+  // buffers
+  return new Transform({ transform, readableObjectMode: true });
+}

package/src/node/buffer-line-transform.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 /**
  * @typedef {object} BufferLineTransformOptions
  * @property {Buffer | string | number} [break] line break matcher for Buffer.indexOf() (default: 10)
@@ -23,7 +22,7 @@ export default class BufferLineTransform extends Transform {
      * @param {BufferEncoding | 'buffer'} encoding
      * @param {import('node:stream').TransformCallback} cb
      */
-    override _transform(chunk: any, encoding: BufferEncoding | 'buffer', cb: import('node:stream').TransformCallback): void;
+    override _transform(chunk: any, encoding: BufferEncoding | "buffer", cb: import("node:stream").TransformCallback): void;
     /** @param {Buffer} line */
     _writeItem(line: Buffer): void;
 }
@@ -37,5 +36,5 @@ export type BufferLineTransformOptions = {
      */
     breakEncoding?: BufferEncoding | undefined;
 };
-import { Transform } from "stream";
+import { Transform } from 'node:stream';
 //# sourceMappingURL=buffer-line-transform.d.ts.map

package/src/node/buffer-line-transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-line-transform.d.ts","sourceRoot":"","sources":["buffer-line-transform.js"],"names":[],"mappings":";AAKA;;;;GAIG;AAEH;IACE;;;;;OAKG;IACH,oGAuBC;IAhBC,sCAAmC;IACnC,2CAAmC;IAWnC,qBAA+B;IAE/B,4BAA4B;IAC5B,SADW,MAAM,MAAM,CAAC,CACP;IAGnB;;;;;OAKG;IACH,2BAJW,GAAG,YACH,cAAc,GAAG,QAAQ,MACzB,OAAO,aAAa,EAAE,iBAAiB,QAgDjD;IAeD,2BAA2B;IAC3B,iBADY,MAAM,QAOjB;CACF"}
+{"version":3,"file":"buffer-line-transform.d.ts","sourceRoot":"","sources":["buffer-line-transform.js"],"names":[],"mappings":"AAKA;;;;GAIG;AAEH;IACE;;;;;OAKG;IACH,oGAuBC;IAhBC,sCAAmC;IACnC,2CAAmC;IAWnC,qBAA+B;IAE/B,4BAA4B;IAC5B,SADW,KAAK,CAAC,MAAM,CAAC,CACP;IAGnB;;;;;OAKG;IACH,2BAJW,GAAG,YACH,cAAc,GAAG,QAAQ,MACzB,OAAO,aAAa,EAAE,iBAAiB,QAgDjD;IAeD,2BAA2B;IAC3B,iBADY,MAAM,QAOjB;CACF;;;;;;;;;;;0BAnHyB,aAAa"}

package/src/node/createBundles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createBundles.d.ts","sourceRoot":"","sources":["createBundles.js"],"names":[],"mappings":"AAUO,6EAyBN;AAEM,mFAMN;AAEM,iGAkCN"}
+{"version":3,"file":"createBundles.d.ts","sourceRoot":"","sources":["createBundles.js"],"names":[],"mappings":"AAWO,6EA+BN;AAEM,mFAMN;AAEM,iGAkCN"}

package/src/node/createBundles.js

@@ -1,3 +1,4 @@
+/* global process */
 // Use modules not prefixed with `node:` since some deploy scripts may
 // still be running in esm emulation
 import path from 'path';
@@ -22,14 +23,20 @@ export const createBundlesFromAbsolute = async sourceBundles => {
     }
     const bundle = match[1];
 
-    const args = cacheToArgs.get(cache) || ['--to', cache];
+    const args = cacheToArgs.get(cache) || ['--cache-js', cache];
     args.push(srcPath, bundle);
     cacheToArgs.set(cache, args);
   }
 
   for (const args of cacheToArgs.values()) {
     console.log(BUNDLE_SOURCE_PROGRAM, ...args);
-    const { status } = spawnSync(prog, args, { stdio: 'inherit' });
+    const env = /** @type {NodeJS.ProcessEnv} */ (
+      /** @type {unknown} */ ({
+        __proto__: process.env,
+        LOCKDOWN_OVERRIDE_TAMING: 'severe',
+      })
+    );
+    const { status } = spawnSync(prog, args, { stdio: 'inherit', env });
     status === 0 ||
       Fail`${q(BUNDLE_SOURCE_PROGRAM)} failed with status ${q(status)}`;
   }

package/src/node/fs-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-stream.d.ts","sourceRoot":"","sources":["fs-stream.js"],"names":[],"mappings":"AAQO,sCAHI,OAAO,IAAI,EAAE,UAAU,GAAG,OAAO,IAAI,EAAE,WAAW,GAChD,QAAQ,IAAI,CAAC,CAgCtB;AAQG,6CADK,MAAM,GAAG,SAAS,GAAG,IAAI;;;;eA2DpC;6BA5Da,YAAY,QAAQ,WAAW,yBAAyB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"fs-stream.d.ts","sourceRoot":"","sources":["fs-stream.js"],"names":[],"mappings":"AAOO,sCAHI,OAAO,IAAI,EAAE,UAAU,GAAG,OAAO,IAAI,EAAE,WAAW,GAChD,OAAO,CAAC,IAAI,CAAC,CAgCtB;AAQG,6CADK,MAAM,GAAG,SAAS,GAAG,IAAI;;;;eA2DpC;6BA5Da,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC"}

package/src/node/fs-stream.js

@@ -1,6 +1,5 @@
 import { createWriteStream } from 'node:fs';
 import { open } from 'node:fs/promises';
-import { makeAggregateError } from '../utils.js';
 
 /**
  * @param {import("fs").ReadStream | import("fs").WriteStream} stream
@@ -78,7 +77,7 @@ export const makeFsStreamWriter = async filePath => {
         Promise.reject(
           written.then(
             () => err,
-            writtenError => makeAggregateError([err, writtenError]),
+            writtenError => AggregateError([err, writtenError]),
           ),
         ),
     );

package/src/priority-senders.d.ts

@@ -13,7 +13,7 @@ export function makePrioritySendersManager(sendersNode: ERef<import("./lib-chain
      * @returns {Promise<void>}
      */
     remove: (rawNamespace: string, address: string) => Promise<void>;
-} & import("@endo/eventual-send").RemotableBrand<{}, {
+} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     /**
      * @param {string} rawNamespace
      * @param {string} address

package/src/priority-senders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"priority-senders.d.ts","sourceRoot":"","sources":["priority-senders.js"],"names":[],"mappings":"AAMA,4CAA4C;AAC5C,mDADuB,MAAM,KAAK,MAAM,CAMtC;AAQK;IAoCH;;;;OAIG;wBAHQ,MAAM,WACN,MAAM,KACJ,QAAQ,IAAI,CAAC;IAe1B;;;;OAIG;2BAHQ,MAAM,WACN,MAAM,KACJ,QAAQ,IAAI,CAAC;;IArB1B;;;;OAIG;wBAHQ,MAAM,WACN,MAAM,KACJ,QAAQ,IAAI,CAAC;IAe1B;;;;OAIG;2BAHQ,MAAM,WACN,MAAM,KACJ,QAAQ,IAAI,CAAC;GAuB7B;qCAGa,WAAW,iCAAiC,CAAC"}
+{"version":3,"file":"priority-senders.d.ts","sourceRoot":"","sources":["priority-senders.js"],"names":[],"mappings":"AAMA,4CAA4C;AAC5C,uCADW,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAMtC;AAQK,wDAFI,IAAI,CAAC,OAAO,uBAAuB,EAAE,WAAW,CAAC;IAsCxD;;;;OAIG;wBAHQ,MAAM,WACN,MAAM,KACJ,OAAO,CAAC,IAAI,CAAC;IAe1B;;;;OAIG;2BAHQ,MAAM,WACN,MAAM,KACJ,OAAO,CAAC,IAAI,CAAC;;IArB1B;;;;OAIG;wBAHQ,MAAM,WACN,MAAM,KACJ,OAAO,CAAC,IAAI,CAAC;IAe1B;;;;OAIG;2BAHQ,MAAM,WACN,MAAM,KACJ,OAAO,CAAC,IAAI,CAAC;GAuB7B;qCAGa,UAAU,CAAC,OAAO,0BAA0B,CAAC"}

package/src/queue.d.ts

@@ -1,2 +1,2 @@
-export function makeWithQueue(): <T extends any[], R>(inner: (...args: T) => Promise<R>) => (...args: T) => Promise<R>;
+export function makeWithQueue(): <T extends (...args: any[]) => any>(inner: T) => (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
 //# sourceMappingURL=queue.d.ts.map

package/src/queue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["queue.js"],"names":[],"mappings":"AAQO,uHAiDN"}
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["queue.js"],"names":[],"mappings":"AAQO,kCA8BqC,CAAC,mBANnB,GAAG,EAAE,KAAK,GAAG,SAMK,CAAC,AAL/B,eAIC,UAAU,CACmB,CAAC,AADlB,CAAC,KACX,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAkB/C"}

package/src/queue.js

@@ -16,7 +16,7 @@ export const makeWithQueue = () => {
     }
     const [thunk, resolve, reject] = queue[0];
     // Run the thunk in a new turn.
-    Promise.resolve()
+    void Promise.resolve()
       .then(thunk)
       // Resolve or reject our caller with the thunk's value.
       .then(resolve, reject)
@@ -30,14 +30,13 @@ export const makeWithQueue = () => {
   };
 
   /**
-   * @template {any[]} T
-   * @template R
-   * @param {(...args: T) => Promise<R>} inner
+   * @template {(...args: any[]) => any} T
+   * @param {T} inner
    */
   return function withQueue(inner) {
     /**
-     * @param {T} args
-     * @returns {Promise<R>}
+     * @param {Parameters<T>} args
+     * @returns {Promise<Awaited<ReturnType<T>>>}
      */
     return function queueCall(...args) {
       // Curry the arguments into the inner function, and

package/src/scratch.d.ts

@@ -6,7 +6,7 @@ export default function makeScratchPad(): {
     keys: () => Promise<any[]>;
     list: () => Promise<any[]>;
     set: (keyP: any, objP: any) => Promise<any>;
-} & import("@endo/eventual-send").RemotableBrand<{}, {
+} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     delete: (keyP: any) => Promise<void>;
     get: (keyP: any) => Promise<any>;
     lookup: (...path: any[]) => any;

package/src/scratch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scratch.d.ts","sourceRoot":"","sources":["scratch.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgDC;yBACa,WAAW,qBAAqB,CAAC"}
+{"version":3,"file":"scratch.d.ts","sourceRoot":"","sources":["scratch.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgDC;yBACa,UAAU,CAAC,OAAO,cAAc,CAAC"}

package/src/storage-test-utils.d.ts

@@ -1,99 +1,58 @@
-export function slotToRemotable(_slotId: string, iface?: string): import("@endo/eventual-send").RemotableBrand<{}, {}>;
+export function slotToRemotable(_slotId: string, iface?: string): import("@endo/marshal").RemotableObject<string> & import("@endo/eventual-send").RemotableBrand<{}, {}>;
 /**
  * A basic marshaller whose unserializer produces Remotables. It can
  * only serialize plain data, not Remotables.
  */
 export const defaultMarshaller: {
-    toCapData: import("@endo/marshal/src/marshal.js").ToCapData<string>;
-    fromCapData: import("@endo/marshal/src/marshal.js").FromCapData<string>;
-    serialize: import("@endo/marshal/src/marshal.js").ToCapData<string>;
-    unserialize: import("@endo/marshal/src/marshal.js").FromCapData<string>;
+    toCapData: import("@endo/marshal").ToCapData<string>;
+    fromCapData: import("@endo/marshal").FromCapData<string>;
+    serialize: import("@endo/marshal").ToCapData<string>;
+    unserialize: import("@endo/marshal").FromCapData<string>;
 };
-export function slotStringUnserialize(capData: any): any;
-export function makeFakeStorageKit(rootPath: string, rootOptions?: [handleStorageMessage: (message: import("./lib-chainStorage.js").StorageMessage) => any, rootPath: string, rootOptions?: {
-    sequence?: boolean | undefined;
-} | undefined][2]): {
-    rootNode: {
+export const slotStringUnserialize: (capData: any) => any;
+export function makeFakeStorageKit(rootPath: string, rootOptions?: Parameters<typeof makeChainStorageRoot>[2]): {
+    rootNode: import("@endo/exo").Guarded<{
         getPath(): string;
-        getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
+        getStoreKey(): Promise<globalThis.VStorageKey>;
         makeChildNode(name: string, childNodeOptions?: {
-            sequence?: boolean | undefined;
-        } | undefined): import("./lib-chainStorage.js").StorageNode;
-        setValue(value: string): Promise<void>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getPath(): string;
-        getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
-        makeChildNode(name: string, childNodeOptions?: {
-            sequence?: boolean | undefined;
-        } | undefined): import("./lib-chainStorage.js").StorageNode;
+            sequence?: boolean;
+        }): StorageNode;
         setValue(value: string): Promise<void>;
     }>;
     data: Map<string, string>;
-    messages: import("./lib-chainStorage.js").StorageMessage[];
-    toStorage: (message: import('../src/lib-chainStorage.js').StorageMessage) => string | number | any[] | {
+    messages: StorageMessage[];
+    toStorage: (message: StorageMessage) => string | number | any[] | {
         storeName: string;
         storeSubkey: string;
     } | null | undefined;
 };
-export function makeMockChainStorageRoot(): {
-    /**
-     * Defaults to deserializing slot references into plain Remotable
-     * objects having the specified interface name (as from `Far(iface)`),
-     * but can accept a different marshaller for producing Remotables
-     * that e.g. embed the slot string in their iface name.
-     *
-     * @param {string} path
-     * @param {import('./lib-chainStorage.js').Marshaller} marshaller
-     * @returns {unknown}
-     */
-    getBody: (path: string, marshaller?: import('./lib-chainStorage.js').Marshaller) => unknown;
-    keys: () => string[];
-    getPath(): string;
-    getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
-    makeChildNode(name: string, childNodeOptions?: {
-        sequence?: boolean | undefined;
-    } | undefined): import("./lib-chainStorage.js").StorageNode;
-    setValue(value: string): Promise<void>;
-} & import("@endo/eventual-send").RemotableBrand<{}, {
-    /**
-     * Defaults to deserializing slot references into plain Remotable
-     * objects having the specified interface name (as from `Far(iface)`),
-     * but can accept a different marshaller for producing Remotables
-     * that e.g. embed the slot string in their iface name.
-     *
-     * @param {string} path
-     * @param {import('./lib-chainStorage.js').Marshaller} marshaller
-     * @returns {unknown}
-     */
-    getBody: (path: string, marshaller?: import('./lib-chainStorage.js').Marshaller) => unknown;
-    keys: () => string[];
-    getPath(): string;
-    getStoreKey(): Promise<import("./lib-chainStorage.js").VStorageKey>;
-    makeChildNode(name: string, childNodeOptions?: {
-        sequence?: boolean | undefined;
-    } | undefined): import("./lib-chainStorage.js").StorageNode;
-    setValue(value: string): Promise<void>;
-}>;
+export function makeMockChainStorageRoot(): MockChainStorageRoot;
 /**
  * A map corresponding with a total function such that `get(key)`
  * is assumed to always succeed.
  */
-export type TotalMap<K, V> = {
-    [Symbol.iterator]: () => IterableIterator<[K, V]>;
-    [Symbol.toStringTag]: string;
-    entries: () => IterableIterator<[K, V]>;
-    keys: () => IterableIterator<K>;
-    values: () => IterableIterator<V>;
-    has: (key: K) => boolean;
-    size: number;
-    set: (key: K, value: V) => Map<K, V>;
-    clear: () => void;
-    delete: (key: K) => boolean;
-    forEach: (callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any) => void;
-} & {
+export type TotalMap<K, V> = { [k in Exclude<keyof Map<K, V>, "get">]: Map<K, V>[k]; } & {
     get: (key: K) => V;
 };
 export type TotalMapFrom<T> = T extends Map<infer K, infer V> ? TotalMap<K, V> : never;
 export type FakeStorageKit = ReturnType<typeof makeFakeStorageKit>;
-export type MockChainStorageRoot = ReturnType<typeof makeMockChainStorageRoot>;
+export type MockChainStorageRootMethods = {
+    /**
+     * Defaults to deserializing slot references into plain Remotable
+     * objects having the specified interface name (as from `Far(iface)`),
+     * but can accept a different marshaller for producing Remotables
+     * that e.g. embed the slot string in their iface name.
+     */
+    getBody: (path: string, marshaller?: {
+        toCapData: import("@endo/marshal").ToCapData<unknown>;
+        fromCapData: import("@endo/marshal").FromCapData<unknown>;
+        serialize: import("@endo/marshal").ToCapData<unknown>;
+        unserialize: import("@endo/marshal").FromCapData<unknown>;
+    } | undefined, index?: number) => unknown;
+    keys: () => string[];
+};
+export type MockChainStorageRoot = StorageNode & MockChainStorageRootMethods;
+import { makeChainStorageRoot } from './lib-chainStorage.js';
+import type { StorageNode } from './lib-chainStorage.js';
+import type { StorageMessage } from './lib-chainStorage.js';
 //# sourceMappingURL=storage-test-utils.d.ts.map

package/src/storage-test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-test-utils.d.ts","sourceRoot":"","sources":["storage-test-utils.js"],"names":[],"mappings":"AAkCO,yCAHI,MAAM,UACN,MAAM,wDAGC;AAElB;;;GAGG;AACH;;;;;EAEG;AAsBW,+CAAU,GAAG,GAAK,GAAG,CAAA;AAgC5B,6CAHI,MAAM,gBACN;;eAAwC,CAAC,CAAC;;;;;;;;;;;;;;;;;;yBAyBvC,OAAO,4BAA4B,EAAE,cAAc;;;;EAoFhE;AAIM;IAIH;;;;;;;;;OASG;oBAHQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,KACxC,OAAO;;;;;;;;;IARpB;;;;;;;;;OASG;oBAHQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,KACxC,OAAO;;;;;;;;GAWvB;;;;;;;;;;;;;;;;;;eAnNiF,CAAC,KAAK,CAAC;;;6BA0L3E,WAAY,yBAAyB,CAAC;mCA0BtC,WAAW,+BAA+B,CAAC"}
+{"version":3,"file":"storage-test-utils.d.ts","sourceRoot":"","sources":["storage-test-utils.js"],"names":[],"mappings":"AAmCO,yCAHI,MAAM,UACN,MAAM,0GAGC;AAElB;;;GAGG;AACH;;;;;EAEG;AA4CH,8CAtBwB,GAAG,KAAK,GAAG,CAsB8B;AAU1D,6CAHI,MAAM,gBACN,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC;;;;uDA+FtC;YAAE,QAAQ,CAAC,UAAS;SAAC;;;UAUf,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;EAIvC;AAgBM,4CADO,oBAAoB,CAyBjC;;;;;qBAhOiF,CAAC,EAAK,CAAC,IAA5E,GAAE,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,CAA6C,CAAC,AAA5C,EAAiD,CAAC,AAA/C,CAAC,EAAE,KAAK,CAAC,GAAG,GAAG,CAAyB,CAAC,AAAxB,EAA6B,CAAC,AAA3B,CAAC,CAAC,CAAC,CAAC,GAAC,GAAG;IAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;CAAC;yBAI7E,CAAC,IAAD,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK;6BAsLvD,UAAU,CAAE,OAAO,kBAAkB,CAAC;;;;;;;;oBAI/B,MAAM;;;;;2BAAmC,MAAM,KAAK,OAAO;UAKlE,MAAM,MAAM,EAAE;;;qCAnNuB,uBAAuB;iCAIF,uBAAuB;oCAAvB,uBAAuB"}

package/src/storage-test-utils.js

@@ -1,14 +1,15 @@
 // @ts-check
 import { Far } from '@endo/far';
 import { makeMarshal, Remotable } from '@endo/marshal';
+import { unmarshalFromVstorage } from './marshal.js';
 import { makeTracer } from './debug.js';
-import {
-  isStreamCell,
-  makeChainStorageRoot,
-  unmarshalFromVstorage,
-} from './lib-chainStorage.js';
+import { isStreamCell, makeChainStorageRoot } from './lib-chainStorage.js';
 import { bindAllMethods } from './method-tools.js';
 
+/**
+ * @import {Marshaller, StorageEntry, StorageMessage, StorageNode} from './lib-chainStorage.js';
+ */
+
 const { Fail } = assert;
 
 const trace = makeTracer('StorTU', false);
@@ -116,10 +117,10 @@ export const makeFakeStorageKit = (rootPath, rootOptions) => {
     }
     return childEntries;
   };
-  /** @type {import('../src/lib-chainStorage.js').StorageMessage[]} */
+  /** @type {StorageMessage[]} */
   const messages = [];
-  /** @param {import('../src/lib-chainStorage.js').StorageMessage} message */
-  // eslint-disable-next-line consistent-return
+  /** @param {StorageMessage} message */
+
   const toStorage = message => {
     messages.push(message);
     switch (message.method) {
@@ -146,7 +147,7 @@ export const makeFakeStorageKit = (rootPath, rootOptions) => {
       case 'set':
       case 'setWithoutNotify': {
         trace('toStorage set', message);
-        /** @type {import('../src/lib-chainStorage.js').StorageEntry[]} */
+        /** @type {StorageEntry[]} */
         const newEntries = message.args;
         for (const [key, value] of newEntries) {
           if (value != null) {
@@ -159,7 +160,7 @@ export const makeFakeStorageKit = (rootPath, rootOptions) => {
       }
       case 'append': {
         trace('toStorage append', message);
-        /** @type {import('../src/lib-chainStorage.js').StorageEntry[]} */
+        /** @type {StorageEntry[]} */
         const newEntries = message.args;
         for (const [key, value] of newEntries) {
           value != null || Fail`attempt to append with no value`;
@@ -206,6 +207,18 @@ export const makeFakeStorageKit = (rootPath, rootOptions) => {
 harden(makeFakeStorageKit);
 /** @typedef {ReturnType< typeof makeFakeStorageKit>} FakeStorageKit */
 
+/**
+ * @typedef MockChainStorageRootMethods
+ * @property {(path: string, marshaller?: Marshaller, index?: number) => unknown} getBody
+ * Defaults to deserializing slot references into plain Remotable
+ * objects having the specified interface name (as from `Far(iface)`),
+ * but can accept a different marshaller for producing Remotables
+ * that e.g. embed the slot string in their iface name.
+ * @property {() => string[]} keys
+ */
+/** @typedef {StorageNode & MockChainStorageRootMethods} MockChainStorageRoot */
+
+/** @returns {MockChainStorageRoot} */
 export const makeMockChainStorageRoot = () => {
   const { rootNode, data } = makeFakeStorageKit('mockChainStorageRoot');
   return Far('mockChainStorage', {
@@ -217,17 +230,17 @@ export const makeMockChainStorageRoot = () => {
      * that e.g. embed the slot string in their iface name.
      *
      * @param {string} path
-     * @param {import('./lib-chainStorage.js').Marshaller} marshaller
+     * @param {Marshaller} marshaller
+     * @param {number} [index]
      * @returns {unknown}
      */
-    getBody: (path, marshaller = defaultMarshaller) => {
+    getBody: (path, marshaller = defaultMarshaller, index = -1) => {
       data.size || Fail`no data in storage`;
       /** @type {ReturnType<typeof import('@endo/marshal').makeMarshal>['fromCapData']} */
       const fromCapData = (...args) =>
         Reflect.apply(marshaller.fromCapData, marshaller, args);
-      return unmarshalFromVstorage(data, path, fromCapData);
+      return unmarshalFromVstorage(data, path, fromCapData, index);
     },
     keys: () => [...data.keys()],
   });
 };
-/** @typedef {ReturnType<typeof makeMockChainStorageRoot>} MockChainStorageRoot */