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

package/dist/reducer.d.ts

@@ -1,18 +1,259 @@
-import { c2 as SchemaLike, a as AnySchema, cH as SystemActionEvent, bW as RuntimeTableRecord, cL as TableQueriesOfState, cK as TableQueries, e as BoardIdOfTable, c as BoardContainerIdOfTable, aF as PlayerIdOfState } from './runtime-RJ5orDJU.js';
-export { h as BoardRef, R as FrameworkErrorCodes, S as GameEvent, T as GameEventDetail, U as GameOutcome, ak as OutcomeResult, al as OutcomeScoreComponent, am as OutcomeStanding, an as OutcomeTieBreak, ao as PerPlayer, ap as PerPlayerBoardRef, aq as PerPlayerSchemaOptions, aD as PlayerId, aO as ReducerAccept, aU as ReducerReject, aV as ReducerResult, aY as ReducerValidationResult, cl as SharedBoardRef, cZ as asPlayerId, c$ as boardRef, d0 as boardRefKey, d1 as boardRefSchema, d7 as isPerPlayer, d8 as isPerPlayerBoardRef, d9 as isPlayerId, da as isSharedBoardRef, dd as parseBoardRefKey, de as perPlayer, df as perPlayerBoardRef, dg as perPlayerEntries, dh as perPlayerGet, di as perPlayerHas, dj as perPlayerKeys, dk as perPlayerMap, dl as perPlayerRequire, dm as perPlayerSchema, dn as perPlayerSet, dp as perPlayerSize, dq as perPlayerValues, ds as sharedBoardRef } from './runtime-RJ5orDJU.js';
-import { y as CollectorState, Z as InputCollector, a4 as InputSelectionDescriptor, z as ContinuationCallable, T as EffectRollDieDefinition, U as EffectShuffleDefinition, V as EffectShufflePlayerZoneDefinition, aH as ReducerGameContractLike, au as PhaseMapOf, bc as ViewMapOf, aI as ReducerGameDefinition } from './views-BpuWcOyN.js';
-export { J as DerivedDefinition, K as DerivedResolver, ad as InteractionRule, an as Op, aJ as ReducerOps, aL as ReducerStateBase, aN as ReducerTransaction, aO as ReducerTransactionOutcome, aX as RotatePlayerZoneArgs, ba as ValidationIssue, bh as createDerivedResolver, bi as createReducerOps, bj as defineDerived, bk as pipe } from './views-BpuWcOyN.js';
-import { o as TargetPredicate, A as AnyReducerGameContract, i as ContractState, h as ContractManifest, a as AuthoredManifest, g as CompiledManifest } from './game-CsZScpcn.js';
-export { B as BoardTargetPredicate, b as BoundInputBuilders, c as BoundTargetPredicate, d as BoundViewBuilders, C as ChoiceOptionsFactory, e as ChoiceTargetOption, f as ChoiceTargetPredicate, j as ContractTypes, D as DefinedInputs, k as DependencyValues, G as GameAuthoring, I as InputFieldRef, M as ManifestIdsOf, l as ManifestTable, P as PhaseAuthoring, m as PhaseTypes, n as PlayerBoardSpaceTarget, T as TargetContext, p as TargetPredicateArgs, q as createGame, s as defineInputs } from './game-CsZScpcn.js';
-import { z } from 'zod';
-import { a as ReducerBundleContract } from './index.d-DjzoK7zn.js';
-import { a as ReducerDiagnosticsSink } from './diagnostics-DIi3ina7.js';
-export { D as DispatchTraceSummaryEntry, R as ReducerDiagnosticEvent, n as noopDiagnosticsSink } from './diagnostics-DIi3ina7.js';
-export { S as StaleContractArtifactError, a as StaleContractArtifactErrorOptions, b as StaleContractArtifactKind, i as isStaleContractArtifactError } from './stale-contract-artifact-error-XLaweZtF.js';
-import './types.js';
-import './protocol-dYgafTYY.js';
-
-type CardTargetPredicate<State extends CollectorState, Id extends string> = TargetPredicate<State, Id>;
+import { ae as ManifestIdSchema, aV as SchemaLike, t as CollectorState, S as InputCollector, as as PlayerIdOfState, b6 as TableQueriesOfState, aM as ResourceMapDomainDescriptor, p as BoundedNumberDomainDescriptor, q as ChoiceDomainDescriptor, r as ChoiceListDomainDescriptor, bh as TopologyDefinitions, v as CollectorValueWitness, u as CollectorValueOf, X as InputSelectionDescriptor, aH as ReducerManifestContractLike, aT as RuntimeTableRecord, aS as RuntimeRecord, b2 as StateDefinition, ac as ManifestContractOf, B as BaseGameStateOfContract, E as ErrorCodeOfContract, be as TiledBoardIdOfTable, b4 as TableOfManifest, bg as TiledVertexIdOfTable, bf as TiledEdgeIdOfTable, h as BoardIdOfTable, b0 as SpaceIdOfTable, j as BoardSpaceTarget, an as PerPlayerInstanceId, bs as ZoneIdOfTable, C as CardIdOfManifest, au as PositionTargetSchema, at as PositionTarget, b9 as TileIdOfTable, ah as OptionsOfContract, aJ as ReducerTransaction, bn as ViewData, bo as ViewDefinition, ap as PhaseMapOf, bp as ViewOfContract, aF as ReducerGameDefinitionInput, aE as ReducerGameDefinition, ab as InteractionSteps, aW as ScopedPhaseState, a9 as InteractionSpec, a8 as InteractionRule, a7 as InteractionMap, ao as PhaseDefinition, aG as ReducerManifestContract, aC as ReducerGameContract, x as CompiledManifestWitness, w as CompiledManifest, b3 as SystemActionEvent, aD as ReducerGameContractLike, aR as RuntimeQueryTable, br as ZoneDefinitions, b5 as TableQueries, aU as SchemaAuthoring, O as GameTopologyManifest$1, z as FieldsInput, c as AuthoredTileDisclosure, aO as RuntimeIdsFromCount, bc as TileSpaceIds, g as BoardEdgeRef, o as BoardVertexRef, ad as ManifestCountValidation, bi as ValidatedManifest, a as AuthoredManifest, aA as ReadonlyRuntimeData, b as AuthoredOf } from './extract-CwJWDrSD.js';
+export { d as AuthoredTileFaceAudience, f as BoardEdgeId, i as BoardSpaceHostId, n as BoardVertexId, F as FieldSchema, G as FieldsOutput, H as FrameworkErrorCodes, I as GameEvent, J as GameEventDetail, L as GameOutcome, af as ManifestIdsOf, ag as ManifestTable, ai as OutcomeResult, aj as OutcomeScoreComponent, ak as OutcomeStanding, al as OutcomeTieBreak, am as PerPlayerInstanceFamily, ar as PlayerId, az as PublicTileAppearance, aK as ReducerTransactionOutcome, aL as ReducerValidationResult, bD as ReducerWire, bC as ReducerWireZod, aN as RotateZoneArgs, aZ as SeatSpaceRef, a_ as SeatTileRef, b1 as SquareBoardSpec, b7 as TileDisclosure, b8 as TileFaceAudience, ba as TileSeedSpec, bb as TileSpaceId, bd as TileTypeSpec, bj as ValidationIssue, bu as asPlayerId, bv as boardSpaceHostId, bw as isPlayerId, bx as parseBoardSpaceHostId, by as parsePerPlayerInstanceId, bz as parseTileSpaceId, bA as perPlayerInstanceId, bB as ref, bE as tileSpaceId } from './extract-CwJWDrSD.js';
+import * as z from 'zod';
+import { z as z$1 } from 'zod';
+export { z };
+import { a as ReducerBundleContract, c as ReducerDiagnosticsSink } from './diagnostics-ZAPEBlJP.js';
+export { D as DispatchTraceSummaryEntry, M as MaybePromise, R as REDUCER_CONTRACT_VERSION, b as ReducerDiagnosticEvent, d as assertReducerBundleContract, n as noopDiagnosticsSink } from './diagnostics-ZAPEBlJP.js';
+export { b as boardEdgeId, a as boardVertexId, p as parseBoardElementId } from './board-element-CqtxU5VZ.js';
+import 'honeycomb-grid';
+
+type DomainContext<State extends CollectorState> = {
+    state: State;
+    playerId: PlayerIdOfState<State>;
+    q: TableQueriesOfState<State>;
+};
+type ManifestFormInputSchema = ManifestIdSchema<unknown> | z.ZodOptional<ManifestIdSchema<unknown>> | z.ZodNullable<ManifestIdSchema<unknown>>;
+type DomainNumber<State extends CollectorState> = number | ((context: DomainContext<State>) => number);
+type ResourceMapInputOptions<State extends CollectorState> = {
+    resources: ReadonlyArray<{
+        resourceId: string;
+        label?: string;
+        icon?: string;
+        min?: DomainNumber<State>;
+        max: DomainNumber<State>;
+    }>;
+};
+type ChoiceValue = string | null;
+type FormCollector<Schema extends SchemaLike<unknown>, State extends CollectorState, Domain extends ResourceMapDomainDescriptor | BoundedNumberDomainDescriptor | ChoiceDomainDescriptor | ChoiceListDomainDescriptor, Value = z.infer<Schema>> = Omit<InputCollector<Schema, State, "form", Value>, "domain"> & {
+    readonly domain: (state: CollectorState, playerId: string, q: unknown) => Domain;
+};
+type DomainChoice<Value extends ChoiceValue> = {
+    value: Value;
+    label: string;
+    icon?: string;
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+type DomainChoicePresentation = {
+    badge?: string;
+    description?: string;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+type ResourceMapChoiceDecorator<State extends CollectorState> = (context: DomainContext<State> & {
+    resourceId: string;
+    label: string;
+    icon?: string;
+}) => DomainChoicePresentation | null | undefined;
+type ResourceMapChoiceSource<State extends CollectorState> = "resourceMap" | {
+    source: "resourceMap";
+    decorate?: ResourceMapChoiceDecorator<State>;
+};
+type DomainChoices<Value extends ChoiceValue, State extends CollectorState> = ReadonlyArray<DomainChoice<Value>> | ResourceMapChoiceSource<State> | ((context: DomainContext<State>) => ReadonlyArray<DomainChoice<Value>>);
+type ChoiceListDefaultValue<Value extends string, State extends CollectorState> = Value[] | "all" | ((context: DomainContext<State> & {
+    choices: ReadonlyArray<DomainChoice<Value>>;
+}) => Value[]);
+type ChoiceDefaultResolver<Value extends ChoiceValue, State extends CollectorState> = (context: DomainContext<State> & {
+    choices: ReadonlyArray<DomainChoice<Value>>;
+}) => Value | undefined;
+declare function baseFormInput<Schema extends ManifestFormInputSchema & SchemaLike<unknown>, State extends CollectorState = CollectorState>(schema: Schema): InputCollector<Schema, State, "form">;
+declare function baseFormInput<Schema extends ManifestFormInputSchema & SchemaLike<unknown>, State extends CollectorState = CollectorState>(schema: Schema, options: {
+    defaultValue: z.infer<Schema>;
+}): InputCollector<Schema, State, "form"> & {
+    readonly defaultValue: z.infer<Schema>;
+};
+declare function resourceMapInput<State extends CollectorState = CollectorState>(options: ResourceMapInputOptions<State>): FormCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, ResourceMapDomainDescriptor>;
+declare function resourceMapInput<State extends CollectorState = CollectorState>(options: ResourceMapInputOptions<State> & {
+    defaultValue: Record<string, number>;
+}): FormCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, ResourceMapDomainDescriptor> & {
+    readonly defaultValue: Record<string, number>;
+};
+declare function numberInput<State extends CollectorState = CollectorState>(options: {
+    min: DomainNumber<State>;
+    max: DomainNumber<State>;
+    step?: DomainNumber<State>;
+}): FormCollector<z.ZodNumber, State, BoundedNumberDomainDescriptor>;
+declare function numberInput<State extends CollectorState = CollectorState>(options: {
+    min: DomainNumber<State>;
+    max: DomainNumber<State>;
+    step?: DomainNumber<State>;
+    defaultValue: number;
+}): FormCollector<z.ZodNumber, State, BoundedNumberDomainDescriptor> & {
+    readonly defaultValue: number;
+};
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState>(options: {
+    choices: ReadonlyArray<DomainChoice<Value>>;
+    defaultValue: Value;
+}): FormCollector<SchemaLike<Value>, State, ChoiceDomainDescriptor, Value> & {
+    readonly defaultValue: Value;
+};
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    defaultValue: Value;
+}): FormCollector<SchemaLike<ChoiceValue>, State, ChoiceDomainDescriptor, Value> & {
+    readonly defaultValue: Value;
+};
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState>(options: {
+    choices: ReadonlyArray<DomainChoice<Value>>;
+    defaultValue: ChoiceDefaultResolver<Value, State>;
+}): FormCollector<SchemaLike<Value>, State, ChoiceDomainDescriptor, Value>;
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    defaultValue: ChoiceDefaultResolver<Value, State>;
+}): FormCollector<SchemaLike<ChoiceValue>, State, ChoiceDomainDescriptor, Value>;
+type ChoiceListCollector<Value extends string, State extends CollectorState> = InputCollector<z.ZodArray<z.ZodString>, State, "form", Value[]> & {
+    readonly domain: (state: CollectorState, playerId: string, q: unknown) => ChoiceListDomainDescriptor;
+};
+declare function choiceListInput<Value extends string, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    min?: DomainNumber<State>;
+    max?: DomainNumber<State>;
+    defaultValue: Value[];
+}): ChoiceListCollector<Value, State> & {
+    readonly defaultValue: Value[];
+};
+declare function choiceListInput<Value extends string, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    min?: DomainNumber<State>;
+    max?: DomainNumber<State>;
+    defaultValue?: ChoiceListDefaultValue<Value, State>;
+}): ChoiceListCollector<Value, State>;
+type FormInputForState<State extends CollectorState> = {
+    <Schema extends ManifestFormInputSchema & SchemaLike<unknown>>(schema: Schema): InputCollector<Schema, State, "form">;
+    <Schema extends ManifestFormInputSchema & SchemaLike<unknown>>(schema: Schema, options: {
+        defaultValue: z.infer<Schema>;
+    }): InputCollector<Schema, State, "form"> & {
+        readonly defaultValue: z.infer<Schema>;
+    };
+    resourceMap(options: ResourceMapInputOptions<State>): FormCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, ResourceMapDomainDescriptor>;
+    resourceMap(options: ResourceMapInputOptions<State> & {
+        defaultValue: Record<string, number>;
+    }): FormCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, ResourceMapDomainDescriptor> & {
+        readonly defaultValue: Record<string, number>;
+    };
+    resourceChoices(options?: {
+        decorate?: ResourceMapChoiceDecorator<State>;
+    }): ResourceMapChoiceSource<State>;
+    number: typeof numberInput<State>;
+    choice<Value extends ChoiceValue>(options: {
+        choices: ReadonlyArray<DomainChoice<Value>>;
+        defaultValue: Value;
+    }): FormCollector<SchemaLike<Value>, State, ChoiceDomainDescriptor, Value> & {
+        readonly defaultValue: Value;
+    };
+    choice<Value extends ChoiceValue>(options: {
+        choices: DomainChoices<Value, State>;
+        defaultValue: Value;
+    }): FormCollector<SchemaLike<ChoiceValue>, State, ChoiceDomainDescriptor, Value> & {
+        readonly defaultValue: Value;
+    };
+    choice<Value extends ChoiceValue>(options: {
+        choices: ReadonlyArray<DomainChoice<Value>>;
+        defaultValue: ChoiceDefaultResolver<Value, State>;
+    }): FormCollector<SchemaLike<Value>, State, ChoiceDomainDescriptor, Value>;
+    choice<Value extends ChoiceValue>(options: {
+        choices: DomainChoices<Value, State>;
+        defaultValue: ChoiceDefaultResolver<Value, State>;
+    }): FormCollector<SchemaLike<ChoiceValue>, State, ChoiceDomainDescriptor, Value>;
+    choiceList<Value extends string>(options: {
+        choices: DomainChoices<Value, State>;
+        min?: DomainNumber<State>;
+        max?: DomainNumber<State>;
+        defaultValue: Value[];
+    }): ChoiceListCollector<Value, State> & {
+        readonly defaultValue: Value[];
+    };
+    choiceList<Value extends string>(options: {
+        choices: DomainChoices<Value, State>;
+        min?: DomainNumber<State>;
+        max?: DomainNumber<State>;
+        defaultValue?: ChoiceListDefaultValue<Value, State>;
+    }): ChoiceListCollector<Value, State>;
+};
+declare function formInputForState<State extends CollectorState>(): FormInputForState<State>;
+/**
+ * Manifest-backed id input. Free-form Zod schemas are intentionally explicit:
+ * if the runtime cannot disclose valid values or numeric bounds through a
+ * manifest id or domain helper, use a custom interaction surface with an
+ * explicit `paramsSchema` instead of the default form renderer.
+ */
+declare const formInput: typeof baseFormInput & {
+    resourceMap: typeof resourceMapInput;
+    resourceChoices: <State extends CollectorState = CollectorState>(options?: {
+        decorate?: ResourceMapChoiceDecorator<State>;
+    }) => ResourceMapChoiceSource<State>;
+    number: typeof numberInput;
+    choice: typeof choiceInput;
+    choiceList: typeof choiceListInput;
+    forState: typeof formInputForState;
+};
+
+type TargetContext<State extends CollectorState, Definitions extends TopologyDefinitions = TopologyDefinitions> = {
+    state: State;
+    playerId: PlayerIdOfState<State>;
+    q: TableQueriesOfState<State, Definitions>;
+};
+type TargetPredicateArgs<State extends CollectorState, Target, Definitions extends TopologyDefinitions = TopologyDefinitions> = TargetContext<State, Definitions> & {
+    targetId: Target;
+};
+type TargetPredicate<State extends CollectorState, Target, Definitions extends TopologyDefinitions = TopologyDefinitions> = {
+    id: string;
+    errorCode: string;
+    message?: string;
+    test: (args: TargetPredicateArgs<State, Target, Definitions>) => boolean;
+};
+
+type BoardTargetPredicate<State extends CollectorState, Target, Definitions extends TopologyDefinitions = TopologyDefinitions> = TargetPredicate<State, Target, Definitions>;
+
+type BoardSpaceInputSchema = z.ZodObject<{
+    boardId: ManifestIdSchema<string, "boardId">;
+    spaceId: z.ZodString;
+}>;
+
+type CardTargetPredicate<State extends CollectorState, Id extends string, Definitions extends TopologyDefinitions = TopologyDefinitions> = TargetPredicate<State, Id, Definitions>;
+
+type ChoiceTargetOption<Id extends string> = {
+    id: Id;
+    label?: string;
+};
+type ChoiceOptionsFactory<State extends CollectorState, Id extends string> = (state: State, playerId: PlayerIdOfState<State>, q: TableQueriesOfState<State>) => ReadonlyArray<ChoiceTargetOption<Id>>;
+type ChoiceTargetPredicate<State extends CollectorState, Id extends string> = TargetPredicate<State, Id>;
+
+/**
+ * `rngInput.*` helpers produce collectors whose value is *sampled by the
+ * engine on submit* rather than supplied by the client. The schema pins
+ * the exact output shape so `ParamsOf<Collectors>` sees precisely typed
+ * results.
+ *
+ * Determinism:
+ *   Sampling happens inside `submitInteraction` only, never inside
+ *   reducer validation. This lets clients check a submission without
+ *   burning RNG state.
+ */
+type DieRoll = z.ZodObject<{
+    values: z.ZodArray<z.ZodNumber>;
+}>;
+type CoinFlip = z.ZodObject<{
+    value: z.ZodEnum<{
+        heads: "heads";
+        tails: "tails";
+    }>;
+}>;
+type RngCollector<Schema extends DieRoll | CoinFlip, State extends CollectorState> = InputCollector<Schema, State, "rng">;
+/**
+ * Roll `count` d6s. The submitted value is `{ values: number[] }` with
+ * `values.length === count` and each face `1..6`.
+ */
+declare function d6<State extends CollectorState = CollectorState>(count?: number): RngCollector<DieRoll, State>;
+/** Flip a coin. The submitted value is `{ value: "heads" | "tails" }`. */
+declare function coin<State extends CollectorState = CollectorState>(): RngCollector<CoinFlip, State>;
+declare const rngInput: {
+    d6: typeof d6;
+    coin: typeof coin;
+};
 
 type ManyOptions = {
     count: number;
@@ -25,48 +266,208 @@ type ManyOptions = {
 type NonRngCollector = InputCollector<SchemaLike<unknown>, CollectorState> & {
     readonly kind: Exclude<InputCollector["kind"], "rng">;
 };
-type CollectorSchema<Collector extends NonRngCollector> = [Collector] extends [
-    InputCollector<infer Schema, CollectorState>
-] ? Schema : never;
-type CollectorStateOf<Collector extends NonRngCollector> = [Collector] extends [
-    InputCollector<SchemaLike<unknown>, infer State>
-] ? State : never;
-type CollectorKindOf<Collector extends NonRngCollector> = [Collector] extends [
-    {
-        readonly kind: infer Kind extends Exclude<InputCollector["kind"], "rng">;
-    }
-] ? Kind : never;
-type ManyInputCollector<Schema extends SchemaLike<unknown> = SchemaLike<unknown>, State extends CollectorState = CollectorState, Kind extends Exclude<InputCollector["kind"], "rng"> = Exclude<InputCollector["kind"], "rng">> = InputCollector<z.ZodArray<Schema>, State, Kind> & {
+/** Lift the value schema while retaining the collector's exact domain and routing. */
+type ManyInputCollector<Collector extends NonRngCollector> = Omit<Collector, "schema" | "selection" | "defaultValue" | "resolveDefaultValue" | keyof CollectorValueWitness<unknown>> & CollectorValueWitness<CollectorValueOf<Collector>[]> & {
+    readonly schema: z.ZodArray<Collector["schema"]>;
     readonly selection: Extract<InputSelectionDescriptor, {
         mode: "many";
     }>;
 };
-declare function many<Collector extends NonRngCollector>(collector: Collector, options: ManyOptions): ManyInputCollector<CollectorSchema<Collector>, CollectorStateOf<Collector>, CollectorKindOf<Collector>> & Pick<Collector, "meta">;
+declare function many<Collector extends NonRngCollector>(collector: Collector, options: ManyOptions): ManyInputCollector<Collector>;
 
-type EffectRollDieInput<Contract extends AnyReducerGameContract, Id extends string, ContextSchema extends AnySchema> = {
-    type: "rollDie";
-    id: Id;
-    context?: ContextSchema;
-    reduce?: ContinuationCallable<ContextSchema, ContractState<Contract>, ContractManifest<Contract>, Id, "rollDie">["reduce"];
+type TileTargetPredicate<State extends CollectorState, Id extends string, Definitions extends TopologyDefinitions = TopologyDefinitions> = TargetPredicate<State, Id, Definitions>;
+
+type AnyReducerGameContract = {
+    manifest: ReducerManifestContractLike<RuntimeTableRecord>;
+    options: SchemaLike<RuntimeRecord>;
+    state: StateDefinition<SchemaLike<object>, SchemaLike<object>, SchemaLike<object>>;
 };
-type EffectShuffleInput<Contract extends AnyReducerGameContract, Id extends string, ContextSchema extends AnySchema> = {
-    type: "shuffleSharedZone";
-    id: Id;
-    context?: ContextSchema;
-    reduce?: ContinuationCallable<ContextSchema, ContractState<Contract>, ContractManifest<Contract>, Id, "shuffleSharedZone">["reduce"];
+type ContractState<Contract extends AnyReducerGameContract> = BaseGameStateOfContract<Contract>;
+type ContractManifest<Contract extends AnyReducerGameContract> = ManifestContractOf<Contract>;
+type ContractErrorCode<Contract extends AnyReducerGameContract> = ErrorCodeOfContract<Contract>;
+
+type ContractWithPhases = AnyReducerGameContract & {
+    readonly phases: Record<string, SchemaLike<object>>;
 };
-type EffectShufflePlayerZoneInput<Contract extends AnyReducerGameContract, Id extends string, ContextSchema extends AnySchema> = {
-    type: "shufflePlayerZone";
-    id: Id;
-    context?: ContextSchema;
-    reduce?: ContinuationCallable<ContextSchema, ContractState<Contract>, ContractManifest<Contract>, Id, "shufflePlayerZone">["reduce"];
+type BoundState<Contract extends ContractWithPhases> = ContractState<Contract>;
+type BoundManifest<Contract extends ContractWithPhases> = ContractManifest<Contract>;
+type BoundTable<Contract extends ContractWithPhases> = TableOfManifest<BoundManifest<Contract>>;
+type BoundPhaseState<Contract extends ContractWithPhases, PhaseStateSchema extends SchemaLike<object>> = ScopedPhaseState<BoundState<Contract>, z$1.infer<PhaseStateSchema>>;
+type BoundFormInputs<Contract extends ContractWithPhases> = ReturnType<typeof formInput.forState<BoundState<Contract>>>;
+/** The selected board owns the element namespace, including generic spaces. */
+type BoundBoardInputOptions<Contract extends ContractWithPhases, BoardId, Id> = {
+    boardId: BoardId;
+    where?: BoundWhere<Contract, Id>;
+};
+type PlayerBoardBaseId<Contract extends ContractWithPhases> = {
+    [B in keyof BoundManifest<Contract>["boardDefinitions"] & string]: BoundManifest<Contract>["boardDefinitions"][B] extends {
+        scope: "perPlayer";
+    } ? B : never;
+}[keyof BoundManifest<Contract>["boardDefinitions"] & string];
+type PlayerBoardRuntimeId<Table, Base extends string> = Extract<BoardIdOfTable<Table>, PerPlayerInstanceId<"board", Base>>;
+type BoundBoardInputs<Contract extends ContractWithPhases> = {
+    vertex<B extends TiledBoardIdOfTable<BoundTable<Contract>, BoundManifest<Contract>>>(options: BoundBoardInputOptions<Contract, B, TiledVertexIdOfTable<BoundTable<Contract>, NoInfer<B>, BoundManifest<Contract>>>): InputCollector<z$1.ZodString, BoundState<Contract>, "board-vertex", TiledVertexIdOfTable<BoundTable<Contract>, B, BoundManifest<Contract>>>;
+    edge<B extends TiledBoardIdOfTable<BoundTable<Contract>, BoundManifest<Contract>>>(options: BoundBoardInputOptions<Contract, B, TiledEdgeIdOfTable<BoundTable<Contract>, NoInfer<B>, BoundManifest<Contract>>>): InputCollector<z$1.ZodString, BoundState<Contract>, "board-edge", TiledEdgeIdOfTable<BoundTable<Contract>, B, BoundManifest<Contract>>>;
+    space<B extends BoardIdOfTable<BoundTable<Contract>>>(options: BoundBoardInputOptions<Contract, B, SpaceIdOfTable<BoundTable<Contract>, NoInfer<B>, BoundManifest<Contract>>>): InputCollector<z$1.ZodString, BoundState<Contract>, "board-space", SpaceIdOfTable<BoundTable<Contract>, B, BoundManifest<Contract>>>;
+    playerSpace<B extends PlayerBoardBaseId<Contract>>(options: {
+        boardId: B;
+        where?: BoundWhere<Contract, BoardSpaceTarget<PerPlayerInstanceId<"board", NoInfer<B>>, SpaceIdOfTable<BoundTable<Contract>, PlayerBoardRuntimeId<BoundTable<Contract>, NoInfer<B>>, BoundManifest<Contract>>>>;
+    }): InputCollector<BoardSpaceInputSchema, BoundState<Contract>, "board-space", BoardSpaceTarget<PerPlayerInstanceId<"board", B>, SpaceIdOfTable<BoundTable<Contract>, PlayerBoardRuntimeId<BoundTable<Contract>, B>, BoundManifest<Contract>>>>;
+};
+/**
+ * An eligibility predicate whose `errorCode` is checked against the model's
+ * declared error codes. The unbound `TargetPredicate` accepts any string.
+ */
+type BoundTargetPredicate<Contract extends ContractWithPhases, Target> = Omit<TargetPredicate<BoundState<Contract>, Target, BoundManifest<Contract>>, "errorCode"> & {
+    errorCode: ContractErrorCode<Contract>;
 };
-declare function defineEffect<Contract extends AnyReducerGameContract>(): {
-    <Id extends string, ContextSchema extends AnySchema = z.ZodObject<Record<string, never>, z.core.$strip>>(definition: EffectRollDieInput<Contract, Id, ContextSchema>): EffectRollDieDefinition<Id, ContextSchema, ContractState<Contract>, ContractManifest<Contract>>;
-    <Id extends string, ContextSchema extends AnySchema = z.ZodObject<Record<string, never>, z.core.$strip>>(definition: EffectShuffleInput<Contract, Id, ContextSchema>): EffectShuffleDefinition<Id, ContextSchema, ContractState<Contract>, ContractManifest<Contract>>;
-    <Id extends string, ContextSchema extends AnySchema = z.ZodObject<Record<string, never>, z.core.$strip>>(definition: EffectShufflePlayerZoneInput<Contract, Id, ContextSchema>): EffectShufflePlayerZoneDefinition<Id, ContextSchema, ContractState<Contract>, ContractManifest<Contract>>;
+type BoundWhere<Contract extends ContractWithPhases, Target> = BoundTargetPredicate<Contract, Target> | readonly BoundTargetPredicate<Contract, Target>[];
+type BoundCardCollector<Contract extends ContractWithPhases, Id extends string, ZoneIds extends readonly string[]> = InputCollector<z$1.ZodString, BoundState<Contract>, "card", Id> & {
+    readonly meta: {
+        readonly zoneId: ZoneIds[number];
+        readonly zoneIds: ZoneIds;
+        readonly targetKind: "card";
+    };
+};
+/**
+ * Card collector: the zones to draw candidates from and the predicates that
+ * filter them. The target rule is built internally.
+ */
+type BoundCardInput<Contract extends ContractWithPhases> = <const ZoneIds extends readonly ZoneIdOfTable<BoundTable<Contract>>[]>(options: {
+    from: ZoneIds;
+    where?: BoundWhere<Contract, CardIdOfManifest<BoundManifest<Contract>>>;
+}) => BoundCardCollector<Contract, CardIdOfManifest<BoundManifest<Contract>>, ZoneIds>;
+/** Tile instances in authored zones or exact runtime boards. */
+type BoundTileInput<Contract extends ContractWithPhases> = (options: ({
+    from: readonly ZoneIdOfTable<BoundTable<Contract>>[];
+    boards?: never;
+} | {
+    boards: readonly TiledBoardIdOfTable<BoundTable<Contract>, BoundManifest<Contract>>[];
+    from?: never;
+}) & {
+    where?: BoundWhere<Contract, TileIdOfTable<BoundTable<Contract>>>;
+}) => InputCollector<z$1.ZodType<TileIdOfTable<BoundTable<Contract>>>, BoundState<Contract>, "tile", TileIdOfTable<BoundTable<Contract>>>;
+/**
+ * An insertion point in one of the zones, in each host the player may reach.
+ * `tx.moveComponentToPosition` places a card there.
+ */
+type BoundPositionInput<Contract extends ContractWithPhases> = <const ZoneIds extends readonly ZoneIdOfTable<BoundTable<Contract>>[]>(options: {
+    zones: ZoneIds;
+}) => InputCollector<typeof PositionTargetSchema, BoundState<Contract>, "position", PositionTarget<ZoneIds[number]>> & {
+    readonly meta: {
+        readonly zoneIds: ZoneIds;
+    };
+};
+type BoundRngInputs<Contract extends ContractWithPhases> = {
+    d6(count?: number): ReturnType<typeof rngInput.d6<BoundState<Contract>>>;
+    coin(): ReturnType<typeof rngInput.coin<BoundState<Contract>>>;
+};
+type BoundInputBuilders<Contract extends ContractWithPhases> = {
+    readonly board: BoundBoardInputs<Contract>;
+    readonly card: BoundCardInput<Contract>;
+    readonly position: BoundPositionInput<Contract>;
+    readonly tile: BoundTileInput<Contract>;
+    readonly form: BoundFormInputs<Contract>;
+    readonly rng: BoundRngInputs<Contract>;
+};
+/** Preserve each phase kind's required fields while binding its state schema. */
+type PhaseDefinitionWithoutState<Definition> = Definition extends unknown ? Omit<Definition, "state"> : never;
+type PhaseAuthoring<Contract extends ContractWithPhases, PhaseStateSchema extends SchemaLike<object>> = {
+    steps(): InteractionSteps<BoundPhaseState<Contract, PhaseStateSchema>, Record<never, never>, BoundManifest<Contract>>;
+    interaction<Collectors extends Record<string, InputCollector>>(spec: Extract<InteractionSpec<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, ContractErrorCode<Contract>>, {
+        steps: unknown;
+    }>): Extract<InteractionSpec<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, ContractErrorCode<Contract>>, {
+        steps: unknown;
+    }>;
+    interaction<Collectors extends Record<string, InputCollector>>(spec: Extract<InteractionSpec<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, ContractErrorCode<Contract>>, {
+        inputs: unknown;
+    }>): Extract<InteractionSpec<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, ContractErrorCode<Contract>>, {
+        inputs: unknown;
+    }>;
+    rule<Collectors extends Record<string, InputCollector> = Record<string, InputCollector>>(rule: InteractionRule<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, ContractErrorCode<Contract>>): InteractionRule<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, ContractErrorCode<Contract>>;
+    define<SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Interactions extends InteractionMap<BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>> = Record<string, never>, const Kind extends "player" | "simultaneousPlayer" | "auto" = "player" | "simultaneousPlayer" | "auto">(definition: PhaseDefinitionWithoutState<PhaseDefinition<PhaseStateSchema, BoundState<Contract>, BoundManifest<Contract>, SubmitCollectors, Interactions, OptionsOfContract<Contract>, ContractErrorCode<Contract>>> & {
+        kind: Kind;
+    }): PhaseDefinition<PhaseStateSchema, BoundState<Contract>, BoundManifest<Contract>, SubmitCollectors, Interactions, OptionsOfContract<Contract>, ContractErrorCode<Contract>> & {
+        kind: Kind;
+    };
+    readonly inputs: BoundInputBuilders<Contract>;
+    /** Compile-time only. Reading any member at runtime throws. */
+    readonly types: PhaseTypes<Contract, PhaseStateSchema>;
+};
+/**
+ * Phantom type carriers for one phase: `typeof playing.types.State` is the
+ * phase-scoped game state (`state.phase` narrowed to this phase's schema).
+ */
+type PhaseTypes<Contract extends ContractWithPhases, PhaseStateSchema extends SchemaLike<object>> = {
+    readonly State: BoundPhaseState<Contract, PhaseStateSchema>;
+    readonly PhaseState: z$1.infer<PhaseStateSchema>;
+    readonly Tx: ReducerTransaction<BoundPhaseState<Contract, PhaseStateSchema>, ContractErrorCode<Contract>, BoundManifest<Contract>>;
+};
+/**
+ * Phantom type carriers for the whole game. These replace the
+ * `GameStateOf<GameContractOf<typeof model>>` chain: a module that has the
+ * bound game value can write `typeof game.types.State` and stop there.
+ */
+type ContractTypes<Contract extends ContractWithPhases> = {
+    readonly Contract: Contract;
+    readonly Options: OptionsOfContract<Contract>;
+    readonly State: BoundState<Contract>;
+    readonly Manifest: BoundManifest<Contract>;
+    readonly ErrorCode: ContractErrorCode<Contract>;
+    readonly PlayerId: PlayerIdOfState<BoundState<Contract>>;
+    readonly Queries: TableQueriesOfState<BoundState<Contract>, BoundManifest<Contract>>;
+    readonly Tx: ReducerTransaction<BoundState<Contract>, ContractErrorCode<Contract>, BoundManifest<Contract>>;
+};
+type GameAuthoring<Contract extends ContractWithPhases> = {
+    readonly contract: Contract;
+    view<Projection extends ViewData>(view: ViewDefinition<BoundState<Contract>, BoundManifest<Contract>, Projection>): ViewDefinition<BoundState<Contract>, BoundManifest<Contract>, Projection>;
+    /** Compile-time only. Reading any member at runtime throws. */
+    readonly types: ContractTypes<Contract>;
+    /** Assemble the final game definition from phases and the seat view. */
+    assemble<Definitions extends PhaseMapOf<Contract>, View extends ViewOfContract<Contract>>(definition: ReducerGameDefinitionInput<Contract, Definitions, View>): ReducerGameDefinition<Contract, Definitions, View>;
+    phase<Name extends keyof Contract["phases"] & string>(name: Name): PhaseAuthoring<Contract, Contract["phases"][Name]>;
 };
 
+/**
+ * Narrows a manifest's `literals.phaseNames` and `ids.phaseName` to the
+ * author-supplied phase-name tuple. Lets `defineGameContract` override the
+ * codegen-emitted `phaseNames: readonly string[]` / `phaseName: z.string()`
+ * placeholders so `PhaseNameOfContract<Contract>` resolves to a literal
+ * union and flows through `tx.transition`, `PhaseMapOf`, and the flow
+ * state's `currentPhase`.
+ */
+type NarrowManifestPhaseNames<Manifest, PhaseNames extends readonly string[]> = Manifest & {
+    literals: Manifest extends {
+        literals: infer L;
+    } ? Omit<L, "phaseNames"> & {
+        phaseNames: PhaseNames;
+    } : {
+        phaseNames: PhaseNames;
+    };
+    ids: Manifest extends {
+        ids: infer I;
+    } ? Omit<I, "phaseName"> & {
+        phaseName: z.ZodType<PhaseNames[number]>;
+    } : {
+        phaseName: z.ZodType<PhaseNames[number]>;
+    };
+};
+type ReducerGameContractInput<Table extends RuntimeTableRecord, Manifest extends ReducerManifestContract<Table, string, string, string, string>, PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>, Phases extends Record<string, SchemaLike<object>>, Errors extends Record<string, string> | undefined = undefined, OptionsSchema extends SchemaLike<RuntimeRecord> = SchemaLike<Record<string, never>>> = {
+    manifest: Manifest;
+    state: StateDefinition<PublicSchema, PrivateSchema, HiddenSchema>;
+    phases: Phases;
+    errors?: Errors;
+    options?: OptionsSchema;
+};
+type DefinedGameContract<Table extends RuntimeTableRecord, Manifest extends ReducerManifestContract<Table, string, string, string, string>, PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>, Phases extends Record<string, SchemaLike<object>>, Errors extends Record<string, string> | undefined = undefined, OptionsSchema extends SchemaLike<RuntimeRecord> = SchemaLike<Record<string, never>>> = ReducerGameContract<Table, NarrowManifestPhaseNames<Manifest, readonly (keyof Phases & string)[]>, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors, OptionsSchema> & {
+    readonly phases: Phases;
+    readonly errors: Errors;
+    readonly phaseNames: readonly (keyof Phases & string)[];
+};
+
+/** Bind a compiler-produced manifest to state schemas, phases and game assembly. */
+declare function createGame<Table extends RuntimeTableRecord, const Manifest extends ReducerManifestContract<Table, string, string, string, string> & CompiledManifestWitness<CompiledManifest<unknown>>, PublicSchema extends SchemaLike<object>, PrivateSchema extends SchemaLike<object>, HiddenSchema extends SchemaLike<object>, const Phases extends Record<string, SchemaLike<object>>, const Errors extends Record<string, string> | undefined = undefined, OptionsSchema extends SchemaLike<RuntimeRecord> = SchemaLike<Record<string, never>>>(model: ReducerGameContractInput<Table, Manifest, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors, OptionsSchema>): GameAuthoring<DefinedGameContract<Table, Manifest, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors, OptionsSchema>>;
+
 declare const gameEvent: {
     systemAction(event: Omit<SystemActionEvent, "kind">): SystemActionEvent;
 };
@@ -77,71 +478,601 @@ declare function sparseMap<KeySchema extends z.ZodType<string>, ValueSchema exte
 declare function sparseCounts<KeySchema extends z.ZodType<string>>(keySchema: KeySchema): z.ZodType<SparseCounts<z.infer<KeySchema>>>;
 declare function normalizeCommandParams<Output>(schema: SchemaLike<Output>, input: unknown): Output;
 
-declare function createTableQueries<Table extends RuntimeTableRecord>(table: Table): TableQueries<Table>;
-declare function createStateQueries<State extends {
-    table: RuntimeTableRecord;
-}>(state: State): TableQueriesOfState<State>;
-
 type InteractionDiagnosticsMode = "verbose" | undefined;
 
 type ReducerBundleOptions = {
-    /**
-     * Host-owned reducer diagnostics sink. Events are summarized and must not
-     * contain reducer state.
-     *
-     * The legacy `"verbose"` value is retained as an additive alias for
-     * descriptorDiagnostics while existing callers migrate.
-     */
     diagnostics?: ReducerDiagnosticsSink | InteractionDiagnosticsMode;
     descriptorDiagnostics?: InteractionDiagnosticsMode;
 };
 type ReducerBundle = ReducerBundleContract;
 
-/** The complete runner boundary. Authoring inspection stays SDK-owned. */
-declare function createReducerBundle<Contract extends ReducerGameContractLike, Definitions extends PhaseMapOf<Contract>, Views extends ViewMapOf<Contract>>(definition: ReducerGameDefinition<Contract, Definitions, Views>, options?: ReducerBundleOptions): ReducerBundle;
+/** The single validated production execution and projection boundary. */
+declare function createReducerBundle<Contract extends ReducerGameContractLike, Definitions extends PhaseMapOf<Contract>, View extends ViewOfContract<Contract>>(definition: ReducerGameDefinition<Contract, Definitions, View>, options?: ReducerBundleOptions): ReducerBundle;
+
+/** Cache a pure calculation by immutable object identity. Do not pass a mutable draft. */
+declare function memoize<A extends object, R>(fn: (a: A) => R): (a: A) => R;
 
-type FingerprintableContract = ReducerGameContractLike & {
-    phases?: Record<string, z.ZodTypeAny>;
-    errors?: Record<string, string> | undefined;
+declare function createTableQueries<Table extends RuntimeQueryTable, Definitions extends ZoneDefinitions>(table: Table, definitions: Definitions): TableQueries<Table, Definitions>;
+declare function createStateQueries<State extends {
+    table: RuntimeQueryTable;
+}, Definitions extends ZoneDefinitions>(state: State, definitions: Definitions): TableQueriesOfState<State, Definitions>;
+
+type GameTopologyManifest = SchemaAuthoring<GameTopologyManifest$1>;
+type ArrayItem<T> = T extends readonly (infer Item)[] ? Item : never;
+type EntryId<T> = T extends {
+    id: infer Id extends string;
+} ? Id : never;
+type IdsOf<T> = EntryId<ArrayItem<NonNullable<T>>>;
+type CardSetId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["cardSets"]>;
+type BoardId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["boards"]>;
+type PerPlayerBoardId<Manifest extends GameTopologyManifest> = EntryId<Extract<ArrayItem<NonNullable<Manifest["boards"]>>, {
+    scope: "perPlayer";
+}>>;
+type SharedBoardId<Manifest extends GameTopologyManifest> = Exclude<BoardId<Manifest>, PerPlayerBoardId<Manifest>>;
+type PieceTypeId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["pieceTypes"]>;
+type DieTypeId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["dieTypes"]>;
+type PieceSeedOf<Manifest extends GameTopologyManifest> = ArrayItem<NonNullable<Manifest["pieceSeeds"]>>;
+type DieSeedOf<Manifest extends GameTopologyManifest> = ArrayItem<NonNullable<Manifest["dieSeeds"]>>;
+type BoardOf<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["boards"]>>, {
+    id: CurrentBoardId;
+}>;
+type SpaceIdOf<BoardLike, Manifest> = BoardLike extends {
+    layout: "hex" | "square";
+} ? TileSpaceIds<Manifest, BoardLike["layout"]> : IdsOf<BoardLike extends {
+    spaces?: infer Spaces;
+} ? Spaces : never>;
+type SpaceIdForBoard<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = SpaceIdOf<BoardOf<Manifest, CurrentBoardId>, Manifest>;
+type PieceTypeOf<Manifest extends GameTopologyManifest, T extends PieceTypeId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["pieceTypes"]>>, {
+    id: T;
+}>;
+type DieTypeOf<Manifest extends GameTopologyManifest, T extends DieTypeId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["dieTypes"]>>, {
+    id: T;
+}>;
+type TypedSharedSpaceHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in SharedBoardId<Manifest>]: {
+        type: "space";
+        boardId: CurrentBoardId;
+        spaceId: SpaceIdForBoard<Manifest, CurrentBoardId>;
+    };
+}[SharedBoardId<Manifest>];
+type TypedPerPlayerSpaceHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
+        type: "space";
+        boardId: CurrentBoardId;
+        spaceId: SpaceIdForBoard<Manifest, CurrentBoardId>;
+    };
+}[PerPlayerBoardId<Manifest>];
+type TypedSharedEdgeHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in SharedBoardId<Manifest>]: {
+        type: "edge";
+        boardId: CurrentBoardId;
+        ref: SchemaAuthoring<BoardEdgeRef>;
+    };
+}[SharedBoardId<Manifest>];
+type TypedPerPlayerEdgeHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
+        type: "edge";
+        boardId: CurrentBoardId;
+        ref: SchemaAuthoring<BoardEdgeRef>;
+    };
+}[PerPlayerBoardId<Manifest>];
+type TypedSharedVertexHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in SharedBoardId<Manifest>]: {
+        type: "vertex";
+        boardId: CurrentBoardId;
+        ref: SchemaAuthoring<BoardVertexRef>;
+    };
+}[SharedBoardId<Manifest>];
+type TypedPerPlayerVertexHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
+        type: "vertex";
+        boardId: CurrentBoardId;
+        ref: SchemaAuthoring<BoardVertexRef>;
+    };
+}[PerPlayerBoardId<Manifest>];
+type ExpandedSeedId<Seed> = Seed extends {
+    typeId: infer T extends string;
+} ? RuntimeIdsFromCount<Seed extends {
+    id: infer I extends string;
+} ? I : T, Seed extends {
+    count: infer C;
+} ? C : never> : never;
+type ZoneHomeFor<Zone, Manifest extends GameTopologyManifest, Shared extends boolean> = Zone extends {
+    id: infer Z extends string;
+} ? Zone extends {
+    scope: "shared";
+} ? {
+    type: "zone";
+    zoneId: Z;
+    component?: never;
+} : Zone extends {
+    scope: "perPlayer";
+} ? Shared extends true ? never : {
+    type: "zone";
+    zoneId: Z;
+    component?: never;
+} : Zone extends {
+    attachedTo: {
+        board: infer B;
+    };
+} ? B extends SharedBoardId<Manifest> ? {
+    type: "zone";
+    zoneId: Z;
+    component?: never;
+} : Shared extends true ? never : {
+    type: "zone";
+    zoneId: Z;
+    component?: never;
+} : Zone extends {
+    attachedTo: {
+        pieceType: infer T;
+    };
+} ? ComponentZoneHome<Z, Extract<PieceSeedOf<Manifest>, {
+    typeId: T;
+}>, Shared> : Zone extends {
+    attachedTo: {
+        dieType: infer T;
+    };
+} ? ComponentZoneHome<Z, Extract<DieSeedOf<Manifest>, {
+    typeId: T;
+}>, Shared> : Zone extends {
+    attachedTo: {
+        tileType: infer T;
+    };
+} ? ComponentZoneHome<Z, Extract<ArrayItem<Manifest["tileSeeds"]>, {
+    typeId: T;
+}>, Shared> : never : never;
+type ComponentZoneHome<Z extends string, Seed, Shared extends boolean> = (Shared extends true ? Exclude<Seed, {
+    scope: "perPlayer";
+}> : Seed) extends infer Host ? Host extends object ? {
+    type: "zone";
+    zoneId: Z;
+    component: ExpandedSeedId<Host>;
+} : never : never;
+type TypedSharedZoneHomeSpec<Manifest extends GameTopologyManifest> = ZoneHomeFor<ArrayItem<NonNullable<Manifest["zones"]>>, Manifest, true>;
+type TypedPerPlayerZoneHomeSpec<Manifest extends GameTopologyManifest> = ZoneHomeFor<ArrayItem<NonNullable<Manifest["zones"]>>, Manifest, false>;
+type TypedPlayerScopedComponentHomeSpec<Manifest extends GameTopologyManifest> = TypedPerPlayerZoneHomeSpec<Manifest> | TypedPerPlayerSpaceHomeSpec<Manifest> | TypedPerPlayerEdgeHomeSpec<Manifest> | TypedPerPlayerVertexHomeSpec<Manifest>;
+type TypedSharedComponentHomeSpec<Manifest extends GameTopologyManifest> = {
+    type: "detached";
+} | TypedSharedZoneHomeSpec<Manifest> | TypedSharedSpaceHomeSpec<Manifest> | TypedSharedEdgeHomeSpec<Manifest> | TypedSharedVertexHomeSpec<Manifest>;
+type TypedComponentHomeSpec<Manifest extends GameTopologyManifest> = TypedSharedComponentHomeSpec<Manifest> | TypedPlayerScopedComponentHomeSpec<Manifest>;
+type TypedSeedLocationSpec<Seed, Manifest extends GameTopologyManifest> = Omit<Seed, "home"> & {
+    home?: Seed extends {
+        scope: "perPlayer";
+    } ? TypedComponentHomeSpec<Manifest> : TypedSharedComponentHomeSpec<Manifest>;
+};
+type AuthoredComponent<T> = Omit<T, "ownerId" | "visibility"> & {
+    ownerId?: never;
+    visibility?: {
+        faceUp?: boolean;
+        visibleTo?: never;
+    };
 };
