@dxos/app-framework 0.8.4-main.3eb6e50203 → 0.8.4-main.3fbcb4aa9b

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

@@ -5,10 +5,15 @@
 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 } from '@dxos/compute';
+import { OperationInvoker } from '@dxos/operation';
+
+const testRuntime = ManagedRuntime.make(Layer.empty) as unknown as ManagedRuntime.ManagedRuntime<any, any>;
 
 import { UndoOperation } from '../../common';
 import {
@@ -21,7 +26,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 +39,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 +59,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 +85,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 +118,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 +153,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 +192,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 +206,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 +216,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 +250,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 +262,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 +289,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 +308,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 +346,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

@@ -7,10 +7,9 @@ import * as Stream from 'effect/Stream';
 
 import { runAndForwardErrors } from '@dxos/effect';
 import { log } from '@dxos/log';
-import { type OperationInvoker } from '@dxos/operation';
+import { 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/types.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { Operation } from '@dxos/operation';
+import type { Operation } from '@dxos/compute';
 
 /**
  * History entry stored by HistoryTracker.

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

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { Operation } from '@dxos/operation';
+import type { Operation } from '@dxos/compute';
 
 /**
  * Label type for translatable text (canonical definition in @dxos/app-toolkit).

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/history/undo-registry.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { Operation } from '@dxos/operation';
+import type { Operation } from '@dxos/compute';
 
 import type * as UndoMapping from './undo-mapping';
 

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

@@ -4,6 +4,7 @@
 
 import * as Effect from 'effect/Effect';
 
+import { OperationHandlerSet } from '@dxos/compute';
 import { OperationInvoker } from '@dxos/operation';
 
 import { ActivationEvents, Capabilities } from '../common';
@@ -20,17 +21,31 @@ 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(Capabilities.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(ActivationEvents.SetupOperationResolver);
-          return (yield* Capability.getAll(Capabilities.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,
     );

package/src/plugin-operation/meta.ts

@@ -5,7 +5,8 @@
 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.',
+  tags: ['system'],
 };

package/src/plugin-operation/testing.ts

@@ -9,49 +9,40 @@ import * as Ref from 'effect/Ref';
 import * as Schema from 'effect/Schema';
 import * as Stream from 'effect/Stream';
 
-import { Operation, type OperationInvoker, OperationResolver } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
+import { OperationInvoker } from '@dxos/operation';
 
 //
 // Test Operations
 //
 
 export const Compute = Operation.make({
-  schema: {
-    input: Schema.Struct({ value: Schema.Number }),
-    output: Schema.Struct({ value: Schema.Number }),
-  },
+  input: Schema.Struct({ value: Schema.Number }),
+  output: Schema.Struct({ value: Schema.Number }),
   meta: { key: 'test.compute' },
 });
 
 export const HalveCompute = Operation.make({
-  schema: {
-    input: Schema.Struct({ value: Schema.Number }),
-    output: Schema.Struct({ value: Schema.Number }),
-  },
+  input: Schema.Struct({ value: Schema.Number }),
+  output: Schema.Struct({ value: Schema.Number }),
   meta: { key: 'test.halve-compute' },
 });
 
 export const ToString = Operation.make({
-  schema: {
-    input: Schema.Struct({ value: Schema.Number }),
-    output: Schema.Struct({ string: Schema.String }),
-  },
+  input: Schema.Struct({ value: Schema.Number }),
+  output: Schema.Struct({ string: Schema.String }),
   meta: { key: 'test.to-string' },
 });
 
 export const Add = Operation.make({
-  schema: {
-    input: Schema.Tuple(Schema.Number, Schema.Number),
-    output: Schema.Number,
-  },
+  input: Schema.Tuple(Schema.Number, Schema.Number),
+  output: Schema.Number,
   meta: { key: 'test.add' },
 });
 
 export const SideEffect = Operation.make({
-  schema: {
-    input: Schema.Void,
-    output: Schema.Void,
-  },
+  input: Schema.Void,
+  output: Schema.Void,
   meta: { key: 'test.side-effect' },
 });
 
@@ -59,34 +50,24 @@ export const SideEffect = Operation.make({
 // Test Handlers
 //
 
-export const computeHandler = OperationResolver.make({
-  operation: Compute,
-  handler: (data) =>
-    Effect.gen(function* () {
-      yield* Effect.sleep(data.value * 10);
-      return { value: data.value * 2 };
-    }),
-});
+export const computeHandler = Operation.withHandler(Compute, (data) =>
+  Effect.gen(function* () {
+    yield* Effect.sleep(data.value * 10);
+    return { value: data.value * 2 };
+  }),
+);
 
-export const halveComputeHandler = OperationResolver.make({
-  operation: HalveCompute,
-  handler: (data) => Effect.succeed({ value: data.value / 2 }),
-});
+export const halveComputeHandler = Operation.withHandler(HalveCompute, (data) =>
+  Effect.succeed({ value: data.value / 2 }),
+);
 
-export const toStringHandler = OperationResolver.make({
-  operation: ToString,
-  handler: (data) => Effect.succeed({ string: data.value.toString() }),
-});
+export const toStringHandler = Operation.withHandler(ToString, (data) =>
+  Effect.succeed({ string: data.value.toString() }),
+);
 
-export const addHandler = OperationResolver.make({
-  operation: Add,
-  handler: (data) => Effect.succeed(data[0] + data[1]),
-});
+export const addHandler = Operation.withHandler(Add, (data) => Effect.succeed(data[0] + data[1]));
 
-export const sideEffectHandler = OperationResolver.make({
-  operation: SideEffect,
-  handler: () => Effect.succeed(undefined),
-});
+export const sideEffectHandler = Operation.withHandler(SideEffect, () => Effect.succeed(undefined));
 
 //
 // Test Utilities

package/src/plugin-runtime/RuntimePlugin.ts

@@ -4,7 +4,6 @@
 
 import { ActivationEvents } from '../common';
 import { Capability, Plugin } from '../core';
-
 import { meta } from './meta';
 
 const ManagedRuntimeCapability = Capability.lazy('ManagedRuntime', () => import('./capability'));
@@ -12,8 +11,8 @@ const ManagedRuntimeCapability = Capability.lazy('ManagedRuntime', () => import(
 export const RuntimePlugin = Plugin.define(meta).pipe(
   Plugin.addModule({
     activatesOn: ActivationEvents.Startup,
-    activatesBefore: [ActivationEvents.SetupLayer],
-    activatesAfter: [ActivationEvents.ManagedRuntimeReady],
+    firesBeforeActivation: [ActivationEvents.SetupLayer],
+    firesAfterActivation: [ActivationEvents.ManagedRuntimeReady],
     activate: ManagedRuntimeCapability,
   }),
   Plugin.make,

package/src/plugin-runtime/meta.ts

@@ -5,7 +5,8 @@
 import { type Plugin } from '../core';
 
 export const meta: Plugin.Meta = {
-  id: 'dxos.org/plugin/runtime',
+  id: 'org.dxos.plugin.runtime',
   name: 'Runtime Plugin',
   description: 'Provides a managed Effect runtime by composing contributed layers.',
+  tags: ['system'],
 };