@dxos/plugin-chess 0.8.4-main.84f28bd → 0.8.4-main.8baae0fced

package/dist/lib/neutral/ChessArticle-QLLKZGPH.mjs

@@ -0,0 +1,88 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/containers/ChessArticle/ChessArticle.tsx
+import { Chess as ChessJS } from "chess.js";
+import React, { useCallback, useRef, useState } from "react";
+import { Obj } from "@dxos/echo";
+import { Panel, Toolbar, useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/ui-theme";
+import { Chessboard } from "#components";
+import { meta } from "#meta";
+import { Chess } from "#types";
+var ChessArticle = ({ role, variant }) => {
+  const { t } = useTranslation(meta.id);
+  const [orientation, setOrientation] = useState("white");
+  const [showInfo, setShowInfo] = useState(true);
+  const controller = useRef(null);
+  const handleSelect = useCallback((index) => {
+    controller.current?.setMoveNumber(index);
+  }, []);
+  const isGameOver = (() => {
+    if (!Obj.instanceOf(Chess.State, variant) || !variant.pgn && !variant.fen) {
+      return false;
+    }
+    try {
+      const chess = new ChessJS();
+      if (variant.pgn) {
+        chess.loadPgn(variant.pgn);
+      } else if (variant.fen) {
+        chess.load(variant.fen);
+      }
+      return chess.isGameOver();
+    } catch {
+      return false;
+    }
+  })();
+  const handleNewGame = useCallback(() => {
+    if (!Obj.instanceOf(Chess.State, variant)) {
+      return;
+    }
+    Obj.update(variant, (variant2) => {
+      const mutable = variant2;
+      mutable.pgn = void 0;
+      mutable.fen = void 0;
+    });
+  }, [
+    variant
+  ]);
+  if (!Obj.instanceOf(Chess.State, variant)) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(Chessboard.Root, {
+    state: variant,
+    ref: controller
+  }, /* @__PURE__ */ React.createElement(Panel.Root, {
+    role,
+    classNames: "@container"
+  }, /* @__PURE__ */ React.createElement(Panel.Toolbar, {
+    asChild: true
+  }, /* @__PURE__ */ React.createElement(Toolbar.Root, null, isGameOver && /* @__PURE__ */ React.createElement(Toolbar.Button, {
+    onClick: handleNewGame
+  }, t("new-game.button")), /* @__PURE__ */ React.createElement("div", {
+    className: "grow"
+  }), /* @__PURE__ */ React.createElement(Toolbar.IconButton, {
+    icon: "ph--info--regular",
+    iconOnly: true,
+    label: t("toggle-info.button"),
+    classNames: mx("invisible @4xl:visible"),
+    onClick: () => setShowInfo((open) => !open)
+  }))), /* @__PURE__ */ React.createElement(Panel.Content, null, /* @__PURE__ */ React.createElement("div", {
+    className: mx("grid h-full w-full", showInfo && "@4xl:grid-cols-[1fr_320px] gap-8", role === "article" && "p-4", role === "section" && "aspect-square", role === "section" && showInfo && "@4xl:aspect-auto")
+  }, /* @__PURE__ */ React.createElement(Chessboard.Content, null, /* @__PURE__ */ React.createElement(Chessboard.Board, {
+    classNames: "border rounded-xs",
+    orientation
+  })), showInfo && /* @__PURE__ */ React.createElement("div", {
+    className: "hidden @4xl:flex flex-col justify-center items-center overflow-hidden"
+  }, /* @__PURE__ */ React.createElement(Chessboard.Info, {
+    orientation,
+    min: 8,
+    max: 8,
+    onOrientationChange: setOrientation,
+    onClose: () => setShowInfo(false),
+    onSelect: handleSelect
+  }))))));
+};
+export {
+  ChessArticle as default
+};
+//# sourceMappingURL=ChessArticle-QLLKZGPH.mjs.map

package/dist/lib/neutral/ChessArticle-QLLKZGPH.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/containers/ChessArticle/ChessArticle.tsx"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Chess as ChessJS } from 'chess.js';\nimport React, { useCallback, useRef, useState } from 'react';\n\nimport { Obj } from '@dxos/echo';\nimport { type GameVariantSurfaceProps } from '@dxos/plugin-game';\nimport { Panel, Toolbar, useTranslation } from '@dxos/react-ui';\nimport { type Player } from '@dxos/react-ui-gameboard';\nimport { mx } from '@dxos/ui-theme';\n\nimport { Chessboard, type ChessboardController, type ChessboardInfoProps } from '#components';\nimport { meta } from '#meta';\nimport { Chess } from '#types';\n\nexport type ChessArticleProps = GameVariantSurfaceProps;\n\nexport const ChessArticle = ({ role, variant }: ChessArticleProps) => {\n  const { t } = useTranslation(meta.id);\n  const [orientation, setOrientation] = useState<Player>('white');\n  const [showInfo, setShowInfo] = useState(true);\n  const controller = useRef<ChessboardController>(null);\n\n  const handleSelect = useCallback<NonNullable<ChessboardInfoProps['onSelect']>>((index) => {\n    controller.current?.setMoveNumber(index);\n  }, []);\n\n  const isGameOver = (() => {\n    if (!Obj.instanceOf(Chess.State, variant) || (!variant.pgn && !variant.fen)) {\n      return false;\n    }\n    try {\n      const chess = new ChessJS();\n      if (variant.pgn) {\n        chess.loadPgn(variant.pgn);\n      } else if (variant.fen) {\n        chess.load(variant.fen);\n      }\n      return chess.isGameOver();\n    } catch {\n      return false;\n    }\n  })();\n\n  const handleNewGame = useCallback(() => {\n    if (!Obj.instanceOf(Chess.State, variant)) {\n      return;\n    }\n    Obj.update(variant, (variant) => {\n      const mutable = variant as Obj.Mutable<typeof variant>;\n      mutable.pgn = undefined;\n      mutable.fen = undefined;\n    });\n  }, [variant]);\n\n  if (!Obj.instanceOf(Chess.State, variant)) {\n    return null;\n  }\n\n  return (\n    <Chessboard.Root state={variant} ref={controller}>\n      <Panel.Root role={role} classNames='@container'>\n        <Panel.Toolbar asChild>\n          <Toolbar.Root>\n            {isGameOver && <Toolbar.Button onClick={handleNewGame}>{t('new-game.button')}</Toolbar.Button>}\n            <div className='grow' />\n            <Toolbar.IconButton\n              icon='ph--info--regular'\n              iconOnly\n              label={t('toggle-info.button')}\n              classNames={mx('invisible @4xl:visible')}\n              onClick={() => setShowInfo((open) => !open)}\n            />\n          </Toolbar.Root>\n        </Panel.Toolbar>\n        <Panel.Content>\n          <div\n            className={mx(\n              'grid h-full w-full',\n              showInfo && '@4xl:grid-cols-[1fr_320px] gap-8',\n              role === 'article' && 'p-4',\n              role === 'section' && 'aspect-square',\n              role === 'section' && showInfo && '@4xl:aspect-auto',\n            )}\n          >\n            <Chessboard.Content>\n              <Chessboard.Board classNames='border rounded-xs' orientation={orientation} />\n            </Chessboard.Content>\n            {showInfo && (\n              <div className='hidden @4xl:flex flex-col justify-center items-center overflow-hidden'>\n                <Chessboard.Info\n                  orientation={orientation}\n                  min={8}\n                  max={8}\n                  onOrientationChange={setOrientation}\n                  onClose={() => setShowInfo(false)}\n                  onSelect={handleSelect}\n                />\n              </div>\n            )}\n          </div>\n        </Panel.Content>\n      </Panel.Root>\n    </Chessboard.Root>\n  );\n};\n"],
+  "mappings": ";;;AAIA,SAASA,SAASC,eAAe;AACjC,OAAOC,SAASC,aAAaC,QAAQC,gBAAgB;AAErD,SAASC,WAAW;AAEpB,SAASC,OAAOC,SAASC,sBAAsB;AAE/C,SAASC,UAAU;AAEnB,SAASC,kBAAuE;AAChF,SAASC,YAAY;AACrB,SAASZ,aAAa;AAIf,IAAMa,eAAe,CAAC,EAAEC,MAAMC,QAAO,MAAqB;AAC/D,QAAM,EAAEC,EAAC,IAAKP,eAAeG,KAAKK,EAAE;AACpC,QAAM,CAACC,aAAaC,cAAAA,IAAkBd,SAAiB,OAAA;AACvD,QAAM,CAACe,UAAUC,WAAAA,IAAehB,SAAS,IAAA;AACzC,QAAMiB,aAAalB,OAA6B,IAAA;AAEhD,QAAMmB,eAAepB,YAA0D,CAACqB,UAAAA;AAC9EF,eAAWG,SAASC,cAAcF,KAAAA;EACpC,GAAG,CAAA,CAAE;AAEL,QAAMG,cAAc,MAAA;AAClB,QAAI,CAACrB,IAAIsB,WAAW5B,MAAM6B,OAAOd,OAAAA,KAAa,CAACA,QAAQe,OAAO,CAACf,QAAQgB,KAAM;AAC3E,aAAO;IACT;AACA,QAAI;AACF,YAAMC,QAAQ,IAAI/B,QAAAA;AAClB,UAAIc,QAAQe,KAAK;AACfE,cAAMC,QAAQlB,QAAQe,GAAG;MAC3B,WAAWf,QAAQgB,KAAK;AACtBC,cAAME,KAAKnB,QAAQgB,GAAG;MACxB;AACA,aAAOC,MAAML,WAAU;IACzB,QAAQ;AACN,aAAO;IACT;EACF,GAAA;AAEA,QAAMQ,gBAAgBhC,YAAY,MAAA;AAChC,QAAI,CAACG,IAAIsB,WAAW5B,MAAM6B,OAAOd,OAAAA,GAAU;AACzC;IACF;AACAT,QAAI8B,OAAOrB,SAAS,CAACA,aAAAA;AACnB,YAAMsB,UAAUtB;AAChBsB,cAAQP,MAAMQ;AACdD,cAAQN,MAAMO;IAChB,CAAA;EACF,GAAG;IAACvB;GAAQ;AAEZ,MAAI,CAACT,IAAIsB,WAAW5B,MAAM6B,OAAOd,OAAAA,GAAU;AACzC,WAAO;EACT;AAEA,SACE,sBAAA,cAACJ,WAAW4B,MAAI;IAACC,OAAOzB;IAAS0B,KAAKnB;KACpC,sBAAA,cAACf,MAAMgC,MAAI;IAACzB;IAAY4B,YAAW;KACjC,sBAAA,cAACnC,MAAMC,SAAO;IAACmC,SAAAA;KACb,sBAAA,cAACnC,QAAQ+B,MAAI,MACVZ,cAAc,sBAAA,cAACnB,QAAQoC,QAAM;IAACC,SAASV;KAAgBnB,EAAE,iBAAA,CAAA,GAC1D,sBAAA,cAAC8B,OAAAA;IAAIC,WAAU;MACf,sBAAA,cAACvC,QAAQwC,YAAU;IACjBC,MAAK;IACLC,UAAAA;IACAC,OAAOnC,EAAE,oBAAA;IACT0B,YAAYhC,GAAG,wBAAA;IACfmC,SAAS,MAAMxB,YAAY,CAAC+B,SAAS,CAACA,IAAAA;QAI5C,sBAAA,cAAC7C,MAAM8C,SAAO,MACZ,sBAAA,cAACP,OAAAA;IACCC,WAAWrC,GACT,sBACAU,YAAY,oCACZN,SAAS,aAAa,OACtBA,SAAS,aAAa,iBACtBA,SAAS,aAAaM,YAAY,kBAAA;KAGpC,sBAAA,cAACT,WAAW0C,SAAO,MACjB,sBAAA,cAAC1C,WAAW2C,OAAK;IAACZ,YAAW;IAAoBxB;OAElDE,YACC,sBAAA,cAAC0B,OAAAA;IAAIC,WAAU;KACb,sBAAA,cAACpC,WAAW4C,MAAI;IACdrC;IACAsC,KAAK;IACLC,KAAK;IACLC,qBAAqBvC;IACrBwC,SAAS,MAAMtC,YAAY,KAAA;IAC3BuC,UAAUrC;;AAS5B;",
+  "names": ["Chess", "ChessJS", "React", "useCallback", "useRef", "useState", "Obj", "Panel", "Toolbar", "useTranslation", "mx", "Chessboard", "meta", "ChessArticle", "role", "variant", "t", "id", "orientation", "setOrientation", "showInfo", "setShowInfo", "controller", "handleSelect", "index", "current", "setMoveNumber", "isGameOver", "instanceOf", "State", "pgn", "fen", "chess", "loadPgn", "load", "handleNewGame", "update", "mutable", "undefined", "Root", "state", "ref", "classNames", "asChild", "Button", "onClick", "div", "className", "IconButton", "icon", "iconOnly", "label", "open", "Content", "Board", "Info", "min", "max", "onOrientationChange", "onClose", "onSelect"]
+}

