@johnmorrisdotca/kumimoji 1.2.1 → 1.3.0

package/dist/check.d.ts

@@ -11,9 +11,34 @@ import type { KumimojiCheck, KumimojiLevel, KumimojiOptions } from "./kumimoji.t
  * Written out here rather than asked of the play page, which is what made the
  * grid; the list must have been loaded (`loadTileWords`), and a check that
  * cannot read it refuses.
+ *
+ * @param size - The supported initial hand size.
+ * @param givens - The original bag of internal tile codes.
+ * @param answer - The encoded completed grid to verify.
+ * @param options - Native game, component or presentation options.
+ * @returns WHETHER A GRID FINISHES A KUMIMOJI: the one check the server also runs. O(squares) and a lookup a word, nothing searched: the grid uses exactly the tiles of the bag, as many of each, it is all one piece, and every run of two or more across or down is in the list — and, for a game set up with Diagonals, every run of three or more along a diagonal. Which tiles were traded on the way does not matter — a finished game holds the whole bag whatever came out of it when — so the answer is the grid alone.
+ * @example
+ * ```ts
+ * import { checkKumimoji } from "@johnmorrisdotca/kumimoji";
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ *
+ * await loadTileWordsFromModule("english");
+ * console.log(checkKumimoji(3,"cat","cat",{level:"hard"}));
+ * ```
  */
 export declare function checkKumimoji(size: number, givens: string, answer: string, options?: KumimojiOptions & {
     level?: KumimojiLevel;
 }): KumimojiCheck;
-/** A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed. */
+/** A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed.
+ *
+ * @param givens - The original bag of internal tile codes.
+ * @param elapsedMs - The elapsed solve time in milliseconds.
+ * @returns A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed.
+ * @example
+ * ```ts
+ * import { kumimojiPoints } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(kumimojiPoints("cat",12000));
+ * ```
+ */
 export declare function kumimojiPoints(givens: string, elapsedMs: number): number;

package/dist/check.js

@@ -14,6 +14,20 @@ import { tileWords } from "./tileWords.js";
  * Written out here rather than asked of the play page, which is what made the
  * grid; the list must have been loaded (`loadTileWords`), and a check that
  * cannot read it refuses.
