@dxos/plugin-chess 0.7.5-main.499c70c → 0.7.5-main.5ae2ba8

package/dist/lib/node-esm/artifact-definition-LHQK5BBZ.mjs

@@ -0,0 +1,181 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ChessAction,
+  ChessType,
+  meta
+} from "./chunk-IP66EHSW.mjs";
+
+// packages/plugins/plugin-chess/src/capabilities/artifact-definition.ts
+import { Chess } from "chess.js";
+import { pipe } from "effect";
+import { Capabilities, chain, contributes, createIntent } from "@dxos/app-framework";
+import { defineArtifact, defineTool, ToolResult } from "@dxos/artifact";
+import { createArtifactElement } from "@dxos/assistant";
+import { isInstanceOf, ObjectId, S } from "@dxos/echo-schema";
+import { invariant } from "@dxos/invariant";
+import { SpaceAction } from "@dxos/plugin-space/types";
+import { Filter } from "@dxos/react-client/echo";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-chess/src/capabilities/artifact-definition.ts";
+var artifact_definition_default = () => {
+  const definition = defineArtifact({
+    id: meta.id,
+    name: meta.name,
+    description: "Provides a simple chess engine.",
+    instructions: `
+      - If the user's message relates to a chess game, you must return the chess game inside the artifact tag as a valid FEN string with no additional text.
+    `,
+    schema: ChessType,
+    tools: [
+      defineTool(meta.id, {
+        name: "create",
+        description: "Create a new chess game. Returns the artifact definition for the game.",
+        caption: "Creating chess game...",
+        schema: S.Struct({
+          fen: S.String.annotations({
+            description: "The state of the chess game in the FEN format."
+          })
+        }),
+        execute: async ({ fen }, { extensions }) => {
+          invariant(extensions?.space, "No space", {
+            F: __dxlog_file,
+            L: 45,
+            S: void 0,
+            A: [
+              "extensions?.space",
+              "'No space'"
+            ]
+          });
+          invariant(extensions?.dispatch, "No intent dispatcher", {
+            F: __dxlog_file,
+            L: 46,
+            S: void 0,
+            A: [
+              "extensions?.dispatch",
+              "'No intent dispatcher'"
+            ]
+          });
+          const intent = pipe(createIntent(ChessAction.Create, {
+            fen
+          }), chain(SpaceAction.AddObject, {
+            target: extensions.space
+          }));
+          const { data, error } = await extensions.dispatch(intent);
+          if (!data || error) {
+            return ToolResult.Error(error?.message ?? "Failed to create chess game");
+          }
+          return ToolResult.Success(createArtifactElement(data.id));
+        }
+      }),
+      defineTool(meta.id, {
+        name: "list",
+        description: "Query all active chess games.",
+        caption: "Getting games...",
+        schema: S.Struct({}),
+        execute: async (_, { extensions }) => {
+          invariant(extensions?.space, "No space", {
+            F: __dxlog_file,
+            L: 65,
+            S: void 0,
+            A: [
+              "extensions?.space",
+              "'No space'"
+            ]
+          });
+          const { objects: games } = await extensions.space.db.query(Filter.schema(ChessType)).run();
+          invariant(games.length > 0, "No chess games found", {
+            F: __dxlog_file,
+            L: 67,
+            S: void 0,
+            A: [
+              "games.length > 0",
+              "'No chess games found'"
+            ]
+          });
+          return ToolResult.Success(games);
+        }
+      }),
+      defineTool(meta.id, {
+        name: "inspect",
+        description: "Get the current state of the chess game.",
+        caption: "Inspecting game...",
+        schema: S.Struct({
+          id: ObjectId
+        }),
+        execute: async ({ id }, { extensions }) => {
+          invariant(extensions?.space, "No space", {
+            F: __dxlog_file,
+            L: 77,
+            S: void 0,
+            A: [
+              "extensions?.space",
+              "'No space'"
+            ]
+          });
+          const { objects: games } = await extensions.space.db.query(Filter.schema(ChessType)).run();
+          const game = games.find((game2) => game2.id === id);
+          invariant(isInstanceOf(ChessType, game), void 0, {
+            F: __dxlog_file,
+            L: 80,
+            S: void 0,
+            A: [
+              "isInstanceOf(ChessType, game)",
+              ""
+            ]
+          });
+          return ToolResult.Success(game.fen);
+        }
+      }),
+      defineTool(meta.id, {
+        name: "move",
+        description: "Make a move in the chess game.",
+        caption: "Making chess move...",
+        schema: S.Struct({
+          id: ObjectId,
+          move: S.String.annotations({
+            description: "The move to make in the chess game.",
+            examples: [
+              "e4",
+              "Bf3"
+            ]
+          })
+        }),
+        execute: async ({ id, move }, { extensions }) => {
+          invariant(extensions?.space, "No space", {
+            F: __dxlog_file,
+            L: 96,
+            S: void 0,
+            A: [
+              "extensions?.space",
+              "'No space'"
+            ]
+          });
+          const { objects: games } = await extensions.space.db.query(Filter.schema(ChessType)).run();
+          const game = games.find((game2) => game2.id === id);
+          invariant(isInstanceOf(ChessType, game), void 0, {
+            F: __dxlog_file,
+            L: 99,
+            S: void 0,
+            A: [
+              "isInstanceOf(ChessType, game)",
+              ""
+            ]
+          });
+          const board = new Chess(game.fen);
+          try {
+            board.move(move);
+          } catch (error) {
+            return ToolResult.Error(error.message);
+          }
+          game.pgn = board.pgn();
+          game.fen = board.fen();
+          return ToolResult.Success(game.fen);
+        }
+      })
+    ]
+  });
+  return contributes(Capabilities.ArtifactDefinition, definition);
+};
+export {
+  artifact_definition_default as default
+};
+//# sourceMappingURL=artifact-definition-LHQK5BBZ.mjs.map

