@dxos/plugin-chess 0.8.4-main.f9ba587 → 0.8.4-main.fcc0d83b33

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/types/Chess.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Chess as ChessJS } from 'chess.js';\nimport * as Schema from 'effect/Schema';\n\nimport { Annotation, Obj, Type } from '@dxos/echo';\nimport { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/internal';\nimport { log } from '@dxos/log';\n\nexport const Game = Schema.Struct({\n  name: Schema.optional(Schema.String),\n  players: Schema.Struct({\n    white: Schema.optional(\n      Schema.String.annotations({\n        description: 'DID of white player',\n      }),\n    ),\n    black: Schema.optional(\n      Schema.String.annotations({\n        description: 'DID of black player',\n      }),\n    ),\n  }).pipe(FormInputAnnotation.set(false), Schema.optional),\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',\n    version: '0.1.0',\n  }),\n  LabelAnnotation.set(['name']),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--shield-chevron--regular',\n    hue: 'amber',\n  }),\n);\n\nexport interface Game extends Schema.Schema.Type<typeof Game> {}\n\nexport const make = ({ name, pgn, fen }: { name?: string; pgn?: string; fen?: string } = {}) => {\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(Game, {\n    name,\n    pgn,\n    fen,\n    players: {},\n  });\n};\n"],
+  "mappings": ";;;;;;AAAA;;;;;AAIA,SAASA,SAASC,eAAe;AACjC,YAAYC,YAAY;AAExB,SAASC,YAAYC,KAAKC,YAAY;AACtC,SAASC,qBAAqBC,uBAAuB;AACrD,SAASC,WAAW;AAEpB,IAAA,eAAaC;AAEXC,IAASR,OAAc,cAAA;QACdA,gBACLA,aAAOS;WACLC,cAAa;IACf,OAAA,gBAAA,cAAA,YAAA;MAEFC,aAAcC;;IAGZ,OAAA,gBAAA,cAAA,YAAA;MAEIR,aAAAA;IACRS,CAAKb,CAAAA;UACHU,oBAAa,IAAA,KAAA,GAAA,eAAA;EACf,KAAQN,cAAAA,YAAuB;IAC/BU,aAAYL;UACVC,oBAAa,IAAA,KAAA,GAAA,eAAA;EACf,KAAQN,cAAAA,YAAuB;IAE/BD,aAAY;EACVY,CAAAA,EAAAA,KAAAA,oBAAU,IAAA,KAAA,GAAA,eAAA;QACVC,KAAS,OAAA;EAEXX,UAAAA;EAAqB,SAAA;CAAO,GAC5BJ,gBAAWgB,IAAAA;EACTC;IACAC,WAAK,eAAA,IAAA;EAEP,MAAA;EAIF,KAAO;;AAEL,IAAS,OAAA,CAAA,EAAA,MAAA,KAAA,IAAA,IAAA,CAAA,MAAA;QACP,QAAI,IAAA,QAAA;WACFC;AACF,QAAE;AACAd,YAAIe,QAAKR,GAAAA;IACX,QAAA;AACF,UAAA,KAAA,KAAA,QAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,OAAA,CAAA;IAEA;;SAEEA,IAAAA,KAAAA,MAAAA;IACAC;IACAN;IACF;IACA,SAAA,CAAA;;;",
+  "names": ["Chess", "ChessJS", "Schema", "Annotation", "Obj", "Type", "FormInputAnnotation", "LabelAnnotation", "log", "Game", "players", "String", "description", "black", "optional", "pgn", "fen", "typename", "version", "IconAnnotation", "icon", "hue", "chess", "warn"]
+}

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

