@endo/compartment-mapper 1.6.2 → 2.0.0

package/src/generic-graph.js

@@ -0,0 +1,356 @@
+/**
+ * Provides {@link GenericGraph} and {@link makeShortestPath}.
+ *
+ * Portions adapted from
+ * [graph data structure](https://github.com/datavis-tech/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 { quote: q } = assert;
+
+/**
+ * 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 = [];
+
+  assert(
+    source !== target,
+    `Source ${q(source)} cannot be the same as target ${q(target)}`,
+  );
+
+  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 at 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/guards.d.ts

@@ -0,0 +1,18 @@
+export function isErrorModuleConfiguration(value: ModuleConfiguration): value is ErrorModuleConfiguration;
+export function isFileModuleConfiguration(value: ModuleConfiguration): value is FileModuleConfiguration;
+export function isExitModuleConfiguration(value: ModuleConfiguration): value is ExitModuleConfiguration;
+export function isCompartmentModuleConfiguration(value: ModuleConfiguration): value is CompartmentModuleConfiguration;
+export function isErrorModuleSource(value: ModuleSource): value is ErrorModuleSource;
+export function isExitModuleSource(value: ModuleSource): value is ExitModuleSource;
+export function isLocalModuleSource(value: ModuleSource): value is LocalModuleSource;
+export function isNonNullableObject(value: unknown): value is object;
+import type { ModuleConfiguration } from './types.js';
+import type { ErrorModuleConfiguration } from './types.js';
+import type { FileModuleConfiguration } from './types.js';
+import type { ExitModuleConfiguration } from './types.js';
+import type { CompartmentModuleConfiguration } from './types.js';
+import type { ModuleSource } from './types.js';
+import type { ErrorModuleSource } from './types.js';
+import type { ExitModuleSource } from './types.js';
+import type { LocalModuleSource } from './types.js';
+//# sourceMappingURL=guards.d.ts.map

package/src/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["guards.js"],"names":[],"mappings":"AA2BO,kDAHI,mBAAmB,GACjB,KAAK,IAAI,wBAAwB,CAIU;AAQjD,iDAHI,mBAAmB,GACjB,KAAK,IAAI,uBAAuB,CAKT;AAO7B,iDAHI,mBAAmB,GACjB,KAAK,IAAI,uBAAuB,CAKT;AAO7B,wDAHI,mBAAmB,GACjB,KAAK,IAAI,8BAA8B,CAOhB;AAO7B,2CAHI,YAAY,GACV,KAAK,IAAI,iBAAiB,CAIiB;AAQjD,0CAHI,YAAY,GACV,KAAK,IAAI,gBAAgB,CAKT;AAQtB,2CAHI,YAAY,GACV,KAAK,IAAI,iBAAiB,CAWV;AAQtB,2CAHI,OAAO,GACL,KAAK,IAAI,MAAM,CAGiB;yCAzFnC,YAAY;8CAAZ,YAAY;6CAAZ,YAAY;6CAAZ,YAAY;oDAAZ,YAAY;kCAAZ,YAAY;uCAAZ,YAAY;sCAAZ,YAAY;uCAAZ,YAAY"}

package/src/guards.js

@@ -0,0 +1,109 @@
+/**
+ * Common type guards.
+ *
+ * @module
+ */
+
+const { hasOwn } = Object;
+
+/**
+ * @import {
+ *  ModuleConfiguration,
+ *  FileModuleConfiguration,
+ *  ErrorModuleConfiguration,
+ *  ModuleSource,
+ *  ExitModuleSource,
+ *  ErrorModuleSource,
+ *  LocalModuleSource,
+ *  ExitModuleConfiguration,
+ *  CompartmentModuleConfiguration
+ * } from './types.js';
+ */
+
+/**
+ * Type guard for an {@link ErrorModuleConfiguration}.
+ * @param {ModuleConfiguration} value
+ * @returns {value is ErrorModuleConfiguration}
+ */
+export const isErrorModuleConfiguration = value =>
+  hasOwn(value, 'deferredError') &&
+  /** @type {any} */ (value).deferredError !== undefined;
+
+/**
+ * Type guard for a {@link FileModuleConfiguration}.
+ *
+ * @param {ModuleConfiguration} value
+ * @returns {value is FileModuleConfiguration}
+ */
+export const isFileModuleConfiguration = value =>
+  hasOwn(value, 'parser') &&
+  /** @type {any} */ (value).parser !== undefined &&
+  !isErrorModuleConfiguration(value);
+
+/**
+ * Type guard for an {@link ExitModuleConfiguration}.
+ * @param {ModuleConfiguration} value
+ * @returns {value is ExitModuleConfiguration}
+ */
+export const isExitModuleConfiguration = value =>
+  hasOwn(value, 'exit') &&
+  /** @type {any} */ (value).exit !== undefined &&
+  !isErrorModuleConfiguration(value);
+
+/**
+ * Type guard for an {@link CompartmentModuleConfiguration}.
+ * @param {ModuleConfiguration} value
+ * @returns {value is CompartmentModuleConfiguration}
+ */
+export const isCompartmentModuleConfiguration = value =>
+  hasOwn(value, 'compartment') &&
+  /** @type {any} */ (value).compartment !== undefined &&
+  hasOwn(value, 'module') &&
+  /** @type {any} */ (value).module !== undefined &&
+  !isErrorModuleConfiguration(value);
+/**
+ * Type guard for an {@link ErrorModuleSource}.
+ *
+ * @param {ModuleSource} value
+ * @returns {value is ErrorModuleSource}
+ */
+export const isErrorModuleSource = value =>
+  hasOwn(value, 'deferredError') &&
+  /** @type {any} */ (value).deferredError !== undefined;
+
+/**
+ * Type guard for an {@link ExitModuleSource}.
+ *
+ * @param {ModuleSource} value
+ * @returns {value is ExitModuleSource}
+ */
+export const isExitModuleSource = value =>
+  hasOwn(value, 'exit') &&
+  /** @type {any} */ (value).exit !== undefined &&
+  !isErrorModuleSource(value);
+
+/**
+ * Type guard for an {@link LocalModuleSource}.
+ *
+ * @param {ModuleSource} value
+ * @returns {value is LocalModuleSource}
+ */
+export const isLocalModuleSource = value =>
+  hasOwn(value, 'bytes') &&
+  /** @type {any} */ (value).bytes !== undefined &&
+  hasOwn(value, 'parser') &&
+  /** @type {any} */ (value).parser !== undefined &&
+  hasOwn(value, 'sourceDirname') &&
+  /** @type {any} */ (value).sourceDirname !== undefined &&
+  hasOwn(value, 'location') &&
+  /** @type {any} */ (value).location !== undefined &&
+  !isErrorModuleSource(value);
+
+/**
+ * Type guard for a non-nullable object
+ *
+ * @param {unknown} value
+ * @returns {value is object}
+ */
+export const isNonNullableObject = value =>
+  typeof value === 'object' && value !== null;