package/dist/lib/neutral/ChessCard-I5RSZZIP.mjs

@@ -0,0 +1,19 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/containers/ChessCard/ChessCard.tsx
+import React from "react";
+import { Obj } from "@dxos/echo";
+import { Chessboard } from "#components";
+import { Chess } from "#types";
+var ChessCard = ({ variant }) => {
+  if (!Obj.instanceOf(Chess.State, variant)) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(Chessboard.Root, {
+    state: variant
+  }, /* @__PURE__ */ React.createElement(Chessboard.Content, null, /* @__PURE__ */ React.createElement(Chessboard.Board, null)));
+};
+export {
+  ChessCard as default
+};
+//# sourceMappingURL=ChessCard-I5RSZZIP.mjs.map

package/dist/lib/neutral/ChessCard-I5RSZZIP.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/containers/ChessCard/ChessCard.tsx"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport React from 'react';\n\nimport { Obj } from '@dxos/echo';\nimport { type GameVariantSurfaceProps } from '@dxos/plugin-game';\n\nimport { Chessboard } from '#components';\nimport { Chess } from '#types';\n\nexport type ChessCardProps = GameVariantSurfaceProps;\n\nexport const ChessCard = ({ variant }: ChessCardProps) => {\n  if (!Obj.instanceOf(Chess.State, variant)) {\n    return null;\n  }\n\n  return (\n    <Chessboard.Root state={variant}>\n      <Chessboard.Content>\n        <Chessboard.Board />\n      </Chessboard.Content>\n    </Chessboard.Root>\n  );\n};\n"],
+  "mappings": ";;;AAIA,OAAOA,WAAW;AAElB,SAASC,WAAW;AAGpB,SAASC,kBAAkB;AAC3B,SAASC,aAAa;AAIf,IAAMC,YAAY,CAAC,EAAEC,QAAO,MAAkB;AACnD,MAAI,CAACJ,IAAIK,WAAWH,MAAMI,OAAOF,OAAAA,GAAU;AACzC,WAAO;EACT;AAEA,SACE,sBAAA,cAACH,WAAWM,MAAI;IAACC,OAAOJ;KACtB,sBAAA,cAACH,WAAWQ,SAAO,MACjB,sBAAA,cAACR,WAAWS,OAAK,IAAA,CAAA,CAAA;AAIzB;",
+  "names": ["React", "Obj", "Chessboard", "Chess", "ChessCard", "variant", "instanceOf", "State", "Root", "state", "Content", "Board"]
+}

