MetaMask · rekmarks · Feb 2, 2026 · Feb 3, 2026 · Feb 3, 2026 · Feb 3, 2026
@@ -138,7 +138,7 @@ const config = createConfig([
   },
 
   {
-    files: ['**/*.test.ts', '**/*.test.tsx'],
+    files: ['**/test/**/*', '**/*.test.ts', '**/*.test.tsx'],
     extends: [metamaskVitestConfig],
     rules: {
       // It's fine to do this in tests.

@@ -20,6 +20,12 @@ export async function bundleVat(sourcePath: string): Promise<VatBundle> {
   const result = await build({
     configFile: false,
     logLevel: 'silent',
+    // TODO: Remove this define block and add a process shim to VatSupervisor
+    // workerEndowments instead. This injects into ALL bundles but is only needed
+    // for libraries like immer that check process.env.NODE_ENV.
+    define: {
+      'process.env.NODE_ENV': JSON.stringify('production'),
+    },
     build: {
       write: false,
       lib: {

@@ -49,6 +49,7 @@
     "@metamask/kernel-ui": "workspace:^",
     "@metamask/kernel-utils": "workspace:^",
     "@metamask/logger": "workspace:^",
+    "@metamask/ocap-kernel": "workspace:^",
     "@metamask/streams": "workspace:^",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",

@@ -1,4 +1,4 @@
-import type { KernelFacade } from '@metamask/kernel-browser-runtime';
+import type { KernelFacet } from '@metamask/ocap-kernel';
 
 // Type declarations for kernel dev console API.
 declare global {
@@ -16,7 +16,7 @@ declare global {
   var E: typeof import('@endo/eventual-send').E;
 
   // eslint-disable-next-line no-var
-  var kernel: KernelFacade | Promise<KernelFacade>;
+  var kernel: KernelFacet | Promise<KernelFacet>;
 }
 
 export {};
@@ -191,19 +191,19 @@ test.describe('Control Panel', () => {
     const v3Values = [
       '{"key":"e.nextPromiseId.v3","value":"2"}',
       '{"key":"e.nextObjectId.v3","value":"1"}',
-      '{"key":"ko5.owner","value":"v3"}',
-      '{"key":"v3.c.ko5","value":"R o+0"}',
-      '{"key":"v3.c.o+0","value":"ko5"}',
+      '{"key":"ko6.owner","value":"v3"}',
+      '{"key":"v3.c.ko6","value":"R o+0"}',
+      '{"key":"v3.c.o+0","value":"ko6"}',
       '{"key":"v3.c.kp4","value":"R p-1"}',
       '{"key":"v3.c.p-1","value":"kp4"}',
-      '{"key":"ko5.refCount","value":"1,1"}',
+      '{"key":"ko6.refCount","value":"1,1"}',
       '{"key":"kp4.refCount","value":"2"}',
     ];
     const v1koValues = [
-      '{"key":"v1.c.ko4","value":"R o-1"}',
-      '{"key":"v1.c.o-1","value":"ko4"}',
-      '{"key":"v1.c.ko5","value":"R o-2"}',
-      '{"key":"v1.c.o-2","value":"ko5"}',
+      '{"key":"v1.c.ko5","value":"R o-1"}',
+      '{"key":"v1.c.o-1","value":"ko5"}',
+      '{"key":"v1.c.ko6","value":"R o-2"}',
+      '{"key":"v1.c.o-2","value":"ko6"}',
     ];
     await expect(
       popupPage.locator('[data-testid="message-output"]'),
@@ -263,7 +263,7 @@ test.describe('Control Panel', () => {
         popupPage.locator('[data-testid="message-output"]'),
       ).not.toContainText(value);
     }
-    // ko3 (vat root) reference still exists for v1
+    // v2/v3 vat root references still exist for v1
     for (const value of v1koValues) {
       await expect(
         popupPage.locator('[data-testid="message-output"]'),

@@ -108,7 +108,7 @@ test.describe('Object Registry', () => {
 
   test('should revoke an object', async () => {
     const owner = 'v1';
-    const v1Root = 'ko3';
+    const v1Root = 'ko4';
     const [target, method, params] = [v1Root, 'hello', '["Bob"]'];
 
     // Before revoking, we should be able to send a message to the object

@@ -118,8 +118,8 @@ test.describe('Remote Communications', () => {
     await expect(targetSelect).toBeVisible();
     const options = await targetSelect.locator('option').all();
     expect(options.length).toBeGreaterThan(1);
-    await targetSelect.selectOption({ value: 'ko3' });
-    expect(await targetSelect.inputValue()).toBe('ko3');
+    await targetSelect.selectOption({ value: 'ko4' });
+    expect(await targetSelect.inputValue()).toBe('ko4');
 
     // Set method to doRunRun (the remote communication method)
     const methodInput = popupPage1.locator('[data-testid="message-method"]');

@@ -1,8 +1,9 @@
 import { makeCapTP } from '@endo/captp';
 import type { JsonRpcMessage, JsonRpcCall } from '@metamask/kernel-utils';
+import type { KernelFacet } from '@metamask/ocap-kernel';
 import type { JsonRpcNotification } from '@metamask/utils';
 
-import type { CapTPMessage, KernelFacade } from './types.ts';
+import type { CapTPMessage } from './types.ts';
 
 export type { CapTPMessage };
 
@@ -79,12 +80,12 @@ export type BackgroundCapTP = {
   dispatch: (message: CapTPMessage) => boolean;
 
   /**
-   * Get the remote kernel facade.
+   * Get the remote kernel facet.
    * This is how the background calls kernel methods using E().
    *
-   * @returns A promise for the kernel facade remote presence.
+   * @returns A promise for the kernel facet remote presence.
    */
-  getKernel: () => Promise<KernelFacade>;
+  getKernel: () => Promise<KernelFacet>;
 
   /**
    * Abort the CapTP connection.

@@ -11,7 +11,6 @@ export * from './makeIframeVatWorker.ts';
 export * from './PlatformServicesClient.ts';
 export * from './PlatformServicesServer.ts';
 export * from './utils/index.ts';
-export type { KernelFacade } from './types.ts';
 export {
   makeBackgroundCapTP,
   isCapTPNotification,

@@ -1,5 +1,6 @@
 import { E } from '@endo/eventual-send';
 import type { ClusterConfig, Kernel } from '@metamask/ocap-kernel';
+import { makeKernelFacet, kslot } from '@metamask/ocap-kernel';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 import { makeKernelCapTP } from './kernel-captp.ts';
@@ -10,7 +11,7 @@ import type { CapTPMessage } from '../../background-captp.ts';
  * Integration tests for CapTP communication between background and kernel endpoints.
  *
  * These tests validate that the two CapTP endpoints can communicate correctly
- * and that E() works properly with the kernel facade remote presence.
+ * and that E() works properly with the kernel facet remote presence.
  */
 describe('CapTP Integration', () => {
   let mockKernel: Kernel;
@@ -20,31 +21,59 @@ describe('CapTP Integration', () => {
   beforeEach(() => {
     // Create mock kernel with method implementations
     mockKernel = {
+      getPresence: vi
+        .fn()
+        .mockImplementation(async (kref: string, iface: string) =>
+          kslot(kref, iface),
+        ),
+      getStatus: vi.fn().mockResolvedValue({
+        vats: [{ id: 'v1', name: 'test-vat' }],
+        subclusters: ['sc1'],
+        remoteComms: false,
+      }),
+      getSubcluster: vi.fn().mockReturnValue(undefined),
+      getSubclusters: vi.fn().mockReturnValue([]),
+      getSystemSubclusterRoot: vi.fn().mockReturnValue('ko99'),
       launchSubcluster: vi.fn().mockResolvedValue({
         subclusterId: 'sc1',
-        bootstrapRootKref: 'ko1',
+        rootKref: 'ko1',
         bootstrapResult: {
           body: '#{"result":"ok"}',
           slots: [],
         },
       }),
-      terminateSubcluster: vi.fn().mockResolvedValue(undefined),
+      pingVat: vi.fn().mockResolvedValue('pong'),
       queueMessage: vi.fn().mockResolvedValue({
         body: '#{"result":"message-sent"}',
         slots: [],
       }),
-      getStatus: vi.fn().mockResolvedValue({
-        vats: [{ id: 'v1', name: 'test-vat' }],
-        subclusters: ['sc1'],
-        remoteComms: false,
-      }),
-      pingVat: vi.fn().mockResolvedValue('pong'),
+      reloadSubcluster: vi.fn().mockResolvedValue({ id: 'sc1', vats: [] }),
+      reset: vi.fn().mockResolvedValue(undefined),
+      terminateSubcluster: vi.fn().mockResolvedValue(undefined),
+      provideFacet: vi.fn(),
     } as unknown as Kernel;
 
+    // Wire up provideFacet to return a real facet backed by the mock kernel.
+    // We wrap each mock method with a delegate so that harden() inside
+    // makeKernelFacet (via makeDefaultExo) freezes the wrapper functions
+    // instead of the original vi.fn() instances, keeping call tracking intact.
+    vi.mocked(mockKernel.provideFacet).mockReturnValue(
+      makeKernelFacet(
+        Object.fromEntries(
+          Object.entries(mockKernel)
+            .filter(
+              (entry): entry is [string, (...args: never[]) => unknown] =>
+                typeof entry[1] === 'function',
+            )
+            .map(([key, fn]) => [key, (...args: never[]) => fn(...args)]),
+        ) as unknown as Kernel,
+      ),
+    );
+
     // Wire up CapTP endpoints to dispatch messages synchronously to each other
     // This simulates direct message passing for testing
 
-    // Kernel-side: exposes facade as bootstrap
+    // Kernel-side: exposes facet as bootstrap
     kernelCapTP = makeKernelCapTP({
       kernel: mockKernel,
       send: (message: CapTPMessage) => {
@@ -64,7 +93,7 @@ describe('CapTP Integration', () => {
 
   describe('bootstrap', () => {
     it('background can get kernel remote presence via getKernel', async () => {
-      // Request the kernel facade - with synchronous dispatch, this resolves immediately
+      // Request the kernel facet - with synchronous dispatch, this resolves immediately
       const kernel = await backgroundCapTP.getKernel();
       expect(kernel).toBeDefined();
     });
@@ -115,10 +144,14 @@ describe('CapTP Integration', () => {
       // Call launchSubcluster via E()
       const result = await E(kernel).launchSubcluster(config);
 
-      // The kernel facade now returns LaunchResult instead of CapData
+      // The kernel facet delegates to the kernel's launchSubcluster
       expect(result).toStrictEqual({
         subclusterId: 'sc1',
         rootKref: 'ko1',
+        bootstrapResult: {
+          body: '#{"result":"ok"}',
+          slots: [],
+        },
       });
 
       expect(mockKernel.launchSubcluster).toHaveBeenCalledWith(config);

@@ -3,5 +3,3 @@ export {
   type KernelCapTP,
   type KernelCapTPOptions,
 } from './kernel-captp.ts';
-
-export { makeKernelFacade, type KernelFacade } from './kernel-facade.ts';
@@ -1,11 +1,33 @@
 import type { Kernel } from '@metamask/ocap-kernel';
+import { makeKernelFacet, kslot } from '@metamask/ocap-kernel';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 import { makeKernelCapTP } from './kernel-captp.ts';
 import type { CapTPMessage } from '../../types.ts';
 
 describe('makeKernelCapTP', () => {
-  const mockKernel: Kernel = {} as unknown as Kernel;
+  const mockKernel = {
+    getPresence: vi
+      .fn()
+      .mockImplementation(async (kref: string, iface: string) =>
+        kslot(kref, iface),
+      ),
+    getStatus: vi.fn(),
+    getSubcluster: vi.fn(),
+    getSubclusters: vi.fn(),
+    getSystemSubclusterRoot: vi.fn(),
+    launchSubcluster: vi.fn(),
+    pingVat: vi.fn(),
+    queueMessage: vi.fn(),
+    reloadSubcluster: vi.fn(),
+    reset: vi.fn(),
+    terminateSubcluster: vi.fn(),
+    provideFacet: vi.fn(),
+  } as unknown as Kernel;
+
+  vi.mocked(mockKernel.provideFacet).mockReturnValue(
+    makeKernelFacet(mockKernel),
+  );
   let sendMock: (message: CapTPMessage) => void;
 
   beforeEach(() => {

@@ -1,7 +1,6 @@
 import { makeCapTP } from '@endo/captp';
 import type { Kernel } from '@metamask/ocap-kernel';
 
-import { makeKernelFacade } from './kernel-facade.ts';
 import type { CapTPMessage } from '../../types.ts';
 
 /**
@@ -44,7 +43,7 @@ export type KernelCapTP = {
 /**
  * Create a CapTP endpoint for the kernel.
  *
- * This sets up a CapTP connection that exposes the kernel facade as the
+ * This sets up a CapTP connection that exposes the kernel facet as the
  * bootstrap object. The background can then use `E(kernel).method()` to
  * call kernel methods.
  *
@@ -54,11 +53,8 @@ export type KernelCapTP = {
 export function makeKernelCapTP(options: KernelCapTPOptions): KernelCapTP {
   const { kernel, send } = options;
 
-  // Create the kernel facade that will be exposed to the background
-  const kernelFacade = makeKernelFacade(kernel);
-
-  // Create the CapTP endpoint
-  const { dispatch, abort } = makeCapTP('kernel', send, kernelFacade);
+  // Create the CapTP endpoint with the kernel facet as the bootstrap object
+  const { dispatch, abort } = makeCapTP('kernel', send, kernel.provideFacet());
 
   return harden({
     dispatch,