@dxos/plugin-client 0.10.0 → 0.11.0

package/src/capabilities/{react-surface.tsx → react-surface.ts}

@@ -3,7 +3,7 @@
 //
 
 import * as Effect from 'effect/Effect';
-import React, { type ComponentProps } from 'react';
+import { type ComponentProps } from 'react';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { Surface } from '@dxos/app-framework/ui';
@@ -36,37 +36,39 @@ export default Capability.makeModule(
       Surface.create({
         id: Account.Profile,
         filter: AppSurface.literal(AppSurface.Article, Account.Profile),
-        component: () => <ProfileContainer />,
+        component: ProfileContainer,
       }),
       Surface.create({
         id: Account.Devices,
         filter: AppSurface.literal(AppSurface.Article, Account.Devices),
-        component: () => <DevicesContainer createInvitationUrl={createInvitationUrl} />,
+        component: DevicesContainer,
+        props: () => ({ createInvitationUrl }),
       }),
       Surface.create({
         id: Account.Security,
         filter: AppSurface.literal(AppSurface.Article, Account.Security),
-        component: () => <RecoveryCredentialsContainer />,
+        component: RecoveryCredentialsContainer,
       }),
       Surface.create({
         id: Account.Account,
         filter: AppSurface.literal(AppSurface.Article, Account.Account),
-        component: () => <AccountContainer />,
+        component: AccountContainer,
       }),
       Surface.create({
         id: Account.Invitations,
         filter: AppSurface.literal(AppSurface.Article, Account.Invitations),
-        component: () => <InvitationsContainer />,
+        component: InvitationsContainer,
       }),
       Surface.create({
         id: Account.Usage,
         filter: AppSurface.literal(AppSurface.Article, Account.Usage),
-        component: () => <UsageContainer />,
+        component: UsageContainer,
       }),
       Surface.create({
         id: JOIN_DIALOG,
         filter: AppSurface.component<ComponentProps<typeof JoinDialog>>(AppSurface.Dialog, JOIN_DIALOG),
-        component: ({ data }) => <JoinDialog {...data.props} />,
+        component: JoinDialog,
+        props: ({ data: { props } }) => ({ ...props }),
       }),
       Surface.create({
         id: RECOVERY_CODE_DIALOG,
@@ -74,14 +76,14 @@ export default Capability.makeModule(
           AppSurface.Dialog,
           RECOVERY_CODE_DIALOG,
         ),
-        component: ({ data }) => <RecoveryCodeDialog {...data.props} />,
+        component: RecoveryCodeDialog,
+        props: ({ data: { props } }) => ({ ...props }),
       }),
       Surface.create({
         id: RESET_DIALOG,
         filter: AppSurface.component<Pick<ComponentProps<typeof ResetDialog>, 'mode'>>(AppSurface.Dialog, RESET_DIALOG),
-        component: ({ data }) => (
-          <ResetDialog {...data.props} onReset={onReset} capabilityManager={capabilityManager} />
-        ),
+        component: ResetDialog,
+        props: ({ data: { props } }) => ({ ...props, onReset, capabilityManager }),
       }),
     ]);
   }),

package/src/capabilities/remote-trace-monitor.ts

