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

package/src/marshal/wrap-marshaller.js

@@ -0,0 +1,439 @@
+// @ts-check
+import { makeCacheMapKit } from '@endo/cache-map';
+import { Fail, q } from '@endo/errors';
+import { E } from '@endo/eventual-send';
+import { Far } from '@endo/far';
+import { PASS_STYLE } from '@endo/pass-style';
+import { makeMarshal } from '@endo/marshal';
+import { makeInaccessibleVal } from './inaccessible-val.js';
+
+/**
+ * @import {WeakMapAPI} from '@endo/cache-map';
+ * @import {EOnly} from '@endo/eventual-send';
+ * @import {RemotableObject, Simplify} from '@endo/pass-style';
+ * @import {CapData, Passable, Marshal, MakeMarshalOptions} from '@endo/marshal';
+ * @import {ERemote} from '../types.js';
+ */
+
+/**
+ * A Marshaller which methods may be async. Use this type to indicate accepting
+ * either a sync or async marshaller, usually through `E` eventual-sends.
+ *
+ * @template [Slot=unknown]
+ * @typedef {Simplify<EOnly<Marshal<Slot>>>} EMarshaller
+ */
+
+const { slotToWrapper, wrapperToSlot } = (() => {
+  /** @typedef {'Remotable' | `Alleged: ${string}`} InterfaceSpec */
+
+  /** @template [Slot=unknown] */
+  class SlotWrapper {
+    /** @type {Slot} */
+    #slot;
+
+    /** @type {InterfaceSpec} */
+    [Symbol.toStringTag];
+
+    /**
+     * @param {Slot} slot
+     * @param {string} [iface]
+     */
+    constructor(slot, iface) {
+      if (iface == null || iface === 'Remotable') {
+        iface = 'Remotable';
+      } else if (!iface.startsWith('Alleged: ')) {
+        iface = `Alleged: ${iface}`;
+      }
+      this.#slot = slot;
+      this[Symbol.toStringTag] = /** @type {InterfaceSpec} */ (iface);
+    }
+
+    /** @param {SlotWrapper} wrapper */
+    static getSlot(wrapper) {
+      return wrapper.#slot;
+    }
+  }
+  Object.defineProperties(SlotWrapper.prototype, {
+    [PASS_STYLE]: { value: 'remotable' },
+    [Symbol.toStringTag]: { value: 'Alleged: SlotWrapper' },
+  });
+  Reflect.deleteProperty(SlotWrapper.prototype, 'constructor');
+  harden(SlotWrapper);
+
+  /**
+   * @type {<Slot = unknown>(
+   *   wrapper: SlotWrapper<Slot> & RemotableObject<InterfaceSpec>,
+   * ) => Slot}
+   */
+  const getSlot = SlotWrapper.getSlot;
+
+  return {
+    /**
+     * @template [Slot=unknown]
+     * @param {Slot} slot
+     * @param {string} [iface]
+     */
+    slotToWrapper: (slot, iface) =>
+      /** @type {SlotWrapper<Slot> & RemotableObject<InterfaceSpec>} */ (
+        harden(new SlotWrapper(slot, iface))
+      ),
+
+    wrapperToSlot: getSlot,
+  };
+})();
+
+/**
+ * @template [Slot=unknown] @typedef {ReturnType<typeof slotToWrapper<Slot>>}
+ *   SlotWrapper
+ */
+
+const capacityOfDefaultCache = 50;
+
+// TODO(https://github.com/Agoric/agoric-sdk/issues/12111)
+// Check cost of using virtual-aware WeakMap in liveslots
+/**
+ * @template K
+ * @template V
+ * @param {boolean} [weakKey]
+ */
+const makeDefaultCacheMap = weakKey =>
+  /** @type {WeakMapAPI<K, V>} */ (
+    makeCacheMapKit(capacityOfDefaultCache, {
+      makeMap: weakKey ? WeakMap : Map,
+    }).cache
+  );
+
+/**
+ * Wraps a marshaller, either sync or async, local or remote, into a local async
+ * marshaller which only sends slots for resolution to the wrapped marshaller.
+ * Optionally and by default, caches the resolution of slots.
+ *
+ * Assumes that a null-ish slot value is a severed presence that can be resolved
+ * locally. By default if a presence is mapped to a null-ish slot by the wrapped
+ * marshaller, that mapping is not cached, allowing the wrapped marshaller to
+ * create a mapping in the future.
+ *
+ * @template [Slot=unknown]
+ * @param {ERemote<Pick<EMarshaller<Slot>, 'fromCapData' | 'toCapData'>>} marshaller
+ * @param {MakeMarshalOptions} [marshalOptions]
+ * @param {object} [caches]
+ * @param {WeakMapAPI<object, Slot> | null} [caches.valToSlot]
+ * @param {WeakMapAPI<Slot, object> | null} [caches.slotToVal]
+ * @param {boolean} [caches.cacheSeveredVal]
+ * @returns {ReturnType<typeof Far<EMarshaller<Slot>>>}
+ */
+export const wrapRemoteMarshallerSendSlotsOnly = (
+  marshaller,
+  {
+    serializeBodyFormat = 'smallcaps',
+    errorTagging = 'off', // Disable error tagging by default
+    ...otherMarshalOptions
+  } = {},
+  {
+    valToSlot = makeDefaultCacheMap(true),
+    slotToVal = makeDefaultCacheMap(false),
+    cacheSeveredVal = false,
+  } = {},
+) => {
+  const marshalOptions = harden({
+    serializeBodyFormat,
+    errorTagging,
+    ...otherMarshalOptions,
+  });
+  // The implementation of this wrapped marshaller internally uses 2 marshallers
+  // to transform the CapData into a Passable structure and vice-versa:
+  // - A cap pass-through marshaller which places capabilities as-is in the slots.
+  //   When unserializing CapData with null-ish slots, a severed presence is created.
+  //   This pass-through marshaller is used to locally process the structure, and
+  //   separate capabilities into a slots array for potential resolution by the
+  //   wrapped marshaller.
+  // - A "SlotWrapper" marshaller used to wrap into remotables the slots of the
+  //   wrapped marshaller. When unserializing CapData, it is used to recreate
+  //   CapData of a simple array of non-severed capabilities for resolution by
+  //   the wrapped marshaller. When serializing to CapData, it allows extracting
+  //   the slots from the capabilities array serialized by the wrapped marshaller.
+
+  /** @type {Marshal<object | null>} */
+  const passThroughMarshaller = makeMarshal(
+    undefined,
+    (slot, iface) => slot ?? makeInaccessibleVal(iface),
+    marshalOptions,
+  );
+
+  /** @type {Map<Slot, SlotWrapper<NonNullable<Slot>>>} */
+  const currentSlotToWrapper = new Map();
+
+  const convertWrapperToSlot = /** @type {typeof wrapperToSlot<Slot>} */ (
+    wrapperToSlot
+  );
+  /**
+   * @param {Slot} slot
+   * @param {string | undefined} [iface]
+   */
+  const convertSlotToWrapper = (slot, iface) => {
+    if (slot == null) {
+      // The wrapped marshaller may send us CapData with a null slot. These are not
+      // meant to be considered equivalent with each other, so bypass mapping.
+      return slotToWrapper(slot, iface);
+    }
+    let wrapper = currentSlotToWrapper.get(slot);
+    if (!wrapper) {
+      wrapper = slotToWrapper(slot, iface);
+      currentSlotToWrapper.set(slot, wrapper);
+    }
+
+    return wrapper;
+  };
+
+  /** @type {Pick<Marshal<Slot>, 'toCapData' | 'fromCapData'>} */
+  const slotWrapperMarshaller = makeMarshal(
+    convertWrapperToSlot,
+    convertSlotToWrapper,
+    marshalOptions,
+  );
+
+  /**
+   * Resolves an array of wrapped marshaller's slots to an array of
+   * capabilities.
+   *
+   * This is used by `fromCapData` to map slots before using the pass-through
+   * marshaller to recreate the passable data.
+   *
+   * @param {Slot[]} slots
+   * @param {(index: number) => SlotWrapper<NonNullable<Slot>>} getWrapper
+   * @returns {Promise<(object | null)[]>}
+   */
+  const mapSlotsToCaps = async (slots, getWrapper) => {
+    let hasRemoteCap = false;
+    const { length } = slots;
+    /** @type {(SlotWrapper<NonNullable<Slot>> | null | undefined)[]} */
+    const slotWrapperMappedSlots = Array.from({ length });
+    /** @type {(object | null | undefined)[]} */
+    const locallyResolvedCapSlots = Array.from({ length });
+
+    for (const [index, slot] of slots.entries()) {
+      if (slot === null) {
+        const nullSlot = /** @type {null} */ (slot);
+        slotWrapperMappedSlots[index] = nullSlot;
+        locallyResolvedCapSlots[index] = nullSlot;
+      } else if (slot !== undefined) {
+        const cachedCap = slotToVal?.get(slot);
+        if (cachedCap !== undefined) {
+          valToSlot?.set(cachedCap, slot);
+          locallyResolvedCapSlots[index] = cachedCap;
+        } else {
+          hasRemoteCap = true;
+          slotWrapperMappedSlots[index] = getWrapper(index);
+        }
+      }
+    }
+
+    await null;
+    if (hasRemoteCap) {
+      harden(slotWrapperMappedSlots);
+      const slotsOnlyCapData = slotWrapperMarshaller.toCapData(
+        slotWrapperMappedSlots,
+      );
+
+      /** @type {(object | null | undefined)[]} */
+      const remotelyResolvedCapSlots =
+        await E(marshaller).fromCapData(slotsOnlyCapData);
+
+      for (const [index, val] of remotelyResolvedCapSlots.entries()) {
+        if (val != null) {
+          const slot = slots[index];
+          slotToVal?.set(slot, val);
+          valToSlot?.set(val, slot);
+          locallyResolvedCapSlots[index] = val;
+        } else if (locallyResolvedCapSlots[index] === undefined) {
+          const slot = slots[index];
+          console.warn('⚠️ Unresolved local slot in wrapped marshaller', {
+            index,
+            slot,
+          });
+        }
+      }
+    }
+
+    return harden(locallyResolvedCapSlots);
+  };
+
+  /**
+   * Resolves an array of capabilities into an array of slots of the wrapped
+   * marshaller.
+   *
+   * This is used by `toCapData` to map slots after the pass-through marshaller
+   * has serialized the passable data.
+   *
+   * @param {object[]} caps
+   * @returns {Promise<Slot[]>}
+   */
+  const mapCapsToSlots = async caps => {
+    if (caps.length === 0) {
+      return caps;
+    }
+    let hasRemoteCap = false;
+    const { length } = caps;
+    /** @type {(Slot | null | undefined)[]} */
+    const locallyResolvedSlots = Array.from({ length });
+    /** @type {(object | null | undefined)[]} */
+    const remoteCapsToResolve = Array.from({ length });
+
+    for (const [index, cap] of caps.entries()) {
+      if (cap === null) {
+        // We shouldn't get null caps here, but we mirror handle them anyway
+        const nullCap = /** @type {null} */ (cap);
+        remoteCapsToResolve[index] = nullCap;
+        locallyResolvedSlots[index] = nullCap;
+      } else if (cap !== undefined) {
+        const cachedSlot = valToSlot?.get(cap);
+        if (cachedSlot !== undefined) {
+          if (cachedSlot !== null) {
+            slotToVal?.set(cachedSlot, cap);
+          }
+          locallyResolvedSlots[index] = cachedSlot;
+        } else {
+          hasRemoteCap = true;
+          remoteCapsToResolve[index] = cap;
+        }
+      }
+    }
+
+    await null;
+    if (hasRemoteCap) {
+      const remotelyResolvedSlotsCapData =
+        await E(marshaller).toCapData(remoteCapsToResolve);
+      try {
+        /** @type {(SlotWrapper<Slot> | null | undefined)[]} */
+        const slotWrapperMappedSlots = slotWrapperMarshaller.fromCapData(
+          remotelyResolvedSlotsCapData,
+        );
+        for (const [index, slotWrapper] of slotWrapperMappedSlots.entries()) {
+          if (slotWrapper != null) {
+            const slot = convertWrapperToSlot(slotWrapper);
+            const val = caps[index];
+            locallyResolvedSlots[index] = slot;
+            if (slot != null) {
+              slotToVal?.set(slot, val);
+            }
+            if (slot != null || cacheSeveredVal) {
+              valToSlot?.set(val, slot);
+            }
+          } else if (locallyResolvedSlots[index] === undefined) {
+            const cap = caps[index];
+            console.warn('⚠️ Unresolved local slot in wrapped marshaller', {
+              index,
+              cap,
+            });
+          }
+        }
+      } finally {
+        // We're done with the slotWrapperMarshaller, clear its state
+        currentSlotToWrapper.clear();
+      }
+    }
+
+    // All slots should have been resolved by now (or warned about)
+    return /** @type {Slot[]} */ (harden(locallyResolvedSlots));
+  };
+
+  /**
+   * Unfortunately CapData only contains iface information for slotted
+   * capabilities nested inside the body, which means we need to process the
+   * body to extract it. Maybe in the future CapData could be extended to carry
+   * this separately. See https://github.com/endojs/endo/issues/2991
+   *
+   * Since this helper is used internally to ultimately provide SlotWrapper
+   * objects to the corresponding marshaller, and that we use the same
+   * marshaller to extract the iface information, directly return the full
+   * SlotWrapper object instead of just the iface.
+   *
+   * @param {CapData<Slot>} data
+   */
+  const makeIfaceExtractor = data => {
+    const { slots } = data;
+    /** @param {number} index */
+    const getWrapper = index => {
+      const slot = slots[index];
+      let wrapper = currentSlotToWrapper.get(slot);
+      if (!wrapper) {
+        void slotWrapperMarshaller.fromCapData(data);
+      }
+      wrapper = currentSlotToWrapper.get(slot);
+      if (!wrapper) {
+        throw Fail`Marshaller didn't create wrapper for slot ${q(slot)} (index=${q(index)})`;
+      }
+      return wrapper;
+    };
+
+    return getWrapper;
+  };
+
+  /**
+   * @param {Passable} val
+   * @returns {Promise<CapData<Slot>>}
+   */
+  const toCapData = async val => {
+    const capData = passThroughMarshaller.toCapData(val);
+    const mappedSlots = await mapCapsToSlots(capData.slots);
+    return harden({ ...capData, slots: mappedSlots });
+  };
+
+  /**
+   * @param {CapData<Slot>} data
+   * @returns {Promise<Passable>}
+   */
+  const fromCapData = async data => {
+    const getWrapper = makeIfaceExtractor(data);
+    await null;
+    try {
+      const mappedSlots = await mapSlotsToCaps(data.slots, getWrapper);
+      return passThroughMarshaller.fromCapData({ ...data, slots: mappedSlots });
+    } finally {
+      currentSlotToWrapper.clear();
+    }
+  };
+
+  return Far('wrapped remote marshaller', {
+    toCapData,
+    fromCapData,
+
+    // for backwards compatibility
+    /** @deprecated use toCapData */
+    serialize: toCapData,
+    /** @deprecated use fromCapData */
+    unserialize: fromCapData,
+  });
+};
+
+/**
+ * @template [Slot=unknown]
+ * @param {ERemote<Pick<EMarshaller<Slot>, 'fromCapData' | 'toCapData'>>} marshaller
+ * @returns {ReturnType<typeof Far<EMarshaller<Slot>>>}
+ */
+export const wrapRemoteMarshallerDirectSend = marshaller => {
+  /**
+   * @param {Passable} val
+   * @returns {Promise<CapData<Slot>>}
+   */
+  const toCapData = val => E(marshaller).toCapData(val);
+
+  /**
+   * @param {CapData<Slot>} data
+   * @returns {Promise<Passable>}
+   */
+  const fromCapData = data => E(marshaller).fromCapData(data);
+
+  return Far('wrapped remote marshaller', {
+    toCapData,
+    fromCapData,
+
+    // for backwards compatibility
+    /** @deprecated use toCapData */
+    serialize: toCapData,
+    /** @deprecated use fromCapData */
+    unserialize: fromCapData,
+  });
+};
+
+export const wrapRemoteMarshaller = wrapRemoteMarshallerSendSlotsOnly;

