@agoric/internal 0.4.0 → 0.4.1-upgrade-23-dev-bd79330.0.bd79330

package/src/marshal/wrap-marshaller.d.ts

@@ -0,0 +1,60 @@
+export function wrapRemoteMarshallerSendSlotsOnly<Slot = unknown>(marshaller: ERemote<Pick<EMarshaller<Slot>, "fromCapData" | "toCapData">>, { serializeBodyFormat, errorTagging, ...otherMarshalOptions }?: MakeMarshalOptions, { valToSlot, slotToVal, cacheSeveredVal, }?: {
+    valToSlot?: WeakMapAPI<any, Slot> | null | undefined;
+    slotToVal?: WeakMapAPI<Slot, any> | null | undefined;
+    cacheSeveredVal?: boolean | undefined;
+}): ReturnType<typeof Far<EMarshaller<Slot>>>;
+export function wrapRemoteMarshallerDirectSend<Slot = unknown>(marshaller: ERemote<Pick<EMarshaller<Slot>, "fromCapData" | "toCapData">>): ReturnType<typeof Far<EMarshaller<Slot>>>;
+export function wrapRemoteMarshaller<Slot = unknown>(marshaller: ERemote<Pick<EMarshaller<Slot>, "fromCapData" | "toCapData">>, { serializeBodyFormat, errorTagging, ...otherMarshalOptions }?: MakeMarshalOptions, { valToSlot, slotToVal, cacheSeveredVal, }?: {
+    valToSlot?: WeakMapAPI<any, Slot> | null | undefined;
+    slotToVal?: WeakMapAPI<Slot, any> | null | undefined;
+    cacheSeveredVal?: boolean | undefined;
+}): ReturnType<typeof Far<EMarshaller<Slot>>>;
+/**
+ * A Marshaller which methods may be async. Use this type to indicate accepting
+ * either a sync or async marshaller, usually through `E` eventual-sends.
+ */
+export type EMarshaller<Slot = unknown> = Simplify<EOnly<Marshal<Slot>>>;
+export type InterfaceSpec = "Remotable" | `Alleged: ${string}`;
+export type RemotableSlotWrapper<Slot = unknown> = SlotWrapper<Slot> & PassStyled<"remotable", InterfaceSpec>;
+import type { ERemote } from '../types.js';
+import type { MakeMarshalOptions } from '@endo/marshal';
+import type { WeakMapAPI } from '@endo/cache-map';
+import { Far } from '@endo/far';
+import type { Marshal } from '@endo/marshal';
+import type { EOnly } from '@endo/eventual-send';
+import type { Simplify } from '@endo/pass-style';
+/**
+ * @import {WeakMapAPI} from '@endo/cache-map';
+ * @import {EOnly} from '@endo/eventual-send';
+ * @import {PassStyled, 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
+ */
+/** @typedef {'Remotable' | `Alleged: ${string}`} InterfaceSpec */
+/** @template [Slot=unknown] */
+declare class SlotWrapper<Slot = unknown> {
+    /**
+     * @template [Slot=unknown]
+     * @param {SlotWrapper<Slot>} wrapper
+     * @returns {Slot}
+     */
+    static getSlot<Slot_1 = unknown>(wrapper: SlotWrapper<Slot_1>): Slot_1;
+    /**
+     * @param {Slot} slot
+     * @param {string} [iface]
+     */
+    constructor(slot: Slot, iface?: string);
+    /** @type {InterfaceSpec} */
+    [Symbol.toStringTag]: InterfaceSpec;
+    #private;
+}
+import type { PassStyled } from '@endo/pass-style';
+export {};
+//# sourceMappingURL=wrap-marshaller.d.ts.map

package/src/marshal/wrap-marshaller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-marshaller.d.ts","sourceRoot":"","sources":["wrap-marshaller.js"],"names":[],"mappings":"AAqHO,kDATO,IAAI,wBACP,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC,CAAC,kEAC7D,kBAAkB,+CAE1B;IAAiD,SAAS;IACT,SAAS;IACjC,eAAe;CACxC,GAAU,UAAU,CAAC,OAAO,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CA4RrD;AAOM,+CAJO,IAAI,wBACP,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC,CAAC,GAC3D,UAAU,CAAC,OAAO,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAyBrD;AAxTM,qCATO,IAAI,wBACP,QAAQ,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC,CAAC,kEAC7D,kBAAkB,+CAE1B;IAAiD,SAAS;IACT,SAAS;IACjC,eAAe;CACxC,GAAU,UAAU,CAAC,OAAO,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CA4RrD;;;;;wBA1Xa,IAAI,cACL,SAAS,MAAM,QAAQ,IAAI,CAAC,CAAC,CAAC;4BAG7B,WAAW,GAAG,YAAY,MAAM,EAAE;iCAyClC,IAAI,cACL,WAAW,CAAC,IAAI,CAAC,GAAG,WAAW,WAAW,EAAE,aAAa,CAAC;6BArD7C,aAAa;wCAD0B,eAAe;gCAHnD,iBAAiB;oBAN1B,WAAW;6BASkC,eAAe;2BAFxD,qBAAqB;8BACN,kBAAkB;AAHzD;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH,kEAAkE;AAElE,+BAA+B;AAC/B,0BADe,IAAI;IAsBjB;;;;OAIG;IACH,0CAHW,WAAW,CAAC,MAAI,CAAC,GACf,MAAI,CAIhB;IArBD;;;OAGG;IACH,kBAHW,IAAI,UACJ,MAAM,EAUhB;IAfD,4BAA4B;IAC5B,sBADW,aAAa,CACsB;;CAwB/C;gCA7CsC,kBAAkB"}

package/src/marshal/wrap-marshaller.js