package/src/hooks.md

@@ -0,0 +1,124 @@
+# Review of compartment-mapper hooks
+
+
+
+| Hook Name                 | Description                                                                           |
+|-------------------------- | --- |
+| `packageDataHook`         | Receives all found package descriptors data before graph translation.                                   |
+| `packageDependenciesHook` | Allows dynamic mutation of dependencies during node_modules graph translation.              |
+| `unknownCanonicalNameHook`| Called when the policy references unknown canonical names, can suggest typos/similar names. |
+| `moduleSourceHook`        | Invoked when a module source is created.                                             |
+| `packageConnectionsHook`  | Surfaces connections during digest. (ignored in archiving)                                               |
+
+
+
+[Type declarations for the hooks](./types/external.ts)
+
+```mermaid
+graph TB
+
+  exports((public exports))
+  exports -.- compartmentMapForNodeModules
+  exports -.- mapNodeModules
+  exports -.- loadLocation
+  exports -.- importLocation
+  exports -.- captureFromMap
+  exports -.- importFromMap
+  exports -.- loadFromMap
+  exports -.- digestCompartmentMap
+  exports -.- makeFunctor
+  exports -.- makeScript
+
+
+subgraph "import-hook.js"
+  moduleSourceHook{{moduleSourceHook}} -.- note5["for all module sources read"]
+  makeDeferError --> moduleSourceHook
+  makeImportHookMaker --> makeDeferError
+  makeImportNowHookMaker --> makeDeferError
+  makeImportNowHookMaker -- via importNowHook --> chooseModuleDescriptor --> executeLocalModuleSourceHook--> moduleSourceHook
+  makeImportHookMaker --via importHook exitModule logic--> moduleSourceHook
+  makeImportHookMaker --via importHook call--> chooseModuleDescriptor
+end
+
+subgraph "node-modules.js"
+  compartmentMapForNodeModules --> packageDataHook{{packageDataHook}} -.- note0["called once"]
+  compartmentMapForNodeModules --> unknownCanonicalNameHook{{unknownCanonicalNameHook}} -.- note1["for all issues from policy;<br>after defaultUnknownCanonicalNameHandler"]
+  compartmentMapForNodeModules --> translateGraph --> packageDependenciesHook{{packageDependenciesHook}} -.-note3["for all locatons in graph<br>after defaultPackageDependenciesFilter"]
+  mapNodeModules --> compartmentMapForNodeModules
+
+end
+
+subgraph "digest.js"
+  digestCompartmentMap --> translateCompartmentMap --> packageConnectionsHook{{packageConnectionsHook}} -.- note4["for all retained compartments"]
+end
+
+subgraph "bundle.js"
+  makeFunctor -- options:can include hooks ----------> mapNodeModules
+  makeScript -- options:can include hooks ----------> mapNodeModules
+end
+
+
+subgraph "import-lite.js"
+  importFromMap --> loadFromMap ---> makeImportHookMaker
+  loadFromMap ----> makeImportNowHookMaker
+end
+
+
+subgraph "capture-lite.js"
+  captureFromMap -----> makeImportHookMaker
+  captureFromMap --> captureCompartmentMap --> digestCompartmentMap
+end
+
+
+subgraph "import.js"
+  loadLocation ----------> mapNodeModules
+  importLocation --> loadLocation
+  loadLocation --> loadFromMap
+end
+
+
+%% STYLING
+classDef note fill:#999, stroke:#ccb
+class note0,note1,note2,note3,note4,note5 note
+
+```
+
+
+
+<details>
+<summary>Bundle and Archive bits of the diagram that don't use hooks</summary>
+
+These are calling the functions accepting hooks but don't pass them
+
+> [TODO]
+> copy-paste this to the main diagram whenever the connections are made.
+
+```mermaid
+
+graph TB
+
+subgraph "bundle.js"
+  makeFunctor -- options:transparently ----------> mapNodeModules
+  makeScript -- options:transparently ----------> mapNodeModules
+  makeFunctorFromMap  -- no moduleSourceHook ----x makeImportHookMaker
+end
+
+subgraph "bundle-lite.js"
+makeFunctorFromMap2 --no moduleSourceHook -----x makeImportHookMaker
+end
+
+subgraph "archive-lite.js"
+digestFromMap -- no moduleSourceHook -----x makeImportHookMaker
+makeArchiveCompartmentMap --no packageConnectionsHook----x digestCompartmentMap
+end
+
+subgraph "archive.js"
+archive(("multiple <br> methods")) --no hooks passed-----------x mapNodeModules
+end
+
+```
+
+</details>
+
+
+

