@metamask/snaps-controllers 4.0.0 → 5.0.0

package/dist/esm/interface/utils.js

@@ -0,0 +1,62 @@
+import { NodeType, assert } from '@metamask/snaps-sdk';
+/**
+ * Construct the state for a stray input (not enclosed in a form).
+ *
+ * @param state - The interface state.
+ * @param component - The Input component.
+ * @returns The input state.
+ */ export const constructInputState = (state, component)=>{
+    return component.value ?? state[component.name] ?? null;
+};
+/**
+ * Construct the state for a form input.
+ *
+ * Sets the state to either the specified component value, the previous value from the old state or null.
+ *
+ * @param state - The interface state.
+ * @param component - The Input component.
+ * @param form - The parent form name of the input.
+ * @returns The input state.
+ */ export const constructFormInputState = (state, component, form)=>{
+    const oldFormState = state[form];
+    const oldInputState = oldFormState?.[component.name];
+    return component.value ?? oldInputState ?? null;
+};
+/**
+ * Assert that the component name is unique in state.
+ *
+ * @param state - The interface state to verify against.
+ * @param name - The component name to verify.
+ */ export const assertNameIsUnique = (state, name)=>{
+    assert(state[name] === undefined, `Duplicate component names are not allowed, found multiple instances of: "${name}".`);
+};
+/**
+ * Construct the interface state for a given component tree while preserving values for matching stateful components in the old state.
+ *
+ * @param oldState - The previous state.
+ * @param component - The UI component to construct state from.
+ * @param newState - The state that is being constructed.
+ * @returns The interface state of the passed component.
+ */ export const constructState = (oldState, component, newState = {})=>{
+    const { type } = component;
+    if (type === NodeType.Panel) {
+        return component.children.reduce((acc, node)=>constructState(oldState, node, acc), newState);
+    }
+    if (type === NodeType.Form) {
+        assertNameIsUnique(newState, component.name);
+        newState[component.name] = component.children.reduce((acc, node)=>{
+            if (node.type === NodeType.Input) {
+                assertNameIsUnique(acc, node.name);
+                acc[node.name] = constructFormInputState(oldState, node, component.name);
+            }
+            return acc;
+        }, {});
+    }
+    if (type === NodeType.Input) {
+        assertNameIsUnique(newState, component.name);
+        newState[component.name] = constructInputState(oldState, component);
+    }
+    return newState;
+};
+
+//# sourceMappingURL=utils.js.map

package/dist/esm/interface/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/interface/utils.ts"],"sourcesContent":["import { NodeType, assert } from '@metamask/snaps-sdk';\nimport type {\n  Component,\n  Input,\n  FormState,\n  InterfaceState,\n} from '@metamask/snaps-sdk';\n\n/**\n * Construct the state for a stray input (not enclosed in a form).\n *\n * @param state - The interface state.\n * @param component - The Input component.\n * @returns The input state.\n */\nexport const constructInputState = (\n  state: InterfaceState,\n  component: Input,\n) => {\n  return component.value ?? state[component.name] ?? null;\n};\n\n/**\n * Construct the state for a form input.\n *\n * Sets the state to either the specified component value, the previous value from the old state or null.\n *\n * @param state - The interface state.\n * @param component - The Input component.\n * @param form - The parent form name of the input.\n * @returns The input state.\n */\nexport const constructFormInputState = (\n  state: InterfaceState,\n  component: Input,\n  form: string,\n) => {\n  const oldFormState = state[form] as FormState;\n  const oldInputState = oldFormState?.[component.name];\n  return component.value ?? oldInputState ?? null;\n};\n\n/**\n * Assert that the component name is unique in state.\n *\n * @param state - The interface state to verify against.\n * @param name - The component name to verify.\n */\nexport const assertNameIsUnique = (state: InterfaceState, name: string) => {\n  assert(\n    state[name] === undefined,\n    `Duplicate component names are not allowed, found multiple instances of: \"${name}\".`,\n  );\n};\n\n/**\n * Construct the interface state for a given component tree while preserving values for matching stateful components in the old state.\n *\n * @param oldState - The previous state.\n * @param component - The UI component to construct state from.\n * @param newState - The state that is being constructed.\n * @returns The interface state of the passed component.\n */\nexport const constructState = (\n  oldState: InterfaceState,\n  component: Component,\n  newState: InterfaceState = {},\n): InterfaceState => {\n  const { type } = component;\n  if (type === NodeType.Panel) {\n    return component.children.reduce(\n      (acc, node) => constructState(oldState, node, acc),\n      newState,\n    );\n  }\n\n  if (type === NodeType.Form) {\n    assertNameIsUnique(newState, component.name);\n    newState[component.name] = component.children.reduce<FormState>(\n      (acc, node) => {\n        if (node.type === NodeType.Input) {\n          assertNameIsUnique(acc, node.name);\n          acc[node.name] = constructFormInputState(\n            oldState,\n            node,\n            component.name,\n          );\n        }\n\n        return acc;\n      },\n      {},\n    );\n  }\n\n  if (type === NodeType.Input) {\n    assertNameIsUnique(newState, component.name);\n    newState[component.name] = constructInputState(oldState, component);\n  }\n\n  return newState;\n};\n"],"names":["NodeType","assert","constructInputState","state","component","value","name","constructFormInputState","form","oldFormState","oldInputState","assertNameIsUnique","undefined","constructState","oldState","newState","type","Panel","children","reduce","acc","node","Form","Input"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,QAAQ,sBAAsB;AAQvD;;;;;;CAMC,GACD,OAAO,MAAMC,sBAAsB,CACjCC,OACAC;IAEA,OAAOA,UAAUC,KAAK,IAAIF,KAAK,CAACC,UAAUE,IAAI,CAAC,IAAI;AACrD,EAAE;AAEF;;;;;;;;;CASC,GACD,OAAO,MAAMC,0BAA0B,CACrCJ,OACAC,WACAI;IAEA,MAAMC,eAAeN,KAAK,CAACK,KAAK;IAChC,MAAME,gBAAgBD,cAAc,CAACL,UAAUE,IAAI,CAAC;IACpD,OAAOF,UAAUC,KAAK,IAAIK,iBAAiB;AAC7C,EAAE;AAEF;;;;;CAKC,GACD,OAAO,MAAMC,qBAAqB,CAACR,OAAuBG;IACxDL,OACEE,KAAK,CAACG,KAAK,KAAKM,WAChB,CAAC,yEAAyE,EAAEN,KAAK,EAAE,CAAC;AAExF,EAAE;AAEF;;;;;;;CAOC,GACD,OAAO,MAAMO,iBAAiB,CAC5BC,UACAV,WACAW,WAA2B,CAAC,CAAC;IAE7B,MAAM,EAAEC,IAAI,EAAE,GAAGZ;IACjB,IAAIY,SAAShB,SAASiB,KAAK,EAAE;QAC3B,OAAOb,UAAUc,QAAQ,CAACC,MAAM,CAC9B,CAACC,KAAKC,OAASR,eAAeC,UAAUO,MAAMD,MAC9CL;IAEJ;IAEA,IAAIC,SAAShB,SAASsB,IAAI,EAAE;QAC1BX,mBAAmBI,UAAUX,UAAUE,IAAI;QAC3CS,QAAQ,CAACX,UAAUE,IAAI,CAAC,GAAGF,UAAUc,QAAQ,CAACC,MAAM,CAClD,CAACC,KAAKC;YACJ,IAAIA,KAAKL,IAAI,KAAKhB,SAASuB,KAAK,EAAE;gBAChCZ,mBAAmBS,KAAKC,KAAKf,IAAI;gBACjCc,GAAG,CAACC,KAAKf,IAAI,CAAC,GAAGC,wBACfO,UACAO,MACAjB,UAAUE,IAAI;YAElB;YAEA,OAAOc;QACT,GACA,CAAC;IAEL;IAEA,IAAIJ,SAAShB,SAASuB,KAAK,EAAE;QAC3BZ,mBAAmBI,UAAUX,UAAUE,IAAI;QAC3CS,QAAQ,CAACX,UAAUE,IAAI,CAAC,GAAGJ,oBAAoBY,UAAUV;IAC3D;IAEA,OAAOW;AACT,EAAE"}

