@endo/compartment-mapper 1.1.5 → 1.2.0

package/src/bundle-mjs.d.ts

@@ -1,22 +1,6 @@
 export const runtime: "function observeImports(map, importName, importIndex) {\n  for (const [name, observers] of map.get(importName)) {\n    const cell = cells[importIndex][name];\n    if (cell === undefined) {\n      throw new ReferenceError(`Cannot import name ${name}`);\n    }\n    for (const observer of observers) {\n      cell.observe(observer);\n    }\n  }\n}\n";
-declare namespace _default {
-    export { runtime };
-    export function getBundlerKit({ index, indexedImports, record: { __syncModuleProgram__, __fixedExportMap__, __liveExportMap__, __reexportMap__, reexports, }, }: {
-        index: any;
-        indexedImports: any;
-        record: {
-            __syncModuleProgram__: any;
-            __fixedExportMap__?: {} | undefined;
-            __liveExportMap__?: {} | undefined;
-            __reexportMap__?: {} | undefined;
-            reexports: any;
-        };
-    }): {
-        getFunctor: () => string;
-        getCells: () => string;
-        getReexportsWiring: () => any;
-        getFunctorCall: () => string;
-    };
-}
+declare const _default: BundlerSupport<PrecompiledModuleSource>;
 export default _default;
+import type { PrecompiledModuleSource } from 'ses';
+import type { BundlerSupport } from './bundle.js';
 //# sourceMappingURL=bundle-mjs.d.ts.map

package/src/bundle-mjs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle-mjs.d.ts","sourceRoot":"","sources":["bundle-mjs.js"],"names":[],"mappings":"AAiCA,oXAYE;;;IAIA;;;;;;;;;;;;;;;MAqEC"}
+{"version":3,"file":"bundle-mjs.d.ts","sourceRoot":"","sources":["bundle-mjs.js"],"names":[],"mappings":"AAsCA,oXAYE;wBAES,eAAe,uBAAuB,CAAC;;6CAlDP,KAAK;oCACd,aAAa"}

package/src/bundle-mjs.js

@@ -1,3 +1,8 @@
+/* Provides ESM support for `bundle.js`. */
+
+/** @import {PrecompiledModuleSource} from 'ses' */
+/** @import {BundlerSupport} from './bundle.js' */
+
 /** quotes strings */
 const q = JSON.stringify;
 