package/dist/lib/neutral/ChessPlugin.mjs

@@ -0,0 +1,10 @@
+import {
+  ChessPlugin,
+  ChessPlugin_default
+} from "./chunk-HVIKFYAW.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  ChessPlugin,
+  ChessPlugin_default as default
+};
+//# sourceMappingURL=ChessPlugin.mjs.map

package/dist/lib/neutral/ChessPlugin.node.mjs

@@ -0,0 +1,23 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/ChessPlugin.node.ts
+import { Plugin } from "@dxos/app-framework";
+import { AppPlugin } from "@dxos/app-toolkit";
+import { BlueprintDefinition, OperationHandler } from "#capabilities";
+import { meta } from "#meta";
+import { Chess } from "#types";
+var ChessPlugin = Plugin.define(meta).pipe(AppPlugin.addSchemaModule({
+  schema: [
+    Chess.State
+  ]
+}), AppPlugin.addBlueprintDefinitionModule({
+  activate: BlueprintDefinition
+}), AppPlugin.addOperationHandlerModule({
+  activate: OperationHandler
+}), Plugin.make);
+var ChessPlugin_node_default = ChessPlugin;
+export {
+  ChessPlugin,
+  ChessPlugin_node_default as default
+};
+//# sourceMappingURL=ChessPlugin.node.mjs.map

package/dist/lib/neutral/ChessPlugin.node.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ChessPlugin.node.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport { Plugin } from '@dxos/app-framework';\nimport { AppPlugin } from '@dxos/app-toolkit';\n\nimport { BlueprintDefinition, OperationHandler } from '#capabilities';\nimport { meta } from '#meta';\nimport { Chess } from '#types';\n\n/**\n * Headless variant of ChessPlugin (no React surfaces / GameVariant).\n * Used in node contexts (CLI, agents) where rendering is unavailable.\n */\nexport const ChessPlugin = Plugin.define(meta).pipe(\n  AppPlugin.addSchemaModule({ schema: [Chess.State] }),\n  AppPlugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),\n  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),\n  Plugin.make,\n);\n\nexport default ChessPlugin;\n"],
+  "mappings": ";;;AAIA,SAASA,cAAc;AACvB,SAASC,iBAAiB;AAE1B,SAASC,qBAAqBC,wBAAwB;AACtD,SAASC,YAAY;AACrB,SAASC,aAAa;AAMf,IAAMC,cAAcN,OAAOO,OAAOH,IAAAA,EAAMI,KAC7CP,UAAUQ,gBAAgB;EAAEC,QAAQ;IAACL,MAAMM;;AAAO,CAAA,GAClDV,UAAUW,6BAA6B;EAAEC,UAAUX;AAAoB,CAAA,GACvED,UAAUa,0BAA0B;EAAED,UAAUV;AAAiB,CAAA,GACjEH,OAAOe,IAAI;AAGb,IAAA,2BAAeT;",
+  "names": ["Plugin", "AppPlugin", "BlueprintDefinition", "OperationHandler", "meta", "Chess", "ChessPlugin", "define", "pipe", "addSchemaModule", "schema", "State", "addBlueprintDefinitionModule", "activate", "addOperationHandlerModule", "make"]
+}

package/dist/lib/neutral/ChessPlugin.workerd.mjs

