@agoric/internal 0.3.3-other-dev-8f8782b.0 → 0.3.3-other-dev-fbe72e7.0.fbe72e7

package/src/storage-test-utils.js

@@ -1,33 +1,24 @@
 // @ts-check
+import { Fail } from '@endo/errors';
 import { Far } from '@endo/far';
 import { makeMarshal, Remotable } from '@endo/marshal';
 import { makeTracer } from './debug.js';
-import {
-  isStreamCell,
-  makeChainStorageRoot,
-  unmarshalFromVstorage,
-} from './lib-chainStorage.js';
+import { NonNullish } from './errors.js';
+import { isStreamCell, makeChainStorageRoot } from './lib-chainStorage.js';
+import { unmarshalFromVstorage } from './marshal.js';
 import { bindAllMethods } from './method-tools.js';
-
-const { Fail } = assert;
-
-const trace = makeTracer('StorTU', false);
+import { eventLoopIteration } from './testing-utils.js';
 
 /**
- * A map corresponding with a total function such that `get(key)`
- * is assumed to always succeed.
- *
- * @template K, V
- * @typedef {{[k in Exclude<keyof Map<K, V>, 'get'>]: Map<K, V>[k]} & {get: (key: K) => V}} TotalMap
- */
-/**
- * @template T
- * @typedef {T extends Map<infer K, infer V> ? TotalMap<K, V> : never} TotalMapFrom
+ * @import {TotalMap} from './types.js';
+ * @import {Marshaller, StorageEntry, StorageMessage, StorageNode, StreamCell} from './lib-chainStorage.js';
  */
 
