@endo/compartment-mapper 1.6.2 → 1.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@endo/compartment-mapper",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "description": "The compartment mapper assembles Node applications in a sandbox",
   "keywords": [
     "node",
@@ -61,11 +61,11 @@
   },
   "dependencies": {
     "@endo/cjs-module-analyzer": "^1.0.11",
-    "@endo/module-source": "^1.3.2",
+    "@endo/module-source": "^1.3.3",
     "@endo/path-compare": "^1.1.0",
     "@endo/trampoline": "^1.0.5",
     "@endo/zip": "^1.0.11",
-    "ses": "^1.13.1"
+    "ses": "^1.14.0"
   },
   "devDependencies": {
     "ava": "^6.1.3",
@@ -119,5 +119,5 @@
   "typeCoverage": {
     "atLeast": 86.14
   },
-  "gitHead": "03b92fc383da5d8bb4ea993b90149a0db5799d0b"
+  "gitHead": "9815aea9541f241389d2135c6097a7442bdffa17"
 }

package/src/generic-graph.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @template [T=string] The type of nodes in the graph
+ *
+ * A generic graph implementation with edge weights.
+ *
+ * Edge weights are assumed to be non-negative numbers (including `Infinity`)
+ */
+export class GenericGraph<T = string> {
+    /**
+     * Returns a shallow copy of the `Set` of nodes in the graph.
+     */
+    get nodes(): Set<T>;
+    /**
+     * Adds a node to the graph.
+     * If node was already added, this function does nothing.
+     * If node was not already added, this function sets up an empty adjacency list.
+     * @param {T} node Node to add
+     * @returns {this} This graph instance
+     */
+    addNode(node: T): this;
+    /**
+     * Removes a node from the graph.
+     * Also removes incoming and outgoing edges.
+     * @param {T} node
+     * @returns {this}
+     */
+    removeNode(node: T): this;
+    /**
+     * Gets the adjacent nodes set for the given node.
+     * @param {T} node
+     * @returns {Set<T>|undefined}
+     */
+    adjacent(node: T): Set<T> | undefined;
+    /**
+     * Sets the weight of the given edge between `source` and `target`.
+     *
+     * @param {T} source Source node
+     * @param {T} target Target node
+     * @param {number} weight New edge weight
+     * @returns {this}
+     */
+    setEdgeWeight(source: T, target: T, weight: number): this;
+    /**
+     * Gets the weight of the given edge between `source` and `target`.
+     *
+     * @param {T} source Source node
+     * @param {T} target Target node
+     * @returns {number} Edge weight from source to target
+     */
+    getEdgeWeight(source: T, target: T): number;
+    /**
+     * Adds an edge from the `source` node to `target` node.
+     *
+     * This method will create the `source` and `target` node(s) if they do not
+     * already exist.
+     *
+     * If {@link T `T`} is an object, the comparison is by-reference.
+     *
+     * @param {T} source Source node
+     * @param {T} target Target node
+     * @param {number} weight Edge weight from source to target
+     * @returns {this} This graph instance
+     */
+    addEdge(source: T, target: T, weight: number): this;
+    /**
+     * Removes the edge from the `source` node to `target` node.
+     * Does not remove the nodes themselves.
+     * Does nothing if the edge does not exist.
+     * @param {T} source
+     * @param {T} target
+     * @returns {this}
+     */
+    removeEdge(source: T, target: T): this;
+    /**
+     * Returns true if there is an edge from the `source` node to `target` node.
+     * @param {T} source
+     * @param {T} target
+     * @returns {boolean}
+     */
+    hasEdge(source: T, target: T): boolean;
+    #private;
+}
+export function makeShortestPath<T = string>(graph: GenericGraph<T>): (source: NoInfer<T>, target: NoInfer<T>) => [T, T, ...T[]];
+//# sourceMappingURL=generic-graph.d.ts.map