package/dist/lib/node-esm/artifact-definition-LHQK5BBZ.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/artifact-definition.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Chess } from 'chess.js';\nimport { pipe } from 'effect';\n\nimport { Capabilities, chain, contributes, createIntent, type PromiseIntentDispatcher } from '@dxos/app-framework';\nimport { defineArtifact, defineTool, ToolResult } from '@dxos/artifact';\nimport { createArtifactElement } from '@dxos/assistant';\nimport { isInstanceOf, ObjectId, S } from '@dxos/echo-schema';\nimport { invariant } from '@dxos/invariant';\nimport { SpaceAction } from '@dxos/plugin-space/types';\nimport { Filter, type Space } from '@dxos/react-client/echo';\n\nimport { meta } from '../meta';\nimport { ChessAction, ChessType } from '../types';\n\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: meta.id,\n    name: meta.name,\n    description: 'Provides a simple chess engine.',\n    instructions: `\n      - If the user's message relates to a chess game, you must return the chess game inside the artifact tag as a valid FEN string with no additional text.\n    `,\n    schema: ChessType,\n    tools: [\n      defineTool(meta.id, {\n        name: 'create',\n        description: 'Create a new chess game. Returns the artifact definition for the game.',\n        caption: 'Creating chess game...',\n        schema: S.Struct({\n          fen: S.String.annotations({ description: 'The state of the chess game in the FEN format.' }),\n        }),\n        execute: async ({ fen }, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n          invariant(extensions?.dispatch, 'No intent dispatcher');\n          const intent = pipe(\n            createIntent(ChessAction.Create, { fen }),\n            chain(SpaceAction.AddObject, { target: extensions.space }),\n          );\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(data.id));\n        },\n      }),\n      defineTool(meta.id, {\n        name: 'list',\n        description: 'Query all active chess games.',\n        caption: 'Getting games...',\n        schema: S.Struct({}),\n        execute: async (_, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n          const { objects: games } = await extensions.space.db.query(Filter.schema(ChessType)).run();\n          invariant(games.length > 0, 'No chess games found');\n          return ToolResult.Success(games);\n        },\n      }),\n      defineTool(meta.id, {\n        name: 'inspect',\n        description: 'Get the current state of the chess game.',\n        caption: 'Inspecting game...',\n        schema: S.Struct({ id: ObjectId }),\n        execute: async ({ id }, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n          const { objects: games } = await extensions.space.db.query(Filter.schema(ChessType)).run();\n          const game = games.find((game) => game.id === id);\n          invariant(isInstanceOf(ChessType, game));\n          return ToolResult.Success(game.fen);\n        },\n      }),\n      defineTool(meta.id, {\n        name: 'move',\n        description: 'Make a move in the chess game.',\n        caption: 'Making chess move...',\n        schema: S.Struct({\n          id: ObjectId,\n          move: S.String.annotations({\n            description: 'The move to make in the chess game.',\n            examples: ['e4', 'Bf3'],\n          }),\n        }),\n        execute: async ({ id, move }, { extensions }) => {\n          invariant(extensions?.space, 'No space');\n          const { objects: games } = await extensions.space.db.query(Filter.schema(ChessType)).run();\n          const game = games.find((game) => game.id === id);\n          invariant(isInstanceOf(ChessType, game));\n          const board = new Chess(game.fen);\n          try {\n            board.move(move);\n          } catch (error: any) {\n            return ToolResult.Error(error.message);\n          }\n          game.pgn = board.pgn();\n          game.fen = board.fen();\n          return ToolResult.Success(game.fen);\n        },\n      }),\n    ],\n  });\n\n  return contributes(Capabilities.ArtifactDefinition, definition);\n};\n"],
+  "mappings": "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",
+  "names": ["Chess", "pipe", "Capabilities", "chain", "contributes", "createIntent", "defineArtifact", "defineTool", "ToolResult", "createArtifactElement", "isInstanceOf", "ObjectId", "S", "invariant", "SpaceAction", "Filter", "definition", "defineArtifact", "id", "meta", "name", "description", "instructions", "schema", "ChessType", "tools", "defineTool", "caption", "S", "Struct", "fen", "String", "annotations", "execute", "extensions", "invariant", "space", "dispatch", "intent", "pipe", "createIntent", "ChessAction", "Create", "chain", "SpaceAction", "AddObject", "target", "data", "error", "ToolResult", "Error", "message", "Success", "createArtifactElement", "_", "objects", "games", "db", "query", "Filter", "run", "length", "ObjectId", "game", "find", "isInstanceOf", "move", "examples", "board", "Chess", "pgn", "contributes", "Capabilities", "ArtifactDefinition"]
+}

