@dxos/plugin-space 0.8.1-main.ae460ac → 0.8.1-staging.31c3ee1

package/src/capabilities/schema-tool.test.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it, expect } from 'vitest';
+
+import { S } from '@dxos/echo-schema';
+
+import { TypeNameSchema } from './schema-tools';
+
+describe('TypeNameSchema format', () => {
+  const valid = [
+    'example.com/usCities',
+    'dxos.org/Contact',
+    'dxos.org/Table',
+    'dxos.org/Table/Contact',
+    'dxos.org/PluginName/TypeName',
+    // Case variations
+    'DXOS.org/Table',
+    'dxos.ORG/table',
+  ];
+
+  const invalid = [
+    'http://dxos.org/Table', // No protocol allowed
+    'dxos.org/', // Must have type path
+    // TODO(dmaretskyi): Decide if we want to ban numbers.
+    // 'dxos.org/1Type', // Path segments must start with letter
+    'dxos.org/Type!', // Invalid character
+    '.org/Type', // Must have domain
+  ];
+
+  const validate = S.validateSync(TypeNameSchema);
+
+  valid.forEach((typename) => {
+    it(`should accept valid typename: ${typename}`, () => {
+      expect(() => validate(typename)).not.toThrow();
+    });
+  });
+
+  invalid.forEach((typename) => {
+    it(`should reject invalid typename: ${typename}`, () => {
+      expect(() => validate(typename)).toThrow();
+    });
+  });
+});

package/src/capabilities/schema-tools.ts

@@ -0,0 +1,124 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { DescriptionAnnotationId, ExamplesAnnotationId, TitleAnnotationId } from 'effect/SchemaAST';
+
+import { Capabilities, contributes, type PromiseIntentDispatcher } from '@dxos/app-framework';
+import { defineTool, ToolResult } from '@dxos/artifact';
+import { type Space } from '@dxos/client/echo';
+import { FormatEnum, FormatEnums, S, SelectOptionSchema, GeoPoint, toJsonSchema } from '@dxos/echo-schema';
+import { invariant } from '@dxos/invariant';
+import { hues } from '@dxos/react-ui-theme';
+import { getSchemaFromPropertyDefinitions } from '@dxos/schema';
+
+// TODO(burdon): Factor out.
+declare global {
+  interface ToolContextExtensions {
+    space?: Space;
+    dispatch?: PromiseIntentDispatcher;
+  }
+}
+
+// TODO(ZaymonFC): Move this somewhere common.
+export const TypeNameSchema = S.String.pipe(
+  S.pattern(/^\w+\.\w{2,}\/[\w/]+$/i),
+  S.annotations({
+    [TitleAnnotationId]: 'TypeName',
+    [DescriptionAnnotationId]:
+      'Domain-style type name path. Dashes are not allowed. Use camel case for the final component of the type name.',
+    [ExamplesAnnotationId]: ['example.com/type/Document', 'example.com/type/FlightList'],
+  }),
+);
+
+const formatDescription = `The format of the property. Additional information:
+  ${FormatEnum.GeoPoint}: ${JSON.stringify(toJsonSchema(GeoPoint))}
+  This tuple is GeoJSON. You must specify \`${FormatEnum.GeoPoint}\` as [Longitude, Latitude]`;
+
+// TODO(ZaymonFC): All properties are default optional, but maybe we should allow for required properties.
+const PropertyDefinitionSchema = S.Struct({
+  name: S.String.annotations({ [DescriptionAnnotationId]: 'The name of the property.' }),
+  format: S.Union(...FormatEnums.map((format) => S.Literal(format))).annotations({
+    [DescriptionAnnotationId]: formatDescription,
+  }),
+  config: S.optional(
+    S.Struct({
+      options: S.optional(
+        S.Array(SelectOptionSchema)
+          .annotations({
+            description: `Options for SingleSelect/MultiSelect formats. Available colors: ${hues.join(', ')}`,
+          })
+          .pipe(S.mutable),
+      ),
+    }),
+  ),
+}).pipe(S.mutable);
+
+const SYSTEM_NAMESPACE = 'dxos.org/echo/schema';
+
+export default () =>
+  contributes(Capabilities.Tools, [
+    defineTool(SYSTEM_NAMESPACE, {
+      name: 'list',
+      description: 'List registered schemas in the space.',
+      caption: 'Listing registered schemas...',
+      schema: S.Struct({}),
+      execute: async (_input, { extensions }) => {
+        invariant(extensions?.space, 'No space.');
+        const space = extensions.space;
+
+        const schemas = await space.db.schemaRegistry.query({}).run();
+        return ToolResult.Success(
+          schemas.map((schema) => ({
+            typename: schema.typename,
+            version: schema.version,
+          })),
+        );
+      },
+    }),
+    defineTool(SYSTEM_NAMESPACE, {
+      name: 'get',
+      description: 'Get a specific schema by its typename.',
+      caption: 'Getting schema...',
+      schema: S.Struct({
+        typename: S.String.annotations({
+          description: 'The fully qualified typename of the schema.',
+        }),
+      }),
+      execute: async ({ typename }, { extensions }) => {
+        invariant(extensions?.space, 'No space.');
+        const space = extensions.space;
+
+        const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
+        if (!schema) {
+          return ToolResult.Error(`Schema not found: ${typename}`);
+        }
+
+        return ToolResult.Success(schema);
+      },
+    }),
+    defineTool(SYSTEM_NAMESPACE, {
+      name: 'create',
+      description: 'Create a new schema with the provided definition.',
+      caption: 'Creating schema...',
+      schema: S.Struct({
+        typename: TypeNameSchema.annotations({
+          description:
+            'The fully qualified schema typename. Must start with a domain, and then one or more path components (e.g., "example.com/type/TypeName").',
+        }),
+        properties: S.Array(PropertyDefinitionSchema).pipe(
+          S.annotations({ description: 'Array of property definitions for the schema.' }),
+          S.mutable,
+        ),
+      }),
+      execute: async ({ typename, properties }, { extensions }) => {
+        invariant(extensions?.space, 'No space.');
+        const space = extensions.space;
+
+        const schema = getSchemaFromPropertyDefinitions(typename, properties);
+        const [registeredSchema] = await space.db.schemaRegistry.register([schema]);
+
+        return ToolResult.Success(registeredSchema);
+      },
+    }),
+  ]);

