@dxos/plugin-thread 0.8.3 → 0.8.4-main.03d5cd7b56

package/src/components/MessageContainer.tsx

@@ -1,167 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { EditorView } from '@codemirror/view';
-import { Check, PencilSimple, X } from '@phosphor-icons/react';
-import React, { forwardRef, useCallback, useEffect, useRef, useState } from 'react';
-
-import { Surface } from '@dxos/app-framework';
-import { type Obj, type Type } from '@dxos/echo';
-import { RefArray } from '@dxos/live-object';
-import { PublicKey } from '@dxos/react-client';
-import { type SpaceMember } from '@dxos/react-client/echo';
-import { useIdentity, type Identity } from '@dxos/react-client/halo';
-import { Button, ButtonGroup, Tooltip, useOnTransition, useThemeContext, useTranslation } from '@dxos/react-ui';
-import { createBasicExtensions, createThemeExtensions, useTextEditor } from '@dxos/react-ui-editor';
-import {
-  getSize,
-  hoverableControlItem,
-  hoverableControls,
-  hoverableFocusedWithinControls,
-  mx,
-} from '@dxos/react-ui-theme';
-import { MessageHeading, MessageRoot } from '@dxos/react-ui-thread';
-import { type DataType } from '@dxos/schema';
-
-import { command } from './command-extension';
-import { useOnEditAnalytics } from '../hooks';
-import { THREAD_PLUGIN } from '../meta';
-import { getMessageMetadata } from '../util';
-
-// TODO(thure): #8149
-const messageControlClassNames = ['!p-1 !min-bs-0 transition-opacity', hoverableControlItem];
-
-export type MessageContainerProps = {
-  message: DataType.Message;
-  members: SpaceMember[];
-  editable?: boolean;
-  onDelete?: (id: string) => void;
-};
-
-export const MessageContainer = ({ message, members, editable = false, onDelete }: MessageContainerProps) => {
-  const senderIdentity = members.find(
-    (member) =>
-      (message.sender.identityDid && member.identity.did === message.sender.identityDid) ||
-      (message.sender.identityKey && PublicKey.equals(member.identity.identityKey, message.sender.identityKey)),
-  )?.identity;
-  const messageMetadata = getMessageMetadata(message.id, senderIdentity);
-  const userIsAuthor = useIdentity()?.did === messageMetadata.authorId;
-  const [editing, setEditing] = useState(false);
-  const handleDelete = useCallback(() => onDelete?.(message.id), [message, onDelete]);
-  const { t } = useTranslation(THREAD_PLUGIN);
-  const editLabel = t(editing ? 'save message label' : 'edit message label');
-  const deleteLabel = t('delete message label');
-  const textBlock = message.blocks.find((block) => block.type === 'text');
-  const references = message.blocks.filter((block) => block.type === 'reference').map((block) => block.reference);
-
-  useOnEditAnalytics(message, textBlock, !!editing);
-
-  return (
-    <MessageRoot {...messageMetadata} classNames={[hoverableControls, hoverableFocusedWithinControls]}>
-      <MessageHeading authorName={messageMetadata.authorName} timestamp={messageMetadata.timestamp}>
-        <ButtonGroup classNames='mie-1'>
-          {userIsAuthor && editable && (
-            <Tooltip.Trigger asChild content={editLabel}>
-              <Button
-                variant='ghost'
-                data-testid={editing ? 'thread.message.save' : 'thread.message.edit'}
-                classNames={messageControlClassNames}
-                onClick={() => setEditing((editing) => !editing)}
-              >
-                <span className='sr-only'>{editLabel}</span>
-                {editing ? <Check className={getSize(4)} /> : <PencilSimple className={getSize(4)} />}
-              </Button>
-            </Tooltip.Trigger>
-          )}
-          {onDelete && (
-            <Tooltip.Trigger asChild content={deleteLabel}>
-              <Button
-                variant='ghost'
-                data-testid='thread.message.delete'
-                classNames={messageControlClassNames}
-                onClick={() => handleDelete()}
-              >
-                <span className='sr-only'>{deleteLabel}</span>
-                <X className={getSize(4)} />
-              </Button>
-            </Tooltip.Trigger>
-          )}
-        </ButtonGroup>
-      </MessageHeading>
-      {textBlock && <TextboxBlock block={textBlock} isAuthor={userIsAuthor} editing={editing} />}
-      {RefArray.targets(references).map((reference, index) => (
-        <MessagePart key={index} part={reference} />
-      ))}
-    </MessageRoot>
-  );
-};
-
-const MessagePart = ({ part }: { part: Type.Expando }) => {
-  return <MessageBlockObjectTile subject={part} />;
-};
-
-const TextboxBlock = ({
-  block,
-  isAuthor,
-  editing,
-}: {
-  block: DataType.MessageBlock.Text;
-  editing?: boolean;
-  isAuthor?: boolean;
-  identity?: Identity;
-}) => {
-  const { themeMode } = useThemeContext();
-  const inMemoryContentRef = useRef(block.text);
-
-  const handleDocumentChange = useCallback((newState: string) => {
-    inMemoryContentRef.current = newState;
-  }, []);
-
-  const saveDocumentChange = useCallback(() => {
-    block.text = inMemoryContentRef.current;
-  }, [block]);
-
-  useOnTransition(editing, true, false, saveDocumentChange);
-
-  const { parentRef, focusAttributes, view } = useTextEditor(
-    () => ({
-      initialValue: block.text,
-      extensions: [
-        createBasicExtensions({ readOnly: !isAuthor || !editing }),
-        createThemeExtensions({ themeMode }),
-        command,
-        EditorView.updateListener.of((update) => {
-          if (update.docChanged) {
-            handleDocumentChange(update.state.doc.toString());
-          }
-        }),
-      ],
-    }),
-    [block.text, editing, isAuthor, themeMode, handleDocumentChange],
-  );
-
-  useEffect(() => {
-    editing && view?.focus();
-  }, [editing, view]);
-
-  return <div role='none' ref={parentRef} className='mie-4' {...focusAttributes} />;
-};
-
-const MessageBlockObjectTile = forwardRef<HTMLDivElement, { subject: Obj.Any }>(({ subject }, forwardedRef) => {
-  // TODO(burdon): Use annotation to get title.
-  let title = (subject as any).name ?? (subject as any).title ?? (subject as any).type ?? 'Object';
-  if (typeof title !== 'string') {
-    title = title?.content ?? '';
-  }
-
-  return (
-    <div
-      role='group'
-      className={mx('grid col-span-3 py-1 pr-4', hoverableControls, hoverableFocusedWithinControls)}
-      ref={forwardedRef}
-    >
-      <Surface role='card' limit={1} data={{ subject }} fallback={title} />
-    </div>
-  );
-});