package/dist/lib/node-esm/chunk-6SEDGO5G.mjs

@@ -0,0 +1,44 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// packages/plugins/plugin-chess/src/components/ChessComponent.tsx
+import { Chess } from "chess.js";
+import React, { useCallback, useEffect, useMemo } from "react";
+import { getSpace } from "@dxos/react-client/echo";
+import { ChessModel, Board, Chessboard } from "@dxos/react-ui-gameboard";
+var ChessComponent = ({ game }) => {
+  const model = useMemo(() => new ChessModel(), []);
+  useEffect(() => {
+    if (!model || game.pgn !== model?.game.pgn()) {
+      const chess = new Chess();
+      if (game.pgn) {
+        chess.loadPgn(game.pgn);
+      }
+      model.initialize(chess.fen());
+    }
+  }, [
+    game.pgn
+  ]);
+  const space = getSpace(game);
+  if (!space) {
+    return null;
+  }
+  const handleDrop = useCallback((move) => {
+    if (model.makeMove(move)) {
+      game.pgn = model.game.pgn();
+      game.fen = model.game.fen();
+      return true;
+    }
+    return false;
+  }, [
+    model
+  ]);
+  return /* @__PURE__ */ React.createElement(Board.Root, {
+    model,
+    onDrop: handleDrop
+  }, /* @__PURE__ */ React.createElement(Chessboard, null));
+};
+
+export {
+  ChessComponent
+};
+//# sourceMappingURL=chunk-6SEDGO5G.mjs.map

