@agoric/internal 0.4.0-upgrade-14-dev-0169c7e.0 → 0.4.0-upgrade-16-dev-07b0130.0

package/src/lib-nodejs/spawnSubprocessWorker.js

@@ -0,0 +1,89 @@
+// 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

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

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

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

package/src/lib-nodejs/waitUntilQuiescent.js

@@ -0,0 +1,18 @@
+/* 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

@@ -0,0 +1,4 @@
+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

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

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

@@ -0,0 +1,54 @@
+/* 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() {
+  /**
+   * @param {any} object
+   * @param {BufferEncoding} encoding
+   * @param {any} callback
+   * @this {{ push: (b: Buffer) => void }}
+   */
+  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() {
+  /**
+   * @param {Buffer} buf
+   * @param {BufferEncoding} encoding
+   * @param {any} callback
+   * @this {{ push: (b: Buffer) => void }}
+   */
+  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/magic-cookie-test-only.js

@@ -3,8 +3,8 @@
 const cookie = harden({});
 
 /**
- * Facilitate static analysis to prevent
- * demo/test facilities from being bundled in production.
+ * Facilitate static analysis to prevent demo/test facilities from being bundled
+ * in production.
  */
 export const notForProductionUse = () => {
   return cookie;

package/src/marshal.d.ts

@@ -0,0 +1,20 @@
+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) | undefined): Omit<import("@endo/marshal").Marshal<string | null>, "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: [string, string][], slotToVal?: ((slot: string, iface?: string) => any) | undefined): {
+    getItem: (key: string) => any;
+    children: (prefix: string) => string[];
+    has: (k: string) => boolean;
+};
+/**
+ * Should be a union with Remotable, but that's `any`, making this type
+ * meaningless
+ */
+export type BoardRemote = {
+    getBoardId: () => string | null;
+};
+//# sourceMappingURL=marshal.d.ts.map

package/src/marshal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marshal.d.ts","sourceRoot":"","sources":["marshal.js"],"names":[],"mappings":"AAkBO,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,4DANW,MAAM,SAAS,MAAM,KAAK,GAAG,gBAClC,IAAI,CAChB,OAAW,eAAe,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,EAClD,WAAe,GAAG,aAAa,CAC5B,CAMH;AA6BM,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,sBACX,MAAM,UAAU,MAAM,KAAK,GAAG;mBAQlC,MAAM;uBAEN,MAAM;aAYN,MAAM;EAInB;;;;;0BA9HY;IAAE,UAAU,EAAE,MAAM,MAAM,GAAG,IAAI,CAAA;CAAE"}

package/src/marshal.js

@@ -0,0 +1,138 @@
+// @ts-check
+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 | null }} BoardRemote
+ */
+
+/**
+ * @param {{ boardId: string | null; iface?: string }} slotInfo
+ * @returns {BoardRemote}
+ */
+export const makeBoardRemote = ({ boardId, iface }) => {
+  const nonalleged = iface ? iface.replace(/^Alleged: /, '') : '';
+  return Far(`BoardRemote${nonalleged}`, { getBoardId: () => boardId });
+};
+
+/**
+ * @param {string} boardId
+ * @param {string} iface
+ */
+export const slotToBoardRemote = (boardId, iface) =>
+  makeBoardRemote({ boardId, iface });
+
+/** @param {BoardRemote | object} val */
+const boardValToSlot = val => {
+  if ('getBoardId' in val) {
+    return val.getBoardId();
+  }
+  throw 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 | null>,
+ *   '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
+ * @returns {any}
+ */
+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 {[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);
+  /** @param {...unknown} args } */
+  const fromCapData = (...args) =>
+    Reflect.apply(board.fromCapData, board, args);
+  /** @param {string} key } */
+  const getItem = key => unmarshalFromVstorage(vsMap, key, fromCapData, -1);
+  /** @param {string} prefix } */
+  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]),
+      ),
+    ]);
+  };
+  /** @param {string} k } */
+  const has = k => vsMap.get(k) !== undefined;
+
+  return harden({ getItem, children, has });
+};

package/src/method-tools.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"method-tools.d.ts","sourceRoot":"","sources":["method-tools.js"],"names":[],"mappings":"AAyCO,gFAoBN;AAgCM,8EAeJ"}
+{"version":3,"file":"method-tools.d.ts","sourceRoot":"","sources":["method-tools.js"],"names":[],"mappings":"AA0CO,+BAJoB,CAAC,SAAd,WAAY,OACf,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GACZ,CAAC,EAAE,CAsBf;AAUM,qCAJoB,CAAC,SAAd,WAAY,OACf,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GACZ,MAAM,EAAE,CAKlB;AA+BI,+BAJiC,CAAC,SAA3B,MAAM,CAAC,WAAW,EAAE,GAAG,CAAE,OAC5B,CAAC,GACC,CAAC,CAiBX"}

package/src/method-tools.js

