@dxos/app-framework 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/core/url-loader.test.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { assert, describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import * as Plugin from './plugin';
+import * as UrlLoader from './url-loader';
+
+const testMeta = { id: 'org.dxos.plugin.test', name: 'Test' };
+
+describe('UrlLoader', () => {
+  describe('make', () => {
+    it.effect('resolves built-in plugins by meta.id', () =>
+      Effect.gen(function* () {
+        const testPlugin = Plugin.make(Plugin.define(testMeta))();
+        const loader = UrlLoader.make([testPlugin]);
+        const result = yield* loader(testMeta.id);
+        assert.strictEqual(result.meta.id, testMeta.id);
+      }),
+    );
+
+    it.effect('fails for unknown non-URL locator', () =>
+      Effect.gen(function* () {
+        const loader = UrlLoader.make([]);
+        const exit = yield* Effect.exit(loader('not-a-url'));
+        assert.isTrue(exit._tag === 'Failure');
+      }),
+    );
+  });
+
+  describe('preload', () => {
+    it('returns empty array when storage has no entries', async ({ expect }) => {
+      const storage: UrlLoader.Storage = {
+        get: () => null,
+        set: () => {},
+      };
+      const result = await UrlLoader.preload({ storage });
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array when storage has invalid JSON', async ({ expect }) => {
+      const storage: UrlLoader.Storage = {
+        get: () => '{{invalid json',
+        set: () => {},
+      };
+      const result = await UrlLoader.preload({ storage });
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array when storage contains null', async ({ expect }) => {
+      const storage: UrlLoader.Storage = {
+        get: () => 'null',
+        set: () => {},
+      };
+      const result = await UrlLoader.preload({ storage });
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array when storage contains an object', async ({ expect }) => {
+      const storage: UrlLoader.Storage = {
+        get: () => '{}',
+        set: () => {},
+      };
+      const result = await UrlLoader.preload({ storage });
+      expect(result).toEqual([]);
+    });
+
+    it('returns empty array when entries are missing required fields', async ({ expect }) => {
+      const storage: UrlLoader.Storage = {
+        get: () => '[{"title":"no url"}]',
+        set: () => {},
+      };
+      const result = await UrlLoader.preload({ storage });
+      expect(result).toEqual([]);
+    });
+  });
+});

package/src/core/url-loader.ts

@@ -0,0 +1,148 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { log } from '@dxos/log';
+
+import * as Plugin from './plugin';
+
+const DEFAULT_KEY = 'org.dxos.composer.remote-plugins';
+
+/**
+ * Abstraction over key-value storage (defaults to localStorage).
+ */
+export type Storage = {
+  get(key: string): string | null;
+  set(key: string, value: string): void;
+};
+
+/**
+ * Options for configuring the URL loader.
+ */
+export type Options = {
+  storage?: Storage;
+  key?: string;
+};
+
+type RemotePluginEntry = { id: string; url: string };
+
+const defaultStorage = (): Storage => ({
+  get: (key) => localStorage.getItem(key),
+  set: (key, value) => localStorage.setItem(key, value),
+});
+
+const getPersistedRemotePlugins = (storage: Storage, key: string): RemotePluginEntry[] => {
+  try {
+    const parsed: unknown = JSON.parse(storage.get(key) ?? '[]');
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.filter(
+      (entry): entry is RemotePluginEntry =>
+        typeof entry === 'object' && entry !== null && typeof entry.id === 'string' && typeof entry.url === 'string',
+    );
+  } catch {
+    return [];
+  }
+};
+
+const persistRemotePlugin = (storage: Storage, key: string, entry: RemotePluginEntry): void => {
+  try {
+    const entries = getPersistedRemotePlugins(storage, key).filter((existing) => existing.id !== entry.id);
+    entries.push(entry);
+    storage.set(key, JSON.stringify(entries));
+  } catch (error) {
+    log.warn('failed to persist remote plugin entry', { entry, error });
+  }
+};
+
+const isUrl = (locator: string): boolean => {
+  try {
+    const url = new URL(locator);
+    return url.protocol === 'http:' || url.protocol === 'https:';
+  } catch {
+    return false;
+  }
+};
+
+const normalizePluginExport = (mod: Record<string, unknown>): Plugin.Plugin => {
+  const exported = mod.default;
+  if (Plugin.isPlugin(exported)) {
+    return exported;
+  }
+  if (typeof exported === 'function') {
+    const result = (exported as () => unknown)();
+    if (Plugin.isPlugin(result)) {
+      return result;
+    }
+  }
+  throw new Error('Remote module default export is not a Plugin or a zero-arg plugin factory.');
+};
+
+const loadRemotePlugin = async (url: string): Promise<Plugin.Plugin> => {
+  log.info('loading remote plugin', { url });
+  const mod = await import(/* @vite-ignore */ url);
+  const plugin = normalizePluginExport(mod);
+  if (!plugin.meta.id || !plugin.meta.name) {
+    throw new Error(`Remote plugin at ${url} is missing required meta.id or meta.name.`);
+  }
+  return plugin;
+};
+
+/**
+ * Preloads previously persisted remote plugins from storage.
+ */
+export const preload = async (options: Options = {}): Promise<Plugin.Plugin[]> => {
+  const storage = options.storage ?? defaultStorage();
+  const key = options.key ?? DEFAULT_KEY;
+
+  const entries = getPersistedRemotePlugins(storage, key);
+  if (entries.length === 0) {
+    return [];
+  }
+  log.info('preloading remote plugins', { count: entries.length });
+  const results = await Promise.allSettled(entries.map((entry) => loadRemotePlugin(entry.url)));
+  const plugins: Plugin.Plugin[] = [];
+  for (let index = 0; index < results.length; index++) {
+    const result = results[index];
+    if (result.status === 'fulfilled') {
+      plugins.push(result.value);
+    } else {
+      log.warn('failed to preload remote plugin', { entry: entries[index], error: result.reason });
+    }
+  }
+  return plugins;
+};
+
+/**
+ * Creates a plugin loader that resolves built-in plugins by ID or loads remote plugins from URLs.
+ */
+export const make = (builtinPlugins: Plugin.Plugin[], options: Options = {}) => {
+  const storage = options.storage ?? defaultStorage();
+  const key = options.key ?? DEFAULT_KEY;
+
+  return (locator: string): Effect.Effect<Plugin.Plugin, Error> =>
+    Effect.gen(function* () {
+      const builtin = builtinPlugins.find((plugin) => plugin.meta.id === locator);
+      if (builtin) {
+        return builtin;
+      }
+      if (!isUrl(locator)) {
+        return yield* Effect.fail(new Error(`Plugin not found and locator is not a URL: ${locator}`));
+      }
+      const plugin = yield* Effect.tryPromise({
+        try: () => loadRemotePlugin(locator),
+        catch: (error) => new Error(`Failed to load remote plugin from ${locator}: ${error}`),
+      });
+      const duplicate = builtinPlugins.find((existing) => existing.meta.id === plugin.meta.id);
+      if (duplicate) {
+        return yield* Effect.fail(
+          new Error(`Remote plugin ${plugin.meta.id} conflicts with built-in plugin of the same id.`),
+        );
+      }
+      persistRemotePlugin(storage, key, { id: plugin.meta.id, url: locator });
+      return plugin;
+    });
+};

package/src/index.ts

@@ -2,10 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './cli';
-export * as Common from './common';
+export * from './common';
 export * from './context';
 export * from './core';
 export * from './plugin-operation';
 export * from './plugin-runtime';
-export * from './plugin-settings';

package/src/plugin-operation/OperationPlugin.ts

@@ -2,9 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Common from '../common';
+import { ActivationEvents } from '../common';
 import { Capability, Plugin } from '../core';
-
 import { meta } from './meta';
 
 const OperationInvoker = Capability.lazy('OperationInvoker', () => import('./invoker-capability'));
@@ -12,13 +11,13 @@ const HistoryCapabilities = Capability.lazy('HistoryCapabilities', () => import(
 
 export const OperationPlugin = Plugin.define(meta).pipe(
   Plugin.addModule({
-    activatesOn: Common.ActivationEvent.ManagedRuntimeReady,
-    activatesBefore: [Common.ActivationEvent.SetupOperationResolver],
-    activatesAfter: [Common.ActivationEvent.OperationInvokerReady],
+    activatesOn: ActivationEvents.ManagedRuntimeReady,
+    activatesBefore: [ActivationEvents.SetupOperationHandler],
+    activatesAfter: [ActivationEvents.OperationInvokerReady],
     activate: OperationInvoker,
   }),
   Plugin.addModule({
-    activatesOn: Common.ActivationEvent.OperationInvokerReady,
+    activatesOn: ActivationEvents.OperationInvokerReady,
     activate: HistoryCapabilities,
   }),
   Plugin.make,

package/src/plugin-operation/history/capability.ts

@@ -6,9 +6,8 @@ import * as Effect from 'effect/Effect';
 
 import { type OperationInvoker } from '@dxos/operation';
 
-import * as Common from '../../common';
+import { Capabilities } from '../../common';
 import { Capability } from '../../core';
-
 import * as HistoryTracker from './history-tracker';
 import * as UndoRegistry from './undo-registry';
 
@@ -22,16 +21,16 @@ export default Capability.makeModule(
     const capabilities = yield* Capability.Service;
 
     // Create UndoRegistry.
-    const undoRegistry = UndoRegistry.make(() => capabilities.getAll(Common.Capability.UndoMapping).flat());
+    const undoRegistry = UndoRegistry.make(() => capabilities.getAll(Capabilities.UndoMapping).flat());
 
     // Create HistoryTracker (depends on UndoRegistry and OperationInvoker).
-    const invoker = yield* Capability.get(Common.Capability.OperationInvoker);
+    const invoker = yield* Capability.get(Capabilities.OperationInvoker);
     // Cast to internal type - the factory always returns OperationInvokerInternal.
     const historyTracker = HistoryTracker.make(invoker as OperationInvoker.OperationInvokerInternal, undoRegistry);
 
     return [
-      Capability.contributes(Common.Capability.UndoRegistry, undoRegistry),
-      Capability.contributes(Common.Capability.HistoryTracker, historyTracker),
+      Capability.contributes(Capabilities.UndoRegistry, undoRegistry),
+      Capability.contributes(Capabilities.HistoryTracker, historyTracker),
     ];
   }),
 );

package/src/plugin-operation/history/errors.ts

@@ -2,10 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { OperationError } from '@dxos/operation';
+import { BaseError } from '@dxos/errors';
 
-export class EmptyHistoryError extends OperationError {
-  constructor() {
-    super('EMPTY_HISTORY', 'Cannot undo: history is empty.');
-  }
-}
+export class EmptyHistoryError extends BaseError.extend('EmptyHistoryError', 'Cannot undo: history is empty.') {}

package/src/plugin-operation/history/history-tracker.test.ts

@@ -5,10 +5,14 @@
 import { it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as Fiber from 'effect/Fiber';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
 import * as TestClock from 'effect/TestClock';
 import { describe, expect } from 'vitest';
 
-import { OperationInvoker, OperationResolver } from '@dxos/operation';
+import { Operation, OperationInvoker } from '@dxos/operation';
+
+const testRuntime = ManagedRuntime.make(Layer.empty) as unknown as ManagedRuntime.ManagedRuntime<any, any>;
 
 import { UndoOperation } from '../../common';
 import {
@@ -21,7 +25,6 @@ import {
   toStringHandler,
   waitUntil,
 } from '../testing';
-
 import * as HistoryTracker from './history-tracker';
 import * as UndoMapping from './undo-mapping';
 import * as UndoRegistry from './undo-registry';
@@ -35,7 +38,7 @@ describe('HistoryTracker', () => {
         deriveContext: (_input, output) => ({ value: output.value }),
       });
 
-      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, halveComputeHandler]));
+      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, halveComputeHandler]), testRuntime);
       const undoRegistry = UndoRegistry.make(() => [undoMapping]);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
 
