@dxos/plugin-chess 0.9.1-staging.ee54ba693a → 0.11.0

package/src/operations/rebuild-position-index.test.ts

@@ -0,0 +1,118 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import { describe, expect, test } from 'vitest';
+
+import { AssistantTestLayer } from '@dxos/agent-runtime/testing';
+import { Operation } from '@dxos/compute';
+import { Database, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { EntityId } from '@dxos/keys';
+import { Game } from '@dxos/plugin-game/types';
+
+import * as positionIndexInternal from '../internal/position-index';
+import { Chess, ChessOperation, ChessPositionIndex, PlayerReview } from '../types';
+import { ChessOperationHandlerSet } from './index';
+
+EntityId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: ChessOperationHandlerSet,
+  types: [Chess.State, Game.Game, PlayerReview.Review, ChessPositionIndex.PositionIndex],
+  disableLlmMemoization: true,
+});
+
+describe('position-index', () => {
+  test('normalizes FEN to the first four fields', () => {
+    expect(positionIndexInternal.normalizeFen('rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1')).toBe(
+      'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3',
+    );
+  });
+
+  test('collects white-to-move positions from PGN', () => {
+    const fens = positionIndexInternal.positionsForSide({
+      pgn: '1. e4 e5 2. Nf3',
+      side: 'white',
+    });
+    expect(fens.length).toBeGreaterThan(1);
+    expect(fens[0]).toBe(
+      positionIndexInternal.normalizeFen('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'),
+    );
+  });
+
+  test('indexes only the first 10 full moves', () => {
+    const tenMoves =
+      '1. e4 e5 2. Nf3 Nc6 3. Bb5 a6 4. Ba4 Nf6 5. O-O Be7 6. Re1 b5 7. Bb3 d6 8. c3 O-O 9. h3 Na5 10. Bc2 c5 *';
+    const longer = `${tenMoves.slice(0, -2)} 11. d4 cxd4 12. cxd4 *`;
+
+    const limited = positionIndexInternal.positionsForSide({ pgn: longer, side: 'white' });
+    const baseline = positionIndexInternal.positionsForSide({ pgn: tenMoves, side: 'white' });
+
+    expect(limited).toEqual(baseline);
+  });
+});
+
+describe('RebuildPositionIndex', () => {
+  it.effect(
+    'indexes games for the reviewed player',
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const review = yield* Database.add(PlayerReview.makeReview({ playerName: 'alice' }));
+        const variant = Chess.make({ pgn: '1. e4 e5 2. Nf3 Nc6 *' });
+        const game = Game.make({
+          name: 'alice vs bob',
+          players: [
+            { role: 'white', name: 'alice' },
+            { role: 'black', name: 'bob' },
+          ],
+          variant,
+        });
+        yield* Database.add(variant);
+        yield* Database.add(game);
+        yield* Database.flush();
+
+        const result = yield* Operation.invoke(ChessOperation.RebuildPositionIndex, { review: Ref.make(review) });
+        expect(result.gamesScanned).toBe(1);
+        expect(result.positionsUpdated).toBeGreaterThan(0);
+
+        const index = yield* Database.load(review.positionIndex);
+        const whiteKeys = Object.keys(index.index.white);
+        expect(whiteKeys.length).toBeGreaterThan(0);
+        const startKey = positionIndexInternal.normalizeFen('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
+        expect(index.index.white[startKey]?.games).toHaveLength(1);
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.effect(
+    'updates only changed FEN leaves on rebuild',
+    Effect.fnUntraced(
+      function* ({ expect }) {
+        const review = yield* Database.add(PlayerReview.makeReview({ playerName: 'alice' }));
+        const variant = Chess.make({ pgn: '1. e4 e5 *' });
+        const game = Game.make({
+          players: [
+            { role: 'white', name: 'alice' },
+            { role: 'black', name: 'bob' },
+          ],
+          variant,
+        });
+        yield* Database.add(variant);
+        yield* Database.add(game);
+        yield* Database.flush();
+
+        const first = yield* Operation.invoke(ChessOperation.RebuildPositionIndex, { review: Ref.make(review) });
+        const second = yield* Operation.invoke(ChessOperation.RebuildPositionIndex, { review: Ref.make(review) });
+        expect(first.positionsUpdated).toBeGreaterThan(0);
+        expect(second.positionsUpdated).toBe(0);
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/operations/rebuild-position-index.ts

@@ -0,0 +1,73 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Operation } from '@dxos/compute';
+import { Database, Filter, Ref } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Game, GameVariantMismatchError, loadGame } from '@dxos/plugin-game/types';
+
+import * as positionIndexInternal from '../internal/position-index';
+import { Chess, ChessOperation, ChessPositionIndex } from '../types';
+
+export default ChessOperation.RebuildPositionIndex.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ review: reviewRef }) {
+      const review = yield* Database.load(reviewRef);
+      invariant(
+        review.playerIdentity || review.playerName,
+        'Player review requires playerIdentity or playerName to match games.',
+      );
+
+      const positionIndex = yield* Database.load(review.positionIndex);
+      const games = yield* Database.query(Filter.type(Game.Game)).run;
+
+      const processed: Array<{
+        game: Game.Game;
+        side: ChessPositionIndex.Side;
+        fens: readonly string[];
+      }> = [];
+
+      for (const game of games) {
+        const side = positionIndexInternal.playerSideInGame(review, game);
+        if (!side) {
+          continue;
+        }
+
+        // Skip games whose variant is not chess, but let database/ref failures abort the rebuild
+        // rather than silently producing a partial index.
+        const loaded = yield* loadGame(Ref.make(game), Chess.State).pipe(
+          Effect.asSome,
+          Effect.catchIf(
+            (error) => error instanceof GameVariantMismatchError,
+            () => Effect.succeedNone,
+          ),
+        );
+        if (Option.isNone(loaded)) {
+          continue;
+        }
+
+        const { variant } = loaded.value;
+        processed.push({
+          game,
+          side,
+          fens: positionIndexInternal.positionsForSide({
+            pgn: variant.pgn,
+            fen: variant.fen,
+            side,
+          }),
+        });
+      }
+
+      const nextIndex = positionIndexInternal.buildIndex(processed);
+      const positionsUpdated = positionIndexInternal.applyIndexDiff(positionIndex, nextIndex);
+      yield* Database.flush();
+
+      return { gamesScanned: processed.length, positionsUpdated };
+    }),
+  ),
+  Operation.opaqueHandler,
+);

