@agoric/notifier 0.6.3-dev-fa844b5.0 → 0.6.3-dev-a477bee.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/notifier",
-  "version": "0.6.3-dev-fa844b5.0+fa844b5",
+  "version": "0.6.3-dev-a477bee.0+a477bee",
   "description": "Notifier allows services to update clients about state changes using a stream of promises",
   "type": "module",
   "main": "src/index.js",
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "build": "exit 0",
-    "prepack": "echo \"export {}; \" | cat - src/types-ambient.js > src/types.js && tsc --build --clean tsconfig.build.json",
+    "prepack": "echo \"export {}; \" | cat - src/types-ambient.js > src/types.js && tsc --build tsconfig.build.json",
     "postpack": "git clean -f '*.d.ts*' src/types.js",
     "test": "ava",
     "test:c8": "c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
@@ -33,19 +33,19 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-fa844b5.0+fa844b5",
-    "@agoric/internal": "0.3.3-dev-fa844b5.0+fa844b5",
-    "@agoric/vat-data": "0.5.3-dev-fa844b5.0+fa844b5",
+    "@agoric/assert": "0.6.1-dev-a477bee.0+a477bee",
+    "@agoric/internal": "0.3.3-dev-a477bee.0+a477bee",
+    "@agoric/vat-data": "0.5.3-dev-a477bee.0+a477bee",
     "@endo/far": "^1.1.0",
     "@endo/marshal": "^1.4.0",
     "@endo/patterns": "^1.3.0",
     "@endo/promise-kit": "^1.1.0"
   },
   "devDependencies": {
-    "@agoric/kmarshal": "0.1.1-dev-fa844b5.0+fa844b5",
-    "@agoric/swing-store": "0.9.2-dev-fa844b5.0+fa844b5",
-    "@agoric/swingset-liveslots": "0.10.3-dev-fa844b5.0+fa844b5",
-    "@agoric/swingset-vat": "0.32.3-dev-fa844b5.0+fa844b5",
+    "@agoric/kmarshal": "0.1.1-dev-a477bee.0+a477bee",
+    "@agoric/swing-store": "0.9.2-dev-a477bee.0+a477bee",
+    "@agoric/swingset-liveslots": "0.10.3-dev-a477bee.0+a477bee",
+    "@agoric/swingset-vat": "0.32.3-dev-a477bee.0+a477bee",
     "@endo/init": "^1.1.0",
     "@endo/ses-ava": "^1.2.0",
     "ava": "^5.3.0",
@@ -78,5 +78,5 @@
   "typeCoverage": {
     "atLeast": 89.76
   },
-  "gitHead": "fa844b51a10ab02af61af19207c164c99c2d8d8c"
+  "gitHead": "a477bee3be6e0e98b9346c0640380e276cf8423e"
 }

