OpenService: Store delegated mode on the realm-global inventory

Two import paths of the registry in one realm now share the same flag, so
an attached caller cannot register services that still dispatch locally.

Author: cursoragent

code/core/src/shared/open-service/README.md

@@ -710,8 +710,10 @@ Every registered runtime plays **both** roles at once, decided per command:
   validates input, mutates state, and broadcasts the post-mutation snapshot through the normal command
   wrappers so every peer converges — then emits `services:command-result` or `services:command-error`.
 
-A runtime never requests a command it implements (it runs that locally), so a responder never answers
-its own invoke echo: `onInvoke` only acts on commands in its `implementedCommandNames` set.
+Outside [delegated mode](#delegated-mode), a runtime never requests a command it implements (it runs
+that locally), so a responder never answers its own invoke echo: `onInvoke` only acts on commands in
+its `implementedCommandNames` set. A delegated runtime does request commands it implements — that is
+how dispatch reaches the Storybook it attached to.
 
 ### Events
 
@@ -805,10 +807,12 @@ rejects outstanding calls with `OpenServiceRemoteCommandDisconnectedError`.
 ### Delegated mode
 
 A runtime that attaches to an already-running Storybook (rather than starting its own) must not
-execute anything itself: the Storybook it attached to owns the story index, the module graph, and the
-providers, so it is the implementer for every command. `setDelegatedMode(true)` in
-[service-registry.ts](./service-registry.ts) puts the whole runtime in that role; `isDelegatedMode()`
-reads it and the default is `false`.
+dispatch commands locally: the Storybook it attached to owns the story index, the module graph, and
+the providers, so it is the implementer for every command. Loads, toolset methods, and query handlers
+still run in this process. `setDelegatedMode(true)` in [service-registry.ts](./service-registry.ts)
+puts command dispatch in that role; `isDelegatedMode()` reads it and the default is `false`. The flag
+lives on the same realm-global inventory as the service map, so every import path in one realm sees
+the same value.
 
 What changes is **dispatch**, not registration:
 

code/core/src/shared/open-service/service-delegated-mode.test.ts

@@ -91,6 +91,19 @@ describe('delegated mode flag', () => {
     clearRegistry();
     expect(isDelegatedMode()).toBe(false);
   });
+
+  it('shares the flag with a separately loaded copy of this module', async () => {
+    setDelegatedMode(true);
+
+    vi.resetModules();
+    const other = await import('./service-registry.ts');
+
+    expect(isDelegatedMode()).toBe(true);
+    expect(other.isDelegatedMode()).toBe(true);
+
+    other.setDelegatedMode(false);
+    expect(isDelegatedMode()).toBe(false);
+  });
 });
 
 describe('delegated command dispatch', () => {

code/core/src/shared/open-service/service-registry.ts

@@ -54,24 +54,34 @@ type RegistryEntry = {
 
 const REGISTRY_SYMBOL = Symbol.for('storybook.open-service.registry');
 
+type RegistryInventory = {
+  entries: Map<string, RegistryEntry>;
+  delegatedMode: boolean;
+};
+
 /**
- * Returns the realm-global registry backing service registration.
+ * Returns the realm-global inventory backing service registration and delegated mode.
  *
  * Lazily created so importing the module does not eagerly mutate global state. Anchoring it on a
- * `globalThis` symbol keeps runtime lookups, static builds, and tests pointed at one service inventory
- * even when the module is reached through different import paths.
+ * `globalThis` symbol keeps the service map and the delegated-mode flag shared even when this file is
+ * reached through different import paths.
  */
-function getRegistry(): Map<string, RegistryEntry> {
+function getInventory(): RegistryInventory {
   const registryGlobal = globalThis as {
-    [key: symbol]: Map<string, RegistryEntry> | undefined;
+    [key: symbol]: RegistryInventory | undefined;
   };
 
-  registryGlobal[REGISTRY_SYMBOL] ??= new Map<string, RegistryEntry>();
+  registryGlobal[REGISTRY_SYMBOL] ??= {
+    entries: new Map<string, RegistryEntry>(),
+    delegatedMode: false,
+  };
 
   return registryGlobal[REGISTRY_SYMBOL];
 }
 
-let delegatedMode = false;
+function getRegistry(): Map<string, RegistryEntry> {
+  return getInventory().entries;
+}
 
 /**
  * Marks this runtime as delegated, so every registered service dispatches its commands over the
@@ -83,12 +93,12 @@ let delegatedMode = false;
  * attached to is the implementer.
  */
 export function setDelegatedMode(enabled: boolean): void {
-  delegatedMode = enabled;
+  getInventory().delegatedMode = enabled;
 }
 
 /** Whether this runtime delegates command dispatch to the Storybook it is attached to. */
 export function isDelegatedMode(): boolean {
-  return delegatedMode;
+  return getInventory().delegatedMode;
 }
 
 function assertUniqueOperationNames(definition: AnyServiceDefinition): void {
@@ -316,7 +326,7 @@ export function registerService<
     commands: runtime.commands as Record<string, (input: unknown) => Promise<unknown>>,
     implementedCommandNames,
     commandNames: Object.keys(resolvedDefinition.commands),
-    delegated: delegatedMode,
+    delegated: isDelegatedMode(),
     runtime,
   });
 
@@ -420,5 +430,5 @@ export function clearRegistry(): void {
   }
 
   registry.clear();
-  delegatedMode = false;
+  getInventory().delegatedMode = false;
 }