diff --git a/eslint-warning-thresholds.json b/eslint-warning-thresholds.json
index 92cc78a3f77..58fa581cf06 100644
--- a/eslint-warning-thresholds.json
+++ b/eslint-warning-thresholds.json
@@ -3,23 +3,24 @@
   "@typescript-eslint/no-base-to-string": 3,
   "@typescript-eslint/no-duplicate-enum-values": 2,
   "@typescript-eslint/no-unsafe-enum-comparison": 34,
-  "@typescript-eslint/no-unused-vars": 36,
-  "@typescript-eslint/prefer-promise-reject-errors": 13,
-  "@typescript-eslint/prefer-readonly": 145,
+  "@typescript-eslint/no-unused-vars": 41,
+  "@typescript-eslint/prefer-promise-reject-errors": 33,
+  "@typescript-eslint/prefer-readonly": 147,
+  "@typescript-eslint/switch-exhaustiveness-check": 0,
   "import-x/namespace": 189,
   "import-x/no-named-as-default": 1,
   "import-x/no-named-as-default-member": 8,
-  "import-x/order": 205,
-  "jest/no-conditional-in-test": 129,
+  "import-x/order": 211,
+  "jest/no-conditional-in-test": 138,
   "jest/prefer-lowercase-title": 2,
   "jest/prefer-strict-equal": 2,
   "jsdoc/check-tag-names": 375,
-  "jsdoc/require-returns": 22,
-  "jsdoc/tag-lines": 328,
+  "jsdoc/require-returns": 25,
+  "jsdoc/tag-lines": 335,
   "n/no-unsupported-features/node-builtins": 18,
   "n/prefer-global/text-encoder": 4,
   "n/prefer-global/text-decoder": 4,
-  "prettier/prettier": 115,
+  "prettier/prettier": 118,
   "promise/always-return": 3,
   "promise/catch-or-return": 2,
   "promise/param-names": 8,
diff --git a/packages/multichain/package.json b/packages/multichain/package.json
index a1dedd8ee86..82ba5fb4a73 100644
--- a/packages/multichain/package.json
+++ b/packages/multichain/package.json
@@ -51,13 +51,18 @@
     "@metamask/controller-utils": "^11.4.5",
     "@metamask/eth-json-rpc-filters": "^9.0.0",
     "@metamask/rpc-errors": "^7.0.2",
+    "@metamask/safe-event-emitter": "^3.0.0",
     "@metamask/utils": "^11.0.1",
+    "@open-rpc/schema-utils-js": "^2.0.5",
+    "jsonschema": "^1.4.1",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
     "@metamask/auto-changelog": "^3.4.4",
+    "@metamask/json-rpc-engine": "^10.0.2",
     "@metamask/network-controller": "^22.1.1",
     "@metamask/permission-controller": "^11.0.5",
+    "@open-rpc/meta-schema": "^1.14.6",
     "@types/jest": "^27.4.1",
     "deepmerge": "^4.2.2",
     "jest": "^27.5.1",
diff --git a/packages/multichain/src/adapters/caip-permission-adapter-permittedChains.ts b/packages/multichain/src/adapters/caip-permission-adapter-permittedChains.ts
index f56ff36137a..a2dfffa7369 100644
--- a/packages/multichain/src/adapters/caip-permission-adapter-permittedChains.ts
+++ b/packages/multichain/src/adapters/caip-permission-adapter-permittedChains.ts
@@ -1,6 +1,6 @@
 import { toHex } from '@metamask/controller-utils';
 import type { Hex } from '@metamask/utils';
-import { KnownCaipNamespace } from '@metamask/utils';
+import { hexToBigInt, KnownCaipNamespace } from '@metamask/utils';
 
 import type { Caip25CaveatValue } from '../caip25Permission';
 import { getUniqueArrayItems } from '../scope/transform';
@@ -57,7 +57,7 @@ export const addPermittedEthChainId = (
   caip25CaveatValue: Caip25CaveatValue,
   chainId: Hex,
 ): Caip25CaveatValue => {
-  const scopeString = `eip155:${parseInt(chainId, 16)}`;
+  const scopeString = `eip155:${hexToBigInt(chainId).toString(10)}`;
   if (
     Object.keys(caip25CaveatValue.requiredScopes).includes(scopeString) ||
     Object.keys(caip25CaveatValue.optionalScopes).includes(scopeString)
diff --git a/packages/multichain/src/adapters/caip-permission-adapter-session-scopes.test.ts b/packages/multichain/src/adapters/caip-permission-adapter-session-scopes.test.ts
new file mode 100644
index 00000000000..62b183f5185
--- /dev/null
+++ b/packages/multichain/src/adapters/caip-permission-adapter-session-scopes.test.ts
@@ -0,0 +1,135 @@
+import {
+  KnownNotifications,
+  KnownRpcMethods,
+  KnownWalletNamespaceRpcMethods,
+  KnownWalletRpcMethods,
+} from '../scope/constants';
+import {
+  getInternalScopesObject,
+  getSessionScopes,
+} from './caip-permission-adapter-session-scopes';
+
+describe('CAIP-25 session scopes adapters', () => {
+  describe('getInternalScopesObject', () => {
+    it('returns an InternalScopesObject with only the accounts from each NormalizedScopeObject', () => {
+      const result = getInternalScopesObject({
+        'wallet:eip155': {
+          methods: ['foo', 'bar'],
+          notifications: ['baz'],
+          accounts: ['wallet:eip155:0xdead'],
+        },
+        'eip155:1': {
+          methods: ['eth_call'],
+          notifications: ['eth_subscription'],
+          accounts: ['eip155:1:0xdead', 'eip155:1:0xbeef'],
+        },
+      });
+
+      expect(result).toStrictEqual({
+        'wallet:eip155': {
+          accounts: ['wallet:eip155:0xdead'],
+        },
+        'eip155:1': {
+          accounts: ['eip155:1:0xdead', 'eip155:1:0xbeef'],
+        },
+      });
+    });
+  });
+
+  describe('getSessionScopes', () => {
+    it('returns a NormalizedScopesObject for the wallet scope', () => {
+      const result = getSessionScopes({
+        requiredScopes: {},
+        optionalScopes: {
+          wallet: {
+            accounts: [],
+          },
+        },
+      });
+
+      expect(result).toStrictEqual({
+        wallet: {
+          methods: KnownWalletRpcMethods,
+          notifications: [],
+          accounts: [],
+        },
+      });
+    });
+
+    it('returns a NormalizedScopesObject for the wallet:eip155 scope', () => {
+      const result = getSessionScopes({
+        requiredScopes: {},
+        optionalScopes: {
+          'wallet:eip155': {
+            accounts: ['wallet:eip155:0xdeadbeef'],
+          },
+        },
+      });
+
+      expect(result).toStrictEqual({
+        'wallet:eip155': {
+          methods: KnownWalletNamespaceRpcMethods.eip155,
+          notifications: [],
+          accounts: ['wallet:eip155:0xdeadbeef'],
+        },
+      });
+    });
+
+    it('returns a NormalizedScopesObject with empty methods and notifications for scope with wallet namespace and unknown reference', () => {
+      const result = getSessionScopes({
+        requiredScopes: {},
+        optionalScopes: {
+          'wallet:foobar': {
+            accounts: ['wallet:foobar:0xdeadbeef'],
+          },
+        },
+      });
+
+      expect(result).toStrictEqual({
+        'wallet:foobar': {
+          methods: [],
+          notifications: [],
+          accounts: ['wallet:foobar:0xdeadbeef'],
+        },
+      });
+    });
+
+    it('returns a NormalizedScopesObject with empty methods and notifications for scope not wallet namespace and unknown reference', () => {
+      const result = getSessionScopes({
+        requiredScopes: {},
+        optionalScopes: {
+          'foo:1': {
+            accounts: ['foo:1:0xdeadbeef'],
+          },
+        },
+      });
+
+      expect(result).toStrictEqual({
+        'foo:1': {
+          methods: [],
+          notifications: [],
+          accounts: ['foo:1:0xdeadbeef'],
+        },
+      });
+    });
+
+    it('returns a NormalizedScopesObject for a eip155 namespaced scope', () => {
+      const result = getSessionScopes({
+        requiredScopes: {},
+        optionalScopes: {
+          'eip155:1': {
+            accounts: ['eip155:1:0xdeadbeef'],
+          },
+        },
+      });
+
+      expect(result).toStrictEqual({
+        'eip155:1': {
+          methods: KnownRpcMethods.eip155,
+          notifications: KnownNotifications.eip155,
+          accounts: ['eip155:1:0xdeadbeef'],
+        },
+      });
+    });
+  });
+});
diff --git a/packages/multichain/src/adapters/caip-permission-adapter-session-scopes.ts b/packages/multichain/src/adapters/caip-permission-adapter-session-scopes.ts
new file mode 100644
index 00000000000..7e05eb01ad3
--- /dev/null
+++ b/packages/multichain/src/adapters/caip-permission-adapter-session-scopes.ts
@@ -0,0 +1,101 @@
+import { KnownCaipNamespace } from '@metamask/utils';
+
+import type { Caip25CaveatValue } from '../caip25Permission';
+import {
+  KnownNotifications,
+  KnownRpcMethods,
+  KnownWalletNamespaceRpcMethods,
+  KnownWalletRpcMethods,
+} from '../scope/constants';
+import { mergeScopes } from '../scope/transform';
+import type {
+  InternalScopesObject,
+  NonWalletKnownCaipNamespace,
+  NormalizedScopesObject,
+} from '../scope/types';
+import { parseScopeString } from '../scope/types';
+
+/**
+ * Converts an NormalizedScopesObject to a InternalScopesObject.
+ * @param normalizedScopesObject - The NormalizedScopesObject to convert.
+ * @returns An InternalScopesObject.
+ */
+export const getInternalScopesObject = (
+  normalizedScopesObject: NormalizedScopesObject,
+) => {
+  const internalScopes: InternalScopesObject = {};
+
+  Object.entries(normalizedScopesObject).forEach(
+    ([_scopeString, { accounts }]) => {
+      const scopeString = _scopeString as keyof typeof normalizedScopesObject;
+
+      internalScopes[scopeString] = {
+        accounts,
+      };
+    },
+  );
+
+  return internalScopes;
+};
+
+/**
+ * Converts an InternalScopesObject to a NormalizedScopesObject.
+ * @param internalScopesObject - The InternalScopesObject to convert.
+ * @returns A NormalizedScopesObject.
+ */
+const getNormalizedScopesObject = (
+  internalScopesObject: InternalScopesObject,
+) => {
+  const normalizedScopes: NormalizedScopesObject = {};
+
+  Object.entries(internalScopesObject).forEach(
+    ([_scopeString, { accounts }]) => {
+      const scopeString = _scopeString as keyof typeof internalScopesObject;
+      const { namespace, reference } = parseScopeString(scopeString);
+      let methods: string[] = [];
+      let notifications: string[] = [];
+
+      if (namespace === KnownCaipNamespace.Wallet) {
+        if (reference) {
+          methods =
+            KnownWalletNamespaceRpcMethods[
+              reference as NonWalletKnownCaipNamespace
+            ] ?? [];
+        } else {
+          methods = KnownWalletRpcMethods;
+        }
+      } else {
+        methods =
+          KnownRpcMethods[namespace as NonWalletKnownCaipNamespace] ?? [];
+        notifications =
+          KnownNotifications[namespace as NonWalletKnownCaipNamespace] ?? [];
+      }
+
+      normalizedScopes[scopeString] = {
+        methods,
+        notifications,
+        accounts,
+      };
+    },
+  );
+
+  return normalizedScopes;
+};
+
+/**
+ * Takes the scopes from an endowment:caip25 permission caveat value,
+ * hydrates them with supported methods and notifications, and returns a NormalizedScopesObject.
+ * @param caip25CaveatValue - The CAIP-25 CaveatValue to convert.
+ * @returns A NormalizedScopesObject.
+ */
+export const getSessionScopes = (
+  caip25CaveatValue: Pick<
+    Caip25CaveatValue,
+    'requiredScopes' | 'optionalScopes'
+  >,
+) => {
+  return mergeScopes(
+    getNormalizedScopesObject(caip25CaveatValue.requiredScopes),
+    getNormalizedScopesObject(caip25CaveatValue.optionalScopes),
+  );
+};
diff --git a/packages/multichain/src/handlers/wallet-getSession.test.ts b/packages/multichain/src/handlers/wallet-getSession.test.ts
new file mode 100644
index 00000000000..206f706eb0f
--- /dev/null
+++ b/packages/multichain/src/handlers/wallet-getSession.test.ts
@@ -0,0 +1,160 @@
+import type { JsonRpcRequest } from '@metamask/utils';
+
+import * as PermissionAdapterSessionScopes from '../adapters/caip-permission-adapter-session-scopes';
+import {
+  Caip25CaveatType,
+  Caip25EndowmentPermissionName,
+} from '../caip25Permission';
+import { walletGetSession } from './wallet-getSession';
+
+jest.mock('../adapters/caip-permission-adapter-session-scopes', () => ({
+  getSessionScopes: jest.fn(),
+}));
+const MockPermissionAdapterSessionScopes = jest.mocked(
+  PermissionAdapterSessionScopes,
+);
+
+const baseRequest: JsonRpcRequest & { origin: string } = {
+  origin: 'http://test.com',
+  jsonrpc: '2.0' as const,
+  method: 'wallet_getSession',
+  params: {},
+  id: 1,
+};
+
+const createMockedHandler = () => {
+  const next = jest.fn();
+  const end = jest.fn();
+  const getCaveatForOrigin = jest.fn().mockReturnValue({
+    value: {
+      requiredScopes: {
+        'eip155:1': {
+          accounts: [],
+        },
+        'eip155:5': {
+          accounts: [],
+        },
+      },
+      optionalScopes: {
+        'eip155:1': {
+          accounts: [],
+        },
+        wallet: {
+          accounts: [],
+        },
+      },
+    },
+  });
+  const response = {
+    result: {
+      sessionScopes: {},
+    },
+    id: 1,
+    jsonrpc: '2.0' as const,
+  };
+  const handler = (request: JsonRpcRequest & { origin: string }) =>
+    walletGetSession.implementation(request, response, next, end, {
+      getCaveatForOrigin,
+    });
+
+  return {
+    next,
+    response,
+    end,
+    getCaveatForOrigin,
+    handler,
+  };
+};
+
+describe('wallet_getSession', () => {
+  it('gets the authorized scopes from the CAIP-25 endowment permission', async () => {
+    const { handler, getCaveatForOrigin } = createMockedHandler();
+
+    await handler(baseRequest);
+    expect(getCaveatForOrigin).toHaveBeenCalledWith(
+      Caip25EndowmentPermissionName,
+      Caip25CaveatType,
+    );
+  });
+
+  it('returns empty scopes if the CAIP-25 endowment permission does not exist', async () => {
+    const { handler, response, getCaveatForOrigin } = createMockedHandler();
+    getCaveatForOrigin.mockImplementation(() => {
+      throw new Error('permission not found');
+    });
+
+    await handler(baseRequest);
+    expect(response.result).toStrictEqual({
+      sessionScopes: {},
+    });
+  });
+
+  it('gets the session scopes from the CAIP-25 caveat value', async () => {
+    const { handler } = createMockedHandler();
+
+    await handler(baseRequest);
+    expect(
+      MockPermissionAdapterSessionScopes.getSessionScopes,
+    ).toHaveBeenCalledWith({
+      requiredScopes: {
+        'eip155:1': {
+          accounts: [],
+        },
+        'eip155:5': {
+          accounts: [],
+        },
+      },
+      optionalScopes: {
+        'eip155:1': {
+          accounts: [],
+        },
+        wallet: {
+          accounts: [],
+        },
+      },
+    });
+  });
+
+  it('returns the session scopes', async () => {
+    const { handler, response } = createMockedHandler();
+
+    MockPermissionAdapterSessionScopes.getSessionScopes.mockReturnValue({
+      'eip155:1': {
+        methods: ['eth_call', 'net_version'],
+        notifications: ['chainChanged'],
+        accounts: [],
+      },
+      'eip155:5': {
+        methods: ['eth_chainId'],
+        notifications: [],
+        accounts: [],
+      },
+      wallet: {
+        methods: ['wallet_watchAsset'],
+        notifications: [],
+        accounts: [],
+      },
+    });
+
+    await handler(baseRequest);
+    expect(response.result).toStrictEqual({
+      sessionScopes: {
+        'eip155:1': {
+          methods: ['eth_call', 'net_version'],
+          notifications: ['chainChanged'],
+          accounts: [],
+        },
+        'eip155:5': {
+          methods: ['eth_chainId'],
+          notifications: [],
+          accounts: [],
+        },
+        wallet: {
+          methods: ['wallet_watchAsset'],
+          notifications: [],
+          accounts: [],
+        },
+      },
+    });
+  });
+});
diff --git a/packages/multichain/src/handlers/wallet-getSession.ts b/packages/multichain/src/handlers/wallet-getSession.ts
new file mode 100644
index 00000000000..bf343495091
--- /dev/null
+++ b/packages/multichain/src/handlers/wallet-getSession.ts
@@ -0,0 +1,64 @@
+import type { Caveat } from '@metamask/permission-controller';
+import type { JsonRpcRequest, JsonRpcSuccess } from '@metamask/utils';
+import type { NormalizedScopesObject } from 'src/scope/types';
+
+import { getSessionScopes } from '../adapters/caip-permission-adapter-session-scopes';
+import type { Caip25CaveatValue } from '../caip25Permission';
+import {
+  Caip25CaveatType,
+  Caip25EndowmentPermissionName,
+} from '../caip25Permission';
+
+/**
+ * Handler for the `wallet_getSession` RPC method as specified by [CAIP-312](https://chainagnostic.org/CAIPs/caip-312).
+ * The implementation below deviates from the linked spec in that it ignores the `sessionId` param entirely,
+ * and that an empty object is returned for the `sessionScopes` result rather than throwing an error if there
+ * is no active session for the origin.
+ *
+ * @param request - The request object.
+ * @param response - The response object.
+ * @param _next - The next middleware function. Unused.
+ * @param end - The end function.
+ * @param hooks - The hooks object.
+ * @param hooks.getCaveatForOrigin - Function to retrieve a caveat for the origin.
+ */
+async function walletGetSessionHandler(
+  request: JsonRpcRequest & { origin: string },
+  response: JsonRpcSuccess<{ sessionScopes: NormalizedScopesObject }>,
+  _next: () => void,
+  end: () => void,
+  hooks: {
+    getCaveatForOrigin: (
+      endowmentPermissionName: string,
+      caveatType: string,
+    ) => Caveat<typeof Caip25CaveatType, Caip25CaveatValue>;
+  },
+) {
+  let caveat;
+  try {
+    caveat = hooks.getCaveatForOrigin(
+      Caip25EndowmentPermissionName,
+      Caip25CaveatType,
+    );
+  } catch (e) {
+    // noop
+  }
+
+  if (!caveat) {
+    response.result = { sessionScopes: {} };
+    return end();
+  }
+
+  response.result = {
+    sessionScopes: getSessionScopes(caveat.value),
+  };
+  return end();
+}
+
+export const walletGetSession = {
+  methodNames: ['wallet_getSession'],
+  implementation: walletGetSessionHandler,
+  hookNames: {
+    getCaveatForOrigin: true,
+  },
+};
diff --git a/packages/multichain/src/handlers/wallet-invokeMethod.test.ts b/packages/multichain/src/handlers/wallet-invokeMethod.test.ts
new file mode 100644
index 00000000000..ae7da846565
--- /dev/null
+++ b/packages/multichain/src/handlers/wallet-invokeMethod.test.ts
@@ -0,0 +1,328 @@
+import { providerErrors, rpcErrors } from '@metamask/rpc-errors';
+
+import * as PermissionAdapterSessionScopes from '../adapters/caip-permission-adapter-session-scopes';
+import {
+  Caip25CaveatType,
+  Caip25EndowmentPermissionName,
+} from '../caip25Permission';
+import type { WalletInvokeMethodRequest } from './wallet-invokeMethod';
+import { walletInvokeMethod } from './wallet-invokeMethod';
+
+jest.mock('../adapters/caip-permission-adapter-session-scopes', () => ({
+  getSessionScopes: jest.fn(),
+}));
+const MockPermissionAdapterSessionScopes = jest.mocked(
+  PermissionAdapterSessionScopes,
+);
+
+const createMockedRequest = () => ({
+  jsonrpc: '2.0' as const,
+  id: 0,
+  origin: 'http://test.com',
+  method: 'wallet_invokeMethod',
+  params: {
+    scope: 'eip155:1',
+    request: {
+      method: 'eth_call',
+      params: {
+        foo: 'bar',
+      },
+    },
+  },
+});
+
+const createMockedHandler = () => {
+  const next = jest.fn();
+  const end = jest.fn();
+  const getCaveatForOrigin = jest.fn().mockReturnValue({
+    value: {
+      requiredScopes: {
+        'eip155:1': {
+          accounts: [],
+        },
+        'eip155:5': {
+          accounts: [],
+        },
+      },
+      optionalScopes: {
+        'eip155:1': {
+          accounts: [],
+        },
+        wallet: {
+          accounts: [],
+        },
+      },
+      isMultichainOrigin: true,
+    },
+  });
+  const findNetworkClientIdByChainId = jest.fn().mockReturnValue('mainnet');
+  const getSelectedNetworkClientId = jest
+    .fn()
+    .mockReturnValue('selectedNetworkClientId');
+  const handler = (request: WalletInvokeMethodRequest) =>
+    walletInvokeMethod.implementation(
+      request,
+      { jsonrpc: '2.0', id: 1 },
+      next,
+      end,
+      {
+        getCaveatForOrigin,
+        findNetworkClientIdByChainId,
+        getSelectedNetworkClientId,
+      },
+    );
+
+  return {
+    next,
+    end,
+    getCaveatForOrigin,
+    findNetworkClientIdByChainId,
+    getSelectedNetworkClientId,
+    handler,
+  };
+};
+
+describe('wallet_invokeMethod', () => {
+  beforeEach(() => {
+    MockPermissionAdapterSessionScopes.getSessionScopes.mockReturnValue({
+      'eip155:1': {
+        methods: ['eth_call', 'net_version'],
+        notifications: [],
+        accounts: [],
+      },
+      'eip155:5': {
+        methods: ['eth_chainId'],
+        notifications: [],
+        accounts: [],
+      },
+      wallet: {
+        methods: ['wallet_watchAsset'],
+        notifications: [],
+        accounts: [],
+      },
+      'unknown:scope': {
+        methods: ['foobar'],
+        notifications: [],
+        accounts: [],
+      },
+    });
+  });
+
+  it('gets the authorized scopes from the CAIP-25 endowment permission', async () => {
+    const request = createMockedRequest();
+    const { handler, getCaveatForOrigin } = createMockedHandler();
+    await handler(request);
+    expect(getCaveatForOrigin).toHaveBeenCalledWith(
+      Caip25EndowmentPermissionName,
+      Caip25CaveatType,
+    );
+  });
+
+  it('gets the session scopes from the CAIP-25 caveat value', async () => {
+    const request = createMockedRequest();
+    const { handler } = createMockedHandler();
+    await handler(request);
+    expect(
+      MockPermissionAdapterSessionScopes.getSessionScopes,
+    ).toHaveBeenCalledWith({
+      requiredScopes: {
+        'eip155:1': {
+          accounts: [],
+        },
+        'eip155:5': {
+          accounts: [],
+        },
+      },
+      optionalScopes: {
+        'eip155:1': {
+          accounts: [],
+        },
+        wallet: {
+          accounts: [],
+        },
+      },
+      isMultichainOrigin: true,
+    });
+  });
+
+  it('throws an unauthorized error when there is no CAIP-25 endowment permission', async () => {
+    const request = createMockedRequest();
+    const { handler, getCaveatForOrigin, end } = createMockedHandler();
+    getCaveatForOrigin.mockImplementation(() => {
+      throw new Error('permission not found');
+    });
+    await handler(request);
+    expect(end).toHaveBeenCalledWith(providerErrors.unauthorized());
+  });
+
+  it('throws an unauthorized error when the CAIP-25 endowment permission was not granted from the multichain flow', async () => {
+    const request = createMockedRequest();
+    const { handler, getCaveatForOrigin, end } = createMockedHandler();
+    getCaveatForOrigin.mockReturnValue({
+      value: {
+        isMultichainOrigin: false,
+      },
+    });
+    await handler(request);
+    expect(end).toHaveBeenCalledWith(providerErrors.unauthorized());
+  });
+
+  it('throws an unauthorized error if the requested scope is not authorized', async () => {
+    const request = createMockedRequest();
+    const { handler, end } = createMockedHandler();
+
+    await handler({
+      ...request,
+      params: {
+        ...request.params,
+        scope: 'eip155:999',
+      },
+    });
+    expect(end).toHaveBeenCalledWith(providerErrors.unauthorized());
+  });
+
+  it('throws an unauthorized error if the requested scope method is not authorized', async () => {
+    const request = createMockedRequest();
+    const { handler, end } = createMockedHandler();
+
+    await handler({
+      ...request,
+      params: {
+        ...request.params,
+        request: {
+          ...request.params.request,
+          method: 'unauthorized_method',
+        },
+      },
+    });
+    expect(end).toHaveBeenCalledWith(providerErrors.unauthorized());
+  });
+
+  it('throws an internal error for authorized but unsupported scopes', async () => {
+    const request = createMockedRequest();
+    const { handler, end } = createMockedHandler();
+
+    await handler({
+      ...request,
+      params: {
+        ...request.params,
+        scope: 'unknown:scope',
+        request: {
+          ...request.params.request,
+          method: 'foobar',
+        },
+      },
+    });
+
+    expect(end).toHaveBeenCalledWith(rpcErrors.internal());
+  });
+
+  describe('ethereum scope', () => {
+    it('gets the networkClientId for the chainId', async () => {
+      const request = createMockedRequest();
+      const { handler, findNetworkClientIdByChainId } = createMockedHandler();
+
+      await handler(request);
+      expect(findNetworkClientIdByChainId).toHaveBeenCalledWith('0x1');
+    });
+
+    it('throws an internal error if a networkClientId does not exist for the chainId', async () => {
+      const request = createMockedRequest();
+      const { handler, findNetworkClientIdByChainId, end } =
+        createMockedHandler();
+      findNetworkClientIdByChainId.mockReturnValue(undefined);
+
+      await handler(request);
+      expect(end).toHaveBeenCalledWith(rpcErrors.internal());
+    });
+
+    it('sets the networkClientId and unwraps the CAIP-27 request', async () => {
+      const request = createMockedRequest();
+      const { handler, next } = createMockedHandler();
+
+      await handler(request);
+      expect(request).toStrictEqual({
+        jsonrpc: '2.0' as const,
+        id: 0,
+        scope: 'eip155:1',
+        origin: 'http://test.com',
+        networkClientId: 'mainnet',
+        method: 'eth_call',
+        params: {
+          foo: 'bar',
+        },
+      });
+      expect(next).toHaveBeenCalled();
+    });
+  });
+
+  describe('wallet scope', () => {
+    it('gets the networkClientId for the globally selected network', async () => {
+      const request = createMockedRequest();
+      const { handler, getSelectedNetworkClientId } = createMockedHandler();
+
+      await handler({
+        ...request,
+        params: {
+          ...request.params,
+          scope: 'wallet',
+          request: {
+            ...request.params.request,
+            method: 'wallet_watchAsset',
+          },
+        },
+      });
+      expect(getSelectedNetworkClientId).toHaveBeenCalled();
+    });
+
+    it('throws an internal error if a networkClientId cannot be retrieved for the globally selected network', async () => {
+      const request = createMockedRequest();
+      const { handler, getSelectedNetworkClientId, end } =
+        createMockedHandler();
+      getSelectedNetworkClientId.mockReturnValue(undefined);
+
+      await handler({
+        ...request,
+        params: {
+          ...request.params,
+          scope: 'wallet',
+          request: {
+            ...request.params.request,
+            method: 'wallet_watchAsset',
+          },
+        },
+      });
+      expect(end).toHaveBeenCalledWith(rpcErrors.internal());
+    });
+
+    it('sets the networkClientId and unwraps the CAIP-27 request', async () => {
+      const request = createMockedRequest();
+      const { handler, next } = createMockedHandler();
+
+      const walletRequest = {
+        ...request,
+        params: {
+          ...request.params,
+          scope: 'wallet',
+          request: {
+            ...request.params.request,
+            method: 'wallet_watchAsset',
+          },
+        },
+      };
+      await handler(walletRequest);
+      expect(walletRequest).toStrictEqual({
+        jsonrpc: '2.0' as const,
+        id: 0,
+        scope: 'wallet',
+        origin: 'http://test.com',
+        networkClientId: 'selectedNetworkClientId',
+        method: 'wallet_watchAsset',
+        params: {
+          foo: 'bar',
+        },
+      });
+      expect(next).toHaveBeenCalled();
+    });
+  });
+});
diff --git a/packages/multichain/src/handlers/wallet-invokeMethod.ts b/packages/multichain/src/handlers/wallet-invokeMethod.ts
new file mode 100644
index 00000000000..cc2e8cf0b03
--- /dev/null
+++ b/packages/multichain/src/handlers/wallet-invokeMethod.ts
@@ -0,0 +1,127 @@
+import type { NetworkClientId } from '@metamask/network-controller';
+import type { Caveat } from '@metamask/permission-controller';
+import { providerErrors, rpcErrors } from '@metamask/rpc-errors';
+import type {
+  Hex,
+  Json,
+  JsonRpcRequest,
+  PendingJsonRpcResponse,
+} from '@metamask/utils';
+import { numberToHex } from '@metamask/utils';
+
+import { getSessionScopes } from '../adapters/caip-permission-adapter-session-scopes';
+import type { Caip25CaveatValue } from '../caip25Permission';
+import {
+  Caip25CaveatType,
+  Caip25EndowmentPermissionName,
+} from '../caip25Permission';
+import { assertIsInternalScopeString } from '../scope/assert';
+import type { ExternalScopeString } from '../scope/types';
+import { parseScopeString } from '../scope/types';
+
+export type WalletInvokeMethodRequest = JsonRpcRequest & {
+  origin: string;
+  params: {
+    scope: ExternalScopeString;
+    request: Pick<JsonRpcRequest, 'method' | 'params'>;
+  };
+};
+
+/**
+ * Handler for the `wallet_invokeMethod` RPC method as specified by [CAIP-27](https://chainagnostic.org/CAIPs/caip-27).
+ * The implementation below deviates from the linked spec in that it ignores the `sessionId` param
+ * and instead uses the singular session for the origin if available.
+ *
+ * @param request - The request object.
+ * @param _response - The response object. Unused.
+ * @param next - The next middleware function.
+ * @param end - The end function.
+ * @param hooks - The hooks object.
+ * @param hooks.getCaveatForOrigin - the hook for getting a caveat from a permission for an origin.
+ * @param hooks.findNetworkClientIdByChainId - the hook for finding the networkClientId for a chainId.
+ * @param hooks.getSelectedNetworkClientId - the hook for getting the current globally selected networkClientId.
+ */
+async function walletInvokeMethodHandler(
+  request: WalletInvokeMethodRequest,
+  _response: PendingJsonRpcResponse<Json>,
+  next: () => void,
+  end: (error: Error) => void,
+  hooks: {
+    getCaveatForOrigin: (
+      endowmentPermissionName: string,
+      caveatType: string,
+    ) => Caveat<typeof Caip25CaveatType, Caip25CaveatValue>;
+    findNetworkClientIdByChainId: (chainId: Hex) => NetworkClientId | undefined;
+    getSelectedNetworkClientId: () => NetworkClientId;
+  },
+) {
+  const { scope, request: wrappedRequest } = request.params;
+
+  assertIsInternalScopeString(scope);
+
+  let caveat;
+  try {
+    caveat = hooks.getCaveatForOrigin(
+      Caip25EndowmentPermissionName,
+      Caip25CaveatType,
+    );
+  } catch (e) {
+    // noop
+  }
+  if (!caveat?.value?.isMultichainOrigin) {
+    return end(providerErrors.unauthorized());
+  }
+
+  const scopeObject = getSessionScopes(caveat.value)[scope];
+
+  if (!scopeObject?.methods?.includes(wrappedRequest.method)) {
+    return end(providerErrors.unauthorized());
+  }
+
+  const { namespace, reference } = parseScopeString(scope);
+
+  let networkClientId;
+  switch (namespace) {
+    case 'wallet':
+      networkClientId = hooks.getSelectedNetworkClientId();
+      break;
+    case 'eip155':
+      if (reference) {
+        networkClientId = hooks.findNetworkClientIdByChainId(
+          numberToHex(parseInt(reference, 10)),
+        );
+      }
+      break;
+    default:
+      console.error(
+        'failed to resolve namespace for wallet_invokeMethod',
+        request,
+      );
+      return end(rpcErrors.internal());
+  }
+
+  if (!networkClientId) {
+    console.error(
+      'failed to resolve network client for wallet_invokeMethod',
+      request,
+    );
+    return end(rpcErrors.internal());
+  }
+
+  Object.assign(request, {
+    scope,
+    networkClientId,
+    method: wrappedRequest.method,
+    params: wrappedRequest.params,
+  });
+  return next();
+}
+export const walletInvokeMethod = {
+  methodNames: ['wallet_invokeMethod'],
+  implementation: walletInvokeMethodHandler,
+  hookNames: {
+    getCaveatForOrigin: true,
+    findNetworkClientIdByChainId: true,
+    getSelectedNetworkClientId: true,
+  },
+};
diff --git a/packages/multichain/src/handlers/wallet-revokeSession.test.ts b/packages/multichain/src/handlers/wallet-revokeSession.test.ts
new file mode 100644
index 00000000000..c74c95a1f7c
--- /dev/null
+++ b/packages/multichain/src/handlers/wallet-revokeSession.test.ts
@@ -0,0 +1,91 @@
+import {
+  PermissionDoesNotExistError,
+  UnrecognizedSubjectError,
+} from '@metamask/permission-controller';
+import { rpcErrors } from '@metamask/rpc-errors';
+import type { JsonRpcRequest } from '@metamask/utils';
+
+import { Caip25EndowmentPermissionName } from '../caip25Permission';
+import { walletRevokeSession } from './wallet-revokeSession';
+
+const baseRequest: JsonRpcRequest & { origin: string } = {
+  origin: 'http://test.com',
+  params: {},
+  jsonrpc: '2.0' as const,
+  id: 1,
+  method: 'wallet_revokeSession',
+};
+
+const createMockedHandler = () => {
+  const next = jest.fn();
+  const end = jest.fn();
+  const revokePermissionForOrigin = jest.fn();
+  const response = {
+    result: true,
+    id: 1,
+    jsonrpc: '2.0' as const,
+  };
+  const handler = (request: JsonRpcRequest & { origin: string }) =>
+    walletRevokeSession.implementation(request, response, next, end, {
+      revokePermissionForOrigin,
+    });
+
+  return {
+    next,
+    response,
+    end,
+    revokePermissionForOrigin,
+    handler,
+  };
+};
+
+describe('wallet_revokeSession', () => {
+  it('revokes the the CAIP-25 endowment permission', async () => {
+    const { handler, revokePermissionForOrigin } = createMockedHandler();
+
+    await handler(baseRequest);
+    expect(revokePermissionForOrigin).toHaveBeenCalledWith(
+      Caip25EndowmentPermissionName,
+    );
+  });
+
+  it('returns true if the CAIP-25 endowment permission does not exist', async () => {
+    const { handler, response, revokePermissionForOrigin } = createMockedHandler();
+    revokePermissionForOrigin.mockImplementation(() => {
+      throw new PermissionDoesNotExistError(
+        'foo.com',
+        Caip25EndowmentPermissionName,
+      );
+    });
+
+    await handler(baseRequest);
+    expect(response.result).toBe(true);
+  });
+
+  it('returns true if the subject does not exist', async () => {
+    const { handler, response, revokePermissionForOrigin } = createMockedHandler();
+    revokePermissionForOrigin.mockImplementation(() => {
+      throw new UnrecognizedSubjectError('foo.com');
+    });
+
+    await handler(baseRequest);
+    expect(response.result).toBe(true);
+  });
+
+  it('throws an internal RPC error if something unexpected goes wrong with revoking the permission', async () => {
+    const { handler, revokePermissionForOrigin, end } = createMockedHandler();
+    revokePermissionForOrigin.mockImplementation(() => {
+      throw new Error('revoke failed');
+    });
+
+    await handler(baseRequest);
+    expect(end).toHaveBeenCalledWith(rpcErrors.internal());
+  });
+
+  it('returns true if the permission was revoked', async () => {
+    const { handler, response } = createMockedHandler();
+
+    await handler(baseRequest);
+    expect(response.result).toBe(true);
+  });
+});
diff --git a/packages/multichain/src/handlers/wallet-revokeSession.ts b/packages/multichain/src/handlers/wallet-revokeSession.ts
new file mode 100644
index 00000000000..46878cac016
--- /dev/null
+++ b/packages/multichain/src/handlers/wallet-revokeSession.ts
@@ -0,0 +1,58 @@
+import type {
+  JsonRpcEngineNextCallback,
+  JsonRpcEngineEndCallback,
+} from '@metamask/json-rpc-engine';
+import {
+  PermissionDoesNotExistError,
+  UnrecognizedSubjectError,
+} from '@metamask/permission-controller';
+import { rpcErrors } from '@metamask/rpc-errors';
+import type { JsonRpcSuccess, Json, JsonRpcRequest } from '@metamask/utils';
+
+import { Caip25EndowmentPermissionName } from '../caip25Permission';
+
+/**
+ * Handler for the `wallet_revokeSession` RPC method as specified by [CAIP-285](https://chainagnostic.org/CAIPs/caip-285).
+ * The implementation below deviates from the linked spec in that it ignores the `sessionId` param
+ * and instead revokes the singular session for the origin if available. Additionally,
+ * the handler also does not return an error if there is currently no active session and instead
+ * returns true which is the same result returned if an active session was actually revoked.
+ *
+ * @param request - The JSON-RPC request object.
+ * @param response - The JSON-RPC response object.
+ * @param _next - The next middleware function. Unused.
+ * @param end - The end callback function.
+ * @param hooks - The hooks object.
+ * @param hooks.revokePermissionForOrigin - The hook for revoking a permission for an origin function.
+ */
+async function walletRevokeSessionHandler(
+  request: JsonRpcRequest & { origin: string },
+  response: JsonRpcSuccess<Json>,
+  _next: JsonRpcEngineNextCallback,
+  end: JsonRpcEngineEndCallback,
+  hooks: {
+    revokePermissionForOrigin: (permissionName: string) => void;
+  },
+) {
+  try {
+    hooks.revokePermissionForOrigin(Caip25EndowmentPermissionName);
+  } catch (err) {
+    if (
+      !(err instanceof UnrecognizedSubjectError) &&
+      !(err instanceof PermissionDoesNotExistError)
+    ) {
+      console.error(err);
+      return end(rpcErrors.internal());
+    }
+  }
+
+  response.result = true;
+  return end();
+}
+export const walletRevokeSession = {
+  methodNames: ['wallet_revokeSession'],
+  implementation: walletRevokeSessionHandler,
+  hookNames: {
+    revokePermissionForOrigin: true,
+  },
+};
diff --git a/packages/multichain/src/index.test.ts b/packages/multichain/src/index.test.ts
index 38ab1bdde85..8465d5a24fd 100644
--- a/packages/multichain/src/index.test.ts
+++ b/packages/multichain/src/index.test.ts
@@ -9,12 +9,22 @@ describe('@metamask/multichain', () => {
         "getPermittedEthChainIds",
         "addPermittedEthChainId",
         "setPermittedEthChainIds",
+        "getInternalScopesObject",
+        "getSessionScopes",
+        "walletGetSession",
+        "walletInvokeMethod",
+        "walletRevokeSession",
+        "multichainMethodCallValidatorMiddleware",
+        "MultichainMiddlewareManager",
+        "MultichainSubscriptionManager",
         "validateAndNormalizeScopes",
+        "bucketScopes",
         "KnownWalletRpcMethods",
         "KnownRpcMethods",
         "KnownWalletNamespaceRpcMethods",
         "KnownNotifications",
         "KnownWalletScopeString",
+        "getSupportedScopeObjects",
         "parseScopeString",
         "normalizeScope",
         "mergeScopeObject",
diff --git a/packages/multichain/src/index.ts b/packages/multichain/src/index.ts
index 5b56923ffa9..60732796b47 100644
--- a/packages/multichain/src/index.ts
+++ b/packages/multichain/src/index.ts
@@ -7,9 +7,24 @@ export {
   addPermittedEthChainId,
   setPermittedEthChainIds,
 } from './adapters/caip-permission-adapter-permittedChains';
+export {
+  getInternalScopesObject,
+  getSessionScopes,
+} from './adapters/caip-permission-adapter-session-scopes';
+
+export { walletGetSession } from './handlers/wallet-getSession';
+export { walletInvokeMethod } from './handlers/wallet-invokeMethod';
+export { walletRevokeSession } from './handlers/wallet-revokeSession';
+
+export { multichainMethodCallValidatorMiddleware } from './middlewares/multichainMethodCallValidator';
+export { MultichainMiddlewareManager } from './middlewares/MultichainMiddlewareManager';
+export { MultichainSubscriptionManager } from './middlewares/MultichainSubscriptionManager';
 
 export type { Caip25Authorization } from './scope/authorization';
-export { validateAndNormalizeScopes } from './scope/authorization';
+export {
+  validateAndNormalizeScopes,
+  bucketScopes,
+} from './scope/authorization';
 export {
   KnownWalletRpcMethods,
   KnownRpcMethods,
@@ -17,6 +32,7 @@ export {
   KnownNotifications,
   KnownWalletScopeString,
 } from './scope/constants';
+export { getSupportedScopeObjects } from './scope/filter';
 export type {
   ExternalScopeString,
   ExternalScopeObject,
diff --git a/packages/multichain/src/middlewares/MultichainMiddlewareManager.test.ts b/packages/multichain/src/middlewares/MultichainMiddlewareManager.test.ts
new file mode 100644
index 00000000000..ac65138b2ec
--- /dev/null
+++ b/packages/multichain/src/middlewares/MultichainMiddlewareManager.test.ts
@@ -0,0 +1,247 @@
+import type { ExtendedJsonRpcMiddleware } from './MultichainMiddlewareManager';
+import { MultichainMiddlewareManager } from './MultichainMiddlewareManager';
+
+const scope = 'eip155:1';
+const origin = 'example.com';
+const tabId = 123;
+
+describe('MultichainMiddlewareManager', () => {
+  it('should add middleware and get called for the scope, origin, and tabId', () => {
+    const multichainMiddlewareManager = new MultichainMiddlewareManager();
+    const middlewareSpy = jest.fn() as unknown as ExtendedJsonRpcMiddleware;
+    multichainMiddlewareManager.addMiddleware({
+      scope,
+      origin,
+      tabId,
+      middleware: middlewareSpy,
+    });
+
+    const middleware =
+      multichainMiddlewareManager.generateMultichainMiddlewareForOriginAndTabId(
+        origin,
+        123,
+      );
+
+    const nextSpy = jest.fn();
+    const endSpy = jest.fn();
+
+    middleware(
+      { jsonrpc: '2.0' as const, id: 0, method: 'method', scope },
+      { jsonrpc: '2.0', id: 0 },
+      nextSpy,
+      endSpy,
+    );
+    expect(middlewareSpy).toHaveBeenCalledWith(
+      { jsonrpc: '2.0' as const, id: 0, method: 'method', scope },
+      { jsonrpc: '2.0', id: 0 },
+      nextSpy,
+      endSpy,
+    );
+    expect(nextSpy).not.toHaveBeenCalled();
+    expect(endSpy).not.toHaveBeenCalled();
+  });
+
+  it('should remove middleware by origin and tabId when the multiplexing middleware is destroyed and the middleware has no destroy function', async () => {
+    const multichainMiddlewareManager = new MultichainMiddlewareManager();
+    const middlewareSpy = jest.fn() as unknown as ExtendedJsonRpcMiddleware;
+    multichainMiddlewareManager.addMiddleware({
+      scope,
+      origin,
+      tabId,
+      middleware: middlewareSpy,
+    });
+
+    const middleware =
+      multichainMiddlewareManager.generateMultichainMiddlewareForOriginAndTabId(
+        origin,
+        123,
+      );
+
+    await middleware.destroy?.();
+
+    const nextSpy = jest.fn();
+    const endSpy = jest.fn();
+
+    middleware(
+      { jsonrpc: '2.0' as const, id: 0, method: 'method', scope },
+      { jsonrpc: '2.0', id: 0 },
+      nextSpy,
+      endSpy,
+    );
+    expect(middlewareSpy).not.toHaveBeenCalled();
+    expect(nextSpy).toHaveBeenCalled();
+    expect(endSpy).not.toHaveBeenCalled();
+  });
+
+  it('should remove middleware by origin and tabId when the multiplexing middleware is destroyed and the middleware destroy function resolves', async () => {
+    const multichainMiddlewareManager = new MultichainMiddlewareManager();
+    const middlewareSpy = jest.fn() as unknown as ExtendedJsonRpcMiddleware;
+    // eslint-disable-next-line jest/prefer-spy-on
+    middlewareSpy.destroy = jest.fn().mockResolvedValue(undefined);
+    multichainMiddlewareManager.addMiddleware({
+      scope,
+      origin,
+      tabId,
+      middleware: middlewareSpy,
+    });
+
+    const middleware =
+      multichainMiddlewareManager.generateMultichainMiddlewareForOriginAndTabId(
+        origin,
+        123,
+      );
+
+    await middleware.destroy?.();
+
+    expect(middlewareSpy.destroy).toHaveBeenCalled();
+
+    const nextSpy = jest.fn();
+    const endSpy = jest.fn();
+
+    middleware(
+      { jsonrpc: '2.0' as const, id: 0, method: 'method', scope },
+      { jsonrpc: '2.0', id: 0 },
+      nextSpy,
+      endSpy,
+    );
+    expect(middlewareSpy).not.toHaveBeenCalled();
+    expect(nextSpy).toHaveBeenCalled();
+    expect(endSpy).not.toHaveBeenCalled();
+  });
+
+  it('should remove middleware by origin and tabId when the multiplexing middleware is destroyed and the middleware destroy function rejects', async () => {
+    const multichainMiddlewareManager = new MultichainMiddlewareManager();
+    const middlewareSpy = jest.fn() as unknown as ExtendedJsonRpcMiddleware;
+    // eslint-disable-next-line jest/prefer-spy-on
+    middlewareSpy.destroy = jest
+      .fn()
+      .mockRejectedValue(
+        new Error('failed to destroy the actual underlying middleware'),
+      );
+    multichainMiddlewareManager.addMiddleware({
+      scope,
+      origin,
+      tabId,
+      middleware: middlewareSpy,
+    });
+
+    const middleware =
+      multichainMiddlewareManager.generateMultichainMiddlewareForOriginAndTabId(
+        origin,
+        123,
+      );
+
+    await middleware.destroy?.();
+
+    expect(middlewareSpy.destroy).toHaveBeenCalled();
+
+    const nextSpy = jest.fn();
+    const endSpy = jest.fn();
+
+    middleware(
+      { jsonrpc: '2.0' as const, id: 0, method: 'method', scope },
+      { jsonrpc: '2.0', id: 0 },
+      nextSpy,
+      endSpy,
+    );
+    expect(middlewareSpy).not.toHaveBeenCalled();
+    expect(nextSpy).toHaveBeenCalled();
+    expect(endSpy).not.toHaveBeenCalled();
+  });
+
+  it('should remove middleware by scope', () => {
+    const multichainMiddlewareManager = new MultichainMiddlewareManager();
+    const middlewareSpy = jest.fn() as unknown as ExtendedJsonRpcMiddleware;
+    multichainMiddlewareManager.addMiddleware({
+      scope,
+      origin,
+      tabId,
+      middleware: middlewareSpy,
+    });
+
+    multichainMiddlewareManager.removeMiddlewareByScope(scope);
+
+    const middleware =
+      multichainMiddlewareManager.generateMultichainMiddlewareForOriginAndTabId(
+        origin,
+        123,
+      );
+
+    const nextSpy = jest.fn();
+    const endSpy = jest.fn();
+
+    middleware(
+      { jsonrpc: '2.0' as const, id: 0, method: 'method', scope },
+      { jsonrpc: '2.0', id: 0 },
+      nextSpy,
+      endSpy,
+    );
+    expect(middlewareSpy).not.toHaveBeenCalled();
+    expect(nextSpy).toHaveBeenCalled();
+    expect(endSpy).not.toHaveBeenCalled();
+  });
+
+  it('should remove middleware by scope and origin', () => {
+    const multichainMiddlewareManager = new MultichainMiddlewareManager();
+    const middlewareSpy = jest.fn() as unknown as ExtendedJsonRpcMiddleware;
+    multichainMiddlewareManager.addMiddleware({
+      scope,
+      origin,
+      tabId,
+      middleware: middlewareSpy,
+    });
+
+    multichainMiddlewareManager.removeMiddlewareByScopeAndOrigin(scope, origin);
+
+    const middleware =
+      multichainMiddlewareManager.generateMultichainMiddlewareForOriginAndTabId(
+        origin,
+        123,
+      );
+
+    const nextSpy = jest.fn();
+    const endSpy = jest.fn();
+
+    middleware(
+      { jsonrpc: '2.0' as const, id: 0, method: 'method', scope },
+      { jsonrpc: '2.0', id: 0 },
+      nextSpy,
+      endSpy,
+    );
+    expect(middlewareSpy).not.toHaveBeenCalled();
+    expect(nextSpy).toHaveBeenCalled();
+    expect(endSpy).not.toHaveBeenCalled();
+  });
+
+  it('should remove middleware by origin and tabId', () => {
+    const multichainMiddlewareManager = new MultichainMiddlewareManager();
+    const middlewareSpy = jest.fn() as unknown as ExtendedJsonRpcMiddleware;
+    multichainMiddlewareManager.addMiddleware({
+      scope,
+      origin,
+      tabId,
+      middleware: middlewareSpy,
+    });
+
+    multichainMiddlewareManager.removeMiddlewareByOriginAndTabId(origin, tabId);
+
+    const middleware =
+      multichainMiddlewareManager.generateMultichainMiddlewareForOriginAndTabId(
+        origin,
+        123,
+      );
+
+    const nextSpy = jest.fn();
+    const endSpy = jest.fn();
+
+    middleware(
+      { jsonrpc: '2.0' as const, id: 0, method: 'method', scope },
+      { jsonrpc: '2.0', id: 0 },
+      nextSpy,
+      endSpy,
+    );
+    expect(middlewareSpy).not.toHaveBeenCalled();
+    expect(nextSpy).toHaveBeenCalled();
+    expect(endSpy).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/multichain/src/middlewares/MultichainMiddlewareManager.ts b/packages/multichain/src/middlewares/MultichainMiddlewareManager.ts
new file mode 100644
index 00000000000..9ae20e668f8
--- /dev/null
+++ b/packages/multichain/src/middlewares/MultichainMiddlewareManager.ts
@@ -0,0 +1,141 @@
+import type {
+  JsonRpcEngineEndCallback,
+  JsonRpcEngineNextCallback,
+} from '@metamask/json-rpc-engine';
+import type {
+  Json,
+  JsonRpcRequest,
+  PendingJsonRpcResponse,
+} from '@metamask/utils';
+
+import type { ExternalScopeString } from '../scope/types';
+
+export type ExtendedJsonRpcMiddleware = {
+  (
+    req: JsonRpcRequest & { scope: string },
+    res: PendingJsonRpcResponse<Json>,
+    next: JsonRpcEngineNextCallback,
+    end: JsonRpcEngineEndCallback,
+  ): void;
+  destroy?: () => void | Promise<void>;
+};
+
+type MiddlewareKey = {
+  scope: ExternalScopeString;
+  origin: string;
+  tabId?: number;
+};
+type MiddlewareEntry = MiddlewareKey & {
+  middleware: ExtendedJsonRpcMiddleware;
+};
+
+/**
+ * A helper that facilates registering and calling of provided middleware instances
+ * in the RPC pipeline based on the incoming request's scope, origin, and tabId.
+ * The core purpose of this class is to enable and manage multichain subscriptions
+ * (i.e. eth_subscribe called accross different chains and domains).
+ *
+ * Note that only one middleware instance can be registered per scope, origin, tabId key.
+ */
+export class MultichainMiddlewareManager {
+  #middlewares: MiddlewareEntry[] = [];
+
+  #getMiddlewareEntry({
+    scope,
+    origin,
+    tabId,
+  }: MiddlewareKey): MiddlewareEntry | undefined {
+    return this.#middlewares.find((middlewareEntry) => {
+      return (
+        middlewareEntry.scope === scope &&
+        middlewareEntry.origin === origin &&
+        middlewareEntry.tabId === tabId
+      );
+    });
+  }
+
+  #removeMiddlewareEntry({ scope, origin, tabId }: MiddlewareEntry) {
+    this.#middlewares = this.#middlewares.filter((middlewareEntry) => {
+      return (
+        middlewareEntry.scope !== scope ||
+        middlewareEntry.origin !== origin ||
+        middlewareEntry.tabId !== tabId
+      );
+    });
+  }
+
+  addMiddleware(middlewareEntry: MiddlewareEntry) {
+    const { scope, origin, tabId } = middlewareEntry;
+    if (!this.#getMiddlewareEntry({ scope, origin, tabId })) {
+      this.#middlewares.push(middlewareEntry);
+    }
+  }
+
+  #removeMiddleware(middlewareEntry: MiddlewareEntry) {
+    // When the destroy function on the middleware is async,
+    // we don't need to wait for it complete
+    Promise.resolve(middlewareEntry.middleware.destroy?.()).catch(() => {
+      // do nothing
+    });
+
+    this.#removeMiddlewareEntry(middlewareEntry);
+  }
+
+  removeMiddlewareByScope(scope: ExternalScopeString) {
+    this.#middlewares.forEach((middlewareEntry) => {
+      if (middlewareEntry.scope === scope) {
+        this.#removeMiddleware(middlewareEntry);
+      }
+    });
+  }
+
+  removeMiddlewareByScopeAndOrigin(scope: ExternalScopeString, origin: string) {
+    this.#middlewares.forEach((middlewareEntry) => {
+      if (
+        middlewareEntry.scope === scope &&
+        middlewareEntry.origin === origin
+      ) {
+        this.#removeMiddleware(middlewareEntry);
+      }
+    });
+  }
+
+  removeMiddlewareByOriginAndTabId(origin: string, tabId?: number) {
+    this.#middlewares.forEach((middlewareEntry) => {
+      if (
+        middlewareEntry.origin === origin &&
+        middlewareEntry.tabId === tabId
+      ) {
+        this.#removeMiddleware(middlewareEntry);
+      }
+    });
+  }
+
+  generateMultichainMiddlewareForOriginAndTabId(
+    origin: string,
+    tabId?: number,
+  ) {
+    const middleware: ExtendedJsonRpcMiddleware = (req, res, next, end) => {
+      const { scope } = req;
+      const middlewareEntry = this.#getMiddlewareEntry({
+        scope,
+        origin,
+        tabId,
+      });
+
+      if (middlewareEntry) {
+        middlewareEntry.middleware(req, res, next, end);
+      } else {
+        return next();
+      }
+      return undefined;
+    };
+    middleware.destroy = this.removeMiddlewareByOriginAndTabId.bind(
+      this,
+      origin,
+      tabId,
+    );
+
+    return middleware;
+  }
+}
diff --git a/packages/multichain/src/middlewares/MultichainSubscriptionManager.test.ts b/packages/multichain/src/middlewares/MultichainSubscriptionManager.test.ts
new file mode 100644
index 00000000000..75c6d3df05f
--- /dev/null
+++ b/packages/multichain/src/middlewares/MultichainSubscriptionManager.test.ts
@@ -0,0 +1,165 @@
+import createSubscriptionManager from '@metamask/eth-json-rpc-filters/subscriptionManager';
+import type SafeEventEmitter from '@metamask/safe-event-emitter';
+
+import { MultichainSubscriptionManager } from './MultichainSubscriptionManager';
+
+jest.mock('@metamask/eth-json-rpc-filters/subscriptionManager', () =>
+  jest.fn(),
+);
+const MockCreateSubscriptionManager = jest.mocked(createSubscriptionManager);
+
+const newHeadsNotificationMock = {
+  method: 'eth_subscription',
+  params: {
+    result: {
+      difficulty: '0x15d9223a23aa',
+      extraData: '0xd983010305844765746887676f312e342e328777696e646f7773',
+      gasLimit: '0x47e7c4',
+      gasUsed: '0x38658',
+      logsBloom:
+        '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+      miner: '0xf8b483dba2c3b7176a3da549ad41a48bb3121069',
+      nonce: '0x084149998194cc5f',
+      number: '0x1348c9',
+      parentHash:
+        '0x7736fab79e05dc611604d22470dadad26f56fe494421b5b333de816ce1f25701',
+      receiptRoot:
+        '0x2fab35823ad00c7bb388595cb46652fe7886e00660a01e867824d3dceb1c8d36',
+      sha3Uncles:
+        '0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347',
+      stateRoot:
+        '0xb3346685172db67de536d8765c43c31009d0eb3bd9c501c9be3229203f15f378',
+      timestamp: '0x56ffeff8',
+    },
+  },
+};
+
+const scope = 'eip155:1';
+const origin = 'example.com';
+const tabId = 123;
+
+const createMultichainSubscriptionManager = () => {
+  const mockFindNetworkClientIdByChainId = jest.fn();
+  const mockGetNetworkClientById = jest.fn().mockImplementation(() => ({
+    blockTracker: {},
+    provider: {},
+  }));
+  const multichainSubscriptionManager = new MultichainSubscriptionManager({
+    findNetworkClientIdByChainId: mockFindNetworkClientIdByChainId,
+    getNetworkClientById: mockGetNetworkClientById,
+  });
+
+  return { multichainSubscriptionManager };
+};
+
+const createMockSubscriptionManager = () => ({
+  events: {
+    on: jest.fn(),
+  } as unknown as jest.Mocked<SafeEventEmitter>,
+  destroy: jest.fn(),
+  middleware: {
+    destroy: jest.fn(),
+  },
+});
+
+describe('MultichainSubscriptionManager', () => {
+  let mockSubscriptionManager = createMockSubscriptionManager();
+
+  beforeEach(() => {
+    mockSubscriptionManager = createMockSubscriptionManager();
+    MockCreateSubscriptionManager.mockReturnValue(mockSubscriptionManager);
+  });
+
+  it('should not create a new subscriptionManager if one matches the passed in subscriptionKey', () => {
+    const { multichainSubscriptionManager } =
+      createMultichainSubscriptionManager();
+
+    const firstSubscription = multichainSubscriptionManager.subscribe({
+      scope,
+      origin,
+      tabId,
+    });
+
+    const secondSubscription = multichainSubscriptionManager.subscribe({
+      scope,
+      origin,
+      tabId,
+    });
+
+    expect(secondSubscription).toBe(firstSubscription);
+    expect(MockCreateSubscriptionManager).toHaveBeenCalledTimes(1);
+  });
+
+  it('should subscribe to a scope, origin, and tabId', () => {
+    const { multichainSubscriptionManager } =
+      createMultichainSubscriptionManager();
+    multichainSubscriptionManager.subscribe({ scope, origin, tabId });
+    const notifySpy = jest.fn();
+    multichainSubscriptionManager.on('notification', notifySpy);
+
+    mockSubscriptionManager.events.on.mock.calls[0][1](
+      newHeadsNotificationMock,
+    );
+
+    expect(notifySpy).toHaveBeenCalledWith(origin, tabId, {
+      method: 'wallet_notify',
+      params: {
+        scope,
+        notification: newHeadsNotificationMock,
+      },
+    });
+  });
+
+  it('should unsubscribe from a scope', () => {
+    const { multichainSubscriptionManager } =
+      createMultichainSubscriptionManager();
+    multichainSubscriptionManager.subscribe({ scope, origin, tabId });
+    multichainSubscriptionManager.unsubscribeByScope(scope);
+
+    expect(mockSubscriptionManager.destroy).toHaveBeenCalled();
+  });
+
+  it('should unsubscribe from a scope and origin', () => {
+    const { multichainSubscriptionManager } =
+      createMultichainSubscriptionManager();
+    multichainSubscriptionManager.subscribe({ scope, origin, tabId });
+    multichainSubscriptionManager.unsubscribeByScopeAndOrigin(scope, origin);
+
+    expect(mockSubscriptionManager.destroy).toHaveBeenCalled();
+  });
+
+  it('should do nothing if an unsubscribe call does not match an existing subscription', () => {
+    const { multichainSubscriptionManager } =
+      createMultichainSubscriptionManager();
+    multichainSubscriptionManager.subscribe({ scope, origin, tabId });
+    multichainSubscriptionManager.unsubscribeByScope('eip155:10');
+    multichainSubscriptionManager.unsubscribeByScopeAndOrigin(
+      scope,
+      'other-origin',
+    );
+    multichainSubscriptionManager.unsubscribeByOriginAndTabId(
+      'other-origin',
+      123,
+    );
+
+    expect(mockSubscriptionManager.destroy).not.toHaveBeenCalled();
+  });
+
+  it('should unsubscribe from a origin and tabId', () => {
+    const { multichainSubscriptionManager } =
+      createMultichainSubscriptionManager();
+    multichainSubscriptionManager.subscribe({ scope, origin, tabId });
+    multichainSubscriptionManager.unsubscribeByOriginAndTabId(origin, tabId);
+
+    expect(mockSubscriptionManager.destroy).toHaveBeenCalled();
+  });
+
+  it('should unsubscribe when the middleware is destroyed', () => {
+    const { multichainSubscriptionManager } =
+      createMultichainSubscriptionManager();
+    multichainSubscriptionManager.subscribe({ scope, origin, tabId });
+    mockSubscriptionManager.middleware.destroy();
+
+    expect(mockSubscriptionManager.destroy).toHaveBeenCalled();
+  });
+});
diff --git a/packages/multichain/src/middlewares/MultichainSubscriptionManager.ts b/packages/multichain/src/middlewares/MultichainSubscriptionManager.ts
new file mode 100644
index 00000000000..9df0bb48518
--- /dev/null
+++ b/packages/multichain/src/middlewares/MultichainSubscriptionManager.ts
@@ -0,0 +1,173 @@
+import { toHex } from '@metamask/controller-utils';
+import createSubscriptionManager from '@metamask/eth-json-rpc-filters/subscriptionManager';
+import type { NetworkController } from '@metamask/network-controller';
+import SafeEventEmitter from '@metamask/safe-event-emitter';
+import type { CaipChainId, Hex } from '@metamask/utils';
+import { parseCaipChainId } from '@metamask/utils';
+
+import type { ExternalScopeString } from '../scope/types';
+import type { ExtendedJsonRpcMiddleware } from './MultichainMiddlewareManager';
+
+export type SubscriptionManager = {
+  events: SafeEventEmitter;
+  destroy?: () => void;
+  middleware: ExtendedJsonRpcMiddleware;
+};
+
+type SubscriptionNotificationEvent = {
+  jsonrpc: '2.0';
+  method: 'eth_subscription';
+  params: {
+    subscription: Hex;
+    result: unknown;
+  };
+};
+
+type SubscriptionKey = {
+  scope: ExternalScopeString;
+  origin: string;
+  tabId?: number;
+};
+type SubscriptionEntry = SubscriptionKey & {
+  subscriptionManager: SubscriptionManager;
+};
+
+type MultichainSubscriptionManagerOptions = {
+  findNetworkClientIdByChainId: NetworkController['findNetworkClientIdByChainId'];
+  getNetworkClientById: NetworkController['getNetworkClientById'];
+};
+
+/**
+ * A helper that facilates the lifecycle of a SubscriptionManager instance that
+ * is meant to handle subscriptons for only one specific scope, origin, and tabId combination.
+ */
+export class MultichainSubscriptionManager extends SafeEventEmitter {
+  #findNetworkClientIdByChainId: NetworkController['findNetworkClientIdByChainId'];
+
+  #getNetworkClientById: NetworkController['getNetworkClientById'];
+
+  #subscriptions: SubscriptionEntry[] = [];
+
+  /**
+   * Construct a MultichainSubscriptionManager.
+   *
+   * @param options - The controller options.
+   * @param options.findNetworkClientIdByChainId - The hook to get the networkClientId from a chainId.
+   * @param options.getNetworkClientById - The hook to get the network client instance by its networkClientId.
+   */
+  constructor(options: MultichainSubscriptionManagerOptions) {
+    super();
+    this.#findNetworkClientIdByChainId = options.findNetworkClientIdByChainId;
+    this.#getNetworkClientById = options.getNetworkClientById;
+  }
+
+  notify(
+    { scope, origin, tabId }: SubscriptionKey,
+    { method, params }: SubscriptionNotificationEvent,
+  ) {
+    this.emit('notification', origin, tabId, {
+      method: 'wallet_notify',
+      params: {
+        scope,
+        notification: { method, params },
+      },
+    });
+  }
+
+  #getSubscriptionEntry({
+    scope,
+    origin,
+    tabId,
+  }: SubscriptionKey): SubscriptionEntry | undefined {
+    return this.#subscriptions.find((subscriptionEntry) => {
+      return (
+        subscriptionEntry.scope === scope &&
+        subscriptionEntry.origin === origin &&
+        subscriptionEntry.tabId === tabId
+      );
+    });
+  }
+
+  #removeSubscriptionEntry({ scope, origin, tabId }: SubscriptionEntry) {
+    this.#subscriptions = this.#subscriptions.filter((subscriptionEntry) => {
+      return (
+        subscriptionEntry.scope !== scope ||
+        subscriptionEntry.origin !== origin ||
+        subscriptionEntry.tabId !== tabId
+      );
+    });
+  }
+
+  subscribe(subscriptionKey: SubscriptionKey) {
+    const subscriptionEntry = this.#getSubscriptionEntry(subscriptionKey);
+    if (subscriptionEntry) {
+      return subscriptionEntry.subscriptionManager;
+    }
+
+    const networkClientId = this.#findNetworkClientIdByChainId(
+      toHex(parseCaipChainId(subscriptionKey.scope as CaipChainId).reference),
+    );
+    const networkClient = this.#getNetworkClientById(networkClientId);
+    const subscriptionManager = createSubscriptionManager({
+      blockTracker: networkClient.blockTracker,
+      provider: networkClient.provider,
+    });
+
+    subscriptionManager.events.on(
+      'notification',
+      (message: SubscriptionNotificationEvent) => {
+        this.notify(subscriptionKey, message);
+      },
+    );
+
+    const newSubscriptionManagerEntry = {
+      ...subscriptionKey,
+      subscriptionManager,
+    };
+    subscriptionManager.destroy = subscriptionManager.middleware.destroy;
+    subscriptionManager.middleware.destroy = this.#unsubscribe.bind(
+      this,
+      newSubscriptionManagerEntry,
+    );
+
+    this.#subscriptions.push(newSubscriptionManagerEntry);
+
+    return subscriptionManager;
+  }
+
+  #unsubscribe(subscriptionEntry: SubscriptionEntry) {
+    subscriptionEntry.subscriptionManager.destroy?.();
+
+    this.#removeSubscriptionEntry(subscriptionEntry);
+  }
+
+  unsubscribeByScope(scope: ExternalScopeString) {
+    this.#subscriptions.forEach((subscriptionEntry) => {
+      if (subscriptionEntry.scope === scope) {
+        this.#unsubscribe(subscriptionEntry);
+      }
+    });
+  }
+
+  unsubscribeByScopeAndOrigin(scope: ExternalScopeString, origin: string) {
+    this.#subscriptions.forEach((subscriptionEntry) => {
+      if (
+        subscriptionEntry.scope === scope &&
+        subscriptionEntry.origin === origin
+      ) {
+        this.#unsubscribe(subscriptionEntry);
+      }
+    });
+  }
+
+  unsubscribeByOriginAndTabId(origin: string, tabId?: number) {
+    this.#subscriptions.forEach((subscriptionEntry) => {
+      if (
+        subscriptionEntry.origin === origin &&
+        subscriptionEntry.tabId === tabId
+      ) {
+        this.#unsubscribe(subscriptionEntry);
+      }
+    });
+  }
+}
diff --git a/packages/multichain/src/middlewares/multichainMethodCallValidator.test.ts b/packages/multichain/src/middlewares/multichainMethodCallValidator.test.ts
new file mode 100644
index 00000000000..3ba8bd4b4a2
--- /dev/null
+++ b/packages/multichain/src/middlewares/multichainMethodCallValidator.test.ts
@@ -0,0 +1,474 @@
+import type {
+  JsonRpcError,
+  JsonRpcRequest,
+  JsonRpcResponse,
+} from '@metamask/utils';
+
+import { multichainMethodCallValidatorMiddleware } from './multichainMethodCallValidator';
+
+describe('multichainMethodCallValidatorMiddleware', () => {
+  const mockNext = jest.fn();
+
+  describe('"wallet_invokeMethod" request', () => {
+    it('should pass validation and call next when passed a valid "wallet_invokeMethod" request', async () => {
+      const request: JsonRpcRequest = {
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'wallet_invokeMethod',
+        params: {
+          scope: 'test',
+          request: {
+            method: 'test_method',
+            params: {
+              test: 'test',
+            },
+          },
+        },
+      };
+      const response = {} as JsonRpcResponse<typeof request>;
+
+      await new Promise<void>((resolve, reject) => {
+        multichainMethodCallValidatorMiddleware(
+          request,
+          response,
+          mockNext,
+          (error) => {
+            reject(error);
+          },
+        );
+
+        process.nextTick(() => {
+          try {
+            expect(mockNext).toHaveBeenCalled();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    });
+    it('should throw an error when passed a "wallet_invokeMethod" request with no scope', async () => {
+      const request: JsonRpcRequest = {
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'wallet_invokeMethod',
+        params: {
+          request: {
+            method: 'test_method',
+            params: {
+              test: 'test',
+            },
+          },
+        },
+      };
+      const response = {} as JsonRpcResponse<typeof request>;
+
+      await new Promise<void>((resolve, reject) => {
+        multichainMethodCallValidatorMiddleware(
+          request,
+          response,
+          mockNext,
+          (error) => {
+            try {
+              const rpcError = error as JsonRpcError & { data: JsonRpcError[] };
+              expect(rpcError.message).toBe('Invalid method parameter(s).');
+              expect(rpcError.code).toBe(-32602);
+              expect(rpcError.data[0].data).toStrictEqual({
+                got: undefined,
+                param: 'scope',
+                path: [],
+                schema: {
+                  pattern: '[-a-z0-9]{3,8}(:[-_a-zA-Z0-9]{1,32})?',
+                  type: 'string',
+                },
+              });
+              expect(rpcError.data[0].message).toBe(
+                'scope is required, but is undefined',
+              );
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          },
+        );
+
+        process.nextTick(() => {
+          try {
+            expect(mockNext).not.toHaveBeenCalled();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    });
+    it('should throw an error for a "wallet_invokeMethod" request without a nested request object', async () => {
+      const request: JsonRpcRequest = {
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'wallet_invokeMethod',
+        params: {
+          scope: 'test',
+        },
+      };
+      const response = {} as JsonRpcResponse<typeof request>;
+
+      await new Promise<void>((resolve, reject) => {
+        multichainMethodCallValidatorMiddleware(
+          request,
+          response,
+          mockNext,
+          (error) => {
+            try {
+              const rpcError = error as JsonRpcError & { data: JsonRpcError[] };
+              expect(rpcError.message).toBe('Invalid method parameter(s).');
+              expect(rpcError.code).toBe(-32602);
+              expect(rpcError.data[0].data).toStrictEqual({
+                got: undefined,
+                param: 'request',
+                path: [],
+                schema: {
+                  properties: {
+                    method: {
+                      type: 'string',
+                    },
+                    params: true,
+                  },
+                  type: 'object',
+                },
+              });
+              expect(rpcError.data[0].message).toBe(
+                'request is required, but is undefined',
+              );
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          },
+        );
+
+        process.nextTick(() => {
+          try {
+            expect(mockNext).not.toHaveBeenCalled();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    });
+    it('should throw an error for an invalidly formatted "wallet_invokeMethod" request', async () => {
+      const request: JsonRpcRequest = {
+        id: 1,
+        jsonrpc: '2.0',
+        method: 'wallet_invokeMethod',
+        params: {
+          scope: 'test',
+          request: {
+            method: {}, // expected to be a string
+            params: {
+              test: 'test',
+            },
+          },
+        },
+      };
+      const response = {} as JsonRpcResponse<typeof request>;
+
+      await new Promise<void>((resolve, reject) => {
+        multichainMethodCallValidatorMiddleware(
+          request,
+          response,
+          mockNext,
+          (error) => {
+            try {
+              const rpcError = error as JsonRpcError & { data: JsonRpcError[] };
+              expect(rpcError.message).toBe('Invalid method parameter(s).');
+              expect(rpcError.code).toBe(-32602);
+              expect(rpcError.data[0].data).toStrictEqual({
+                got: {
+                  method: {},
+                  params: {
+                    test: 'test',
+                  },
+                },
+                param: 'request',
+                path: ['method'],
+                schema: {
+                  type: 'string',
+                },
+              });
+              expect(rpcError.data[0].message).toBe(
+                'request.method is not of a type(s) string',
+              );
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          },
+        );
+
+        process.nextTick(() => {
+          try {
+            expect(mockNext).not.toHaveBeenCalled();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    });
+  });
+
+  describe('"wallet_notify" request', () => {
+    it('should pass validation for a "wallet_notify" request and call next', async () => {
+      const request: JsonRpcRequest = {
+        id: 2,
+        jsonrpc: '2.0',
+        method: 'wallet_notify',
+        params: {
+          scope: 'test_scope',
+          notification: {
+            method: 'test_method',
+            params: {
+              data: {
+                key: 'value',
+              },
+            },
+          },
+        },
+      };
+      const response = {} as JsonRpcResponse<typeof request>;
+
+      await new Promise<void>((resolve, reject) => {
+        multichainMethodCallValidatorMiddleware(
+          request,
+          response,
+          mockNext,
+          (error) => {
+            reject(error);
+          },
+        );
+
+        process.nextTick(() => {
+          try {
+            expect(mockNext).toHaveBeenCalled();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    });
+
+    it('should throw an error for a "wallet_notify" request with invalid params', async () => {
+      const request: JsonRpcRequest = {
+        id: 2,
+        jsonrpc: '2.0',
+        method: 'wallet_notify',
+        params: {
+          scope: 'test_scope',
+          request: {
+            data: {},
+          },
+        },
+      };
+      const response = {} as JsonRpcResponse<typeof request>;
+
+      await new Promise<void>((resolve, reject) => {
+        multichainMethodCallValidatorMiddleware(
+          request,
+          response,
+          mockNext,
+          (error) => {
+            try {
+              const rpcError = error as JsonRpcError & { data: JsonRpcError[] };
+              expect(rpcError.message).toBe('Invalid method parameter(s).');
+              expect(rpcError.code).toBe(-32602);
+              expect(rpcError.data[0].data).toStrictEqual({
+                got: undefined,
+                param: 'notification',
+                path: [],
+                schema: {
+                  properties: {
+                    method: {
+                      type: 'string',
+                    },
+                    params: true,
+                  },
+                  type: 'object',
+                },
+              });
+              expect(rpcError.data[0].message).toBe(
+                'notification is required, but is undefined',
+              );
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          },
+        );
+
+        process.nextTick(() => {
+          try {
+            expect(mockNext).not.toHaveBeenCalled();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    });
+  });
+
+  describe('"wallet_revokeSession" request', () => {
+    it('should pass validation and call next when passed a valid "wallet_revokeSession" request', async () => {
+      const request: JsonRpcRequest = {
+        id: 3,
+        jsonrpc: '2.0',
+        method: 'wallet_revokeSession',
+      };
+      const response = {} as JsonRpcResponse<typeof request>;
+
+      await new Promise<void>((resolve, reject) => {
+        multichainMethodCallValidatorMiddleware(
+          request,
+          response,
+          mockNext,
+          (error) => {
+            reject(error);
+          },
+        );
+
+        process.nextTick(() => {
+          try {
+            expect(mockNext).toHaveBeenCalled();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    });
+  });
+
+  describe('"wallet_getSession" request', () => {
+    it('should pass validation and call next when passed a valid "wallet_getSession" request', async () => {
+      const request: JsonRpcRequest = {
+        id: 5,
+        jsonrpc: '2.0',
+        method: 'wallet_getSession',
+        params: {},
+      };
+      const response = {} as JsonRpcResponse<typeof request>;
+
+      await new Promise<void>((resolve, reject) => {
+        multichainMethodCallValidatorMiddleware(
+          request,
+          response,
+          mockNext,
+          (error) => {
+            reject(error);
+          },
+        );
+
+        process.nextTick(() => {
+          try {
+            expect(mockNext).toHaveBeenCalled();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+    });
+  });
+
+  it('should throw an error if the top level params are not an object', async () => {
+    const request: JsonRpcRequest = {
+      id: 1,
+      jsonrpc: '2.0',
+      method: 'wallet_invokeMethod',
+      params: ['test'],
+    };
+    const response = {} as JsonRpcResponse<typeof request>;
+
+    await new Promise<void>((resolve, reject) => {
+      multichainMethodCallValidatorMiddleware(
+        request,
+        response,
+        mockNext,
+        (error) => {
+          try {
+            expect(error).toBeDefined();
+            expect((error as JsonRpcError).code).toBe(-32602);
+            expect((error as JsonRpcError).message).toBe(
+              'Invalid method parameter(s).',
+            );
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        },
+      );
+
+      process.nextTick(() => {
+        try {
+          expect(mockNext).not.toHaveBeenCalled();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+  });
+
+  it('should throw an error when passed an unknown method at the top level', async () => {
+    const request: JsonRpcRequest = {
+      id: 1,
+      jsonrpc: '2.0',
+      method: 'unknown_method',
+      params: {
+        request: {
+          method: 'test_method',
+          params: {
+            test: 'test',
+          },
+        },
+      },
+    };
+    const response = {} as JsonRpcResponse<typeof request>;
+
+    await new Promise<void>((resolve, reject) => {
+      multichainMethodCallValidatorMiddleware(
+        request,
+        response,
+        mockNext,
+        (error) => {
+          try {
+            const rpcError = error as JsonRpcError & { data: JsonRpcError[] };
+            expect(rpcError.message).toBe('Invalid method parameter(s).');
+            expect(rpcError.code).toBe(-32602);
+            expect(rpcError.data[0].data).toStrictEqual({
+              method: 'unknown_method',
+            });
+            expect(rpcError.data[0].message).toBe(
+              'The method does not exist / is not available.',
+            );
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        },
+      );
+
+      process.nextTick(() => {
+        try {
+          expect(mockNext).not.toHaveBeenCalled();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+  });
+});
diff --git a/packages/multichain/src/middlewares/multichainMethodCallValidator.ts b/packages/multichain/src/middlewares/multichainMethodCallValidator.ts
new file mode 100644
index 00000000000..77977930849
--- /dev/null
+++ b/packages/multichain/src/middlewares/multichainMethodCallValidator.ts
@@ -0,0 +1,108 @@
+import { MultiChainOpenRPCDocument } from '@metamask/api-specs';
+import { createAsyncMiddleware } from '@metamask/json-rpc-engine';
+import { rpcErrors } from '@metamask/rpc-errors';
+import { isObject } from '@metamask/utils';
+import type { JsonRpcError, JsonRpcParams } from '@metamask/utils';
+import type {
+  ContentDescriptorObject,
+  MethodObject,
+  OpenrpcDocument,
+  ReferenceObject,
+} from '@open-rpc/meta-schema';
+import dereferenceDocument from '@open-rpc/schema-utils-js/build/dereference-document';
+import { makeCustomResolver } from '@open-rpc/schema-utils-js/build/parse-open-rpc-document';
+import type { Schema, ValidationError } from 'jsonschema';
+import { Validator } from 'jsonschema';
+
+const transformError = (
+  error: ValidationError,
+  param: ContentDescriptorObject,
+  got: unknown,
+) => {
+  // if there is a path, add it to the message
+  const message = `${param.name}${
+    error.path.length > 0 ? `.${error.path.join('.')}` : ''
+  } ${error.message}`;
+
+  return rpcErrors.invalidParams({
+    message,
+    data: {
+      param: param.name,
+      path: error.path,
+      schema: error.schema,
+      got,
+    },
+  });
+};
+
+const v = new Validator();
+
+const dereffedPromise = dereferenceDocument(
+  MultiChainOpenRPCDocument as unknown as OpenrpcDocument,
+  makeCustomResolver({}),
+);
+
+/**
+ * Helper that utilizes the Multichain method specifications from `@metamask/api-specs`
+ * to validate the params of a Multichain request.
+ *
+ * @param method - The request's method.
+ * @param params - The request's optional JsonRpcParams object.
+ * @returns an array of error objects for each validation error or an empty array if no errors.
+ */
+const multichainMethodCallValidator = async (
+  method: string,
+  params: JsonRpcParams | undefined,
+) => {
+  const dereffed = await dereffedPromise;
+
+  const methodToCheck = dereffed.methods.find(
+    (m: MethodObject | ReferenceObject) => (m as MethodObject).name === method,
+  ) as MethodObject | undefined;
+
+  if (
+    !methodToCheck ||
+    !isObject(methodToCheck) ||
+    !('params' in methodToCheck)
+  ) {
+    return [rpcErrors.methodNotFound({ data: { method } })] as JsonRpcError[];
+  }
+
+  const errors: JsonRpcError[] = [];
+  for (const param of methodToCheck.params) {
+    if (!isObject(params)) {
+      return [rpcErrors.invalidParams()] as JsonRpcError[];
+    }
+    const p = param as ContentDescriptorObject;
+    const paramToCheck = params[p.name];
+
+    const result = v.validate(paramToCheck, p.schema as unknown as Schema, {
+      required: p.required,
+    });
+    if (result.errors) {
+      errors.push(
+        ...result.errors.map((e) => {
+          return transformError(e, p, paramToCheck) as JsonRpcError;
+        }),
+      );
+    }
+  }
+  return errors;
+};
+
+/**
+ * Middleware that validates the params of a Multichain method request
+ * using the specifications from `@metamask/api-specs`.
+ */
+export const multichainMethodCallValidatorMiddleware = createAsyncMiddleware(
+  async (request, _response, next) => {
+    const errors = await multichainMethodCallValidator(
+      request.method,
+      request.params,
+    );
+    if (errors.length > 0) {
+      throw rpcErrors.invalidParams<JsonRpcError[]>({ data: errors });
+    }
+    return await next();
+  },
+);
diff --git a/packages/multichain/src/scope/assert.test.ts b/packages/multichain/src/scope/assert.test.ts
index 0fd23b5bf61..2b27abd6728 100644
--- a/packages/multichain/src/scope/assert.test.ts
+++ b/packages/multichain/src/scope/assert.test.ts
@@ -5,6 +5,7 @@ import {
   assertScopesSupported,
   assertIsExternalScopesObject,
   assertIsInternalScopesObject,
+  assertIsInternalScopeString,
 } from './assert';
 import { Caip25Errors } from './errors';
 import * as Supported from './supported';
@@ -18,6 +19,7 @@ jest.mock('./supported', () => ({
 
 jest.mock('@metamask/utils', () => ({
   ...jest.requireActual('@metamask/utils'),
+  isCaipChainId: jest.fn(),
   isCaipReference: jest.fn(),
   isCaipAccountId: jest.fn(),
 }));
@@ -33,6 +35,7 @@ const validScopeObject: NormalizedScopeObject = {
 
 describe('Scope Assert', () => {
   beforeEach(() => {
+    MockUtils.isCaipChainId.mockImplementation(() => true);
     MockUtils.isCaipReference.mockImplementation(() => true);
     MockUtils.isCaipAccountId.mockImplementation(() => true);
   });
@@ -261,7 +264,7 @@ describe('Scope Assert', () => {
     });
 
     it('throws an error if passed an object with a key that is not a valid ExternalScopeString', () => {
-      jest.spyOn(Utils, 'isCaipReference').mockImplementation(() => false);
+      MockUtils.isCaipChainId.mockReturnValue(false);
 
       expect(() =>
         assertIsExternalScopesObject({ 'invalid-scope-string': {} }),
@@ -480,6 +483,44 @@ describe('Scope Assert', () => {
     });
   });
 
+  describe('assertIsInternalScopeString', () => {
+    it('throws an error if the value is not a string', () => {
+      expect(() => assertIsInternalScopeString({})).toThrow(
+        'scopeString is not a valid InternalScopeString',
+      );
+      expect(() => assertIsInternalScopeString(123)).toThrow(
+        'scopeString is not a valid InternalScopeString',
+      );
+      expect(() => assertIsInternalScopeString(undefined)).toThrow(
+        'scopeString is not a valid InternalScopeString',
+      );
+      expect(() => assertIsInternalScopeString(null)).toThrow(
+        'scopeString is not a valid InternalScopeString',
+      );
+    });
+
+    it("does not throw an error if the value is 'wallet'", () => {
+      expect(assertIsInternalScopeString('wallet')).toBeUndefined();
+      expect(MockUtils.isCaipChainId).not.toHaveBeenCalled();
+    });
+
+    it('does not throw an error if the value is a valid CAIP-2 Chain ID', () => {
+      MockUtils.isCaipChainId.mockReturnValue(true);
+
+      expect(assertIsInternalScopeString('scopeString')).toBeUndefined();
+      expect(MockUtils.isCaipChainId).toHaveBeenCalledWith('scopeString');
+    });
+
+    it('throws an error if the value is not a valid CAIP-2 Chain ID', () => {
+      MockUtils.isCaipChainId.mockReturnValue(false);
+
+      expect(() => assertIsInternalScopeString('scopeString')).toThrow(
+        'scopeString is not a valid InternalScopeString',
+      );
+      expect(MockUtils.isCaipChainId).toHaveBeenCalledWith('scopeString');
+    });
+  });
+
   describe('assertIsInternalScopesObject', () => {
     it('does not throw if passed obj is a valid InternalScopesObject with all valid properties', () => {
       const obj = {
@@ -509,7 +550,7 @@ describe('Scope Assert', () => {
     });
 
     it('throws an error if passed an object with a key that is not a valid InternalScopeString', () => {
-      jest.spyOn(Utils, 'isCaipReference').mockImplementation(() => false);
+      MockUtils.isCaipChainId.mockReturnValue(false);
 
       expect(() =>
         assertIsInternalScopesObject({ 'invalid-scope-string': {} }),
diff --git a/packages/multichain/src/scope/assert.ts b/packages/multichain/src/scope/assert.ts
index 0d2c8c16cb7..873c577575e 100644
--- a/packages/multichain/src/scope/assert.ts
+++ b/packages/multichain/src/scope/assert.ts
@@ -219,7 +219,7 @@ function assertIsInternalScopeObject(
  * Asserts that a scope string is a valid InternalScopeString.
  * @param scopeString - The scope string to assert.
  */
-function assertIsInternalScopeString(
+export function assertIsInternalScopeString(
   scopeString: unknown,
 ): asserts scopeString is InternalScopeString {
   if (
diff --git a/packages/multichain/src/scope/authorization.test.ts b/packages/multichain/src/scope/authorization.test.ts
index 4759b40edd0..885d71b0e07 100644
--- a/packages/multichain/src/scope/authorization.test.ts
+++ b/packages/multichain/src/scope/authorization.test.ts
@@ -1,8 +1,14 @@
-import { validateAndNormalizeScopes } from './authorization';
+import { bucketScopes, validateAndNormalizeScopes } from './authorization';
+import * as Filter from './filter';
 import * as Transform from './transform';
 import type { ExternalScopeObject } from './types';
 import * as Validation from './validation';
 
+jest.mock('./filter', () => ({
+  bucketScopesBySupport: jest.fn(),
+}));
+const MockFilter = jest.mocked(Filter);
+
 jest.mock('./validation', () => ({
   getValidScopes: jest.fn(),
 }));
@@ -88,4 +94,129 @@ describe('Scope Authorization', () => {
       });
     });
   });
+
+  describe('bucketScopes', () => {
+    beforeEach(() => {
+      let callCount = 0;
+      MockFilter.bucketScopesBySupport.mockImplementation(() => {
+        callCount += 1;
+        return {
+          supportedScopes: {
+            'mock:A': {
+              methods: [`mock_method_${callCount}`],
+              notifications: [],
+              accounts: [],
+            },
+          },
+          unsupportedScopes: {
+            'mock:B': {
+              methods: [`mock_method_${callCount}`],
+              notifications: [],
+              accounts: [],
+            },
+          },
+        };
+      });
+    });
+
+    it('buckets the scopes by supported', () => {
+      const isChainIdSupported = jest.fn();
+      bucketScopes(
+        {
+          wallet: {
+            methods: [],
+            notifications: [],
+            accounts: [],
+          },
+        },
+        {
+          isChainIdSupported,
+          isChainIdSupportable: jest.fn(),
+        },
+      );
+
+      expect(MockFilter.bucketScopesBySupport).toHaveBeenCalledWith(
+        {
+          wallet: {
+            methods: [],
+            notifications: [],
+            accounts: [],
+          },
+        },
+        {
+          isChainIdSupported,
+        },
+      );
+    });
+
+    it('buckets the maybe supportable scopes', () => {
+      const isChainIdSupportable = jest.fn();
+      bucketScopes(
+        {
+          wallet: {
+            methods: [],
+            notifications: [],
+            accounts: [],
+          },
+        },
+        {
+          isChainIdSupported: jest.fn(),
+          isChainIdSupportable,
+        },
+      );
+
+      expect(MockFilter.bucketScopesBySupport).toHaveBeenCalledWith(
+        {
+          'mock:B': {
+            methods: [`mock_method_1`],
+            notifications: [],
+            accounts: [],
+          },
+        },
+        {
+          isChainIdSupported: isChainIdSupportable,
+        },
+      );
+    });
+
+    it('returns the bucketed scopes', () => {
+      expect(
+        bucketScopes(
+          {
+            wallet: {
+              methods: [],
+              notifications: [],
+              accounts: [],
+            },
+          },
+          {
+            isChainIdSupported: jest.fn(),
+            isChainIdSupportable: jest.fn(),
+          },
+        ),
+      ).toStrictEqual({
+        supportedScopes: {
+          'mock:A': {
+            methods: [`mock_method_1`],
+            notifications: [],
+            accounts: [],
+          },
+        },
+        supportableScopes: {
+          'mock:A': {
+            methods: [`mock_method_2`],
+            notifications: [],
+            accounts: [],
+          },
+        },
+        unsupportableScopes: {
+          'mock:B': {
+            methods: [`mock_method_2`],
+            notifications: [],
+            accounts: [],
+          },
+        },
+      });
+    });
+  });
 });
diff --git a/packages/multichain/src/scope/authorization.ts b/packages/multichain/src/scope/authorization.ts
index 0f43fa33e40..97d796d8b6d 100644
--- a/packages/multichain/src/scope/authorization.ts
+++ b/packages/multichain/src/scope/authorization.ts
@@ -1,5 +1,6 @@
-import type { Json } from '@metamask/utils';
+import type { Hex, Json } from '@metamask/utils';
 
+import { bucketScopesBySupport } from './filter';
 import { normalizeAndMergeScopes } from './transform';
 import type {
   ExternalScopesObject,
@@ -51,3 +52,42 @@ export const validateAndNormalizeScopes = (
     normalizedOptionalScopes,
   };
 };
+
+/**
+ * Groups a NormalizedScopesObject into three separate
+ * NormalizedScopesObjects for supported scopes,
+ * supportable scopes, and unsupportable scopes.
+ * @param scopes - The NormalizedScopesObject to group.
+ * @param hooks - The hooks.
+ * @param hooks.isChainIdSupported - A helper that returns true if an eth chainId is currently supported by the wallet.
+ * @param hooks.isChainIdSupportable - A helper that returns true if an eth chainId could be supported by the wallet.
+ * @returns an object with three NormalizedScopesObjects separated by support.
+ */
+export const bucketScopes = (
+  scopes: NormalizedScopesObject,
+  {
+    isChainIdSupported,
+    isChainIdSupportable,
+  }: {
+    isChainIdSupported: (chainId: Hex) => boolean;
+    isChainIdSupportable: (chainId: Hex) => boolean;
+  },
+): {
+  supportedScopes: NormalizedScopesObject;
+  supportableScopes: NormalizedScopesObject;
+  unsupportableScopes: NormalizedScopesObject;
+} => {
+  const { supportedScopes, unsupportedScopes: maybeSupportableScopes } =
+    bucketScopesBySupport(scopes, {
+      isChainIdSupported,
+    });
+
+  const {
+    supportedScopes: supportableScopes,
+    unsupportedScopes: unsupportableScopes,
+  } = bucketScopesBySupport(maybeSupportableScopes, {
+    isChainIdSupported: isChainIdSupportable,
+  });
+
+  return { supportedScopes, supportableScopes, unsupportableScopes };
+};
diff --git a/packages/multichain/src/scope/constants.test.ts b/packages/multichain/src/scope/constants.test.ts
index fa0da9ba41e..a01691f2bf5 100644
--- a/packages/multichain/src/scope/constants.test.ts
+++ b/packages/multichain/src/scope/constants.test.ts
@@ -6,15 +6,9 @@ describe('KnownRpcMethods', () => {
       Object {
         "bip122": Array [],
         "eip155": Array [
-          "wallet_switchEthereumChain",
-          "wallet_getPermissions",
-          "wallet_requestPermissions",
-          "wallet_revokePermissions",
           "personal_sign",
           "eth_signTypedData_v4",
           "wallet_watchAsset",
-          "eth_requestAccounts",
-          "eth_accounts",
           "eth_sendTransaction",
           "eth_decrypt",
           "eth_getEncryptionPublicKey",
@@ -24,7 +18,6 @@ describe('KnownRpcMethods', () => {
           "eth_blockNumber",
           "eth_call",
           "eth_chainId",
-          "eth_coinbase",
           "eth_estimateGas",
           "eth_feeHistory",
           "eth_gasPrice",
diff --git a/packages/multichain/src/scope/constants.ts b/packages/multichain/src/scope/constants.ts
index 4273b008d0a..8ad272a7a65 100644
--- a/packages/multichain/src/scope/constants.ts
+++ b/packages/multichain/src/scope/constants.ts
@@ -27,15 +27,37 @@ export const KnownWalletRpcMethods: string[] = [
   'wallet_scanQRCode',
 ];
 
+/**
+ * Methods that belong to the `wallet:eip155` scope.
+ */
 const WalletEip155Methods = ['wallet_addEthereumChain'];
 
+/**
+ * Methods that are only supported via the EIP-1193 API.
+ */
+export const Eip1193OnlyMethods = [
+  'wallet_switchEthereumChain',
+  'wallet_getPermissions',
+  'wallet_requestPermissions',
+  'wallet_revokePermissions',
+  'eth_requestAccounts',
+  'eth_accounts',
+  'eth_coinbase',
+  'net_version',
+  'metamask_logWeb3ShimUsage',
+  'metamask_getProviderState',
+  'metamask_sendDomainMetadata',
+  'wallet_registerOnboarding',
+];
+
 /**
  * All MetaMask methods, except for ones we have specified in the constants above.
  */
 const Eip155Methods = MetaMaskOpenRPCDocument.methods
   .map(({ name }: { name: string }) => name)
   .filter((method: string) => !WalletEip155Methods.includes(method))
-  .filter((method: string) => !KnownWalletRpcMethods.includes(method));
+  .filter((method: string) => !KnownWalletRpcMethods.includes(method))
+  .filter((method: string) => !Eip1193OnlyMethods.includes(method));
 
 /**
  * Methods by ecosystem that are chain specific.
diff --git a/packages/multichain/src/scope/filter.test.ts b/packages/multichain/src/scope/filter.test.ts
new file mode 100644
index 00000000000..8be87ec7983
--- /dev/null
+++ b/packages/multichain/src/scope/filter.test.ts
@@ -0,0 +1,279 @@
+import * as Assert from './assert';
+import {
+  bucketScopesBySupport,
+  getSupportedScopeObjects,
+} from './filter';
+import * as Supported from './supported';
+
+jest.mock('./assert', () => ({
+  ...jest.requireActual('./assert'),
+  assertScopeSupported: jest.fn(),
+}));
+const MockAssert = jest.mocked(Assert);
+
+jest.mock('./supported', () => ({
+  ...jest.requireActual('./supported'),
+  isSupportedMethod: jest.fn(),
+  isSupportedNotification: jest.fn(),
+}));
+const MockSupported = jest.mocked(Supported);
+
+describe('filter', () => {
+  describe('bucketScopesBySupport', () => {
+    const isChainIdSupported = jest.fn();
+
+    it('checks if each scope is supported', () => {
+      bucketScopesBySupport(
+        {
+          'eip155:1': {
+            methods: ['a'],
+            notifications: [],
+            accounts: [],
+          },
+          'eip155:5': {
+            methods: ['b'],
+            notifications: [],
+            accounts: [],
+          },
+        },
+        { isChainIdSupported },
+      );
+
+      expect(MockAssert.assertScopeSupported).toHaveBeenCalledWith(
+        'eip155:1',
+        {
+          methods: ['a'],
+          notifications: [],
+          accounts: [],
+        },
+        { isChainIdSupported },
+      );
+      expect(MockAssert.assertScopeSupported).toHaveBeenCalledWith(
+        'eip155:5',
+        {
+          methods: ['b'],
+          notifications: [],
+          accounts: [],
+        },
+        { isChainIdSupported },
+      );
+    });
+
+    it('returns supported and unsupported scopes', () => {
+      MockAssert.assertScopeSupported.mockImplementation((scopeString) => {
+        if (scopeString === 'eip155:1') {
+          throw new Error('scope not supported');
+        }
+      });
+
+      expect(
+        bucketScopesBySupport(
+          {
+            'eip155:1': {
+              methods: ['a'],
+              notifications: [],
+              accounts: [],
+            },
+            'eip155:5': {
+              methods: ['b'],
+              notifications: [],
+              accounts: [],
+            },
+          },
+          { isChainIdSupported },
+        ),
+      ).toStrictEqual({
+        supportedScopes: {
+          'eip155:5': {
+            methods: ['b'],
+            notifications: [],
+            accounts: [],
+          },
+        },
+        unsupportedScopes: {
+          'eip155:1': {
+            methods: ['a'],
+            notifications: [],
+            accounts: [],
+          },
+        },
+      });
+    });
+  });
+
+  describe('getSupportedScopeObjects', () => {
+    it('checks if each scopeObject method is supported', () => {
+      getSupportedScopeObjects({
+        'eip155:1': {
+          methods: ['method1', 'method2'],
+          notifications: [],
+          accounts: [],
+        },
+        'eip155:5': {
+          methods: ['methodA', 'methodB'],
+          notifications: [],
+          accounts: [],
+        },
+      });
+
+      expect(MockSupported.isSupportedMethod).toHaveBeenCalledTimes(4);
+      expect(MockSupported.isSupportedMethod).toHaveBeenCalledWith(
+        'eip155:1',
+        'method1',
+      );
+      expect(MockSupported.isSupportedMethod).toHaveBeenCalledWith(
+        'eip155:1',
+        'method2',
+      );
+      expect(MockSupported.isSupportedMethod).toHaveBeenCalledWith(
+        'eip155:5',
+        'methodA',
+      );
+      expect(MockSupported.isSupportedMethod).toHaveBeenCalledWith(
+        'eip155:5',
+        'methodB',
+      );
+    });
+
+    it('returns only supported methods', () => {
+      MockSupported.isSupportedMethod.mockImplementation(
+        (scopeString, method) => {
+          if (scopeString === 'eip155:1' && method === 'method1') {
+            return false;
+          }
+          if (scopeString === 'eip155:5' && method === 'methodB') {
+            return false;
+          }
+          return true;
+        },
+      );
+
+      const result = getSupportedScopeObjects({
+        'eip155:1': {
+          methods: ['method1', 'method2'],
+          notifications: [],
+          accounts: [],
+        },
+        'eip155:5': {
+          methods: ['methodA', 'methodB'],
+          notifications: [],
+          accounts: [],
+        },
+      });
+
+      expect(result).toStrictEqual({
+        'eip155:1': {
+          methods: ['method2'],
+          notifications: [],
+          accounts: [],
+        },
+        'eip155:5': {
+          methods: ['methodA'],
+          notifications: [],
+          accounts: [],
+        },
+      });
+    });
+
+    it('checks if each scopeObject notification is supported', () => {
+      getSupportedScopeObjects({
+        'eip155:1': {
+          methods: [],
+          notifications: ['notification1', 'notification2'],
+          accounts: [],
+        },
+        'eip155:5': {
+          methods: [],
+          notifications: ['notificationA', 'notificationB'],
+          accounts: [],
+        },
+      });
+
+      expect(MockSupported.isSupportedNotification).toHaveBeenCalledTimes(4);
+      expect(MockSupported.isSupportedNotification).toHaveBeenCalledWith(
+        'eip155:1',
+        'notification1',
+      );
+      expect(MockSupported.isSupportedNotification).toHaveBeenCalledWith(
+        'eip155:1',
+        'notification2',
+      );
+      expect(MockSupported.isSupportedNotification).toHaveBeenCalledWith(
+        'eip155:5',
+        'notificationA',
+      );
+      expect(MockSupported.isSupportedNotification).toHaveBeenCalledWith(
+        'eip155:5',
+        'notificationB',
+      );
+    });
+
+    it('returns only supported notifications', () => {
+      MockSupported.isSupportedNotification.mockImplementation(
+        (scopeString, notification) => {
+          if (scopeString === 'eip155:1' && notification === 'notification1') {
+            return false;
+          }
+          if (scopeString === 'eip155:5' && notification === 'notificationB') {
+            return false;
+          }
+          return true;
+        },
+      );
+
+      const result = getSupportedScopeObjects({
+        'eip155:1': {
+          methods: [],
+          notifications: ['notification1', 'notification2'],
+          accounts: [],
+        },
+        'eip155:5': {
+          methods: [],
+          notifications: ['notificationA', 'notificationB'],
+          accounts: [],
+        },
+      });
+
+      expect(result).toStrictEqual({
+        'eip155:1': {
+          methods: [],
+          notifications: ['notification2'],
+          accounts: [],
+        },
+        'eip155:5': {
+          methods: [],
+          notifications: ['notificationA'],
+          accounts: [],
+        },
+      });
+    });
+
+    it('does not modify accounts', () => {
+      const result = getSupportedScopeObjects({
+        'eip155:1': {
+          methods: [],
+          notifications: [],
+          accounts: ['eip155:1:0xdeadbeef'],
+        },
+        'eip155:5': {
+          methods: [],
+          notifications: [],
+          accounts: ['eip155:5:0xdeadbeef'],
+        },
+      });
+
+      expect(result).toStrictEqual({
+        'eip155:1': {
+          methods: [],
+          notifications: [],
+          accounts: ['eip155:1:0xdeadbeef'],
+        },
+        'eip155:5': {
+          methods: [],
+          notifications: [],
+          accounts: ['eip155:5:0xdeadbeef'],
+        },
+      });
+    });
+  });
+});
diff --git a/packages/multichain/src/scope/filter.ts b/packages/multichain/src/scope/filter.ts
new file mode 100644
index 00000000000..0cd9a886620
--- /dev/null
+++ b/packages/multichain/src/scope/filter.ts
@@ -0,0 +1,92 @@
+import { type Hex } from '@metamask/utils';
+
+import { assertIsInternalScopeString, assertScopeSupported } from './assert';
+import { isSupportedMethod, isSupportedNotification } from './supported';
+import type {
+  InternalScopeString,
+  NormalizedScopeObject,
+  NormalizedScopesObject,
+} from './types';
+
+/**
+ * Groups a NormalizedScopesObject into two separate
+ * NormalizedScopesObject with supported scopes in one
+ * and unsupported scopes in the other.
+ * @param scopes - The NormalizedScopesObject to group.
+ * @param hooks - The hooks.
+ * @param hooks.isChainIdSupported - A helper that returns true if an eth chainId is currently supported by the wallet.
+ * @returns an object with two NormalizedScopesObjects separated by support.
+ */
+export const bucketScopesBySupport = (
+  scopes: NormalizedScopesObject,
+  {
+    isChainIdSupported,
+  }: {
+    isChainIdSupported: (chainId: Hex) => boolean;
+  },
+) => {
+  const supportedScopes: NormalizedScopesObject = {};
+  const unsupportedScopes: NormalizedScopesObject = {};
+
+  for (const [scopeString, scopeObject] of Object.entries(scopes)) {
+    assertIsInternalScopeString(scopeString);
+    try {
+      assertScopeSupported(scopeString, scopeObject, {
+        isChainIdSupported,
+      });
+      supportedScopes[scopeString] = scopeObject;
+    } catch (err) {
+      unsupportedScopes[scopeString] = scopeObject;
+    }
+  }
+
+  return { supportedScopes, unsupportedScopes };
+};
+
+/**
+ * Returns a NormalizedScopeObject with
+ * unsupported methods and notifications removed.
+ * @param scopeString - The InternalScopeString for the scopeObject.
+ * @param scopeObject - The NormalizedScopeObject to filter.
+ * @returns a NormalizedScopeObject with only methods and notifications that are currently supported.
+ */
+const getSupportedScopeObject = (
+  scopeString: InternalScopeString,
+  scopeObject: NormalizedScopeObject,
+) => {
+  const { methods, notifications } = scopeObject;
+
+  const supportedMethods = methods.filter((method) =>
+    isSupportedMethod(scopeString, method),
+  );
+
+  const supportedNotifications = notifications.filter((notification) =>
+    isSupportedNotification(scopeString, notification),
+  );
+
+  return {
+    ...scopeObject,
+    methods: supportedMethods,
+    notifications: supportedNotifications,
+  };
+};
+
+/**
+ * Returns a NormalizedScopesObject with
+ * unsupported methods and notifications removed from scopeObjects.
+ * @param scopes - The NormalizedScopesObject to filter.
+ * @returns a NormalizedScopesObject with only methods, and notifications that are currently supported.
+ */
+export const getSupportedScopeObjects = (scopes: NormalizedScopesObject) => {
+  const filteredScopesObject: NormalizedScopesObject = {};
+
+  for (const [scopeString, scopeObject] of Object.entries(scopes)) {
+    assertIsInternalScopeString(scopeString);
+    filteredScopesObject[scopeString] = getSupportedScopeObject(
+      scopeString,
+      scopeObject,
+    );
+  }
+
+  return filteredScopesObject;
+};
diff --git a/packages/multichain/src/scope/types.ts b/packages/multichain/src/scope/types.ts
index f639c58d2ea..b13b5edae75 100644
--- a/packages/multichain/src/scope/types.ts
+++ b/packages/multichain/src/scope/types.ts
@@ -60,7 +60,8 @@ export type InternalScopesObject = Record<CaipChainId, InternalScopeObject> & {
  * [CAIP-217](https://chainagnostic.org/CAIPs/caip-217), with the exception that
  * we resolve the `references` property into a scopeObject per reference and
  * assign an empty array to the `accounts` property if not already defined
- * to more easily read chain specific permissions.
+ * to more easily perform support checks for `wallet_createSession` requests.
+ * Also used as the return type for `wallet_createSession` and `wallet_sessionChanged`.
  */
 export type NormalizedScopeObject = {
   methods: string[];
@@ -74,7 +75,8 @@ export type NormalizedScopeObject = {
  * [CAIP-217](https://chainagnostic.org/CAIPs/caip-217), with the exception that
  * we resolve the `references` property into a scopeObject per reference and
  * assign an empty array to the `accounts` property if not already defined
- * to more easily read chain specific permissions.
+ * to more easily perform support checks for `wallet_createSession` requests.
+ * Also used as the return type for `wallet_createSession` and `wallet_sessionChanged`.
  */
 export type NormalizedScopesObject = Record<
   CaipChainId,
diff --git a/types/@metamask/eth-json-rpc-filters.d.ts b/types/@metamask/eth-json-rpc-filters.d.ts
new file mode 100644
index 00000000000..5a51785b82b
--- /dev/null
+++ b/types/@metamask/eth-json-rpc-filters.d.ts
@@ -0,0 +1 @@
+declare module '@metamask/eth-json-rpc-filters/subscriptionManager';
diff --git a/yarn.lock b/yarn.lock
index f88317fe241..6a417de7c06 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -193,10 +193,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/compat-data@npm:^7.25.9":
-  version: 7.26.3
-  resolution: "@babel/compat-data@npm:7.26.3"
-  checksum: 10/0bf4e491680722aa0eac26f770f2fae059f92e2ac083900b241c90a2c10f0fc80e448b1feccc2b332687fab4c3e33e9f83dee9ef56badca1fb9f3f71266d9ebf
+"@babel/compat-data@npm:^7.26.5":
+  version: 7.26.5
+  resolution: "@babel/compat-data@npm:7.26.5"
+  checksum: 10/afe35751f27bda80390fa221d5e37be55b7fc42cec80de9896086e20394f2306936c4296fcb4d62b683e3b49ba2934661ea7e06196ca2dacdc2e779fbea4a1a9
   languageName: node
   linkType: hard
 
@@ -223,65 +223,65 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/generator@npm:^7.26.0, @babel/generator@npm:^7.26.3, @babel/generator@npm:^7.7.2":
-  version: 7.26.3
-  resolution: "@babel/generator@npm:7.26.3"
+"@babel/generator@npm:^7.26.0, @babel/generator@npm:^7.26.5, @babel/generator@npm:^7.7.2":
+  version: 7.26.5
+  resolution: "@babel/generator@npm:7.26.5"
   dependencies:
-    "@babel/parser": "npm:^7.26.3"
-    "@babel/types": "npm:^7.26.3"
+    "@babel/parser": "npm:^7.26.5"
+    "@babel/types": "npm:^7.26.5"
     "@jridgewell/gen-mapping": "npm:^0.3.5"
     "@jridgewell/trace-mapping": "npm:^0.3.25"
     jsesc: "npm:^3.0.2"
-  checksum: 10/c1d8710cc1c52af9d8d67f7d8ea775578aa500887b327d2a81e27494764a6ef99e438dd7e14cf7cd3153656492ee27a8362980dc438087c0ca39d4e75532c638
+  checksum: 10/aa5f176155431d1fb541ca11a7deddec0fc021f20992ced17dc2f688a0a9584e4ff4280f92e8a39302627345cd325762f70f032764806c579c6fd69432542bcb
   languageName: node
   linkType: hard
 
-"@babel/helper-annotate-as-pure@npm:^7.24.7":
-  version: 7.24.7
-  resolution: "@babel/helper-annotate-as-pure@npm:7.24.7"
+"@babel/helper-annotate-as-pure@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-annotate-as-pure@npm:7.25.9"
   dependencies:
-    "@babel/types": "npm:^7.24.7"
-  checksum: 10/a9017bfc1c4e9f2225b967fbf818004703de7cf29686468b54002ffe8d6b56e0808afa20d636819fcf3a34b89ba72f52c11bdf1d69f303928ee10d92752cad95
+    "@babel/types": "npm:^7.25.9"
+  checksum: 10/41edda10df1ae106a9b4fe617bf7c6df77db992992afd46192534f5cff29f9e49a303231733782dd65c5f9409714a529f215325569f14282046e9d3b7a1ffb6c
   languageName: node
   linkType: hard
 
 "@babel/helper-compilation-targets@npm:^7.25.9":
-  version: 7.25.9
-  resolution: "@babel/helper-compilation-targets@npm:7.25.9"
+  version: 7.26.5
+  resolution: "@babel/helper-compilation-targets@npm:7.26.5"
   dependencies:
-    "@babel/compat-data": "npm:^7.25.9"
+    "@babel/compat-data": "npm:^7.26.5"
     "@babel/helper-validator-option": "npm:^7.25.9"
     browserslist: "npm:^4.24.0"
     lru-cache: "npm:^5.1.1"
     semver: "npm:^6.3.1"
-  checksum: 10/8053fbfc21e8297ab55c8e7f9f119e4809fa7e505268691e1bedc2cf5e7a5a7de8c60ad13da2515378621b7601c42e101d2d679904da395fa3806a1edef6b92e
+  checksum: 10/f3b5f0bfcd7b6adf03be1a494b269782531c6e415afab2b958c077d570371cf1bfe001c442508092c50ed3711475f244c05b8f04457d8dea9c34df2b741522bf
   languageName: node
   linkType: hard
 
-"@babel/helper-create-class-features-plugin@npm:^7.25.0":
-  version: 7.25.4
-  resolution: "@babel/helper-create-class-features-plugin@npm:7.25.4"
+"@babel/helper-create-class-features-plugin@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-create-class-features-plugin@npm:7.25.9"
   dependencies:
-    "@babel/helper-annotate-as-pure": "npm:^7.24.7"
-    "@babel/helper-member-expression-to-functions": "npm:^7.24.8"
-    "@babel/helper-optimise-call-expression": "npm:^7.24.7"
-    "@babel/helper-replace-supers": "npm:^7.25.0"
-    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.24.7"
-    "@babel/traverse": "npm:^7.25.4"
+    "@babel/helper-annotate-as-pure": "npm:^7.25.9"
+    "@babel/helper-member-expression-to-functions": "npm:^7.25.9"
+    "@babel/helper-optimise-call-expression": "npm:^7.25.9"
+    "@babel/helper-replace-supers": "npm:^7.25.9"
+    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.25.9"
+    "@babel/traverse": "npm:^7.25.9"
     semver: "npm:^6.3.1"
   peerDependencies:
     "@babel/core": ^7.0.0
-  checksum: 10/47218da9fd964af30d41f0635d9e33eed7518e03aa8f10c3eb8a563bb2c14f52be3e3199db5912ae0e26058c23bb511c811e565c55ecec09427b04b867ed13c2
+  checksum: 10/d1d47a7b5fd317c6cb1446b0e4f4892c19ddaa69ea0229f04ba8bea5f273fc8168441e7114ad36ff919f2d310f97310cec51adc79002e22039a7e1640ccaf248
   languageName: node
   linkType: hard
 
-"@babel/helper-member-expression-to-functions@npm:^7.24.8":
-  version: 7.24.8
-  resolution: "@babel/helper-member-expression-to-functions@npm:7.24.8"
+"@babel/helper-member-expression-to-functions@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-member-expression-to-functions@npm:7.25.9"
   dependencies:
-    "@babel/traverse": "npm:^7.24.8"
-    "@babel/types": "npm:^7.24.8"
-  checksum: 10/ac878761cfd0a46c081cda0da75cc186f922cf16e8ecdd0c4fb6dca4330d9fe4871b41a9976224cf9669c9e7fe0421b5c27349f2e99c125fa0be871b327fa770
+    "@babel/traverse": "npm:^7.25.9"
+    "@babel/types": "npm:^7.25.9"
+  checksum: 10/ef8cc1c1e600b012b312315f843226545a1a89f25d2f474ce2503fd939ca3f8585180f291a3a13efc56cf13eddc1d41a3a040eae9a521838fd59a6d04cc82490
   languageName: node
   linkType: hard
 
@@ -295,7 +295,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-module-transforms@npm:^7.24.8, @babel/helper-module-transforms@npm:^7.26.0":
+"@babel/helper-module-transforms@npm:^7.26.0":
   version: 7.26.0
   resolution: "@babel/helper-module-transforms@npm:7.26.0"
   dependencies:
@@ -308,52 +308,42 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-optimise-call-expression@npm:^7.24.7":
-  version: 7.24.7
-  resolution: "@babel/helper-optimise-call-expression@npm:7.24.7"
+"@babel/helper-optimise-call-expression@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-optimise-call-expression@npm:7.25.9"
   dependencies:
-    "@babel/types": "npm:^7.24.7"
-  checksum: 10/da7a7f2d1bb1be4cffd5fa820bd605bc075c7dd014e0458f608bb6f34f450fe9412c8cea93e788227ab396e0e02c162d7b1db3fbcb755a6360e354c485d61df0
+    "@babel/types": "npm:^7.25.9"
+  checksum: 10/f09d0ad60c0715b9a60c31841b3246b47d67650c512ce85bbe24a3124f1a4d66377df793af393273bc6e1015b0a9c799626c48e53747581c1582b99167cc65dc
   languageName: node
   linkType: hard
 
-"@babel/helper-plugin-utils@npm:^7.0.0, @babel/helper-plugin-utils@npm:^7.10.4, @babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.14.5, @babel/helper-plugin-utils@npm:^7.24.7, @babel/helper-plugin-utils@npm:^7.24.8, @babel/helper-plugin-utils@npm:^7.8.0":
-  version: 7.24.8
-  resolution: "@babel/helper-plugin-utils@npm:7.24.8"
-  checksum: 10/adbc9fc1142800a35a5eb0793296924ee8057fe35c61657774208670468a9fbfbb216f2d0bc46c680c5fefa785e5ff917cc1674b10bd75cdf9a6aa3444780630
+"@babel/helper-plugin-utils@npm:^7.0.0, @babel/helper-plugin-utils@npm:^7.10.4, @babel/helper-plugin-utils@npm:^7.12.13, @babel/helper-plugin-utils@npm:^7.14.5, @babel/helper-plugin-utils@npm:^7.25.9, @babel/helper-plugin-utils@npm:^7.26.5, @babel/helper-plugin-utils@npm:^7.8.0":
+  version: 7.26.5
+  resolution: "@babel/helper-plugin-utils@npm:7.26.5"
+  checksum: 10/1cc0fd8514da3bb249bed6c27227696ab5e84289749d7258098701cffc0c599b7f61ec40dd332f8613030564b79899d9826813c96f966330bcfc7145a8377857
   languageName: node
   linkType: hard
 
-"@babel/helper-replace-supers@npm:^7.25.0":
-  version: 7.25.0
-  resolution: "@babel/helper-replace-supers@npm:7.25.0"
+"@babel/helper-replace-supers@npm:^7.25.9":
+  version: 7.26.5
+  resolution: "@babel/helper-replace-supers@npm:7.26.5"
   dependencies:
-    "@babel/helper-member-expression-to-functions": "npm:^7.24.8"
-    "@babel/helper-optimise-call-expression": "npm:^7.24.7"
-    "@babel/traverse": "npm:^7.25.0"
+    "@babel/helper-member-expression-to-functions": "npm:^7.25.9"
+    "@babel/helper-optimise-call-expression": "npm:^7.25.9"
+    "@babel/traverse": "npm:^7.26.5"
   peerDependencies:
     "@babel/core": ^7.0.0
-  checksum: 10/97c6c17780cb9692132f7243f5a21fb6420104cb8ff8752dc03cfc9a1912a243994c0290c77ff096637ab6f2a7363b63811cfc68c2bad44e6b39460ac2f6a63f
-  languageName: node
-  linkType: hard
-
-"@babel/helper-simple-access@npm:^7.24.7":
-  version: 7.24.7
-  resolution: "@babel/helper-simple-access@npm:7.24.7"
-  dependencies:
-    "@babel/traverse": "npm:^7.24.7"
-    "@babel/types": "npm:^7.24.7"
-  checksum: 10/5083e190186028e48fc358a192e4b93ab320bd016103caffcfda81302a13300ccce46c9cd255ae520c25d2a6a9b47671f93e5fe5678954a2329dc0a685465c49
+  checksum: 10/cfb911d001a8c3d2675077dbb74ee8d7d5533b22d74f8d775cefabf19c604f6cbc22cfeb94544fe8efa626710d920f04acb22923017e68f46f5fdb1cb08b32ad
   languageName: node
   linkType: hard
 
-"@babel/helper-skip-transparent-expression-wrappers@npm:^7.24.7":
-  version: 7.24.7
-  resolution: "@babel/helper-skip-transparent-expression-wrappers@npm:7.24.7"
+"@babel/helper-skip-transparent-expression-wrappers@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/helper-skip-transparent-expression-wrappers@npm:7.25.9"
   dependencies:
-    "@babel/traverse": "npm:^7.24.7"
-    "@babel/types": "npm:^7.24.7"
-  checksum: 10/784a6fdd251a9a7e42ccd04aca087ecdab83eddc60fda76a2950e00eb239cc937d3c914266f0cc476298b52ac3f44ffd04c358e808bd17552a7e008d75494a77
+    "@babel/traverse": "npm:^7.25.9"
+    "@babel/types": "npm:^7.25.9"
+  checksum: 10/fdbb5248932198bc26daa6abf0d2ac42cab9c2dbb75b7e9f40d425c8f28f09620b886d40e7f9e4e08ffc7aaa2cefe6fc2c44be7c20e81f7526634702fb615bdc
   languageName: node
   linkType: hard
 
@@ -371,7 +361,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/helper-validator-option@npm:^7.24.7, @babel/helper-validator-option@npm:^7.25.9":
+"@babel/helper-validator-option@npm:^7.25.9":
   version: 7.25.9
   resolution: "@babel/helper-validator-option@npm:7.25.9"
   checksum: 10/9491b2755948ebbdd68f87da907283698e663b5af2d2b1b02a2765761974b1120d5d8d49e9175b167f16f72748ffceec8c9cf62acfbee73f4904507b246e2b3d
@@ -388,14 +378,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.0, @babel/parser@npm:^7.24.7, @babel/parser@npm:^7.25.9, @babel/parser@npm:^7.26.0, @babel/parser@npm:^7.26.3":
-  version: 7.26.3
-  resolution: "@babel/parser@npm:7.26.3"
+"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.0, @babel/parser@npm:^7.25.3, @babel/parser@npm:^7.25.9, @babel/parser@npm:^7.26.0, @babel/parser@npm:^7.26.5":
+  version: 7.26.5
+  resolution: "@babel/parser@npm:7.26.5"
   dependencies:
-    "@babel/types": "npm:^7.26.3"
+    "@babel/types": "npm:^7.26.5"
   bin:
     parser: ./bin/babel-parser.js
-  checksum: 10/e7e3814b2dc9ee3ed605d38223471fa7d3a84cbe9474d2b5fa7ac57dc1ddf75577b1fd3a93bf7db8f41f28869bda795cddd80223f980be23623b6434bf4c88a8
+  checksum: 10/d92097066e3e26625a485149f54c27899e4d94d7ef2f76d8fc9de2019212e7951940a31c0003f26ccad22e664f89ff51e5d5fe80a11eafaaec2420655010533c
   languageName: node
   linkType: hard
 
@@ -444,13 +434,13 @@ __metadata:
   linkType: hard
 
 "@babel/plugin-syntax-import-attributes@npm:^7.24.7":
-  version: 7.24.7
-  resolution: "@babel/plugin-syntax-import-attributes@npm:7.24.7"
+  version: 7.26.0
+  resolution: "@babel/plugin-syntax-import-attributes@npm:7.26.0"
   dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.24.7"
+    "@babel/helper-plugin-utils": "npm:^7.25.9"
   peerDependencies:
     "@babel/core": ^7.0.0-0
-  checksum: 10/22fc50bd85a491bb8d22065f330a41f60d66f2f2d7a1deb73e80c8a4b5d7a42a092a03f8da18800650eca0fc14585167cc4e5c9fab351f0d390d1592347162ae
+  checksum: 10/c122aa577166c80ee67f75aebebeef4150a132c4d3109d25d7fc058bf802946f883e330f20b78c1d3e3a5ada631c8780c263d2d01b5dbaecc69efefeedd42916
   languageName: node
   linkType: hard
 
@@ -476,14 +466,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-jsx@npm:^7.24.7":
-  version: 7.24.7
-  resolution: "@babel/plugin-syntax-jsx@npm:7.24.7"
+"@babel/plugin-syntax-jsx@npm:^7.25.9":
+  version: 7.25.9
+  resolution: "@babel/plugin-syntax-jsx@npm:7.25.9"
   dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.24.7"
+    "@babel/helper-plugin-utils": "npm:^7.25.9"
   peerDependencies:
     "@babel/core": ^7.0.0-0
-  checksum: 10/a93516ae5b34868ab892a95315027d4e5e38e8bd1cfca6158f2974b0901cbb32bbe64ea10ad5b25f919ddc40c6d8113c4823372909c9c9922170c12b0b1acecb
+  checksum: 10/bb609d1ffb50b58f0c1bac8810d0e46a4f6c922aa171c458f3a19d66ee545d36e782d3bffbbc1fed0dc65a558bdce1caf5279316583c0fff5a2c1658982a8563
   languageName: node
   linkType: hard
 
@@ -575,66 +565,65 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/plugin-syntax-typescript@npm:^7.24.7, @babel/plugin-syntax-typescript@npm:^7.7.2":
-  version: 7.25.4
-  resolution: "@babel/plugin-syntax-typescript@npm:7.25.4"
+"@babel/plugin-syntax-typescript@npm:^7.25.9, @babel/plugin-syntax-typescript@npm:^7.7.2":
+  version: 7.25.9
+  resolution: "@babel/plugin-syntax-typescript@npm:7.25.9"
   dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.24.8"
+    "@babel/helper-plugin-utils": "npm:^7.25.9"
   peerDependencies:
     "@babel/core": ^7.0.0-0
-  checksum: 10/0771b45a35fd536cd3b3a48e5eda0f53e2d4f4a0ca07377cc247efa39eaf6002ed1c478106aad2650e54aefaebcb4f34f3284c4ae9252695dbd944bf66addfb0
+  checksum: 10/0e9821e8ba7d660c36c919654e4144a70546942ae184e85b8102f2322451eae102cbfadbcadd52ce077a2b44b400ee52394c616feab7b5b9f791b910e933fd33
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-modules-commonjs@npm:^7.23.3, @babel/plugin-transform-modules-commonjs@npm:^7.24.7":
-  version: 7.24.8
-  resolution: "@babel/plugin-transform-modules-commonjs@npm:7.24.8"
+"@babel/plugin-transform-modules-commonjs@npm:^7.23.3, @babel/plugin-transform-modules-commonjs@npm:^7.25.9":
+  version: 7.26.3
+  resolution: "@babel/plugin-transform-modules-commonjs@npm:7.26.3"
   dependencies:
-    "@babel/helper-module-transforms": "npm:^7.24.8"
-    "@babel/helper-plugin-utils": "npm:^7.24.8"
-    "@babel/helper-simple-access": "npm:^7.24.7"
+    "@babel/helper-module-transforms": "npm:^7.26.0"
+    "@babel/helper-plugin-utils": "npm:^7.25.9"
   peerDependencies:
     "@babel/core": ^7.0.0-0
-  checksum: 10/18e5d229767c7b5b6ff0cbf1a8d2d555965b90201839d0ac2dc043b56857624ea344e59f733f028142a8c1d54923b82e2a0185694ef36f988d797bfbaf59819c
+  checksum: 10/f817f02fa04d13f1578f3026239b57f1003bebcf9f9b8d854714bed76a0e4986c79bd6d2e0ac14282c5d309454a8dab683c179709ca753b0152a69c69f3a78e3
   languageName: node
   linkType: hard
 
-"@babel/plugin-transform-typescript@npm:^7.24.7":
-  version: 7.25.2
-  resolution: "@babel/plugin-transform-typescript@npm:7.25.2"
+"@babel/plugin-transform-typescript@npm:^7.25.9":
+  version: 7.26.5
+  resolution: "@babel/plugin-transform-typescript@npm:7.26.5"
   dependencies:
-    "@babel/helper-annotate-as-pure": "npm:^7.24.7"
-    "@babel/helper-create-class-features-plugin": "npm:^7.25.0"
-    "@babel/helper-plugin-utils": "npm:^7.24.8"
-    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.24.7"
-    "@babel/plugin-syntax-typescript": "npm:^7.24.7"
+    "@babel/helper-annotate-as-pure": "npm:^7.25.9"
+    "@babel/helper-create-class-features-plugin": "npm:^7.25.9"
+    "@babel/helper-plugin-utils": "npm:^7.26.5"
+    "@babel/helper-skip-transparent-expression-wrappers": "npm:^7.25.9"
+    "@babel/plugin-syntax-typescript": "npm:^7.25.9"
   peerDependencies:
     "@babel/core": ^7.0.0-0
-  checksum: 10/50e017ffd131c08661daa22b6c759999bb7a6cdfbf683291ee4bcbea4ae839440b553d2f8896bcf049aca1d267b39f3b09e8336059e919e83149b5ad859671f6
+  checksum: 10/28c315ed51cf6a23e14181ee8b265e6ae5bc474cd604e6dac5a4fa5aed114447972690a7d327d8f8e679b7fa18e52218fced0e2a039e4eb854c6016f00dff956
   languageName: node
   linkType: hard
 
 "@babel/preset-typescript@npm:^7.23.3":
-  version: 7.24.7
-  resolution: "@babel/preset-typescript@npm:7.24.7"
+  version: 7.26.0
+  resolution: "@babel/preset-typescript@npm:7.26.0"
   dependencies:
-    "@babel/helper-plugin-utils": "npm:^7.24.7"
-    "@babel/helper-validator-option": "npm:^7.24.7"
-    "@babel/plugin-syntax-jsx": "npm:^7.24.7"
-    "@babel/plugin-transform-modules-commonjs": "npm:^7.24.7"
-    "@babel/plugin-transform-typescript": "npm:^7.24.7"
+    "@babel/helper-plugin-utils": "npm:^7.25.9"
+    "@babel/helper-validator-option": "npm:^7.25.9"
+    "@babel/plugin-syntax-jsx": "npm:^7.25.9"
+    "@babel/plugin-transform-modules-commonjs": "npm:^7.25.9"
+    "@babel/plugin-transform-typescript": "npm:^7.25.9"
   peerDependencies:
     "@babel/core": ^7.0.0-0
-  checksum: 10/995e9783f8e474581e7533d6b10ec1fbea69528cc939ad8582b5937e13548e5215d25a8e2c845e7b351fdaa13139896b5e42ab3bde83918ea4e41773f10861ac
+  checksum: 10/81a60826160163a3daae017709f42147744757b725b50c9024ef3ee5a402ee45fd2e93eaecdaaa22c81be91f7940916249cfb7711366431cfcacc69c95878c03
   languageName: node
   linkType: hard
 
 "@babel/runtime@npm:^7.23.9":
-  version: 7.25.4
-  resolution: "@babel/runtime@npm:7.25.4"
+  version: 7.26.0
+  resolution: "@babel/runtime@npm:7.26.0"
   dependencies:
     regenerator-runtime: "npm:^0.14.0"
-  checksum: 10/70d2a420c24a3289ea6c4addaf3a1c4186bc3d001c92445faa3cd7601d7d2fbdb32c63b3a26b9771e20ff2f511fa76b726bf256f823cdb95bc37b8eadbd02f70
+  checksum: 10/9f4ea1c1d566c497c052d505587554e782e021e6ccd302c2ad7ae8291c8e16e3f19d4a7726fb64469e057779ea2081c28b7dbefec6d813a22f08a35712c0f699
   languageName: node
   linkType: hard
 
@@ -649,28 +638,28 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@babel/traverse@npm:^7.23.2, @babel/traverse@npm:^7.24.7, @babel/traverse@npm:^7.24.8, @babel/traverse@npm:^7.25.0, @babel/traverse@npm:^7.25.4, @babel/traverse@npm:^7.25.9, @babel/traverse@npm:^7.7.2":
-  version: 7.26.4
-  resolution: "@babel/traverse@npm:7.26.4"
+"@babel/traverse@npm:^7.23.2, @babel/traverse@npm:^7.25.9, @babel/traverse@npm:^7.26.5, @babel/traverse@npm:^7.7.2":
+  version: 7.26.5
+  resolution: "@babel/traverse@npm:7.26.5"
   dependencies:
     "@babel/code-frame": "npm:^7.26.2"
-    "@babel/generator": "npm:^7.26.3"
-    "@babel/parser": "npm:^7.26.3"
+    "@babel/generator": "npm:^7.26.5"
+    "@babel/parser": "npm:^7.26.5"
     "@babel/template": "npm:^7.25.9"
-    "@babel/types": "npm:^7.26.3"
+    "@babel/types": "npm:^7.26.5"
     debug: "npm:^4.3.1"
     globals: "npm:^11.1.0"
-  checksum: 10/30c81a80d66fc39842814bc2e847f4705d30f3859156f130d90a0334fe1d53aa81eed877320141a528ecbc36448acc0f14f544a7d410fa319d1c3ab63b50b58f
+  checksum: 10/b0131159450e3cd4208354cdea57e832e1a344fcc284b6ac84d1e13567a10501c4747bfd0ce637d2bd02277526b49372cfca71edd5c825cea74dcc9f52bb9225
   languageName: node
   linkType: hard
 
-"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.23.0, @babel/types@npm:^7.24.7, @babel/types@npm:^7.24.8, @babel/types@npm:^7.25.9, @babel/types@npm:^7.26.0, @babel/types@npm:^7.26.3, @babel/types@npm:^7.3.3":
-  version: 7.26.3
-  resolution: "@babel/types@npm:7.26.3"
+"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.23.0, @babel/types@npm:^7.25.9, @babel/types@npm:^7.26.0, @babel/types@npm:^7.26.5, @babel/types@npm:^7.3.3":
+  version: 7.26.5
+  resolution: "@babel/types@npm:7.26.5"
   dependencies:
     "@babel/helper-string-parser": "npm:^7.25.9"
     "@babel/helper-validator-identifier": "npm:^7.25.9"
-  checksum: 10/c31d0549630a89abfa11410bf82a318b0c87aa846fbf5f9905e47ba5e2aa44f41cc746442f105d622c519e4dc532d35a8d8080460ff4692f9fc7485fbf3a00eb
+  checksum: 10/148f6bead7bc39371176ba681873c930087503a8bfd2b0dab5090de32752241806c95f4e87cee8b2976bb0277c6cbc150f16c333fc90269634b711d3711c0f18
   languageName: node
   linkType: hard
 
@@ -682,29 +671,29 @@ __metadata:
   linkType: hard
 
 "@contentful/content-source-maps@npm:^0.11.0":
-  version: 0.11.1
-  resolution: "@contentful/content-source-maps@npm:0.11.1"
+  version: 0.11.7
+  resolution: "@contentful/content-source-maps@npm:0.11.7"
   dependencies:
     "@vercel/stega": "npm:^0.1.2"
     json-pointer: "npm:^0.6.2"
-  checksum: 10/598e88349210aed21c9ee871250353ae15cb4130180ade9cf283261e192a80c72f8674c5533c490ad1358850e45578ed6ed4ac997b32c23b029ae4d096fa5646
+  checksum: 10/7d228f73fc6be3aa2f341fcae7d15cdc60565d81dc9b0770a33f5d50aa729faeb6e33a19c2b8211932119857d06ab858e5e60da9778a5901f06940c7d2ecb78a
   languageName: node
   linkType: hard
 
 "@contentful/rich-text-html-renderer@npm:^16.5.2":
-  version: 16.6.9
-  resolution: "@contentful/rich-text-html-renderer@npm:16.6.9"
+  version: 16.6.10
+  resolution: "@contentful/rich-text-html-renderer@npm:16.6.10"
   dependencies:
-    "@contentful/rich-text-types": "npm:^16.8.4"
+    "@contentful/rich-text-types": "npm:^16.8.5"
     escape-html: "npm:^1.0.3"
-  checksum: 10/10bdcee4c01b89e5ab54ccab592bad7d3658fdd32ee58e2d5d18628a59ca47c7393c8dec41e96172b4c171f7fb4d2d1d6b9da9d6eeebbe5ed83fc3de8c4c0c89
+  checksum: 10/fdf5121524355c96cd8a4628b2cc50a61b9b9d37da167dd983cc8fa24fa822427809d00064ebca9b85b8f40d92719f0b86f0e4ea4eaa8d078656ed56c51df6bb
   languageName: node
   linkType: hard
 
-"@contentful/rich-text-types@npm:^16.0.2, @contentful/rich-text-types@npm:^16.8.4":
-  version: 16.8.4
-  resolution: "@contentful/rich-text-types@npm:16.8.4"
-  checksum: 10/22e0a165545f32cc51d1e6231a9e7b617af98c452ecfb28ace9ba8a53b89bb2d940019ffae00ef2bc77c998630a66bfc88d01031e732afb11172f877064aa5b2
+"@contentful/rich-text-types@npm:^16.0.2, @contentful/rich-text-types@npm:^16.8.5":
+  version: 16.8.5
+  resolution: "@contentful/rich-text-types@npm:16.8.5"
+  checksum: 10/7c1ec7088cc39bbd8f5edc14867ed3d59d06a55f2c92e6c62913aa2312056e920528e6ca6d59780b32c6fe2ab89c429b9f0bce9a52f456be7260f458527ccc3b
   languageName: node
   linkType: hard
 
@@ -717,10 +706,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@endo/env-options@npm:^1.1.5":
-  version: 1.1.5
-  resolution: "@endo/env-options@npm:1.1.5"
-  checksum: 10/ce4cb29ecf387f52f7d1c9e7e43b0a1064326587ebac62e7c239bf2df71aa4c3296d2a05cf169d1efcd8c1ddf73aeede8afd86e7b5c9387b80e8e0939d1af0f6
+"@endo/env-options@npm:^1.1.8":
+  version: 1.1.8
+  resolution: "@endo/env-options@npm:1.1.8"
+  checksum: 10/f7e84346599dd2bcb6365c314e9a8129c5ebbb457476de72ed896ea461d616c0b7e0dfc7733e20c0abb8400212fb5eafdae993bcfd4cbfe92acbb5c881a6ad0d
   languageName: node
   linkType: hard
 
@@ -764,12 +753,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@eslint/core@npm:^0.9.0":
-  version: 0.9.1
-  resolution: "@eslint/core@npm:0.9.1"
+"@eslint/core@npm:^0.10.0":
+  version: 0.10.0
+  resolution: "@eslint/core@npm:0.10.0"
   dependencies:
     "@types/json-schema": "npm:^7.0.15"
-  checksum: 10/f2263f8f94fdf84fc34573e027de98f1fce6287120513ae672ddf0652c75b9fa77c314d565628fc58e0a6f959766acc34c8191f9b94f1757b910408ffa04adde
+  checksum: 10/de41d7fa5dc468b70fb15c72829096939fc0217c41b8519af4620bc1089cb42539a15325c4c3ee3832facac1836c8c944c4a0c4d0cc8b33ffd8e95962278ae14
   languageName: node
   linkType: hard
 
@@ -790,10 +779,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@eslint/js@npm:9.17.0, @eslint/js@npm:^9.11.0":
-  version: 9.17.0
-  resolution: "@eslint/js@npm:9.17.0"
-  checksum: 10/1a89e62f5c50e75d44565b7f3b91701455a999132c991e10bac59c118fbb54bdd54be22b9bda1ac730f78a2e64604403d65ce5dd7726d80b2632982cfc3d84ac
+"@eslint/js@npm:9.18.0, @eslint/js@npm:^9.11.0":
+  version: 9.18.0
+  resolution: "@eslint/js@npm:9.18.0"
+  checksum: 10/364a7d030dad9dbda1458d8dbcea0199fe7d48bcfefe4b49389df6c45cdc5a2449f70e5d8a794e46ed9fb34af3fe5a3f53e30020d306b6ee791e2a1b2b9fa25f
   languageName: node
   linkType: hard
 
@@ -804,12 +793,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@eslint/plugin-kit@npm:^0.2.3":
-  version: 0.2.4
-  resolution: "@eslint/plugin-kit@npm:0.2.4"
+"@eslint/plugin-kit@npm:^0.2.5":
+  version: 0.2.5
+  resolution: "@eslint/plugin-kit@npm:0.2.5"
   dependencies:
+    "@eslint/core": "npm:^0.10.0"
     levn: "npm:^0.4.1"
-  checksum: 10/e34d02ea1dccd716e51369620263a4b2167aff3c0510ed776e21336cc3ad7158087449a76931baf07cdc33810cb6919db375f2e9f409435d2c6e0dd5f4786b25
+  checksum: 10/82d0142bc7054587bde4f75c2c517f477df7c320e4bdb47a4d5f766899a313ce65e9ce5d59428178d0be473a95292065053f69637042546b811ad89079781cbc
   languageName: node
   linkType: hard
 
@@ -1145,25 +1135,18 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@fastify/busboy@npm:^2.0.0":
-  version: 2.1.1
-  resolution: "@fastify/busboy@npm:2.1.1"
-  checksum: 10/2bb8a7eca8289ed14c9eb15239bc1019797454624e769b39a0b90ed204d032403adc0f8ed0d2aef8a18c772205fa7808cf5a1b91f21c7bfc7b6032150b1062c5
-  languageName: node
-  linkType: hard
-
-"@firebase/analytics-compat@npm:0.2.13":
-  version: 0.2.13
-  resolution: "@firebase/analytics-compat@npm:0.2.13"
+"@firebase/analytics-compat@npm:0.2.14":
+  version: 0.2.14
+  resolution: "@firebase/analytics-compat@npm:0.2.14"
   dependencies:
-    "@firebase/analytics": "npm:0.10.7"
+    "@firebase/analytics": "npm:0.10.8"
     "@firebase/analytics-types": "npm:0.8.2"
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/37af40ac540c68593a118e75c0fc2031459633b46d3fd32f97290fd8c3865fe425cc85feac2243c461924da698e27f4a5c174898e847027b5afd347274080c9c
+  checksum: 10/0e368159d24223076b488b27308c11e5ef50456aff49fc58e1f66616228021c61e60c3299f63ce52ddc2f7099d803e9048bc28cd952cf5c302917002c03c85ee
   languageName: node
   linkType: hard
 
@@ -1174,34 +1157,34 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/analytics@npm:0.10.7":
-  version: 0.10.7
-  resolution: "@firebase/analytics@npm:0.10.7"
+"@firebase/analytics@npm:0.10.8":
+  version: 0.10.8
+  resolution: "@firebase/analytics@npm:0.10.8"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/installations": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/installations": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/610c67d4ebbd671ace4d0baf2fa7733e1fa97a2f900cb6337b054528a7c98110d861030b2f3c95553ed81253a9cd152edf2b9dc9388a8bec679050bf46674cfe
+  checksum: 10/152ddaf68146f02baa7060d34426c25ec13890a53942ffa2db09faa148bef35f59ee9810e6fb8f561fb3d115b71d1fb9fb111d2a0f0199aa510220782557c765
   languageName: node
   linkType: hard
 
-"@firebase/app-check-compat@npm:0.3.14":
-  version: 0.3.14
-  resolution: "@firebase/app-check-compat@npm:0.3.14"
+"@firebase/app-check-compat@npm:0.3.15":
+  version: 0.3.15
+  resolution: "@firebase/app-check-compat@npm:0.3.15"
   dependencies:
-    "@firebase/app-check": "npm:0.8.7"
+    "@firebase/app-check": "npm:0.8.8"
     "@firebase/app-check-types": "npm:0.5.2"
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/8d4c835fa95474d556b36ec73f571f3e967cbe590cc76f9964eb9d50905becadf195c5e3cd628fc278efb162529a86a0b5433b72d5d232249168865ab8564392
+  checksum: 10/ae541d324d5f91dbb7b479855d3380c4fe73e365013b80973a54620405093e6fd2f8e418549155b3a527530472a19b6edf6df1481a708f823eba42e376105b28
   languageName: node
   linkType: hard
 
@@ -1219,30 +1202,30 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/app-check@npm:0.8.7":
-  version: 0.8.7
-  resolution: "@firebase/app-check@npm:0.8.7"
+"@firebase/app-check@npm:0.8.8":
+  version: 0.8.8
+  resolution: "@firebase/app-check@npm:0.8.8"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/3f09160bccd99006e33d7bc342dc6c242094be7ffccc6ff0259207006f93f645badb5c1c1743c8a1540d0dab6536a5019eff0ba231b37488ead1209b853287ac
+  checksum: 10/a3676f2143c8e438d7e8ac11bb163af30880f6ce6acc5cc54cfcc214b8efd5dabce14c040626f8a64a3967db144b99834f1108c2076a0eae8a6baf864b5a3d77
   languageName: node
   linkType: hard
 
-"@firebase/app-compat@npm:0.2.39":
-  version: 0.2.39
-  resolution: "@firebase/app-compat@npm:0.2.39"
+"@firebase/app-compat@npm:0.2.43":
+  version: 0.2.43
+  resolution: "@firebase/app-compat@npm:0.2.43"
   dependencies:
-    "@firebase/app": "npm:0.10.9"
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/app": "npm:0.10.13"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
-  checksum: 10/266a35f349417d8f5ecc69b4d877b0a41e4ef78ddd927fa8f90eb15ea3d709bed7d504b6be49407e2a1e14ad392933be6aff5eb67c2127ab68a00ddb7c26f806
+  checksum: 10/e27340dbc9804ffd0d469cc1fa919cd61b6e04fe96599d14414aa06c3dcbe75b23c324f0bedfff4dbd5d9b829b8dde5a2e8b5464f1f686d66f9c00971d9d4c56
   languageName: node
   linkType: hard
 
@@ -1253,32 +1236,32 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/app@npm:0.10.9":
-  version: 0.10.9
-  resolution: "@firebase/app@npm:0.10.9"
+"@firebase/app@npm:0.10.13":
+  version: 0.10.13
+  resolution: "@firebase/app@npm:0.10.13"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     idb: "npm:7.1.1"
     tslib: "npm:^2.1.0"
-  checksum: 10/faf344390ce2a857171ca347ca6b81b867b6d4acd87232698c4a93678100c82308796cf906cecad287dadcc83b0a645a22678292b3fb3a97c94cc3ee44c88609
+  checksum: 10/54ec64b3a992c2f30c800fb5638bf586e7e7f351899887c701d5f946ad8ca445d8c1d3024007b7939a7e6ae29a51d90567552a863323594dc6fca22f1e811e0b
   languageName: node
   linkType: hard
 
-"@firebase/auth-compat@npm:0.5.12":
-  version: 0.5.12
-  resolution: "@firebase/auth-compat@npm:0.5.12"
+"@firebase/auth-compat@npm:0.5.14":
+  version: 0.5.14
+  resolution: "@firebase/auth-compat@npm:0.5.14"
   dependencies:
-    "@firebase/auth": "npm:1.7.7"
+    "@firebase/auth": "npm:1.7.9"
     "@firebase/auth-types": "npm:0.12.2"
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
-    undici: "npm:5.28.4"
+    undici: "npm:6.19.7"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/1eeeec3ce7983dbadd1e95cf75e7665486d68eb60b0bc56642412120bdb05d2a389294343532b3cff2114ab8b782c00620ddecf5c194944bfcaead016075a568
+  checksum: 10/85d5259e7b04b14b5d02dc1fb19b015d742c594c14138f33f13146ed9f6caa7ed9d19d65bb99aaca57e70ffd2a491e520d8638eadefbd00f839d37ef972cbbda
   languageName: node
   linkType: hard
 
@@ -1299,86 +1282,101 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/auth@npm:1.7.7":
-  version: 1.7.7
-  resolution: "@firebase/auth@npm:1.7.7"
+"@firebase/auth@npm:1.7.9":
+  version: 1.7.9
+  resolution: "@firebase/auth@npm:1.7.9"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
-    undici: "npm:5.28.4"
+    undici: "npm:6.19.7"
   peerDependencies:
     "@firebase/app": 0.x
     "@react-native-async-storage/async-storage": ^1.18.1
   peerDependenciesMeta:
     "@react-native-async-storage/async-storage":
       optional: true
-  checksum: 10/fe329cdb9cd827cf0c3dd6cba6090496b79bcc09b0e53e685026dc9a1c723310387d4e3655d300ed4789608c7d0fcacbb666c19c4c2be7f416dcc47fb91df0cd
+  checksum: 10/010013ec339c9ef7b4d9278c6cacfd8e2eb3282f27a3e4e89c42a5968955976a26277421f34fda3e9400409a22a61f632bcc03e713b3f39d71e4777bc003165d
   languageName: node
   linkType: hard
 
-"@firebase/component@npm:0.6.8":
-  version: 0.6.8
-  resolution: "@firebase/component@npm:0.6.8"
+"@firebase/component@npm:0.6.9":
+  version: 0.6.9
+  resolution: "@firebase/component@npm:0.6.9"
   dependencies:
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
-  checksum: 10/0df2a61a9d3a32981a82889b4f23923c9adc468e89cadec5984b52d2422bb2b184c1219ed78dc7ec0b7f973ac0b7c2e8f486dee4a32a6741c0627648960e4314
+  checksum: 10/76c865d640e4b24a0e50876ecdc0e1199df38af562131a937b5a4bac924d61b6933339afb7906881dca509f38f3b0c511cd6b5008e061424c61b20876de9531e
   languageName: node
   linkType: hard
 
-"@firebase/database-compat@npm:1.0.7":
-  version: 1.0.7
-  resolution: "@firebase/database-compat@npm:1.0.7"
+"@firebase/data-connect@npm:0.1.0":
+  version: 0.1.0
+  resolution: "@firebase/data-connect@npm:0.1.0"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/database": "npm:1.0.7"
-    "@firebase/database-types": "npm:1.0.4"
+    "@firebase/auth-interop-types": "npm:0.2.3"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
-  checksum: 10/87d6185b65d58784e0c645a8be232f034d7e3bdfbe030b7d88b5597f7d18dc9329a6c6b0eab84f887ab87ef34caf171afc5b97bbd917fa8682015286cb9fcad4
+  peerDependencies:
+    "@firebase/app": 0.x
+  checksum: 10/20dac7c4755a0dde17abea0c99b41e96c9f7eea6ea39c36fd85f3f5554991b718a25b4bc1f92850208ec1f0e3b1ee584b1cf1913c4ad6c41643655682c06a2b0
   languageName: node
   linkType: hard
 
-"@firebase/database-types@npm:1.0.4":
-  version: 1.0.4
-  resolution: "@firebase/database-types@npm:1.0.4"
+"@firebase/database-compat@npm:1.0.8":
+  version: 1.0.8
+  resolution: "@firebase/database-compat@npm:1.0.8"
+  dependencies:
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/database": "npm:1.0.8"
+    "@firebase/database-types": "npm:1.0.5"
+    "@firebase/logger": "npm:0.4.2"
+    "@firebase/util": "npm:1.10.0"
+    tslib: "npm:^2.1.0"
+  checksum: 10/28389efcc87da77b822cb27c31707824fe98e7b0a3bf9cbf2b0c0fccd9edd72e2681a9467b76b120281464dbfc814852ebca63d99a385a9cb68fb55c7b334105
+  languageName: node
+  linkType: hard
+
+"@firebase/database-types@npm:1.0.5":
+  version: 1.0.5
+  resolution: "@firebase/database-types@npm:1.0.5"
   dependencies:
     "@firebase/app-types": "npm:0.9.2"
-    "@firebase/util": "npm:1.9.7"
-  checksum: 10/d76125998d322d1fa31a6bf028e21ba03eafb26d7ae3b408ea8f84f52caf1dea716a236a21c64deb857c5eb091ea53cf148b9a2b99f4e97efc5b7c8cabae9acd
+    "@firebase/util": "npm:1.10.0"
+  checksum: 10/bdf667da0369dce8623987fc01cad8db09cfe1895130f69ab581d34a0ee043ca6113c32457629147ae1441a934d985ede9d7cbe104ac346de6d0c21629903a8b
   languageName: node
   linkType: hard
 
-"@firebase/database@npm:1.0.7":
-  version: 1.0.7
-  resolution: "@firebase/database@npm:1.0.7"
+"@firebase/database@npm:1.0.8":
+  version: 1.0.8
+  resolution: "@firebase/database@npm:1.0.8"
   dependencies:
     "@firebase/app-check-interop-types": "npm:0.3.2"
     "@firebase/auth-interop-types": "npm:0.2.3"
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     faye-websocket: "npm:0.11.4"
     tslib: "npm:^2.1.0"
-  checksum: 10/d299c07ac647efb09b644ff91c2aa1d49622c16adc40f75506563aeb8de73f79b17949a13db8089337497e570cebf0df69e8404e934d44a49bb703d05375c245
+  checksum: 10/adb199a6ad7866b418e8b319cc505e108bfc8200b5406f21857706df0849d4e5982a1b0e44e07001821edebef73c4dfffc7f96fb77a2cff10bb9ac26f17d40c3
   languageName: node
   linkType: hard
 
-"@firebase/firestore-compat@npm:0.3.35":
-  version: 0.3.35
-  resolution: "@firebase/firestore-compat@npm:0.3.35"
+"@firebase/firestore-compat@npm:0.3.38":
+  version: 0.3.38
+  resolution: "@firebase/firestore-compat@npm:0.3.38"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/firestore": "npm:4.7.0"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/firestore": "npm:4.7.3"
     "@firebase/firestore-types": "npm:3.0.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/e3d4cb5cbf555e840eef862cace318d5dc829546c2c7e29d8cabd5ff5d0eb7c756405c4985490c0e1cd524b3dd1ed4e19d4d4a06230e5b6126adac0571010d99
+  checksum: 10/de9e92b5ac612ea73322407b65b1d90067f7138d2159bcfd2400535d09968ea8c8b44956282172129eca78bf951f74a6991394b2634913458927570bb4fa8cd8
   languageName: node
   linkType: hard
 
@@ -1392,36 +1390,36 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/firestore@npm:4.7.0":
-  version: 4.7.0
-  resolution: "@firebase/firestore@npm:4.7.0"
+"@firebase/firestore@npm:4.7.3":
+  version: 4.7.3
+  resolution: "@firebase/firestore@npm:4.7.3"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     "@firebase/webchannel-wrapper": "npm:1.0.1"
     "@grpc/grpc-js": "npm:~1.9.0"
     "@grpc/proto-loader": "npm:^0.7.8"
     tslib: "npm:^2.1.0"
-    undici: "npm:5.28.4"
+    undici: "npm:6.19.7"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/b3cb3a62bd3cc5b7ade8689d396d0b0a49821d8709caf787078bbc9306e5d4ddbcb20afbda5138b09934e5fc30ce3561e53419776e7ca454a5025fd195343b12
+  checksum: 10/f46a6e3c03eadfa970d8ecc17627d0d696931a19092fcf5be4b2056a209da3691be0bd040a11d333d26c15fd14329ce0fb5dfc32bf2cfa530a4d035b45ef4edf
   languageName: node
   linkType: hard
 
-"@firebase/functions-compat@npm:0.3.12":
-  version: 0.3.12
-  resolution: "@firebase/functions-compat@npm:0.3.12"
+"@firebase/functions-compat@npm:0.3.14":
+  version: 0.3.14
+  resolution: "@firebase/functions-compat@npm:0.3.14"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/functions": "npm:0.11.6"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/functions": "npm:0.11.8"
     "@firebase/functions-types": "npm:0.6.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/d9803c909e848dc381c892d36885a9519b5b025a46afb2c096bf099e840c5c0afc2290b5660a9d763cf6a8bf0ad6f303f85d3011abfc02d75348452bfe3200c8
+  checksum: 10/a8d6cbcdc646d78adecfcdc1f8fa14a5d9af2394dd69cac00c6826106b923e01d246c67fb7e09025ca7cfb876f8d5df97240cc056c64ccee8899ca5f17178a6c
   languageName: node
   linkType: hard
 
@@ -1432,35 +1430,35 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/functions@npm:0.11.6":
-  version: 0.11.6
-  resolution: "@firebase/functions@npm:0.11.6"
+"@firebase/functions@npm:0.11.8":
+  version: 0.11.8
+  resolution: "@firebase/functions@npm:0.11.8"
   dependencies:
     "@firebase/app-check-interop-types": "npm:0.3.2"
     "@firebase/auth-interop-types": "npm:0.2.3"
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/messaging-interop-types": "npm:0.2.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
-    undici: "npm:5.28.4"
+    undici: "npm:6.19.7"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/c1ac2887dd986c8abc408db1da26531f5f9d252f2cd4ee36352239ed0a0fc11902dd1f85db9ec21818028fd737c5a09461c01c0701c85f9ea96b9dc8dfc69f03
+  checksum: 10/44f3e42df189f3f3cb3c366b38e93a0ffdfaa1a7b3f6dba624bcd9a7cda3d3271df66f2769b7cbe7e1e5ff01bf6ab3bef6c1e1e15c6646e34514d1e2ebb60555
   languageName: node
   linkType: hard
 
-"@firebase/installations-compat@npm:0.2.8":
-  version: 0.2.8
-  resolution: "@firebase/installations-compat@npm:0.2.8"
+"@firebase/installations-compat@npm:0.2.9":
+  version: 0.2.9
+  resolution: "@firebase/installations-compat@npm:0.2.9"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/installations": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/installations": "npm:0.6.9"
     "@firebase/installations-types": "npm:0.5.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/b0eece054763ac6d229b2fca7ead9cbdd10e6c8429be9f03d95e8ed4a488fcf1cbc3a136f49800b07f2b82fb0f5ff1fecb41bee923aa045314ed854bada256d8
+  checksum: 10/919e1a4f4b63f5fe757a3c9cefb4a36cbab92deb4a6e15f249c94d6e80d1c6d37e5e384a460af8c17fc88e3091594bf43d036c88b704516c279b5ab8401977e1
   languageName: node
   linkType: hard
 
@@ -1473,17 +1471,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/installations@npm:0.6.8":
-  version: 0.6.8
-  resolution: "@firebase/installations@npm:0.6.8"
+"@firebase/installations@npm:0.6.9":
+  version: 0.6.9
+  resolution: "@firebase/installations@npm:0.6.9"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/util": "npm:1.10.0"
     idb: "npm:7.1.1"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/84cdf30d393fad859f035b276c0ef372cd94907fe042498cdd7c24a719d786866a2f976834b90a49c543e37ae317edd669676830ba7cd83f3a3d34b6f2c0f1ee
+  checksum: 10/349c8b7e877b002fb29f274f4d239fbca4c2c266ccb66ecfb5f1762f973a7fe1be99cc3346184d1230e6e35feb2b6f9e8b7169479fa0018b53e4a83837848619
   languageName: node
   linkType: hard
 
@@ -1496,17 +1494,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/messaging-compat@npm:0.2.10":
-  version: 0.2.10
-  resolution: "@firebase/messaging-compat@npm:0.2.10"
+"@firebase/messaging-compat@npm:0.2.12":
+  version: 0.2.12
+  resolution: "@firebase/messaging-compat@npm:0.2.12"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/messaging": "npm:0.12.10"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/messaging": "npm:0.12.12"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/3565546cc935f553c0331dc86e593cd39e09c198c549e801dfb9d4ee53152fcc3bab277355bf1a82a063506b8462038dbd3d2122178b9c1edd39c08a0503244d
+  checksum: 10/0437ba6b24327d9eb02dc87ba61146fbb9720491ad671dc554438ac87e162d5fb154c704400d55c87ce01dd5aeedada9d0367fd114d840ead0d07802475eaa60
   languageName: node
   linkType: hard
 
@@ -1517,35 +1515,35 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/messaging@npm:0.12.10":
-  version: 0.12.10
-  resolution: "@firebase/messaging@npm:0.12.10"
+"@firebase/messaging@npm:0.12.12":
+  version: 0.12.12
+  resolution: "@firebase/messaging@npm:0.12.12"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/installations": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/installations": "npm:0.6.9"
     "@firebase/messaging-interop-types": "npm:0.2.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     idb: "npm:7.1.1"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/c883b465da2cdee0e08f37119bcb4eb1152bec482fe87136f4dbc6fc9ffbbba1f7c25fff70948844633949ab77bc38d81afd31e7227bf398863cccb878be3095
+  checksum: 10/a00125489085782faf189ad42f75bed108c6632b9d198d114e0a8ce28d89f9455b4f78ff8f7d24d4a86ad13e1e14e0f17fa2ff3605c6dd0c8ff1b65fef23ce3d
   languageName: node
   linkType: hard
 
-"@firebase/performance-compat@npm:0.2.8":
-  version: 0.2.8
-  resolution: "@firebase/performance-compat@npm:0.2.8"
+"@firebase/performance-compat@npm:0.2.9":
+  version: 0.2.9
+  resolution: "@firebase/performance-compat@npm:0.2.9"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/performance": "npm:0.6.8"
+    "@firebase/performance": "npm:0.6.9"
     "@firebase/performance-types": "npm:0.2.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/354a31f31c0d07df10a2b33f4ef2b34ba931cb51738c533c5af9e85c1645d9421f2262ec72eb54a3821f1df52644254f92b866d836c528d6a8ff91b399a2aad4
+  checksum: 10/bc4e8b0208c9bc603518e1388713ec80658ee109c6af80d429479447ccb85e8e831269383233c379ed66bf37469d13f5c234074d0c0c9e7e69e909be5fdeca4f
   languageName: node
   linkType: hard
 
@@ -1556,34 +1554,34 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/performance@npm:0.6.8":
-  version: 0.6.8
-  resolution: "@firebase/performance@npm:0.6.8"
+"@firebase/performance@npm:0.6.9":
+  version: 0.6.9
+  resolution: "@firebase/performance@npm:0.6.9"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/installations": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/installations": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/5c989d154daea84f009f221245231bf5050cf0d96688bf1b20add98429088c815cc6e76e91180394c9d7fe5759094bbe4261c13604ff349c67e3d7113959b146
+  checksum: 10/d682d0b1e342ed3eda1a5ddab39c8ddac33afc9edb2c7335a2f9a28eb8c268b975bbf450a3bad5443138edebaf2aa731dca0b774bcf3211a6dc215b35d86d849
   languageName: node
   linkType: hard
 
-"@firebase/remote-config-compat@npm:0.2.8":
-  version: 0.2.8
-  resolution: "@firebase/remote-config-compat@npm:0.2.8"
+"@firebase/remote-config-compat@npm:0.2.9":
+  version: 0.2.9
+  resolution: "@firebase/remote-config-compat@npm:0.2.9"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/remote-config": "npm:0.4.8"
+    "@firebase/remote-config": "npm:0.4.9"
     "@firebase/remote-config-types": "npm:0.3.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/342b27720635c7f68ce8953cd22a5badfc628c3fb9414b32d40a2eaacb2feb2068079eac15c3c811f4327a06d01aa71631a6f2cfe8b80460f1910cfd37126342
+  checksum: 10/a6db7509512d8d22b7ddf1127c741715e379e04e5b3246372bb0302d7c84afb421a94550adebecddcce5def115d61729a9580940dce6e65f8d77f9af30f69fe1
   languageName: node
   linkType: hard
 
@@ -1594,33 +1592,33 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/remote-config@npm:0.4.8":
-  version: 0.4.8
-  resolution: "@firebase/remote-config@npm:0.4.8"
+"@firebase/remote-config@npm:0.4.9":
+  version: 0.4.9
+  resolution: "@firebase/remote-config@npm:0.4.9"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/installations": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/installations": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/58f934b8cdc8582f260a8caf5b903d484d74aecba420221bf57e5df28f8ba7d3f9ca1ab58946c90ab2c29659bbfdad679fc59247468068063a5329d92cd27613
+  checksum: 10/f14189f38c8cf75db16bf8b85dd004486b1dd8242f62d697c716fa85cd32928aed549ccea8c632a528870a424fc7f04f1132a14b3b099276cd7696c78e644b28
   languageName: node
   linkType: hard
 
-"@firebase/storage-compat@npm:0.3.10":
-  version: 0.3.10
-  resolution: "@firebase/storage-compat@npm:0.3.10"
+"@firebase/storage-compat@npm:0.3.12":
+  version: 0.3.12
+  resolution: "@firebase/storage-compat@npm:0.3.12"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/storage": "npm:0.13.0"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/storage": "npm:0.13.2"
     "@firebase/storage-types": "npm:0.8.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app-compat": 0.x
-  checksum: 10/63486c25c9b241ad5a55d9ab0a448ee9fc6a53b39733709ea56bce26e32cbdd1e8d4a22601a233ee18734ba1111a7ee52ca0196c281d0f4a88061a555306efb1
+  checksum: 10/4eea49a57f1d7537da697e5ff8b4e035ff1af69e416e7eab14485753c39c25eaa5a71bd2bafba0985ac6a7ce803f98f2f2f83c613c78c8f74bce286e3259b8ec
   languageName: node
   linkType: hard
 
@@ -1634,42 +1632,42 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@firebase/storage@npm:0.13.0":
-  version: 0.13.0
-  resolution: "@firebase/storage@npm:0.13.0"
+"@firebase/storage@npm:0.13.2":
+  version: 0.13.2
+  resolution: "@firebase/storage@npm:0.13.2"
   dependencies:
-    "@firebase/component": "npm:0.6.8"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/component": "npm:0.6.9"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
-    undici: "npm:5.28.4"
+    undici: "npm:6.19.7"
   peerDependencies:
     "@firebase/app": 0.x
-  checksum: 10/b33708f14ccb4aa7755a1e4dea3ce483aec0bd077bb9db8df4238f4c96f80e39ef687940ece39c3fa7dcceb0f6e5f3a22874f19dc8d05246226d4c1637508158
+  checksum: 10/d887f80cf95ef5daa80ffb2e6d564d25abb8a3e84099bee9730c95082597a12028bbf73bfe66fca2df3cdf04eaadea8e9d74ec0a826f946bc8f002293a9983ea
   languageName: node
   linkType: hard
 
-"@firebase/util@npm:1.9.7":
-  version: 1.9.7
-  resolution: "@firebase/util@npm:1.9.7"
+"@firebase/util@npm:1.10.0":
+  version: 1.10.0
+  resolution: "@firebase/util@npm:1.10.0"
   dependencies:
     tslib: "npm:^2.1.0"
-  checksum: 10/c31290f45794af68a3ab571db1c0e3cb4d15443adfdc50107b835274b4ad525f839ee79a0da2898dd8b31e64ff811c126d338b0bab117be59c0a065ce984a89a
+  checksum: 10/eb161f1c6294ff097f3c40236820e9e6e29cd6582e5e1254148157143272493580535ee2cb9e7c6055d3909b3ef39d8b64086895b071c665827acb66742b63eb
   languageName: node
   linkType: hard
 
-"@firebase/vertexai-preview@npm:0.0.3":
-  version: 0.0.3
-  resolution: "@firebase/vertexai-preview@npm:0.0.3"
+"@firebase/vertexai-preview@npm:0.0.4":
+  version: 0.0.4
+  resolution: "@firebase/vertexai-preview@npm:0.0.4"
   dependencies:
     "@firebase/app-check-interop-types": "npm:0.3.2"
-    "@firebase/component": "npm:0.6.8"
+    "@firebase/component": "npm:0.6.9"
     "@firebase/logger": "npm:0.4.2"
-    "@firebase/util": "npm:1.9.7"
+    "@firebase/util": "npm:1.10.0"
     tslib: "npm:^2.1.0"
   peerDependencies:
     "@firebase/app": 0.x
     "@firebase/app-types": 0.x
-  checksum: 10/490ea78f153b764e117989cb0ee9abeb0f456c6daefc58aa949147b1404a2d90d49c84a04556f8d84a729692ca99ed670b9dd9b37169b93ac01dc8d9242dac13
+  checksum: 10/8ec48d81f48aebdcc63b65d802c67bf36880f256e5c2f5f3b152dc91c8c0e924053fba2fac5218716612f8ee720b25d0822337a214f16f5b7e51ce0247dfc4e5
   languageName: node
   linkType: hard
 
@@ -1794,6 +1792,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@isaacs/fs-minipass@npm:^4.0.0":
+  version: 4.0.1
+  resolution: "@isaacs/fs-minipass@npm:4.0.1"
+  dependencies:
+    minipass: "npm:^7.0.4"
+  checksum: 10/4412e9e6713c89c1e66d80bb0bb5a2a93192f10477623a27d08f228ba0316bb880affabc5bfe7f838f58a34d26c2c190da726e576cdfc18c49a72e89adabdcf5
+  languageName: node
+  linkType: hard
+
 "@istanbuljs/load-nyc-config@npm:^1.0.0":
   version: 1.1.0
   resolution: "@istanbuljs/load-nyc-config@npm:1.1.0"
@@ -2084,13 +2091,13 @@ __metadata:
   linkType: hard
 
 "@jridgewell/gen-mapping@npm:^0.3.5":
-  version: 0.3.5
-  resolution: "@jridgewell/gen-mapping@npm:0.3.5"
+  version: 0.3.8
+  resolution: "@jridgewell/gen-mapping@npm:0.3.8"
   dependencies:
     "@jridgewell/set-array": "npm:^1.2.1"
     "@jridgewell/sourcemap-codec": "npm:^1.4.10"
     "@jridgewell/trace-mapping": "npm:^0.3.24"
-  checksum: 10/81587b3c4dd8e6c60252122937cea0c637486311f4ed208b52b62aae2e7a87598f63ec330e6cd0984af494bfb16d3f0d60d3b21d7e5b4aedd2602ff3fe9d32e2
+  checksum: 10/9d3a56ab3612ab9b85d38b2a93b87f3324f11c5130859957f6500e4ac8ce35f299d5ccc3ecd1ae87597601ecf83cee29e9afd04c18777c24011073992ff946df
   languageName: node
   linkType: hard
 
@@ -2142,6 +2149,48 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@json-schema-spec/json-pointer@npm:^0.1.2":
+  version: 0.1.2
+  resolution: "@json-schema-spec/json-pointer@npm:0.1.2"
+  checksum: 10/2a691ffc11f1a266ca4d0c9e2c99791679d580f343ef69746fad623d1abcf4953adde987890e41f906767d7729604c0182341e9012388b73a44d5b21fb296453
+  languageName: node
+  linkType: hard
+
+"@json-schema-tools/dereferencer@npm:^1.6.3":
+  version: 1.6.3
+  resolution: "@json-schema-tools/dereferencer@npm:1.6.3"
+  dependencies:
+    "@json-schema-tools/reference-resolver": "npm:^1.2.6"
+    "@json-schema-tools/traverse": "npm:^1.10.4"
+    fast-safe-stringify: "npm:^2.1.1"
+  checksum: 10/da6ef5b82a8a9c3a7e62ffcab5c04c581f1e0f8165c0debdb272bb1e08ccd726107ee194487b8fa736cac00fb390b8df74bc1ad1b200eddbe25c98ee0d3d000b
+  languageName: node
+  linkType: hard
+
+"@json-schema-tools/meta-schema@npm:^1.7.5":
+  version: 1.7.5
+  resolution: "@json-schema-tools/meta-schema@npm:1.7.5"
+  checksum: 10/707dc3a285c26c37d00f418e9d0ef8a2ad1c23d4936ad5aab0ce94c9ae36a7a6125c4ca5048513af64b7e6e527b5472a1701d1f709c379acdd7ad12f6409d2cd
+  languageName: node
+  linkType: hard
+
+"@json-schema-tools/reference-resolver@npm:^1.2.6":
+  version: 1.2.6
+  resolution: "@json-schema-tools/reference-resolver@npm:1.2.6"
+  dependencies:
+    "@json-schema-spec/json-pointer": "npm:^0.1.2"
+    isomorphic-fetch: "npm:^3.0.0"
+  checksum: 10/91d6b4b2ac43f8163fd27bde6d826f29f339e9c7ce3b7e2b73b85e891fa78e3702fd487deda143a0701879cbc2fe28c53a4efce4cd2d2dd2fe6e82b64bbd9c9c
+  languageName: node
+  linkType: hard
+
+"@json-schema-tools/traverse@npm:^1.10.4":
+  version: 1.10.4
+  resolution: "@json-schema-tools/traverse@npm:1.10.4"
+  checksum: 10/0027bc90df01c5eeee0833e722b7320b53be8b5ce3f4e0e4a6e45713a38e6f88f21aba31e3dd973093ef75cd21a40c07fe8f112da8f49a7919b1c0e44c904d20
+  languageName: node
+  linkType: hard
+
 "@keystonehq/alias-sampling@npm:^0.1.1":
   version: 0.1.2
   resolution: "@keystonehq/alias-sampling@npm:0.1.2"
@@ -2200,31 +2249,32 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@lavamoat/aa@npm:^4.3.0":
-  version: 4.3.0
-  resolution: "@lavamoat/aa@npm:4.3.0"
+"@lavamoat/aa@npm:^4.3.1":
+  version: 4.3.1
+  resolution: "@lavamoat/aa@npm:4.3.1"
   dependencies:
     resolve: "npm:1.22.8"
   bin:
     lavamoat-ls: src/cli.js
-  checksum: 10/c6c24ea88194ad06a83cc2a9e0b6918ee41ab40abcc5c889e1a33f214e48eb160dd0c4cea7b0e299f86d472810ef80e7caf0b2600499222b108690516d9f8123
+  checksum: 10/664692b22c6fcf44a47259ec3b48873c0064872a5a285c7ee4ddc0f99217d5a6653236304cc393f03970f0810694ab44d1f02ce4c980ce86cc24b0e27e9c622f
   languageName: node
   linkType: hard
 
 "@lavamoat/allow-scripts@npm:^3.0.4":
-  version: 3.2.0
-  resolution: "@lavamoat/allow-scripts@npm:3.2.0"
+  version: 3.3.1
+  resolution: "@lavamoat/allow-scripts@npm:3.3.1"
   dependencies:
-    "@lavamoat/aa": "npm:^4.3.0"
+    "@lavamoat/aa": "npm:^4.3.1"
     "@npmcli/run-script": "npm:8.1.0"
     bin-links: "npm:4.0.4"
     npm-normalize-package-bin: "npm:3.0.1"
+    type-fest: "npm:4.30.0"
     yargs: "npm:17.7.2"
   peerDependencies:
     "@lavamoat/preinstall-always-fail": "*"
   bin:
     allow-scripts: src/cli.js
-  checksum: 10/21afb11ce25c0b2c9763bfb8f1127bb89f304ed83f64e00955c4d3007216a0ee553b777359e9ded874c61b3d7fa8d19ff8a35881cd3816985adab4d6b58bcb07
+  checksum: 10/78bb7502136cee509592e66a1824a3e049a392e79740d99f528774743934d28e2099d3e80beded9a6623ce8842250d6207ebeea694d08c87e4fd8e2899eb0d7a
   languageName: node
   linkType: hard
 
@@ -2337,13 +2387,13 @@ __metadata:
   linkType: soft
 
 "@metamask/api-specs@npm:^0.10.12":
-  version: 0.10.12
-  resolution: "@metamask/api-specs@npm:0.10.12"
-  checksum: 10/e592f27f350994688d3d54a8a8db16de033011ef665efe3283a77431914d8d69d1c3312fad33e4245b4984e1223b04c98da3d0a68c7f9577cf8290ba441c52ee
+  version: 0.10.13
+  resolution: "@metamask/api-specs@npm:0.10.13"
+  checksum: 10/c3a4d61a4fa5a610ee8c7bec68852d8a301e9003493ae3a37e475329cf1d37036746f3d9417026e13670eafc848895ff6274fe12472d34338f344d2f80c32d8d
   languageName: node
   linkType: hard
 
-"@metamask/approval-controller@npm:^7.1.1, @metamask/approval-controller@npm:^7.1.2, @metamask/approval-controller@workspace:packages/approval-controller":
+"@metamask/approval-controller@npm:^7.1.2, @metamask/approval-controller@workspace:packages/approval-controller":
   version: 0.0.0-use.local
   resolution: "@metamask/approval-controller@workspace:packages/approval-controller"
   dependencies:
@@ -2463,7 +2513,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@metamask/base-controller@npm:^7.0.2, @metamask/base-controller@npm:^7.1.1, @metamask/base-controller@workspace:packages/base-controller":
+"@metamask/base-controller@npm:^7.0.3, @metamask/base-controller@npm:^7.1.1, @metamask/base-controller@workspace:packages/base-controller":
   version: 0.0.0-use.local
   resolution: "@metamask/base-controller@workspace:packages/base-controller"
   dependencies:
@@ -2733,16 +2783,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@metamask/eth-block-tracker@npm:^11.0.3":
-  version: 11.0.3
-  resolution: "@metamask/eth-block-tracker@npm:11.0.3"
+"@metamask/eth-block-tracker@npm:^11.0.3, @metamask/eth-block-tracker@npm:^11.0.4":
+  version: 11.0.4
+  resolution: "@metamask/eth-block-tracker@npm:11.0.4"
   dependencies:
     "@metamask/eth-json-rpc-provider": "npm:^4.1.5"
     "@metamask/safe-event-emitter": "npm:^3.1.1"
-    "@metamask/utils": "npm:^9.1.0"
+    "@metamask/utils": "npm:^11.0.1"
     json-rpc-random-id: "npm:^1.0.1"
     pify: "npm:^5.0.0"
-  checksum: 10/c73a570f889c613ab309643c84a4aed1a4eeed5c101434da84b34babe2352218c65f863602e013a8a55052e3f80a538efed865cc5fb7af558d168c52c5a399a4
+  checksum: 10/56b60255a3ae23a378570a49c30d0c13bd74094c0509a978cad20ef57079c80bae91fd35749acb9ac5feef2922eec45a6fef8c0ee6e754cbf3722f8e5d0d771e
   languageName: node
   linkType: hard
 
@@ -2785,21 +2835,21 @@ __metadata:
   linkType: hard
 
 "@metamask/eth-json-rpc-middleware@npm:^15.0.1":
-  version: 15.0.1
-  resolution: "@metamask/eth-json-rpc-middleware@npm:15.0.1"
+  version: 15.1.2
+  resolution: "@metamask/eth-json-rpc-middleware@npm:15.1.2"
   dependencies:
-    "@metamask/eth-block-tracker": "npm:^11.0.3"
-    "@metamask/eth-json-rpc-provider": "npm:^4.1.5"
-    "@metamask/eth-sig-util": "npm:^7.0.3"
-    "@metamask/json-rpc-engine": "npm:^10.0.0"
-    "@metamask/rpc-errors": "npm:^7.0.0"
-    "@metamask/utils": "npm:^9.1.0"
+    "@metamask/eth-block-tracker": "npm:^11.0.4"
+    "@metamask/eth-json-rpc-provider": "npm:^4.1.7"
+    "@metamask/eth-sig-util": "npm:^8.1.2"
+    "@metamask/json-rpc-engine": "npm:^10.0.2"
+    "@metamask/rpc-errors": "npm:^7.0.2"
+    "@metamask/utils": "npm:^11.0.1"
     "@types/bn.js": "npm:^5.1.5"
     bn.js: "npm:^5.2.1"
     klona: "npm:^2.0.6"
     pify: "npm:^5.0.0"
     safe-stable-stringify: "npm:^2.4.3"
-  checksum: 10/9777fca31440bf0076f5d2c24e2ddb4848ecd9d41b0a5d6114c27339567e60bfcb9057d6bfa81f18f5ca0ffa848ecf9603c765f606b8de206d3e34dba519c501
+  checksum: 10/71e7d61cc58df250bfef73438a9e30cc2f78e0e979feb8a9c0be72bbad470a2fe068fa790194cb88ef56865e36156e525272bc3e1a2a7135d07f7bd81a752239
   languageName: node
   linkType: hard
 
@@ -3100,7 +3150,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/json-rpc-engine@npm:^10.0.0, @metamask/json-rpc-engine@npm:^10.0.1, @metamask/json-rpc-engine@npm:^10.0.2, @metamask/json-rpc-engine@workspace:packages/json-rpc-engine":
+"@metamask/json-rpc-engine@npm:^10.0.0, @metamask/json-rpc-engine@npm:^10.0.2, @metamask/json-rpc-engine@workspace:packages/json-rpc-engine":
   version: 0.0.0-use.local
   resolution: "@metamask/json-rpc-engine@workspace:packages/json-rpc-engine"
   dependencies:
@@ -3120,7 +3170,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/json-rpc-middleware-stream@npm:^8.0.5, @metamask/json-rpc-middleware-stream@workspace:packages/json-rpc-middleware-stream":
+"@metamask/json-rpc-middleware-stream@npm:^8.0.6, @metamask/json-rpc-middleware-stream@workspace:packages/json-rpc-middleware-stream":
   version: 0.0.0-use.local
   resolution: "@metamask/json-rpc-middleware-stream@workspace:packages/json-rpc-middleware-stream"
   dependencies:
@@ -3143,16 +3193,16 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/key-tree@npm:^9.1.2":
-  version: 9.1.2
-  resolution: "@metamask/key-tree@npm:9.1.2"
+"@metamask/key-tree@npm:^10.0.2":
+  version: 10.0.2
+  resolution: "@metamask/key-tree@npm:10.0.2"
   dependencies:
     "@metamask/scure-bip39": "npm:^2.1.1"
-    "@metamask/utils": "npm:^9.0.0"
+    "@metamask/utils": "npm:^11.0.1"
     "@noble/curves": "npm:^1.2.0"
     "@noble/hashes": "npm:^1.3.2"
     "@scure/base": "npm:^1.0.0"
-  checksum: 10/9b178a4156b2f36bf630564dd0530c41c6356492971d2bcc8f979c79c81144945823a5b770e4097e12b89b42133b81f00c95a7b8fe9931ea1dd928989ee3c406
+  checksum: 10/fd2e445c75dc3cd3976fdc38a5029ee71a6f4afcbbf5c9a17152bba70cf35df8095caa853ae62eef90a51b43f23eeb9546fc6eb7d93a099d82effe8dc7592259
   languageName: node
   linkType: hard
 
@@ -3316,13 +3366,18 @@ __metadata:
     "@metamask/auto-changelog": "npm:^3.4.4"
     "@metamask/controller-utils": "npm:^11.4.5"
     "@metamask/eth-json-rpc-filters": "npm:^9.0.0"
+    "@metamask/json-rpc-engine": "npm:^10.0.2"
     "@metamask/network-controller": "npm:^22.1.1"
     "@metamask/permission-controller": "npm:^11.0.5"
     "@metamask/rpc-errors": "npm:^7.0.2"
+    "@metamask/safe-event-emitter": "npm:^3.0.0"
     "@metamask/utils": "npm:^11.0.1"
+    "@open-rpc/meta-schema": "npm:^1.14.6"
+    "@open-rpc/schema-utils-js": "npm:^2.0.5"
     "@types/jest": "npm:^27.4.1"
     deepmerge: "npm:^4.2.2"
     jest: "npm:^27.5.1"
+    jsonschema: "npm:^1.4.1"
     lodash: "npm:^4.17.21"
     ts-jest: "npm:^27.1.4"
     typedoc: "npm:^0.24.8"
@@ -3394,14 +3449,14 @@ __metadata:
   linkType: soft
 
 "@metamask/nonce-tracker@npm:^6.0.0":
-  version: 6.0.0
-  resolution: "@metamask/nonce-tracker@npm:6.0.0"
+  version: 6.0.1
+  resolution: "@metamask/nonce-tracker@npm:6.0.1"
   dependencies:
     "@ethersproject/providers": "npm:^5.7.2"
-    async-mutex: "npm:^0.3.1"
+    async-mutex: "npm:^0.5.0"
   peerDependencies:
     "@metamask/eth-block-tracker": ">=9"
-  checksum: 10/e62edd38eeaba6d917bc3aed38017294f2bfdb59120a9fb4f093fe96a46d8d9214453a802fe782faaf4a007f4cd5f393607c70a2ff8479ecd7ef18827cad067a
+  checksum: 10/3f0ba80be867e210dbde4b3cfef7d3b458217a2b744731efb9500c6223910c08e301c1d2c69a2502b0bf396ddd6bf5328d525acafb3613756aa1ae658948ec25
   languageName: node
   linkType: hard
 
@@ -3449,27 +3504,27 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@metamask/object-multiplex@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "@metamask/object-multiplex@npm:2.0.0"
+"@metamask/object-multiplex@npm:^2.0.0, @metamask/object-multiplex@npm:^2.1.0":
+  version: 2.1.0
+  resolution: "@metamask/object-multiplex@npm:2.1.0"
   dependencies:
     once: "npm:^1.4.0"
     readable-stream: "npm:^3.6.2"
-  checksum: 10/54baea752a3ac7c2742c376512e00d4902d383e9da8787574d3b21eb0081523309e24e3915a98f3ae0341d65712b6832d2eb7eeb862f4ef0da1ead52dcde5387
+  checksum: 10/e119f695e89eb20c3174f8ac6d74587498d85cff92c37e83e167cb758b3d3147d5b5e1a997d6198d430ebcf2cede6265bf5d4513fe96dbb2d82bbc6167752caa
   languageName: node
   linkType: hard
 
 "@metamask/obs-store@npm:^9.0.0":
-  version: 9.0.0
-  resolution: "@metamask/obs-store@npm:9.0.0"
+  version: 9.1.0
+  resolution: "@metamask/obs-store@npm:9.1.0"
   dependencies:
     "@metamask/safe-event-emitter": "npm:^3.0.0"
     readable-stream: "npm:^3.6.2"
-  checksum: 10/1c202a5bbdc79a6b8b3fba946c09dc5521e87260956d30db6543e7bf3d95bd44ebd958f509e3e7332041845176487fe78d3b40bdedbc213061ba849fd978e468
+  checksum: 10/fa37a0b9e1e25f54c93a8f16449b3fc771c15b70d79d590cf41e22f871a19d673bcfd0d08b044093235d10d0bb031b47b8209d89997def0cb256abe3e371064f
   languageName: node
   linkType: hard
 
-"@metamask/permission-controller@npm:^11.0.3, @metamask/permission-controller@npm:^11.0.5, @metamask/permission-controller@workspace:packages/permission-controller":
+"@metamask/permission-controller@npm:^11.0.5, @metamask/permission-controller@workspace:packages/permission-controller":
   version: 0.0.0-use.local
   resolution: "@metamask/permission-controller@workspace:packages/permission-controller"
   dependencies:
@@ -3517,7 +3572,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/phishing-controller@npm:^12.0.2, @metamask/phishing-controller@workspace:packages/phishing-controller":
+"@metamask/phishing-controller@npm:^12.3.1, @metamask/phishing-controller@workspace:packages/phishing-controller":
   version: 0.0.0-use.local
   resolution: "@metamask/phishing-controller@workspace:packages/phishing-controller"
   dependencies:
@@ -3566,13 +3621,13 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/post-message-stream@npm:^8.1.1":
-  version: 8.1.1
-  resolution: "@metamask/post-message-stream@npm:8.1.1"
+"@metamask/post-message-stream@npm:^9.0.0":
+  version: 9.0.0
+  resolution: "@metamask/post-message-stream@npm:9.0.0"
   dependencies:
-    "@metamask/utils": "npm:^9.0.0"
+    "@metamask/utils": "npm:^11.0.1"
     readable-stream: "npm:3.6.2"
-  checksum: 10/8218d321abe734522aefaf6b44e4203966c3feaf83e2de6e68eef9dbe92b7fb47fe7fd82eae362147b1d741cc58d78bcc95d8bf02058e260ad2fb978104c96cf
+  checksum: 10/5da711d3274e724452322939a5a77c60ed1d7ed73cdaa62e95c16debc443804d5a16de116dce742e05b3fbfa962e009dfeafc3a12a66f20e163617567f2cace5
   languageName: node
   linkType: hard
 
@@ -3640,16 +3695,16 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/providers@npm:^18.1.1":
-  version: 18.1.1
-  resolution: "@metamask/providers@npm:18.1.1"
+"@metamask/providers@npm:^18.1.1, @metamask/providers@npm:^18.3.1":
+  version: 18.3.1
+  resolution: "@metamask/providers@npm:18.3.1"
   dependencies:
-    "@metamask/json-rpc-engine": "npm:^10.0.1"
-    "@metamask/json-rpc-middleware-stream": "npm:^8.0.5"
+    "@metamask/json-rpc-engine": "npm:^10.0.2"
+    "@metamask/json-rpc-middleware-stream": "npm:^8.0.6"
     "@metamask/object-multiplex": "npm:^2.0.0"
-    "@metamask/rpc-errors": "npm:^7.0.1"
+    "@metamask/rpc-errors": "npm:^7.0.2"
     "@metamask/safe-event-emitter": "npm:^3.1.1"
-    "@metamask/utils": "npm:^10.0.0"
+    "@metamask/utils": "npm:^11.0.1"
     detect-browser: "npm:^5.2.0"
     extension-port-stream: "npm:^4.1.0"
     fast-deep-equal: "npm:^3.1.3"
@@ -3657,7 +3712,7 @@ __metadata:
     readable-stream: "npm:^3.6.2"
   peerDependencies:
     webextension-polyfill: ^0.10.0 || ^0.11.0 || ^0.12.0
-  checksum: 10/dca428d84e490343d85921d4fb09216a0b64be59a036d7b4f7b5ca4e2581c29a4106d58ff9dfe0650dc2b9387dd2adad508fc61073a9fda8ebde8ee3a5137abe
+  checksum: 10/0e21ba9cce926a49dedbfe30fc964cd2349ee6bf9156f525fb894dcbc147a3ae480384884131a6b1a0a508989b547d8c8d2aeb3d10e11f67a8ee5230c45631a8
   languageName: node
   linkType: hard
 
@@ -3731,7 +3786,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/rpc-errors@npm:^7.0.0, @metamask/rpc-errors@npm:^7.0.1, @metamask/rpc-errors@npm:^7.0.2":
+"@metamask/rpc-errors@npm:^7.0.0, @metamask/rpc-errors@npm:^7.0.2":
   version: 7.0.2
   resolution: "@metamask/rpc-errors@npm:7.0.2"
   dependencies:
@@ -3742,9 +3797,9 @@ __metadata:
   linkType: hard
 
 "@metamask/safe-event-emitter@npm:^3.0.0, @metamask/safe-event-emitter@npm:^3.1.1":
-  version: 3.1.1
-  resolution: "@metamask/safe-event-emitter@npm:3.1.1"
-  checksum: 10/e24db4d7c20764bfc5b025065f92518c805f0ffb1da4820078b8cff7dcae964c0f354cf053fcb7ac659de015d5ffdf21aae5e8d44e191ee8faa9066855f22653
+  version: 3.1.2
+  resolution: "@metamask/safe-event-emitter@npm:3.1.2"
+  checksum: 10/8ef7579f9317eb5c94ecf3e6abb8d13b119af274b678805eac76abe4c0667bfdf539f385e552bb973e96333b71b77aa7c787cb3fce9cd5fb4b00f1dbbabf880d
   languageName: node
   linkType: hard
 
@@ -3817,107 +3872,111 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/slip44@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "@metamask/slip44@npm:4.0.0"
-  checksum: 10/3e47e8834b0fbdabe1f126fd78665767847ddc1f9ccc8defb23007dd71fcd2e4899c8ca04857491be3630668a3765bad1e40fdfca9a61ef33236d8d08e51535e
+"@metamask/slip44@npm:^4.1.0":
+  version: 4.1.0
+  resolution: "@metamask/slip44@npm:4.1.0"
+  checksum: 10/4265254a1800a24915bd1de15f86f196737132f9af2a084c2efc885decfc5dd87ad8f0687269d90b35e2ec64d3ea4fbff0caa793bcea6e585b1f3a290952b750
   languageName: node
   linkType: hard
 
 "@metamask/snaps-controllers@npm:^9.10.0":
-  version: 9.13.0
-  resolution: "@metamask/snaps-controllers@npm:9.13.0"
+  version: 9.17.0
+  resolution: "@metamask/snaps-controllers@npm:9.17.0"
   dependencies:
-    "@metamask/approval-controller": "npm:^7.1.1"
-    "@metamask/base-controller": "npm:^7.0.2"
-    "@metamask/json-rpc-engine": "npm:^10.0.1"
-    "@metamask/json-rpc-middleware-stream": "npm:^8.0.5"
-    "@metamask/object-multiplex": "npm:^2.0.0"
-    "@metamask/permission-controller": "npm:^11.0.3"
-    "@metamask/phishing-controller": "npm:^12.0.2"
-    "@metamask/post-message-stream": "npm:^8.1.1"
-    "@metamask/rpc-errors": "npm:^7.0.1"
-    "@metamask/snaps-registry": "npm:^3.2.2"
-    "@metamask/snaps-rpc-methods": "npm:^11.5.1"
-    "@metamask/snaps-sdk": "npm:^6.11.0"
-    "@metamask/snaps-utils": "npm:^8.6.0"
-    "@metamask/utils": "npm:^10.0.0"
+    "@metamask/approval-controller": "npm:^7.1.2"
+    "@metamask/base-controller": "npm:^7.0.3"
+    "@metamask/json-rpc-engine": "npm:^10.0.2"
+    "@metamask/json-rpc-middleware-stream": "npm:^8.0.6"
+    "@metamask/key-tree": "npm:^10.0.2"
+    "@metamask/object-multiplex": "npm:^2.1.0"
+    "@metamask/permission-controller": "npm:^11.0.5"
+    "@metamask/phishing-controller": "npm:^12.3.1"
+    "@metamask/post-message-stream": "npm:^9.0.0"
+    "@metamask/rpc-errors": "npm:^7.0.2"
+    "@metamask/snaps-registry": "npm:^3.2.3"
+    "@metamask/snaps-rpc-methods": "npm:^11.9.0"
+    "@metamask/snaps-sdk": "npm:^6.15.0"
+    "@metamask/snaps-utils": "npm:^8.8.0"
+    "@metamask/utils": "npm:^11.0.1"
     "@xstate/fsm": "npm:^2.0.0"
+    async-mutex: "npm:^0.5.0"
     browserify-zlib: "npm:^0.2.0"
     concat-stream: "npm:^2.0.0"
     fast-deep-equal: "npm:^3.1.3"
     get-npm-tarball-url: "npm:^2.0.3"
     immer: "npm:^9.0.6"
+    luxon: "npm:^3.5.0"
     nanoid: "npm:^3.1.31"
     readable-stream: "npm:^3.6.2"
     readable-web-to-node-stream: "npm:^3.0.2"
     semver: "npm:^7.5.4"
     tar-stream: "npm:^3.1.7"
   peerDependencies:
-    "@metamask/snaps-execution-environments": ^6.10.0
+    "@metamask/snaps-execution-environments": ^6.12.0
   peerDependenciesMeta:
     "@metamask/snaps-execution-environments":
       optional: true
-  checksum: 10/bcf60b61de067f89439cb15acbdf6f808b4bcda8e1cbc9debd693ca2c545c9d38c4e6f380191c4703bd9d28d7dd41e4ce5111664d7b474d5e86e460bcefc3637
+  checksum: 10/c09eb4a31e685a9fbe41f2b407d9037785e572a7ef135ecfbede3cf015eaa87bef53c17e615a85ad8bbb757d8baf969cd14766dc70c04aa7645ef819ef03417d
   languageName: node
   linkType: hard
 
-"@metamask/snaps-registry@npm:^3.2.2":
-  version: 3.2.2
-  resolution: "@metamask/snaps-registry@npm:3.2.2"
+"@metamask/snaps-registry@npm:^3.2.3":
+  version: 3.2.3
+  resolution: "@metamask/snaps-registry@npm:3.2.3"
   dependencies:
     "@metamask/superstruct": "npm:^3.1.0"
-    "@metamask/utils": "npm:^10.0.0"
+    "@metamask/utils": "npm:^11.0.1"
     "@noble/curves": "npm:^1.2.0"
     "@noble/hashes": "npm:^1.3.2"
-  checksum: 10/ca8239e838bbb913435e166136bbc9bd7222c4bd87b1525fa7ae3cdf2e0b868b5d4d90a67d1ed49633d566bdef9243abdbf5f5937b85a85d24184087f555813e
+  checksum: 10/37760f29b7aaa337d815cf0c11fa34af5093d87fdc60a3750c494cf8bae6293cd52da03e7694b467b79733052d75ec6e3781ab3590d7259a050784e5be347d12
   languageName: node
   linkType: hard
 
-"@metamask/snaps-rpc-methods@npm:^11.5.1":
-  version: 11.5.1
-  resolution: "@metamask/snaps-rpc-methods@npm:11.5.1"
+"@metamask/snaps-rpc-methods@npm:^11.9.0":
+  version: 11.9.0
+  resolution: "@metamask/snaps-rpc-methods@npm:11.9.0"
   dependencies:
-    "@metamask/key-tree": "npm:^9.1.2"
-    "@metamask/permission-controller": "npm:^11.0.3"
-    "@metamask/rpc-errors": "npm:^7.0.1"
-    "@metamask/snaps-sdk": "npm:^6.10.0"
-    "@metamask/snaps-utils": "npm:^8.5.0"
+    "@metamask/key-tree": "npm:^10.0.2"
+    "@metamask/permission-controller": "npm:^11.0.5"
+    "@metamask/rpc-errors": "npm:^7.0.2"
+    "@metamask/snaps-sdk": "npm:^6.15.0"
+    "@metamask/snaps-utils": "npm:^8.8.0"
     "@metamask/superstruct": "npm:^3.1.0"
-    "@metamask/utils": "npm:^10.0.0"
+    "@metamask/utils": "npm:^11.0.1"
     "@noble/hashes": "npm:^1.3.1"
-  checksum: 10/0f999a5dd64f1b1123366f448ae833f0e95a415791600bb535959ba67d2269fbe3c4504d47f04db71bafa79a9a87d6b832fb2e2b5ef29567078c95bce2638f35
+    luxon: "npm:^3.5.0"
+  checksum: 10/44d47d3d8dcaa349863f2df2622c6fedc15e56e77d00ee97caadf3cebef6ddca06c8d4fa199b196a067bbdce59ec9a867446c133658b098216746bc23e7245f8
   languageName: node
   linkType: hard
 
-"@metamask/snaps-sdk@npm:^6.10.0, @metamask/snaps-sdk@npm:^6.11.0, @metamask/snaps-sdk@npm:^6.7.0":
-  version: 6.11.0
-  resolution: "@metamask/snaps-sdk@npm:6.11.0"
+"@metamask/snaps-sdk@npm:^6.15.0, @metamask/snaps-sdk@npm:^6.7.0":
+  version: 6.15.0
+  resolution: "@metamask/snaps-sdk@npm:6.15.0"
   dependencies:
-    "@metamask/key-tree": "npm:^9.1.2"
-    "@metamask/providers": "npm:^18.1.1"
-    "@metamask/rpc-errors": "npm:^7.0.1"
+    "@metamask/key-tree": "npm:^10.0.2"
+    "@metamask/providers": "npm:^18.3.1"
+    "@metamask/rpc-errors": "npm:^7.0.2"
     "@metamask/superstruct": "npm:^3.1.0"
-    "@metamask/utils": "npm:^10.0.0"
-  checksum: 10/0f9b507139d1544b1b3d85ff8de81b800d543012d3ee9414c607c23abe9562e0dca48de089ed94be69f5ad981730a0f443371edfe6bc2d5ffb140b28e437bfd2
+    "@metamask/utils": "npm:^11.0.1"
+  checksum: 10/0e561a0b3ae96521efbdb7223a46e42a634f84a61f271288b5c549ccc2a974247100925d551b359bd84d76aec75529dff726176e5379f446721c48f702cf2598
   languageName: node
   linkType: hard
 
-"@metamask/snaps-utils@npm:^8.3.0, @metamask/snaps-utils@npm:^8.5.0, @metamask/snaps-utils@npm:^8.6.0":
-  version: 8.6.0
-  resolution: "@metamask/snaps-utils@npm:8.6.0"
+"@metamask/snaps-utils@npm:^8.3.0, @metamask/snaps-utils@npm:^8.8.0":
+  version: 8.8.0
+  resolution: "@metamask/snaps-utils@npm:8.8.0"
   dependencies:
     "@babel/core": "npm:^7.23.2"
     "@babel/types": "npm:^7.23.0"
-    "@metamask/base-controller": "npm:^7.0.2"
-    "@metamask/key-tree": "npm:^9.1.2"
-    "@metamask/permission-controller": "npm:^11.0.3"
-    "@metamask/rpc-errors": "npm:^7.0.1"
-    "@metamask/slip44": "npm:^4.0.0"
-    "@metamask/snaps-registry": "npm:^3.2.2"
-    "@metamask/snaps-sdk": "npm:^6.11.0"
+    "@metamask/base-controller": "npm:^7.0.3"
+    "@metamask/key-tree": "npm:^10.0.2"
+    "@metamask/permission-controller": "npm:^11.0.5"
+    "@metamask/rpc-errors": "npm:^7.0.2"
+    "@metamask/slip44": "npm:^4.1.0"
+    "@metamask/snaps-registry": "npm:^3.2.3"
+    "@metamask/snaps-sdk": "npm:^6.15.0"
     "@metamask/superstruct": "npm:^3.1.0"
-    "@metamask/utils": "npm:^10.0.0"
+    "@metamask/utils": "npm:^11.0.1"
     "@noble/hashes": "npm:^1.3.1"
     "@scure/base": "npm:^1.1.1"
     chalk: "npm:^4.1.2"
@@ -3930,7 +3989,7 @@ __metadata:
     semver: "npm:^7.5.4"
     ses: "npm:^1.1.0"
     validate-npm-package-name: "npm:^5.0.0"
-  checksum: 10/c0f538f3f95e1875f6557b6ecc32f981bc4688d581af8cdc62c6c3ab8951c138286cd0b2d1cd82f769df24fcec10f71dcda67ae9a47edcff9ff73d52672df191
+  checksum: 10/567354cf09dc74fe392e281e836325bfec570428dd77101935fa443bcc987bfdee6a568a572b92269639fda30a7f02ff1047ad887aed52b73709ab7a6bf1cddd
   languageName: node
   linkType: hard
 
@@ -4041,23 +4100,6 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@metamask/utils@npm:^10.0.0":
-  version: 10.0.0
-  resolution: "@metamask/utils@npm:10.0.0"
-  dependencies:
-    "@ethereumjs/tx": "npm:^4.2.0"
-    "@metamask/superstruct": "npm:^3.1.0"
-    "@noble/hashes": "npm:^1.3.1"
-    "@scure/base": "npm:^1.1.3"
-    "@types/debug": "npm:^4.1.7"
-    debug: "npm:^4.3.4"
-    pony-cause: "npm:^2.1.10"
-    semver: "npm:^7.5.4"
-    uuid: "npm:^9.0.1"
-  checksum: 10/9c2e6421f685d8a45145b6026a6f9fd0701eb5a2e8490fc6d18e64c103d5a62097f301cbc797790da52ceb5853bd9f65845c934b00299e69e5e6736c52b32f0f
-  languageName: node
-  linkType: hard
-
 "@metamask/utils@npm:^11.0.1":
   version: 11.0.1
   resolution: "@metamask/utils@npm:11.0.1"
@@ -4150,11 +4192,11 @@ __metadata:
   linkType: hard
 
 "@noble/curves@npm:^1.2.0":
-  version: 1.5.0
-  resolution: "@noble/curves@npm:1.5.0"
+  version: 1.8.0
+  resolution: "@noble/curves@npm:1.8.0"
   dependencies:
-    "@noble/hashes": "npm:1.4.0"
-  checksum: 10/d7707d756a887a0daf9eba709526017ac6905d4be58760947e0f0652961926295ba62a5a699d9a9f0bf2a2e0c6803381373e14542be5ff3885b3434bb59be86c
+    "@noble/hashes": "npm:1.7.0"
+  checksum: 10/c54ce84cf54b8bda1a37a10dfae2e49e5b6cdf5dd98b399efa8b8a80a286b3f8f27bde53202cb308353bfd98719938991a78bed6e43f81f13b17f8181b7b82eb
   languageName: node
   linkType: hard
 
@@ -4165,13 +4207,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@noble/hashes@npm:1.4.0, @noble/hashes@npm:^1.1.2, @noble/hashes@npm:^1.3.1, @noble/hashes@npm:^1.3.2, @noble/hashes@npm:^1.4.0, @noble/hashes@npm:~1.4.0":
+"@noble/hashes@npm:1.4.0, @noble/hashes@npm:~1.4.0":
   version: 1.4.0
   resolution: "@noble/hashes@npm:1.4.0"
   checksum: 10/e156e65794c473794c52fa9d06baf1eb20903d0d96719530f523cc4450f6c721a957c544796e6efd0197b2296e7cd70efeb312f861465e17940a3e3c7e0febc6
   languageName: node
   linkType: hard
 
+"@noble/hashes@npm:1.7.0, @noble/hashes@npm:^1.1.2, @noble/hashes@npm:^1.3.1, @noble/hashes@npm:^1.3.2, @noble/hashes@npm:^1.4.0":
+  version: 1.7.0
+  resolution: "@noble/hashes@npm:1.7.0"
+  checksum: 10/ab038a816c8c9bb986e92797e3d9c5a5b37c020e0c3edc55bcae5061dbdd457f1f0a22787f83f4787c17415ba0282a20a1e455d36ed0cdcace4ce21ef1869f60
+  languageName: node
+  linkType: hard
+
 "@noble/hashes@npm:~1.3.2":
   version: 1.3.3
   resolution: "@noble/hashes@npm:1.3.3"
@@ -4226,6 +4275,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@npmcli/agent@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "@npmcli/agent@npm:3.0.0"
+  dependencies:
+    agent-base: "npm:^7.1.0"
+    http-proxy-agent: "npm:^7.0.0"
+    https-proxy-agent: "npm:^7.0.1"
+    lru-cache: "npm:^10.0.1"
+    socks-proxy-agent: "npm:^8.0.3"
+  checksum: 10/775c9a7eb1f88c195dfb3bce70c31d0fe2a12b28b754e25c08a3edb4bc4816bfedb7ac64ef1e730579d078ca19dacf11630e99f8f3c3e0fd7b23caa5fd6d30a6
+  languageName: node
+  linkType: hard
+
 "@npmcli/fs@npm:^3.1.0":
   version: 3.1.1
   resolution: "@npmcli/fs@npm:3.1.1"
@@ -4235,6 +4297,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@npmcli/fs@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "@npmcli/fs@npm:4.0.0"
+  dependencies:
+    semver: "npm:^7.3.5"
+  checksum: 10/405c4490e1ff11cf299775449a3c254a366a4b1ffc79d87159b0ee7d5558ac9f6a2f8c0735fd6ff3873cef014cb1a44a5f9127cb6a1b2dbc408718cca9365b5a
+  languageName: node
+  linkType: hard
+
 "@npmcli/git@npm:^5.0.0":
   version: 5.0.8
   resolution: "@npmcli/git@npm:5.0.8"
@@ -4260,8 +4331,8 @@ __metadata:
   linkType: hard
 
 "@npmcli/package-json@npm:^5.0.0":
-  version: 5.2.0
-  resolution: "@npmcli/package-json@npm:5.2.0"
+  version: 5.2.1
+  resolution: "@npmcli/package-json@npm:5.2.1"
   dependencies:
     "@npmcli/git": "npm:^5.0.0"
     glob: "npm:^10.2.2"
@@ -4270,7 +4341,7 @@ __metadata:
     normalize-package-data: "npm:^6.0.0"
     proc-log: "npm:^4.0.0"
     semver: "npm:^7.5.3"
-  checksum: 10/c3d2218877bfc005bca3b7a11f53825bf16a68811b8e8ed0c9b219cceb8e8e646d70efab8c5d6decbd8007f286076468b3f456dab4d41d648aff73a5f3a6fce2
+  checksum: 10/304a819b93f79a6e0e56cb371961a66d2db72142e310d545ecbbbe4d917025a30601aa8e63a5f0cc28f0fe281c116bdaf79b334619b105a1d027a2b769ecd137
   languageName: node
   linkType: hard
 
@@ -4297,6 +4368,31 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@open-rpc/meta-schema@npm:^1.14.6, @open-rpc/meta-schema@npm:^1.14.9":
+  version: 1.14.9
+  resolution: "@open-rpc/meta-schema@npm:1.14.9"
+  checksum: 10/51505dcf7aa1a2285c78953c9b33711cede5f2765aa37dcb9ee7756d689e2ff2a89cfc6039504f0569c52a805fb9aa18f30a7c02ad7a06e793c801e43b419104
+  languageName: node
+  linkType: hard
+
+"@open-rpc/schema-utils-js@npm:^2.0.5":
+  version: 2.0.5
+  resolution: "@open-rpc/schema-utils-js@npm:2.0.5"
+  dependencies:
+    "@json-schema-tools/dereferencer": "npm:^1.6.3"
+    "@json-schema-tools/meta-schema": "npm:^1.7.5"
+    "@json-schema-tools/reference-resolver": "npm:^1.2.6"
+    "@open-rpc/meta-schema": "npm:^1.14.9"
+    ajv: "npm:^6.10.0"
+    detect-node: "npm:^2.0.4"
+    fast-safe-stringify: "npm:^2.0.7"
+    fs-extra: "npm:^10.1.0"
+    is-url: "npm:^1.2.4"
+    isomorphic-fetch: "npm:^3.0.0"
+  checksum: 10/9e10215606e9a00a47b082c9cfd70d05bf0d38de6cf1c147246c545c6997375d94cd3caafe919b71178df58b5facadfd0dcc8b6857bf5e79c40e5e33683dd3d5
+  languageName: node
+  linkType: hard
+
 "@pkgjs/parseargs@npm:^0.11.0":
   version: 0.11.0
   resolution: "@pkgjs/parseargs@npm:0.11.0"
@@ -4384,10 +4480,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@scure/base@npm:^1.0.0, @scure/base@npm:^1.1.1, @scure/base@npm:^1.1.3, @scure/base@npm:~1.1.3, @scure/base@npm:~1.1.6":
-  version: 1.1.7
-  resolution: "@scure/base@npm:1.1.7"
-  checksum: 10/fc50ffaab36cb46ff9fa4dc5052a06089ab6a6707f63d596bb34aaaec76173c9a564ac312a0b981b5e7a5349d60097b8878673c75d6cbfc4da7012b63a82099b
+"@scure/base@npm:^1.0.0, @scure/base@npm:^1.1.1, @scure/base@npm:^1.1.3":
+  version: 1.2.1
+  resolution: "@scure/base@npm:1.2.1"
+  checksum: 10/f7bdd17618ccae7a74c8cbe410a235e4adbe54aa8afe4e2fb1294338aa92f6fd04b1f1f5dea60552f638b5f5e3e74902b7baf59d3954e5e42c0a36c6baa2ebe0
+  languageName: node
+  linkType: hard
+
+"@scure/base@npm:~1.1.3, @scure/base@npm:~1.1.6":
+  version: 1.1.9
+  resolution: "@scure/base@npm:1.1.9"
+  checksum: 10/f0ab7f687bbcdee2a01377fe3cd808bf63977999672751295b6a92625d5322f4754a96d40f6bd579bc367aad48ecf8a4e6d0390e70296e6ded1076f52adb16bb
   languageName: node
   linkType: hard
 
@@ -4545,8 +4648,8 @@ __metadata:
   linkType: hard
 
 "@ts-bridge/cli@npm:^0.6.1":
-  version: 0.6.1
-  resolution: "@ts-bridge/cli@npm:0.6.1"
+  version: 0.6.2
+  resolution: "@ts-bridge/cli@npm:0.6.2"
   dependencies:
     "@ts-bridge/resolver": "npm:^0.2.0"
     chalk: "npm:^5.3.0"
@@ -4557,7 +4660,7 @@ __metadata:
   bin:
     ts-bridge: ./dist/index.js
     tsbridge: ./dist/index.js
-  checksum: 10/1cbb8fbfc7f58b804553ab9bc06b689b409d4cdd0f1e960a0ea87971ec7885b5ee2a86cb192d955c7d3611afcadb960e7dfee66aeca60f798a70e7f97aa969c3
+  checksum: 10/df690edb0c78eaa91bea93582d628ef3ee0b2555fc27f9fc12ee1eb29d681b387ba76788359190ec330e29d8a31ba8974d2420d2b8dc16adc28c669a18f76de1
   languageName: node
   linkType: hard
 
@@ -4638,11 +4741,11 @@ __metadata:
   linkType: hard
 
 "@types/bn.js@npm:^5.1.0, @types/bn.js@npm:^5.1.5":
-  version: 5.1.5
-  resolution: "@types/bn.js@npm:5.1.5"
+  version: 5.1.6
+  resolution: "@types/bn.js@npm:5.1.6"
   dependencies:
     "@types/node": "npm:*"
-  checksum: 10/9719330c86aeae0a6a447c974cf0f853ba3660ede20de61f435b03d699e30e6d8b35bf71a8dc9fdc8317784438e83177644ba068ed653d0ae0106e1ecbfe289e
+  checksum: 10/db565b5a2af59b09459d74441153bf23a0e80f1fb2d070330786054e7ce1a7285dc40afcd8f289426c61a83166bdd70814f70e2d439744686aac5d3ea75daf13
   languageName: node
   linkType: hard
 
@@ -4756,12 +4859,12 @@ __metadata:
   linkType: hard
 
 "@types/jest@npm:*":
-  version: 29.5.12
-  resolution: "@types/jest@npm:29.5.12"
+  version: 29.5.14
+  resolution: "@types/jest@npm:29.5.14"
   dependencies:
     expect: "npm:^29.0.0"
     pretty-format: "npm:^29.0.0"
-  checksum: 10/312e8dcf92cdd5a5847d6426f0940829bca6fe6b5a917248f3d7f7ef5d85c9ce78ef05e47d2bbabc40d41a930e0e36db2d443d2610a9e3db9062da2d5c904211
+  checksum: 10/59ec7a9c4688aae8ee529316c43853468b6034f453d08a2e1064b281af9c81234cec986be796288f1bbb29efe943bc950e70c8fa8faae1e460d50e3cf9760f9b
   languageName: node
   linkType: hard
 
@@ -4792,9 +4895,9 @@ __metadata:
   linkType: hard
 
 "@types/lodash@npm:^4.14.191":
-  version: 4.17.7
-  resolution: "@types/lodash@npm:4.17.7"
-  checksum: 10/b8177f19cf962414a66989837481b13f546afc2e98e8d465bec59e6ac03a59c584eb7053ce511cde3a09c5f3096d22a5ae22cfb56b23f3b0da75b0743b6b1a44
+  version: 4.17.14
+  resolution: "@types/lodash@npm:4.17.14"
+  checksum: 10/6ee40725f3e192f5ef1f493caca19210aa7acd7adc3136b8dba84d418a35be0abea0668105aed9f696ad62a54310a9c0d328971ad4b157f5bcda700424ed5aae
   languageName: node
   linkType: hard
 
@@ -4813,34 +4916,36 @@ __metadata:
   linkType: hard
 
 "@types/node@npm:*, @types/node@npm:>=12.12.47, @types/node@npm:>=13.7.0":
-  version: 22.5.0
-  resolution: "@types/node@npm:22.5.0"
+  version: 22.10.6
+  resolution: "@types/node@npm:22.10.6"
   dependencies:
-    undici-types: "npm:~6.19.2"
-  checksum: 10/89af3bd217b1559b645a9ed16d4ae3add75749814cbd8eefddd1b96003d1973afb1c8a2b23d69f3a8cc6c532e3aa185eaf5cc29a6e7c42c311a2aad4c99430ae
+    undici-types: "npm:~6.20.0"
+  checksum: 10/ac93c9b6337ddb70176abade1ca4cdec24cde93cfc19023f3e001d80cb42f1d3c2487dd1626ce016985953319de30528d9e73dc5c6e2e28be9eaa9ec0237fc1d
   languageName: node
   linkType: hard
 
-"@types/node@npm:18.15.13":
-  version: 18.15.13
-  resolution: "@types/node@npm:18.15.13"
-  checksum: 10/b9bbe923573797ef7c5fd2641a6793489e25d9369c32aeadcaa5c7c175c85b42eb12d6fe173f6781ab6f42eaa1ebd9576a419eeaa2a1ec810094adb8adaa9a54
+"@types/node@npm:22.7.5":
+  version: 22.7.5
+  resolution: "@types/node@npm:22.7.5"
+  dependencies:
+    undici-types: "npm:~6.19.2"
+  checksum: 10/e8ba102f8c1aa7623787d625389be68d64e54fcbb76d41f6c2c64e8cf4c9f4a2370e7ef5e5f1732f3c57529d3d26afdcb2edc0101c5e413a79081449825c57ac
   languageName: node
   linkType: hard
 
 "@types/node@npm:^16.18.54":
-  version: 16.18.106
-  resolution: "@types/node@npm:16.18.106"
-  checksum: 10/1970719a048bfc56554f8e132e8e5292c197d6e023d334190b0d3817a05a12bfb6537eaa24778ddb695d2073195f0545e5a4b6bcaf81b656994bbca39f349c3b
+  version: 16.18.123
+  resolution: "@types/node@npm:16.18.123"
+  checksum: 10/461cb72845a539941e38720362a391e873b5ae26c8eabc04252ed883a165d15281cc7a45da7a47b3c4e7b8cf59da8a2d9025aae9b9b74ecfdc7d3147a638a6c0
   languageName: node
   linkType: hard
 
 "@types/node@npm:^18.17.15":
-  version: 18.19.68
-  resolution: "@types/node@npm:18.19.68"
+  version: 18.19.70
+  resolution: "@types/node@npm:18.19.70"
   dependencies:
     undici-types: "npm:~5.26.4"
-  checksum: 10/024a4a8eeca21c0d1eaa575036dbc44528eae180821de71b77868ddc24d18032b988582046db4f7ea2643970a5169d790e1884153472145de07d629bc2ce2ec6
+  checksum: 10/374abb7e75f7f8b2418cde5b0a8dae0032d4e1e3a76097a507a90ed9e66e40c12d19b75493db3aa9d4f92b03ae90d7d9f67c7d64c7f73f20145577350adf0e9b
   languageName: node
   linkType: hard
 
@@ -4994,15 +5099,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/eslint-plugin@npm:8.19.1, @typescript-eslint/eslint-plugin@npm:^8.7.0":
-  version: 8.19.1
-  resolution: "@typescript-eslint/eslint-plugin@npm:8.19.1"
+"@typescript-eslint/eslint-plugin@npm:8.20.0, @typescript-eslint/eslint-plugin@npm:^8.7.0":
+  version: 8.20.0
+  resolution: "@typescript-eslint/eslint-plugin@npm:8.20.0"
   dependencies:
     "@eslint-community/regexpp": "npm:^4.10.0"
-    "@typescript-eslint/scope-manager": "npm:8.19.1"
-    "@typescript-eslint/type-utils": "npm:8.19.1"
-    "@typescript-eslint/utils": "npm:8.19.1"
-    "@typescript-eslint/visitor-keys": "npm:8.19.1"
+    "@typescript-eslint/scope-manager": "npm:8.20.0"
+    "@typescript-eslint/type-utils": "npm:8.20.0"
+    "@typescript-eslint/utils": "npm:8.20.0"
+    "@typescript-eslint/visitor-keys": "npm:8.20.0"
     graphemer: "npm:^1.4.0"
     ignore: "npm:^5.3.1"
     natural-compare: "npm:^1.4.0"
@@ -5011,64 +5116,64 @@ __metadata:
     "@typescript-eslint/parser": ^8.0.0 || ^8.0.0-alpha.0
     eslint: ^8.57.0 || ^9.0.0
     typescript: ">=4.8.4 <5.8.0"
-  checksum: 10/c9a6d3181ec01068075b85ad3ac454910b4452281d60c775cc7229827f6d6a076b7336f5f07a7ad89bf08b3224f6a49aa20342b9438702393bee0aa7315d23b2
+  checksum: 10/9f027dc0eb7b4b0afed41a6f16a731321fb45b621722ddc68d6c87c708021f10cb84efbb6bacc75c91e60a7619c9957bc9ed557bfb5925900b866ef7d6d6b8a2
   languageName: node
   linkType: hard
 
-"@typescript-eslint/parser@npm:8.19.1, @typescript-eslint/parser@npm:^8.7.0":
-  version: 8.19.1
-  resolution: "@typescript-eslint/parser@npm:8.19.1"
+"@typescript-eslint/parser@npm:8.20.0, @typescript-eslint/parser@npm:^8.7.0":
+  version: 8.20.0
+  resolution: "@typescript-eslint/parser@npm:8.20.0"
   dependencies:
-    "@typescript-eslint/scope-manager": "npm:8.19.1"
-    "@typescript-eslint/types": "npm:8.19.1"
-    "@typescript-eslint/typescript-estree": "npm:8.19.1"
-    "@typescript-eslint/visitor-keys": "npm:8.19.1"
+    "@typescript-eslint/scope-manager": "npm:8.20.0"
+    "@typescript-eslint/types": "npm:8.20.0"
+    "@typescript-eslint/typescript-estree": "npm:8.20.0"
+    "@typescript-eslint/visitor-keys": "npm:8.20.0"
     debug: "npm:^4.3.4"
   peerDependencies:
     eslint: ^8.57.0 || ^9.0.0
     typescript: ">=4.8.4 <5.8.0"
-  checksum: 10/da3db63ff655cf0fb91745ba8e52d853386f601cf6106d36f4541efcb9e2c6c3b82c6743b15680eff9eafeccaf31c9b26191a955e66ae19de9172f67335463ab
+  checksum: 10/52960498961d0927e9dc60f724e9df6445357db06133a7c00cc840823d92c8dd9f0b47cebc026aef12c316748732e5c04ca61861db05d2264cf53ab88fdb34e9
   languageName: node
   linkType: hard
 
-"@typescript-eslint/scope-manager@npm:8.19.1, @typescript-eslint/scope-manager@npm:^8.1.0":
-  version: 8.19.1
-  resolution: "@typescript-eslint/scope-manager@npm:8.19.1"
+"@typescript-eslint/scope-manager@npm:8.20.0, @typescript-eslint/scope-manager@npm:^8.1.0":
+  version: 8.20.0
+  resolution: "@typescript-eslint/scope-manager@npm:8.20.0"
   dependencies:
-    "@typescript-eslint/types": "npm:8.19.1"
-    "@typescript-eslint/visitor-keys": "npm:8.19.1"
-  checksum: 10/6ffc78b15367f211eb6650459ca2bb6bfe4c1fa95a3474adc08ee9a20c250b2e0e02fd99be36bd3dad74967ecd9349e792b5d818d85735cba40f1b5c236074d1
+    "@typescript-eslint/types": "npm:8.20.0"
+    "@typescript-eslint/visitor-keys": "npm:8.20.0"
+  checksum: 10/0ea30ba12007d77659b43bbbec463c142d3d4d36f7de381d1f59a97f95240203e79dd9a24040be7113eb4c8bd231339f9322d9a40e1a1fb178e9ac52d9c559ab
   languageName: node
   linkType: hard
 
-"@typescript-eslint/type-utils@npm:8.19.1":
-  version: 8.19.1
-  resolution: "@typescript-eslint/type-utils@npm:8.19.1"
+"@typescript-eslint/type-utils@npm:8.20.0":
+  version: 8.20.0
+  resolution: "@typescript-eslint/type-utils@npm:8.20.0"
   dependencies:
-    "@typescript-eslint/typescript-estree": "npm:8.19.1"
-    "@typescript-eslint/utils": "npm:8.19.1"
+    "@typescript-eslint/typescript-estree": "npm:8.20.0"
+    "@typescript-eslint/utils": "npm:8.20.0"
     debug: "npm:^4.3.4"
     ts-api-utils: "npm:^2.0.0"
   peerDependencies:
     eslint: ^8.57.0 || ^9.0.0
     typescript: ">=4.8.4 <5.8.0"
-  checksum: 10/123ecda88b057d6a4b68226701f435661440a420fda88cba60b49d7fb3e4f49483164ff174f259e28c0beabb0ed04500462a20faefd78331ba202bf54b01e3ef
+  checksum: 10/cdde9d30e684c0c44434ed97e11c962d8f80f53b8a0050e8fe10b7f20c26f7684a340acd21c83bdcbc1feb3eef334eb5b0fef31d2d330648e52d4afe57942a95
   languageName: node
   linkType: hard
 
-"@typescript-eslint/types@npm:8.19.1":
-  version: 8.19.1
-  resolution: "@typescript-eslint/types@npm:8.19.1"
-  checksum: 10/5833a5f8fdac4a490dd3906a0243a0713fbf138fabb451870c70b0b089c539a9624b467b0913ddc0a225a8284342e7fd31cd506dec53c1a6d8f3c8c8902b9cae
+"@typescript-eslint/types@npm:8.20.0":
+  version: 8.20.0
+  resolution: "@typescript-eslint/types@npm:8.20.0"
+  checksum: 10/434859226136ea9e439e8abf5dcf813ea3b55b7e4af6ecc8d290a2f925e3baad0579765ac32d21005b0caedaac38b8624131f87b572c84ca92ac3e742a52e149
   languageName: node
   linkType: hard
 
-"@typescript-eslint/typescript-estree@npm:8.19.1":
-  version: 8.19.1
-  resolution: "@typescript-eslint/typescript-estree@npm:8.19.1"
+"@typescript-eslint/typescript-estree@npm:8.20.0":
+  version: 8.20.0
+  resolution: "@typescript-eslint/typescript-estree@npm:8.20.0"
   dependencies:
-    "@typescript-eslint/types": "npm:8.19.1"
-    "@typescript-eslint/visitor-keys": "npm:8.19.1"
+    "@typescript-eslint/types": "npm:8.20.0"
+    "@typescript-eslint/visitor-keys": "npm:8.20.0"
     debug: "npm:^4.3.4"
     fast-glob: "npm:^3.3.2"
     is-glob: "npm:^4.0.3"
@@ -5077,32 +5182,32 @@ __metadata:
     ts-api-utils: "npm:^2.0.0"
   peerDependencies:
     typescript: ">=4.8.4 <5.8.0"
-  checksum: 10/5de467452d5ef1a380d441b06cd0134652a0c98cdb4ce31b93eb589f7dc75ef60364d03fd80ca0a48d0c8b268f7258d4f6528b16fe1b89442d60a4bc960fe5f5
+  checksum: 10/8dbb1b835492574b4c8765c64964179e258f811d3f4cd7f6a90e1cb297520090728f77366cfb05233c26f4c07b1f2be990fa3f54eae9e7abc218005d51ee6804
   languageName: node
   linkType: hard
 
-"@typescript-eslint/utils@npm:8.19.1, @typescript-eslint/utils@npm:^6.0.0 || ^7.0.0 || ^8.0.0, @typescript-eslint/utils@npm:^8.1.0":
-  version: 8.19.1
-  resolution: "@typescript-eslint/utils@npm:8.19.1"
+"@typescript-eslint/utils@npm:8.20.0, @typescript-eslint/utils@npm:^6.0.0 || ^7.0.0 || ^8.0.0, @typescript-eslint/utils@npm:^8.1.0":
+  version: 8.20.0
+  resolution: "@typescript-eslint/utils@npm:8.20.0"
   dependencies:
     "@eslint-community/eslint-utils": "npm:^4.4.0"
-    "@typescript-eslint/scope-manager": "npm:8.19.1"
-    "@typescript-eslint/types": "npm:8.19.1"
-    "@typescript-eslint/typescript-estree": "npm:8.19.1"
+    "@typescript-eslint/scope-manager": "npm:8.20.0"
+    "@typescript-eslint/types": "npm:8.20.0"
+    "@typescript-eslint/typescript-estree": "npm:8.20.0"
   peerDependencies:
     eslint: ^8.57.0 || ^9.0.0
     typescript: ">=4.8.4 <5.8.0"
-  checksum: 10/bb92116a53fe143ee87e830941afb21d4222a64ca3f2b6dac5c2d9984f981408e60e52b04c32d95208896075ac222fb4ee631c5b0c4826b87d4bd8091c421ab1
+  checksum: 10/d4369f3e535d5c75eedce2b8f4ea1e857b75ac2ea73f2c707ba3fa3533053f63d8c22f085e58573a2d035d61ed69f6fef4ba0bc7c7df173d26b3adce73bf6aed
   languageName: node
   linkType: hard
 
-"@typescript-eslint/visitor-keys@npm:8.19.1":
-  version: 8.19.1
-  resolution: "@typescript-eslint/visitor-keys@npm:8.19.1"
+"@typescript-eslint/visitor-keys@npm:8.20.0":
+  version: 8.20.0
+  resolution: "@typescript-eslint/visitor-keys@npm:8.20.0"
   dependencies:
-    "@typescript-eslint/types": "npm:8.19.1"
+    "@typescript-eslint/types": "npm:8.20.0"
     eslint-visitor-keys: "npm:^4.2.0"
-  checksum: 10/510eb196e7b7d59d3981d672a75454615159e931fe78e2a64b09607c3cfa45110709b0eb5ac3dd271d757a0d98cf4868ad2f45bf9193f96e9efec3efa92a19c1
+  checksum: 10/31f32efb975a10cb1b0028a6d0f47b65acb322ed446f93862e39a3a0d5b55a2354ab0f062794fb148f45c8ce09fb93878d8a101a72d09d4a06ffa2f0d163d65f
   languageName: node
   linkType: hard
 
@@ -5113,60 +5218,60 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@vue/compiler-core@npm:3.4.38":
-  version: 3.4.38
-  resolution: "@vue/compiler-core@npm:3.4.38"
+"@vue/compiler-core@npm:3.5.13":
+  version: 3.5.13
+  resolution: "@vue/compiler-core@npm:3.5.13"
   dependencies:
-    "@babel/parser": "npm:^7.24.7"
-    "@vue/shared": "npm:3.4.38"
+    "@babel/parser": "npm:^7.25.3"
+    "@vue/shared": "npm:3.5.13"
     entities: "npm:^4.5.0"
     estree-walker: "npm:^2.0.2"
     source-map-js: "npm:^1.2.0"
-  checksum: 10/16449e9083c290e6c13e1cc0cb0a0a457817a52533d10902388c872fb1337ba0fa29fb7b8394df5a10f5ed3bad264d6c386f9eaf47c07982a543f277dbee9b8a
+  checksum: 10/22f042bb47c8a1edb9d602e24da8092ab542d5640f0459a9b99ecf35f90e96678f870209dd30f774f5340c6d817d3c5a46ca49cefb9659ee5b228bd42d1f076a
   languageName: node
   linkType: hard
 
-"@vue/compiler-dom@npm:3.4.38":
-  version: 3.4.38
-  resolution: "@vue/compiler-dom@npm:3.4.38"
+"@vue/compiler-dom@npm:3.5.13":
+  version: 3.5.13
+  resolution: "@vue/compiler-dom@npm:3.5.13"
   dependencies:
-    "@vue/compiler-core": "npm:3.4.38"
-    "@vue/shared": "npm:3.4.38"
-  checksum: 10/4012fab212dc0628ef72f5ae13aa2dd551efb8be7f2aa8abe2a1db15058ddda29912a1e3aa1fc6712e2d8efe84724f16a907ad2cda987631bfc79330afc8d451
+    "@vue/compiler-core": "npm:3.5.13"
+    "@vue/shared": "npm:3.5.13"
+  checksum: 10/5dc628c52091264a443c2d7326b759d7d3999c7e9c00078c2eb370b778e60b9f2ef258a8decf2fd97c8fa0923f895d449eabc1e5bc3d8a45d3ef99c9eb0599d7
   languageName: node
   linkType: hard
 
 "@vue/compiler-sfc@npm:^3.3.4":
-  version: 3.4.38
-  resolution: "@vue/compiler-sfc@npm:3.4.38"
-  dependencies:
-    "@babel/parser": "npm:^7.24.7"
-    "@vue/compiler-core": "npm:3.4.38"
-    "@vue/compiler-dom": "npm:3.4.38"
-    "@vue/compiler-ssr": "npm:3.4.38"
-    "@vue/shared": "npm:3.4.38"
+  version: 3.5.13
+  resolution: "@vue/compiler-sfc@npm:3.5.13"
+  dependencies:
+    "@babel/parser": "npm:^7.25.3"
+    "@vue/compiler-core": "npm:3.5.13"
+    "@vue/compiler-dom": "npm:3.5.13"
+    "@vue/compiler-ssr": "npm:3.5.13"
+    "@vue/shared": "npm:3.5.13"
     estree-walker: "npm:^2.0.2"
-    magic-string: "npm:^0.30.10"
-    postcss: "npm:^8.4.40"
+    magic-string: "npm:^0.30.11"
+    postcss: "npm:^8.4.48"
     source-map-js: "npm:^1.2.0"
-  checksum: 10/3eec1ddc03e06a162087dbbff9679f941ff34c43e553006aa2717c6a396445f488b62b89afa9cf65688468a05d8517bf1ee64936ad78d7ba6647a850a089e0e0
+  checksum: 10/08d55bbdbe86ad0a1fc0501dbf5f535161d35ecb378adb478dd4a75b97e8d21852516966c0ad8aed1d6da11b0d8280b7848ff142b4181cb8f24eaaecd7827f73
   languageName: node
   linkType: hard
 
-"@vue/compiler-ssr@npm:3.4.38":
-  version: 3.4.38
-  resolution: "@vue/compiler-ssr@npm:3.4.38"
+"@vue/compiler-ssr@npm:3.5.13":
+  version: 3.5.13
+  resolution: "@vue/compiler-ssr@npm:3.5.13"
   dependencies:
-    "@vue/compiler-dom": "npm:3.4.38"
-    "@vue/shared": "npm:3.4.38"
-  checksum: 10/3ee052c8f10bf18db5d6788df21105698c139fac1de6c82532878cca86be4d052510a216184b3ea73331d84befcefd3f9ada11470c862f03696fed96ce1005cb
+    "@vue/compiler-dom": "npm:3.5.13"
+    "@vue/shared": "npm:3.5.13"
+  checksum: 10/09f2706455a7d8a5acc67c98120d28d0105d006184402b045636be7791939f5a77fd1c37657047b0129fa431f03437dcab9befc6baa172367ecdef7618407149
   languageName: node
   linkType: hard
 
-"@vue/shared@npm:3.4.38":
-  version: 3.4.38
-  resolution: "@vue/shared@npm:3.4.38"
-  checksum: 10/46bfc1f3932fd154ff84dcd267cae4db730c98db433c848d40c9c0dc23dcabdb5efe96a3a378c9ed3b7e8281ca17e2753f0ce98ae43b54b315550dfaccb56868
+"@vue/shared@npm:3.5.13":
+  version: 3.5.13
+  resolution: "@vue/shared@npm:3.5.13"
+  checksum: 10/5c0c24f443533392dde08c3e4272ff2e19af9762f90baeaa808850e05106537bbd9e2d2ad2081d979b8c4bc89902395b46036b67f74c60b76025924de37833b1
   languageName: node
   linkType: hard
 
@@ -5178,17 +5283,17 @@ __metadata:
   linkType: hard
 
 "@yarnpkg/cli@npm:^4.5.3":
-  version: 4.5.3
-  resolution: "@yarnpkg/cli@npm:4.5.3"
+  version: 4.6.0
+  resolution: "@yarnpkg/cli@npm:4.6.0"
   dependencies:
-    "@yarnpkg/core": "npm:^4.1.6"
+    "@yarnpkg/core": "npm:^4.2.0"
     "@yarnpkg/fslib": "npm:^3.1.1"
     "@yarnpkg/libzip": "npm:^3.1.0"
     "@yarnpkg/parsers": "npm:^3.0.2"
     "@yarnpkg/plugin-compat": "npm:^4.0.10"
     "@yarnpkg/plugin-constraints": "npm:^4.0.2"
     "@yarnpkg/plugin-dlx": "npm:^4.0.0"
-    "@yarnpkg/plugin-essentials": "npm:^4.2.2"
+    "@yarnpkg/plugin-essentials": "npm:^4.3.0"
     "@yarnpkg/plugin-exec": "npm:^3.0.0"
     "@yarnpkg/plugin-file": "npm:^3.0.0"
     "@yarnpkg/plugin-git": "npm:^3.1.0"
@@ -5202,12 +5307,12 @@ __metadata:
     "@yarnpkg/plugin-npm-cli": "npm:^4.0.4"
     "@yarnpkg/plugin-pack": "npm:^4.0.0"
     "@yarnpkg/plugin-patch": "npm:^4.0.1"
-    "@yarnpkg/plugin-pnp": "npm:^4.0.5"
+    "@yarnpkg/plugin-pnp": "npm:^4.0.6"
     "@yarnpkg/plugin-pnpm": "npm:^2.0.0"
     "@yarnpkg/plugin-stage": "npm:^4.0.0"
     "@yarnpkg/plugin-typescript": "npm:^4.1.1"
     "@yarnpkg/plugin-version": "npm:^4.0.4"
-    "@yarnpkg/plugin-workspace-tools": "npm:^4.1.1"
+    "@yarnpkg/plugin-workspace-tools": "npm:^4.1.2"
     "@yarnpkg/shell": "npm:^4.1.1"
     ci-info: "npm:^4.0.0"
     clipanion: "npm:^4.0.0-rc.2"
@@ -5215,14 +5320,14 @@ __metadata:
     tslib: "npm:^2.4.0"
     typanion: "npm:^3.14.0"
   peerDependencies:
-    "@yarnpkg/core": ^4.1.6
-  checksum: 10/bd3f8748cc4f3b041f815b0fa5287c8c181a8d3a600a9b30694180bee6cf37fcede2296d46ff20d3ab04e837be33401824432c57712aa8367690c741b809826e
+    "@yarnpkg/core": ^4.2.0
+  checksum: 10/8bfe4ea7165b0928bbc5542e520d7e638d66cbb21797269bb4eb1e7d136e2dad14495e9698ce89ffe5d5129debcd5bcc337bf0e5b1849f393c8127b2ad484708
   languageName: node
   linkType: hard
 
-"@yarnpkg/core@npm:^4.1.6":
-  version: 4.1.6
-  resolution: "@yarnpkg/core@npm:4.1.6"
+"@yarnpkg/core@npm:^4.1.6, @yarnpkg/core@npm:^4.2.0":
+  version: 4.2.0
+  resolution: "@yarnpkg/core@npm:4.2.0"
   dependencies:
     "@arcanis/slice-ansi": "npm:^1.1.1"
     "@types/semver": "npm:^7.1.0"
@@ -5250,7 +5355,7 @@ __metadata:
     treeify: "npm:^1.1.0"
     tslib: "npm:^2.4.0"
     tunnel: "npm:^0.0.6"
-  checksum: 10/6a766f3b91485ce210c898468ab51d97fcd49a3b19afd524c1adee031f46322311e559312f245c8ad32c853f6ace3b80665c08612876957dbce49f18fddbbba1
+  checksum: 10/fd7f2093dd6a77759c116e79bde2ecd2142bfaa25aa6957c50e8fb42c105f299cf4f779acf4717cd5f95002aa335bbe36e8acd3fbfb573f455f76b5e0c9ec515
   languageName: node
   linkType: hard
 
@@ -5360,11 +5465,11 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@yarnpkg/plugin-essentials@npm:^4.2.2":
-  version: 4.2.2
-  resolution: "@yarnpkg/plugin-essentials@npm:4.2.2"
+"@yarnpkg/plugin-essentials@npm:^4.3.0":
+  version: 4.3.0
+  resolution: "@yarnpkg/plugin-essentials@npm:4.3.0"
   dependencies:
-    "@yarnpkg/fslib": "npm:^3.1.0"
+    "@yarnpkg/fslib": "npm:^3.1.1"
     "@yarnpkg/parsers": "npm:^3.0.2"
     ci-info: "npm:^4.0.0"
     clipanion: "npm:^4.0.0-rc.2"
@@ -5375,10 +5480,10 @@ __metadata:
     tslib: "npm:^2.4.0"
     typanion: "npm:^3.14.0"
   peerDependencies:
-    "@yarnpkg/cli": ^4.4.0
-    "@yarnpkg/core": ^4.1.2
+    "@yarnpkg/cli": ^4.6.0
+    "@yarnpkg/core": ^4.2.0
     "@yarnpkg/plugin-git": ^3.1.0
-  checksum: 10/976a5c57fb5ba8446bdd9aad6b0b9b3a6e20699027c03df0190ce73e2fb4c77599ca16d8bc4ddf861c866abc853458e0e9cbd920e0b52e60953dd095cfa0394d
+  checksum: 10/52a5672dc47589d5b850b3c849e063b414289bf457bced7066eba8dc7962bfa024f17c775c0f432a5d1511e07b61a64244525fcb7647817138ad6fde25855f4d
   languageName: node
   linkType: hard
 
@@ -5583,20 +5688,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@yarnpkg/plugin-pnp@npm:^4.0.0, @yarnpkg/plugin-pnp@npm:^4.0.5":
-  version: 4.0.5
-  resolution: "@yarnpkg/plugin-pnp@npm:4.0.5"
+"@yarnpkg/plugin-pnp@npm:^4.0.0, @yarnpkg/plugin-pnp@npm:^4.0.5, @yarnpkg/plugin-pnp@npm:^4.0.6":
+  version: 4.0.6
+  resolution: "@yarnpkg/plugin-pnp@npm:4.0.6"
   dependencies:
-    "@yarnpkg/fslib": "npm:^3.1.0"
+    "@yarnpkg/fslib": "npm:^3.1.1"
     "@yarnpkg/plugin-stage": "npm:^4.0.0"
-    "@yarnpkg/pnp": "npm:^4.0.5"
+    "@yarnpkg/pnp": "npm:^4.0.8"
     clipanion: "npm:^4.0.0-rc.2"
     micromatch: "npm:^4.0.2"
     tslib: "npm:^2.4.0"
   peerDependencies:
-    "@yarnpkg/cli": ^4.2.2
-    "@yarnpkg/core": ^4.0.5
-  checksum: 10/7d3277ffbb71ba8f6a1a647f4f66ff618c8645556784f3acf9fa198bbb2fad650043a8a927b7bc446f4748b1433a03219ea7030414b07417b3c31b8390631c0a
+    "@yarnpkg/cli": ^4.6.0
+    "@yarnpkg/core": ^4.2.0
+  checksum: 10/263b92aa005c929d31470484139cc28b42e86386da47e2a0303c8a45b2bdf7d1a2c72d881b9bd59659c725d6609523ad784ee175b4e8f987531802ebaf96f580
   languageName: node
   linkType: hard
 
@@ -5669,9 +5774,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@yarnpkg/plugin-workspace-tools@npm:^4.1.1":
-  version: 4.1.1
-  resolution: "@yarnpkg/plugin-workspace-tools@npm:4.1.1"
+"@yarnpkg/plugin-workspace-tools@npm:^4.1.2":
+  version: 4.1.2
+  resolution: "@yarnpkg/plugin-workspace-tools@npm:4.1.2"
   dependencies:
     "@yarnpkg/fslib": "npm:^3.1.1"
     clipanion: "npm:^4.0.0-rc.2"
@@ -5680,20 +5785,20 @@ __metadata:
     tslib: "npm:^2.4.0"
     typanion: "npm:^3.14.0"
   peerDependencies:
-    "@yarnpkg/cli": ^4.5.3
-    "@yarnpkg/core": ^4.1.6
+    "@yarnpkg/cli": ^4.6.0
+    "@yarnpkg/core": ^4.2.0
     "@yarnpkg/plugin-git": ^3.1.0
-  checksum: 10/0011a6e3973b5b15029e074d4aa9caae7bd44d3a989b9cff3d9e6ae1d1a58cfd7c308dfbe0acef18e65c966233794a17275f996e5f5fbdc4f6115b2c1cb194fa
+  checksum: 10/f6f99728ad796c6bf0ce56d8a69dc2a93094ae787d03b67c8a32e981a4ad8803a2e906616089aa21ee686505aedf0f0b8d986bb2f40842470d8529ee9331ac7b
   languageName: node
   linkType: hard
 
-"@yarnpkg/pnp@npm:^4.0.5, @yarnpkg/pnp@npm:^4.0.6, @yarnpkg/pnp@npm:^4.0.7":
-  version: 4.0.7
-  resolution: "@yarnpkg/pnp@npm:4.0.7"
+"@yarnpkg/pnp@npm:^4.0.6, @yarnpkg/pnp@npm:^4.0.7, @yarnpkg/pnp@npm:^4.0.8":
+  version: 4.0.8
+  resolution: "@yarnpkg/pnp@npm:4.0.8"
   dependencies:
     "@types/node": "npm:^18.17.15"
     "@yarnpkg/fslib": "npm:^3.1.1"
-  checksum: 10/0a13983923b7cb5d3e6f70cb87deed07f3e71a57bcc46c51bf244bdad6c524002999bb02f2b4a0737d1747e72c7353b97b5ecc3626dda3580b97bfbb41506f32
+  checksum: 10/1dcef20bdd92e539df84ebe58c513d2fe486bda490666ad6883a5f4bf2c2fd9f057aa906691f8e9271331e2734e73b0d299e4dc108a75f43a707efbbb3b918ae
   languageName: node
   linkType: hard
 
@@ -5834,12 +5939,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"agent-base@npm:^7.0.2, agent-base@npm:^7.1.0, agent-base@npm:^7.1.1":
-  version: 7.1.1
-  resolution: "agent-base@npm:7.1.1"
-  dependencies:
-    debug: "npm:^4.3.4"
-  checksum: 10/c478fec8f79953f118704d007a38f2a185458853f5c45579b9669372bd0e12602e88dc2ad0233077831504f7cd6fcc8251c383375bba5eaaf563b102938bda26
+"agent-base@npm:^7.1.0, agent-base@npm:^7.1.2":
+  version: 7.1.3
+  resolution: "agent-base@npm:7.1.3"
+  checksum: 10/3db6d8d4651f2aa1a9e4af35b96ab11a7607af57a24f3bc721a387eaa3b5f674e901f0a648b0caefd48f3fd117c7761b79a3b55854e2aebaa96c3f32cf76af84
   languageName: node
   linkType: hard
 
@@ -5853,7 +5956,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ajv@npm:^6.12.4":
+"ajv@npm:^6.10.0, ajv@npm:^6.12.4":
   version: 6.12.6
   resolution: "ajv@npm:6.12.6"
   dependencies:
@@ -5912,9 +6015,9 @@ __metadata:
   linkType: hard
 
 "ansi-regex@npm:^6.0.1":
-  version: 6.0.1
-  resolution: "ansi-regex@npm:6.0.1"
-  checksum: 10/1ff8b7667cded1de4fa2c9ae283e979fc87036864317da86a2e546725f96406746411d0d85e87a2d12fa5abd715d90006de7fa4fa0477c92321ad3b4c7d4e169
+  version: 6.1.0
+  resolution: "ansi-regex@npm:6.1.0"
+  checksum: 10/495834a53b0856c02acd40446f7130cb0f8284f4a39afdab20d5dc42b2e198b1196119fe887beed8f9055c4ff2055e3b2f6d4641d0be018cdfb64fedf6fc1aac
   languageName: node
   linkType: hard
 
@@ -6036,15 +6139,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"async-mutex@npm:^0.3.1":
-  version: 0.3.2
-  resolution: "async-mutex@npm:0.3.2"
-  dependencies:
-    tslib: "npm:^2.3.1"
-  checksum: 10/cf0b02f7f916d202a727e15a64d51110c3258a719588ca263875024172aa9368efa5dbec6dc4f4fd10e35744e238e1075306a93ce86549de642d5f7d0c06bc23
-  languageName: node
-  linkType: hard
-
 "async-mutex@npm:^0.5.0":
   version: 0.5.0
   resolution: "async-mutex@npm:0.5.0"
@@ -6078,20 +6172,20 @@ __metadata:
   linkType: hard
 
 "axios@npm:^1.7.4":
-  version: 1.7.5
-  resolution: "axios@npm:1.7.5"
+  version: 1.7.9
+  resolution: "axios@npm:1.7.9"
   dependencies:
     follow-redirects: "npm:^1.15.6"
     form-data: "npm:^4.0.0"
     proxy-from-env: "npm:^1.1.0"
-  checksum: 10/6cbcfe943a84089f420a900a3a3aeb54ee94dcc9c2b81b150434896357be5d1079eff0b1bbb628597371e79f896b1bc5776df04184756ba99656ff31df9a75bf
+  checksum: 10/b7a5f660ea53ba9c2a745bf5ad77ad8bf4f1338e13ccc3f9f09f810267d6c638c03dac88b55dae8dc98b79c57d2d6835be651d58d2af97c174f43d289a9fd007
   languageName: node
   linkType: hard
 
 "b4a@npm:^1.6.4":
-  version: 1.6.6
-  resolution: "b4a@npm:1.6.6"
-  checksum: 10/6154a36bd78b53ecd2843a829352532a1bf9fc8081dab339ba06ca3c9ffcf25d340c3b18fe4ba0fc17a546a54c1ed814cea92cd6b895f6bd2837ca4ee0fc9f52
+  version: 1.6.7
+  resolution: "b4a@npm:1.6.7"
+  checksum: 10/1ac056e3bce378d4d3e570e57319360a9d3125ab6916a1921b95bea33d9ee646698ebc75467561fd6fcc80ff697612124c89bb9b95e80db94c6dc23fcb977705
   languageName: node
   linkType: hard
 
@@ -6234,9 +6328,9 @@ __metadata:
   linkType: hard
 
 "bare-events@npm:^2.2.0":
-  version: 2.4.2
-  resolution: "bare-events@npm:2.4.2"
-  checksum: 10/c1006ad13b7e62a412466d4eac8466b4ceb46ce84a5e2fc164cd4b10edaaa5016adc684147134b67a6a3865aaf5aa007191647bdb5dbf859b1d5735d2a9ddf3b
+  version: 2.5.4
+  resolution: "bare-events@npm:2.5.4"
+  checksum: 10/135ef380b13f554ca2c6905bdbcfac8edae08fce85b7f953fa01f09a9f5b0da6a25e414111659bc9a6118216f0dd1f732016acd11ce91517f2afb26ebeb4b721
   languageName: node
   linkType: hard
 
@@ -6340,9 +6434,9 @@ __metadata:
   linkType: hard
 
 "bn.js@npm:^4.11.9":
-  version: 4.12.0
-  resolution: "bn.js@npm:4.12.0"
-  checksum: 10/10f8db196d3da5adfc3207d35d0a42aa29033eb33685f20ba2c36cadfe2de63dad05df0a20ab5aae01b418d1c4b3d4d205273085262fa020d17e93ff32b67527
+  version: 4.12.1
+  resolution: "bn.js@npm:4.12.1"
+  checksum: 10/07f22df8880b423c4890648e95791319898b96712b6ebc5d6b1082b34074f09dedb8601e717d67f905ce29bb1a5313f9a2b1a2015a679e42c9eed94392c0d379
   languageName: node
   linkType: hard
 
@@ -6517,6 +6611,26 @@ __metadata:
   languageName: node
   linkType: hard
 
+"cacache@npm:^19.0.1":
+  version: 19.0.1
+  resolution: "cacache@npm:19.0.1"
+  dependencies:
+    "@npmcli/fs": "npm:^4.0.0"
+    fs-minipass: "npm:^3.0.0"
+    glob: "npm:^10.2.2"
+    lru-cache: "npm:^10.0.1"
+    minipass: "npm:^7.0.3"
+    minipass-collect: "npm:^2.0.1"
+    minipass-flush: "npm:^1.0.5"
+    minipass-pipeline: "npm:^1.2.4"
+    p-map: "npm:^7.0.2"
+    ssri: "npm:^12.0.0"
+    tar: "npm:^7.4.3"
+    unique-filename: "npm:^4.0.0"
+  checksum: 10/ea026b27b13656330c2bbaa462a88181dcaa0435c1c2e705db89b31d9bdf7126049d6d0445ba746dca21454a0cfdf1d6f47fd39d34c8c8435296b30bc5738a13
+  languageName: node
+  linkType: hard
+
 "cacheable-lookup@npm:^5.0.3":
   version: 5.0.4
   resolution: "cacheable-lookup@npm:5.0.4"
@@ -6539,23 +6653,42 @@ __metadata:
   languageName: node
   linkType: hard
 
-"call-bind@npm:^1.0.0, call-bind@npm:^1.0.2, call-bind@npm:^1.0.5, call-bind@npm:^1.0.7":
-  version: 1.0.7
-  resolution: "call-bind@npm:1.0.7"
+"call-bind-apply-helpers@npm:^1.0.0, call-bind-apply-helpers@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "call-bind-apply-helpers@npm:1.0.1"
   dependencies:
-    es-define-property: "npm:^1.0.0"
     es-errors: "npm:^1.3.0"
     function-bind: "npm:^1.1.2"
-    get-intrinsic: "npm:^1.2.4"
-    set-function-length: "npm:^1.2.1"
-  checksum: 10/cd6fe658e007af80985da5185bff7b55e12ef4c2b6f41829a26ed1eef254b1f1c12e3dfd5b2b068c6ba8b86aba62390842d81752e67dcbaec4f6f76e7113b6b7
+  checksum: 10/6e30c621170e45f1fd6735e84d02ee8e02a3ab95cb109499d5308cbe5d1e84d0cd0e10b48cc43c76aa61450ae1b03a7f89c37c10fc0de8d4998b42aab0f268cc
   languageName: node
   linkType: hard
 
-"callsite@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "callsite@npm:1.0.0"
-  checksum: 10/39fc89ef9dbee7d5491bc69034fc16fbb8876a73456f831cc27060b5828e94357bb6705e0127a6d0182d79b03dbdb0ef88223d0b599c26667c871c89b30eb681
+"call-bind@npm:^1.0.0, call-bind@npm:^1.0.2, call-bind@npm:^1.0.7, call-bind@npm:^1.0.8":
+  version: 1.0.8
+  resolution: "call-bind@npm:1.0.8"
+  dependencies:
+    call-bind-apply-helpers: "npm:^1.0.0"
+    es-define-property: "npm:^1.0.0"
+    get-intrinsic: "npm:^1.2.4"
+    set-function-length: "npm:^1.2.2"
+  checksum: 10/659b03c79bbfccf0cde3a79e7d52570724d7290209823e1ca5088f94b52192dc1836b82a324d0144612f816abb2f1734447438e38d9dafe0b3f82c2a1b9e3bce
+  languageName: node
+  linkType: hard
+
+"call-bound@npm:^1.0.2, call-bound@npm:^1.0.3":
+  version: 1.0.3
+  resolution: "call-bound@npm:1.0.3"
+  dependencies:
+    call-bind-apply-helpers: "npm:^1.0.1"
+    get-intrinsic: "npm:^1.2.6"
+  checksum: 10/c39a8245f68cdb7c1f5eea7b3b1e3a7a90084ea6efebb78ebc454d698ade2c2bb42ec033abc35f1e596d62496b6100e9f4cdfad1956476c510130e2cda03266d
+  languageName: node
+  linkType: hard
+
+"callsite@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "callsite@npm:1.0.0"
+  checksum: 10/39fc89ef9dbee7d5491bc69034fc16fbb8876a73456f831cc27060b5828e94357bb6705e0127a6d0182d79b03dbdb0ef88223d0b599c26667c871c89b30eb681
   languageName: node
   linkType: hard
 
@@ -6581,9 +6714,9 @@ __metadata:
   linkType: hard
 
 "caniuse-lite@npm:^1.0.30001688":
-  version: 1.0.30001690
-  resolution: "caniuse-lite@npm:1.0.30001690"
-  checksum: 10/9fb4659eb09a298601b9593739072c481e2f5cc524bd0530e5e0f002e66246da5e866669854dfc0d53195ee36b201dab02f7933a7cdf60ccba7adb2d4a304caf
+  version: 1.0.30001692
+  resolution: "caniuse-lite@npm:1.0.30001692"
+  checksum: 10/92449ec9e9ac6cd8ce7ecc18a8759ae34e4b3ef412acd998714ee9d70dc286bc8d0d6e4917fa454798da9b37667eb5b3b41386bc9d25e4274d0b9c7af8339b0e
   languageName: node
   linkType: hard
 
@@ -6615,9 +6748,9 @@ __metadata:
   linkType: hard
 
 "chalk@npm:^5.3.0":
-  version: 5.3.0
-  resolution: "chalk@npm:5.3.0"
-  checksum: 10/6373caaab21bd64c405bfc4bd9672b145647fc9482657b5ea1d549b3b2765054e9d3d928870cdf764fb4aad67555f5061538ff247b8310f110c5c888d92397ea
+  version: 5.4.1
+  resolution: "chalk@npm:5.4.1"
+  checksum: 10/29df3ffcdf25656fed6e95962e2ef86d14dfe03cd50e7074b06bad9ffbbf6089adbb40f75c00744d843685c8d008adaf3aed31476780312553caf07fa86e5bc7
   languageName: node
   linkType: hard
 
@@ -6635,6 +6768,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"chownr@npm:^3.0.0":
+  version: 3.0.0
+  resolution: "chownr@npm:3.0.0"
+  checksum: 10/b63cb1f73d171d140a2ed8154ee6566c8ab775d3196b0e03a2a94b5f6a0ce7777ee5685ca56849403c8d17bd457a6540672f9a60696a6137c7a409097495b82c
+  languageName: node
+  linkType: hard
+
 "ci-info@npm:^2.0.0":
   version: 2.0.0
   resolution: "ci-info@npm:2.0.0"
@@ -6657,19 +6797,19 @@ __metadata:
   linkType: hard
 
 "cipher-base@npm:^1.0.0, cipher-base@npm:^1.0.1, cipher-base@npm:^1.0.3":
-  version: 1.0.4
-  resolution: "cipher-base@npm:1.0.4"
+  version: 1.0.6
+  resolution: "cipher-base@npm:1.0.6"
   dependencies:
-    inherits: "npm:^2.0.1"
-    safe-buffer: "npm:^5.0.1"
-  checksum: 10/3d5d6652ca499c3f7c5d7fdc2932a357ec1e5aa84f2ad766d850efd42e89753c97b795c3a104a8e7ae35b4e293f5363926913de3bf8181af37067d9d541ca0db
+    inherits: "npm:^2.0.4"
+    safe-buffer: "npm:^5.2.1"
+  checksum: 10/faf232deff2351448ea23d265eb8723e035ebbb454baca45fb60c1bd71056ede8b153bef1b221e067f13e6b9288ebb83bb6ae2d5dd4cec285411f9fc22ec1f5b
   languageName: node
   linkType: hard
 
 "cjs-module-lexer@npm:^1.0.0, cjs-module-lexer@npm:^1.3.1":
-  version: 1.4.0
-  resolution: "cjs-module-lexer@npm:1.4.0"
-  checksum: 10/b041096749792526120d8b8756929f8ef5dd4596502a0e1013f857e3027acd6091915fea77037921d70ee1a99988a100d994d3d3c2e323b04dd4c5ffd516cf13
+  version: 1.4.1
+  resolution: "cjs-module-lexer@npm:1.4.1"
+  checksum: 10/6e830a1e00a34d416949bbc1924f3e8da65cef4a6a09e2b7fa35722e2d1c34bf378d3baca987b698d1cbc3eb83e44b044039b4e82755c96f30e0f03d1d227637
   languageName: node
   linkType: hard
 
@@ -6872,30 +7012,30 @@ __metadata:
   linkType: hard
 
 "contentful-resolve-response@npm:^1.9.0":
-  version: 1.9.0
-  resolution: "contentful-resolve-response@npm:1.9.0"
+  version: 1.9.2
+  resolution: "contentful-resolve-response@npm:1.9.2"
   dependencies:
     fast-copy: "npm:^2.1.7"
-  checksum: 10/0c5daa59a3a6b020f9b5316812e3f14e62833b4aead008527c5bfde6549365e8e8e9f373af8836f06ca7b2023d861fdd2c241d3e74d3797133d18983be8bb3b3
+  checksum: 10/7fce57e33d5f874c65683567af30d1f1c32a8769558479f61b4d465201f8ea979a52b9b31f33d01a5437477aa0195a00565792efba345f2b21689e13519d70b3
   languageName: node
   linkType: hard
 
 "contentful-sdk-core@npm:^8.3.1":
-  version: 8.3.1
-  resolution: "contentful-sdk-core@npm:8.3.1"
+  version: 8.3.2
+  resolution: "contentful-sdk-core@npm:8.3.2"
   dependencies:
     fast-copy: "npm:^2.1.7"
     lodash.isplainobject: "npm:^4.0.6"
     lodash.isstring: "npm:^4.0.1"
     p-throttle: "npm:^4.1.1"
     qs: "npm:^6.11.2"
-  checksum: 10/645d3a5d296d0e2a5ce87cceb04cf1ddf572183b5946cb1b3b717436bc7be96864216225fb845e61850d580436021c6284e7c95da0600a16c89c0af81a5f0d2c
+  checksum: 10/4af0aba2bb7e3db3ebf260fea74843de89f150f5af883134c370eb695fd8b2587cf94d4524d03020286f565eb3bff7b12d42f2a38718b62eb75cb28556e40f42
   languageName: node
   linkType: hard
 
 "contentful@npm:^10.15.0":
-  version: 10.15.0
-  resolution: "contentful@npm:10.15.0"
+  version: 10.15.1
+  resolution: "contentful@npm:10.15.1"
   dependencies:
     "@contentful/content-source-maps": "npm:^0.11.0"
     "@contentful/rich-text-types": "npm:^16.0.2"
@@ -6904,7 +7044,7 @@ __metadata:
     contentful-sdk-core: "npm:^8.3.1"
     json-stringify-safe: "npm:^5.0.1"
     type-fest: "npm:^4.0.0"
-  checksum: 10/b57c51faa99074a2f60c930c4827d1f8fe9867a359e53738532bbe859f5d72e750645fa4e195e65ad015811f344d95a0b3cebe6debef7d4e92ce9510bd55939e
+  checksum: 10/eb913a79e38d87bc7fb3a79952e4d7c5a1de5cccfbe0a012e8131c9c1e5a0a525cfcb7eaea971b02fb9e57b9e49c71ce96dd7096c3f65483992017ef70de80e5
   languageName: node
   linkType: hard
 
@@ -7231,6 +7371,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"detect-node@npm:^2.0.4":
+  version: 2.1.0
+  resolution: "detect-node@npm:2.1.0"
+  checksum: 10/832184ec458353e41533ac9c622f16c19f7c02d8b10c303dfd3a756f56be93e903616c0bb2d4226183c9351c15fc0b3dba41a17a2308262afabcfa3776e6ae6e
+  languageName: node
+  linkType: hard
+
 "diff-sequences@npm:^27.5.1":
   version: 27.5.1
   resolution: "diff-sequences@npm:27.5.1"
@@ -7259,15 +7406,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dir-glob@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "dir-glob@npm:3.0.1"
-  dependencies:
-    path-type: "npm:^4.0.0"
-  checksum: 10/fa05e18324510d7283f55862f3161c6759a3f2f8dbce491a2fc14c8324c498286c54282c1f0e933cb930da8419b30679389499b919122952a4f8592362ef4615
-  languageName: node
-  linkType: hard
-
 "doctrine@npm:^3.0.0":
   version: 3.0.0
   resolution: "doctrine@npm:3.0.0"
@@ -7293,6 +7431,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"dunder-proto@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "dunder-proto@npm:1.0.1"
+  dependencies:
+    call-bind-apply-helpers: "npm:^1.0.1"
+    es-errors: "npm:^1.3.0"
+    gopd: "npm:^1.2.0"
+  checksum: 10/5add88a3d68d42d6e6130a0cac450b7c2edbe73364bbd2fc334564418569bea97c6943a8fcd70e27130bf32afc236f30982fc4905039b703f23e9e0433c29934
+  languageName: node
+  linkType: hard
+
 "eastasianwidth@npm:^0.2.0":
   version: 0.2.0
   resolution: "eastasianwidth@npm:0.2.0"
@@ -7301,9 +7450,9 @@ __metadata:
   linkType: hard
 
 "electron-to-chromium@npm:^1.5.73":
-  version: 1.5.79
-  resolution: "electron-to-chromium@npm:1.5.79"
-  checksum: 10/c5b25ba04b4f4b46c4024b96e00e43adcd6c321b48c74c8d2660f69704901da5a6592009cbf96c36c89e3f6b53d7742e2b89514477fddbccf4e5c4caebed9d49
+  version: 1.5.82
+  resolution: "electron-to-chromium@npm:1.5.82"
+  checksum: 10/2c8e01d71515773d6789013162505a31b831c4f4e7b4a1e9fc65ed6d7e31e21f71b0880dd141eadbb93d89e2a2fce9636ac72604c28fa0960d44e8dacbed431e
   languageName: node
   linkType: hard
 
@@ -7411,12 +7560,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"es-define-property@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "es-define-property@npm:1.0.0"
-  dependencies:
-    get-intrinsic: "npm:^1.2.4"
-  checksum: 10/f66ece0a887b6dca71848fa71f70461357c0e4e7249696f81bad0a1f347eed7b31262af4a29f5d726dc026426f085483b6b90301855e647aa8e21936f07293c6
+"es-define-property@npm:^1.0.0, es-define-property@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "es-define-property@npm:1.0.1"
+  checksum: 10/f8dc9e660d90919f11084db0a893128f3592b781ce967e4fccfb8f3106cb83e400a4032c559184ec52ee1dbd4b01e7776c7cd0b3327b1961b1a4a7008920fe78
   languageName: node
   linkType: hard
 
@@ -7434,6 +7581,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"es-object-atoms@npm:^1.0.0":
+  version: 1.1.1
+  resolution: "es-object-atoms@npm:1.1.1"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+  checksum: 10/54fe77de288451dae51c37bfbfe3ec86732dc3778f98f3eb3bdb4bf48063b2c0b8f9c93542656986149d08aa5be3204286e2276053d19582b76753f1a2728867
+  languageName: node
+  linkType: hard
+
 "escalade@npm:^3.1.1, escalade@npm:^3.2.0":
   version: 3.2.0
   resolution: "escalade@npm:3.2.0"
@@ -7575,8 +7731,8 @@ __metadata:
   linkType: hard
 
 "eslint-plugin-jest@npm:^28.8.3":
-  version: 28.10.0
-  resolution: "eslint-plugin-jest@npm:28.10.0"
+  version: 28.11.0
+  resolution: "eslint-plugin-jest@npm:28.11.0"
   dependencies:
     "@typescript-eslint/utils": "npm:^6.0.0 || ^7.0.0 || ^8.0.0"
   peerDependencies:
@@ -7588,7 +7744,7 @@ __metadata:
       optional: true
     jest:
       optional: true
-  checksum: 10/cb19f2171e93873d9207425c4fa52ec49018579d73ece23a1ffea90f3ffd284b0e48f74ff4f50b15ff31882b06b03fec0e48c9c6ca830acdeff8931802ef0a9e
+  checksum: 10/7f3896ec2dc03110688bb9f359a7aa1ba1a6d9a60ffbc3642361c4aaf55afcba9ce36b6609b20b1507028c2170ffe29b0f3e9cc9b7fe12fdd233740a2f9ce0a1
   languageName: node
   linkType: hard
 
@@ -7632,8 +7788,8 @@ __metadata:
   linkType: hard
 
 "eslint-plugin-prettier@npm:^5.2.1":
-  version: 5.2.1
-  resolution: "eslint-plugin-prettier@npm:5.2.1"
+  version: 5.2.2
+  resolution: "eslint-plugin-prettier@npm:5.2.2"
   dependencies:
     prettier-linter-helpers: "npm:^1.0.0"
     synckit: "npm:^0.9.1"
@@ -7647,7 +7803,7 @@ __metadata:
       optional: true
     eslint-config-prettier:
       optional: true
-  checksum: 10/10ddf68215237e327af09a47adab4c63f3885fda4fb28c4c42d1fc5f47d8a0cc45df6484799360ff1417a0aa3c77c3aaac49d7e9dfd145557b17e2d7ecc2a27c
+  checksum: 10/292569865fde6a91646037f58105c18225f5cd57e255966f8388b13c196ce023f84e22100408dcd30472c02d0846a897b8afe460ece57dfc23e80e6cac70a644
   languageName: node
   linkType: hard
 
@@ -7687,16 +7843,16 @@ __metadata:
   linkType: hard
 
 "eslint@npm:^9.11.0":
-  version: 9.17.0
-  resolution: "eslint@npm:9.17.0"
+  version: 9.18.0
+  resolution: "eslint@npm:9.18.0"
   dependencies:
     "@eslint-community/eslint-utils": "npm:^4.2.0"
     "@eslint-community/regexpp": "npm:^4.12.1"
     "@eslint/config-array": "npm:^0.19.0"
-    "@eslint/core": "npm:^0.9.0"
+    "@eslint/core": "npm:^0.10.0"
     "@eslint/eslintrc": "npm:^3.2.0"
-    "@eslint/js": "npm:9.17.0"
-    "@eslint/plugin-kit": "npm:^0.2.3"
+    "@eslint/js": "npm:9.18.0"
+    "@eslint/plugin-kit": "npm:^0.2.5"
     "@humanfs/node": "npm:^0.16.6"
     "@humanwhocodes/module-importer": "npm:^1.0.1"
     "@humanwhocodes/retry": "npm:^0.4.1"
@@ -7731,7 +7887,7 @@ __metadata:
       optional: true
   bin:
     eslint: bin/eslint.js
-  checksum: 10/a48ee67dd4e737974bbb49ca5d12d0ce35bcd874507807599e3655bb398320ab27c9deed1aad508a963967815e626c21208f52158c2fc0796d0cc8186528efeb
+  checksum: 10/85f22991aab4b0809fdfc557ec2bd309062e7211b631674e71827a73c45e44febaa80dedda35150154e331a2d372c3a25e8e5dd4a99dc8a982fe8f7d645d859f
   languageName: node
   linkType: hard
 
@@ -7882,17 +8038,17 @@ __metadata:
   linkType: hard
 
 "ethers@npm:^6.12.0":
-  version: 6.13.2
-  resolution: "ethers@npm:6.13.2"
+  version: 6.13.5
+  resolution: "ethers@npm:6.13.5"
   dependencies:
     "@adraffy/ens-normalize": "npm:1.10.1"
     "@noble/curves": "npm:1.2.0"
     "@noble/hashes": "npm:1.3.2"
-    "@types/node": "npm:18.15.13"
+    "@types/node": "npm:22.7.5"
     aes-js: "npm:4.0.0-beta.5"
-    tslib: "npm:2.4.0"
+    tslib: "npm:2.7.0"
     ws: "npm:8.17.1"
-  checksum: 10/e611c2e2c5340982dfd1f004895f55abda11748a7edec9e6315226dec42d58aa61b827dd389ec904db5f9a244c475ae795e528da579251fdf62e914bde12809e
+  checksum: 10/ccba21a83679fb6a7c3eb9d187593501565d140064f2db28057a64d6707678bacf2adf4555882c4814688246da73173560df81fd3361fd2f227b5d3c75cb8685
   languageName: node
   linkType: hard
 
@@ -8070,7 +8226,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fast-glob@npm:^3.2.2, fast-glob@npm:^3.3.0, fast-glob@npm:^3.3.2":
+"fast-glob@npm:^3.2.2, fast-glob@npm:^3.3.2":
   version: 3.3.3
   resolution: "fast-glob@npm:3.3.3"
   dependencies:
@@ -8104,7 +8260,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fast-safe-stringify@npm:^2.0.6":
+"fast-safe-stringify@npm:^2.0.6, fast-safe-stringify@npm:^2.0.7, fast-safe-stringify@npm:^2.1.1":
   version: 2.1.1
   resolution: "fast-safe-stringify@npm:2.1.1"
   checksum: 10/dc1f063c2c6ac9533aee14d406441f86783a8984b2ca09b19c2fe281f9ff59d315298bc7bc22fd1f83d26fe19ef2f20e2ddb68e96b15040292e555c5ced0c1e4
@@ -8112,13 +8268,13 @@ __metadata:
   linkType: hard
 
 "fast-xml-parser@npm:^4.4.1":
-  version: 4.4.1
-  resolution: "fast-xml-parser@npm:4.4.1"
+  version: 4.5.1
+  resolution: "fast-xml-parser@npm:4.5.1"
   dependencies:
     strnum: "npm:^1.0.5"
   bin:
     fxparser: src/cli/cli.js
-  checksum: 10/0c05ab8703630d8c857fafadbd78d0020d3a8e54310c3842179cd4a0d9d97e96d209ce885e91241f4aa9dd8dfc2fd924a682741a423d65153cad34da2032ec44
+  checksum: 10/17ce5908e798de1b6d12a39d26f04ac3b582ea9ce28f3a6e3b9c401edcb74790f28df84d75377608af53308ff8caad2b244ba1283cc4b5b4cf4cc7bd532a9983
   languageName: node
   linkType: hard
 
@@ -8130,11 +8286,11 @@ __metadata:
   linkType: hard
 
 "fastq@npm:^1.6.0":
-  version: 1.17.1
-  resolution: "fastq@npm:1.17.1"
+  version: 1.18.0
+  resolution: "fastq@npm:1.18.0"
   dependencies:
     reusify: "npm:^1.0.4"
-  checksum: 10/a443180068b527dd7b3a63dc7f2a47ceca2f3e97b9c00a1efe5538757e6cc4056a3526df94308075d7727561baf09ebaa5b67da8dcbddb913a021c5ae69d1f69
+  checksum: 10/c5b501333dc8f5d188d828ea162aad03ff5a81aed185b6d4a5078aaeae0a42babc34296d7af13ebce86401cccd93c9b7b3cbf61280821c5f20af233378b42fbb
   languageName: node
   linkType: hard
 
@@ -8156,6 +8312,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"fdir@npm:^6.4.2":
+  version: 6.4.2
+  resolution: "fdir@npm:6.4.2"
+  peerDependencies:
+    picomatch: ^3 || ^4
+  peerDependenciesMeta:
+    picomatch:
+      optional: true
+  checksum: 10/5ff80d1d2034e75cc68be175401c9f64c4938a6b2c1e9a0c27f2d211ffbe491fd86d29e4576825d9da8aff9bd465f0283427c2dddc11653457906c46d3bbc448
+  languageName: node
+  linkType: hard
+
 "figgy-pudding@npm:^3.5.1":
   version: 3.5.2
   resolution: "figgy-pudding@npm:3.5.2"
@@ -8214,37 +8382,38 @@ __metadata:
   linkType: hard
 
 "firebase@npm:^10.11.0":
-  version: 10.13.0
-  resolution: "firebase@npm:10.13.0"
-  dependencies:
-    "@firebase/analytics": "npm:0.10.7"
-    "@firebase/analytics-compat": "npm:0.2.13"
-    "@firebase/app": "npm:0.10.9"
-    "@firebase/app-check": "npm:0.8.7"
-    "@firebase/app-check-compat": "npm:0.3.14"
-    "@firebase/app-compat": "npm:0.2.39"
+  version: 10.14.1
+  resolution: "firebase@npm:10.14.1"
+  dependencies:
+    "@firebase/analytics": "npm:0.10.8"
+    "@firebase/analytics-compat": "npm:0.2.14"
+    "@firebase/app": "npm:0.10.13"
+    "@firebase/app-check": "npm:0.8.8"
+    "@firebase/app-check-compat": "npm:0.3.15"
+    "@firebase/app-compat": "npm:0.2.43"
     "@firebase/app-types": "npm:0.9.2"
-    "@firebase/auth": "npm:1.7.7"
-    "@firebase/auth-compat": "npm:0.5.12"
-    "@firebase/database": "npm:1.0.7"
-    "@firebase/database-compat": "npm:1.0.7"
-    "@firebase/firestore": "npm:4.7.0"
-    "@firebase/firestore-compat": "npm:0.3.35"
-    "@firebase/functions": "npm:0.11.6"
-    "@firebase/functions-compat": "npm:0.3.12"
-    "@firebase/installations": "npm:0.6.8"
-    "@firebase/installations-compat": "npm:0.2.8"
-    "@firebase/messaging": "npm:0.12.10"
-    "@firebase/messaging-compat": "npm:0.2.10"
-    "@firebase/performance": "npm:0.6.8"
-    "@firebase/performance-compat": "npm:0.2.8"
-    "@firebase/remote-config": "npm:0.4.8"
-    "@firebase/remote-config-compat": "npm:0.2.8"
-    "@firebase/storage": "npm:0.13.0"
-    "@firebase/storage-compat": "npm:0.3.10"
-    "@firebase/util": "npm:1.9.7"
-    "@firebase/vertexai-preview": "npm:0.0.3"
-  checksum: 10/dd4d62acb3146cb96f88a98eead8a5a02ef42dc5f5a918bbf496f2f894a048ff9aef64b79f2dc8909995b7d3ad2d4d36d6a72add7c8ef3ee46cb811641fc572a
+    "@firebase/auth": "npm:1.7.9"
+    "@firebase/auth-compat": "npm:0.5.14"
+    "@firebase/data-connect": "npm:0.1.0"
+    "@firebase/database": "npm:1.0.8"
+    "@firebase/database-compat": "npm:1.0.8"
+    "@firebase/firestore": "npm:4.7.3"
+    "@firebase/firestore-compat": "npm:0.3.38"
+    "@firebase/functions": "npm:0.11.8"
+    "@firebase/functions-compat": "npm:0.3.14"
+    "@firebase/installations": "npm:0.6.9"
+    "@firebase/installations-compat": "npm:0.2.9"
+    "@firebase/messaging": "npm:0.12.12"
+    "@firebase/messaging-compat": "npm:0.2.12"
+    "@firebase/performance": "npm:0.6.9"
+    "@firebase/performance-compat": "npm:0.2.9"
+    "@firebase/remote-config": "npm:0.4.9"
+    "@firebase/remote-config-compat": "npm:0.2.9"
+    "@firebase/storage": "npm:0.13.2"
+    "@firebase/storage-compat": "npm:0.3.12"
+    "@firebase/util": "npm:1.10.0"
+    "@firebase/vertexai-preview": "npm:0.0.4"
+  checksum: 10/1b2fd7b653f632d2bb0cf3b87e7eda0ae69d28b702a7de00d2a166c7985b8747ef9d15f7ac151847d242f91a1cb08c689d0a07197e8b80561ff1a679398bf9f8
   languageName: node
   linkType: hard
 
@@ -8259,19 +8428,19 @@ __metadata:
   linkType: hard
 
 "flatted@npm:^3.2.9":
-  version: 3.3.1
-  resolution: "flatted@npm:3.3.1"
-  checksum: 10/7b8376061d5be6e0d3658bbab8bde587647f68797cf6bfeae9dea0e5137d9f27547ab92aaff3512dd9d1299086a6d61be98e9d48a56d17531b634f77faadbc49
+  version: 3.3.2
+  resolution: "flatted@npm:3.3.2"
+  checksum: 10/ac3c159742e01d0e860a861164bcfd35bb567ccbebb8a0dd041e61cf3c64a435b917dd1e7ed1c380c2ebca85735fb16644485ec33665bc6aafc3b316aa1eed44
   languageName: node
   linkType: hard
 
 "follow-redirects@npm:^1.15.6":
-  version: 1.15.6
-  resolution: "follow-redirects@npm:1.15.6"
+  version: 1.15.9
+  resolution: "follow-redirects@npm:1.15.9"
   peerDependenciesMeta:
     debug:
       optional: true
-  checksum: 10/70c7612c4cab18e546e36b991bbf8009a1a41cf85354afe04b113d1117569abf760269409cb3eb842d9f7b03d62826687086b081c566ea7b1e6613cf29030bf7
+  checksum: 10/e3ab42d1097e90d28b913903841e6779eb969b62a64706a3eb983e894a5db000fbd89296f45f08885a0e54cd558ef62e81be1165da9be25a6c44920da10f424c
   languageName: node
   linkType: hard
 
@@ -8302,24 +8471,24 @@ __metadata:
   linkType: hard
 
 "form-data@npm:^3.0.0":
-  version: 3.0.1
-  resolution: "form-data@npm:3.0.1"
+  version: 3.0.2
+  resolution: "form-data@npm:3.0.2"
   dependencies:
     asynckit: "npm:^0.4.0"
     combined-stream: "npm:^1.0.8"
     mime-types: "npm:^2.1.12"
-  checksum: 10/944b40ff63b9cb1ca7a97e70f72104c548e0b0263e3e817e49919015a0d687453086259b93005389896dbffd3777cccea2e67c51f4e827590e5979b14ff91bf7
+  checksum: 10/b8d71d7149de5881c6c8ac75c03ac2e809b1b729399320cc41f59a63043fa34b95dfef5259212d6d902abb4916af48a7ca60ad5c035806ba8e3c7843dbaf3057
   languageName: node
   linkType: hard
 
 "form-data@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "form-data@npm:4.0.0"
+  version: 4.0.1
+  resolution: "form-data@npm:4.0.1"
   dependencies:
     asynckit: "npm:^0.4.0"
     combined-stream: "npm:^1.0.8"
     mime-types: "npm:^2.1.12"
-  checksum: 10/7264aa760a8cf09482816d8300f1b6e2423de1b02bba612a136857413fdc96d7178298ced106817655facc6b89036c6e12ae31c9eb5bdc16aabf502ae8a5d805
+  checksum: 10/6adb1cff557328bc6eb8a68da205f9ae44ab0e88d4d9237aaf91eed591ffc64f77411efb9016af7d87f23d0a038c45a788aa1c6634e51175c4efa36c2bc53774
   languageName: node
   linkType: hard
 
@@ -8330,6 +8499,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"fs-extra@npm:^10.1.0":
+  version: 10.1.0
+  resolution: "fs-extra@npm:10.1.0"
+  dependencies:
+    graceful-fs: "npm:^4.2.0"
+    jsonfile: "npm:^6.0.1"
+    universalify: "npm:^2.0.0"
+  checksum: 10/05ce2c3b59049bcb7b52001acd000e44b3c4af4ec1f8839f383ef41ec0048e3cfa7fd8a637b1bddfefad319145db89be91f4b7c1db2908205d38bf91e7d1d3b7
+  languageName: node
+  linkType: hard
+
 "fs-minipass@npm:^2.0.0":
   version: 2.1.0
   resolution: "fs-minipass@npm:2.1.0"
@@ -8395,16 +8575,21 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-intrinsic@npm:^1.1.3, get-intrinsic@npm:^1.2.4":
-  version: 1.2.4
-  resolution: "get-intrinsic@npm:1.2.4"
+"get-intrinsic@npm:^1.2.4, get-intrinsic@npm:^1.2.5, get-intrinsic@npm:^1.2.6":
+  version: 1.2.7
+  resolution: "get-intrinsic@npm:1.2.7"
   dependencies:
+    call-bind-apply-helpers: "npm:^1.0.1"
+    es-define-property: "npm:^1.0.1"
     es-errors: "npm:^1.3.0"
+    es-object-atoms: "npm:^1.0.0"
     function-bind: "npm:^1.1.2"
-    has-proto: "npm:^1.0.1"
-    has-symbols: "npm:^1.0.3"
-    hasown: "npm:^2.0.0"
-  checksum: 10/85bbf4b234c3940edf8a41f4ecbd4e25ce78e5e6ad4e24ca2f77037d983b9ef943fd72f00f3ee97a49ec622a506b67db49c36246150377efcda1c9eb03e5f06d
+    get-proto: "npm:^1.0.0"
+    gopd: "npm:^1.2.0"
+    has-symbols: "npm:^1.1.0"
+    hasown: "npm:^2.0.2"
+    math-intrinsics: "npm:^1.1.0"
+  checksum: 10/4f7149c9a826723f94c6d49f70bcb3df1d3f9213994fab3668f12f09fa72074681460fb29ebb6f135556ec6372992d63802386098791a8f09cfa6f27090fa67b
   languageName: node
   linkType: hard
 
@@ -8422,6 +8607,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"get-proto@npm:^1.0.0":
+  version: 1.0.1
+  resolution: "get-proto@npm:1.0.1"
+  dependencies:
+    dunder-proto: "npm:^1.0.1"
+    es-object-atoms: "npm:^1.0.0"
+  checksum: 10/4fc96afdb58ced9a67558698b91433e6b037aaa6f1493af77498d7c85b141382cf223c0e5946f334fb328ee85dfe6edd06d218eaf09556f4bc4ec6005d7f5f7b
+  languageName: node
+  linkType: hard
+
 "get-stdin@npm:^9.0.0":
   version: 9.0.0
   resolution: "get-stdin@npm:9.0.0"
@@ -8587,19 +8782,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"globby@npm:^13.1.2":
-  version: 13.2.2
-  resolution: "globby@npm:13.2.2"
-  dependencies:
-    dir-glob: "npm:^3.0.1"
-    fast-glob: "npm:^3.3.0"
-    ignore: "npm:^5.2.4"
-    merge2: "npm:^1.4.1"
-    slash: "npm:^4.0.0"
-  checksum: 10/4494a9d2162a7e4d327988b26be66d8eab87d7f59a83219e74b065e2c3ced23698f68fb10482bf9337133819281803fb886d6ae06afbb2affa743623eb0b1949
-  languageName: node
-  linkType: hard
-
 "globrex@npm:^0.1.2":
   version: 0.1.2
   resolution: "globrex@npm:0.1.2"
@@ -8607,12 +8789,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"gopd@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "gopd@npm:1.0.1"
-  dependencies:
-    get-intrinsic: "npm:^1.1.3"
-  checksum: 10/5fbc7ad57b368ae4cd2f41214bd947b045c1a4be2f194a7be1778d71f8af9dbf4004221f3b6f23e30820eb0d052b4f819fe6ebe8221e2a3c6f0ee4ef173421ca
+"gopd@npm:^1.0.1, gopd@npm:^1.2.0":
+  version: 1.2.0
+  resolution: "gopd@npm:1.2.0"
+  checksum: 10/94e296d69f92dc1c0768fcfeecfb3855582ab59a7c75e969d5f96ce50c3d201fd86d5a2857c22565764d5bb8a816c7b1e58f133ec318cd56274da36c5e3fb1a1
   languageName: node
   linkType: hard
 
@@ -8635,7 +8815,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"graceful-fs@npm:^4.2.10, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6, graceful-fs@npm:^4.2.9":
+"graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.10, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6, graceful-fs@npm:^4.2.9":
   version: 4.2.11
   resolution: "graceful-fs@npm:4.2.11"
   checksum: 10/bf152d0ed1dc159239db1ba1f74fdbc40cb02f626770dcd5815c427ce0688c2635a06ed69af364396da4636d0408fcf7d4afdf7881724c3307e46aff30ca49e2
@@ -8672,21 +8852,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"has-proto@npm:^1.0.1":
-  version: 1.0.3
-  resolution: "has-proto@npm:1.0.3"
-  checksum: 10/0b67c2c94e3bea37db3e412e3c41f79d59259875e636ba471e94c009cdfb1fa82bf045deeffafc7dbb9c148e36cae6b467055aaa5d9fad4316e11b41e3ba551a
-  languageName: node
-  linkType: hard
-
-"has-symbols@npm:^1.0.3":
-  version: 1.0.3
-  resolution: "has-symbols@npm:1.0.3"
-  checksum: 10/464f97a8202a7690dadd026e6d73b1ceeddd60fe6acfd06151106f050303eaa75855aaa94969df8015c11ff7c505f196114d22f7386b4a471038da5874cf5e9b
+"has-symbols@npm:^1.0.3, has-symbols@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "has-symbols@npm:1.1.0"
+  checksum: 10/959385c98696ebbca51e7534e0dc723ada325efa3475350951363cce216d27373e0259b63edb599f72eb94d6cde8577b4b2375f080b303947e560f85692834fa
   languageName: node
   linkType: hard
 
-"has-tostringtag@npm:^1.0.0, has-tostringtag@npm:^1.0.2":
+"has-tostringtag@npm:^1.0.2":
   version: 1.0.2
   resolution: "has-tostringtag@npm:1.0.2"
   dependencies:
@@ -8716,7 +8889,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"hasown@npm:^2.0.0, hasown@npm:^2.0.2":
+"hasown@npm:^2.0.2":
   version: 2.0.2
   resolution: "hasown@npm:2.0.2"
   dependencies:
@@ -8790,9 +8963,9 @@ __metadata:
   linkType: hard
 
 "http-parser-js@npm:>=0.5.1":
-  version: 0.5.8
-  resolution: "http-parser-js@npm:0.5.8"
-  checksum: 10/2a78a567ee6366dae0129d819b799dce1f95ec9732c5ab164a78ee69804ffb984abfa0660274e94e890fc54af93546eb9f12b6d10edbaed017e2d41c29b7cf29
+  version: 0.5.9
+  resolution: "http-parser-js@npm:0.5.9"
+  checksum: 10/65e6ef5e063b4f67c590bdd122b255e9b70c5bf3429718f8b72951fe98f4f968c55a58ec88cc96a11357a437d75c4af9302b8026c0b53c525065ff4eb0cd969e
   languageName: node
   linkType: hard
 
@@ -8838,12 +9011,12 @@ __metadata:
   linkType: hard
 
 "https-proxy-agent@npm:^7.0.1":
-  version: 7.0.5
-  resolution: "https-proxy-agent@npm:7.0.5"
+  version: 7.0.6
+  resolution: "https-proxy-agent@npm:7.0.6"
   dependencies:
-    agent-base: "npm:^7.0.2"
+    agent-base: "npm:^7.1.2"
     debug: "npm:4"
-  checksum: 10/6679d46159ab3f9a5509ee80c3a3fc83fba3a920a5e18d32176c3327852c3c00ad640c0c4210a8fd70ea3c4a6d3a1b375bf01942516e7df80e2646bdc77658ab
+  checksum: 10/784b628cbd55b25542a9d85033bdfd03d4eda630fb8b3c9477959367f3be95dc476ed2ecbb9836c359c7c698027fc7b45723a302324433590f45d6c1706e8c13
   languageName: node
   linkType: hard
 
@@ -9044,12 +9217,12 @@ __metadata:
   linkType: hard
 
 "is-arguments@npm:^1.0.4":
-  version: 1.1.1
-  resolution: "is-arguments@npm:1.1.1"
+  version: 1.2.0
+  resolution: "is-arguments@npm:1.2.0"
   dependencies:
-    call-bind: "npm:^1.0.2"
-    has-tostringtag: "npm:^1.0.0"
-  checksum: 10/a170c7e26082e10de9be6e96d32ae3db4d5906194051b792e85fae3393b53cf2cb5b3557863e5c8ccbab55e2fd8f2f75aa643d437613f72052cf0356615c34be
+    call-bound: "npm:^1.0.2"
+    has-tostringtag: "npm:^1.0.2"
+  checksum: 10/471a8ef631b8ee8829c43a8ab05c081700c0e25180c73d19f3bf819c1a8448c426a9e8e601f278973eca68966384b16ceb78b8c63af795b099cd199ea5afc457
   languageName: node
   linkType: hard
 
@@ -9087,12 +9260,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-core-module@npm:^2.12.0, is-core-module@npm:^2.13.0":
-  version: 2.15.1
-  resolution: "is-core-module@npm:2.15.1"
+"is-core-module@npm:^2.12.0, is-core-module@npm:^2.13.0, is-core-module@npm:^2.16.0":
+  version: 2.16.1
+  resolution: "is-core-module@npm:2.16.1"
   dependencies:
     hasown: "npm:^2.0.2"
-  checksum: 10/77316d5891d5743854bcef2cd2f24c5458fb69fbc9705c12ca17d54a2017a67d0693bbf1ba8c77af376c0eef6bf6d1b27a4ab08e4db4e69914c3789bdf2ceec5
+  checksum: 10/452b2c2fb7f889cbbf7e54609ef92cf6c24637c568acc7e63d166812a0fb365ae8a504c333a29add8bdb1686704068caa7f4e4b639b650dde4f00a038b8941fb
   languageName: node
   linkType: hard
 
@@ -9125,11 +9298,14 @@ __metadata:
   linkType: hard
 
 "is-generator-function@npm:^1.0.7":
-  version: 1.0.10
-  resolution: "is-generator-function@npm:1.0.10"
+  version: 1.1.0
+  resolution: "is-generator-function@npm:1.1.0"
   dependencies:
-    has-tostringtag: "npm:^1.0.0"
-  checksum: 10/499a3ce6361064c3bd27fbff5c8000212d48506ebe1977842bbd7b3e708832d0deb1f4cc69186ece3640770e8c4f1287b24d99588a0b8058b2dbdd344bc1f47f
+    call-bound: "npm:^1.0.3"
+    get-proto: "npm:^1.0.0"
+    has-tostringtag: "npm:^1.0.2"
+    safe-regex-test: "npm:^1.1.0"
+  checksum: 10/5906ff51a856a5fbc6b90a90fce32040b0a6870da905f98818f1350f9acadfc9884f7c3dec833fce04b83dd883937b86a190b6593ede82e8b1af8b6c4ecf7cbd
   languageName: node
   linkType: hard
 
@@ -9187,6 +9363,18 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-regex@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "is-regex@npm:1.2.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    gopd: "npm:^1.2.0"
+    has-tostringtag: "npm:^1.0.2"
+    hasown: "npm:^2.0.2"
+  checksum: 10/c42b7efc5868a5c9a4d8e6d3e9816e8815c611b09535c00fead18a1138455c5cb5e1887f0023a467ad3f9c419d62ba4dc3d9ba8bafe55053914d6d6454a945d2
+  languageName: node
+  linkType: hard
+
 "is-ssh@npm:^1.4.0":
   version: 1.4.0
   resolution: "is-ssh@npm:1.4.0"
@@ -9211,11 +9399,11 @@ __metadata:
   linkType: hard
 
 "is-typed-array@npm:^1.1.3":
-  version: 1.1.13
-  resolution: "is-typed-array@npm:1.1.13"
+  version: 1.1.15
+  resolution: "is-typed-array@npm:1.1.15"
   dependencies:
-    which-typed-array: "npm:^1.1.14"
-  checksum: 10/f850ba08286358b9a11aee6d93d371a45e3c59b5953549ee1c1a9a55ba5c1dd1bd9952488ae194ad8f32a9cf5e79c8fa5f0cc4d78c00720aa0bbcf238b38062d
+    which-typed-array: "npm:^1.1.16"
+  checksum: 10/e8cf60b9ea85667097a6ad68c209c9722cfe8c8edf04d6218366469e51944c5cc25bae45ffb845c23f811d262e4314d3b0168748eb16711aa34d12724cdf0735
   languageName: node
   linkType: hard
 
@@ -9226,6 +9414,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"is-url@npm:^1.2.4":
+  version: 1.2.4
+  resolution: "is-url@npm:1.2.4"
+  checksum: 10/100e74b3b1feab87a43ef7653736e88d997eb7bd32e71fd3ebc413e58c1cbe56269699c776aaea84244b0567f2a7d68dfaa512a062293ed2f9fdecb394148432
+  languageName: node
+  linkType: hard
+
 "is-windows@npm:^1.0.1, is-windows@npm:^1.0.2":
   version: 1.0.2
   resolution: "is-windows@npm:1.0.2"
@@ -9919,11 +10114,11 @@ __metadata:
   linkType: hard
 
 "jest-when@npm:^3.4.2":
-  version: 3.6.0
-  resolution: "jest-when@npm:3.6.0"
+  version: 3.7.0
+  resolution: "jest-when@npm:3.7.0"
   peerDependencies:
     jest: ">= 25"
-  checksum: 10/0cb92738ccfa5711a685107f4437f18aefbe3cda120c912a9d49b612eeef03a910481ab40fe753fd42c4e617ffbb3d84c6bd66a76d963dac7f1ad9e9e5059359
+  checksum: 10/b5b88d077ed467aab220c71c885dbc5f448604f06e68f761ce9f479c99bb74e0dbf553d1cc980751d88401b034a578e1c44eec5e4095743b7586f02bb7c6313d
   languageName: node
   linkType: hard
 
@@ -10170,10 +10365,23 @@ __metadata:
   languageName: node
   linkType: hard
 
+"jsonfile@npm:^6.0.1":
+  version: 6.1.0
+  resolution: "jsonfile@npm:6.1.0"
+  dependencies:
+    graceful-fs: "npm:^4.1.6"
+    universalify: "npm:^2.0.0"
+  dependenciesMeta:
+    graceful-fs:
+      optional: true
+  checksum: 10/03014769e7dc77d4cf05fa0b534907270b60890085dd5e4d60a382ff09328580651da0b8b4cdf44d91e4c8ae64d91791d965f05707beff000ed494a38b6fec85
+  languageName: node
+  linkType: hard
+
 "jsonschema@npm:^1.4.1":
-  version: 1.4.1
-  resolution: "jsonschema@npm:1.4.1"
-  checksum: 10/d7a188da7a3100a2caa362b80e98666d46607b7a7153aac405b8e758132961911c6df02d444d4700691330874e21a62639f550e856b21ddd28423690751ca9c6
+  version: 1.5.0
+  resolution: "jsonschema@npm:1.5.0"
+  checksum: 10/46bf49b388ba922073bcb3c8d5e90af9d29fc8303dc866fd440182c88d6b4fd2807679fd39cdefb4113156d104ea47da9c0ff4bbcb0032c9fa29461cb1a92182
   languageName: node
   linkType: hard
 
@@ -10311,16 +10519,16 @@ __metadata:
   linkType: hard
 
 "loglevel@npm:^1.8.1":
-  version: 1.9.1
-  resolution: "loglevel@npm:1.9.1"
-  checksum: 10/863cbbcddf850a937482c604e2d11586574a5110b746bb49c7cc04739e01f6035f6db841d25377106dd330bca7142d74995f15a97c5f3ea0af86d9472d4a99f4
+  version: 1.9.2
+  resolution: "loglevel@npm:1.9.2"
+  checksum: 10/6153d8db308323f7ee20130bc40309e7a976c30a10379d8666b596d9c6441965c3e074c8d7ee3347fe5cfc059c0375b6f3e8a10b93d5b813cc5547f5aa412a29
   languageName: node
   linkType: hard
 
 "long@npm:^5.0.0":
-  version: 5.2.3
-  resolution: "long@npm:5.2.3"
-  checksum: 10/9167ec6947a825b827c30da169a7384eec6c0c9ec2f0b9c74da2e93d81159bbe39fb09c3f13dae9721d4b807ccfa09797a7dd1012f5d478e3e33ca3c78b608e6
+  version: 5.2.4
+  resolution: "long@npm:5.2.4"
+  checksum: 10/c27c060a683d4d76dc48da12ded0ae49c610aaf10d028ec938829d7bebe916979dcc8b67ed71f8bf6d845a90151b66a9b741a3ee51ec874908e496c2a576697a
   languageName: node
   linkType: hard
 
@@ -10365,19 +10573,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"luxon@npm:^3.2.1":
+"luxon@npm:^3.2.1, luxon@npm:^3.5.0":
   version: 3.5.0
   resolution: "luxon@npm:3.5.0"
   checksum: 10/48f86e6c1c96815139f8559456a3354a276ba79bcef0ae0d4f2172f7652f3ba2be2237b0e103b8ea0b79b47715354ac9fac04eb1db3485dcc72d5110491dd47f
   languageName: node
   linkType: hard
 
-"magic-string@npm:^0.30.10":
-  version: 0.30.11
-  resolution: "magic-string@npm:0.30.11"
+"magic-string@npm:^0.30.11":
+  version: 0.30.17
+  resolution: "magic-string@npm:0.30.17"
   dependencies:
     "@jridgewell/sourcemap-codec": "npm:^1.5.0"
-  checksum: 10/b784d2240252f5b1e755d487354ada4c672cbca16f045144f7185a75b059210e5fcca7be7be03ef1bac2ca754c4428b21d36ae64a9057ba429916f06b8c54eb2
+  checksum: 10/2f71af2b0afd78c2e9012a29b066d2c8ba45a9cd0c8070f7fd72de982fb1c403b4e3afdb1dae00691d56885ede66b772ef6bedf765e02e3a7066208fe2fec4aa
   languageName: node
   linkType: hard
 
@@ -10417,6 +10625,25 @@ __metadata:
   languageName: node
   linkType: hard
 
+"make-fetch-happen@npm:^14.0.3":
+  version: 14.0.3
+  resolution: "make-fetch-happen@npm:14.0.3"
+  dependencies:
+    "@npmcli/agent": "npm:^3.0.0"
+    cacache: "npm:^19.0.1"
+    http-cache-semantics: "npm:^4.1.1"
+    minipass: "npm:^7.0.2"
+    minipass-fetch: "npm:^4.0.0"
+    minipass-flush: "npm:^1.0.5"
+    minipass-pipeline: "npm:^1.2.4"
+    negotiator: "npm:^1.0.0"
+    proc-log: "npm:^5.0.0"
+    promise-retry: "npm:^2.0.1"
+    ssri: "npm:^12.0.0"
+  checksum: 10/fce0385840b6d86b735053dfe941edc2dd6468fda80fe74da1eeff10cbd82a75760f406194f2bc2fa85b99545b2bc1f84c08ddf994b21830775ba2d1a87e8bdf
+  languageName: node
+  linkType: hard
+
 "makeerror@npm:1.0.12":
   version: 1.0.12
   resolution: "makeerror@npm:1.0.12"
@@ -10444,6 +10671,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"math-intrinsics@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "math-intrinsics@npm:1.1.0"
+  checksum: 10/11df2eda46d092a6035479632e1ec865b8134bdfc4bd9e571a656f4191525404f13a283a515938c3a8de934dbfd9c09674d9da9fa831e6eb7e22b50b197d2edd
+  languageName: node
+  linkType: hard
+
 "md5.js@npm:^1.3.4":
   version: 1.3.5
   resolution: "md5.js@npm:1.3.5"
@@ -10462,7 +10696,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"merge2@npm:^1.3.0, merge2@npm:^1.4.1":
+"merge2@npm:^1.3.0":
   version: 1.4.1
   resolution: "merge2@npm:1.4.1"
   checksum: 10/7268db63ed5169466540b6fb947aec313200bcf6d40c5ab722c22e242f651994619bcd85601602972d3c85bd2cc45a358a4c61937e9f11a061919a1da569b0c2
@@ -10595,6 +10829,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"minipass-fetch@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "minipass-fetch@npm:4.0.0"
+  dependencies:
+    encoding: "npm:^0.1.13"
+    minipass: "npm:^7.0.3"
+    minipass-sized: "npm:^1.0.3"
+    minizlib: "npm:^3.0.1"
+  dependenciesMeta:
+    encoding:
+      optional: true
+  checksum: 10/4b0772dbee77727b469dc5bfc371541d9aba1e243fbb46ddc1b9ff7efa4de4a4cf5ff3a359d6a3b3a460ca26df9ae67a9c93be26ab6417c225e49d63b52b2801
+  languageName: node
+  linkType: hard
+
 "minipass-flush@npm:^1.0.5":
   version: 1.0.5
   resolution: "minipass-flush@npm:1.0.5"
@@ -10638,7 +10887,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.1.2":
+"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3, minipass@npm:^7.0.4, minipass@npm:^7.1.2":
   version: 7.1.2
   resolution: "minipass@npm:7.1.2"
   checksum: 10/c25f0ee8196d8e6036661104bacd743785b2599a21de5c516b32b3fa2b83113ac89a2358465bc04956baab37ffb956ae43be679b2262bf7be15fce467ccd7950
@@ -10655,6 +10904,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"minizlib@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "minizlib@npm:3.0.1"
+  dependencies:
+    minipass: "npm:^7.0.4"
+    rimraf: "npm:^5.0.5"
+  checksum: 10/622cb85f51e5c206a080a62d20db0d7b4066f308cb6ce82a9644da112367c3416ae7062017e631eb7ac8588191cfa4a9a279b8651c399265202b298e98c4acef
+  languageName: node
+  linkType: hard
+
 "mkdirp@npm:^1.0.3":
   version: 1.0.4
   resolution: "mkdirp@npm:1.0.4"
@@ -10664,6 +10923,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"mkdirp@npm:^3.0.1":
+  version: 3.0.1
+  resolution: "mkdirp@npm:3.0.1"
+  bin:
+    mkdirp: dist/cjs/src/bin.js
+  checksum: 10/16fd79c28645759505914561e249b9a1f5fe3362279ad95487a4501e4467abeb714fd35b95307326b8fd03f3c7719065ef11a6f97b7285d7888306d1bd2232ba
+  languageName: node
+  linkType: hard
+
 "ms@npm:^2.1.1, ms@npm:^2.1.3":
   version: 2.1.3
   resolution: "ms@npm:2.1.3"
@@ -10672,9 +10940,9 @@ __metadata:
   linkType: hard
 
 "multiformats@npm:^13.1.0":
-  version: 13.2.2
-  resolution: "multiformats@npm:13.2.2"
-  checksum: 10/6e673320e9b06d5fdbbf2bde0d3132f13fac94fb40f36d646265b5c38eba4a28c40a2c76b4efa0c1a23517fe87320e540e9ef7f28d71c1cc3239c91bf6770ce6
+  version: 13.3.1
+  resolution: "multiformats@npm:13.3.1"
+  checksum: 10/2e529613d457590dffe212a658546f313c7c7296d240d952d2baee7ce0abb227116d784f05cf4d238ef0db7d72ad2c3d04ea3c6b9bfd20db805a092024ce8d7e
   languageName: node
   linkType: hard
 
@@ -10698,7 +10966,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nanoid@npm:^3.1.31, nanoid@npm:^3.3.7, nanoid@npm:^3.3.8":
+"nanoid@npm:^3.1.31, nanoid@npm:^3.3.8":
   version: 3.3.8
   resolution: "nanoid@npm:3.3.8"
   bin:
@@ -10715,9 +10983,16 @@ __metadata:
   linkType: hard
 
 "negotiator@npm:^0.6.3":
-  version: 0.6.3
-  resolution: "negotiator@npm:0.6.3"
-  checksum: 10/2723fb822a17ad55c93a588a4bc44d53b22855bf4be5499916ca0cab1e7165409d0b288ba2577d7b029f10ce18cf2ed8e703e5af31c984e1e2304277ef979837
+  version: 0.6.4
+  resolution: "negotiator@npm:0.6.4"
+  checksum: 10/d98c04a136583afd055746168f1067d58ce4bfe6e4c73ca1d339567f81ea1f7e665b5bd1e81f4771c67b6c2ea89b21cb2adaea2b16058c7dc31317778f931dab
+  languageName: node
+  linkType: hard
+
+"negotiator@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "negotiator@npm:1.0.0"
+  checksum: 10/b5734e87295324fabf868e36fb97c84b7d7f3156ec5f4ee5bf6e488079c11054f818290fc33804cef7b1ee21f55eeb14caea83e7dafae6492a409b3e573153e5
   languageName: node
   linkType: hard
 
@@ -10735,13 +11010,13 @@ __metadata:
   linkType: hard
 
 "nock@npm:^13.3.1":
-  version: 13.5.5
-  resolution: "nock@npm:13.5.5"
+  version: 13.5.6
+  resolution: "nock@npm:13.5.6"
   dependencies:
     debug: "npm:^4.1.0"
     json-stringify-safe: "npm:^5.0.1"
     propagate: "npm:^2.0.0"
-  checksum: 10/c19d7bf9654db056357a22b00127bb5606c1bbdff188a5b6c469825e580e31cd0cb0701bce8dd8b4876dbbd36a145fdb681fd69fd59308d6db4923ce8ab2439e
+  checksum: 10/a57c265b75e5f7767e2f8baf058773cdbf357c31c5fea2761386ec03a008a657f9df921899fe2a9502773b47145b708863b32345aef529b3c45cba4019120f88
   languageName: node
   linkType: hard
 
@@ -10778,19 +11053,19 @@ __metadata:
   linkType: hard
 
 "node-gyp-build@npm:^4.2.0":
-  version: 4.8.1
-  resolution: "node-gyp-build@npm:4.8.1"
+  version: 4.8.4
+  resolution: "node-gyp-build@npm:4.8.4"
   bin:
     node-gyp-build: bin.js
     node-gyp-build-optional: optional.js
     node-gyp-build-test: build-test.js
-  checksum: 10/b9297770f96a92e5f2b854f3fd5e4bd418df81d7785a81ab60cec5cf2e5e72dc2c3319808978adc572cfa3885e6b12338cb5f4034bed2cab35f0d76a4b75ccdf
+  checksum: 10/6a7d62289d1afc419fc8fc9bd00aa4e554369e50ca0acbc215cb91446148b75ff7e2a3b53c2c5b2c09a39d416d69f3d3237937860373104b5fe429bf30ad9ac5
   languageName: node
   linkType: hard
 
-"node-gyp@npm:^10.0.0, node-gyp@npm:latest":
-  version: 10.2.0
-  resolution: "node-gyp@npm:10.2.0"
+"node-gyp@npm:^10.0.0":
+  version: 10.3.1
+  resolution: "node-gyp@npm:10.3.1"
   dependencies:
     env-paths: "npm:^2.2.0"
     exponential-backoff: "npm:^3.1.1"
@@ -10804,7 +11079,27 @@ __metadata:
     which: "npm:^4.0.0"
   bin:
     node-gyp: bin/node-gyp.js
-  checksum: 10/41773093b1275751dec942b985982fd4e7a69b88cae719b868babcef3880ee6168aaec8dcaa8cd0b9fa7c84873e36cc549c6cac6a124ee65ba4ce1f1cc108cfe
+  checksum: 10/d3004f648559e42d7ec8791ea75747fe8a163a6061c202e311e5d7a5f6266baa9a5f5c6fde7be563974c88b030c5d0855fd945364f52fcd230d2a2ceee7be80d
+  languageName: node
+  linkType: hard
+
+"node-gyp@npm:latest":
+  version: 11.0.0
+  resolution: "node-gyp@npm:11.0.0"
+  dependencies:
+    env-paths: "npm:^2.2.0"
+    exponential-backoff: "npm:^3.1.1"
+    glob: "npm:^10.3.10"
+    graceful-fs: "npm:^4.2.6"
+    make-fetch-happen: "npm:^14.0.3"
+    nopt: "npm:^8.0.0"
+    proc-log: "npm:^5.0.0"
+    semver: "npm:^7.3.5"
+    tar: "npm:^7.4.3"
+    which: "npm:^5.0.0"
+  bin:
+    node-gyp: bin/node-gyp.js
+  checksum: 10/5d07430e887a906f85c7c6ed87e8facb7ecd4ce42d948a2438c471df2e24ae6af70f4def114ec1a03127988d164648dda8d75fe666f3c4b431e53856379fdf13
   languageName: node
   linkType: hard
 
@@ -10840,6 +11135,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"nopt@npm:^8.0.0":
+  version: 8.0.0
+  resolution: "nopt@npm:8.0.0"
+  dependencies:
+    abbrev: "npm:^2.0.0"
+  bin:
+    nopt: bin/nopt.js
+  checksum: 10/2d137f64b6f9331ec97047dd1cbbe4dcd9a61ceef4fd0f2252c0bbac1d69ba15671e6fd83a441328824b3ca78afe6ebe1694f12ebcd162b73a221582a06179ff
+  languageName: node
+  linkType: hard
+
 "normalize-package-data@npm:^6.0.0":
   version: 6.0.2
   resolution: "normalize-package-data@npm:6.0.2"
@@ -10947,10 +11253,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object-inspect@npm:^1.13.1":
-  version: 1.13.2
-  resolution: "object-inspect@npm:1.13.2"
-  checksum: 10/7ef65583b6397570a17c56f0c1841e0920e83900f2c94638927abb7b81ac08a19c7aae135bd9dcca96208cac0c7332b4650fb927f027b0cf92d71df2990d0561
+"object-inspect@npm:^1.13.3":
+  version: 1.13.3
+  resolution: "object-inspect@npm:1.13.3"
+  checksum: 10/14cb973d8381c69e14d7f1c8c75044eb4caf04c6dabcf40ca5c2ce42dc2073ae0bb2a9939eeca142b0c05215afaa1cd5534adb7c8879c32cba2576e045ed8368
   languageName: node
   linkType: hard
 
@@ -10972,14 +11278,16 @@ __metadata:
   linkType: hard
 
 "object.assign@npm:^4.1.4":
-  version: 4.1.5
-  resolution: "object.assign@npm:4.1.5"
+  version: 4.1.7
+  resolution: "object.assign@npm:4.1.7"
   dependencies:
-    call-bind: "npm:^1.0.5"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
     define-properties: "npm:^1.2.1"
-    has-symbols: "npm:^1.0.3"
+    es-object-atoms: "npm:^1.0.0"
+    has-symbols: "npm:^1.1.0"
     object-keys: "npm:^1.1.1"
-  checksum: 10/dbb22da4cda82e1658349ea62b80815f587b47131b3dd7a4ab7f84190ab31d206bbd8fe7e26ae3220c55b65725ac4529825f6142154211220302aa6b1518045d
+  checksum: 10/3fe28cdd779f2a728a9a66bd688679ba231a2b16646cd1e46b528fe7c947494387dda4bc189eff3417f3717ef4f0a8f2439347cf9a9aa3cef722fbfd9f615587
   languageName: node
   linkType: hard
 
@@ -11076,6 +11384,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"p-map@npm:^7.0.2":
+  version: 7.0.3
+  resolution: "p-map@npm:7.0.3"
+  checksum: 10/2ef48ccfc6dd387253d71bf502604f7893ed62090b2c9d73387f10006c342606b05233da0e4f29388227b61eb5aeface6197e166520c465c234552eeab2fe633
+  languageName: node
+  linkType: hard
+
 "p-throttle@npm:^4.1.1":
   version: 4.1.1
   resolution: "p-throttle@npm:4.1.1"
@@ -11091,9 +11406,9 @@ __metadata:
   linkType: hard
 
 "package-json-from-dist@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "package-json-from-dist@npm:1.0.0"
-  checksum: 10/ac706ec856a5a03f5261e4e48fa974f24feb044d51f84f8332e2af0af04fbdbdd5bbbfb9cbbe354190409bc8307c83a9e38c6672c3c8855f709afb0006a009ea
+  version: 1.0.1
+  resolution: "package-json-from-dist@npm:1.0.1"
+  checksum: 10/58ee9538f2f762988433da00e26acc788036914d57c71c246bf0be1b60cdbd77dd60b6a3e1a30465f0b248aeb80079e0b34cb6050b1dfa18c06953bb1cbc7602
   languageName: node
   linkType: hard
 
@@ -11248,7 +11563,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"picocolors@npm:^1.0.0, picocolors@npm:^1.0.1, picocolors@npm:^1.1.1":
+"picocolors@npm:^1.0.0, picocolors@npm:^1.1.1":
   version: 1.1.1
   resolution: "picocolors@npm:1.1.1"
   checksum: 10/e1cf46bf84886c79055fdfa9dcb3e4711ad259949e3565154b004b260cd356c5d54b31a1437ce9782624bf766272fe6b0154f5f0c744fb7af5d454d2b60db045
@@ -11262,6 +11577,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"picomatch@npm:^4.0.2":
+  version: 4.0.2
+  resolution: "picomatch@npm:4.0.2"
+  checksum: 10/ce617b8da36797d09c0baacb96ca8a44460452c89362d7cb8f70ca46b4158ba8bc3606912de7c818eb4a939f7f9015cef3c766ec8a0c6bfc725fdc078e39c717
+  languageName: node
+  linkType: hard
+
 "pify@npm:^5.0.0":
   version: 5.0.0
   resolution: "pify@npm:5.0.0"
@@ -11308,14 +11630,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"postcss@npm:^8.4.40":
-  version: 8.4.41
-  resolution: "postcss@npm:8.4.41"
+"postcss@npm:^8.4.48":
+  version: 8.5.1
+  resolution: "postcss@npm:8.5.1"
   dependencies:
-    nanoid: "npm:^3.3.7"
-    picocolors: "npm:^1.0.1"
-    source-map-js: "npm:^1.2.0"
-  checksum: 10/6e6176c2407eff60493ca60a706c6b7def20a722c3adda94ea1ece38345eb99964191336fd62b62652279cec6938e79e0b1e1d477142c8d3516e7a725a74ee37
+    nanoid: "npm:^3.3.8"
+    picocolors: "npm:^1.1.1"
+    source-map-js: "npm:^1.2.1"
+  checksum: 10/1fbd28753143f7f03e4604813639918182b15343c7ad0f4e72f3875fc2cc0b8494c887f55dc05008fad5fbf1e1e908ce2edbbce364a91f84dcefb71edf7cd31d
   languageName: node
   linkType: hard
 
@@ -11336,17 +11658,17 @@ __metadata:
   linkType: hard
 
 "prettier-plugin-packagejson@npm:^2.4.5":
-  version: 2.5.2
-  resolution: "prettier-plugin-packagejson@npm:2.5.2"
+  version: 2.5.7
+  resolution: "prettier-plugin-packagejson@npm:2.5.7"
   dependencies:
-    sort-package-json: "npm:2.10.1"
-    synckit: "npm:0.9.1"
+    sort-package-json: "npm:2.13.0"
+    synckit: "npm:0.9.2"
   peerDependencies:
     prettier: ">= 1.16.0"
   peerDependenciesMeta:
     prettier:
       optional: true
-  checksum: 10/f280d69327a468cd104c72a81134258d3573e56d697a88a5c4498c8d02cecda9a27d9eb3f1d29cc726491782eb3f279c9d41ecf8364a197e20b239c5ccfd0269
+  checksum: 10/eca337657660e706134a1509053c39a88249965ff8ec692074c24ad7c2234b878d48c0ccb803e0827a47e676cbeb5ce7845e21f9fbe2c9bdf12e2565b91d0515
   languageName: node
   linkType: hard
 
@@ -11397,6 +11719,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"proc-log@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "proc-log@npm:5.0.0"
+  checksum: 10/35610bdb0177d3ab5d35f8827a429fb1dc2518d9e639f2151ac9007f01a061c30e0c635a970c9b00c39102216160f6ec54b62377c92fac3b7bfc2ad4b98d195c
+  languageName: node
+  linkType: hard
+
 "process@npm:^0.11.10":
   version: 0.11.10
   resolution: "process@npm:0.11.10"
@@ -11483,9 +11812,11 @@ __metadata:
   linkType: hard
 
 "psl@npm:^1.1.33":
-  version: 1.9.0
-  resolution: "psl@npm:1.9.0"
-  checksum: 10/d07879d4bfd0ac74796306a8e5a36a93cfb9c4f4e8ee8e63fbb909066c192fe1008cd8f12abd8ba2f62ca28247949a20c8fb32e1d18831d9e71285a1569720f9
+  version: 1.15.0
+  resolution: "psl@npm:1.15.0"
+  dependencies:
+    punycode: "npm:^2.3.1"
+  checksum: 10/5e7467eb5196eb7900d156783d12907d445c0122f76c73203ce96b148a6ccf8c5450cc805887ffada38ff92d634afcf33720c24053cb01d5b6598d1c913c5caf
   languageName: node
   linkType: hard
 
@@ -11506,7 +11837,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"punycode@npm:^2.1.0, punycode@npm:^2.1.1":
+"punycode@npm:^2.1.0, punycode@npm:^2.1.1, punycode@npm:^2.3.1":
   version: 2.3.1
   resolution: "punycode@npm:2.3.1"
   checksum: 10/febdc4362bead22f9e2608ff0171713230b57aff9dddc1c273aa2a651fbd366f94b7d6a71d78342a7c0819906750351ca7f2edd26ea41b626d87d6a13d1bd059
@@ -11514,11 +11845,11 @@ __metadata:
   linkType: hard
 
 "qs@npm:^6.11.2":
-  version: 6.13.0
-  resolution: "qs@npm:6.13.0"
+  version: 6.14.0
+  resolution: "qs@npm:6.14.0"
   dependencies:
-    side-channel: "npm:^1.0.6"
-  checksum: 10/f548b376e685553d12e461409f0d6e5c59ec7c7d76f308e2a888fd9db3e0c5e89902bedd0754db3a9038eda5f27da2331a6f019c8517dc5e0a16b3c9a6e9cef8
+    side-channel: "npm:^1.1.0"
+  checksum: 10/a60e49bbd51c935a8a4759e7505677b122e23bf392d6535b8fc31c1e447acba2c901235ecb192764013cd2781723dc1f61978b5fdd93cc31d7043d31cdc01974
   languageName: node
   linkType: hard
 
@@ -11638,15 +11969,15 @@ __metadata:
   linkType: hard
 
 "readable-stream@npm:^3.6.2 || ^4.4.2":
-  version: 4.5.2
-  resolution: "readable-stream@npm:4.5.2"
+  version: 4.7.0
+  resolution: "readable-stream@npm:4.7.0"
   dependencies:
     abort-controller: "npm:^3.0.0"
     buffer: "npm:^6.0.3"
     events: "npm:^3.3.0"
     process: "npm:^0.11.10"
     string_decoder: "npm:^1.3.0"
-  checksum: 10/01b128a559c5fd76a898495f858cf0a8839f135e6a69e3409f986e88460134791657eb46a2ff16826f331682a3c4d0c5a75cef5e52ef259711021ba52b1c2e82
+  checksum: 10/bdf096c8ff59452ce5d08f13da9597f9fcfe400b4facfaa88e74ec057e5ad1fdfa140ffe28e5ed806cf4d2055f0b812806e962bca91dce31bc4cef08e53be3a4
   languageName: node
   linkType: hard
 
@@ -11771,7 +12102,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve@npm:1.22.8, resolve@npm:^1.20.0, resolve@npm:^1.22.3, resolve@npm:^1.22.4":
+"resolve@npm:1.22.8":
   version: 1.22.8
   resolution: "resolve@npm:1.22.8"
   dependencies:
@@ -11784,7 +12115,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve@patch:resolve@npm%3A1.22.8#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.20.0#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.3#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.4#optional!builtin<compat/resolve>":
+"resolve@npm:^1.20.0, resolve@npm:^1.22.3, resolve@npm:^1.22.4":
+  version: 1.22.10
+  resolution: "resolve@npm:1.22.10"
+  dependencies:
+    is-core-module: "npm:^2.16.0"
+    path-parse: "npm:^1.0.7"
+    supports-preserve-symlinks-flag: "npm:^1.0.0"
+  bin:
+    resolve: bin/resolve
+  checksum: 10/0a398b44da5c05e6e421d70108822c327675febb880eebe905587628de401854c61d5df02866ff34fc4cb1173a51c9f0e84a94702738df3611a62e2acdc68181
+  languageName: node
+  linkType: hard
+
+"resolve@patch:resolve@npm%3A1.22.8#optional!builtin<compat/resolve>":
   version: 1.22.8
   resolution: "resolve@patch:resolve@npm%3A1.22.8#optional!builtin<compat/resolve>::version=1.22.8&hash=c3c19d"
   dependencies:
@@ -11797,6 +12141,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"resolve@patch:resolve@npm%3A^1.20.0#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.3#optional!builtin<compat/resolve>, resolve@patch:resolve@npm%3A^1.22.4#optional!builtin<compat/resolve>":
+  version: 1.22.10
+  resolution: "resolve@patch:resolve@npm%3A1.22.10#optional!builtin<compat/resolve>::version=1.22.10&hash=c3c19d"
+  dependencies:
+    is-core-module: "npm:^2.16.0"
+    path-parse: "npm:^1.0.7"
+    supports-preserve-symlinks-flag: "npm:^1.0.0"
+  bin:
+    resolve: bin/resolve
+  checksum: 10/d4d878bfe3702d215ea23e75e0e9caf99468e3db76f5ca100d27ebdc527366fee3877e54bce7d47cc72ca8952fc2782a070d238bfa79a550eeb0082384c3b81a
+  languageName: node
+  linkType: hard
+
 "responselike@npm:^2.0.0":
   version: 2.0.1
   resolution: "responselike@npm:2.0.1"
@@ -11905,7 +12262,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"safe-buffer@npm:>=5.1.0, safe-buffer@npm:^5.0.1, safe-buffer@npm:^5.1.0, safe-buffer@npm:^5.1.1, safe-buffer@npm:^5.1.2, safe-buffer@npm:^5.2.0, safe-buffer@npm:~5.2.0":
+"safe-buffer@npm:>=5.1.0, safe-buffer@npm:^5.0.1, safe-buffer@npm:^5.1.0, safe-buffer@npm:^5.1.1, safe-buffer@npm:^5.1.2, safe-buffer@npm:^5.2.0, safe-buffer@npm:^5.2.1, safe-buffer@npm:~5.2.0":
   version: 5.2.1
   resolution: "safe-buffer@npm:5.2.1"
   checksum: 10/32872cd0ff68a3ddade7a7617b8f4c2ae8764d8b7d884c651b74457967a9e0e886267d3ecc781220629c44a865167b61c375d2da6c720c840ecd73f45d5d9451
@@ -11919,6 +12276,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"safe-regex-test@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "safe-regex-test@npm:1.1.0"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    is-regex: "npm:^1.2.1"
+  checksum: 10/ebdb61f305bf4756a5b023ad86067df5a11b26898573afe9e52a548a63c3bd594825d9b0e2dde2eb3c94e57e0e04ac9929d4107c394f7b8e56a4613bed46c69a
+  languageName: node
+  linkType: hard
+
 "safe-stable-stringify@npm:^2.4.3":
   version: 2.5.0
   resolution: "safe-stable-stringify@npm:2.5.0"
@@ -11997,15 +12365,15 @@ __metadata:
   linkType: hard
 
 "ses@npm:^1.1.0":
-  version: 1.7.0
-  resolution: "ses@npm:1.7.0"
+  version: 1.10.0
+  resolution: "ses@npm:1.10.0"
   dependencies:
-    "@endo/env-options": "npm:^1.1.5"
-  checksum: 10/8d1227fadcd06653d1b49083c067ae07e55164af984c9e8b393238fbbd315f47216472e3ac65a78638955f3f1a2537e9c9865f0ab142639a6862b902cb1cf6f2
+    "@endo/env-options": "npm:^1.1.8"
+  checksum: 10/57073350cab333e3c4516e8ea09e1ddd2f81fdd954dc48798548d098550d1da8bb3266def0461a34a4e11c0a1027bde03e05f2ac5feb512ff3fc33dd327a9bb2
   languageName: node
   linkType: hard
 
-"set-function-length@npm:^1.2.1":
+"set-function-length@npm:^1.2.2":
   version: 1.2.2
   resolution: "set-function-length@npm:1.2.2"
   dependencies:
@@ -12087,15 +12455,51 @@ __metadata:
   languageName: node
   linkType: hard
 
-"side-channel@npm:^1.0.6":
-  version: 1.0.6
-  resolution: "side-channel@npm:1.0.6"
+"side-channel-list@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "side-channel-list@npm:1.0.0"
   dependencies:
-    call-bind: "npm:^1.0.7"
     es-errors: "npm:^1.3.0"
-    get-intrinsic: "npm:^1.2.4"
-    object-inspect: "npm:^1.13.1"
-  checksum: 10/eb10944f38cebad8ad643dd02657592fa41273ce15b8bfa928d3291aff2d30c20ff777cfe908f76ccc4551ace2d1245822fdc576657cce40e9066c638ca8fa4d
+    object-inspect: "npm:^1.13.3"
+  checksum: 10/603b928997abd21c5a5f02ae6b9cc36b72e3176ad6827fab0417ead74580cc4fb4d5c7d0a8a2ff4ead34d0f9e35701ed7a41853dac8a6d1a664fcce1a044f86f
+  languageName: node
+  linkType: hard
+
+"side-channel-map@npm:^1.0.1":
+  version: 1.0.1
+  resolution: "side-channel-map@npm:1.0.1"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.5"
+    object-inspect: "npm:^1.13.3"
+  checksum: 10/5771861f77feefe44f6195ed077a9e4f389acc188f895f570d56445e251b861754b547ea9ef73ecee4e01fdada6568bfe9020d2ec2dfc5571e9fa1bbc4a10615
+  languageName: node
+  linkType: hard
+
+"side-channel-weakmap@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "side-channel-weakmap@npm:1.0.2"
+  dependencies:
+    call-bound: "npm:^1.0.2"
+    es-errors: "npm:^1.3.0"
+    get-intrinsic: "npm:^1.2.5"
+    object-inspect: "npm:^1.13.3"
+    side-channel-map: "npm:^1.0.1"
+  checksum: 10/a815c89bc78c5723c714ea1a77c938377ea710af20d4fb886d362b0d1f8ac73a17816a5f6640f354017d7e292a43da9c5e876c22145bac00b76cfb3468001736
+  languageName: node
+  linkType: hard
+
+"side-channel@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "side-channel@npm:1.1.0"
+  dependencies:
+    es-errors: "npm:^1.3.0"
+    object-inspect: "npm:^1.13.3"
+    side-channel-list: "npm:^1.0.0"
+    side-channel-map: "npm:^1.0.1"
+    side-channel-weakmap: "npm:^1.0.2"
+  checksum: 10/7d53b9db292c6262f326b6ff3bc1611db84ece36c2c7dc0e937954c13c73185b0406c56589e2bb8d071d6fee468e14c39fb5d203ee39be66b7b8174f179afaba
   languageName: node
   linkType: hard
 
@@ -12171,13 +12575,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"slash@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "slash@npm:4.0.0"
-  checksum: 10/da8e4af73712253acd21b7853b7e0dbba776b786e82b010a5bfc8b5051a1db38ed8aba8e1e8f400dd2c9f373be91eb1c42b66e91abb407ff42b10feece5e1d2d
-  languageName: node
-  linkType: hard
-
 "slashes@npm:^3.0.12":
   version: 3.0.12
   resolution: "slashes@npm:3.0.12"
@@ -12204,13 +12601,13 @@ __metadata:
   linkType: hard
 
 "socks-proxy-agent@npm:^8.0.3":
-  version: 8.0.4
-  resolution: "socks-proxy-agent@npm:8.0.4"
+  version: 8.0.5
+  resolution: "socks-proxy-agent@npm:8.0.5"
   dependencies:
-    agent-base: "npm:^7.1.1"
+    agent-base: "npm:^7.1.2"
     debug: "npm:^4.3.4"
     socks: "npm:^2.8.3"
-  checksum: 10/c8e7c2b398338b49a0a0f4d2bae5c0602aeeca6b478b99415927b6c5db349ca258448f2c87c6958ebf83eea17d42cbc5d1af0bfecb276cac10b9658b0f07f7d7
+  checksum: 10/ee99e1dacab0985b52cbe5a75640be6e604135e9489ebdc3048635d186012fbaecc20fbbe04b177dee434c319ba20f09b3e7dfefb7d932466c0d707744eac05c
   languageName: node
   linkType: hard
 
@@ -12231,28 +12628,28 @@ __metadata:
   languageName: node
   linkType: hard
 
-"sort-package-json@npm:2.10.1":
-  version: 2.10.1
-  resolution: "sort-package-json@npm:2.10.1"
+"sort-package-json@npm:2.13.0":
+  version: 2.13.0
+  resolution: "sort-package-json@npm:2.13.0"
   dependencies:
     detect-indent: "npm:^7.0.1"
     detect-newline: "npm:^4.0.0"
     get-stdin: "npm:^9.0.0"
     git-hooks-list: "npm:^3.0.0"
-    globby: "npm:^13.1.2"
     is-plain-obj: "npm:^4.1.0"
     semver: "npm:^7.6.0"
     sort-object-keys: "npm:^1.1.3"
+    tinyglobby: "npm:^0.2.9"
   bin:
     sort-package-json: cli.js
-  checksum: 10/3a08cb9227c244d51bfb0eaaa5a9ea82fd3c96ea299c040365700b3f445d46a98411df4237f4e3c96ba67be4dcd53931747eab3b799f0335d278b36d64f1061d
+  checksum: 10/06081222ca6a0affddb613d6ee703012aba460b3b41930a229b1ba222f5829fc5dba996b69e229c198164112600455dc3178bbd7819f80c33503dbea61f67fac
   languageName: node
   linkType: hard
 
-"source-map-js@npm:^1.2.0":
-  version: 1.2.0
-  resolution: "source-map-js@npm:1.2.0"
-  checksum: 10/74f331cfd2d121c50790c8dd6d3c9de6be21926de80583b23b37029b0f37aefc3e019fa91f9a10a5e120c08135297e1ecf312d561459c45908cb1e0e365f49e5
+"source-map-js@npm:^1.2.0, source-map-js@npm:^1.2.1":
+  version: 1.2.1
+  resolution: "source-map-js@npm:1.2.1"
+  checksum: 10/ff9d8c8bf096d534a5b7707e0382ef827b4dd360a577d3f34d2b9f48e12c9d230b5747974ee7c607f0df65113732711bb701fe9ece3c7edbd43cb2294d707df3
   languageName: node
   linkType: hard
 
@@ -12318,9 +12715,9 @@ __metadata:
   linkType: hard
 
 "spdx-license-ids@npm:^3.0.0":
-  version: 3.0.20
-  resolution: "spdx-license-ids@npm:3.0.20"
-  checksum: 10/30e566ea74b04232c64819d1f5313c00d92e9c73d054541650331fc794499b3bcc4991bcd90fa3c2fc4d040006f58f63104706255266e87a9d452e6574afc60c
+  version: 3.0.21
+  resolution: "spdx-license-ids@npm:3.0.21"
+  checksum: 10/17a033b4c3485f081fc9faa1729dde8782a85d9131b156f2397c71256c2e1663132857d3cba1457c4965f179a4dcf1b69458a31e9d3d0c766d057ef0e3a0b4f2
   languageName: node
   linkType: hard
 
@@ -12347,6 +12744,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ssri@npm:^12.0.0":
+  version: 12.0.0
+  resolution: "ssri@npm:12.0.0"
+  dependencies:
+    minipass: "npm:^7.0.3"
+  checksum: 10/7024c1a6e39b3f18aa8f1c8290e884fe91b0f9ca5a6c6d410544daad54de0ba664db879afe16412e187c6c292fd60b937f047ee44292e5c2af2dcc6d8e1a9b48
+  languageName: node
+  linkType: hard
+
 "ssri@npm:^6.0.1":
   version: 6.0.2
   resolution: "ssri@npm:6.0.2"
@@ -12373,8 +12779,8 @@ __metadata:
   linkType: hard
 
 "streamx@npm:^2.15.0":
-  version: 2.19.0
-  resolution: "streamx@npm:2.19.0"
+  version: 2.21.1
+  resolution: "streamx@npm:2.21.1"
   dependencies:
     bare-events: "npm:^2.2.0"
     fast-fifo: "npm:^1.3.2"
@@ -12383,7 +12789,7 @@ __metadata:
   dependenciesMeta:
     bare-events:
       optional: true
-  checksum: 10/3e57a12402200cce347bd0658b5e7ef14a41636341256d2a9f43100e5c4f5d82166a4df77aef92082686150805a1b14f74370f3c96b4ed3d6d9889da1e3b3c21
+  checksum: 10/d61ee82033f8b900226e2405aeb683de5f51a68ded1d40198d548cd9a7b2e47b7706442c9142bbc7fc59874f03063ee41ddf9e8667e63186b507b2e6b394ac28
   languageName: node
   linkType: hard
 
@@ -12532,17 +12938,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"synckit@npm:0.9.1":
-  version: 0.9.1
-  resolution: "synckit@npm:0.9.1"
-  dependencies:
-    "@pkgr/core": "npm:^0.1.0"
-    tslib: "npm:^2.6.2"
-  checksum: 10/bff3903976baf8b699b5483228116d70223781a93b17c70e685c277ee960cdfd1a09cb5a741e6a9ec35e2428f14f4664baec41ccc99a598f267608b2a54f529b
-  languageName: node
-  linkType: hard
-
-"synckit@npm:^0.9.1":
+"synckit@npm:0.9.2, synckit@npm:^0.9.1":
   version: 0.9.2
   resolution: "synckit@npm:0.9.2"
   dependencies:
@@ -12597,6 +12993,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tar@npm:^7.4.3":
+  version: 7.4.3
+  resolution: "tar@npm:7.4.3"
+  dependencies:
+    "@isaacs/fs-minipass": "npm:^4.0.0"
+    chownr: "npm:^3.0.0"
+    minipass: "npm:^7.1.2"
+    minizlib: "npm:^3.0.1"
+    mkdirp: "npm:^3.0.1"
+    yallist: "npm:^5.0.0"
+  checksum: 10/12a2a4fc6dee23e07cc47f1aeb3a14a1afd3f16397e1350036a8f4cdfee8dcac7ef5978337a4e7b2ac2c27a9a6d46388fc2088ea7c80cb6878c814b1425f8ecf
+  languageName: node
+  linkType: hard
+
 "tau-prolog@npm:^0.2.66":
   version: 0.2.81
   resolution: "tau-prolog@npm:0.2.81"
@@ -12629,11 +13039,11 @@ __metadata:
   linkType: hard
 
 "text-decoder@npm:^1.1.0":
-  version: 1.1.1
-  resolution: "text-decoder@npm:1.1.1"
+  version: 1.2.3
+  resolution: "text-decoder@npm:1.2.3"
   dependencies:
     b4a: "npm:^1.6.4"
-  checksum: 10/c6981b93850daeafc8bd1dbd8f984d4fb2d14632f450de0892692b5bbee2d2f4cbef8a807142527370649fd357f58491ede4915d43669eca624cb52b8dd247b6
+  checksum: 10/bcdec33c0f070aeac38e46e4cafdcd567a58473ed308bdf75260bfbd8f7dc76acbc0b13226afaec4a169d0cb44cec2ab89c57b6395ccf02e941eaebbe19e124a
   languageName: node
   linkType: hard
 
@@ -12654,6 +13064,16 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tinyglobby@npm:^0.2.9":
+  version: 0.2.10
+  resolution: "tinyglobby@npm:0.2.10"
+  dependencies:
+    fdir: "npm:^6.4.2"
+    picomatch: "npm:^4.0.2"
+  checksum: 10/10c976866d849702edc47fc3fef27d63f074c40f75ef17171ecc1452967900699fa1e62373681dd58e673ddff2e3f6094bcd0a2101e3e4b30f4c2b9da41397f2
+  languageName: node
+  linkType: hard
+
 "tinylogic@npm:^2.0.0":
   version: 2.0.0
   resolution: "tinylogic@npm:2.0.0"
@@ -12792,14 +13212,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tslib@npm:2.4.0":
-  version: 2.4.0
-  resolution: "tslib@npm:2.4.0"
-  checksum: 10/d8379e68b36caf082c1905ec25d17df8261e1d68ddc1abfd6c91158a064f6e4402039ae7c02cf4c81d12e3a2a2c7cd8ea2f57b233eb80136a2e3e7279daf2911
+"tslib@npm:2.7.0":
+  version: 2.7.0
+  resolution: "tslib@npm:2.7.0"
+  checksum: 10/9a5b47ddac65874fa011c20ff76db69f97cf90c78cff5934799ab8894a5342db2d17b4e7613a087046bc1d133d21547ddff87ac558abeec31ffa929c88b7fce6
   languageName: node
   linkType: hard
 
-"tslib@npm:^2.1.0, tslib@npm:^2.3.0, tslib@npm:^2.3.1, tslib@npm:^2.4.0, tslib@npm:^2.6.2, tslib@npm:^2.6.3":
+"tslib@npm:^2.1.0, tslib@npm:^2.3.0, tslib@npm:^2.4.0, tslib@npm:^2.6.2, tslib@npm:^2.6.3":
   version: 2.8.1
   resolution: "tslib@npm:2.8.1"
   checksum: 10/3e2e043d5c2316461cb54e5c7fe02c30ef6dccb3384717ca22ae5c6b5bc95232a6241df19c622d9c73b809bea33b187f6dbc73030963e29950c2141bc32a79f7
@@ -12850,6 +13270,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"type-fest@npm:4.30.0":
+  version: 4.30.0
+  resolution: "type-fest@npm:4.30.0"
+  checksum: 10/46c733df4feb87dfd281fba4fa3913dc38b45136be35adffbcef95e13414105a4669476c1f8686680b9c98e59ed5dc85efe42caf67adbaa04f48dfc41f8330fa
+  languageName: node
+  linkType: hard
+
 "type-fest@npm:^0.12.0":
   version: 0.12.0
   resolution: "type-fest@npm:0.12.0"
@@ -12872,9 +13299,9 @@ __metadata:
   linkType: hard
 
 "type-fest@npm:^4.0.0":
-  version: 4.25.0
-  resolution: "type-fest@npm:4.25.0"
-  checksum: 10/16ddf51dbfeef45e6f0a139c16f06d6cd05b61be76b048c41e79997f150a66422219d7ec10a2717ab926505402d59b1ddc8560f5f6c245e1b8a35971c2f1b754
+  version: 4.32.0
+  resolution: "type-fest@npm:4.32.0"
+  checksum: 10/7cee33a2d82c992e97e85eca4016a7dd62239fc6f95a7f86d46671900cad594eda832d97a1d4231d3bb2ed7ff5144c5f3cf4644e1f722faa4e6decef0c5276ca
   languageName: node
   linkType: hard
 
@@ -12920,16 +13347,16 @@ __metadata:
   linkType: hard
 
 "typescript-eslint@npm:^8.7.0":
-  version: 8.19.1
-  resolution: "typescript-eslint@npm:8.19.1"
+  version: 8.20.0
+  resolution: "typescript-eslint@npm:8.20.0"
   dependencies:
-    "@typescript-eslint/eslint-plugin": "npm:8.19.1"
-    "@typescript-eslint/parser": "npm:8.19.1"
-    "@typescript-eslint/utils": "npm:8.19.1"
+    "@typescript-eslint/eslint-plugin": "npm:8.20.0"
+    "@typescript-eslint/parser": "npm:8.20.0"
+    "@typescript-eslint/utils": "npm:8.20.0"
   peerDependencies:
     eslint: ^8.57.0 || ^9.0.0
     typescript: ">=4.8.4 <5.8.0"
-  checksum: 10/3e7861bcd47c0bea962662d5f18a9f9214270057c082f2e3839ee2f681a42018395755216005d2408447de5b96892b6a18cc794daf8663bba1753def48e6756c
+  checksum: 10/5d72ec36d9a6a519cedb003af28bdad37560999a6f8a126193098ff403d6cc6947f3f27d09171d446bc62e43a1aeb00563ce1adfc85014a011993bfa2c95a20f
   languageName: node
   linkType: hard
 
@@ -12967,12 +13394,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"undici@npm:5.28.4":
-  version: 5.28.4
-  resolution: "undici@npm:5.28.4"
-  dependencies:
-    "@fastify/busboy": "npm:^2.0.0"
-  checksum: 10/a666a9f5ac4270c659fafc33d78b6b5039a0adbae3e28f934774c85dcc66ea91da907896f12b414bd6f578508b44d5dc206fa636afa0e49a4e1c9e99831ff065
+"undici-types@npm:~6.20.0":
+  version: 6.20.0
+  resolution: "undici-types@npm:6.20.0"
+  checksum: 10/583ac7bbf4ff69931d3985f4762cde2690bb607844c16a5e2fbb92ed312fe4fa1b365e953032d469fa28ba8b224e88a595f0b10a449332f83fa77c695e567dbe
+  languageName: node
+  linkType: hard
+
+"undici@npm:6.19.7":
+  version: 6.19.7
+  resolution: "undici@npm:6.19.7"
+  checksum: 10/77fb8b0377388f6dba8244b015841318d621031211b4f3c2273d809304b77ec44adeba4b89dfd6708bdc044190e18f068e5b231882ef15d057d4624e46f544e3
   languageName: node
   linkType: hard
 
@@ -12985,6 +13417,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"unique-filename@npm:^4.0.0":
+  version: 4.0.0
+  resolution: "unique-filename@npm:4.0.0"
+  dependencies:
+    unique-slug: "npm:^5.0.0"
+  checksum: 10/6a62094fcac286b9ec39edbd1f8f64ff92383baa430af303dfed1ffda5e47a08a6b316408554abfddd9730c78b6106bef4ca4d02c1231a735ddd56ced77573df
+  languageName: node
+  linkType: hard
+
 "unique-slug@npm:^4.0.0":
   version: 4.0.0
   resolution: "unique-slug@npm:4.0.0"
@@ -12994,6 +13435,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"unique-slug@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "unique-slug@npm:5.0.0"
+  dependencies:
+    imurmurhash: "npm:^0.1.4"
+  checksum: 10/beafdf3d6f44990e0a5ce560f8f881b4ee811be70b6ba0db25298c31c8cf525ed963572b48cd03be1c1349084f9e339be4241666d7cf1ebdad20598d3c652b27
+  languageName: node
+  linkType: hard
+
 "universalify@npm:^0.2.0":
   version: 0.2.0
   resolution: "universalify@npm:0.2.0"
@@ -13001,6 +13451,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"universalify@npm:^2.0.0":
+  version: 2.0.1
+  resolution: "universalify@npm:2.0.1"
+  checksum: 10/ecd8469fe0db28e7de9e5289d32bd1b6ba8f7183db34f3bfc4ca53c49891c2d6aa05f3fb3936a81285a905cc509fb641a0c3fc131ec786167eff41236ae32e60
+  languageName: node
+  linkType: hard
+
 "update-browserslist-db@npm:^1.1.1":
   version: 1.1.2
   resolution: "update-browserslist-db@npm:1.1.2"
@@ -13268,16 +13725,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"which-typed-array@npm:^1.1.14, which-typed-array@npm:^1.1.2":
-  version: 1.1.15
-  resolution: "which-typed-array@npm:1.1.15"
+"which-typed-array@npm:^1.1.16, which-typed-array@npm:^1.1.2":
+  version: 1.1.18
+  resolution: "which-typed-array@npm:1.1.18"
   dependencies:
     available-typed-arrays: "npm:^1.0.7"
-    call-bind: "npm:^1.0.7"
+    call-bind: "npm:^1.0.8"
+    call-bound: "npm:^1.0.3"
     for-each: "npm:^0.3.3"
-    gopd: "npm:^1.0.1"
+    gopd: "npm:^1.2.0"
     has-tostringtag: "npm:^1.0.2"
-  checksum: 10/c3b6a99beadc971baa53c3ee5b749f2b9bdfa3b3b9a70650dd8511a48b61d877288b498d424712e9991d16019633086bd8b5923369460d93463c5825fa36c448
+  checksum: 10/11eed801b2bd08cdbaecb17aff381e0fb03526532f61acc06e6c7b9370e08062c33763a51f27825f13fdf34aabd0df6104007f4e8f96e6eaef7db0ce17a26d6e
   languageName: node
   linkType: hard
 
@@ -13325,6 +13783,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"which@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "which@npm:5.0.0"
+  dependencies:
+    isexe: "npm:^3.1.1"
+  bin:
+    node-which: bin/which.js
+  checksum: 10/6ec99e89ba32c7e748b8a3144e64bfc74aa63e2b2eacbb61a0060ad0b961eb1a632b08fb1de067ed59b002cec3e21de18299216ebf2325ef0f78e0f121e14e90
+  languageName: node
+  linkType: hard
+
 "widest-line@npm:^3.1.0":
   version: 3.1.0
   resolution: "widest-line@npm:3.1.0"
@@ -13492,6 +13961,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"yallist@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "yallist@npm:5.0.0"
+  checksum: 10/1884d272d485845ad04759a255c71775db0fac56308764b4c77ea56a20d56679fad340213054c8c9c9c26fcfd4c4b2a90df993b7e0aaf3cdb73c618d1d1a802a
+  languageName: node
+  linkType: hard
+
 "yaml@npm:^1.10.0":
   version: 1.10.2
   resolution: "yaml@npm:1.10.2"
@@ -13500,11 +13976,11 @@ __metadata:
   linkType: hard
 
 "yaml@npm:^2.2.2":
-  version: 2.5.0
-  resolution: "yaml@npm:2.5.0"
+  version: 2.7.0
+  resolution: "yaml@npm:2.7.0"
   bin:
     yaml: bin.mjs
-  checksum: 10/72e903fdbe3742058885205db4a6c9ff38e5f497f4e05e631264f7756083c05e7d10dfb5e4ce9d7a95de95338f9b20d19dd0b91c60c65f7d7608b6b3929820ad
+  checksum: 10/c8c314c62fbd49244a6a51b06482f6d495b37ab10fa685fcafa1bbaae7841b7233ee7d12cab087bcca5a0b28adc92868b6e437322276430c28d00f1c1732eeec
   languageName: node
   linkType: hard