package/src/capabilities/spaces-ready.ts

@@ -3,7 +3,7 @@
 //
 
 import { contributes, createIntent, type PluginsContext, Capabilities, LayoutAction } from '@dxos/app-framework';
-import { EventSubscriptions } from '@dxos/async';
+import { SubscriptionList } from '@dxos/async';
 import { Expando } from '@dxos/echo-schema';
 import { scheduledEffect } from '@dxos/echo-signals/core';
 import { create } from '@dxos/live-object';
@@ -24,8 +24,8 @@ const ACTIVE_NODE_BROADCAST_INTERVAL = 30_000;
 const WAIT_FOR_OBJECT_TIMEOUT = 1000;
 
 export default async (context: PluginsContext) => {
-  const subscriptions = new EventSubscriptions();
-  const spaceSubscriptions = new EventSubscriptions();
+  const subscriptions = new SubscriptionList();
+  const spaceSubscriptions = new SubscriptionList();
 
   const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
   const { graph } = context.requestCapability(Capabilities.AppGraph);

package/src/capabilities/state.ts

@@ -14,9 +14,11 @@ import { SPACE_PLUGIN } from '../meta';
 import { type PluginState } from '../types';
 
 export default (context: PluginsContext) => {
+  const sections = context.requestCapabilities(SpaceCapabilities.SettingsSection);
   const state = new LocalStorageStore<PluginState>(SPACE_PLUGIN, {
     awaiting: undefined,
     spaceNames: {},
+    spaceSettingsOpenSections: sections.map((section) => section.id),
     viewersByObject: {},
     // TODO(wittjosiah): Stop using (Complex)Map inside reactive object.
     viewersByIdentity: new ComplexMap(PublicKey.hash),

package/src/components/CreateDialog/CreateObjectDialog.tsx

@@ -22,7 +22,7 @@ import { Button, Dialog, Icon, useTranslation } from '@dxos/react-ui';
 import { CreateObjectPanel, type CreateObjectPanelProps } from './CreateObjectPanel';
 import { SpaceCapabilities } from '../../capabilities';
 import { SPACE_PLUGIN } from '../../meta';
-import { CollectionType, type ObjectForm, SpaceAction } from '../../types';
+import { type ObjectForm, SpaceAction } from '../../types';
 
 export const CREATE_OBJECT_DIALOG = `${SPACE_PLUGIN}/CreateObjectDialog`;
 
@@ -53,16 +53,13 @@ export const CreateObjectDialog = ({
   const handleCreateObject = useCallback(
     async ({
       form,
-      target: _target,
+      target,
       data = {},
     }: {
       form: ObjectForm;
       target: CreateObjectPanelProps['target'];
       data?: Record<string, any>;
     }) => {
-      const target = isSpace(_target)
-        ? (_target.properties[CollectionType.typename]?.target as CollectionType | undefined)
-        : _target;
       if (!target) {
         // TODO(wittjosiah): UI feedback.
         return;
@@ -76,7 +73,7 @@ export const CreateObjectDialog = ({
       const result = await dispatch(form.getIntent(data, { space }));
       const object = result.data?.object;
       if (isReactiveObject(object)) {
-        const addObjectIntent = createIntent(SpaceAction.AddObject, { target, object });
+        const addObjectIntent = createIntent(SpaceAction.AddObject, { target, object, hidden: form.hidden });
         const shouldNavigate = _shouldNavigate ?? (() => true);
         if (shouldNavigate(object)) {
           await dispatch(pipe(addObjectIntent, chain(LayoutAction.Open, { part: 'main' })));

package/src/components/CreateDialog/CreateObjectPanel.tsx

@@ -5,7 +5,7 @@
 import React, { useCallback, useState } from 'react';
 
 import { Surface, isSurfaceAvailable, usePluginManager } from '@dxos/app-framework';
-import { getObjectAnnotation, type ObjectAnnotation, type S } from '@dxos/echo-schema';
+import { getTypeAnnotation, type TypeAnnotation, type S } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { type SpaceId, type Space } from '@dxos/react-client/echo';
 import { Icon, type ThemedClassName, toLocalizedString, useTranslation } from '@dxos/react-ui';
@@ -69,9 +69,9 @@ export const CreateObjectPanel = ({
   const { t } = useTranslation(SPACE_PLUGIN);
   const [typename, setTypename] = useState<string | undefined>(initialTypename);
   const [target, setTarget] = useState<Space | CollectionType | undefined>(initialTarget);
-  const form = forms.find((form) => getObjectAnnotation(form.objectSchema)?.typename === typename);
-  const options: ObjectAnnotation[] = forms
-    .map((form) => getObjectAnnotation(form.objectSchema))
+  const form = forms.find((form) => getTypeAnnotation(form.objectSchema)?.typename === typename);
+  const options: TypeAnnotation[] = forms
+    .map((form) => getTypeAnnotation(form.objectSchema))
     .filter(isNonNullable)
     .sort((a, b) => {
       const nameA = t('typename label', { ns: a.typename, defaultValue: a.typename });
@@ -92,7 +92,7 @@ export const CreateObjectPanel = ({
   const handleSetTypename = useCallback(
     async (typename: string) => {
       invariant(target, 'target is required');
-      const form = forms.find((form) => getObjectAnnotation(form.objectSchema)?.typename === typename);
+      const form = forms.find((form) => getTypeAnnotation(form.objectSchema)?.typename === typename);
       if (form && !form.formSchema) {
         await onCreateObject?.({ form, target });
       } else {
@@ -170,7 +170,7 @@ const SelectSchema = ({
   resolve,
   onChange,
 }: {
-  options: ObjectAnnotation[];
+  options: TypeAnnotation[];
   onChange: (type: string) => void;
 } & Pick<CreateObjectPanelProps, 'resolve'>) => {
   const { t } = useTranslation(SPACE_PLUGIN);

package/src/components/JoinDialog.tsx

@@ -5,9 +5,10 @@
 import React, { useCallback } from 'react';
 
 import { createIntent, LayoutAction, useAppGraph, useIntentDispatcher } from '@dxos/app-framework';
-import { log } from '@dxos/log';
+import { Trigger } from '@dxos/async';
 import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { useClient } from '@dxos/react-client';
+import { type Space } from '@dxos/react-client/echo';
 import { type InvitationResult } from '@dxos/react-client/invitations';
 import { Dialog, useTranslation } from '@dxos/react-ui';
 import { JoinPanel, type JoinPanelProps } from '@dxos/shell/react';
@@ -28,34 +29,44 @@ export const JoinDialog = ({ navigableCollections, onDone, ...props }: JoinDialo
 
   const handleDone = useCallback(
     async (result: InvitationResult | null) => {
-      if (result?.spaceKey) {
-        await Promise.all([
-          dispatch(
-            createIntent(LayoutAction.AddToast, {
-              part: 'toast',
-              subject: {
-                id: `${SPACE_PLUGIN}/join-success`,
-                duration: 5_000,
-                title: ['join success label', { ns: SPACE_PLUGIN }],
-                closeLabel: ['dismiss label', { ns: SPACE_PLUGIN }],
-              },
-            }),
-          ),
-          dispatch(
-            createIntent(LayoutAction.UpdateDialog, {
-              part: 'dialog',
-              options: {
-                state: false,
-              },
-            }),
-          ),
-        ]);
+      const spaceKey = result?.spaceKey;
+      if (!spaceKey) {
+        return;
       }
 
-      const space = result?.spaceKey ? client.spaces.get(result.spaceKey) : undefined;
+      await Promise.all([
+        dispatch(
+          createIntent(LayoutAction.AddToast, {
+            part: 'toast',
+            subject: {
+              id: `${SPACE_PLUGIN}/join-success`,
+              duration: 5_000,
+              title: ['join success label', { ns: SPACE_PLUGIN }],
+              closeLabel: ['dismiss label', { ns: SPACE_PLUGIN }],
+            },
+          }),
+        ),
+        dispatch(
+          createIntent(LayoutAction.UpdateDialog, {
+            part: 'dialog',
+            options: {
+              state: false,
+            },
+          }),
+        ),
+      ]);
+
+      let space = client.spaces.get(spaceKey);
       if (!space) {
-        log.warn('Space not found', result?.spaceKey);
-        return;
+        // TODO(wittjosiah): Add api to wait for a space.
+        const trigger = new Trigger<Space>();
+        client.spaces.subscribe(() => {
+          const space = client.spaces.get(spaceKey);
+          if (space) {
+            trigger.wake(space);
+          }
+        });
+        space = await trigger.wait();
       }
 
       await dispatch(createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: space.id }));
@@ -78,7 +89,12 @@ export const JoinDialog = ({ navigableCollections, onDone, ...props }: JoinDialo
 
       if (space) {
         await dispatch(
-          createIntent(ObservabilityAction.SendEvent, { name: 'space.join', properties: { spaceId: space.id } }),
+          createIntent(ObservabilityAction.SendEvent, {
+            name: 'space.join',
+            properties: {
+              spaceId: space.id,
+            },
+          }),
         );
       }
     },

package/src/components/MembersContainer.stories.tsx

@@ -0,0 +1,34 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { type StoryObj, type Meta } from '@storybook/react';
+
+import { withClientProvider } from '@dxos/react-client/testing';
+import { osTranslations } from '@dxos/shell/react';
+import { withTheme, withLayout } from '@dxos/storybook-utils';
+
+import { MembersContainer } from './MembersContainer';
+import translations from '../translations';
+
+const meta: Meta = {
+  title: 'plugins/plugin-space/MembersContainer',
+  component: MembersContainer,
+  decorators: [
+    withClientProvider({ createIdentity: true, createSpace: true }),
+    withTheme,
+    withLayout({ tooltips: true }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations: [...translations, osTranslations],
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof MembersContainer>;
+
+export const Default: Story = {};

package/src/components/MembersContainer.tsx

@@ -0,0 +1,255 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Check, X } from '@phosphor-icons/react';
+import React, { type Dispatch, type SetStateAction, useMemo, useState } from 'react';
+import { QR } from 'react-qr-rounded';
+
+import { log } from '@dxos/log';
+import { useConfig } from '@dxos/react-client';
+import { fullyQualifiedId, useSpaceInvitations, type Space } from '@dxos/react-client/echo';
+import { type CancellableInvitationObservable, Invitation, InvitationEncoder } from '@dxos/react-client/invitations';
+import { Button, Clipboard, Icon, useId, useTranslation } from '@dxos/react-ui';
+import { ControlSection, ControlFrame, ControlFrameItem } from '@dxos/react-ui-form';
+import { StackItem } from '@dxos/react-ui-stack';
+import { getSize, mx } from '@dxos/react-ui-theme';
+import {
+  type ActionMenuItem,
+  AuthCode,
+  BifurcatedAction,
+  Centered,
+  Emoji,
+  InvitationList,
+  SpaceMemberList,
+  Viewport,
+} from '@dxos/shell/react';
+import { hexToEmoji } from '@dxos/util';
+
+import { SPACE_PLUGIN } from '../meta';
+import { CollectionType } from '../types';
+
+// TODO(wittjosiah): Copied from Shell.
+const activeActionKey = 'dxos:react-shell/space-manager/active-action';
+
+const handleInvitationEvent = (invitation: Invitation, subscription: ZenObservable.Subscription) => {
+  const invitationCode = InvitationEncoder.encode(invitation);
+  if (invitation.state === Invitation.State.CONNECTING) {
+    log.info(JSON.stringify({ invitationCode, authCode: invitation.authCode }));
+    subscription.unsubscribe();
+  }
+};
+
+export const MembersContainer = ({
+  space,
+  createInvitationUrl,
+}: {
+  space: Space;
+  createInvitationUrl: (invitationCode: string) => string;
+}) => {
+  const { t } = useTranslation('os');
+  const config = useConfig();
+  const invitations = useSpaceInvitations(space.key);
+  const visibleInvitations = invitations?.filter(
+    (invitation) => ![Invitation.State.CANCELLED].includes(invitation.get().state),
+  );
+
+  const [activeAction, setInternalActiveAction] = useState(localStorage.getItem(activeActionKey) ?? 'inviteMany');
+
+  const setActiveAction = (nextAction: string) => {
+    setInternalActiveAction(nextAction);
+    localStorage.setItem(activeActionKey, nextAction);
+  };
+
+  // TODO(wittjosiah): Track which was the most recently viewed object.
+  const target = space.properties[CollectionType.typename]?.target?.objects[0]?.target;
+
+  const inviteActions = useMemo(
+    (): Record<string, ActionMenuItem> => ({
+      inviteOne: {
+        label: t('invite one label'),
+        description: t('invite one description'),
+        icon: () => <Icon icon='ph--user-plus--regular' size={5} />,
+        testId: 'membersContainer.inviteOne',
+        onClick: () => {
+          const invitation = space.share?.({
+            type: Invitation.Type.INTERACTIVE,
+            authMethod: Invitation.AuthMethod.SHARED_SECRET,
+            multiUse: false,
+            target: target && fullyQualifiedId(target),
+          });
+          if (invitation && config.values.runtime?.app?.env?.DX_ENVIRONMENT !== 'production') {
+            const subscription: ZenObservable.Subscription = invitation.subscribe((invitation) =>
+              handleInvitationEvent(invitation, subscription),
+            );
+          }
+        },
+      },
+      inviteMany: {
+        label: t('invite many label'),
+        description: t('invite many description'),
+        icon: () => <Icon icon='ph--users-three--regular' size={5} />,
+        testId: 'membersContainer.inviteMany',
+        onClick: () => {
+          const invitation = space.share?.({
+            type: Invitation.Type.DELEGATED,
+            authMethod: Invitation.AuthMethod.KNOWN_PUBLIC_KEY,
+            multiUse: true,
+            target: target && fullyQualifiedId(target),
+          });
+          if (invitation && config.values.runtime?.app?.env?.DX_ENVIRONMENT !== 'production') {
+            const subscription: ZenObservable.Subscription = invitation.subscribe((invitation) =>
+              handleInvitationEvent(invitation, subscription),
+            );
+          }
+        },
+      },
+    }),
+    [t, space, target],
+  );
+
+  const [selectedInvitation, setSelectedInvitation] = useState<CancellableInvitationObservable | null>(null);
+  const handleSend = (event: { type: 'selectInvitation'; invitation: CancellableInvitationObservable }) => {
+    setSelectedInvitation(event.invitation);
+  };
+  const handleBack = () => {
+    setSelectedInvitation(null);
+  };
+
+  return (
+    <StackItem.Content classNames='p-2 block overflow-y-auto'>
+      <ControlSection
+        title={t('members verbose label', { ns: SPACE_PLUGIN })}
+        description={t('members description', { ns: SPACE_PLUGIN })}
+      >
+        <ControlFrame>
+          <ControlFrameItem title={t('members label', { ns: SPACE_PLUGIN })}>
+            <SpaceMemberList spaceKey={space.key} includeSelf />
+          </ControlFrameItem>
+          <ControlFrameItem title={t('invitations label', { ns: SPACE_PLUGIN })}>
+            {selectedInvitation && <InvitationSection {...selectedInvitation} onBack={handleBack} />}
+            {!selectedInvitation && (
+              <>
+                <p className='text-description mbe-2'>{t('space invitation description', { ns: SPACE_PLUGIN })}</p>
+                <InvitationList
+                  className='mb-2'
+                  send={handleSend}
+                  invitations={visibleInvitations ?? []}
+                  onClickRemove={(invitation) => invitation.cancel()}
+                  createInvitationUrl={createInvitationUrl}
+                />
+                <BifurcatedAction
+                  actions={inviteActions}
+                  activeAction={activeAction}
+                  onChangeActiveAction={setActiveAction as Dispatch<SetStateAction<string>>}
+                  data-testid='membersContainer.createInvitation'
+                />
+              </>
+            )}
+          </ControlFrameItem>
+        </ControlFrame>
+      </ControlSection>
+    </StackItem.Content>
+  );
+};
+
+// TODO(wittjosiah): Reconcile the below components with DevicesContainer in @dxos/plugin-client.
+
+type InvitationComponentProps = Partial<
+  Pick<Invitation, 'authCode' | 'invitationId'> & {
+    state: Invitation.State;
+    url: string;
+    onBack: () => void;
+  }
+>;
+
+const InvitationSection = ({
+  state = Invitation.State.INIT,
+  authCode,
+  invitationId = 'never',
+  url = 'never',
+  onBack,
+}: InvitationComponentProps) => {
+  const activeView =
+    state < 0
+      ? 'init'
+      : state >= Invitation.State.CANCELLED
+        ? 'complete'
+        : state >= Invitation.State.READY_FOR_AUTHENTICATION && authCode
+          ? 'auth-code'
+          : 'qr-code';
+  return (
+    <Viewport.Root activeView={activeView}>
+      <Viewport.Views>
+        <Viewport.View id='init'>
+          {/* This view intentionally left blank while conditionally rendering the viewport. */}
+        </Viewport.View>
+        <Viewport.View id='complete'>
+          <InvitationComplete statusValue={state} />
+        </Viewport.View>
+        <Viewport.View id='auth-code'>
+          <InvitationAuthCode id={invitationId} code={authCode ?? 'never'} onCancel={onBack} />
+        </Viewport.View>
+        <Viewport.View id='qr-code'>
+          <InvitationQR id={invitationId} url={url} onCancel={onBack} />
+        </Viewport.View>
+      </Viewport.Views>
+    </Viewport.Root>
+  );
+};
+
+const InvitationQR = ({ id, url, onCancel }: { id: string; url: string; onCancel?: () => void }) => {
+  const { t } = useTranslation('os');
+  const qrLabel = useId('members-container__qr-code');
+  const emoji = hexToEmoji(id);
+  return (
+    <Clipboard.Provider>
+      <p className='text-description'>{t('qr code description', { ns: SPACE_PLUGIN })}</p>
+      <div role='group' className='grid grid-cols-[1fr_min-content] mlb-2 gap-2'>
+        <div role='none' className='is-full aspect-square relative text-description'>
+          <QR
+            rounding={100}
+            backgroundColor='transparent'
+            color='currentColor'
+            aria-labelledby={qrLabel}
+            errorCorrectionLevel='Q'
+            cutout={true}
+          >
+            {url ?? 'never'}
+          </QR>
+          <Centered>
+            <Emoji text={emoji} />
+          </Centered>
+        </div>
+        <span id={qrLabel} className='sr-only'>
+          {t('qr label')}
+        </span>
+        <Clipboard.Button value={url ?? 'never'} />
+      </div>
+      <Button variant='ghost' onClick={onCancel}>
+        {t('cancel label')}
+      </Button>
+    </Clipboard.Provider>
+  );
+};
+
+const InvitationAuthCode = ({ id, code, onCancel }: { id: string; code: string; onCancel?: () => void }) => {
+  const { t } = useTranslation('os');
+  const emoji = hexToEmoji(id);
+
+  return (
+    <>
+      <p className='text-description'>{t('auth other device emoji message')}</p>
+      {emoji && <Emoji text={emoji} className='mli-auto mlb-2 text-center' />}
+      <p className='text-description'>{t('auth code message')}</p>
+      <AuthCode code={code} large classNames='mli-auto mlb-2 text-center grow' />
+      <Button variant='ghost' onClick={onCancel}>
+        {t('cancel label')}
+      </Button>
+    </>
+  );
+};
+
+const InvitationComplete = ({ statusValue }: { statusValue: number }) => {
+  return statusValue > 0 ? <Check className={mx('m-1.5', getSize(6))} /> : <X className={mx('m-1.5', getSize(6))} />;
+};