@dxos/app-framework 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/app-framework",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "A framework for building applications from composible plugins.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -171,27 +171,27 @@
     "esbuild": "0.28.2",
     "idb-keyval": "^6.2.1",
     "solid-js": "^1.9.11",
-    "@dxos/async": "0.13.0",
-    "@dxos/compute": "0.13.0",
-    "@dxos/context": "0.13.0",
-    "@dxos/compute-runtime": "0.13.0",
-    "@dxos/debug": "0.13.0",
-    "@dxos/edge-client": "0.13.0",
-    "@dxos/echo": "0.13.0",
-    "@dxos/effect": "0.13.0",
-    "@dxos/errors": "0.13.0",
-    "@dxos/graph": "0.13.0",
-    "@dxos/invariant": "0.13.0",
-    "@dxos/keys": "0.13.0",
-    "@dxos/log": "0.13.0",
-    "@dxos/operation": "0.13.0",
-    "@dxos/protocols": "0.13.0",
-    "@dxos/react-error-boundary": "0.13.0",
-    "@dxos/react-hooks": "0.13.0",
-    "@dxos/ui-theme": "0.13.0",
-    "@dxos/util": "0.13.0",
-    "@dxos/web-context": "0.13.0",
-    "@dxos/web-context-react": "0.13.0"
+    "@dxos/async": "0.14.0",
+    "@dxos/compute": "0.14.0",
+    "@dxos/compute-runtime": "0.14.0",
+    "@dxos/context": "0.14.0",
+    "@dxos/debug": "0.14.0",
+    "@dxos/echo": "0.14.0",
+    "@dxos/edge-client": "0.14.0",
+    "@dxos/effect": "0.14.0",
+    "@dxos/errors": "0.14.0",
+    "@dxos/graph": "0.14.0",
+    "@dxos/invariant": "0.14.0",
+    "@dxos/keys": "0.14.0",
+    "@dxos/log": "0.14.0",
+    "@dxos/operation": "0.14.0",
+    "@dxos/protocols": "0.14.0",
+    "@dxos/react-error-boundary": "0.14.0",
+    "@dxos/react-hooks": "0.14.0",
+    "@dxos/ui-theme": "0.14.0",
+    "@dxos/util": "0.14.0",
+    "@dxos/web-context": "0.14.0",
+    "@dxos/web-context-react": "0.14.0"
   },
   "devDependencies": {
     "@effect/atom-react": "4.0.0",
@@ -206,10 +206,10 @@
     "storybook-solidjs-vite": "^10.7.1",
     "typedoc": "0.28.1",
     "vite": "^8.2.2",
-    "@dxos/brand": "0.13.0",
-    "@dxos/random": "0.13.0",
-    "@dxos/react-ui": "0.13.0",
-    "@dxos/react-ui-list": "0.13.0"
+    "@dxos/brand": "0.14.0",
+    "@dxos/random": "0.14.0",
+    "@dxos/react-ui": "0.14.0",
+    "@dxos/react-ui-list": "0.14.0"
   },
   "peerDependencies": {
     "@effect/atom-react": "4.0.0",

package/src/common/capabilities.ts

@@ -195,7 +195,6 @@ export type ProcessManagerRuntimeServices =
   | Plugin$.Service
   | ProcessManager$.ProcessManagerService
   | Operation.Service
-  | ProcessManager$.ProcessOperationInvoker.Service
   | ComputeServiceResolver.ServiceResolver;
 
 /**
@@ -264,7 +263,7 @@ export const UndoMapping = Capability$.make<UndoMapping[]>()('org.dxos.app-frame
 
 /**
  * Operation invoker backed by the process manager. Spawns a process per
- * operation invocation; see {@link ProcessManager$.ProcessOperationInvoker}.
+ * operation invocation; see `ProcessOperationInvoker` in `@dxos/compute-runtime`.
  */
 export type OperationInvoker = OperationInvoker$.OperationInvoker;
 

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

@@ -3,15 +3,20 @@
 //
 
 import { describe, expect, it, test } from '@effect/vitest';
+import * as Cause from 'effect/Cause';
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
 import * as Layer from 'effect/Layer';
+import * as Registry from 'effect/reactivity/AtomRegistry';
 
+import { RemoteProcessManager } from '@dxos/compute-runtime';
 import * as LayerSpec from '@dxos/compute/LayerSpec';
+import * as Process from '@dxos/compute/Process';
 import * as ServiceResolver from '@dxos/compute/ServiceResolver';
 import * as Trace from '@dxos/compute/Trace';
 import { Obj } from '@dxos/echo';
-import { DXN } from '@dxos/keys';
+import { DXN, SpaceId } from '@dxos/keys';
 import { type LogConfig, type LogEntry, LogLevel, log } from '@dxos/log';
 
 import { ActivationEvents, Capabilities } from '../common/index.ts';
@@ -281,3 +286,75 @@ describe('dynamic trace sink', () => {
     expect(reached).toEqual(['second']);
   });
 });
