feat(ocap-kernel): plumb allowedGlobalNames from Kernel.make() to VatSupervisor

Add allowedGlobalNames option to Kernel.make() so the kernel owner can
restrict which globals are available to vats. The names flow through
VatManager → VatHandle → initVat RPC to VatSupervisor, which filters
DEFAULT_ALLOWED_GLOBALS by the received names. When omitted, all
defaults remain available.

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

Author: sirtimid

packages/ocap-kernel/src/Kernel.ts

@@ -103,6 +103,7 @@ export class Kernel {
    * @param options.keySeed - Optional seed for libp2p key generation.
    * @param options.mnemonic - Optional BIP39 mnemonic for deriving the kernel identity.
    * @param options.ioChannelFactory - Optional factory for creating IO channels.
+   * @param options.allowedGlobalNames - Optional list of allowed global names for vat endowments.
    */
   // eslint-disable-next-line no-restricted-syntax
   private constructor(
@@ -114,6 +115,7 @@ export class Kernel {
       keySeed?: string | undefined;
       mnemonic?: string | undefined;
       ioChannelFactory?: IOChannelFactory;
+      allowedGlobalNames?: string[];
     } = {},
   ) {
     this.#platformServices = platformServices;
@@ -145,6 +147,7 @@ export class Kernel {
       kernelStore: this.#kernelStore,
       kernelQueue: this.#kernelQueue,
       logger: this.#logger.subLogger({ tags: ['VatManager'] }),
+      allowedGlobalNames: options.allowedGlobalNames,
     });
 
     this.#remoteManager = new RemoteManager({
@@ -229,6 +232,7 @@ export class Kernel {
    * @param options.mnemonic - Optional BIP39 mnemonic for deriving the kernel identity.
    * @param options.ioChannelFactory - Optional factory for creating IO channels.
    * @param options.systemSubclusters - Optional array of system subcluster configurations.
+   * @param options.allowedGlobalNames - Optional list of allowed global names for vat endowments. When set, only these names from DEFAULT_ALLOWED_GLOBALS are available to vats.
    * @returns A promise for the new kernel instance.
    */
   static async make(
@@ -241,6 +245,7 @@ export class Kernel {
       mnemonic?: string | undefined;
       ioChannelFactory?: IOChannelFactory;
       systemSubclusters?: SystemSubclusterConfig[];
+      allowedGlobalNames?: string[];
     } = {},
   ): Promise<Kernel> {
     const kernel = new Kernel(platformServices, kernelDatabase, options);

packages/ocap-kernel/src/rpc/vat/initVat.ts

@@ -1,5 +1,11 @@
 import type { MethodSpec, Handler } from '@metamask/kernel-rpc-methods';
-import { array, object, string, tuple } from '@metamask/superstruct';
+import {
+  array,
+  exactOptional,
+  object,
+  string,
+  tuple,
+} from '@metamask/superstruct';
 import type { Infer } from '@metamask/superstruct';
 
 import { VatDeliveryResultStruct } from './shared.ts';
@@ -9,6 +15,7 @@ import type { VatConfig, VatDeliveryResult } from '../../types.ts';
 const paramsStruct = object({
   vatConfig: VatConfigStruct,
   state: array(tuple([string(), string()])),
+  allowedGlobalNames: exactOptional(array(string())),
 });
 
 type Params = Infer<typeof paramsStruct>;
@@ -28,6 +35,7 @@ export const initVatSpec: InitVatSpec = {
 export type InitVat = (
   vatConfig: VatConfig,
   state: Map<string, string>,
+  allowedGlobalNames: string[] | undefined,
 ) => Promise<VatDeliveryResult>;
 
 type InitVatHooks = {
@@ -45,6 +53,10 @@ export const initVatHandler: InitVatHandler = {
   ...initVatSpec,
   hooks: { initVat: true },
   implementation: async ({ initVat }, params) => {
-    return await initVat(params.vatConfig, new Map(params.state));
+    return await initVat(
+      params.vatConfig,
+      new Map(params.state),
+      params.allowedGlobalNames,
+    );
   },
 };

packages/ocap-kernel/src/vats/VatHandle.ts

@@ -45,6 +45,7 @@ type VatConstructorProps = {
   kernelStore: KernelStore;
   kernelQueue: KernelQueue;
   logger?: Logger | undefined;
+  allowedGlobalNames?: string[] | undefined;
 };
 
 /**
@@ -63,6 +64,9 @@ export class VatHandle implements EndpointHandle {
   /** Logger for outputting messages (such as errors) to the console */
   readonly #logger: Logger | undefined;
 
+  /** Optional list of allowed global names for vat endowments */
+  readonly #allowedGlobalNames: string[] | undefined;
+
   /** Storage holding the kernel's persistent state */
   readonly #kernelStore: KernelStore;
 
@@ -89,6 +93,7 @@ export class VatHandle implements EndpointHandle {
    * @param params.kernelStore - The kernel's persistent state store.
    * @param params.kernelQueue - The kernel's queue.
    * @param params.logger - Optional logger for error and diagnostic output.
+   * @param params.allowedGlobalNames - Optional list of allowed global names for vat endowments.
    */
   // eslint-disable-next-line no-restricted-syntax
   private constructor({
@@ -98,10 +103,12 @@ export class VatHandle implements EndpointHandle {
     kernelStore,
     kernelQueue,
     logger,
+    allowedGlobalNames,
   }: VatConstructorProps) {
     this.vatId = vatId;
     this.config = vatConfig;
     this.#logger = logger;
+    this.#allowedGlobalNames = allowedGlobalNames;
     this.#vatStream = vatStream;
     this.#kernelStore = kernelStore;
     this.#vatStore = kernelStore.makeVatStore(vatId);
@@ -171,6 +178,9 @@ export class VatHandle implements EndpointHandle {
       params: {
         vatConfig: this.config,
         state: this.#vatStore.getKVData(),
+        ...(this.#allowedGlobalNames
+          ? { allowedGlobalNames: this.#allowedGlobalNames }
+          : {}),
       },
     });
   }

packages/ocap-kernel/src/vats/VatManager.ts

@@ -25,6 +25,7 @@ type VatManagerOptions = {
   kernelStore: KernelStore;
   kernelQueue: KernelQueue;
   logger?: Logger;
+  allowedGlobalNames?: string[] | undefined;
 };
 
 /**
@@ -46,6 +47,9 @@ export class VatManager {
   /** Logger for outputting messages (such as errors) to the console */
   readonly #logger: Logger;
 
+  /** Optional list of allowed global names for vat endowments */
+  readonly #allowedGlobalNames: string[] | undefined;
+
   /**
    * Creates a new VatManager instance.
    *
@@ -54,18 +58,21 @@ export class VatManager {
    * @param options.kernelStore - The kernel's persistent state store.
    * @param options.kernelQueue - The kernel's message queue for scheduling deliveries.
    * @param options.logger - Logger instance for debugging and diagnostics.
+   * @param options.allowedGlobalNames - Optional list of allowed global names for vat endowments.
    */
   constructor({
     platformServices,
     kernelStore,
     kernelQueue,
     logger,
+    allowedGlobalNames,
   }: VatManagerOptions) {
     this.#vats = new Map();
     this.#platformServices = platformServices;
     this.#kernelStore = kernelStore;
     this.#kernelQueue = kernelQueue;
     this.#logger = logger ?? new Logger('VatManager');
+    this.#allowedGlobalNames = allowedGlobalNames;
     harden(this);
   }
 
@@ -134,6 +141,7 @@ export class VatManager {
       kernelStore: this.#kernelStore,
       kernelQueue: this.#kernelQueue,
       logger: vatLogger,
+      allowedGlobalNames: this.#allowedGlobalNames,
     });
     this.#vats.set(vatId, vat);
   }

packages/ocap-kernel/src/vats/VatSupervisor.ts

@@ -263,12 +263,13 @@ export class VatSupervisor {
    *
    * @param vatConfig - Configuration object describing the vat to be intialized.
    * @param state - A Map representing the current persistent state of the vat.
-   *
+   * @param allowedGlobalNames - Optional list of allowed global names to restrict the available endowments.
    * @returns a promise for a checkpoint of the new vat.
    */
   async #initVat(
     vatConfig: VatConfig,
     state: Map<string, string>,
+    allowedGlobalNames: string[] | undefined,
   ): Promise<VatDeliveryResult> {
     if (this.#loaded) {
       throw Error(
@@ -306,12 +307,22 @@ export class VatSupervisor {
 
     const { bundleSpec, parameters, platformConfig, globals } = vatConfig;
 
+    // If the kernel specified a restricted set of allowed global names,
+    // filter the full allowlist down to only those names.
+    const effectiveAllowedGlobals = allowedGlobalNames
+      ? Object.fromEntries(
+          allowedGlobalNames
+            .filter((name) => hasProperty(this.#allowedGlobals, name))
+            .map((name) => [name, this.#allowedGlobals[name]]),
+        )
+      : this.#allowedGlobals;
+
     // Build additional endowments from globals list
     const requestedGlobals: Record<string, unknown> = {};
     if (globals) {
       for (const name of globals) {
-        if (hasProperty(this.#allowedGlobals, name)) {
-          requestedGlobals[name] = this.#allowedGlobals[name];
+        if (hasProperty(effectiveAllowedGlobals, name)) {
+          requestedGlobals[name] = effectiveAllowedGlobals[name];
         } else {
           this.#logger.warn(
             `Vat "${this.id}" requested unknown global "${name}"`,