@agoric/internal 0.5.0-u23.0 → 0.5.0-u23.1

package/src/lib-chainStorage.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Create a heap-based root storage node for a given backing function and root
+ * path.
+ *
+ * @param {(message: StorageMessage) => any} handleStorageMessage a function for
+ *   sending a storageMessage object to the storage implementation (cf.
+ *   golang/cosmos/x/vstorage/vstorage.go)
+ * @param {string} rootPath
+ * @param {object} [rootOptions]
+ * @param {boolean} [rootOptions.sequence] employ a wrapping structure that
+ *   preserves each value set within a single block, and default child nodes to
+ *   do the same
+ */
+export function makeChainStorageRoot(handleStorageMessage: (message: StorageMessage) => any, rootPath: string, rootOptions?: {
+    sequence?: boolean | undefined;
+}): import("@endo/exo").Guarded<{
+    getPath(): string;
+    getStoreKey(): Promise<VStorageKey>;
+    makeChildNode(name: string, childNodeOptions?: {
+        sequence?: boolean;
+    }): StorageNode;
+    setValue(value: string): Promise<void>;
+}>;
+/**
+ * Convenience function for returning a storage node at or under its input,
+ * falling back to an inert object with the correct interface (but incomplete
+ * behavior) when that is unavailable.
+ *
+ * @param {ERef<Remote<StorageNode> | null>} storageNodeRef
+ * @param {string} childName
+ * @returns {Promise<Remote<StorageNode>>}
+ */
+export function makeStorageNodeChild(storageNodeRef: ERef<Remote<StorageNode> | null>, childName: string): Promise<Remote<StorageNode>>;
+/**
+ * @import {ERef} from '@endo/far';
+ * @import {Marshal, Passable} from '@endo/marshal';
+ * @import {Remote, ERemote, TypedPattern} from './types.js';
+ * @import {EMarshaller} from './marshal/wrap-marshaller.js';
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Callback} from './types.js';
+ */
+/** @typedef {Marshal<unknown>} Marshaller */
+/** @typedef {Pick<Marshaller, 'fromCapData'>} Unserializer */
+/**
+ * Defined by vstorageStoreKey in vstorage.go
+ *
+ * @typedef VStorageKey
+ * @property {string} storeName
+ * @property {string} storeSubkey
+ * @property {string} dataPrefixBytes
+ * @property {string} [noDataValue]
+ */
+/**
+ * @template [T=unknown]
+ * @typedef StreamCell
+ * @property {string} blockHeight corresponding with the write of `values`
+ *   (decimal representation of a natural number)
+ * @property {T[]} values
+ */
+/** @type {TypedPattern<StreamCell>} */
+export const StreamCellShape: TypedPattern<StreamCell>;
+export function isStreamCell(cell: any): cell is StreamCell;
+/** @type {(name: string) => void} */
+export const assertPathSegment: (name: string) => void;
+export function prepareChainStorageNode(zone: Zone): (messenger: Callback<(message: StorageMessage) => any>, path: string, args_2?: {
+    sequence?: boolean | undefined;
+} | undefined) => import("@endo/exo").Guarded<{
+    getPath(): string;
+    getStoreKey(): Promise<VStorageKey>;
+    makeChildNode(name: string, childNodeOptions?: {
+        sequence?: boolean;
+    }): StorageNode;
+    setValue(value: string): Promise<void>;
+}>;
+export function makeSerializeToStorage(storageNode: ERemote<StorageNode>, marshaller: ERemote<EMarshaller>): (value: Passable) => Promise<void>;
+export type Marshaller = Marshal<unknown>;
+export type Unserializer = Pick<Marshaller, "fromCapData">;
+/**
+ * Defined by vstorageStoreKey in vstorage.go
+ */
+export type VStorageKey = {
+    storeName: string;
+    storeSubkey: string;
+    dataPrefixBytes: string;
+    noDataValue?: string | undefined;
+};
+export type StreamCell<T = unknown> = {
+    /**
+     * corresponding with the write of `values`
+     * (decimal representation of a natural number)
+     */
+    blockHeight: string;
+    values: T[];
+};
+/**
+ * This represents a node in an IAVL tree.
+ *
+ * The active implementation is x/vstorage, an Agoric extension of the Cosmos
+ * SDK.
+ *
+ * Vstorage is a hierarchical externally-reachable storage structure that
+ * identifies children by restricted ASCII name and is associated with arbitrary
+ * string-valued data for each node, defaulting to the empty string.
+ */
+export type StorageNode = {
+    /**
+     * publishes some data
+     */
+    setValue: (data: string) => Promise<void>;
+    /**
+     * the chain storage path at which the node was
+     * constructed
+     */
+    getPath: () => string;
+    /**
+     * DEPRECATED use getPath
+     */
+    getStoreKey: () => Promise<VStorageKey>;
+    makeChildNode: (subPath: string, options?: {
+        sequence?: boolean;
+    }) => StorageNode;
+};
+export type StoredFacet = {
+    /**
+     * the chain storage path at which the
+     * node was constructed
+     */
+    getPath: () => Promise<string>;
+    /**
+     * DEPRECATED use getPath
+     */
+    getStoreKey: StorageNode["getStoreKey"];
+    /**
+     * get the unserializer for the
+     * stored data
+     */
+    getUnserializer: () => Unserializer;
+};
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageGetByPathMessageMethod = "get" | "getStoreKey" | "has" | "children" | "entries" | "values" | "size";
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageUpdateEntriesMessageMethod = "set" | "setWithoutNotify" | "append";
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageMessageMethod = StorageGetByPathMessageMethod | StorageUpdateEntriesMessageMethod;
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageGetByPathMessageArgs = [path: string];
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageEntry = [path: string, value?: string | null];
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageUpdateEntriesMessageArgs = StorageEntry[];
+/**
+ * Must match the switch in vstorage.go using `vstorageMessage` type
+ */
+export type StorageMessage = {
+    method: StorageGetByPathMessageMethod;
+    args: StorageGetByPathMessageArgs;
+} | {
+    method: StorageUpdateEntriesMessageMethod;
+    args: StorageUpdateEntriesMessageArgs;
+};
+import type { Remote } from './types.js';
+import type { ERef } from '@endo/far';
+import type { TypedPattern } from './types.js';
+import type { Zone } from '@agoric/base-zone';
+import type { Callback } from './types.js';
+import type { ERemote } from './types.js';
+import type { EMarshaller } from './marshal/wrap-marshaller.js';
+import type { Passable } from '@endo/marshal';
+import type { Marshal } from '@endo/marshal';
+//# sourceMappingURL=lib-chainStorage.d.ts.map