package/src/components/ThreadComplementary.tsx

@@ -1,151 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import React, { useCallback, useMemo } from 'react';
-
-import {
-  Capabilities,
-  LayoutAction,
-  createIntent,
-  useCapability,
-  useCapabilities,
-  useIntentDispatcher,
-} from '@dxos/app-framework';
-import { Filter, Obj, Query, Relation } from '@dxos/echo';
-import { fullyQualifiedId, getSpace, useQuery } from '@dxos/react-client/echo';
-import { useIdentity } from '@dxos/react-client/halo';
-import { useThemeContext, useTranslation } from '@dxos/react-ui';
-import { useAttended } from '@dxos/react-ui-attention';
-import { StackItem } from '@dxos/react-ui-stack';
-import { Tabs } from '@dxos/react-ui-tabs';
-import { AnchoredTo } from '@dxos/schema';
-
-import { ThreadCapabilities } from '../capabilities';
-import { CommentsContainer } from '../components';
-import { THREAD_PLUGIN } from '../meta';
-import { ThreadAction, ThreadType } from '../types';
-
-export const ThreadComplementary = ({ subject }: { subject: any }) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const identity = useIdentity();
-  const { t } = useTranslation(THREAD_PLUGIN);
-  const { tx } = useThemeContext();
-  const subjectId = fullyQualifiedId(subject);
-
-  const { state, getViewState } = useCapability(ThreadCapabilities.MutableState);
-  const drafts = state.drafts[subjectId];
-  const viewState = useMemo(() => getViewState(subjectId), [getViewState, subjectId]);
-  const { showResolvedThreads } = viewState;
-  const onChangeViewState = useCallback(
-    (nextValue: string) => {
-      viewState.showResolvedThreads = nextValue === 'all';
-    },
-    [viewState],
-  );
-
-  const anchorSorts = useCapabilities(Capabilities.AnchorSort);
-  const sort = useMemo(
-    () => anchorSorts.find(({ key }) => key === Obj.getTypename(subject))?.sort,
-    [anchorSorts, subject],
-  );
-
-  const space = getSpace(subject);
-  const objectsAnchoredTo = useQuery(space, Query.select(Filter.ids(subject.id)).targetOf(AnchoredTo));
-  const anchors = objectsAnchoredTo
-    .toSorted((a, b) => sort?.(a, b) ?? 0)
-    .filter((anchor) => Obj.instanceOf(ThreadType, Relation.getSource(anchor)))
-    .concat(drafts ?? []);
-
-  const attended = useAttended();
-
-  const handleAttend = useCallback(
-    (anchor: AnchoredTo) => {
-      const thread = Relation.getSource(anchor) as ThreadType;
-      const threadId = fullyQualifiedId(thread);
-
-      if (state.current !== threadId) {
-        state.current = threadId;
-
-        // TODO(wittjosiah): Should this be a thread-specific intent?
-        //  The layout doesn't know about threads and this working depends on other plugins conditionally handling it.
-        //  This may be overloading this intent or highjacking its intended purpose.
-        void dispatch(
-          createIntent(LayoutAction.ScrollIntoView, {
-            part: 'current',
-            subject: fullyQualifiedId(subject),
-            options: {
-              cursor: anchor.anchor,
-              ref: threadId,
-            },
-          }),
-        );
-      }
-    },
-    [state.current, dispatch, subject],
-  );
-
-  const handleComment = useCallback(
-    async (anchor: AnchoredTo, text: string) => {
-      await dispatch(
-        createIntent(ThreadAction.AddMessage, { anchor, subject, sender: { identityDid: identity?.did }, text }),
-      );
-
-      const thread = Relation.getSource(anchor) as ThreadType;
-      state.current = fullyQualifiedId(thread);
-    },
-    [dispatch, identity, subject],
-  );
-
-  const handleResolve = useCallback(
-    (anchor: AnchoredTo) =>
-      dispatch(createIntent(ThreadAction.ToggleResolved, { thread: Relation.getSource(anchor) as ThreadType })),
-    [dispatch],
-  );
-
-  const handleThreadDelete = useCallback(
-    (anchor: AnchoredTo) => dispatch(createIntent(ThreadAction.Delete, { anchor, subject })),
-    [dispatch, subject],
-  );
-
-  const handleMessageDelete = useCallback(
-    (anchor: AnchoredTo, messageId: string) =>
-      dispatch(createIntent(ThreadAction.DeleteMessage, { anchor, subject, messageId })),
-    [dispatch, subject],
-  );
-
-  const comments = (
-    <CommentsContainer
-      anchors={anchors}
-      currentId={attended.includes(subjectId) ? state.current : undefined}
-      showResolvedThreads={showResolvedThreads}
-      onAttend={handleAttend}
-      onComment={handleComment}
-      onResolve={handleResolve}
-      onMessageDelete={handleMessageDelete}
-      onThreadDelete={handleThreadDelete}
-    />
-  );
-
-  return (
-    <StackItem.Content toolbar>
-      <Tabs.Root
-        value={showResolvedThreads ? 'all' : 'unresolved'}
-        orientation='horizontal'
-        classNames='contents [&_[role="tabpanel"]]:min-bs-0 [&_[role="tabpanel"]]:overflow-y-auto [&_[role="tabpanel"]]:scrollbar-thin'
-        onValueChange={onChangeViewState}
-      >
-        <Tabs.Tablist classNames={tx('toolbar.root', 'toolbar', {})}>
-          <Tabs.Tab value='unresolved' classNames='text-sm'>
-            {t('show unresolved label')}
-          </Tabs.Tab>
-          <Tabs.Tab value='all' classNames='text-sm'>
-            {t('show all label')}
-          </Tabs.Tab>
-        </Tabs.Tablist>
-        <Tabs.Tabpanel value='all'>{showResolvedThreads && comments}</Tabs.Tabpanel>
-        <Tabs.Tabpanel value='unresolved'>{!showResolvedThreads && comments}</Tabs.Tabpanel>
-      </Tabs.Root>
-    </StackItem.Content>
-  );
-};

