@agoric/internal 0.3.3-dev-eb7e9eb.0 → 0.3.3-u11.0

package/src/lib-nodejs/engine-gc.js

@@ -1,22 +0,0 @@
-import v8 from 'v8';
-import vm from 'vm';
-
-/* global globalThis */
-let bestGC = globalThis.gc;
-if (typeof bestGC !== 'function') {
-  // Node.js v8 wizardry.
-  v8.setFlagsFromString('--expose_gc');
-  bestGC = vm.runInNewContext('gc');
-  assert(bestGC);
-  // We leave --expose_gc turned on, otherwise AVA's shared workers
-  // may race and disable it before we manage to extract the
-  // binding. This won't cause 'gc' to be visible to new Compartments
-  // because SES strips out everything it doesn't recognize.
-
-  // // Hide the gc global from new contexts/workers.
-  // v8.setFlagsFromString('--no-expose_gc');
-}
-
-// Export a const.
-const engineGC = bestGC;
-export default engineGC;

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

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

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

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

package/src/lib-nodejs/gc-and-finalize.js

@@ -1,91 +0,0 @@
-/* global setImmediate */
-
-/* A note on our GC terminology:
- *
- * We define four states for any JS object to be in:
- *
- * REACHABLE: There exists a path from some root (live export or top-level
- * global) to this object, making it ineligible for collection. Userspace vat
- * code has a strong reference to it (and userspace is not given access to
- * WeakRef, so it has no weak reference that might be used to get access).
- *
- * UNREACHABLE: There is no strong reference from a root to the object.
- * Userspace vat code has no means to access the object, although liveslots
- * might (via a WeakRef). The object is eligible for collection, but that
- * collection has not yet happened. The liveslots WeakRef is still alive: if
- * it were to call `.deref()`, it would get the object.
- *
- * COLLECTED: The JS engine has performed enough GC to notice the
- * unreachability of the object, and has collected it. The liveslots WeakRef
- * is dead: `wr.deref() === undefined`. Neither liveslots nor userspace has
- * any way to reach the object, and never will again. A finalizer callback
- * has been queued, but not yet executed.
- *
- * FINALIZED: The JS engine has run the finalizer callback. Once the
- * callback completes, the object is thoroughly dead and unremembered,
- * and no longer exists in one of these four states.
- *
- * The transition from REACHABLE to UNREACHABLE always happens as a result of
- * a message delivery or resolution notification (e.g when userspace
- * overwrites a variable, deletes a Map entry, or a callback on the promise
- * queue which closed over some objects is retired and deleted).
- *
- * The transition from UNREACHABLE to COLLECTED can happen spontaneously, as
- * the JS engine decides it wants to perform GC. It will also happen
- * deliberately if we provoke a GC call with a magic function like `gc()`
- * (when Node.js imports `engine-gc`, which is morally-equivalent to
- * running with `--expose-gc`, or when XS is configured to provide it as a
- * C-level callback). We can force GC, but we cannot prevent it from happening
- * at other times.
- *
- * FinalizationRegistry callbacks are defined to run on their own turn, so
- * the transition from COLLECTED to FINALIZED occurs at a turn boundary.
- * Node.js appears to schedule these finalizers on the timer/IO queue, not
- * the promise/microtask queue. So under Node.js, you need a `setImmediate()`
- * or two to ensure that finalizers have had a chance to run. XS is different
- * but responds well to similar techniques.
- */
-
-/*
- * `gcAndFinalize` must be defined in the start compartment. It uses
- * platform-specific features to provide a function which provokes a full GC
- * operation: all "UNREACHABLE" objects should transition to "COLLECTED"
- * before it returns. In addition, `gcAndFinalize()` returns a Promise. This
- * Promise will resolve (with `undefined`) after all FinalizationRegistry
- * callbacks have executed, causing all COLLECTED objects to transition to
- * FINALIZED. If the caller can manage call gcAndFinalize with an empty
- * promise queue, then their .then callback will also start with an empty
- * promise queue, and there will be minimal uncollected unreachable objects
- * in the heap when it begins.
- *
- * `gcAndFinalize` depends upon platform-specific tools to provoke a GC sweep
- * and wait for finalizers to run: a `gc()` function, and `setImmediate`. If
- * these tools do not exist, this function will do nothing, and return a
- * dummy pre-resolved Promise.
- */
-
-export function makeGcAndFinalize(gcPower) {
-  if (typeof gcPower !== 'function') {
-    if (gcPower !== false) {
-      // We weren't explicitly disabled, so warn.
-      console.warn(
-        Error(`no gcPower() function; skipping finalizer provocation`),
-      );
-    }
-  }
-  return async function gcAndFinalize() {
-    if (typeof gcPower !== 'function') {
-      return;
-    }
-
-    // on Node.js, GC seems to work better if the promise queue is empty first
-    await new Promise(setImmediate);
-    // on xsnap, we must do it twice for some reason
-    await new Promise(setImmediate);
-    gcPower();
-    // this gives finalizers a chance to run
-    await new Promise(setImmediate);
-    // Node.js seems to need another for promises to get cleared out
-    await new Promise(setImmediate);
-  };
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"spawnSubprocessWorker.d.ts","sourceRoot":"","sources":["spawnSubprocessWorker.js"],"names":[],"mappings":";AA8BA;;;;;;;;;;;EAwDC;qBAlEc,OAAO,eAAe,EAAE,MAAM;uBAC9B,OAAO,QAAQ,EAAE,QAAQ"}