package/src/generic-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-graph.d.ts","sourceRoot":"","sources":["generic-graph.js"],"names":[],"mappings":"AAoHA;;;;;;GAMG;AACH,0BANc,CAAC;IA+Bb;;OAEG;IACH,oBAEC;IAED;;;;;;OAMG;IACH,cAHW,CAAC,GACC,IAAI,CAUhB;IAED;;;;;OAKG;IACH,iBAHW,CAAC,GACC,IAAI,CAShB;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,GAAG,CAAC,CAAC,CAAC,GAAC,SAAS,CAI5B;IAED;;;;;;;OAOG;IACH,sBALW,CAAC,UACD,CAAC,UACD,MAAM,GACJ,IAAI,CAWhB;IAED;;;;;;OAMG;IACH,sBAJW,CAAC,UACD,CAAC,GACC,MAAM,CAUlB;IAED;;;;;;;;;;;;OAYG;IACH,gBALW,CAAC,UACD,CAAC,UACD,MAAM,GACJ,IAAI,CAWhB;IAED;;;;;;;OAOG;IACH,mBAJW,CAAC,UACD,CAAC,GACC,IAAI,CAKhB;IAED;;;;;OAKG;IACH,gBAJW,CAAC,UACD,CAAC,GACC,OAAO,CAInB;;CACF;AA6DM,iCAHO,CAAC,kBACJ,YAAY,CAAC,CAAC,CAAC,YAIb,OAAO,CAAC,CAAC,CAAC,UACV,OAAO,CAAC,CAAC,CAAC,KACR,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAO5B"}

package/src/generic-graph.js