@@ -0,0 +1,62 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import * as Stream from 'effect/Stream';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { RemoteTraceMonitor } from '@dxos/compute-runtime';
+
+import { ClientCapabilities } from '#types';
+
+/**
+ * Contributes a swarm-backed {@link Capabilities.RemoteTraceMonitor} (DX-1125). Remote runtimes
+ * (edge intrinsics / function-invoker) broadcast their ephemeral trace messages over the space swarm;
+ * this monitor subscribes via the client's network service and decodes them so the aggregate
+ * {@link Process.Monitor.subscribeToTraceMessages} surfaces remote progress.
+ *
+ * The client is resolved lazily inside the subscribe closure (invoked only when a consumer
+ * subscribes, well after `ClientReady`), so this module can be collected at `SetupProcessManager`
+ * before the client capability exists.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilityManager = yield* Capability.Service;
+
+    const monitor = RemoteTraceMonitor.createSwarmRemoteTraceMonitor({
+      subscribe: (tags) =>
+        // Empty tag set matches nothing (avoids a firehose) — skip the subscription entirely.
+        tags.length === 0
+          ? Stream.empty
+          : Stream.unwrap(
+              Effect.sync(() => {
+                const client = capabilityManager.getAll(ClientCapabilities.Client)[0];
+                if (!client) {
+                  return Stream.empty;
+                }
+                // The subscribing peer is nominal for broadcasts: the edge keys the subscription off
+                // the WebSocket connection, not this object; it only affects point-to-point filtering.
+                const peer = {
+                  peerKey:
+                    client.halo.device?.deviceKey.toHex() ?? client.halo.identity.get()?.identityKey.toHex() ?? '',
+                };
+                return client.services.rpc.NetworkService.subscribeMessages({ peer, tags }).pipe(
+                  // Carry the envelope tags with the payload — the wire payload drops ref meta
+                  // (`trigger`), and decode restores it from the tags for cancel addressing.
+                  Stream.filterMap((message) =>
+                    message.payload?.value
+                      ? Option.some({ payload: message.payload.value, tags: message.tags })
+                      : Option.none(),
+                  ),
+                  // Never fail the aggregate monitor stream on a transient network error.
+                  Stream.catchAll(() => Stream.empty),
+                );
+              }),
+            ),
+    });
+
+    return Capability.contributes(Capabilities.RemoteTraceMonitor, monitor);
+  }),
+);

package/src/capabilities/space-replication-progress.ts

@@ -0,0 +1,143 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Scope from 'effect/Scope';
+import * as Stream from 'effect/Stream';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { type Space, SpaceState } from '@dxos/client/echo';
+import { ServiceResolver } from '@dxos/compute';
+import { Database } from '@dxos/echo';
+
+import { ClientCapabilities } from '#types';
+
+import { createSpaceFeedReplicationProgressKey, createSpaceReplicationProgressKey } from '../progress';
+
+type MonitorUpdate = {
+  readonly label: string;
+  readonly current: number;
+  readonly total: number;
+  readonly note?: string;
+};
+
+/**
+ * Publishes per-space replication backlog — automerge documents and ECHO feed blocks — into the
+ * {@link AppCapabilities.ProgressRegistry}. Subscribes to the combined sync-state stream and drops
+ * monitors once a space catches up.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const client = yield* Capability.get(ClientCapabilities.Client);
+    const registry = yield* Capability.get(AppCapabilities.ProgressRegistry);
+    const processManagerRuntime = yield* Capability.get(Capabilities.ProcessManagerRuntime);
+
+    const monitors = new Map<string, AppCapabilities.ProgressMonitor>();
+
+    yield* Effect.addFinalizer(() =>
+      Effect.sync(() => {
+        for (const monitor of monitors.values()) {
+          monitor.remove();
+        }
+        monitors.clear();
+      }),
+    );
+
+    const applyMonitor = (key: string, update: MonitorUpdate | undefined): void => {
+      if (update === undefined) {
+        monitors.get(key)?.remove();
+        monitors.delete(key);
+        return;
+      }
+
+      let monitor = monitors.get(key);
+      if (!monitor) {
+        monitor = registry.register(key, { label: update.label, total: update.total });
+        monitors.set(key, monitor);
+      }
+      monitor.set(update.current);
+      monitor.total(update.total);
+      if (update.note !== undefined) {
+        monitor.note(update.note);
+      }
+    };
+
+    // A space that has not finished initializing throws from its `properties` getter, and the
+    // spaces subscription fires before initialization completes (startup, space creation) — so
+    // the name is read lazily per sync-state update, and only once the space is SPACE_READY.
+    const getSpaceName = (space: Space): string | undefined =>
+      space.state.get() === SpaceState.SPACE_READY ? space.properties.name : undefined;
+
+    const runtime = yield* Effect.runtime<Scope.Scope>();
+    const subscribeSpace = (space: Space): void =>
+      void Effect.gen(function* () {
+        const fiber = processManagerRuntime.runFork(
+          Database.subscribeToSyncState().pipe(
+            Stream.runForEach(
+              Effect.fnUntraced(function* (state) {
+                const name = getSpaceName(space);
+                applyMonitor(createSpaceReplicationProgressKey(space.id), toDocumentUpdate(name, state));
+                applyMonitor(createSpaceFeedReplicationProgressKey(space.id), toFeedUpdate(name, state));
+              }),
+            ),
+            Effect.provide(ServiceResolver.provide({ space: space.id }, Database.Service)),
+          ),
+        );
+
+        yield* Effect.addFinalizer(() => Fiber.interrupt(fiber));
+      }).pipe(Effect.provide(runtime), Effect.runFork);
+
+    const spacesSubscription = client.spaces.subscribe((spaces) => {
+      for (const space of spaces) {
+        subscribeSpace(space);
+      }
+    });
+    yield* Effect.addFinalizer(() => Effect.sync(() => spacesSubscription.unsubscribe()));
+    for (const space of client.spaces.get()) {
+      subscribeSpace(space);
+    }
+  }),
+);
+
+/** Derives the automerge document monitor state, or `undefined` when caught up. */
+const toDocumentUpdate = (name: string | undefined, state: Database.SyncState): MonitorUpdate | undefined => {
+  const unsynced = state.unsyncedDocumentCount;
+  if (unsynced === 0) {
+    return undefined;
+  }
+
+  const total = state.totalDocumentCount > 0 ? state.totalDocumentCount : unsynced;
+  return {
+    label: getSpaceProgressLabel(name ?? 'Space', 'CRDTs'),
+    current: Math.max(0, total - unsynced),
+    total,
+  };
+};
+
+/** Derives the ECHO feed block monitor state, or `undefined` when caught up. */
+const toFeedUpdate = (name: string | undefined, state: Database.SyncState): MonitorUpdate | undefined => {
+  const blocksToPull = Number(state.blocksToPull);
+  const blocksToPush = Number(state.blocksToPush);
+  const pending = blocksToPull + blocksToPush;
+  if (pending === 0) {
+    return undefined;
+  }
+
+  const totalBlocks = Number(state.totalBlocks);
+  const total = totalBlocks > 0 ? totalBlocks : pending;
+  return {
+    label: getSpaceProgressLabel(name ?? 'Space', 'Feeds'),
+    current: Math.max(0, total - pending),
+    total,
+    note: `↓${blocksToPull} ↑${blocksToPush}`,
+  };
+};
+
+/** Human label for a space progress monitor. */
+const getSpaceProgressLabel = (name: string | undefined, suffix?: string): string => {
+  const name_ = name ?? 'Space';
+  return suffix ? `${name_} · ${suffix}` : name_;
+};