@@ -0,0 +1,432 @@
+// @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 {PassStyled, 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
+ */
+
+/** @typedef {'Remotable' | `Alleged: ${string}`} InterfaceSpec */
+
+/** @template [Slot=unknown] */
+class SlotWrapper {
+  /** @type {Slot} */
+  #slot;
+
+  /** @type {InterfaceSpec} */
+  [Symbol.toStringTag] = 'Alleged: SlotWrapper';
+
+  /**
+   * @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);
+  }
+
+  /**
+   * @template [Slot=unknown]
+   * @param {SlotWrapper<Slot>} wrapper
+   * @returns {Slot}
+   */
+  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);
+
+/**
+ * @template [Slot=unknown]
+ * @typedef {SlotWrapper<Slot> & PassStyled<'remotable', InterfaceSpec>} RemotableSlotWrapper
+ */
+
+/**
+ * @template [Slot=unknown]
+ * @param {Slot} slot
+ * @param {string} [iface]
+ */
+const slotToWrapper = (slot, iface) =>
+  /** @type {RemotableSlotWrapper<Slot>} */ (
+    harden(new SlotWrapper(slot, iface))
+  );
+
+const wrapperToSlot = SlotWrapper.getSlot;
+
+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, RemotableSlotWrapper<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) => RemotableSlotWrapper<NonNullable<Slot>>} getWrapper
+   * @returns {Promise<(object | null)[]>}
+   */
+  const mapSlotsToCaps = async (slots, getWrapper) => {
+    let hasRemoteCap = false;
+    const { length } = slots;
+    /** @type {(RemotableSlotWrapper<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 {(RemotableSlotWrapper<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/module-utils.d.ts

@@ -1,2 +1,3 @@
 export function getSpecifier(fileUrl: string): Promise<string>;
+export function resolveToPath(specifier: string, baseURL: string): string;
 //# sourceMappingURL=module-utils.d.ts.map

package/src/module-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-utils.d.ts","sourceRoot":"","sources":["module-utils.js"],"names":[],"mappings":"AAaO,sCAHI,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAc3B"}
+{"version":3,"file":"module-utils.d.ts","sourceRoot":"","sources":["module-utils.js"],"names":[],"mappings":"AAcO,sCAHI,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAc3B;AAWM,yCAJI,MAAM,WACN,MAAM,GACJ,MAAM,CAMlB"}

package/src/module-utils.js

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
+import { resolve as importMetaResolve } from 'import-meta-resolve';
 import { search } from '@endo/compartment-mapper';
 import { Fail } from '@endo/errors';
 
@@ -25,3 +26,18 @@ export const getSpecifier = async fileUrl => {
   return `${name}/${moduleSpecifier.replace(/^\.\//, '')}`;
 };
 harden(getSpecifier);
+
+/**
+ * Given an import specifier and importer URL (usually import.meta.url), return
+ * a file system path corresponding with the specifier for the importer.
+ *
+ * @param {string} specifier
+ * @param {string} baseURL
+ * @returns {string}
+ */
+export const resolveToPath = (specifier, baseURL) => {
+  const resolved = importMetaResolve(specifier, baseURL);
+  const resolvedURL = new URL(resolved);
+  return fileURLToPath(resolvedURL);
+};
+harden(resolveToPath);

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
@@ -19,30 +21,63 @@ const compareNats = (a, b) => {
 
 // TODO: compareByCodePoints
 // https://github.com/endojs/endo/pull/2008
-// 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]+)/;
 
 /**
- * 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]).
+ * 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 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/netstring.d.ts

@@ -20,5 +20,5 @@ export function decode(data: Buffer, optMaxChunkSize?: number): {
  * @returns {Transform}
  */
 export function netstringDecoderStream(optMaxChunkSize?: number): Transform;
-import { Transform } from 'stream';
+import { Transform } from 'node:stream';
 //# sourceMappingURL=netstring.d.ts.map

package/src/netstring.d.ts.map

@@ -1 +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,oBAEN,MAAM,GACJ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAmCpD;AAED;;;GAGG;AAEH,yDAJW,MAAM,GACJ,SAAS,CAqCrB;0BAxHyB,QAAQ"}
+{"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,oBAEN,MAAM,GACJ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAmCpD;AAED;;;GAGG;AAEH,yDAJW,MAAM,GACJ,SAAS,CAqCrB;0BAxHyB,aAAa"}

package/src/netstring.js

@@ -2,7 +2,7 @@
 import { Fail } from '@endo/errors';
 
 // adapted from 'netstring-stream', https://github.com/tlivings/netstring-stream/
-import { Transform } from 'stream';
+import { Transform } from 'node:stream';
 
 const COLON = 58;
 const COMMA = 44;
@@ -21,11 +21,11 @@ export function encode(data) {
 export function netstringEncoderStream() {
   /**
    * @param {Buffer} chunk
-   * @param {BufferEncoding} encoding
+   * @param {BufferEncoding} _encoding
    * @param {any} callback
    * @this {{ push: (b: Buffer) => void }}
    */
-  function transform(chunk, encoding, callback) {
+  function transform(chunk, _encoding, callback) {
     if (!Buffer.isBuffer(chunk)) {
       throw Error('stream requires Buffers');
     }
@@ -93,11 +93,11 @@ export function netstringDecoderStream(optMaxChunkSize) {
   let buffered = Buffer.from('');
   /**
    * @param {Buffer} chunk
-   * @param {BufferEncoding} encoding
+   * @param {BufferEncoding} _encoding
    * @param {any} callback
    * @this {{ push: (b: Buffer) => void }}
    */
-  function transform(chunk, encoding, callback) {
+  function transform(chunk, _encoding, callback) {
     if (!Buffer.isBuffer(chunk)) {
       throw Error('stream requires Buffers');
     }