+
+describe('one process manager', () => {
+  const remoteMeta = Plugin.makeMeta({ key: DXN.make('org.dxos.test.remoteRuntime'), name: 'Remote runtime' });
+  const edge = { location: { kind: 'edge', space: SpaceId.random() } } as const;
+
+  /** A plugin contributing a remote manager whose `list` records the spaces it was asked about, as EDGE's does. */
+  const RemoteRuntime = (listed: string[]) =>
+    Plugin.make(
+      Plugin.define(remoteMeta).pipe(
+        Plugin.addModule({
+          id: 'remote-process-manager',
+          activatesOn: ActivationEvents.Startup,
+          provides: [Capabilities.LayerSpec],
+          activate: () =>
+            Effect.succeed([
+              Capability.contribute(
+                Capabilities.LayerSpec,
+                LayerSpec.make(
+                  {
+                    affinity: 'application',
+                    requires: [Registry.AtomRegistry],
+                    provides: [RemoteProcessManager.Service],
+                  },
+                  () =>
+                    Layer.effect(
+                      RemoteProcessManager.Service,
+                      Effect.gen(function* () {
+                        const noop = yield* RemoteProcessManager.Service;
+                        return {
+                          ...noop,
+                          list: ({ spaceId }: RemoteProcessManager.ListOptions) =>
+                            Effect.sync(() => {
+                              listed.push(spaceId);
+                              return [];
+                            }),
+                        };
+                      }),
+                    ).pipe(Layer.provide(RemoteProcessManager.layerNoop)),
+                ),
+              ),
+            ]),
+        }),
+      ),
+    );
+
+  it.effect("sends the app's edge control to the remote manager a plugin contributes", () =>
+    Effect.gen(function* () {
+      const listed: string[] = [];
+      const manager = makeManager({ plugins: [RemoteRuntime(listed)()], enabled: [remoteMeta.profile.key] });
+      yield* manager.activate(ActivationEvents.Startup);
+
+      // The app's manager and the stack's (the one `AgentService` resolves) are the same one.
+      const appManager = yield* manager.capabilities.waitFor(Capabilities.ProcessManager);
+      const stackManager = yield* resolveWith(manager, Process.ManagerService);
+      yield* appManager.handles(edge);
+      yield* stackManager.handles(edge);
+      expect(listed).toEqual([edge.location.space, edge.location.space]);
+    }),
+  );
+
+  it.effect('falls back to no remote control without such a plugin, and keeps local control', () =>
+    Effect.gen(function* () {
+      const manager = makeManager({ plugins: [], enabled: [] });
+      yield* manager.activate(ActivationEvents.Startup);
+
+      const appManager = yield* manager.capabilities.waitFor(Capabilities.ProcessManager);
+      expect(yield* appManager.handles()).toEqual([]);
+      const remote = yield* Effect.exit(appManager.handles(edge));
+      expect(Exit.isFailure(remote) && String(Cause.squash(remote.cause))).toContain('offers no process control');
+    }),
+  );
+});

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

@@ -2,15 +2,21 @@
 // Copyright 2026 DXOS.org
 //
 
+import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
 import * as Layer from 'effect/Layer';
 import * as ManagedRuntime from 'effect/ManagedRuntime';
+import * as Atom from 'effect/reactivity/Atom';
 import * as Registry from 'effect/reactivity/AtomRegistry';
