@endo/compartment-mapper 1.2.1 → 1.3.0

package/src/node-modules.js

@@ -12,6 +12,8 @@
 /* eslint no-shadow: 0 */
 
 /** @import {CanonicalFn} from './types.js' */
+/** @import {CompartmentMapForNodeModulesOptions} from './types.js' */
+/** @import {SomePolicy} from './types.js' */
 /** @import {CompartmentDescriptor} from './types.js' */
 /** @import {CompartmentMapDescriptor} from './types.js' */
 /** @import {Language} from './types.js' */
@@ -605,7 +607,7 @@ const graphPackages = async (
  * @param {Graph} graph
  * @param {Set<string>} conditions - build conditions about the target environment
  * for selecting relevant exports, e.g., "browser" or "node".
- * @param {import('./types.js').Policy} [policy]
+ * @param {SomePolicy} [policy]
  * @returns {CompartmentMapDescriptor}
  */
 const translateGraph = (
@@ -642,6 +644,12 @@ const translateGraph = (
     /** @type {Record<string, ScopeDescriptor>} */
     const scopes = Object.create(null);
 
+    /**
+     * List of all the compartments (by name) that this compartment can import from.
+     *
+     * @type {Set<string>}
+     */
+    const compartmentNames = new Set();
     const packagePolicy = getPolicyForPackage(
       {
         isEntry: dependeeLocation === entryPackageLocation,
@@ -699,6 +707,7 @@ const translateGraph = (
     for (const dependencyName of keys(dependencyLocations).sort()) {
       const dependencyLocation = dependencyLocations[dependencyName];
       digestExternalAliases(dependencyName, dependencyLocation);
+      compartmentNames.add(dependencyLocation);
     }
     // digest own internal aliases
     for (const modulePath of keys(internalAliases).sort()) {
@@ -724,6 +733,7 @@ const translateGraph = (
       parsers,
       types,
       policy: /** @type {SomePackagePolicy} */ (packagePolicy),
+      compartments: compartmentNames,
     };
   }
 
@@ -745,10 +755,7 @@ const translateGraph = (
  * @param {Set<string>} conditions
  * @param {object} packageDescriptor
  * @param {string} moduleSpecifier
- * @param {object} [options]
- * @param {boolean} [options.dev]
- * @param {object} [options.commonDependencies]
- * @param {object} [options.policy]
+ * @param {CompartmentMapForNodeModulesOptions} [options]
  * @returns {Promise<CompartmentMapDescriptor>}
  */
 export const compartmentMapForNodeModules = async (

package/src/node-powers.d.ts

@@ -1,44 +1,50 @@
+export function makeReadNowPowers({ fs, url, crypto, path, }: {
+    fs: FsInterface;
+    url?: UrlInterface | undefined;
+    crypto?: CryptoInterface | undefined;
+    path?: PathInterface | undefined;
+}): MaybeReadPowers & ReadNowPowers;
 /**
  * The implementation of `makeReadPowers` and the deprecated
  * `makeNodeReadPowers` handles the case when the `url` power is not provided,
  * but `makeReadPowers` presents a type that requires `url`.
  *
  * @param {object} args
- * @param {typeof import('fs')} args.fs
- * @param {typeof import('url')} [args.url]
- * @param {typeof import('crypto')} [args.crypto]
+ * @param {FsInterface} args.fs
+ * @param {UrlInterface} [args.url]
+ * @param {CryptoInterface} [args.crypto]
+ * @param {PathInterface} [args.path]
+ * @returns {MaybeReadPowers}
  */
-export function makeReadPowers({ fs, url, crypto }: {
-    fs: typeof import("fs");
-    url?: typeof import("url") | undefined;
-    crypto?: typeof import("crypto") | undefined;
-}): {
-    read: (location: string) => Promise<Buffer>;
-    maybeRead: (location: string) => Promise<Buffer | undefined>;
-    fileURLToPath: (location: string) => string;
-    pathToFileURL: ((path: string) => string) | typeof import("url").pathToFileURL;
-    canonical: (location: string) => Promise<string>;
-    computeSha512: HashFn | undefined;
-    requireResolve: (from: any, specifier: any, options: any) => string;
-};
+export function makeReadPowers({ fs, url, crypto, path, }: {
+    fs: FsInterface;
+    url?: UrlInterface | undefined;
+    crypto?: CryptoInterface | undefined;
+    path?: PathInterface | undefined;
+}): MaybeReadPowers;
 /**
  * The implementation of `makeWritePowers` and the deprecated
  * `makeNodeWritePowers` handles the case when the `url` power is not provided,
  * but `makeWritePowers` presents a type that requires `url`.
  *
  * @param {object} args
- * @param {typeof import('fs')} args.fs
- * @param {typeof import('url')} [args.url]
+ * @param {FsInterface} args.fs
+ * @param {UrlInterface} [args.url]
  */
 export function makeWritePowers({ fs, url }: {
-    fs: typeof import("fs");
-    url?: typeof import("url") | undefined;
+    fs: FsInterface;
+    url?: UrlInterface | undefined;
 }): {
     write: (location: string, data: Uint8Array) => Promise<void>;
 };
-export function makeNodeReadPowers(fs: typeof import("fs"), crypto?: typeof import("crypto") | undefined): ReadPowers;
-export function makeNodeWritePowers(fs: typeof import("fs")): WritePowers;
-import type { HashFn } from './types.js';
+export function makeNodeReadPowers(fs: FsInterface, crypto?: CryptoInterface | undefined): ReadPowers;
+export function makeNodeWritePowers(fs: FsInterface): WritePowers;
+import type { FsInterface } from './types.js';
+import type { UrlInterface } from './types.js';
+import type { CryptoInterface } from './types.js';
+import type { PathInterface } from './types.js';
+import type { MaybeReadPowers } from './types.js';
+import type { ReadNowPowers } from './types.js';
 import type { ReadPowers } from './types.js';
 import type { WritePowers } from './types.js';
 //# sourceMappingURL=node-powers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"node-powers.d.ts","sourceRoot":"","sources":["node-powers.js"],"names":[],"mappings":"AAkCA;;;;;;;;;GASG;AACH,oDAJG;IAAkC,EAAE,EAA5B,cAAc,IAAI,CAAC;IACS,GAAG;IACA,MAAM;CAAC;qBAWpC,MAAM;0BAqBN,MAAM;8BAzDR,MAAM;2BAWN,MAAM;0BA2EJ,MAAM;;;EAqClB;AAED;;;;;;;;GAQG;AACH,6CAHG;IAAkC,EAAE,EAA5B,cAAc,IAAI,CAAC;IACS,GAAG;CAAC;sBAO9B,MAAM,QACN,UAAU;EAYtB;AA0BM,uCAJI,cAAc,IAAI,CAAC,iDAEjB,UAAU,CAItB;AAUM,wCAHI,cAAc,IAAI,CAAC,GACjB,WAAW,CAIvB;4BAtMyB,YAAY;gCADR,YAAY;iCAEX,YAAY"}
+{"version":3,"file":"node-powers.d.ts","sourceRoot":"","sources":["node-powers.js"],"names":[],"mappings":"AAqLO,8DANJ;IAA0B,EAAE,EAApB,WAAW;IACS,GAAG;IACA,MAAM;IACR,IAAI;CACjC,GAAU,eAAe,GAAG,aAAa,CAoC3C;AAlKD;;;;;;;;;;;GAWG;AACH,2DANG;IAA0B,EAAE,EAApB,WAAW;IACS,GAAG;IACA,MAAM;IACR,IAAI;CACjC,GAAU,eAAe,CA0G3B;AAgDD;;;;;;;;GAQG;AACH,6CAHG;IAA0B,EAAE,EAApB,WAAW;IACS,GAAG;CAAC;sBAOtB,MAAM,QACN,UAAU;EAYtB;AA2BM,uCALI,WAAW,yCAET,UAAU,CAKtB;AAWM,wCAJI,WAAW,GACT,WAAW,CAKvB;iCAjR8B,YAAY;kCAWX,YAAY;qCAbT,YAAY;mCAOd,YAAY;qCADV,YAAY;mCAMd,YAAY;gCAFf,YAAY;iCAIX,YAAY"}

package/src/node-powers.js

@@ -8,14 +8,28 @@
 
 // @ts-check
 
-/** @import {ReadPowers} from './types.js' */
+/** @import {CanonicalFn} from './types.js' */
+/** @import {CryptoInterface} from './types.js' */
+/** @import {FileURLToPathFn} from './types.js' */
+/** @import {FsInterface} from './types.js' */
 /** @import {HashFn} from './types.js' */
+/** @import {IsAbsoluteFn} from './types.js' */
+/** @import {MaybeReadFn} from './types.js' */
+/** @import {MaybeReadPowers} from './types.js' */
+/** @import {PathInterface} from './types.js' */
+/** @import {PathToFileURLFn} from './types.js' */
+/** @import {ReadFn} from './types.js' */
+/** @import {ReadPowers} from './types.js' */
+/** @import {RequireResolveFn} from './types.js' */
+/** @import {ReadNowPowers} from './types.js' */
+/** @import {UrlInterface} from './types.js' */
 /** @import {WritePowers} from './types.js' */
+/** @import {MaybeReadNowFn} from './types.js' */
 
 import { createRequire } from 'module';
 
 /**
- * @param {string} location
+ * @type {FileURLToPathFn}
  */
 const fakeFileURLToPath = location => {
   const url = new URL(location);
@@ -26,32 +40,45 @@ const fakeFileURLToPath = location => {
 };
 
 /**
- * @param {string} path
+ * @type {PathToFileURLFn} path
  */
 const fakePathToFileURL = path => {
   return new URL(path, 'file://').toString();
 };
 
+/**
+ * @type {IsAbsoluteFn}
+ */
+const fakeIsAbsolute = () => false;
+
 /**
  * The implementation of `makeReadPowers` and the deprecated
  * `makeNodeReadPowers` handles the case when the `url` power is not provided,
  * but `makeReadPowers` presents a type that requires `url`.
  *
  * @param {object} args
- * @param {typeof import('fs')} args.fs
- * @param {typeof import('url')} [args.url]
- * @param {typeof import('crypto')} [args.crypto]
+ * @param {FsInterface} args.fs
+ * @param {UrlInterface} [args.url]
+ * @param {CryptoInterface} [args.crypto]
+ * @param {PathInterface} [args.path]
+ * @returns {MaybeReadPowers}
  */
-const makeReadPowersSloppy = ({ fs, url = undefined, crypto = undefined }) => {
+const makeReadPowersSloppy = ({
+  fs,
+  url = undefined,
+  crypto = undefined,
+  path = undefined,
+}) => {
   const fileURLToPath =
     url === undefined ? fakeFileURLToPath : url.fileURLToPath;
   const pathToFileURL =
     url === undefined ? fakePathToFileURL : url.pathToFileURL;
+  const isAbsolute = path === undefined ? fakeIsAbsolute : path.isAbsolute;
 
   let readMutex = Promise.resolve(undefined);
 
   /**
-   * @param {string} location
+   * @type {ReadFn}
    */
   const read = async location => {
     const promise = readMutex;
@@ -61,18 +88,18 @@ const makeReadPowersSloppy = ({ fs, url = undefined, crypto = undefined }) => {
     });
     await promise;
 
-    const path = fileURLToPath(location);
+    const filepath = fileURLToPath(location);
     try {
       // We await here to ensure that we release the mutex only after
       // completing the read.
-      return await fs.promises.readFile(path);
+      return await fs.promises.readFile(filepath);
     } finally {
       release(undefined);
     }
   };
 
   /**
-   * @param {string} location
+   * @type {MaybeReadFn}
    */
   const maybeRead = location =>
     read(location).catch(error => {
@@ -85,6 +112,7 @@ const makeReadPowersSloppy = ({ fs, url = undefined, crypto = undefined }) => {
       throw error;
     });
 
+  /** @type {RequireResolveFn} */
   const requireResolve = (from, specifier, options) =>
     createRequire(from).resolve(specifier, options);
 
@@ -101,7 +129,7 @@ const makeReadPowersSloppy = ({ fs, url = undefined, crypto = undefined }) => {
    * non-existent directory on the next step after canonicalizing the package
    * location.
    *
-   * @param {string} location
+   * @type {CanonicalFn}
    */
   const canonical = async location => {
     await null;
@@ -120,7 +148,7 @@ const makeReadPowersSloppy = ({ fs, url = undefined, crypto = undefined }) => {
     }
   };
 
-  /** @type {HashFn=} */
+  /** @type {HashFn | undefined} */
   const computeSha512 = crypto
     ? bytes => {
         const hash = crypto.createHash('sha512');
@@ -137,6 +165,53 @@ const makeReadPowersSloppy = ({ fs, url = undefined, crypto = undefined }) => {
     canonical,
     computeSha512,
     requireResolve,
+    isAbsolute,
+  };
+};
+
+/**
+ * Creates {@link ReadPowers} for dynamic module support
+ *
+ * @param {object} args
+ * @param {FsInterface} args.fs
+ * @param {UrlInterface} [args.url]
+ * @param {CryptoInterface} [args.crypto]
+ * @param {PathInterface} [args.path]
+ * @returns {MaybeReadPowers & ReadNowPowers}
+ */
+export const makeReadNowPowers = ({
+  fs,
+  url = undefined,
+  crypto = undefined,
+  path = undefined,
+}) => {
+  const powers = makeReadPowersSloppy({ fs, url, crypto, path });
+  const fileURLToPath = powers.fileURLToPath || fakeFileURLToPath;
+  const isAbsolute = powers.isAbsolute || fakeIsAbsolute;
+
+  /**
+   * @type {MaybeReadNowFn}
+   */
+  const maybeReadNow = location => {
+    const filePath = fileURLToPath(location);
+    try {
+      return fs.readFileSync(filePath);
+    } catch (error) {
+      if (
+        'code' in error &&
+        (error.code === 'ENOENT' || error.code === 'EISDIR')
+      ) {
+        return undefined;
+      }
+      throw error;
+    }
+  };
+
+  return {
+    ...powers,
+    maybeReadNow,
+    fileURLToPath,
+    isAbsolute,
   };
 };
 
@@ -146,8 +221,8 @@ const makeReadPowersSloppy = ({ fs, url = undefined, crypto = undefined }) => {
  * but `makeWritePowers` presents a type that requires `url`.
  *
  * @param {object} args
- * @param {typeof import('fs')} args.fs
- * @param {typeof import('url')} [args.url]
+ * @param {FsInterface} args.fs
+ * @param {UrlInterface} [args.url]
  */
 const makeWritePowersSloppy = ({ fs, url = undefined }) => {
   const fileURLToPath =
@@ -171,39 +246,41 @@ const makeWritePowersSloppy = ({ fs, url = undefined }) => {
 
 /**
  * @param {object} args
- * @param {typeof import('fs')} args.fs
- * @param {typeof import('url')} args.url
- * @param {typeof import('crypto')} [args.crypto]
+ * @param {FsInterface} args.fs
+ * @param {UrlInterface} args.url
+ * @param {CryptoInterface} [args.crypto]
  */
 export const makeReadPowers = makeReadPowersSloppy;
 
 /**
  * @param {object} args
- * @param {typeof import('fs')} args.fs
- * @param {typeof import('url')} args.url
+ * @param {FsInterface} args.fs
+ * @param {UrlInterface} args.url
  */
 export const makeWritePowers = makeWritePowersSloppy;
 
 /**
- * @deprecated in favor of makeReadPowers.
+ * Deprecated in favor of {@link makeReadPowers}.
  * It transpires that positional arguments needed to become an arguments bag to
  * reasonably expand to multiple optional dependencies.
  *
- * @param {typeof import('fs')} fs
- * @param {typeof import('crypto')} [crypto]
+ * @param {FsInterface} fs
+ * @param {CryptoInterface} [crypto]
  * @returns {ReadPowers}
+ * @deprecated
  */
 export const makeNodeReadPowers = (fs, crypto = undefined) => {
   return makeReadPowersSloppy({ fs, crypto });
 };
 
 /**
- * @deprecated in favor of makeWritePowers.
+ * Deprecated in favor of {@link makeWritePowers}.
  * It transpires that positional arguments needed to become an arguments bag to
  * reasonably expand to multiple optional dependencies.
  *
- * @param {typeof import('fs')} fs
+ * @param {FsInterface} fs
  * @returns {WritePowers}
+ * @deprecated
  */
 export const makeNodeWritePowers = fs => {
   return makeWritePowersSloppy({ fs });

package/src/parse-archive-cjs.js

@@ -16,7 +16,7 @@ const noopExecute = () => {};
 freeze(noopExecute);
 
 /** @type {import('./types.js').ParseFn} */
-export const parseArchiveCjs = async (
+export const parseArchiveCjs = (
   bytes,
   specifier,
   location,
@@ -66,4 +66,5 @@ export const parseArchiveCjs = async (
 export default {
   parse: parseArchiveCjs,
   heuristicImports: true,
+  synchronous: true,
 };

package/src/parse-archive-mjs.js

@@ -9,7 +9,7 @@ const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
 
 /** @type {import('./types.js').ParseFn} */
-export const parseArchiveMjs = async (
+export const parseArchiveMjs = (
   bytes,
   specifier,
   sourceUrl,
@@ -35,4 +35,5 @@ export const parseArchiveMjs = async (
 export default {
   parse: parseArchiveMjs,
   heuristicImports: false,
+  synchronous: true,
 };

package/src/parse-bytes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-bytes.d.ts","sourceRoot":"","sources":["parse-bytes.js"],"names":[],"mappings":"AAcA,2CAA2C;AAC3C,yBADW,OAAO,YAAY,EAAE,OAAO,CA+BrC;wBAES,OAAO,YAAY,EAAE,oBAAoB"}
+{"version":3,"file":"parse-bytes.d.ts","sourceRoot":"","sources":["parse-bytes.js"],"names":[],"mappings":"AAcA,2CAA2C;AAC3C,yBADW,OAAO,YAAY,EAAE,OAAO,CA0BrC;wBAES,OAAO,YAAY,EAAE,oBAAoB"}

package/src/parse-bytes.js

@@ -13,12 +13,7 @@
 const freeze = Object.freeze;
 
 /** @type {import('./types.js').ParseFn} */
-export const parseBytes = async (
-  bytes,
-  _specifier,
-  _location,
-  _packageLocation,
-) => {
+export const parseBytes = (bytes, _specifier, _location, _packageLocation) => {
   // Snapshot ArrayBuffer
   const buffer = new ArrayBuffer(bytes.length);
   const bytesView = new Uint8Array(buffer);
@@ -49,4 +44,5 @@ export const parseBytes = async (
 export default {
   parse: parseBytes,
   heuristicImports: false,
+  synchronous: true,
 };

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":"AAmCO,2CAPI,UAAU,GAAG,MAAM,GAAG,SAAS,YAC/B,MAAM,GACJ;IACZ,QAAY,EAAC,MAAM,GAAC,IAAI,CAAC;IACzB,OAAW,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;IACZ,MAAU,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAC;IAC7B,aAAiB,EAAE,GAAG,CAAC;IACvB,YAAgB,WAAW;IAC3B,OAAW,WAAW;CACnB,CAsHH;gCAhM6B,YAAY;4BADhB,YAAY"}
+{"version":3,"file":"parse-cjs-shared-export-wrapper.d.ts","sourceRoot":"","sources":["parse-cjs-shared-export-wrapper.js"],"names":[],"mappings":"AAuCO,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;gCA/M6B,YAAY;4BADhB,YAAY"}

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

@@ -3,6 +3,8 @@
  * module source.
  */
 
+import { findInvalidReadNowPowersProps, isReadNowPowers } from './powers.js';
+
 // @ts-check
 
 /** @import {ReadFn} from './types.js' */
@@ -24,7 +26,9 @@ const noTrailingSlash = path => {
 };
 
 /**
- * Generates values for __filename and __dirname from location
+ * Generates values for __filename and __dirname from location _if and only if_
+ * `readPowers` is of type {@link ReadPowers} containing a
+ * {@link ReadPowers.fileURLToPath} method.
  *
  * @param {ReadPowers | ReadFn | undefined} readPowers
  * @param {string} location
@@ -141,13 +145,26 @@ export const wrap = ({
     },
   });
 
-  const require = (/** @type {string} */ importSpecifier) => {
+  /** @param {string} importSpecifier */
+  const require = importSpecifier => {
+    // if this fails, tell user
+
+    /** @type {import('ses').ModuleExportsNamespace} */
+    let namespace;
+
     if (!has(resolvedImports, importSpecifier)) {
-      throw new Error(
-        `Cannot find module "${importSpecifier}" in "${location}"`,
-      );
+      if (isReadNowPowers(readPowers)) {
+        namespace = compartment.importNow(importSpecifier);
+      } else {
+        const invalidProps = findInvalidReadNowPowersProps(readPowers).sort();
+        throw new Error(
+          `Synchronous readPowers required for dynamic import of ${assert.quote(importSpecifier)}; missing or invalid prop(s): ${invalidProps.join(', ')}`,
+        );
+      }
+    } else {
+      namespace = compartment.importNow(resolvedImports[importSpecifier]);
     }
-    const namespace = compartment.importNow(resolvedImports[importSpecifier]);
+
     // If you read this file carefully, you'll see it's not possible for a cjs module to not have the default anymore.
     // It's currently possible to require modules that were not created by this file though.
     if (has(namespace, 'default')) {

package/src/parse-cjs.js

@@ -12,7 +12,7 @@ const textDecoder = new TextDecoder();
 const { freeze } = Object;
 
 /** @type {import('./types.js').ParseFn} */
-export const parseCjs = async (
+export const parseCjs = (
   bytes,
   _specifier,
   location,
@@ -31,7 +31,7 @@ export const parseCjs = async (
     exports.push('default');
   }
 
-  const { filename, dirname } = await getModulePaths(readPowers, location);
+  const { filename, dirname } = getModulePaths(readPowers, location);
 
   /**
    * @param {object} moduleEnvironmentRecord
@@ -67,4 +67,5 @@ export const parseCjs = async (
 export default {
   parse: parseCjs,
   heuristicImports: true,
+  synchronous: true,
 };

package/src/parse-json.d.ts

@@ -1,5 +1,7 @@
-/** @type {import('./types.js').ParseFn} */
-export const parseJson: import("./types.js").ParseFn;
-declare const _default: import("./types.js").ParserImplementation;
+/** @type {ParseFn} */
+export const parseJson: ParseFn;
+declare const _default: ParserImplementation;
 export default _default;
+import type { ParseFn } from './types.js';
+import type { ParserImplementation } from './types.js';
 //# sourceMappingURL=parse-json.d.ts.map

package/src/parse-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-json.d.ts","sourceRoot":"","sources":["parse-json.js"],"names":[],"mappings":"AAgBA,2CAA2C;AAC3C,wBADW,OAAO,YAAY,EAAE,OAAO,CAyBrC;wBAES,OAAO,YAAY,EAAE,oBAAoB"}
+{"version":3,"file":"parse-json.d.ts","sourceRoot":"","sources":["parse-json.js"],"names":[],"mappings":"AAoBA,sBAAsB;AACtB,wBADW,OAAO,CAoBhB;wBAES,oBAAoB;;6BArCJ,YAAY;0CACC,YAAY"}

package/src/parse-json.js

@@ -2,25 +2,24 @@
 
 // @ts-check
 
+/** @import {Harden} from 'ses' */
+/** @import {ParseFn} from './types.js' */
+/** @import {ParserImplementation} from './types.js' */
+
 import { parseLocatedJson } from './json.js';
 
 /**
  * TypeScript cannot be relied upon to deal with the nuances of Readonly, so we
  * borrow the pass-through type definition of harden here.
  *
- * @type {import('ses').Harden}
+ * @type {Harden}
  */
 const freeze = Object.freeze;
 
 const textDecoder = new TextDecoder();
 
-/** @type {import('./types.js').ParseFn} */
-export const parseJson = async (
-  bytes,
-  _specifier,
-  location,
-  _packageLocation,
-) => {
+/** @type {ParseFn} */
+export const parseJson = (bytes, _specifier, location, _packageLocation) => {
   const source = textDecoder.decode(bytes);
   const imports = freeze([]);
 
@@ -41,8 +40,9 @@ export const parseJson = async (
   };
 };
 
-/** @type {import('./types.js').ParserImplementation} */
+/** @type {ParserImplementation} */
 export default {
   parse: parseJson,
   heuristicImports: false,
+  synchronous: true,
 };

package/src/parse-mjs.js

@@ -7,7 +7,7 @@ import { ModuleSource } from '@endo/module-source';
 const textDecoder = new TextDecoder();
 
 /** @type {import('./types.js').ParseFn} */
-export const parseMjs = async (
+export const parseMjs = (
   bytes,
   _specifier,
   sourceUrl,
@@ -33,4 +33,5 @@ export const parseMjs = async (
 export default {
   parse: parseMjs,
   heuristicImports: false,
+  synchronous: true,
 };

package/src/parse-pre-cjs.js

@@ -12,7 +12,7 @@ import { wrap, getModulePaths } from './parse-cjs-shared-export-wrapper.js';
 const textDecoder = new TextDecoder();
 
 /** @type {import('./types.js').ParseFn} */
-export const parsePreCjs = async (
+export const parsePreCjs = (
   bytes,
   _specifier,
   location,
@@ -25,7 +25,7 @@ export const parsePreCjs = async (
     location,
   );
 
-  const { filename, dirname } = await getModulePaths(readPowers, location);
+  const { filename, dirname } = getModulePaths(readPowers, location);
 
   /**
    * @param {object} moduleEnvironmentRecord
@@ -64,4 +64,5 @@ export const parsePreCjs = async (
 export default {
   parse: parsePreCjs,
   heuristicImports: true,
+  synchronous: true,
 };

package/src/parse-pre-mjs.js

@@ -11,7 +11,7 @@ import { parseLocatedJson } from './json.js';
 const textDecoder = new TextDecoder();
 
 /** @type {import('./types.js').ParseFn} */
-export const parsePreMjs = async (
+export const parsePreMjs = (
   bytes,
   _specifier,
   location,
@@ -38,4 +38,5 @@ export const parsePreMjs = async (
 export default {
   parse: parsePreMjs,
   heuristicImports: false,
+  synchronous: true,
 };

package/src/parse-text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-text.d.ts","sourceRoot":"","sources":["parse-text.js"],"names":[],"mappings":"AAiBA,2CAA2C;AAC3C,wBADW,OAAO,YAAY,EAAE,OAAO,CA4BrC;wBAES,OAAO,YAAY,EAAE,oBAAoB"}
+{"version":3,"file":"parse-text.d.ts","sourceRoot":"","sources":["parse-text.js"],"names":[],"mappings":"AAiBA,2CAA2C;AAC3C,wBADW,OAAO,YAAY,EAAE,OAAO,CAuBrC;wBAES,OAAO,YAAY,EAAE,oBAAoB"}

package/src/parse-text.js

@@ -16,12 +16,7 @@ const freeze = Object.freeze;
 const textDecoder = new TextDecoder();
 
 /** @type {import('./types.js').ParseFn} */
-export const parseText = async (
-  bytes,
-  _specifier,
-  _location,
-  _packageLocation,
-) => {
+export const parseText = (bytes, _specifier, _location, _packageLocation) => {
   const text = textDecoder.decode(bytes);
 
   /** @type {Array<string>} */
@@ -49,4 +44,5 @@ export const parseText = async (
 export default {
   parse: parseText,
   heuristicImports: false,
+  synchronous: true,
 };