@@ -45,6 +50,7 @@ function observeImports(map, importName, importIndex) {
 }
 `;
 
+/** @type {BundlerSupport<PrecompiledModuleSource>} */
 export default {
   runtime,
   getBundlerKit({

package/src/bundle.d.ts

@@ -1,14 +1,57 @@
-export function makeBundle(read: ReadFn, moduleLocation: string, options?: {
-    moduleTransforms?: ModuleTransforms | undefined;
-    dev?: boolean | undefined;
-    tags?: Set<string> | undefined;
-    commonDependencies?: object;
-    searchSuffixes?: string[] | undefined;
-    sourceMapHook?: import("./types.js").SourceMapHook | undefined;
-} | undefined): Promise<string>;
+export function makeBundle(readPowers: ReadFn | ReadPowers | MaybeReadPowers, moduleLocation: string, options?: ArchiveOptions | undefined): Promise<string>;
 export function writeBundle(write: WriteFn, read: ReadFn, bundleLocation: string, moduleLocation: string, options?: ArchiveOptions | undefined): Promise<void>;
+export type BundlerKit = {
+    /**
+     * Produces a JavaScript string consisting of
+     * a function expression followed by a comma delimiter that will be evaluated in
+     * a lexical scope with no free variables except the globals.
+     * In the generated bundle runtime, the function will receive an environment
+     * record: a record mapping every name of the corresponding module's internal
+     * namespace to a "cell" it can use to get, set, or observe the linked
+     * variable.
+     */
+    getFunctor: () => string;
+    /**
+     * Produces a JavaScript string consisting of
+     * a JavaScript object and a trailing comma.
+     * The string is evaluated in a lexical context with a `cell` maker, the `cells`
+     * array of every module's internal environment record.
+     */
+    getCells: () => string;
+    /**
+     * Produces a JavaScript string may
+     * be a statement that calls this module's functor with the calling convention
+     * appropriate for its language, injecting whatever cells it needs to link to
+     * other module namespaces.
+     */
+    getFunctorCall: () => string;
+    /**
+     * Produces a JavaScript string
+     * that may include statements that bind the cells reexported by this module.
+     */
+    getReexportsWiring: () => string;
+};
+export type BundleModule<SpecificModuleSource extends unknown> = {
+    key: string;
+    compartmentName: string;
+    moduleSpecifier: string;
+    parser: string;
+    record: StaticModuleType & SpecificModuleSource;
+    resolvedImports: Record<string, string>;
+    indexedImports: Record<string, number>;
+    bytes: Uint8Array;
+    index: number;
+    bundlerKit: BundlerKit;
+};
+export type GetBundlerKit<SpecificModuleSource extends unknown> = (module: BundleModule<SpecificModuleSource>) => BundlerKit;
+export type BundlerSupport<SpecificModuleSource extends unknown> = {
+    runtime: string;
+    getBundlerKit: GetBundlerKit<SpecificModuleSource>;
+};
 import type { ReadFn } from './types.js';
-import type { ModuleTransforms } from './types.js';
-import type { WriteFn } from './types.js';
+import type { ReadPowers } from './types.js';
+import type { MaybeReadPowers } from './types.js';
 import type { ArchiveOptions } from './types.js';
+import type { WriteFn } from './types.js';
+import type { StaticModuleType } from 'ses';
 //# sourceMappingURL=bundle.d.ts.map

package/src/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["bundle.js"],"names":[],"mappings":"AA4KO,yDAVI,MAAM;;;;yBAKN,MAAM;;;gBAGJ,OAAO,CAAC,MAAM,CAAC,CA8J3B;AASM,0EAJI,MAAM,kBACN,MAAM,uDAahB;4BAnVyB,YAAY;sCACF,YAAY;6BAErB,YAAY;oCACL,YAAY"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["bundle.js"],"names":[],"mappings":"AA4NO,uCALI,MAAM,GAAG,UAAU,GAAG,eAAe,kBACrC,MAAM,yCAEJ,OAAO,CAAC,MAAM,CAAC,CA4K3B;AASM,mCANI,OAAO,QACP,MAAM,kBACN,MAAM,kBACN,MAAM,uDAahB;;;;;;;;;;;gBAxYa,MAAM,MAAM;;;;;;;cAOZ,MAAM,MAAM;;;;;;;oBAIZ,MAAM,MAAM;;;;;wBAIZ,MAAM,MAAM;;yBAKH,oBAAoB,SAA9B,OAAS;SAER,MAAM;qBACN,MAAM;qBACN,MAAM;YACN,MAAM;YACN,gBAAgB,GAAG,oBAAoB;qBACvC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;oBACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;WACtB,UAAU;WACV,MAAM;gBACN,UAAU;;0BAID,oBAAoB,SAA9B,OAAS,aAEX,YAAY,CAAC,oBAAoB,CAAC,KAChC,UAAU;2BAIA,oBAAoB,SAA9B,OAAS;aAER,MAAM;mBACN,aAAa,CAAC,oBAAoB,CAAC;;4BApDvB,YAAY;gCACR,YAAY;qCAHP,YAAY;oCAHb,YAAY;6BAQnB,YAAY;sCAVH,KAAK"}

package/src/bundle.js

@@ -1,47 +1,85 @@
 // @ts-check
 /* eslint no-shadow: 0 */
 
-/** @import {ResolveHook} from 'ses' */
-/** @import {PrecompiledStaticModuleInterface} from 'ses' */
-/** @import {ParserImplementation} from './types.js' */
+/** @import {StaticModuleType} from 'ses' */
+
+/** @import {ArchiveOptions} from './types.js' */
 /** @import {CompartmentDescriptor} from './types.js' */
 /** @import {CompartmentSources} from './types.js' */
+/** @import {MaybeReadPowers} from './types.js' */
+/** @import {PrecompiledStaticModuleInterface} from 'ses' */
 /** @import {ReadFn} from './types.js' */
-/** @import {ModuleTransforms} from './types.js' */
+/** @import {ReadPowers} from './types.js' */
 /** @import {Sources} from './types.js' */
 /** @import {WriteFn} from './types.js' */
-/** @import {ArchiveOptions} from './types.js' */
+
+/**
+ * @typedef {object} BundlerKit
+ * @property {() => string} getFunctor Produces a JavaScript string consisting of
+ * a function expression followed by a comma delimiter that will be evaluated in
+ * a lexical scope with no free variables except the globals.
+ * In the generated bundle runtime, the function will receive an environment
+ * record: a record mapping every name of the corresponding module's internal
+ * namespace to a "cell" it can use to get, set, or observe the linked
+ * variable.
+ * @property {() => string} getCells Produces a JavaScript string consisting of
+ * a JavaScript object and a trailing comma.
+ * The string is evaluated in a lexical context with a `cell` maker, the `cells`
+ * array of every module's internal environment record.
+ * @property {() => string} getFunctorCall Produces a JavaScript string may
+ * be a statement that calls this module's functor with the calling convention
+ * appropriate for its language, injecting whatever cells it needs to link to
+ * other module namespaces.
+ * @property {() => string} getReexportsWiring Produces a JavaScript string
+ * that may include statements that bind the cells reexported by this module.
+ */
+
+/**
+ * @template {unknown} SpecificModuleSource
+ * @typedef {object} BundleModule
+ * @property {string} key
+ * @property {string} compartmentName
+ * @property {string} moduleSpecifier
+ * @property {string} parser
+ * @property {StaticModuleType & SpecificModuleSource} record
+ * @property {Record<string, string>} resolvedImports
+ * @property {Record<string, number>} indexedImports
+ * @property {Uint8Array} bytes
+ * @property {number} index
+ * @property {BundlerKit} bundlerKit
+ */
+
+/**
+ * @template {unknown} SpecificModuleSource
+ * @callback GetBundlerKit
+ * @param {BundleModule<SpecificModuleSource>} module
+ * @returns {BundlerKit}
+ */
+
+/**
+ * @template {unknown} SpecificModuleSource
+ * @typedef {object} BundlerSupport
+ * @property {string} runtime
+ * @property {GetBundlerKit<SpecificModuleSource>} getBundlerKit
+ */
 
 import { resolve } from './node-module-specifier.js';
 import { compartmentMapForNodeModules } from './node-modules.js';
 import { search } from './search.js';
 import { link } from './link.js';
+import { unpackReadPowers } from './powers.js';
 import { makeImportHookMaker } from './import-hook.js';
-import parserJson from './parse-json.js';
-import parserText from './parse-text.js';
-import parserBytes from './parse-bytes.js';
-import parserArchiveCjs from './parse-archive-cjs.js';
-import parserArchiveMjs from './parse-archive-mjs.js';
+import { defaultParserForLanguage } from './archive-parsers.js';
 import { parseLocatedJson } from './json.js';
 
 import mjsSupport from './bundle-mjs.js';
 import cjsSupport from './bundle-cjs.js';
+import jsonSupport from './bundle-json.js';
 
 const textEncoder = new TextEncoder();
 
 const { quote: q } = assert;
 
-/** @type {Record<string, ParserImplementation>} */
-const parserForLanguage = {
-  mjs: parserArchiveMjs,
-  'pre-mjs-json': parserArchiveMjs,
-  cjs: parserArchiveCjs,
-  'pre-cjs-json': parserArchiveCjs,
-  json: parserJson,
-  text: parserText,
-  bytes: parserBytes,
-};
-
 /**
  * @param {Record<string, CompartmentDescriptor>} compartmentDescriptors
  * @param {Record<string, CompartmentSources>} compartmentSources
@@ -54,8 +92,11 @@ const sortedModules = (
   entryCompartmentName,
   entryModuleSpecifier,
 ) => {
+  /** @type {BundleModule<unknown>[]} */
   const modules = [];
+  /** @type {Map<string, string>} aliaes */
   const aliases = new Map();
+  /** @type {Set<string>} seen */
   const seen = new Set();
 
   /**
@@ -71,7 +112,9 @@ const sortedModules = (
 
     const source = compartmentSources[compartmentName][moduleSpecifier];
     if (source !== undefined) {
-      const { record, parser, deferredError } = source;
+      const { record, parser, deferredError, bytes } = source;
+      assert(parser !== undefined);
+      assert(bytes !== undefined);
       if (deferredError) {
         throw Error(
           `Cannot bundle: encountered deferredError ${deferredError}`,
@@ -99,6 +142,11 @@ const sortedModules = (
           parser,
           record,
           resolvedImports,
+          bytes,
+          // @ts-expect-error
+          index: undefined,
+          // @ts-expect-error
+          bundlerKit: null,
         });
 
         return key;
@@ -132,61 +180,77 @@ const sortedModules = (
   return { modules, aliases };
 };
 
-const implementationPerParser = {
+/** @type {Record<string, BundlerSupport<unknown>>} */
+const bundlerSupportForLanguage = {
   'pre-mjs-json': mjsSupport,
   'pre-cjs-json': cjsSupport,
+  json: jsonSupport,
 };
 
-function getRuntime(parser) {
-  return implementationPerParser[parser]
-    ? implementationPerParser[parser].runtime
-    : `/*unknown parser:${parser}*/`;
-}
-
-function getBundlerKitForModule(module) {
-  const parser = module.parser;
-  if (!implementationPerParser[parser]) {
-    const warning = `/*unknown parser:${parser}*/`;
+/** @param {string} language */
+const getRuntime = language =>
+  bundlerSupportForLanguage[language]
+    ? bundlerSupportForLanguage[language].runtime
+    : `/*unknown language:${language}*/`;
+
+/** @param {BundleModule<unknown>} module */
+const getBundlerKitForModule = module => {
+  const language = module.parser;
+  assert(language !== undefined);
+  if (bundlerSupportForLanguage[language] === undefined) {
+    const warning = `/*unknown language:${language}*/`;
     // each item is a function to avoid creating more in-memory copies of the source text etc.
+    /** @type {BundlerKit} */
     return {
-      getFunctor: () => `(()=>{${warning}})`,
-      getCells: `{${warning}}`,
-      getFunctorCall: warning,
+      getFunctor: () => `(()=>{${warning}}),`,
+      getCells: () => `{${warning}},`,
+      getFunctorCall: () => warning,
+      getReexportsWiring: () => '',
     };
   }
-  const { getBundlerKit } = implementationPerParser[parser];
+  const { getBundlerKit } = bundlerSupportForLanguage[language];
   return getBundlerKit(module);
-}
+};
 
 /**
- * @param {ReadFn} read
+ * @param {ReadFn | ReadPowers | MaybeReadPowers} readPowers
  * @param {string} moduleLocation
- * @param {object} [options]
- * @param {ModuleTransforms} [options.moduleTransforms]
- * @param {boolean} [options.dev]
- * @param {Set<string>} [options.tags]
- * @param {object} [options.commonDependencies]
- * @param {Array<string>} [options.searchSuffixes]
- * @param {import('./types.js').SourceMapHook} [options.sourceMapHook]
+ * @param {ArchiveOptions} [options]
  * @returns {Promise<string>}
  */
-export const makeBundle = async (read, moduleLocation, options) => {
+export const makeBundle = async (readPowers, moduleLocation, options) => {
+  const { read } = unpackReadPowers(readPowers);
+
   const {
     moduleTransforms,
     dev,
     tags: tagsOption,
+    conditions: conditionsOption = tagsOption,
     searchSuffixes,
     commonDependencies,
     sourceMapHook = undefined,
+    parserForLanguage: parserForLanguageOption = {},
+    languageForExtension: languageForExtensionOption = {},
   } = options || {};
-  const tags = new Set(tagsOption);
+  const conditions = new Set(conditionsOption);
+
+  const parserForLanguage = Object.freeze(
+    Object.assign(
+      Object.create(null),
+      defaultParserForLanguage,
+      parserForLanguageOption,
+    ),
+  );
+  const languageForExtension = Object.freeze(
+    Object.assign(Object.create(null), languageForExtensionOption),
+  );
 
   const {
     packageLocation,
     packageDescriptorText,
     packageDescriptorLocation,
     moduleSpecifier,
-  } = await search(read, moduleLocation);
+  } = await search(readPowers, moduleLocation);
 
   const packageDescriptor = parseLocatedJson(
     packageDescriptorText,
@@ -195,7 +259,7 @@ export const makeBundle = async (read, moduleLocation, options) => {
   const compartmentMap = await compartmentMapForNodeModules(
     read,
     packageLocation,
-    tags,
+    conditions,
     packageDescriptor,
     moduleSpecifier,
     { dev, commonDependencies },
@@ -223,6 +287,7 @@ export const makeBundle = async (read, moduleLocation, options) => {
     makeImportHook,
     moduleTransforms,
     parserForLanguage,
+    languageForExtension,
   });
   await compartment.load(entryModuleSpecifier);
 
@@ -271,10 +336,7 @@ export const makeBundle = async (read, moduleLocation, options) => {
 
   const bundle = `\
 'use strict';