package/src/lib-nodejs/spawnSubprocessWorker.js

@@ -1,87 +0,0 @@
-// this file is loaded by the controller, in the start compartment
-import { spawn } from 'child_process';
-import { makePromiseKit } from '@endo/promise-kit';
-import { NonNullish } from '@agoric/assert';
-import { arrayEncoderStream, arrayDecoderStream } from './worker-protocol.js';
-import {
-  netstringEncoderStream,
-  netstringDecoderStream,
-} from '../netstring.js';
-
-// Start a subprocess from a given executable, and arrange a bidirectional
-// message channel with a "supervisor" within that process. Return a {
-// toChild, fromChild } pair of Streams which accept/emit hardened Arrays of
-// JSON-serializable data.
-
-// eslint-disable-next-line no-unused-vars
-function parentLog(first, ...args) {
-  // console.error(`--parent: ${first}`, ...args);
-}
-
-/** @typedef { import('child_process').IOType } IOType */
-/** @typedef { import('stream').Writable } Writable */
-
-// we send on fd3, and receive on fd4. We pass fd1/2 (stdout/err) through, so
-// console log/err from the child shows up normally. We don't use Node's
-// built-in serialization feature ('ipc') because the child process won't
-// always be Node.
-/** @type { IOType[] } */
-const stdio = harden(['inherit', 'inherit', 'inherit', 'pipe', 'pipe']);
-
-export function startSubprocessWorker(
-  execPath,
-  procArgs = [],
-  { netstringMaxChunkSize = undefined } = {},
-) {
-  const proc = spawn(execPath, procArgs, { stdio });
-
-  const toChild = arrayEncoderStream();
-  toChild
-    .pipe(netstringEncoderStream())
-    .pipe(/** @type {Writable} */ (proc.stdio[3]));
-  // proc.stdio[4].setEncoding('utf-8');
-  const fromChild = NonNullish(proc.stdio[4])
-    .pipe(netstringDecoderStream(netstringMaxChunkSize))
-    .pipe(arrayDecoderStream());
-
-  // fromChild.addListener('data', data => parentLog(`fd4 data`, data));
-  // toChild.write('hello child');
-
-  const pk = makePromiseKit();
-
-  proc.once('exit', code => {
-    parentLog('child exit', code);
-    pk.resolve(code);
-  });
-  proc.once('error', e => {
-    parentLog('child error', e);
-    pk.reject(e);
-  });
-  parentLog(`waiting on child`);
-
-  function terminate() {
-    proc.kill();
-  }
-
-  // the Transform objects don't like being hardened, so we wrap the methods
-  // that get used
-  /* @type {typeof fromChild} */
-  const wrappedFromChild = {
-    on: (...args) =>
-      fromChild.on(.../** @type {Parameters<typeof fromChild['on']>} */ (args)),
-  };
-  /* @type {typeof toChild} */
-  const wrappedToChild = {
-    write: (...args) =>
-      toChild.write(
-        .../** @type {Parameters<typeof toChild['write']>} */ (args),
-      ),
-  };
-
-  return harden({
-    fromChild: wrappedFromChild,
-    toChild: wrappedToChild,
-    terminate,
-    done: pk.promise,
-  });
-}

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

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

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

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