package/src/asyncIterableAdaptor.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @deprecated Use `subscribeLatest` from `@agoric/notifier/subscribe.js` instead.
+ *
+ * Adaptor from a notifierP to an async iterable.
+ * The notifierP can be any object that has an eventually invocable
+ * `getUpdateSince` method that behaves according to the notifier
+ * spec. This can be a notifier, a promise for a local or remote
+ * notifier, or a presence of a remote notifier.
+ *
+ * It is also used internally by notifier.js so that a notifier itself is an
+ * async iterable.
+ *
+ * An async iterable is an object with a `[Symbol.asyncIterator]()` method
+ * that returns an async iterator. The async iterator we return here has only
+ * a `next()` method, without the optional `return` and `throw` methods. The
+ * omitted methods, if present, would be used by the for/await/of loop to
+ * inform the iterator of early termination. But this adaptor would not do
+ * anything useful in reaction to this notification.
+ *
+ * An async iterator's `next()` method returns a promise for an iteration
+ * result. An iteration result is a record with `value` and `done` properties.
+ *
+ * The purpose of building on the notifier protocol is to have a lossy
+ * adaptor, where intermediate results can be missed in favor of more recent
+ * results which are therefore less stale. See
+ * https://github.com/Agoric/documentation/blob/HEAD/main/guides/js-programming/notifiers.md
+ *
+ * @template T
+ * @param {ERef<BaseNotifier<T>>} notifierP
+ * @returns {ForkableAsyncIterable<T>}
+ */
+export const makeAsyncIterableFromNotifier: <T_1>(topic: ERef<LatestTopic<T_1>>) => {
+    [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T_1, T_1, undefined>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T_1, T_1, undefined>;
+}>;
+export function observeIterator<T_1>(asyncIteratorP: ERef<AsyncIterator<T_1, any, undefined>>, iterationObserver: Partial<IterationObserver<T_1>>): Promise<undefined>;
+export function observeIteration<T_1>(asyncIterableP: ERef<AsyncIterable<T_1>>, iterationObserver: Partial<IterationObserver<T_1>>): Promise<undefined>;
+export function observeNotifier<T_1>(notifierP: ERef<LatestTopic<T_1>>, iterationObserver: Partial<IterationObserver<T_1>>): Promise<undefined>;
+//# sourceMappingURL=asyncIterableAdaptor.d.ts.map

package/src/asyncIterableAdaptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncIterableAdaptor.d.ts","sourceRoot":"","sources":["asyncIterableAdaptor.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;;;;GAA6D;AAatD,oJAFM,QAAQ,SAAS,CAAC,CAyB9B;AAaM,qIAFM,QAAQ,SAAS,CAAC,CAK9B;AAaM,6HAFM,QAAQ,SAAS,CAAC,CAGkC"}

package/src/index.d.ts

@@ -0,0 +1,9 @@
+export { makePinnedHistoryTopic } from "./topic.js";
+export * from "./storesub.js";
+export * from "./stored-notifier.js";
+export { makePublishKit, prepareDurablePublishKit, ForkableAsyncIterableIteratorShape, IterableEachTopicI, IterableLatestTopicI, SubscriberShape } from "./publish-kit.js";
+export { subscribeEach, subscribeLatest } from "./subscribe.js";
+export { makeNotifier, makeNotifierKit, makeNotifierFromAsyncIterable, makeNotifierFromSubscriber } from "./notifier.js";
+export { makeSubscription, makeSubscriptionKit } from "./subscriber.js";
+export { observeNotifier, observeIterator, observeIteration, makeAsyncIterableFromNotifier } from "./asyncIterableAdaptor.js";
+//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

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

package/src/notifier.d.ts

@@ -0,0 +1,5 @@
+export function makeNotifier<T>(sharableInternalsP: ERef<LatestTopic<T>>): Notifier<T>;
+export function makeNotifierFromSubscriber<T>(subscriber: ERef<Subscriber<T>>): Notifier<T>;
+export function makeNotifierKit<T>(...initialStateArr: [] | [T]): NotifierRecord<T>;
+export function makeNotifierFromAsyncIterable<T>(asyncIterableP: ERef<AsyncIterable<T>>): Notifier<T>;
+//# sourceMappingURL=notifier.d.ts.map

package/src/notifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifier.d.ts","sourceRoot":"","sources":["notifier.js"],"names":[],"mappings":"AAcO,uFAsBN;AAOM,4FAeN;AAoBM,oFAoBN;AAcM,sGAqEN"}

package/src/publish-kit.d.ts

@@ -0,0 +1,60 @@
+export const PublisherI: import("@endo/patterns").InterfaceGuard<{
+    publish: import("@endo/patterns").MethodGuard;
+    finish: import("@endo/patterns").MethodGuard;
+    fail: import("@endo/patterns").MethodGuard;
+}>;
+export const UpdateCountShape: import("@endo/patterns").Matcher;
+export const SubscriberI: import("@endo/patterns").InterfaceGuard<{
+    subscribeAfter: import("@endo/patterns").MethodGuard;
+    getUpdateSince: import("@endo/patterns").MethodGuard;
+}>;
+export namespace publishKitIKit {
+    export { PublisherI as publisher };
+    export { SubscriberI as subscriber };
+}
+export const ForkableAsyncIterableIteratorShape: import("@endo/patterns").InterfaceGuard<{
+    fork: import("@endo/patterns").MethodGuard;
+    [Symbol.asyncIterator]: import("@endo/patterns").MethodGuard;
+    next: import("@endo/patterns").MethodGuard;
+}>;
+export const IterableEachTopicI: import("@endo/patterns").InterfaceGuard<{
+    subscribeAfter: import("@endo/patterns").MethodGuard;
+    [Symbol.asyncIterator]: import("@endo/patterns").MethodGuard;
+}>;
+export const IterableLatestTopicI: import("@endo/patterns").InterfaceGuard<{
+    getUpdateSince: import("@endo/patterns").MethodGuard;
+    [Symbol.asyncIterator]: import("@endo/patterns").MethodGuard;
+}>;
+export function makePublishKit<T>(): PublishKit<T>;
+export function prepareDurablePublishKit(baggage: MapStore<string, any>, kindName: string): (options?: {
+    valueDurability?: "mandatory" | undefined;
+} | undefined) => import("@endo/exo").GuardedKit<{
+    publisher: {
+        publish(value: any): void;
+        finish(finalValue: any): void;
+        fail(reason: any): void;
+    };
+    subscriber: {
+        subscribeAfter(publishCount?: bigint): Promise<any>;
+        getUpdateSince(updateCount: any): any;
+    };
+}>;
+export const SubscriberShape: import("@endo/patterns").Matcher;
+export type DurablePublishKitEphemeralKey = Publisher<any>;
+export type DurablePublishKitEphemeralData = {
+    /**
+     * The current-result promise
+     * (undefined unless resolved with unrecoverable ephemeral data)
+     */
+    currentP: Promise<any> | undefined;
+    /**
+     * The next-result promise
+     */
+    tailP: Promise<any>;
+    /**
+     * The next-result resolver
+     * (undefined when the publish kit has terminated)
+     */
+    tailR: ((value: any) => void) | undefined;
+};
+//# sourceMappingURL=publish-kit.d.ts.map

package/src/publish-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-kit.d.ts","sourceRoot":"","sources":["publish-kit.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AAGH,gEAA6D;AAC7D;;;GAGG;;;;;AAMH;;;;GAOE;AAEF;;;GAMG;AAEH;;;GAMG;AA+CI,mDA0FN;AA6MM,mFAFI,MAAM;;;;;;;;;;;;GA2EhB;AAGD,+DAAyD;4CAlP3C,cAAY;;;;;;cASZ,YAAU,GAAG,SAAS;;;;WAEtB,YAAU;;;;;WACV,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,SAAS"}

package/src/stored-notifier.d.ts

@@ -0,0 +1,3 @@
+export function makeStoredNotifier<T>(notifier: ERef<Notifier<T>>, storageNode: ERef<StorageNode>, marshaller: ERef<Marshaller<unknown>>): StoredNotifier<T>;
+export type StoredNotifier<T> = BaseNotifier<T> & Omit<StoredFacet, 'getStoreKey'>;
+//# sourceMappingURL=stored-notifier.d.ts.map

package/src/stored-notifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-notifier.d.ts","sourceRoot":"","sources":["stored-notifier.js"],"names":[],"mappings":"AA2BO,6JA+BN;gCAjDY,aAAa,CAAC,CAAC,GAAG,KAAK,WAAW,EAAE,aAAa,CAAC"}

package/src/storesub.d.ts

@@ -0,0 +1,21 @@
+export function forEachPublicationRecord<T>(subscriber: Subscriber<T>, consumeValue: (v: T) => void): Promise<void>;
+export function makeStoredSubscriber<T>(subscriber: Subscriber<T>, storageNode: ERef<StorageNode>, marshaller: ERef<{
+    toCapData: import("../../../node_modules/@endo/marshal/src/marshal.js").ToCapData<unknown>;
+    fromCapData: import("../../../node_modules/@endo/marshal/src/marshal.js").FromCapData<unknown>;
+    serialize: import("../../../node_modules/@endo/marshal/src/marshal.js").ToCapData<unknown>;
+    unserialize: import("../../../node_modules/@endo/marshal/src/marshal.js").FromCapData<unknown>;
+}>): StoredSubscriber<T>;
+export function makeStoredSubscription<T>(subscription: Subscription<T>, storageNode?: ERef<StorageNode> | undefined, marshaller?: ERef<{
+    toCapData: import("../../../node_modules/@endo/marshal/src/marshal.js").ToCapData<unknown>;
+    fromCapData: import("../../../node_modules/@endo/marshal/src/marshal.js").FromCapData<unknown>;
+    serialize: import("../../../node_modules/@endo/marshal/src/marshal.js").ToCapData<unknown>;
+    unserialize: import("../../../node_modules/@endo/marshal/src/marshal.js").FromCapData<unknown>;
+}> | undefined): StoredSubscription<T>;
+export function makeStoredPublisherKit<T = unknown>(storageNode?: ERef<StorageNode> | undefined, marshaller?: ERef<Marshaller<unknown>> | undefined, childPath?: string | undefined): StoredPublisherKit<T>;
+export function makeStoredPublishKit<T = unknown>(storageNode: ERef<StorageNode>, marshaller: ERef<Marshaller<unknown>>): StoredPublishKit<T>;
+export type StoredPublisherKit<T> = {
+    subscriber: StoredSubscription<T>;
+    publisher: IterationObserver<T>;
+};
+import { makeMarshal } from '@endo/marshal';
+//# sourceMappingURL=storesub.d.ts.map

package/src/storesub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storesub.d.ts","sourceRoot":"","sources":["storesub.js"],"names":[],"mappings":"AAiBO,+FAFc,IAAI,iBAcxB;AAiBM;;;;;yBA2BN;AAkBM;;;;;uCAmEN;AAoBM,4MAkBN;AAgBM,8IAQN;;gBAvDa,mBAAmB,CAAC,CAAC;eACrB,kBAAkB,CAAC,CAAC;;4BArKN,eAAe"}

package/src/subscribe.d.ts

@@ -0,0 +1,28 @@
+export function subscribe<T>(itP: ERef<AsyncIterableIterator<T>>): {
+    [Symbol.asyncIterator]: () => {
+        [Symbol.asyncIterator]: () => any & import("@endo/eventual-send").RemotableBrand<{}, any>;
+        next: () => Promise<IteratorResult<T, any>>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        [Symbol.asyncIterator]: () => any & import("@endo/eventual-send").RemotableBrand<{}, any>;
+        next: () => Promise<IteratorResult<T, any>>;
+    }>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    [Symbol.asyncIterator]: () => {
+        [Symbol.asyncIterator]: () => any & import("@endo/eventual-send").RemotableBrand<{}, any>;
+        next: () => Promise<IteratorResult<T, any>>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        [Symbol.asyncIterator]: () => any & import("@endo/eventual-send").RemotableBrand<{}, any>;
+        next: () => Promise<IteratorResult<T, any>>;
+    }>;
+}>;
+export function subscribeEach<T>(topic: ERef<EachTopic<T>>): {
+    [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T, T, undefined>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T, T, undefined>;
+}>;
+export function subscribeLatest<T>(topic: ERef<LatestTopic<T>>): {
+    [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T, T, undefined>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T, T, undefined>;
+}>;
+//# sourceMappingURL=subscribe.d.ts.map

package/src/subscribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["subscribe.js"],"names":[],"mappings":"AAkEO;;;;;;;;;;;;;;;;GAUH;AAuEG;;;;GAQN;AAsGM;;;;GAKN"}

package/src/subscriber.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @template T
+ * @param {ERef<EachTopic<T>>} topic
+ * @returns {Subscription<T>}
+ */
+export function makeSubscription<T>(topic: ERef<EachTopic<T>>): Subscription<T>;
+/**
+ * @deprecated Producers should use
+ * ```js
+ * const { publisher, subscriber } = makePublishKit();
+ * const topic = makePinnedHistoryTopic(subscriber);
+ * ```
+ * instead, which makes it clearer that all the subscriber's history is
+ * retained, preventing GC.  Potentially remote consumers use
+ * ```js
+ * for await (const value of subscribeEach(topic)) { ... }
+ * ```
+ *
+ * Makes a `{ publication, subscription }` for doing lossless efficient
+ * distributed pub/sub.
+ *
+ * @template T
+ * @returns {SubscriptionRecord<T>}
+ */
+export function makeSubscriptionKit<T>(): SubscriptionRecord<T>;
+//# sourceMappingURL=subscriber.d.ts.map

package/src/subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriber.d.ts","sourceRoot":"","sources":["subscriber.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,gFAgBC;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,gEAiBC"}

package/src/topic.d.ts

@@ -0,0 +1,2 @@
+export function makePinnedHistoryTopic<T>(topic: EachTopic<T> & LatestTopic<T>): EachTopic<T> & LatestTopic<T>;
+//# sourceMappingURL=topic.d.ts.map

package/src/topic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"topic.d.ts","sourceRoot":"","sources":["topic.js"],"names":[],"mappings":"AAcO,+GAkBN"}

package/src/types-ambient.d.ts

@@ -0,0 +1,298 @@
+/**
+ * An AsyncIterator that can be forked at a given position
+ * into multiple independent ForkableAsyncIterators starting from that position.
+ */
+type ForkableAsyncIterator<T, TReturn = any, TNext = undefined> = AsyncIterator<T, TReturn, TNext> & {
+    fork(): ForkableAsyncIterator<T, TReturn, TNext>;
+};
+type AsyncIterableOnly<T, TReturn = any, TNext = undefined> = {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
+};
+type ForkableAsyncIterableIterator<T, TReturn = any, TNext = undefined> = {
+    [Symbol.asyncIterator](): ForkableAsyncIterableIterator<T, TReturn, TNext>;
+    fork(): ForkableAsyncIterableIterator<T, TReturn, TNext>;
+} & ForkableAsyncIterator<T, TReturn, TNext>;
+/**
+ * An AsyncIterable that produces ForkableAsyncIterators.
+ */
+type ForkableAsyncIterable<T, TReturn = any, TNext = undefined> = {
+    [Symbol.asyncIterator]: () => ForkableAsyncIterator<T, TReturn, TNext>;
+};
+/**
+ * <T>
+ * A valid sequence of calls to the methods of an `IterationObserver`
+ * represents an iteration. A valid sequence consists of any number of calls
+ * to `updateState` with the successive non-final values, followed by a
+ * final call to either `finish` with a successful `completion` value
+ * or `fail` with the alleged `reason` for failure. After at most one
+ * terminating calls, no further calls to these methods are valid and must be
+ * rejected.
+ */
+type IterationObserver<T> = {
+    updateState: (nonFinalValue: T) => void;
+    finish: (completion: T) => void;
+    fail: (reason: unknown) => void;
+};
+/**
+ * Will be shared between machines, so it must be safe to expose. But software
+ * outside the current package should consider it opaque, not depending on its
+ * internal structure.
+ */
+type PublicationRecord<T> = {
+    head: IteratorResult<T>;
+    /**
+     * starts at 1 for the first result
+     * and advances by 1 for each subsequent result
+     */
+    publishCount: bigint;
+    tail: Promise<PublicationRecord<T>>;
+};
+type EachTopic<T> = {
+    /**
+     * Returns a promise for a "current" PublicationRecord (referencing its
+     * immediate successor via a `tail` promise) that is later than the
+     * provided publishCount.
+     * Used to make forward-lossless ("each") iterators.
+     */
+    subscribeAfter: (publishCount?: bigint) => Promise<PublicationRecord<T>>;
+};
+/**
+ * An EachTopic with default asyncIterable behaviour.
+ *
+ * NOTE: the publication records and iterators returned by this object are
+ * ephemeral and will be severed during upgrade.  A caller should use
+ * `subscribeEach` to wrap this topic in a local iterable which automatically
+ * attempts to reconnect upon being severed.
+ */
+type IterableEachTopic<T> = ForkableAsyncIterable<T, T> & EachTopic<T>;
+/**
+ * A LatestTopic with default asyncIterable behaviour.
+ *
+ * NOTE: the iterators returned by this object are ephemeral and will be severed
+ * during upgrade.  A caller should use `subscribeLatest` to wrap this topic in
+ * a local iterable which automatically attempts to reconnect upon being
+ * severed.
+ */
+type IterableLatestTopic<T> = AsyncIterableOnly<T, T> & LatestTopic<T>;
+type LatestTopic<T> = {
+    /**
+     * Returns a promise for an update record as of an update count.
+     * If the `updateCount` argument is omitted or differs from the current update count,
+     * the promise promptly resolves to the current record.
+     * Otherwise, after the next state change, the promise resolves to the resulting record.
+     * This is an attenuated form of `subscribeAfter` whose return value stands alone and
+     * does not allow consumers to pin a chain of historical PublicationRecords.
+     * Used to make lossy ("latest") iterators.
+     * NOTE: Use of `number` as an `updateCount` is deprecated.
+     */
+    getUpdateSince: (updateCount?: bigint | number) => Promise<UpdateRecord<T>>;
+};
+/**
+ * This type is deprecated but is still
+ * used externally.
+ */
+type BaseNotifier<T> = LatestTopic<T>;
+/**
+ * A stream of results that allows consumers to configure
+ * forward-lossless "each" iteration with `subscribeEach` and
+ * lossy "latest" iteration with `subscribeLatest`.
+ */
+type Subscriber<T> = LatestTopic<T> & EachTopic<T>;
+/**
+ * A valid sequence of calls to the methods of an `IterationObserver`
+ * represents an iteration. A valid sequence consists of any number of calls
+ * to `publish` with the successive non-final values, followed by a
+ * final call to either `finish` with a successful `completion` value
+ * or `fail` with the alleged `reason` for failure. After at most one
+ * terminating calls, no further calls to these methods are valid and must be
+ * rejected.
+ */
+type Publisher<T> = {
+    publish: (nonFinalValue: T) => void;
+    finish: (completion: T) => void;
+    fail: (reason: any) => void;
+};
+type PublishObserver<T> = Partial<Publisher<T>>;
+/**
+ * <T>
+ */
+type PublishKit<T> = {
+    publisher: Publisher<T>;
+    subscriber: Subscriber<T>;
+};
+/**
+ * <T>
+ */
+type StoredPublishKit<T> = {
+    publisher: Publisher<T>;
+    subscriber: StoredSubscriber<T>;
+};
+/**
+ * Durability configures constraints on non-terminal values that can be
+ * published to a durable publish kit (terminal values sent to finish or fail
+ * must always be durable).
+ * - 'mandatory' means that each value must be durable, so it can be restored
+ *   on upgrade.
+ * - 'opportunistic' means that a durable value is persisted for post-upgrade
+ *   restoration, but a non-durable value is still accepted (and will result in
+ *   valueless restoration).
+ * - 'ignored' means that a value is not persisted for restoration even if it
+ *   is durable.
+ *
+ * 'mandatory' is the only currently-supported value, and others must not be
+ * enabled without test coverage.
+ */
+type DurablePublishKitValueDurability = 'mandatory' | 'opportunistic' | 'ignored';
+type DurablePublishKitState = {
+    valueDurability: DurablePublishKitValueDurability;
+    publishCount: bigint;
+    status: 'live' | 'finished' | 'failed';
+    /**
+     * hasValue indicates the presence of value. It starts off false,
+     * and can be reset to false when a durable publish kit is restored and
+     * the previous value was not durable, or non-terminal and valueDurablity is 'ignored'.
+     */
+    hasValue: boolean;
+    /**
+     * value holds either a non-terminal value from `publish` or a terminal value
+     * from `finish` or `fail`, depending upon the value in status.
+     */
+    value: any;
+};
+/**
+ * <T>
+ */
+type UpdateRecord<T> = {
+    /**
+     * is whatever state the service wants to publish
+     */
+    value: T;
+    /**
+     * is a value that identifies the update.  For
+     * the last update, it is `undefined`.
+     */
+    updateCount?: bigint | undefined;
+};
+/**
+ * Will be shared between machines,
+ * so it must be safe to expose. But other software should avoid depending on
+ * its internal structure.
+ */
+type NotifierInternals<T> = BaseNotifier<T>;
+/**
+ * <T> an object that can be used to get the current state or updates
+ */
+type Notifier<T> = NotifierInternals<T> & ForkableAsyncIterable<T, T> & SharableNotifier<T>;
+type SharableNotifier<T> = {
+    /**
+     * Used to replicate the multicast values at other sites. To manually create a
+     * local representative of a Notification, do
+     * ```js
+     * localIterable =
+     *   makeNotifier(E(remoteIterable).getSharableNotifierInternals());
+     * ```
+     * The resulting `localIterable` also supports such remote use, and
+     * will return access to the same representation.
+     */
+    getSharableNotifierInternals: () => Promise<NotifierInternals<T>>;
+};
+/**
+ * <T> the produced notifier/updater pair
+ */
+type NotifierRecord<T> = {
+    /**
+     * the (closely-held) notifier producer
+     */
+    updater: IterationObserver<T>;
+    /**
+     * the (widely-held) notifier consumer
+     */
+    notifier: Notifier<T>;
+};
+/**
+ * <T>
+ * A form of AsyncIterable supporting distributed and multicast usage.
+ */
+type Subscription<T> = IterableEachTopic<T> & EachTopic<T> & SharableSubscription<T>;
+type SharableSubscription<T> = {
+    /**
+     * Used to replicate the multicast values at other sites. To manually create a
+     * local representative of a Subscription, do
+     * ```js
+     * localIterable =
+     *   makeSubscription(E(remoteIterable).getSharableSubscriptionInternals());
+     * ```
+     * The resulting `localIterable` also supports such remote use, and
+     * will return access to the same representation.
+     */
+    getSharableSubscriptionInternals: () => Promise<EachTopic<T>>;
+};
+/**
+ * <T>
+ */
+type SubscriptionRecord<T> = {
+    publication: IterationObserver<T>;
+    subscription: Subscription<T>;
+};
+type Marshaller<Slot = unknown> = import('@endo/marshal').Marshal<Slot>;
+type Unserializer = Pick<Marshaller, 'fromCapData'>;
+/**
+ * Defined by vstorageStoreKey in vstorage.go
+ */
+type VStorageKey = {
+    storeName: string;
+    storeSubkey: string;
+    dataPrefixBytes: string;
+    noDataValue?: string | undefined;
+};
+/**
+ * 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.
+ */
+type StorageNode = {
+    /**
+     * publishes some data (append to the node)
+     */
+    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;
+};
+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;
+};
+type StoredSubscription<T> = Subscription<T> & {
+    getStoreKey: () => Promise<VStorageKey & {
+        subscription: Subscription<T>;
+    }>;
+    getUnserializer: () => Unserializer;
+};
+type StoredSubscriber<T> = Subscriber<T> & StoredFacet;
+import type { ERef } from '@endo/far';
+import type { PromiseKit } from '@endo/promise-kit';
+import type { PromiseRecord } from '@endo/promise-kit';
+//# sourceMappingURL=types-ambient.d.ts.map