@@ -0,0 +1,21 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/ChessPlugin.workerd.ts
+import { Plugin } from "@dxos/app-framework";
+import { AppPlugin } from "@dxos/app-toolkit";
+import { OperationHandler } from "#capabilities";
+import { meta } from "#meta";
+import { Chess } from "#types";
+var ChessPlugin = Plugin.define(meta).pipe(AppPlugin.addOperationHandlerModule({
+  activate: OperationHandler
+}), AppPlugin.addSchemaModule({
+  schema: [
+    Chess.State
+  ]
+}), Plugin.make);
+var ChessPlugin_workerd_default = ChessPlugin;
+export {
+  ChessPlugin,
+  ChessPlugin_workerd_default as default
+};
+//# sourceMappingURL=ChessPlugin.workerd.mjs.map

package/dist/lib/neutral/ChessPlugin.workerd.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ChessPlugin.workerd.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport { Plugin } from '@dxos/app-framework';\nimport { AppPlugin } from '@dxos/app-toolkit';\n\nimport { OperationHandler } from '#capabilities';\nimport { meta } from '#meta';\nimport { Chess } from '#types';\n\nexport const ChessPlugin = Plugin.define(meta).pipe(\n  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),\n  AppPlugin.addSchemaModule({ schema: [Chess.State] }),\n  Plugin.make,\n);\n\nexport default ChessPlugin;\n"],
+  "mappings": ";;;AAIA,SAASA,cAAc;AACvB,SAASC,iBAAiB;AAE1B,SAASC,wBAAwB;AACjC,SAASC,YAAY;AACrB,SAASC,aAAa;AAEf,IAAMC,cAAcL,OAAOM,OAAOH,IAAAA,EAAMI,KAC7CN,UAAUO,0BAA0B;EAAEC,UAAUP;AAAiB,CAAA,GACjED,UAAUS,gBAAgB;EAAEC,QAAQ;IAACP,MAAMQ;;AAAO,CAAA,GAClDZ,OAAOa,IAAI;AAGb,IAAA,8BAAeR;",
+  "names": ["Plugin", "AppPlugin", "OperationHandler", "meta", "Chess", "ChessPlugin", "define", "pipe", "addOperationHandlerModule", "activate", "addSchemaModule", "schema", "State", "make"]
+}

package/dist/lib/neutral/blueprint-definition-PZXHAYLD.mjs

@@ -0,0 +1,15 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/capabilities/blueprint-definition.ts
+import * as Effect from "effect/Effect";
+import { Capability } from "@dxos/app-framework";
+import { AppCapabilities } from "@dxos/app-toolkit";
+import { ChessBlueprint } from "#blueprints";
+var blueprintDefinition = Capability.makeModule(() => Effect.succeed([
+  Capability.contributes(AppCapabilities.BlueprintDefinition, ChessBlueprint)
+]));
+var blueprint_definition_default = blueprintDefinition;
+export {
+  blueprint_definition_default as default
+};
+//# sourceMappingURL=blueprint-definition-PZXHAYLD.mjs.map

package/dist/lib/neutral/blueprint-definition-PZXHAYLD.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/blueprint-definition.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Capability } from '@dxos/app-framework';\nimport { AppCapabilities } from '@dxos/app-toolkit';\n// eslint-disable-next-line unused-imports/no-unused-imports\nimport type { Blueprint } from '@dxos/compute';\n\nimport { ChessBlueprint } from '#blueprints';\n\nconst blueprintDefinition = Capability.makeModule<\n  [],\n  Capability.Capability<typeof AppCapabilities.BlueprintDefinition>[]\n>(() => Effect.succeed([Capability.contributes(AppCapabilities.BlueprintDefinition, ChessBlueprint)]));\n\nexport default blueprintDefinition;\n"],
+  "mappings": ";;;AAIA,YAAYA,YAAY;AAExB,SAASC,kBAAkB;AAC3B,SAASC,uBAAuB;AAIhC,SAASC,sBAAsB;AAE/B,IAAMC,sBAAsBH,WAAWI,WAGrC,MAAaC,eAAQ;EAACL,WAAWM,YAAYL,gBAAgBM,qBAAqBL,cAAAA;CAAgB,CAAA;AAEpG,IAAA,+BAAeC;",
+  "names": ["Effect", "Capability", "AppCapabilities", "ChessBlueprint", "blueprintDefinition", "makeModule", "succeed", "contributes", "BlueprintDefinition"]
+}

package/dist/lib/neutral/blueprints/index.mjs

@@ -0,0 +1,8 @@
+import {
+  chess_blueprint_default
+} from "../chunk-XWKNXG62.mjs";
+import "../chunk-J5LGTIGS.mjs";
+export {
+  chess_blueprint_default as ChessBlueprint
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/capabilities/index.mjs

@@ -0,0 +1,13 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/capabilities/index.ts
+import { Capability } from "@dxos/app-framework";
+var BlueprintDefinition = Capability.lazy("BlueprintDefinition", () => import("../blueprint-definition-PZXHAYLD.mjs"));
+var GameVariant = Capability.lazy("GameVariant", () => import("../game-variant-24UKIBRM.mjs"));
+var OperationHandler = Capability.lazy("OperationHandler", () => import("../operation-handler-EKZKFQUG.mjs"));
+export {
+  BlueprintDefinition,
+  GameVariant,
+  OperationHandler
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/neutral/capabilities/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/capabilities/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capability } from '@dxos/app-framework';\n// eslint-disable-next-line unused-imports/no-unused-imports\nimport type { Blueprint, OperationHandlerSet } from '@dxos/compute';\n\nexport const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));\nexport const GameVariant = Capability.lazy('GameVariant', () => import('./game-variant'));\nexport const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(\n  'OperationHandler',\n  () => import('./operation-handler'),\n);\n"],
+  "mappings": ";;;AAIA,SAASA,kBAAkB;AAIpB,IAAMC,sBAAsBD,WAAWE,KAAK,uBAAuB,MAAM,OAAO,sCAAA,CAAA;AAChF,IAAMC,cAAcH,WAAWE,KAAK,eAAe,MAAM,OAAO,8BAAA,CAAA;AAChE,IAAME,mBAAmBJ,WAAWE,KACzC,oBACA,MAAM,OAAO,mCAAA,CAAA;",
+  "names": ["Capability", "BlueprintDefinition", "lazy", "GameVariant", "OperationHandler"]
+}

