@adobe/data 0.9.82 → 0.9.84

package/dist/types/async-args-provider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A provider of deferred or streamed arguments. Calling it yields the real
+ * argument value either once (a `Promise`) or repeatedly over time (an
+ * `AsyncGenerator`).
+ *
+ * Two layers reason about this shape:
+ * - Transaction dispatch exposes an overload accepting one, so a single
+ *   logical mutation can be driven by a live source (a drag, a slider, a
+ *   stream) and committed once when the source settles.
+ * - The UIService restriction preserves that calling convention (while
+ *   rewriting the return to `void`) so UI consumers can drive such a
+ *   transaction without ever awaiting it.
+ *
+ * This lives in the shared `types` kernel because both the `ecs` and
+ * `service` layers depend on it, and neither should depend on the other.
+ */
+export type AsyncArgsProvider<T> = () => Promise<T> | AsyncGenerator<T>;

package/dist/types/async-args-provider.js

@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export {};
+//# sourceMappingURL=async-args-provider.js.map

package/dist/types/async-args-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-args-provider.js","sourceRoot":"","sources":["../../src/types/async-args-provider.ts"],"names":[],"mappings":"AAAA,uDAAuD"}

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./types.js";
 export * from "./assert.js";
 export * from "./equal.js";
+export * from "./async-args-provider.js";
 export * from "./typed-array-constructer.js";
 export * from "./typed-array.js";
 export * from "./replace.js";

package/dist/types/index.js

@@ -2,6 +2,7 @@
 export * from "./types.js";
 export * from "./assert.js";
 export * from "./equal.js";
+export * from "./async-args-provider.js";
 export * from "./typed-array-constructer.js";
 export * from "./typed-array.js";
 export * from "./replace.js";

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data",
-  "version": "0.9.82",
+  "version": "0.9.84",
   "description": "Adobe data oriented programming library",
   "type": "module",
   "sideEffects": false,

package/references/data-lit/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@adobe/data-lit",
-  "version": "0.9.82",
+  "version": "0.9.84",
   "description": "Adobe data Lit bindings - hooks, elements, decorators",
   "type": "module",
   "private": false,
+  "sideEffects": [
+    "**/application-host.js"
+  ],
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -13,7 +16,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-lit/src/elements/database-element.ts