package/dist/esm/services/ProxyPostMessageStream.js

@@ -49,7 +49,7 @@ function _class_private_method_init(obj, privateSet) {
     privateSet.add(obj);
 }
 import { BasePostMessageStream } from '@metamask/post-message-stream';
-var _stream = /*#__PURE__*/ new WeakMap(), _jobId = /*#__PURE__*/ new WeakMap(), _extra = /*#__PURE__*/ new WeakMap(), /**
+var _stream = /*#__PURE__*/ new WeakMap(), _jobId = /*#__PURE__*/ new WeakMap(), /**
    * Handle incoming data from the underlying stream. This checks that the job
    * ID matches the expected job ID, and pushes the data to the stream if so.
    *
@@ -67,8 +67,7 @@ var _stream = /*#__PURE__*/ new WeakMap(), _jobId = /*#__PURE__*/ new WeakMap(),
    */ _postMessage(data) {
         _class_private_field_get(this, _stream).write({
             jobId: _class_private_field_get(this, _jobId),
-            data,
-            extra: _class_private_field_get(this, _extra)
+            data
         });
     }
     /**
@@ -77,8 +76,7 @@ var _stream = /*#__PURE__*/ new WeakMap(), _jobId = /*#__PURE__*/ new WeakMap(),
    * @param args - The constructor arguments.
    * @param args.stream - The underlying stream to use for communication.
    * @param args.jobId - The ID of the job this stream is associated with.
-   * @param args.extra - Extra data to include in the post message.
-   */ constructor({ stream, jobId, extra }){
+   */ constructor({ stream, jobId }){
         super();
         _class_private_method_init(this, _onData);
         _class_private_field_init(this, _stream, {
@@ -89,13 +87,8 @@ var _stream = /*#__PURE__*/ new WeakMap(), _jobId = /*#__PURE__*/ new WeakMap(),
             writable: true,
             value: void 0
         });
-        _class_private_field_init(this, _extra, {
-            writable: true,
-            value: void 0
-        });
         _class_private_field_set(this, _stream, stream);
         _class_private_field_set(this, _jobId, jobId);
-        _class_private_field_set(this, _extra, extra);
         _class_private_field_get(this, _stream).on('data', _class_private_method_get(this, _onData, onData).bind(this));
     }
 }