@@ -2,7 +2,8 @@
 import { isObject } from '@endo/marshal';
 
 /**
- * @file method-tools use dynamic property lookup, which is not Jessie-compatible
+ * @file method-tools use dynamic property lookup, which is not
+ *   Jessie-compatible
  */
 
 const { getPrototypeOf, create, fromEntries, getOwnPropertyDescriptors } =
@@ -12,8 +13,8 @@ const { ownKeys, apply } = Reflect;
 /**
  * Prioritize symbols as earlier than strings.
  *
- * @param {string|symbol} a
- * @param {string|symbol} b
+ * @param {string | symbol} a
+ * @param {string | symbol} b
  * @returns {-1 | 0 | 1}
  */
 const compareStringified = (a, b) => {
@@ -62,25 +63,37 @@ export const getMethodNames = val => {
 };
 harden(getMethodNames);
 
+/**
+ * The subset of `getMethodNames` containing only string names, without symbols
+ *
+ * @template {PropertyKey} K
+ * @param {Record<K, any>} val
+ * @returns {string[]}
+ */
+export const getStringMethodNames = val =>
+  /** @type {string[]} */ (
+    getMethodNames(val).filter(name => typeof name === 'string')
+  );
+
 /**
  * TODO This function exists only to ease the
  * https://github.com/Agoric/agoric-sdk/pull/5970 transition, from all methods
- * being own properties to methods being inherited from a common prototype.
- * This transition breaks two patterns used in prior code: autobinding,
- * and enumerating methods by enumerating own properties. For both, the
- * preferred repairs are
- *    * autobinding: Replace, for example,
- *      `foo(obj.method)` with `foo(arg => `obj.method(arg))`. IOW, stop relying
- *      on expressions like `obj.method` to extract a method still bound to the
- *      state of `obj` because, for virtual and durable objects,
- *      they no longer will after #5970.
- *    * method enumeration: Replace, for example
- *      `Reflect.ownKeys(obj)` with `getMethodNames(obj)`.
+ * being own properties to methods being inherited from a common prototype. This
+ * transition breaks two patterns used in prior code: autobinding, and
+ * enumerating methods by enumerating own properties. For both, the preferred
+ * repairs are
+ *
+ * - autobinding: Replace, for example, `foo(obj.method)` with `foo(arg =>
+ *   `obj.method(arg))`. IOW, stop relying on expressions like `obj.method`to
+ *   extract a method still bound to the state of`obj` because, for virtual and
+ *   durable objects, they no longer will after #5970.
+ * - method enumeration: Replace, for example `Reflect.ownKeys(obj)` with
+ *   `getMethodNames(obj)`.
  *
  * Once all problematic cases have been converted in this manner, this
  * `bindAllMethods` hack can and TODO should be deleted. However, we currently
- * have no reliable static way to track down and fix all autobinding sites.
- * For those objects that have not yet been fully repaired by the above two
+ * have no reliable static way to track down and fix all autobinding sites. For
+ * those objects that have not yet been fully repaired by the above two
  * techniques, `bindAllMethods` creates an object that acts much like the
  * pre-#5970 objects, with all their methods as instance-bound own properties.
  * It does this by making a new object inheriting from `obj` where the new

package/src/netstring.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {Buffer} data
+ * @returns {Buffer} netstring-wrapped
+ */
+export function encode(data: Buffer): Buffer;
+export function netstringEncoderStream(): Transform;
+/**
+ * @param {Buffer} data containing zero or more netstrings and maybe some
+ *   leftover bytes
+ * @param {number} [optMaxChunkSize]
+ * @returns {{ leftover: Buffer; payloads: Buffer[] }} zero or more decoded
+ *   Buffers, one per netstring,
+ */
+export function decode(data: Buffer, optMaxChunkSize?: number | undefined): {
+    leftover: Buffer;
+    payloads: Buffer[];
+};
+/**
+ * @param {number} [optMaxChunkSize]
+ * @returns {Transform}
+ */
+export function netstringDecoderStream(optMaxChunkSize?: number | undefined): Transform;
+import { Transform } from 'stream';
+//# sourceMappingURL=netstring.d.ts.map

package/src/netstring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"netstring.d.ts","sourceRoot":"","sources":["netstring.js"],"names":[],"mappings":"AASA;;;GAGG;AACH,6BAHW,MAAM,GACJ,MAAM,CAMlB;AAGD,oDAsBC;AAED;;;;;;GAMG;AACH,6BANW,MAAM,yCAGJ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAmCpD;AAED;;;GAGG;AAEH,8EAHa,SAAS,CAoCrB;0BAvHyB,QAAQ"}

package/src/netstring.js

