@metamask/snaps-controllers 1.0.2 → 2.0.1

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

@@ -0,0 +1,20 @@
+import { ProcessParentMessageStream } from '@metamask/post-message-stream';
+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 stream = new ProcessParentMessageStream({
+            process: worker
+        });
+        return Promise.resolve({
+            worker,
+            stream
+        });
+    }
+    terminateJob(jobWrapper) {
+        jobWrapper.worker.kill();
+    }
+}
+
+//# sourceMappingURL=NodeProcessExecutionService.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,21 @@
+import { ThreadParentMessageStream } from '@metamask/post-message-stream';
+// eslint-disable-next-line @typescript-eslint/no-shadow
+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 stream = new ThreadParentMessageStream({
+            thread: worker
+        });
+        return Promise.resolve({
+            worker,
+            stream
+        });
+    }
+    async terminateJob(jobWrapper) {
+        await jobWrapper.worker.terminate();
+    }
+}
+
+//# sourceMappingURL=NodeThreadExecutionService.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,4 @@
+export * from './NodeProcessExecutionService';
+export * from './NodeThreadExecutionService';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/node/index.ts"],"sourcesContent":["export * from './NodeProcessExecutionService';\nexport * from './NodeThreadExecutionService';\n"],"names":[],"mappings":"AAAA,cAAc,gCAAgC;AAC9C,cAAc,+BAA+B"}

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

