@endo/compartment-mapper 1.4.0 → 1.6.0

package/src/node-modules.js

@@ -17,57 +17,27 @@
  *   CompartmentDescriptor,
  *   CompartmentMapDescriptor,
  *   CompartmentMapForNodeModulesOptions,
- *   Language,
  *   LanguageForExtension,
  *   MapNodeModulesOptions,
  *   MaybeReadFn,
  *   MaybeReadPowers,
- *   ModuleDescriptor,
+ *   PackageDescriptor,
+ *   ReadDescriptorFn,
  *   ReadFn,
  *   ReadPowers,
- *   ScopeDescriptor,
  *   SomePackagePolicy,
  *   SomePolicy,
  * } from './types.js'
- */
-
-/**
- * The graph is an intermediate object model that the functions of this module
- * build by exploring the `node_modules` tree dropped by tools like npm and
- * consumed by tools like Node.js.
- * This gets translated finally into a compartment map.
- *
- * @typedef {Record<string, Node>} Graph
- */
-
-/**
- * @typedef {object} Node
- * @property {string} label
- * @property {string} name
- * @property {Array<string>} path
- * @property {Array<string>} logicalPath
- * @property {boolean} explicitExports
- * @property {Record<string, string>} internalAliases
- * @property {Record<string, string>} externalAliases
- * @property {Record<string, string>} dependencyLocations - from module name to
- * location in storage.
- * @property {LanguageForExtension} parsers - the parser for
- * modules based on their extension.
- * @property {Record<string, Language>} types - the parser for specific
- * modules.
- */
-
-/**
- * @typedef {object} LanguageOptions
- * @property {LanguageForExtension} commonjsLanguageForExtension
- * @property {LanguageForExtension} moduleLanguageForExtension
- * @property {LanguageForExtension} workspaceCommonjsLanguageForExtension
- * @property {LanguageForExtension} workspaceModuleLanguageForExtension
- * @property {Set<string>} languages
- */
-
-/**
- * @typedef {Record<string, {spec: string, alias: string}>} CommonDependencyDescriptors
+ * @import {
+ *   Graph,
+ *   Node,
+ *   LanguageOptions,
+ *   CommonDependencyDescriptors,
+ *   GatherDependencyOptions,
+ *   GraphPackageOptions,
+ *   GraphPackagesOptions,
+ *   PackageDetails,
+ * } from './types/node-modules.js'
  */
 
 import { pathCompare } from './compartment-map.js';
@@ -90,6 +60,11 @@ const decoder = new TextDecoder();
 // q, as in quote, for enquoting strings in error messages.
 const q = JSON.stringify;
 
+/**
+ * Default logger that does nothing.
+ */
+const noop = () => {};
+
 /**
  * @param {string} rel - a relative URL
  * @param {string} abs - a fully qualified URL
@@ -99,12 +74,16 @@ const resolveLocation = (rel, abs) => {
   return new URL(rel, abs).toString();
 };
 
+// Exported for testing:
 /**
  * @param {string} location
  * @returns {string}
  */
