@adobe/data 0.9.82 → 0.9.84

package/references/data-lit-tictactoe/src/{elements → features/main/ui}/tictactoe-cell/tictactoe-cell-element.ts

@@ -2,9 +2,9 @@
 
 import { customElement, property } from "lit/decorators.js";
 import { useObservableValues } from "@adobe/data-lit";
-import { BoardState } from "../../types/board-state/board-state.js";
-import { TictactoeElement } from "../../tictactoe-element.js";
+import { TictactoeElement } from "../tictactoe-element.js";
 import { styles } from "./tictactoe-cell.css.js";
+import { observeCell } from "./observe-cell.js";
 import * as presentation from "./tictactoe-cell-presentation.js";
 
 const tagName = "tictactoe-cell";
@@ -24,19 +24,15 @@ export class TictactoeCellElement extends TictactoeElement {
 
     render() {
         const values = useObservableValues(
-            () => ({ board: this.service.observe.resources.board }),
-            [],
+            () => ({ view: observeCell(this.service, this.index) }),
+            [this.index],
         );
-
-        const board = values?.board ?? "         ";
-        const cell = BoardState.getCell(board, this.index);
-        const isWinning = BoardState.isCellWinning(board, this.index);
-        const isPlayable = BoardState.isCellPlayable(board, this.index);
+        const view = values?.view;
 
         return presentation.render({
-            cell,
-            isWinning,
-            isPlayable,
+            cell: view?.cell ?? " ",
+            isWinning: view?.isWinning ?? false,
+            isPlayable: view?.isPlayable ?? false,
             playMove: () => {
                 this.service.transactions.playMove({ index: this.index });
             },

package/references/data-lit-tictactoe/src/features/main/ui/tictactoe-cell/tictactoe-cell-presentation.test.ts

@@ -0,0 +1,41 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { Template } from "@adobe/data-lit";
+import { render } from "./tictactoe-cell-presentation.js";
+
+const props = (over: Partial<Parameters<typeof render>[0]> = {}) => ({
+  cell: " ",
+  isWinning: false,
+  isPlayable: false,
+  playMove: () => {},
+  ...over,
+});
+
+describe("tictactoe-cell-presentation", () => {
+  it("shows the mark of an occupied cell", () => {
+    const t = Template.from(render(props({ cell: "X" })));
+    expect(t.has("cell")).toBe(true);
+    expect(t.text).toContain("X");
+  });
+
+  it("flags winning and playable cells via class", () => {
+    const t = Template.from(render(props({ isWinning: true, isPlayable: true })));
+    expect(t.has("winning")).toBe(true);
+    expect(t.has("playable")).toBe(true);
+  });
+
+  it("invokes playMove when a playable cell is clicked", () => {
+    let calls = 0;
+    const t = Template.from(render(props({ isPlayable: true, playMove: () => { calls++; } })));
+    const onClick = t.values.find((v): v is () => void => typeof v === "function");
+    onClick?.();
+    expect(calls).toBe(1);
+  });
+
+  it("ignores clicks on a non-playable cell", () => {
+    let calls = 0;
+    const t = Template.from(render(props({ isPlayable: false, playMove: () => { calls++; } })));
+    t.values.find((v): v is () => void => typeof v === "function")?.();
+    expect(calls).toBe(0);
+  });
+});

package/references/data-lit-tictactoe/src/{elements → features/main/ui}/tictactoe-cell/tictactoe-cell-presentation.ts

@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { html } from "lit";
-import { PlayerMark } from "../../types/player-mark/player-mark.js";
+import { PlayerMark } from "../../data/player-mark/player-mark.js";
 
 export function render(args: {
   cell: string;

package/references/data-lit-tictactoe/src/features/main/ui/tictactoe-element.ts

@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import { DatabaseElement } from "@adobe/data-lit";
+import { ComputedDatabase } from "../ecs/computed-database/computed-database.js";
+
+/**
+ * Base class for all Tic-Tac-Toe elements. Deliberately typed on the minimal
+ * base-game surface (`ComputedDatabase`), NOT the assembled `FeatureDatabase`,
+ * so any database that *extends* the base game can be injected as `.service` —
+ * the standalone agent-extended app and the p2p presence build both do this.
+ * (This is the sanctioned exception to "type consumers on `FeatureDatabase`":
+ * an element meant to be extended types on the layer it actually consumes.)
+ */
+export class TictactoeElement extends DatabaseElement<
+  typeof ComputedDatabase.plugin
+> {
+  get plugin() {
+    return ComputedDatabase.plugin;
+  }
+}

package/references/data-lit-tictactoe/src/{elements → features/main/ui}/tictactoe-hud/tictactoe-hud-element.ts

@@ -2,9 +2,8 @@
 
 import { customElement } from "lit/decorators.js";
 import { useObservableValues } from "@adobe/data-lit";
-import { BoardState } from "../../types/board-state/board-state.js";
-import { PlayerMark } from "../../types/player-mark/player-mark.js";
-import { TictactoeElement } from "../../tictactoe-element.js";
+import { PlayerMark } from "../../data/player-mark/player-mark.js";
+import { TictactoeElement } from "../tictactoe-element.js";
 import { styles } from "./tictactoe-hud.css.js";
 import * as presentation from "./tictactoe-hud-presentation.js";
 
@@ -23,8 +22,9 @@ export class TictactoeHudElement extends TictactoeElement {
     render() {
         const values = useObservableValues(
             () => ({
-                board: this.service.observe.resources.board,
-                firstPlayer: this.service.observe.resources.firstPlayer,
+                status: this.service.computed.status,
+                winner: this.service.computed.winner,
+                currentPlayer: this.service.computed.currentPlayer,
                 xWins: this.service.observe.resources.xWins,
                 oWins: this.service.observe.resources.oWins,
                 draws: this.service.observe.resources.draws,
@@ -32,22 +32,10 @@ export class TictactoeHudElement extends TictactoeElement {
             [],
         );
 
-        const board = values?.board ?? "         ";
-        const firstPlayer = values?.firstPlayer ?? PlayerMark.values[0];
-
-        const currentPlayer = BoardState.currentPlayer(board, firstPlayer);
-        const status = BoardState.deriveStatus(board);
-        const winner = BoardState.getWinner(board);
-
-        const statusText =
-            status === "won" && winner !== null
-                ? `${winner} wins!`
-                : status === "draw"
-                    ? "Draw!"
-                    : `${currentPlayer}'s turn`;
-
         return presentation.render({
-            statusText,
+            status: values?.status ?? "idle",
+            winner: values?.winner ?? null,
+            currentPlayer: values?.currentPlayer ?? PlayerMark.values[0],
             xWins: values?.xWins ?? 0,
             oWins: values?.oWins ?? 0,
             draws: values?.draws ?? 0,

package/references/data-lit-tictactoe/src/features/main/ui/tictactoe-hud/tictactoe-hud-presentation.test.ts

@@ -0,0 +1,45 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { Template } from "@adobe/data-lit";
+import { render } from "./tictactoe-hud-presentation.js";
+
+const props = (over: Partial<Parameters<typeof render>[0]> = {}) => ({
+  status: "in_progress" as const,
+  winner: null,
+  currentPlayer: "X" as const,
+  xWins: 0,
+  oWins: 0,
+  draws: 0,
+  restartGame: () => {},
+  ...over,
+});
+
+describe("tictactoe-hud-presentation", () => {
+  it("shows whose turn it is while in progress", () => {
+    const t = Template.from(render(props({ currentPlayer: "O" })));
+    expect(t.text).toContain("O's turn");
+  });
+
+  it("announces the winner", () => {
+    const t = Template.from(render(props({ status: "won", winner: "X" })));
+    expect(t.text).toContain("X wins!");
+  });
+
+  it("announces a draw", () => {
+    const t = Template.from(render(props({ status: "draw" })));
+    expect(t.text).toContain("Draw!");
+  });
+
+  it("renders the score tallies", () => {
+    const t = Template.from(render(props({ xWins: 2, oWins: 3, draws: 4 })));
+    expect(t.text).toContain("2");
+    expect(t.text).toContain("3");
+    expect(t.text).toContain("4");
+  });
+
+  it("wires the restart button to restartGame", () => {
+    const restartGame = () => {};
+    const t = Template.from(render(props({ restartGame })));
+    expect(t.values).toContain(restartGame);
+  });
+});

package/references/data-lit-tictactoe/src/{elements → features/main/ui}/tictactoe-hud/tictactoe-hud-presentation.ts

@@ -1,15 +1,25 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { html } from "lit";
+import type { GameStatus } from "../../data/game-status/game-status.js";
+import type { PlayerMark } from "../../data/player-mark/player-mark.js";
 
 export function render(args: {
-  statusText: string;
+  status: GameStatus;
+  winner: PlayerMark | "cat" | null;
+  currentPlayer: PlayerMark;
   xWins: number;
   oWins: number;
   draws: number;
   restartGame: () => void;
 }) {
-  const { statusText, xWins, oWins, draws, restartGame } = args;
+  const { status, winner, currentPlayer, xWins, oWins, draws, restartGame } = args;
+  const statusText =
+    status === "won" && winner !== null
+      ? `${winner} wins!`
+      : status === "draw"
+        ? "Draw!"
+        : `${currentPlayer}'s turn`;
   return html`
     <div class="hud">
       <div class="score">

package/references/data-lit-tictactoe/src/index.ts

@@ -3,14 +3,20 @@
 // Library entry point for data-lit-tictactoe.
 // Consumers (e.g. data-p2p-tictactoe) import from this barrel.
 
-export { tictactoePlugin } from "./state/tictactoe-plugin.js";
-export type { TictactoeDatabase } from "./state/tictactoe-plugin.js";
+// The assembled feature database: the base game extended with AI agent
+// services. Feature-qualified per the cross-feature naming rule so a peer or
+// downstream package never collides with another feature's database. Carries
+// `.plugin` / `.Store` for consumers that build their own database.
+export { FeatureDatabase as TictactoeDatabase } from "./features/main/ecs/feature-database.js";
 
-export { agentPlugin } from "./state/agent-plugin.js";
+// The base game database — all game logic (resources, transactions, computed),
+// no AI. Combine its `.plugin` with P2P-specific plugins, or reach for
+// `TictactoeDatabase` to get the agent-extended assembly.
+export { ComputedDatabase as TictactoeGameDatabase } from "./features/main/ecs/computed-database/computed-database.js";
 
-export { Tictactoe } from "./elements/tictactoe-app/tictactoe-app.js";
-export { TictactoeElement } from "./tictactoe-element.js";
+export { Tictactoe } from "./features/main/ui/tictactoe-app/tictactoe-app.js";
+export { TictactoeElement } from "./features/main/ui/tictactoe-element.js";
 
-export { BoardState } from "./types/board-state/board-state.js";
-export { PlayerMark } from "./types/player-mark/player-mark.js";
-export { PlayMoveArgs } from "./types/play-move-args/play-move-args.js";
+export { BoardState } from "./features/main/data/board-state/board-state.js";
+export { PlayerMark } from "./features/main/data/player-mark/player-mark.js";
+export { PlayMoveArgs } from "./features/main/data/play-move-args/play-move-args.js";

package/references/data-lit-tictactoe/src/main.ts

@@ -2,14 +2,14 @@
 
 import { render } from "lit";
 import { Database } from "@adobe/data/ecs";
-import { Tictactoe } from "./elements/tictactoe-app/tictactoe-app.js";
-import { agentPlugin } from "./state/agent-plugin.js";
+import { Tictactoe } from "./features/main/ui/tictactoe-app/tictactoe-app.js";
+import { FeatureDatabase } from "./features/main/ecs/feature-database.js";
 
 const app = document.getElementById("app");
 if (app) {
-    // The agent plugin extends tictactoePlugin with AI services. Built once
-    // here and passed to the lazy wrapper so the upgraded element receives
-    // the agent-extended database.
-    const service = Database.create(agentPlugin);
+    // The assembled feature database extends the base game with AI services.
+    // Built once here and passed to the lazy wrapper so the upgraded element
+    // receives the agent-extended database.
+    const service = Database.create(FeatureDatabase.plugin);
     render(Tictactoe({ service }), app);
 }

package/references/data-react/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-react",
-  "version": "0.9.82",
+  "version": "0.9.84",
   "description": "Adobe data React bindings — hooks and context for ECS database",
   "type": "module",
   "private": false,
@@ -13,7 +13,8 @@
     "dev": "tsc -b -w",
     "link": "pnpm build && pnpm link --global",
     "test": "vitest --run --passWithNoTests",
-    "publish-public": "pnpm build && pnpm publish --no-git-checks --access public"
+    "publish-public": "pnpm build && pnpm publish --no-git-checks --access public",
+    "typecheck": "tsc -b"
   },
   "dependencies": {
     "@adobe/data": "workspace:*"

package/references/data-react-hello/package.json

@@ -1,12 +1,13 @@
 {
   "name": "data-react-hello",
-  "version": "0.9.82",
+  "version": "0.9.84",
   "description": "Hello World sample - click counter using @adobe/data-react",
   "type": "module",
   "private": true,
   "scripts": {
     "build": "vite build",
     "dev": "vite",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
     "publish-public": "true"
   },
   "dependencies": {

package/references/data-react-pixie/package.json

@@ -1,12 +1,13 @@
 {
   "name": "data-react-pixie",
-  "version": "0.9.82",
+  "version": "0.9.84",
   "description": "PixiJS React sample - ECS sprites (bunny, fox) with @adobe/data-react",
   "type": "module",
   "private": true,
   "scripts": {
     "build": "vite build",
     "dev": "vite",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
     "publish-public": "true"
   },
   "dependencies": {

package/references/data-lit-tictactoe/src/elements/tictactoe-app/tictactoe-app.ts

@@ -1,18 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { html, type TemplateResult } from "lit";
-import type { Database } from "@adobe/data/ecs";
-import type { tictactoePlugin } from "../../state/tictactoe-plugin.js";
-
-type TictactoeService = Database.Plugin.ToDatabase<typeof tictactoePlugin>;
-
-/**
- * Generic over `S` so callers may pass a database built from any plugin
- * that extends `tictactoePlugin` (for example one that adds AI agents
- * or peer presence). The element class itself is typed on the minimal
- * `tictactoePlugin` surface and ignores the extra capabilities.
- */
-export const Tictactoe = <S extends TictactoeService>(args: { service: S }): TemplateResult => {
-    void import("./tictactoe-app-element.js");
-    return html`<tictactoe-app .database=${args.service}></tictactoe-app>`;
-};

package/references/data-lit-tictactoe/src/state/tictactoe-plugin.ts

@@ -1,64 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { Database } from "@adobe/data/ecs";
-import { Observe } from "@adobe/data/observe";
-import { BoardState } from "../types/board-state/board-state";
-import { PlayerMark } from "../types/player-mark/player-mark";
-import { PlayMoveArgs } from "../types/play-move-args/play-move-args";
-
-export const tictactoePlugin = Database.Plugin.create({
-  resources: {
-    board: { default: BoardState.createInitialBoard() },
-    firstPlayer: { default: PlayerMark.values[0] },
-    xWins: { default: 0 as number },
-    oWins: { default: 0 as number },
-    draws: { default: 0 as number },
-  },
-  computed: {
-    currentPlayer: (db) =>
-      Observe.withFilter(db.observe.resources.board, (board) =>
-        BoardState.currentPlayer(board, db.resources.firstPlayer),
-      ),
-    moveCount: (db) =>
-      Observe.withFilter(db.observe.resources.board, BoardState.getMoveCount),
-    status: (db) =>
-      Observe.withFilter(db.observe.resources.board, BoardState.deriveStatus),
-    winningLine: (db) =>
-      Observe.withFilter(db.observe.resources.board, BoardState.getWinningLine),
-    winner: (db) =>
-      Observe.withFilter(db.observe.resources.board, BoardState.getWinner),
-    isGameOver: (db) =>
-      Observe.withFilter(db.observe.resources.board, BoardState.isGameOver),
-  },
-  transactions: {
-    restartGame: (t) => {
-      const winner = BoardState.getWinner(t.resources.board);
-      const status = BoardState.deriveStatus(t.resources.board);
-      if (winner === "X") t.resources.xWins = t.resources.xWins + 1;
-      else if (winner === "O") t.resources.oWins = t.resources.oWins + 1;
-      else if (status === "draw") t.resources.draws = t.resources.draws + 1;
-      t.resources.firstPlayer = PlayerMark.opponent[t.resources.firstPlayer];
-      t.resources.board = BoardState.createInitialBoard();
-    },
-    playMove: (t, { index }: PlayMoveArgs) => {
-      const mark = BoardState.currentPlayer(
-        t.resources.board,
-        t.resources.firstPlayer,
-      );
-      // When userId is set (sync/P2P mode) a peer may only play their own mark.
-      if (t.userId !== undefined && t.userId !== mark) return;
-      const validation = PlayMoveArgs.canPlayMove({
-        board: t.resources.board,
-        index,
-      });
-      if (!validation.ok) return;
-      t.resources.board = BoardState.setBoardCell({
-        board: t.resources.board,
-        index,
-        mark,
-      });
-    },
-  },
-});
-
-export type TictactoeDatabase = Database.FromPlugin<typeof tictactoePlugin>;

package/references/data-lit-tictactoe/src/tictactoe-element.ts

@@ -1,15 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import { DatabaseElement } from "@adobe/data-lit";
-import { tictactoePlugin } from "./state/tictactoe-plugin.js";
-
-/**
- * Base class for all Tic-Tac-Toe elements. Typed on the minimal
- * `tictactoePlugin` surface so that any database extending that plugin (e.g.
- * one that adds AI agents or presence) can be injected as `.service`.
- */
-export class TictactoeElement extends DatabaseElement<typeof tictactoePlugin> {
-  get plugin() {
-    return tictactoePlugin;
-  }
-}

package/references/data-lit-tictactoe/src/types/board-cell.ts

@@ -1,5 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import type { PlayerMark } from "./player-mark/player-mark";
-
-export type BoardCell = PlayerMark | " ";

package/references/data-lit-tictactoe/src/types/board-state/get-cell.ts

@@ -1,7 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import type { BoardState } from "./board-state";
-import type { BoardCell } from "../board-cell";
-
-export const getCell = (board: BoardState, index: number): BoardCell =>
-  (board[index] as BoardCell) ?? " ";

package/references/data-lit-tictactoe/src/types/board-state/get-winning-line.ts

@@ -1,25 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import type { BoardState } from "./board-state";
-import type { WinningLine } from "../winning-line";
-
-const LINES: readonly WinningLine[] = [
-  [0, 1, 2],
-  [3, 4, 5],
-  [6, 7, 8],
-  [0, 3, 6],
-  [1, 4, 7],
-  [2, 5, 8],
-  [0, 4, 8],
-  [2, 4, 6],
-];
-
-export const getWinningLine = (board: BoardState): WinningLine | null => {
-  for (const [a, b, c] of LINES) {
-    const mark = board[a];
-    if (mark !== " " && mark === board[b] && mark === board[c]) {
-      return [a, b, c];
-    }
-  }
-  return null;
-};

package/references/data-lit-tictactoe/src/types/board-state/is-cell-playable.ts

@@ -1,13 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import type { BoardState } from "./board-state";
-import { deriveStatus } from "./derive-status";
-import { getCell } from "./get-cell";
-
-export const isCellPlayable = (board: BoardState, index: number): boolean => {
-  const status = deriveStatus(board);
-  const cell = getCell(board, index);
-  return (
-    (status === "in_progress" || status === "idle") && cell === " "
-  );
-};

package/references/data-lit-tictactoe/src/types/board-state/is-cell-winning.ts

@@ -1,9 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-import type { BoardState } from "./board-state";
-import { getWinningLine } from "./get-winning-line";
-
-export const isCellWinning = (board: BoardState, index: number): boolean => {
-  const line = getWinningLine(board);
-  return line !== null && line.includes(index);
-};

package/references/data-lit-tictactoe/src/types/board-state/public.ts

@@ -1,15 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export { schema } from "./schema";
-export { createInitialBoard } from "./create-initial-board";
-export { currentPlayer } from "./current-player";
-export { deriveStatus } from "./derive-status";
-export { getCell } from "./get-cell";
-export { getWinningLine } from "./get-winning-line";
-export { isCellPlayable } from "./is-cell-playable";
-export { isCellWinning } from "./is-cell-winning";
-export { getWinner } from "./get-winner";
-export { getMoveCount } from "./get-move-count";
-export { isBoardFull } from "./is-board-full";
-export { isGameOver } from "./is-game-over";
-export { setBoardCell } from "./set-board-cell";

package/references/data-lit-tictactoe/src/types/game-status.ts

@@ -1,3 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export type GameStatus = "idle" | "in_progress" | "won" | "draw";

package/references/data-lit-tictactoe/src/types/move-reject-reason.ts

@@ -1,7 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export type MoveRejectReason =
-  | "index_out_of_bounds"
-  | "game_not_active"
-  | "cell_occupied"
-  | "game_over";

package/references/data-lit-tictactoe/src/types/player-mark/public.ts

@@ -1,7 +0,0 @@
-// © 2026 Adobe. MIT License. See /LICENSE for details.
-
-export { schema } from "./schema";
-export { is } from "./is";
-export { values } from "./values";
-export { markColor } from "./mark-color";
-export { opponent } from "./opponent";