package/dist/lib/neutral/chunk-5UOTTW6U.mjs

@@ -0,0 +1,8 @@
+// src/operations/index.ts
+import { OperationHandlerSet } from "@dxos/compute";
+var ChessOperationHandlerSet = OperationHandlerSet.lazy(() => import("./move-RQZ7BJY3.mjs"), () => import("./play-GDGCEPQL.mjs"), () => import("./print-ZQA74KZI.mjs"));
+
+export {
+  ChessOperationHandlerSet
+};
+//# sourceMappingURL=chunk-5UOTTW6U.mjs.map

package/dist/lib/neutral/chunk-5UOTTW6U.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { OperationHandlerSet } from '@dxos/compute';\n\nexport const ChessOperationHandlerSet = OperationHandlerSet.lazy(\n  () => import('./move'),\n  () => import('./play'),\n  () => import('./print'),\n);\n"],
+  "mappings": ";AAIA,SAASA,2BAA2B;AAE7B,IAAMC,2BAA2BD,oBAAoBE,KAC1D,MAAM,OAAO,qBAAA,GACb,MAAM,OAAO,qBAAA,GACb,MAAM,OAAO,sBAAA,CAAA;",
+  "names": ["OperationHandlerSet", "ChessOperationHandlerSet", "lazy"]
+}

package/dist/lib/neutral/chunk-E4LZPHAQ.mjs

@@ -0,0 +1,148 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/types/Chess.ts
+var Chess_exports = {};
+__export(Chess_exports, {
+  BLUEPRINT_KEY: () => BLUEPRINT_KEY,
+  State: () => State,
+  make: () => make
+});
+import { Chess as ChessJS } from "chess.js";
+import * as Schema from "effect/Schema";
+import { BlueprintsAnnotation } from "@dxos/app-toolkit";
+import { Annotation, Obj, Type } from "@dxos/echo";
+import { FormInputAnnotation, SystemTypeAnnotation } from "@dxos/echo/internal";
+import { log } from "@dxos/log";
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-chess/src/types/Chess.ts";
+var BLUEPRINT_KEY = "org.dxos.blueprint.chess";
+var State = Schema.Struct({
+  pgn: Schema.String.annotations({
+    description: "Portable Game Notation."
+  }).pipe(FormInputAnnotation.set(false), Schema.optional),
+  fen: Schema.String.annotations({
+    description: "Forsyth-Edwards Notation."
+  }).pipe(FormInputAnnotation.set(false), Schema.optional)
+}).pipe(
+  Type.object({
+    typename: "org.dxos.type.chess.state",
+    version: "0.1.0"
+  }),
+  Annotation.IconAnnotation.set({
+    icon: "ph--shield-chevron--regular",
+    hue: "amber"
+  }),
+  BlueprintsAnnotation.set([
+    BLUEPRINT_KEY
+  ]),
+  // Implementation detail of the unified `Game` schema. The user-facing object is `Game`;
+  // this state is only ever referenced via `Game.variant`. SystemType keeps it out of the
+  // navtree's typed branches so an orphaned state object doesn't reappear after the
+  // wrapping Game is deleted.
+  SystemTypeAnnotation.set(true)
+);
+var make = ({ pgn, fen } = {}) => {
+  const chess = new ChessJS();
+  if (pgn) {
+    try {
+      chess.loadPgn(pgn);
+    } catch {
+      log.warn(pgn, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 40, S: void 0 });
+    }
+  }
+  return Obj.make(State, {
+    pgn,
+    fen
+  });
+};
+
+// src/types/ChessOperation.ts
+var ChessOperation_exports = {};
+__export(ChessOperation_exports, {
+  Move: () => Move,
+  Play: () => Play,
+  Print: () => Print
+});
+import * as Schema2 from "effect/Schema";
+import { Operation } from "@dxos/compute";
+import { Database } from "@dxos/echo";
+import { GameRef } from "@dxos/plugin-game";
+var Move = Operation.make({
+  meta: {
+    key: "org.dxos.function.chess.move",
+    name: "Move",
+    description: "Makes a move in the given chess game."
+  },
+  input: Schema2.Struct({
+    game: GameRef(State).annotations({
+      description: "The ID of the game object (variant must be Chess)."
+    }),
+    move: Schema2.String.annotations({
+      description: "The move to make in the chess game.",
+      examples: [
+        "e4",
+        "Bf3"
+      ]
+    })
+  }),
+  output: Schema2.Struct({
+    pgn: Schema2.String.annotations({
+      description: "The PGN of the game after the move was played."
+    })
+  }),
+  services: [
+    Database.Service
+  ]
+});
+var Play = Operation.make({
+  meta: {
+    key: "org.dxos.function.chess.play",
+    name: "Play",
+    description: "Uses the chess engine to play the next move."
+  },
+  input: Schema2.Struct({
+    game: GameRef(State).annotations({
+      description: "The ID of the game object (variant must be Chess)."
+    }),
+    side: Schema2.optional(Schema2.Literal("white", "black", "any")).annotations({
+      description: "The side to play.",
+      defaultValue: "any"
+    })
+  }),
+  output: Schema2.Struct({
+    pgn: Schema2.String.annotations({
+      description: "The PGN of the game after the move was played."
+    }),
+    move: Schema2.optional(Schema2.String).annotations({
+      description: "The move that was played."
+    })
+  }),
+  services: [
+    Database.Service
+  ]
+});
+var Print = Operation.make({
+  meta: {
+    key: "org.dxos.function.chess.print",
+    name: "Print game",
+    description: "Prints the chess game to ASCII."
+  },
+  input: Schema2.Struct({
+    pgn: Schema2.optional(Schema2.String.annotations({
+      description: "Portable Game Notation."
+    })),
+    fen: Schema2.optional(Schema2.String.annotations({
+      description: "Forsyth-Edwards Notation."
+    }))
+  }),
+  output: Schema2.Struct({
+    ascii: Schema2.String
+  })
+});
+
+export {
+  Chess_exports,
+  ChessOperation_exports
+};
+//# sourceMappingURL=chunk-E4LZPHAQ.mjs.map