package/dist/esm/services/ProxyPostMessageStream.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/services/ProxyPostMessageStream.ts"],"sourcesContent":["import { BasePostMessageStream } from '@metamask/post-message-stream';\nimport type { JsonRpcRequest } from '@metamask/utils';\n\nexport type ProxyPostMessageStreamArgs = {\n  stream: BasePostMessageStream;\n  jobId: string;\n  extra?: Record<string, unknown>;\n};\n\nexport type ProxyPostMessage = {\n  jobId: string;\n  data: JsonRpcRequest;\n  extra?: Record<string, unknown>;\n};\n\n/**\n * A post message stream that wraps messages in a job ID, before sending them\n * over the underlying stream.\n */\nexport class ProxyPostMessageStream extends BasePostMessageStream {\n  readonly #stream: BasePostMessageStream;\n\n  readonly #jobId: string;\n\n  readonly #extra?: Record<string, unknown>;\n\n  /**\n   * Initializes a new `ProxyPostMessageStream` instance.\n   *\n   * @param args - The constructor arguments.\n   * @param args.stream - The underlying stream to use for communication.\n   * @param args.jobId - The ID of the job this stream is associated with.\n   * @param args.extra - Extra data to include in the post message.\n   */\n  constructor({ stream, jobId, extra }: ProxyPostMessageStreamArgs) {\n    super();\n\n    this.#stream = stream;\n    this.#jobId = jobId;\n    this.#extra = extra;\n\n    this.#stream.on('data', this.#onData.bind(this));\n  }\n\n  /**\n   * Handle incoming data from the underlying stream. This checks that the job\n   * ID matches the expected job ID, and pushes the data to the stream if so.\n   *\n   * @param data - The data to handle.\n   */\n  #onData(data: ProxyPostMessage) {\n    if (data.jobId !== this.#jobId) {\n      return;\n    }\n\n    this.push(data.data);\n  }\n\n  /**\n   * Write data to the underlying stream. This wraps the data in an object with\n   * the job ID.\n   *\n   * @param data - The data to write.\n   */\n  _postMessage(data: ProxyPostMessage) {\n    this.#stream.write({\n      jobId: this.#jobId,\n      data,\n      extra: this.#extra,\n    });\n  }\n}\n"],"names":["BasePostMessageStream","ProxyPostMessageStream","_postMessage","data","stream","write","jobId","extra","constructor","on","onData","bind","push"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,qBAAqB,QAAQ,gCAAgC;IAoB3D,uCAEA,sCAEA,sCAoBT;;;;;GAKC,GACD;AAnCF;;;CAGC,GACD,OAAO,MAAMC,+BAA+BD;IAuC1C;;;;;GAKC,GACDE,aAAaC,IAAsB,EAAE;QACnC,yBAAA,IAAI,EAAEC,SAAOC,KAAK,CAAC;YACjBC,KAAK,2BAAE,IAAI,EAAEA;YACbH;YACAI,KAAK,2BAAE,IAAI,EAAEA;QACf;IACF;IA5CA;;;;;;;GAOC,GACDC,YAAY,EAAEJ,MAAM,EAAEE,KAAK,EAAEC,KAAK,EAA8B,CAAE;QAChE,KAAK;QAeP,iCAAA;QA9BA,gCAAS;;mBAAT,KAAA;;QAEA,gCAAS;;mBAAT,KAAA;;QAEA,gCAAS;;mBAAT,KAAA;;uCAaQH,SAASA;uCACTE,QAAQA;uCACRC,QAAQA;QAEd,yBAAA,IAAI,EAAEH,SAAOK,EAAE,CAAC,QAAQ,0BAAA,IAAI,EAAEC,SAAAA,QAAOC,IAAI,CAAC,IAAI;IAChD;AA6BF;AArBE,SAAA,OAAQR,IAAsB;IAC5B,IAAIA,KAAKG,KAAK,8BAAK,IAAI,EAAEA,SAAO;QAC9B;IACF;IAEA,IAAI,CAACM,IAAI,CAACT,KAAKA,IAAI;AACrB"}
+{"version":3,"sources":["../../../src/services/ProxyPostMessageStream.ts"],"sourcesContent":["import { BasePostMessageStream } from '@metamask/post-message-stream';\nimport type { JsonRpcRequest } from '@metamask/utils';\n\nexport type ProxyPostMessageStreamArgs = {\n  stream: BasePostMessageStream;\n  jobId: string;\n  extra?: Record<string, unknown>;\n};\n\nexport type ProxyPostMessage = {\n  jobId: string;\n  data: JsonRpcRequest;\n  extra?: Record<string, unknown>;\n};\n\n/**\n * A post message stream that wraps messages in a job ID, before sending them\n * over the underlying stream.\n */\nexport class ProxyPostMessageStream extends BasePostMessageStream {\n  readonly #stream: BasePostMessageStream;\n\n  readonly #jobId: string;\n\n  /**\n   * Initializes a new `ProxyPostMessageStream` instance.\n   *\n   * @param args - The constructor arguments.\n   * @param args.stream - The underlying stream to use for communication.\n   * @param args.jobId - The ID of the job this stream is associated with.\n   */\n  constructor({ stream, jobId }: ProxyPostMessageStreamArgs) {\n    super();\n\n    this.#stream = stream;\n    this.#jobId = jobId;\n\n    this.#stream.on('data', this.#onData.bind(this));\n  }\n\n  /**\n   * Handle incoming data from the underlying stream. This checks that the job\n   * ID matches the expected job ID, and pushes the data to the stream if so.\n   *\n   * @param data - The data to handle.\n   */\n  #onData(data: ProxyPostMessage) {\n    if (data.jobId !== this.#jobId) {\n      return;\n    }\n\n    this.push(data.data);\n  }\n\n  /**\n   * Write data to the underlying stream. This wraps the data in an object with\n   * the job ID.\n   *\n   * @param data - The data to write.\n   */\n  _postMessage(data: ProxyPostMessage) {\n    this.#stream.write({\n      jobId: this.#jobId,\n      data,\n    });\n  }\n}\n"],"names":["BasePostMessageStream","ProxyPostMessageStream","_postMessage","data","stream","write","jobId","constructor","on","onData","bind","push"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,qBAAqB,QAAQ,gCAAgC;IAoB3D,uCAEA,sCAkBT;;;;;GAKC,GACD;AA/BF;;;CAGC,GACD,OAAO,MAAMC,+BAA+BD;IAmC1C;;;;;GAKC,GACDE,aAAaC,IAAsB,EAAE;QACnC,yBAAA,IAAI,EAAEC,SAAOC,KAAK,CAAC;YACjBC,KAAK,2BAAE,IAAI,EAAEA;YACbH;QACF;IACF;IAzCA;;;;;;GAMC,GACDI,YAAY,EAAEH,MAAM,EAAEE,KAAK,EAA8B,CAAE;QACzD,KAAK;QAcP,iCAAA;QA1BA,gCAAS;;mBAAT,KAAA;;QAEA,gCAAS;;mBAAT,KAAA;;uCAYQF,SAASA;uCACTE,QAAQA;QAEd,yBAAA,IAAI,EAAEF,SAAOI,EAAE,CAAC,QAAQ,0BAAA,IAAI,EAAEC,SAAAA,QAAOC,IAAI,CAAC,IAAI;IAChD;AA4BF;AApBE,SAAA,OAAQP,IAAsB;IAC5B,IAAIA,KAAKG,KAAK,8BAAK,IAAI,EAAEA,SAAO;QAC9B;IACF;IAEA,IAAI,CAACK,IAAI,CAACR,KAAKA,IAAI;AACrB"}

package/dist/esm/services/browser.js

@@ -4,6 +4,7 @@ export * from './ExecutionService';
 export * from './ProxyPostMessageStream';
 export * from './iframe';
 export * from './offscreen';
+export * from './webview';
 export { WebWorkerExecutionService } from './webworker';
 
 //# sourceMappingURL=browser.js.map

package/dist/esm/services/browser.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/services/browser.ts"],"sourcesContent":["// Subset of exports meant for browser environments, omits Node.js services\nexport * from './AbstractExecutionService';\nexport * from './ExecutionService';\nexport * from './ProxyPostMessageStream';\nexport * from './iframe';\nexport * from './offscreen';\nexport { WebWorkerExecutionService } from './webworker';\n"],"names":["WebWorkerExecutionService"],"mappings":"AAAA,2EAA2E;AAC3E,cAAc,6BAA6B;AAC3C,cAAc,qBAAqB;AACnC,cAAc,2BAA2B;AACzC,cAAc,WAAW;AACzB,cAAc,cAAc;AAC5B,SAASA,yBAAyB,QAAQ,cAAc"}
+{"version":3,"sources":["../../../src/services/browser.ts"],"sourcesContent":["// Subset of exports meant for browser environments, omits Node.js services\nexport * from './AbstractExecutionService';\nexport * from './ExecutionService';\nexport * from './ProxyPostMessageStream';\nexport * from './iframe';\nexport * from './offscreen';\nexport * from './webview';\nexport { WebWorkerExecutionService } from './webworker';\n"],"names":["WebWorkerExecutionService"],"mappings":"AAAA,2EAA2E;AAC3E,cAAc,6BAA6B;AAC3C,cAAc,qBAAqB;AACnC,cAAc,2BAA2B;AACzC,cAAc,WAAW;AACzB,cAAc,cAAc;AAC5B,cAAc,YAAY;AAC1B,SAASA,yBAAyB,QAAQ,cAAc"}

package/dist/esm/services/index.js

@@ -4,6 +4,7 @@ export * from './ProxyPostMessageStream';
 export * from './iframe';
 export * from './node';
 export * from './offscreen';
+export * from './webview';
 export { WebWorkerExecutionService } from './webworker';
 
 //# sourceMappingURL=index.js.map

package/dist/esm/services/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/services/index.ts"],"sourcesContent":["export * from './AbstractExecutionService';\nexport * from './ExecutionService';\nexport * from './ProxyPostMessageStream';\nexport * from './iframe';\nexport * from './node';\nexport * from './offscreen';\nexport { WebWorkerExecutionService } from './webworker';\n"],"names":["WebWorkerExecutionService"],"mappings":"AAAA,cAAc,6BAA6B;AAC3C,cAAc,qBAAqB;AACnC,cAAc,2BAA2B;AACzC,cAAc,WAAW;AACzB,cAAc,SAAS;AACvB,cAAc,cAAc;AAC5B,SAASA,yBAAyB,QAAQ,cAAc"}
+{"version":3,"sources":["../../../src/services/index.ts"],"sourcesContent":["export * from './AbstractExecutionService';\nexport * from './ExecutionService';\nexport * from './ProxyPostMessageStream';\nexport * from './iframe';\nexport * from './node';\nexport * from './offscreen';\nexport * from './webview';\nexport { WebWorkerExecutionService } from './webworker';\n"],"names":["WebWorkerExecutionService"],"mappings":"AAAA,cAAc,6BAA6B;AAC3C,cAAc,qBAAqB;AACnC,cAAc,2BAA2B;AACzC,cAAc,WAAW;AACzB,cAAc,SAAS;AACvB,cAAc,cAAc;AAC5B,cAAc,YAAY;AAC1B,SAASA,yBAAyB,QAAQ,cAAc"}

package/dist/esm/services/node/NodeProcessExecutionService.js

@@ -3,7 +3,19 @@ import { fork } from 'child_process';
 import { AbstractExecutionService } from '..';
 export class NodeProcessExecutionService extends AbstractExecutionService {
     async initEnvStream() {
-        const worker = fork(require.resolve('@metamask/snaps-execution-environments/dist/browserify/node-process/bundle.js'));
+        const worker = fork(require.resolve('@metamask/snaps-execution-environments/dist/browserify/node-process/bundle.js'), {
+            stdio: 'pipe'
+        });
+        // Capturing `stdout` and `stderr` from the worker prevents the worker from
+        // writing to them directly, making it easier to capture them Jest.
+        worker.stdout?.on('data', (data)=>{
+            // eslint-disable-next-line no-console
+            console.log(data.toString());
+        });
+        worker.stderr?.on('data', (data)=>{
+            // eslint-disable-next-line no-console
+            console.error(data.toString());
+        });
         const stream = new ProcessParentMessageStream({
             process: worker
         });

package/dist/esm/services/node/NodeProcessExecutionService.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/services/node/NodeProcessExecutionService.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { ProcessParentMessageStream } from '@metamask/post-message-stream';\nimport type { ChildProcess } from 'child_process';\nimport { fork } from 'child_process';\n\nimport type { Job } from '..';\nimport { AbstractExecutionService } from '..';\n\nexport class NodeProcessExecutionService extends AbstractExecutionService<ChildProcess> {\n  protected async initEnvStream(): Promise<{\n    worker: ChildProcess;\n    stream: BasePostMessageStream;\n  }> {\n    const worker = fork(\n      require.resolve(\n        '@metamask/snaps-execution-environments/dist/browserify/node-process/bundle.js',\n      ),\n    );\n\n    const stream = new ProcessParentMessageStream({ process: worker });\n    return Promise.resolve({ worker, stream });\n  }\n\n  protected terminateJob(jobWrapper: Job<ChildProcess>): void {\n    jobWrapper.worker.kill();\n  }\n}\n"],"names":["ProcessParentMessageStream","fork","AbstractExecutionService","NodeProcessExecutionService","initEnvStream","worker","require","resolve","stream","process","Promise","terminateJob","jobWrapper","kill"],"mappings":"AACA,SAASA,0BAA0B,QAAQ,gCAAgC;AAE3E,SAASC,IAAI,QAAQ,gBAAgB;AAGrC,SAASC,wBAAwB,QAAQ,KAAK;AAE9C,OAAO,MAAMC,oCAAoCD;IAC/C,MAAgBE,gBAGb;QACD,MAAMC,SAASJ,KACbK,QAAQC,OAAO,CACb;QAIJ,MAAMC,SAAS,IAAIR,2BAA2B;YAAES,SAASJ;QAAO;QAChE,OAAOK,QAAQH,OAAO,CAAC;YAAEF;YAAQG;QAAO;IAC1C;IAEUG,aAAaC,UAA6B,EAAQ;QAC1DA,WAAWP,MAAM,CAACQ,IAAI;IACxB;AACF"}
+{"version":3,"sources":["../../../../src/services/node/NodeProcessExecutionService.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { ProcessParentMessageStream } from '@metamask/post-message-stream';\nimport type { ChildProcess } from 'child_process';\nimport { fork } from 'child_process';\n\nimport type { Job } from '..';\nimport { AbstractExecutionService } from '..';\n\nexport class NodeProcessExecutionService extends AbstractExecutionService<ChildProcess> {\n  protected async initEnvStream(): Promise<{\n    worker: ChildProcess;\n    stream: BasePostMessageStream;\n  }> {\n    const worker = fork(\n      require.resolve(\n        '@metamask/snaps-execution-environments/dist/browserify/node-process/bundle.js',\n      ),\n      {\n        stdio: 'pipe',\n      },\n    );\n\n    // Capturing `stdout` and `stderr` from the worker prevents the worker from\n    // writing to them directly, making it easier to capture them Jest.\n    worker.stdout?.on('data', (data) => {\n      // eslint-disable-next-line no-console\n      console.log(data.toString());\n    });\n\n    worker.stderr?.on('data', (data) => {\n      // eslint-disable-next-line no-console\n      console.error(data.toString());\n    });\n\n    const stream = new ProcessParentMessageStream({ process: worker });\n    return Promise.resolve({ worker, stream });\n  }\n\n  protected terminateJob(jobWrapper: Job<ChildProcess>): void {\n    jobWrapper.worker.kill();\n  }\n}\n"],"names":["ProcessParentMessageStream","fork","AbstractExecutionService","NodeProcessExecutionService","initEnvStream","worker","require","resolve","stdio","stdout","on","data","console","log","toString","stderr","error","stream","process","Promise","terminateJob","jobWrapper","kill"],"mappings":"AACA,SAASA,0BAA0B,QAAQ,gCAAgC;AAE3E,SAASC,IAAI,QAAQ,gBAAgB;AAGrC,SAASC,wBAAwB,QAAQ,KAAK;AAE9C,OAAO,MAAMC,oCAAoCD;IAC/C,MAAgBE,gBAGb;QACD,MAAMC,SAASJ,KACbK,QAAQC,OAAO,CACb,kFAEF;YACEC,OAAO;QACT;QAGF,2EAA2E;QAC3E,mEAAmE;QACnEH,OAAOI,MAAM,EAAEC,GAAG,QAAQ,CAACC;YACzB,sCAAsC;YACtCC,QAAQC,GAAG,CAACF,KAAKG,QAAQ;QAC3B;QAEAT,OAAOU,MAAM,EAAEL,GAAG,QAAQ,CAACC;YACzB,sCAAsC;YACtCC,QAAQI,KAAK,CAACL,KAAKG,QAAQ;QAC7B;QAEA,MAAMG,SAAS,IAAIjB,2BAA2B;YAAEkB,SAASb;QAAO;QAChE,OAAOc,QAAQZ,OAAO,CAAC;YAAEF;YAAQY;QAAO;IAC1C;IAEUG,aAAaC,UAA6B,EAAQ;QAC1DA,WAAWhB,MAAM,CAACiB,IAAI;IACxB;AACF"}

package/dist/esm/services/node/NodeThreadExecutionService.js

@@ -4,7 +4,20 @@ import { Worker } from 'worker_threads';
 import { AbstractExecutionService } from '..';
 export class NodeThreadExecutionService extends AbstractExecutionService {
     async initEnvStream() {
-        const worker = new Worker(require.resolve('@metamask/snaps-execution-environments/dist/browserify/node-thread/bundle.js'));
+        const worker = new Worker(require.resolve('@metamask/snaps-execution-environments/dist/browserify/node-thread/bundle.js'), {
+            stdout: true,
+            stderr: true
+        });
+        // Capturing `stdout` and `stderr` from the worker prevents the worker from
+        // writing to them directly, making it easier to capture them Jest.
+        worker.stdout.on('data', (data)=>{
+            // eslint-disable-next-line no-console
+            console.log(data.toString());
+        });
+        worker.stderr.on('data', (data)=>{
+            // eslint-disable-next-line no-console
+            console.error(data.toString());
+        });
         const stream = new ThreadParentMessageStream({
             thread: worker
         });

package/dist/esm/services/node/NodeThreadExecutionService.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/services/node/NodeThreadExecutionService.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { ThreadParentMessageStream } from '@metamask/post-message-stream';\n// eslint-disable-next-line @typescript-eslint/no-shadow\nimport { Worker } from 'worker_threads';\n\nimport type { Job } from '..';\nimport { AbstractExecutionService } from '..';\n\nexport class NodeThreadExecutionService extends AbstractExecutionService<Worker> {\n  protected async initEnvStream(): Promise<{\n    worker: Worker;\n    stream: BasePostMessageStream;\n  }> {\n    const worker = new Worker(\n      require.resolve(\n        '@metamask/snaps-execution-environments/dist/browserify/node-thread/bundle.js',\n      ),\n    );\n    const stream = new ThreadParentMessageStream({ thread: worker });\n    return Promise.resolve({ worker, stream });\n  }\n\n  protected async terminateJob(jobWrapper: Job<Worker>): Promise<void> {\n    await jobWrapper.worker.terminate();\n  }\n}\n"],"names":["ThreadParentMessageStream","Worker","AbstractExecutionService","NodeThreadExecutionService","initEnvStream","worker","require","resolve","stream","thread","Promise","terminateJob","jobWrapper","terminate"],"mappings":"AACA,SAASA,yBAAyB,QAAQ,gCAAgC;AAC1E,wDAAwD;AACxD,SAASC,MAAM,QAAQ,iBAAiB;AAGxC,SAASC,wBAAwB,QAAQ,KAAK;AAE9C,OAAO,MAAMC,mCAAmCD;IAC9C,MAAgBE,gBAGb;QACD,MAAMC,SAAS,IAAIJ,OACjBK,QAAQC,OAAO,CACb;QAGJ,MAAMC,SAAS,IAAIR,0BAA0B;YAAES,QAAQJ;QAAO;QAC9D,OAAOK,QAAQH,OAAO,CAAC;YAAEF;YAAQG;QAAO;IAC1C;IAEA,MAAgBG,aAAaC,UAAuB,EAAiB;QACnE,MAAMA,WAAWP,MAAM,CAACQ,SAAS;IACnC;AACF"}
+{"version":3,"sources":["../../../../src/services/node/NodeThreadExecutionService.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { ThreadParentMessageStream } from '@metamask/post-message-stream';\n// eslint-disable-next-line @typescript-eslint/no-shadow\nimport { Worker } from 'worker_threads';\n\nimport type { Job } from '..';\nimport { AbstractExecutionService } from '..';\n\nexport class NodeThreadExecutionService extends AbstractExecutionService<Worker> {\n  protected async initEnvStream(): Promise<{\n    worker: Worker;\n    stream: BasePostMessageStream;\n  }> {\n    const worker = new Worker(\n      require.resolve(\n        '@metamask/snaps-execution-environments/dist/browserify/node-thread/bundle.js',\n      ),\n      {\n        stdout: true,\n        stderr: true,\n      },\n    );\n\n    // Capturing `stdout` and `stderr` from the worker prevents the worker from\n    // writing to them directly, making it easier to capture them Jest.\n    worker.stdout.on('data', (data) => {\n      // eslint-disable-next-line no-console\n      console.log(data.toString());\n    });\n\n    worker.stderr.on('data', (data) => {\n      // eslint-disable-next-line no-console\n      console.error(data.toString());\n    });\n\n    const stream = new ThreadParentMessageStream({ thread: worker });\n    return Promise.resolve({ worker, stream });\n  }\n\n  protected async terminateJob(jobWrapper: Job<Worker>): Promise<void> {\n    await jobWrapper.worker.terminate();\n  }\n}\n"],"names":["ThreadParentMessageStream","Worker","AbstractExecutionService","NodeThreadExecutionService","initEnvStream","worker","require","resolve","stdout","stderr","on","data","console","log","toString","error","stream","thread","Promise","terminateJob","jobWrapper","terminate"],"mappings":"AACA,SAASA,yBAAyB,QAAQ,gCAAgC;AAC1E,wDAAwD;AACxD,SAASC,MAAM,QAAQ,iBAAiB;AAGxC,SAASC,wBAAwB,QAAQ,KAAK;AAE9C,OAAO,MAAMC,mCAAmCD;IAC9C,MAAgBE,gBAGb;QACD,MAAMC,SAAS,IAAIJ,OACjBK,QAAQC,OAAO,CACb,iFAEF;YACEC,QAAQ;YACRC,QAAQ;QACV;QAGF,2EAA2E;QAC3E,mEAAmE;QACnEJ,OAAOG,MAAM,CAACE,EAAE,CAAC,QAAQ,CAACC;YACxB,sCAAsC;YACtCC,QAAQC,GAAG,CAACF,KAAKG,QAAQ;QAC3B;QAEAT,OAAOI,MAAM,CAACC,EAAE,CAAC,QAAQ,CAACC;YACxB,sCAAsC;YACtCC,QAAQG,KAAK,CAACJ,KAAKG,QAAQ;QAC7B;QAEA,MAAME,SAAS,IAAIhB,0BAA0B;YAAEiB,QAAQZ;QAAO;QAC9D,OAAOa,QAAQX,OAAO,CAAC;YAAEF;YAAQW;QAAO;IAC1C;IAEA,MAAgBG,aAAaC,UAAuB,EAAiB;QACnE,MAAMA,WAAWf,MAAM,CAACgB,SAAS;IACnC;AACF"}

package/dist/esm/services/offscreen/OffscreenExecutionService.js

@@ -3,40 +3,15 @@ function _check_private_redeclaration(obj, privateCollection) {
         throw new TypeError("Cannot initialize the same private elements twice on an object");
     }
 }
-function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) {
-        return descriptor.get.call(receiver);
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
     }
-    return descriptor.value;
+    return fn;
 }
-function _class_apply_descriptor_set(receiver, descriptor, value) {
-    if (descriptor.set) {
-        descriptor.set.call(receiver, value);
-    } else {
-        if (!descriptor.writable) {
-            throw new TypeError("attempted to set read only private field");
-        }
-        descriptor.value = value;
-    }
-}
-function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to " + action + " private field on non-instance");
-    }
-    return privateMap.get(receiver);
-}
-function _class_private_field_get(receiver, privateMap) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-    return _class_apply_descriptor_get(receiver, descriptor);
-}
-function _class_private_field_init(obj, privateMap, value) {
-    _check_private_redeclaration(obj, privateMap);
-    privateMap.set(obj, value);
-}
-function _class_private_field_set(receiver, privateMap, value) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
-    _class_apply_descriptor_set(receiver, descriptor, value);
-    return value;
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
 }
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -52,27 +27,9 @@ function _define_property(obj, key, value) {
     return obj;
 }
 import { BrowserRuntimePostMessageStream } from '@metamask/post-message-stream';
