@dxos/plugin-space 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/src/components/SyncStatus/Space.tsx

@@ -0,0 +1,133 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { type HTMLAttributes, useEffect, useState } from 'react';
+
+import { useClient } from '@dxos/react-client';
+import { type SpaceId, useSpace } from '@dxos/react-client/echo';
+import { Icon, toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { type ThemedClassName } from '@dxos/react-ui';
+import { mx } from '@dxos/react-ui-theme';
+
+import { type Progress, type PeerSyncState } from './sync-state';
+import { SPACE_PLUGIN } from '../../meta';
+import { getSpaceDisplayName } from '../../util';
+
+export const SYNC_STALLED_TIMEOUT = 5_000;
+
+// TODO(wittjosiah): Define sematic color tokens.
+const styles = {
+  barBg: 'bg-neutral-50 dark:bg-green-900 text-black',
+  barFg: 'bg-neutral-100 bg-green-500',
+  barHover: 'dark:hover:bg-green-500',
+};
+
+const useActive = (count: number) => {
+  const [current, setCurrent] = useState(count);
+  const [active, setActive] = useState(false);
+  useEffect(() => {
+    let t: NodeJS.Timeout | undefined;
+    if (count !== current) {
+      setActive(true);
+      setCurrent(count);
+      t && clearTimeout(t);
+      t = setTimeout(() => {
+        setActive(false);
+      }, SYNC_STALLED_TIMEOUT);
+    }
+
+    return () => {
+      setActive(false);
+      clearTimeout(t);
+    };
+  }, [count, current]);
+  return active;
+};
+
+export type SpaceRowContainerProps = Omit<SpaceRowProps, 'spaceName'>;
+
+export const SpaceRowContainer = ({ spaceId, state }: SpaceRowContainerProps) => {
+  const { t } = useTranslation(SPACE_PLUGIN);
+  const client = useClient();
+  const space = useSpace(spaceId);
+  if (!space) {
+    return null;
+  }
+
+  const spaceName = toLocalizedString(getSpaceDisplayName(space, { personal: space === client.spaces.default }), t);
+
+  return <SpaceRow spaceId={spaceId} spaceName={spaceName} state={state} />;
+};
+
+export type SpaceRowProps = {
+  spaceId: SpaceId;
+  spaceName: string;
+  state: PeerSyncState;
+};
+
+export const SpaceRow = ({
+  spaceId,
+  spaceName,
+  state: { localDocumentCount, remoteDocumentCount, missingOnLocal, missingOnRemote },
+}: SpaceRowProps) => {
+  const downActive = useActive(localDocumentCount);
+  const upActive = useActive(remoteDocumentCount);
+
+  return (
+    <div
+      className='flex items-center mx-0.5 gap-0.5 cursor-pointer'
+      title={spaceId}
+      onClick={() => {
+        void navigator.clipboard.writeText(spaceId);
+      }}
+    >
+      <span className='is-1/2 truncate'>{spaceName}</span>
+      <Icon
+        icon='ph--arrow-fat-line-left--regular'
+        size={3}
+        classNames={mx(downActive && 'animate-[pulse_1s_infinite]')}
+      />
+      <Candle
+        up={{ count: remoteDocumentCount, total: remoteDocumentCount + missingOnRemote }}
+        down={{ count: localDocumentCount, total: localDocumentCount + missingOnLocal }}
+        title={spaceId}
+      />
+      <Icon
+        icon='ph--arrow-fat-line-right--regular'
+        size={3}
+        classNames={mx(upActive && 'animate-[pulse_1s_step-start_infinite]')}
+      />
+    </div>
+  );
+};
+
+type CandleProps = ThemedClassName<Pick<HTMLAttributes<HTMLDivElement>, 'title'>> & { up: Progress; down: Progress };
+
+const Candle = ({ classNames, up, down }: CandleProps) => {
+  return (
+    <div className={mx('grid grid-cols-[1fr_2rem_1fr] w-full h-3', classNames)}>
+      <Bar classNames='justify-end' {...up} />
+      <div className='relative'>
+        <div className={mx('absolute inset-0 flex items-center justify-center text-xs', styles.barBg)}>{up.total}</div>
+      </div>
+      <Bar {...down} />
+    </div>
+  );
+};
+
+const Bar = ({ classNames, count, total }: ThemedClassName<Progress>) => {
+  let p = (count / total) * 100;
+  if (count < total) {
+    p = Math.min(p, 95);
+  }
+
+  return (
+    <div className={mx('relative flex w-full', styles.barBg, classNames)}>
+      <div className={mx('shrink-0', styles.barFg)} style={{ width: `${p}%` }}></div>
+      {count !== total && (
+        <div className='absolute top-0 bottom-0 flex items-center mx-0.5 text-black text-xs'>{count}</div>
+      )}
+    </div>
+  );
+};

package/src/components/SyncStatus/SyncStatus.tsx

@@ -2,19 +2,22 @@
 // Copyright 2024 DXOS.org
 //
 
-import React, { useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
 
 import { StatusBar } from '@dxos/plugin-status-bar';
 import { useClient } from '@dxos/react-client';
-import { getSyncSummary, type SpaceSyncStateMap, useSyncState } from '@dxos/react-client/echo';
-import { Icon, useTranslation } from '@dxos/react-ui';
+import { type SpaceId } from '@dxos/react-client/echo';
+import { Icon, Input, Popover, useTranslation } from '@dxos/react-ui';
+import { type ThemedClassName } from '@dxos/react-ui';
+import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
+import { mx } from '@dxos/react-ui-theme';
 
+import { SpaceRowContainer, SYNC_STALLED_TIMEOUT } from './Space';
 import { createClientSaveTracker } from './save-tracker';
 import { getIcon, getStatus } from './status';
+import { type PeerSyncState, type SpaceSyncStateMap, getSyncSummary, useSyncState } from './sync-state';
 import { SPACE_PLUGIN } from '../../meta';
 
-const SYNC_STALLED_TIMEOUT = 5_000;
-
 export const SyncStatus = () => {
   const client = useClient();
   const state = useSyncState();
@@ -54,5 +57,65 @@ export const SyncStatusIndicator = ({ state, saved }: { state: SpaceSyncStateMap
   const title = t(`${status} label`);
   const icon = <Icon icon={getIcon(status)} size={4} classNames={classNames} />;
 
-  return <StatusBar.Item title={title}>{icon}</StatusBar.Item>;
+  if (offline) {
+    return <StatusBar.Item title={title}>{icon}</StatusBar.Item>;
+  } else {
+    return (
+      <Popover.Root>
+        <Popover.Trigger asChild>
+          <StatusBar.Button title={title}>{icon}</StatusBar.Button>
+        </Popover.Trigger>
+        <Popover.Portal>
+          <Popover.Content>
+            <SyncStatusDetail state={state} summary={summary} debug={false} />
+            <Popover.Arrow />
+          </Popover.Content>
+        </Popover.Portal>
+      </Popover.Root>
+    );
+  }
+};
+
+export type SyncStatusDetailProps = ThemedClassName<{
+  state: SpaceSyncStateMap;
+  summary: PeerSyncState;
+  debug?: boolean;
+}>;
+
+// TODO(wittjosiah): This currently does not show `differentDocuments` at all.
+export const SyncStatusDetail = ({ classNames, state, summary, debug }: SyncStatusDetailProps) => {
+  const [showAll, setShowAll] = useState(false);
+  const { t } = useTranslation(SPACE_PLUGIN);
+  const entries = Object.entries(state)
+    .filter(([_, value]) => showAll || value.missingOnLocal + value.missingOnRemote > 0)
+    .toSorted(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+
+  const handleCheckedChange = useCallback((state: boolean) => setShowAll(state), [setShowAll]);
+
+  // TODO(burdon): Normalize to max document count?
+  return (
+    <div className={mx('flex flex-col gap-3 p-2 text-xs min-w-[400px]', classNames)}>
+      <div role='none' className='flex items-center'>
+        <h1 className='flex-1'>{t('sync status title')}</h1>
+        <div className='flex items-center gap-2'>
+          <Input.Root>
+            <Input.Label classNames='text-xs'>{t('show all label')}</Input.Label>
+            <Input.Checkbox checked={showAll} onCheckedChange={handleCheckedChange} />
+          </Input.Root>
+        </div>
+      </div>
+      <div className='flex flex-col gap-2'>
+        {entries.length === 0 && (
+          <div role='none' className='flex justify-center'>
+            {/* TODO(wittjosiah): This text should be updated once status includes different documents. */}
+            {t('no sync status label')}
+          </div>
+        )}
+        {entries.map(([spaceId, state]) => (
+          <SpaceRowContainer key={spaceId} spaceId={spaceId as SpaceId} state={state} />
+        ))}
+      </div>
+      {debug && <SyntaxHighlighter language='json'>{JSON.stringify(summary, null, 2)}</SyntaxHighlighter>}
+    </div>
+  );
 };

package/src/components/SyncStatus/SyncStatusDetail.stories.tsx

@@ -0,0 +1,89 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { type Meta, type StoryObj } from '@storybook/react';
+import React, { useState } from 'react';
+
+import { type Client } from '@dxos/client';
+import { faker } from '@dxos/random';
+import { useClient } from '@dxos/react-client';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { useAsyncEffect } from '@dxos/react-ui';
+import { withTheme, withLayout } from '@dxos/storybook-utils';
+
+import { SyncStatusDetail } from './SyncStatus';
+import { getSyncSummary, type SpaceSyncStateMap } from './sync-state';
+import translations from '../../translations';
+
+const random = ({ min, max }: { min: number; max: number }) => min + Math.floor(Math.random() * (max - min));
+
+const createSpaceSyncStateMap = async (client: Client): Promise<SpaceSyncStateMap> => {
+  const spaces = await Promise.all(
+    Array.from({ length: 10 }).map(() => client.spaces.create({ name: faker.company.name() })),
+  );
+
+  return spaces.reduce<SpaceSyncStateMap>((map, space, i) => {
+    if (i > 4) {
+      const total = random({ min: 10, max: 500 });
+      map[space.id] = {
+        localDocumentCount: total,
+        remoteDocumentCount: total,
+        missingOnLocal: 0,
+        missingOnRemote: 0,
+        differentDocuments: 0,
+      };
+      return map;
+    }
+
+    const total = random({ min: 10, max: 500 });
+    const haveLocal = random({ min: 0, max: total });
+    const haveRemote = random({ min: 0, max: total });
+    map[space.id] = {
+      localDocumentCount: haveLocal,
+      remoteDocumentCount: haveRemote,
+      missingOnLocal: total - haveLocal,
+      missingOnRemote: total - haveRemote,
+      differentDocuments: 0,
+    };
+
+    return map;
+  }, {});
+};
+
+const meta: Meta<typeof SyncStatusDetail> = {
+  title: 'plugins/plugin-space/SyncStatusDetail',
+  component: SyncStatusDetail,
+  decorators: [withTheme, withLayout(), withClientProvider({ createIdentity: true })],
+  parameters: {
+    translations,
+    layout: 'centered',
+  },
+  args: {
+    classNames: 'm-2 border border-separator rounded-md',
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof SyncStatusDetail>;
+
+export const Default: Story = {
+  render: (args) => {
+    return <SyncStatusDetail {...args} state={{}} />;
+  },
+};
+
+export const Sync: Story = {
+  render: (args) => {
+    const client = useClient();
+    const [state, setState] = useState<SpaceSyncStateMap>({});
+    useAsyncEffect(async () => {
+      setState(await createSpaceSyncStateMap(client));
+    });
+
+    return <SyncStatusDetail {...args} state={state} summary={getSyncSummary(state)} />;
+  },
+};

package/src/components/SyncStatus/sync-state.ts

@@ -0,0 +1,101 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { useEffect, useState } from 'react';
+
+import { type Space, type SpaceId, type SpaceSyncState } from '@dxos/client/echo';
+import { Context } from '@dxos/context';
+import { EdgeService } from '@dxos/protocols';
+import { useClient } from '@dxos/react-client';
+
+export type Progress = { count: number; total: number };
+
+export type PeerSyncState = Omit<SpaceSyncState.PeerState, 'peerId'>;
+
+export type SpaceSyncStateMap = Record<SpaceId, PeerSyncState>;
+
+export const createEmptyEdgeSyncState = (): PeerSyncState => ({
+  missingOnLocal: 0,
+  missingOnRemote: 0,
+  localDocumentCount: 0,
+  remoteDocumentCount: 0,
+  differentDocuments: 0,
+});
+
+export const getSyncSummary = (syncMap: SpaceSyncStateMap): PeerSyncState => {
+  return Object.entries(syncMap).reduce<PeerSyncState>((summary, [_spaceId, peerState]) => {
+    summary.missingOnLocal += peerState.missingOnLocal;
+    summary.missingOnRemote += peerState.missingOnRemote;
+    summary.localDocumentCount += peerState.localDocumentCount;
+    summary.remoteDocumentCount += peerState.remoteDocumentCount;
+    summary.differentDocuments += peerState.differentDocuments;
+    return summary;
+  }, createEmptyEdgeSyncState());
+};
+
+const isEdgePeerId = (peerId: string, spaceId: SpaceId) =>
+  peerId.startsWith(`${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}`);
+
+/**
+ * Hook Subscribes to sync state for each space.
+ */
+export const useSyncState = (): SpaceSyncStateMap => {
+  const client = useClient();
+  const [spaceState, setSpaceState] = useState<SpaceSyncStateMap>({});
+
+  useEffect(() => {
+    const ctx = new Context();
+    const createSubscriptions = (spaces: Space[]) => {
+      for (const space of spaces) {
+        if (spaceState[space.id]) {
+          continue;
+        }
+
+        ctx.onDispose(
+          space.crud.subscribeToSyncState(ctx, ({ peers = [] }) => {
+            const syncState = peers.find((state) => isEdgePeerId(state.peerId, space.id));
+            if (syncState) {
+              setSpaceState((spaceState) => ({ ...spaceState, [space.id]: syncState }));
+            }
+          }),
+        );
+      }
+    };
+
+    createSubscriptions(client.spaces.get());
+    client.spaces.subscribe((spaces) => {
+      createSubscriptions(spaces);
+    });
+
+    return () => {
+      void ctx.dispose();
+    };
+  }, [client]);
+
+  return spaceState;
+};
+
+/**
+ * Hook Subscribes to sync state for a single space.
+ */
+// TODO(wittjosiah): Reconcile w/ useSyncState.
+export const useSpaceSyncState = (space: Space): PeerSyncState | undefined => {
+  const [spaceState, setSpaceState] = useState<PeerSyncState>();
+
+  useEffect(() => {
+    const ctx = new Context();
+    space.crud.subscribeToSyncState(ctx, ({ peers = [] }) => {
+      const syncState = peers.find((state) => isEdgePeerId(state.peerId, space.id));
+      if (syncState) {
+        setSpaceState(syncState);
+      }
+    });
+
+    return () => {
+      void ctx.dispose();
+    };
+  }, [space]);
+
+  return spaceState;
+};

package/src/components/index.ts

@@ -9,11 +9,12 @@ export * from './CollectionSection';
 export * from './JoinDialog';
 export * from './MembersContainer';
 export * from './MenuFooter';
-export * from './ObjectSettings';
+export * from './ObjectSettingsContainer';
 export * from './PersistenceStatus';
+export * from './PopoverAddSpace';
 export * from './PopoverRenameObject';
 export * from './PopoverRenameSpace';
-export * from './SchemaContainer';
+export * from './ShareSpaceButton';
 export * from './SpacePresence';
 export * from './SpacePluginSettings';
 export * from './SpaceSettings';

package/src/hooks/index.ts

@@ -2,6 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './useActiveSpace';
-export * from './useInputSurfaceLookup';
 export * from './usePath';

package/src/hooks/usePath.ts

@@ -2,10 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Option } from 'effect';
 import { useEffect, useState } from 'react';
 
-import { type ReadableGraph } from '@dxos/plugin-graph';
+import { type Graph } from '@dxos/plugin-graph';
 
 /**
  * React hook to get a path from the graph.
@@ -16,17 +15,15 @@ import { type ReadableGraph } from '@dxos/plugin-graph';
  * @returns Path if found, undefined otherwise.
  */
 // TODO(wittjosiah): Factor out.
-export const usePath = (graph: ReadableGraph, id?: string, timeout?: number): Option.Option<string[]> => {
-  const [pathState, setPathState] = useState<Option.Option<string[]>>(
-    id ? graph.getPath({ target: id }) : Option.none(),
-  );
+export const usePath = (graph: Graph, id?: string, timeout?: number): string[] | undefined => {
+  const [pathState, setPathState] = useState<string[] | undefined>(id ? graph.getPath({ target: id }) : undefined);
 
   useEffect(() => {
     if (!id && pathState) {
-      setPathState(Option.none());
+      setPathState(undefined);
     }
 
-    if ((Option.isSome(pathState) && pathState.value.at(-1) === id) || !id) {
+    if (pathState?.at(-1) === id || !id) {
       return;
     }
 
@@ -35,7 +32,7 @@ export const usePath = (graph: ReadableGraph, id?: string, timeout?: number): Op
       try {
         const path = await graph.waitForPath({ target: id }, { timeout });
         if (path) {
-          setPathState(Option.some(path));
+          setPathState(path);
         }
       } catch {}
     });

package/src/index.ts

@@ -6,7 +6,6 @@ export { SpaceCapabilities, ThreadCapabilities } from './capabilities';
 export { SpaceEvents, ThreadEvents } from './events';
 
 export * from './components';
-export * from './hooks';
 export * from './meta';
 export * from './SpacePlugin';
 export * from './util';

package/src/translations.ts

@@ -15,6 +15,7 @@ export default [
       [SPACE_PLUGIN]: {
         'plugin name': 'Spaces',
         'first run message': 'Nothing selected.',
+        'add space label': 'Create or join a space',
         'create space label': 'Create space',
         'join space label': 'Join space',
         'empty space message': 'No documents',
@@ -33,7 +34,7 @@ export default [
         'export data label': 'Export data',
         'import data label': 'Import data',
         'migrate space label': 'Migrate space',
-        'share space label': 'Share current space',
+        'share space': 'Share space',
         'save space to disk label': 'Save to disk',
         'load space from disk label': 'Load from disk',
         'confirm restore title': 'Overwrite files in this space?',
@@ -42,7 +43,7 @@ export default [
         'object placeholder': 'Type a title here…',
         'personal space label': 'Personal Space',
         'spaces label': 'Spaces',
-        'show hidden spaces label': 'Show archived spaces',
+        'show hidden spaces label': 'Show closed spaces',
         'save files to directory label': 'Save files to disk',
         'select path label': 'Select path',
         'rename collection label': 'Rename collection',
@@ -66,6 +67,7 @@ export default [
           'The requested object has not been found yet. Ensure there are enough peers online in the space with an updated copy.',
         'create object in space label': 'Add to space',
         'create object in collection label': 'Add to collection',
+        'share space label': 'Share',
         'space members label': 'Space members',
         'active space members heading': 'Online ({{count}})',
         'inactive space members heading': 'Offline ({{count}})',
@@ -94,7 +96,7 @@ export default [
         'join success label': 'Successfully joined space',
         'name label': 'Name',
         'name placeholder': 'Name',
-        'object settings label': 'Details',
+        'object settings label': 'Settings',
         'edge replication label': 'Enable EDGE Replication',
         'saving locally label': 'Writing to disk',
         'downloading label': 'Replicating from peers',
@@ -116,7 +118,6 @@ export default [
         'advanced settings label': 'Advanced',
         'foreign keys': 'Foreign Keys',
         'add key': 'Add Key',
-        'open space settings label': 'Open',
 
         'members panel label': 'Members',
         'members verbose label': 'Manage space members',
@@ -125,29 +126,16 @@ export default [
         'invitations label': 'Invitations',
         'space invitation description': 'Manage invitations to the space.',
         'qr code description': 'Share this QR code, or copy the URL and share it with the person you want to invite.',
-        'locked space description': 'This space is locked, unlock it to invite new members.',
-        'space locked label': 'Lock space',
-        'space locked description': 'Locking a space prevents new members from being invited to the space.',
 
         'settings panel label': 'Space Settings',
-        'open current space settings label': 'Open current space settings',
-        'space settings properties label': 'General settings',
-        'space properties settings verbose label': 'Manage space properties',
-        'space properties settings description': 'You can configure how this space is displayed in the app here.',
-        'space settings schema label': 'Schema',
-        'schema verbose label': 'Manage schema',
-        'schema description': 'You can manage all of the schema stored within this space here.',
-        'no schemas found message': 'No schemas found',
+        'open space settings label': 'Space Settings',
+        'space settings properties label': 'General',
         'display name input placeholder': 'Space name',
         'display name description': 'Name of the space as it appears in the app.',
         'icon description': 'Icon used to represent the space in the app.',
         'hue description': 'Color used to represent the space in the app.',
         'edge replication description':
           "Only change this if you know what you're doing. Disabling this will prevent the space from replicating through Composer's EDGE services, and relies solely on peer-to-peer sync.",
-        'archive space description':
-          'Archiving a space will remove it from the sidebar and stop replicating updates, but will not delete the data. You can unarchive it by enabling archived spaces in the app settings.',
-        'archive space label': 'Archive',
-        'unarchive space label': 'Unarchive',
       },
     },
   },

package/src/types/collection.ts

@@ -2,17 +2,15 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
-
-import { Expando, Ref, TypedObject } from '@dxos/echo-schema';
+import { Expando, Ref, S, TypedObject } from '@dxos/echo-schema';
 
 export class CollectionType extends TypedObject({ typename: 'dxos.org/type/Collection', version: '0.1.0' })({
-  name: Schema.optional(Schema.String),
-  objects: Schema.mutable(Schema.Array(Ref(Expando))),
+  name: S.optional(S.String),
+  objects: S.mutable(S.Array(Ref(Expando))),
   // Key is schema typename and value is reference to a view object of the associated schema.
   // Having collection reference the views rather than vice versa ensures that the state converges to a single view per key (i.e. type).
   // This also leaves open a future where this key could be changed to allow for multiple stack views per section.
   // TODO(wittjosiah): Any way to make this more type safe?
   // TODO(wittjosiah): Should the views be separate objects or just be schemas for view data in this record?
-  views: Schema.mutable(Schema.Record({ key: Schema.String, value: Ref(Expando) })),
+  views: S.mutable(S.Record({ key: S.String, value: Ref(Expando) })),
 }) {}

package/src/types/thread.ts

@@ -2,29 +2,23 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
-
-import { Expando, Ref, TypedObject } from '@dxos/echo-schema';
-import { DataType } from '@dxos/schema';
+import { Expando, Ref, S, TypedObject } from '@dxos/echo-schema';
+import { MessageType } from '@dxos/schema';
 
 // TODO(wittjosiah): These types were placed here rather than in @dxos/plugin-thread
 //   in order to avoid a circular dependency between threads and other objects that use threads.
 
-export const ThreadStatus = Schema.Union(
-  Schema.Literal('staged'),
-  Schema.Literal('active'),
-  Schema.Literal('resolved'),
-);
+export const ThreadStatus = S.Union(S.Literal('staged'), S.Literal('active'), S.Literal('resolved'));
 
 export class ThreadType extends TypedObject({ typename: 'dxos.org/type/Thread', version: '0.1.0' })({
-  name: Schema.optional(Schema.String),
+  name: S.optional(S.String),
   /** AM cursor-range: 'from:to'. */
-  anchor: Schema.optional(Schema.String),
-  status: Schema.optional(ThreadStatus),
-  messages: Schema.mutable(Schema.Array(Ref(DataType.Message))),
+  anchor: S.optional(S.String),
+  status: S.optional(ThreadStatus),
+  messages: S.mutable(S.Array(Ref(MessageType))),
 }) {}
 
 export class ChannelType extends TypedObject({ typename: 'dxos.org/type/Channel', version: '0.1.0' })({
-  name: Schema.optional(Schema.String),
+  name: S.optional(S.String),
   queue: Ref(Expando),
 }) {}