@endo/compartment-mapper 1.6.3 → 2.0.0

package/src/digest.d.ts

@@ -1,5 +1,25 @@
-export function digestCompartmentMap(compartmentMap: CompartmentMapDescriptor, sources: Sources): DigestResult;
-import type { CompartmentMapDescriptor } from './types.js';
+/**
+ * @template {string} [OldCompartmentName=FileUrlString]
+ * @template {string} [NewCompartmentName=PackageCompartmentDescriptorName]
+ * @overload
+ * @param {PackageCompartmentMapDescriptor} compartmentMap
+ * @param {Sources} sources
+ * @param {DigestCompartmentMapOptions<OldCompartmentName, NewCompartmentName>} [options]
+ * @returns {DigestResult<OldCompartmentName, NewCompartmentName>}
+ */
+export function digestCompartmentMap<OldCompartmentName extends string = `file://${string}`, NewCompartmentName extends string = PackageCompartmentDescriptorName>(compartmentMap: PackageCompartmentMapDescriptor, sources: Sources, options?: DigestCompartmentMapOptions<OldCompartmentName, NewCompartmentName> | undefined): DigestResult<OldCompartmentName, NewCompartmentName>;
+/**
+ * @overload
+ * @param {PackageCompartmentMapDescriptor} compartmentMap
+ * @param {Sources} sources
+ * @param {DigestCompartmentMapOptions<FileUrlString, PackageCompartmentDescriptorName>} [options]
+ * @returns {DigestResult<FileUrlString, PackageCompartmentDescriptorName>}
+ */
+export function digestCompartmentMap(compartmentMap: PackageCompartmentMapDescriptor, sources: Sources, options?: DigestCompartmentMapOptions<`file://${string}`, PackageCompartmentDescriptorName> | undefined): DigestResult<FileUrlString, PackageCompartmentDescriptorName>;
+import type { PackageCompartmentDescriptorName } from './types.js';
+import type { PackageCompartmentMapDescriptor } from './types.js';
 import type { Sources } from './types.js';
+import type { DigestCompartmentMapOptions } from './types.js';
 import type { DigestResult } from './types.js';
+import type { FileUrlString } from './types.js';
 //# sourceMappingURL=digest.d.ts.map

package/src/digest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"digest.d.ts","sourceRoot":"","sources":["digest.js"],"names":[],"mappings":"AAqLO,qDAJI,wBAAwB,WACxB,OAAO,GACL,YAAY,CAoDxB;8CAxNS,YAAY;6BAAZ,YAAY;kCAAZ,YAAY"}
+{"version":3,"file":"digest.d.ts","sourceRoot":"","sources":["digest.js"],"names":[],"mappings":";;;;;;;;;AAiQG,qCA5JoB,kBAAkB,SAA5B,MAAQ,uBACE,kBAAkB,SAA5B,MAAQ,qDA4JV,+BAA+B,WAC/B,OAAO,8FAEL,aAAa,kBAAkB,EAAE,kBAAkB,CAAC,CAChE;;;;;;;;AAGE,qDACQ,+BAA+B,WAC/B,OAAO,4GAEL,aAAa,aAAa,EAAE,gCAAgC,CAAC,CACzE;sDAlPS,YAAY;qDAAZ,YAAY;6BAAZ,YAAY;iDAAZ,YAAY;kCAAZ,YAAY;mCAAZ,YAAY"}

package/src/digest.js

@@ -8,18 +8,41 @@
 
 /**
  * @import {
- *   CompartmentDescriptor,
- *   CompartmentMapDescriptor,
+ *   DigestedCompartmentDescriptors,
  *   DigestResult,
- *   ModuleDescriptor,
+ *   PackageCompartmentDescriptors,
+ *   PackageCompartmentMapDescriptor,
+ *   ModuleConfiguration,
  *   Sources,
+ *   ExitModuleConfiguration,
+ *   FileModuleConfiguration,
+ *   ErrorModuleConfiguration,
+ *   DigestedCompartmentMapDescriptor,
+ *   DigestedCompartmentDescriptor,
+ *   DigestCompartmentMapOptions,
+ *   PackageCompartmentDescriptor,
+ *   PackageCompartmentDescriptorName,
+ *   CompartmentModuleConfiguration,
+ *   CanonicalName,
+ *   CompartmentsRenameFn,
+ FileUrlString,
  * } from './types.js'
  */
 