package/src/components/ThreadSettings.tsx

@@ -1,17 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import React from 'react';
-
-// import { useTranslation } from '@dxos/react-ui';
-import { DeprecatedFormContainer } from '@dxos/react-ui-form';
-
-// import { THREAD_PLUGIN } from '../meta';
-import type { ThreadSettingsProps } from '../types';
-
-export const ThreadSettings = ({ settings }: { settings: ThreadSettingsProps }) => {
-  // const { t } = useTranslation(THREAD_PLUGIN);
-
-  return <DeprecatedFormContainer></DeprecatedFormContainer>;
-};

package/src/components/testing.ts

@@ -1,29 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Obj, Ref } from '@dxos/echo';
-import { IdentityDid } from '@dxos/keys';
-import { faker } from '@dxos/random';
-import { type Identity } from '@dxos/react-client/halo';
-import { DataType } from '@dxos/schema';
-
-import { ThreadType } from '../types';
-
-export const createCommentThread = (identity: Identity): ThreadType => {
-  return Obj.make(ThreadType, {
-    messages: faker.helpers.multiple(
-      () =>
-        Ref.make(
-          Obj.make(DataType.Message, {
-            sender: {
-              identityDid: faker.datatype.boolean() ? identity.did : IdentityDid.random(),
-            },
-            created: new Date().toISOString(),
-            blocks: [{ type: 'text', text: faker.lorem.sentences(3) }],
-          }),
-        ),
-      { count: { min: 2, max: 3 } },
-    ),
-  });
-};