package/src/lib-chainStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib-chainStorage.d.ts","sourceRoot":"","sources":["lib-chainStorage.js"],"names":[],"mappings":"AAiPA;;;;;;;;;;;;GAYG;AACH,2DATW,CAAC,OAAO,EAAE,cAAc,KAAK,GAAG,YAGhC,MAAM,gBAEd;IAA8B,QAAQ;CAGxC;;mBAnEqB,OAAO,CAAC,WAAW,CAAC;wBAWzB,MAAM,qBACO;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,WAAW;oBAYA,MAAM,GAAK,OAAO,CAAC,IAAI,CAAC;GAqDhD;AAcD;;;;;;;;GAQG;AACH,qDAJW,KAAK,OAAO,WAAW,CAAC,GAAG,IAAI,CAAC,aAChC,MAAM,GACJ,OAAO,CAAC,OAAO,WAAW,CAAC,CAAC,CAMxC;AA3RD;;;;;;;GAOG;AAEH,6CAA6C;AAC7C,8DAA8D;AAE9D;;;;;;;;GAQG;AAEH;;;;;;GAMG;AAEH,uCAAuC;AACvC,8BADW,aAAa,UAAU,CAAC,CAIhC;AAwCI,mCAHI,GAAG,GACD,IAAI,IAAI,UAAU,CAOa;AAmB5C,qCAAqC;AACrC,gCADW,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAI/B;AAyCK,8CAFI,IAAI,kCAqBmB,cAAc,KAAK,GAAG;;;;mBAgBlC,OAAO,CAAC,WAAW,CAAC;wBAWzB,MAAM,qBACO;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,WAAW;oBAYA,MAAM,GAAK,OAAO,CAAC,IAAI,CAAC;GA0BhD;AA+DM,oDAJI,QAAQ,WAAW,CAAC,cACpB,QAAQ,WAAW,CAAC,GAClB,CAAC,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAQ9C;yBAjSa,QAAQ,OAAO,CAAC;2BAChB,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC;;;;;eAM/B,MAAM;iBACN,MAAM;qBACN,MAAM;;;uBAKN,CAAC;;;;;iBAED,MAAM;YAEN,CAAC,EAAE;;;;;;;;;;;;;;;;cAoBH,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC;;;;;aAC/B,MAAM,MAAM;;;;iBAEZ,MAAM,OAAO,CAAC,WAAW,CAAC;mBAC1B,CACT,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAC7B,WAAW;;;;;;;aA8BL,MAAM,OAAO,CAAC,MAAM,CAAC;;;;iBAErB,WAAW,CAAC,aAAa,CAAC;;;;;qBAC1B,MAAM,YAAY;;;;;4CAqBnB,KAAK,GACX,aAAa,GACb,KAAK,GACL,UAAU,GACV,SAAS,GACT,QAAQ,GACR,MAAM;;;;gDAGA,KAAK,GAAG,kBAAkB,GAAG,QAAQ;;;;mCAGrC,6BAA6B,GACnC,iCAAiC;;;;0CAG3B,CAAC,IAAI,EAAE,MAAM,CAAC;;;;2BAEd,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;;;;8CAErC,YAAY,EAAE;;;;6BAEd;IACJ,MAAM,EAAE,6BAA6B,CAAC;IACtC,IAAI,EAAE,2BAA2B,CAAC;CACnC,GACD;IACE,MAAM,EAAE,iCAAiC,CAAC;IAC1C,IAAI,EAAE,+BAA+B,CAAC;CACvC;4BAtIwC,YAAY;0BAFrC,WAAW;kCAEc,YAAY;0BAErC,mBAAmB;8BACf,YAAY;6BAHS,YAAY;iCAC9B,8BAA8B;8BAFxB,eAAe;6BAAf,eAAe"}

