@endo/compartment-mapper 1.6.3 → 2.1.0

package/src/generic-graph.js

@@ -2,38 +2,56 @@
  * Provides {@link GenericGraph} and {@link makeShortestPath}.
  *
  * Portions adapted from
- * {@link https://github.com/datavis-tech/graph-data-structure graph-data-structure},
+ * [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 { pathCompare } from '@endo/path-compare';
+
 /**
- * @import {TraversalContext} from './types/generic-graph.js';
+ * @import {GenericGraphNode, TraversalContext} from './types/generic-graph.js';
  */
 
-const { stringify: q } = JSON;
+const { quote: q } = assert;
+
+/**
+ * Returns `true` if the cost of path `a` is less than the cost of path `b`.
+ *
+ * @template {GenericGraphNode} [T=string]
+ * @param {T[]} [pathA]
+ * @param {T[]} [pathB]
+ * @returns {boolean}
+ */
+const isLowerCost = (pathA, pathB) =>
+  pathCompare(pathA?.map(String), pathB?.map(String)) < 0;
 
 /**
  * Remove the node with the minimum weight from the priority queue.
  *
  * Performs linear search.
- * @template [T=string]
+ *
+ * @template {GenericGraphNode} [T=string]
  * @param {TraversalContext<T>} tracks
  * @returns {T|undefined}
  */
-const extractMin = ({ distances, queue }) => {
-  let min = Infinity;
+const extractMin = ({ paths, queue }) => {
+  /** @type {T[]|undefined} */
+  let minPath;
 
   /** @type {T|undefined} */
   let minNode;
 
   queue.forEach(node => {
-    const nodeWeight = distances.get(node) ?? Infinity;
+    const path = paths.get(node);
+    if (!path) {
+      return;
+    }
 
-    if (nodeWeight < min) {
-      min = nodeWeight;
+    if (!minPath || isLowerCost(path, minPath)) {
+      minPath = path;
       minNode = node;
     }
   });
@@ -48,32 +66,23 @@ const extractMin = ({ distances, queue }) => {
 };
 
 /**
- * Update context with the new distance to the target node if the distance
- * through the source node is shorter than the current distance.
+ * Update context to include the current lowest-cost path to a target node
+ * reachable by a single edge from a source node.
  *
- * @template [T=string]
- * @param {GenericGraph<T>} graph
- * @param {TraversalContext<NoInfer<T>>} context
+ * @template {GenericGraphNode} [T=string]
+ * @param {TraversalContext<T>} context
  * @param {NoInfer<T>} source
  * @param {NoInfer<T>} target
  */
-const relax = (graph, { distances, predecessors }, source, target) => {
-  const number = graph.getEdgeWeight(source, target);
+const relax = ({ paths, predecessors }, source, target) => {
+  const pathSource = paths.get(source);
+  assert(pathSource, `Missing path to source ${q(source)}`);
 
-  const distanceSource = distances.get(source);
-  const distanceTarget = distances.get(target);
+  const pathTarget = paths.get(target);
+  const newPath = [...pathSource, 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);
+  if (!pathTarget || isLowerCost(newPath, pathTarget)) {
+    paths.set(target, newPath);
     predecessors.set(target, source);
   }
 };
@@ -82,7 +91,7 @@ const relax = (graph, { distances, predecessors }, source, target) => {
  * Assembles the shortest path by traversing the
  * predecessor subgraph from destination to source.
  *
- * @template [T=string]
+ * @template {GenericGraphNode} [T=string]
  * @param {TraversalContext<NoInfer<T>>} context Traversal context object
  * @param {NoInfer<T>} source Source node
  * @param {NoInfer<T>} target Destination node
@@ -94,6 +103,11 @@ 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)) {
@@ -102,24 +116,27 @@ const getPath = ({ predecessors }, source, target) => {
     node = currentNode;
   }
 
-  assert.equal(node, source, `No path found from ${q(source)} to ${q(target)}`);
+  assert.equal(
+    node,
+    source,
+    `No path found from ${q(String(source))} to ${q(String(target))}`,
+  );
 
   nodeList.push(node);
 
   assert(
     nodeList.length >= 2,
-    `The path from ${source} to ${target} should have a least two nodes`,
+    `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.
+ * A generic graph implementation.
  *
- * Edge weights are assumed to be non-negative numbers (including `Infinity`)
+ * @template {GenericGraphNode} [T=string] The type of nodes in the graph. If
+ * `T` is not a string, relative paths will be compared by coercion to strings.
  */
 export class GenericGraph {
   /**
@@ -132,16 +149,10 @@ export class GenericGraph {
    */
   #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();
   }
@@ -194,42 +205,6 @@ export class GenericGraph {
     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.
    *
@@ -240,17 +215,15 @@ export class GenericGraph {
    *
    * @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) {
+  addEdge(source, target) {
     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;
   }
 
@@ -279,42 +252,32 @@ export class GenericGraph {
 }
 
 /**
- * Dijkstra's algorithm for shortest paths in a graph.
- * @template [T=string] The type of nodes in the graph
+ * Dijkstra's single-source shortest path algorithm.
+ *
+ * Computes shortest paths from `source` to **all** reachable nodes.
+ *
+ * @template {GenericGraphNode} [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 dijkstra = (graph, source) => {
   const { nodes } = graph;
   /** @type {TraversalContext<T>} */
   const context = {
-    distances: new Map(),
+    paths: new Map(),
     predecessors: new Map(),
-    queue: new Set(),
+    queue: nodes,
   };
-  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);
+  const { queue, paths } = context;
 
   for (const node of nodes) {
     queue.add(node);
   }
 
+  assert(queue.has(source), `Source ${q(source)} is not in the graph`);
+  paths.set(source, []);
+
   while (queue.size !== 0) {
     const node = extractMin(context);
     if (node === undefined) {
@@ -323,7 +286,7 @@ const dijkstra = (graph, source, target) => {
     const adjacent = graph.adjacent(node);
     if (adjacent) {
       for (const edge of adjacent) {
-        relax(graph, context, node, edge);
+        relax(context, node, edge);
       }
     }
   }
@@ -331,20 +294,32 @@ const dijkstra = (graph, source, target) => {
 };
 
 /**
- * Returns a function which uses Dijkstra's shortest path algorithm to compute
- * the shortest path from `source` to `destination` in the given `graph`.
+ * Returns a function which computes the shortest path from `source` to
+ * `target` in the given `graph`.
  *
- * @template [T=string]
+ * Dijkstra's algorithm is a _single-source_ shortest path algorithm: one run
+ * produces shortest paths to every reachable node. The returned function
+ * caches the traversal context by source, so the first call for a given source
+ * pays O(V²) and every subsequent call with the same source is O(path length).
+ *
+ * @template {GenericGraphNode} [T=string]
  * @param {GenericGraph<T>} graph Graph to use
  */
 export const makeShortestPath = graph => {
+  /** @type {Map<T, TraversalContext<T>>} */
+  const contextCache = new Map();
+
   /**
    * @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);
+    let context = contextCache.get(source);
+    if (!context) {
+      context = dijkstra(graph, source);
+      contextCache.set(source, context);
+    }
     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,