feat: Export endowment factories via sub-path (#3957)

## Summary

- Adds `@metamask/snaps-execution-environments/endowments` sub-path
export exposing all endowment factory modules: `timeout`, `interval`,
`date`, `textEncoder`, `textDecoder`, `crypto`, `math`,
`consoleEndowment`, `network`
- Also exports `buildCommonEndowments` and types: `EndowmentFactory`,
`EndowmentFactoryOptions`, `EndowmentFactoryResult`, `NotifyFunction`,
`ConsoleEndowmentOptions`, `NetworkEndowmentOptions`
- Generalizes the API for reuse by external SES-based projects like
[ocap-kernel](MetaMask/ocap-kernel#935):
- Extracts `NotifyFunction` from `BaseSnapExecutor` into the endowments
module (re-exported for backward compat)
- Renames `snapId` to `sourceLabel` in `EndowmentFactoryOptions` — Snaps
passes `Snap: ${snapId}` internally, external consumers provide their
own label
- Adds `EndowmentFactoryResult` type with explicit `teardownFunction`
for lifecycle management
- **Type-safe required options at the barrel**: factory implementations
accept the wide `EndowmentFactoryOptions` internally (no casts), and the
barrel re-exports `consoleEndowment` / `network` with narrow factory
types (`ConsoleEndowmentOptions`, `NetworkEndowmentOptions`). External
consumers get compile-time errors when required options are missing:
  - `consoleEndowment.factory({})` → `Property 'sourceLabel' is missing`
  - `network.factory({})` → `Property 'notify' is missing`
- **Prerequisite for consumers**: factories call the SES `harden()`
global — the environment must have called `lockdown()` before invoking
any factory
- Snaps behavior is fully preserved — no changes to console output
format or internal endowment wiring

## Test plan

- [x] All existing endowment tests pass (console, network, timeout,
interval, index integration)
- [x] Barrel smoke test verifies all 9 modules + `buildCommonEndowments`
are correctly exported
- [x] Non-Snap label test (`ocap-kernel: vat-42`) validates generic
`sourceLabel` usage
- [x] Missing `sourceLabel` / `notify` tests verify descriptive error
for external consumers
- [x] Compile-time verification that narrow types reject `factory({})`
at the barrel
- [x] Build succeeds (ts-bridge ESM/CJS + LavaMoat webpack bundles)
- [x] Lint passes with no new errors

🤖 Generated with [Claude Code](https://claude.com/claude-code)

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Introduces a new public entrypoint and changes endowment factory
option contracts (`snapId`→`sourceLabel`, required
`notify`/`sourceLabel`), which could affect downstream consumers and
runtime if any call sites omit the newly-required options.
> 
> **Overview**
> Adds a new public subpath export,
`@metamask/snaps-execution-environments/endowments`, exposing hardened
endowment factory modules (plus `buildCommonEndowments`) and the
associated factory/types for reuse by non-Snaps SES consumers.
> 
> Refactors endowment factory typing and options: moves `NotifyFunction`
into `commonEndowmentFactory`, introduces `EndowmentFactoryResult` with
optional `teardownFunction`, and replaces `snapId` with a generic
`sourceLabel` (Snaps now pass `Snap: ${snapId}` internally). Tightens
runtime validation by requiring `sourceLabel` for the console factory
and `notify` for the network factory, and expands tests (including
`undefined` timeout/interval defaults) to cover the new contracts.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
46918a8. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sirtimid

packages/snaps-execution-environments/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Export endowment factories via `@metamask/snaps-execution-environments/endowments` ([#3957](https://github.com/MetaMask/snaps/pull/3957))
+
 ## [11.0.2]
 
 ### Changed

packages/snaps-execution-environments/coverage.json

@@ -1,5 +1,5 @@
 {
-  "branches": 90.09,
+  "branches": 92.03,
   "functions": 95.34,
   "lines": 92.74,
   "statements": 91.69

packages/snaps-execution-environments/package.json

@@ -28,6 +28,16 @@
         "default": "./dist/index.cjs"
       }
     },
+    "./endowments": {
+      "import": {
+        "types": "./dist/endowments.d.mts",
+        "default": "./dist/endowments.mjs"
+      },
+      "require": {
+        "types": "./dist/endowments.d.cts",
+        "default": "./dist/endowments.cjs"
+      }
+    },
     "./node-process": "./dist/webpack/node-process/bundle.js",
     "./node-thread": "./dist/webpack/node-thread/bundle.js",
     "./package.json": "./package.json"

packages/snaps-execution-environments/src/common/BaseSnapExecutor.ts

@@ -89,9 +89,7 @@ export type InvokeSnap = (
   args: InvokeSnapArgs | undefined,
 ) => Promise<Json>;
 
-export type NotifyFunction = (
-  notification: Omit<JsonRpcNotification, 'jsonrpc'>,
-) => Promise<void>;
+export type { NotifyFunction } from './endowments/commonEndowmentFactory';
 
 export class BaseSnapExecutor {
   readonly #snapData: Map<string, SnapData>;

packages/snaps-execution-environments/src/common/endowments/commonEndowmentFactory.ts

@@ -1,3 +1,5 @@
+import type { JsonRpcNotification } from '@metamask/utils';
+
 import consoleEndowment from './console';
 import crypto from './crypto';
 import date from './date';
@@ -7,19 +9,64 @@ import network from './network';
 import textDecoder from './textDecoder';
 import textEncoder from './textEncoder';
 import timeout from './timeout';
-import type { NotifyFunction } from '../BaseSnapExecutor';
 import { rootRealmGlobal } from '../globalObject';
 
+/**
+ * A function for sending JSON-RPC notifications from an endowment.
+ * Used by endowments that perform outbound operations (e.g., network `fetch`)
+ * to signal request lifecycle events.
+ */
+export type NotifyFunction = (
+  notification: Omit<JsonRpcNotification, 'jsonrpc'>,
+) => Promise<void>;
+
+/**
+ * Options passed to endowment factory functions.
+ */
 export type EndowmentFactoryOptions = {
-  snapId?: string;
+  /**
+   * A label identifying the source of endowment interactions, used as a
+   * prefix in console output. For example, passing `"MyApp"` causes console
+   * messages to be prefixed with `[MyApp]`.
+   */
+  sourceLabel?: string;
+
+  /**
+   * A notification callback used by endowments that perform outbound
+   * operations (e.g., network `fetch`).
+   */
   notify?: NotifyFunction;
 };
 
+/**
+ * The object returned by an endowment factory. Contains the endowment values
+ * keyed by their global name (e.g., `setTimeout`, `Date`) and an optional
+ * teardown function for lifecycle management.
+ */
+export type EndowmentFactoryResult = {
+  /**
+   * An optional function that performs cleanup when active resources (e.g.,
+   * pending timers or open network connections) should be released. Must not
+   * render endowments unusable — only restore them to their initial state,
+   * since they may be reused without reconstruction.
+   */
+  teardownFunction?: () => Promise<void> | void;
+  [key: string]: unknown;
+};
+
+/**
+ * Describes an endowment factory module. Each module exposes the names of
+ * the endowments it provides and a factory function that produces them.
+ */
 export type EndowmentFactory = {
   names: readonly string[];
-  factory: (options?: EndowmentFactoryOptions) => { [key: string]: unknown };
+  factory: (options?: EndowmentFactoryOptions) => EndowmentFactoryResult;
 };
 
+/**
+ * Describes a simple global value that should be hardened and exposed as an
+ * endowment without additional attenuation.
+ */
 export type CommonEndowmentSpecification = {
   endowment: unknown;
   name: string;

packages/snaps-execution-environments/src/common/endowments/console.test.ts

@@ -16,7 +16,7 @@ describe('Console endowment', () => {
 
   it('returns console properties from rootRealmGlobal', () => {
     const { console }: { console: Partial<typeof rootRealmGlobal.console> } =
-      consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+      consoleEndowment.factory({ sourceLabel: `Snap: ${MOCK_SNAP_ID}` });
     const consoleProperties = Object.getOwnPropertyNames(
       rootRealmGlobal.console,
     );
@@ -33,12 +33,16 @@ describe('Console endowment', () => {
 
   describe('log', () => {
     it('does not return the original console.log', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       expect(console.log).not.toStrictEqual(rootRealmGlobal.console.log);
     });
 
-    it('will log a message identifying the source of the call (snap id)', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+    it('prefixes output with the source label', () => {
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       const logSpy = jest.spyOn(rootRealmGlobal.console, 'log');
       console.log('This is a log message.');
       expect(logSpy).toHaveBeenCalledTimes(1);
@@ -48,7 +52,9 @@ describe('Console endowment', () => {
     });
 
     it('can handle non-string message types', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       const logSpy = jest.spyOn(rootRealmGlobal.console, 'log');
       console.log(12345);
       console.log({ foo: 'bar' });
@@ -66,12 +72,16 @@ describe('Console endowment', () => {
 
   describe('error', () => {
     it('does not return the original console.error', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       expect(console.error).not.toStrictEqual(rootRealmGlobal.console.error);
     });
 
-    it('will log a message identifying the source of the call (snap id)', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+    it('prefixes output with the source label', () => {
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       const errorSpy = jest.spyOn(rootRealmGlobal.console, 'error');
       console.error('This is an error message.');
       expect(errorSpy).toHaveBeenCalledTimes(1);
@@ -83,12 +93,16 @@ describe('Console endowment', () => {
 
   describe('assert', () => {
     it('does not return the original console.assert', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       expect(console.assert).not.toStrictEqual(rootRealmGlobal.console.assert);
     });
 
-    it('will log a message identifying the source of the call (snap id)', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+    it('prefixes output with the source label', () => {
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       const assertSpy = jest.spyOn(rootRealmGlobal.console, 'assert');
       console.assert(1 > 2, 'This is an assert message.');
       expect(assertSpy).toHaveBeenCalledTimes(1);
@@ -101,12 +115,16 @@ describe('Console endowment', () => {
 
   describe('debug', () => {
     it('does not return the original console.debug', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       expect(console.debug).not.toStrictEqual(rootRealmGlobal.console.debug);
     });
 
-    it('will log a message identifying the source of the call (snap id)', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+    it('prefixes output with the source label', () => {
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       const debugSpy = jest.spyOn(rootRealmGlobal.console, 'debug');
       console.debug('This is a debug message.');
       expect(debugSpy).toHaveBeenCalledTimes(1);
@@ -118,12 +136,16 @@ describe('Console endowment', () => {
 
   describe('info', () => {
     it('does not return the original console.info', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       expect(console.info).not.toStrictEqual(rootRealmGlobal.console.info);
     });
 
-    it('will log a message identifying the source of the call (snap id)', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+    it('prefixes output with the source label', () => {
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       const infoSpy = jest.spyOn(rootRealmGlobal.console, 'info');
       console.info('This is an info message.');
       expect(infoSpy).toHaveBeenCalledTimes(1);
@@ -135,12 +157,16 @@ describe('Console endowment', () => {
 
   describe('warn', () => {
     it('does not return the original console.warn', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       expect(console.warn).not.toStrictEqual(rootRealmGlobal.console.warn);
     });
 
-    it('will log a message identifying the source of the call (snap id)', () => {
-      const { console } = consoleEndowment.factory({ snapId: MOCK_SNAP_ID });
+    it('prefixes output with the source label', () => {
+      const { console } = consoleEndowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+      });
       const warnSpy = jest.spyOn(rootRealmGlobal.console, 'warn');
       console.warn('This is a warn message.');
       expect(warnSpy).toHaveBeenCalledTimes(1);
@@ -149,4 +175,23 @@ describe('Console endowment', () => {
       );
     });
   });
+
+  it('throws when sourceLabel is not provided', () => {
+    expect(() => consoleEndowment.factory()).toThrow(
+      'The "sourceLabel" option is required by the console endowment factory.',
+    );
+
+    expect(() => consoleEndowment.factory({})).toThrow(
+      'The "sourceLabel" option is required by the console endowment factory.',
+    );
+  });
+
+  it('supports arbitrary source labels for non-Snap consumers', () => {
+    const { console } = consoleEndowment.factory({
+      sourceLabel: 'ocap-kernel: vat-42',
+    });
+    const logSpy = jest.spyOn(rootRealmGlobal.console, 'log');
+    console.log('test message');
+    expect(logSpy).toHaveBeenCalledWith('[ocap-kernel: vat-42] test message');
+  });
 });

packages/snaps-execution-environments/src/common/endowments/console.ts

@@ -13,8 +13,9 @@ export const consoleAttenuatedMethods = new Set([
 ]);
 
 /**
- * A set of all the `console` values that will be passed to the snap. This has
- * all the values that are available in both the browser and Node.js.
+ * A set of all the `console` method names that will be included in the
+ * attenuated console object. Covers values available in both browser and
+ * Node.js.
  */
 export const consoleMethods = new Set([
   'debug',
@@ -52,13 +53,13 @@ type ConsoleFunctions = {
  * Gets the appropriate (prepended) message to pass to one of the attenuated
  * method calls.
  *
- * @param snapId - Id of the snap that we're getting a message for.
- * @param message - The id of the snap that will interact with the endowment.
+ * @param sourceLabel - Label identifying the source of the console call.
+ * @param message - The first argument passed to the console method.
  * @param args - The array of additional arguments.
  * @returns An array of arguments to be passed into an attenuated console method call.
  */
-function getMessage(snapId: string, message: unknown, ...args: unknown[]) {
-  const prefix = `[Snap: ${snapId}]`;
+function getMessage(sourceLabel: string, message: unknown, ...args: unknown[]) {
+  const prefix = `[${sourceLabel}]`;
 
   // If the first argument is a string, prepend the prefix to the message, and keep the
   // rest of the arguments as-is.
@@ -72,15 +73,18 @@ function getMessage(snapId: string, message: unknown, ...args: unknown[]) {
 }
 
 /**
- * Create a a {@link console} object, with the same properties as the global
+ * Create a {@link console} object, with the same properties as the global
  * {@link console} object, but with some methods replaced.
  *
  * @param options - Factory options used in construction of the endowment.
- * @param options.snapId - The id of the snap that will interact with the endowment.
+ * @param options.sourceLabel - Label identifying the source of the console call.
  * @returns The {@link console} object with the replaced methods.
  */
-function createConsole({ snapId }: EndowmentFactoryOptions = {}) {
-  assert(snapId !== undefined);
+function createConsole({ sourceLabel }: EndowmentFactoryOptions = {}) {
+  assert(
+    sourceLabel !== undefined,
+    'The "sourceLabel" option is required by the console endowment factory.',
+  );
   const keys = Object.getOwnPropertyNames(
     rootRealmGlobal.console,
   ) as (keyof typeof console)[];
@@ -103,15 +107,15 @@ function createConsole({ snapId }: EndowmentFactoryOptions = {}) {
       ) => {
         rootRealmGlobal.console.assert(
           value,
-          ...getMessage(snapId, message, ...optionalParams),
+          ...getMessage(sourceLabel, message, ...optionalParams),
         );
       },
       ...consoleFunctions.reduce<ConsoleFunctions>((target, key) => {
         return {
           ...target,
           [key]: (message?: unknown, ...optionalParams: any[]) => {
             rootRealmGlobal.console[key](
-              ...getMessage(snapId, message, ...optionalParams),
+              ...getMessage(sourceLabel, message, ...optionalParams),
             );
           },
         };

packages/snaps-execution-environments/src/common/endowments/endowments.test.browser.ts

@@ -43,7 +43,10 @@ describe('endowments', () => {
     const modules = buildCommonEndowments();
     modules.forEach((endowment) =>
       // @ts-expect-error: Partial mock.
-      endowment.factory({ snapId: MOCK_SNAP_ID, notify: mockNotify }),
+      endowment.factory({
+        sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
+        notify: mockNotify,
+      }),
     );
 
     // Specially attenuated endowments or endowments that require
@@ -70,7 +73,7 @@ describe('endowments', () => {
     });
     const { Date: DateAttenuated } = date.factory();
     const { console: consoleAttenuated } = consoleEndowment.factory({
-      snapId: MOCK_SNAP_ID,
+      sourceLabel: `Snap: ${MOCK_SNAP_ID}`,
     });
 
     const TEST_ENDOWMENTS = {