package/dist/lib/neutral/chunk-E4LZPHAQ.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/Chess.ts", "../../../src/types/ChessOperation.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Chess as ChessJS } from 'chess.js';\nimport * as Schema from 'effect/Schema';\n\nimport { BlueprintsAnnotation } from '@dxos/app-toolkit';\nimport { Annotation, Obj, Type } from '@dxos/echo';\nimport { FormInputAnnotation, SystemTypeAnnotation } from '@dxos/echo/internal';\nimport { log } from '@dxos/log';\n\nexport const BLUEPRINT_KEY = 'org.dxos.blueprint.chess';\n\n/**\n * Chess variant state. Referenced by the base `Game` object via `Game.variant`.\n * Players, name, and other game-shared fields live on the base `Game`.\n */\nexport const State = Schema.Struct({\n  pgn: Schema.String.annotations({\n    description: 'Portable Game Notation.',\n  }).pipe(FormInputAnnotation.set(false), Schema.optional),\n  fen: Schema.String.annotations({\n    description: 'Forsyth-Edwards Notation.',\n  }).pipe(FormInputAnnotation.set(false), Schema.optional),\n}).pipe(\n  Type.object({\n    typename: 'org.dxos.type.chess.state',\n    version: '0.1.0',\n  }),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--shield-chevron--regular',\n    hue: 'amber',\n  }),\n  BlueprintsAnnotation.set([BLUEPRINT_KEY]),\n  // Implementation detail of the unified `Game` schema. The user-facing object is `Game`;\n  // this state is only ever referenced via `Game.variant`. SystemType keeps it out of the\n  // navtree's typed branches so an orphaned state object doesn't reappear after the\n  // wrapping Game is deleted.\n  SystemTypeAnnotation.set(true),\n);\n\nexport interface State extends Schema.Schema.Type<typeof State> {}\n\nexport const make = ({ pgn, fen }: { pgn?: string; fen?: string } = {}): State => {\n  const chess = new ChessJS();\n  if (pgn) {\n    try {\n      chess.loadPgn(pgn);\n    } catch {\n      log.warn(pgn);\n    }\n  }\n\n  return Obj.make(State, {\n    pgn,\n    fen,\n  });\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { Operation } from '@dxos/compute';\nimport { Database } from '@dxos/echo';\nimport { GameRef } from '@dxos/plugin-game';\n\nimport * as Chess from './Chess';\n\nexport const Move = Operation.make({\n  meta: {\n    key: 'org.dxos.function.chess.move',\n    name: 'Move',\n    description: 'Makes a move in the given chess game.',\n  },\n  input: Schema.Struct({\n    game: GameRef(Chess.State).annotations({\n      description: 'The ID of the game object (variant must be Chess).',\n    }),\n    move: Schema.String.annotations({\n      description: 'The move to make in the chess game.',\n      examples: ['e4', 'Bf3'],\n    }),\n  }),\n  output: Schema.Struct({\n    pgn: Schema.String.annotations({\n      description: 'The PGN of the game after the move was played.',\n    }),\n  }),\n  services: [Database.Service],\n});\n\nexport const Play = Operation.make({\n  meta: {\n    key: 'org.dxos.function.chess.play',\n    name: 'Play',\n    description: 'Uses the chess engine to play the next move.',\n  },\n  input: Schema.Struct({\n    game: GameRef(Chess.State).annotations({\n      description: 'The ID of the game object (variant must be Chess).',\n    }),\n    side: Schema.optional(Schema.Literal('white', 'black', 'any')).annotations({\n      description: 'The side to play.',\n      defaultValue: 'any',\n    }),\n  }),\n  output: Schema.Struct({\n    pgn: Schema.String.annotations({\n      description: 'The PGN of the game after the move was played.',\n    }),\n    move: Schema.optional(Schema.String).annotations({\n      description: 'The move that was played.',\n    }),\n  }),\n  services: [Database.Service],\n});\n\nexport const Print = Operation.make({\n  meta: {\n    key: 'org.dxos.function.chess.print',\n    name: 'Print game',\n    description: 'Prints the chess game to ASCII.',\n  },\n  input: Schema.Struct({\n    pgn: Schema.optional(\n      Schema.String.annotations({\n        description: 'Portable Game Notation.',\n      }),\n    ),\n    fen: Schema.optional(\n      Schema.String.annotations({\n        description: 'Forsyth-Edwards Notation.',\n      }),\n    ),\n  }),\n  output: Schema.Struct({\n    ascii: Schema.String,\n  }),\n});\n"],
+  "mappings": ";;;;;AAAA;;;;;;AAIA,SAASA,SAASC,eAAe;AACjC,YAAYC,YAAY;AAExB,SAASC,4BAA4B;AACrC,SAASC,YAAYC,KAAKC,YAAY;AACtC,SAASC,qBAAqBC,4BAA4B;AAC1D,SAASC,WAAW;AAEpB,IAAA,eAAaC;;AAQTC,IAAAA,QAAa,cAAA;EACf,KAAQJ,cAAAA,YAAuB;IAC/BK,aAAYC;UACVF,oBAAa,IAAA,KAAA,GAAA,eAAA;EACf,KAAQJ,cAAAA,YAAuB;IAE/BD,aAAY;EACVQ,CAAAA,EAAAA,KAAAA,oBAAU,IAAA,KAAA,GAAA,eAAA;;EACVC,KAAS,OAAA;IAEXX,UAAAA;IACEY,SAAM;;EACNC,WAAK,eAAA,IAAA;IAEPd,MAAAA;IAA0BO,KAAAA;GAAc;EACxC,qBAAA,IAAA;IACA;EACA,CAAA;;;;;uBAQc,IAAIT,IAAAA;AAAAA;AAClB,IAAS,OAAA,CAAA,EAAA,KAAA,IAAA,IAAA,CAAA,MAAA;QACP,QAAI,IAAA,QAAA;WACFiB;AACF,QAAE;AACAT,YAAIU,QAAKC,GAAAA;IACX,QAAA;AACF,UAAA,KAAA,KAAA,QAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,OAAA,CAAA;IAEA;;SAEER,IAAAA,KAAAA,OAAAA;IACF;IACA;;;;;AC1DF;;;;;;AAMA,YAAYS,aAAY;AAExB,SAASC,iBAAiB;AAC1B,SAASC,gBAAgB;AACzB,SAASC,eAAe;AAIjB,IAAMC,OAAOC,UAAUC,KAAK;EACjCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,eAAO;IACnBC,MAAMC,QAAcC,KAAK,EAAEC,YAAY;MACrCN,aAAa;IACf,CAAA;IACAO,MAAaC,eAAOF,YAAY;MAC9BN,aAAa;MACbS,UAAU;QAAC;QAAM;;IACnB,CAAA;EACF,CAAA;EACAC,QAAeR,eAAO;IACpBS,KAAYH,eAAOF,YAAY;MAC7BN,aAAa;IACf,CAAA;EACF,CAAA;EACAY,UAAU;IAACC,SAASC;;AACtB,CAAA;AAEO,IAAMC,OAAOpB,UAAUC,KAAK;EACjCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,eAAO;IACnBC,MAAMC,QAAcC,KAAK,EAAEC,YAAY;MACrCN,aAAa;IACf,CAAA;IACAgB,MAAaC,iBAAgBC,gBAAQ,SAAS,SAAS,KAAA,CAAA,EAAQZ,YAAY;MACzEN,aAAa;MACbmB,cAAc;IAChB,CAAA;EACF,CAAA;EACAT,QAAeR,eAAO;IACpBS,KAAYH,eAAOF,YAAY;MAC7BN,aAAa;IACf,CAAA;IACAO,MAAaU,iBAAgBT,cAAM,EAAEF,YAAY;MAC/CN,aAAa;IACf,CAAA;EACF,CAAA;EACAY,UAAU;IAACC,SAASC;;AACtB,CAAA;AAEO,IAAMM,QAAQzB,UAAUC,KAAK;EAClCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,eAAO;IACnBS,KAAYM,iBACHT,eAAOF,YAAY;MACxBN,aAAa;IACf,CAAA,CAAA;IAEFqB,KAAYJ,iBACHT,eAAOF,YAAY;MACxBN,aAAa;IACf,CAAA,CAAA;EAEJ,CAAA;EACAU,QAAeR,eAAO;IACpBoB,OAAcd;EAChB,CAAA;AACF,CAAA;",
+  "names": ["Chess", "ChessJS", "Schema", "BlueprintsAnnotation", "Annotation", "Obj", "Type", "FormInputAnnotation", "SystemTypeAnnotation", "log", "BLUEPRINT_KEY", "description", "fen", "String", "typename", "version", "icon", "hue", "chess", "warn", "pgn", "Schema", "Operation", "Database", "GameRef", "Move", "Operation", "make", "meta", "key", "name", "description", "input", "Struct", "game", "GameRef", "State", "annotations", "move", "String", "examples", "output", "pgn", "services", "Database", "Service", "Play", "side", "optional", "Literal", "defaultValue", "Print", "fen", "ascii"]
+}

