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

package/src/templates/chess.ts

@@ -2,26 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
 // @ts-ignore
-import { defineFunction } from 'dxos:functions';
+import { defineFunction, S } 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: Schema.Struct({
-    changedObjectId: Schema.String.annotations({
+  inputSchema: S.Struct({
+    changedObjectId: S.String.annotations({
       description: 'The objects to play the game on.',
     }),
-    player: Schema.optional(Schema.Literal('w', 'b')).annotations({
+    player: S.optional(S.Literal('w', 'b')).annotations({
       description: 'The player to play the game as.',
     }),
   }),
 
-  outputSchema: Schema.Struct({
-    state: Schema.String.annotations({
+  outputSchema: S.Struct({
+    state: S.String.annotations({
       description: 'The state of the game as an ASCII art board.',
     }),
   }),

package/src/templates/data-generator.ts

@@ -2,20 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
 // @ts-ignore
 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: Schema.Struct({
-    documentAmount: Schema.optional(Schema.Number),
-    textSize: Schema.optional(Schema.Number),
-    mutationAmount: Schema.optional(Schema.Number),
+  inputSchema: S.Struct({
+    documentAmount: S.optional(S.Number),
+    textSize: S.optional(S.Number),
+    mutationAmount: S.optional(S.Number),
   }),
 
-  outputSchema: Schema.Struct({}),
+  outputSchema: S.Struct({}),
 
   handler: async ({
     event: {

package/src/templates/discord.ts

@@ -2,9 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
 // @ts-ignore
-import { create, defineFunction, DXN, Filter, ObjectId, S } from 'dxos:functions';
+import { create, EchoObject, defineFunction, DXN, Filter, ObjectId, S } from 'dxos:functions';
 import {
   FetchHttpClient,
   // @ts-ignore
@@ -14,20 +13,13 @@ import { DiscordConfig, DiscordREST, DiscordRESTMemoryLive } from 'https://esm.s
 // @ts-ignore
 import { Effect, Config, Redacted, Ref } from 'https://esm.sh/effect@3.13.3';
 
-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 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' }));
 
 const DEFAULT_AFTER = 1704067200; // 2024-01-01
 
@@ -37,17 +29,17 @@ const generateSnowflake = (unixTimestamp: number): bigint => {
 };
 
 export default defineFunction({
-  inputSchema: Schema.Struct({
+  inputSchema: S.Struct({
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
-    tick: Schema.optional(Schema.String),
-    channelId: Schema.String,
-    after: Schema.optional(Schema.Number),
-    pageSize: Schema.optional(Schema.Number),
-    queueId: Schema.String,
+    tick: S.optional(S.String),
+    channelId: S.String,
+    after: S.optional(S.Number),
+    pageSize: S.optional(S.Number),
+    queueId: S.String,
   }),
 
-  outputSchema: Schema.Struct({
-    newMessages: Schema.Number,
+  outputSchema: S.Struct({
+    newMessages: S.Number,
   }),
 
   handler: ({

package/src/templates/forex-effect.ts

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

package/src/templates/forex.ts

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

package/src/templates/gmail.ts

@@ -3,8 +3,7 @@
 //
 
 // @ts-ignore
-import { create, defineFunction, Filter, ObjectId } from 'dxos:functions';
-// @ts-ignore
+import { create, defineFunction, EchoObject, Filter, ObjectId, S } from 'dxos:functions';
 import {
   HttpClient,
   HttpClientRequest,
@@ -12,33 +11,30 @@ import {
   // @ts-ignore
 } from 'https://esm.sh/@effect/platform@0.77.2?deps=effect@3.13.3';
 // @ts-ignore
-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';
+import { pipe, Chunk, Effect, Ref, Schedule, Stream } from 'https://esm.sh/effect@3.13.3';
 
-import { Type } from '@dxos/echo';
+// TODO(ZaymonFC): Calculate this dynamically and expose a parameter.
+const DEFAULT_AFTER = '2025-01-01';
 
 export default defineFunction({
-  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)),
+  inputSchema: S.Struct({
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
-    tick: Schema.optional(Schema.String),
+    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,
   }),
 
-  outputSchema: Schema.Struct({
-    newMessages: Schema.Number,
+  outputSchema: S.Struct({
+    newMessages: S.Number,
   }),
 
   handler: ({
-    context: { space },
     event: {
-      data: { mailboxId, userId, after, pageSize },
+      data: { mailboxId, userId = 'me', after = DEFAULT_AFTER, pageSize = 100 },
     },
+    context: { space },
   }: any) =>
     Effect.gen(function* () {
       const { token } = yield* Effect.tryPromise({
@@ -46,10 +42,9 @@ export default defineFunction({
         catch: (e: any) => e,
       });
 
-      // NOTE: Google API bundles size is v. large and caused runtime issues.
-      const makeRequest = (url: string) =>
+      const makeRequest = (path: string) =>
         pipe(
-          url,
+          path,
           HttpClientRequest.get,
           HttpClientRequest.setHeaders({ Authorization: `Bearer ${token}`, Accept: 'application/json' }),
           HttpClient.execute,
@@ -59,10 +54,13 @@ export default defineFunction({
           Effect.scoped,
         );
 
-      const listMessages = (userId: string, q: string, pageSize: number, pageToken: string | null) =>
-        makeRequest(getUrl(userId, undefined, { q, pageSize, pageToken }));
+      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 getMessage = (userId: string, messageId: string) => makeRequest(getUrl(userId, messageId));
+      const getMessage = (userId: string, id: string) =>
+        makeRequest(`https://gmail.googleapis.com/gmail/v1/users/${userId}/messages/${id}`);
 
       const mailbox = yield* Effect.tryPromise({
         try: () => space.db.query({ id: mailboxId }).first(),
@@ -139,14 +137,6 @@ 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.
  */
@@ -163,96 +153,92 @@ 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 = 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 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 AbstractContentBlock = Schema.Struct({
-  pending: Schema.optional(Schema.Boolean),
+const AbstractContentBlock = S.Struct({
+  pending: S.optional(S.Boolean),
 });
-type AbstractContentBlock = Schema.Schema.Type<typeof AbstractContentBlock>;
-const TextContentBlock = Schema.extend(
+type AbstractContentBlock = S.Schema.Type<typeof AbstractContentBlock>;
+const TextContentBlock = S.extend(
   AbstractContentBlock,
-  Schema.Struct({
-    type: Schema.Literal('text'),
-    disposition: Schema.optional(Schema.String),
-    text: Schema.String,
+  S.Struct({
+    type: S.Literal('text'),
+    disposition: S.optional(S.String),
+    text: S.String,
   }),
-).pipe(Schema.mutable);
-type TextContentBlock = Schema.Schema.Type<typeof TextContentBlock>;
-const JsonContentBlock = Schema.extend(
+).pipe(S.mutable);
+type TextContentBlock = S.Schema.Type<typeof TextContentBlock>;
+const JsonContentBlock = S.extend(
   AbstractContentBlock,
-  Schema.Struct({
-    type: Schema.Literal('json'),
-    disposition: Schema.optional(Schema.String),
-    data: Schema.String,
+  S.Struct({
+    type: S.Literal('json'),
+    disposition: S.optional(S.String),
+    data: S.String,
   }),
-).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(
+).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(
   AbstractContentBlock,
-  Schema.Struct({
-    type: Schema.Literal('image'),
-    id: Schema.optional(Schema.String),
-    source: Schema.optional(ImageSource),
+  S.Struct({
+    type: S.Literal('image'),
+    id: S.optional(S.String),
+    source: S.optional(ImageSource),
   }),
-).pipe(Schema.mutable);
-type ImageContentBlock = Schema.Schema.Type<typeof ImageContentBlock>;
-const ReferenceContentBlock = Schema.extend(
+).pipe(S.mutable);
+type ImageContentBlock = S.Schema.Type<typeof ImageContentBlock>;
+const ReferenceContentBlock = S.extend(
   AbstractContentBlock,
-  Schema.Struct({
-    type: Schema.Literal('reference'),
-    reference: Schema.Any,
+  S.Struct({
+    type: S.Literal('reference'),
+    reference: S.Any,
   }),
-).pipe(Schema.mutable);
-type ReferenceContentBlock = Schema.Schema.Type<typeof ReferenceContentBlock>;
-const MessageContentBlock = Schema.Union(TextContentBlock, JsonContentBlock, ImageContentBlock, ReferenceContentBlock);
+).pipe(S.mutable);
+type ReferenceContentBlock = S.Schema.Type<typeof ReferenceContentBlock>;
+const MessageContentBlock = S.Union(TextContentBlock, JsonContentBlock, ImageContentBlock, ReferenceContentBlock);
 
-const MessageType = Schema.Struct({
+const MessageType = S.Struct({
   id: ObjectId,
-  created: Schema.String.annotations({
+  created: S.String.annotations({
     description: 'ISO date string when the message was sent.',
   }),
   sender: ActorSchema.annotations({
     description: 'Identity of the message sender.',
   }),
-  blocks: Schema.Array(MessageContentBlock).annotations({
+  blocks: S.Array(MessageContentBlock).annotations({
     description: 'Contents of the message.',
   }),
-  properties: Schema.optional(
-    Schema.mutable(
-      Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
+  properties: S.optional(
+    S.mutable(
+      S.Record({ key: S.String, value: S.Any }).annotations({
         description: 'Custom properties for specific message types (e.g. attention context, email subject, etc.).',
       }),
     ),
   ),
-}).pipe(
-  Type.def({
-    typename: 'dxos.org/type/Message',
-    version: '0.1.0',
-  }),
-);
-type MessageType = Schema.Schema.Type<typeof MessageType>;
+}).pipe(EchoObject({ typename: 'dxos.org/type/Message', version: '0.1.0' }));
+type MessageType = S.Schema.Type<typeof MessageType>;

package/src/translations.ts

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

package/src/types.ts

@@ -2,10 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema, SchemaAST } from 'effect';
+import { TitleAnnotationId } from 'effect/SchemaAST';
 
 import { SpaceSchema } from '@dxos/client/echo';
-import { ScriptType } from '@dxos/functions';
+import { S } from '@dxos/echo-schema';
+import { ScriptType } from '@dxos/functions/types';
 import { EditorInputMode } from '@dxos/react-ui-editor';
 
 import { SCRIPT_PLUGIN } from './meta';
@@ -16,27 +17,27 @@ export { SCRIPT_PLUGIN };
 export namespace ScriptAction {
   const SCRIPT_ACTION = `${SCRIPT_PLUGIN}/action`;
 
-  export const CreateScriptSchema = Schema.Struct({
-    name: Schema.optional(Schema.String),
+  export const CreateScriptSchema = S.Struct({
+    name: S.optional(S.String),
     // TODO(wittjosiah): Placeholder annotation?
-    gistUrl: Schema.optional(Schema.String.annotations({ [SchemaAST.TitleAnnotationId]: 'Import from Gist (url)' })),
-    initialTemplateId: Schema.optional(Schema.String),
+    gistUrl: S.optional(S.String.annotations({ [TitleAnnotationId]: 'Import from Gist (url)' })),
+    initialTemplateId: S.optional(S.String),
   });
 
-  export type CreateScriptProps = Schema.Schema.Type<typeof CreateScriptSchema>;
+  export type CreateScriptProps = S.Schema.Type<typeof CreateScriptSchema>;
 
-  export class Create extends Schema.TaggedClass<Create>()(`${SCRIPT_ACTION}/create`, {
-    input: Schema.extend(CreateScriptSchema, Schema.Struct({ space: SpaceSchema })),
-    output: Schema.Struct({
+  export class Create extends S.TaggedClass<Create>()(`${SCRIPT_ACTION}/create`, {
+    input: S.extend(CreateScriptSchema, S.Struct({ space: SpaceSchema })),
+    output: S.Struct({
       object: ScriptType,
     }),
   }) {}
 }
 
-export const ScriptSettingsSchema = Schema.mutable(
-  Schema.Struct({
+export const ScriptSettingsSchema = S.mutable(
+  S.Struct({
     editorInputMode: EditorInputMode,
   }),
 );
 
-export type ScriptSettingsProps = Schema.Schema.Type<typeof ScriptSettingsSchema>;
+export type ScriptSettingsProps = S.Schema.Type<typeof ScriptSettingsSchema>;

package/src/util/deploy.ts

@@ -7,11 +7,12 @@ import {
   FunctionType,
   type ScriptType,
   getUserFunctionUrlInMetadata,
+  incrementSemverPatch,
   makeFunctionUrl,
   setUserFunctionUrlInMetadata,
+  uploadWorkerFunction,
 } from '@dxos/functions';
 import { Bundler } from '@dxos/functions/bundler';
-import { incrementSemverPatch, uploadWorkerFunction } from '@dxos/functions/edge';
 import { log } from '@dxos/log';
 import { live, getMeta, makeRef, type Space } from '@dxos/react-client/echo';
 

package/dist/lib/browser/ScriptContainer-YI4U25EM.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/components/ScriptContainer.tsx", "../../../src/components/ScriptToolbar/ScriptToolbar.tsx", "../../../src/components/TypescriptEditor/TypescriptEditor.tsx"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport React, { useMemo } from 'react';\n\nimport { type ScriptType } from '@dxos/functions';\nimport { createDocAccessor, getSpace } from '@dxos/react-client/echo';\nimport { useIdentity } from '@dxos/react-client/halo';\nimport { type ThemedClassName } from '@dxos/react-ui';\nimport { createDataExtensions, listener, stackItemContentEditorClassNames } from '@dxos/react-ui-editor';\nimport { StackItem } from '@dxos/react-ui-stack';\nimport { mx } from '@dxos/react-ui-theme';\n\nimport { ScriptToolbar } from './ScriptToolbar';\nimport { TypescriptEditor, type TypescriptEditorProps } from './TypescriptEditor';\nimport { useDeployState, useToolbarState } from '../hooks';\nimport { type ScriptSettingsProps } from '../types';\n\nexport type ScriptEditorProps = ThemedClassName<\n  {\n    role?: string;\n    script: ScriptType;\n    settings?: ScriptSettingsProps;\n  } & Pick<TypescriptEditorProps, 'env'>\n>;\n\nexport const ScriptContainer = ({\n  classNames,\n  role,\n  script,\n  settings = { editorInputMode: 'vscode' },\n  env,\n}: ScriptEditorProps) => {\n  const identity = useIdentity();\n  const space = getSpace(script);\n  const state = useToolbarState();\n  useDeployState({ state, script });\n\n  const extensions = useMemo(\n    () => [\n      listener({\n        onChange: (text) => {\n          if (script.source.target && script.source.target.content !== text) {\n            script.changed = true;\n          }\n        },\n      }),\n      createDataExtensions({\n        id: script.id,\n        text: script.source.target && createDocAccessor(script.source.target, ['content']),\n        space,\n        identity,\n      }),\n    ],\n    [identity, space, script, script.source.target],\n  );\n\n  return (\n    <StackItem.Content toolbar classNames='divide-y divide-separator'>\n      <ScriptToolbar state={state} role={role} script={script} />\n      <TypescriptEditor\n        id={script.id}\n        env={env}\n        initialValue={script.source?.target?.content}\n        extensions={extensions}\n        className={mx(stackItemContentEditorClassNames(role))}\n        inputMode={settings.editorInputMode}\n        toolbar\n      />\n    </StackItem.Content>\n  );\n};\n\nexport default ScriptContainer;\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport React, { useCallback } from 'react';\n\nimport { type ScriptType } from '@dxos/functions';\nimport { fullyQualifiedId } from '@dxos/react-client/echo';\nimport { ElevationProvider, type ThemedClassName } from '@dxos/react-ui';\nimport { stackItemContentToolbarClassNames } from '@dxos/react-ui-editor';\nimport { createGapSeparator, MenuProvider, ToolbarMenu, useMenuActions } from '@dxos/react-ui-menu';\n\nimport {\n  type ScriptToolbarState,\n  createDeploy,\n  createFormat,\n  createTemplateSelect,\n  useToolbarAction,\n} from '../../hooks';\n\nexport type ScriptToolbarProps = ThemedClassName<{\n  role?: string;\n  script: ScriptType;\n  state: ScriptToolbarState;\n}>;\n\nconst createToolbar = (state: ScriptToolbarState) => {\n  const templateSelect = createTemplateSelect();\n  const format = createFormat();\n  const gap = createGapSeparator();\n  const deploy = createDeploy(state);\n  return {\n    nodes: [...templateSelect.nodes, ...format.nodes, ...gap.nodes, ...deploy.nodes],\n    edges: [...templateSelect.edges, ...format.edges, ...gap.edges, ...deploy.edges],\n  };\n};\n\nexport const ScriptToolbar = ({ script, role, state, classNames }: ScriptToolbarProps) => {\n  const handleAction = useToolbarAction({ state, script });\n  const toolbarCreator = useCallback(() => createToolbar(state), [state]);\n  const menu = useMenuActions(toolbarCreator);\n\n  return (\n    <div role='none' className={stackItemContentToolbarClassNames(role)}>\n      <ElevationProvider elevation={role === 'section' ? 'positioned' : 'base'}>\n        <MenuProvider {...menu} onAction={handleAction} attendableId={fullyQualifiedId(script)}>\n          <ToolbarMenu classNames={classNames} />\n        </MenuProvider>\n      </ElevationProvider>\n    </div>\n  );\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { javascript } from '@codemirror/lang-javascript';\nimport { defaultHighlightStyle } from '@codemirror/language';\nimport { Prec } from '@codemirror/state';\nimport { oneDarkHighlightStyle } from '@codemirror/theme-one-dark';\nimport { keymap } from '@codemirror/view';\nimport { tags } from '@lezer/highlight';\nimport { type VirtualTypeScriptEnvironment } from '@typescript/vfs';\nimport { continueKeymap } from '@valtown/codemirror-continue';\nimport { tsSync, tsFacet, tsLinter, tsAutocomplete, tsHover, type HoverInfo } from '@valtown/codemirror-ts';\nimport React from 'react';\n\nimport { type ThemeMode, useThemeContext } from '@dxos/react-ui';\nimport {\n  autocomplete,\n  createBasicExtensions,\n  createThemeExtensions,\n  editorFullWidth,\n  type EditorInputMode,\n  editorMonospace,\n  EditorView,\n  folding,\n  InputModeExtensions,\n  useTextEditor,\n  type UseTextEditorProps,\n} from '@dxos/react-ui-editor';\nimport { isNonNullable } from '@dxos/util';\n\nexport type TypescriptEditorProps = {\n  id: string;\n  inputMode?: EditorInputMode;\n  env?: VirtualTypeScriptEnvironment;\n  toolbar?: boolean;\n} & Pick<UseTextEditorProps, 'className' | 'initialValue' | 'extensions' | 'scrollTo' | 'selection'>;\n\nexport const TypescriptEditor = ({\n  id,\n  env,\n  className,\n  initialValue,\n  extensions,\n  scrollTo,\n  selection,\n  toolbar,\n  inputMode = 'vscode',\n}: TypescriptEditorProps) => {\n  const { themeMode } = useThemeContext();\n  const { parentRef, focusAttributes } = useTextEditor(\n    () => ({\n      id,\n      initialValue,\n      extensions: [\n        extensions,\n        createBasicExtensions({\n          highlightActiveLine: true,\n          indentWithTab: true,\n          lineNumbers: true,\n          lineWrapping: false,\n          scrollPastEnd: true,\n        }),\n        createThemeExtensions({\n          themeMode,\n          syntaxHighlighting: true,\n          slots: {\n            content: { className: editorFullWidth },\n          },\n        }),\n        // NOTE: Not using default editor gutter because folding for code works best right beside text.\n        EditorView.theme({\n          '.cm-gutters': {\n            // Match margin from content.\n            marginTop: '16px',\n            background: 'var(--dx-baseSurface)',\n          },\n        }),\n        InputModeExtensions[inputMode],\n        folding(),\n        // Continues block comments when you hit Enter.\n        Prec.high(keymap.of(continueKeymap)),\n        // TODO(burdon): Factor out.\n        [\n          editorMonospace,\n          javascript({ typescript: true }),\n          // https://github.com/val-town/codemirror-ts\n          autocomplete({ override: env ? [tsAutocomplete()] : [] }),\n          env\n            ? [\n                tsFacet.of({ env, path: `/src/${id}.ts` }),\n                tsSync(),\n                tsLinter(),\n                tsHover({ renderTooltip: createTooltipRenderer(themeMode) }),\n              ]\n            : [],\n        ],\n      ].filter(isNonNullable),\n      selection,\n      scrollTo,\n    }),\n    [id, extensions, themeMode, inputMode, selection, scrollTo],\n  );\n\n  return (\n    <div ref={parentRef} data-toolbar={toolbar ? 'enabled' : 'disabled'} className={className} {...focusAttributes} />\n  );\n};\n\nconst createTooltipRenderer = (themeMode: ThemeMode) => {\n  const theme = themeMode === 'dark' ? oneDarkHighlightStyle : defaultHighlightStyle;\n\n  const classFromKind = (_kind: string) => {\n    // E.g., localName, methodName, parameterName, etc.\n    const kind = _kind.endsWith('Name') ? 'name' : _kind;\n    const validTag = kind in tags;\n    if (!validTag) {\n      return '';\n    }\n\n    const tag = tags[kind as keyof typeof tags];\n    if (typeof tag === 'function') {\n      return '';\n    }\n\n    return theme.style([tag]) ?? '';\n  };\n\n  return (info: HoverInfo) => {\n    const div = document.createElement('div');\n    div.className = 'p-1 rounded border border-separator bg-baseSurface xs:max-w-80 max-w-lg';\n\n    if (info.quickInfo?.displayParts) {\n      for (const part of info.quickInfo.displayParts) {\n        const span = div.appendChild(document.createElement('span'));\n        span.className = classFromKind(part.kind);\n        span.innerText = part.text;\n      }\n    }\n\n    return { dom: div };\n  };\n};\n\nexport default TypescriptEditor;\n"],
-  "mappings": "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",
-  "names": ["React", "useMemo", "createDocAccessor", "getSpace", "useIdentity", "createDataExtensions", "listener", "stackItemContentEditorClassNames", "StackItem", "mx", "React", "useCallback", "fullyQualifiedId", "ElevationProvider", "stackItemContentToolbarClassNames", "createGapSeparator", "MenuProvider", "ToolbarMenu", "useMenuActions", "createToolbar", "state", "templateSelect", "createTemplateSelect", "format", "createFormat", "gap", "createGapSeparator", "deploy", "createDeploy", "nodes", "edges", "ScriptToolbar", "script", "role", "classNames", "handleAction", "useToolbarAction", "toolbarCreator", "useCallback", "menu", "useMenuActions", "div", "className", "stackItemContentToolbarClassNames", "ElevationProvider", "elevation", "MenuProvider", "onAction", "attendableId", "fullyQualifiedId", "ToolbarMenu", "javascript", "defaultHighlightStyle", "Prec", "oneDarkHighlightStyle", "keymap", "tags", "continueKeymap", "tsSync", "tsFacet", "tsLinter", "tsAutocomplete", "tsHover", "React", "useThemeContext", "autocomplete", "createBasicExtensions", "createThemeExtensions", "editorFullWidth", "editorMonospace", "EditorView", "folding", "InputModeExtensions", "useTextEditor", "isNonNullable", "TypescriptEditor", "id", "env", "className", "initialValue", "extensions", "scrollTo", "selection", "toolbar", "inputMode", "themeMode", "useThemeContext", "parentRef", "focusAttributes", "useTextEditor", "createBasicExtensions", "highlightActiveLine", "indentWithTab", "lineNumbers", "lineWrapping", "scrollPastEnd", "createThemeExtensions", "syntaxHighlighting", "slots", "content", "editorFullWidth", "EditorView", "theme", "marginTop", "background", "InputModeExtensions", "folding", "Prec", "high", "keymap", "of", "continueKeymap", "editorMonospace", "javascript", "typescript", "autocomplete", "override", "tsAutocomplete", "tsFacet", "path", "tsSync", "tsLinter", "tsHover", "renderTooltip", "createTooltipRenderer", "filter", "isNonNullable", "React", "div", "ref", "data-toolbar", "oneDarkHighlightStyle", "defaultHighlightStyle", "classFromKind", "_kind", "kind", "endsWith", "validTag", "tags", "tag", "style", "info", "document", "createElement", "quickInfo", "displayParts", "part", "span", "appendChild", "innerText", "text", "dom", "ScriptContainer", "classNames", "role", "script", "settings", "editorInputMode", "env", "identity", "useIdentity", "space", "getSpace", "state", "useToolbarState", "useDeployState", "extensions", "useMemo", "listener", "onChange", "text", "source", "target", "content", "changed", "createDataExtensions", "id", "createDocAccessor", "React", "StackItem", "Content", "toolbar", "ScriptToolbar", "TypescriptEditor", "initialValue", "className", "mx", "stackItemContentEditorClassNames", "inputMode"]
-}

package/dist/lib/browser/artifact-definition-PD4UAAQZ.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/capabilities/artifact-definition.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Schema } from 'effect';\n\nimport { Capabilities, contributes, createIntent, type PromiseIntentDispatcher } from '@dxos/app-framework';\nimport { defineArtifact, defineTool, ToolResult } from '@dxos/artifact';\nimport { createArtifactElement } from '@dxos/assistant';\nimport { ScriptType } from '@dxos/functions';\nimport { invariant } from '@dxos/invariant';\nimport { SpaceAction } from '@dxos/plugin-space/types';\nimport { live, makeRef, type Space } from '@dxos/react-client/echo';\nimport { DataType } from '@dxos/schema';\n\nimport { meta } from '../meta';\n// TODO(burdon): Factor out.\ndeclare global {\n  interface ToolContextExtensions {\n    space?: Space;\n    dispatch?: PromiseIntentDispatcher;\n  }\n}\n\nexport default () => {\n  const definition = defineArtifact({\n    id: `artifact:${meta.id}`,\n    name: meta.name,\n    // TODO(dmaretskyi): Since writing scripts requires a lot of domain knowledge,\n    //  we should offload the work of synthesizing the code to a separate model.\n    //  The main reasoning model will give it a concrete task and the script model will synthesize the code, knowing all the docs.\n    instructions: `\n      If the user explicitly requests you to write a script, you can create one.\n      If the user requests you to change one of the existing script, you can update it.\n      You must not create a script unless the user explicitly requests it.\n      Scripts are short code pieces of executable code that can be used to perform computations, integrate with external systems, and perform automated tasks.\n      Each script must follow as strict shape for the definition but the body can contain any valid executable code.\n      Scripts are written in JavaScript or TypeScript.\n      Each script must define an input schema and output schema.\n      Each script must have its own detailed description.\n\n      Important: You cannot execute scripts. Scripts are only available as tools after the user deploys them. You must only call the available tools.\n\n      Description:\n        The description is a detailed description of the script.\n        It is used to describe the script's purpose, input, and output.\n        The description is used to generate the script's documentation.\n        The description is also goes into the script metadata.\n        The description is used by AI to understand the script and its purpose.\n        The description must provide cases on when the script should be used.\n\n      Schema: \n        The schema is defined using a schema-DSL library called Effect Schema.\n        The input schema describes the arguments that the script accepts.\n        The output schema describes the result that the script produces.\n        The schema is used to validate the script's input and output.\n        The schema is also goes into the script metadata.\n        The properties in the schema must have valid descriptions.\n        The input and output schemas must both be a struct of fields.\n\n      Restricts:\n        The scripts can only import code from \"dxos:functions\" module. No other modules are allowed.\n        Some web APIs are available - like fetch.\n\n      Reasoning:\n        Before writing a script, synthesize the following information:\n        - Description\n        - What APIs will be used.\n        - Detailed input schema\n        - Detailed output schema\n\n      <apis>\n        export function defineFunction(params: { \n          description: string, \n          inputSchema: Schema.Schema, \n          outputSchema: Schema.Schema, \n          handler: (params: { event: { data: TInput } }) => Promise<TOutput> \n        }): FunctionDefinition\n        /**\n         * Effect Schema\n         */\n        export const Schema; \n\n        // Examples: \n\n        Schema.String\n        Schema.Number\n        Schema.Boolean\n        Schema.Struct({\n          from: Schema.String.annotations({ description: 'The source currency' }),\n          to: Schema.String.annotations({ description: 'The target currency' }),\n        })\n        Schema.Array(Schema.String)\n        Schema.Union(Schema.String, Schema.Number)\n        Schema.optional(Schema.String)\n        Schema.String.annotations({ description: 'The source currency' })\n      </apis>\n\n      <handler_function>\n        Async function that takes the argument in the form of:\n\n        type HandlerFunctionParam = {\n          event: {\n            data: T // The input schema\n          },\n        }\n\n        The function must return the result that matches the output schema.\n      </handler_function>\n      \n      <example>\n        import { defineFunction, S } from 'dxos:functions';\n\n        export default defineFunction({\n          description: 'Returns the exchange rate between two currencies.',\n\n          inputSchema: Schema.Struct({\n            from: Schema.String.annotations({ description: 'The source currency' }),\n            to: Schema.String.annotations({ description: 'The target currency' }),\n          }),\n\n          outputSchema: Schema.Struct({\n            rate: Schema.String.annotations({ description: 'The exchange rate' }),\n          }),\n\n          handler: async ({\n            event: {\n              data: { from, to },\n            },\n          }: any) => {\n            const res = await fetch(\\`https://free.ratesdb.com/v1/rates?from=\\${from}&to=\\${to}\\`);\n            const {\n              data: { rates },\n            } = await res.json();\n\n            return { rate: rates[to].toString() };\n          },\n        });\n      </example>\n  `,\n    schema: ScriptType,\n    tools: [\n      defineTool(meta.id, {\n        name: 'create',\n        description: 'Create a new script. Returns the artifact definition for the script',\n        caption: 'Creating script...',\n        schema: Schema.Struct({\n          name: Schema.String.annotations({ description: 'The name of the script' }),\n          code: Schema.String.annotations({\n            description: 'The full code of the script in JavaScript or TypeScript. Must be valid executable code.',\n          }),\n        }),\n        execute: async ({ name, code }, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n          invariant(extensions?.dispatch, 'No intent dispatcher');\n          const script = live(ScriptType, {\n            name,\n            source: makeRef(\n              live(DataType.Text, {\n                content: code,\n              }),\n            ),\n          });\n          extensions.space.db.add(script);\n          await extensions.space.db.flush();\n\n          const intent = createIntent(SpaceAction.AddObject, { target: extensions.space, object: script });\n          const { data, error } = await extensions.dispatch(intent);\n          if (!data || error) {\n            return ToolResult.Error(error?.message ?? 'Failed to create chess game');\n          }\n\n          return ToolResult.Success(createArtifactElement(script.id));\n        },\n      }),\n      defineTool(meta.id, {\n        name: 'inspect',\n        description: 'Inspect a script. Returns the artifact definition for the script',\n        caption: 'Inspecting script...',\n        schema: Schema.Struct({\n          // TODO(wittjosiah): ObjectId schema should be used here but it's not working.\n          id: Schema.String.annotations({ description: 'The ID of the script' }),\n        }),\n        execute: async ({ id }, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n\n          const script = (await extensions.space.db.query({ id }).first()) as ScriptType;\n          const { content } = await script.source.load();\n\n          return ToolResult.Success({\n            name: script.name,\n            code: content,\n          });\n        },\n      }),\n      defineTool(meta.id, {\n        name: 'update',\n        description: 'Update a script. Returns the artifact definition for the script',\n        caption: 'Updating script...',\n        schema: Schema.Struct({\n          // TODO(wittjosiah): ObjectId schema should be used here but it's not working.\n          id: Schema.String.annotations({ description: 'The ID of the script to update' }),\n          code: Schema.String.annotations({\n            description: 'The full code of the script in JavaScript or TypeScript. Must be valid executable code.',\n          }),\n        }),\n        execute: async ({ id, code }, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n\n          const script = (await extensions.space.db.query({ id }).first()) as ScriptType;\n          const source = await script.source.load();\n          if (!source) {\n            return ToolResult.Error('Script not found');\n          }\n\n          source.content = code;\n          await extensions.space?.db.flush();\n\n          return ToolResult.Success({\n            name: script.name,\n          });\n        },\n      }),\n    ],\n  });\n\n  return contributes(Capabilities.ArtifactDefinition, definition);\n};\n"],
-  "mappings": "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",
-  "names": ["Schema", "Capabilities", "contributes", "createIntent", "defineArtifact", "defineTool", "ToolResult", "createArtifactElement", "ScriptType", "invariant", "SpaceAction", "live", "makeRef", "DataType", "definition", "defineArtifact", "id", "meta", "name", "instructions", "schema", "ScriptType", "tools", "defineTool", "description", "caption", "Schema", "Struct", "String", "annotations", "code", "execute", "extensions", "invariant", "space", "dispatch", "script", "live", "source", "makeRef", "DataType", "Text", "content", "db", "add", "flush", "intent", "createIntent", "SpaceAction", "AddObject", "target", "object", "data", "error", "ToolResult", "Error", "message", "Success", "createArtifactElement", "query", "first", "load", "contributes", "Capabilities", "ArtifactDefinition"]
-}