@dxos/plugin-client 0.9.0 → 0.9.1-staging.ee54ba693a

package/src/containers/UsageContainer/UsageView.tsx

@@ -0,0 +1,270 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import React, { useCallback, useMemo, useState } from 'react';
+
+import { type GetProfileUsageResponse, type MeteringLimit, type MeteringUsageItem } from '@dxos/protocols';
+import { IconButton, Message, Status, ToggleIconButton, useTranslation } from '@dxos/react-ui';
+import { Form, type FormFieldProvider } from '@dxos/react-ui-form';
+import { JsonHighlighter } from '@dxos/react-ui-syntax-highlighter';
+
+import { meta } from '#meta';
+
+export type UsageViewState = 'loading' | 'ready' | 'error' | 'unavailable';
+
+type UsageViewCommonProps = {
+  /** Epoch milliseconds of the last successful fetch. */
+  lastUpdated?: number;
+  /** Invoked when the user requests a refresh. */
+  onRefresh?: () => void;
+};
+
+/**
+ * Discriminated on `state`: the payload is required (and only present) when `state` is `'ready'`, so a
+ * missing payload can't be silently rendered as an empty plan.
+ */
+export type UsageViewProps =
+  | (UsageViewCommonProps & { state: Exclude<UsageViewState, 'ready'>; data?: undefined })
+  | (UsageViewCommonProps & { state: 'ready'; data: GetProfileUsageResponse });
+
+type TFunction = (key: string, options?: Record<string, unknown>) => string;
+
+/**
+ * Whether a usage row falls under a limit. Subtype segments are matched positionally against
+ * `subtypePattern` where `*` matches any segment.
+ */
+const usageMatchesLimit = (item: MeteringUsageItem, limit: MeteringLimit): boolean => {
+  if (item.eventType !== limit.eventType || item.valueKey !== limit.valueKey) {
+    return false;
+  }
+  return limit.subtypePattern.every((pattern, index) => pattern === '*' || pattern === item.subtypePattern[index]);
+};
+
+/** Sum every usage item that falls under the limit. */
+const sumUsageForLimit = (usage: GetProfileUsageResponse['usage'], limit: MeteringLimit): number =>
+  usage.reduce((total, item) => (usageMatchesLimit(item, limit) ? total + item.amount : total), 0);
+
+/** Humanize a camelCase value key, e.g. `outputTokens` → `output tokens`. */
+const formatValueKey = (valueKey: string): string =>
+  valueKey
+    .replace(/([A-Z])/g, ' $1')
+    .trim()
+    .toLowerCase();
+
+/**
+ * Human label for a limit: a scope followed by the value key, e.g.
+ * `{ eventType: 'ai', valueKey: 'outputTokens', subtypePattern: ['*'] }` → `All models · output tokens`,
+ * `{ eventType: 'ai', valueKey: 'inputTokens', subtypePattern: ['claude-opus-4'] }` → `claude-opus-4 · input tokens`.
+ */
+const formatLimitLabel = (limit: MeteringLimit, t: TFunction): string => {
+  const metric = formatValueKey(limit.valueKey);
+  const subtype = limit.subtypePattern.filter((segment) => segment && segment !== '*').join('/');
+  if (limit.eventType === 'ai') {
+    return `${subtype || t('usage-all-models.label')} · ${metric}`;
+  }
+  return `${subtype ? `${limit.eventType}/${subtype}` : limit.eventType} · ${metric}`;
+};
+
+const formatAmount = (amount: number): string => amount.toLocaleString();
+
+const SECONDS_PER_HOUR = 60 * 60;
+
+/** Render `windowHours` as a localized "N months / days / hours" string. */
+const formatWindow = (windowHours: number, t: TFunction): string => {
+  if (windowHours % (24 * 30) === 0) {
+    return t('usage-window-months.label', { count: windowHours / (24 * 30) });
+  }
+  if (windowHours % 24 === 0) {
+    return t('usage-window-days.label', { count: windowHours / 24 });
+  }
+  return t('usage-window-hours.label', { count: windowHours });
+};
+
+type UsageRow = {
+  key: string;
+  /** Field label (schema `title` annotation). */
+  label: string;
+  /** Field caption (schema `description` annotation). */
+  caption: string;
+  /** Consumption as a whole percentage (`0`–`100`); `undefined` for an unlimited limit. */
+  percent?: number;
+  windowHours: number;
+};
+
+/** One display row per limit, shorter windows first. A `null` limit is reported as unlimited. */
+const computeRows = (data: GetProfileUsageResponse, t: TFunction): UsageRow[] =>
+  data.limits
+    .map((limit): UsageRow => {
+      const used = sumUsageForLimit(data.usage, limit);
+      const label = formatLimitLabel(limit, t);
+      const windowHours = limit.windowDuration / SECONDS_PER_HOUR;
+      const window = formatWindow(windowHours, t);
+      const key = `${limit.eventType}/${limit.subtypePattern.join(',')}/${limit.valueKey}/${limit.windowDuration}/${limit.limit ?? 'unlimited'}`;
+      if (limit.limit === null) {
+        return {
+          key,
+          label,
+          caption: t('usage-unlimited.description', { used: formatAmount(used), window }),
+          windowHours,
+        };
+      }
+      const percent = limit.limit > 0 ? Math.min(100, Math.round((used / limit.limit) * 100)) : used > 0 ? 100 : 0;
+      return {
+        key,
+        label,
+        caption: `${t('usage-percent-used.label', { percent })} · ${t('usage-limit.description', { used: formatAmount(used), limit: formatAmount(limit.limit), window })}`,
+        percent,
+        windowHours,
+      };
+    })
+    .sort((left, right) => left.windowHours - right.windowHours);
+
+/**
+ * A single usage field: an optional number carrying its label/caption as `title`/`description`
+ * annotations and the consumption percentage as its value. Optional so the form renders no required
+ * markers; `Schema.Number` keeps the field context-free (`R = never`) so the struct stays assignable to `Form`.
+ */
+const usageField = (title: string, description: string) =>
+  Schema.optional(Schema.Number.annotations({ title, description }));
+
+/**
+ * Build the Effect schema (one annotated field per limit) and matching values. Unlimited limits have no
+ * value, so their field reads `undefined` and the renderer shows the "Unlimited" label instead of a meter.
+ */
+const buildUsageForm = (rows: UsageRow[]) => {
+  const fields: Record<string, ReturnType<typeof usageField>> = {};
+  const values: Record<string, number> = {};
+  rows.forEach((row, index) => {
+    const field = `metric_${index}`;
+    fields[field] = usageField(row.label, row.caption);
+    if (row.percent !== undefined) {
+      values[field] = row.percent;
+    }
+  });
+  return { schema: Schema.Struct(fields), values };
+};
+
+/** Non-data states shown as a single `Message`, keyed by message variant (translation keys for the copy). */
+const STATE_MESSAGES = {
+  unavailable: {
+    valence: 'warning',
+    icon: 'ph--cloud-slash--duotone',
+    title: 'usage-unavailable.title',
+    description: 'usage-unavailable.description',
+  },
+  error: {
+    valence: 'error',
+    icon: 'ph--cloud-x--duotone',
+    title: 'usage-offline.title',
+    description: 'usage-offline.description',
+  },
+  empty: {
+    valence: 'neutral',
+    icon: 'ph--chart-bar--duotone',
+    title: 'usage-empty.title',
+    description: 'usage-empty.description',
+  },
+} as const;
+
+/**
+ * Presentational view of profile usage: renders loading/error/unavailable/empty states, or a
+ * schema-driven settings form (one read-only field per limit), plus a refresh control and a
+ * collapsible raw-response viewer. Pure — all data via props.
+ */
+export const UsageView = ({ state, data, lastUpdated, onRefresh }: UsageViewProps) => {
+  const { t } = useTranslation(meta.profile.key);
+  const [rawExpanded, setRawExpanded] = useState(false);
+
+  const { schema, values, empty } = useMemo(() => {
+    const rows = data ? computeRows(data, t) : [];
+    return { ...buildUsageForm(rows), empty: rows.length === 0 };
+  }, [data, t]);
+
+  // Non-data states resolve to a `Message`; `loading` shows a spinner and `ready` with data shows the form.
+  const message =
+    state === 'unavailable'
+      ? STATE_MESSAGES.unavailable
+      : state === 'error'
+        ? STATE_MESSAGES.error
+        : state === 'ready' && empty
+          ? STATE_MESSAGES.empty
+          : undefined;
+
+  // Render each metric as a meter from its percentage value; unlimited limits (no value) show a label.
+  const meterFieldProvider = useCallback<FormFieldProvider>(
+    ({ fieldProps: { label, description, getValue } }) => {
+      const percent = getValue();
+      return (
+        <Form.Row label={label} description={description}>
+          {typeof percent === 'number' ? (
+            <Status progress={percent / 100} aria-label={t('usage-percent-used.label', { percent })} />
+          ) : (
+            t('usage-unlimited.label')
+          )}
+        </Form.Row>
+      );
+    },
+    [t],
+  );
+
+  return (
+    <Form.Root variant='settings' layout='static' schema={schema} values={values}>
+      <Form.Viewport scroll>
+        <Form.Content>
+          <Form.Section title={t('usage-section.title')} description={t('usage-section.description')}>
+            {state === 'loading' ? (
+              <Status indeterminate aria-label={t('usage-section.title')} />
+            ) : message ? (
+              <Message.Root valence={message.valence}>
+                <Message.Title icon={message.icon}>{t(message.title)}</Message.Title>
+                <Message.Content>{t(message.description)}</Message.Content>
+              </Message.Root>
+            ) : (
+              <Form.FieldSet fieldProvider={meterFieldProvider} />
+            )}
+          </Form.Section>
+
+          {state === 'ready' && data && (
+            <Form.Section>
+              <Form.Row
+                label={
+                  lastUpdated !== undefined
+                    ? t('usage-last-updated.label', { time: new Date(lastUpdated).toLocaleTimeString() })
+                    : t('usage-refresh.label')
+                }
+              >
+                {onRefresh && (
+                  <IconButton
+                    iconOnly
+                    variant='ghost'
+                    icon='ph--arrow-clockwise--regular'
+                    label={t('usage-refresh.label')}
+                    onClick={onRefresh}
+                  />
+                )}
+              </Form.Row>
+            </Form.Section>
+          )}
+
+          {state === 'ready' && data && (
+            <Form.Section>
+              <Form.Row label={t('usage-raw-json.label')}>
+                <ToggleIconButton
+                  iconOnly
+                  variant='ghost'
+                  active={rawExpanded}
+                  icon='ph--caret-right--regular'
+                  label={t('usage-raw-json.label')}
+                  onClick={() => setRawExpanded((value) => !value)}
+                />
+              </Form.Row>
+              {rawExpanded && <JsonHighlighter data={data} testId='usage-raw-json' />}
+            </Form.Section>
+          )}
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
+  );
+};