-type FingerprintableDefinition = {
-    contract: FingerprintableContract;
-    phases?: Record<string, z.ZodTypeAny | {
-        state?: z.ZodTypeAny;
+type TypedFields<T, Schema, Manifest extends GameTopologyManifest, BoardLike = never> = T extends {
+    fields?: unknown;
+} ? Omit<T, "fields"> & {
+    fields?: FieldsInput<Schema, Manifest, BoardLike>;
+} : T;
+type TypedBoardRelation<Relation, Manifest extends GameTopologyManifest, BoardLike, RelationSchema> = Relation extends object ? Omit<TypedFields<Relation, RelationSchema, Manifest, BoardLike>, "fromSpaceId" | "toSpaceId"> & {
+    fromSpaceId: SpaceIdOf<BoardLike, Manifest>;
+    toSpaceId: SpaceIdOf<BoardLike, Manifest>;
+} : Relation;
+type TypedOptionalArray<Base, Source, Key extends string, Item> = Source extends {
+    [Property in Key]?: readonly unknown[];
+} ? Base & {
+    [Property in Key]?: ReadonlyArray<Item>;
+} : Base;
+type SchemaForEntry<Entry, Key extends string> = Key extends keyof Entry ? Entry[Key] : undefined;
+type TypedGenericBoardLike<Entry, Manifest extends GameTopologyManifest, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "relations">, SchemaForEntry<Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
+    spaces?: infer S;
+} ? S : never>>, SchemaForEntry<Entry, "spaceFieldsSchema">, Manifest, BoardLike>>, Entry, "relations", TypedBoardRelation<ArrayItem<NonNullable<Entry extends {
+    relations?: infer R;
+} ? R : never>>, Manifest, BoardLike, SchemaForEntry<Entry, "relationFieldsSchema">>>;
+type AuthoredKeys<T> = {
+    [K in keyof T]-?: Record<never, never> extends Pick<T, K> ? [Exclude<T[K], undefined>] extends [never] ? never : K : K;
+}[keyof T];
+type TypedBoardLikeEntry<Entry, Manifest extends GameTopologyManifest> = "containers" | "containerFieldsSchema" | "shape" | "exclude" | "edges" | "vertices" | "edgeFieldsSchema" | "vertexFieldsSchema" extends infer Legacy ? Extract<Legacy, AuthoredKeys<Entry>> extends never ? Entry extends {
+    layout: "generic";
+} ? TypedGenericBoardLike<Entry, Manifest, Entry> : "spaces" | "spaceFieldsSchema" extends infer Geometry ? Extract<Geometry, AuthoredKeys<Entry>> extends never ? TypedFields<Entry, SchemaForEntry<Entry, "boardFieldsSchema">, Manifest, Entry> : never : never : never : never;
+type AuthoredCardType<Card> = Card extends {
+    cardType: infer Category extends string;
+} ? Category : never;
+type TypedCard<Card, Manifest extends GameTopologyManifest, CardSchema> = Card extends {
+    id: string;
+    cardType: string;
+} ? Omit<AuthoredComponent<Card>, "home" | "properties"> & {
+    home?: Card extends {
+        scope: "perPlayer";
+    } ? TypedComponentHomeSpec<Manifest> : TypedSharedComponentHomeSpec<Manifest>;
+    properties: CardSchema extends {
+        byCardType: infer Variants extends Record<string, unknown>;
+    } ? AuthoredCardType<Card> extends keyof Variants ? FieldsInput<Variants[AuthoredCardType<Card>], Manifest> : never : FieldsInput<CardSchema, Manifest>;
+} : Card;
+type TypedCardSet<CardSet, Manifest extends GameTopologyManifest> = CardSet extends {
+    cardSchema: infer CardSchema;
+    cards: infer Cards extends readonly unknown[];
+} ? Omit<CardSet, "cards" | "defaultHome"> & {
+    defaultHome: TypedComponentHomeSpec<Manifest>;
+    cards: ReadonlyArray<TypedCard<ArrayItem<Cards>, Manifest, CardSchema>>;
+} : CardSet;
+type TypedAllowedCardSetIds<T, Manifest extends GameTopologyManifest> = T extends object ? Omit<T, "allowedCardSetIds"> & {
+    allowedCardSetIds?: readonly CardSetId<Manifest>[];
+} : T;
+type TypedZone<Zone, Manifest extends GameTopologyManifest> = TypedAllowedCardSetIds<Zone, Manifest> & (Zone extends {
+    attachedTo: infer A;
+} ? {
+    attachedTo: A extends {
+        board: infer B;
+    } ? B extends BoardId<Manifest> ? A extends {
+        space: unknown;
+    } ? BoardOf<Manifest, B> extends {
+        layout: "generic";
+    } ? {
+        board: B;
+        space: SpaceIdForBoard<Manifest, B>;
+    } : never : {
+        board: B;
+    } : never : A extends {
+        pieceType: unknown;
+    } ? {
+        pieceType: PieceTypeId<Manifest>;
+    } : A extends {
+        dieType: unknown;
+    } ? {
+        dieType: DieTypeId<Manifest>;
+    } : A extends {
+        tileType: infer T;
+    } ? {
+        tileType: T;
+        cell: IdsOf<Extract<ArrayItem<Manifest["tileTypes"]>, {
+            id: T;
+        }>["cells"]>;
+    } : never;
+} : unknown);
+type TypedPieceSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends {
+    typeId: infer CurrentTypeId;
+} ? CurrentTypeId extends PieceTypeId<Manifest> ? Omit<TypedSeedLocationSpec<AuthoredComponent<Seed>, Manifest>, "typeId" | "home" | "fields"> & {
+    typeId: CurrentTypeId;
+    fields?: FieldsInput<PieceTypeOf<Manifest, CurrentTypeId> extends {
+        fieldsSchema?: infer FieldsSchema;
+    } ? FieldsSchema : undefined, Manifest>;
+} & Pick<TypedSeedLocationSpec<AuthoredComponent<Seed>, Manifest>, "home"> : Omit<Seed, "typeId"> & {
+    typeId: PieceTypeId<Manifest>;
+} : never;
+type TypedDieSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends {
+    typeId: infer CurrentTypeId;
+} ? CurrentTypeId extends DieTypeId<Manifest> ? Omit<TypedSeedLocationSpec<AuthoredComponent<Seed>, Manifest>, "typeId" | "home" | "fields"> & {
+    typeId: CurrentTypeId;
+    fields?: FieldsInput<DieTypeOf<Manifest, CurrentTypeId> extends {
+        fieldsSchema?: infer FieldsSchema;
+    } ? FieldsSchema : undefined, Manifest>;
+} & Pick<TypedSeedLocationSpec<AuthoredComponent<Seed>, Manifest>, "home"> : Omit<Seed, "typeId"> & {
+    typeId: DieTypeId<Manifest>;
+} : never;
+type TileTypeId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["tileTypes"]>;
+type TypedTileType<T, Manifest extends GameTopologyManifest> = T extends object ? Omit<TypedFields<T, SchemaForEntry<T, "fieldsSchema">, Manifest>, "cells" | "edges" | "vertices"> & {
+    cells: ReadonlyArray<TypedFields<ArrayItem<T extends {
+        cells: infer C;
+    } ? C : never>, SchemaForEntry<T, "cellFieldsSchema">, Manifest>>;
+    edges?: ReadonlyArray<TypedFields<ArrayItem<T extends {
+        edges?: infer E;
+    } ? E : never>, SchemaForEntry<T, "edgeFieldsSchema">, Manifest> & {
+        cellId: IdsOf<T extends {
+            cells: infer C;
+        } ? C : never>;
     }>;
+    vertices?: ReadonlyArray<TypedFields<ArrayItem<T extends {
+        vertices?: infer V;
+    } ? V : never>, SchemaForEntry<T, "vertexFieldsSchema">, Manifest> & {
+        cellId: IdsOf<T extends {
+            cells: infer C;
+        } ? C : never>;
+    }>;
+} : never;
+type TileBoardHome<Seed, Manifest extends GameTopologyManifest, T> = ArrayItem<Manifest["boards"]> extends infer B ? B extends {
+    id: infer I;
+    layout: infer L extends "hex" | "square";
+} ? Extract<ArrayItem<Manifest["tileTypes"]>, {
+    id: T;
+}> extends {
+    layout: L;
+} ? Seed extends {
+    scope: "perPlayer";
+} ? TileBoardCoordinates<L> & {
+    type: "board";
+    boardId: I;
+    layout: L;
+} : B extends {
+    scope: "shared";
+} ? TileBoardCoordinates<L> & {
+    type: "board";
+    boardId: I;
+    layout: L;
+} : never : never : never : never;
+type TileBoardCoordinates<L> = L extends "hex" ? {
+    q: number;
+    r: number;
+    rotation: 0 | 1 | 2 | 3 | 4 | 5;
+} : {
+    col: number;
+    row: number;
+    rotation: 0 | 1 | 2 | 3;
 };
-type ContractFingerprint = {
-    /** "cfp1:" + first 16 hex chars of sha256 over the canonical payload. */
-    value: string;
-    /** Component hashes that fed the final fingerprint. */
-    parts: {
-        manifest: string;
-        publicState: string;
-        privateState: string;
-        hiddenState: string;
-        phases: Record<string, string>;
-        errors: string;
-    };
+type TypedTileSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends {
+    typeId: infer T;
+} ? Omit<Seed, "typeId" | "properties" | "home" | "ownerId" | "visibility" | "disclosure"> & {
+    ownerId?: never;
+    visibility?: never;
+    disclosure?: SchemaAuthoring<AuthoredTileDisclosure>;
+    typeId: TileTypeId<Manifest>;
+    properties?: FieldsInput<SchemaForEntry<Extract<ArrayItem<Manifest["tileTypes"]>, {
+        id: T;
+    }>, "propertiesSchema">, Manifest>;
+    home?: {
+        type: "detached";
+    } | TileBoardHome<Seed, Manifest, T> | ZoneHomeFor<ArrayItem<NonNullable<Manifest["zones"]>>, Manifest, Seed extends {
+        scope: "perPlayer";
+    } ? false : true>;
+} : never;
+type TypedTopologyManifest<Manifest extends GameTopologyManifest> = Omit<Manifest, "cardSets" | "zones" | "boards" | "pieceTypes" | "dieTypes" | "pieceSeeds" | "dieSeeds" | "tileTypes" | "tileSeeds"> & {
+    tileTypes?: ReadonlyArray<TypedTileType<ArrayItem<Manifest["tileTypes"]>, Manifest>>;
+    tileSeeds?: ReadonlyArray<TypedTileSeed<ArrayItem<Manifest["tileSeeds"]>, Manifest>>;
+    pieceTypes?: ReadonlyArray<ArrayItem<Manifest["pieceTypes"]> extends infer T ? "slots" extends keyof T ? never : T : never>;
+    dieTypes?: ReadonlyArray<ArrayItem<Manifest["dieTypes"]> extends infer T ? "slots" extends keyof T ? never : T : never>;
+    cardSets: ReadonlyArray<TypedCardSet<ArrayItem<Manifest["cardSets"]>, Manifest>>;
+    zones?: Manifest["zones"] extends readonly unknown[] ? ReadonlyArray<TypedZone<ArrayItem<Manifest["zones"]>, Manifest>> : Manifest["zones"];
+    boards?: Manifest["boards"] extends readonly unknown[] ? ReadonlyArray<TypedBoardLikeEntry<ArrayItem<Manifest["boards"]>, Manifest>> : Manifest["boards"];
+    pieceSeeds?: Manifest["pieceSeeds"] extends readonly unknown[] ? ReadonlyArray<TypedPieceSeed<ArrayItem<Manifest["pieceSeeds"]>, Manifest>> : Manifest["pieceSeeds"];
+    dieSeeds?: Manifest["dieSeeds"] extends readonly unknown[] ? ReadonlyArray<TypedDieSeed<ArrayItem<Manifest["dieSeeds"]>, Manifest>> : Manifest["dieSeeds"];
 };
-/**
- * Compute a stable shape fingerprint for stale generated artifacts.
- *
- * The fingerprint intentionally tracks decoded shape, not semantic refinements:
- * Zod schemas are converted with `unrepresentable: "any"`, so refinements and
- * custom validators that do not affect the JSON shape do not invalidate stored
- * sessions or generated base states.
- */
-declare function contractFingerprint(source: FingerprintableContract | FingerprintableDefinition): ContractFingerprint;
+type TopologyManifestValidation<Manifest> = Manifest extends GameTopologyManifest ? TypedTopologyManifest<Manifest> : GameTopologyManifest;
+declare function defineTopologyManifest<const Manifest>(manifest: Manifest & TopologyManifestValidation<NoInfer<Manifest>> & ManifestCountValidation<NoInfer<Manifest>>): ValidatedManifest<Manifest>;
+
+type JsonManifestInput = ReadonlyRuntimeData<GameTopologyManifest$1>;
+type ManifestDocumentInput = AuthoredManifest | ValidatedManifest | JsonManifestInput;
+type ManifestAdmission<M> = [M] extends [ValidatedManifest<unknown>] ? unknown : [M] extends [ManifestDocumentInput] ? AuthoredManifest extends M ? unknown : M extends AuthoredManifest ? TypedTopologyManifest<M> : unknown : ManifestDocumentInput;
+type ManifestInput<M> = M & ManifestCountValidation<NoInfer<M>> & ManifestAdmission<NoInfer<M>>;
+/** Compile authored topology once, in memory, with the same validation used by initialization. */
+declare function compileManifest<const M>(manifest: ManifestInput<M>): CompiledManifest<AuthoredOf<M>>;
 
-declare function assertCardAllowedInContainer<Table extends RuntimeTableRecord, BoardId extends BoardIdOfTable<NoInfer<Table>>, ContainerId extends BoardContainerIdOfTable<NoInfer<Table>, BoardId>>(table: Table, boardId: BoardId, containerId: ContainerId, componentId: string): void;
+/** Admit an external JSON document using the SDK's structural and semantic contract. */
+declare function parseTopologyManifestJson(value: unknown): GameTopologyManifest$1;
 
-declare function setActivePlayers<State extends {
-    flow: {
-        activePlayers: PlayerIdOfState<State>[];
+type Coordinate = {
+    readonly q: number;
+    readonly r: number;
+};
+type TileIdentity = {
+    readonly boardId: string;
+    readonly tileTypeId: string;
+    readonly tileId: string;
+    readonly name?: string;
+};
+type CoordinateCell<C extends Coordinate> = C extends Coordinate ? {
+    id: `${C["q"]},${C["r"]}`;
+    at: {
+        q: C["q"];
+        r: C["r"];
     };
-}>(state: State, activePlayers: PlayerIdOfState<State>[]): State;
+} : never;
+/** Fixed boards use the same definitions and seeded placements as movable inventory. */
+declare function fromCoordinates<const Options extends TileIdentity & {
+    readonly coordinates: readonly Coordinate[];
+}>(options: Options): {
+    tileTypes: {
+        id: Options["tileTypeId"];
+        name: string;
+        layout: "hex";
+        cells: CoordinateCell<Options["coordinates"][number]>[];
+    }[];
+    tileSeeds: {
+        id: Options["tileId"];
+        typeId: Options["tileTypeId"];
+        home: {
+            type: "board";
+            boardId: Options["boardId"];
+            layout: "hex";
+            q: number;
+            r: number;
+            rotation: 0;
+        };
+    }[];
+};
+type RadiusOptions = TileIdentity & {
+    readonly radius: number;
+    readonly center?: Coordinate;
+};
+declare function hexagon<const Options extends RadiusOptions>(options: Options): {
+    tileTypes: {
+        id: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileTypeId"];
+        name: string;
+        layout: "hex";
+        cells: CoordinateCell<(Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["coordinates"][number]>[];
+    }[];
+    tileSeeds: {
+        id: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileId"];
+        typeId: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileTypeId"];
+        home: {
+            type: "board";
+            boardId: (Options & {
+                readonly coordinates: {
+                    q: number;
+                    r: number;
+                }[];
+            })["boardId"];
+            layout: "hex";
+            q: number;
+            r: number;
+            rotation: 0;
+        };
+    }[];
+};
+declare function spiral<const Options extends RadiusOptions>(options: Options): {
+    tileTypes: {
+        id: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileTypeId"];
+        name: string;
+        layout: "hex";
+        cells: CoordinateCell<(Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["coordinates"][number]>[];
+    }[];
+    tileSeeds: {
+        id: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileId"];
+        typeId: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileTypeId"];
+        home: {
+            type: "board";
+            boardId: (Options & {
+                readonly coordinates: {
+                    q: number;
+                    r: number;
+                }[];
+            })["boardId"];
+            layout: "hex";
+            q: number;
+            r: number;
+            rotation: 0;
+        };
+    }[];
+};
+declare function ring<const Options extends RadiusOptions>(options: Options): {
+    tileTypes: {
+        id: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileTypeId"];
+        name: string;
+        layout: "hex";
+        cells: CoordinateCell<(Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["coordinates"][number]>[];
+    }[];
+    tileSeeds: {
+        id: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileId"];
+        typeId: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileTypeId"];
+        home: {
+            type: "board";
+            boardId: (Options & {
+                readonly coordinates: {
+                    q: number;
+                    r: number;
+                }[];
+            })["boardId"];
+            layout: "hex";
+            q: number;
+            r: number;
+            rotation: 0;
+        };
+    }[];
+};
+declare function rectangle<const Options extends TileIdentity & {
+    readonly width: number;
+    readonly height: number;
+    readonly start?: Coordinate;
+}>(options: Options): {
+    tileTypes: {
+        id: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileTypeId"];
+        name: string;
+        layout: "hex";
+        cells: CoordinateCell<(Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["coordinates"][number]>[];
+    }[];
+    tileSeeds: {
+        id: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileId"];
+        typeId: (Options & {
+            readonly coordinates: {
+                q: number;
+                r: number;
+            }[];
+        })["tileTypeId"];
+        home: {
+            type: "board";
+            boardId: (Options & {
+                readonly coordinates: {
+                    q: number;
+                    r: number;
+                }[];
+            })["boardId"];
+            layout: "hex";
+            q: number;
+            r: number;
+            rotation: 0;
+        };
+    }[];
+};
 
-/** Compile authored topology once, in memory, with the same validation used by initialization. */
-declare function compileManifest<const M extends AuthoredManifest>(manifest: M): CompiledManifest<M>;
+type MaterializeOptions = {
+    manifest: GameTopologyManifest$1;
+    playerIds: readonly string[];
+    shuffleItems: <Value>(values: readonly Value[]) => Value[];
+};
+/** Construct actual session inventory; references use the supplied live roster. */
+declare function materializeManifestTable(options: MaterializeOptions): Record<string, unknown>;
 
-export { AuthoredManifest, type CardTargetPredicate, CompiledManifest, type ContractFingerprint, type ManyOptions, type ReducerBundle, type ReducerBundleOptions, ReducerDiagnosticsSink, ReducerGameDefinition, type SparseCounts, type SparseMap, SystemActionEvent, TableQueries, TableQueriesOfState, TargetPredicate, assertCardAllowedInContainer, compileManifest, contractFingerprint, createReducerBundle, createStateQueries, createTableQueries, defineEffect, gameEvent, many, normalizeCommandParams, setActivePlayers, sparseCounts, sparseMap };
+export { AuthoredManifest, AuthoredTileDisclosure, BoardSpaceTarget, type BoardTargetPredicate, type BoundInputBuilders, type BoundTargetPredicate, type CardTargetPredicate, type ChoiceOptionsFactory, type ChoiceTargetOption, type ChoiceTargetPredicate, CompiledManifest, type ContractTypes, FieldsInput, type GameAuthoring, GameTopologyManifest$1 as GameTopologyManifest, InteractionRule, type ManyOptions, PerPlayerInstanceId, type PhaseAuthoring, type PhaseTypes, PositionTarget, type ReducerBundle, ReducerBundleContract, type ReducerBundleOptions, ReducerDiagnosticsSink, ReducerGameDefinition, ReducerGameDefinitionInput, ReducerTransaction, type SparseCounts, type SparseMap, SystemActionEvent, TableQueries, TableQueriesOfState, type TargetContext, type TargetPredicate, type TargetPredicateArgs, type TileTargetPredicate, type TypedTopologyManifest, ValidatedManifest, compileManifest, createGame, createReducerBundle, createStateQueries, createTableQueries, defineTopologyManifest, fromCoordinates, gameEvent, hexagon, many, materializeManifestTable, memoize, normalizeCommandParams, parseTopologyManifestJson, rectangle, ring, sparseCounts, sparseMap, spiral };