package/src/natural-sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"natural-sort.d.ts","sourceRoot":"","sources":["natural-sort.js"],"names":[],"mappings":"AAqCO,kCAJI,MAAM,KACN,MAAM,GACJ,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAWtB"}
+{"version":3,"file":"natural-sort.d.ts","sourceRoot":"","sources":["natural-sort.js"],"names":[],"mappings":"AAgDO,kCAJI,MAAM,KACN,MAAM,GACJ,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAmCtB"}

package/src/natural-sort.js

@@ -1,3 +1,5 @@
+import { provideLazyMap } from './js-utils.js';
+
 /**
  * @param {string} a
  * @param {string} b
@@ -22,27 +24,60 @@ const compareNats = (a, b) => {
 // eslint-disable-next-line no-nested-ternary
 const compareStrings = (a, b) => (a > b ? 1 : a < b ? -1 : 0);
 
-const rPrefixedDigits = /^(\D*)(\d+)(\D.*|)/s;
+const rCaptureDigits = /([0-9]+)/;
+
+/**
+ * Splitting by regular expression can be expensive; we don't want to repeat
+ * that for every comparison against the same string.
+ *
+ * @type {Map<string, string[]>}
+ */
+const partsCache = new Map();
 
 /**
- * Perform a single-level natural-sort comparison, finding the first decimal
- * digit sequence in each operand and comparing first by the (possibly empty)
- * preceding prefix as strings, then by the digits as integers, then by any
- * following suffix (e.g., sorting 'ko42' before 'ko100' as ['ko', 42] vs.
- * ['ko', 100]).
+ * Perform a multi-level natural-sort comparison, finding the decimal digit
+ * sequences in each operand and comparing first by each ([possibly empty]
+ * string prefix, integer) pair in turn, with a final comparision by string
+ * suffix as necessary (e.g., sorting 'ko42' before 'ko100' as ['ko', 42] vs.
+ * ['ko', 100] and 'parent1.child8' before 'parent1.child10' as ['parent', 1,
+ * 'child', 8] vs. ['parent', 1, 'child', 10]).
  *
  * @param {string} a
  * @param {string} b
  * @returns {-1 | 0 | 1}
  */
 export const naturalCompare = (a, b) => {
-  const [_a, aPrefix, aDigits, aSuffix] = rPrefixedDigits.exec(a) || [];
-  if (aPrefix !== undefined) {
-    const [_b, bPrefix, bDigits, bSuffix] = rPrefixedDigits.exec(b) || [];
-    if (bPrefix === aPrefix) {
-      return compareNats(aDigits, bDigits) || compareStrings(aSuffix, bSuffix);
+  // We want to maintain a cache only for the duration of each call to
+  // array.sort, and leverage the synchronous nature of that method in the first
+  // invocation of each turn (indicated by an empty cache) to schedule cache
+  // clearing in the *next* turn.
+  if (!partsCache.size) void Promise.resolve().then(() => partsCache.clear());
+
+  const aParts = provideLazyMap(partsCache, a, () => a.split(rCaptureDigits));
+  const bParts = provideLazyMap(partsCache, b, () => b.split(rCaptureDigits));
+
+  // An even index corresponds with a string part; an odd one with a digit part.
+  let i = 0;
+  for (; i + 1 < aParts.length; i += 2) {
+    if (i + 1 < bParts.length) {
+      // Both `a` and `b` have a digit part here, but we compare the preceding
+      // string part first in case those are unequal.
+      const result =
+        compareStrings(aParts[i], bParts[i]) ||
+        compareNats(aParts[i + 1], bParts[i + 1]);
+      if (result) return result;
+    } else {
+      // After a (possibly empty) common prefix, `a` has digits where `b` does
+      // not, so we use string comparison of `${aString}${aDigits}` vs.
+      // `${bString}`.
+      return compareStrings(`${aParts[i]}${aParts[i + 1]}`, bParts[i]);
     }
   }
-  return compareStrings(a, b);
+  if (bParts.length > aParts.length) {
+    // `b` has digits where `a` does not.
+    return compareStrings(aParts[i], `${bParts[i]}${bParts[i + 1]}`);
+  }
+  // If `a` and `b` differ, it's only in the final string suffix.
+  return compareStrings(aParts[i], bParts[i]);
 };
 harden(naturalCompare);

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

@@ -1,3 +1,7 @@
+/**
+ * @import {TransformOptions} from 'node:stream';
+ * @import {TransformCallback} from 'node:stream';
+ */
 /**
  * @typedef {object} BufferLineTransformOptions
  * @property {Buffer | string | number} [break] line break matcher for
@@ -10,10 +14,9 @@ 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
      *
-     * @param {import('node:stream').TransformOptions &
-     *   BufferLineTransformOptions} [options]
+     * @param {TransformOptions & BufferLineTransformOptions} [options]
      */
-    constructor(options?: import("node:stream").TransformOptions & BufferLineTransformOptions);
+    constructor(options?: TransformOptions & BufferLineTransformOptions);
     _breakValue: string | number | Buffer<ArrayBufferLike>;
     _breakEncoding: BufferEncoding | undefined;
     _breakLength: number;
@@ -22,10 +25,10 @@ export default class BufferLineTransform extends Transform {
     /**
      * @param {any} chunk
      * @param {BufferEncoding | 'buffer'} encoding
-     * @param {import('node:stream').TransformCallback} cb
+     * @param {TransformCallback} cb
      * @override
      */
-    override _transform(chunk: any, encoding: BufferEncoding | "buffer", cb: import("node:stream").TransformCallback): void;
+    override _transform(chunk: any, encoding: BufferEncoding | "buffer", cb: TransformCallback): void;
     /** @param {Buffer} line */
     _writeItem(line: Buffer): void;
 }
@@ -42,4 +45,6 @@ export type BufferLineTransformOptions = {
     breakEncoding?: BufferEncoding | undefined;
 };
 import { Transform } from 'node:stream';
+import type { TransformCallback } from 'node:stream';
+import type { TransformOptions } 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;;;;;;GAMG;AAEH;IACE;;;;;;OAMG;IACH,sBAHW,OAAO,aAAa,EAAE,gBAAgB,GAC5C,0BAA0B,EAyB9B;IAhBC,uDAAmC;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"}
+{"version":3,"file":"buffer-line-transform.d.ts","sourceRoot":"","sources":["buffer-line-transform.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;;;GAMG;AAEH;IACE;;;;;OAKG;IACH,sBAFW,gBAAgB,GAAG,0BAA0B,EAyBvD;IAhBC,uDAAmC;IACnC,2CAAmC;IAWnC,qBAA+B;IAE/B,uBAAuB;IACvB,SADW,MAAM,EAAE,CACF;IAGnB;;;;;OAKG;IACH,2BALW,GAAG,YACH,cAAc,GAAG,QAAQ,MACzB,iBAAiB,QAiD3B;IAeD,2BAA2B;IAC3B,iBADY,MAAM,QAOjB;CACF;;;;;;;;;;;;;0BA1HyB,aAAa;uCAIH,aAAa;sCADd,aAAa"}

package/src/node/buffer-line-transform.js

@@ -3,6 +3,11 @@
 
 import { Transform } from 'node:stream';
 
+/**
+ * @import {TransformOptions} from 'node:stream';
+ * @import {TransformCallback} from 'node:stream';
+ */
+
 /**
  * @typedef {object} BufferLineTransformOptions
  * @property {Buffer | string | number} [break] line break matcher for
@@ -16,8 +21,7 @@ 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
    *
-   * @param {import('node:stream').TransformOptions &
-   *   BufferLineTransformOptions} [options]
+   * @param {TransformOptions & BufferLineTransformOptions} [options]
    */
   constructor(options) {
     const {
@@ -47,7 +51,7 @@ export default class BufferLineTransform extends Transform {
   /**
    * @param {any} chunk
    * @param {BufferEncoding | 'buffer'} encoding
-   * @param {import('node:stream').TransformCallback} cb
+   * @param {TransformCallback} cb
    * @override
    */
   _transform(chunk, encoding, cb) {
@@ -99,7 +103,7 @@ export default class BufferLineTransform extends Transform {
   }
 
   /**
-   * @param {import('node:stream').TransformCallback} cb
+   * @param {TransformCallback} cb
    * @override
    */
   _flush(cb) {

package/src/node/fs-stream.d.ts

@@ -1,8 +1,11 @@
-export function fsStreamReady(stream: import("fs").ReadStream | import("fs").WriteStream | import("net").Socket): Promise<void>;
+export function fsStreamReady(stream: ReadStream | WriteStream | Socket): Promise<void>;
 export function makeFsStreamWriter(filePath: string | undefined | null): Promise<{
     write: (data: any) => Promise<void>;
     flush: () => Promise<void>;
     close: () => Promise<void>;
 } | undefined>;
 export type FsStreamWriter = NonNullable<Awaited<ReturnType<typeof makeFsStreamWriter>>>;
+import type { ReadStream } from 'fs';
+import type { WriteStream } from 'fs';
+import type { Socket } from 'net';
 //# sourceMappingURL=fs-stream.d.ts.map

package/src/node/fs-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-stream.d.ts","sourceRoot":"","sources":["fs-stream.js"],"names":[],"mappings":"AAUO,sCALI,OAAO,IAAI,EAAE,UAAU,GAC3B,OAAO,IAAI,EAAE,WAAW,GACxB,OAAO,KAAK,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAgCtB;AAIG,6CADK,MAAM,GAAG,SAAS,GAAG,IAAI;;;;eAwEpC;6BAzEa,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"fs-stream.d.ts","sourceRoot":"","sources":["fs-stream.js"],"names":[],"mappings":"AAcO,sCAHI,UAAU,GAAG,WAAW,GAAG,MAAM,GAC/B,OAAO,CAAC,IAAI,CAAC,CAgCtB;AAIG,6CADK,MAAM,GAAG,SAAS,GAAG,IAAI;;;;eAsEpC;6BAvEa,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC;gCAzC5C,IAAI;iCACH,IAAI;4BACT,KAAK"}

package/src/node/fs-stream.js

@@ -3,9 +3,13 @@ import process from 'node:process';
 import { promisify } from 'node:util';
 
 /**
- * @param {import('fs').ReadStream
- *   | import('fs').WriteStream
- *   | import('net').Socket} stream
+ * @import {ReadStream} from 'fs';
+ * @import {WriteStream} from 'fs';
+ * @import {Socket} from 'net';
+ */
+
+/**
+ * @param {ReadStream | WriteStream | Socket} stream
  * @returns {Promise<void>}
  */
 export const fsStreamReady = stream =>
@@ -60,9 +64,7 @@ export const makeFsStreamWriter = async filePath => {
   const closeAsync =
     useStdout || !(/** @type {any} */ (stream).close)
       ? undefined
-      : promisify(
-          /** @type {import('fs').WriteStream} */ (stream).close.bind(stream),
-        );
+      : promisify(/** @type {WriteStream} */ (stream).close.bind(stream));
 
   let flushed = Promise.resolve();
   let closed = false;

package/src/node/shutdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["shutdown.js"],"names":[],"mappings":"AAKO;;EA8DN;AAGM,wDAON"}
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["shutdown.js"],"names":[],"mappings":"AAOO;;EA8DN;AAGM,wDAON"}

package/src/node/shutdown.js

@@ -1,6 +1,8 @@
 import process from 'node:process';
 import anylogger from 'anylogger';
 
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore TODO remove when anylogger has types
 const console = anylogger('shutdown');
 
 export const makeFreshShutdown = (verbose = true) => {