package/src/lib-nodejs/waitUntilQuiescent.js

@@ -1,18 +0,0 @@
-/* global setImmediate */
-import { makePromiseKit } from '@endo/promise-kit';
-
-// This can only be imported from the Start Compartment, where 'setImmediate'
-// is available.
-
-export function waitUntilQuiescent() {
-  // the delivery might cause some number of (native) Promises to be
-  // created and resolved, so we use the IO queue to detect when the
-  // Promise queue is empty. The IO queue (setImmediate and setTimeout) is
-  // lower-priority than the Promise queue on browsers and Node 11, but on
-  // Node 10 it is higher. So this trick requires Node 11.
-  // https://jsblog.insiderattack.net/new-changes-to-timers-and-microtasks-from-node-v11-0-0-and-above-68d112743eb3
-  /** @type {import('@endo/promise-kit').PromiseKit<void>} */
-  const { promise: queueEmptyP, resolve } = makePromiseKit();
-  setImmediate(() => resolve());
-  return queueEmptyP;
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"worker-protocol.d.ts","sourceRoot":"","sources":["worker-protocol.js"],"names":[],"mappings":"AAMA,gDAsBC;AAED,gDAyBC;0BAtDyB,QAAQ"}

package/src/lib-nodejs/worker-protocol.js

@@ -1,56 +0,0 @@
-/* global Buffer */
-import { Transform } from 'stream';
-
-// Transform objects which convert from hardened Arrays of JSON-serializable
-// data into Buffers suitable for netstring conversion.
-
-export function arrayEncoderStream() {
-  /**
-   *
-   * @this {{ push: (b: Buffer) => void }}
-   * @param {*} object
-   * @param {BufferEncoding} encoding
-   * @param {*} callback
-   */
-  function transform(object, encoding, callback) {
-    if (!Array.isArray(object)) {
-      throw Error('stream requires Arrays');
-    }
-    let err;
-    try {
-      this.push(Buffer.from(JSON.stringify(object)));
-    } catch (e) {
-      err = e;
-    }
-    callback(err);
-  }
-  // Array in, Buffer out, hence writableObjectMode
-  return new Transform({ transform, writableObjectMode: true });
-}
-
-export function arrayDecoderStream() {
-  /**
-   *
-   * @this {{ push: (b: Buffer) => void }}
-   * @param {Buffer} buf
-   * @param {BufferEncoding} encoding
-   * @param {*} callback
-   */
-  function transform(buf, encoding, callback) {
-    let err;
-    try {
-      if (!Buffer.isBuffer(buf)) {
-        throw Error('stream expects Buffers');
-      }
-      this.push(JSON.parse(buf.toString()));
-    } catch (e) {
-      err = e;
-    }
-    // this Transform is a one-to-one conversion of Buffer into Array, so we
-    // always consume the input each time we're called
-    callback(err);
-  }
-
-  // Buffer in, Array out, hence readableObjectMode
-  return new Transform({ transform, readableObjectMode: true });
-}

package/src/marshal.d.ts

@@ -1,17 +0,0 @@
-export function makeBoardRemote({ boardId, iface }: any): BoardRemote;
-export function slotToBoardRemote(boardId: any, iface: any): BoardRemote;
-export function boardValToSlot(val: any): any;
-export function boardSlottingMarshaller(slotToVal?: ((slot: string, iface: string) => any) | undefined): Omit<import('@endo/marshal').Marshal<string>, 'serialize' | 'unserialize'>;
-export function unmarshalFromVstorage(data: Map<string, string>, key: string, fromCapData: ReturnType<typeof import('@endo/marshal').makeMarshal>['fromCapData'], index: number): any;
-export function makeHistoryReviver(entries: Array<[string, string]>, slotToVal?: ((slot: string, iface?: string) => any) | undefined): {
-    getItem: (key: any) => any;
-    children: (prefix: any) => string[];
-    has: (k: any) => boolean;
-};
-/**
- * Should be a union with Remotable, but that's `any`, making this type meaningless
- */
-export type BoardRemote = {
-    getBoardId: () => string;
-};
-//# 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":"AAgBO,0DAFM,WAAW,CAKvB;AAEM,yEAC8B;AAE9B,8CAKN;AAWM,4DAHW,MAAM,SAAS,MAAM,KAAK,GAAG,gBAClC,KAAK,OAAO,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,CAMtF;AAyBM,4CALI,IAAI,MAAM,EAAE,MAAM,CAAC,OACnB,MAAM,eACN,WAAW,cAAc,eAAe,EAAE,WAAW,CAAC,CAAC,aAAa,CAAC,SACrE,MAAM,OAwBhB;AASM,4CAHI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,sBAChB,MAAM,UAAU,MAAM,KAAK,GAAG;;;;EAoB/C;;;;0BA7GY;IAAE,UAAU,EAAE,MAAM,MAAM,CAAA;CAAE"}