package/src/import-archive-lite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-archive-lite.d.ts","sourceRoot":"","sources":["import-archive-lite.js"],"names":[],"mappings":"AAsPO,2CALI,UAAU,oBACV,MAAM,YACN,mBAAmB,GACjB,OAAO,CAAC,WAAW,CAAC,CAiKhC;AAQM,wCALI,MAAM,GAAG,UAAU,mBACnB,MAAM,YACN,kBAAkB,GAChB,OAAO,CAAC,WAAW,CAAC,CAwBhC;AAQM,0CALI,MAAM,GAAG,UAAU,mBACnB,MAAM,WACN,kBAAkB,GAChB,OAAO,CAAC,UAAU,CAAC,CAK/B;yCAxZS,YAAY;iCAAZ,YAAY;4BAAZ,YAAY;gCAAZ,YAAY;wCAAZ,YAAY;gCAAZ,YAAY"}
+{"version":3,"file":"import-archive-lite.d.ts","sourceRoot":"","sources":["import-archive-lite.js"],"names":[],"mappings":"AA0PO,2CALI,UAAU,oBACV,MAAM,YACN,mBAAmB,GACjB,OAAO,CAAC,WAAW,CAAC,CAiKhC;AAQM,wCALI,MAAM,GAAG,UAAU,mBACnB,MAAM,YACN,kBAAkB,GAChB,OAAO,CAAC,WAAW,CAAC,CAwBhC;AAQM,0CALI,MAAM,GAAG,UAAU,mBACnB,MAAM,WACN,kBAAkB,GAChB,OAAO,CAAC,UAAU,CAAC,CAK/B;yCA5ZS,YAAY;iCAAZ,YAAY;4BAAZ,YAAY;gCAAZ,YAAY;wCAAZ,YAAY;gCAAZ,YAAY"}