-const basename = location => {
-  const { pathname } = new URL(location);
+export const basename = location => {
+  let { pathname } = new URL(location);
+  if (pathname.endsWith('/')) {
+    pathname = pathname.slice(0, -1);
+  }
   const index = pathname.lastIndexOf('/');
   if (index < 0) {
     return pathname;
@@ -145,27 +124,19 @@ const readDescriptorWithMemo = async (memo, maybeRead, packageLocation) => {
 };
 
 /**
- * @callback ReadDescriptorFn
- * @param {string} packageLocation
- * @returns {Promise<object>}
- */
-
-/**
- * findPackage behaves as Node.js to find third-party modules by searching
+ * `findPackage` behaves as Node.js to find third-party modules by searching
  * parent to ancestor directories for a `node_modules` directory that contains
  * the name.
+ *
  * Node.js does not actually require these to be packages, but in practice,
- * these are the locations that pakcage managers drop a package so Node.js can
+ * these are the locations that package managers drop a package so Node.js can
  * find it efficiently.
  *
  * @param {ReadDescriptorFn} readDescriptor
  * @param {CanonicalFn} canonical
  * @param {string} directory
  * @param {string} name
- * @returns {Promise<{
- *   packageLocation: string,
- *   packageDescriptor: object,
- * } | undefined>}
+ * @returns {Promise<PackageDetails|undefined>}
  */
 const findPackage = async (readDescriptor, canonical, directory, name) => {
   await null;
@@ -198,6 +169,7 @@ const findPackage = async (readDescriptor, canonical, directory, name) => {
   }
 };
 
+/** @satisfies {LanguageForExtension} */
 const defaultLanguageForExtension = /** @type {const} */ ({
   mjs: 'mjs',
   cjs: 'cjs',
@@ -205,15 +177,19 @@ const defaultLanguageForExtension = /** @type {const} */ ({
   text: 'text',
   bytes: 'bytes',
 });
+
+/** @satisfies {LanguageForExtension} */
 const defaultCommonjsLanguageForExtension = /** @type {const} */ ({
   js: 'cjs',
 });
+
+/** @satisfies {LanguageForExtension} */
 const defaultModuleLanguageForExtension = /** @type {const} */ ({
   js: 'mjs',
 });
 
 /**
- * @param {object} descriptor
+ * @param {PackageDescriptor} descriptor
  * @param {string} location
  * @param {LanguageOptions} languageOptions
  * @returns {Record<string, string>}
@@ -278,7 +254,7 @@ const inferParsers = (descriptor, location, languageOptions) => {
 };
 
 /**
- * graphPackage and gatherDependency are mutually recursive functions that
+ * `graphPackage` and {@link gatherDependency} are mutually recursive functions that
  * gather the metadata for a package and its transitive dependencies.
  * The keys of the graph are the locations of the package descriptors.
  * The metadata include a label (which is informative and not necessarily
@@ -289,15 +265,12 @@ const inferParsers = (descriptor, location, languageOptions) => {
  * @param {ReadDescriptorFn} readDescriptor
  * @param {CanonicalFn} canonical
  * @param {Graph} graph
- * @param {object} packageDetails
- * @param {string} packageDetails.packageLocation
- * @param {object} packageDetails.packageDescriptor
+ * @param {PackageDetails} packageDetails
  * @param {Set<string>} conditions
  * @param {boolean | undefined} dev
- * @param {CommonDependencyDescriptors} commonDependencyDescriptors
  * @param {LanguageOptions} languageOptions
- * @param {Map<string, Array<string>>} preferredPackageLogicalPathMap
- * @param {Array<string>} logicalPath
+ * @param {boolean} strict
+ * @param {GraphPackageOptions} options
  * @returns {Promise<undefined>}
  */
 const graphPackage = async (
@@ -308,10 +281,14 @@ const graphPackage = async (
   { packageLocation, packageDescriptor },
   conditions,
   dev,
-  commonDependencyDescriptors,
   languageOptions,
-  preferredPackageLogicalPathMap = new Map(),
-  logicalPath = [],
+  strict,
+  {
+    commonDependencyDescriptors = {},
+    preferredPackageLogicalPathMap = new Map(),
+    logicalPath = [],
+    log = noop,
+  } = {},
 ) => {
   if (graph[packageLocation] !== undefined) {
     // Returning the promise here would create a causal cycle and stall recursion.
@@ -319,20 +296,19 @@ const graphPackage = async (
   }
 
   if (packageDescriptor.name !== name) {
-    console.warn(
-      `Package named ${q(
-        name,
-      )} does not match location ${packageLocation} got (${q(
-        packageDescriptor.name,
-      )})`,
-    );
+    log('Package name does not match location', {
+      name,
+      packageDescriptorName: packageDescriptor.name,
+      packageLocation,
+    });
   }
 
-  const result = {};
-  graph[packageLocation] = /** @type {Node} */ (result);
+  const result = /** @type {Node} */ ({});
+  graph[packageLocation] = result;
 
-  /** @type {Record<string, string>} */
+  /** @type {Node['dependencyLocations']} */
   const dependencyLocations = {};
+  /** @type {ReturnType<typeof gatherDependency>[]} */
   const children = [];
   const optionals = new Set();
   const {
@@ -344,14 +320,18 @@ const graphPackage = async (
     devDependencies = {},
   } = packageDescriptor;
   const allDependencies = {};
-  assign(allDependencies, commonDependencyDescriptors);
-  for (const [name, { spec }] of Object.entries(commonDependencyDescriptors)) {
-    allDependencies[name] = spec;
+  for (const [name, descriptor] of Object.entries(
+    commonDependencyDescriptors,
+  )) {
+    if (Object(descriptor) === descriptor) {
+      const { spec } = descriptor;
+      allDependencies[name] = spec;
+    }
   }
   assign(allDependencies, dependencies);
   assign(allDependencies, peerDependencies);
-  for (const [name, { optional }] of Object.entries(peerDependenciesMeta)) {
-    if (optional) {
+  for (const [name, meta] of Object.entries(peerDependenciesMeta)) {
+    if (Object(meta) === meta && meta.optional) {
       optionals.add(name);
     }
   }
@@ -360,7 +340,7 @@ const graphPackage = async (
   for (const name of Object.keys(optionalDependencies)) {
     optionals.add(name);
   }
-  if (dev !== undefined && dev !== null ? dev : conditions.has('development')) {
+  if (dev) {
     assign(allDependencies, devDependencies);
   }
 
@@ -380,17 +360,25 @@ const graphPackage = async (
         conditions,
         preferredPackageLogicalPathMap,
         languageOptions,
-        childLogicalPath,
-        optional,
-        commonDependencyDescriptors,
+        strict,
+        {
+          childLogicalPath,
+          optional,
+          commonDependencyDescriptors,
+          log,
+        },
       ),
     );
   }
 
   const { version = '', exports: exportsDescriptor } = packageDescriptor;
-  /** @type {Record<string, Language>} */
+  /** @type {Node['types']} */
   const types = {};
 
+  /**
+   * @param {string} path
+   * @returns {Promise<PackageDescriptor>}
+   */
   const readDescriptorUpwards = async path => {
     const location = resolveLocation(path, packageLocation);
     // readDescriptor coming from above is memoized, so this is not awfully slow
@@ -398,9 +386,9 @@ const graphPackage = async (
     return data;
   };
 
-  /** @type {Record<string, string>} */
+  /** @type {Node['externalAliases']} */
   const externalAliases = {};
-  /** @type {Record<string, string>} */
+  /** @type {Node['internalAliases']} */
   const internalAliases = {};
 
   inferExportsAndAliases(
@@ -417,10 +405,13 @@ const graphPackage = async (
     languageOptions,
   );
 
+  const sourceDirname = basename(packageLocation);
+
   Object.assign(result, {
     name,
     path: logicalPath,
     label: `${name}${version ? `-v${version}` : ''}`,
+    sourceDirname,
     explicitExports: exportsDescriptor !== undefined,
     externalAliases,
     internalAliases,
@@ -472,6 +463,8 @@ const graphPackage = async (
 };
 
 /**
+ * Adds information for the dependency of the package at `packageLocation` to the `graph` object.
+ *
  * @param {ReadDescriptorFn} readDescriptor
  * @param {CanonicalFn} canonical
  * @param {Graph} graph - the partially build graph.
@@ -481,9 +474,9 @@ const graphPackage = async (
  * @param {Set<string>} conditions
  * @param {Map<string, Array<string>>} preferredPackageLogicalPathMap
  * @param {LanguageOptions} languageOptions
- * @param {Array<string>} [childLogicalPath]
- * @param {boolean} [optional] - whether the dependency is optional
- * @param {object} [commonDependencyDescriptors] - dependencies to be added to all packages
+ * @param {boolean} strict - If `true`, a missing dependency will throw an exception
+ * @param {GatherDependencyOptions} options
+ * @returns {Promise<void>}
  */
 const gatherDependency = async (
   readDescriptor,
@@ -495,9 +488,13 @@ const gatherDependency = async (
   conditions,
   preferredPackageLogicalPathMap,
   languageOptions,
-  childLogicalPath = [],
-  optional = false,
-  commonDependencyDescriptors = undefined,
+  strict,
+  {
+    childLogicalPath = [],
+    optional = false,
+    commonDependencyDescriptors = {},
+    log = noop,
+  } = {},
 ) => {
   const dependency = await findPackage(
     readDescriptor,
@@ -507,7 +504,7 @@ const gatherDependency = async (
   );
   if (dependency === undefined) {
     // allow the dependency to be missing if optional
-    if (optional) {
+    if (optional || !strict) {
       return;
     }
     throw Error(`Cannot find dependency ${name} for ${packageLocation}`);
@@ -530,32 +527,35 @@ const gatherDependency = async (
     dependency,
     conditions,
     false,
-    commonDependencyDescriptors,
     languageOptions,
-    preferredPackageLogicalPathMap,
-    childLogicalPath,
+    strict,
+    {
+      commonDependencyDescriptors,
+      preferredPackageLogicalPathMap,
+      logicalPath: childLogicalPath,
+      log,
+    },
   );
 };
 
 /**
- * graphPackages returns a graph whose keys are nominally URLs, one per
- * package, with values that are label: (an informative Compartment name, built
- * as ${name}@${version}), dependencies: (a list of URLs), and exports: (an
- * object whose keys are the thing being imported, and the values are the names
- * of the matching module, relative to the containing package's root, that is,
- * the URL that was used as the key of graph).
- * The URLs in dependencies will all exist as other keys of graph.
+ * Resolves with a {@link Graph} representing the packages for which
+ * {@link CompartmentDescriptor CompartmentDescriptors} will be created.
  *
  * @param {MaybeReadFn} maybeRead
  * @param {CanonicalFn} canonical
  * @param {string} packageLocation - location of the main package.
  * @param {Set<string>} conditions
- * @param {object} mainPackageDescriptor - the parsed contents of the main
- * package.json, which was already read when searching for the package.json.
- * @param {boolean|undefined} dev - whether to use devDependencies from this package (and
- * only this package).
- * @param {Record<string,string>} commonDependencies - dependencies to be added to all packages
+ * @param {PackageDescriptor} mainPackageDescriptor - the parsed contents of the
+ * main `package.json`, which was already read when searching for the
+ * `package.json`.
+ * @param {boolean|undefined} dev - whether to use devDependencies from this
+ * package (and only this package).
+ * @param {Record<string,string>} commonDependencies - dependencies to be added
+ * to all packages
  * @param {LanguageOptions} languageOptions
+ * @param {boolean} strict
+ * @param {GraphPackagesOptions} options
  */
 const graphPackages = async (
   maybeRead,
@@ -566,11 +566,13 @@ const graphPackages = async (
   dev,
   commonDependencies,
   languageOptions,
+  strict,
+  { log = noop } = {},
 ) => {
   const memo = create(null);
   /**
    * @param {string} packageLocation
-   * @returns {Promise<object>}
+   * @returns {Promise<PackageDescriptor>}
    */
   const readDescriptor = packageLocation =>
     readDescriptorWithMemo(memo, maybeRead, packageLocation);
@@ -621,15 +623,19 @@ const graphPackages = async (
     },
     conditions,
     dev,
-    commonDependencyDescriptors,
     languageOptions,
+    strict,
+    {
+      commonDependencyDescriptors,
+      log,
+    },
   );
   return graph;
 };
 
 /**
- * translateGraph converts the graph returned by graph packages (above) into a
- * compartment map.
+ * `translateGraph` converts the graph returned by graph packages (above) into a
+ * {@link CompartmentMapDescriptor compartment map}.
  *
  * @param {string} entryPackageLocation
  * @param {string} entryModuleSpecifier
@@ -646,7 +652,7 @@ const translateGraph = (
   conditions,
   policy,
 ) => {
-  /** @type {Record<string, CompartmentDescriptor>} */
+  /** @type {CompartmentMapDescriptor['compartments']} */
   const compartments = Object.create(null);
 
   // For each package, build a map of all the external modules the package can
@@ -663,14 +669,15 @@ const translateGraph = (
       name,
       path,
       label,
+      sourceDirname,
       dependencyLocations,
       internalAliases,
       parsers,
       types,
     } = graph[dependeeLocation];
-    /** @type {Record<string, ModuleDescriptor>} */
+    /** @type {CompartmentDescriptor['modules']} */
     const moduleDescriptors = Object.create(null);
-    /** @type {Record<string, ScopeDescriptor>} */
+    /** @type {CompartmentDescriptor['scopes']} */
     const scopes = Object.create(null);
 
     /**
@@ -757,6 +764,7 @@ const translateGraph = (
       name,
       path,
       location: dependeeLocation,
+      sourceDirname,
       modules: moduleDescriptors,
       scopes,
       parsers,
@@ -849,33 +857,49 @@ const makeLanguageOptions = ({
 /**
  * @param {ReadFn | ReadPowers | MaybeReadPowers} readPowers
  * @param {string} packageLocation
- * @param {Set<string>} conditions
- * @param {object} packageDescriptor
+ * @param {Set<string>} conditionsOption
+ * @param {PackageDescriptor} packageDescriptor
  * @param {string} moduleSpecifier
  * @param {CompartmentMapForNodeModulesOptions} [options]
  * @returns {Promise<CompartmentMapDescriptor>}
+ * @deprecated Use {@link mapNodeModules} instead.
  */
 export const compartmentMapForNodeModules = async (
   readPowers,
   packageLocation,
-  conditions,
+  conditionsOption,
   packageDescriptor,
   moduleSpecifier,
   options = {},
 ) => {
-  const { dev = undefined, commonDependencies = {}, policy } = options;
+  const {
+    dev = false,
+    commonDependencies = {},
+    policy,
+    strict = false,
+    log = noop,
+  } = options;
   const { maybeRead, canonical } = unpackReadPowers(readPowers);
   const languageOptions = makeLanguageOptions(options);
 
+  const conditions = new Set(conditionsOption || []);
+
+  // dev is only set for the entry package, and implied by the development
+  // condition.
+  // The dev option is deprecated in favor of using conditions, since that
+  // covers more intentional behaviors of the development mode.
+
   const graph = await graphPackages(
     maybeRead,
     canonical,
     packageLocation,
     conditions,
     packageDescriptor,
-    dev,
+    dev || (conditions && conditions.has('development')),
     commonDependencies,
     languageOptions,
+    strict,
+    { log },
   );
 
   if (policy) {
@@ -906,6 +930,11 @@ export const compartmentMapForNodeModules = async (
 };
 
 /**
+ * Creates a {@link CompartmentMapDescriptor} from the module at
+ * `moduleLocation`, considering dependencies found in `node_modules`.
+ *
+ * Locates the {@link PackageDescriptor} for the module at `moduleLocation`
+ *
  * @param {ReadFn | ReadPowers | MaybeReadPowers} readPowers
  * @param {string} moduleLocation
  * @param {MapNodeModulesOptions} [options]
@@ -914,20 +943,17 @@ export const compartmentMapForNodeModules = async (
 export const mapNodeModules = async (
   readPowers,
   moduleLocation,
-  options = {},
+  { tags = new Set(), conditions = tags, log = noop, ...otherOptions } = {},
 ) => {
-  const { tags = new Set(), conditions = tags, ...otherOptions } = options;
-
   const {
     packageLocation,
     packageDescriptorText,
     packageDescriptorLocation,
     moduleSpecifier,
-  } = await search(readPowers, moduleLocation);
+  } = await search(readPowers, moduleLocation, { log });
 
-  const packageDescriptor = parseLocatedJson(
-    packageDescriptorText,
-    packageDescriptorLocation,
+  const packageDescriptor = /** @type {PackageDescriptor} */ (
+    parseLocatedJson(packageDescriptorText, packageDescriptorLocation)
   );
 
   return compartmentMapForNodeModules(
@@ -936,6 +962,6 @@ export const mapNodeModules = async (
     conditions,
     packageDescriptor,
     moduleSpecifier,
-    otherOptions,
+    { log, ...otherOptions },
   );
 };

package/src/parse-archive-cjs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-archive-cjs.d.ts","sourceRoot":"","sources":["parse-archive-cjs.js"],"names":[],"mappings":"AAkBA,sBAAsB;AACtB,8BADW,OAAO,CA6ChB;wBAES,OAAO,YAAY,EAAE,oBAAoB;;6BA5DzB,YAAY"}
+{"version":3,"file":"parse-archive-cjs.d.ts","sourceRoot":"","sources":["parse-archive-cjs.js"],"names":[],"mappings":"AAkBA,sBAAsB;AACtB,8BADW,OAAO,CAkDhB;wBAES,OAAO,YAAY,EAAE,oBAAoB;;6BAjEzB,YAAY"}

package/src/parse-archive-cjs.js

@@ -22,9 +22,12 @@ export const parseArchiveCjs = (
   _specifier,
   location,
   _packageLocation,
+  options = {},
 ) => {
   const source = textDecoder.decode(bytes);
 
+  const { archiveOnly = false } = options;
+
   const {
     requires: imports,
     exports,
@@ -35,18 +38,20 @@ export const parseArchiveCjs = (
     exports.push('default');
   }
 
-  const cjsWrappedSource = `(function (require, exports, module, __filename, __dirname) { ${source} //*/\n})\n`;
+  let cjsFunctor = `(function (require, exports, module, __filename, __dirname) { 'use strict'; ${source} //*/\n})\n`;
 
   const pre = textEncoder.encode(
     JSON.stringify({
       imports,
       exports,
       reexports,
-      source: cjsWrappedSource,
+      source: cjsFunctor,
     }),
   );
 
-  const cjsFunctor = `${cjsWrappedSource}//# sourceURL=${location}\n`;
+  if (!archiveOnly) {
+    cjsFunctor = `${cjsFunctor}//# sourceURL=${location}\n`;
+  }
 
   return {
     parser: 'pre-cjs-json',

package/src/parse-cjs-shared-export-wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-cjs-shared-export-wrapper.d.ts","sourceRoot":"","sources":["parse-cjs-shared-export-wrapper.js"],"names":[],"mappings":"AAwCO,2CAPI,UAAU,GAAG,MAAM,GAAG,SAAS,YAC/B,MAAM,GACJ;IACR,QAAQ,EAAC,MAAM,GAAC,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,GAAC,IAAI,CAAA;CACrB,CAgCH;AAmBM,uGAZJ;IAAmB,uBAAuB,EAAlC,MAAM;IACU,WAAW,EAA3B,WAAW;IACgB,eAAe,EAA1C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IACX,QAAQ,EAAnB,MAAM;IAC8B,UAAU,EAA9C,MAAM,GAAG,UAAU,GAAG,SAAS;CACvC,GAAU;IACR,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,YAAY,WAAW;IACvB,OAAO,WAAW;CACnB,CAmIH;gCApNqC,YAAY;4BAAZ,YAAY"}
+{"version":3,"file":"parse-cjs-shared-export-wrapper.d.ts","sourceRoot":"","sources":["parse-cjs-shared-export-wrapper.js"],"names":[],"mappings":"AAwCO,2CAPI,UAAU,GAAG,MAAM,GAAG,SAAS,YAC/B,MAAM,GACJ;IACR,QAAQ,EAAC,MAAM,GAAC,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,GAAC,IAAI,CAAA;CACrB,CAgCH;AAmBM,uGAZJ;IAAmB,uBAAuB,EAAlC,MAAM;IACU,WAAW,EAA3B,WAAW;IACgB,eAAe,EAA1C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IACX,QAAQ,EAAnB,MAAM;IAC8B,UAAU,EAA9C,MAAM,GAAG,UAAU,GAAG,SAAS;CACvC,GAAU;IACR,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,YAAY,WAAW;IACvB,OAAO,WAAW;CACnB,CA2HH;gCA5MqC,YAAY;4BAAZ,YAAY"}

package/src/parse-cjs-shared-export-wrapper.js

@@ -135,16 +135,7 @@ export const wrap = ({
     },
   });
 
-  let finalExports = originalExports;
-
-  const module = freeze({
-    get exports() {
-      return finalExports;
-    },
-    set exports(value) {
-      finalExports = value;
-    },
-  });
+  const module = { exports: originalExports };
 
   /** @param {string} importSpecifier */
   const require = importSpecifier => {
@@ -192,6 +183,7 @@ export const wrap = ({
   freeze(require);
 
   const afterExecute = () => {
+    const finalExports = module.exports; // in case it's a getter, only call it once
     const exportsHaveBeenOverwritten = finalExports !== originalExports;
     // Promotes keys from redefined module.export to top level namespace for import *
     // Note: We could do it less consistently but closer to how node does it if we iterated over exports detected by

package/src/parse-cjs.js

@@ -41,7 +41,7 @@ export const parseCjs = (
    */
   const execute = (moduleEnvironmentRecord, compartment, resolvedImports) => {
     const functor = compartment.evaluate(
-      `(function (require, exports, module, __filename, __dirname) { ${source} //*/\n})\n//# sourceURL=${location}`,
+      `(function (require, exports, module, __filename, __dirname) { 'use strict'; ${source} })\n`,
     );
 
     const { require, moduleExports, module, afterExecute } = wrap({

package/src/parse-mjs.js

@@ -14,10 +14,10 @@ export const parseMjs = (
   _packageLocation,
   options = {},
 ) => {
-  const { sourceMap, sourceMapHook } = options;
+  const { sourceMap, sourceMapHook, archiveOnly = false } = options;
   const source = textDecoder.decode(bytes);
   const record = new ModuleSource(source, {
-    sourceUrl,
+    sourceUrl: archiveOnly ? undefined : sourceUrl,
     sourceMap,
     sourceMapUrl: sourceUrl,
     sourceMapHook,