@dxos/plugin-script 0.8.1 → 0.8.2-main.2f9c567

package/src/components/DeploymentDialog/DeploymentDialog.tsx

@@ -7,7 +7,7 @@ import React, { useEffect, useMemo } from 'react';
 import { createIntent, LayoutAction, useIntentDispatcher } from '@dxos/app-framework';
 import { getSpace } from '@dxos/react-client/echo';
 import { Button, Dialog, Icon, useTranslation } from '@dxos/react-ui';
-import { type AccessTokenType } from '@dxos/schema';
+import { type DataType } from '@dxos/schema';
 
 import { useCreateAndDeployScriptTemplates } from '../../hooks/useCreateAndDeployScriptTemplates';
 import { SCRIPT_PLUGIN } from '../../meta';
@@ -21,7 +21,7 @@ export const DEPLOYMENT_DIALOG = `${SCRIPT_PLUGIN}/deployment/dialog`;
 //   - Pending / onError states.
 
 type DeploymentDialogProps = {
-  accessToken: AccessTokenType;
+  accessToken: DataType.AccessToken;
   scriptTemplates: Template[];
 };
 

package/src/components/ScriptContainer.tsx

@@ -4,7 +4,7 @@
 
 import React, { useMemo } from 'react';
 
-import { type ScriptType } from '@dxos/functions/types';
+import { type ScriptType } from '@dxos/functions';
 import { createDocAccessor, getSpace } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { type ThemedClassName } from '@dxos/react-ui';

package/src/components/ScriptToolbar/ScriptToolbar.tsx

@@ -4,7 +4,7 @@
 
 import React, { useCallback } from 'react';
 
-import { type ScriptType } from '@dxos/functions/types';
+import { type ScriptType } from '@dxos/functions';
 import { fullyQualifiedId } from '@dxos/react-client/echo';
 import { ElevationProvider, type ThemedClassName } from '@dxos/react-ui';
 import { stackItemContentToolbarClassNames } from '@dxos/react-ui-editor';

package/src/components/Settings/ScriptObjectSettings.tsx

@@ -6,12 +6,12 @@ import { Octokit } from '@octokit/core';
 import React, { type ChangeEvent, useCallback, useEffect, useState } from 'react';
 
 import { createIntent, SettingsAction, useIntentDispatcher } from '@dxos/app-framework';
