@agoric/notifier 0.7.0 → 0.7.1-upgrade-23-dev-bd79330.0.bd79330

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/notifier",
-  "version": "0.7.0",
+  "version": "0.7.1-upgrade-23-dev-bd79330.0.bd79330",
   "description": "Notifier allows services to update clients about state changes using a stream of promises",
   "type": "module",
   "main": "src/index.js",
@@ -9,14 +9,14 @@
   },
   "scripts": {
     "build": "exit 0",
-    "prepack": "yarn run -T tsc --build tsconfig.build.json",
-    "postpack": "git clean -f '*.d.*ts*' '*.tsbuildinfo'",
+    "prepack": "yarn run -T prepack-package",
+    "postpack": "yarn run -T postpack-package",
     "test": "ava",
     "test:c8": "c8 --all ${C8_OPTIONS:-} ava",
     "test:xs": "exit 0",
     "lint-fix": "yarn lint:eslint --fix",
     "lint": "yarn run -T run-s --continue-on-error 'lint:*'",
-    "lint:eslint": "yarn run -T eslint .",
+    "lint:eslint": "node ../../scripts/eslint-repo.mjs .",
     "lint:types": "yarn run -T tsc"
   },
   "repository": {
@@ -33,8 +33,8 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/internal": "0.4.0",
-    "@agoric/vat-data": "0.6.0",
+    "@agoric/internal": "0.4.1-upgrade-23-dev-bd79330.0.bd79330",
+    "@agoric/vat-data": "0.6.1-upgrade-23-dev-bd79330.0.bd79330",
     "@endo/errors": "^1.2.13",
     "@endo/far": "^1.1.14",
     "@endo/marshal": "^1.8.0",
@@ -42,18 +42,17 @@
     "@endo/promise-kit": "^1.1.13"
   },
   "devDependencies": {
-    "@agoric/kmarshal": "0.2.0",
-    "@agoric/swing-store": "0.10.0",
-    "@agoric/swingset-liveslots": "0.11.0",
-    "@agoric/swingset-vat": "0.33.0",
+    "@agoric/kmarshal": "0.2.1-upgrade-23-dev-bd79330.0.bd79330",
+    "@agoric/swing-store": "0.10.1-upgrade-23-dev-bd79330.0.bd79330",
+    "@agoric/swingset-liveslots": "0.11.1-upgrade-23-dev-bd79330.0.bd79330",
+    "@agoric/swingset-vat": "0.33.1-upgrade-23-dev-bd79330.0.bd79330",
     "@endo/init": "^1.1.12",
     "@endo/ses-ava": "^1.3.2",
-    "ava": "^5.3.0",
+    "ava": "^6.4.1",
     "c8": "^10.1.3"
   },
   "exports": {
     ".": "./src/index.js",
-    "./exported.js": "./exported.js",
     "./subscribe.js": "./subscribe.js",
     "./tools/testSupports.js": "./tools/testSupports.js"
   },
@@ -78,5 +77,5 @@
   "typeCoverage": {
     "atLeast": 90.92
   },
-  "gitHead": "0922d0447ab8fae9d2d87415964403330b5ca313"
+  "gitHead": "bd79330f78dae2faf9cc3d8b10063567700da07b"
 }

package/src/asyncIterableAdaptor.d.ts

@@ -34,9 +34,9 @@
  * @returns {ForkableAsyncIterable<T>}
  */
 export const makeAsyncIterableFromNotifier: <T_1>(topic: ERef<LatestTopic<T_1>>) => {
-    [Symbol.asyncIterator]: () => import("./types-index.js").ForkableAsyncIterableIterator<T_1, T_1>;
+    [Symbol.asyncIterator]: () => import("../src/types.js").ForkableAsyncIterableIterator<T_1, T_1>;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
-    [Symbol.asyncIterator]: () => import("./types-index.js").ForkableAsyncIterableIterator<T_1, T_1>;
+    [Symbol.asyncIterator]: () => import("../src/types.js").ForkableAsyncIterableIterator<T_1, T_1>;
 }>;
 export function observeIterator<T_1>(asyncIteratorP: ERef<AsyncIterator<T_1>>, iterationObserver: Partial<IterationObserver<T_1>>): Promise<undefined>;
 export function observeIteration<T_1>(asyncIterableP: ERef<AsyncIterable<T_1>>, iterationObserver: Partial<IterationObserver<T_1>>): Promise<undefined>;

package/src/index.js