+import * as Scope from 'effect/Scope';
+import * as Stream from 'effect/Stream';
 import * as Tracer from 'effect/Tracer';
 
 import {
   LayerStack,
   ProcessManager,
+  ProcessOperationInvoker,
   RemoteProcessManager,
   RemoteTraceMonitor,
   UnifiedProcessManager,
@@ -87,6 +93,62 @@ export const makeDynamicTraceSink = (
   return { write: (message) => Trace.mergeSinks(resolve()).write(message) };
 };
 
+/**
+ * The application's one {@link Process.ManagerService}, as built by the stack. Every built-in and plugin
+ * consumer sees the same manager, so a host's remote manager (e.g. EDGE) reaches the app's invoker too.
+ */
+const ProcessManagerSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [
+      ProcessManager.ProcessManagerService,
+      RemoteProcessManager.Service,
+      RemoteTraceMonitor.Service,
+      Registry.AtomRegistry,
+    ],
+    provides: [Process.ManagerService],
+  },
+  () => UnifiedProcessManager.layer,
+);
+
+/**
+ * A {@link Process.Manager} that is the stack's {@link Process.ManagerService}, resolved on first use: building it
+ * resolves the host's remote manager, which may need services (the client) that are not ready at activation.
+ * The process tree reads empty until then.
+ */
+export const fromStack = (
+  resolver: ServiceResolver.ServiceResolver,
+  scope: Scope.Scope,
+  registry: Registry.AtomRegistry,
+): Process.Manager => {
+  const resolvedAtom = Atom.make<Process.Manager | undefined>(undefined).pipe(Atom.keepAlive);
+  const manager: Effect.Effect<Process.Manager> = Effect.suspend(() => {
+    const resolved = registry.get(resolvedAtom);
+    return resolved !== undefined
+      ? Effect.succeed(resolved)
+      : resolver.resolve(Process.ManagerService, {}).pipe(
+          Scope.provide(scope),
+          Effect.tap((stackManager) => Effect.sync(() => registry.set(resolvedAtom, stackManager))),
+          // The framework's own spec provides it, so a failure here is a broken stack, not a missing plugin.
+          Effect.orDie,
+        );
+  });
+
+  return {
+    processTree: Effect.flatMap(manager, (stackManager) => stackManager.processTree),
+    processTreeAtom: Atom.make((get) => {
+      const stackManager = get(resolvedAtom);
+      return stackManager === undefined ? [] : get(stackManager.processTreeAtom);
+    }),
+    list: (filter) => Effect.flatMap(manager, (stackManager) => stackManager.list(filter)),
+    subscribeToTraceMessages: (filter) =>
+      Stream.unwrap(Effect.map(manager, (stackManager) => stackManager.subscribeToTraceMessages(filter))),
+    spawn: (definition, options) => Effect.flatMap(manager, (stackManager) => stackManager.spawn(definition, options)),
+    handles: (options) => Effect.flatMap(manager, (stackManager) => stackManager.handles(options)),
+    attach: (pid, options) => Effect.flatMap(manager, (stackManager) => stackManager.attach(pid, options)),
+  };
+};
+
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
     const capabilityManager = yield* Capability.Service;
@@ -143,7 +205,32 @@ export default Capability.makeModule(
         ),
     );
 
-    const layerStack = new LayerStack.LayerStack({ layers: [ambientLayerSpec, ...layerSpecs] });
+    // Fallbacks for a host with no remote runtime; a plugin spec providing either tag (e.g. EDGE's) wins.
+    const fallbacks = Effect.runSync(
+      Effect.gen(function* () {
+        const remoteProcessManager = yield* RemoteProcessManager.Service;
+        const remoteTraceMonitor = yield* RemoteTraceMonitor.Service;
+        return Context.make(RemoteProcessManager.Service, remoteProcessManager).pipe(
+          Context.add(RemoteTraceMonitor.Service, remoteTraceMonitor),
+        );
+      }).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            RemoteProcessManager.layerNoop,
+            // Remote ephemeral trace (DX-1125): the first contributed swarm-backed monitor, else no-op.
+            remoteTraceMonitors.length > 0
+              ? Layer.succeed(RemoteTraceMonitor.Service, remoteTraceMonitors[0])
+              : RemoteTraceMonitor.layerNoop,
+          ),
+        ),
+        Effect.provideService(Registry.AtomRegistry, atomRegistry),
+      ),
+    );
+
+    const layerStack = new LayerStack.LayerStack({
+      layers: [ambientLayerSpec, ProcessManagerSpec, ...layerSpecs],
+      services: fallbacks,
+    });
     const serviceResolver = layerStack.getServiceResolver();
 
     // The stack extends built slices in place, so admitting a late spec costs no live service.