-import { pathCompare } from '@endo/path-compare';
-import { assertCompartmentMap, stringCompare } from './compartment-map.js';
+import {
+  assertDigestedCompartmentMap,
+  stringCompare,
+} from './compartment-map.js';
+import {
+  isErrorModuleSource,
+  isExitModuleSource,
+  isLocalModuleSource,
+} from './guards.js';
 
-const { create, fromEntries, entries, keys } = Object;
+const { create, fromEntries, entries, keys, values } = Object;
+const { quote: q } = assert;
+
+const noop = () => {};
 
 /**
  * We attempt to produce compartment maps that are consistent regardless of
@@ -49,71 +72,94 @@ const { create, fromEntries, entries, keys } = Object;
  * actual installation location, so should be orthogonal to the vagaries of the
  * package manager's deduplication algorithm.
  *
- * @param {Record<string, CompartmentDescriptor>} compartments
- * @returns {Record<string, string>} map from old to new compartment names.
+ * @type {CompartmentsRenameFn<FileUrlString, PackageCompartmentDescriptorName>}
  */
-const renameCompartments = compartments => {
-  /** @type {Record<string, string>} */
+const defaultRenameCompartments = compartments => {
+  /** @type {Record<FileUrlString, PackageCompartmentDescriptorName>} */
   const compartmentRenames = create(null);
-  let index = 0;
-  let prev = '';
 
   // The sort below combines two comparators to avoid depending on sort
   // stability, which became standard as recently as 2019.
   // If that date seems quaint, please accept my regards from the distant past.
   // We are very proud of you.
-  const compartmentsByPath = Object.entries(compartments)
-    .map(([name, compartment]) => ({
-      name,
-      path: compartment.path,
-      label: compartment.label,
-    }))
-    .sort((a, b) => {
-      if (a.label === b.label) {
-        assert(a.path !== undefined && b.path !== undefined);
-        return pathCompare(a.path, b.path);
-      }
-      return stringCompare(a.label, b.label);
-    });
-
-  for (const { name, label } of compartmentsByPath) {
-    if (label === prev) {
-      compartmentRenames[name] = `${label}-n${index}`;
-      index += 1;
-    } else {
-      compartmentRenames[name] = label;
-      prev = label;
-      index = 1;
-    }
+  const comaprtmentNamesToLabel =
+    /** @type {Array<{name: FileUrlString, label: PackageCompartmentDescriptorName}>} */ (
+      Object.entries(compartments)
+        .map(([name, compartment]) => ({
+          name,
+          label: compartment.label,
+        }))
+        .sort((a, b) => stringCompare(a.label, b.label))
+    );
+
+  for (const { name, label } of comaprtmentNamesToLabel) {
+    compartmentRenames[name] = label;
   }
   return compartmentRenames;
 };
 
 /**
- * @param {Record<string, CompartmentDescriptor>} compartments
+ * @template {string} [OldCompartmentName=FileUrlString]
+ * @template {string} [NewCompartmentName=PackageCompartmentDescriptorName]
+ * @overload
+ * @param {PackageCompartmentDescriptors} compartmentDescriptors
  * @param {Sources} sources
- * @param {Record<string, string>} compartmentRenames
+ * @param {Record<OldCompartmentName, NewCompartmentName>} compartmentRenames
+ * @param {DigestCompartmentMapOptions<OldCompartmentName, NewCompartmentName>} [options]
+ * @returns {DigestedCompartmentDescriptors}
  */
-const translateCompartmentMap = (compartments, sources, compartmentRenames) => {
+/**
+ * @overload
+ * @param {PackageCompartmentDescriptors} compartmentDescriptors
+ * @param {Sources} sources
+ * @param {Record<FileUrlString, PackageCompartmentDescriptorName>} compartmentRenames
+ * @param {DigestCompartmentMapOptions} [options]
+ * @returns {DigestedCompartmentDescriptors}
+ */
+
+/**
+ * @template {string} [OldCompartmentName=FileUrlString]
+ * @template {string} [NewCompartmentName=PackageCompartmentDescriptorName]
+ * @param {PackageCompartmentDescriptors} compartmentDescriptors
+ * @param {Sources} sources
+ * @param {Record<OldCompartmentName, NewCompartmentName>} compartmentRenames
+ * @param {DigestCompartmentMapOptions<OldCompartmentName, NewCompartmentName>} [options]
+ */
+const translateCompartmentMap = (
+  compartmentDescriptors,
+  sources,
+  compartmentRenames,
+  { packageConnectionsHook, log = noop } = {},
+) => {
   const result = create(null);
   for (const compartmentName of keys(compartmentRenames)) {
-    const compartment = compartments[compartmentName];
-    const { name, label, retained: compartmentRetained, policy } = compartment;
+    /** @type {PackageCompartmentDescriptor} */
+    const compartmentDescriptor = compartmentDescriptors[compartmentName];
+    const {
+      name,
+      label,
+      retained: compartmentRetained,
+      policy,
+    } = compartmentDescriptor;
+    /** @type {Record<string, PackageCompartmentDescriptorName>} */
+    const renamedModuleConfigurations = {};
     if (compartmentRetained) {
       // rename module compartments
-      /** @type {Record<string, ModuleDescriptor>} */
+      /** @type {Record<string, ModuleConfiguration>} */
       const modules = create(null);
-      const compartmentModules = compartment.modules;
-      if (compartment.modules) {
+      const compartmentModules = compartmentDescriptor.modules;
+      if (compartmentDescriptor.modules) {
         for (const name of keys(compartmentModules).sort()) {
           const { retained: moduleRetained, ...retainedModule } =
             compartmentModules[name];
           if (moduleRetained) {
             if (retainedModule.compartment !== undefined) {
+              /** @type {CompartmentModuleConfiguration} */
               modules[name] = {
                 ...retainedModule,
                 compartment: compartmentRenames[retainedModule.compartment],
               };
+              renamedModuleConfigurations[name] = retainedModule.compartment;
             } else {
               modules[name] = retainedModule;
             }
@@ -126,25 +172,40 @@ const translateCompartmentMap = (compartments, sources, compartmentRenames) => {
       if (compartmentSources) {
         for (const name of keys(compartmentSources).sort()) {
           const source = compartmentSources[name];
-          const { location, parser, exit, sha512, deferredError } = source;
-          if (location !== undefined) {
+          if (isLocalModuleSource(source)) {
+            const { location, parser, sha512 } = source;
+            /** @type {FileModuleConfiguration} */
             modules[name] = {
               location,
               parser,
               sha512,
+              __createdBy: 'digest',
             };
-          } else if (exit !== undefined) {
+          } else if (isExitModuleSource(source)) {
+            const { exit } = source;
+            /** @type {ExitModuleConfiguration} */
             modules[name] = {
               exit,
+              __createdBy: 'digest',
             };
-          } else if (deferredError !== undefined) {
+          } else if (isErrorModuleSource(source)) {
+            const { deferredError } = source;
+            /** @type {ErrorModuleConfiguration} */
             modules[name] = {
               deferredError,
+              __createdBy: 'digest',
             };
+          } else {
+            throw new TypeError(
+              `Unexpected source type for compartment ${compartmentName} module ${name}: ${q(
+                source,
+              )}`,
+            );
           }
         }
       }
 
+      /** @type {DigestedCompartmentDescriptor} */
       result[compartmentRenames[compartmentName]] = {
         name,
         label,
@@ -154,6 +215,23 @@ const translateCompartmentMap = (compartments, sources, compartmentRenames) => {
         // `scopes`, `types`, and `parsers` are not necessary since every
         // loadable module is captured in `modules`.
       };
+
+      const links = /** @type {Set<CanonicalName>} */ (
+        values(modules).reduce((acc, moduleDescriptorConfig) => {
+          if ('compartment' in moduleDescriptorConfig) {
+            acc.add(moduleDescriptorConfig.compartment);
+          }
+          return acc;
+        }, new Set())
+      );
+
+      if (packageConnectionsHook) {
+        packageConnectionsHook({
+          canonicalName: label,
+          connections: links,
+          log,
+        });
+      }
     }
   }
 
@@ -175,26 +253,53 @@ const renameSources = (sources, compartmentRenames) => {
 };
 
 /**
- * @param {CompartmentMapDescriptor} compartmentMap
+ * @template {string} [OldCompartmentName=FileUrlString]
+ * @template {string} [NewCompartmentName=PackageCompartmentDescriptorName]
+ * @overload
+ * @param {PackageCompartmentMapDescriptor} compartmentMap
+ * @param {Sources} sources
+ * @param {DigestCompartmentMapOptions<OldCompartmentName, NewCompartmentName>} [options]
+ * @returns {DigestResult<OldCompartmentName, NewCompartmentName>}
+ */
+
+/**
+ * @overload
+ * @param {PackageCompartmentMapDescriptor} compartmentMap
  * @param {Sources} sources
- * @returns {DigestResult}
+ * @param {DigestCompartmentMapOptions<FileUrlString, PackageCompartmentDescriptorName>} [options]
+ * @returns {DigestResult<FileUrlString, PackageCompartmentDescriptorName>}
  */
-export const digestCompartmentMap = (compartmentMap, sources) => {
+
+/**
+ * @template {string} [OldCompartmentName=FileUrlString]
+ * @template {string} [NewCompartmentName=PackageCompartmentDescriptorName]
+ * @param {PackageCompartmentMapDescriptor} compartmentMap
+ * @param {Sources} sources
+ * @param {DigestCompartmentMapOptions<OldCompartmentName, NewCompartmentName>} [options]
+ */
+export const digestCompartmentMap = (
+  compartmentMap,
+  sources,
+  { packageConnectionsHook, log = noop, renameCompartments } = {},
+) => {
   const {
     compartments,
     entry: { compartment: entryCompartmentName, module: entryModuleSpecifier },
   } = compartmentMap;
 
-  const oldToNewCompartmentNames = renameCompartments(compartments);
+  const renameCompartmentsFn = renameCompartments ?? defaultRenameCompartments;
+  const oldToNewCompartmentNames = renameCompartmentsFn(compartments);
   const digestCompartments = translateCompartmentMap(
     compartments,
     sources,
     oldToNewCompartmentNames,
+    { packageConnectionsHook, log },
   );
   const digestEntryCompartmentName =
     oldToNewCompartmentNames[entryCompartmentName];
   const digestSources = renameSources(sources, oldToNewCompartmentNames);
 
+  /** @type {DigestedCompartmentMapDescriptor} */
   const digestCompartmentMap = {
     // TODO graceful migration from tags to conditions
     // https://github.com/endojs/endo/issues/2388
@@ -210,8 +315,18 @@ export const digestCompartmentMap = (compartmentMap, sources) => {
   // We assert that we have constructed a valid compartment map, not because it
   // might not be, but to ensure that the assertCompartmentMap function can
   // accept all valid compartment maps.
-  assertCompartmentMap(digestCompartmentMap);
+  try {
+    assertDigestedCompartmentMap(digestCompartmentMap);
+  } catch (err) {
+    throw new TypeError(
+      `Invalid compartment map; ${JSON.stringify(
+        digestCompartmentMap,
+      )}:\n${err.message}`,
+      { cause: err },
+    );
+  }
 
+  /** @type {Record<NewCompartmentName, OldCompartmentName>} */
   const newToOldCompartmentNames = fromEntries(
     entries(oldToNewCompartmentNames).map(([oldName, newName]) => [
       newName,
@@ -219,14 +334,22 @@ export const digestCompartmentMap = (compartmentMap, sources) => {
     ]),
   );
 
-  /** @type {DigestResult} */
-  const digestResult = {
+  if (renameCompartments === defaultRenameCompartments) {
+    /** @type {DigestResult} */
+    return {
+      compartmentMap: digestCompartmentMap,
+      sources: digestSources,
+      oldToNewCompartmentNames,
+      newToOldCompartmentNames,
+      compartmentRenames: newToOldCompartmentNames,
+    };
+  }
+  /** @type {DigestResult<OldCompartmentName, NewCompartmentName>} */
+  return {
     compartmentMap: digestCompartmentMap,
     sources: digestSources,
     oldToNewCompartmentNames,
     newToOldCompartmentNames,
     compartmentRenames: newToOldCompartmentNames,
   };
-
-  return digestResult;
 };

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

@@ -1 +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"}
+{"version":3,"file":"generic-graph.d.ts","sourceRoot":"","sources":["generic-graph.js"],"names":[],"mappings":"AAyHA;;;;;;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

@@ -2,7 +2,7 @@
  * 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.
  *
@@ -13,7 +13,7 @@
  * @import {TraversalContext} from './types/generic-graph.js';
  */
 
-const { stringify: q } = JSON;
+const { quote: q } = assert;
 
 /**
  * Remove the node with the minimum weight from the priority queue.
@@ -94,6 +94,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)) {
@@ -108,7 +113,7 @@ const getPath = ({ predecessors }, source, target) => {
 
   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());

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;