package/src/capabilities/trace-progress.ts

@@ -0,0 +1,84 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Stream from 'effect/Stream';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, type CancelTarget, createProgressTraceSink, resolveTriggerId } from '@dxos/app-toolkit';
+import { Trace } from '@dxos/compute';
+import { RemoteProcessManager } from '@dxos/compute-runtime';
+import { log } from '@dxos/log';
+
+/**
+ * Projects remote (edge-runtime) `status.update` trace events into the {@link AppCapabilities.ProgressRegistry}
+ * (DX-1125). Subscribes to the aggregate {@link Process.Monitor.subscribeToTraceMessages}, whose remote
+ * source is the swarm-backed monitor contributed by `remote-trace-monitor`.
+ *
+ * Only edge-runtime messages are projected here: local progress already flows through the
+ * `plugin-progress` trace sink, and both write the same progress keys — projecting local messages
+ * twice would let two writers clobber each other's registry handles.
+ *
+ * Cancel on this path always routes to {@link RemoteProcessManager} (edge) — local terminate is
+ * handled by the `plugin-progress` sink, which never sees these messages.
+ */
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilityManager = yield* Capability.Service;
+    const monitor = yield* Capability.get(Capabilities.ProcessMonitor);
+    const processManagerRuntime = yield* Capability.get(Capabilities.ProcessManagerRuntime);
+    const resolver = yield* Capability.get(Capabilities.ServiceResolver);
+
+    // Edge-only cancel. Soft-fails (the meter has already cleared locally), but never silently: an
+    // unresolvable manager or a rejected request means the run may still be going on the edge.
+    const cancelRemote = (space: string, trigger: string, pid?: string) =>
+      Effect.runFork(
+        resolver.resolve(RemoteProcessManager.Service, {}).pipe(
+          Effect.flatMap((manager) => manager.cancel?.({ space, trigger, pid }) ?? Effect.void),
+          Effect.scoped,
+          Effect.catchAllCause((cause) =>
+            Effect.sync(() => log.warn('edge progress cancel failed', { space, trigger, pid, cause })),
+          ),
+        ),
+      );
+
+    const progressSink = createProgressTraceSink(() => capabilityManager.getAll(AppCapabilities.ProgressRegistry)[0], {
+      // An edge run is a chain of bounded invocations, each with a fresh pid, so a pid tombstone
+      // would only mask one chain link and the next would resurrect the meter — suppress the key
+      // until the run's terminal status, matching the local (single-pid) cancel behaviour.
+      cancelScope: 'run',
+      cancelProcess: (target: CancelTarget) => {
+        const triggerId = resolveTriggerId(target);
+        if (target.space && triggerId) {
+          cancelRemote(target.space, triggerId, target.pid);
+        } else {
+          // Never drop a user's cancel silently — an unresolvable target means the trace meta lost
+          // its addressing (e.g. the swarm wire codec), which must surface in the log.
+          log.warn('edge progress cancel dropped: unresolvable target', {
+            space: target.space,
+            trigger: target.trigger?.uri.toString(),
+            pid: target.pid,
+          });
+        }
+      },
+    });
+
+    // TODO(mykola): Possible bug source. Use `Effect.forkDaemon`.
+    const fiber = processManagerRuntime.runFork(
+      monitor.subscribeToTraceMessages({ type: Trace.StatusUpdate.key }).pipe(
+        Stream.runForEach((message) =>
+          Effect.sync(() => {
+            const runtimeName = message.meta.runtimeName;
+            if (runtimeName && Trace.isEdgeRuntime(runtimeName)) {
+              progressSink.write(message);
+            }
+          }),
+        ),
+      ),
+    );
+
+    yield* Effect.addFinalizer(() => Fiber.interrupt(fiber));
+  }),
+);

