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

package/src/work-pool.d.ts

@@ -0,0 +1,13 @@
+export function makeWorkPool<T, U = T, M extends "all" | "allSettled" = "all">(source: AsyncIterable<T> | Iterable<T>, config: undefined | [capacity: number][0] | {
+    capacity?: number;
+    mode?: M;
+}, processInput?: (input: Awaited<T>, index?: number) => Promise<Awaited<U>> | Awaited<U>): AsyncGenerator<[M extends "allSettled" ? PromiseSettledResult<Awaited<U>> : Awaited<U>, number]> & {
+    done: Promise<boolean>;
+    then: () => never;
+};
+export type PromiseKit<T> = {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason: any) => void;
+    promise: Promise<T>;
+};
+//# sourceMappingURL=work-pool.d.ts.map

package/src/work-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-pool.d.ts","sourceRoot":"","sources":["work-pool.js"],"names":[],"mappings":"AAgFO,6BAlBM,CAAC,EACA,CAAC,MACsB,CAAC,SAAxB,KAAK,GAAG,YAAa,kBACxB,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,UAC9B,SAAS,GACb,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,GACrB;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,CAAC,CAAA;CAAE,iBAC3B,CACN,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EACjB,KAAK,CAAC,EAAE,MAAM,KACX,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC3B,cAAc,CAC1B,CACM,CAAC,SAAS,YAAY,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC5E,MAAY,CACP,CACF,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,KAAK,CAAA;CAAE,CA0JnD;uBAtNY,CAAC;aAEA,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;YACnC,CAAC,MAAM,EAAE,GAAG,KAAK,IAAI;aACrB,OAAO,CAAC,CAAC,CAAC"}

package/src/work-pool.js

