@adobe/data 0.9.82 → 0.9.84

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

@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+import { schema } from "./schema.js";
+
+export type MoveRejectReason = Schema.ToType<typeof schema>;
+export * as MoveRejectReason from "./public.js";

package/references/data-lit-tictactoe/src/features/main/data/move-reject-reason/public.ts

@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { schema } from "./schema.js";

package/references/data-lit-tictactoe/src/features/main/data/move-reject-reason/schema.ts

@@ -0,0 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+
+export const schema = {
+  type: "string",
+  enum: ["index_out_of_bounds", "game_not_active", "cell_occupied", "game_over"],
+} as const satisfies Schema;

package/references/data-lit-tictactoe/src/features/main/data/placed-mark/placed-mark.ts

@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+import { schema } from "./schema.js";
+
+export type PlacedMark = Schema.ToType<typeof schema>;
+export * as PlacedMark from "./public.js";

package/references/data-lit-tictactoe/src/features/main/data/placed-mark/public.ts

@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { schema } from "./schema.js";

package/references/data-lit-tictactoe/src/features/main/data/placed-mark/schema.ts

@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+import { PlayerMark } from "../player-mark/player-mark.js";
+import { CellIndex } from "../cell-index/cell-index.js";
+
+// One mark placed on the board: which mark, and which cell it occupies. This is
+// the shape of a PlacedMark entity's row — the archetype is checked against it
+// (see ecs/archetypes).
+export const schema = Schema.fromObjectProperties(
+  { mark: PlayerMark.schema, index: CellIndex.schema },
+  ["mark", "index"],
+);

package/references/data-lit-tictactoe/src/{types → features/main/data}/play-move-args/can-play-move.ts

@@ -1,14 +1,18 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import { BoardState } from "../board-state/board-state";
-import type { MoveRejectReason } from "../move-reject-reason";
+import { BoardState } from "../board-state/board-state.js";
+import { BoardCell } from "../board-cell/board-cell.js";
+import type { MoveRejectReason } from "../move-reject-reason/move-reject-reason.js";
 