package/src/lib-nodejs/ava-unhandled-rejection.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @import {ExecutionContext, ImplementationFn, Macro, MacroDeclarationOptions,TestFn} from 'ava';
+ */
+/** Not an official AVA feature, so prefix with `AGORIC_` */
+export const AGORIC_AVA_EXPECT_UNHANDLED_REJECTIONS: "AGORIC_AVA_EXPECT_UNHANDLED_REJECTIONS";
+/** Backwards compatibility... */
+export const AVA_EXPECT_UNHANDLED_REJECTIONS: "AGORIC_AVA_EXPECT_UNHANDLED_REJECTIONS";
+export function countUnhandled(work: () => any | Promise<any>, { gcAndFinalize }: {
+    gcAndFinalize: () => Promise<void>;
+}): Promise<{
+    unhandled: number;
+    pending: number;
+    seenUnhandled: number;
+}>;
+export function makeExpectUnhandledRejection<C>({ test, sameWorker, importMetaUrl, }: {
+    test: TestFn<C>;
+    sameWorker?: boolean | undefined;
+    importMetaUrl: string;
+}): (expectedUnhandled: number) => Macro<[name: string, impl: (t: ExecutionContext<C>) => any], C>;
+export function makeExpectUnhandledRejectionMacro<C = unknown>({ test, sameWorker, importMetaUrl, }: {
+    test: TestFn<C>;
+    sameWorker?: boolean | undefined;
+    importMetaUrl: string;
+}): (numUnhandled: number, innerMacro?: Macro<A, C>) => Macro<A, C>;
+import type { TestFn } from 'ava';
+import type { ExecutionContext } from 'ava';
+import type { Macro } from 'ava';
+//# sourceMappingURL=ava-unhandled-rejection.d.ts.map