package/src/commands/account/login/login.ts

@@ -11,6 +11,7 @@ import * as Effect from 'effect/Effect';
 import * as Match from 'effect/Match';
 import * as Option from 'effect/Option';
 
+import { Capabilities, Plugin } from '@dxos/app-framework';
 import { CommandConfig, performRecoveryOAuthFlow, print } from '@dxos/cli-util';
 import { type Client, ClientService } from '@dxos/client';
 import { Invitation, InvitationEncoder } from '@dxos/client/invitations';
@@ -19,6 +20,8 @@ import { HubHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { ATPROTO_OAUTH_SCOPES, OAuthProvider } from '@dxos/protocols';
 
+import { ClientOperation } from '#operations';
+
 import { printIdentity, waitForState } from '../../halo/util';
 
 type LoginMethod = 'email' | 'atproto' | 'device-invitation' | 'recovery-code';
@@ -56,6 +59,8 @@ export const login = Command.make(
   Effect.fn(function* ({ method, input }) {
     const { json } = yield* CommandConfig;
     const client = yield* ClientService;
+    const manager = yield* Plugin.Service;
+    const { invoke } = manager.capabilities.get(Capabilities.OperationInvoker);
     // TODO(wittjosiah): How to surface this error to the user cleanly?
     invariant(!client.halo.identity.get(), 'Already logged in. Run `dx account logout` first.');
 
@@ -69,7 +74,7 @@ export const login = Command.make(
 
     const identity = yield* Match.value(resolvedMethod).pipe(
       Match.when('atproto', () => loginWithAtproto(client, resolvedInput)),
-      Match.when('email', () => loginWithEmail(client, resolvedInput)),
+      Match.when('email', () => loginWithEmail(client, resolvedInput, invoke)),
       Match.when('recovery-code', () => loginWithRecoveryCode(client, resolvedInput)),
       Match.when('device-invitation', () => loginWithDeviceInvitation(client, resolvedInput)),
       Match.exhaustive,
@@ -108,16 +113,53 @@ const loginWithRecoveryCode = (client: Client, recoveryCode: string) =>
   Effect.tryPromise(() => client.halo.recoverIdentity({ recoveryCode }));
 
 /**
- * Email login: hub-service inlines a one-time `token` for test emails and emails it out-of-band
- * otherwise. Redeems the token to admit this device into HALO.
+ * Email login, mirroring the gate's login tab (`WelcomeScreen.handleLogin`). Hub-service answers in
+ * one of three ways:
+ *
+ * - `needsIdentity`: the address may bind a fresh Account but has no identity yet. Create one
+ *   locally and retry with its DID; the hub then admits it directly — there is no token because
+ *   there is nothing to recover — and we provision the agent as the gate does.
+ * - `token`: an Account exists and the hub returned a one-time recovery token inline.
+ * - neither: the link went out by email, so prompt for the token from the message.
  */
-const loginWithEmail = (client: Client, email: string) =>
+const loginWithEmail = (client: Client, email: string, invoke: Capabilities.OperationInvoker['invoke']) =>
   Effect.gen(function* () {
     const hubUrl = client.config.values?.runtime?.app?.env?.DX_HUB_URL;
     invariant(hubUrl, 'Hub URL not configured (runtime.app.env.DX_HUB_URL).');
     const hub = new HubHttpClient(hubUrl);
-    const { token: inlineToken } = yield* Effect.tryPromise(() => hub.login(DxContext.default(), { email }));
-    let token = inlineToken;
+    const result = yield* Effect.tryPromise(() => hub.login(DxContext.default(), { email }));
+
+    if (result.needsIdentity) {
+      // `CreateIdentity` fires `IdentityCreated`, which is what provisions the personal space.
+      yield* invoke(ClientOperation.CreateIdentity, { displayName: email.split('@')[0] });
+      const identity = client.halo.identity.get();
+      invariant(identity, 'identity should exist after create');
+      // The local identity outlives any failure from here on, and the `Already logged in` guard
+      // above rejects a plain retry, so a rejected request and a non-admitting response both need
+      // the same recovery guidance.
+      const notAdmitted = (detail: string) =>
+        new Error(
+          `Hub did not admit ${email} (${detail}). A local identity was created and remains bound to ` +
+            'this profile; run `dx account logout` to clear it before retrying.',
+        );
+
+      const retry = yield* Effect.tryPromise({
+        try: () =>
+          hub.login(DxContext.default(), {
+            email,
+            identityDid: identity.did,
+            identityKey: identity.identityKey.toHex(),
+          }),
+        catch: (cause) => notAdmitted(cause instanceof Error ? cause.message : String(cause)),
+      });
+      if (!retry.admitted) {
+        return yield* Effect.fail(notAdmitted('no admission granted'));
+      }
+      yield* invoke(ClientOperation.CreateAgent);
+      return identity;
+    }
+
+    let token = result.token;
     if (!token) {
       yield* Console.log(`A login link was sent to ${email}. Paste the token from the email below.`);
       token = yield* Prompt.text({ message: 'Login token' }).pipe(Prompt.run);

package/src/commands/account/logout/logout.ts

@@ -40,6 +40,10 @@ export const logout = Command.make(
         () => Effect.void,
       ),
     );
+    // Recreate the (now empty) data root: the client's SQLite storage opens a file inside it
+    // without creating the directory first, so leaving it absent makes every later command fail
+    // with "unable to open database file" — including the login this logout exists to enable.
+    yield* fs.makeDirectory(path, { recursive: true });
     if (json) {
       yield* Console.log(JSON.stringify({ profile, loggedOut: true }, null, 2));
     } else {

package/src/commands/halo/index.ts

@@ -4,18 +4,22 @@
 
 import * as Command from '@effect/cli/Command';
 
+import { create } from './create';
 import { credential } from './credential';
 import { identity } from './identity';
 import { keys } from './keys';
 import { seed } from './seed';
+import { share } from './share';
 import { update } from './update';
 
 // `create`, `join`, and `recover` are superseded by `dx account login`, which logs in to an
 // existing identity via the same methods as Composer (email / atproto / device-invitation /
 // recovery-code). Note: `join` was omitted and the `device-invitation` login method may hang —
-// both rely on p2p networking which does not work in bun.
+// both rely on p2p networking which does not work in bun. `create` and `share` are registered
+// for the CLI-first pairing flow (CLI hosts the device invitation; the browser joins), which
+// runs over the edge messenger rather than raw p2p.
 
 export const halo: Command.Command<any, any, any, any> = Command.make('halo').pipe(
   Command.withDescription('Manage HALO identity.'),
-  Command.withSubcommands([credential, identity, keys, seed, update]),
+  Command.withSubcommands([create, credential, identity, keys, seed, share, update]),
 );

package/src/commands/halo/share/share.ts

@@ -24,6 +24,13 @@ export const handler = Effect.fn(function* ({
   const { json } = yield* CommandConfig;
   const client = yield* ClientService;
 
+  // Validate up front — an invalid host inside `onConnecting` would abort after the invitation
+  // is already hosted, without printing the codes.
+  yield* Effect.try({
+    try: () => new URL(host),
+    catch: () => new Error(`--host must be an absolute URL: ${host}`),
+  });
+
   // Always use persistent and delegated (auth required) due to P2P limitations
   const observable = client.halo.share({
     authMethod: Invitation.AuthMethod.SHARED_SECRET,
@@ -42,16 +49,20 @@ export const handler = Effect.fn(function* ({
           // Copy auth code to clipboard
           yield* copyToClipboard(authCode).pipe(Effect.catchAll(() => Effect.void));
 
+          const url = new URL(host);
+          url.searchParams.set('deviceInvitationCode', invitationCode);
+
           if (!json) {
             yield* Console.log(`\nSecret: ${authCode} (copied to clipboard)\n`);
+            yield* Console.log(`\nInvitation: ${invitationCode}\n`);
+            // Print the joinable URL even when not opening so it can be pasted manually.
+            yield* Console.log(`\nURL: ${url.toString()}\n`);
           }
 
           if (open) {
-            const url = new URL(host);
-            url.searchParams.append('deviceInvitationCode', invitationCode);
-            yield* openBrowser(url.toString()).pipe(Effect.catchAll(() => Effect.void));
-          } else if (!json) {
-            yield* Console.log(`\nInvitation: ${invitationCode}\n`);
+            yield* openBrowser(url.toString()).pipe(
+              Effect.catchAll(() => Console.error(`Failed to open browser: ${url.toString()}`)),
+            );
           }
         }),
     },

package/src/commands/profile/create.ts

@@ -17,47 +17,30 @@ import { trim } from '@dxos/util';
 
 import { printProfileCreated } from './util';
 
+// `edgeFeatures` must match Composer's defaults (see composer-app/dx.yml): without
+// `signaling: true` the client silently falls back to an isolated in-memory signal manager and
+// device invitations hang at "Connecting…" (host and guest never meet in the swarm).
+const makeTemplate = (edgeUrl: string) => trim`
+  version: 1
+  runtime:
+    client:
+      storage:
+        persistent: true
+      edgeFeatures:
+        signaling: true
+        subductionReplicator: true
+        feedReplicator: true
+        agents: true
+    services:
+      edge:
+        url: ${edgeUrl}
+`;
+
 const TEMPLATES = {
-  default: trim`
-    version: 1
-    runtime:
-      client:
-        storage:
-          persistent: true
-      services:
-        edge:
-          url: https://edge-production.dxos.workers.dev
-  `,
-  main: trim`
-    version: 1
-    runtime:
-      client:
-        storage:
-          persistent: true
-      services:
-        edge:
-          url: https://edge-main.dxos.workers.dev
-  `,
-  dev: trim`
-    version: 1
-    runtime:
-      client:
-        storage:
-          persistent: true
-      services:
-        edge:
-          url: https://edge.dxos.workers.dev
-  `,
-  local: trim`
-    version: 1
-    runtime:
-      client:
-        storage:
-          persistent: true
-      services:
-        edge:
-          url: http://localhost:8787
-  `,
+  default: makeTemplate('https://edge-production.dxos.workers.dev'),
+  main: makeTemplate('https://edge-main.dxos.workers.dev'),
+  dev: makeTemplate('https://edge.dxos.workers.dev'),
+  local: makeTemplate('http://localhost:8787'),
 } as const;
 
 export const create = Command.make(

package/src/containers/AccountContainer/AccountContainer.tsx

@@ -8,8 +8,7 @@ import React, { type FormEvent, useCallback, useState } from 'react';
 import { useCapability, useOperationInvoker } from '@dxos/app-framework/ui';
 import { LayoutOperation } from '@dxos/app-toolkit';
 import { Context } from '@dxos/context';
-import { createDidFromIdentityKey } from '@dxos/credentials';
-import { useIdentity } from '@dxos/react-client/halo';
+import { useIdentity } from '@dxos/halo-react';
 import { Button, Icon, IconButton, Input, Message, useAsyncEffect, useTranslation } from '@dxos/react-ui';
 import { Form } from '@dxos/react-ui-form';
 
@@ -81,7 +80,7 @@ export const AccountContainer = () => {
         return;
       }
       try {
-        const identityDid = identity ? await createDidFromIdentityKey(identity.identityKey) : undefined;
+        const identityDid = identity?.did;
         await hubHttp.requestAccess(new Context(), { email, identityDid });
       } catch {
         // Surface a generic confirmation; failure details would leak signal.
@@ -122,7 +121,7 @@ export const AccountContainer = () => {
               <>
                 <Message.Root valence='warning'>
                   <Message.Title icon='ph--warning--duotone'>{t('no-edge-access.title')}</Message.Title>
-                  <Message.Content>{t('no-edge-access.description')}</Message.Content>
+                  <Message.Body>{t('no-edge-access.description')}</Message.Body>
                 </Message.Root>
                 <Form.Row label={t('request-access.label')} description={t('request-access.description')}>
                   {requestSubmitted ? (
@@ -149,7 +148,7 @@ export const AccountContainer = () => {
             ) : accountState === 'error' && !account ? (
               <Message.Root valence='error'>
                 <Message.Title icon='ph--cloud-x--duotone'>{t('account-offline.title')}</Message.Title>
-                <Message.Content>{t('account-offline.description')}</Message.Content>
+                <Message.Body>{t('account-offline.description')}</Message.Body>
               </Message.Root>
             ) : account ? (
               <>
@@ -181,3 +180,5 @@ export const AccountContainer = () => {
     </Form.Root>
   );
 };
+
+AccountContainer.displayName = 'AccountContainer';

package/src/containers/DevicesContainer/DevicesContainer.tsx

@@ -293,3 +293,5 @@ const InvitationComplete = ({ statusValue }: { statusValue: number }) => {
     <Icon icon='ph--x--regular' size={6} classNames='m-1.5' />
   );
 };
+
+DevicesContainer.displayName = 'DevicesContainer';

package/src/containers/InvitationsContainer/InvitationsContainer.tsx

@@ -138,3 +138,5 @@ const RedeemedInvitationItem = ({ row }: { row: AccountCacheInvitation }) => {
     </Listbox.Item>
   );
 };
+
+InvitationsContainer.displayName = 'InvitationsContainer';

package/src/containers/JoinDialog/JoinDialog.tsx

@@ -54,3 +54,5 @@ export const JoinDialog = (props: JoinPanelProps) => {
     </Dialog.Content>
   );
 };
+
+JoinDialog.displayName = 'JoinDialog';