package/src/containers/UsageContainer/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { UsageContainer as default } from './UsageContainer';

package/src/containers/index.ts

@@ -10,6 +10,7 @@ export { type ResetDialogProps } from './ResetDialog';
 export const AccountContainer: ComponentType<any> = lazy(() => import('./AccountContainer'));
 export const DevicesContainer: ComponentType<any> = lazy(() => import('./DevicesContainer'));
 export const InvitationsContainer: ComponentType<any> = lazy(() => import('./InvitationsContainer'));
+export const UsageContainer: ComponentType<any> = lazy(() => import('./UsageContainer'));
 export const JoinDialog: ComponentType<any> = lazy(() => import('./JoinDialog'));
 export const ProfileContainer: ComponentType<any> = lazy(() => import('./ProfileContainer'));
 export const RecoveryCodeDialog: ComponentType<any> = lazy(() => import('./RecoveryCodeDialog'));

package/src/hooks/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './useHubClient';

package/src/meta.ts

@@ -3,16 +3,7 @@
 //
 
 import { Plugin } from '@dxos/app-framework';
-import { DXN } from '@dxos/keys';
-import { trim } from '@dxos/util';
 
-export const meta = Plugin.makeMeta({
-  key: DXN.make('org.dxos.plugin.client'),
-  name: 'Client',
-  author: 'DXOS',
-  description: trim`
-    Core client connectivity and peer-to-peer networking infrastructure.
-    Manages identity, authentication, and real-time synchronization across devices.
-  `,
-  tags: ['system'],
-});
+import config from '../dx.config';
+
+export const meta = Plugin.getMetaFromConfig(config);