package/dist/lib/neutral/chunk-HVIKFYAW.mjs

@@ -0,0 +1,29 @@
+// src/ChessPlugin.tsx
+import { Plugin } from "@dxos/app-framework";
+import { AppPlugin, AppActivationEvents } from "@dxos/app-toolkit";
+import { BlueprintDefinition, GameVariant, OperationHandler } from "#capabilities";
+import { meta } from "#meta";
+import { translations } from "#translations";
+import { Chess } from "#types";
+var ChessPlugin = Plugin.define(meta).pipe(Plugin.addModule({
+  id: "game-variant",
+  activatesOn: AppActivationEvents.SetupSchema,
+  activate: GameVariant
+}), AppPlugin.addBlueprintDefinitionModule({
+  activate: BlueprintDefinition
+}), AppPlugin.addOperationHandlerModule({
+  activate: OperationHandler
+}), AppPlugin.addSchemaModule({
+  schema: [
+    Chess.State
+  ]
+}), AppPlugin.addTranslationsModule({
+  translations
+}), Plugin.make);
+var ChessPlugin_default = ChessPlugin;
+
+export {
+  ChessPlugin,
+  ChessPlugin_default
+};
+//# sourceMappingURL=chunk-HVIKFYAW.mjs.map

package/dist/lib/neutral/chunk-HVIKFYAW.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ChessPlugin.tsx"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { Plugin } from '@dxos/app-framework';\nimport { AppPlugin, AppActivationEvents } from '@dxos/app-toolkit';\n\nimport { BlueprintDefinition, GameVariant, OperationHandler } from '#capabilities';\nimport { meta } from '#meta';\nimport { translations } from '#translations';\nimport { Chess } from '#types';\n\nexport const ChessPlugin = Plugin.define(meta).pipe(\n  Plugin.addModule({\n    id: 'game-variant',\n    activatesOn: AppActivationEvents.SetupSchema,\n    activate: GameVariant,\n  }),\n  AppPlugin.addBlueprintDefinitionModule({ activate: BlueprintDefinition }),\n  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),\n  AppPlugin.addSchemaModule({ schema: [Chess.State] }),\n  AppPlugin.addTranslationsModule({ translations }),\n  Plugin.make,\n);\n\nexport default ChessPlugin;\n"],
+  "mappings": ";AAIA,SAASA,cAAc;AACvB,SAASC,WAAWC,2BAA2B;AAE/C,SAASC,qBAAqBC,aAAaC,wBAAwB;AACnE,SAASC,YAAY;AACrB,SAASC,oBAAoB;AAC7B,SAASC,aAAa;AAEf,IAAMC,cAAcT,OAAOU,OAAOJ,IAAAA,EAAMK,KAC7CX,OAAOY,UAAU;EACfC,IAAI;EACJC,aAAaZ,oBAAoBa;EACjCC,UAAUZ;AACZ,CAAA,GACAH,UAAUgB,6BAA6B;EAAED,UAAUb;AAAoB,CAAA,GACvEF,UAAUiB,0BAA0B;EAAEF,UAAUX;AAAiB,CAAA,GACjEJ,UAAUkB,gBAAgB;EAAEC,QAAQ;IAACZ,MAAMa;;AAAO,CAAA,GAClDpB,UAAUqB,sBAAsB;EAAEf;AAAa,CAAA,GAC/CP,OAAOuB,IAAI;AAGb,IAAA,sBAAed;",
+  "names": ["Plugin", "AppPlugin", "AppActivationEvents", "BlueprintDefinition", "GameVariant", "OperationHandler", "meta", "translations", "Chess", "ChessPlugin", "define", "pipe", "addModule", "id", "activatesOn", "SetupSchema", "activate", "addBlueprintDefinitionModule", "addOperationHandlerModule", "addSchemaModule", "schema", "State", "addTranslationsModule", "make"]
+}