@@ -0,0 +1,29 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Create,
+  Move,
+  Play,
+  Print
+} from "./chunk-G2EHRXHX.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/operations/index.ts
+var operations_exports = {};
+__export(operations_exports, {
+  ChessHandlers: () => ChessHandlers,
+  Create: () => Create,
+  Move: () => Move,
+  Play: () => Play,
+  Print: () => Print
+});
+import { OperationHandlerSet } from "@dxos/compute";
+var Handlers = OperationHandlerSet.lazy(() => import("./create-CC2P7GPT.mjs"), () => import("./move-CYHXWHHM.mjs"), () => import("./play-KTNK2PBL.mjs"), () => import("./print-P23VKVNU.mjs"));
+var ChessHandlers = Handlers;
+
+export {
+  ChessHandlers,
+  operations_exports
+};
+//# sourceMappingURL=chunk-V4FN2DZR.mjs.map

package/dist/lib/node-esm/chunk-V4FN2DZR.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\nconst Handlers = OperationHandlerSet.lazy(\n  () => import('./create'),\n  () => import('./move'),\n  () => import('./play'),\n  () => import('./print'),\n);\n\nexport { Create, Move, Play, Print } from './definitions';\n\nexport const ChessHandlers = Handlers;\n"],
+  "mappings": ";;;;;;;;;;;;AAAA;;;;;;;;AAIA,SAASA,2BAA2B;AAEpC,IAAMC,WAAWD,oBAAoBE,KACnC,MAAM,OAAO,uBAAA,GACb,MAAM,OAAO,qBAAA,GACb,MAAM,OAAO,qBAAA,GACb,MAAM,OAAO,sBAAA,CAAA;AAKR,IAAMC,gBAAgBF;",
+  "names": ["OperationHandlerSet", "Handlers", "lazy", "ChessHandlers"]
+}

package/dist/lib/node-esm/cli/index.mjs

@@ -0,0 +1,35 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import "../chunk-HSLMI22Q.mjs";
+
+// src/cli/plugin.ts
+import * as Effect from "effect/Effect";
+import { Plugin } from "@dxos/app-framework";
+import { AppPlugin } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { SpaceOperation } from "@dxos/plugin-space/operations";
+import { meta } from "#meta";
+import { Chess } from "#types";
+var ChessPlugin = Plugin.define(meta).pipe(AppPlugin.addMetadataModule({
+  metadata: {
+    id: Chess.Game.typename,
+    metadata: {
+      createObject: (props, options) => Effect.gen(function* () {
+        const object = Chess.make(props);
+        return yield* Operation.invoke(SpaceOperation.AddObject, {
+          object,
+          target: options.target,
+          hidden: true,
+          targetNodeId: options.targetNodeId
+        });
+      })
+    }
+  }
+}), AppPlugin.addSchemaModule({
+  schema: [
+    Chess.Game
+  ]
+}), Plugin.make);
+export {
+  ChessPlugin
+};
+//# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/cli/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cli/plugin.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Plugin } from '@dxos/app-framework';\nimport { AppPlugin } from '@dxos/app-toolkit';\nimport { Operation } from '@dxos/compute';\nimport { SpaceOperation } from '@dxos/plugin-space/operations';\nimport { type CreateObject } from '@dxos/plugin-space/types';\n\nimport { meta } from '#meta';\nimport { Chess } from '#types';\n\n// TODO(wittjosiah): Factor out shared modules.\nexport const ChessPlugin = Plugin.define(meta).pipe(\n  AppPlugin.addMetadataModule({\n    metadata: {\n      id: Chess.Game.typename,\n      metadata: {\n        createObject: ((props, options) =>\n          Effect.gen(function* () {\n            const object = Chess.make(props);\n            return yield* Operation.invoke(SpaceOperation.AddObject, {\n              object,\n              target: options.target,\n              hidden: true,\n              targetNodeId: options.targetNodeId,\n            });\n          })) satisfies CreateObject,\n      },\n    },\n  }),\n  AppPlugin.addSchemaModule({ schema: [Chess.Game] }),\n  Plugin.make,\n);\n"],
+  "mappings": ";;;;AAIA,YAAYA,YAAY;AAExB,SAASC,cAAc;AACvB,SAASC,iBAAiB;AAC1B,SAASC,iBAAiB;AAC1B,SAASC,sBAAsB;AAG/B,SAASC,YAAY;AACrB,SAASC,aAAa;AAGf,IAAMC,cAAcN,OAAOO,OAAOH,IAAAA,EAAMI,KAC7CP,UAAUQ,kBAAkB;EAC1BC,UAAU;IACRC,IAAIN,MAAMO,KAAKC;IACfH,UAAU;MACRI,cAAe,CAACC,OAAOC,YACdC,WAAI,aAAA;AACT,cAAMC,SAASb,MAAMc,KAAKJ,KAAAA;AAC1B,eAAO,OAAOb,UAAUkB,OAAOjB,eAAekB,WAAW;UACvDH;UACAI,QAAQN,QAAQM;UAChBC,QAAQ;UACRC,cAAcR,QAAQQ;QACxB,CAAA;MACF,CAAA;IACJ;EACF;AACF,CAAA,GACAvB,UAAUwB,gBAAgB;EAAEC,QAAQ;IAACrB,MAAMO;;AAAM,CAAA,GACjDZ,OAAOmB,IAAI;",
+  "names": ["Effect", "Plugin", "AppPlugin", "Operation", "SpaceOperation", "meta", "Chess", "ChessPlugin", "define", "pipe", "addMetadataModule", "metadata", "id", "Game", "typename", "createObject", "props", "options", "gen", "object", "make", "invoke", "AddObject", "target", "hidden", "targetNodeId", "addSchemaModule", "schema"]
+}