package/src/operations/create-passkey.ts

@@ -6,7 +6,7 @@ import * as Effect from 'effect/Effect';
 import * as Match from 'effect/Match';
 
 import { Capability } from '@dxos/app-framework';
-import { supportsNativePasskeys, createNativePasskey, extractPublicKeyFromAttestation } from '@dxos/app-toolkit';
+import { NativePasskey } from '@dxos/app-toolkit';
 import { PublicKey } from '@dxos/client';
 import { Operation } from '@dxos/compute';
 import { invariant } from '@dxos/invariant';
@@ -23,16 +23,18 @@ const handler: Operation.WithHandler<typeof CreatePasskey> = CreatePasskey.pipe(
 
       const lookupKey = PublicKey.random();
 
-      const { recoveryKey, algorithm } = yield* Match.value(supportsNativePasskeys()).pipe(
+      const { recoveryKey, algorithm } = yield* Match.value(NativePasskey.supportsNativePasskeys()).pipe(
         Match.when(true, () =>
           Effect.gen(function* () {
             const result = yield* Effect.promise(() =>
-              createNativePasskey({
+              NativePasskey.createNativePasskey({
                 username: identity.did,
                 userId: lookupKey.asUint8Array(),
               }),
             );
-            const { publicKey, algorithm: alg } = extractPublicKeyFromAttestation(result.attestation_object);
+            const { publicKey, algorithm: alg } = NativePasskey.extractPublicKeyFromAttestation(
+              result.attestation_object,
+            );
             return {
               recoveryKey: PublicKey.from(publicKey),
               algorithm: alg === -7 ? 'ES256' : 'ED25519',

package/src/operations/definitions.ts

@@ -10,7 +10,7 @@ import { DXN, IdentityDid, SpaceId } from '@dxos/keys';
 
 import { meta } from '#meta';
 
-const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
+const makeKey = (name: string) => DXN.make(`${meta.profile.key}.operation.${name}`);
 
 const IdentitySchema = Schema.Struct({
   identityDid: IdentityDid,
@@ -57,6 +57,17 @@ export const ShareIdentity = Operation.make({
   output: Schema.Void,
 });
 
+export const OpenUsage = Operation.make({
+  meta: {
+    key: makeKey('openUsage'),
+    name: 'Open Usage',
+    icon: 'ph--chart-bar--regular',
+  },
+  services: [Capability.Service],
+  input: Schema.Void,
+  output: Schema.Void,
+});
+
 export const RecoverIdentity = Operation.make({
   meta: { key: makeKey('recoverIdentity'), name: 'Recover Identity', icon: 'ph--key--regular' },
   services: [Capability.Service],

package/src/operations/index.ts

@@ -12,6 +12,7 @@ export const ClientOperationHandlerSet = OperationHandlerSet.lazy(
   () => import('./create-passkey'),
   () => import('./create-recovery-code'),
   () => import('./join-identity'),
+  () => import('./open-usage'),
   () => import('./recover-identity'),
   () => import('./redeem-passkey'),
   () => import('./redeem-token'),

package/src/operations/open-usage.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { LayoutOperation, Paths } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
+
+import { Account } from '../types';
+import { OpenUsage } from './definitions';
+
+const handler: Operation.WithHandler<typeof OpenUsage> = OpenUsage.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* () {
+      yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: Paths.getSpacePath(Account.id) });
+      yield* Operation.invoke(LayoutOperation.Open, {
+        subject: [Paths.getSpacePath(Account.id, Account.Usage)],
+      });
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/redeem-passkey.ts

@@ -6,7 +6,7 @@ import * as Effect from 'effect/Effect';
 import * as Match from 'effect/Match';
 
 import { Capability } from '@dxos/app-framework';
-import { decodeUrlSafeBase64, supportsNativePasskeys, loginNativePasskey } from '@dxos/app-toolkit';
+import { NativePasskey } from '@dxos/app-toolkit';
 import { PublicKey } from '@dxos/client';
 import { Operation } from '@dxos/compute';
 import { invariant } from '@dxos/invariant';
@@ -24,19 +24,19 @@ const handler: Operation.WithHandler<typeof RedeemPasskey> = RedeemPasskey.pipe(
       );
 
       const { lookupKey, signature, clientDataJson, authenticatorData } = yield* Match.value(
-        supportsNativePasskeys(),
+        NativePasskey.supportsNativePasskeys(),
       ).pipe(
         Match.when(true, () =>
           Effect.gen(function* () {
             const result = yield* Effect.promise(() =>
-              loginNativePasskey({ challenge: Uint8Array.from(Buffer.from(challenge, 'base64')) }),
+              NativePasskey.loginNativePasskey({ challenge: Uint8Array.from(Buffer.from(challenge, 'base64')) }),
             );
             invariant(result, 'Native passkey login returned no result');
             return {
-              lookupKey: PublicKey.from(decodeUrlSafeBase64(result.user_handle)),
-              signature: Buffer.from(decodeUrlSafeBase64(result.signature)),
-              clientDataJson: Buffer.from(decodeUrlSafeBase64(result.client_data_json)),
-              authenticatorData: Buffer.from(decodeUrlSafeBase64(result.authenticator_data)),
+              lookupKey: PublicKey.from(NativePasskey.decodeUrlSafeBase64(result.user_handle)),
+              signature: Buffer.from(NativePasskey.decodeUrlSafeBase64(result.signature)),
+              clientDataJson: Buffer.from(NativePasskey.decodeUrlSafeBase64(result.client_data_json)),
+              authenticatorData: Buffer.from(NativePasskey.decodeUrlSafeBase64(result.authenticator_data)),
             };
           }),
         ),

package/src/operations/share-identity.ts

@@ -4,7 +4,7 @@
 
 import * as Effect from 'effect/Effect';
 
-import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { LayoutOperation, Paths } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
 import { ObservabilityOperation } from '@dxos/plugin-observability';
 
@@ -14,9 +14,9 @@ import { ShareIdentity } from './definitions';
 const handler: Operation.WithHandler<typeof ShareIdentity> = ShareIdentity.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* () {
-      yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: getSpacePath(Account.id) });
+      yield* Operation.invoke(LayoutOperation.SwitchWorkspace, { subject: Paths.getSpacePath(Account.id) });
       yield* Operation.invoke(LayoutOperation.Open, {
-        subject: [`${getSpacePath(Account.id)}/${Account.Profile}`],
+        subject: [Paths.getSpacePath(Account.id, Account.Profile)],
       });
       yield* Operation.schedule(ObservabilityOperation.SendEvent, { name: 'identity.share' });
     }),

package/src/testing/initializeIdentity.ts

@@ -4,13 +4,14 @@
 
 import * as Effect from 'effect/Effect';
 
-import { PERSONAL_SPACE_TAG } from '@dxos/app-toolkit';
+import { AppSpace } from '@dxos/app-toolkit';
 import { type Client } from '@dxos/client';
 import { type Space } from '@dxos/client-protocol';
 import { type Identity } from '@dxos/protocols/proto/dxos/client/services';
 
 export type InitializeIdentityResult = {
   identity: Identity;
+  // TODO(burdon): Rename to space.
   personalSpace: Space;
 };
 
@@ -21,7 +22,9 @@ export type InitializeIdentityResult = {
 export const initializeIdentity = (client: Client): Effect.Effect<InitializeIdentityResult, never, never> =>
   Effect.gen(function* () {
     const identity = yield* Effect.promise(() => client.halo.createIdentity());
-    const personalSpace = yield* Effect.promise(() => client.spaces.create({}, { tags: [PERSONAL_SPACE_TAG] }));
+    const personalSpace = yield* Effect.promise(() =>
+      client.spaces.create({}, { tags: [AppSpace.PERSONAL_SPACE_TAG] }),
+    );
     yield* Effect.promise(() => personalSpace.waitUntilReady());
     return {
       identity,

package/src/translations.ts

@@ -11,7 +11,7 @@ import { meta } from '#meta';
 const pluginTranslations = [
   {
     'en-US': {
-      [meta.id]: {
+      [meta.profile.key]: {
         'account.label': 'User profile',
         'profile.label': 'Profile',
         'profile.description': 'User profile and account settings.',
@@ -27,6 +27,30 @@ const pluginTranslations = [
         'security.label': 'Security',
         'account-panel.label': 'Account',
         'invitations-panel.label': 'Invitations',
+        'usage-panel.label': 'Usage',
+        'usage-section.title': 'Usage',
+        'usage-section.description':
+          'Rolling-window consumption against your plan limits for edge services such as AI inference.',
+        'usage-unavailable.title': 'Usage unavailable',
+        'usage-unavailable.description': 'Hub service is not configured, so usage data cannot be loaded.',
+        'usage-offline.title': 'Couldn’t load usage',
+        'usage-offline.description': 'Reconnect and reopen this panel to refresh usage and limits.',
+        'usage-empty.title': 'No usage recorded',
+        'usage-empty.description': 'Usage will appear here once you start using metered edge services.',
+        'usage-limit.description': '{{used}} of {{limit}} in the last {{window}}',
+        'usage-window-hours.label_one': '{{count}} hour',
+        'usage-window-hours.label_other': '{{count}} hours',
+        'usage-window-days.label_one': '{{count}} day',
+        'usage-window-days.label_other': '{{count}} days',
+        'usage-window-months.label_one': '{{count}} month',
+        'usage-window-months.label_other': '{{count}} months',
+        'usage-percent-used.label': '{{percent}}% used',
+        'usage-all-models.label': 'All models',
+        'usage-unlimited.label': 'Unlimited',
+        'usage-unlimited.description': '{{used}} used in the last {{window}}',
+        'usage-last-updated.label': 'Last updated {{time}}',
+        'usage-refresh.label': 'Refresh',
+        'usage-raw-json.label': 'Raw JSON',
         'account-section.title': 'Account',
         'account-section.description':
           'Your identity on this device is bound to a DXOS account that gates access to edge services like sync, agents, and AI.',

package/src/types/capabilities.ts

@@ -12,12 +12,14 @@ import { type HubHttpClient } from '@dxos/edge-client';
 
 import { meta } from '#meta';
 
-import { type AccountCache as AccountCacheType } from '../state/account-cache';
+import { type AccountCache as AccountCacheType } from './account-cache';
 
 export namespace ClientCapabilities {
-  export const Client = Capability.make<Client>(`${meta.id}.capability.client`);
-  export const Schema = Capability.make<Type.AnyEntity[]>(`${meta.id}.capability.schema`);
-  export const Migration = Capability.make<ObjectMigration[]>(`${meta.id}.capability.migration`);
-  export const AccountCache = Capability.make<Atom.Writable<AccountCacheType>>(`${meta.id}.capability.accountCache`);
-  export const HubHttpClient = Capability.make<HubHttpClient>(`${meta.id}.capability.hubHttpClient`);
+  export const Client = Capability.make<Client>(`${meta.profile.key}.capability.client`);
+  export const Schema = Capability.make<Type.AnyEntity[]>(`${meta.profile.key}.capability.schema`);
+  export const Migration = Capability.make<ObjectMigration[]>(`${meta.profile.key}.capability.migration`);
+  export const AccountCache = Capability.make<Atom.Writable<AccountCacheType>>(
+    `${meta.profile.key}.capability.accountCache`,
+  );
+  export const HubHttpClient = Capability.make<HubHttpClient>(`${meta.profile.key}.capability.hubHttpClient`);
 }

package/src/types/events.ts

@@ -7,9 +7,9 @@ import { ActivationEvent } from '@dxos/app-framework';
 import { meta } from '#meta';
 
 export namespace ClientEvents {
-  export const ClientReady = ActivationEvent.make(`${meta.id}.event.client-ready`);
-  export const SetupSchema = ActivationEvent.make(`${meta.id}.event.setup-schema`);
-  export const SetupMigration = ActivationEvent.make(`${meta.id}.event.setup-migration`);
-  export const IdentityCreated = ActivationEvent.make(`${meta.id}.event.identity-created`);
-  export const SpacesReady = ActivationEvent.make(`${meta.id}.event.spaces-ready`);
+  export const ClientReady = ActivationEvent.make(`${meta.profile.key}.event.clientReady`);
+  export const SetupSchema = ActivationEvent.make(`${meta.profile.key}.event.setupSchema`);
+  export const SetupMigration = ActivationEvent.make(`${meta.profile.key}.event.setupMigration`);
+  export const IdentityCreated = ActivationEvent.make(`${meta.profile.key}.event.identityCreated`);
+  export const SpacesReady = ActivationEvent.make(`${meta.profile.key}.event.spacesReady`);
 }

package/src/types/index.ts

@@ -2,6 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './account-cache';
 export * from './capabilities';
 export * from './events';
 export * from './schema';