-export type CanPlayMoveArgs = {
+// Declared, not exported (one public export per file — `canPlayMove`). A
+// consumer needing these infers them from the function:
+// `Parameters<typeof canPlayMove>[0]` / `ReturnType<typeof canPlayMove>`.
+type CanPlayMoveArgs = {
   readonly board: BoardState;
   readonly index: number;
 };
 
-export type CanPlayMoveResult =
+type CanPlayMoveResult =
   | { readonly ok: true }
   | { readonly ok: false; readonly reason: MoveRejectReason };
 
@@ -25,7 +29,7 @@ export const canPlayMove = ({
     return { ok: false, reason: "game_over" };
   }
 
-  if (board[index] !== " ") {
+  if (board[index] !== BoardCell.blank) {
     return { ok: false, reason: "cell_occupied" };
   }
 

package/references/data-lit-tictactoe/src/{types → features/main/data}/play-move-args/play-move-args.ts

@@ -1,4 +1,4 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 export type PlayMoveArgs = { readonly index: number };
-export * as PlayMoveArgs from "./public";
+export * as PlayMoveArgs from "./public.js";

package/references/data-lit-tictactoe/src/features/main/data/play-move-args/public.ts

@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+export { canPlayMove } from "./can-play-move.js";

package/references/data-lit-tictactoe/src/{types → features/main/data}/player-mark/is.ts

@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { PlayerMark } from "./player-mark";
-import { schema } from "./schema";
+import type { PlayerMark } from "./player-mark.js";
+import { schema } from "./schema.js";
 
 const set: ReadonlySet<unknown> = new Set(schema.enum);
 

package/references/data-lit-tictactoe/src/{types → features/main/data}/player-mark/mark-color.ts

@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { PlayerMark } from "./player-mark";
+import type { PlayerMark } from "./player-mark.js";
 
 /**
  * Visual identity colour for each mark. Used by HUDs, badges, and overlays

package/references/data-lit-tictactoe/src/{types → features/main/data}/player-mark/opponent.ts

@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { PlayerMark } from "./player-mark";
+import type { PlayerMark } from "./player-mark.js";
 
 /**
  * Maps each `PlayerMark` to its opponent. Use anywhere code needs to

package/references/data-lit-tictactoe/src/{types → features/main/data}/player-mark/player-mark.ts

@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 import { Schema } from "@adobe/data/schema";
-import { schema } from "./schema";
+import { schema } from "./schema.js";
 
 export type PlayerMark = Schema.ToType<typeof schema>;
-export * as PlayerMark from "./public";
+export * as PlayerMark from "./public.js";

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

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

package/references/data-lit-tictactoe/src/{types → features/main/data}/player-mark/schema.ts

@@ -1,9 +1,9 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-
 import { Schema } from "@adobe/data/schema";
 
 export const schema = {
   type: "string",
   enum: ["X", "O"],
   description: "Player mark",
+  default: "X",
 } as const satisfies Schema;

package/references/data-lit-tictactoe/src/{types → features/main/data}/player-mark/values.ts

@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { PlayerMark } from "./player-mark";
-import { schema } from "./schema";
+import type { PlayerMark } from "./player-mark.js";
+import { schema } from "./schema.js";
 
 export const values: readonly PlayerMark[] = schema.enum;

package/references/data-lit-tictactoe/src/features/main/data/score/public.ts

@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { schema } from "./schema.js";

package/references/data-lit-tictactoe/src/features/main/data/score/schema.ts

@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+
+// A non-negative scoreboard tally (wins, draws). Starts at zero.
+export const schema = {
+  type: "number",
+  minimum: 0,
+  default: 0,
+} as const satisfies Schema;

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

@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+import { schema } from "./schema.js";
+
+export type Score = Schema.ToType<typeof schema>;
+export * as Score from "./public.js";

package/references/data-lit-tictactoe/src/features/main/data/state/conformance-case.ts

@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { State } from "./state.js";
+
+// One spec-owned conformance case: a `data/` transform's `{ before, args, after }`
+// authored as full `State`. Lives in `<transform>.cases.ts` and is shared,
+// unchanged, by the data transform test and the ecs conformance runner
+// (see `ecs/conformance/`).
+export type ConformanceCase<Args> = {
+  readonly name: string;
+  readonly before: State;
+  readonly args: Args;
+  readonly after: State;
+};

package/references/data-lit-tictactoe/src/features/main/data/state/expect-state-matches.ts

@@ -0,0 +1,36 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { expect } from "vitest";
+import { equalsUnordered } from "@adobe/data";
+import type { State } from "./state.js";
+
+// Spec-owned tolerant `State` equality, shared by the data/ transform tests and
+// the ecs conformance runner. Two orthogonal concerns, kept separate:
+//
+//   precision — normalise every number on both sides onto a shared grid, so a
+//     value that differs only by F32↔f64 storage rounding compares equal.
+//     `Math.fround` collapses the F32 rounding; rounding to 1e-2 collapses any
+//     residual epsilon. `+ 0` normalises `-0` to `0`. (Tic-tac-toe's scalars are
+//     integer counters and the board is a string, so this is a no-op here — kept
+//     to mirror the shared pattern and stay robust if a float field is added.)
+//   ordering — `equalsUnordered` compares arrays as MULTISETS (archetype
+//     hole-fills make row order nondeterministic) and is object key-order
+//     independent.
+const quantize = (n: number): number => Math.round(Math.fround(n) * 100) / 100 + 0;
+
+const normalize = (value: unknown): unknown => {
+  if (typeof value === "number") return quantize(value);
+  if (Array.isArray(value)) return value.map(normalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, v]) => [key, normalize(v)]));
+  }
+  return value;
+};
+
+export const expectStateMatches = (actual: State, expected: State): void => {
+  const a = normalize(actual);
+  const b = normalize(expected);
+  expect(
+    equalsUnordered(a, b),
+    `State mismatch:\n  actual   ${JSON.stringify(a)}\n  expected ${JSON.stringify(b)}`,
+  ).toBe(true);
+};

package/references/data-lit-tictactoe/src/features/main/data/state/play-move.cases.ts

@@ -0,0 +1,47 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { PlayMoveArgs } from "../play-move-args/play-move-args.js";
+import type { ConformanceCase } from "./conformance-case.js";
+
+// Spec-owned `{ before, args, after }` cases for `State.playMove`, shared with
+// the ecs `playMove` transaction. Covers every branch of the move guard —
+// a legal placement, turn alternation by move count, a winning placement, plus
+// the three rejections (occupied cell, out of bounds, game already over) that
+// each leave the state unchanged.
+export const cases: readonly ConformanceCase<PlayMoveArgs>[] = [
+  {
+    name: "places the first player's mark into an empty cell",
+    before: { board: "         ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+    args: { index: 4 },
+    after: { board: "    X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+  },
+  {
+    name: "alternates to the opponent by move count",
+    before: { board: "    X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+    args: { index: 0 },
+    after: { board: "O   X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+  },
+  {
+    name: "completes a three-in-a-row (winning placement is still just a placement)",
+    before: { board: "XX  OO   ", firstPlayer: "X", xWins: 1, oWins: 2, draws: 0 },
+    args: { index: 2 },
+    after: { board: "XXX OO   ", firstPlayer: "X", xWins: 1, oWins: 2, draws: 0 },
+  },
+  {
+    name: "ignores an occupied cell (no-op)",
+    before: { board: "    X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+    args: { index: 4 },
+    after: { board: "    X    ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+  },
+  {
+    name: "ignores an out-of-bounds index (no-op)",
+    before: { board: "         ", firstPlayer: "O", xWins: 0, oWins: 0, draws: 0 },
+    args: { index: 9 },
+    after: { board: "         ", firstPlayer: "O", xWins: 0, oWins: 0, draws: 0 },
+  },
+  {
+    name: "ignores a move once the game is already won (no-op)",
+    before: { board: "XXX      ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+    args: { index: 4 },
+    after: { board: "XXX      ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+  },
+];

package/references/data-lit-tictactoe/src/features/main/data/state/play-move.test.ts

@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it } from "vitest";
+import { State } from "./state.js";
+import { cases } from "./play-move.cases.js";
+import { expectStateMatches } from "./expect-state-matches.js";
+
+describe("State.playMove", () => {
+  for (const { name, before, args, after } of cases) {
+    it(name, () => {
+      expectStateMatches(State.playMove(before, args), after);
+    });
+  }
+});

package/references/data-lit-tictactoe/src/features/main/data/state/play-move.ts

@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { BoardState } from "../board-state/board-state.js";
+import { PlayMoveArgs } from "../play-move-args/play-move-args.js";
+import type { State } from "./state.js";
+
+// Place the current player's mark into `index`. Illegal moves (out of bounds,
+// occupied, game over) are ignored, keeping the transform idempotent.
+export const playMove = <T extends Pick<State, "board" | "firstPlayer">>(
+  state: T,
+  input: PlayMoveArgs,
+): T => {
+  if (!PlayMoveArgs.canPlayMove({ board: state.board, index: input.index }).ok) {
+    return state;
+  }
+  const mark = BoardState.currentPlayer(state.board, state.firstPlayer);
+  return {
+    ...state,
+    board: BoardState.setBoardCell({ board: state.board, index: input.index, mark }),
+  };
+};

package/references/data-lit-tictactoe/src/features/main/data/state/public.ts

@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { playMove } from "./play-move.js";
+export { restartGame } from "./restart-game.js";

package/references/data-lit-tictactoe/src/features/main/data/state/restart-game.cases.ts

@@ -0,0 +1,34 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { ConformanceCase } from "./conformance-case.js";
+
+// Spec-owned `{ before, args, after }` cases for `State.restartGame` (no args),
+// shared with the ecs `restartGame` transaction. Every restart clears the board
+// and hands the first move to the other player; the scoreboard is bumped only
+// for the finished game's outcome — X win, O win, draw (cat), or, when the game
+// wasn't finished, no counter at all.
+export const cases: readonly ConformanceCase<undefined>[] = [
+  {
+    name: "tallies an X win, alternates first player, clears the board",
+    before: { board: "XXX      ", firstPlayer: "X", xWins: 0, oWins: 0, draws: 0 },
+    args: undefined,
+    after: { board: "         ", firstPlayer: "O", xWins: 1, oWins: 0, draws: 0 },
+  },
+  {
+    name: "tallies an O win",
+    before: { board: "OOOXX    ", firstPlayer: "O", xWins: 1, oWins: 2, draws: 0 },
+    args: undefined,
+    after: { board: "         ", firstPlayer: "X", xWins: 1, oWins: 3, draws: 0 },
+  },
+  {
+    name: "tallies a draw (full board, no line)",
+    before: { board: "XOXXOOOXX", firstPlayer: "O", xWins: 2, oWins: 1, draws: 0 },
+    args: undefined,
+    after: { board: "         ", firstPlayer: "X", xWins: 2, oWins: 1, draws: 1 },
+  },
+  {
+    name: "restarts an unfinished game without touching any counter",
+    before: { board: "X O      ", firstPlayer: "X", xWins: 1, oWins: 1, draws: 1 },
+    args: undefined,
+    after: { board: "         ", firstPlayer: "O", xWins: 1, oWins: 1, draws: 1 },
+  },
+];

package/references/data-lit-tictactoe/src/features/main/data/state/restart-game.test.ts

@@ -0,0 +1,13 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it } from "vitest";
+import { State } from "./state.js";
+import { cases } from "./restart-game.cases.js";
+import { expectStateMatches } from "./expect-state-matches.js";
+
+describe("State.restartGame", () => {
+  for (const { name, before, after } of cases) {
+    it(name, () => {
+      expectStateMatches(State.restartGame(before), after);
+    });
+  }
+});

package/references/data-lit-tictactoe/src/features/main/data/state/restart-game.ts

@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { BoardState } from "../board-state/board-state.js";
+import { PlayerMark } from "../player-mark/player-mark.js";
+import type { State } from "./state.js";
+
+// Tally the finished game into the scoreboard, hand the first move to the other
+// player, and clear the board.
+export const restartGame = (state: State): State => {
+  const winner = BoardState.getWinner(state.board);
+  const status = BoardState.deriveStatus(state.board);
+  return {
+    board: BoardState.createInitialBoard(),
+    firstPlayer: PlayerMark.opponent[state.firstPlayer],
+    xWins: state.xWins + (winner === "X" ? 1 : 0),
+    oWins: state.oWins + (winner === "O" ? 1 : 0),
+    draws: state.draws + (status === "draw" ? 1 : 0),
+  };
+};

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

@@ -0,0 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { BoardState } from "../board-state/board-state.js";
+import type { PlayerMark } from "../player-mark/player-mark.js";
+import type { Score } from "../score/score.js";
+
+// The full persistent game state as one immutable object — the specification
+// the ECS implementation is verified against.
+export type State = {
+  readonly board: BoardState;
+  readonly firstPlayer: PlayerMark;
+  readonly xWins: Score;
+  readonly oWins: Score;
+  readonly draws: Score;
+};
+export * as State from "./public.js";

package/references/data-lit-tictactoe/src/features/main/data/winning-line/lines.ts

@@ -0,0 +1,14 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { WinningLine } from "./winning-line.js";
+
+// The eight lines (rows, columns, diagonals) that win a game, as board indices.
+export 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],
+];

package/references/data-lit-tictactoe/src/features/main/data/winning-line/public.ts

@@ -0,0 +1,2 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { lines } from "./lines.js";

package/references/data-lit-tictactoe/src/{types → features/main/data/winning-line}/winning-line.ts

@@ -1,3 +1,4 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
 export type WinningLine = readonly [number, number, number];
+export * as WinningLine from "./public.js";

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/board.ts

@@ -0,0 +1,22 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { cached } from "@adobe/data/cache";
+import { Observe } from "@adobe/data/observe";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import type { PlacedMark } from "../../../data/placed-mark/placed-mark.js";
+import type { IndexDatabase } from "../../index-database/index-database.js";
+
+// The board snapshot, derived reactively from the placed-mark entities. The
+// derive re-emits whenever a transaction adds or removes a mark. `withCache`
+// shares one run across all subscribers (each cell element observes the board).
+export const board = cached((db: IndexDatabase) =>
+  Observe.withCache(db.derive((read) => {
+    const marks: PlacedMark[] = [];
+    for (const id of read.select(db.archetypes.PlacedMark.components)) {
+      const m = read.read(id);
+      if (m && m.mark !== undefined && m.index !== undefined) {
+        marks.push({ mark: m.mark, index: m.index });
+      }
+    }
+    return BoardState.fromMarks(marks);
+  })),
+);

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/current-player.ts

@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { cached } from "@adobe/data/cache";
+import { Observe } from "@adobe/data/observe";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import type { IndexDatabase } from "../../index-database/index-database.js";
+import { board } from "./board.js";
+
+export const currentPlayer = cached((db: IndexDatabase) =>
+  Observe.withFilter(board(db), (snapshot) =>
+    BoardState.currentPlayer(snapshot, db.resources.firstPlayer),
+  ),
+);

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/index.ts

@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * from "./state.js";
+export * from "./board.js";
+export * from "./current-player.js";
+export * from "./move-count.js";
+export * from "./status.js";
+export * from "./winning-line.js";
+export * from "./winner.js";
+export * from "./is-game-over.js";

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/is-game-over.ts

@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { cached } from "@adobe/data/cache";
+import { Observe } from "@adobe/data/observe";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import type { IndexDatabase } from "../../index-database/index-database.js";
+import { board } from "./board.js";
+
+export const isGameOver = cached((db: IndexDatabase) =>
+  Observe.withFilter(board(db), BoardState.isGameOver),
+);

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/move-count.ts

@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { cached } from "@adobe/data/cache";
+import { Observe } from "@adobe/data/observe";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import type { IndexDatabase } from "../../index-database/index-database.js";
+import { board } from "./board.js";
+
+export const moveCount = cached((db: IndexDatabase) =>
+  Observe.withFilter(board(db), BoardState.getMoveCount),
+);

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/state.ts

@@ -0,0 +1,29 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { cached } from "@adobe/data/cache";
+import { Observe } from "@adobe/data/observe";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import type { PlacedMark } from "../../../data/placed-mark/placed-mark.js";
+import type { State } from "../../../data/state/state.js";
+import type { IndexDatabase } from "../../index-database/index-database.js";
+
+// The full logical `State` projected from the ECS — the conformance anchor
+// between the data-layer spec and this implementation. Mark entities are folded
+// back into the board string; scalars come straight from resources.
+export const state = cached((db: IndexDatabase) =>
+  Observe.withCache(db.derive((read): State => {
+    const marks: PlacedMark[] = [];
+    for (const id of read.select(db.archetypes.PlacedMark.components)) {
+      const m = read.read(id);
+      if (m && m.mark !== undefined && m.index !== undefined) {
+        marks.push({ mark: m.mark, index: m.index });
+      }
+    }
+    return {
+      board: BoardState.fromMarks(marks),
+      firstPlayer: read.resources.firstPlayer,
+      xWins: read.resources.xWins,
+      oWins: read.resources.oWins,
+      draws: read.resources.draws,
+    };
+  })),
+);

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/status.ts

@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { cached } from "@adobe/data/cache";
+import { Observe } from "@adobe/data/observe";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import type { IndexDatabase } from "../../index-database/index-database.js";
+import { board } from "./board.js";
+
+export const status = cached((db: IndexDatabase) =>
+  Observe.withFilter(board(db), BoardState.deriveStatus),
+);

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/winner.ts

@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { cached } from "@adobe/data/cache";
+import { Observe } from "@adobe/data/observe";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import type { IndexDatabase } from "../../index-database/index-database.js";
+import { board } from "./board.js";
+
+export const winner = cached((db: IndexDatabase) =>
+  Observe.withFilter(board(db), BoardState.getWinner),
+);

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed/winning-line.ts

@@ -0,0 +1,10 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { cached } from "@adobe/data/cache";
+import { Observe } from "@adobe/data/observe";
+import { BoardState } from "../../../data/board-state/board-state.js";
+import type { IndexDatabase } from "../../index-database/index-database.js";
+import { board } from "./board.js";
+
+export const winningLine = cached((db: IndexDatabase) =>
+  Observe.withFilter(board(db), BoardState.getWinningLine),
+);

package/references/data-lit-tictactoe/src/features/main/ecs/computed-database/computed-database.ts

@@ -0,0 +1,18 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { TransactionDatabase } from "../transaction-database/transaction-database.js";
+import * as computed from "./computed/index.js";
+
+const computedDatabasePlugin = Database.Plugin.create({
+  extends: TransactionDatabase.plugin,
+  computed,
+});
+
+export type ComputedDatabase = Database.Plugin.ToDatabase<
+  typeof computedDatabasePlugin
+>;
+
+export namespace ComputedDatabase {
+  export const plugin = computedDatabasePlugin;
+  export type Store = Database.Plugin.ToStore<typeof computedDatabasePlugin>;
+}

package/references/data-lit-tictactoe/src/features/main/ecs/conformance/create-store.ts

@@ -0,0 +1,12 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Store } from "@adobe/data/ecs";
+import type { CoreDatabase } from "../core-database/core-database.js";
+import { IndexDatabase } from "../index-database/index-database.js";
+
+// A fresh writable store carrying the feature's whole schema. `IndexDatabase` is
+// the lowest layer that declares it all (components / resources / archetypes +
+// indexes) — the behaviour layers above add none — and `Store.create` reads a
+// plugin's schema facets directly. Typed as `CoreDatabase.Store`: the surface the
+// projection (`fromState` / `toState`) and the raw transaction functions use.
+// Test-only.
+export const createStore = (): CoreDatabase.Store => Store.create(IndexDatabase.plugin);