-import { nanoid } from 'nanoid';
-import { AbstractExecutionService } from '../AbstractExecutionService';
-import { ProxyPostMessageStream } from '../ProxyPostMessageStream';
-var _runtimeStream = /*#__PURE__*/ new WeakMap();
-export class OffscreenExecutionService extends AbstractExecutionService {
-    /**
-   * Send a termination command to the offscreen document.
-   *
-   * @param job - The job to terminate.
-   */ async terminateJob(job) {
-        // The `AbstractExecutionService` will have already closed the job stream,
-        // so we write to the runtime stream directly.
-        _class_private_field_get(this, _runtimeStream).write({
-            jobId: job.id,
-            data: {
-                jsonrpc: '2.0',
-                method: 'terminateJob',
-                id: nanoid()
-            }
-        });
-    }
+import { ProxyExecutionService } from '../proxy/ProxyExecutionService';
+var _createDocument = /*#__PURE__*/ new WeakSet();
+export class OffscreenExecutionService extends ProxyExecutionService {
     /**
    * Create a new stream for the specified job. This wraps the runtime stream
    * in a stream specific to the job.
@@ -80,38 +37,8 @@ export class OffscreenExecutionService extends AbstractExecutionService {
    * @param jobId - The job ID.
    */ async initEnvStream(jobId) {
         // Lazily create the offscreen document.
-        await this.createDocument();
-        const stream = new ProxyPostMessageStream({
-            stream: _class_private_field_get(this, _runtimeStream),
-            extra: {
-                // TODO: Rather than injecting the frame URL here, we should come up
-                // with a better way to do this. The frame URL is needed to avoid hard
-                // coding it in the offscreen execution environment.
-                frameUrl: this.frameUrl.toString()
-            },
-            jobId
-        });
-        return {
-            worker: jobId,
-            stream
-        };
-    }
-    /**
-   * Creates the offscreen document to be used as the execution environment.
-   *
-   * If the document already exists, this does nothing.
-   */ async createDocument() {
-        // Extensions can only have a single offscreen document.
-        if (await chrome.offscreen.hasDocument()) {
-            return;
-        }
-        await chrome.offscreen.createDocument({
-            justification: 'MetaMask Snaps Execution Environment',
-            reasons: [
-                'IFRAME_SCRIPTING'
-            ],
-            url: this.documentUrl.toString()
-        });
+        await _class_private_method_get(this, _createDocument, createDocument).call(this);
+        return super.initEnvStream(jobId);
     }
     /**
    * Create a new offscreen execution service.
@@ -120,30 +47,40 @@ export class OffscreenExecutionService extends AbstractExecutionService {
    * @param args.documentUrl - The URL of the offscreen document to use as the
    * execution environment. This must be a URL relative to the location where
    * this is called. This cannot be a public (http(s)) URL.
-   * @param args.frameUrl - The URL of the iframe to load inside the offscreen
-   * document.
    * @param args.messenger - The messenger to use for communication with the
    * `SnapController`.
    * @param args.setupSnapProvider - The function to use to set up the snap
    * provider.
-   */ constructor({ documentUrl, frameUrl, messenger, setupSnapProvider }){
+   */ constructor({ documentUrl, messenger, setupSnapProvider }){
         super({
             messenger,
-            setupSnapProvider
+            setupSnapProvider,
+            stream: new BrowserRuntimePostMessageStream({
+                name: 'parent',
+                target: 'child'
+            })
         });
+        /**
+   * Creates the offscreen document to be used as the execution environment.
+   *
+   * If the document already exists, this does nothing.
+   */ _class_private_method_init(this, _createDocument);
         _define_property(this, "documentUrl", void 0);
-        _define_property(this, "frameUrl", void 0);
-        _class_private_field_init(this, _runtimeStream, {
-            writable: true,
-            value: void 0
-        });
         this.documentUrl = documentUrl;
-        this.frameUrl = frameUrl;
-        _class_private_field_set(this, _runtimeStream, new BrowserRuntimePostMessageStream({
-            name: 'parent',
-            target: 'child'
-        }));
     }
 }
+async function createDocument() {
+    // Extensions can only have a single offscreen document.
+    if (await chrome.offscreen.hasDocument()) {
+        return;
+    }
+    await chrome.offscreen.createDocument({
+        justification: 'MetaMask Snaps Execution Environment',
+        reasons: [
+            'IFRAME_SCRIPTING'
+        ],
+        url: this.documentUrl.toString()
+    });
+}
 
 //# sourceMappingURL=OffscreenExecutionService.js.map

package/dist/esm/services/offscreen/OffscreenExecutionService.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/services/offscreen/OffscreenExecutionService.ts"],"sourcesContent":["import { BrowserRuntimePostMessageStream } from '@metamask/post-message-stream';\nimport { nanoid } from 'nanoid';\n\nimport type { ExecutionServiceArgs, Job } from '../AbstractExecutionService';\nimport { AbstractExecutionService } from '../AbstractExecutionService';\nimport { ProxyPostMessageStream } from '../ProxyPostMessageStream';\n\ntype OffscreenExecutionEnvironmentServiceArgs = {\n  documentUrl: URL;\n  frameUrl: URL;\n} & ExecutionServiceArgs;\n\nexport class OffscreenExecutionService extends AbstractExecutionService<string> {\n  public readonly documentUrl: URL;\n\n  public readonly frameUrl: URL;\n\n  readonly #runtimeStream: BrowserRuntimePostMessageStream;\n\n  /**\n   * Create a new offscreen execution service.\n   *\n   * @param args - The constructor arguments.\n   * @param args.documentUrl - The URL of the offscreen document to use as the\n   * execution environment. This must be a URL relative to the location where\n   * this is called. This cannot be a public (http(s)) URL.\n   * @param args.frameUrl - The URL of the iframe to load inside the offscreen\n   * document.\n   * @param args.messenger - The messenger to use for communication with the\n   * `SnapController`.\n   * @param args.setupSnapProvider - The function to use to set up the snap\n   * provider.\n   */\n  constructor({\n    documentUrl,\n    frameUrl,\n    messenger,\n    setupSnapProvider,\n  }: OffscreenExecutionEnvironmentServiceArgs) {\n    super({\n      messenger,\n      setupSnapProvider,\n    });\n\n    this.documentUrl = documentUrl;\n    this.frameUrl = frameUrl;\n    this.#runtimeStream = new BrowserRuntimePostMessageStream({\n      name: 'parent',\n      target: 'child',\n    });\n  }\n\n  /**\n   * Send a termination command to the offscreen document.\n   *\n   * @param job - The job to terminate.\n   */\n  protected async terminateJob(job: Job<string>) {\n    // The `AbstractExecutionService` will have already closed the job stream,\n    // so we write to the runtime stream directly.\n    this.#runtimeStream.write({\n      jobId: job.id,\n      data: {\n        jsonrpc: '2.0',\n        method: 'terminateJob',\n        id: nanoid(),\n      },\n    });\n  }\n\n  /**\n   * Create a new stream for the specified job. This wraps the runtime stream\n   * in a stream specific to the job.\n   *\n   * @param jobId - The job ID.\n   */\n  protected async initEnvStream(jobId: string) {\n    // Lazily create the offscreen document.\n    await this.createDocument();\n\n    const stream = new ProxyPostMessageStream({\n      stream: this.#runtimeStream,\n      extra: {\n        // TODO: Rather than injecting the frame URL here, we should come up\n        // with a better way to do this. The frame URL is needed to avoid hard\n        // coding it in the offscreen execution environment.\n        frameUrl: this.frameUrl.toString(),\n      },\n      jobId,\n    });\n\n    return { worker: jobId, stream };\n  }\n\n  /**\n   * Creates the offscreen document to be used as the execution environment.\n   *\n   * If the document already exists, this does nothing.\n   */\n  private async createDocument() {\n    // Extensions can only have a single offscreen document.\n    if (await chrome.offscreen.hasDocument()) {\n      return;\n    }\n\n    await chrome.offscreen.createDocument({\n      justification: 'MetaMask Snaps Execution Environment',\n      reasons: ['IFRAME_SCRIPTING' as chrome.offscreen.Reason],\n      url: this.documentUrl.toString(),\n    });\n  }\n}\n"],"names":["BrowserRuntimePostMessageStream","nanoid","AbstractExecutionService","ProxyPostMessageStream","OffscreenExecutionService","terminateJob","job","runtimeStream","write","jobId","id","data","jsonrpc","method","initEnvStream","createDocument","stream","extra","frameUrl","toString","worker","chrome","offscreen","hasDocument","justification","reasons","url","documentUrl","constructor","messenger","setupSnapProvider","name","target"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,+BAA+B,QAAQ,gCAAgC;AAChF,SAASC,MAAM,QAAQ,SAAS;AAGhC,SAASC,wBAAwB,QAAQ,8BAA8B;AACvE,SAASC,sBAAsB,QAAQ,4BAA4B;IAYxD;AALX,OAAO,MAAMC,kCAAkCF;IAwC7C;;;;GAIC,GACD,MAAgBG,aAAaC,GAAgB,EAAE;QAC7C,0EAA0E;QAC1E,8CAA8C;QAC9C,yBAAA,IAAI,EAAEC,gBAAcC,KAAK,CAAC;YACxBC,OAAOH,IAAII,EAAE;YACbC,MAAM;gBACJC,SAAS;gBACTC,QAAQ;gBACRH,IAAIT;YACN;QACF;IACF;IAEA;;;;;GAKC,GACD,MAAgBa,cAAcL,KAAa,EAAE;QAC3C,wCAAwC;QACxC,MAAM,IAAI,CAACM,cAAc;QAEzB,MAAMC,SAAS,IAAIb,uBAAuB;YACxCa,MAAM,2BAAE,IAAI,EAAET;YACdU,OAAO;gBACL,oEAAoE;gBACpE,sEAAsE;gBACtE,oDAAoD;gBACpDC,UAAU,IAAI,CAACA,QAAQ,CAACC,QAAQ;YAClC;YACAV;QACF;QAEA,OAAO;YAAEW,QAAQX;YAAOO;QAAO;IACjC;IAEA;;;;GAIC,GACD,MAAcD,iBAAiB;QAC7B,wDAAwD;QACxD,IAAI,MAAMM,OAAOC,SAAS,CAACC,WAAW,IAAI;YACxC;QACF;QAEA,MAAMF,OAAOC,SAAS,CAACP,cAAc,CAAC;YACpCS,eAAe;YACfC,SAAS;gBAAC;aAA8C;YACxDC,KAAK,IAAI,CAACC,WAAW,CAACR,QAAQ;QAChC;IACF;IA3FA;;;;;;;;;;;;;GAaC,GACDS,YAAY,EACVD,WAAW,EACXT,QAAQ,EACRW,SAAS,EACTC,iBAAiB,EACwB,CAAE;QAC3C,KAAK,CAAC;YACJD;YACAC;QACF;QA7BF,uBAAgBH,eAAhB,KAAA;QAEA,uBAAgBT,YAAhB,KAAA;QAEA,gCAAS;;mBAAT,KAAA;;QA2BE,IAAI,CAACS,WAAW,GAAGA;QACnB,IAAI,CAACT,QAAQ,GAAGA;uCACVX,gBAAgB,IAAIP,gCAAgC;YACxD+B,MAAM;YACNC,QAAQ;QACV;IACF;AA6DF"}
+{"version":3,"sources":["../../../../src/services/offscreen/OffscreenExecutionService.ts"],"sourcesContent":["import { BrowserRuntimePostMessageStream } from '@metamask/post-message-stream';\n\nimport type { ExecutionServiceArgs } from '../AbstractExecutionService';\nimport { ProxyExecutionService } from '../proxy/ProxyExecutionService';\n\ntype OffscreenExecutionEnvironmentServiceArgs = {\n  documentUrl: URL;\n} & ExecutionServiceArgs;\n\nexport class OffscreenExecutionService extends ProxyExecutionService {\n  public readonly documentUrl: URL;\n\n  /**\n   * Create a new offscreen execution service.\n   *\n   * @param args - The constructor arguments.\n   * @param args.documentUrl - The URL of the offscreen document to use as the\n   * execution environment. This must be a URL relative to the location where\n   * this is called. This cannot be a public (http(s)) URL.\n   * @param args.messenger - The messenger to use for communication with the\n   * `SnapController`.\n   * @param args.setupSnapProvider - The function to use to set up the snap\n   * provider.\n   */\n  constructor({\n    documentUrl,\n    messenger,\n    setupSnapProvider,\n  }: OffscreenExecutionEnvironmentServiceArgs) {\n    super({\n      messenger,\n      setupSnapProvider,\n      stream: new BrowserRuntimePostMessageStream({\n        name: 'parent',\n        target: 'child',\n      }),\n    });\n\n    this.documentUrl = documentUrl;\n  }\n\n  /**\n   * Create a new stream for the specified job. This wraps the runtime stream\n   * in a stream specific to the job.\n   *\n   * @param jobId - The job ID.\n   */\n  protected async initEnvStream(jobId: string) {\n    // Lazily create the offscreen document.\n    await this.#createDocument();\n\n    return super.initEnvStream(jobId);\n  }\n\n  /**\n   * Creates the offscreen document to be used as the execution environment.\n   *\n   * If the document already exists, this does nothing.\n   */\n  async #createDocument() {\n    // Extensions can only have a single offscreen document.\n    if (await chrome.offscreen.hasDocument()) {\n      return;\n    }\n\n    await chrome.offscreen.createDocument({\n      justification: 'MetaMask Snaps Execution Environment',\n      reasons: ['IFRAME_SCRIPTING' as chrome.offscreen.Reason],\n      url: this.documentUrl.toString(),\n    });\n  }\n}\n"],"names":["BrowserRuntimePostMessageStream","ProxyExecutionService","OffscreenExecutionService","initEnvStream","jobId","createDocument","constructor","documentUrl","messenger","setupSnapProvider","stream","name","target","chrome","offscreen","hasDocument","justification","reasons","url","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,+BAA+B,QAAQ,gCAAgC;AAGhF,SAASC,qBAAqB,QAAQ,iCAAiC;IAwD/D;AAlDR,OAAO,MAAMC,kCAAkCD;IAgC7C;;;;;GAKC,GACD,MAAgBE,cAAcC,KAAa,EAAE;QAC3C,wCAAwC;QACxC,MAAM,0BAAA,IAAI,EAAEC,iBAAAA,qBAAN,IAAI;QAEV,OAAO,KAAK,CAACF,cAAcC;IAC7B;IAxCA;;;;;;;;;;;GAWC,GACDE,YAAY,EACVC,WAAW,EACXC,SAAS,EACTC,iBAAiB,EACwB,CAAE;QAC3C,KAAK,CAAC;YACJD;YACAC;YACAC,QAAQ,IAAIV,gCAAgC;gBAC1CW,MAAM;gBACNC,QAAQ;YACV;QACF;QAkBF;;;;GAIC,GACD,iCAAM;QAjDN,uBAAgBL,eAAhB,KAAA;QA4BE,IAAI,CAACA,WAAW,GAAGA;IACrB;AAgCF;AAZE,eAAA;IACE,wDAAwD;IACxD,IAAI,MAAMM,OAAOC,SAAS,CAACC,WAAW,IAAI;QACxC;IACF;IAEA,MAAMF,OAAOC,SAAS,CAACT,cAAc,CAAC;QACpCW,eAAe;QACfC,SAAS;YAAC;SAA8C;QACxDC,KAAK,IAAI,CAACX,WAAW,CAACY,QAAQ;IAChC;AACF"}

package/dist/esm/services/proxy/ProxyExecutionService.js

@@ -0,0 +1,100 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+import { nanoid } from 'nanoid';
+import { AbstractExecutionService } from '../AbstractExecutionService';
+import { ProxyPostMessageStream } from '../ProxyPostMessageStream';
+var _stream = /*#__PURE__*/ new WeakMap();
+export class ProxyExecutionService extends AbstractExecutionService {
+    /**
+   * Send a termination command to the proxy stream.
+   *
+   * @param job - The job to terminate.
+   */ async terminateJob(job) {
+        // The `AbstractExecutionService` will have already closed the job stream,
+        // so we write to the runtime stream directly.
+        _class_private_field_get(this, _stream).write({
+            jobId: job.id,
+            data: {
+                jsonrpc: '2.0',
+                method: 'terminateJob',
+                id: nanoid()
+            }
+        });
+    }
+    /**
+   * Create a new stream for the specified job. This wraps the root stream
+   * in a stream specific to the job.
+   *
+   * @param jobId - The job ID.
+   */ async initEnvStream(jobId) {
+        const stream = new ProxyPostMessageStream({
+            stream: _class_private_field_get(this, _stream),
+            jobId
+        });
+        return {
+            worker: jobId,
+            stream
+        };
+    }
+    /**
+   * Create a new proxy execution service.
+   *
+   * @param args - The constructor arguments.
+   * @param args.messenger - The messenger to use for communication with the
+   * `SnapController`.
+   * @param args.setupSnapProvider - The function to use to set up the snap
+   * provider.
+   * @param args.stream - The stream to use for communicating with the proxy
+   * executor.
+   */ constructor({ stream, messenger, setupSnapProvider }){
+        super({
+            messenger,
+            setupSnapProvider
+        });
+        _class_private_field_init(this, _stream, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _stream, stream);
+    }
+}
+
+//# sourceMappingURL=ProxyExecutionService.js.map

package/dist/esm/services/proxy/ProxyExecutionService.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/proxy/ProxyExecutionService.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { nanoid } from 'nanoid';\n\nimport type { ExecutionServiceArgs, Job } from '../AbstractExecutionService';\nimport { AbstractExecutionService } from '../AbstractExecutionService';\nimport { ProxyPostMessageStream } from '../ProxyPostMessageStream';\n\ntype ProxyExecutionEnvironmentServiceArgs = {\n  stream: BasePostMessageStream;\n} & ExecutionServiceArgs;\n\nexport class ProxyExecutionService extends AbstractExecutionService<string> {\n  readonly #stream: BasePostMessageStream;\n\n  /**\n   * Create a new proxy execution service.\n   *\n   * @param args - The constructor arguments.\n   * @param args.messenger - The messenger to use for communication with the\n   * `SnapController`.\n   * @param args.setupSnapProvider - The function to use to set up the snap\n   * provider.\n   * @param args.stream - The stream to use for communicating with the proxy\n   * executor.\n   */\n  constructor({\n    stream,\n    messenger,\n    setupSnapProvider,\n  }: ProxyExecutionEnvironmentServiceArgs) {\n    super({\n      messenger,\n      setupSnapProvider,\n    });\n\n    this.#stream = stream;\n  }\n\n  /**\n   * Send a termination command to the proxy stream.\n   *\n   * @param job - The job to terminate.\n   */\n  protected async terminateJob(job: Job<string>) {\n    // The `AbstractExecutionService` will have already closed the job stream,\n    // so we write to the runtime stream directly.\n    this.#stream.write({\n      jobId: job.id,\n      data: {\n        jsonrpc: '2.0',\n        method: 'terminateJob',\n        id: nanoid(),\n      },\n    });\n  }\n\n  /**\n   * Create a new stream for the specified job. This wraps the root stream\n   * in a stream specific to the job.\n   *\n   * @param jobId - The job ID.\n   */\n  protected async initEnvStream(jobId: string) {\n    const stream = new ProxyPostMessageStream({\n      stream: this.#stream,\n      jobId,\n    });\n\n    return { worker: jobId, stream };\n  }\n}\n"],"names":["nanoid","AbstractExecutionService","ProxyPostMessageStream","ProxyExecutionService","terminateJob","job","stream","write","jobId","id","data","jsonrpc","method","initEnvStream","worker","constructor","messenger","setupSnapProvider"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAASA,MAAM,QAAQ,SAAS;AAGhC,SAASC,wBAAwB,QAAQ,8BAA8B;AACvE,SAASC,sBAAsB,QAAQ,4BAA4B;IAOxD;AADX,OAAO,MAAMC,8BAA8BF;IA2BzC;;;;GAIC,GACD,MAAgBG,aAAaC,GAAgB,EAAE;QAC7C,0EAA0E;QAC1E,8CAA8C;QAC9C,yBAAA,IAAI,EAAEC,SAAOC,KAAK,CAAC;YACjBC,OAAOH,IAAII,EAAE;YACbC,MAAM;gBACJC,SAAS;gBACTC,QAAQ;gBACRH,IAAIT;YACN;QACF;IACF;IAEA;;;;;GAKC,GACD,MAAgBa,cAAcL,KAAa,EAAE;QAC3C,MAAMF,SAAS,IAAIJ,uBAAuB;YACxCI,MAAM,2BAAE,IAAI,EAAEA;YACdE;QACF;QAEA,OAAO;YAAEM,QAAQN;YAAOF;QAAO;IACjC;IAvDA;;;;;;;;;;GAUC,GACDS,YAAY,EACVT,MAAM,EACNU,SAAS,EACTC,iBAAiB,EACoB,CAAE;QACvC,KAAK,CAAC;YACJD;YACAC;QACF;QArBF,gCAAS;;mBAAT,KAAA;;uCAuBQX,SAASA;IACjB;AAkCF"}

package/dist/esm/services/webview/WebViewExecutionService.js

@@ -0,0 +1,89 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+import { ProxyExecutionService } from '../proxy/ProxyExecutionService';
+import { WebViewMessageStream } from './WebViewMessageStream';
+var _getWebView = /*#__PURE__*/ new WeakMap(), _ensureWebViewLoaded = /*#__PURE__*/ new WeakSet();
+export class WebViewExecutionService extends ProxyExecutionService {
+    /**
+   * Create a new stream for the specified job. This wraps the runtime stream
+   * in a stream specific to the job.
+   *
+   * @param jobId - The job ID.
+   */ async initEnvStream(jobId) {
+        // Ensure that the WebView has been loaded before we proceed.
+        await _class_private_method_get(this, _ensureWebViewLoaded, ensureWebViewLoaded).call(this);
+        return super.initEnvStream(jobId);
+    }
+    constructor({ messenger, setupSnapProvider, getWebView }){
+        super({
+            messenger,
+            setupSnapProvider,
+            stream: new WebViewMessageStream({
+                name: 'parent',
+                target: 'child',
+                getWebView
+            })
+        });
+        /**
+   * Ensure that the WebView has been loaded by awaiting the getWebView promise.
+   */ _class_private_method_init(this, _ensureWebViewLoaded);
+        _class_private_field_init(this, _getWebView, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _getWebView, getWebView);
+    }
+}
+async function ensureWebViewLoaded() {
+    await _class_private_field_get(this, _getWebView).call(this);
+}
+
+//# sourceMappingURL=WebViewExecutionService.js.map