package/src/lib-nodejs/ava-unhandled-rejection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ava-unhandled-rejection.d.ts","sourceRoot":"","sources":["ava-unhandled-rejection.js"],"names":[],"mappings":"AAOA;;GAEG;AAEH,4DAA4D;AAC5D,qDACE,wCAAwC,CAAC;AAC3C,iCAAiC;AACjC,uFACyC;AA2ElC,qCAJI,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,qBAEhC;IAAoC,aAAa,EAAzC,MAAM,OAAO,CAAC,IAAI,CAAC;CAC7B;;;;GA4BA;AAeM,6CARM,CAAC,wCAEX;IAA0B,IAAI,EAAtB,OAAO,CAAC,CAAC;IACQ,UAAU;IACZ,aAAa,EAA5B,MAAM;CACd,GAAU,CAAE,iBAAiB,EAAE,MAAM,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EACzE,iBAAqB,CAAC,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC,CAkEpC;AASM,kDANO,CAAC,kDAEZ;IAA0B,IAAI,EAAtB,OAAO,CAAC,CAAC;IACQ,UAAU;IACZ,aAAa,EAA5B,MAAM;CAChB,IAiBS,cAJG,MAIS,EAAE,aAHX,MAAM,CAAC,EAAE,CAAC,CAGW,KAFnB,MAAM,CAAC,EAAE,CAAC,CAAC,CAoCzB;4BAxP2F,KAAK;sCAAL,KAAK;2BAAL,KAAK"}

package/src/lib-nodejs/engine-gc.d.ts

@@ -0,0 +1,3 @@
+export default engineGC;
+declare const engineGC: GCFunction;
+//# sourceMappingURL=engine-gc.d.ts.map

package/src/lib-nodejs/engine-gc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-gc.d.ts","sourceRoot":"","sources":["engine-gc.js"],"names":[],"mappings":";AAoBA,mCAAwB"}

package/src/lib-nodejs/gc-and-finalize.d.ts

@@ -0,0 +1,2 @@
+export function makeGcAndFinalize(gcPower: any): () => Promise<void>;
+//# sourceMappingURL=gc-and-finalize.d.ts.map

package/src/lib-nodejs/gc-and-finalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gc-and-finalize.d.ts","sourceRoot":"","sources":["gc-and-finalize.js"],"names":[],"mappings":"AAkEA,qEAwBC"}

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

@@ -0,0 +1,13 @@
+export function startSubprocessWorker(execPath: any, procArgs?: any[], { netstringMaxChunkSize }?: {
+    netstringMaxChunkSize?: undefined;
+}): {
+    fromChild: {
+        on: (...args: any[]) => import("stream").Transform;
+    };
+    toChild: {
+        write: (...args: any[]) => boolean;
+    };
+    terminate: () => void;
+    done: Promise<any>;
+};
+//# sourceMappingURL=spawnSubprocessWorker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spawnSubprocessWorker.d.ts","sourceRoot":"","sources":["spawnSubprocessWorker.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;EA0DC"}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export function notForProductionUse(): {};
+//# sourceMappingURL=magic-cookie-test-only.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/marshal/wrap-marshaller.d.ts