package/src/peers.stories.tsx

@@ -1,189 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import '@dxos-theme';
-
-import { type StoryObj, type Meta } from '@storybook/react';
-import React, { useEffect, useMemo, useRef, useState } from 'react';
-
-import { scheduleTask, sleep } from '@dxos/async';
-import { Context } from '@dxos/context';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-import { Config, useConfig } from '@dxos/react-client';
-import { withClientProvider } from '@dxos/react-client/testing';
-import { Button } from '@dxos/react-ui';
-import { Json } from '@dxos/react-ui-syntax-highlighter';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
-
-import { type TrackObject, CallsServicePeer, CALLS_URL } from './calls';
-// @ts-ignore
-import video from '../testing/video.mp4';
-
-const useVideoStreamTrack = (videoElement: HTMLVideoElement | null) => {
-  // Get video stream track.
-  const [videoStreamTrack, setVideoStreamTrack] = useState<MediaStreamTrack | undefined>(undefined);
-  const hadRun = useRef(false);
-  useEffect(() => {
-    // This is done to capture only one video stream.
-    if (!videoElement || hadRun.current || !video) {
-      return;
-    }
-    hadRun.current = true;
-
-    videoElement.src = video;
-    videoElement.addEventListener('playing', () => {
-      const stream = (videoElement as any).captureStream();
-      log.info('captured stream', { stream });
-      stream.onaddtrack = (event: MediaStreamTrackEvent) => {
-        if (event.track.kind === 'video') {
-          log.info('video stream track state', { state: event.track.readyState });
-          setVideoStreamTrack(event.track);
-        }
-      };
-    });
-  }, [videoElement]);
-
-  return videoStreamTrack;
-};
-
-const DefaultStory = ({ videoSrc }: { videoSrc: string }) => {
-  const config = useConfig();
-  const callsConfig = {
-    iceServers: config.get('runtime.services.ice'),
-    apiBase: `${CALLS_URL}/api/calls`,
-  };
-  const peerPush = useMemo(() => new CallsServicePeer(callsConfig), []);
-  const peerPull = useMemo(() => new CallsServicePeer(callsConfig), []);
-  const pushVideoElement = useRef<HTMLVideoElement>(null);
-  const pullVideoElement = useRef<HTMLVideoElement>(null);
-  const [metrics, setMetrics] = useState<Record<string, any>>({});
-  // Get video stream track.
-  const videoStreamTrack = useVideoStreamTrack(pushVideoElement.current);
-  const pullCtx = useRef<Context | undefined>(undefined);
-  const trackInfo = useRef<TrackObject | undefined>(undefined);
-  const hadRun = useRef(false);
-
-  // Push/pull video stream track to cloudflare.
-  useEffect(() => {
-    if (hadRun.current || !videoStreamTrack || !peerPush || !peerPull) {
-      return;
-    }
-    hadRun.current = true;
-    const ctx = new Context();
-    scheduleTask(ctx, async () => {
-      log.info('starting push/pull', { videoStreamTrack });
-      await peerPush.open();
-      await peerPull.open();
-      ctx.onDispose(() => {
-        void peerPush.close();
-        void peerPull.close();
-      });
-
-      // Push track to cloudflare.
-      performance.mark('push:begin');
-      const pushedTrack = await peerPush.pushTrack({ track: videoStreamTrack });
-      trackInfo.current = pushedTrack;
-      performance.mark('push:end');
-      const pushTime = performance.measure('push', 'push:begin', 'push:end').duration;
-      log.info('successfully pushed track', { pushTime, pushedTrack });
-      setMetrics((prev) => ({ ...prev, 'time to push track [ms]': Math.round(pushTime) }));
-
-      // Wait for cloudflare to process the track.
-      await sleep(500);
-
-      // Pull track from cloudflare.
-      performance.mark('pullTrack:begin');
-      pullCtx.current = new Context();
-      const pulledTrack = await peerPull.pullTrack({
-        trackData: { ...pushedTrack, mid: undefined },
-        ctx: pullCtx.current,
-      });
-      performance.mark('pullTrack:end');
-      const pullTime = performance.measure('pullTrack', 'pullTrack:begin', 'pullTrack:end').duration;
-      setMetrics((prev) => ({ ...prev, 'time to pull track [ms]': Math.round(pullTime) }));
-      log.info('successfully pulled track', { pullTime, pulledTrack });
-
-      invariant(pulledTrack);
-      invariant(pullVideoElement.current);
-      performance.mark('playVideo:begin');
-      pullVideoElement.current.srcObject = new MediaStream([pulledTrack]);
-      await pullVideoElement.current.play();
-      performance.mark('playVideo:end');
-      const playTime = performance.measure('playVideo', 'playVideo:begin', 'playVideo:end').duration;
-      setMetrics((prev) => ({ ...prev, 'time to play pulled video [ms]': Math.round(playTime) }));
-    });
-
-    return () => {
-      void ctx.dispose();
-    };
-  }, [videoStreamTrack, peerPush, peerPull]);
-
-  const handleRePullVideo = async () => {
-    performance.mark('rePullVideo:begin');
-    invariant(pullVideoElement.current);
-    invariant(pullVideoElement.current.srcObject instanceof MediaStream);
-    const pulledTrack = pullVideoElement.current.srcObject.getTracks()[0];
-    invariant(pulledTrack);
-    pullVideoElement.current.srcObject.removeTrack(pulledTrack);
-    await pullCtx.current!.dispose();
-    pulledTrack.stop();
-    pullCtx.current = new Context();
-    const newPulledTrack = await peerPull.pullTrack({
-      trackData: { ...trackInfo.current!, mid: undefined },
-      ctx: pullCtx.current,
-    });
-    invariant(newPulledTrack);
-    pullVideoElement.current.srcObject.addTrack(newPulledTrack);
-    performance.mark('rePullVideo:end');
-    const rePullTime = performance.measure('rePullVideo', 'rePullVideo:begin', 'rePullVideo:end').duration;
-    setMetrics((prev) => ({ ...prev, 'time to re-pull video [ms]': Math.round(rePullTime) }));
-  };
-
-  return (
-    <div className='grid grid-cols-3 gap-4 items-center'>
-      <video ref={pushVideoElement} muted autoPlay src={video} loop />
-      <Json data={metrics} />
-      <div className='flex flex-col gap-4'>
-        <video ref={pullVideoElement} muted />
-        <Button
-          disabled={
-            !(
-              pullVideoElement?.current?.srcObject instanceof MediaStream &&
-              pullVideoElement.current.srcObject.getTracks()[0]
-            )
-          }
-          onClick={handleRePullVideo}
-        >
-          Re-pull video
-        </Button>
-      </div>
-    </div>
-  );
-};
-
-const meta: Meta<typeof DefaultStory> = {
-  title: 'plugins/plugin-thread/peers',
-  render: DefaultStory,
-  decorators: [
-    withClientProvider({
-      config: new Config({ runtime: { services: { iceProviders: [{ urls: 'https://edge.dxos.workers.dev/ice' }] } } }),
-    }),
-    withTheme,
-    withLayout(),
-  ],
-  parameters: {
-    layout: 'centered',
-  },
-};
-
-export default meta;
-
-type Story = StoryObj<typeof DefaultStory>;
-
-export const Default: Story = {
-  args: {
-    videoSrc: video,
-  },
-};