package/src/marshal.js

@@ -1,119 +0,0 @@
-import { Far } from '@endo/far';
-import { makeMarshal } from '@endo/marshal';
-import { isStreamCell } from './lib-chainStorage.js';
-
-const { Fail } = assert;
-
-/**
- * Should be a union with Remotable, but that's `any`, making this type meaningless
- *
- * @typedef {{ getBoardId: () => string }} BoardRemote
- */
-
-/**
- * @param {*} slotInfo
- * @returns {BoardRemote}
- */
-export const makeBoardRemote = ({ boardId, iface }) => {
-  const nonalleged = iface ? iface.replace(/^Alleged: /, '') : '';
-  return Far(`BoardRemote${nonalleged}`, { getBoardId: () => boardId });
-};
-
-export const slotToBoardRemote = (boardId, iface) =>
-  makeBoardRemote({ boardId, iface });
-
-export const boardValToSlot = val => {
-  if ('getBoardId' in val) {
-    return val.getBoardId();
-  }
-  Fail`unknown obj in boardSlottingMarshaller.valToSlot ${val}`;
-};
-
-/**
- * A marshaller which can serialize getBoardId() -bearing
- * Remotables. This allows the caller to pick their slots. The
- * deserializer is configurable: the default cannot handle
- * Remotable-bearing data.
- *
- * @param {(slot: string, iface: string) => any} [slotToVal]
- * @returns {Omit<import('@endo/marshal').Marshal<string>, 'serialize' | 'unserialize'>}
- */
-export const boardSlottingMarshaller = (slotToVal = undefined) => {
-  return makeMarshal(boardValToSlot, slotToVal, {
-    serializeBodyFormat: 'smallcaps',
-  });
-};
-
-// TODO: Consolidate with `insistCapData` functions from swingset-liveslots,
-// swingset-xsnap-supervisor, etc.
-/**
- * @param {unknown} data
- * @returns {asserts data is import('@endo/marshal').CapData<string>}
- */
-const assertCapData = data => {
-  assert.typeof(data, 'object');
-  assert(data);
-  assert.typeof(data.body, 'string');
-  assert(Array.isArray(data.slots));
-  // XXX check that the .slots array elements are actually strings
-};
-harden(assertCapData);
-
-/**
- * Read and unmarshal a value from a map representation of vstorage data
- *
- * @param {Map<string, string>} data
- * @param {string} key
- * @param {ReturnType<typeof import('@endo/marshal').makeMarshal>['fromCapData']} fromCapData
- * @param {number} index index of the desired value in a deserialized stream cell
- */
-export const unmarshalFromVstorage = (data, key, fromCapData, index) => {
-  const serialized = data.get(key) || Fail`no data for ${key}`;
-  assert.typeof(serialized, 'string');
-  assert.typeof(index, 'number');
-
-  const streamCell = JSON.parse(serialized);
-  if (!isStreamCell(streamCell)) {
-    throw Fail`not a StreamCell: ${streamCell}`;
-  }
-
-  const { values } = streamCell;
-  values.length > 0 || Fail`no StreamCell values: ${streamCell}`;
-
-  const marshalled = values.at(index);
-  assert.typeof(marshalled, 'string');
-
-  /** @type {import("@endo/marshal").CapData<string>} */
-  const capData = harden(JSON.parse(marshalled));
-  assertCapData(capData);
-
-  const unmarshalled = fromCapData(capData);
-  return unmarshalled;
-};
-harden(unmarshalFromVstorage);
-
-/**
- * Provide access to object graphs serialized in vstorage.
- *
- * @param {Array<[string, string]>} entries
- * @param {(slot: string, iface?: string) => any} [slotToVal]
- */
-export const makeHistoryReviver = (entries, slotToVal = undefined) => {
-  const board = boardSlottingMarshaller(slotToVal);
-  const vsMap = new Map(entries);
-  const fromCapData = (...args) =>
-    Reflect.apply(board.fromCapData, board, args);
-  const getItem = key => unmarshalFromVstorage(vsMap, key, fromCapData, -1);
-  const children = prefix => {
-    prefix.endsWith('.') || Fail`prefix must end with '.'`;
-    return harden([
-      ...new Set(
-        entries
-          .map(([k, _]) => k)
-          .filter(k => k.startsWith(prefix))
-          .map(k => k.slice(prefix.length).split('.')[0]),
-      ),
-    ]);
-  };
-  return harden({ getItem, children, has: k => vsMap.get(k) !== undefined });
-};