@@ -0,0 +1,351 @@
+/**
+ * Provides {@link GenericGraph} and {@link makeShortestPath}.
+ *
+ * Portions adapted from
+ * {@link https://github.com/datavis-tech/graph-data-structure graph-data-structure},
+ * which is Copyright (c) 2016 Curran Kelleher and licensed under the MIT
+ * License.
+ *
+ * @module
+ */
+
+/**
+ * @import {TraversalContext} from './types/generic-graph.js';
+ */
+
+const { stringify: q } = JSON;
+
+/**
+ * Remove the node with the minimum weight from the priority queue.
+ *
+ * Performs linear search.
+ * @template [T=string]
+ * @param {TraversalContext<T>} tracks
+ * @returns {T|undefined}
+ */
+const extractMin = ({ distances, queue }) => {
+  let min = Infinity;
+
+  /** @type {T|undefined} */
+  let minNode;
+
+  queue.forEach(node => {
+    const nodeWeight = distances.get(node) ?? Infinity;
+
+    if (nodeWeight < min) {
+      min = nodeWeight;
+      minNode = node;
+    }
+  });
+
+  if (minNode === undefined) {
+    queue.clear();
+    return undefined;
+  }
+
+  queue.delete(minNode);
+  return minNode;
+};
+
+/**
+ * Update context with the new distance to the target node if the distance
+ * through the source node is shorter than the current distance.
+ *
+ * @template [T=string]
+ * @param {GenericGraph<T>} graph
+ * @param {TraversalContext<NoInfer<T>>} context
+ * @param {NoInfer<T>} source
+ * @param {NoInfer<T>} target
+ */
+const relax = (graph, { distances, predecessors }, source, target) => {
+  const number = graph.getEdgeWeight(source, target);
+
+  const distanceSource = distances.get(source);
+  const distanceTarget = distances.get(target);
+
+  assert(
+    distanceSource !== undefined,
+    `Missing distance for source ${q(source)}`,
+  );
+  assert(
+    distanceTarget !== undefined,
+    `Missing distance for target ${q(target)} target`,
+  );
+
+  if (distanceTarget > distanceSource + number) {
+    distances.set(target, distanceSource + number);
+    predecessors.set(target, source);
+  }
+};
+
+/**
+ * Assembles the shortest path by traversing the
+ * predecessor subgraph from destination to source.
+ *
+ * @template [T=string]
+ * @param {TraversalContext<NoInfer<T>>} context Traversal context object
+ * @param {NoInfer<T>} source Source node
+ * @param {NoInfer<T>} target Destination node
+ * @returns {[T, T, ...T[]]} Nodes from `source` to `target` inclusive
+ * @throws If no path is found
+ * @throws If the path has less than two nodes
+ */
+const getPath = ({ predecessors }, source, target) => {
+  /** @type {T[]} */
+  const nodeList = [];
+
+  let node = target;
+
+  while (predecessors.has(node)) {
+    const currentNode = /** @type {T} */ (predecessors.get(node));
+    nodeList.push(node);
+    node = currentNode;
+  }
+
+  assert.equal(node, source, `No path found from ${q(source)} to ${q(target)}`);
+
+  nodeList.push(node);
+
+  assert(
+    nodeList.length >= 2,
+    `The path from ${source} to ${target} should have a least two nodes`,
+  );
+
+  return /** @type {[T, T, ...T[]]} */ (nodeList.reverse());
+};
+
+/**
+ * @template [T=string] The type of nodes in the graph
+ *
+ * A generic graph implementation with edge weights.
+ *
+ * Edge weights are assumed to be non-negative numbers (including `Infinity`)
+ */
+export class GenericGraph {
+  /**
+   * @type {Set<T>}
+   */
+  #nodes;
+
+  /**
+   * @type {Map<T, Set<T>>}
+   */
+  #edges;
+
+  /**
+   * @type {Map<T, Map<T, number>>}
+   */
+  #edgeWeights;
+
+  /**
+   * Initializes internal data structures.
+   */
+  constructor() {
+    this.#edgeWeights = new Map();
+    this.#edges = new Map();
+    this.#nodes = new Set();
+  }
+
+  /**
+   * Returns a shallow copy of the `Set` of nodes in the graph.
+   */
+  get nodes() {
+    return new Set(this.#nodes);
+  }
+
+  /**
+   * Adds a node to the graph.
+   * If node was already added, this function does nothing.
+   * If node was not already added, this function sets up an empty adjacency list.
+   * @param {T} node Node to add
+   * @returns {this} This graph instance
+   */
+  addNode(node) {
+    if (!this.#nodes.has(node)) {
+      this.#nodes.add(node);
+    }
+    if (!this.#edges.has(node)) {
+      this.#edges.set(node, new Set());
+    }
+    return this;
+  }
+
+  /**
+   * Removes a node from the graph.
+   * Also removes incoming and outgoing edges.
+   * @param {T} node
+   * @returns {this}
+   */
+  removeNode(node) {
+    this.#edges.delete(node);
+    this.#nodes.delete(node);
+    for (const adjacentNodes of this.#edges.values()) {
+      adjacentNodes.delete(node);
+    }
+    return this;
+  }
+
+  /**
+   * Gets the adjacent nodes set for the given node.
+   * @param {T} node
+   * @returns {Set<T>|undefined}
+   */
+  adjacent(node) {
+    return this.#edges.get(node);
+  }
+
+  /**
+   * Sets the weight of the given edge between `source` and `target`.
+   *
+   * @param {T} source Source node
+   * @param {T} target Target node
+   * @param {number} weight New edge weight
+   * @returns {this}
+   */
+  setEdgeWeight(source, target, weight) {
+    if (!this.#edgeWeights.has(source)) {
+      this.#edgeWeights.set(source, new Map());
+    }
+    const weights = /** @type {Map<T, number>} */ (
+      this.#edgeWeights.get(source)
+    );
+    weights.set(target, weight);
+    return this;
+  }
+
+  /**
+   * Gets the weight of the given edge between `source` and `target`.
+   *
+   * @param {T} source Source node
+   * @param {T} target Target node
+   * @returns {number} Edge weight from source to target
+   */
+  getEdgeWeight(source, target) {
+    const weight = this.#edgeWeights.get(source)?.get(target);
+    if (weight === undefined) {
+      throw new ReferenceError(
+        `Edge weight from ${q(source)} to ${q(target)} is not set`,
+      );
+    }
+    return weight;
+  }
+
+  /**
+   * Adds an edge from the `source` node to `target` node.
+   *
+   * This method will create the `source` and `target` node(s) if they do not
+   * already exist.
+   *
+   * If {@link T `T`} is an object, the comparison is by-reference.
+   *
+   * @param {T} source Source node
+   * @param {T} target Target node
+   * @param {number} weight Edge weight from source to target
+   * @returns {this} This graph instance
+   */
+  addEdge(source, target, weight) {
+    this.addNode(source);
+    this.addNode(target);
+    const adjacentNodes = this.adjacent(source);
+    assert(adjacentNodes, `Source ${q(source)} should have adjacent nodes`);
+
+    adjacentNodes.add(target);
+    this.setEdgeWeight(source, target, weight);
+    return this;
+  }
+
+  /**
+   * Removes the edge from the `source` node to `target` node.
+   * Does not remove the nodes themselves.
+   * Does nothing if the edge does not exist.
+   * @param {T} source
+   * @param {T} target
+   * @returns {this}
+   */
+  removeEdge(source, target) {
+    this.#edges.get(source)?.delete(target);
+    return this;
+  }
+
+  /**
+   * Returns true if there is an edge from the `source` node to `target` node.
+   * @param {T} source
+   * @param {T} target
+   * @returns {boolean}
+   */
+  hasEdge(source, target) {
+    return this.#edges.get(source)?.has(target) ?? false;
+  }
+}
+
+/**
+ * Dijkstra's algorithm for shortest paths in a graph.
+ * @template [T=string] The type of nodes in the graph
+ * @param {GenericGraph<T>} graph
+ * @param {T} source
+ * @param {T} target
+ * @returns {TraversalContext<T>}
+ */
+const dijkstra = (graph, source, target) => {
+  const { nodes } = graph;
+  /** @type {TraversalContext<T>} */
+  const context = {
+    distances: new Map(),
+    predecessors: new Map(),
+    queue: new Set(),
+  };
+  const { queue, distances } = context;
+
+  for (const node of nodes) {
+    distances.set(node, Infinity);
+  }
+
+  assert(
+    distances.get(source) === Infinity,
+    `Source ${q(source)} is not in the graph`,
+  );
+  assert(
+    distances.get(target) === Infinity,
+    `Target ${q(target)} is not in the graph`,
+  );
+
+  distances.set(source, 0);
+
+  for (const node of nodes) {
+    queue.add(node);
+  }
+
+  while (queue.size !== 0) {
+    const node = extractMin(context);
+    if (node === undefined) {
+      return context;
+    }
+    const adjacent = graph.adjacent(node);
+    if (adjacent) {
+      for (const edge of adjacent) {
+        relax(graph, context, node, edge);
+      }
+    }
+  }
+  return context;
+};
+
+/**
+ * Returns a function which uses Dijkstra's shortest path algorithm to compute
+ * the shortest path from `source` to `destination` in the given `graph`.
+ *
+ * @template [T=string]
+ * @param {GenericGraph<T>} graph Graph to use
+ */
+export const makeShortestPath = graph => {
+  /**
+   * @param {NoInfer<T>} source Source node
+   * @param {NoInfer<T>} target Target node
+   * @returns {[T, T, ...T[]]} Nodes from `source` to `target` inclusive (minimum of two nodes)
+   */
+  const shortestPath = (source, target) => {
+    const context = dijkstra(graph, source, target);
+    return getPath(context, source, target);
+  };
+  return shortestPath;
+};

package/src/import-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-hook.d.ts","sourceRoot":"","sources":["import-hook.js"],"names":[],"mappings":"AAkoBA;;;;;;;GAOG;AACH,mDALW,aAAa,gBACb,MAAM,2IACN,6BAA6B,GAC3B,kBAAkB,CAkN9B;AAnoBM,oGALJ;IAAqC,OAAO;IACN,oBAAoB;IACnC,oBAAoB,EAAnC,MAAM;CACd,GAAU,oBAAoB,GAAC,SAAS,CA8B1C;AAiPM,gDALI,MAAM,GAAC,UAAU,gBACjB,MAAM,iLACN,0BAA0B,GACxB,eAAe,CA8J3B;mCAzlBS,YAAY;mDAAZ,YAAY;wCAAZ,YAAY;0CAAZ,YAAY;4BAAZ,YAAY;gCAAZ,YAAY;gDAAZ,YAAY;qCAAZ,YAAY"}
+{"version":3,"file":"import-hook.d.ts","sourceRoot":"","sources":["import-hook.js"],"names":[],"mappings":"AAipBA;;;;;;;GAOG;AACH,mDALW,aAAa,gBACb,MAAM,2IACN,6BAA6B,GAC3B,kBAAkB,CAmN9B;AAlpBM,oGALJ;IAAqC,OAAO;IACN,oBAAoB;IACnC,oBAAoB,EAAnC,MAAM;CACd,GAAU,oBAAoB,GAAC,SAAS,CA8B1C;AA+PM,gDALI,MAAM,GAAC,UAAU,gBACjB,MAAM,iLACN,0BAA0B,GACxB,eAAe,CA8J3B;mCAxmBS,YAAY;mDAAZ,YAAY;wCAAZ,YAAY;0CAAZ,YAAY;4BAAZ,YAAY;gCAAZ,YAAY;gDAAZ,YAAY;qCAAZ,YAAY"}

package/src/import-hook.js

@@ -194,7 +194,8 @@ const findRedirect = ({
       // go up a directory
       const parentLocation = new URL('../', someLocation).href;
 
-      // afaict this behavior is consistent across both windows and posix
+      // afaict this behavior is consistent across both windows and posix:
+      // if this is true, we hit the filesystem root
       if (parentLocation === someLocation) {
         throw new Error(
           `Could not import unknown module: ${q(absoluteModuleSpecifier)}`,
@@ -338,6 +339,20 @@ function* chooseModuleDescriptor(
     // name, they are usable as URL's.
     const moduleLocation = resolveLocation(candidateSpecifier, packageLocation);
 
+    // check if moduleLocation is within the compartment if it is not, then
+    // create a redirect record using absolute path which will be resolved by
+    // findRedirect
+    const { fileURLToPath } = unpackReadPowers(readPowers);
+    if (
+      typeof fileURLToPath === 'function' &&
+      !isLocationWithinCompartment(moduleLocation, packageLocation)
+    ) {
+      return {
+        specifier: fileURLToPath(moduleLocation),
+        compartment: compartments[packageLocation],
+      };
+    }
+
     // "next" values must have type assertions for narrowing because we have
     // multiple yielded types
     const moduleBytes = /** @type {Uint8Array|undefined} */ (
@@ -809,7 +824,8 @@ export function makeImportNowHookMaker(
           }
         } else if (
           moduleSpecifier !== '.' &&
-          !moduleSpecifier.startsWith('./')
+          !moduleSpecifier.startsWith('./') &&
+          !moduleSpecifier.startsWith('../')
         ) {
           // could be a builtin, which means we should not bother bouncing on the trampoline to find it.
           return importExitModuleOrFail(moduleSpecifier, compartmentDescriptor);

package/src/json.d.ts

@@ -1,2 +1,2 @@
-export function parseLocatedJson(source: string, location: string): any;
+export function parseLocatedJson<T = any>(source: string, location: string): T;
 //# sourceMappingURL=json.d.ts.map

package/src/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["json.js"],"names":[],"mappings":"AASO,yCAHI,MAAM,YACN,MAAM,OAWhB"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["json.js"],"names":[],"mappings":"AAgBO,iCANO,CAAC,gBAEJ,MAAM,YACN,MAAM,GACJ,CAAC,CAWb"}

package/src/json.js

@@ -1,11 +1,18 @@
-/** @module Annotates JSON parse exceptions with the location of the source. */
+/**
+ * Annotates JSON parse exceptions with the location of the source.
+ *
+ * @module
+ */
 
 /**
- * Parses JSON and, if necessary, throws exceptions that include the location
- * of the offending file.
+ * Parses JSON and, if necessary, throws exceptions that include the location of
+ * the offending file.
  *
+ * @template [T=any] The desired type of the parsed JSON. `unknown` is
+ * recommended; using the default is unsafe.
  * @param {string} source
  * @param {string} location
+ * @returns {T}
  */
 export const parseLocatedJson = (source, location) => {
   try {

package/src/node-modules.d.ts

@@ -1,7 +1,8 @@
 export function basename(location: string): string;
-export function compartmentMapForNodeModules(readPowers: ReadFn | ReadPowers | MaybeReadPowers, packageLocation: string, conditionsOption: Set<string>, packageDescriptor: PackageDescriptor, moduleSpecifier: string, options?: CompartmentMapForNodeModulesOptions): Promise<CompartmentMapDescriptor>;
-export function mapNodeModules(readPowers: ReadFn | ReadPowers | MaybeReadPowers, moduleLocation: string, { tags, conditions, log, ...otherOptions }?: MapNodeModulesOptions): Promise<CompartmentMapDescriptor>;
+export function compartmentMapForNodeModules(readPowers: ReadFn | ReadPowers<FileUrlString> | MaybeReadPowers<FileUrlString>, packageLocation: FileUrlString, conditionsOption: Set<string>, packageDescriptor: PackageDescriptor, moduleSpecifier: string, options?: CompartmentMapForNodeModulesOptions): Promise<CompartmentMapDescriptor>;
+export function mapNodeModules(readPowers: ReadFn | ReadPowers<FileUrlString> | MaybeReadPowers<FileUrlString>, moduleLocation: string, { tags, conditions, log, ...otherOptions }?: MapNodeModulesOptions): Promise<CompartmentMapDescriptor>;
 import type { ReadFn } from './types.js';
+import type { FileUrlString } from './types.js';
 import type { ReadPowers } from './types.js';
 import type { MaybeReadPowers } from './types.js';
 import type { PackageDescriptor } from './types.js';

package/src/node-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-modules.d.ts","sourceRoot":"","sources":["node-modules.js"],"names":[],"mappings":"AAmFO,mCAHI,MAAM,GACJ,MAAM,CAYlB;AA43BM,yDATI,MAAM,GAAG,UAAU,GAAG,eAAe,mBACrC,MAAM,oBACN,GAAG,CAAC,MAAM,CAAC,qBACX,iBAAiB,mBACjB,MAAM,YACN,mCAAmC,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAkE7C;AAaM,2CALI,MAAM,GAAG,UAAU,GAAG,eAAe,kBACrC,MAAM,+CACN,qBAAqB,GACnB,OAAO,CAAC,wBAAwB,CAAC,CA0B7C;4BA9hCS,YAAY;gCAAZ,YAAY;qCAAZ,YAAY;uCAAZ,YAAY;yDAAZ,YAAY;8CAAZ,YAAY;2CAAZ,YAAY"}
+{"version":3,"file":"node-modules.d.ts","sourceRoot":"","sources":["node-modules.js"],"names":[],"mappings":"AAyHO,mCAHI,MAAM,GACJ,MAAM,CAYlB;AAw1BM,yDATI,MAAM,GAAG,WAAW,aAAa,CAAC,GAAG,gBAAgB,aAAa,CAAC,mBACnE,aAAa,oBACb,GAAG,CAAC,MAAM,CAAC,qBACX,iBAAiB,mBACjB,MAAM,YACN,mCAAmC,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAgG7C;AAaM,2CALI,MAAM,GAAG,WAAW,aAAa,CAAC,GAAG,gBAAgB,aAAa,CAAC,kBACnE,MAAM,+CACN,qBAAqB,GACnB,OAAO,CAAC,wBAAwB,CAAC,CA6B7C;4BAnjCS,YAAY;mCAAZ,YAAY;gCAAZ,YAAY;qCAAZ,YAAY;uCAAZ,YAAY;yDAAZ,YAAY;8CAAZ,YAAY;2CAAZ,YAAY"}