@@ -0,0 +1,124 @@
+/* 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() {
+  /**
+   * @param {Buffer} chunk
+   * @param {BufferEncoding} encoding
+   * @param {any} callback
+   * @this {{ push: (b: Buffer) => void }}
+   */
+  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 });
+}
+
+/**
+ * @param {Buffer} data containing zero or more netstrings and maybe some
+ *   leftover bytes
+ * @param {number} [optMaxChunkSize]
+ * @returns {{ leftover: Buffer; payloads: Buffer[] }} zero or more decoded
+ *   Buffers, one per netstring,
+ */
+export function decode(data, 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 };
+}
+
+/**
+ * @param {number} [optMaxChunkSize]
+ * @returns {Transform}
+ */
+// input is a byte pipe, output is a sequence of Buffers
+export function netstringDecoderStream(optMaxChunkSize) {
+  let buffered = Buffer.from('');
+  /**
+   * @param {Buffer} chunk
+   * @param {BufferEncoding} encoding
+   * @param {any} callback
+   * @this {{ push: (b: Buffer) => void }}
+   */
+  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/node/buffer-line-transform.d.ts

@@ -1,41 +1,45 @@
-/// <reference types="node" />
 /**
  * @typedef {object} BufferLineTransformOptions
- * @property {Buffer | string | number} [break] line break matcher for Buffer.indexOf() (default: 10)
- * @property {BufferEncoding} [breakEncoding] if break is a string, the encoding to use
+ * @property {Buffer | string | number} [break] line break matcher for
+ *   Buffer.indexOf() (default: 10)
+ * @property {BufferEncoding} [breakEncoding] if break is a string, the encoding
+ *   to use
  */
 export default class BufferLineTransform extends Transform {
     /**
-     * The BufferLineTransform is reading String or Buffer content from a Readable stream
-     * and writing each line as a Buffer in object mode
+     * The BufferLineTransform is reading String or Buffer content from a Readable
+     * stream and writing each line as a Buffer in object mode
      *
-     * @param {import('node:stream').TransformOptions & BufferLineTransformOptions} [options]
+     * @param {import('node:stream').TransformOptions &
+     *   BufferLineTransformOptions} [options]
      */
     constructor(options?: (import("stream").TransformOptions & BufferLineTransformOptions) | undefined);
     _breakValue: string | number | Buffer;
     _breakEncoding: BufferEncoding | undefined;
     _breakLength: number;
-    /** @type {Array<Buffer>} */
-    _chunks: Array<Buffer>;
+    /** @type {Buffer[]} */
+    _chunks: Buffer[];
     /**
-     * @override
      * @param {any} chunk
      * @param {BufferEncoding | 'buffer'} encoding
      * @param {import('node:stream').TransformCallback} cb
+     * @override
      */
-    override _transform(chunk: any, encoding: BufferEncoding | 'buffer', cb: import('node:stream').TransformCallback): void;
+    override _transform(chunk: any, encoding: BufferEncoding | "buffer", cb: import("node:stream").TransformCallback): void;
     /** @param {Buffer} line */
     _writeItem(line: Buffer): void;
 }
 export type BufferLineTransformOptions = {
     /**
-     * line break matcher for Buffer.indexOf() (default: 10)
+     * line break matcher for
+     * Buffer.indexOf() (default: 10)
      */
     break?: string | number | Buffer | undefined;
     /**
-     * if break is a string, the encoding to use
+     * if break is a string, the encoding
+     * to use
      */
     breakEncoding?: BufferEncoding | undefined;
 };
-import { Transform } from "stream";
+import { Transform } from 'node:stream';
 //# sourceMappingURL=buffer-line-transform.d.ts.map

package/src/node/buffer-line-transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buffer-line-transform.d.ts","sourceRoot":"","sources":["buffer-line-transform.js"],"names":[],"mappings":";AAKA;;;;GAIG;AAEH;IACE;;;;;OAKG;IACH,oGAuBC;IAhBC,sCAAmC;IACnC,2CAAmC;IAWnC,qBAA+B;IAE/B,4BAA4B;IAC5B,SADW,MAAM,MAAM,CAAC,CACP;IAGnB;;;;;OAKG;IACH,2BAJW,GAAG,YACH,cAAc,GAAG,QAAQ,MACzB,OAAO,aAAa,EAAE,iBAAiB,QAgDjD;IAeD,2BAA2B;IAC3B,iBADY,MAAM,QAOjB;CACF"}
+{"version":3,"file":"buffer-line-transform.d.ts","sourceRoot":"","sources":["buffer-line-transform.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AAEH;IACE;;;;;;OAMG;IACH,oGAuBC;IAhBC,sCAAmC;IACnC,2CAAmC;IAWnC,qBAA+B;IAE/B,uBAAuB;IACvB,SADW,MAAM,EAAE,CACF;IAGnB;;;;;OAKG;IACH,2BALW,GAAG,YACH,cAAc,GAAG,QAAQ,MACzB,OAAO,aAAa,EAAE,iBAAiB,QAiDjD;IAeD,2BAA2B;IAC3B,iBADY,MAAM,QAOjB;CACF;;;;;;;;;;;;;0BAtHyB,aAAa"}