@dxos/app-framework 0.8.4-main.c85a9c8dae → 0.8.4-main.d05539e30a

package/src/{plugin-operation → plugin-process-manager}/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 → plugin-process-manager}/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 → plugin-process-manager}/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 → plugin-process-manager}/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 → plugin-process-manager}/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 → plugin-process-manager}/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 → plugin-process-manager}/index.ts

@@ -3,4 +3,4 @@
 //
 
 export * from './history';
-export * from './OperationPlugin';
+export * from './ProcessManagerPlugin';

package/src/plugin-process-manager/meta.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Plugin } from '../core';
+
+export const meta: Plugin.Meta = {
+  id: 'org.dxos.plugin.process-manager',
+  name: 'Process Manager Plugin',
+  author: 'DXOS',
+  description:
+    'Hosts the process-manager runtime that composes contributed layer specs into a service resolver, exposes the operation invoker built on top of it, and registers undo/history tracking.',
+  tags: ['system'],
+};

package/src/plugin-process-manager/process-manager-capability.ts

@@ -0,0 +1,178 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Registry } from '@effect-atom/atom';
+import * as KeyValueStore from '@effect/platform/KeyValueStore';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+
+import { LayerSpec, OperationHandlerSet, Process, ServiceResolver, Trace } from '@dxos/compute';
+import { LayerStack, ProcessManager } from '@dxos/compute-runtime';
+import { invariant } from '@dxos/invariant';
+// Explicit import so the emitted `.d.ts` references the package via its public
+// alias instead of a relative `node_modules` path (TS2883).
+import { OperationInvoker } from '@dxos/operation';
+
+import { ActivationEvents, Capabilities } from '../common';
+import { Capability, Plugin } from '../core';
+
+//
+// Capability Module
+//
+// Hosts the {@link ProcessManager} runtime for the plugin system.
+//
+// Workflow:
+// 1. Activates {@link ActivationEvents.SetupProcessManager} so plugins can
+//    contribute {@link Capabilities.LayerSpec} entries and
+//    {@link Capabilities.OperationHandler} sets.
+// 2. Collects all contributed {@link LayerSpec.LayerSpec}s and builds a
+//    {@link LayerStack} whose {@link ServiceResolver} drives process-scoped
+//    service resolution.
+// 3. Wires a reactive {@link OperationHandlerSet} that tracks
+//    {@link Capabilities.OperationHandler} contributions and invalidates its
+//    cached merge when new handlers register.
+// 4. Composes the fixed runtime requirements (capability/plugin managers,
+//    service resolver, operation invoker, process manager) into a single
+//    {@link Layer} and builds a {@link ManagedRuntime} from it.
+// 5. Exposes a disposable-less wrapper as {@link Capabilities.ProcessManagerRuntime}
+//    (the plugin system manages its lifecycle).
+//
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilityManager = yield* Capability.Service;
+    const pluginManager = yield* Plugin.Service;
+    const atomRegistry = yield* Capability.get(Capabilities.AtomRegistry);
+
+    yield* Plugin.activate(ActivationEvents.SetupProcessManager);
+
+    const layerSpecs = yield* Capability.getAll(Capabilities.LayerSpec);
+    const traceSinkFactories = yield* Capability.getAll(Capabilities.TraceSink);
+
+    // Forward reference to `ProcessManager.ProcessManagerService`. The runtime
+    // that owns the manager depends transitively on `ServiceResolver` (which is
+    // built from the `LayerStack` below), so we cannot materialise it before
+    // the stack exists. Instead we publish the manager into this holder as
+    // soon as the runtime is built, and the ambient layer reads it lazily via
+    // `Layer.effect` — slice init only runs once a process actually triggers
+    // service resolution, by which point the holder is populated.
+    let processManagerHolder: ProcessManager.Manager | undefined;
+
+    // Expose the foundational app-framework services through the LayerStack so
+    // that operations declaring `services: [Capability.Service]` (and friends)
+    // can resolve them via the ServiceResolver. Without this, only consumers
+    // sitting on the same ManagedRuntime layer graph can see them — process
+    // executions go through ServiceResolver.resolveAll and would fail.
+    const ambientLayerSpec = LayerSpec.make(
+      {
+        affinity: 'application',
+        requires: [],
+        provides: [Capability.Service, Plugin.Service, Registry.AtomRegistry, ProcessManager.ProcessManagerService],
+      },
+      () =>
+        Layer.mergeAll(
+          Layer.succeed(Capability.Service, capabilityManager),
+          Layer.succeed(Plugin.Service, pluginManager),
+          Layer.succeed(Registry.AtomRegistry, atomRegistry),
+          Layer.effect(
+            ProcessManager.ProcessManagerService,
+            Effect.sync(() => {
+              invariant(
+                processManagerHolder,
+                'ProcessManagerService accessed before the process-manager runtime was initialised',
+              );
+              return processManagerHolder;
+            }),
+          ),
+        ),
+    );
+
+    const layerStack = new LayerStack.LayerStack({ layers: [ambientLayerSpec, ...layerSpecs] });
+    const serviceResolver = layerStack.getServiceResolver();
+
+    const handlerSet = OperationHandlerSet.reactive(
+      atomRegistry,
+      capabilityManager.atom(Capabilities.OperationHandler),
+    );
+
+    const traceSinks = traceSinkFactories.map((factory) => factory({ resolver: serviceResolver }));
+    const mergedTraceSink = Trace.mergeSinks(traceSinks);
+
+    // Base services required by ProcessManager and the operation invoker.
+    // Sensible defaults are provided here; plugins that want alternative
+    // implementations (e.g. persistent KV store, real tracing) can contribute
+    // their own LayerSpec entries against the ServiceResolver.
+    const baseLayer = Layer.mergeAll(
+      Layer.succeed(Capability.Service, capabilityManager),
+      Layer.succeed(Plugin.Service, pluginManager),
+      Layer.succeed(Registry.AtomRegistry, atomRegistry),
+      Layer.succeed(ServiceResolver.ServiceResolver, serviceResolver),
+      OperationHandlerSet.provide(handlerSet),
+      KeyValueStore.layerMemory,
+      Layer.succeed(Trace.TraceSink, mergedTraceSink),
+    );
+
+    const processManagerLayer = ProcessManager.layer({ runtimeName: Trace.CommonRuntimeName.local }).pipe(
+      Layer.provide(baseLayer),
+    );
+    const operationInvokerLayer = ProcessManager.ProcessOperationInvoker.layer.pipe(
+      Layer.provide(Layer.mergeAll(processManagerLayer, baseLayer)),
+    );
+
+    const runtimeLayer = Layer.mergeAll(baseLayer, processManagerLayer, operationInvokerLayer);
+
+    const managedRuntime = ManagedRuntime.make(runtimeLayer as Layer.Layer<any, any, never>);
+
+    // TODO(dmaretskyi): Capability modules don't currently expose a teardown
+    // hook (`makeModule` only allows `Service | Plugin.Service` in the effect's
+    // requirements, ruling out `Effect.addFinalizer`). Once the plugin
+    // framework grows a shutdown lifecycle, dispose `managedRuntime` and then
+    // call `layerStack.destroy()` to tear down keep-alive slices.
+
+    const processManagerRuntime: Capabilities.ProcessManagerRuntime = {
+      runPromise: (effect, options) => managedRuntime.runPromise(effect as Effect.Effect<any, any, any>, options),
+      runPromiseExit: (effect, options) =>
+        managedRuntime.runPromiseExit(effect as Effect.Effect<any, any, any>, options),
+      runFork: (effect, options) => managedRuntime.runFork(effect as Effect.Effect<any, any, any>, options),
+      runSync: (effect) => managedRuntime.runSync(effect as Effect.Effect<any, any, any>),
+    };
+
+    // Eagerly extract the process monitor. Safe because it does not require a
+    // fresh scope and is a stable reference for the lifetime of the runtime.
+    const processMonitor = managedRuntime.runSync(
+      Effect.flatMap(Process.ProcessMonitorService, Effect.succeed) as Effect.Effect<Process.Monitor, never, never>,
+    );
+
+    // Publish the manager into the ambient-layer holder so that
+    // `ProcessManager.ProcessManagerService` becomes resolvable through the
+    // LayerStack alongside the other framework-supplied services.
+    processManagerHolder = managedRuntime.runSync(
+      Effect.flatMap(ProcessManager.ProcessManagerService, Effect.succeed) as Effect.Effect<
+        ProcessManager.Manager,
+        never,
+        never
+      >,
+    );
+
+    // Eagerly extract the operation invoker built by ProcessOperationInvoker.layer.
+    // Pulled via the ProcessOperationInvoker tag so the contributed value carries
+    // the full OperationInvoker interface (`invocations`, `pendingFollowups`,
+    // `awaitFollowups`, `_invokeCore`) that HistoryTracker requires.
+    const operationInvoker: OperationInvoker.OperationInvoker = managedRuntime.runSync(
+      Effect.flatMap(ProcessManager.ProcessOperationInvoker.Service, Effect.succeed) as unknown as Effect.Effect<
+        OperationInvoker.OperationInvoker,
+        never,
+        never
+      >,
+    );
+
+    return [
+      Capability.contributes(Capabilities.ProcessManagerRuntime, processManagerRuntime),
+      Capability.contributes(Capabilities.ServiceResolver, serviceResolver),
+      Capability.contributes(Capabilities.ProcessMonitor, processMonitor),
+      Capability.contributes(Capabilities.OperationInvoker, operationInvoker),
+    ];
+  }),
+);

package/src/{plugin-operation → plugin-process-manager}/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