@@ -0,0 +1,233 @@
+// @ts-check
+/**
+ * @file A pure JavaScript async work pool utility that is compatible with but
+ *   not dependent upon a hardened environment.
+ */
+
+const { isInteger } = Number;
+
+const sink = () => {};
+
+/**
+ * @param {unknown} val
+ * @returns {val is bigint | boolean | null | number | string | symbol | undefined}
+ */
+const isPrimitive = val =>
+  !val || (typeof val !== 'object' && typeof val !== 'function');
+
+/**
+ * @template T
+ * @typedef {object} PromiseKit
+ * @property {(value: T | PromiseLike<T>) => void} resolve
+ * @property {(reason: any) => void} reject
+ * @property {Promise<T>} promise
+ */
+
+/**
+ * @template T
+ * @returns {PromiseKit<T>}
+ */
+const makePromiseKit = () => {
+  /** @type {PromiseKit<T>['resolve']} */
+  let resolve;
+  /** @type {PromiseKit<T>['reject']} */
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  // @ts-expect-error TS2454 use before assign
+  return { promise, resolve, reject };
+};
+
+/**
+ * Consume an async iterable with at most `capacity` unsettled results at any
+ * given time, passing each input through `processInput` and providing [result,
+ * index] pairs in settlement order. Source order can be recovered with consumer
+ * code like:
+ *
+ *     const results = [];
+ *     for (const [result, i] of makeWorkPool(...)) results[i] = result;
+ *
+ * or something more sophisticated to eagerly detect complete subsequences
+ * immediately following a previous high-water mark for contiguous results.
+ *
+ * To support cases in which `processInput` is used only for side effects rather
+ * than its return value, the returned AsyncGenerator has a promise-valued
+ * `done` property that fulfills when all input has been processed (to `true` if
+ * the source was exhausted or to `false` if iteration was aborted early),
+ * regardless of how many final iteration results have been consumed:
+ *
+ *     await makeWorkPool(...).done;
+ *
+ * @template T
+ * @template [U=T]
+ * @template {'all' | 'allSettled'} [M='all']
+ * @param {AsyncIterable<T> | Iterable<T>} source
+ * @param {undefined
+ *   | [capacity: number][0]
+ *   | { capacity?: number; mode?: M }} config
+ * @param {(
+ *   input: Awaited<T>,
+ *   index?: number,
+ * ) => Promise<Awaited<U>> | Awaited<U>} [processInput]
+ * @returns {AsyncGenerator<
+ *   [
+ *     M extends 'allSettled' ? PromiseSettledResult<Awaited<U>> : Awaited<U>,
+ *     number,
+ *   ]
+ * > & { done: Promise<boolean>; then: () => never }}
+ */
+export const makeWorkPool = (
+  source,
+  config,
+  processInput = x => /** @type {any} */ (x),
+) => {
+  // Validate arguments.
+  if (isPrimitive(config)) config = { capacity: config, mode: undefined };
+  const { capacity = 10, mode = 'all' } = config;
+  if (!(capacity === Infinity || (isInteger(capacity) && capacity > 0))) {
+    throw RangeError('capacity must be a positive integer');
+  }
+  if (mode !== 'all' && mode !== 'allSettled') {
+    throw RangeError('mode must be "all" or "allSettled"');
+  }
+
+  // Normalize source into an `inputs` iterator.
+  const makeInputs = source[Symbol.asyncIterator] || source[Symbol.iterator];
+  const inputs =
+    /** @type {AsyncIterator<Awaited<T>> | Iterator<Awaited<T>>} */ (
+      Reflect.apply(makeInputs, source, [])
+    );
+  let inputsExhausted = false;
+  let terminated = false;
+  const doneKit = /** @type {PromiseKit<boolean>} */ (makePromiseKit());
+
+  // Concurrently consume up to `capacity` inputs, pushing the result of
+  // processing each into a linked chain of promises before consuming more.
+  let nextIndex = 0;
+  /**
+   * @typedef {object} ResultNode
+   * @property {Promise<ResultNode>} nextP
+   * @property {number} index
+   * @property {M extends 'allSettled'
+   *   ? PromiseSettledResult<Awaited<U>>
+   *   : Awaited<U>} result
+   */
+  const { promise: headP, ...headResolvers } =
+    /** @type {PromiseKit<ResultNode>} */ (makePromiseKit());
+  let { resolve: resolveCurrent, reject } = headResolvers;
+  let inFlight = 0;
+  const takeMoreInput = async () => {
+    await null;
+    while (inFlight < capacity && !inputsExhausted && !terminated) {
+      inFlight += 1;
+      const index = nextIndex;
+      nextIndex += 1;
+      /** @type {Promise<IteratorResult<Awaited<T>>>} */
+      let iterResultP;
+      try {
+        iterResultP = Promise.resolve(inputs.next());
+      } catch (err) {
+        iterResultP = Promise.reject(err);
+      }
+      void iterResultP
+        .then(async iterResult => {
+          if (terminated) return;
+
+          if (iterResult.done) {
+            inFlight -= 1;
+            inputsExhausted = true;
+            void takeMoreInput();
+            return;
+          }
+
+          // Process the input, propagating errors if mode is not "allSettled".
+          await null;
+          /** @type {PromiseSettledResult<Awaited<U>>} */
+          let settlementDesc = { status: 'rejected', reason: undefined };
+          try {
+            const fulfillment = await processInput(iterResult.value, index);
+            if (terminated) return;
+            settlementDesc = { status: 'fulfilled', value: fulfillment };
+          } catch (err) {
+            if (terminated) return;
+            if (mode !== 'allSettled') throw err;
+            /** @type {PromiseRejectedResult} */ (settlementDesc).reason = err;
+          }
+
+          // Fulfill the current tail promise with a record that includes the
+          // source index to which it corresponds and a reference to a new
+          // [unsettled] successor (thereby extending the chain), then try to
+          // consume more input.
+          const { promise: nextP, ...nextResolvers } =
+            /** @type {PromiseKit<ResultNode>} */ (makePromiseKit());
+          // Analogous to `Promise.allSettled`, mode "allSettled" produces
+          // { status, value, reason } PromiseSettledResult records.
+          const result =
+            mode === 'allSettled'
+              ? settlementDesc
+              : /** @type {PromiseFulfilledResult<Awaited<U>>} */ (
+                  settlementDesc
+                ).value;
+          inFlight -= 1;
+          void takeMoreInput();
+          const untypedResult = /** @type {any} */ (result);
+          resolveCurrent({ nextP, index, result: untypedResult });
+          ({ resolve: resolveCurrent, reject } = nextResolvers);
+        })
+        .catch(err => {
+          // End the chain with this rejection.
+          terminated = true;
+          reject(err);
+          doneKit.reject(err);
+          void (async () => inputs.throw?.(err))().catch(sink);
+        });
+    }
+    if (inFlight <= 0 && inputsExhausted) {
+      // @ts-expect-error This dummy signaling record conveys no result.
+      resolveCurrent({ nextP: undefined, index: -1, result: undefined });
+      doneKit.resolve(true);
+    }
+  };
+
+  const results = (async function* generateResults(nextP) {
+    await null;
+    let exhausted = false;
+    try {
+      for (;;) {
+        const { nextP: successor, index, result } = await nextP;
+        nextP = successor;
+        if (!successor) break;
+        yield /** @type {[typeof result, number]} */ (
+          Object.freeze([result, index])
+        );
+      }
+      exhausted = true;
+    } catch (err) {
+      terminated = true;
+      doneKit.reject(err);
+      void (async () => inputs.throw?.(err))().catch(sink);
+      throw err;
+    } finally {
+      const interrupted = !exhausted && !terminated;
+      terminated = true;
+      doneKit.resolve(false);
+      if (interrupted) void (async () => inputs.return?.())().catch(sink);
+    }
+  })(headP);
+  Object.defineProperty(results, 'done', {
+    value: doneKit.promise,
+    enumerable: true,
+  });
+  Object.defineProperty(results, 'then', {
+    value: () => {
+      throw Error('A work pool is not thenable; did you forget `.done`?');
+    },
+  });
+
+  void takeMoreInput();
+
+  // @ts-expect-error
+  return Object.freeze(results);
+};