package/src/netstring.d.ts

@@ -1,13 +0,0 @@
-/**
- * @param {Buffer} data
- * @returns {Buffer} netstring-wrapped
- */
-export function encode(data: Buffer): Buffer;
-export function netstringEncoderStream(): Transform;
-export function decode(data: any, optMaxChunkSize: any): {
-    leftover: any;
-    payloads: any[];
-};
-export function netstringDecoderStream(optMaxChunkSize: any): Transform;
-import { Transform } from 'stream';
-//# sourceMappingURL=netstring.d.ts.map

package/src/netstring.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"netstring.d.ts","sourceRoot":"","sources":["netstring.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,6BAHW,MAAM,GACJ,MAAM,CAMlB;AAGD,oDAuBC;AAMD;;;EAgCC;AAGD,wEAkCC;0BAlHyB,QAAQ"}

package/src/netstring.js

@@ -1,119 +0,0 @@
-/* global Buffer */
-import { Fail } from '@agoric/assert';
-
-// adapted from 'netstring-stream', https://github.com/tlivings/netstring-stream/
-import { Transform } from 'stream';
-
-const COLON = 58;
-const COMMA = 44;
-
-/**
- * @param {Buffer} data
- * @returns {Buffer} netstring-wrapped
- */
-export function encode(data) {
-  const prefix = Buffer.from(`${data.length}:`);
-  const suffix = Buffer.from(',');
-  return Buffer.concat([prefix, data, suffix]);
-}
-
-// input is a sequence of strings, output is a byte pipe
-export function netstringEncoderStream() {
-  /**
-   *
-   * @this {{ push: (b: Buffer) => void }}
-   * @param {Buffer} chunk
-   * @param {BufferEncoding} encoding
-   * @param {*} callback
-   */
-  function transform(chunk, encoding, callback) {
-    if (!Buffer.isBuffer(chunk)) {
-      throw Error('stream requires Buffers');
-    }
-    let err;
-    try {
-      this.push(encode(chunk));
-    } catch (e) {
-      err = e;
-    }
-    callback(err);
-  }
-  // (maybe empty) Buffer in, Buffer out. We use writableObjectMode to
-  // indicate that empty input buffers are important
-  return new Transform({ transform, writableObjectMode: true });
-}
-
-// Input is a Buffer containing zero or more netstrings and maybe some
-// leftover bytes. Output is zero or more decoded Buffers, one per netstring,
-// plus a Buffer of leftover bytes.
-//
-export function decode(data, optMaxChunkSize) {
-  // TODO: it would be more efficient to accumulate pending data in an array,
-  // rather than doing a concat each time
-  let start = 0;
-  const payloads = [];
-
-  for (;;) {
-    const colon = data.indexOf(COLON, start);
-    if (colon === -1) {
-      break; // still waiting for `${LENGTH}:`
-    }
-    const sizeString = data.toString('utf-8', start, colon);
-    const size = parseInt(sizeString, 10);
-    if (!(size > -1)) {
-      // reject NaN, all negative numbers
-      Fail`unparsable size ${sizeString}, should be integer`;
-    }
-    if (optMaxChunkSize) {
-      size <= optMaxChunkSize ||
-        Fail`size ${size} exceeds limit of ${optMaxChunkSize}`;
-    }
-    if (data.length < colon + 1 + size + 1) {
-      break; // still waiting for `${DATA}.`
-    }
-    data[colon + 1 + size] === COMMA ||
-      Fail`malformed netstring: not terminated by comma`;
-    payloads.push(data.subarray(colon + 1, colon + 1 + size));
-    start = colon + 1 + size + 1;
-  }
-
-  const leftover = data.subarray(start);
-  return { leftover, payloads };
-}
-
-// input is a byte pipe, output is a sequence of Buffers
-export function netstringDecoderStream(optMaxChunkSize) {
-  let buffered = Buffer.from('');
-  /**
-   *
-   * @this {{ push: (b: Buffer) => void }}
-   * @param {Buffer} chunk
-   * @param {BufferEncoding} encoding
-   * @param {*} callback
-   */
-  function transform(chunk, encoding, callback) {
-    if (!Buffer.isBuffer(chunk)) {
-      throw Error('stream requires Buffers');
-    }
-    buffered = Buffer.concat([buffered, chunk]);
-    let err;
-    try {
-      const { leftover, payloads } = decode(buffered, optMaxChunkSize);
-      buffered = leftover;
-      for (let i = 0; i < payloads.length; i += 1) {
-        this.push(payloads[i]);
-      }
-    } catch (e) {
-      err = e;
-    }
-    // we buffer all data internally, to accommodate netstrings larger than
-    // Transform's default buffer size, and callback() indicates that we've
-    // consumed the input
-    callback(err);
-  }
-
-  // Buffer in, Buffer out, except that each output Buffer is precious, even
-  // empty ones, and without readableObjectMode the Stream will discard empty
-  // buffers
-  return new Transform({ transform, readableObjectMode: true });
-}

