@dxos/plugin-script 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

package/src/notebook/{notebook.ts → compute-graph.ts}

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Signal, signal } from '@preact/signals-core';
+import { Atom, type Registry } from '@effect-atom/atom-react';
 
 import { log } from '@dxos/log';
 
@@ -14,35 +14,76 @@ import { type ParsedExpression, VirtualTypeScriptParser } from './vfs-parser';
 /**
  * Compute graph that evaluates the notebook cells.
  */
+// TODO(burdon): Reconcile with @dxos/conductor.
 export class ComputeGraph {
   private readonly _parser = new VirtualTypeScriptParser();
 
-  private _expressions = signal<Record<string, ParsedExpression>>({});
-  private _values = signal<Record<string, any>>({});
+  private _expressionsAtom = Atom.make<Record<string, ParsedExpression>>({});
+  private _valuesByCellIdAtom = Atom.make<Record<string, any>>({});
+  private _valuesByNameAtom = Atom.make<Record<string, any>>({});
 
-  constructor(private readonly _notebook: Notebook.Notebook) {}
+  constructor(
+    private readonly _notebook: Notebook.Notebook,
+    private readonly _registry: Registry.Registry,
+  ) {}
 
   /**
-   * Parsed expressions by cell ID.
+   * Atom for parsed expressions by cell ID.
    */
-  get expressions(): Signal<Record<string, ParsedExpression>> {
-    return this._expressions;
+  get expressions(): Atom.Atom<Record<string, ParsedExpression>> {
+    return this._expressionsAtom;
   }
 
   /**
-   * Computed values by cell ID.
+   * Get current expressions by cell ID.
    */
-  get values(): Signal<Record<string, any>> {
-    return this._values;
+  getExpressions(): Record<string, ParsedExpression> {
+    return this._registry.get(this._expressionsAtom);
+  }
+
+  /**
+   * Atom for computed values by cell ID.
+   */
+  get values(): Atom.Atom<Record<string, any>> {
+    return this._valuesByCellIdAtom;
+  }
+
+  /**
+   * Get computed values by cell ID.
+   */
+  getValues(): Record<string, any> {
+    return this._registry.get(this._valuesByCellIdAtom);
+  }
+
+  /**
+   * Atom for computed values by name.
+   */
+  get valuesByName(): Atom.Atom<Record<string, any>> {
+    return this._valuesByNameAtom;
+  }
+
+  /**
+   * Get current values by name.
+   */
+  getValuesByName(): Record<string, any> {
+    return this._registry.get(this._valuesByNameAtom);
+  }
+
+  /**
+   * Get computed value by cell ID.
+   */
+  getValue(cellId: string): any {
+    return this._registry.get(this._valuesByCellIdAtom)[cellId];
   }
 
   /**
    * Compute values.
    */
-  evaluate() {
+  async evaluate() {
     // Parse expressions.
     const { expressions, dependencyGraph } = this.parse();
-    this._values.value = {};
+    this._registry.set(this._valuesByCellIdAtom, {});
+    this._registry.set(this._valuesByNameAtom, {});
 
     // Create a map of cell IDs to expressions for easy lookup.
     const cellExpressions = new Map<string, ParsedExpression>();
@@ -65,7 +106,7 @@ export class ComputeGraph {
         continue;
       }
 
-      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.script?.target?.content;
+      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.source?.target?.content;
       if (!cellSource) {
         log.error('no source for cell', { cellId });
         continue;
@@ -90,7 +131,7 @@ export class ComputeGraph {
               rhs = rhs.slice(0, -1).trim();
             }
 
-            const result = evalScript(rhs, valuesByName);
+            const result = await this.eval(rhs, valuesByName);
             valuesByName[expr.name] = result;
             if (typeof result !== 'function') {
               valuesByCellId[cellId] = result;
@@ -98,18 +139,24 @@ export class ComputeGraph {
           }
         } else {
           // For expressions without assignment, just evaluate.
-          const result = evalScript(cellSource, valuesByName);
+          const result = await this.eval(cellSource, valuesByName);
           valuesByCellId[cellId] = result;
         }
       } catch (error) {
+        // TODO(burdon): Set error state.
         log.error('error evaluating cell', { cellId, error });
       }
     }
 
-    this._values.value = valuesByCellId;
+    this._registry.set(this._valuesByCellIdAtom, valuesByCellId);
+    this._registry.set(this._valuesByNameAtom, valuesByName);
     return valuesByCellId;
   }
 
+  private async eval(source: string, values: Record<string, any>) {
+    return evalScript(source, values);
+  }
+
   /**
    * Parse expressions.
    */
@@ -117,7 +164,7 @@ export class ComputeGraph {
     const expressions = this._notebook.cells
       .filter((cell) => cell.type === 'script')
       .reduce<Record<string, ParsedExpression>>((acc, cell) => {
-        const text = cell.script?.target?.content.trim();
+        const text = cell.source?.target?.content.trim();
         if (text) {
           const parsed = this._parser.parseExpression(text);
           acc[cell.id] = parsed;
@@ -128,7 +175,7 @@ export class ComputeGraph {
 
     // Build dependency graph.
     const dependencyGraph = this.buildDependencyGraph(expressions);
-    this._expressions.value = expressions;
+    this._registry.set(this._expressionsAtom, expressions);
     return { expressions, dependencyGraph };
   }
 

package/src/notebook/eval.ts

@@ -7,7 +7,7 @@ import { trim } from '@dxos/util';
 /**
  * Evaluate the script (with dependencies as arguments).
  */
-export const evalScript = (code: string, deps: Record<string, any> = {}) => {
+export const evalScript = async (code: string, deps: Record<string, any> = {}) => {
   // Create a sandboxed environment that blocks access to window and document.
   const sandbox = {
     ...deps,

package/src/notebook/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-export * from './notebook';
+export * from './compute-graph';

package/src/templates/anthropic.ts

@@ -0,0 +1,42 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as LanguageModel from '@effect/ai/LanguageModel';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import * as Stream from 'effect/Stream';
+
+import { AiService } from '@dxos/ai';
+import { defineFunction } from '@dxos/functions';
+
+export default defineFunction({
+  key: 'dxos.org/script/anthropic',
+  name: 'Anthropic Chat',
+  description: 'Chat with Anthropic',
+  inputSchema: Schema.Struct({
+    message: Schema.String,
+  }),
+  services: [AiService.AiService],
+  handler: ({ data }) => {
+    return Effect.gen(function* () {
+      const model = (yield* AiService.AiService).model('@anthropic/claude-sonnet-4-5');
+      //
+      // Basic example.
+      //
+      const { text } = yield* LanguageModel.generateText({ prompt: data.message }).pipe(Effect.provide(model));
+
+      //
+      // Streaming example.
+      //
+      const parts = yield* LanguageModel.streamText({
+        prompt: 'Count from 1 to 5, one number per line.',
+      }).pipe(Stream.runCollect, Effect.map(Chunk.toArray), Effect.provide(model));
+      const textDeltas = parts.filter((p) => p.type === 'text-delta');
+      const fullText = textDeltas.map((p) => (p as { delta: string }).delta).join('');
+
+      return { response: text, streamText: fullText };
+    });
+  },
+});

package/src/templates/chess-bot.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Chess as ChessJS } from 'chess.js';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Database, Obj, Type } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Chess } from '@dxos/plugin-chess/types';
+
+export default defineFunction({
+  key: 'dxos.org/script/chess-bot',
+  name: 'Chess Bot',
+  description: 'Plays a random move in a chess game.',
+
+  inputSchema: Schema.Struct({
+    game: Type.Ref(Chess.Game).annotations({
+      description: 'The chess game to comment on.',
+    }),
+    player: Schema.optional(Schema.Literal('white', 'black')).annotations({
+      description: 'The player to play the game as.',
+    }),
+  }),
+
+  outputSchema: Schema.Struct({
+    state: Schema.String.annotations({
+      description: 'The state of the game as an ASCII art board.',
+    }),
+  }),
+
+  types: [Chess.Game],
+  services: [Database.Service],
+
+  handler: Effect.fnUntraced(function* ({ data: { game, player = 'black' } }) {
+    const loadedGame = yield* Database.load(game);
+    const chess = new ChessJS();
+    chess.loadPgn(loadedGame.pgn ?? '');
+    if (chess.turn() !== (player === 'white' ? 'w' : 'b')) {
+      return { state: chess.ascii() };
+    }
+
+    const moves = chess.moves({ verbose: true });
+    const move = moves[Math.floor(Math.random() * moves.length)];
+    if (!move) {
+      return { state: chess.ascii() };
+    }
+
+    chess.move(move.san);
+    const newPgn = chess.pgn();
+    Obj.change(loadedGame, (g) => {
+      g.pgn = newPgn;
+    });
+    yield* Database.flush();
+    return { state: chess.ascii() };
+  }),
+});

package/src/templates/commentary.ts

@@ -0,0 +1,230 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as A from '@automerge/automerge';
+import { Chess as ChessJS } from 'chess.js';
+import * as Array from 'effect/Array';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+
+import { AiService, ConsolePrinter, ToolExecutionService, ToolResolverService } from '@dxos/ai';
+import { AiSession, GenerationObserver } from '@dxos/assistant';
+import { ArtifactId } from '@dxos/assistant';
+import { Database, Filter, Obj, Ref, Relation, Type } from '@dxos/echo';
+import { createDocAccessor } from '@dxos/echo-db';
+import { TracingService, defineFunction } from '@dxos/functions';
+import { log } from '@dxos/log';
+import { Chess } from '@dxos/plugin-chess/types';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { Collection, Text } from '@dxos/schema';
+import { HasSubject } from '@dxos/types';
+import { trim } from '@dxos/util';
+
+export default defineFunction({
+  key: 'dxos.org/function/chess/commentary',
+  name: 'Commentary',
+  description: 'Adds commentary about the most recent move to a markdown document associated with the chess game.',
+  inputSchema: Schema.Struct({
+    game: Type.Ref(Chess.Game).annotations({
+      description: 'The chess game to comment on.',
+    }),
+  }),
+  outputSchema: Schema.Union(
+    Schema.Struct({
+      documentId: ArtifactId.annotations({
+        description: 'The ID of the markdown document that was updated or created.',
+      }),
+      commentary: Schema.String.annotations({
+        description: 'The commentary that was added.',
+      }),
+    }),
+    Schema.Void.annotations({
+      description: 'Function did not find anything to comment on.',
+    }),
+  ),
+  types: [Chess.Game, Markdown.Document, Text.Text, HasSubject.HasSubject, Collection.Collection],
+  services: [AiService.AiService, Database.Service],
+  handler: Effect.fnUntraced(
+    function* ({ data: { game: gameRef } }) {
+      // Load the chess game
+      log.info('load game', { gameRef });
+      const chessGame = yield* Database.load(gameRef);
+
+      // Load the chess position from PGN or FEN
+      const chess = new ChessJS();
+      if (chessGame.pgn) {
+        chess.loadPgn(chessGame.pgn);
+      } else if (chessGame.fen) {
+        chess.load(chessGame.fen);
+      } else {
+        log.info('Early return: no pgn or fen');
+        return;
+      }
+
+      // Get the most recent move
+      const history = chess.history({ verbose: true });
+      if (history.length === 0) {
+        throw new Error('No moves have been played yet');
+      }
+      const lastMove = history[history.length - 1];
+      const moveNumber = Math.ceil(history.length / 2);
+      const isWhiteMove = history.length % 2 === 1;
+      const player = isWhiteMove ? 'White' : 'Black';
+      const moveNotation = lastMove.san;
+
+      // Generate AI commentary about the move
+      const result = yield* new AiSession().run({
+        prompt:
+          `Comment on this chess move as if you're commentating a live match for an audience:\n\n` +
+          `Move ${moveNumber}: ${player} plays ${moveNotation} (${lastMove.from} to ${lastMove.to})${lastMove.captured ? `, capturing ${lastMove.captured}` : ''}\n` +
+          `Current position: ${chess.fen()}\n` +
+          `${chess.isCheck() ? 'The king is in check! ' : ''}` +
+          `${chess.isCheckmate() ? 'CHECKMATE! ' : ''}` +
+          `${chess.isStalemate() ? 'STALEMATE! ' : ''}` +
+          `\nGame so far:\n${chess.pgn()}`,
+        system: COMMENTARY_SYSTEM_PROMPT,
+        history: [],
+        observer: GenerationObserver.fromPrinter(new ConsolePrinter({ tag: 'chess-commentary' })),
+      });
+
+      const commentaryText = Function.pipe(
+        result,
+        Array.findLast((msg) => msg.sender.role === 'assistant' && msg.blocks.some((block) => block._tag === 'text')),
+        Option.flatMap((msg) =>
+          Function.pipe(
+            msg.blocks,
+            Array.findLast((block) => block._tag === 'text'),
+            Option.map((block) => block.text),
+          ),
+        ),
+        Option.getOrThrowWith(() => new Error('No commentary generated')),
+      );
+
+      const commentary = `## Move ${moveNumber}: ${player} plays ${moveNotation}\n\n${commentaryText}\n\n`;
+      log.info('commentary', { commentary });
+
+      // TODO(wittjosiah): Functions currently don't support traversals.
+      // const docs = yield* Database.runQuery(
+      //   Query.select(Filter.id(chessGame.id)).targetOf(HasSubject.HasSubject).source(),
+      // ).pipe(Effect.map((objects) => objects.filter((object) => Obj.instanceOf(Markdown.Document, object))));
+      const docs = yield* Database.runQuery(Filter.type(HasSubject.HasSubject)).pipe(
+        Effect.map((relations) =>
+          relations.filter((relation) => {
+            // TODO(wittjosiah): This is a workaround for getTarget not handling deleted objects.
+            try {
+              log.info('relation', {
+                source: Obj.getDXN(Relation.getTarget(relation)).toString(),
+                game: Obj.getDXN(chessGame).toString(),
+              });
+              return Obj.getDXN(Relation.getTarget(relation)).toString() === Obj.getDXN(chessGame).toString();
+            } catch {
+              return false;
+            }
+          }),
+        ),
+        Effect.map((relations) =>
+          relations
+            .map((relation) => {
+              // TODO(wittjosiah): This is a workaround for getSource not handling deleted objects.
+              try {
+                return Relation.getSource(relation);
+              } catch {
+                return undefined;
+              }
+            })
+            .filter((source) => source !== undefined),
+        ),
+        Effect.map((sources) => {
+          const docs = sources.filter((source) => Obj.instanceOf(Markdown.Document, source));
+          log.info('docs', { sources, docs });
+          return docs;
+        }),
+      );
+      log.info('docs', { count: docs.length });
+
+      let document: Markdown.Document;
+      if (docs.length === 0) {
+        // TODO(wittjosiah): Deploy fails if `SpaceProperties` schema is imported because its from `client-protocol`.
+        const [properties] = yield* Database.runQuery(Filter.typename('dxos.org/type/Properties'));
+        const rootCollection = yield* Database.load<Collection.Collection>(properties[Collection.Collection.typename]);
+
+        log.info('rootCollection', { rootCollection });
+
+        // Create a new markdown document
+        const gameName = chessGame.name || 'Chess Game';
+        document = yield* Database.add(
+          Markdown.make({
+            name: `${gameName} Commentary`,
+            content: `# ${gameName} Commentary\n\n${commentary}`,
+          }),
+        );
+
+        const documentRef = Ref.make(document);
+        Obj.change(rootCollection, (c) => {
+          c.objects.push(documentRef);
+        });
+
+        // Create the HasSubject relation
+        yield* Database.add(
+          Relation.make(HasSubject.HasSubject, {
+            [Relation.Source]: document,
+            [Relation.Target]: chessGame,
+            completedAt: new Date().toISOString(),
+          }),
+        );
+      } else {
+        document = docs[0];
+
+        // Load the text content and append the commentary
+        const text = yield* Database.load(document.content);
+        const accessor = createDocAccessor(text, ['content']);
+        accessor.handle.change((doc: A.Doc<Text.Text>) => {
+          A.splice(doc, accessor.path.slice(), text.content.length, 0, commentary);
+        });
+      }
+
+      log.info('result', { documentId: Obj.getDXN(document).toString(), commentary });
+
+      yield* Database.flush();
+
+      return {
+        documentId: Obj.getDXN(document).toString(),
+        commentary,
+      };
+    },
+    Effect.provide(
+      Layer.mergeAll(
+        AiService.model('@anthropic/claude-haiku-4-5'),
+        ToolResolverService.layerEmpty,
+        ToolExecutionService.layerEmpty,
+        TracingService.layerNoop,
+      ),
+    ),
+  ),
+});
+
+const COMMENTARY_SYSTEM_PROMPT = trim`
+  You are a professional chess commentator providing live commentary for a chess match.
+
+  # Style
+  - Write in an engaging, enthusiastic style as if commentating for a live audience
+  - Be concise but informative (2-4 sentences)
+  - Explain the strategic implications of the move
+  - Note any tactical elements (captures, threats, checks)
+  - Comment on the position and what it means for the game
+
+  # Format
+  - Write in plain text (no markdown formatting in the commentary itself)
+  - Be natural and conversational
+  - Use chess terminology appropriately but keep it accessible
+
+  # Special Situations
+  - If it's checkmate, express excitement about the conclusion
+  - If it's check, note the pressure on the king
+  - If a piece is captured, mention the material exchange
+  - Comment on the development of pieces and control of key squares when relevant
+`;

package/src/templates/data-generator.ts

@@ -23,7 +23,7 @@ export default defineFunction({
     data: { documentAmount = 1, textSize = 10, mutationAmount = 0, waitAfterCreation = 10_000 },
     context: { space },
   }: any) => {
-    await space.db.graph.schemaRegistry.addSchema([Expando]);
+    await space.db.graph.schemaRegistry.register([Expando]);
     const result: Record<string, any> = {};
     const objects: Expando[] = [];
 

package/src/templates/forex-effect.ts

@@ -2,41 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
-import {
-  FetchHttpClient,
-  HttpClient,
-  HttpClientRequest,
-  // @ts-ignore
-} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
-// @ts-ignore
-import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
-// @ts-ignore
-import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import * as Effect from 'effect/Effect';
+import * as Schedule from 'effect/Schedule';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
 
 export default defineFunction({
   key: 'dxos.org/script/forex-effect',
   name: 'Forex Effect',
   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 ({ data: { from, to } }: any) =>
-    Effect.gen(function* () {
-      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
-        HttpClient.execute,
-        Effect.flatMap((res: any) => res.json),
-        Effect.timeout('1 second'),
-        Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
-        Effect.scoped,
-      );
+  handler: Effect.fnUntraced(function* ({ data: { from, to } }) {
+    const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+      HttpClient.execute,
+      Effect.flatMap((res: any) => res.json),
+      Effect.timeout('5 seconds'),
+      Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+      Effect.scoped,
+    );
 
-      return res.data.rates[to].toString();
-    }).pipe(Effect.provide(FetchHttpClient.layer)),
+    return (res as any).data.rates[to].toString();
+  }, Effect.provide(FetchHttpClient.layer)),
 });

package/src/templates/forex.ts

@@ -2,20 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
 
 export default defineFunction({
   key: 'dxos.org/script/forex',
   name: 'Forex',
   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 ({ data: { from, to } }: any) => {
+  handler: async ({ data: { from, to } }) => {
     const res = await fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`);
     const {
       data: { rates },

package/src/templates/gmail.ts

@@ -175,8 +175,7 @@ const parseFromHeader = (value: string): { name?: string; email: string } | unde
 // TODO(wittjosiah): These schemas should be imported from @dxos/schema.
 //
 
-const ActorRoles = ['user', 'assistant'] as const;
-const ActorRole = S.Literal(...ActorRoles);
+const ActorRole = S.Literal('user', 'assistant');
 type ActorRole = S.Schema.Type<typeof ActorRole>;
 
 const ActorSchema = S.Struct({

package/src/templates/index.ts

@@ -2,8 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
+import anthropic from './anthropic.ts?raw';
 import chat from './chat.ts?raw';
-import chess from './chess.ts?raw';
+import chessBot from './chess-bot.ts?raw';
+import commentary from './commentary.ts?raw';
 import dataGenerator from './data-generator.ts?raw';
 import discord from './discord.ts?raw';
 import email from './email.ts?raw';
@@ -46,10 +48,10 @@ export const templates = [
     presetId: 'dxos.org/function/gpt',
   },
   {
-    id: 'dxos.org/script/chess',
-    name: 'Chess',
-    source: removeHeader(chess),
-    presetId: 'dxos.org/function/chess',
+    id: 'dxos.org/script/chess-bot',
+    name: 'Chess Bot',
+    source: removeHeader(chessBot),
+    presetId: 'dxos.org/function/chess-bot',
   },
   {
     id: 'dxos.org/script/email',
@@ -75,4 +77,15 @@ export const templates = [
     source: removeHeader(dataGenerator),
     presetId: 'dxos.org/function/data-generator',
   },
+  {
+    id: 'dxos.org/script/anthropic',
+    name: 'Anthropic',
+    source: removeHeader(anthropic),
+  },
+  {
+    id: 'dxos.org/script/commentary',
+    name: 'Commentary',
+    source: removeHeader(commentary),
+    presetId: 'dxos.org/function/chess/commentary',
+  },
 ] as const;