package/dist/lib/node-esm/create-CC2P7GPT.mjs

@@ -0,0 +1,25 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Create
+} from "./chunk-G2EHRXHX.mjs";
+import {
+  Chess_exports
+} from "./chunk-OHBKSL2Q.mjs";
+import "./chunk-HSLMI22Q.mjs";
+
+// src/operations/create.ts
+import * as Effect from "effect/Effect";
+import { Operation } from "@dxos/compute";
+import { Database } from "@dxos/echo";
+var handler = Create.pipe(Operation.withHandler(Effect.fn(function* ({ name, pgn, fen }) {
+  return yield* Database.add(Chess_exports.make({
+    name,
+    pgn,
+    fen
+  }));
+})));
+var create_default = handler;
+export {
+  create_default as default
+};
+//# sourceMappingURL=create-CC2P7GPT.mjs.map

package/dist/lib/node-esm/create-CC2P7GPT.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/operations/create.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport { Operation } from '@dxos/compute';\nimport { Database } from '@dxos/echo';\n\nimport { Chess } from '../types';\nimport { Create } from './definitions';\n\nconst handler: Operation.WithHandler<typeof Create> = Create.pipe(\n  Operation.withHandler(\n    Effect.fn(function* ({ name, pgn, fen }) {\n      return yield* Database.add(Chess.make({ name, pgn, fen }));\n    }),\n  ),\n);\n\nexport default handler;\n"],
+  "mappings": ";;;;;;;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,iBAAiB;AAC1B,SAASC,gBAAgB;AAKzB,IAAMC,UAAgDC,OAAOC,KAC3DC,UAAUC,YACDC,UAAG,WAAW,EAAEC,MAAMC,KAAKC,IAAG,GAAE;AACrC,SAAO,OAAOC,SAASC,IAAIC,cAAMC,KAAK;IAAEN;IAAMC;IAAKC;EAAI,CAAA,CAAA;AACzD,CAAA,CAAA,CAAA;AAIJ,IAAA,iBAAeR;",
+  "names": ["Effect", "Operation", "Database", "handler", "Create", "pipe", "Operation", "withHandler", "fn", "name", "pgn", "fen", "Database", "add", "Chess", "make"]
+}

package/dist/lib/node-esm/index.mjs

@@ -1,97 +1,343 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  ChessContainer
-} from "./chunk-TD2SWK2H.mjs";
-import {
-  CHESS_PLUGIN,
-  ChessAction,
-  ChessType,
-  meta
-} from "./chunk-IS3Y25PL.mjs";
-import {
-  ChessComponent
-} from "./chunk-2DRWEDVT.mjs";
+import "./chunk-HSLMI22Q.mjs";
 
