@agoric/internal 0.2.2-pismo-dev-50dc068.0 → 0.3.0

package/src/priority-senders.js

@@ -0,0 +1,104 @@
+import { E, Far } from '@endo/far';
+
+const { Fail, quote: q } = assert;
+
+const PRIORITY_SENDERS_NAMESPACE_RE = /^[a-zA-Z0-9_-]{1,50}$/;
+
+/** @type {(namespace: string) => string} */
+export const normalizeSenderNamespace = namespace => {
+  const candidate = namespace.replace(/[ ,()]/g, '_');
+  PRIORITY_SENDERS_NAMESPACE_RE.test(candidate) ||
+    Fail`invalid namespace ${q(namespace)}`;
+  return candidate;
+};
+harden(normalizeSenderNamespace);
+
+/**
+ * XXX lets holder manage sender list for all namespaces
+ *
+ * @param {ERef<import('./lib-chainStorage.js').StorageNode>} sendersNode
+ */
+export const makePrioritySendersManager = sendersNode => {
+  /**
+   * address to tuple with storage node and set of namespaces that requested priority
+   *
+   * @type {Map<string, readonly [node: StorageNode, namespaces: Set<string>]>}
+   */
+  const addressRecords = new Map();
+
+  /**
+   * Write a list of namespaces into a storage node.
+   *
+   * @param {import('./lib-chainStorage.js').StorageNode} node
+   * @param {Set<string>} namespaces
+   */
+  const refreshVstorage = (node, namespaces) => {
+    return E(node).setValue(
+      // if the list set is empty, the string will be '' and thus deleted from IAVL
+      [...namespaces.keys()].sort().join(','),
+    );
+  };
+
+  const provideRecordForAddress = async address => {
+    const extant = addressRecords.get(address);
+    if (extant) {
+      return extant;
+    }
+    const node = await E(sendersNode).makeChildNode(address, {
+      sequence: false,
+    });
+    /** @type {readonly [ node: StorageNode, namespaces: Set<string> ]} */
+    const r = [node, new Set()];
+    addressRecords.set(address, r);
+    return r;
+  };
+
+  return Far('prioritySenders manager', {
+    /**
+     * @param {string} rawNamespace
+     * @param {string} address
+     * @returns {Promise<void>}
+     */
+    add: async (rawNamespace, address) => {
+      const namespace = normalizeSenderNamespace(rawNamespace);
+
+      const record = await provideRecordForAddress(address);
+
+      const [node, namespaces] = record;
+      if (namespaces.has(namespace)) {
+        throw Fail`namespace ${q(namespace)} already has address ${q(address)}`;
+      }
+      namespaces.add(namespace);
+
+      return refreshVstorage(node, namespaces);
+    },
+    /**
+     * @param {string} rawNamespace
+     * @param {string} address
+     * @returns {Promise<void>}
+     */
+    remove: (rawNamespace, address) => {
+      const namespace = normalizeSenderNamespace(rawNamespace);
+      const record = addressRecords.get(address);
+      if (!record) {
+        throw Fail`address not registered: ${q(address)}`;
+      }
+      const [node, namespaces] = record;
+      if (!namespaces.has(namespace)) {
+        throw Fail`namespace ${q(namespace)} does not have address ${q(
+          address,
+        )}`;
+      }
+
+      namespaces.delete(namespace);
+      if (namespaces.size === 0) {
+        addressRecords.delete(address);
+      }
+
+      return refreshVstorage(node, namespaces);
+    },
+  });
+};
+harden(makePrioritySendersManager);
+
+/** @typedef {ReturnType<typeof makePrioritySendersManager>} PrioritySendersManager */

package/src/queue.d.ts

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

package/src/queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["queue.js"],"names":[],"mappings":"AAQO,uHAiDN"}

package/src/queue.js