@@ -55,7 +58,7 @@ describe('HistoryTracker', () => {
 
   it.effect('does not track operations without undo mapping', () =>
     Effect.gen(function* () {
-      const invoker = OperationInvoker.make(() => Effect.succeed([toStringHandler]));
+      const invoker = OperationInvoker.make(() => Effect.succeed([toStringHandler]), testRuntime);
       const undoRegistry = UndoRegistry.make(() => []);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
       const collector = yield* createEventCollector(invoker);
@@ -81,15 +84,12 @@ describe('HistoryTracker', () => {
       });
 
       let halveWasCalled = false;
-      const trackingHalveHandler = OperationResolver.make({
-        operation: HalveCompute,
-        handler: (data) => {
-          halveWasCalled = true;
-          return Effect.succeed({ value: data.value / 2 });
-        },
+      const trackingHalveHandler = Operation.withHandler(HalveCompute, (data) => {
+        halveWasCalled = true;
+        return Effect.succeed({ value: data.value / 2 });
       });
 
-      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, trackingHalveHandler]));
+      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, trackingHalveHandler]), testRuntime);
       const undoRegistry = UndoRegistry.make(() => [undoMapping]);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
 
@@ -117,7 +117,7 @@ describe('HistoryTracker', () => {
         deriveContext: (_input, output) => ({ value: output.value }),
       });
 
-      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, halveComputeHandler]));
+      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, halveComputeHandler]), testRuntime);
       const undoRegistry = UndoRegistry.make(() => [undoMapping]);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
       const collector = yield* createEventCollector(invoker);