+ *
+ * @param size - The supported initial hand size.
+ * @param givens - The original bag of internal tile codes.
+ * @param answer - The encoded completed grid to verify.
+ * @param options - Native game, component or presentation options.
+ * @returns WHETHER A GRID FINISHES A KUMIMOJI: the one check the server also runs. O(squares) and a lookup a word, nothing searched: the grid uses exactly the tiles of the bag, as many of each, it is all one piece, and every run of two or more across or down is in the list — and, for a game set up with Diagonals, every run of three or more along a diagonal. Which tiles were traded on the way does not matter — a finished game holds the whole bag whatever came out of it when — so the answer is the grid alone.
+ * @example
+ * ```ts
+ * import { checkKumimoji } from "@johnmorrisdotca/kumimoji";
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ *
+ * await loadTileWordsFromModule("english");
+ * console.log(checkKumimoji(3,"cat","cat",{level:"hard"}));
+ * ```
  */
 export function checkKumimoji(size, givens, answer, options = {}) {
     const gameLength = options.gameLength ?? "short";
@@ -60,7 +74,18 @@ export function checkKumimoji(size, givens, answer, options = {}) {
         return { ok: false, reason: "the grid is not finished" };
     return { ok: true };
 }
-/** A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed. */
+/** A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed.
+ *
+ * @param givens - The original bag of internal tile codes.
+ * @param elapsedMs - The elapsed solve time in milliseconds.
+ * @returns A finished game's leaderboard points (`KUMIMOJI_SCORE`): ten a tile, and up to as much again for speed.
+ * @example
+ * ```ts
+ * import { kumimojiPoints } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(kumimojiPoints("cat",12000));
+ * ```
+ */
 export function kumimojiPoints(givens, elapsedMs) {
     const tiles = givens.length;
     const base = KUMIMOJI_SCORE.tile * tiles;

package/dist/computer.types.d.ts

@@ -1,5 +1,14 @@
 import type { PartyGame } from "./party.types.ts";
-/** What a computer did in one step of its turn, for the line over its table. */
+/** What a computer did in one step of its turn, for the line over its table.
+ *
+ * @example
+ * ```ts
+ * import type { ComputerSaid } from "@johnmorrisdotca/kumimoji";
+ *
+ * const value: ComputerSaid = {kind:"drew"};
+ * console.log(value);
+ * ```
+ */
 export type ComputerSaid = {
     kind: "rebuilt";
 } | {
@@ -16,7 +25,20 @@ export type ComputerSaid = {
 } | {
     kind: "resigned";
 };
-/** One step of a computer's turn: the game after it, and what it did. The last step's game is the one kept. */
+/** One step of a computer's turn: the game after it, and what it did. The last step's game is the one kept.
+ *
+ * @example
+ * ```ts
+ * import { startParty } from "@johnmorrisdotca/kumimoji";
+ * import type { ComputerStep } from "@johnmorrisdotca/kumimoji";
+ *
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * const value: ComputerStep = {game,said:{kind:"drew"}};
+ * console.log(value);
+ * ```
+ */
 export type ComputerStep = {
     game: PartyGame;
     said: ComputerSaid;

package/dist/computerPlay.d.ts

@@ -1,17 +1,60 @@
 import { type GridRules, type GridVerdict, type Tiles } from "./grid.ts";
 import { type TilePlay } from "./play.ts";
 import type { TileWords } from "./tileWords.ts";
-/** Whether a grid is sound, read against the loaded word list by the game's rules: the same judgement the desk shows. */
+/** Whether a grid is sound, read against the loaded word list by the game's rules: the same judgement the desk shows.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @param words - The loaded native language word list and tile mappings.
+ * @param rules - Whether diagonal runs are also judged.
+ * @returns Whether a grid is sound, read against the loaded word list by the game's rules: the same judgement the desk shows.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { judgeTiles } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(judgeTiles(tiles,words));
+ * ```
+ */
 export declare function judgeTiles(tiles: Tiles, words: TileWords, rules?: GridRules): GridVerdict;
 /**
  * THE COMPUTER'S NEXT WORD: its play after laying the best word its hand can
  * lay on its table, and the word, or null when there is none. The grid after
  * it is judged against the list, by the game's rules (`rules`), and is
  * always sound.
+ *
+ * @param play - The current immutable solo-game progress.
+ * @param words - The loaded native language word list and tile mappings.
+ * @param rules - Whether diagonal runs are also judged.
+ * @returns THE COMPUTER'S NEXT WORD: its play after laying the best word its hand can lay on its table, and the word, or null when there is none. The grid after it is judged against the list, by the game's rules (`rules`), and is always sound.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { bestLaying, deal } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const play = deal("catdog",3);
+ * console.log(bestLaying(play,words)?.word);
+ * ```
  */
 export declare function bestLaying(play: TilePlay, words: TileWords, rules?: GridRules): {
     play: TilePlay;
     word: string;
 } | null;
-/** The tile a computer trades: its rarest letter in the set, the first of those in its hand; never a wild. Null for a hand of wilds. */
+/** The tile a computer trades: its rarest letter in the set, the first of those in its hand; never a wild. Null for a hand of wilds.
+ *
+ * @param hand - The hand size or tile codes, as declared by the function signature.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns The tile a computer trades: its rarest letter in the set, the first of those in its hand; never a wild. null for a hand of wilds.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { deal, tradeChoice } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const play = deal("catdog",3);
+ * console.log(tradeChoice(play.hand,words));
+ * ```
+ */
 export declare function tradeChoice(hand: readonly string[], words: TileWords): number | null;

package/dist/computerPlay.js

@@ -28,7 +28,22 @@ function plainOf(tile, words) {
     const sound = words.soundOf(tile);
     return sound === null ? "" : (words.codeOf(sound) ?? "");
 }
-/** Whether a grid is sound, read against the loaded word list by the game's rules: the same judgement the desk shows. */
+/** Whether a grid is sound, read against the loaded word list by the game's rules: the same judgement the desk shows.
+ *
+ * @param tiles - The map from row,column square names to internal tile codes.
+ * @param words - The loaded native language word list and tile mappings.
+ * @param rules - Whether diagonal runs are also judged.
+ * @returns Whether a grid is sound, read against the loaded word list by the game's rules: the same judgement the desk shows.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { judgeTiles } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const tiles = new Map([["0,0","c"],["0,1","a"],["0,2","t"]]);
+ * console.log(judgeTiles(tiles,words));
+ * ```
+ */
 export function judgeTiles(tiles, words, rules = {}) {
     return judgeWithWords(tiles, words, rules);
 }
@@ -173,6 +188,20 @@ const JUDGED_MOST = 12;
  * lay on its table, and the word, or null when there is none. The grid after
  * it is judged against the list, by the game's rules (`rules`), and is
  * always sound.
+ *
+ * @param play - The current immutable solo-game progress.
+ * @param words - The loaded native language word list and tile mappings.
+ * @param rules - Whether diagonal runs are also judged.
+ * @returns THE COMPUTER'S NEXT WORD: its play after laying the best word its hand can lay on its table, and the word, or null when there is none. The grid after it is judged against the list, by the game's rules (`rules`), and is always sound.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { bestLaying, deal } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const play = deal("catdog",3);
+ * console.log(bestLaying(play,words)?.word);
+ * ```
  */
 export function bestLaying(play, words, rules = {}) {
     if (play.hand.length === 0)
@@ -186,7 +215,21 @@ export function bestLaying(play, words, rules = {}) {
     }
     return null;
 }
-/** The tile a computer trades: its rarest letter in the set, the first of those in its hand; never a wild. Null for a hand of wilds. */
+/** The tile a computer trades: its rarest letter in the set, the first of those in its hand; never a wild. Null for a hand of wilds.
+ *
+ * @param hand - The hand size or tile codes, as declared by the function signature.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns The tile a computer trades: its rarest letter in the set, the first of those in its hand; never a wild. null for a hand of wilds.
+ * @example
+ * ```ts
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { deal, tradeChoice } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const play = deal("catdog",3);
+ * console.log(tradeChoice(play.hand,words));
+ * ```
+ */
 export function tradeChoice(hand, words) {
     let chosen = null;
     let fewest = Infinity;

package/dist/computerTurn.d.ts

@@ -24,9 +24,48 @@ import type { TileWords } from "./tileWords.ts";
  * - Resign only where the rules offer it (`mayResign`) and it can do nothing
  *   at all: nothing to lay, nothing to trade for, and it is not its last turn.
  */
-/** The most things a computer does in one turn before pressing Done: at the page's pause, a turn of about three seconds. */
+/** The most things a computer does in one turn before pressing Done: at the page's pause, a turn of about three seconds.
+ *
+ * @example
+ * ```ts
+ * import { COMPUTER_STEPS_MOST } from "@johnmorrisdotca/kumimoji";
+ * console.log(COMPUTER_STEPS_MOST);
+ * ```
+ */
 export declare const COMPUTER_STEPS_MOST = 8;
-/** A computer seat's whole turn as its steps, in order, for a page to show one at a time. None when it is not a computer's turn or the game is over. */
+/** A computer seat's whole turn as its steps, in order, for a page to show one at a time. None when it is not a computer's turn or the game is over.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns A computer seat's whole turn as its steps, in order, for a page to show one at a time. None when it is not a computer's turn or the game is over.
+ * @example
+ * ```ts no-run
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { planComputerTurn, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(planComputerTurn(game,words).map(step=>step.said));
+ * ```
+ */
 export declare function planComputerTurn(game: PartyGame, words: TileWords): ComputerStep[];
-/** The game a computer's turn passes on: its plan's last step, or the game as it was where there is nothing to play. */
+/** The game a computer's turn passes on: its plan's last step, or the game as it was where there is nothing to play.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns The game a computer's turn passes on: its plan's last step, or the game as it was where there is nothing to play.
+ * @example
+ * ```ts no-run
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { afterComputerTurn, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(afterComputerTurn(game,words).turn);
+ * ```
+ */
 export declare function afterComputerTurn(game: PartyGame, words: TileWords): PartyGame;

package/dist/computerTurn.js

@@ -25,11 +25,34 @@ import { liftAll, mayTrade, trade } from "./play.js";
  * - Resign only where the rules offer it (`mayResign`) and it can do nothing
  *   at all: nothing to lay, nothing to trade for, and it is not its last turn.
  */
-/** The most things a computer does in one turn before pressing Done: at the page's pause, a turn of about three seconds. */
+/** The most things a computer does in one turn before pressing Done: at the page's pause, a turn of about three seconds.
+ *
+ * @example
+ * ```ts
+ * import { COMPUTER_STEPS_MOST } from "@johnmorrisdotca/kumimoji";
+ * console.log(COMPUTER_STEPS_MOST);
+ * ```
+ */
 export const COMPUTER_STEPS_MOST = 8;
 /** How many settling steps may be needed at the end to be allowed Done at all; one trade a turn and a hand of tiles, so it is bounded anyway. */
 const SETTLING_MOST = 200;
-/** A computer seat's whole turn as its steps, in order, for a page to show one at a time. None when it is not a computer's turn or the game is over. */
+/** A computer seat's whole turn as its steps, in order, for a page to show one at a time. None when it is not a computer's turn or the game is over.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns A computer seat's whole turn as its steps, in order, for a page to show one at a time. None when it is not a computer's turn or the game is over.
+ * @example
+ * ```ts no-run
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { planComputerTurn, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(planComputerTurn(game,words).map(step=>step.said));
+ * ```
+ */
 export function planComputerTurn(game, words) {
     const steps = [];
     if (game.ending !== null || !isComputer(game, game.turn))
@@ -89,7 +112,23 @@ export function planComputerTurn(game, words) {
     take(endTurn(now, verdict(), handSpells), { kind: "done", out: goesOut(now, verdict()) });
     return steps;
 }
-/** The game a computer's turn passes on: its plan's last step, or the game as it was where there is nothing to play. */
+/** The game a computer's turn passes on: its plan's last step, or the game as it was where there is nothing to play.
+ *
+ * @param game - The current immutable shared-bag party game.
+ * @param words - The loaded native language word list and tile mappings.
+ * @returns The game a computer's turn passes on: its plan's last step, or the game as it was where there is nothing to play.
+ * @example
+ * ```ts no-run
+ * import { loadTileWordsFromModule } from "@johnmorrisdotca/kumimoji/words";
+ * import { afterComputerTurn, startParty } from "@johnmorrisdotca/kumimoji";
+ *
+ * const words = await loadTileWordsFromModule("english");
+ * const settings = {size:3,level:"hard",seed:44,gameLength:"short",language:"english",doubleSet:false,diagonals:false,hints:false} as const;
+ * const bag = "catdogsun";
+ * const game = startParty(settings,bag,["Seat 1","Seat 2"]);
+ * console.log(afterComputerTurn(game,words).turn);
+ * ```
+ */
 export function afterComputerTurn(game, words) {
     return planComputerTurn(game, words).at(-1)?.game ?? game;
 }

package/dist/daily.d.ts

@@ -8,7 +8,27 @@
  * hand, level, length) gets the same bag, in the same order. The race against
  * the clock is then theirs.
  */
-/** The day a moment falls on, in UTC, written `YYYY-MM-DD`. Throws a `RangeError` for an invalid `Date`. */
+/** The day a moment falls on, in UTC, written `YYYY-MM-DD`. Throws a `RangeError` for an invalid `Date`.
+ *
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns The day a moment falls on, in UTC, written `YYYY-MM-DD`. Throws a `RangeError` for an invalid `Date`.
+ * @example
+ * ```ts
+ * import { kumimojiDay } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(kumimojiDay(new Date("2026-10-12T12:00:00Z")));
+ * ```
+ */
 export declare function kumimojiDay(at: Date): string;
-/** Today's seed, the date as a number: 2026-10-01 is 20261001. The day is UTC, so it is one seed worldwide. */
+/** Today's seed, the date as a number: 2026-10-01 is 20261001. The day is UTC, so it is one seed worldwide.
+ *
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns Today's seed, the date as a number: 2026-10-01 is 20261001. The day is UTC, so it is one seed worldwide.
+ * @example
+ * ```ts
+ * import { kumimojiDailySeed } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(kumimojiDailySeed(new Date("2026-10-12T12:00:00Z")));
+ * ```
+ */
 export declare function kumimojiDailySeed(at: Date): number;

package/dist/daily.js

@@ -9,13 +9,33 @@
  * the clock is then theirs.
  */
 const pad = (value, width) => String(value).padStart(width, "0");
-/** The day a moment falls on, in UTC, written `YYYY-MM-DD`. Throws a `RangeError` for an invalid `Date`. */
+/** The day a moment falls on, in UTC, written `YYYY-MM-DD`. Throws a `RangeError` for an invalid `Date`.
+ *
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns The day a moment falls on, in UTC, written `YYYY-MM-DD`. Throws a `RangeError` for an invalid `Date`.
+ * @example
+ * ```ts
+ * import { kumimojiDay } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(kumimojiDay(new Date("2026-10-12T12:00:00Z")));
+ * ```
+ */
 export function kumimojiDay(at) {
     if (Number.isNaN(at.getTime()))
         throw new RangeError("kumimoji: an invalid Date has no day");
     return `${pad(at.getUTCFullYear(), 4)}-${pad(at.getUTCMonth() + 1, 2)}-${pad(at.getUTCDate(), 2)}`;
 }
-/** Today's seed, the date as a number: 2026-10-01 is 20261001. The day is UTC, so it is one seed worldwide. */
+/** Today's seed, the date as a number: 2026-10-01 is 20261001. The day is UTC, so it is one seed worldwide.
+ *
+ * @param at - The word offset, seat index or date specified by this signature.
+ * @returns Today's seed, the date as a number: 2026-10-01 is 20261001. The day is UTC, so it is one seed worldwide.
+ * @example
+ * ```ts
+ * import { kumimojiDailySeed } from "@johnmorrisdotca/kumimoji";
+ *
+ * console.log(kumimojiDailySeed(new Date("2026-10-12T12:00:00Z")));
+ * ```
+ */
 export function kumimojiDailySeed(at) {
     const [year, month, day] = kumimojiDay(at).split("-").map(Number);
     return year * 10000 + month * 100 + day;

package/dist/element-define.d.ts

@@ -1 +1 @@
-export {};
+export * from "./element.ts";

package/dist/element-define.js

@@ -1,13 +1,3 @@
-/**
- * Defines the `<kumimoji-table>` element on the page. Import it for its effect:
- *
- * ```html
- * <script type="module" src="https://cdn.jsdelivr.net/npm/@johnmorrisdotca/kumimoji@1/dist/element-define.js"></script>
- * <kumimoji-table language="english" hand="7"></kumimoji-table>
- * ```
- *
- * A tag already defined is left as it is, and on a server, where there is no page, nothing happens.
- */
-import { KumimojiTable } from "./element.js";
-if (typeof customElements !== "undefined" && customElements.get("kumimoji-table") === undefined)
-    customElements.define("kumimoji-table", KumimojiTable);
+import { defineTable } from "./element.js";
+defineTable();
+export * from "./element.js";

package/dist/element.d.ts

@@ -1,4 +1,4 @@
-import { type KumimojiTableHandle } from "./ui/mount.ts";
+import { type KumimojiTableHandle, type KumimojiTableOptions } from "./ui/mount.ts";
 import type { KumimojiSaved } from "./export.ts";
 declare const ElementBase: typeof HTMLElement;
 /**
@@ -12,8 +12,7 @@ declare const ElementBase: typeof HTMLElement;
  * <kumimoji-table language="japanese" level="easy" seed="daily"></kumimoji-table>
  * ```
  *
- * Attributes (each is read again when it changes; a change to any but `lang`
- * deals a new game):
+ * Attributes configure the starting game; display, language and control changes preserve play:
  *  - `language`: the tiles, `english` (default) or `japanese` kana.
  *  - `hand`: the opening hand, 3, 7 (default) or 11.
  *  - `level`: how many tiles are wild, `easy` (most), `medium` (default) or `hard` (none).
@@ -25,11 +24,41 @@ declare const ElementBase: typeof HTMLElement;
  * It fires `kumimoji-change` after every change to the game, with the game as it would
  * be saved as `event.detail.saved`, and `kumimoji-finish` when the last tile is laid and every run
  * is a word, with `event.detail` the deal, the play and the time it took. It has the methods
- * `newGame()` and `setGame()`. A table the rules do not offer (a hand of 5, say) draws nothing.
+ * `newGame()` and `setGame()`. Invalid input shows a status and a plain error event.
+ */
+/**
+ * Native table options, checked alongside builder coverage.
+ * @example
+ * ```ts
+ * import { KUMIMOJI_EMBED_OPTION_KEYS } from "@johnmorrisdotca/kumimoji/element";
+ * console.log(KUMIMOJI_EMBED_OPTION_KEYS.includes("saved"));
+ * ```
+ */
+export declare const KUMIMOJI_EMBED_OPTION_KEYS: string[];
+/**
+ * Full native host options, including saved state, private words and callbacks.
+ * @example
+ * ```ts
+ * import type { KumimojiElementOptions } from "@johnmorrisdotca/kumimoji/element";
+ * const options: KumimojiElementOptions = { keep: false, locale: "ja" };
+ * console.log(options.locale);
+ * ```
+ */
+export type KumimojiElementOptions = KumimojiTableOptions;
+/**
+ * A reflected crossword table with the native table handle and saved-state getter.
+ * @example
+ * ```ts
+ * import { KumimojiTable } from "@johnmorrisdotca/kumimoji/element";
+ * console.log(KumimojiTable.observedAttributes.includes("daily"));
+ * ```
  */
 export declare class KumimojiTable extends ElementBase {
     #private;
     static observedAttributes: string[];
+    /** Native host options. Callback/presentation changes preserve the current game. */
+    get options(): KumimojiElementOptions;
+    set options(value: KumimojiElementOptions);
     connectedCallback(): void;
     disconnectedCallback(): void;
     attributeChangedCallback(): void;
@@ -41,5 +70,57 @@ export declare class KumimojiTable extends ElementBase {
     newGame(options?: Parameters<KumimojiTableHandle["newGame"]>[0]): Promise<void>;
     /** Put a game on the table: see `KumimojiTableHandle.setGame`. */
     setGame(saved: KumimojiSaved): Promise<void>;
+    /** The `language` attribute, reflected. */
+    get language(): string | null;
+    set language(value: string | number | boolean | null | undefined);
+    /** The `hand` attribute, reflected. */
+    get hand(): string | null;
+    set hand(value: string | number | boolean | null | undefined);
+    /** The `level` attribute, reflected. */
+    get level(): string | null;
+    set level(value: string | number | boolean | null | undefined);
+    /** The `length` attribute, reflected. */
+    get length(): string | null;
+    set length(value: string | number | boolean | null | undefined);
+    /** The `diagonals` attribute, reflected. */
+    get diagonals(): string | null;
+    set diagonals(value: string | number | boolean | null | undefined);
+    /** The `seed` attribute, reflected. */
+    get seed(): string | null;
+    set seed(value: string | number | boolean | null | undefined);
+    /** The `keep` attribute, reflected. */
+    get keep(): string | null;
+    set keep(value: string | number | boolean | null | undefined);
+    /** The `daily` attribute, reflected. */
+    get daily(): string | null;
+    set daily(value: string | number | boolean | null | undefined);
+    /** The `controls` attribute, reflected. */
+    get controls(): string | null;
+    set controls(value: string | number | boolean | null | undefined);
+    /** The `theme` attribute, reflected. */
+    get theme(): string | null;
+    set theme(value: string | number | boolean | null | undefined);
+    /** The `size` attribute, reflected. */
+    get size(): string | null;
+    set size(value: string | number | boolean | null | undefined);
+    /** The `width` attribute, reflected. */
+    get width(): string | null;
+    set width(value: string | number | boolean | null | undefined);
+    /** The `label` attribute, reflected. */
+    get label(): string | null;
+    set label(value: string | number | boolean | null | undefined);
 }
+/**
+ * Defines the table or a subclass under a custom tag. Server-safe and idempotent.
+ * @param tagName - The tag name; kumimoji-table by default.
+ * @param registry - The page registry, or undefined on a server.
+ * @returns Nothing; existing definitions are left alone.
+ * @example
+ * ```ts
+ * import { defineTable } from "@johnmorrisdotca/kumimoji/element";
+ * defineTable();
+ * console.log(typeof defineTable);
+ * ```
+ */
+export declare function defineTable(tagName?: string, registry?: CustomElementRegistry | undefined): void;
 export {};