package/src/testing/stories.ts

@@ -1,50 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { IntentPlugin, SettingsPlugin } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
-import { ClientPlugin } from '@dxos/plugin-client';
-import { GraphPlugin } from '@dxos/plugin-graph';
-import { SpacePlugin } from '@dxos/plugin-space';
-import { ThemePlugin } from '@dxos/plugin-theme';
-import { Config } from '@dxos/react-client';
-import { Ref } from '@dxos/react-client/echo';
-import { defaultTx } from '@dxos/react-ui-theme';
-
-import { ThreadPlugin } from '../ThreadPlugin';
-import { ChannelType, ThreadType } from '../types';
-
-export const createThreadPlugins = async () => [
-  ThemePlugin({ tx: defaultTx }),
-  ClientPlugin({
-    onClientInitialized: async (_, client) => {
-      await client.halo.createIdentity({ displayName: 'Test User' });
-    },
-    onSpacesReady: async (_, client) => {
-      await client.spaces.default.waitUntilReady();
-      const thread = Obj.make(ThreadType, { messages: [] });
-      client.spaces.default.db.add(Obj.make(ChannelType, { defaultThread: Ref.make(thread), threads: [] }));
-    },
-    config: new Config({
-      runtime: {
-        client: { edgeFeatures: { signaling: true } },
-        services: {
-          edge: {
-            url: 'https://edge.dxos.workers.dev/',
-          },
-          iceProviders: [
-            {
-              urls: 'https://edge.dxos.workers.dev/ice',
-            },
-          ],
-        },
-      },
-    }),
-  }),
-  SpacePlugin(),
-  IntentPlugin(),
-  SettingsPlugin(),
-  GraphPlugin(),
-  ThreadPlugin(),
-];

