@dreamboard-games/sdk 0.5.0-alpha.2 → 0.5.0-alpha.4

package/README.md

@@ -1,5 +1,7 @@
 # @dreamboard-games/sdk
 
+[Guides and API reference](../../docs/index.md) · [Registry](../../registry/README.md) · [Examples](../../examples/reference-games/README.md)
+
 The public TypeScript SDK for authoring, testing, and rendering Dreamboard
 games. Install this package rather than any of the repository's unpublished
 workspace inputs.
@@ -8,33 +10,15 @@ workspace inputs.
 pnpm add @dreamboard-games/sdk
 ```
 
-The package's declarations and export map are the API authority. Supported
-imports include the root module and explicit subpaths for authoring, runtime,
-reducer contracts, testing, browser interaction, UI, and reference-game
-metadata. Import only subpaths present in the installed package's `exports`
-field.
-
-```ts
-import { DREAMBOARD_SDK_VERSION } from "@dreamboard-games/sdk";
-import type { ReducerWire } from "@dreamboard-games/sdk/reducer-contract";
-import {
-  REFERENCE_GAME_MANIFEST_SCHEMA_VERSION,
-  parseReferenceGameManifest,
-  type ReferenceGameManifest,
-} from "@dreamboard-games/sdk/reference-games";
-
-const manifest: ReferenceGameManifest = parseReferenceGameManifest(input);
-console.log(REFERENCE_GAME_MANIFEST_SCHEMA_VERSION, manifest.id);
-```
-
-Reference-game manifests use schema V5. They describe the game workspace,
-teaching purpose, mechanics, UI patterns, and substantive rights metadata.
+The package declarations and export map are the API authority. There are four entry points:
 
-Include the packaged stylesheet when using SDK UI components:
+- `@dreamboard-games/sdk`: framework-free instances, sources, features and canonical host protocol schemas.
+- `@dreamboard-games/sdk/react`: typed React provider, selectors, subscriptions, and dnd-kit card/drop hooks.
+- `@dreamboard-games/sdk/reducer`: game authoring, manifest compilation, execution and trusted worker admission.
+- `@dreamboard-games/sdk/testing`: browser-safe local/scenario sources, replay, inspection and bounded exploration.
 
-```ts
-import "@dreamboard-games/sdk/ui/plugin-styles.css";
-```
+UI components are source-owned registry items installed into your application.
+The SDK contains no styled components or stylesheet.
 
 ## Game authoring
 
@@ -45,14 +29,19 @@ codes. The returned value is three things at once:
 - the **type leaf**: `typeof game.types.State`, `.ErrorCode`, `.PlayerId`,
   `.Queries`, `.Tx` (phantom carriers; reading them at runtime throws),
 - the **factory namespace**: `game.phase(name)`, `phase.define`,
-  `phase.interaction`, `phase.inputs.*`, `game.views.*`,
-- the **assembler**: `game.assemble({ initial, initialPhase, phases, views })`.
+  `phase.interaction`, `phase.inputs.*`, `game.view`,
+- the **assembler**: `game.assemble({ initial, initialPhase, phases, view })`.
 
 Mutation callbacks (`enter`, `reduce`, `resolve`) receive an open transaction
 `tx`. Mutate through it and finish with a bare `return` (accept), or with
 `tx.transition(name)`, `tx.endGame(outcome)`, or `tx.reject(code)`. Events go
 through `tx.emit(...)`. `state` is the read-only snapshot the callback started
-from; `tx.state` is the current draft.
+from; `tx.state` is the current draft. The transaction clones its table once;
+all card, component, resource, and state-slice updates use that draft. Use
+`tx.q` when a query must observe an earlier mutation in the same callback.
+State patch callbacks return a replacement slice without mutating their input.
+The former `ops`, `pipe`, flat `setActivePlayers`, and `tx.apply` APIs are removed;
+call the named transaction methods directly.
 
 ```ts
 // app/game-model.ts — the model, bound once
@@ -114,8 +103,11 @@ export default play.define({
         });
         tx.patchPhaseState({ leadCardId: input.params.cardId });
         const next = q.player.nextInOrder(input.playerId);