-import { FunctionType, type ScriptType, getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions/types';
+import { FunctionType, type ScriptType, getInvocationUrl, getUserFunctionUrlInMetadata } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';
 import { Filter, getMeta, getSpace, useQuery } from '@dxos/react-client/echo';
 import { Button, Clipboard, Input, useControlledState, useTranslation } from '@dxos/react-ui';
-import { AccessTokenType } from '@dxos/schema';
+import { DataType } from '@dxos/schema';
 
 import { SCRIPT_PLUGIN } from '../../meta';
 
@@ -112,7 +112,7 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
   const { t } = useTranslation(SCRIPT_PLUGIN);
   const { dispatchPromise: dispatch } = useIntentDispatcher();
   const space = getSpace(object);
-  const [githubToken] = useQuery(space, Filter.schema(AccessTokenType, { source: 'github.com' }));
+  const [githubToken] = useQuery(space, Filter.schema(DataType.AccessToken, { source: 'github.com' }));
   const gistKey = getMeta(object).keys.find(({ source }) => source === 'github.com');
   const [gistUrl, setGistUrl] = useState<string | undefined>();
 

package/src/hooks/format.ts

@@ -7,7 +7,7 @@ import prettierPluginEstree from 'prettier/plugins/estree';
 import prettierPluginTypescript from 'prettier/plugins/typescript';
 import { useCallback } from 'react';
 
-import { type ScriptType } from '@dxos/functions/types';
+import { type ScriptType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { createMenuAction } from '@dxos/react-ui-menu';
 

package/src/hooks/template.ts

@@ -4,7 +4,7 @@
 
 import { useCallback } from 'react';
 
-import { FUNCTIONS_PRESET_META_KEY, type ScriptType } from '@dxos/functions/types';
+import { FUNCTIONS_PRESET_META_KEY, type ScriptType } from '@dxos/functions';
 import { getMeta } from '@dxos/live-object';
 import { createMenuItemGroup, createMenuAction } from '@dxos/react-ui-menu';
 

package/src/hooks/useToolbarAction.ts

@@ -4,7 +4,7 @@
 
 import { useCallback } from 'react';
 
-import { type ScriptType } from '@dxos/functions/types';
+import { type ScriptType } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { type MenuAction, type MenuActionHandler } from '@dxos/react-ui-menu';
 

package/src/hooks/useToolbarState.ts

@@ -4,7 +4,7 @@
 
 import { useMemo } from 'react';
 
-import { create } from '@dxos/live-object';
+import { live } from '@dxos/live-object';
 
 import { type DeployState } from './deploy';
 
@@ -12,5 +12,5 @@ export type ScriptToolbarState = Partial<DeployState>;
 
 // TODO(burdon): Replace with context provider?
 export const useToolbarState = (initialState: ScriptToolbarState = {}) => {
-  return useMemo(() => create<ScriptToolbarState>(initialState), []);
+  return useMemo(() => live<ScriptToolbarState>(initialState), []);
 };

package/src/meta.ts

@@ -19,5 +19,6 @@ export const meta: PluginMeta = {
 
 // TODO(ZaymonFC): Configure by scopes?
 export const defaultScriptsForIntegration: Record<string, string[]> = {
+  // TODO(wittjosiah): Also include content extraction scripts in the default set.
   'gmail.com': ['dxos.org/script/gmail'],
 };

package/src/templates/chess.ts

@@ -2,25 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema } from 'effect';
 // @ts-ignore
-import { defineFunction, S } from 'dxos:functions';
+import { defineFunction } from 'dxos:functions';
 // @ts-ignore
 import { Chess } from 'https://esm.sh/chess.js@0.13.1';
 
 export default defineFunction({
   description: 'Plays a random move in a chess game.',
 
-  inputSchema: S.Struct({
-    changedObjectId: S.String.annotations({
+  inputSchema: Schema.Struct({
+    changedObjectId: Schema.String.annotations({
       description: 'The objects to play the game on.',
     }),
-    player: S.optional(S.Literal('w', 'b')).annotations({
+    player: Schema.optional(Schema.Literal('w', 'b')).annotations({
       description: 'The player to play the game as.',
     }),
   }),
 
-  outputSchema: S.Struct({
-    state: S.String.annotations({
+  outputSchema: Schema.Struct({
+    state: Schema.String.annotations({
       description: 'The state of the game as an ASCII art board.',
     }),
   }),

package/src/templates/data-generator.ts

@@ -2,72 +2,53 @@
 // Copyright 2025 DXOS.org
 //
 
-import {
-  EchoObject,
-  defineFunction,
-  S,
-  createStatic,
-  Expando,
-  TypedObject,
-  Ref,
-  LabelAnnotationId,
-  // @ts-ignore
-} from 'dxos:functions';
+import { Schema } from 'effect';
 // @ts-ignore
-import { randParagraph } from 'https://esm.sh/@ngneat/falso@7.1.1';
-
-export class TextType extends TypedObject({ typename: 'dxos.org/type/Text', version: '0.1.0' })({
-  content: S.String,
-}) {}
-
-export const DocumentSchema = S.Struct({
-  name: S.optional(S.String),
-  fallbackName: S.optional(S.String),
-  content: Ref(TextType),
-  threads: S.mutable(S.Array(Ref(Expando))),
-}).annotations({
-  [LabelAnnotationId]: ['name', 'fallbackName'],
-});
-
-export const DocumentType = DocumentSchema.pipe(EchoObject('dxos.org/type/Document', '0.1.0'));
-export type DocumentType = S.Schema.Type<typeof DocumentType>;
+import { defineFunction, S, create, Expando } from 'dxos:functions';
+// @ts-ignore
+import { randText } from 'https://esm.sh/@ngneat/falso@7.1.1';
 
 export default defineFunction({
-  inputSchema: S.Struct({
-    documentAmount: S.optional(S.Number),
-    textSize: S.optional(S.Number),
-    mutationAmount: S.optional(S.Number),
+  inputSchema: Schema.Struct({
+    documentAmount: Schema.optional(Schema.Number),
+    textSize: Schema.optional(Schema.Number),
+    mutationAmount: Schema.optional(Schema.Number),
   }),
 
-  outputSchema: S.Struct({}),
+  outputSchema: Schema.Struct({}),
 
-  handler: async ({ event: { documentAmount = 10, textSize = 10, mutationAmount = 0 }, context: { space } }: any) => {
+  handler: async ({
+    event: {
+      data: { documentAmount = 1, textSize = 10, mutationAmount = 0 },
+    },
+    context: { space },
+  }: any) => {
     await space.db.graph.schemaRegistry.addSchema([Expando]);
+    const result: Record<string, any> = {};
+    const objects: Expando[] = [];
 
-    const objects = [];
-    // const rootCollection = await space.properties[COLLECTION_TYPENAME]?.load();
+    // Create objects.
     for (let i = 0; i < documentAmount; i++) {
       const obj = space.db.add(
-        createStatic(Expando, {
+        create(Expando, {
           name: 'scriptGenerated',
-          content: randParagraph({ length: textSize }),
+          content: randText({ charCount: textSize }),
         }),
       );
-      // rootCollection.objects.push(obj);
       objects.push(obj);
+      const objectResult: any = {};
+      // Mutate the object.
+      for (let i = 0; i < mutationAmount; i++) {
+        obj.content = randText({ charCount: textSize });
+      }
+      objectResult.mutations = mutationAmount;
+      objectResult.contentLength = obj.content.length;
+      result[obj.id] = objectResult;
     }
 
-    for (let i = 0; i < mutationAmount; i++) {
-      const obj = objects[Math.floor(Math.random() * objects.length)];
-      obj.content = randParagraph({ length: textSize });
-    }
-
+    // Flush and wait for data to propagate.
     await space.db.flush();
-    // TODO(mykola): This seems to halp with propagating data to space.
-    for (const obj of objects) {
-      await space.db.query({ id: obj.id }).first();
-      console.log('obj', obj.id);
-    }
-    return 'OK';
+    await new Promise((resolve) => setTimeout(resolve, 10_000));
+    return result;
   },
 });

package/src/templates/discord.ts

@@ -2,8 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema } from 'effect';
 // @ts-ignore
-import { createStatic, EchoObject, defineFunction, DXN, Filter, ObjectId, S } from 'dxos:functions';
+import { create, defineFunction, DXN, Filter, ObjectId, S } from 'dxos:functions';
 import {
   FetchHttpClient,
   // @ts-ignore
@@ -13,13 +14,20 @@ import { DiscordConfig, DiscordREST, DiscordRESTMemoryLive } from 'https://esm.s
 // @ts-ignore
 import { Effect, Config, Redacted, Ref } from 'https://esm.sh/effect@3.13.3';
 
-const MessageSchema = S.Struct({
-  id: S.String,
-  foreignId: S.Any, // bigint?
-  from: S.String,
-  created: S.String,
-  content: S.String,
-}).pipe(EchoObject({ typename: 'example.com/type/Message', version: '0.1.0' }));
+import { Type } from '@dxos/echo';
+
+const MessageSchema = Schema.Struct({
+  id: ObjectId,
+  foreignId: Schema.Any, // bigint?
+  from: Schema.String,
+  created: Schema.String,
+  content: Schema.String,
+}).pipe(
+  Type.def({
+    typename: 'example.com/type/Message',
+    version: '0.1.0',
+  }),
+);
 
 const DEFAULT_AFTER = 1704067200; // 2024-01-01
 
@@ -29,17 +37,17 @@ const generateSnowflake = (unixTimestamp: number): bigint => {
 };
 
 export default defineFunction({
-  inputSchema: S.Struct({
+  inputSchema: Schema.Struct({
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
-    tick: S.optional(S.String),
-    channelId: S.String,
-    after: S.optional(S.Number),
-    pageSize: S.optional(S.Number),
-    queueId: S.String,
+    tick: Schema.optional(Schema.String),
+    channelId: Schema.String,
+    after: Schema.optional(Schema.Number),
+    pageSize: Schema.optional(Schema.Number),
+    queueId: Schema.String,
   }),
 
-  outputSchema: S.Struct({
-    newMessages: S.Number,
+  outputSchema: Schema.Struct({
+    newMessages: Schema.Number,
   }),
 
   handler: ({
@@ -73,7 +81,7 @@ export default defineFunction({
           const messages = yield* rest.getChannelMessages(channelId, options).pipe((res: any) => res.json);
           const queueMessages = messages
             .map((message: any) =>
-              createStatic(MessageSchema, {
+              create(MessageSchema, {
                 id: ObjectId.random(),
                 foreignId: message.id,
                 from: message.author.username,

package/src/templates/forex-effect.ts

@@ -2,8 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema } from 'effect';
 // @ts-ignore
-import { defineFunction, S } from 'dxos:functions';
+import { defineFunction } from 'dxos:functions';
 import {
   HttpClient,
   HttpClientRequest,
@@ -16,12 +17,12 @@ import { Effect, Schedule } from 'https://esm.sh/effect@3.13.3';
 export default defineFunction({
   description: 'Returns the exchange rate between two currencies.',
 
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
+  inputSchema: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
 
-  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
+  outputSchema: Schema.String.annotations({ description: 'The exchange rate between the two currencies' }),
 
   handler: async ({
     event: {

package/src/templates/forex.ts

@@ -2,15 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema } from 'effect';
 // @ts-ignore
-import { defineFunction, S } from 'dxos:functions';
+import { defineFunction } from 'dxos:functions';
 
 export default defineFunction({
   description: 'Returns the exchange rate between two currencies.',
 
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
+  inputSchema: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
 
   handler: async ({

package/src/templates/gmail.ts

@@ -3,7 +3,8 @@
 //
 
 // @ts-ignore
-import { createStatic, defineFunction, EchoObject, Filter, ObjectId, S } from 'dxos:functions';
+import { create, defineFunction, Filter, ObjectId } from 'dxos:functions';
+// @ts-ignore
 import {
   HttpClient,
   HttpClientRequest,
@@ -11,30 +12,33 @@ import {
   // @ts-ignore
 } from 'https://esm.sh/@effect/platform@0.77.2?deps=effect@3.13.3';
 // @ts-ignore
-import { pipe, Chunk, Effect, Ref, Schedule, Stream } from 'https://esm.sh/effect@3.13.3';
+import { format, subDays } from 'https://esm.sh/date-fns@3.3.1';
+// @ts-ignore
+import { pipe, Chunk, Effect, Ref, Schedule, Schema, Stream } from 'https://esm.sh/effect@3.13.3';
 
-// TODO(ZaymonFC): Calculate this dynamically and expose a parameter.
-const DEFAULT_AFTER = '2025-01-01';
+import { Type } from '@dxos/echo';
 
 export default defineFunction({
-  inputSchema: S.Struct({
+  inputSchema: Schema.Struct({
+    mailboxId: Schema.String,
+    userId: Schema.optional(Schema.String).pipe(Schema.withDecodingDefault(() => 'me')),
+    after: Schema.optional(Schema.Union(Schema.Number, Schema.String)).pipe(
+      Schema.withDecodingDefault(() => format(subDays(new Date(), 30), 'yyyy-MM-dd')),
+    ),
+    pageSize: Schema.optional(Schema.Number).pipe(Schema.withDecodingDefault(() => 100)),
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
-    tick: S.optional(S.String),
-    userId: S.optional(S.String),
-    after: S.optional(S.Union(S.Number, S.String)),
-    pageSize: S.optional(S.Number),
-    mailboxId: S.String,
+    tick: Schema.optional(Schema.String),
   }),
 
-  outputSchema: S.Struct({
-    newMessages: S.Number,
+  outputSchema: Schema.Struct({
+    newMessages: Schema.Number,
   }),
 
   handler: ({
+    context: { space },
     event: {
-      data: { mailboxId, userId = 'me', after = DEFAULT_AFTER, pageSize = 100 },
+      data: { mailboxId, userId, after, pageSize },
     },
-    context: { space },
   }: any) =>
     Effect.gen(function* () {
       const { token } = yield* Effect.tryPromise({
@@ -42,9 +46,10 @@ export default defineFunction({
         catch: (e: any) => e,
       });
 
-      const makeRequest = (path: string) =>
+      // NOTE: Google API bundles size is v. large and caused runtime issues.
+      const makeRequest = (url: string) =>
         pipe(
-          path,
+          url,
           HttpClientRequest.get,
           HttpClientRequest.setHeaders({ Authorization: `Bearer ${token}`, Accept: 'application/json' }),
           HttpClient.execute,
@@ -54,13 +59,10 @@ export default defineFunction({
           Effect.scoped,
         );
 
-      const listMessages = (userId: string, q: string, pageSize: number, pageToken: string | null) => {
-        const url = `https://gmail.googleapis.com/gmail/v1/users/${userId}/messages?maxResults=${pageSize}&q=${q}`;
-        return makeRequest(pageToken ? `${url}&pageToken=${pageToken}` : url);
-      };
+      const listMessages = (userId: string, q: string, pageSize: number, pageToken: string | null) =>
+        makeRequest(getUrl(userId, undefined, { q, pageSize, pageToken }));
 
-      const getMessage = (userId: string, id: string) =>
-        makeRequest(`https://gmail.googleapis.com/gmail/v1/users/${userId}/messages/${id}`);
+      const getMessage = (userId: string, messageId: string) => makeRequest(getUrl(userId, messageId));
 
       const mailbox = yield* Effect.tryPromise({
         try: () => space.db.query({ id: mailboxId }).first(),
@@ -97,7 +99,7 @@ export default defineFunction({
             continue;
           }
           const subject = messageDetails.payload.headers.find((h: any) => h.name === 'Subject')?.value;
-          const object = createStatic(MessageType, {
+          const object = create(MessageType, {
             id: ObjectId.random(),
             created,
             sender,
@@ -137,6 +139,14 @@ export default defineFunction({
     }).pipe(Effect.provide(FetchHttpClient.layer)),
 });
 
+const getUrl = (userId: string, messageId?: string, params?: Record<string, any>) => {
+  const api = new URL(
+    [`https://gmail.googleapis.com/gmail/v1/users/${userId}/messages`, messageId].filter(Boolean).join('/'),
+  );
+  Object.entries(params ?? {}).forEach(([key, value]) => api.searchParams.set(key, value));
+  return api.toString();
+};
+
 /**
  * Parses an email string in the format "Name <email@example.com>" into separate name and email components.
  */
@@ -153,92 +163,96 @@ const parseEmailString = (emailString: string): { name?: string; email: string }
   return undefined;
 };
 
-// TODO(wittjosiah): These schemas should be imported from @dxos/schema.
-
 //
 // Schemas
+// TODO(wittjosiah): These schemas should be imported from @dxos/schema.
 //
 
 const ActorRoles = ['user', 'assistant'] as const;
-const ActorRole = S.Literal(...ActorRoles);
-type ActorRole = S.Schema.Type<typeof ActorRole>;
-
-const ActorSchema = S.Struct({
-  identityKey: S.optional(S.String),
-  email: S.optional(S.String),
-  name: S.optional(S.String),
-  role: S.optional(ActorRole),
+const ActorRole = Schema.Literal(...ActorRoles);
+type ActorRole = Schema.Schema.Type<typeof ActorRole>;
+
+const ActorSchema = Schema.Struct({
+  identityKey: Schema.optional(Schema.String),
+  email: Schema.optional(Schema.String),
+  name: Schema.optional(Schema.String),
+  role: Schema.optional(ActorRole),
 });
 
-const AbstractContentBlock = S.Struct({
-  pending: S.optional(S.Boolean),
+const AbstractContentBlock = Schema.Struct({
+  pending: Schema.optional(Schema.Boolean),
 });
-type AbstractContentBlock = S.Schema.Type<typeof AbstractContentBlock>;
-const TextContentBlock = S.extend(
+type AbstractContentBlock = Schema.Schema.Type<typeof AbstractContentBlock>;
+const TextContentBlock = Schema.extend(
   AbstractContentBlock,
-  S.Struct({
-    type: S.Literal('text'),
-    disposition: S.optional(S.String),
-    text: S.String,
+  Schema.Struct({
+    type: Schema.Literal('text'),
+    disposition: Schema.optional(Schema.String),
+    text: Schema.String,
   }),
-).pipe(S.mutable);
-type TextContentBlock = S.Schema.Type<typeof TextContentBlock>;
-const JsonContentBlock = S.extend(
+).pipe(Schema.mutable);
+type TextContentBlock = Schema.Schema.Type<typeof TextContentBlock>;
+const JsonContentBlock = Schema.extend(
   AbstractContentBlock,
-  S.Struct({
-    type: S.Literal('json'),
-    disposition: S.optional(S.String),
-    data: S.String,
+  Schema.Struct({
+    type: Schema.Literal('json'),
+    disposition: Schema.optional(Schema.String),
+    data: Schema.String,
   }),
-).pipe(S.mutable);
-type JsonContentBlock = S.Schema.Type<typeof JsonContentBlock>;
-const Base64ImageSource = S.Struct({
-  type: S.Literal('base64'),
-  mediaType: S.String,
-  data: S.String,
-}).pipe(S.mutable);
-const HttpImageSource = S.Struct({
-  type: S.Literal('http'),
-  url: S.String,
-}).pipe(S.mutable);
-const ImageSource = S.Union(Base64ImageSource, HttpImageSource);
-type ImageSource = S.Schema.Type<typeof ImageSource>;
-const ImageContentBlock = S.extend(
+).pipe(Schema.mutable);
+type JsonContentBlock = Schema.Schema.Type<typeof JsonContentBlock>;
+const Base64ImageSource = Schema.Struct({
+  type: Schema.Literal('base64'),
+  mediaType: Schema.String,
+  data: Schema.String,
+}).pipe(Schema.mutable);
+const HttpImageSource = Schema.Struct({
+  type: Schema.Literal('http'),
+  url: Schema.String,
+}).pipe(Schema.mutable);
+const ImageSource = Schema.Union(Base64ImageSource, HttpImageSource);
+type ImageSource = Schema.Schema.Type<typeof ImageSource>;
+const ImageContentBlock = Schema.extend(
   AbstractContentBlock,
-  S.Struct({
-    type: S.Literal('image'),
-    id: S.optional(S.String),
-    source: S.optional(ImageSource),
+  Schema.Struct({
+    type: Schema.Literal('image'),
+    id: Schema.optional(Schema.String),
+    source: Schema.optional(ImageSource),
   }),
-).pipe(S.mutable);
-type ImageContentBlock = S.Schema.Type<typeof ImageContentBlock>;
-const ReferenceContentBlock = S.extend(
+).pipe(Schema.mutable);
+type ImageContentBlock = Schema.Schema.Type<typeof ImageContentBlock>;
+const ReferenceContentBlock = Schema.extend(
   AbstractContentBlock,
-  S.Struct({
-    type: S.Literal('reference'),
-    reference: S.Any,
+  Schema.Struct({
+    type: Schema.Literal('reference'),
+    reference: Schema.Any,
   }),
-).pipe(S.mutable);
-type ReferenceContentBlock = S.Schema.Type<typeof ReferenceContentBlock>;
-const MessageContentBlock = S.Union(TextContentBlock, JsonContentBlock, ImageContentBlock, ReferenceContentBlock);
+).pipe(Schema.mutable);
+type ReferenceContentBlock = Schema.Schema.Type<typeof ReferenceContentBlock>;
+const MessageContentBlock = Schema.Union(TextContentBlock, JsonContentBlock, ImageContentBlock, ReferenceContentBlock);
 
-const MessageType = S.Struct({
+const MessageType = Schema.Struct({
   id: ObjectId,
-  created: S.String.annotations({
+  created: Schema.String.annotations({
     description: 'ISO date string when the message was sent.',
   }),
   sender: ActorSchema.annotations({
     description: 'Identity of the message sender.',
   }),
-  blocks: S.Array(MessageContentBlock).annotations({
+  blocks: Schema.Array(MessageContentBlock).annotations({
     description: 'Contents of the message.',
   }),
-  properties: S.optional(
-    S.mutable(
-      S.Record({ key: S.String, value: S.Any }).annotations({
+  properties: Schema.optional(
+    Schema.mutable(
+      Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
         description: 'Custom properties for specific message types (e.g. attention context, email subject, etc.).',
       }),
     ),
   ),
-}).pipe(EchoObject({ typename: 'dxos.org/type/Message', version: '0.1.0' }));
-type MessageType = S.Schema.Type<typeof MessageType>;
+}).pipe(
+  Type.def({
+    typename: 'dxos.org/type/Message',
+    version: '0.1.0',
+  }),
+);
+type MessageType = Schema.Schema.Type<typeof MessageType>;

package/src/translations.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { ScriptType } from '@dxos/functions/types';
+import { ScriptType } from '@dxos/functions';
 
 import { SCRIPT_PLUGIN } from './meta';