@@ -0,0 +1,58 @@
+// @jessie-check
+
+import { makePromiseKit } from '@endo/promise-kit';
+
+/**
+ * Return a function that can wrap an async or sync method, but
+ * ensures only one of them (in order) is running at a time.
+ */
+export const makeWithQueue = () => {
+  const queue = [];
+
+  // Execute the thunk at the front of the queue.
+  const dequeue = () => {
+    if (!queue.length) {
+      return;
+    }
+    const [thunk, resolve, reject] = queue[0];
+    // Run the thunk in a new turn.
+    Promise.resolve()
+      .then(thunk)
+      // Resolve or reject our caller with the thunk's value.
+      .then(resolve, reject)
+      // Rerun dequeue() after settling.
+      .finally(() => {
+        queue.shift();
+        if (queue.length) {
+          dequeue();
+        }
+      });
+  };
+
+  /**
+   * @template {any[]} T
+   * @template R
+   * @param {(...args: T) => Promise<R>} inner
+   */
+  return function withQueue(inner) {
+    /**
+     * @param {T} args
+     * @returns {Promise<R>}
+     */
+    return function queueCall(...args) {
+      // Curry the arguments into the inner function, and
+      // resolve/reject with whatever the inner function does.
+      const thunk = _ => inner(...args);
+      const pr = makePromiseKit();
+      queue.push([thunk, pr.resolve, pr.reject]);
+
+      if (queue.length === 1) {
+        // Start running immediately.
+        dequeue();
+      }
+
+      // Allow the caller to retrieve our thunk's results.
+      return pr.promise;
+    };
+  };
+};

package/src/scratch.d.ts

@@ -0,0 +1,19 @@
+export default function makeScratchPad(): {
+    delete: (keyP: any) => Promise<void>;
+    get: (keyP: any) => Promise<any>;
+    lookup: (...path: any[]) => any;
+    init: (keyP: any, objP: any) => Promise<any>;
+    keys: () => Promise<any[]>;
+    list: () => Promise<any[]>;
+    set: (keyP: any, objP: any) => Promise<any>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    delete: (keyP: any) => Promise<void>;
+    get: (keyP: any) => Promise<any>;
+    lookup: (...path: any[]) => any;
+    init: (keyP: any, objP: any) => Promise<any>;
+    keys: () => Promise<any[]>;
+    list: () => Promise<any[]>;
+    set: (keyP: any, objP: any) => Promise<any>;
+}>;
+export type ScratchPad = ReturnType<typeof makeScratchPad>;
+//# sourceMappingURL=scratch.d.ts.map

package/src/scratch.d.ts.map

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

package/src/scratch.js

@@ -0,0 +1,52 @@
+import { E, Far } from '@endo/far';
+
+export default function makeScratchPad() {
+  const map = new Map();
+
+  const keys = async () => {
+    const keyList = [...map.keys()];
+    return harden(keyList.sort());
+  };
+
+  const scratch = Far('scratchPad', {
+    delete: async keyP => {
+      const key = await keyP;
+      map.delete(key);
+    },
+    get: async keyP => {
+      const key = await keyP;
+      return map.get(key);
+    },
+    lookup: (...path) => {
+      if (path.length === 0) {
+        return scratch;
+      }
+      const [first, ...rest] = path;
+      const firstValue = E(scratch).get(first);
+      if (rest.length === 0) {
+        return firstValue;
+      }
+      return E(firstValue).lookup(...rest);
+    },
+    // Initialize a key only if it doesn't already exist.  Needed for atomicity
+    // between multiple invocations.
+    init: async (keyP, objP) => {
+      const [key, obj] = await Promise.all([keyP, objP]);
+      if (map.has(key)) {
+        throw Error(`Scratchpad already has key ${key}`);
+      }
+      map.set(key, obj);
+      return key;
+    },
+    keys,
+    // Legacy alias for `keys`.
+    list: keys,
+    set: async (keyP, objP) => {
+      const [key, obj] = await Promise.all([keyP, objP]);
+      map.set(key, obj);
+      return key;
+    },
+  });
+  return scratch;
+}
+/** @typedef {ReturnType<typeof makeScratchPad>} ScratchPad */

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