@@ -0,0 +1,60 @@
+export function wrapRemoteMarshallerSendSlotsOnly<Slot = unknown>(marshaller: ERemote<Pick<EMarshaller<Slot>, "fromCapData" | "toCapData">>, { serializeBodyFormat, errorTagging, ...otherMarshalOptions }?: MakeMarshalOptions, { valToSlot, slotToVal, cacheSeveredVal, }?: {
+    valToSlot?: WeakMapAPI<any, Slot> | null | undefined;
+    slotToVal?: WeakMapAPI<Slot, any> | null | undefined;
+    cacheSeveredVal?: boolean | undefined;
+}): ReturnType<typeof Far<EMarshaller<Slot>>>;
+export function wrapRemoteMarshallerDirectSend<Slot = unknown>(marshaller: ERemote<Pick<EMarshaller<Slot>, "fromCapData" | "toCapData">>): ReturnType<typeof Far<EMarshaller<Slot>>>;
+export function wrapRemoteMarshaller<Slot = unknown>(marshaller: ERemote<Pick<EMarshaller<Slot>, "fromCapData" | "toCapData">>, { serializeBodyFormat, errorTagging, ...otherMarshalOptions }?: MakeMarshalOptions, { valToSlot, slotToVal, cacheSeveredVal, }?: {
+    valToSlot?: WeakMapAPI<any, Slot> | null | undefined;
+    slotToVal?: WeakMapAPI<Slot, any> | null | undefined;
+    cacheSeveredVal?: boolean | undefined;
+}): ReturnType<typeof Far<EMarshaller<Slot>>>;
+/**
+ * A Marshaller which methods may be async. Use this type to indicate accepting
+ * either a sync or async marshaller, usually through `E` eventual-sends.
+ */
+export type EMarshaller<Slot = unknown> = Simplify<EOnly<Marshal<Slot>>>;
+export type InterfaceSpec = "Remotable" | `Alleged: ${string}`;
+export type RemotableSlotWrapper<Slot = unknown> = SlotWrapper<Slot> & PassStyled<"remotable", InterfaceSpec>;
+import type { ERemote } from '../types.js';
+import type { MakeMarshalOptions } from '@endo/marshal';
+import type { WeakMapAPI } from '@endo/cache-map';
+import { Far } from '@endo/far';
+import type { Marshal } from '@endo/marshal';
+import type { EOnly } from '@endo/eventual-send';
+import type { Simplify } from '@endo/pass-style';
+/**
+ * @import {WeakMapAPI} from '@endo/cache-map';
+ * @import {EOnly} from '@endo/eventual-send';
+ * @import {PassStyled, Simplify} from '@endo/pass-style';
+ * @import {CapData, Passable, Marshal, MakeMarshalOptions} from '@endo/marshal';
+ * @import {ERemote} from '../types.js';
+ */
+/**
+ * A Marshaller which methods may be async. Use this type to indicate accepting
+ * either a sync or async marshaller, usually through `E` eventual-sends.
+ *
+ * @template [Slot=unknown]
+ * @typedef {Simplify<EOnly<Marshal<Slot>>>} EMarshaller
+ */
+/** @typedef {'Remotable' | `Alleged: ${string}`} InterfaceSpec */
+/** @template [Slot=unknown] */
+declare class SlotWrapper<Slot = unknown> {
+    /**
+     * @template [Slot=unknown]
+     * @param {SlotWrapper<Slot>} wrapper
+     * @returns {Slot}
+     */
+    static getSlot<Slot_1 = unknown>(wrapper: SlotWrapper<Slot_1>): Slot_1;
+    /**
+     * @param {Slot} slot
+     * @param {string} [iface]
+     */
+    constructor(slot: Slot, iface?: string);
+    /** @type {InterfaceSpec} */
+    [Symbol.toStringTag]: InterfaceSpec;
+    #private;
+}
+import type { PassStyled } from '@endo/pass-style';
+export {};
+//# sourceMappingURL=wrap-marshaller.d.ts.map

package/src/marshal/wrap-marshaller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-marshaller.d.ts","sourceRoot":"","sources":["wrap-marshaller.js"],"names":[],"mappings":"AAqHO,kDATO,IAAI,wBACP,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC,CAAC,kEAC7D,kBAAkB,+CAE1B;IAAiD,SAAS;IACT,SAAS;IACjC,eAAe;CACxC,GAAU,UAAU,CAAC,OAAO,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CA4RrD;AAOM,+CAJO,IAAI,wBACP,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC,CAAC,GAC3D,UAAU,CAAC,OAAO,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAyBrD;AAxTM,qCATO,IAAI,wBACP,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC,CAAC,kEAC7D,kBAAkB,+CAE1B;IAAiD,SAAS;IACT,SAAS;IACjC,eAAe;CACxC,GAAU,UAAU,CAAC,OAAO,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CA4RrD;;;;;wBA1Xa,IAAI,cACL,SAAS,MAAM,QAAQ,IAAI,CAAC,CAAC,CAAC;4BAG7B,WAAW,GAAG,YAAY,MAAM,EAAE;iCAyClC,IAAI,cACL,WAAW,CAAC,IAAI,CAAC,GAAG,WAAW,WAAW,EAAE,aAAa,CAAC;6BArD7C,aAAa;wCAD0B,eAAe;gCAHnD,iBAAiB;oBAN1B,WAAW;6BASkC,eAAe;2BAFxD,qBAAqB;8BACN,kBAAkB;AAHzD;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH,kEAAkE;AAElE,+BAA+B;AAC/B,0BADe,IAAI;IAsBjB;;;;OAIG;IACH,0CAHW,WAAW,CAAC,MAAI,CAAC,GACf,MAAI,CAIhB;IArBD;;;OAGG;IACH,kBAHW,IAAI,UACJ,MAAM,EAUhB;IAfD,4BAA4B;IAC5B,sBADW,aAAa,CACsB;;CAwB/C;gCA7CsC,kBAAkB"}