package/src/types/schema.ts

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Type } from '@dxos/echo';
-import { DataType } from '@dxos/schema';
-
-export const ThreadStatus = Schema.Union(
-  Schema.Literal('staged'),
-  Schema.Literal('active'),
-  Schema.Literal('resolved'),
-);
-
-const _ThreadType = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  status: Schema.optional(ThreadStatus),
-  messages: Schema.mutable(Schema.Array(Type.Ref(DataType.Message))),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/Thread', version: '0.1.0' }));
-export interface ThreadType extends Schema.Schema.Type<typeof _ThreadType> {}
-export const ThreadType: Type.obj<Schema.Schema<ThreadType, Schema.Schema.Encoded<typeof _ThreadType>, never>> =
-  _ThreadType;
-
-const _ChannelType = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  defaultThread: Type.Ref(ThreadType),
-  // TODO(wittjosiah): Should be an "ordered collection".
-  threads: Schema.mutable(Schema.Array(Type.Ref(ThreadType))),
-}).pipe(Type.Obj({ typename: 'dxos.org/type/Channel', version: '0.1.0' }));
-export interface ChannelType extends Schema.Schema.Type<typeof _ChannelType> {}
-export const ChannelType: Type.obj<Schema.Schema<ChannelType, Schema.Schema.Encoded<typeof _ChannelType>, never>> =
-  _ChannelType;