package/src/import-archive-lite.js

@@ -23,7 +23,7 @@
  * } from 'ses';
  * @import {
  *   Application,
- *   CompartmentDescriptor,
+ *   FileCompartmentDescriptor,
  *   ComputeSourceLocationHook,
  *   ComputeSourceMapLocationHook,
  *   ExecuteFn,
@@ -44,9 +44,13 @@ import { link } from './link.js';
 import { parseLocatedJson } from './json.js';
 import { unpackReadPowers } from './powers.js';
 import { join } from './node-module-specifier.js';
-import { assertCompartmentMap } from './compartment-map.js';
+import { assertFileCompartmentMap } from './compartment-map.js';
 import { exitModuleImportHookMaker } from './import-hook.js';
-import { attenuateModuleHook, enforceModulePolicy } from './policy.js';
+import { attenuateModuleHook, enforcePolicyByModule } from './policy.js';
+import {
+  isErrorModuleConfiguration,
+  isFileModuleConfiguration,
+} from './guards.js';
 
 const { Fail, quote: q } = assert;
 
@@ -77,7 +81,7 @@ const postponeErrorToExecute = errorMessage => {
 
 /**
  * @param {(path: string) => Uint8Array} get
- * @param {Record<string, CompartmentDescriptor>} compartments
+ * @param {Record<string, FileCompartmentDescriptor>} compartments
  * @param {string} archiveLocation
  * @param {ParserForLanguage} parserForLanguage
  * @param {HashFn} [computeSha512]
@@ -118,7 +122,7 @@ const makeArchiveImportHookMaker = (
           // At this point in archive importing, if a module is not found and
           // exitModuleImportHook exists, the only possibility is that the
           // module is a "builtin" module and the policy needs to be enforced.
-          enforceModulePolicy(moduleSpecifier, compartmentDescriptor, {
+          enforcePolicyByModule(moduleSpecifier, compartmentDescriptor, {
             exit: true,
             errorHint: `Blocked in loading. ${q(
               moduleSpecifier,
@@ -161,22 +165,22 @@ const makeArchiveImportHookMaker = (
           )} in archive ${q(archiveLocation)}`,
         );
       }
-      if (module.deferredError !== undefined) {
+      if (isErrorModuleConfiguration(module)) {
         return postponeErrorToExecute(module.deferredError);
       }
-      if (module.parser === undefined) {
+      if (!isFileModuleConfiguration(module)) {
         throw Error(
           `Cannot parse module ${q(moduleSpecifier)} in package ${q(
             packageLocation,
-          )} in archive ${q(archiveLocation)}`,
+          )} in archive ${q(archiveLocation)}; missing parser`,
         );
       }
       const parser = parserForLanguage[module.parser];
       if (parser === undefined) {
         throw Error(
-          `Cannot parse ${q(module.parser)} module ${q(
+          `Cannot parse module ${q(
             moduleSpecifier,
-          )} in package ${q(packageLocation)} in archive ${q(archiveLocation)}`,
+          )} in package ${q(packageLocation)} in archive ${q(archiveLocation)}; unknown parser (${q(module.parser)})`,
         );
       }
       const { parse } = parser;
@@ -306,7 +310,7 @@ export const parseArchive = async (
     compartmentMapText,
     'compartment-map.json',
   );
-  assertCompartmentMap(compartmentMap, archiveLocation);
+  assertFileCompartmentMap(compartmentMap, archiveLocation);
 
   const {
     compartments,