@@ -8,7 +8,8 @@ import { attachDecorator, withHooks } from '../index.js';
 
 export abstract class DatabaseElement<P extends Database.Plugin> extends LitElement {
 
-  /** Full database, hard-private — invisible to subclasses and external callers. */
+  /** Full database, hard-private. Exposed to subclasses only through the
+   *  restricted {@link service} getter and the {@link database} accessor. */
   #database!: Database.Plugin.ToDatabase<P>;
 
   /**
@@ -27,6 +28,18 @@ export abstract class DatabaseElement<P extends Database.Plugin> extends LitElem
     return UIService.restrict(this.#database);
   }
 
+  /**
+   * The full, unrestricted database — for imperative-rendering subclasses
+   * (a canvas / WebGL draw loop that reads columns synchronously each frame,
+   * where the reactive `observe` surface can't help because systems mutate
+   * columns in place without firing observers). Presentations and external
+   * callers still receive only the restricted {@link service}; this privileged
+   * read path is confined to container element authors via `protected`.
+   */
+  protected get database(): Database.Plugin.ToDatabase<P> {
+    return this.#database;
+  }
+
   constructor() {
     super();
     attachDecorator(this, 'render', withHooks);
@@ -35,6 +48,7 @@ export abstract class DatabaseElement<P extends Database.Plugin> extends LitElem
   abstract get plugin(): P;
 
   connectedCallback(): void {
+    this.#upgradeServiceProperty();
     if (!this.#database) {
       const ancestor = this.findAncestorService();
       this.service = ancestor?.extend(this.plugin) ?? Database.create(this.plugin);
@@ -42,6 +56,27 @@ export abstract class DatabaseElement<P extends Database.Plugin> extends LitElem
     super.connectedCallback();
   }
 
+  /**
+   * A lazy wrapper binds `.service` *before* this element's class is upgraded
+   * (the element module is dynamically imported), so the value lands as an own
+   * data property that shadows the `service` accessor: `set service` never runs
+   * (`#database` stays unset, `database` reads `undefined`) and `get service`
+   * returns the raw injected database instead of the restricted view. Reassign
+   * the shadowed value through the accessor so the setter runs — `#database` is
+   * populated and the UI restriction is actually enforced.
+   */
+  #upgradeServiceProperty(): void {
+    if (!Object.prototype.hasOwnProperty.call(this, "service")) return;
+    // The own property was bound by the wrapper as the full database (DI); the
+    // `service` accessor's declared type hides that, hence the widening view.
+    const self = this as unknown as { service?: Database.Plugin.ToDatabase<P> };
+    const injected = self.service;
+    delete self.service;
+    if (injected !== undefined) {
+      this.service = injected;
+    }
+  }
+
   protected findAncestorService(): Database | void {
     for (const element of iterateSelfAndAncestors(this)) {
       // Read each ancestor's `service`. A DatabaseElement returns its full

package/references/data-lit/src/elements/database-element.type-test.ts

@@ -13,6 +13,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
 import { Database } from "@adobe/data/ecs";
+import type { AsyncArgsProvider } from "@adobe/data/ecs";
 import { Observe } from "@adobe/data/observe";
 import { UIService } from "@adobe/data/service";
 import { DatabaseElement } from "./database-element.js";
@@ -25,6 +26,9 @@ const plugin = Database.Plugin.create({
     increment: (t) => {
       t.resources.count = t.resources.count + 1;
     },
+    setCount: (t, input: { readonly value: number }) => {
+      t.resources.count = input.value;
+    },
   },
 });
 
@@ -94,6 +98,22 @@ type _CheckIncrementReturnsVoid = Assert<
   Equal<ReturnType<ServiceType["transactions"]["increment"]>, void>
 >;
 
+// 7. A transaction with input is exposed as an overload pair. The restriction
+//    must preserve the AsyncArgsProvider overload (return rewritten to void) so
+//    a UI element can drive a live, single-commit gesture through its
+//    restricted `service` — this is exactly what `useDragTransaction`
+//    consumes: `(asyncArgs: AsyncArgsProvider<T>) => void`. Regression guard
+//    for the overload-erasure bug in UIService's RestrictProperty.
+type DragConsumer<T> = (asyncArgs: AsyncArgsProvider<T>) => void;
+const _setCountDrivable: DragConsumer<{ readonly value: number }> =
+  null as unknown as ServiceType["transactions"]["setCount"];
+// The plain-args (fire-and-forget) overload also survives, still returning void.
+const _setCountCommit: (arg: { readonly value: number }) => void =
+  null as unknown as ServiceType["transactions"]["setCount"];
+type _CheckSetCountAsyncVoid = Assert<
+  Equal<ReturnType<ServiceType["transactions"]["setCount"]>, void>
+>;
+
 // ----------------------------------------------------------------------------
 // Local helpers (kept inline so this file stays a self-contained type test).
 // ----------------------------------------------------------------------------

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

@@ -3,4 +3,5 @@
 export * from "./hooks/index.js";
 export * from "./elements/index.js";
 export * from "./decorators/index.js";
+export { Template } from "./testing/template/template.js";
 export type { Vec2 } from "@adobe/data/math";

package/references/data-lit/src/testing/template/from.test.ts

@@ -0,0 +1,47 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { html, nothing } from "lit";
+import { Template } from "./template.js";
+
+describe("Template.from", () => {
+  it("collects static markup and interpolated primitives into text", () => {
+    const q = Template.from(html`<sp-toast>${"Saved!"} (${3})</sp-toast>`);
+    expect(q.has("<sp-toast")).toBe(true);
+    expect(q.text).toContain("Saved!");
+    expect(q.text).toContain("(3)");
+  });
+
+  it("exposes leaf binding values for identity checks (callbacks, nothing, booleans)", () => {
+    const onClick = () => {};
+    const q = Template.from(
+      html`<sp-button @click=${onClick} ?disabled=${true}>${nothing}</sp-button>`,
+    );
+    expect(q.values).toContain(onClick);
+    expect(q.values).toContain(true);
+    expect(q.values).toContain(nothing);
+  });
+
+  it("finds interpolated child templates by fragment, recursively", () => {
+    const label = "Undo";
+    const q = Template.from(html`
+      <div>${html`<section>${html`<sp-button>${label}</sp-button>`}</section>`}</div>
+    `);
+    const button = q.find("<sp-button");
+    expect(button).toBeDefined();
+    expect(button?.has("Undo")).toBe(true);
+  });
+
+  it("flattens values from nested templates and arrays", () => {
+    const a = () => {};
+    const b = () => {};
+    const q = Template.from(html`<ul>${[html`<li @x=${a}></li>`, html`<li @x=${b}></li>`]}</ul>`);
+    expect(q.values).toContain(a);
+    expect(q.values).toContain(b);
+    expect(q.children).toHaveLength(2);
+  });
+
+  it("throws when given something that is not a TemplateResult", () => {
+    expect(() => Template.from(nothing)).toThrow(TypeError);
+    expect(() => Template.from(undefined)).toThrow(TypeError);
+  });
+});

package/references/data-lit/src/testing/template/from.ts

@@ -0,0 +1,86 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Query } from "./query.js";
+
+type TemplateLike = { readonly strings: readonly string[]; readonly values: readonly unknown[] };
+
+// Duck-typed, DOM-free check for a Lit TemplateResult (or a nested one).
+const isTemplate = (value: unknown): value is TemplateLike =>
+  typeof value === "object" &&
+  value !== null &&
+  Array.isArray((value as { strings?: unknown }).strings) &&
+  Array.isArray((value as { values?: unknown }).values);
+
+// Static markup + interpolated primitives, concatenated (recursive). Symbols
+// (e.g. `nothing`), null/undefined, booleans and functions contribute no text.
+const collectText = (value: unknown): string => {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "bigint") return String(value);
+  if (Array.isArray(value)) return value.map(collectText).join("");
+  if (isTemplate(value)) {
+    let out = "";
+    for (let i = 0; i < value.strings.length; i++) {
+      out += value.strings[i];
+      if (i < value.values.length) out += collectText(value.values[i]);
+    }
+    return out;
+  }
+  return "";
+};
+
+// Every leaf binding value, flattened; nested templates are recursed into but
+// not themselves pushed (those are exposed as `children`).
+const collectValues = (value: unknown, into: unknown[]): void => {
+  if (isTemplate(value)) {
+    for (const v of value.values) collectValues(v, into);
+  } else if (Array.isArray(value)) {
+    for (const v of value) collectValues(v, into);
+  } else {
+    into.push(value);
+  }
+};
+
+// The interpolated child templates directly inside `result` (flattening arrays,
+// but not descending through other templates — `find` handles depth).
+const collectChildren = (result: TemplateLike): Query[] => {
+  const children: Query[] = [];
+  const visit = (value: unknown): void => {
+    if (isTemplate(value)) children.push(build(value));
+    else if (Array.isArray(value)) value.forEach(visit);
+  };
+  for (const v of result.values) visit(v);
+  return children;
+};
+
+const build = (result: TemplateLike): Query => {
+  const text = collectText(result);
+  const values: unknown[] = [];
+  for (const v of result.values) collectValues(v, values);
+  const children = collectChildren(result);
+  const find = (fragment: string): Query | undefined => {
+    for (const child of children) {
+      if (child.text.includes(fragment)) return child;
+      const deep = child.find(fragment);
+      if (deep) return deep;
+    }
+    return undefined;
+  };
+  return {
+    text,
+    values,
+    children,
+    has: (fragment) => text.includes(fragment),
+    find,
+  };
+};
+
+/**
+ * Wrap a presentation's `render(props)` output in a {@link Query} for DOM-free
+ * assertions. Throws if given something that isn't a `TemplateResult`, so a
+ * presentation that returns `nothing`/`undefined` fails loudly at the call site.
+ */
+export const from = (result: unknown): Query => {
+  if (!isTemplate(result)) {
+    throw new TypeError("Template.from expects a Lit TemplateResult");
+  }
+  return build(result);
+};

package/references/data-lit/src/testing/template/public.ts

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

package/references/data-lit/src/testing/template/query.ts

@@ -0,0 +1,27 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+/**
+ * A DOM-free view over a Lit `TemplateResult`, for asserting on what a pure
+ * `render(props)` presentation *declares* — without mounting anything. Built by
+ * `Template.from`.
+ *
+ * - `text` — all static markup plus interpolated primitives, concatenated
+ *   (recursive). Use for presence: `q.has("<sp-toast")`, `q.text`.
+ * - `values` — every leaf binding value, flattened across nested templates in
+ *   source order (nested templates themselves are excluded — they live in
+ *   `children`). Use identity checks rather than positions:
+ *   `expect(q.values).toContain(onClick)`, `.toContain(nothing)`.
+ * - `children` — the interpolated child templates (`${html`…`}`), each wrapped.
+ * - `has` / `find` — presence sugar and a recursive lookup of the first child
+ *   template whose `text` includes a fragment.
+ *
+ * Note: `find` only sees *interpolated* sub-templates; elements written inline
+ * in a single `html` literal are part of `text`, not `children`.
+ */
+export type Query = {
+  readonly text: string;
+  readonly values: readonly unknown[];
+  readonly children: readonly Query[];
+  has(fragment: string): boolean;
+  find(fragment: string): Query | undefined;
+};

package/references/data-lit/src/testing/template/template.ts

@@ -0,0 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// DOM-free querying of a Lit `TemplateResult` for presentation unit tests.
+// Pure (no side effects) so it tree-shakes out of production bundles.
+export * as Template from "./public.js";

package/references/data-lit-tictactoe/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-lit-tictactoe",
-  "version": "0.9.82",
+  "version": "0.9.84",
   "description": "Tic-Tac-Toe sample - Lit web components with @adobe/data-lit and AgenticService",
   "type": "module",
   "private": true,
@@ -10,6 +10,8 @@
   "scripts": {
     "build": "vite build",
     "dev": "vite",
+    "test": "vitest --run --passWithNoTests",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
     "publish-public": "true"
   },
   "dependencies": {
@@ -18,8 +20,10 @@
     "lit": "^3.3.1"
   },
   "devDependencies": {
+    "jsdom": "^24.1.0",
     "typescript": "^5.8.3",
     "vite": "^5.1.1",
-    "vite-plugin-checker": "^0.12.0"
+    "vite-plugin-checker": "^0.12.0",
+    "vitest": "^1.6.0"
   }
 }