package/src/tokens.d.ts

@@ -1,34 +0,0 @@
-export namespace Stable {
-    export let symbol: "IST";
-    export let denom: "uist";
-    export let proposedName: "Agoric stable token";
-    export { NAT as assetKind };
-    export namespace displayInfo {
-        export let decimalPlaces: 6;
-        export { NAT as assetKind };
-    }
-}
-export namespace Stake {
-    let symbol_1: "BLD";
-    export { symbol_1 as symbol };
-    let denom_1: "ubld";
-    export { denom_1 as denom };
-    let proposedName_1: "Agoric staking token";
-    export { proposedName_1 as proposedName };
-    export { NAT as assetKind };
-    export namespace displayInfo_1 {
-        let decimalPlaces_1: 6;
-        export { decimalPlaces_1 as decimalPlaces };
-        export { NAT as assetKind };
-    }
-    export { displayInfo_1 as displayInfo };
-}
-export type TokenKeyword = 'IST' | 'BLD';
-/** @typedef {'IST' | 'BLD'} TokenKeyword */
-/**
- * This is defined by ERTP. For dependency pragmatism it's repeated here. We
- * rely on the static type check and unit tests to detect any incompatibility.
- */
-declare const NAT: "nat";
-export {};
-//# sourceMappingURL=tokens.d.ts.map

package/src/tokens.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["tokens.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;2BAEc,KAAK,GAAG,KAAK;AAA3B,4CAA4C;AAE5C;;;GAGG;AACH,yBAAkB"}

package/src/tokens.js

@@ -1,35 +0,0 @@
-// @ts-check
-
-/** @typedef {'IST' | 'BLD'} TokenKeyword */
-
-/**
- * This is defined by ERTP. For dependency pragmatism it's repeated here. We
- * rely on the static type check and unit tests to detect any incompatibility.
- */
-const NAT = 'nat';
-
-export const Stable = harden(
-  /** @type {const} */ ({
-    symbol: 'IST',
-    denom: 'uist',
-    proposedName: 'Agoric stable token',
-    assetKind: NAT,
-    displayInfo: {
-      decimalPlaces: 6,
-      assetKind: NAT,
-    },
-  }),
-);
-
-export const Stake = harden(
-  /** @type {const} */ ({
-    symbol: 'BLD',
-    denom: 'ubld',
-    proposedName: 'Agoric staking token',
-    assetKind: NAT,
-    displayInfo: {
-      decimalPlaces: 6,
-      assetKind: NAT,
-    },
-  }),
-);