@@ -195,21 +282,14 @@ export default Capability.makeModule(
     const processManagerLayer = ProcessManager.layer({ runtimeName: Trace.CommonRuntimeName.local }).pipe(
       Layer.provide(baseLayer),
     );
-    const operationInvokerLayer = ProcessManager.ProcessOperationInvoker.layer.pipe(
+    // Holds the stack's application slice that the manager resolves from, for the module's lifetime.
+    const stackScope = yield* Scope.make();
+    yield* Effect.addFinalizer(() => Scope.close(stackScope, Exit.void));
+    const unifiedProcessManager = fromStack(serviceResolver, stackScope, atomRegistry);
+    const unifiedProcessManagerLayer = Layer.succeed(Process.ManagerService, unifiedProcessManager);
+    const operationInvokerLayer = ProcessOperationInvoker.layer.pipe(
       // Operations invoked through the app's own invoker are the person's actions, from a menu, dialog or shortcut.
-      Layer.provide(Layer.mergeAll(processManagerLayer, baseLayer, Layer.succeed(Database.Origin, 'user'))),
-    );
-
-    // App-framework has no EDGE runtime, so the remote process view is empty;
-    // the aggregate manager therefore equals the local process tree.
-    const remoteProcessManagerLayer = RemoteProcessManager.layerNoop.pipe(Layer.provide(baseLayer));
-    // Remote ephemeral trace (DX-1125): use the first contributed swarm-backed monitor, else no-op.
-    const remoteTraceMonitorLayer =
-      remoteTraceMonitors.length > 0
-        ? Layer.succeed(RemoteTraceMonitor.Service, remoteTraceMonitors[0])
-        : RemoteTraceMonitor.layerNoop;
-    const unifiedProcessManagerLayer = UnifiedProcessManager.layer.pipe(
-      Layer.provide(Layer.mergeAll(processManagerLayer, remoteProcessManagerLayer, remoteTraceMonitorLayer, baseLayer)),
+      Layer.provide(Layer.mergeAll(unifiedProcessManagerLayer, baseLayer, Layer.succeed(Database.Origin, 'user'))),
     );
 
     const runtimeLayer = Layer.mergeAll(
@@ -235,12 +315,6 @@ export default Capability.makeModule(
       runSync: (effect) => managedRuntime.runSync(effect as Effect.Effect<any, any, any>),
     };
 
-    // Eagerly extract the process manager. Safe because it does not require a
-    // fresh scope and is a stable reference for the lifetime of the runtime.
-    const unifiedProcessManager = managedRuntime.runSync(
-      Effect.flatMap(Process.ManagerService, Effect.succeed) as Effect.Effect<Process.Manager, 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.
@@ -252,13 +326,16 @@ export default Capability.makeModule(
       >,
     );
 
-    // 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`,
+    // Resolved in the background rather than on first spawn, so a view that only reads the tree still fills in;
+    // after the holder above, which the stack's manager is built over.
+    managedRuntime.runFork(unifiedProcessManager.processTree);
+
+    // Eagerly extract the operation invoker built by ProcessOperationInvoker.layer, via its own 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,
+      Effect.flatMap(ProcessOperationInvoker.Service, Effect.succeed) as Effect.Effect<
+        ProcessOperationInvoker.ProcessOperationInvoker,
         never,
         never
       >,

package/src/vite-plugin/packages.ts

@@ -133,7 +133,6 @@ export const DEFAULT_PACKAGES = [
   '@dxos/react-ui-calendar',
   '@dxos/react-ui-canvas',
   '@dxos/react-ui-canvas-compute',
-  '@dxos/react-ui-canvas-editor',
   '@dxos/react-ui-chat',
   '@dxos/react-ui-components',
   '@dxos/react-ui-dnd',