-        if (next) tx.setActivePlayers([next]);
-        if (q.zone.playerCards(input.playerId, "hand").length === 0) {
+        if (next) {
+          tx.patchPublicState({ currentPlayerId: next });
+          tx.setActivePlayers([next]);
+        }
+        if (tx.q.zone.playerCards(input.playerId, "hand").length === 0) {
           return tx.transition("setup");
         }
       },
@@ -124,6 +116,42 @@ export default play.define({
 });
 ```
 
+Dependent choices use `phase.steps()` instead of `inputs`. Each accepted command
+commits exactly one current value. Factories receive only earlier parsed
+`selected` values; descriptors expose only the current input. The final commit
+runs complete-parameter validation and the reducer once. Use explicit `null`
+for a no-target choice, and `many(...)` for one atomic multi-selection.
+
+```ts
+const choose = play.interaction({
+  steps: play
+    .steps()
+    .input(
+      "kind",
+      play.inputs.form.choice({
+        choices: [{ value: "single", label: "Single" }],
+        defaultValue: () => undefined,
+      }),
+    )
+    .input("count", ({ selected }) =>
+      play.inputs.form.number({
+        min: 1,
+        max: selected.kind === "single" ? 1 : 3,
+        defaultValue: 1,
+      }),
+    ),
+  reduce({ input }) {
+    // input.params contains both kind and count here.
+  },
+});
+```
+
+`rules.available` controls action eligibility; `rules.validate` checks a final
+submission. Accepted state changes reconcile pending prefixes, while phase
+entry clears them. A rejected final submission keeps the prior prefix. The
+actor can cancel an unsealed prefix with `interaction.cancel`, using the same
+transport basis and action identity as submission.
+
 ```ts
 // app/game.ts — assembly
 import { game } from "./game-model";