package/src/method-tools.d.ts

@@ -0,0 +1,4 @@
+export function getMethodNames<K extends PropertyKey>(val: Record<K, any>): K[];
+export function getStringMethodNames<K extends PropertyKey>(val: Record<K, any>): string[];
+export function bindAllMethods<T extends Record<PropertyKey, any>>(obj: T): T;
+//# sourceMappingURL=method-tools.d.ts.map

package/src/method-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-tools.d.ts","sourceRoot":"","sources":["method-tools.js"],"names":[],"mappings":"AAmBO,+BAJoB,CAAC,SAAd,WAAY,OACf,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GACZ,CAAC,EAAE,CAG8B;AAUvC,qCAJoB,CAAC,SAAd,WAAY,OACf,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GACZ,MAAM,EAAE,CAKlB;AA+BI,+BAJiC,CAAC,SAA3B,MAAM,CAAC,WAAW,EAAE,GAAG,CAAE,OAC5B,CAAC,GACC,CAAC,CAiBX"}

package/src/metrics.d.ts

@@ -0,0 +1,183 @@
+export namespace HISTOGRAM_METRICS {
+    namespace swingset_crank_processing_time {
+        let description: "Processing time per crank (ms)";
+        let unit: "ms";
+        let boundaries: number[];
+    }
+    namespace swingset_block_processing_seconds {
+        let description_1: "Processing time per block";
+        export { description_1 as description };
+        let unit_1: "s";
+        export { unit_1 as unit };
+        export { HISTOGRAM_SECONDS_LATENCY_BOUNDARIES as boundaries };
+    }
+    namespace swingset_vat_startup {
+        let description_2: "Vat startup time (ms)";
+        export { description_2 as description };
+        let unit_2: "ms";
+        export { unit_2 as unit };
+        export { HISTOGRAM_MS_LATENCY_BOUNDARIES as boundaries };
+    }
+    namespace swingset_vat_delivery {
+        let description_3: "Vat delivery time (ms)";
+        export { description_3 as description };
+        let unit_3: "ms";
+        export { unit_3 as unit };
+        export { HISTOGRAM_MS_LATENCY_BOUNDARIES as boundaries };
+    }
+    namespace swingset_meter_usage {
+        let description_4: "Vat meter usage";
+        export { description_4 as description };
+        let unit_4: "ms";
+        export { unit_4 as unit };
+        export { HISTOGRAM_MS_LATENCY_BOUNDARIES as boundaries };
+    }
+}
+export namespace BLOCK_HISTOGRAM_METRICS {
+    namespace swingsetRunSeconds {
+        let unit_5: string;
+        export { unit_5 as unit };
+        export namespace advice {
+            let explicitBucketBoundaries: number[];
+        }
+        let description_5: "Per-block time spent executing SwingSet";
+        export { description_5 as description };
+    }
+    namespace swingsetChainSaveSeconds {
+        let unit_6: string;
+        export { unit_6 as unit };
+        export namespace advice_1 { }
+        export { advice_1 as advice };
+        let description_6: "Per-block time spent propagating SwingSet state into cosmos";
+        export { description_6 as description };
+    }
+    namespace swingsetCommitSeconds {
+        let unit_7: string;
+        export { unit_7 as unit };
+        export namespace advice_2 { }
+        export { advice_2 as advice };
+        let description_7: "Per-block time spent committing SwingSet state to host storage";
+        export { description_7 as description };
+    }
+    namespace cosmosCommitSeconds {
+        let unit_8: string;
+        export { unit_8 as unit };
+        export namespace advice_3 { }
+        export { advice_3 as advice };
+        let description_8: "Per-block time spent committing cosmos state";
+        export { description_8 as description };
+    }
+    namespace fullCommitSeconds {
+        let unit_9: string;
+        export { unit_9 as unit };
+        export namespace advice_4 { }
+        export { advice_4 as advice };
+        let description_9: "Per-block time spent committing state, inclusive of COMMIT_BLOCK processing plus time spent [outside of cosmic-swingset] before and after it";
+        export { description_9 as description };
+    }
+    namespace interBlockSeconds {
+        let unit_10: string;
+        export { unit_10 as unit };
+        export namespace advice_5 { }
+        export { advice_5 as advice };
+        let description_10: "Time spent idle between blocks";
+        export { description_10 as description };
+    }
+    namespace afterCommitHangoverSeconds {
+        let unit_11: string;
+        export { unit_11 as unit };
+        export namespace advice_6 { }
+        export { advice_6 as advice };
+        let description_11: "Per-block time spent waiting for previous-block afterCommit work";
+        export { description_11 as description };
+    }
+    namespace blockLagSeconds {
+        export namespace advice_7 {
+            let explicitBucketBoundaries_1: number[];
+            export { explicitBucketBoundaries_1 as explicitBucketBoundaries };
+        }
+        export { advice_7 as advice };
+        let unit_12: string;
+        export { unit_12 as unit };
+        let description_12: "The delay of each block from its expected begin time";
+        export { description_12 as description };
+    }
+}
+export type QueueMetricAspect = (typeof QueueMetricAspect)[keyof typeof QueueMetricAspect];
+export namespace QueueMetricAspect {
+    let Length: "length";
+    let IncrementCount: "increments";
+    let DecrementCount: "decrements";
+}
+export function makeQueueMetricsMeta(namePrefix: string, descPrefix: string): Record<QueueMetricAspect, {
+    name: string;
+    options: MetricAttributes;
+}>;
+export function makeQueueMetrics<QueueName extends string>({ otelMeter, namePrefix, descPrefix, console, }: {
+    otelMeter: OTelMeter;
+    namePrefix: string;
+    descPrefix: string;
+    console?: Pick<Console, "warn"> | undefined;
+}): QueueMetrics<QueueName>;
+/**
+ * @typedef KernelMetricMeta
+ * @property {string} key
+ * @property {string} name
+ * @property {{ dimension: string; value: string }} [sub]
+ * @property {string} description
+ * @property {boolean} [consensus]
+ * @property {MetricType} metricType
+ */
+/** @type {Omit<KernelMetricMeta, 'metricType'>[]} */
+export const KERNEL_STATS_SUM_METRICS: Omit<KernelMetricMeta, "metricType">[];
+/** @type {Omit<KernelMetricMeta, 'metricType'>[]} */
+export const KERNEL_STATS_UPDOWN_METRICS: Omit<KernelMetricMeta, "metricType">[];
+/** @type {KernelMetricMeta[]} */
+export const KERNEL_STATS_METRICS: KernelMetricMeta[];
+export type QueueMetrics<QueueName extends string> = {
+    /**
+     * must be
+     * called before any other function
+     */
+    initLengths: (lengths: Record<QueueName, number>) => void;
+    updateLengths: (lengths: Record<QueueName, number>) => void;
+    /**
+     * for a
+     * non-negative delta
+     */
+    incLength: (queue: QueueName, delta?: number) => void;
+    /**
+     * for a
+     * non-negative delta
+     */
+    decLength: (queue: QueueName, delta?: number) => void;
+};
+export type KernelMetricMeta = {
+    key: string;
+    name: string;
+    sub?: {
+        dimension: string;
+        value: string;
+    } | undefined;
+    description: string;
+    consensus?: boolean | undefined;
+    metricType: MetricType;
+};
+declare const HISTOGRAM_SECONDS_LATENCY_BOUNDARIES: number[];
+/**
+ * @import {Meter as OTelMeter, MetricAttributes} from '@opentelemetry/api';
+ * @import {TotalMap} from '@agoric/internal';
+ */
+declare const HISTOGRAM_MS_LATENCY_BOUNDARIES: number[];
+import type { MetricAttributes } from '@opentelemetry/api';
+import type { Meter as OTelMeter } from '@opentelemetry/api';
+/**
+ * MetricType
+ */
+type MetricType = (typeof MetricType)[keyof typeof MetricType];
+declare namespace MetricType {
+    let Counter: "counter";
+    let Gauge: "gauge";
+}
+export {};
+//# sourceMappingURL=metrics.d.ts.map