package/src/types-ambient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":"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"}

package/src/types.d.ts

@@ -0,0 +1,295 @@
+/**
+ * An AsyncIterator that can be forked at a given position
+ * into multiple independent ForkableAsyncIterators starting from that position.
+ */
+export type ForkableAsyncIterator<T, TReturn = any, TNext = undefined> = AsyncIterator<T, TReturn, TNext> & {
+    fork(): ForkableAsyncIterator<T, TReturn, TNext>;
+};
+export type AsyncIterableOnly<T, TReturn = any, TNext = undefined> = {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
+};
+export type ForkableAsyncIterableIterator<T, TReturn = any, TNext = undefined> = {
+    [Symbol.asyncIterator](): ForkableAsyncIterableIterator<T, TReturn, TNext>;
+    fork(): ForkableAsyncIterableIterator<T, TReturn, TNext>;
+} & ForkableAsyncIterator<T, TReturn, TNext>;
+/**
+ * An AsyncIterable that produces ForkableAsyncIterators.
+ */
+export type ForkableAsyncIterable<T, TReturn = any, TNext = undefined> = {
+    [Symbol.asyncIterator]: () => ForkableAsyncIterator<T, TReturn, TNext>;
+};
+/**
+ * <T>
+ * A valid sequence of calls to the methods of an `IterationObserver`
+ * represents an iteration. A valid sequence consists of any number of calls
+ * to `updateState` with the successive non-final values, followed by a
+ * final call to either `finish` with a successful `completion` value
+ * or `fail` with the alleged `reason` for failure. After at most one
+ * terminating calls, no further calls to these methods are valid and must be
+ * rejected.
+ */
+export type IterationObserver<T> = {
+    updateState: (nonFinalValue: T) => void;
+    finish: (completion: T) => void;
+    fail: (reason: unknown) => void;
+};
+/**
+ * Will be shared between machines, so it must be safe to expose. But software
+ * outside the current package should consider it opaque, not depending on its
+ * internal structure.
+ */
+export type PublicationRecord<T> = {
+    head: IteratorResult<T>;
+    /**
+     * starts at 1 for the first result
+     * and advances by 1 for each subsequent result
+     */
+    publishCount: bigint;
+    tail: Promise<PublicationRecord<T>>;
+};
+export type EachTopic<T> = {
+    /**
+     * Returns a promise for a "current" PublicationRecord (referencing its
+     * immediate successor via a `tail` promise) that is later than the
+     * provided publishCount.
+     * Used to make forward-lossless ("each") iterators.
+     */
+    subscribeAfter: (publishCount?: bigint) => Promise<PublicationRecord<T>>;
+};
+/**
+ * An EachTopic with default asyncIterable behaviour.
+ *
+ * NOTE: the publication records and iterators returned by this object are
+ * ephemeral and will be severed during upgrade.  A caller should use
+ * `subscribeEach` to wrap this topic in a local iterable which automatically
+ * attempts to reconnect upon being severed.
+ */
+export type IterableEachTopic<T> = ForkableAsyncIterable<T, T> & EachTopic<T>;
+/**
+ * A LatestTopic with default asyncIterable behaviour.
+ *
+ * NOTE: the iterators returned by this object are ephemeral and will be severed
+ * during upgrade.  A caller should use `subscribeLatest` to wrap this topic in
+ * a local iterable which automatically attempts to reconnect upon being
+ * severed.
+ */
+export type IterableLatestTopic<T> = AsyncIterableOnly<T, T> & LatestTopic<T>;
+export type LatestTopic<T> = {
+    /**
+     * Returns a promise for an update record as of an update count.
+     * If the `updateCount` argument is omitted or differs from the current update count,
+     * the promise promptly resolves to the current record.
+     * Otherwise, after the next state change, the promise resolves to the resulting record.
+     * This is an attenuated form of `subscribeAfter` whose return value stands alone and
+     * does not allow consumers to pin a chain of historical PublicationRecords.
+     * Used to make lossy ("latest") iterators.
+     * NOTE: Use of `number` as an `updateCount` is deprecated.
+     */
+    getUpdateSince: (updateCount?: bigint | number) => Promise<UpdateRecord<T>>;
+};
+/**
+ * This type is deprecated but is still
+ * used externally.
+ */
+export type BaseNotifier<T> = LatestTopic<T>;
+/**
+ * A stream of results that allows consumers to configure
+ * forward-lossless "each" iteration with `subscribeEach` and
+ * lossy "latest" iteration with `subscribeLatest`.
+ */
+export type Subscriber<T> = LatestTopic<T> & EachTopic<T>;
+/**
+ * A valid sequence of calls to the methods of an `IterationObserver`
+ * represents an iteration. A valid sequence consists of any number of calls
+ * to `publish` with the successive non-final values, followed by a
+ * final call to either `finish` with a successful `completion` value
+ * or `fail` with the alleged `reason` for failure. After at most one
+ * terminating calls, no further calls to these methods are valid and must be
+ * rejected.
+ */
+export type Publisher<T> = {
+    publish: (nonFinalValue: T) => void;
+    finish: (completion: T) => void;
+    fail: (reason: any) => void;
+};
+export type PublishObserver<T> = Partial<Publisher<T>>;
+/**
+ * <T>
+ */
+export type PublishKit<T> = {
+    publisher: Publisher<T>;
+    subscriber: Subscriber<T>;
+};
+/**
+ * <T>
+ */
+export type StoredPublishKit<T> = {
+    publisher: Publisher<T>;
+    subscriber: StoredSubscriber<T>;
+};
+/**
+ * Durability configures constraints on non-terminal values that can be
+ * published to a durable publish kit (terminal values sent to finish or fail
+ * must always be durable).
+ * - 'mandatory' means that each value must be durable, so it can be restored
+ *   on upgrade.
+ * - 'opportunistic' means that a durable value is persisted for post-upgrade
+ *   restoration, but a non-durable value is still accepted (and will result in
+ *   valueless restoration).
+ * - 'ignored' means that a value is not persisted for restoration even if it
+ *   is durable.
+ *
+ * 'mandatory' is the only currently-supported value, and others must not be
+ * enabled without test coverage.
+ */
+export type DurablePublishKitValueDurability = 'mandatory' | 'opportunistic' | 'ignored';
+export type DurablePublishKitState = {
+    valueDurability: DurablePublishKitValueDurability;
+    publishCount: bigint;
+    status: 'live' | 'finished' | 'failed';
+    /**
+     * hasValue indicates the presence of value. It starts off false,
+     * and can be reset to false when a durable publish kit is restored and
+     * the previous value was not durable, or non-terminal and valueDurablity is 'ignored'.
+     */
+    hasValue: boolean;
+    /**
+     * value holds either a non-terminal value from `publish` or a terminal value
+     * from `finish` or `fail`, depending upon the value in status.
+     */
+    value: any;
+};
+/**
+ * <T>
+ */
+export type UpdateRecord<T> = {
+    /**
+     * is whatever state the service wants to publish
+     */
+    value: T;
+    /**
+     * is a value that identifies the update.  For
+     * the last update, it is `undefined`.
+     */
+    updateCount?: bigint | undefined;
+};
+/**
+ * Will be shared between machines,
+ * so it must be safe to expose. But other software should avoid depending on
+ * its internal structure.
+ */
+export type NotifierInternals<T> = BaseNotifier<T>;
+/**
+ * <T> an object that can be used to get the current state or updates
+ */
+export type Notifier<T> = NotifierInternals<T> & ForkableAsyncIterable<T, T> & SharableNotifier<T>;
+export type SharableNotifier<T> = {
+    /**
+     * Used to replicate the multicast values at other sites. To manually create a
+     * local representative of a Notification, do
+     * ```js
+     * localIterable =
+     *   makeNotifier(E(remoteIterable).getSharableNotifierInternals());
+     * ```
+     * The resulting `localIterable` also supports such remote use, and
+     * will return access to the same representation.
+     */
+    getSharableNotifierInternals: () => Promise<NotifierInternals<T>>;
+};
+/**
+ * <T> the produced notifier/updater pair
+ */
+export type NotifierRecord<T> = {
+    /**
+     * the (closely-held) notifier producer
+     */
+    updater: IterationObserver<T>;
+    /**
+     * the (widely-held) notifier consumer
+     */
+    notifier: Notifier<T>;
+};
+/**
+ * <T>
+ * A form of AsyncIterable supporting distributed and multicast usage.
+ */
+export type Subscription<T> = IterableEachTopic<T> & EachTopic<T> & SharableSubscription<T>;
+export type SharableSubscription<T> = {
+    /**
+     * Used to replicate the multicast values at other sites. To manually create a
+     * local representative of a Subscription, do
+     * ```js
+     * localIterable =
+     *   makeSubscription(E(remoteIterable).getSharableSubscriptionInternals());
+     * ```
+     * The resulting `localIterable` also supports such remote use, and
+     * will return access to the same representation.
+     */
+    getSharableSubscriptionInternals: () => Promise<EachTopic<T>>;
+};
+/**
+ * <T>
+ */
+export type SubscriptionRecord<T> = {
+    publication: IterationObserver<T>;
+    subscription: Subscription<T>;
+};
+export type Marshaller<Slot = unknown> = import('@endo/marshal').Marshal<Slot>;
+export type Unserializer = Pick<Marshaller, 'fromCapData'>;
+/**
+ * Defined by vstorageStoreKey in vstorage.go
+ */
+export type VStorageKey = {
+    storeName: string;
+    storeSubkey: string;
+    dataPrefixBytes: string;
+    noDataValue?: string | undefined;
+};
+/**
+ * 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 (append to the node)
+     */
+    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;
+};
+export type StoredSubscription<T> = Subscription<T> & {
+    getStoreKey: () => Promise<VStorageKey & {
+        subscription: Subscription<T>;
+    }>;
+    getUnserializer: () => Unserializer;
+};
+export type StoredSubscriber<T> = Subscriber<T> & StoredFacet;
+//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"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"}

package/tools/testSupports.d.ts

@@ -0,0 +1,11 @@
+export { eventLoopIteration } from "@agoric/internal/src/testing-utils.js";
+export function makeFakeStorage(path: string, publication?: IterationObserver<unknown> | undefined): StorageNode & {
+    countSetValueCalls: () => number;
+};
+export function makeFakeMarshaller(): {
+    toCapData: import("../../../node_modules/@endo/marshal/src/marshal.js").ToCapData<any>;
+    fromCapData: import("../../../node_modules/@endo/marshal/src/marshal.js").FromCapData<any>;
+    serialize: import("../../../node_modules/@endo/marshal/src/marshal.js").ToCapData<any>;
+    unserialize: import("../../../node_modules/@endo/marshal/src/marshal.js").FromCapData<any>;
+};
+//# sourceMappingURL=testSupports.d.ts.map

package/tools/testSupports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testSupports.d.ts","sourceRoot":"","sources":["testSupports.js"],"names":[],"mappings":";AAUO,sCAHI,MAAM;wBAWgC,MAAM,MAAM;EAe5D;AAGM;;;;;EAGH"}