@@ -0,0 +1,99 @@
+export function slotToRemotable(_slotId: string, iface?: 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>;
+};
+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: {
+        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<{}, {
+        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>;
+    }>;
+    data: Map<string, string>;
+    messages: import("./lib-chainStorage.js").StorageMessage[];
+    toStorage: (message: import('../src/lib-chainStorage.js').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>;
+}>;
+/**
+ * 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;
+} & {
+    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>;
+//# sourceMappingURL=storage-test-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storage-test-utils.d.ts","sourceRoot":"","sources":["storage-test-utils.js"],"names":[],"mappings":"AA+BO,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;;;;EAkFhE;AAIM;IAIH;;;;;;;;;OASG;oBAHQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,KACxC,OAAO;;;;;;;;;IARpB;;;;;;;;;OASG;oBAHQ,MAAM,eACN,OAAO,uBAAuB,EAAE,UAAU,KACxC,OAAO;;;;;;;;GAWvB;;;;;;;;;;;;;;;;;;eAjNiF,CAAC,KAAK,CAAC;;;6BAwL3E,WAAY,yBAAyB,CAAC;mCA0BtC,WAAW,+BAA+B,CAAC"}

package/src/storage-test-utils.js

@@ -0,0 +1,228 @@
+// @ts-check
+import { Far } from '@endo/far';
+import { makeMarshal, Remotable } from '@endo/marshal';
+import {
+  isStreamCell,
+  makeChainStorageRoot,
+  unmarshalFromVstorage,
+} from './lib-chainStorage.js';
+import { bindAllMethods } from './method-tools.js';
+
+const { Fail } = assert;
+
+/**
+ * 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
+ */
+
+/**
+ * A convertSlotToVal function that produces basic Remotables. Assumes
+ * that all slots are Remotables (i.e. none are Promises).
+ *
+ * @param {string} _slotId
+ * @param {string} iface
+ */
+export const slotToRemotable = (_slotId, iface = 'Remotable') =>
+  Remotable(iface);
+
+/**
+ * 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' }`.
+ *
+ * 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
+ */
+const makeSlotStringUnserialize = () => {
+  /** @type { (slot: string, iface: string) => any } */
+  const identitySlotToValFn = (slot, _) => Far('unk', { toJSON: () => slot });
+  const { fromCapData } = makeMarshal(undefined, identitySlotToValFn);
+  /** @type { (capData: any) => any } */
+  const unserialize = capData =>
+    JSON.parse(
+      JSON.stringify(fromCapData(capData), (_, val) => {
+        if (typeof val === 'bigint') {
+          // JSON cannot accept BigInts. This unusual string is a
+          // cheap alternative to a proper Hilbert Hotel.
+          return `@encromulate:${val}`;
+        } else {
+          return val;
+        }
+      }),
+      (_key, val) => {
+        if (typeof val === 'string' && val.startsWith('@encromulate')) {
+          return BigInt(val.split(':')[1]);
+        } else {
+          return val;
+        }
+      },
+    );
+  return harden(unserialize);
+};
+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.
+ *
+ * @param {string} rootPath
+ * @param {Parameters<typeof makeChainStorageRoot>[2]} [rootOptions]
+ */
+export const makeFakeStorageKit = (rootPath, rootOptions) => {
+  const resolvedOptions = { sequence: true, ...rootOptions };
+  /** @type {TotalMap<string, string>} */
+  const data = new Map();
+  /** @param {string} prefix */
+  const getChildEntries = prefix => {
+    assert(prefix.endsWith('.'));
+    const childEntries = new Map();
+    for (const [path, value] of data.entries()) {
+      if (!path.startsWith(prefix)) {
+        continue;
+      }
+      const [segment, ...suffix] = path.slice(prefix.length).split('.');
+      if (suffix.length === 0) {
+        childEntries.set(segment, value);
+      } else if (!childEntries.has(segment)) {
+        childEntries.set(segment, null);
+      }
+    }
+    return childEntries;
+  };
+  /** @type {import('../src/lib-chainStorage.js').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': {
+        /** @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);
+          }
+        }
+        break;
+      }
+      case 'append': {
+        /** @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;
+            }
+          }
+          if (streamCell === undefined) {
+            streamCell = {
+              blockHeight: '0',
+              values: oldVal != null ? [oldVal] : [],
+            };
+          }
+          streamCell.values.push(value);
+          data.set(key, JSON.stringify(streamCell));
+        }
+        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}`);
+    }
+  };
+  const rootNode = makeChainStorageRoot(toStorage, rootPath, resolvedOptions);
+  return {
+    rootNode,
+    // eslint-disable-next-line object-shorthand
+    data: /** @type {Map<string, string>} */ (data),
+    messages,
+    toStorage,
+  };
+};
+harden(makeFakeStorageKit);
+/** @typedef {ReturnType< typeof makeFakeStorageKit>} FakeStorageKit */
+
+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.
+     *
+     * @param {string} path
+     * @param {import('./lib-chainStorage.js').Marshaller} marshaller
+     * @returns {unknown}
+     */
+    getBody: (path, marshaller = defaultMarshaller) => {
+      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);
+    },
+    keys: () => [...data.keys()],
+  });
+};
+/** @typedef {ReturnType<typeof makeMockChainStorageRoot>} MockChainStorageRoot */