package/dist/lib/node-esm/chunk-6SEDGO5G.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/components/ChessComponent.tsx"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Chess } from 'chess.js';\nimport React, { useCallback, useEffect, useMemo } from 'react';\n\nimport { getSpace } from '@dxos/react-client/echo';\nimport { ChessModel, Board, Chessboard, type BoardRootProps } from '@dxos/react-ui-gameboard';\n\nimport { type ChessType } from '../types';\n\nexport const ChessComponent = ({ game }: { game: ChessType }) => {\n  const model = useMemo(() => new ChessModel(), []);\n  useEffect(() => {\n    if (!model || game.pgn !== model?.game.pgn()) {\n      const chess = new Chess();\n      if (game.pgn) {\n        chess.loadPgn(game.pgn);\n      }\n\n      model.initialize(chess.fen());\n    }\n  }, [game.pgn]);\n\n  const space = getSpace(game);\n  if (!space) {\n    return null;\n  }\n\n  const handleDrop = useCallback<NonNullable<BoardRootProps['onDrop']>>(\n    (move) => {\n      if (model.makeMove(move)) {\n        game.pgn = model.game.pgn();\n        game.fen = model.game.fen();\n        return true;\n      }\n\n      return false;\n    },\n    [model],\n  );\n\n  return (\n    <Board.Root model={model} onDrop={handleDrop}>\n      <Chessboard />\n    </Board.Root>\n  );\n};\n"],
+  "mappings": ";;;AAIA,SAASA,aAAa;AACtB,OAAOC,SAASC,aAAaC,WAAWC,eAAe;AAEvD,SAASC,gBAAgB;AACzB,SAASC,YAAYC,OAAOC,kBAAuC;AAI5D,IAAMC,iBAAiB,CAAC,EAAEC,KAAI,MAAuB;AAC1D,QAAMC,QAAQC,QAAQ,MAAM,IAAIC,WAAAA,GAAc,CAAA,CAAE;AAChDC,YAAU,MAAA;AACR,QAAI,CAACH,SAASD,KAAKK,QAAQJ,OAAOD,KAAKK,IAAAA,GAAO;AAC5C,YAAMC,QAAQ,IAAIC,MAAAA;AAClB,UAAIP,KAAKK,KAAK;AACZC,cAAME,QAAQR,KAAKK,GAAG;MACxB;AAEAJ,YAAMQ,WAAWH,MAAMI,IAAG,CAAA;IAC5B;EACF,GAAG;IAACV,KAAKK;GAAI;AAEb,QAAMM,QAAQC,SAASZ,IAAAA;AACvB,MAAI,CAACW,OAAO;AACV,WAAO;EACT;AAEA,QAAME,aAAaC,YACjB,CAACC,SAAAA;AACC,QAAId,MAAMe,SAASD,IAAAA,GAAO;AACxBf,WAAKK,MAAMJ,MAAMD,KAAKK,IAAG;AACzBL,WAAKU,MAAMT,MAAMD,KAAKU,IAAG;AACzB,aAAO;IACT;AAEA,WAAO;EACT,GACA;IAACT;GAAM;AAGT,SACE,sBAAA,cAACgB,MAAMC,MAAI;IAACjB;IAAckB,QAAQN;KAChC,sBAAA,cAACO,YAAAA,IAAAA,CAAAA;AAGP;",
+  "names": ["Chess", "React", "useCallback", "useEffect", "useMemo", "getSpace", "ChessModel", "Board", "Chessboard", "ChessComponent", "game", "model", "useMemo", "ChessModel", "useEffect", "pgn", "chess", "Chess", "loadPgn", "initialize", "fen", "space", "getSpace", "handleDrop", "useCallback", "move", "makeMove", "Board", "Root", "onDrop", "Chessboard"]
+}

package/dist/lib/node-esm/chunk-B72CIN6T.mjs

@@ -0,0 +1,10 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// packages/plugins/plugin-chess/src/components/index.ts
+import { lazy } from "react";
+var ChessContainer = lazy(() => import("./ChessContainer-S76WNBWN.mjs"));
+
+export {
+  ChessContainer
+};
+//# sourceMappingURL=chunk-B72CIN6T.mjs.map

package/dist/lib/node-esm/chunk-B72CIN6T.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/components/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { lazy } from 'react';\n\nexport * from './ChessComponent';\n\nexport const ChessContainer = lazy(() => import('./ChessContainer'));\n"],
+  "mappings": ";;;AAIA,SAASA,YAAY;AAId,IAAMC,iBAAiBC,KAAK,MAAM,OAAO,+BAAA,CAAA;",
+  "names": ["lazy", "ChessContainer", "lazy"]
+}