-// src/capabilities/index.ts
-import { lazy } from "@dxos/app-framework";
-var ArtifactDefinition = lazy(() => import("./artifact-definition-TT3747JB.mjs"));
-var IntentResolver = lazy(() => import("./intent-resolver-GXK2JROQ.mjs"));
-var ReactSurface = lazy(() => import("./react-surface-PAUEOIBL.mjs"));
+// src/components/Chessboard/Chessboard.tsx
+import { RegistryContext } from "@effect-atom/atom-react";
+import React2, { forwardRef, useCallback, useContext, useEffect as useEffect2, useImperativeHandle, useMemo as useMemo2, useRef as useRef2 } from "react";
+import { addEventListener } from "@dxos/async";
+import { useObject } from "@dxos/echo-react";
+import { Gameboard, Chessboard as NaturalChessboard, getRawPgn, useGameboardContext as useGameboardContext2 } from "@dxos/react-ui-gameboard";
+import { useSoundEffect } from "@dxos/react-ui-sfx";
 
-// src/ChessPlugin.tsx
-import { Capabilities, contributes, createIntent, defineModule, definePlugin, Events } from "@dxos/app-framework";
-import { ClientEvents } from "@dxos/plugin-client";
-import { SpaceCapabilities } from "@dxos/plugin-space";
-import { defineObjectForm } from "@dxos/plugin-space/types";
+// src/components/Chessboard/Info.tsx
+import { useAtomValue } from "@effect-atom/atom-react";
+import React, { useEffect, useMemo, useRef } from "react";
+import { generateName } from "@dxos/display-name";
+import { Obj } from "@dxos/echo";
+import { useMembers } from "@dxos/react-client/echo";
+import { Icon, IconButton, Select, useTranslation } from "@dxos/react-ui";
+import { useGameboardContext } from "@dxos/react-ui-gameboard";
+import { mx } from "@dxos/ui-theme";
+import { meta } from "#meta";
+var INFO_NAME = "Chessboard.Info";
+var Info = ({ classNames, orientation = "white", onOrientationChange, onClose, ...props }) => {
+  const { t } = useTranslation(meta.id);
+  const { model } = useGameboardContext(INFO_NAME);
+  const db = Obj.getDatabase(model.object);
+  const members = useMembers(db?.spaceId);
+  return /* @__PURE__ */ React.createElement("div", {
+    className: mx("grid grid-rows-[min-content_1fr_min-content] w-full min-w-[18rem] p-2 overflow-hidden bg-group-surface rounded-xs", classNames)
+  }, /* @__PURE__ */ React.createElement(PlayerIndicator, {
+    model,
+    player: orientation === "white" ? "black" : "white",
+    icon: onClose && /* @__PURE__ */ React.createElement(IconButton, {
+      variant: "ghost",
+      icon: "ph--x--regular",
+      iconOnly: true,
+      label: t("close-info.button"),
+      size: 4,
+      onClick: onClose
+    })
+  }, /* @__PURE__ */ React.createElement(PlayerSelector, {
+    value: model.object.players?.[orientation === "white" ? "black" : "white"],
+    onValueChange: (value) => {
+      Obj.update(model.object, (obj) => {
+        obj.players[orientation === "white" ? "black" : "white"] = value;
+      });
+    },
+    members
+  })), /* @__PURE__ */ React.createElement(History, {
+    model,
+    ...props
+  }), /* @__PURE__ */ React.createElement(PlayerIndicator, {
+    model,
+    player: orientation,
+    icon: onOrientationChange && /* @__PURE__ */ React.createElement(IconButton, {
+      classNames: mx("transition duration-200 ease-linear", orientation === "white" && "rotate-180"),
+      icon: "ph--arrows-clockwise--regular",
+      iconOnly: true,
+      label: t("flip-board.button"),
+      size: 4,
+      onClick: () => onOrientationChange(orientation === "white" ? "black" : "white")
+    })
+  }, /* @__PURE__ */ React.createElement(PlayerSelector, {
+    value: model.object.players?.[orientation],
+    onValueChange: (value) => {
+      Obj.update(model.object, (obj) => {
+        obj.players[orientation] = value;
+      });
+    },
+    members
+  })));
+};
+Info.displayName = INFO_NAME;
+var History = ({ classNames, model, min, max, onSelect }) => {
+  const { t } = useTranslation(meta.id);
+  const moveIndex = useAtomValue(model.moveIndex);
+  const label = model.game.isGameOver() ? model.game.isCheckmate() ? t("game.checkmate.label") : model.game.isStalemate() ? t("game.stalemate.label") : t("game.draw.label") : model.game.isCheck() ? t("game.check.label") : void 0;
+  const history = model.game.history();
+  const moves = useMemo(() => history.reduce((acc, move, index) => {
+    if (index % 2 === 0) {
+      acc.push([
+        {
+          index,
+          move
+        }
+      ]);
+    } else {
+      acc[acc.length - 1].push({
+        index,
+        move
+      });
+    }
+    return acc;
+  }, []), [
+    history.length
+  ]);
+  const scrollerRef = useRef(null);
+  useEffect(() => {
+    scrollerRef.current?.scrollTo({
+      top: scrollerRef.current.scrollHeight
+    });
+  }, [
+    history.length
+  ]);
+  useEffect(() => {
+    const div = scrollerRef.current?.querySelector(`[data-index="${moveIndex - 1}"]`);
+    scrollerRef.current?.classList.add("scrollbar-none");
+    div?.scrollIntoView({
+      behavior: "smooth"
+    });
+    scrollerRef.current?.classList.remove("scrollbar-none");
+  }, [
+    moveIndex
+  ]);
+  return /* @__PURE__ */ React.createElement("div", {
+    ref: scrollerRef,
+    className: mx("overflow-y-auto", classNames),
+    style: {
+      minHeight: min === void 0 ? "auto" : `${min * 24}px`,
+      maxHeight: max === void 0 ? "auto" : `${max * 24}px`
+    }
+  }, moves.map(([a, b], index) => /* @__PURE__ */ React.createElement("div", {
+    key: index,
+    className: "grid grid-cols-[3rem_1fr_1fr_1rem] gap-2 ps-4"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "content-center text-xs text-subdued"
+  }, index + 1), a && /* @__PURE__ */ React.createElement("div", {
+    "data-index": a.index,
+    className: mx("ps-2 text-sm cursor-pointer", a.index === moveIndex - 1 && "bg-primary-500"),
+    onClick: () => onSelect?.(a.index + 1)
+  }, a.move), b && /* @__PURE__ */ React.createElement("div", {
+    "data-index": b.index,
+    className: mx("ps-2 text-sm cursor-pointer", b.index === moveIndex - 1 && "bg-primary-500"),
+    onClick: () => onSelect?.(b.index + 1)
+  }, b.move))), label && /* @__PURE__ */ React.createElement("div", {
+    className: "text-center"
+  }, label));
+};
+var PlayerIndicator = ({ children, model, player, icon }) => {
+  const turn = player === (model.game.turn() === "w" ? "white" : "black");
+  return /* @__PURE__ */ React.createElement("div", {
+    className: "grid grid-cols-[2rem_1fr_2rem] gap-2 h-(--dx-rail-size) px-1 flex items-center overflow-hidden"
+  }, /* @__PURE__ */ React.createElement("div", {
+    className: "place-items-center"
+  }, /* @__PURE__ */ React.createElement(Icon, {
+    icon: turn ? "ph--circle--fill" : "ph--circle--thin",
+    size: 6,
+    classNames: mx(turn && (model.game.isCheckmate() ? "text-error-500" : "text-success-text"))
+  })), /* @__PURE__ */ React.createElement("div", {
+    className: "truncate overflow-hidden items-center"
+  }, children), icon);
+};
+var PlayerSelector = ({ value, onValueChange, members }) => {
+  const { t } = useTranslation(meta.id);
+  return /* @__PURE__ */ React.createElement(Select.Root, {
+    value,
+    onValueChange
+  }, /* @__PURE__ */ React.createElement(Select.TriggerButton, {
+    placeholder: t("select-player.button")
+  }), /* @__PURE__ */ React.createElement(Select.Portal, null, /* @__PURE__ */ React.createElement(Select.Content, null, /* @__PURE__ */ React.createElement(Select.Viewport, null, members.map((member) => {
+    const memberKey = member.identity.identityKey.toHex();
+    const displayName = member.identity?.profile?.displayName || generateName(memberKey);
+    return /* @__PURE__ */ React.createElement(Select.Option, {
+      key: memberKey,
+      value: memberKey
+    }, displayName);
+  })), /* @__PURE__ */ React.createElement(Select.Arrow, null))));
+};
+
+// src/components/Chessboard/types.ts
+import { ChessModel } from "@dxos/react-ui-gameboard";
+var ExtendedChessModel = class extends ChessModel {
+  object;
+  constructor(registry, object) {
+    super(registry), this.object = object;
+  }
+};
 