-(() => {
-  const functors = [
-${''.concat(...modules.map(m => m.bundlerKit.getFunctor()))}\
-]; // functors end
+(functors => {
 
   const cell = (name, value = undefined) => {
     const observers = [];
@@ -302,7 +364,7 @@ ${''.concat(...modules.map(m => m.bundlerKit.getCells()))}\
 
 ${''.concat(...modules.map(m => m.bundlerKit.getReexportsWiring()))}\
 
-const namespaces = cells.map(cells => Object.freeze(Object.create(null, {
+  const namespaces = cells.map(cells => Object.freeze(Object.create(null, {
     ...cells,
     // Make this appear like an ESM module namespace object.
     [Symbol.toStringTag]: {
@@ -322,7 +384,7 @@ ${''.concat(...Array.from(parsersInUse).map(parser => getRuntime(parser)))}
 ${''.concat(...modules.map(m => m.bundlerKit.getFunctorCall()))}\
 
   return cells[cells.length - 1]['*'].get();
-})();
+})([${''.concat(...modules.map(m => m.bundlerKit.getFunctor()))}]);
 `;
 
   return bundle;

package/src/capture-lite.d.ts

@@ -0,0 +1,7 @@
+export function captureFromMap(powers: ReadFn | ReadPowers, compartmentMap: CompartmentMapDescriptor, options?: CaptureOptions | undefined): Promise<CaptureResult>;
+import type { ReadFn } from './types.js';
+import type { ReadPowers } from './types.js';
+import type { CompartmentMapDescriptor } from './types.js';
+import type { CaptureOptions } from './types.js';
+import type { CaptureResult } from './types.js';
+//# sourceMappingURL=capture-lite.d.ts.map

package/src/capture-lite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-lite.d.ts","sourceRoot":"","sources":["capture-lite.js"],"names":[],"mappings":"AAkQO,uCALI,MAAM,GAAG,UAAU,kBACnB,wBAAwB,yCAEtB,OAAO,CAAC,aAAa,CAAC,CAmElC;4BAlSyB,YAAY;gCACR,YAAY;8CACE,YAAY;oCACtB,YAAY;mCAIb,YAAY"}