package/src/marshal.d.ts

@@ -1,33 +0,0 @@
-export function makeBoardRemote({ boardId, iface }: {
-    boardId: string | null;
-    iface?: string;
-}): BoardRemote;
-export function slotToBoardRemote(boardId: string, iface: string): BoardRemote;
-export function boardSlottingMarshaller(slotToVal?: (slot: string, iface: string) => any): Omit<import("@endo/marshal").Marshal<string | null>, "serialize" | "unserialize">;
-/**
- * @type {TypedPattern<CapData<any>>}
- */
-export const CapDataShape: TypedPattern<CapData<any>>;
-export function assertCapData(data: unknown): asserts data is CapData<unknown>;
-export function unmarshalFromVstorage(data: Map<string, string>, key: string, fromCapData: ReturnType<typeof import("@endo/marshal").makeMarshal>["fromCapData"], 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 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>>;
-};
-/**
- * Should be a union with Remotable, but that's `any`, making this type
- * meaningless
- */
-export type BoardRemote = {
-    getBoardId: () => string | null;
-};
-import type { CapData } from '@endo/marshal';
-import type { TypedPattern } from './types.js';
-//# sourceMappingURL=marshal.d.ts.map

package/src/marshal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"marshal.d.ts","sourceRoot":"","sources":["marshal.js"],"names":[],"mappings":"AAuBO,oDAHI;IAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC,WAAW,CAKvB;AAMM,2CAHI,MAAM,SACN,MAAM,eAGoB;AAqB9B,oDANI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,GAClC,IAAI,CAChB,OAAW,eAAe,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAClD,WAAe,GAAG,aAAa,CAC5B,CAMH;AAGD;;GAEG;AACH,2BAFU,aAAa,QAAQ,GAAG,CAAC,CAAC,CAE+B;AAS5D,oCAHI,OAAO,GACL,QAAQ,IAAI,IAAI,QAAQ,OAAO,CAAC,CAO5C;AAeM,4CATI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,OACnB,MAAM,eACN,UAAU,CACpB,cAAkB,eAAe,EAAE,WAAW,CAC3C,CAAC,aAAa,CAAC,SACR,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;AAID;;;;;EAEG;;;;;0BA1IU;IAAE,UAAU,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;CAAE;6BARtB,eAAe;kCACV,YAAY"}