package/dist/lib/node-esm/chunk-IP66EHSW.mjs

@@ -0,0 +1,71 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// packages/plugins/plugin-chess/src/types/schema.ts
+import { S, TypedObject } from "@dxos/echo-schema";
+var MoveSchema = S.mutable(S.partial(S.Struct({
+  source: S.String,
+  target: S.String,
+  piece: S.String
+})));
+var ChessType = class extends TypedObject({
+  typename: "dxos.org/type/Chess",
+  version: "0.1.0"
+})({
+  name: S.optional(S.String),
+  playerWhite: S.String,
+  playerBlack: S.String,
+  moves: S.mutable(S.Array(S.String)),
+  // TODO(wittjosiah): Remove. Redundant with moves.
+  pgn: S.String,
+  fen: S.String
+}, {
+  partial: true
+}) {
+};
+
+// packages/plugins/plugin-chess/src/types/types.ts
+import { isInstanceOf, S as S2 } from "@dxos/echo-schema";
+import { isReactiveObject } from "@dxos/live-object";
+
+// packages/plugins/plugin-chess/src/meta.ts
+var CHESS_PLUGIN = "dxos.org/plugin/chess";
+var meta = {
+  id: CHESS_PLUGIN,
+  name: "Chess",
+  description: "Chess is a simple plugin which allows you to render an interactive chessboard inside of a plank. This chessboard can be used for collaborative chess games, or for practice experiments with the LLM. ",
+  icon: "ph--shield-chevron--regular",
+  source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-chess",
+  screenshots: [
+    "https://dxos.network/plugin-details-chess-dark.png"
+  ]
+};
+
+// packages/plugins/plugin-chess/src/types/types.ts
+var ChessAction;
+(function(ChessAction2) {
+  const CHESS_ACTION = `${CHESS_PLUGIN}/action`;
+  class Create extends S2.TaggedClass()(`${CHESS_ACTION}/create`, {
+    input: S2.Struct({
+      name: S2.optional(S2.String),
+      fen: S2.optional(S2.String)
+    }),
+    output: S2.Struct({
+      object: ChessType
+    })
+  }) {
+  }
+  ChessAction2.Create = Create;
+})(ChessAction || (ChessAction = {}));
+var isObject = (object) => {
+  return isReactiveObject(object) && isInstanceOf(ChessType, object);
+};
+
+export {
+  CHESS_PLUGIN,
+  meta,
+  MoveSchema,
+  ChessType,
+  ChessAction,
+  isObject
+};
+//# sourceMappingURL=chunk-IP66EHSW.mjs.map