package/src/testing-utils.d.ts

@@ -0,0 +1,2 @@
+export function eventLoopIteration(): Promise<any>;
+//# sourceMappingURL=testing-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"testing-utils.d.ts","sourceRoot":"","sources":["testing-utils.js"],"names":[],"mappings":"AAWO,mDACwC"}

package/src/testing-utils.js

@@ -0,0 +1,14 @@
+/** @file note this cannot be called test-utils.js due to https://github.com/Agoric/agoric-sdk/issues/7503 */
+/* global setImmediate */
+
+/**
+ * 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.
+ */
+export const eventLoopIteration = async () =>
+  new Promise(resolve => setImmediate(resolve));
+harden(eventLoopIteration);

package/src/typeGuards.d.ts

@@ -0,0 +1,2 @@
+export const StorageNodeShape: import("@endo/patterns").Matcher;
+//# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA,gEAA2D"}

package/src/typeGuards.js

@@ -0,0 +1,5 @@
+// @jessie-check
+
+import { M } from '@endo/patterns';
+
+export const StorageNodeShape = M.remotable('StorageNode');

package/src/types.d.ts

@@ -0,0 +1,20 @@
+/* eslint-disable max-classes-per-file */
+export declare class Callback<I extends (...args: unknown[]) => any> {
+  private iface: I;
+
+  public target: any;
+
+  public methodName?: PropertyKey;
+
+  public bound: unknown[];
+
+  public isSync: boolean;
+}
+
+export declare class SyncCallback<
+  I extends (...args: unknown[]) => any,
+> extends Callback<I> {
+  private syncIface: I;
+
+  public isSync: true;
+}

package/src/upgrade-api.d.ts

@@ -0,0 +1,8 @@
+export function makeUpgradeDisconnection(upgradeMessage: string, toIncarnationNumber: number): DisconnectionObject;
+export function isUpgradeDisconnection(err: any): err is DisconnectionObject;
+export type DisconnectionObject = {
+    name: string;
+    upgradeMessage: string;
+    incarnationNumber: number;
+};
+//# sourceMappingURL=upgrade-api.d.ts.map

package/src/upgrade-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-api.d.ts","sourceRoot":"","sources":["upgrade-api.js"],"names":[],"mappings":"AAgBO,yDAJI,MAAM,uBACN,MAAM,GACJ,mBAAmB,CAO5B;AAcG,4CAHI,GAAG,8BAO6B;kCAlC9B;IAAE,MAAM,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE"}