package/dist/lib/neutral/chunk-J5LGTIGS.mjs

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/lib/neutral/chunk-J5LGTIGS.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/chunk-V4UMIQ6K.mjs

@@ -0,0 +1,31 @@
+// src/meta.ts
+import { meta as gameMeta } from "@dxos/plugin-game";
+import { trim } from "@dxos/util";
+var meta = {
+  id: "org.dxos.plugin.chess",
+  name: "Chess",
+  author: "DXOS",
+  description: trim`
+    Full-featured chess game supporting multiplayer matches with friends or practice sessions against AI opponents.
+    Track game history and analyze moves in real-time.
+  `,
+  icon: "ph--shield-chevron--regular",
+  iconHue: "amber",
+  source: "https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-chess",
+  spec: "PLUGIN.mdl",
+  screenshots: [
+    "https://dxos.network/plugin-details-chess-dark.png"
+  ],
+  dependsOn: [
+    gameMeta.id
+  ],
+  version: "0.8.3",
+  tags: [
+    "game"
+  ]
+};
+
+export {
+  meta
+};
+//# sourceMappingURL=chunk-V4UMIQ6K.mjs.map

package/dist/lib/neutral/chunk-V4UMIQ6K.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/meta.ts"],
+  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { type Plugin } from '@dxos/app-framework';\nimport { meta as gameMeta } from '@dxos/plugin-game';\nimport { trim } from '@dxos/util';\n\nexport const meta: Plugin.Meta = {\n  id: 'org.dxos.plugin.chess',\n  name: 'Chess',\n  author: 'DXOS',\n  description: trim`\n    Full-featured chess game supporting multiplayer matches with friends or practice sessions against AI opponents.\n    Track game history and analyze moves in real-time.\n  `,\n  icon: 'ph--shield-chevron--regular',\n  iconHue: 'amber',\n  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-chess',\n  spec: 'PLUGIN.mdl',\n  screenshots: ['https://dxos.network/plugin-details-chess-dark.png'],\n  dependsOn: [gameMeta.id],\n  version: '0.8.3',\n  tags: ['game'],\n};\n"],
+  "mappings": ";AAKA,SAASA,QAAQC,gBAAgB;AACjC,SAASC,YAAY;AAEd,IAAMF,OAAoB;EAC/BG,IAAI;EACJC,MAAM;EACNC,QAAQ;EACRC,aAAaJ;;;;EAIbK,MAAM;EACNC,SAAS;EACTC,QAAQ;EACRC,MAAM;EACNC,aAAa;IAAC;;EACdC,WAAW;IAACX,SAASE;;EACrBU,SAAS;EACTC,MAAM;IAAC;;AACT;",
+  "names": ["meta", "gameMeta", "trim", "id", "name", "author", "description", "icon", "iconHue", "source", "spec", "screenshots", "dependsOn", "version", "tags"]
+}

package/dist/lib/neutral/chunk-XWKNXG62.mjs

@@ -0,0 +1,34 @@
+// src/blueprints/chess-blueprint.ts
+import { Blueprint, Template } from "@dxos/compute";
+import { trim } from "@dxos/util";
+import { Chess, ChessOperation } from "#types";
+var operations = [
+  ChessOperation.Move,
+  ChessOperation.Play,
+  ChessOperation.Print
+];
+var make = () => Blueprint.make({
+  key: Chess.BLUEPRINT_KEY,
+  name: "Chess",
+  tools: Blueprint.toolDefinitions({
+    operations
+  }),
+  instructions: Template.make({
+    source: trim`
+        You are an expert chess player.
+        To analyze a game you can access the "pgn" property by loading the context object that represents the current game.
+        You could suggest a good next move or offer to play a move.
+        Don't actually make a move unless you are asked to.
+      `
+  })
+});
+var blueprint = {
+  key: Chess.BLUEPRINT_KEY,
+  make
+};
+var chess_blueprint_default = blueprint;
+
+export {
+  chess_blueprint_default
+};
+//# sourceMappingURL=chunk-XWKNXG62.mjs.map

package/dist/lib/neutral/chunk-XWKNXG62.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/blueprints/chess-blueprint.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Blueprint, Template } from '@dxos/compute';\nimport { trim } from '@dxos/util';\n\nimport { Chess, ChessOperation } from '#types';\n\nconst operations = [ChessOperation.Move, ChessOperation.Play, ChessOperation.Print];\n\nconst make = () =>\n  Blueprint.make({\n    key: Chess.BLUEPRINT_KEY,\n    name: 'Chess',\n    tools: Blueprint.toolDefinitions({ operations }),\n    instructions: Template.make({\n      source: trim`\n        You are an expert chess player.\n        To analyze a game you can access the \"pgn\" property by loading the context object that represents the current game.\n        You could suggest a good next move or offer to play a move.\n        Don't actually make a move unless you are asked to.\n      `,\n    }),\n  });\n\nconst blueprint: Blueprint.Definition = {\n  key: Chess.BLUEPRINT_KEY,\n  make,\n};\n\nexport default blueprint;\n"],
+  "mappings": ";AAIA,SAASA,WAAWC,gBAAgB;AACpC,SAASC,YAAY;AAErB,SAASC,OAAOC,sBAAsB;AAEtC,IAAMC,aAAa;EAACD,eAAeE;EAAMF,eAAeG;EAAMH,eAAeI;;AAE7E,IAAMC,OAAO,MACXT,UAAUS,KAAK;EACbC,KAAKP,MAAMQ;EACXC,MAAM;EACNC,OAAOb,UAAUc,gBAAgB;IAAET;EAAW,CAAA;EAC9CU,cAAcd,SAASQ,KAAK;IAC1BO,QAAQd;;;;;;EAMV,CAAA;AACF,CAAA;AAEF,IAAMe,YAAkC;EACtCP,KAAKP,MAAMQ;EACXF;AACF;AAEA,IAAA,0BAAeQ;",
+  "names": ["Blueprint", "Template", "trim", "Chess", "ChessOperation", "operations", "Move", "Play", "Print", "make", "key", "BLUEPRINT_KEY", "name", "tools", "toolDefinitions", "instructions", "source", "blueprint"]
+}