@@ -1,6 +1,3 @@
-// @jessie-check
-/// <reference types="@agoric/internal/exported" />
-
 export {
   makePublishKit,
   prepareDurablePublishKit,

package/src/notifier.d.ts

@@ -3,6 +3,7 @@ export function makeNotifierFromSubscriber<T>(subscriber: ERef<Subscriber<T>> |
 export function makeNotifierKit<T>(...initialStateArr: [] | [T]): NotifierRecord<T>;
 export function makeNotifierFromAsyncIterable<T>(asyncIterableP: ERef<AsyncIterable<T>>): Notifier<T>;
 import type { LatestTopic } from './types.js';
+import type { ERef } from '@agoric/vow';
 import type { Notifier } from './types.js';
 import type { Subscriber } from './types.js';
 import type { Remote } from '@agoric/internal';

package/src/notifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notifier.d.ts","sourceRoot":"","sources":["notifier.js"],"names":[],"mappings":"AAkBO,6BAJM,CAAC,sBACH,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAClB,SAAS,CAAC,CAAC,CAwBvB;AAOM,2CAJM,CAAC,cACH,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,WAAW,CAAC,CAAC,CAAC,GACzC,SAAS,CAAC,CAAC,CAiBvB;AAoBM,gCAJM,CAAC,sBACH,EAAE,GAAG,CAAC,CAAC,CAAC,GACN,eAAe,CAAC,CAAC,CAsB7B;AAcM,8CAJM,CAAC,kBACH,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GACpB,SAAS,CAAC,CAAC,CAuEvB;iCA/K6F,YAAY;8BAAZ,YAAY;gCAAZ,YAAY;4BADjF,kBAAkB;oCACmD,YAAY"}
+{"version":3,"file":"notifier.d.ts","sourceRoot":"","sources":["notifier.js"],"names":[],"mappings":"AAmBO,6BAJM,CAAC,sBACH,KAAK,YAAY,CAAC,CAAC,CAAC,GAClB,SAAS,CAAC,CAAC,CAwBvB;AAOM,2CAJM,CAAC,cACH,KAAK,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,WAAW,CAAC,CAAC,CAAC,GACzC,SAAS,CAAC,CAAC,CAiBvB;AAoBM,gCAJM,CAAC,sBACH,EAAE,GAAG,CAAC,CAAC,CAAC,GACN,eAAe,CAAC,CAAC,CAsB7B;AAcM,8CAJM,CAAC,kBACH,KAAK,aAAa,CAAC,CAAC,CAAC,CAAC,GACpB,SAAS,CAAC,CAAC,CAuEvB;iCAhL6F,YAAY;0BACnF,aAAa;8BAD0D,YAAY;gCAAZ,YAAY;4BADjF,kBAAkB;oCACmD,YAAY"}

package/src/notifier.js

@@ -9,6 +9,7 @@ import { subscribeLatest } from './subscribe.js';
 /**
  * @import {Remote} from '@agoric/internal';
  * @import {LatestTopic, Notifier, NotifierRecord, PublishKit, Subscriber, UpdateRecord} from './types.js';
+ * @import {ERef} from '@agoric/vow';
  */
 
 /**

package/src/publish-kit.d.ts

@@ -26,7 +26,7 @@ export const IterableLatestTopicI: import("@endo/patterns").InterfaceGuard<{
     [Symbol.asyncIterator]: import("@endo/patterns").MethodGuard;
 }>;
 export function makePublishKit<T>(): PublishKit<T>;
-export function prepareDurablePublishKit(baggage: import("@agoric/swingset-liveslots").Baggage, kindName: string): <T>(options?: Parameters<typeof initDurablePublishKitState>[0]) => PublishKit<T>;
+export function prepareDurablePublishKit(baggage: Baggage, kindName: string): <T>(options?: Parameters<typeof initDurablePublishKitState>[0]) => PublishKit<T>;
 export const SubscriberShape: import("@endo/patterns").Matcher;
 export type DurablePublishKitEphemeralKey = Publisher<any>;
 export type DurablePublishKitEphemeralData = {
@@ -46,6 +46,7 @@ export type DurablePublishKitEphemeralData = {
     tailR: ((value: any) => void) | undefined;
 };
 import type { PublishKit } from '../src/types.js';
+import type { Baggage } from '@agoric/swingset-liveslots';
 /**
  * @param {object} [options]
  * @param {DurablePublishKitValueDurability & 'mandatory'} [options.valueDurability]

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

@@ -1 +1 @@
-{"version":3,"file":"publish-kit.d.ts","sourceRoot":"","sources":["publish-kit.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AAGH,gEAA6D;AAC7D;;;GAGG;;;;;AAMH;;;;GAOE;AAEF;;;GAMG;AAEH;;;GAMG;AA+CI,+BA2CQ,CAAC,KA7CH,WAAW,CAAC,CAAC,CA4FzB;AA8MM,kDAJI,OAAO,4BAA4B,EAAE,OAAO,YAC5C,MAAM,GACJ,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAwE5F;AAGD,+DAAyD;4CAhP3C,UAAU,GAAC,CAAC;;;;;;cASZ,OAAO,CAAC,GAAC,CAAC,GAAG,SAAS;;;;WAEtB,OAAO,CAAC,GAAC,CAAC;;;;;WACV,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,SAAS;;gCAjPsI,iBAAiB;AA2MvM;;;;GAIG;AACH,sDAHG;IAAiE,eAAe;CAChF,GAAU,sBAAsB,CAmBlC;+BAjOqL,iBAAiB;4CAAjB,iBAAiB"}
+{"version":3,"file":"publish-kit.d.ts","sourceRoot":"","sources":["publish-kit.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AAGH,gEAA6D;AAC7D;;;GAGG;;;;;AAMH;;;;GAOE;AAEF;;;GAMG;AAEH;;;GAMG;AA+CI,+BA2CQ,CAAC,KA7CH,WAAW,CAAC,CAAC,CA4FzB;AA8MM,kDAJI,OAAO,YACP,MAAM,GACJ,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAwE5F;AAGD,+DAAyD;4CAhP3C,UAAU,GAAC,CAAC;;;;;;cASZ,OAAO,CAAC,GAAC,CAAC,GAAG,SAAS;;;;WAEtB,OAAO,CAAC,GAAC,CAAC;;;;;WACV,CAAC,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC,GAAG,SAAS;;gCAlPsI,iBAAiB;6BAC7K,4BAA4B;AA2MtD;;;;GAIG;AACH,sDAHG;IAAiE,eAAe;CAChF,GAAU,sBAAsB,CAmBlC;+BAlOqL,iBAAiB;4CAAjB,iBAAiB"}

package/src/publish-kit.js

@@ -9,6 +9,7 @@ import { canBeDurable, prepareExoClassKit } from '@agoric/vat-data';
 /**
  * @import {ERef} from '@endo/far';
  * @import {DurablePublishKitState, DurablePublishKitValueDurability, LatestTopic, Notifier, NotifierRecord, PublicationRecord, Publisher, PublishKit, Subscriber, UpdateRecord} from '../src/types.js';
+ * @import {Baggage} from '@agoric/swingset-liveslots';
  */
 
 const sink = () => {};
@@ -400,7 +401,7 @@ const advanceDurablePublishKit = (context, value, targetStatus = 'live') => {
 };
 
 /**
- * @param {import('@agoric/swingset-liveslots').Baggage} baggage
+ * @param {Baggage} baggage
  * @param {string} kindName
  * @returns {<T>(options?: Parameters<typeof initDurablePublishKitState>[0]) => PublishKit<T>}
  */

package/src/stored-notifier.d.ts

@@ -1,10 +1,11 @@
-export function makeStoredNotifier<T extends PassableCap>(notifier: ERef<Notifier<T>>, storageNode: ERef<StorageNode>, marshaller: ERef<Marshaller>): StoredNotifier<T>;
+export function makeStoredNotifier<T extends PassableCap>(notifier: ERef<Notifier<T>>, storageNode: ERemote<StorageNode>, marshaller: ERemote<EMarshaller>): StoredNotifier<T>;
 export type StoredNotifier<T> = BaseNotifier<T> & Omit<StoredFacet, "getStoreKey">;
 import type { PassableCap } from '@endo/pass-style';
 import type { Notifier } from './types.js';
 import type { ERef } from '@endo/far';
 import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
-import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
+import type { ERemote } from '@agoric/internal';
+import type { EMarshaller } from '@agoric/internal/src/marshal/wrap-marshaller.js';
 import type { BaseNotifier } from './types.js';
 import type { StoredFacet } from '@agoric/internal/src/lib-chainStorage.js';
 //# sourceMappingURL=stored-notifier.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"stored-notifier.d.ts","sourceRoot":"","sources":["stored-notifier.js"],"names":[],"mappings":"AAkCO,mCANoB,CAAC,SAAf,WAAa,YACf,KAAK,SAAS,CAAC,CAAC,CAAC,eACjB,KAAK,WAAW,CAAC,cACjB,KAAK,UAAU,CAAC,GACd,cAAc,CAAC,CAAC,CAAC,CAiC7B;2BAlDY,CAAC,IACD,aAAa,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC;iCALhB,kBAAkB;8BAFxB,YAAY;0BAD9B,WAAW;iCAEmC,0CAA0C;gCAA1C,0CAA0C;kCADtE,YAAY;iCACgB,0CAA0C"}
+{"version":3,"file":"stored-notifier.d.ts","sourceRoot":"","sources":["stored-notifier.js"],"names":[],"mappings":"AAkCO,mCANoB,CAAC,SAAf,WAAa,YACf,KAAK,SAAS,CAAC,CAAC,CAAC,eACjB,QAAQ,WAAW,CAAC,cACpB,QAAQ,WAAW,CAAC,GAClB,cAAc,CAAC,CAAC,CAAC,CAiC7B;2BAlDY,CAAC,IACD,aAAa,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC;iCALjC,kBAAkB;8BAJP,YAAY;0BAD9B,WAAW;iCAIuB,0CAA0C;6BAFzE,kBAAkB;iCACd,iDAAiD;kCAFtC,YAAY;iCAGI,0CAA0C"}

package/src/stored-notifier.js

@@ -1,5 +1,3 @@
-// @jessie-check
-
 import { assertAllDefined } from '@agoric/internal';
 import { makeSerializeToStorage } from '@agoric/internal/src/lib-chainStorage.js';
 import { E, Far } from '@endo/far';
@@ -8,8 +6,10 @@ import { observeNotifier } from './asyncIterableAdaptor.js';
 /**
  * @import {ERef} from '@endo/far';
  * @import {BaseNotifier, Notifier} from './types.js';
- * @import {Marshaller, StoredFacet, StorageNode, Unserializer} from '@agoric/internal/src/lib-chainStorage.js';
- * @import {PassableCap, RemotableObject} from '@endo/pass-style';
+ * @import {ERemote} from '@agoric/internal';
+ * @import {EMarshaller} from '@agoric/internal/src/marshal/wrap-marshaller.js';
+ * @import {StoredFacet, StorageNode, Unserializer} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {PassableCap} from '@endo/pass-style';
  */
 
 /**
@@ -28,8 +28,8 @@ import { observeNotifier } from './asyncIterableAdaptor.js';
  *
  * @template {PassableCap} T
  * @param {ERef<Notifier<T>>} notifier
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
+ * @param {ERemote<StorageNode>} storageNode
+ * @param {ERemote<EMarshaller>} marshaller
  * @returns {StoredNotifier<T>}
  */
 export const makeStoredNotifier = (notifier, storageNode, marshaller) => {

package/src/storesub.d.ts

@@ -1,20 +1,20 @@
 export function forEachPublicationRecord<T>(subscriber: Subscriber<T>, consumeValue: (v: T) => void): Promise<void>;
-export function makeStoredSubscriber<T extends import("@endo/marshal").PassableCap>(subscriber: Subscriber<T>, storageNode: ERef<StorageNode>, marshaller: ERef<ReturnType<typeof makeMarshal>>): StoredSubscriber<T>;
-export function makeStoredSubscription<T>(subscription: Subscription<T>, storageNode?: ERef<StorageNode>, marshaller?: ERef<ReturnType<typeof makeMarshal>>): StoredSubscription<T>;
-export function makeStoredPublisherKit<T = unknown>(storageNode?: ERef<StorageNode>, marshaller?: ERef<Marshaller>, childPath?: string): StoredPublisherKit<T>;
-export function makeStoredPublishKit<T = unknown>(storageNode: ERef<StorageNode>, marshaller: ERef<Marshaller>): StoredPublishKit<T>;
+export function makeStoredSubscriber<T extends PassableCap>(subscriber: Subscriber<T>, storageNode: ERemote<StorageNode>, marshaller: ERemote<EMarshaller>): StoredSubscriber<T>;
+export function makeStoredSubscription<T>(subscription: Subscription<T>, storageNode?: ERemote<StorageNode> | null, marshaller?: ERemote<EMarshaller>): StoredSubscription<T>;
+export function makeStoredPublisherKit<T = unknown>(storageNode?: ERemote<StorageNode> | null, marshaller?: ERemote<EMarshaller>, childPath?: string): StoredPublisherKit<T>;
+export function makeStoredPublishKit<T = unknown>(storageNode: ERemote<StorageNode>, marshaller: ERemote<EMarshaller>): StoredPublishKit<T>;
 export type StoredPublisherKit<T> = {
     subscriber: StoredSubscription<T>;
     publisher: IterationObserver<T>;
 };
 import type { Subscriber } from '../src/types.js';
+import type { PassableCap } from '@endo/marshal';
 import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
-import type { ERef } from '@endo/far';
-import { makeMarshal } from '@endo/marshal';
+import type { ERemote } from '@agoric/internal';
+import type { EMarshaller } from '@agoric/internal/src/marshal/wrap-marshaller.js';
 import type { StoredSubscriber } from '../src/types.js';
 import type { Subscription } from '../src/types.js';
 import type { StoredSubscription } from '../src/types.js';
-import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
 import type { StoredPublishKit } from '../src/types.js';
 import type { IterationObserver } from '../src/types.js';
 //# sourceMappingURL=storesub.d.ts.map

package/src/storesub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storesub.d.ts","sourceRoot":"","sources":["storesub.js"],"names":[],"mappings":"AAuBO,yCAJM,CAAC,cACH,WAAW,CAAC,CAAC,gBACb,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,iBAcxB;AAiBM,qCAN4C,CAAC,SAAvC,OAAQ,eAAe,EAAE,WAAY,cACvC,WAAW,CAAC,CAAC,eACb,KAAK,WAAW,CAAC,cACjB,KAAK,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,GAClC,iBAAiB,CAAC,CAAC,CA6B/B;AAkBM,uCANM,CAAC,gBACH,aAAa,CAAC,CAAC,gBACf,KAAK,WAAW,CAAC,eACjB,KAAK,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,GAClC,mBAAmB,CAAC,CAAC,CAqEjC;AAoBM,uCANO,CAAC,0BACJ,KAAK,WAAW,CAAC,eACjB,KAAK,UAAU,CAAC,cAChB,MAAM,GACJ,kBAAkB,CAAC,CAAC,CAAC,CAoBjC;AAgBM,qCALO,CAAC,yBACJ,KAAK,WAAW,CAAC,cACjB,KAAK,UAAU,CAAC,GACd,iBAAiB,CAAC,CAAC,CAU/B;+BAzDY,CAAC;gBAEA,mBAAmB,CAAC,CAAC;eACrB,kBAAkB,CAAC,CAAC;;gCAjKmL,iBAAiB;iCAC9K,0CAA0C;0BAF3E,WAAW;4BATN,eAAe;sCAU0K,iBAAiB;kCAAjB,iBAAiB;wCAAjB,iBAAiB;gCAC9K,0CAA0C;sCADmH,iBAAiB;uCAAjB,iBAAiB"}
+{"version":3,"file":"storesub.d.ts","sourceRoot":"","sources":["storesub.js"],"names":[],"mappings":"AA0BO,yCAJM,CAAC,cACH,WAAW,CAAC,CAAC,gBACb,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,iBAcxB;AAiBM,qCANoB,CAAC,SAAf,WAAa,cACf,WAAW,CAAC,CAAC,eACb,QAAQ,WAAW,CAAC,cACpB,QAAQ,WAAW,CAAC,GAClB,iBAAiB,CAAC,CAAC,CA6B/B;AAkBM,uCANM,CAAC,gBACH,aAAa,CAAC,CAAC,gBACf,QAAQ,WAAW,CAAC,GAAG,IAAI,eAC3B,QAAQ,WAAW,CAAC,GAClB,mBAAmB,CAAC,CAAC,CAqEjC;AAoBM,uCANO,CAAC,0BACJ,QAAQ,WAAW,CAAC,GAAG,IAAI,eAC3B,QAAQ,WAAW,CAAC,cACpB,MAAM,GACJ,kBAAkB,CAAC,CAAC,CAAC,CAoBjC;AAgBM,qCALO,CAAC,yBACJ,QAAQ,WAAW,CAAC,cACpB,QAAQ,WAAW,CAAC,GAClB,iBAAiB,CAAC,CAAC,CAU/B;+BAzDY,CAAC;gBAEA,mBAAmB,CAAC,CAAC;eACrB,kBAAkB,CAAC,CAAC;;gCAnKmL,iBAAiB;iCAGxM,eAAe;iCAFD,0CAA0C;6BAH5D,kBAAkB;iCAId,iDAAiD;sCAFsI,iBAAiB;kCAAjB,iBAAiB;wCAAjB,iBAAiB;sCAAjB,iBAAiB;uCAAjB,iBAAiB"}

package/src/storesub.js

@@ -8,9 +8,12 @@ import { makeSubscriptionKit } from './subscriber.js';
 import { subscribeEach } from './subscribe.js';
 
 /**
+ * @import {ERemote} from '@agoric/internal';
  * @import {ERef} from '@endo/far';
  * @import {IterationObserver, LatestTopic, Notifier, NotifierRecord, PublicationRecord, Publisher, PublishKit, StoredPublishKit, StoredSubscription, StoredSubscriber, Subscriber, Subscription, UpdateRecord} from '../src/types.js';
- * @import {Marshaller, StorageNode, Unserializer} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {StorageNode, Unserializer} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {EMarshaller} from '@agoric/internal/src/marshal/wrap-marshaller.js';
+ * @import {PassableCap} from '@endo/marshal';
  */
 
 /**
@@ -44,10 +47,10 @@ export const forEachPublicationRecord = async (subscriber, consumeValue) => {
  * the iteration themselves, or obtain information to subscribe to the stored
  * data out-of-band.
  *
- * @template {import('@endo/marshal').PassableCap} T
+ * @template {PassableCap} T
  * @param {Subscriber<T>} subscriber
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<ReturnType<typeof makeMarshal>>} marshaller
+ * @param {ERemote<StorageNode>} storageNode
+ * @param {ERemote<EMarshaller>} marshaller
  * @returns {StoredSubscriber<T>}
  */
 export const makeStoredSubscriber = (subscriber, storageNode, marshaller) => {
@@ -91,8 +94,8 @@ export const makeStoredSubscriber = (subscriber, storageNode, marshaller) => {
  *
  * @template T
  * @param {Subscription<T>} subscription
- * @param {ERef<StorageNode>} [storageNode]
- * @param {ERef<ReturnType<typeof makeMarshal>>} [marshaller]
+ * @param {ERemote<StorageNode> | null} [storageNode]
+ * @param {ERemote<EMarshaller>} [marshaller]
  * @returns {StoredSubscription<T>}
  */
 export const makeStoredSubscription = (
@@ -103,7 +106,7 @@ export const makeStoredSubscription = (
     serializeBodyFormat: 'smallcaps',
   }),
 ) => {
-  /** @type {import('@agoric/internal/src/lib-chainStorage.js').Unserializer} */
+  /** @type {Unserializer} */
   const unserializer = Far('unserializer', {
     fromCapData: data => E(marshaller).fromCapData(data),
     unserialize: data => E(marshaller).fromCapData(data),
@@ -177,8 +180,8 @@ harden(makeStoredSubscription);
  * @deprecated incompatible with durability; instead handle vstorage ephemerally on a durable PublishKit
  *
  * @template [T=unknown]
- * @param {ERef<StorageNode>} [storageNode]
- * @param {ERef<Marshaller>} [marshaller]
+ * @param {ERemote<StorageNode> | null} [storageNode]
+ * @param {ERemote<EMarshaller>} [marshaller]
  * @param {string} [childPath]
  * @returns {StoredPublisherKit<T>}
  */
@@ -212,8 +215,8 @@ export const makeStoredPublisherKit = (storageNode, marshaller, childPath) => {
  * What's different is `subscriber` tees records, writing out to storageNode.
  *
  * @template [T=unknown]
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
+ * @param {ERemote<StorageNode>} storageNode
+ * @param {ERemote<EMarshaller>} marshaller
  * @returns {StoredPublishKit<T>}
  */
 export const makeStoredPublishKit = (storageNode, marshaller) => {

package/src/subscribe.d.ts

@@ -1,28 +1,28 @@
 export function subscribe<T>(itP: ERef<AsyncIterableIterator<T>>): {
     [Symbol.asyncIterator]: () => {
-        [Symbol.asyncIterator]: () => /*elided*/ any & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, /*elided*/ any>;
+        [Symbol.asyncIterator]: () => /*elided*/ any & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, /*elided*/ any>;
         next: () => Promise<IteratorResult<T, any>>;
-    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
-        [Symbol.asyncIterator]: () => /*elided*/ any & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, /*elided*/ any>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        [Symbol.asyncIterator]: () => /*elided*/ any & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, /*elided*/ any>;
         next: () => Promise<IteratorResult<T, any>>;
     }>;
-} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+} & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     [Symbol.asyncIterator]: () => {
-        [Symbol.asyncIterator]: () => /*elided*/ any & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, /*elided*/ any>;
+        [Symbol.asyncIterator]: () => /*elided*/ any & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, /*elided*/ any>;
         next: () => Promise<IteratorResult<T, any>>;
-    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
-        [Symbol.asyncIterator]: () => /*elided*/ any & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, /*elided*/ any>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        [Symbol.asyncIterator]: () => /*elided*/ any & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, /*elided*/ any>;
         next: () => Promise<IteratorResult<T, any>>;
     }>;
 }>;
 export function subscribeEach<T>(topic: ERef<EachTopic<T>>): {
     [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T, T>;
-} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+} & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T, T>;
 }>;
 export function subscribeLatest<T>(topic: ERef<LatestTopic<T>>): {
     [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T, T>;
-} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+} & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     [Symbol.asyncIterator]: () => ForkableAsyncIterableIterator<T, T>;
 }>;
 import type { ERef } from '@endo/far';

package/src/subscribe.js

@@ -52,7 +52,7 @@ const reconnectAsNeeded = async (getter, seed = []) => {
             err,
             X`Attempting to recover from disconnection: ${disconnection}`,
           );
-        } catch (_err) {
+        } catch {
           // noop
         }
       }

package/src/subscriber.d.ts

@@ -1,5 +1,6 @@
 /**
  * @import {EachTopic, IterationObserver, LatestTopic, Notifier, NotifierRecord, SubscriptionRecord, Publisher, PublishKit, StoredPublishKit, StoredSubscription, StoredSubscriber, Subscriber, Subscription, UpdateRecord} from '../src/types.js';
+ * @import {ERef} from '@agoric/vow';
  */
 /**
  * @template T
@@ -27,6 +28,7 @@ export function makeSubscription<T>(topic: ERef<EachTopic<T>>): Subscription<T>;
  */
 export function makeSubscriptionKit<T>(): SubscriptionRecord<T>;
 import type { EachTopic } from '../src/types.js';
+import type { ERef } from '@agoric/vow';
 import type { Subscription } from '../src/types.js';
 import type { SubscriptionRecord } from '../src/types.js';
 //# sourceMappingURL=subscriber.d.ts.map

package/src/subscriber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscriber.d.ts","sourceRoot":"","sources":["subscriber.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;;;GAIG;AACH,iCAJa,CAAC,SACH,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAChB,aAAa,CAAC,CAAC,CAkB3B;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAHa,CAAC,KACD,mBAAmB,CAAC,CAAC,CAmBjC;+BA/DgO,iBAAiB;kCAAjB,iBAAiB;wCAAjB,iBAAiB"}
+{"version":3,"file":"subscriber.d.ts","sourceRoot":"","sources":["subscriber.js"],"names":[],"mappings":"AAQA;;;GAGG;AAEH;;;;GAIG;AACH,iCAJa,CAAC,SACH,KAAK,UAAU,CAAC,CAAC,CAAC,GAChB,aAAa,CAAC,CAAC,CAkB3B;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,oCAHa,CAAC,KACD,mBAAmB,CAAC,CAAC,CAmBjC;+BAhEgO,iBAAiB;0BAC3N,aAAa;kCAD6L,iBAAiB;wCAAjB,iBAAiB"}

package/src/subscriber.js

@@ -1,5 +1,3 @@
-// @jessie-check
-
 /// <reference types="ses" />
 
 import { E, Far } from '@endo/far';
@@ -10,6 +8,7 @@ import { makePinnedHistoryTopic } from './topic.js';
 
 /**
  * @import {EachTopic, IterationObserver, LatestTopic, Notifier, NotifierRecord, SubscriptionRecord, Publisher, PublishKit, StoredPublishKit, StoredSubscription, StoredSubscriber, Subscriber, Subscription, UpdateRecord} from '../src/types.js';
+ * @import {ERef} from '@agoric/vow';
  */
 
 /**

package/src/topic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"topic.d.ts","sourceRoot":"","sources":["topic.js"],"names":[],"mappings":"AAiBO,uCALM,CAAC,SACH,UAAU,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,GAE3B,UAAU,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAoBzC;+BA9BwC,iBAAiB;iCAAjB,iBAAiB"}
+{"version":3,"file":"topic.d.ts","sourceRoot":"","sources":["topic.js"],"names":[],"mappings":"AAeO,uCALM,CAAC,SACH,UAAU,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,GAE3B,UAAU,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAoBzC;+BA9BwC,iBAAiB;iCAAjB,iBAAiB"}

package/src/topic.js

@@ -1,5 +1,3 @@
-// @jessie-check
-
 import { Far } from '@endo/far';
 
 /**

package/src/types.js

@@ -0,0 +1,253 @@
+             
+              
+               
+              
+                                                  
+
+/**
+ * An AsyncIterator that can be forked at a given position
+ * into multiple independent ForkableAsyncIterators starting from that position.
+ */
+                                  
+    
+                
+                    
+                                        
+                                                   
+  
+                                                                      
+                                                                     
+  
+                                          
+    
+                
+                    
+     
+                                                                             
+                                                           
+                                             
+/**
+ * An AsyncIterable that produces ForkableAsyncIterators.
+ */
+                                                                          
+                                                                         
+  
+/**
+ * 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.
+ */
+                                    
+                                          
+                                  
+                                  
+  
+/**
+ * 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.
+ */
+                                    
+                          
+     
+                                     
+                                                 
+     
+                       
+                                      
+  
+                            
+     
+                                                                         
+                                                                     
+                           
+                                                      
+     
+                                                                           
+  
+/**
+ * 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.
+ */
+                                                                              
+/**
+ * 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.
+ */
+                                                                              
+                              
+     
+                                                                  
+                                                                                       
+                                                         
+                                                                                          
+                                                                                       
+                                                                              
+                                             
+                                                             
+     
+                                                                              
+  
+/**
+ * This type is deprecated but is still
+ * used externally.
+ */
+                                             
+/**
+ * A stream of results that allows consumers to configure
+ * forward-lossless "each" iteration with `subscribeEach` and
+ * lossy "latest" iteration with `subscribeLatest`.
+ */
+                                                          
+/**
+ * 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.
+ */
+                            
+                                      
+                                  
+                              
+  
+                                                       
+                             
+                          
+                            
+  
+                                   
+                          
+                                  
+  
+/**
+ * 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.
+ */
+                                              
+               
+                   
+              
+                                      
+                                                    
+                       
+                                         
+     
+                                                                   
+                                                                         
+                                                                                         
+     
+                    
+     
+                                                                               
+                                                                 
+     
+             
+  
+                               
+     
+                                                   
+     
+           
+     
+                                                
+                                        
+     
+                                   
+  
+/**
+ * Will be shared between machines,
+ * so it must be safe to expose. But other software should avoid depending on
+ * its internal structure.
+ */
+                                                   
+/**
+ * an object that can be used to get the current state or updates
+ */
+                                                                   
+                        
+                               
+                      
+                                   
+     
+                                                                                
+                                               
+          
+                    
+                                                                      
+        
+                                                                     
+                                                   
+     
+                                                                    
+  
+/**
+ * the produced notifier/updater pair
+ */
+                                 
+     
+                                         
+     
+                                                                          
+     
+                                        
+     
+                        
+  
+/**
+ * A form of AsyncIterable supporting distributed and multicast usage.
+ */
+                                                    
+                
+                          
+                                       
+     
+                                                                                
+                                               
+          
+                    
+                                                                              
+        
+                                                                     
+                                                   
+     
+                                                                
+  
+                                     
+                                    
+                                
+  
+                                                       
+                             
+                   
+                                    
+     
+    
+                                      
+  
+                                                              

package/subscribe.js

@@ -1,3 +1 @@
-// @jessie-check
-
 export * from './src/subscribe.js';

package/exported.js

@@ -1,2 +0,0 @@
-// Dummy file for .d.ts twin to declare ambients
-export {};

package/src/types.ts

@@ -1,253 +0,0 @@
-import type {
-  StoredFacet,
-  Unserializer,
-  VStorageKey,
-} from '@agoric/internal/src/lib-chainStorage.js';
-
-/**
- * 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>;
-};
-/**
- * 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>>;
-export type PublishKit<T> = {
-  publisher: Publisher<T>;
-  subscriber: Subscriber<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;
-};
-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>;
-/**
- * an object that can be used to get the current state or updates
- */
-export type Notifier<T> = import('@endo/marshal').RemotableObject &
-  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>>;
-};
-/**
- * the produced notifier/updater pair
- */
-export type NotifierRecord<T> = {
-  /**
-   * the (closely-held) notifier producer
-   */
-  updater: import('@endo/marshal').RemotableObject & IterationObserver<T>;
-  /**
-   * the (widely-held) notifier consumer
-   */
-  notifier: Notifier<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>>;
-};
-export type SubscriptionRecord<T> = {
-  publication: IterationObserver<T>;
-  subscription: Subscription<T>;
-};
-export type StoredSubscription<T> = Subscription<T> & {
-  getStoreKey: () => Promise<
-    VStorageKey & {
-      subscription: Subscription<T>;
-    }
-  >;
-  getUnserializer: () => Unserializer;
-};
-export type StoredSubscriber<T> = Subscriber<T> & StoredFacet;