@@ -138,16 +166,11 @@ export default game.assemble({
   },
   initialPhase: "setup",
   phases: { setup, play },
-  views: {
-    shared: game.views.empty(),
-    player: game.views.player({
-      project: ({ state, playerId, q }) => ({
-        me: playerId,
-        hand: q.zone.playerCards(playerId, "hand"),
-        current: state.publicState.currentPlayerId,
-      }),
-    }),
-  },
+  view: game.view(({ state, playerId, q }) => ({
+    me: playerId,
+    hand: q.zone.playerCards(playerId, "hand"),
+    current: state.publicState.currentPlayerId,
+  })),
 });
 ```
 
@@ -159,18 +182,69 @@ imports the assembled game, so there is no import cycle.
 New workspaces keep authored starter code in `app/game.ts` and `ui/App.tsx`.
 Import the manifest directly. `compileManifest(manifest)` provides inferred ID schemas,
 table schemas, fresh initial tables, and board metadata in memory. `createGame`
-also accepts the authored manifest directly. Bind UI primitives with
-`createGameUi(game)` from `@dreamboard-games/sdk/runtime/workspace-contract`.
+also accepts the authored manifest directly. Bind a typed React hook with
+`createGameHook<Game>()({ features, coverage })` from `@dreamboard-games/sdk/react`,
+and pass a source to its `GameProvider`. The hosted UI imports `Game` only as a type;
+`iframeSource()` supplies authoritative frames and handles commands.
 No authoring generation step or shared workspace files are needed.
 
+Manifest card counts and explicit piece/die seed counts must be positive safe
+integers. Omitted seed counts mean one copy. Zero, negative, fractional, non-finite,
+and unsafe counts fail before ID expansion; negative, zero, and fractional literals
+also fail typechecking. Widened `number` values still require runtime validation.
+Player bounds must be positive safe integers with `minPlayers <= maxPlayers`.
+
+`defineTopologyManifest` returns `ValidatedManifest<M>` after semantic validation.
+`compileManifest` returns a branded `CompiledManifest<M>` after validation and table
+materialization. Both snapshot the authored input so later source edits do not
+change the validated value or future initial tables. Literal IDs remain inferred.
+
+`ReducerGameDefinitionInput` describes the authored assembly fields. The assembled
+`ReducerGameDefinition` adds the bound contract and validation brand; authors never
+supply those output-only fields.
+
+`game.assemble` checks phase names, the initial phase, interaction declarations,
+and simultaneous-phase requirements, then returns a branded `ReducerGameDefinition`.
+Runtime consumers such as `createReducerBundle` require that assembled type;
+handwritten structural lookalikes do not satisfy it. These brands record SDK
+construction checks, not correctness of arbitrary reducer callbacks, and do not
+replace validation of runtime commands or state. As with other TypeScript types,
+explicit assertions can bypass them; treat constructed definitions as immutable.
+Each card in a manual card set requires `id` for its definition and `cardType`
+for its category:
+
+```ts
+cards: [
+  { id: "ace", cardType: "ranked", name: "Ace", count: 2, properties: {} },
+  { id: "king", cardType: "ranked", name: "King", count: 1, properties: {} },
+];
+```
+
+These definitions create runtime IDs `ace-1`, `ace-2`, and `king`, all in the
+`ranked` category. When the card schema has `variants`, every `cardType` must
+name one of them; `compileManifest` and `createGame` reject unknown categories.
+The inferred table narrows a card lookup by its runtime ID to that definition's
+card set, category, and properties. A variant property overrides a shared
+property of the same name in both the runtime schema and inferred type.
+To migrate an older manifest, replace each card's `type` with `id` and set
+`cardType` explicitly (often to the former `type` value).
+
 ## Reducer runner contract
 
 `createReducerBundle(game)` returns exactly the contract version and four
 operations: `boardStatic()`, `initialize(input)`, `dispatch({ state, input })`,
-and `project({ state, playerIds })`. The runner contract is `0.5.0`; hosts must
-require that exact version. Dispatch includes validation and effect execution. Initialization returns
+and `project({ state, playerIds })`. The runner contract is `0.7.0`; hosts must
+require that exact version. Dispatch includes validation, direct transaction mutations, and phase entry.
+Initialization returns
 `{ state, terminal?, events? }`, preserving outcomes and events from initial
-phase entry and automatic continuations.
+phase entry and returned transitions.
+
+Mutation callbacks use `tx.roll(dieId)`, `tx.shuffle({ zoneId, playerId? })`, and
+`tx.deal({ fromZoneId, toZoneId, playerId, count })` directly. Return
+`tx.transition(phaseName)` to enter a phase, including reentering the current
+phase. An unreturned outcome schedules no work. Entry chains are bounded to
+1,000 entries per dispatch. `tx.endGame(outcome, { transition })` enters the
+final phase once; that entry must not return another transition.
 
 The authoritative state is explicit on every dispatch and projection. A host
 may retain a warm worker and SDK caches, but replaying the same state and input
@@ -182,3 +256,70 @@ owns the monotonically increasing version, perspective, and action-set identity.
 The plugin frame basis contains `version`, `actionSetVersion`, and
 `perspectivePlayerId`; it has no generation counter. Hosts merge the separately
 cached board static projection when materializing plugin gameplay frames.
+
+### Initialization options and actors
+
+Declare lobby options once on `createGame({ options: z.strictObject({ ... }), ... })`.
+The bundle accepts JSON-safe `options` at initialization, validates them with that
+schema, persists the parsed values, and supplies them to initial state and phase
+initializers. Without a schema, only `{}` is accepted. Options schemas must be
+JSON-native: transforms, preprocessing, and coercion are rejected. Restored
+sessions validate their stored options with the same schema.
+
+Perform shuffle, deal, and other initialization mutations in an ordinary phase
+entry callback. Setup profiles and bootstrap instructions are removed.
+Interactions use `actor` to override their phase actor; only authorized seats
+receive their input domains. Use ordinary form choices for responses and explicit
+rules plus transaction resource mutations for affordability. Prompt collectors,
+implicit costs, guidance metadata, and phase zone declarations are removed.
+
+A game authors one `view` for each requested seat. Public and private fields
+compose in that function; the transport never uses a seat view as a spectator
+payload. Static boards come directly from the compiled manifest.
+
+Use `memoize((input: SomeImmutableObject) => result)` for shared pure calculations.
+It caches by object identity with a WeakMap, including `undefined` results. Pass
+immutable snapshots (or stable immutable branches), not an open mutable transaction.
+There is no injected derived-value resolver.
+
+## React adapter dependency
+
+Framework-free consumers can import the package root without React. Applications
+using `@dreamboard-games/sdk/react` must install the maintained React store adapter
+alongside React:
+
+```sh
+pnpm add @dreamboard-games/sdk react@^19 react-dom@^19 @tanstack/react-store@0.11.1
+```
+
+`@tanstack/react-store` is an optional peer of the SDK so headless consumers do not
+install the React adapter. The `/react` entry delegates selectors to that package;
+the application bundler resolves its supported React subscription dependencies.
+
+The SDK includes dnd-kit for `/react` drag and drop. Enable `dragFeature`, export
+`useCardDrag` and `useBoardDrop` from the binding, and use the copied Hand and
+BoardTargets components or your own renderer. GameProvider owns the drag provider.
+Headless `game.drag` remains browser-free and handles atomic domain routing.
+
+## Local development and tests
+
+`localSource(game, { players, seed, as, options })` executes the production reducer
+and materializes the selected seat. `scenarioSource` starts from authored scenario
+checkpoints. Keep these executable game imports in your local development entry;
+the hosted entry uses only `iframeSource()` and type imports.
+
+Local sources expose `inspect`, bounded `explore`, typed explicit-actor `apply`,
+`switchSeat`, `checkpoint`, and validated `restore`. A JSON checkpoint preserves
+pending selections and terminal state; restoring does not replay commands.
+`createTestSource(snapshot)` supplies controlled frames and acknowledgements for
+instance and React tests. Static and hosted sources do not expose `apply`.
+
+Hosts import `assertReducerBundleContract`, `REDUCER_CONTRACT_VERSION`,
+`ReducerWire` types and `ReducerWireZod` schemas from `/reducer`. Canonical iframe
+and gameplay websocket schemas plus `materializePluginGameplayFrame` live at the
+root. Materialize the seat projection with static board data before publishing it;
+sources publish the canonical seat view and keep command bases private.
+
+Card sets contain their authored `cards`, `cardSchema`, and `defaultHome` directly.
+Standard playing cards are game-owned definitions with ordinary suit/rank
+properties; the SDK does not synthesize inventories or assign built-in rules.

package/dist/board-target-B0QG6OYx.d.ts

@@ -0,0 +1,8 @@
+/** A space on one player's board; boardId is the base manifest board ID. */
+type PlayerBoardSpaceTarget<BoardId extends string = string, SpaceId extends string = string, PlayerId extends string = string> = {
+    readonly boardId: BoardId;
+    readonly playerId: PlayerId;
+    readonly spaceId: SpaceId;
+};
+
+export type { PlayerBoardSpaceTarget as P };

package/dist/chunk-3JXUL4VN.js

@@ -0,0 +1,139 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/lookup.ts
+function requireLookup(value, kind, id) {
+  if (value === void 0) throw new Error(`${kind} "${id}" is not present.`);
+  return value;
+}
+
+// src/shared/board-target.ts
+import { z } from "zod";
+var PlayerBoardSpaceTargetSchema = z.strictObject({
+  boardId: z.string(),
+  playerId: z.string(),
+  spaceId: z.string()
+});
+function isPlayerBoardSpaceTarget(value) {
+  return typeof value === "object" && value !== null && Object.keys(value).length === 3 && "boardId" in value && typeof value.boardId === "string" && "playerId" in value && typeof value.playerId === "string" && "spaceId" in value && typeof value.spaceId === "string";
+}
+function samePlayerBoardSpaceTarget(left, right) {
+  return left.boardId === right.boardId && left.playerId === right.playerId && left.spaceId === right.spaceId;
+}
+
+// src/shared/input-domain.ts
+function inputDomainErrors(domain, value, selection, options = {}) {
+  if (selection?.mode === "many") {
+    if (!Array.isArray(value)) return ["Expected a list of values."];
+    const errors = cardinalityErrors(
+      value,
+      selection.min,
+      selection.max,
+      "value",
+      options.ignoreMinimum
+    );
+    if (selection.distinct && new Set(value.map(inputValueKey)).size !== value.length)
+      errors.push("Choose each value only once.");
+    if (value.some(
+      (item) => inputDomainErrors(domain, item, void 0, options).length > 0
+    ))
+      errors.push(ineligibleMessage(domain));
+    return errors;
+  }
+  switch (domain.type) {
+    case "choice":
+      return inputTargetInDomain(domain, value) ? [] : [ineligibleMessage(domain)];
+    case "choiceList": {
+      if (!Array.isArray(value)) return ["Expected a list of choices."];
+      const errors = cardinalityErrors(
+        value,
+        domain.min ?? 0,
+        domain.max ?? domain.choices.length,
+        "option",
+        options.ignoreMinimum
+      );
+      if (value.some((item) => !inputTargetInDomain(domain, item)))
+        errors.push(ineligibleMessage(domain));
+      return errors;
+    }
+    case "cardTarget":
+    case "boardTarget":
+      return inputTargetInDomain(domain, value) ? [] : [ineligibleMessage(domain)];
+    case "boundedNumber":
+      return typeof value === "number" && value >= domain.min && value <= domain.max && Math.abs(
+        (value - domain.min) / (domain.step ?? 1) - Math.round((value - domain.min) / (domain.step ?? 1))
+      ) < 1e-9 ? [] : ["Value is outside the current input domain."];
+    case "resourceMap":
+      return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).every(
+        (key) => domain.resources.some((entry) => entry.resourceId === key)
+      ) && domain.resources.every((entry) => {
+        const amount = value[entry.resourceId] ?? 0;
+        return typeof amount === "number" && Number.isInteger(amount) && amount >= (entry.min ?? 0) && amount <= (entry.max ?? Infinity);
+      }) ? [] : ["Value is outside the current input domain."];
+  }
+}
+function inputValueInDomain(domain, value, selection, options = {}) {
+  return inputDomainErrors(domain, value, selection, options).length === 0;
+}
+function inputTargetInDomain(domain, value) {
+  switch (domain.type) {
+    case "choice":
+    case "choiceList":
+      return domain.choices.some(
+        (choice) => !choice.disabled && Object.is(choice.value, value)
+      );
+    case "cardTarget":
+      return typeof value === "string" && domain.eligibleTargets.includes(value);
+    case "boardTarget":
+      return domain.valueKind === "player-board-space" ? isPlayerBoardSpaceTarget(value) && domain.eligibleTargets.some(
+        (candidate) => samePlayerBoardSpaceTarget(candidate, value)
+      ) : typeof value === "string" && domain.eligibleTargets.includes(value);
+    default:
+      return inputValueInDomain(domain, value);
+  }
+}
+function cardinalityErrors(value, min, max, unit, ignoreMinimum = false) {
+  const errors = [];
+  if (!ignoreMinimum && value.length < min)
+    errors.push(`Choose at least ${min} ${pluralize(unit, min)}.`);
+  if (max !== void 0 && value.length > max)
+    errors.push(`Choose at most ${max} ${pluralize(unit, max)}.`);
+  return errors;
+}
+function ineligibleMessage(domain) {
+  return domain.type === "choice" || domain.type === "choiceList" ? "Selected choice is not eligible." : domain.type === "cardTarget" || domain.type === "boardTarget" ? "Selected target is not eligible." : "Value is outside the current input domain.";
+}
+function inputValueKey(value) {
+  if (value === null) return "null";
+  if (isPlayerBoardSpaceTarget(value))
+    return `player-board-space:${JSON.stringify([value.boardId, value.playerId, value.spaceId])}`;
+  switch (typeof value) {
+    case "string":
+      return `string:${value}`;
+    case "number":
+    case "boolean":
+    case "undefined":
+      return `${typeof value}:${String(value)}`;
+    default:
+      return `json:${JSON.stringify(value)}`;
+  }
+}
+function pluralize(word, count) {
+  return count === 1 ? word : `${word}s`;
+}
+
+export {
+  __export,
+  requireLookup,
+  PlayerBoardSpaceTargetSchema,
+  isPlayerBoardSpaceTarget,
+  samePlayerBoardSpaceTarget,
+  inputDomainErrors,
+  inputValueInDomain,
+  inputTargetInDomain,
+  inputValueKey
+};
+//# sourceMappingURL=chunk-3JXUL4VN.js.map

package/dist/chunk-3JXUL4VN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/lookup.ts","../src/shared/board-target.ts","../src/shared/input-domain.ts"],"sourcesContent":["/** Assert presence at a mutable table or projected-snapshot lookup boundary. */\nexport function requireLookup<T>(\n  value: T | undefined,\n  kind: string,\n  id: string,\n): T {\n  if (value === undefined) throw new Error(`${kind} \"${id}\" is not present.`);\n  return value;\n}\n","import { z } from \"zod\";\n\n/** A space on one player's board; boardId is the base manifest board ID. */\nexport type PlayerBoardSpaceTarget<\n  BoardId extends string = string,\n  SpaceId extends string = string,\n  PlayerId extends string = string,\n> = {\n  readonly boardId: BoardId;\n  readonly playerId: PlayerId;\n  readonly spaceId: SpaceId;\n};\n\nexport const PlayerBoardSpaceTargetSchema = z.strictObject({\n  boardId: z.string(),\n  playerId: z.string(),\n  spaceId: z.string(),\n});\n\nexport function isPlayerBoardSpaceTarget(\n  value: unknown,\n): value is PlayerBoardSpaceTarget {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    Object.keys(value).length === 3 &&\n    \"boardId\" in value &&\n    typeof value.boardId === \"string\" &&\n    \"playerId\" in value &&\n    typeof value.playerId === \"string\" &&\n    \"spaceId\" in value &&\n    typeof value.spaceId === \"string\"\n  );\n}\n\nexport function samePlayerBoardSpaceTarget(\n  left: PlayerBoardSpaceTarget,\n  right: PlayerBoardSpaceTarget,\n): boolean {\n  return (\n    left.boardId === right.boardId &&\n    left.playerId === right.playerId &&\n    left.spaceId === right.spaceId\n  );\n}\n","import {\n  isPlayerBoardSpaceTarget,\n  samePlayerBoardSpaceTarget,\n} from \"./board-target\";\nimport type {\n  InputDomainDescriptor,\n  InputSelectionDescriptor,\n} from \"../reducer/model/spec/inputs\";\n\n/** Projected domain rules only; schemas and authored target checks remain server-owned. */\nexport function inputDomainErrors(\n  domain: InputDomainDescriptor,\n  value: unknown,\n  selection?: InputSelectionDescriptor,\n  options: { ignoreMinimum?: boolean } = {},\n): string[] {\n  if (selection?.mode === \"many\") {\n    if (!Array.isArray(value)) return [\"Expected a list of values.\"];\n    const errors = cardinalityErrors(\n      value,\n      selection.min,\n      selection.max,\n      \"value\",\n      options.ignoreMinimum,\n    );\n    if (\n      selection.distinct &&\n      new Set(value.map(inputValueKey)).size !== value.length\n    )\n      errors.push(\"Choose each value only once.\");\n    if (\n      value.some(\n        (item) =>\n          inputDomainErrors(domain, item, undefined, options).length > 0,\n      )\n    )\n      errors.push(ineligibleMessage(domain));\n    return errors;\n  }\n  switch (domain.type) {\n    case \"choice\":\n      return inputTargetInDomain(domain, value)\n        ? []\n        : [ineligibleMessage(domain)];\n    case \"choiceList\": {\n      if (!Array.isArray(value)) return [\"Expected a list of choices.\"];\n      const errors = cardinalityErrors(\n        value,\n        domain.min ?? 0,\n        domain.max ?? domain.choices.length,\n        \"option\",\n        options.ignoreMinimum,\n      );\n      if (value.some((item) => !inputTargetInDomain(domain, item)))\n        errors.push(ineligibleMessage(domain));\n      return errors;\n    }\n    case \"cardTarget\":\n    case \"boardTarget\":\n      return inputTargetInDomain(domain, value)\n        ? []\n        : [ineligibleMessage(domain)];\n    case \"boundedNumber\":\n      return typeof value === \"number\" &&\n        value >= domain.min &&\n        value <= domain.max &&\n        Math.abs(\n          (value - domain.min) / (domain.step ?? 1) -\n            Math.round((value - domain.min) / (domain.step ?? 1)),\n        ) < 1e-9\n        ? []\n        : [\"Value is outside the current input domain.\"];\n    case \"resourceMap\":\n      return typeof value === \"object\" &&\n        value !== null &&\n        !Array.isArray(value) &&\n        Object.keys(value).every((key) =>\n          domain.resources.some((entry) => entry.resourceId === key),\n        ) &&\n        domain.resources.every((entry) => {\n          const amount =\n            (value as Record<string, unknown>)[entry.resourceId] ?? 0;\n          return (\n            typeof amount === \"number\" &&\n            Number.isInteger(amount) &&\n            amount >= (entry.min ?? 0) &&\n            amount <= (entry.max ?? Infinity)\n          );\n        })\n        ? []\n        : [\"Value is outside the current input domain.\"];\n  }\n}\n\nexport function inputValueInDomain(\n  domain: InputDomainDescriptor,\n  value: unknown,\n  selection?: InputSelectionDescriptor,\n  options: { ignoreMinimum?: boolean } = {},\n): boolean {\n  return inputDomainErrors(domain, value, selection, options).length === 0;\n}\n\n/** One selectable option, including an option within a choiceList or many input. */\nexport function inputTargetInDomain(\n  domain: InputDomainDescriptor,\n  value: unknown,\n): boolean {\n  switch (domain.type) {\n    case \"choice\":\n    case \"choiceList\":\n      return domain.choices.some(\n        (choice) => !choice.disabled && Object.is(choice.value, value),\n      );\n    case \"cardTarget\":\n      return (\n        typeof value === \"string\" && domain.eligibleTargets.includes(value)\n      );\n    case \"boardTarget\":\n      return domain.valueKind === \"player-board-space\"\n        ? isPlayerBoardSpaceTarget(value) &&\n            domain.eligibleTargets.some((candidate) =>\n              samePlayerBoardSpaceTarget(candidate, value),\n            )\n        : typeof value === \"string\" && domain.eligibleTargets.includes(value);\n    default:\n      return inputValueInDomain(domain, value);\n  }\n}\n\nfunction cardinalityErrors(\n  value: readonly unknown[],\n  min: number,\n  max: number | undefined,\n  unit: string,\n  ignoreMinimum = false,\n): string[] {\n  const errors: string[] = [];\n  if (!ignoreMinimum && value.length < min)\n    errors.push(`Choose at least ${min} ${pluralize(unit, min)}.`);\n  if (max !== undefined && value.length > max)\n    errors.push(`Choose at most ${max} ${pluralize(unit, max)}.`);\n  return errors;\n}\n\nfunction ineligibleMessage(domain: InputDomainDescriptor): string {\n  return domain.type === \"choice\" || domain.type === \"choiceList\"\n    ? \"Selected choice is not eligible.\"\n    : domain.type === \"cardTarget\" || domain.type === \"boardTarget\"\n      ? \"Selected target is not eligible.\"\n      : \"Value is outside the current input domain.\";\n}\n\n/** Matches the reducer's JSON value identity for projected distinct selections. */\nexport function inputValueKey(value: unknown): string {\n  if (value === null) return \"null\";\n  if (isPlayerBoardSpaceTarget(value))\n    return `player-board-space:${JSON.stringify([value.boardId, value.playerId, value.spaceId])}`;\n  switch (typeof value) {\n    case \"string\":\n      return `string:${value}`;\n    case \"number\":\n    case \"boolean\":\n    case \"undefined\":\n      return `${typeof value}:${String(value)}`;\n    default:\n      return `json:${JSON.stringify(value)}`;\n  }\n}\n\nfunction pluralize(word: string, count: number): string {\n  return count === 1 ? word : `${word}s`;\n}\n"],"mappings":"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","names":[]}