@agoric/internal 0.3.3-u11wf.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,101 +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
-     * @param {number} [index]
-     * @returns {unknown}
-     */
-    getBody: (path: string, marshaller?: import('./lib-chainStorage.js').Marshaller, index?: number | undefined) => 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
-     * @param {number} [index]
-     * @returns {unknown}
-     */
-    getBody: (path: string, marshaller?: import('./lib-chainStorage.js').Marshaller, index?: number | undefined) => 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;;;;;;;;;;OAUG;oBAJQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,iCAExC,OAAO;;;;;;;;;IATpB;;;;;;;;;;OAUG;oBAJQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,iCAExC,OAAO;;;;;;;;GAWvB;;;;;;;;;;;;;;;;;;eApNiF,CAAC,KAAK,CAAC;;;6BA0L3E,WAAY,yBAAyB,CAAC;mCA2BtC,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,7 +230,7 @@ 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}
      */
@@ -231,4 +244,3 @@ export const makeMockChainStorageRoot = () => {
     keys: () => [...data.keys()],
   });
 };
-/** @typedef {ReturnType<typeof makeMockChainStorageRoot>} MockChainStorageRoot */

package/src/tagged.d.ts

@@ -0,0 +1,155 @@
+/** @file adapted from https://raw.githubusercontent.com/sindresorhus/type-fest/main/source/opaque.d.ts */
+
+declare const tag: unique symbol;
+
+export type TagContainer<Token> = {
+  readonly [tag]: Token;
+};
+
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{
+  [K in Token]: TagMetadata;
+}>;
+
+/**
+Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
+ 
+A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
+ 
+[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
+ 
+A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
+ 
+A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
+  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
+	- `A` contains at least all the tags `B` has;
+	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
+ 
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
+	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
+ 
+@example
+```
+import type {Tagged} from 'type-fest';
+ 
+type AccountNumber = Tagged<number, 'AccountNumber'>;
+type AccountBalance = Tagged<number, 'AccountBalance'>;
+ 
+function createAccountNumber(): AccountNumber {
+	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
+	return 2 as AccountNumber;
+}
+ 
+function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
+	return 4 as AccountBalance;
+}
+ 
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+ 
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
+// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
+getMoneyForAccount(2);
+ 
+// You can also use tagged values like their underlying, untagged type.
+// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
+// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
+const accountNumber = createAccountNumber() + 2;
+```
+ 
+@example
+```
+import type {Tagged} from 'type-fest';
+ 
+// You can apply multiple tags to a type by using `Tagged` repeatedly.
+type Url = Tagged<string, 'URL'>;
+type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
+ 
+// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
+type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
+```
+ 
+@category Type
+ */
+export type Tagged<
+  Type,
+  TagName extends PropertyKey,
+  TagMetadata = never,
+> = Type & Tag<TagName, TagMetadata>;
+
+/**
+Given a type and a tag name, returns the metadata associated with that tag on that type.
+ 
+In the example below, one could use `Tagged<string, 'JSON'>` to represent "a string that is valid JSON". That type might be useful -- for instance, it communicates that the value can be safely passed to `JSON.parse` without it throwing an exception. However, it doesn't indicate what type of value will be produced on parse (which is sometimes known). `JsonOf<T>` solves this; it represents "a string that is valid JSON and that, if parsed, would produce a value of type T". The type T is held in the metadata associated with the `'JSON'` tag.
+ 
+This article explains more about [how tag metadata works and when it can be useful](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
+ 
+@example
+```
+import type {Tagged} from 'type-fest';
+ 
+type JsonOf<T> = Tagged<string, 'JSON', T>;
+ 
+function stringify<T>(it: T) {
+  return JSON.stringify(it) as JsonOf<T>;
+}
+ 
+function parse<T extends JsonOf<unknown>>(it: T) {
+  return JSON.parse(it) as GetTagMetadata<T, 'JSON'>;
+}
+ 
+const x = stringify({ hello: 'world' });
+const parsed = parse(x); // The type of `parsed` is { hello: string }
+```
+ 
+@category Type
+ */
+export type GetTagMetadata<
+  Type extends Tag<TagName, unknown>,
+  TagName extends PropertyKey,
+> = Type[typeof tag][TagName];
+
+/**
+Revert a tagged type back to its original type by removing all tags.
+ 
+Why is this necessary?
+ 
+1. Use a `Tagged` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+ 
+@example
+```
+import type {Tagged, UnwrapTagged} from 'type-fest';
+ 
+type AccountType = Tagged<'SAVINGS' | 'CHECKING', 'AccountType'>;
+ 
+const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
+	SAVINGS: 99,
+	CHECKING: 0.1
+};
+ 
+// Without UnwrapTagged, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+ 
+// Attempting to pass an non-Tagged type to UnwrapTagged will raise a type error.
+type WontWork = UnwrapTagged<string>;
+```
+ 
+@category Type
+ */
+export type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> =
+  RemoveAllTags<TaggedType>;
+
+type RemoveAllTags<T> =
+  T extends Tag<PropertyKey, any>
+    ? {
+        [ThisTag in keyof T[typeof tag]]: T extends Tagged<
+          infer Type,
+          ThisTag,
+          T[typeof tag][ThisTag]
+        >
+          ? RemoveAllTags<Type>
+          : never;
+      }[keyof T[typeof tag]]
+    : T;