@@ -0,0 +1,149 @@
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        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()
+            }
+        });
+    }
+    /**
+   * 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) {
+        // 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()
+        });
+    }
+    /**
+   * Create a new offscreen execution service.
+   *
+   * @param args - The constructor arguments.
+   * @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 }){
+        super({
+            messenger,
+            setupSnapProvider
+        });
+        _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'
+        }));
+    }
+}
+
+//# sourceMappingURL=OffscreenExecutionService.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,3 @@
+export * from './OffscreenExecutionService';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/offscreen/index.ts"],"sourcesContent":["export * from './OffscreenExecutionService';\n"],"names":[],"mappings":"AAAA,cAAc,8BAA8B"}

package/dist/esm/services/webworker/WebWorkerExecutionService.js

@@ -0,0 +1,130 @@
+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 { WindowPostMessageStream } from '@metamask/post-message-stream';
+import { createWindow } from '@metamask/snaps-utils';
+import { assert } from '@metamask/utils';
+import { nanoid } from 'nanoid';
+import { AbstractExecutionService } from '../AbstractExecutionService';
+import { ProxyPostMessageStream } from '../ProxyPostMessageStream';
+export const WORKER_POOL_ID = 'snaps-worker-pool';
+var _documentUrl = /*#__PURE__*/ new WeakMap(), _runtimeStream = /*#__PURE__*/ new WeakMap();
+export class WebWorkerExecutionService extends AbstractExecutionService {
+    /**
+   * Send a termination command to the worker pool 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.
+        assert(_class_private_field_get(this, _runtimeStream), 'Runtime stream not initialized.');
+        _class_private_field_get(this, _runtimeStream).write({
+            jobId: job.id,
+            data: {
+                jsonrpc: '2.0',
+                method: 'terminateJob',
+                id: nanoid()
+            }
+        });
+    }
+    /**
+   * 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) {
+        // Lazily create the worker pool document.
+        await this.createDocument();
+        // `createDocument` should have initialized the runtime stream.
+        assert(_class_private_field_get(this, _runtimeStream), 'Runtime stream not initialized.');
+        const stream = new ProxyPostMessageStream({
+            stream: _class_private_field_get(this, _runtimeStream),
+            jobId
+        });
+        return {
+            worker: jobId,
+            stream
+        };
+    }
+    /**
+   * Creates the worker pool document to be used as the execution environment.
+   *
+   * If the document already exists, this does nothing.
+   */ async createDocument() {
+        // We only want to create a single pool.
+        if (document.getElementById(WORKER_POOL_ID)) {
+            return;
+        }
+        const window = await createWindow(_class_private_field_get(this, _documentUrl).href, WORKER_POOL_ID, false);
+        _class_private_field_set(this, _runtimeStream, new WindowPostMessageStream({
+            name: 'parent',
+            target: 'child',
+            targetWindow: window,
+            targetOrigin: '*'
+        }));
+    }
+    /**
+   * Create a new webworker execution service.
+   *
+   * @param args - The constructor arguments.
+   * @param args.documentUrl - The URL of the worker pool document to use as the
+   * execution environment.
+   * @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, messenger, setupSnapProvider }){
+        super({
+            messenger,
+            setupSnapProvider
+        });
+        _class_private_field_init(this, _documentUrl, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _runtimeStream, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _documentUrl, documentUrl);
+    }
+}
+
+//# sourceMappingURL=WebWorkerExecutionService.js.map

package/dist/esm/services/webworker/WebWorkerExecutionService.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/webworker/WebWorkerExecutionService.ts"],"sourcesContent":["import type { BasePostMessageStream } from '@metamask/post-message-stream';\nimport { WindowPostMessageStream } from '@metamask/post-message-stream';\nimport { createWindow } from '@metamask/snaps-utils';\nimport { assert } from '@metamask/utils';\nimport { nanoid } from 'nanoid';\n\nimport type { ExecutionServiceArgs, Job } from '../AbstractExecutionService';\nimport { AbstractExecutionService } from '../AbstractExecutionService';\nimport { ProxyPostMessageStream } from '../ProxyPostMessageStream';\n\ntype WebWorkerExecutionEnvironmentServiceArgs = {\n  documentUrl: URL;\n} & ExecutionServiceArgs;\n\nexport const WORKER_POOL_ID = 'snaps-worker-pool';\n\nexport class WebWorkerExecutionService extends AbstractExecutionService<string> {\n  #documentUrl: URL;\n\n  #runtimeStream?: BasePostMessageStream;\n\n  /**\n   * Create a new webworker execution service.\n   *\n   * @param args - The constructor arguments.\n   * @param args.documentUrl - The URL of the worker pool document to use as the\n   * execution environment.\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  }: WebWorkerExecutionEnvironmentServiceArgs) {\n    super({\n      messenger,\n      setupSnapProvider,\n    });\n\n    this.#documentUrl = documentUrl;\n  }\n\n  /**\n   * Send a termination command to the worker pool 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    assert(this.#runtimeStream, 'Runtime stream not initialized.');\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 worker pool document.\n    await this.createDocument();\n\n    // `createDocument` should have initialized the runtime stream.\n    assert(this.#runtimeStream, 'Runtime stream not initialized.');\n\n    const stream = new ProxyPostMessageStream({\n      stream: this.#runtimeStream,\n      jobId,\n    });\n\n    return { worker: jobId, stream };\n  }\n\n  /**\n   * Creates the worker pool document to be used as the execution environment.\n   *\n   * If the document already exists, this does nothing.\n   */\n  private async createDocument() {\n    // We only want to create a single pool.\n    if (document.getElementById(WORKER_POOL_ID)) {\n      return;\n    }\n\n    const window = await createWindow(\n      this.#documentUrl.href,\n      WORKER_POOL_ID,\n      false,\n    );\n\n    this.#runtimeStream = new WindowPostMessageStream({\n      name: 'parent',\n      target: 'child',\n      targetWindow: window,\n      targetOrigin: '*',\n    });\n  }\n}\n"],"names":["WindowPostMessageStream","createWindow","assert","nanoid","AbstractExecutionService","ProxyPostMessageStream","WORKER_POOL_ID","WebWorkerExecutionService","terminateJob","job","runtimeStream","write","jobId","id","data","jsonrpc","method","initEnvStream","createDocument","stream","worker","document","getElementById","window","documentUrl","href","name","target","targetWindow","targetOrigin","constructor","messenger","setupSnapProvider"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAASA,uBAAuB,QAAQ,gCAAgC;AACxE,SAASC,YAAY,QAAQ,wBAAwB;AACrD,SAASC,MAAM,QAAQ,kBAAkB;AACzC,SAASC,MAAM,QAAQ,SAAS;AAGhC,SAASC,wBAAwB,QAAQ,8BAA8B;AACvE,SAASC,sBAAsB,QAAQ,4BAA4B;AAMnE,OAAO,MAAMC,iBAAiB,oBAAoB;IAGhD,4CAEA;AAHF,OAAO,MAAMC,kCAAkCH;IA6B7C;;;;GAIC,GACD,MAAgBI,aAAaC,GAAgB,EAAE;QAC7C,0EAA0E;QAC1E,8CAA8C;QAC9CP,gCAAO,IAAI,EAAEQ,iBAAe;QAC5B,yBAAA,IAAI,EAAEA,gBAAcC,KAAK,CAAC;YACxBC,OAAOH,IAAII,EAAE;YACbC,MAAM;gBACJC,SAAS;gBACTC,QAAQ;gBACRH,IAAIV;YACN;QACF;IACF;IAEA;;;;;GAKC,GACD,MAAgBc,cAAcL,KAAa,EAAE;QAC3C,0CAA0C;QAC1C,MAAM,IAAI,CAACM,cAAc;QAEzB,+DAA+D;QAC/DhB,gCAAO,IAAI,EAAEQ,iBAAe;QAE5B,MAAMS,SAAS,IAAId,uBAAuB;YACxCc,MAAM,2BAAE,IAAI,EAAET;YACdE;QACF;QAEA,OAAO;YAAEQ,QAAQR;YAAOO;QAAO;IACjC;IAEA;;;;GAIC,GACD,MAAcD,iBAAiB;QAC7B,wCAAwC;QACxC,IAAIG,SAASC,cAAc,CAAChB,iBAAiB;YAC3C;QACF;QAEA,MAAMiB,SAAS,MAAMtB,aACnB,yBAAA,IAAI,EAAEuB,cAAYC,IAAI,EACtBnB,gBACA;uCAGII,gBAAgB,IAAIV,wBAAwB;YAChD0B,MAAM;YACNC,QAAQ;YACRC,cAAcL;YACdM,cAAc;QAChB;IACF;IAvFA;;;;;;;;;;GAUC,GACDC,YAAY,EACVN,WAAW,EACXO,SAAS,EACTC,iBAAiB,EACwB,CAAE;QAC3C,KAAK,CAAC;YACJD;YACAC;QACF;QAvBF,gCAAA;;mBAAA,KAAA;;QAEA,gCAAA;;mBAAA,KAAA;;uCAuBQR,cAAcA;IACtB;AAkEF"}

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

@@ -0,0 +1,3 @@
+export * from './WebWorkerExecutionService';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/services/webworker/index.ts"],"sourcesContent":["export * from './WebWorkerExecutionService';\n"],"names":[],"mappings":"AAAA,cAAc,8BAA8B"}

package/dist/esm/snaps/RequestQueue.js

@@ -0,0 +1,53 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+export class RequestQueue {
+    /**
+   * Increments the queue count for a particular origin.
+   *
+   * @param origin - A string identifying the origin.
+   */ increment(origin) {
+        const currentCount = this.queueSizes.get(origin) ?? 0;
+        if (currentCount >= this.maxQueueSize) {
+            throw new Error('Maximum number of requests reached. Try again later.');
+        }
+        this.queueSizes.set(origin, currentCount + 1);
+    }
+    /**
+   * Decrements the queue count for a particular origin.
+   *
+   * @param origin - A string identifying the origin.
+   */ decrement(origin) {
+        const currentCount = this.queueSizes.get(origin) ?? 0;
+        if (currentCount === 0) {
+            throw new Error(`Cannot decrement, ${origin} does not have any outstanding requests.`);
+        }
+        this.queueSizes.set(origin, currentCount - 1);
+    }
+    /**
+   * Gets the queue count for a particular origin.
+   *
+   * @param origin - A string identifying the origin.
+   * @returns The queue count for the origin.
+   */ get(origin) {
+        return this.queueSizes.get(origin) ?? 0;
+    }
+    constructor(maxQueueSize){
+        _define_property(this, "maxQueueSize", void 0);
+        _define_property(this, "queueSizes", void 0);
+        this.maxQueueSize = maxQueueSize;
+        this.queueSizes = new Map();
+    }
+}
+
+//# sourceMappingURL=RequestQueue.js.map

package/dist/esm/snaps/RequestQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/snaps/RequestQueue.ts"],"sourcesContent":["export class RequestQueue {\n  public readonly maxQueueSize: number;\n\n  private readonly queueSizes: Map<string, number>;\n\n  constructor(maxQueueSize: number) {\n    this.maxQueueSize = maxQueueSize;\n    this.queueSizes = new Map<string, number>();\n  }\n\n  /**\n   * Increments the queue count for a particular origin.\n   *\n   * @param origin - A string identifying the origin.\n   */\n  public increment(origin: string) {\n    const currentCount = this.queueSizes.get(origin) ?? 0;\n    if (currentCount >= this.maxQueueSize) {\n      throw new Error('Maximum number of requests reached. Try again later.');\n    }\n    this.queueSizes.set(origin, currentCount + 1);\n  }\n\n  /**\n   * Decrements the queue count for a particular origin.\n   *\n   * @param origin - A string identifying the origin.\n   */\n  public decrement(origin: string) {\n    const currentCount = this.queueSizes.get(origin) ?? 0;\n    if (currentCount === 0) {\n      throw new Error(\n        `Cannot decrement, ${origin} does not have any outstanding requests.`,\n      );\n    }\n    this.queueSizes.set(origin, currentCount - 1);\n  }\n\n  /**\n   * Gets the queue count for a particular origin.\n   *\n   * @param origin - A string identifying the origin.\n   * @returns The queue count for the origin.\n   */\n  public get(origin: string): number {\n    return this.queueSizes.get(origin) ?? 0;\n  }\n}\n"],"names":["RequestQueue","increment","origin","currentCount","queueSizes","get","maxQueueSize","Error","set","decrement","constructor","Map"],"mappings":";;;;;;;;;;;;;AAAA,OAAO,MAAMA;IAUX;;;;GAIC,GACD,AAAOC,UAAUC,MAAc,EAAE;QAC/B,MAAMC,eAAe,IAAI,CAACC,UAAU,CAACC,GAAG,CAACH,WAAW;QACpD,IAAIC,gBAAgB,IAAI,CAACG,YAAY,EAAE;YACrC,MAAM,IAAIC,MAAM;QAClB;QACA,IAAI,CAACH,UAAU,CAACI,GAAG,CAACN,QAAQC,eAAe;IAC7C;IAEA;;;;GAIC,GACD,AAAOM,UAAUP,MAAc,EAAE;QAC/B,MAAMC,eAAe,IAAI,CAACC,UAAU,CAACC,GAAG,CAACH,WAAW;QACpD,IAAIC,iBAAiB,GAAG;YACtB,MAAM,IAAII,MACR,CAAC,kBAAkB,EAAEL,OAAO,wCAAwC,CAAC;QAEzE;QACA,IAAI,CAACE,UAAU,CAACI,GAAG,CAACN,QAAQC,eAAe;IAC7C;IAEA;;;;;GAKC,GACD,AAAOE,IAAIH,MAAc,EAAU;QACjC,OAAO,IAAI,CAACE,UAAU,CAACC,GAAG,CAACH,WAAW;IACxC;IAzCAQ,YAAYJ,YAAoB,CAAE;QAJlC,uBAAgBA,gBAAhB,KAAA;QAEA,uBAAiBF,cAAjB,KAAA;QAGE,IAAI,CAACE,YAAY,GAAGA;QACpB,IAAI,CAACF,UAAU,GAAG,IAAIO;IACxB;AAuCF"}