package/src/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["metrics.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAqH2C,MAAM,EAAE;;;;;;;;;;gCAQxC,CAAC,OAAO,iBAAiB,EAAE,MAAM,OAAO,iBAAiB,CAAC;;;;;;AAiB9D,iDAPI,MAAM,cACN,MAAM,GACJ,MAAM,CACd,iBAAiB,EACrB;IAAM,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,gBAAgB,CAAA;CAAE,CAC5C,CAoBH;AA0BM,iCARe,SAAS,SAAlB,MAAQ,mDAElB;IAA0B,SAAS,EAA3B,SAAS;IACM,UAAU,EAAzB,MAAM;IACS,UAAU,EAAzB,MAAM;IACyB,OAAO;CAC9C,GAAU,YAAY,CAAC,SAAS,CAAC,CA8GnC;AAQD;;;;;;;;GAQG;AACH,qDAAqD;AACrD,uCADW,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,EAAE,CAkF/C;AAEF,qDAAqD;AACrD,0CADW,IAAI,CAAC,gBAAgB,EAAE,YAAY,CAAC,EAAE,CA4D/C;AAGF,iCAAiC;AACjC,mCADW,gBAAgB,EAAE,CAI1B;yBA3SmB,SAAS,SAAlB,MAAQ;;;;;iBAEP,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,IAAI;mBAE5C,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,IAAI;;;;;eAC5C,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI;;;;;eAE1C,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,IAAI;;;SAsI1C,MAAM;UACN,MAAM;;mBACO,MAAM;eAAS,MAAM;;iBAClC,MAAM;;gBAEN,UAAU;;AAnRxB,6DACuD;AApBvD;;;GAGG;AAEH,wDAaE;sCAjBqD,oBAAoB;wCAApB,oBAAoB;;;;kBAyRhE,CAAC,OAAO,UAAU,EAAE,MAAM,OAAO,UAAU,CAAC"}