@@ -152,15 +152,12 @@ describe('HistoryTracker', () => {
       });
 
       const halveInputs: number[] = [];
-      const trackingHalveHandler = OperationResolver.make({
-        operation: HalveCompute,
-        handler: (data) => {
-          halveInputs.push(data.value);
-          return Effect.succeed({ value: data.value / 2 });
-        },
+      const trackingHalveHandler = Operation.withHandler(HalveCompute, (data) => {
+        halveInputs.push(data.value);
+        return Effect.succeed({ value: data.value / 2 });
       });
 
-      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, trackingHalveHandler]));
+      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, trackingHalveHandler]), testRuntime);
       const undoRegistry = UndoRegistry.make(() => [undoMapping]);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
       const collector = yield* createEventCollector(invoker);
@@ -194,7 +191,7 @@ describe('HistoryTracker', () => {
 
   it.effect('undo on empty history returns error', () =>
     Effect.gen(function* () {
-      const invoker = OperationInvoker.make(() => Effect.succeed([]));
+      const invoker = OperationInvoker.make(() => Effect.succeed([]), testRuntime);
       const undoRegistry = UndoRegistry.make(() => []);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
 
@@ -208,7 +205,7 @@ describe('HistoryTracker', () => {
 
   it.effect('fires ShowUndo operation when undoable operation is tracked', () =>
     Effect.gen(function* () {
-      const testMessage: [string, { ns: string }] = ['test undo message', { ns: 'test' }];
+      const testMessage: [string, { ns: string }] = ['test-undo.message', { ns: 'test' }];
       const undoMapping = UndoMapping.make({
         operation: Compute,
         inverse: HalveCompute,
@@ -218,17 +215,15 @@ describe('HistoryTracker', () => {
 
       let showUndoWasCalled = false;
       let showUndoMessage: unknown = undefined;
-      const showUndoHandler = OperationResolver.make({
-        operation: UndoOperation.ShowUndo,
-        handler: (input) => {
-          showUndoWasCalled = true;
-          showUndoMessage = input.message;
-          return Effect.succeed(undefined);
-        },
+      const showUndoHandler = Operation.withHandler(UndoOperation.ShowUndo, (input) => {
+        showUndoWasCalled = true;
+        showUndoMessage = input.message;
+        return Effect.succeed(undefined);
       });
 
-      const invoker = OperationInvoker.make(() =>
-        Effect.succeed([computeHandler, halveComputeHandler, showUndoHandler]),
+      const invoker = OperationInvoker.make(
+        () => Effect.succeed([computeHandler, halveComputeHandler, showUndoHandler]),
+        testRuntime,
       );
       const undoRegistry = UndoRegistry.make(() => [undoMapping]);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
@@ -254,7 +249,7 @@ describe('HistoryTracker', () => {
     Effect.gen(function* () {
       // Dynamic message that depends on input/output.
       const dynamicMessage = (input: { value: number }, output: { value: number }): [string, { ns: string }] => [
-        `computed ${input.value} to ${output.value}`,
+        `computed-${input.value}-to-${output.value}`,
         { ns: 'test' },
       ];
       const undoMapping = UndoMapping.make({
@@ -266,17 +261,15 @@ describe('HistoryTracker', () => {
 
       let showUndoWasCalled = false;
       let showUndoMessage: unknown = undefined;
-      const showUndoHandler = OperationResolver.make({
-        operation: UndoOperation.ShowUndo,
-        handler: (input) => {
-          showUndoWasCalled = true;
-          showUndoMessage = input.message;
-          return Effect.succeed(undefined);
-        },
+      const showUndoHandler = Operation.withHandler(UndoOperation.ShowUndo, (input) => {
+        showUndoWasCalled = true;
+        showUndoMessage = input.message;
+        return Effect.succeed(undefined);
       });
 
-      const invoker = OperationInvoker.make(() =>
-        Effect.succeed([computeHandler, halveComputeHandler, showUndoHandler]),
+      const invoker = OperationInvoker.make(
+        () => Effect.succeed([computeHandler, halveComputeHandler, showUndoHandler]),
+        testRuntime,
       );
       const undoRegistry = UndoRegistry.make(() => [undoMapping]);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
@@ -295,7 +288,7 @@ describe('HistoryTracker', () => {
       yield* waitUntil(() => showUndoWasCalled);
       expect(showUndoWasCalled).toBe(true);
       // Compute 2 * 2 = 4, so message should be 'computed 2 to 4'.
-      expect(showUndoMessage).toEqual(['computed 2 to 4', { ns: 'test' }]);
+      expect(showUndoMessage).toEqual(['computed-2-to-4', { ns: 'test' }]);
     }),
   );
 
@@ -314,7 +307,7 @@ describe('HistoryTracker', () => {
         },
       });
 
-      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, halveComputeHandler]));
+      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, halveComputeHandler]), testRuntime);
       const undoRegistry = UndoRegistry.make(() => [undoMapping]);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
       const collector = yield* createEventCollector(invoker);
@@ -352,7 +345,7 @@ describe('HistoryTracker', () => {
         },
       });
 
-      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, halveComputeHandler]));
+      const invoker = OperationInvoker.make(() => Effect.succeed([computeHandler, halveComputeHandler]), testRuntime);
       const undoRegistry = UndoRegistry.make(() => [undoMapping]);
       const tracker = HistoryTracker.make(invoker, undoRegistry);
       const collector = yield* createEventCollector(invoker);

package/src/plugin-operation/history/history-tracker.ts

@@ -10,7 +10,6 @@ import { log } from '@dxos/log';
 import { type OperationInvoker } from '@dxos/operation';
 
 import { UndoOperation } from '../../common';
-
 import { EmptyHistoryError } from './errors';
 import type { HistoryEntry } from './types';
 import { resolveMessage } from './undo-mapping';

package/src/plugin-operation/history/undo-mapping.ts

@@ -4,7 +4,10 @@
 
 import type { Operation } from '@dxos/operation';
 
-import type { Label } from '../../common/translations';
+/**
+ * Label type for translatable text (canonical definition in @dxos/app-toolkit).
+ */
+type Label = string | [string, { ns: string; count?: number; defaultValue?: string }];
 
 /**
  * Extract the input type from an OperationDefinition.
@@ -95,7 +98,7 @@ export interface UndoMappingProps<
  *     thread: output.thread,
  *     anchor: output.anchor,
  *   }),
- *   message: ['thread deleted label', { ns: 'plugin-thread' }],
+ *   message: ['thread deleted label', { ns: '@dxos/plugin-thread' }],
  * });
  *
  * // Dynamic message based on input/output
@@ -106,7 +109,7 @@ export interface UndoMappingProps<
  *   message: (input, _output) =>
  *     input.objects.length === 1
  *       ? ['object deleted label', { ns: getTypename(input.objects[0]) }]
- *       : ['objects deleted label', { ns: 'plugin-space' }],
+ *       : ['objects deleted label', { ns: '@dxos/plugin-space' }],
  * });
  * ```
  */

package/src/plugin-operation/history/undo-registry.test.ts

@@ -5,7 +5,6 @@
 import { describe, test } from 'vitest';
 
 import { Compute, HalveCompute } from '../testing';
-
 import * as UndoMapping from './undo-mapping';
 import * as UndoRegistry from './undo-registry';
 
@@ -52,18 +51,18 @@ describe('resolveMessage', () => {
   });
 
   test('returns static label as-is', ({ expect }) => {
-    const staticMessage: [string, { ns: string }] = ['test message', { ns: 'test' }];
+    const staticMessage: [string, { ns: string }] = ['test.message', { ns: 'test' }];
     const result = UndoMapping.resolveMessage(staticMessage, { value: 1 }, { value: 2 });
     expect(result).toEqual(staticMessage);
   });
 
   test('calls function message with input and output', ({ expect }) => {
     const messageFunc = (input: { value: number }, output: { value: number }): [string, { ns: string }] => [
-      `input: ${input.value}, output: ${output.value}`,
+      `input-${input.value}-output-${output.value}`,
       { ns: 'test' },
     ];
     const result = UndoMapping.resolveMessage(messageFunc, { value: 5 }, { value: 10 });
-    expect(result).toEqual(['input: 5, output: 10', { ns: 'test' }]);
+    expect(result).toEqual(['input-5-output-10', { ns: 'test' }]);
   });
 
   test('returns string label as-is', ({ expect }) => {

package/src/plugin-operation/invoker-capability.ts

@@ -4,9 +4,9 @@
 
 import * as Effect from 'effect/Effect';
 
-import { OperationInvoker } from '@dxos/operation';
+import { OperationHandlerSet, OperationInvoker } from '@dxos/operation';
 
-import * as Common from '../common';
+import { ActivationEvents, Capabilities } from '../common';
 import { Capability, Plugin } from '../core';
 
 //
@@ -20,21 +20,35 @@ export default Capability.makeModule(
     const pluginManager = yield* Plugin.Service;
 
     // Get the ManagedRuntime capability (should be available since we activate after ManagedRuntimeReady).
-    const managedRuntimes = yield* Capability.getAll(Common.Capability.ManagedRuntime);
-    const managedRuntime = managedRuntimes.length > 0 ? managedRuntimes[0] : undefined;
+    const managedRuntime = yield* Capability.get(Capabilities.ManagedRuntime);
+
+    // Cache the merged handler promise to prevent concurrent module loading.
+    // Multiple Effects can invoke getHandlers simultaneously; without caching each
+    // creates a new merge() which triggers parallel dynamic imports that race in
+    // WebKit's module evaluator, causing TDZ errors on export default bindings.
+    let cachedSets: readonly OperationHandlerSet.OperationHandlerSet[] | undefined;
+    let cachedHandlers: ReturnType<OperationHandlerSet.OperationHandlerSet['getHandlers']> | undefined;
 
     const invoker = OperationInvoker.make(
       () =>
         Effect.gen(function* () {
-          yield* Plugin.activate(Common.ActivationEvent.SetupOperationResolver);
-          return (yield* Capability.getAll(Common.Capability.OperationResolver)).flat();
+          yield* Plugin.activate(ActivationEvents.SetupOperationHandler);
+          const sets = yield* Capability.getAll(Capabilities.OperationHandler);
+
+          if (sets !== cachedSets) {
+            cachedSets = sets;
+            cachedHandlers = OperationHandlerSet.merge(...sets).getHandlers();
+          }
+
+          return yield* Effect.promise(() => cachedHandlers!);
         }).pipe(
           Effect.provideService(Capability.Service, capabilityManager),
           Effect.provideService(Plugin.Service, pluginManager),
+          Effect.orDie,
         ),
       managedRuntime,
     );
 
-    return Capability.contributes(Common.Capability.OperationInvoker, invoker);
+    return Capability.contributes(Capabilities.OperationInvoker, invoker);
   }),
 );

package/src/plugin-operation/meta.ts

@@ -5,7 +5,7 @@
 import { type Plugin } from '../core';
 
 export const meta: Plugin.Meta = {
-  id: 'dxos.org/plugin/operation',
+  id: 'org.dxos.plugin.operation',
   name: 'Operation Plugin',
   description: 'Provides operation invocation, undo registry, and history tracking.',
 };