package/references/data-lit-tictactoe/src/features/main/data/board-cell/blank.ts

@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+// The empty cell — a single space, the character used for an unplayed cell in
+// the board string.
+export const blank = " " as const;

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

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

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

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

package/references/data-lit-tictactoe/src/{types → features/main/data}/board-state/board-state.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 BoardState = Schema.ToType<typeof schema>;
-export * as BoardState from "./public";
+export * as BoardState from "./public.js";

package/references/data-lit-tictactoe/src/{types → features/main/data}/board-state/create-initial-board.ts

@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { BoardState } from "./board-state.js";
 
-import type { BoardState } from "./board-state";
-
+// The empty board: nine blank cells.
 export const createInitialBoard = (): BoardState => "         ";

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

@@ -1,7 +1,7 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { BoardState } from "./board-state";
-import { PlayerMark } from "../player-mark/player-mark";
+import type { BoardState } from "./board-state.js";
+import { PlayerMark } from "../player-mark/player-mark.js";
 
 export const currentPlayer = (
   board: BoardState,

package/references/data-lit-tictactoe/src/{types → features/main/data}/board-state/derive-status.ts

@@ -1,9 +1,9 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { BoardState } from "./board-state";
-import type { GameStatus } from "../game-status";
-import { getWinningLine } from "./get-winning-line";
-import { isBoardFull } from "./is-board-full";
+import type { BoardState } from "./board-state.js";
+import type { GameStatus } from "../game-status/game-status.js";
+import { getWinningLine } from "./get-winning-line.js";
+import { isBoardFull } from "./is-board-full.js";
 
 export const deriveStatus = (board: BoardState): GameStatus => {
   if (getWinningLine(board)) return "won";

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

@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { BoardState } from "./board-state.js";
+import type { PlacedMark } from "../placed-mark/placed-mark.js";
+
+// Project the placed marks (the entity source of truth) into the compact
+// index-addressed board snapshot the pure helpers operate on.
+export const fromMarks = (marks: readonly PlacedMark[]): BoardState => {
+  const cells: string[] = new Array(9).fill(" ");
+  for (const { mark, index } of marks) cells[index] = mark;
+  return cells.join("");
+};

package/references/data-lit-tictactoe/src/{types → features/main/data}/board-state/get-move-count.ts

@@ -1,6 +1,6 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { BoardState } from "./board-state";
+import type { BoardState } from "./board-state.js";
 
 export const getMoveCount = (board: BoardState): number =>
   (board.match(/[XO]/g) ?? []).length;

package/references/data-lit-tictactoe/src/{types → features/main/data}/board-state/get-winner.ts

@@ -1,9 +1,9 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { BoardState } from "./board-state";
-import type { PlayerMark } from "../player-mark/player-mark";
-import { getWinningLine } from "./get-winning-line";
-import { isBoardFull } from "./is-board-full";
+import type { BoardState } from "./board-state.js";
+import type { PlayerMark } from "../player-mark/player-mark.js";
+import { getWinningLine } from "./get-winning-line.js";
+import { isBoardFull } from "./is-board-full.js";
 
 export const getWinner = (
   board: BoardState,

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

@@ -0,0 +1,15 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+
+import type { BoardState } from "./board-state.js";
+import { WinningLine } from "../winning-line/winning-line.js";
+import { BoardCell } from "../board-cell/board-cell.js";
+
+export const getWinningLine = (board: BoardState): WinningLine | null => {
+  for (const [a, b, c] of WinningLine.lines) {
+    const mark = board[a];
+    if (mark !== BoardCell.blank && mark === board[b] && mark === board[c]) {
+      return [a, b, c];
+    }
+  }
+  return null;
+};

package/references/data-lit-tictactoe/src/{types → features/main/data}/board-state/is-board-full.ts

@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { BoardState } from "./board-state";
+import type { BoardState } from "./board-state.js";
 
 export const isBoardFull = (board: BoardState): boolean => !board.includes(" ");

package/references/data-lit-tictactoe/src/{types → features/main/data}/board-state/is-game-over.ts

@@ -1,8 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
-import type { BoardState } from "./board-state";
-import { getWinningLine } from "./get-winning-line";
-import { isBoardFull } from "./is-board-full";
+import type { BoardState } from "./board-state.js";
+import { getWinningLine } from "./get-winning-line.js";
+import { isBoardFull } from "./is-board-full.js";
 
 export const isGameOver = (board: BoardState): boolean =>
   getWinningLine(board) !== null || isBoardFull(board);

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

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

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

@@ -1,10 +1,12 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-
 import { Schema } from "@adobe/data/schema";
 
+// The board: 9 cells, top-left to bottom-right, each a space, "X", or "O".
+// The empty board is the natural default.
 export const schema = {
   type: "string",
   description: "Tic-Tac-Toe board top left to bottom right",
+  default: "         ",
   minLength: 9,
   maxLength: 9,
 } as const satisfies Schema;

package/references/data-lit-tictactoe/src/{types → features/main/data}/board-state/set-board-cell.ts

@@ -1,8 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { BoardState } from "./board-state.js";
+import type { PlayerMark } from "../player-mark/player-mark.js";
 
-import type { BoardState } from "./board-state";
-import type { PlayerMark } from "../player-mark/player-mark";
-
+// Return the board with `mark` placed at `index` (pure — the spec's write).
 export const setBoardCell = (args: {
   board: BoardState;
   index: number;

package/references/data-lit-tictactoe/src/features/main/data/cell-index/cell-index.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 CellIndex = Schema.ToType<typeof schema>;
+export * as CellIndex from "./public.js";

package/references/data-lit-tictactoe/src/features/main/data/cell-index/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/cell-index/schema.ts

@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Schema } from "@adobe/data/schema";
+
+// Which of the nine board cells (0 top-left to 8 bottom-right) a mark occupies.
+export const schema = {
+  type: "integer",
+  minimum: 0,
+  maximum: 8,
+} as const satisfies Schema;

package/references/data-lit-tictactoe/src/features/main/data/game-status/game-status.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 GameStatus = Schema.ToType<typeof schema>;
+export * as GameStatus from "./public.js";

package/references/data-lit-tictactoe/src/features/main/data/game-status/is-active.ts

@@ -0,0 +1,6 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { GameStatus } from "./game-status.js";
+
+// Whether the game is still accepting moves.
+export const isActive = (status: GameStatus): boolean =>
+  status === "idle" || status === "in_progress";

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

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

package/references/data-lit-tictactoe/src/features/main/data/game-status/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: ["idle", "in_progress", "won", "draw"],
+} as const satisfies Schema;