+const trace = makeTracer('StorTU', false);
+
 /**
- * A convertSlotToVal function that produces basic Remotables. Assumes
- * that all slots are Remotables (i.e. none are Promises).
+ * A convertSlotToVal function that produces basic Remotables. Assumes that all
+ * slots are Remotables (i.e. none are Promises).
  *
  * @param {string} _slotId
  * @param {string} iface
@@ -36,34 +27,44 @@ export const slotToRemotable = (_slotId, iface = 'Remotable') =>
   Remotable(iface);
 
 /**
- * A basic marshaller whose unserializer produces Remotables. It can
- * only serialize plain data, not Remotables.
+ * A basic marshaller whose unserializer produces Remotables. It can only
+ * serialize plain data, not Remotables.
  */
 export const defaultMarshaller = makeMarshal(undefined, slotToRemotable, {
   serializeBodyFormat: 'smallcaps',
 });
 
 /**
- * A deserializer which produces slot strings instead of Remotables,
- * so if `a = Far('iface')`, and serializing `{ a }` into `capData`
- * assigned it slot `board123`, then `slotStringUnserialize(capData)`
- * would produce `{ a: 'board123' }`.
+ * Serialize/deserialize functions using {@link defaultMarshaller}
+ */
+export const defaultSerializer = {
+  /** @type {(text: string) => unknown} */
+  parse: txt => defaultMarshaller.fromCapData(JSON.parse(txt)),
+  /** @type {(obj: any) => string} */
+  stringify: obj => JSON.stringify(defaultMarshaller.toCapData(obj)),
+};
+
+/**
+ * A deserializer which produces slot strings instead of Remotables, so if `a =
+ * Far('iface')`, and serializing `{ a }` into `capData` assigned it slot
+ * `board123`, then `slotStringUnserialize(capData)` would produce `{ a:
+ * 'board123' }`.
  *
  * This may be useful for display purposes.
  *
  * Limitations:
- *  * it cannot handle Symbols (registered or well-known)
- *  * it can handle BigInts, but serialized data that contains a
- *     particular unusual string will be unserialized into a BigInt by
- *     mistake
- *  * it cannot handle Promises, NaN, +/- Infinity, undefined, or
- *    other non-JSONable JavaScript values
+ *
+ * - it cannot handle Symbols (registered or well-known)
+ * - it can handle BigInts, but serialized data that contains a particular unusual
+ *   string will be unserialized into a BigInt by mistake
+ * - it cannot handle Promises, NaN, +/- Infinity, undefined, or other
+ *   non-JSONable JavaScript values
  */
 const makeSlotStringUnserialize = () => {
-  /** @type { (slot: string, iface: string) => any } */
+  /** @type {(slot: string, iface: string) => any} */
   const identitySlotToValFn = (slot, _) => Far('unk', { toJSON: () => slot });
   const { fromCapData } = makeMarshal(undefined, identitySlotToValFn);
-  /** @type { (capData: any) => any } */
+  /** @type {(capData: any) => any} */
   const unserialize = capData =>
     JSON.parse(
       JSON.stringify(fromCapData(capData), (_, val) => {
@@ -88,9 +89,9 @@ const makeSlotStringUnserialize = () => {
 export const slotStringUnserialize = makeSlotStringUnserialize();
 
 /**
- * For testing, creates a chainStorage root node over an in-memory map
- * and exposes both the map and the sequence of received messages.
- * The `sequence` option defaults to true.
+ * For testing, creates a chainStorage root node over an in-memory map and
+ * exposes both the map and the sequence of received messages. The `sequence`
+ * option defaults to true.
  *
  * @param {string} rootPath
  * @param {Parameters<typeof makeChainStorageRoot>[2]} [rootOptions]
@@ -99,6 +100,14 @@ export const makeFakeStorageKit = (rootPath, rootOptions) => {
   const resolvedOptions = { sequence: true, ...rootOptions };
   /** @type {TotalMap<string, string>} */
   const data = new Map();
+  let currentBlockHeight = 0;
+
+  const updateNewCellBlockHeight = (blockHeight = currentBlockHeight + 1) => {
+    blockHeight > currentBlockHeight ||
+      Fail`blockHeight ${blockHeight} must be greater than ${currentBlockHeight}`;
+    currentBlockHeight = blockHeight;
+  };
+
   /** @param {string} prefix */
   const getChildEntries = prefix => {
     assert(prefix.endsWith('.'));
@@ -116,114 +125,166 @@ 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
-  const toStorage = message => {
-    messages.push(message);
-    switch (message.method) {
-      case 'getStoreKey': {
-        const [key] = message.args;
-        return { storeName: 'swingset', storeSubkey: `fake:${key}` };
-      }
-      case 'get': {
-        const [key] = message.args;
-        return data.has(key) ? data.get(key) : null;
-      }
-      case 'children': {
-        const [key] = message.args;
-        const childEntries = getChildEntries(`${key}.`);
-        return [...childEntries.keys()];
-      }
-      case 'entries': {
-        const [key] = message.args;
-        const childEntries = getChildEntries(`${key}.`);
-        return [...childEntries.entries()].map(entry =>
-          entry[1] != null ? entry : [entry[0]],
-        );
-      }
-      case 'set':
-      case 'setWithoutNotify': {
-        trace('toStorage set', message);
-        /** @type {import('../src/lib-chainStorage.js').StorageEntry[]} */
-        const newEntries = message.args;
-        for (const [key, value] of newEntries) {
-          if (value != null) {
-            data.set(key, value);
-          } else {
-            data.delete(key);
-          }
+
+  const toStorage = Far(
+    'ToStorage',
+    /** @param {StorageMessage} message */
+    message => {
+      messages.push(message);
+      switch (message.method) {
+        case 'getStoreKey': {
+          const [key] = message.args;
+          return { storeName: 'swingset', storeSubkey: `fake:${key}` };
         }
-        break;
-      }
-      case 'append': {
-        trace('toStorage append', message);
-        /** @type {import('../src/lib-chainStorage.js').StorageEntry[]} */
-        const newEntries = message.args;
-        for (const [key, value] of newEntries) {
-          value != null || Fail`attempt to append with no value`;
-          // In the absence of block boundaries, everything goes in a single StreamCell.
-          const oldVal = data.get(key);
-          let streamCell;
-          if (oldVal != null) {
-            try {
-              streamCell = JSON.parse(oldVal);
-              assert(isStreamCell(streamCell));
-            } catch (_err) {
-              streamCell = undefined;
+        case 'get': {
+          const [key] = message.args;
+          return data.has(key) ? data.get(key) : null;
+        }
+        case 'children': {
+          const [key] = message.args;
+          const childEntries = getChildEntries(`${key}.`);
+          return [...childEntries.keys()];
+        }
+        case 'entries': {
+          const [key] = message.args;
+          const childEntries = getChildEntries(`${key}.`);
+          return [...childEntries.entries()].map(entry =>
+            entry[1] != null ? entry : [entry[0]],
+          );
+        }
+        case 'set':
+        case 'setWithoutNotify': {
+          trace('toStorage set', message);
+          /** @type {StorageEntry[]} */
+          const newEntries = message.args;
+          for (const [key, value] of newEntries) {
+            if (value != null) {
+              data.set(key, value);
+            } else {
+              data.delete(key);
             }
           }
-          if (streamCell === undefined) {
-            streamCell = {
-              blockHeight: '0',
-              values: oldVal != null ? [oldVal] : [],
-            };
+          return true;
+        }
+        case 'append': {
+          trace('toStorage append', message);
+          /** @type {StorageEntry[]} */
+          const newEntries = message.args;
+          for (const [key, value] of newEntries) {
+            value != null || Fail`attempt to append with no value`;
+
+            /** @type {string | undefined} */
+            let oldVal = data.get(key);
+            /** @type {StreamCell | undefined} */
+            let streamCell;
+            if (oldVal != null) {
+              try {
+                streamCell = JSON.parse(oldVal);
+                assert(isStreamCell(streamCell));
+              } catch (_err) {
+                streamCell = undefined;
+              }
+              // StreamCells reset at block boundaries.
+              if (
+                streamCell &&
+                Number(streamCell.blockHeight) !== currentBlockHeight
+              ) {
+                streamCell = undefined;
+                oldVal = undefined;
+              }
+            }
+
+            if (streamCell === undefined) {
+              streamCell = {
+                blockHeight: String(currentBlockHeight),
+                values: oldVal != null ? [oldVal] : [],
+              };
+            }
+            streamCell.values.push(value);
+            data.set(key, JSON.stringify(streamCell));
           }
-          streamCell.values.push(value);
-          data.set(key, JSON.stringify(streamCell));
+          return true;
         }
-        break;
+        case 'size':
+          // Intentionally incorrect because it counts non-child descendants,
+          // but nevertheless supports a "has children" test.
+          return [...data.keys()].filter(k =>
+            k.startsWith(`${message.args[0]}.`),
+          ).length;
+        default:
+          throw Error(`unsupported method: ${message.method}`);
       }
-      case 'size':
-        // Intentionally incorrect because it counts non-child descendants,
-        // but nevertheless supports a "has children" test.
-        return [...data.keys()].filter(k => k.startsWith(`${message.args[0]}.`))
-          .length;
-      default:
-        throw Error(`unsupported method: ${message.method}`);
-    }
-  };
+    },
+  );
   const rootNode = makeChainStorageRoot(toStorage, rootPath, resolvedOptions);
+
+  /**
+   * Get the values at a sequence node
+   *
+   * @param {string} path
+   * @returns {string[]}
+   */
+  const getValues = path => {
+    assert(resolvedOptions.sequence);
+    const nodeData = data.get(path);
+    assert(nodeData, `no data at path ${path}`);
+    const wrapper = JSON.parse(nodeData);
+    return wrapper.values;
+  };
+
   return {
     rootNode,
     // eslint-disable-next-line object-shorthand
     data: /** @type {Map<string, string>} */ (data),
+    updateNewCellBlockHeight,
+    getValues,
     messages,
     toStorage,
   };
 };
 harden(makeFakeStorageKit);
-/** @typedef {ReturnType< typeof makeFakeStorageKit>} FakeStorageKit */
+/** @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', {
     ...bindAllMethods(rootNode),
     /**
-     * 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.
+     * 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 {Marshaller} marshaller
      * @param {number} [index]
      * @returns {unknown}
      */
     getBody: (path, marshaller = defaultMarshaller, index = -1) => {
       data.size || Fail`no data in storage`;
-      /** @type {ReturnType<typeof import('@endo/marshal').makeMarshal>['fromCapData']} */
+      /**
+       * @type {ReturnType<
+       *   typeof import('@endo/marshal').makeMarshal
+       * >['fromCapData']}
+       */
       const fromCapData = (...args) =>
         Reflect.apply(marshaller.fromCapData, marshaller, args);
       return unmarshalFromVstorage(data, path, fromCapData, index);
@@ -231,4 +292,61 @@ export const makeMockChainStorageRoot = () => {
     keys: () => [...data.keys()],
   });
 };
-/** @typedef {ReturnType<typeof makeMockChainStorageRoot>} MockChainStorageRoot */
+
+/**
+ * @param {import('ava').ExecutionContext<unknown>} t
+ * @param {MockChainStorageRoot | FakeStorageKit} storage
+ * @param {({ note: string } | { node: string; owner: string }) &
+ *   ({ pattern: string; replacement: string } | {}) & {
+ *     showValue?: (v: string) => unknown;
+ *   }} opts
+ */
+export const documentStorageSchema = async (t, storage, opts) => {
+  // chainStorage publication is unsynchronized
+  await eventLoopIteration();
+
+  const getLast = (/** @type {string} */ cell) =>
+    JSON.parse(cell).values.at(-1) || assert.fail();
+  const { showValue = s => s } = opts;
+  /** @type {(d: Map<string, string>, k: string) => unknown} */
+  const getBodyDefault = (d, k) => showValue(getLast(NonNullish(d.get(k))));
+
+  const [keys, getBody] =
+    'keys' in storage
+      ? [storage.keys(), (/** @type {string} */ k) => storage.getBody(k)]
+      : [
+          storage.data.keys(),
+          (/** @type {string} */ k) => getBodyDefault(storage.data, k),
+        ];
+
+  const { pattern, replacement } =
+    'pattern' in opts
+      ? opts
+      : { pattern: 'mockChainStorageRoot.', replacement: 'published.' };
+
+  const pruned = [...keys]
+    .sort()
+    .filter(
+      'node' in opts
+        ? key =>
+            key
+              .replace(pattern, replacement)
+              .startsWith(`published.${opts.node}`)
+        : _entry => true,
+    );
+
+  const illustration = pruned.map(
+    /** @type {(k: string) => [string, unknown]} */
+    key => [key.replace(pattern, replacement), getBody(key)],
+  );
+
+  const note =
+    'note' in opts
+      ? opts.note
+      : `Under "published", the "${opts.node}" node is delegated to ${opts.owner}.`;
+  const boilerplate = `
+The example below illustrates the schema of the data published there.
+
+See also board marshalling conventions (_to appear_).`;
+  t.snapshot(illustration, note + boilerplate);
+};

package/src/tagged.d.ts

@@ -0,0 +1,152 @@
+/** @file adapted from https://raw.githubusercontent.com/sindresorhus/type-fest/main/source/tagged.d.ts */
+
+// different name to avoid confusion with pass-style "tagged"
+export { Tagged as TypeTag };
+
+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'>;
+```
+ */
+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 }
+```
+ */
+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>;
+```
+ */
+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;

package/src/testing-utils.d.ts

@@ -1,2 +1,4 @@
 export function eventLoopIteration(): Promise<any>;
+export function inspectMapStore(store: MapStore): object;
+import type { MapStore } from '@agoric/store';
 //# sourceMappingURL=testing-utils.d.ts.map

package/src/testing-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing-utils.d.ts","sourceRoot":"","sources":["testing-utils.js"],"names":[],"mappings":"AAWO,mDACwC"}
+{"version":3,"file":"testing-utils.d.ts","sourceRoot":"","sources":["testing-utils.js"],"names":[],"mappings":"AAeO,mDACwC;AAgBxC,uCAHI,QAAQ,GACN,MAAM,CAqBlB;8BA7C2B,eAAe"}

package/src/testing-utils.js

@@ -1,14 +1,53 @@
-/** @file note this cannot be called test-utils.js due to https://github.com/Agoric/agoric-sdk/issues/7503 */
+// @ts-check
+/**
+ * @file note this cannot be called test-utils.js due to
+ *   https://github.com/Agoric/agoric-sdk/issues/7503
+ */
 /* global setImmediate */
+/** @import {MapStore} from '@agoric/store'; */
 
 /**
  * A workaround for some issues with fake time in tests.
  *
- * Lines of test code can depend on async promises outside the test
- * resolving before they run. Awaiting this function result ensures
- * that all promises that can do resolve.
- * Note that this doesn't mean all outstanding promises.
+ * Lines of test code can depend on async promises outside the test resolving
+ * before they run. Awaiting this function result ensures that all promises that
+ * can do resolve. Note that this doesn't mean all outstanding promises.
  */
 export const eventLoopIteration = async () =>
   new Promise(resolve => setImmediate(resolve));
 harden(eventLoopIteration);
+
+/** @type {(value: any) => string} */
+const stringOrTag = value => {
+  if (typeof value === 'string') {
+    return value;
+  } else if (typeof value === 'object' && Symbol.toStringTag in value) {
+    return value[Symbol.toStringTag];
+  }
+  return String(value);
+};
+/**
+ * @param {MapStore} store
+ * @returns {object} tree of the contents of the store
+ */
+export const inspectMapStore = store => {
+  /** @type {Record<string, unknown>} */
+  const obj = {};
+  for (const key of store.keys()) {
+    const value = store.get(key);
+    const hasKeys = typeof value === 'object' && 'keys' in value;
+    const index = stringOrTag(key);
+    if (hasKeys && 'get' in value) {
+      obj[index] = inspectMapStore(value);
+    } else if (hasKeys) {
+      obj[index] = Array.from(value.keys());
+    } else {
+      obj[index] =
+        value instanceof Object && Symbol.toStringTag in value
+          ? value[Symbol.toStringTag]
+          : value;
+    }
+  }
+  return obj;
+};
+harden(inspectMapStore);

package/src/tmpDir.d.ts

@@ -0,0 +1,2 @@
+export function makeTempDirFactory(tmp: Pick<typeof import("tmp"), "dirSync">): (prefix?: string) => [dirName: string, cleanup: () => void];
+//# sourceMappingURL=tmpDir.d.ts.map

package/src/tmpDir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tmpDir.d.ts","sourceRoot":"","sources":["tmpDir.js"],"names":[],"mappings":"AAMO,wCAFI,IAAI,CAAC,oBAAa,EAAE,SAAS,CAAC,aAGlB,MAAM,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC,CASvE"}