-// src/translations.ts
-var translations = [
-  {
-    "en-US": {
-      [ChessType.typename]: {
-        "typename label": "Game",
-        "typename label_zero": "Games",
-        "typename label_one": "Game",
-        "typename label_other": "Games",
-        "object name placeholder": "New game"
-      },
-      [meta.id]: {
-        "plugin name": "Chess",
-        "delete game label": "Delete"
+// src/components/Chessboard/Chessboard.tsx
+var Root = /* @__PURE__ */ forwardRef(({ game, children }, forwardedRef) => {
+  const registry = useContext(RegistryContext);
+  const model = useMemo2(() => new ExtendedChessModel(registry, game), [
+    registry
+  ]);
+  const click = useSoundEffect("Click");
+  const [pgn, updatePgn] = useObject(game, "pgn");
+  useImperativeHandle(forwardedRef, () => {
+    return {
+      setMoveNumber: (index) => model.setMoveIndex(index)
+    };
+  }, [
+    model
+  ]);
+  useEffect2(() => {
+    if (model.pgn !== getRawPgn(pgn ?? "")) {
+      const silent = model.pgn === "*";
+      model.update(pgn);
+      if (!silent) {
+        void click.play();
       }
     }
-  }
-];
+  }, [
+    pgn
+  ]);
+  const handleDrop = useCallback((move) => {
+    if (!model.makeMove(move)) {
+      return false;
+    }
+    void click.play();
+    updatePgn(() => model.pgn);
+    return true;
+  }, [
+    model
+  ]);
+  return /* @__PURE__ */ React2.createElement(Gameboard.Root, {
+    model,
+    onDrop: handleDrop
+  }, children);
+});
+var Content = ({ classNames, children }) => {
+  return /* @__PURE__ */ React2.createElement(Gameboard.Content, {
+    grow: true,
+    contain: true,
+    classNames
+  }, children);
+};
+var BOARD_NAME = "Chessboard.Board";
+var Board = (props) => {
+  const registry = useContext(RegistryContext);
+  const { model } = useGameboardContext2(BOARD_NAME);
+  const ref = useRef2(null);
+  useEffect2(() => {
+    if (!ref.current) {
+      return;
+    }
+    ref.current.setAttribute("data-arrow-keys", "all");
+    return addEventListener(ref.current, "keydown", (ev) => {
+      const moveIndex = registry.get(model.moveIndex);
+      switch (ev.key) {
+        case "ArrowUp":
+          model.setMoveIndex(0);
+          break;
+        case "ArrowDown":
+          model.setMoveIndex(model.game.history().length);
+          break;
+        case "ArrowLeft":
+          if (moveIndex > 0) {
+            model.setMoveIndex(moveIndex - 1);
+          }
+          break;
+        case "ArrowRight":
+          if (moveIndex < model.game.history().length) {
+            model.setMoveIndex(moveIndex + 1);
+          }
+          break;
+      }
+    });
+  }, [
+    registry,
+    model
+  ]);
+  return /* @__PURE__ */ React2.createElement(NaturalChessboard, {
+    ...props,
+    ref
+  });
+};
+Board.displayName = BOARD_NAME;
+var Chessboard = {
+  Root,
+  Content,
+  Board,
+  Info
+};
+
+// src/meta.ts
+import { trim } from "@dxos/util";
+var meta2 = {
+  id: "org.dxos.plugin.chess",
+  name: "Chess",
+  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",
+  screenshots: [
+    "https://dxos.network/plugin-details-chess-dark.png"
+  ]
+};
 
 // src/ChessPlugin.tsx
-var ChessPlugin = () => definePlugin(meta, [
-  defineModule({
-    id: `${meta.id}/module/translations`,
-    activatesOn: Events.SetupTranslations,
-    activate: () => contributes(Capabilities.Translations, translations)
-  }),
-  defineModule({
-    id: `${meta.id}/module/metadata`,
-    activatesOn: Events.SetupMetadata,
-    activate: () => contributes(Capabilities.Metadata, {
-      id: ChessType.typename,
-      metadata: {
-        icon: "ph--shield-chevron--regular"
-      }
-    })
-  }),
-  defineModule({
-    id: `${meta.id}/module/object-form`,
-    activatesOn: ClientEvents.SetupSchema,
-    activate: () => contributes(SpaceCapabilities.ObjectForm, defineObjectForm({
-      objectSchema: ChessType,
-      getIntent: () => createIntent(ChessAction.Create)
-    }))
-  }),
-  defineModule({
-    id: `${meta.id}/module/react-surface`,
-    activatesOn: Events.SetupReactSurface,
-    activate: ReactSurface
-  }),
-  defineModule({
-    id: `${meta.id}/module/intent-resolver`,
-    activatesOn: Events.SetupIntentResolver,
-    activate: IntentResolver
-  }),
-  defineModule({
-    id: `${meta.id}/module/artifact-definition`,
-    activatesOn: Events.SetupArtifactDefinition,
-    activate: ArtifactDefinition
-  })
-]);
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Plugin } from "@dxos/app-framework";
+import { AppPlugin } from "@dxos/app-toolkit";
+import { Operation } from "@dxos/compute";
+import { Annotation } from "@dxos/echo";
+import { SpaceOperation } from "@dxos/plugin-space/operations";
+import { ChessBlueprint } from "#blueprints";
+import { BlueprintDefinition, OperationHandler, ReactSurface } from "#capabilities";
+import { meta as meta3 } from "#meta";
+import { translations } from "#translations";
+import { Chess } from "#types";
+var ChessPlugin = Plugin.define(meta3).pipe(AppPlugin.addBlueprintDefinitionModule({
+  activate: BlueprintDefinition
+}), AppPlugin.addOperationHandlerModule({
+  activate: OperationHandler
+}), AppPlugin.addMetadataModule({
+  metadata: {
+    id: Chess.Game.typename,
+    metadata: {
+      icon: Annotation.IconAnnotation.get(Chess.Game).pipe(Option.getOrThrow).icon,
+      iconHue: Annotation.IconAnnotation.get(Chess.Game).pipe(Option.getOrThrow).hue ?? "white",
+      blueprints: [
+        ChessBlueprint.key
+      ],
+      createObject: (props, options) => Effect.gen(function* () {
+        const object = Chess.make(props);
+        return yield* Operation.invoke(SpaceOperation.AddObject, {
+          object,
+          target: options.target,
+          hidden: true,
+          targetNodeId: options.targetNodeId
+        });
+      })
+    }
+  }
+}), AppPlugin.addSchemaModule({
+  schema: [
+    Chess.Game
+  ]
+}), AppPlugin.addSurfaceModule({
+  activate: ReactSurface
+}), AppPlugin.addTranslationsModule({
+  translations
+}), Plugin.make);
 export {
-  ArtifactDefinition,
-  CHESS_PLUGIN,
-  ChessComponent,
-  ChessContainer,
   ChessPlugin,
-  IntentResolver,
-  ReactSurface,
-  meta
+  Chessboard,
+  meta2 as meta
 };
 //# sourceMappingURL=index.mjs.map