package/src/translations.ts

@@ -6,7 +6,7 @@ import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
 
 import { meta } from '#meta';
-import { Chess } from '#types';
+import { Chess, ChessPositionIndex, PlayerReview } from '#types';
 
 export const translations = [
   {
@@ -21,10 +21,28 @@ export const translations = [
         'rename-object.label': 'Rename chess game',
         'delete-object.label': 'Delete chess game',
       },
+      [Type.getTypename(PlayerReview.Review)]: {
+        'typename.label': 'Player review',
+        'typename.label_zero': 'Player reviews',
+        'typename.label_one': 'Player review',
+        'typename.label_other': 'Player reviews',
+        'object-name.placeholder': 'Player review',
+        'add-object.label': 'Add player review',
+        'rename-object.label': 'Rename player review',
+        'delete-object.label': 'Delete player review',
+      },
+      [Type.getTypename(ChessPositionIndex.PositionIndex)]: {
+        'typename.label': 'Position index',
+        'typename.label_zero': 'Position indexes',
+        'typename.label_one': 'Position index',
+        'typename.label_other': 'Position indexes',
+      },
       [meta.profile.key]: {
         'plugin.name': 'Chess',
         'new-game.button': 'New game',
         'delete-game.label': 'Delete',
+        'rebuild-position-index.button': 'Rebuild index',
+        'rebuild-position-index-error.title': 'Failed to rebuild position index',
         'game.checkmate.label': 'Checkmate',
         'game.stalemate.label': 'Stalemate',
         'game.draw.label': 'Draw',

package/src/types/ChessOperation.ts

@@ -7,10 +7,11 @@
 import * as Schema from 'effect/Schema';
 
 import { Operation } from '@dxos/compute';
-import { Database, DXN } from '@dxos/echo';
-import { GameRef } from '@dxos/plugin-game/types';
+import { Database, DXN, Ref } from '@dxos/echo';
+import { Game } from '@dxos/plugin-game/types';
 
 import * as Chess from './Chess';
+import * as PlayerReview from './PlayerReview';
 
 export const Move = Operation.make({
   meta: {
@@ -20,7 +21,7 @@ export const Move = Operation.make({
     icon: 'ph--play--regular',
   },
   input: Schema.Struct({
-    game: GameRef(Chess.State).annotations({
+    game: Game.GameRef(Chess.State).annotations({
       description: 'The ID of the game object (variant must be Chess).',
     }),
     move: Schema.String.annotations({
@@ -44,7 +45,7 @@ export const Play = Operation.make({
     icon: 'ph--play--regular',
   },
   input: Schema.Struct({
-    game: GameRef(Chess.State).annotations({
+    game: Game.GameRef(Chess.State).annotations({
       description: 'The ID of the game object (variant must be Chess).',
     }),
     side: Schema.optional(Schema.Literal('white', 'black', 'any')).annotations({
@@ -86,3 +87,23 @@ export const Print = Operation.make({
     ascii: Schema.String,
   }),
 });
+
+/** Rebuilds a player review position index from all chess games in the space. */
+export const RebuildPositionIndex = Operation.make({
+  meta: {
+    key: DXN.make('org.dxos.plugin.chess.operation.rebuildPositionIndex'),
+    name: 'Rebuild Position Index',
+    description: 'Scans chess games and updates the player review position index.',
+    icon: 'ph--arrows-clockwise--regular',
+  },
+  services: [Database.Service],
+  input: Schema.Struct({
+    review: Ref.Ref(PlayerReview.Review).annotations({
+      description: 'Player review whose position index should be rebuilt.',
+    }),
+  }),
+  output: Schema.Struct({
+    gamesScanned: Schema.Number,
+    positionsUpdated: Schema.Number,
+  }),
+}).pipe(Operation.visible);

package/src/types/ChessPositionIndex.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { Annotation, DXN, Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation } from '@dxos/echo/Annotation';
+import { Game } from '@dxos/plugin-game/types';
+
+/** Side the reviewed player may play in indexed games. */
+export const Side = Schema.Literal('white', 'black');
+export type Side = Schema.Schema.Type<typeof Side>;
+
+/** Games that reached a normalized FEN while the reviewed player was on this side. */
+export const PositionEntry = Schema.Struct({
+  games: Schema.mutable(Schema.Array(Ref.Ref(Game.Game))).pipe(FormInputAnnotation.set(false)),
+});
+
+export type PositionEntry = Schema.Schema.Type<typeof PositionEntry>;
+
+/** FEN-keyed lookup of {@link PositionEntry} for one side. */
+export const SideIndex = Schema.Record({ key: Schema.String, value: PositionEntry });
+
+export type SideIndex = Schema.Schema.Type<typeof SideIndex>;
+
+/** Per-side position reach counts for a player review. */
+export const Index = Schema.Struct({
+  white: SideIndex,
+  black: SideIndex,
+});
+
+export type Index = Schema.Schema.Type<typeof Index>;
+
+/**
+ * Aggregated chess positions reached by a player across indexed games.
+ * Stored as a child of {@link PlayerReview}.
+ */
+export class PositionIndex extends Type.makeObject<PositionIndex>(
+  DXN.make('org.dxos.type.chess.positionIndex', '0.1.0'),
+)(
+  Schema.Struct({
+    index: Index.pipe(FormInputAnnotation.set(false)),
+  }).pipe(Annotation.IconAnnotation.set({ icon: 'ph--map-trifold--regular', hue: 'amber' })),
+) {}
+
+/** Creates an empty position index. */
+export const make = (): PositionIndex =>
+  Obj.make(PositionIndex, {
+    index: { white: {}, black: {} },
+  });

package/src/types/PlayerReview.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { Annotation, DXN, Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation, LabelAnnotation } from '@dxos/echo/Annotation';
+
+import * as ChessPositionIndex from './ChessPositionIndex';
+
+/**
+ * Personal chess opening/position review for a single player.
+ * Indexes all reachable positions (by side) across games in the space.
+ */
+export class Review extends Type.makeObject<Review>(DXN.make('org.dxos.type.chess.playerReview', '0.1.0'))(
+  Schema.Struct({
+    name: Schema.optional(Schema.String),
+    /** DID of the reviewed player; matched against {@link org.dxos.type.game} players. */
+    playerIdentity: Schema.String.pipe(FormInputAnnotation.set(false), Schema.optional),
+    /** Display name fallback when identity is absent (e.g. Chess.com username). */
+    playerName: Schema.String.pipe(Schema.optional),
+    positionIndex: Ref.Ref(ChessPositionIndex.PositionIndex).pipe(FormInputAnnotation.set(false)),
+  }).pipe(
+    LabelAnnotation.set(['name']),
+    Annotation.IconAnnotation.set({ icon: 'ph--chart-polar--regular', hue: 'amber' }),
+  ),
+) {}
+
+export type MakeReviewProps = {
+  name?: string;
+  playerIdentity?: string;
+  playerName?: string;
+};
+
+/** Creates a player review with an empty child position index. */
+export const makeReview = (props: MakeReviewProps = {}): Review => {
+  const positionIndex = ChessPositionIndex.make();
+  const review = Obj.make(Review, {
+    ...props,
+    name: props.name ?? props.playerName ?? 'Player review',
+    positionIndex: Ref.make(positionIndex),
+  });
+  Obj.setParent(positionIndex, review);
+  return review;
+};

package/src/types/index.ts

@@ -4,3 +4,5 @@
 
 export * as Chess from './Chess';
 export * as ChessOperation from './ChessOperation';
+export * as ChessPositionIndex from './ChessPositionIndex';
+export * as PlayerReview from './PlayerReview';

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

@@ -1,89 +0,0 @@
-import "./chunk-J5LGTIGS.mjs";
-
-// src/containers/ChessArticle/ChessArticle.tsx
-import { Chess as ChessJS } from "chess.js";
-import React, { useCallback, useRef, useState } from "react";
-import { AppSurface } from "@dxos/app-toolkit/ui";
-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.profile.key);
-  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 === AppSurface.Article.role && "p-4", role === AppSurface.Section.role && "aspect-square", role === AppSurface.Section.role && 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-MPRT54KQ.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "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 { AppSurface } from '@dxos/app-toolkit/ui';\nimport { Obj } from '@dxos/echo';\nimport { type GameVariantSurfaceProps } from '@dxos/plugin-game/types';\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.profile.key);\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 === AppSurface.Article.role && 'p-4',\n              role === AppSurface.Section.role && 'aspect-square',\n              role === AppSurface.Section.role && 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": "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",
-  "names": ["Chess", "ChessJS", "React", "useCallback", "useRef", "useState", "AppSurface", "Obj", "Panel", "Toolbar", "useTranslation", "mx", "Chessboard", "meta", "ChessArticle", "role", "variant", "t", "profile", "key", "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", "Article", "Section", "Board", "Info", "min", "max", "onOrientationChange", "onClose", "onSelect"]
-}

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

@@ -1,24 +0,0 @@
-import "./chunk-J5LGTIGS.mjs";
-
-// src/containers/ChessCard/ChessCard.tsx
-import React from "react";
-import { Obj } from "@dxos/echo";
-import { Card } from "@dxos/react-ui";
-import { Chessboard } from "#components";
-import { Chess } from "#types";
-var ChessCard = ({ variant }) => {
-  if (!Obj.instanceOf(Chess.State, variant)) {
-    return null;
-  }
-  return /* @__PURE__ */ React.createElement(Card.Body, null, /* @__PURE__ */ React.createElement(Card.Section, {
-    classNames: "aspect-square"
-  }, /* @__PURE__ */ React.createElement(Card.Row, {
-    fullWidth: true
-  }, /* @__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-VJ3I6MIB.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "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/types';\nimport { Card } from '@dxos/react-ui';\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    <Card.Body>\n      <Card.Section classNames='aspect-square'>\n        <Card.Row fullWidth>\n          <Chessboard.Root state={variant}>\n            <Chessboard.Content>\n              <Chessboard.Board />\n            </Chessboard.Content>\n          </Chessboard.Root>\n        </Card.Row>\n      </Card.Section>\n    </Card.Body>\n  );\n};\n"],
-  "mappings": ";;;AAIA,OAAOA,WAAW;AAElB,SAASC,WAAW;AAEpB,SAASC,YAAY;AAErB,SAASC,kBAAkB;AAC3B,SAASC,aAAa;AAIf,IAAMC,YAAY,CAAC,EAAEC,QAAO,MAAkB;AACnD,MAAI,CAACL,IAAIM,WAAWH,MAAMI,OAAOF,OAAAA,GAAU;AACzC,WAAO;EACT;AAEA,SACE,sBAAA,cAACJ,KAAKO,MAAI,MACR,sBAAA,cAACP,KAAKQ,SAAO;IAACC,YAAW;KACvB,sBAAA,cAACT,KAAKU,KAAG;IAACC,WAAAA;KACR,sBAAA,cAACV,WAAWW,MAAI;IAACC,OAAOT;KACtB,sBAAA,cAACH,WAAWa,SAAO,MACjB,sBAAA,cAACb,WAAWc,OAAK,IAAA,CAAA,CAAA,CAAA,CAAA,CAAA;AAO/B;",
-  "names": ["React", "Obj", "Card", "Chessboard", "Chess", "ChessCard", "variant", "instanceOf", "State", "Body", "Section", "classNames", "Row", "fullWidth", "Root", "state", "Content", "Board"]
-}

package/dist/lib/neutral/ChessPlugin.mjs

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

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

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

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

@@ -1,23 +0,0 @@
-import "./chunk-J5LGTIGS.mjs";
-
-// src/ChessPlugin.node.ts
-import { Plugin } from "@dxos/app-framework";
-import { AppPlugin } from "@dxos/app-toolkit";
-import { OperationHandler, SkillDefinition } from "#capabilities";
-import { meta } from "#meta";
-import { Chess } from "#types";
-var ChessPlugin = Plugin.define(meta).pipe(AppPlugin.addSchemaModule({
-  schema: [
-    Chess.State
-  ]
-}), AppPlugin.addSkillDefinitionModule({
-  activate: SkillDefinition
-}), 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

@@ -1,7 +0,0 @@
-{
-  "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 { OperationHandler, SkillDefinition } 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.addSkillDefinitionModule({ activate: SkillDefinition }),\n  AppPlugin.addOperationHandlerModule({ activate: OperationHandler }),\n  Plugin.make,\n);\n\nexport default ChessPlugin;\n"],
-  "mappings": ";;;AAIA,SAASA,cAAc;AACvB,SAASC,iBAAiB;AAE1B,SAASC,kBAAkBC,uBAAuB;AAClD,SAASC,YAAY;AACrB,SAASC,aAAa;AAMf,IAAMC,cAAcN,OAAOO,OAAOH,IAAAA,EAAMI,KAC7CP,UAAUQ,gBAAgB;EAAEC,QAAQ;IAACL,MAAMM;;AAAO,CAAA,GAClDV,UAAUW,yBAAyB;EAAEC,UAAUV;AAAgB,CAAA,GAC/DF,UAAUa,0BAA0B;EAAED,UAAUX;AAAiB,CAAA,GACjEF,OAAOe,IAAI;AAGb,IAAA,2BAAeT;",
-  "names": ["Plugin", "AppPlugin", "OperationHandler", "SkillDefinition", "meta", "Chess", "ChessPlugin", "define", "pipe", "addSchemaModule", "schema", "State", "addSkillDefinitionModule", "activate", "addOperationHandlerModule", "make"]
-}

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

@@ -1,21 +0,0 @@
-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

@@ -1,7 +0,0 @@
-{
-  "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/capabilities/index.mjs

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

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../../src/capabilities/index.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { Capability } from '@dxos/app-framework';\nimport type { OperationHandlerSet } from '@dxos/compute';\n\nexport const SkillDefinition = Capability.lazy('SkillDefinition', () => import('./skill-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;AAGpB,IAAMC,kBAAkBD,WAAWE,KAAK,mBAAmB,MAAM,OAAO,kCAAA,CAAA;AACxE,IAAMC,cAAcH,WAAWE,KAAK,eAAe,MAAM,OAAO,8BAAA,CAAA;AAChE,IAAME,mBAAmBJ,WAAWE,KACzC,oBACA,MAAM,OAAO,mCAAA,CAAA;",
-  "names": ["Capability", "SkillDefinition", "lazy", "GameVariant", "OperationHandler"]
-}