package/dist/lib/node-esm/chunk-IP66EHSW.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/schema.ts", "../../../src/types/types.ts", "../../../src/meta.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { S, TypedObject } from '@dxos/echo-schema';\n\nexport const MoveSchema = S.mutable(\n  S.partial(\n    S.Struct({\n      source: S.String,\n      target: S.String,\n      piece: S.String,\n    }),\n  ),\n);\n\nexport class ChessType extends TypedObject({ typename: 'dxos.org/type/Chess', version: '0.1.0' })(\n  {\n    name: S.optional(S.String),\n    playerWhite: S.String,\n    playerBlack: S.String,\n    moves: S.mutable(S.Array(S.String)),\n    // TODO(wittjosiah): Remove. Redundant with moves.\n    pgn: S.String,\n    fen: S.String,\n  },\n  { partial: true },\n) {}\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { isInstanceOf, S } from '@dxos/echo-schema';\nimport { isReactiveObject } from '@dxos/live-object';\n\nimport { ChessType } from './schema';\nimport { CHESS_PLUGIN } from '../meta';\n\nexport namespace ChessAction {\n  const CHESS_ACTION = `${CHESS_PLUGIN}/action`;\n\n  export class Create extends S.TaggedClass<Create>()(`${CHESS_ACTION}/create`, {\n    input: S.Struct({\n      name: S.optional(S.String),\n      fen: S.optional(S.String),\n    }),\n    output: S.Struct({\n      object: ChessType,\n    }),\n  }) {}\n}\n\nexport const isObject = (object: unknown): object is typeof ChessType => {\n  return isReactiveObject(object) && isInstanceOf(ChessType, object);\n};\n", "//\n// Copyright 2023 DXOS.org\n//\n\nimport { type PluginMeta } from '@dxos/app-framework';\n\nexport const CHESS_PLUGIN = 'dxos.org/plugin/chess';\n\nexport const meta = {\n  id: CHESS_PLUGIN,\n  name: 'Chess',\n  description:\n    'Chess is a simple plugin which allows you to render an interactive chessboard inside of a plank. This chessboard can be used for collaborative chess games, or for practice experiments with the LLM. ',\n  icon: 'ph--shield-chevron--regular',\n  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-chess',\n  screenshots: ['https://dxos.network/plugin-details-chess-dark.png'],\n} satisfies PluginMeta;\n"],
+  "mappings": ";;;AAIA,SAASA,GAAGC,mBAAmB;AAExB,IAAMC,aAAaC,EAAEC,QAC1BD,EAAEE,QACAF,EAAEG,OAAO;EACPC,QAAQJ,EAAEK;EACVC,QAAQN,EAAEK;EACVE,OAAOP,EAAEK;AACX,CAAA,CAAA,CAAA;AAIG,IAAMG,YAAN,cAAwBC,YAAY;EAAEC,UAAU;EAAuBC,SAAS;AAAQ,CAAA,EAC7F;EACEC,MAAMZ,EAAEa,SAASb,EAAEK,MAAM;EACzBS,aAAad,EAAEK;EACfU,aAAaf,EAAEK;EACfW,OAAOhB,EAAEC,QAAQD,EAAEiB,MAAMjB,EAAEK,MAAM,CAAA;;EAEjCa,KAAKlB,EAAEK;EACPc,KAAKnB,EAAEK;AACT,GACA;EAAEH,SAAS;AAAK,CAAA,EAAA;AACf;;;ACvBH,SAASkB,cAAcC,KAAAA,UAAS;AAChC,SAASC,wBAAwB;;;ACC1B,IAAMC,eAAe;AAErB,IAAMC,OAAO;EAClBC,IAAIF;EACJG,MAAM;EACNC,aACE;EACFC,MAAM;EACNC,QAAQ;EACRC,aAAa;IAAC;;AAChB;;;;UDNiBC,cAAAA;AACf,QAAMC,eAAe,GAAGC,YAAAA;EAEjB,MAAMC,eAAeC,GAAEC,YAAW,EAAW,GAAGJ,YAAAA,WAAuB;IAC5EK,OAAOF,GAAEG,OAAO;MACdC,MAAMJ,GAAEK,SAASL,GAAEM,MAAM;MACzBC,KAAKP,GAAEK,SAASL,GAAEM,MAAM;IAC1B,CAAA;IACAE,QAAQR,GAAEG,OAAO;MACfM,QAAQC;IACV,CAAA;EACF,CAAA,EAAA;EAAI;eARSX,SAAAA;AASf,GAZiBH,gBAAAA,cAAAA,CAAAA,EAAAA;AAcV,IAAMe,WAAW,CAACF,WAAAA;AACvB,SAAOG,iBAAiBH,MAAAA,KAAWI,aAAaH,WAAWD,MAAAA;AAC7D;",
+  "names": ["S", "TypedObject", "MoveSchema", "S", "mutable", "partial", "Struct", "source", "String", "target", "piece", "ChessType", "TypedObject", "typename", "version", "name", "optional", "playerWhite", "playerBlack", "moves", "Array", "pgn", "fen", "isInstanceOf", "S", "isReactiveObject", "CHESS_PLUGIN", "meta", "id", "name", "description", "icon", "source", "screenshots", "ChessAction", "CHESS_ACTION", "CHESS_PLUGIN", "Create", "S", "TaggedClass", "input", "Struct", "name", "optional", "String", "fen", "output", "object", "ChessType", "isObject", "isReactiveObject", "isInstanceOf"]
+}