package/src/module-utils.d.ts

@@ -0,0 +1,3 @@
+export function getSpecifier(fileUrl: string): Promise<string>;
+export function resolveToPath(specifier: string, baseURL: string): string;
+//# sourceMappingURL=module-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module-utils.d.ts","sourceRoot":"","sources":["module-utils.js"],"names":[],"mappings":"AAcO,sCAHI,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAc3B;AAWM,yCAJI,MAAM,WACN,MAAM,GACJ,MAAM,CAMlB"}

package/src/natural-sort.d.ts

@@ -0,0 +1,2 @@
+export function naturalCompare(a: string, b: string): -1 | 0 | 1;
+//# sourceMappingURL=natural-sort.d.ts.map

package/src/natural-sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"natural-sort.d.ts","sourceRoot":"","sources":["natural-sort.js"],"names":[],"mappings":"AAgDO,kCAJI,MAAM,KACN,MAAM,GACJ,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAmCtB"}

package/src/netstring.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {Buffer} data
+ * @returns {Buffer} netstring-wrapped
+ */
+export function encode(data: Buffer): Buffer;
+export function netstringEncoderStream(): Transform;
+/**
+ * @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: Buffer, optMaxChunkSize?: number): {
+    leftover: Buffer;
+    payloads: Buffer[];
+};
+/**
+ * @param {number} [optMaxChunkSize]
+ * @returns {Transform}
+ */
+export function netstringDecoderStream(optMaxChunkSize?: number): Transform;
+import { Transform } from 'node:stream';
+//# sourceMappingURL=netstring.d.ts.map