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

package/dist/reducer.d.ts

@@ -1,19 +1,238 @@
-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 { Y as ManifestIdSchema, aF as SchemaLike, h as CollectorState, t as InputCollector, a8 as PlayerIdOfState, aO as TableQueriesOfState, x as InputSelectionDescriptor, ah as ReducerManifestContractLike, aC as RuntimeTableRecord, az as RuntimeRecord$1, aK as StateDefinition, X as ManifestContractOf, B as BaseGameStateOfContract, E as ErrorCodeOfContract, aS as TiledVertexIdOfTable, aM as TableOfManifest, aP as TiledBoardIdOfTable, aQ as TiledEdgeIdOfTable, aR as TiledSpaceIdOfTable, C as CardIdOfManifest, _ as OptionsOfContract, al as ReducerTransaction, aV as ViewData, aW as ViewDefinition, a4 as PhaseMapOf, aX as ViewOfContract, af as ReducerGameDefinition, a5 as PhaseNameOfContract, V as InteractionSteps, aG as ScopedPhaseState, T as InteractionSpec, S as InteractionRule, R as InteractionMap, a3 as PhaseDefinition, a7 as PhaseSchemasOfContract, p as GameTopologyManifest$2, D as DieTypeSpec$2, f as Brand, ag as ReducerManifestContract, at as RuntimeHexBoardState, Z as ObjectSchema, aa as PropertySchema, ax as RuntimePayload, H as HexEdgeId, r as HexVertexId, q as HexSpaceId, aA as RuntimeSquareBoardState, as as RuntimeGenericBoardState, ap as RuntimeBoardState, aq as RuntimeCardData, ay as RuntimePieceData, ar as RuntimeDieData, ad as ReducerGameContract, aL as SystemActionEvent, aN as TableQueries, ae as ReducerGameContractLike, c as BoardIdOfTable, a as BoardContainerIdOfTable, b as BoardEdgeRef, e as BoardVertexRef, W as JsonValue } from './definition-BaHNPZol.js';
+export { F as FrameworkErrorCodes, G as GameEvent, k as GameEventDetail, m as GameOutcome, $ as OutcomeResult, a0 as OutcomeScoreComponent, a1 as OutcomeStanding, a2 as OutcomeTieBreak, ab as ReducerAccept, ai as ReducerReject, aj as ReducerResult, am as ReducerTransactionOutcome, an as ReducerValidationResult, b2 as ReducerWire, b1 as ReducerWireZod, ao as RotatePlayerZoneArgs, aJ as SquareBoardSpec, aT as ValidationIssue, aZ as fromCoordinates, a_ as hexagon, a$ as rectangle, b0 as ring, b3 as spiral } from './definition-BaHNPZol.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';
+import { a as ReducerBundleContract, c as ReducerDiagnosticsSink } from './diagnostics-B0lgnuZ6.js';
+export { D as DispatchTraceSummaryEntry, M as MaybePromise, R as REDUCER_CONTRACT_VERSION, b as ReducerDiagnosticEvent, d as assertReducerBundleContract, n as noopDiagnosticsSink } from './diagnostics-B0lgnuZ6.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 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>): InputCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, "form">;
+declare function resourceMapInput<State extends CollectorState = CollectorState>(options: ResourceMapInputOptions<State> & {
+    defaultValue: Record<string, number>;
+}): InputCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, "form"> & {
+    readonly defaultValue: Record<string, number>;
+};
+declare function numberInput<State extends CollectorState = CollectorState>(options: {
+    min: DomainNumber<State>;
+    max: DomainNumber<State>;
+    step?: DomainNumber<State>;
+}): InputCollector<z.ZodNumber, State, "form">;
+declare function numberInput<State extends CollectorState = CollectorState>(options: {
+    min: DomainNumber<State>;
+    max: DomainNumber<State>;
+    step?: DomainNumber<State>;
+    defaultValue: number;
+}): InputCollector<z.ZodNumber, State, "form"> & {
+    readonly defaultValue: number;
+};
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    defaultValue: Value;
+}): InputCollector<SchemaLike<Value>, State, "form"> & {
+    readonly defaultValue: Value;
+};
+declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    defaultValue: ChoiceDefaultResolver<Value, State>;
+}): InputCollector<SchemaLike<Value>, State, "form">;
+declare function choiceListInput<Value extends string, State extends CollectorState = CollectorState>(options: {
+    choices: DomainChoices<Value, State>;
+    min?: DomainNumber<State>;
+    max?: DomainNumber<State>;
+    defaultValue: Value[];
+}): InputCollector<SchemaLike<Value[]>, State, "form"> & {
+    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>;
+}): InputCollector<SchemaLike<Value[]>, State, "form">;
+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>): InputCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, "form">;
+    resourceMap(options: ResourceMapInputOptions<State> & {
+        defaultValue: Record<string, number>;
+    }): InputCollector<z.ZodRecord<z.ZodString, z.ZodNumber>, State, "form"> & {
+        readonly defaultValue: Record<string, number>;
+    };
+    resourceChoices(options?: {
+        decorate?: ResourceMapChoiceDecorator<State>;
+    }): ResourceMapChoiceSource<State>;
+    number(options: Parameters<typeof numberInput<State>>[0]): ReturnType<typeof numberInput<State>>;
+    choice<Value extends ChoiceValue>(options: {
+        choices: DomainChoices<Value, State>;
+        defaultValue: Value;
+    }): InputCollector<SchemaLike<Value>, State, "form"> & {
+        readonly defaultValue: Value;
+    };
+    choice<Value extends ChoiceValue>(options: {
+        choices: DomainChoices<Value, State>;
+        defaultValue: ChoiceDefaultResolver<Value, State>;
+    }): InputCollector<SchemaLike<Value>, State, "form">;
+    choiceList<Value extends string>(options: {
+        choices: DomainChoices<Value, State>;
+        min?: DomainNumber<State>;
+        max?: DomainNumber<State>;
+        defaultValue: Value[];
+    }): InputCollector<SchemaLike<Value[]>, State, "form"> & {
+        readonly defaultValue: Value[];
+    };
+    choiceList<Value extends string>(options: {
+        choices: DomainChoices<Value, State>;
+        min?: DomainNumber<State>;
+        max?: DomainNumber<State>;
+        defaultValue?: ChoiceListDefaultValue<Value, State>;
+    }): InputCollector<SchemaLike<Value[]>, State, "form">;
+};
+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> = {
+    state: State;
+    playerId: PlayerIdOfState<State>;
+    q: TableQueriesOfState<State>;
+};
+type TargetPredicateArgs<State extends CollectorState, Target> = TargetContext<State> & {
+    targetId: Target;
+    target: Target;
+};
+type TargetPredicate<State extends CollectorState, Target> = {
+    id: string;
+    errorCode: string;
+    message?: string;
+    test: (args: TargetPredicateArgs<State, Target>) => boolean;
+};
+
+type BoardTargetPredicate<State extends CollectorState, Target> = TargetPredicate<State, Target>;
+type PlayerBoardSpaceTarget<BoardId extends string, SpaceId extends string, PlayerId extends string> = {
+    readonly boardId: BoardId;
+    readonly playerId: PlayerId;
+    readonly spaceId: SpaceId;
+};
+
+type PlayerSpaceInputSchema<BoardId extends string, SpaceId extends string, PlayerId extends string> = z.ZodObject<{
+    boardId: z.ZodLiteral<BoardId>;
+    playerId: ManifestIdSchema<PlayerId, "playerId">;
+    spaceId: z.ZodType<SpaceId>;
+}>;
 
 type CardTargetPredicate<State extends CollectorState, Id extends string> = TargetPredicate<State, Id>;
 
+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;
     distinct?: boolean;
@@ -43,30 +262,517 @@ type ManyInputCollector<Schema extends SchemaLike<unknown> = SchemaLike<unknown>
 };
 declare function many<Collector extends NonRngCollector>(collector: Collector, options: ManyOptions): ManyInputCollector<CollectorSchema<Collector>, CollectorStateOf<Collector>, CollectorKindOf<Collector>> & Pick<Collector, "meta">;
 
-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 AnyReducerGameContract = {
+    manifest: ReducerManifestContractLike<RuntimeTableRecord>;
+    options: SchemaLike<RuntimeRecord$1>;
+    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.infer<PhaseStateSchema>>;
+type BoundFormInputs<Contract extends ContractWithPhases> = ReturnType<typeof formInput.forState<BoundState<Contract>>>;
+/** Board element collector options: the board and the predicates that filter it. */
+type BoundBoardInputOptions<Contract extends ContractWithPhases, Id> = {
+    boardId: string;
+    where?: BoundWhere<Contract, Id>;
+};
+type BoundBoardInputs<Contract extends ContractWithPhases> = {
+    vertex<Id extends string = TiledVertexIdOfTable<BoundTable<Contract>, TiledBoardIdOfTable<BoundTable<Contract>>>>(options: BoundBoardInputOptions<Contract, Id>): InputCollector<z.ZodType<Id>, BoundState<Contract>, "board-vertex">;
+    edge<Id extends string = TiledEdgeIdOfTable<BoundTable<Contract>, TiledBoardIdOfTable<BoundTable<Contract>>>>(options: BoundBoardInputOptions<Contract, Id>): InputCollector<z.ZodType<Id>, BoundState<Contract>, "board-edge">;
+    tile<Id extends string = string>(options: BoundBoardInputOptions<Contract, Id>): InputCollector<z.ZodType<Id>, BoundState<Contract>, "board-tile">;
+    space<Id extends string = TiledSpaceIdOfTable<BoundTable<Contract>, TiledBoardIdOfTable<BoundTable<Contract>>>>(options: BoundBoardInputOptions<Contract, Id>): InputCollector<z.ZodType<Id>, BoundState<Contract>, "board-space">;
+    playerSpace<BoardId extends string = string, SpaceId extends string = string, PlayerId extends string = PlayerIdOfState<BoundState<Contract>>>(options: {
+        boardId: BoardId;
+        where?: BoundWhere<Contract, PlayerBoardSpaceTarget<BoardId, SpaceId, PlayerId>>;
+    }): InputCollector<PlayerSpaceInputSchema<BoardId, SpaceId, PlayerId>, BoundState<Contract>, "board-space">;
+};
+/**
+ * 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>, "errorCode"> & {
+    errorCode: ContractErrorCode<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.ZodType<Id>, BoundState<Contract>, "card"> & {
+    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> = <Id extends string = CardIdOfManifest<BoundManifest<Contract>>, const ZoneIds extends readonly string[] = readonly string[]>(options: {
+    from: ZoneIds;
+    where?: BoundWhere<Contract, Id>;
+}) => BoundCardCollector<Contract, Id, 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 form: BoundFormInputs<Contract>;
+    readonly rng: BoundRngInputs<Contract>;
+};
+type PhaseAuthoring<Contract extends ContractWithPhases, PhaseStateSchema extends SchemaLike<object>> = {
+    steps(): InteractionSteps<BoundPhaseState<Contract, PhaseStateSchema>>;
+    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: Omit<PhaseDefinition<PhaseStateSchema, BoundState<Contract>, BoundManifest<Contract>, SubmitCollectors, Interactions, OptionsOfContract<Contract>, ContractErrorCode<Contract>>, "state"> & {
+        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.infer<PhaseStateSchema>;
+    readonly Tx: ReducerTransaction<BoundPhaseState<Contract, PhaseStateSchema>, ContractErrorCode<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>>;
+    readonly Tx: ReducerTransaction<BoundState<Contract>, ContractErrorCode<Contract>>;
+};
+/**
+ * Rejects phase keys the model did not declare. `PhaseMapOf<Contract>` already
+ * requires every declared phase; this closes the other direction so an extra
+ * key fails at `assemble` instead of at runtime.
+ */
+type NoUndeclaredPhases<Contract, Definitions> = {
+    [Name in Exclude<keyof Definitions, PhaseNameOfContract<Contract>>]: `Phase '${Name & string}' is not declared in model.phases`;
+};
+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: Omit<ReducerGameDefinition<Contract, Definitions, View>, "contract"> & {
+        phases: NoUndeclaredPhases<Contract, Definitions>;
+    }): ReducerGameDefinition<Contract, Definitions, View>;
+    phase<Name extends PhaseNameOfContract<Contract>>(name: Name): PhaseAuthoring<Contract, PhaseSchemasOfContract<Contract>[Name]>;
+};
+
+type DieTypeSpec$1 = Omit<DieTypeSpec$2, "sides"> & {
+    sides?: DieTypeSpec$2["sides"];
+};
+type GameTopologyManifest$1 = Omit<GameTopologyManifest$2, "dieTypes"> & {
+    dieTypes?: Array<DieTypeSpec$1>;
+};
+
+/**
+ * Opaque brand applied to a runtime player identifier.
+ *
+ * The reducer owns the branded `PlayerId` identity. Authors
+ * obtain `PlayerId` values only through:
+ *   - `q.player.order()` / `q.player.current()` (reducer queries),
+ *   - engine-injected interaction and phase callback arguments,
+ *   - `asPlayerId(raw)` as an explicit escape hatch (e.g. ingress parsing).
+ *
+ * The brand is a phantom type: at runtime a `PlayerId` is just a string.
+ * Do not JSON-serialize the brand marker; it exists purely at the type
+ * level to block accidental literal comparisons such as
+ * `playerId === "player-1"`.
+ */
+type PlayerId$1 = Brand<string, "PlayerId">;
+/**
+ * Explicit conversion from a raw string to a branded `PlayerId`.
+ *
+ * Use at trust boundaries only (wire ingress, tests, fixtures). Inside
+ * reducer logic, obtain `PlayerId` values from the engine instead of
+ * constructing them yourself.
+ */
+declare function asPlayerId(raw: string): PlayerId$1;
+/**
+ * Type guard that narrows `unknown` to `PlayerId` when the value is a
+ * non-empty string. Does not validate against a specific player roster;
+ * use manifest/ingress parsing for that.
+ */
+declare function isPlayerId(value: unknown): value is PlayerId$1;
+/**
+ * Reference to a board by its authored `baseId`, plus an optional seat
+ * for per-player boards.
+ *
+ * Replaces the old generated `"ring:player-1" | "ring:player-2" | ...`
+ * flat unions whose keys pretended to be static but were actually
+ * derived from `maxPlayers` and therefore misaligned with the runtime
+ * seat list.
+ *
+ * The discriminant is the *presence* of `seat`, not a `scope` field, so
+ * authors can destructure and pass the ref directly without needing a
+ * discriminator check for shared boards.
+ */
+type BoardRef<BaseId extends string = string, Id extends PlayerId$1 = PlayerId$1> = SharedBoardRef<BaseId> | PerPlayerBoardRef<BaseId, Id>;
+interface SharedBoardRef<BaseId extends string = string> {
+    readonly baseId: BaseId;
+    readonly seat?: undefined;
+}
+interface PerPlayerBoardRef<BaseId extends string = string, Id extends PlayerId$1 = PlayerId$1> {
+    readonly baseId: BaseId;
+    readonly seat: Id;
+}
+/** Construct a shared board ref. */
+declare function sharedBoardRef<BaseId extends string>(baseId: BaseId): SharedBoardRef<BaseId>;
+/** Construct a per-player board ref. */
+declare function perPlayerBoardRef<BaseId extends string, Id extends PlayerId$1>(baseId: BaseId, seat: Id): PerPlayerBoardRef<BaseId, Id>;
+/**
+ * Construct a `BoardRef` without knowing the scope ahead of time. Pass
+ * `seat` for per-player boards; omit for shared boards.
+ */
+declare function boardRef<BaseId extends string, Id extends PlayerId$1>(baseId: BaseId, seat?: Id): BoardRef<BaseId, Id>;
+/** Stable string key for Maps/Records keyed by a `BoardRef`. */
+declare function boardRefKey(ref: BoardRef): string;
+/**
+ * Inverse of `boardRefKey`. Parses `"base"` as a shared ref and
+ * `"base:player-N"` as a per-player ref. Returns `null` for malformed
+ * input.
+ */
+declare function parseBoardRefKey(key: string): BoardRef | null;
+/**
+ * Zod schema for a `BoardRef` with free-form base and seat ids.
+ *
+ * Feed a manifest-scoped `baseIdSchema` and `playerIdSchema` to bind
+ * the ref to a specific workspace.
+ */
+declare function boardRefSchema<BaseId extends string = string, Id extends PlayerId$1 = PlayerId$1>(options?: {
+    readonly baseIdSchema?: z.ZodType<BaseId>;
+    readonly playerIdSchema?: z.ZodType<Id>;
+}): z.ZodType<BoardRef<BaseId, Id>>;
+/** True when `ref` targets a shared board (no seat). */
+declare function isSharedBoardRef<BaseId extends string>(ref: BoardRef<BaseId, PlayerId$1>): ref is SharedBoardRef<BaseId>;
+/** True when `ref` targets a per-player board (has a seat). */
+declare function isPerPlayerBoardRef<BaseId extends string, Id extends PlayerId$1>(ref: BoardRef<BaseId, Id>): ref is PerPlayerBoardRef<BaseId, Id>;
+
+type ReadonlyValue<T> = T extends readonly (infer V)[] ? readonly ReadonlyValue<V>[] : T extends object ? {
+    readonly [K in keyof T]: ReadonlyValue<T[K]>;
+} : T;
+type AuthoredManifest = ReadonlyValue<GameTopologyManifest$1>;
+type Entry<T> = T extends readonly (infer V)[] ? V : never;
+type Get<T, K extends PropertyKey> = T extends unknown ? K extends keyof T ? T[K] : never : never;
+type Entries<M, K extends PropertyKey> = Entry<Get<M, K>>;
+type Id<T> = T extends {
+    id: infer I extends string;
+} ? I : never;
+type NumberRange<N extends number, A extends number[] = []> = number extends N ? number : A["length"] extends 64 ? number : A["length"] extends N ? A[number] | N : NumberRange<N, [...A, A["length"]]>;
+type InstanceIds<Base extends string, Count> = [Count] extends [never] ? Base : Count extends number ? number extends Count ? Base | `${Base}-${number}` : Count extends 0 | 1 ? Base : `${Base}-${Exclude<NumberRange<Count>, 0>}` : Base;
+type SeedIds<S> = S extends {
+    typeId: infer T extends string;
+} ? InstanceIds<S extends {
+    id: infer I extends string;
+} ? I : T, Get<S, "count">> : never;
+type CardIds<C> = C extends {
+    type: infer T extends string;
+} ? InstanceIds<T, Get<C, "count">> : never;
+type StandardSuit = "SPADES" | "HEARTS" | "CLUBS" | "DIAMONDS";
+type StandardRank = "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "J" | "Q" | "K" | "A";
+type ResolvedCardSet<S> = S extends {
+    type: "preset";
+    presetId: "standard_52_deck";
+} ? Omit<S, "type"> & {
+    type: "manual";
+    cards: readonly {
+        type: `${StandardSuit}_${StandardRank}`;
+        count: 1;
+    }[];
+    cardSchema: {
+        properties: {
+            suit: {
+                type: "enum";
+                enums: readonly StandardSuit[];
+            };
+            rank: {
+                type: "string";
+            };
+        };
+    };
+} : S;
+type CardSets<M> = ResolvedCardSet<Entries<M, "cardSets">>;
+type Cards<M> = CardSets<M> extends infer S ? S extends {
+    cards: infer C;
+} ? Entry<C> : never : never;
+type Zone<M, Scope> = Id<Extract<Entries<M, "zones">, {
+    scope: Scope;
+}>>;
+type Boards<M> = Entries<M, "boards">;
+type RuntimeBoardId<B> = B extends {
+    id: infer I extends string;
+} ? B extends {
+    scope: "perPlayer";
+} ? `${I}:${string}` : I : never;
+type CardTypeOf<C> = C extends {
+    cardType: infer T extends string;
+} ? T : Extract<Get<C, "type">, string>;
+type ManifestIdsOf<M> = {
+    playerId: PlayerId$1;
+    phaseName: string;
+    boardLayout: "generic" | "hex" | "square";
+    cardSetId: Id<Entries<M, "cardSets">>;
+    cardType: CardTypeOf<Cards<M>>;
+    cardId: CardIds<Cards<M>>;
+    deckId: Zone<M, "shared">;
+    handId: Zone<M, "perPlayer">;
+    sharedZoneId: Zone<M, "shared">;
+    playerZoneId: Zone<M, "perPlayer">;
+    zoneId: Id<Entries<M, "zones">>;
+    resourceId: Id<Entries<M, "resources">>;
+    pieceTypeId: Id<Entries<M, "pieceTypes">>;
+    pieceId: SeedIds<Entries<M, "pieceSeeds">>;
+    dieTypeId: Id<Entries<M, "dieTypes">>;
+    dieId: SeedIds<Entries<M, "dieSeeds">>;
+    boardTypeId: Extract<Get<Boards<M>, "typeId">, string>;
+    boardBaseId: Id<Boards<M>>;
+    boardId: RuntimeBoardId<Boards<M>>;
+    boardContainerId: Id<Entry<Get<Boards<M>, "containers">>>;
+    relationTypeId: Extract<Get<Entry<Get<Boards<M>, "relations">>, "typeId">, string>;
+    edgeId: HexEdgeId<Extract<Id<Extract<Boards<M>, {
+        layout: "hex";
+    }>>, string>> | (Extract<Boards<M>, {
+        layout: "square";
+    }> extends never ? never : `square-edge:${string}`);
+    edgeTypeId: Extract<Get<Entry<Get<Boards<M>, "edges">>, "typeId">, string>;
+    vertexId: HexVertexId<Extract<Id<Extract<Boards<M>, {
+        layout: "hex";
+    }>>, string>> | (Extract<Boards<M>, {
+        layout: "square";
+    }> extends never ? never : `square-vertex:${string}`);
+    vertexTypeId: Extract<Get<Entry<Get<Boards<M>, "vertices">>, "typeId">, string>;
+    spaceId: BoardSpaceId<Boards<M>>;
+    spaceTypeId: Extract<Get<BoardSpaceEntry<Boards<M>>, "typeId">, string>;
+};
+type PropertyValue<P, M> = PropertySchema extends P ? RuntimePayload : P extends {
+    type: infer T;
+} ? T extends keyof ManifestIdsOf<M> ? ManifestIdsOf<M>[T] : T extends "string" ? string : T extends "number" | "integer" ? number : T extends "boolean" ? boolean : T extends "enum" ? Entry<Get<P, "enums">> : T extends "array" ? PropertyOutput<Get<P, "items">, M>[] : T extends "record" ? Record<string, PropertyOutput<Get<P, "values">, M>> : T extends "object" ? ObjectProperties<Get<P, "properties">, M> : never : never;
+type PropertyOutput<P, M> = PropertyValue<P, M> | (P extends {
+    nullable: true;
+} ? null : never);
+type OptionalKeys<P> = {
+    [K in keyof P]: P[K] extends {
+        optional: true;
+    } ? P[K] extends {
+        default: unknown;
+    } ? never : K : never;
+}[keyof P];
+type ObjectProperties<P, M> = {
+    [K in Exclude<keyof P, OptionalKeys<P>>]: PropertyOutput<P[K], M>;
+} & {
+    [K in OptionalKeys<P>]?: PropertyOutput<P[K], M>;
 };
-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 ObjectFields<S, M> = [S] extends [never] ? RuntimeRecord$1 : ObjectSchema extends S ? RuntimeRecord$1 : S extends {
+    properties: infer P;
+} ? ObjectProperties<P, M> : RuntimeRecord$1;
+type CardFields<S, M> = S extends {
+    variants: infer V;
+} ? ObjectProperties<Get<S, "shared">, M> & ObjectFields<V[keyof V], M> : ObjectFields<S, M>;
+type CardState<M> = CardSets<M> extends infer S ? S extends {
+    id: infer I;
+    cards: unknown;
+} ? Omit<RuntimeCardData, "id" | "cardSetId" | "cardType" | "properties"> & {
+    id: ManifestIdsOf<M>["cardId"];
+    cardSetId: I;
+    cardType: ManifestIdsOf<M>["cardType"];
+    properties: CardFields<Get<S, "cardSchema">, M>;
+} : never : never;
+type BoardField<B, K extends PropertyKey, M> = ObjectFields<Get<B, K>, M>;
+type BoardSpaceEntry<B> = B extends {
+    layout: "hex";
+    spaces: infer Spaces;
+} ? Spaces[keyof Spaces] : Entry<Get<B, "spaces">>;
+type BoardSpaceId<B> = B extends {
+    layout: "hex";
+} ? HexSpaceId<B> : Id<Entry<Get<B, "spaces">>>;
+type BoardParts<M, B> = {
+    id: RuntimeBoardId<B>;
+    baseId: Id<B>;
+    fields: BoardField<B, "boardFieldsSchema", M>;
+    relations: (Omit<RuntimeHexBoardState["relations"][number], "typeId"> & {
+        typeId: Extract<Get<Entry<Get<B, "relations">>, "typeId">, string> | (B extends {
+            layout: "hex" | "square";
+        } ? "adjacent" : never);
+    })[];
+    spaces: Record<BoardSpaceId<B>, (B extends {
+        layout: "hex";
+    } ? {
+        q: number;
+        r: number;
+    } : B extends {
+        layout: "square";
+    } ? {
+        row: number;
+        col: number;
+    } : unknown) & {
+        id: BoardSpaceId<B>;
+        name?: string | null;
+        typeId?: Extract<Get<BoardSpaceEntry<B>, "typeId">, string> | null;
+        fields: BoardField<B, "spaceFieldsSchema", M>;
+        zoneId?: string | null;
+    }>;
+};
+type BoardState<M, B> = B extends {
+    layout: "hex";
+} ? Omit<RuntimeHexBoardState, "id" | "baseId" | "fields" | "spaces" | "edges" | "vertices" | "relations"> & BoardParts<M, B> & {
+    edges: (Omit<RuntimeHexBoardState["edges"][number], "id" | "spaceIds"> & {
+        id: HexEdgeId<Extract<Id<B>, string>>;
+        spaceIds: BoardSpaceId<B>[];
+    })[];
+    vertices: (Omit<RuntimeHexBoardState["vertices"][number], "id" | "spaceIds"> & {
+        id: HexVertexId<Extract<Id<B>, string>>;
+        spaceIds: BoardSpaceId<B>[];
+    })[];
+} : B extends {
+    layout: "square";
+} ? Omit<RuntimeSquareBoardState, "id" | "baseId" | "fields" | "spaces" | "relations"> & BoardParts<M, B> : Omit<RuntimeGenericBoardState, "id" | "baseId" | "fields" | "spaces" | "relations"> & BoardParts<M, B>;
+type BoardMap<M> = {
+    [B in Boards<M> as RuntimeBoardId<B>]: Extract<BoardState<M, B>, RuntimeBoardState>;
+};
+type InferredBoards<M> = {
+    byId: BoardMap<M>;
+    hex: {
+        [B in Extract<Boards<M>, {
+            layout: "hex";
+        }> as RuntimeBoardId<B>]: Extract<BoardState<M, B>, RuntimeHexBoardState>;
+    };
+    square: {
+        [B in Extract<Boards<M>, {
+            layout: "square";
+        }> as RuntimeBoardId<B>]: Extract<BoardState<M, B>, RuntimeSquareBoardState>;
+    };
+    network: Record<string, RuntimeRecord$1>;
+    track: Record<string, RuntimeRecord$1>;
+};
+type ManifestTable<M> = AuthoredManifest extends M ? RuntimeTableRecord : Omit<RuntimeTableRecord, "playerOrder" | "decks" | "hands" | "cards" | "pieces" | "dice" | "boards" | "resources"> & {
+    boards: InferredBoards<M>;
+    playerOrder: PlayerId$1[];
+    decks: Record<ManifestIdsOf<M>["deckId"], ManifestIdsOf<M>["cardId"][]>;
+    hands: Record<ManifestIdsOf<M>["handId"], Record<PlayerId$1, ManifestIdsOf<M>["cardId"][]>>;
+    cards: Record<ManifestIdsOf<M>["cardId"], CardState<M>>;
+    pieces: Record<ManifestIdsOf<M>["pieceId"], RuntimePieceData>;
+    dice: Record<ManifestIdsOf<M>["dieId"], RuntimeDieData>;
+    resources: Record<PlayerId$1, Record<ManifestIdsOf<M>["resourceId"], number>>;
+};
+type CompiledManifest<M extends AuthoredManifest> = Omit<ReducerManifestContract<ManifestTable<M>, string, PlayerId$1, ManifestIdsOf<M>["deckId"], ManifestIdsOf<M>["handId"], ManifestIdsOf<M>["cardId"]>, "ids" | "literals" | "records" | "staticBoards"> & {
+    staticBoards: Pick<InferredBoards<M>, "byId" | "hex" | "square">;
+    literals: Omit<ReducerManifestContract<RuntimeTableRecord, string, string, string, string, string>["literals"], `${keyof ManifestIdsOf<M>}s`> & {
+        [K in keyof ManifestIdsOf<M> as `${K}s`]: readonly ManifestIdsOf<M>[K][];
+    };
+    records: {
+        [K in Exclude<keyof ManifestIdsOf<M>, "playerId"> as `${K}s`]: <V>(initial: V | ((id: ManifestIdsOf<M>[K]) => V)) => Record<ManifestIdsOf<M>[K], V>;
+    };
+    ids: {
+        [K in keyof ManifestIdsOf<M>]: ManifestIdSchema<ManifestIdsOf<M>[K], K>;
+    };
+    schemas: {
+        table: z.ZodType<ManifestTable<M>>;
+        runtime: z.ZodTypeAny;
+    };
+    createInitialTable(options?: {
+        playerIds?: readonly string[];
+        shuffleItems?: <V>(values: readonly V[]) => V[];
+    }): ManifestTable<M>;
+};
+
+type ManifestIdSchemasOf<Ids extends Record<string, SchemaLike<unknown>>> = {
+    readonly [Key in keyof Ids]: Ids[Key] extends SchemaLike<infer Output> ? Ids[Key] & ManifestIdSchema<Output> : Ids[Key];
 };
 
+/**
+ * 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, 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$1> = 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, 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$1> = 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)[];
+    readonly schemas: ManifestIdSchemasOf<NarrowManifestPhaseNames<Manifest, readonly (keyof Phases & string)[]>["ids"]>;
+};
+
+/**
+ * Creates the bound authoring object for a model without assembling the game.
+ *
+ * The returned value is the type leaf (`typeof game.types.State`), the factory namespace
+ * (`game.phase(name)`, `game.view`), and the assembler (`game.assemble`).
+ * Phase files import it directly, so no factory wrappers or `*AuthoringOf`
+ * parameter types are needed.
+ */
+declare function createGame<const Manifest extends AuthoredManifest, 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$1> = SchemaLike<Record<string, never>>>(model: {
+    manifest: Manifest;
+    state: {
+        public: PublicSchema;
+        private: PrivateSchema;
+        hidden: HiddenSchema;
+    };
+    phases: Phases;
+    errors?: Errors;
+    options?: OptionsSchema;
+}): GameAuthoring<DefinedGameContract<ManifestTable<Manifest>, CompiledManifest<Manifest>, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors, OptionsSchema>>;
+declare function createGame<Table extends RuntimeTableRecord, const Manifest extends ReducerManifestContract<Table, string, string, string, string, string>, 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$1> = 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;
 };
@@ -85,63 +791,472 @@ declare function createStateQueries<State extends {
 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;
 
-type FingerprintableContract = ReducerGameContractLike & {
-    phases?: Record<string, z.ZodTypeAny>;
-    errors?: Record<string, string> | undefined;
-};
-type FingerprintableDefinition = {
-    contract: FingerprintableContract;
-    phases?: Record<string, z.ZodTypeAny | {
-        state?: z.ZodTypeAny;
-    }>;
-};
-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;
-    };
-};
-/**
- * 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;
+/** 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;
 
 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;
 
-declare function setActivePlayers<State extends {
-    flow: {
-        activePlayers: PlayerIdOfState<State>[];
-    };
-}>(state: State, activePlayers: PlayerIdOfState<State>[]): State;
-
 /** Compile authored topology once, in memory, with the same validation used by initialization. */
 declare function compileManifest<const M extends AuthoredManifest>(manifest: M): CompiledManifest<M>;
 
-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 };
+declare function materializeManifestTable(options: {
+    manifest: GameTopologyManifest$1;
+    playerIds: readonly string[];
+    shuffleItems: <Value>(values: readonly Value[]) => Value[];
+}): Record<string, unknown>;
+
+type DieTypeSpec = Omit<DieTypeSpec$2, "sides"> & {
+    sides?: DieTypeSpec$2["sides"];
+};
+type DeepReadonly<T> = T extends (...args: readonly unknown[]) => unknown ? T : T extends readonly (infer Item)[] ? ReadonlyArray<DeepReadonly<Item>> : T extends object ? {
+    readonly [Key in keyof T]: DeepReadonly<T[Key]>;
+} : T;
+type GameTopologyManifest = DeepReadonly<Omit<GameTopologyManifest$2, "dieTypes"> & {
+    dieTypes?: readonly DieTypeSpec[];
+}>;
+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 RuntimeRecord = Record<string, JsonValue>;
+type CardSetId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["cardSets"]>;
+type ZoneId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["zones"]>;
+type BoardId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["boards"]>;
+type PerPlayerZoneId<Manifest extends GameTopologyManifest> = EntryId<Extract<ArrayItem<NonNullable<Manifest["zones"]>>, {
+    scope: "perPlayer";
+}>>;
+type SharedZoneId<Manifest extends GameTopologyManifest> = Exclude<ZoneId<Manifest>, PerPlayerZoneId<Manifest>>;
+type PerPlayerBoardId<Manifest extends GameTopologyManifest> = EntryId<Extract<ArrayItem<NonNullable<Manifest["boards"]>>, {
+    scope: "perPlayer";
+}>>;
+type SharedBoardId<Manifest extends GameTopologyManifest> = Exclude<BoardId<Manifest>, PerPlayerBoardId<Manifest>>;
+type ResourceId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["resources"]>;
+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 ManualCardSetOf<Manifest extends GameTopologyManifest> = Extract<ArrayItem<NonNullable<Manifest["cardSets"]>>, {
+    type: "manual";
+}>;
+type CardOf<Manifest extends GameTopologyManifest> = ManualCardSetOf<Manifest> extends infer CardSet ? CardSet extends {
+    cards: infer Cards extends readonly unknown[];
+} ? ArrayItem<Cards> : never : never;
+type BoardOf<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["boards"]>>, {
+    id: CurrentBoardId;
+}>;
+type SpaceIdOf<BoardLike> = BoardLike extends {
+    layout: "hex";
+} ? HexSpaceId<BoardLike> : IdsOf<BoardLike extends {
+    spaces?: infer Spaces;
+} ? Spaces : never>;
+type ContainerIdOf<BoardLike> = IdsOf<BoardLike extends {
+    containers?: infer Containers;
+} ? Containers : never>;
+type SpaceOf<BoardLike> = ArrayItem<NonNullable<BoardLike extends {
+    spaces?: infer Spaces;
+} ? Spaces : never>>;
+type SquareSpaceOf<BoardLike> = Extract<SpaceOf<BoardLike>, {
+    row: number;
+    col: number;
+}>;
+type SpaceIdForBoard<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = SpaceIdOf<BoardOf<Manifest, CurrentBoardId>>;
+type ContainerIdForBoard<Manifest extends GameTopologyManifest, CurrentBoardId extends BoardId<Manifest>> = ContainerIdOf<BoardOf<Manifest, CurrentBoardId>>;
+type RuntimeIdsFromCount<BaseId extends string, Count> = Count extends number ? number extends Count ? BaseId | `${BaseId}-${number}` : Count extends 1 ? BaseId : `${BaseId}-${OneTo<Count>}` : BaseId;
+type CardRuntimeId<Card> = Card extends {
+    type: infer TypeId extends string;
+} ? RuntimeIdsFromCount<TypeId, Card extends {
+    count: infer Count extends number;
+} ? Count : never> : never;
+type SeedRuntimeId<Seed> = Seed extends {
+    typeId: infer TypeId extends string;
+} ? RuntimeIdsFromCount<Seed extends {
+    id: infer Id extends string;
+} ? Id : TypeId, Seed extends {
+    count: infer Count extends number;
+} ? Count : never> : never;
+type CardId<Manifest extends GameTopologyManifest> = CardRuntimeId<CardOf<Manifest>>;
+type PieceId<Manifest extends GameTopologyManifest> = SeedRuntimeId<PieceSeedOf<Manifest>>;
+type DieId<Manifest extends GameTopologyManifest> = SeedRuntimeId<DieSeedOf<Manifest>>;
+type PieceTypeOf<Manifest extends GameTopologyManifest, CurrentTypeId extends PieceTypeId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["pieceTypes"]>>, {
+    id: CurrentTypeId;
+}>;
+type DieTypeOf<Manifest extends GameTopologyManifest, CurrentTypeId extends DieTypeId<Manifest>> = Extract<ArrayItem<NonNullable<Manifest["dieTypes"]>>, {
+    id: CurrentTypeId;
+}>;
+type SlotIdOf<TypeSpec> = IdsOf<TypeSpec extends {
+    slots?: infer Slots;
+} ? Slots : never>;
+type SlotIdForPieceType<Manifest extends GameTopologyManifest, CurrentTypeId extends PieceTypeId<Manifest>> = SlotIdOf<PieceTypeOf<Manifest, CurrentTypeId>>;
+type SlotIdForDieType<Manifest extends GameTopologyManifest, CurrentTypeId extends DieTypeId<Manifest>> = SlotIdOf<DieTypeOf<Manifest, CurrentTypeId>>;
+type SingletonExplicitSeed<Seed> = Seed extends {
+    id: string;
+} ? Seed extends {
+    count: infer Count extends number;
+} ? Count extends 1 ? Seed : never : Seed : never;
+type TypedPieceSlotHostSeed<Manifest extends GameTopologyManifest> = SingletonExplicitSeed<PieceSeedOf<Manifest>> extends infer Seed ? Seed extends {
+    typeId: infer CurrentTypeId extends PieceTypeId<Manifest>;
+} ? [SlotIdForPieceType<Manifest, CurrentTypeId>] extends [never] ? never : Seed : never : never;
+type TypedDieSlotHostSeed<Manifest extends GameTopologyManifest> = SingletonExplicitSeed<DieSeedOf<Manifest>> extends infer Seed ? Seed extends {
+    typeId: infer CurrentTypeId extends DieTypeId<Manifest>;
+} ? [SlotIdForDieType<Manifest, CurrentTypeId>] extends [never] ? never : Seed : never : never;
+type TypedPieceSlotHomeSpec<Manifest extends GameTopologyManifest> = TypedPieceSlotHostSeed<Manifest> extends infer Seed ? Seed extends {
+    id: infer HostId extends string;
+    typeId: infer CurrentTypeId extends PieceTypeId<Manifest>;
+} ? {
+    type: "slot";
+    host: {
+        kind: "piece";
+        id: HostId;
+    };
+    slotId: SlotIdForPieceType<Manifest, CurrentTypeId>;
+} : never : never;
+type TypedDieSlotHomeSpec<Manifest extends GameTopologyManifest> = TypedDieSlotHostSeed<Manifest> extends infer Seed ? Seed extends {
+    id: infer HostId extends string;
+    typeId: infer CurrentTypeId extends DieTypeId<Manifest>;
+} ? {
+    type: "slot";
+    host: {
+        kind: "die";
+        id: HostId;
+    };
+    slotId: SlotIdForDieType<Manifest, CurrentTypeId>;
+} : never : never;
+type RequiredSchemaKeys<Properties extends Readonly<Record<string, unknown>>> = {
+    [Key in keyof Properties]: Properties[Key] extends {
+        optional: true;
+    } ? never : Properties[Key] extends {
+        default: unknown;
+    } ? never : Key;
+}[keyof Properties];
+type OptionalSchemaKeys<Properties extends Readonly<Record<string, unknown>>> = {
+    [Key in keyof Properties]: Properties[Key] extends {
+        optional: true;
+    } ? Key : Properties[Key] extends {
+        default: unknown;
+    } ? Key : never;
+}[keyof Properties];
+type SchemaValueFromObjectProperties<Properties extends Readonly<Record<string, unknown>>, Manifest extends GameTopologyManifest, BoardLike = never> = keyof Properties extends never ? RuntimeRecord : {
+    [Key in RequiredSchemaKeys<Properties>]: SchemaValueForProperty<Properties[Key], Manifest, BoardLike>;
+} & {
+    [Key in OptionalSchemaKeys<Properties>]?: SchemaValueForProperty<Properties[Key], Manifest, BoardLike>;
+};
+type SchemaValueForObjectSchema<Schema, Manifest extends GameTopologyManifest, BoardLike = never> = Schema extends {
+    properties: infer Properties extends Readonly<Record<string, unknown>>;
+} ? SchemaValueFromObjectProperties<Properties, Manifest, BoardLike> : RuntimeRecord;
+type MergeSharedProperties<Variant, Shared> = Variant extends {
+    properties: infer VariantProperties extends Readonly<Record<string, unknown>>;
+} ? {
+    properties: Shared extends Readonly<Record<string, unknown>> ? Omit<Shared, keyof VariantProperties> & VariantProperties : VariantProperties;
+} : Variant;
+type BaseSchemaValueForProperty<Schema, Manifest extends GameTopologyManifest, BoardLike = never> = Schema extends {
+    type: "string";
+} ? string : Schema extends {
+    type: "integer" | "number";
+} ? number : Schema extends {
+    type: "boolean";
+} ? boolean : Schema extends {
+    type: "zoneId";
+} ? ZoneId<Manifest> : Schema extends {
+    type: "cardId";
+} ? CardId<Manifest> : Schema extends {
+    type: "playerId";
+} ? PlayerId<Manifest> : Schema extends {
+    type: "boardId";
+} ? BoardId<Manifest> : Schema extends {
+    type: "spaceId";
+} ? [BoardLike] extends [never] ? string : SpaceIdOf<BoardLike> : Schema extends {
+    type: "edgeId";
+} ? [BoardLike] extends [never] ? string : DerivedEdgeIdOf<BoardLike> : Schema extends {
+    type: "vertexId";
+} ? [BoardLike] extends [never] ? string : DerivedVertexIdOf<BoardLike> : Schema extends {
+    type: "pieceId";
+} ? PieceId<Manifest> : Schema extends {
+    type: "dieId";
+} ? DieId<Manifest> : Schema extends {
+    type: "resourceId";
+} ? ResourceId<Manifest> : Schema extends {
+    type: "enum";
+} ? Schema extends {
+    enums: infer Values extends readonly string[];
+} ? Values[number] : string : Schema extends {
+    type: "array";
+} ? ReadonlyArray<SchemaValueForProperty<Schema extends {
+    items?: infer Items;
+} ? Items : undefined, Manifest, BoardLike>> : Schema extends {
+    type: "object";
+} ? SchemaValueForObjectSchema<Schema extends {
+    properties?: infer Properties extends Record<string, unknown>;
+} ? {
+    properties: Properties;
+} : undefined, Manifest, BoardLike> : Schema extends {
+    type: "record";
+} ? Record<string, SchemaValueForProperty<Schema extends {
+    values?: infer Values;
+} ? Values : undefined, Manifest, BoardLike>> : RuntimeRecord;
+type SchemaValueForProperty<Schema, Manifest extends GameTopologyManifest, BoardLike = never> = Schema extends {
+    nullable: true;
+} ? BaseSchemaValueForProperty<Schema, Manifest, BoardLike> | null : BaseSchemaValueForProperty<Schema, Manifest, BoardLike>;
+type BuildTuple<Length extends number, Accumulator extends unknown[] = []> = Accumulator["length"] extends Length ? Accumulator : BuildTuple<Length, [...Accumulator, unknown]>;
+type EnumerateInternal<Length extends number, Accumulator extends number[] = []> = Accumulator["length"] extends Length ? Accumulator[number] : EnumerateInternal<Length, [...Accumulator, Accumulator["length"]]>;
+type AddOne<Count extends number> = [...BuildTuple<Count>, unknown]["length"] & number;
+type OneTo<Count extends number> = Exclude<EnumerateInternal<AddOne<Count>>, 0>;
+type PlayerId<Manifest extends GameTopologyManifest> = Manifest["players"]["maxPlayers"] extends infer MaxPlayers extends number ? `player-${OneTo<MaxPlayers>}` : `player-${number}`;
+type ToNumber<Input extends string> = Input extends `${infer Value extends number}` ? Value : never;
+type AbsoluteNumber<Count extends number> = `${Count}` extends `-${infer Value extends number}` ? Value : Count;
+type IsNegative<Count extends number> = `${Count}` extends `-${string}` ? true : false;
+type Negate<Count extends number> = Count extends 0 ? 0 : ToNumber<`${`${Count}` extends `-${infer Value extends number}` ? Value : `-${Count}`}`>;
+type AddPositive<Left extends number, Right extends number> = number extends Left | Right ? number : [...BuildTuple<Left>, ...BuildTuple<Right>]["length"] & number;
+type ComparePositive<Left extends number, Right extends number> = Left extends Right ? "equal" : number extends Left | Right ? "unknown" : BuildTuple<Left> extends [...BuildTuple<Right>, ...infer Rest] ? Rest extends [] ? "equal" : "greater" : "less";
+type SubtractPositive<Left extends number, Right extends number> = number extends Left | Right ? number : BuildTuple<Left> extends [...BuildTuple<Right>, ...infer Rest] ? Rest["length"] & number : never;
+type AddSigned<Left extends number, Right extends number> = number extends Left | Right ? number : IsNegative<Left> extends IsNegative<Right> ? IsNegative<Left> extends true ? Negate<AddPositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>>> : AddPositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>> : ComparePositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>> extends "equal" ? 0 : ComparePositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>> extends "greater" ? IsNegative<Left> extends true ? Negate<SubtractPositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>>> : SubtractPositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>> : IsNegative<Right> extends true ? Negate<SubtractPositive<AbsoluteNumber<Right>, AbsoluteNumber<Left>>> : SubtractPositive<AbsoluteNumber<Right>, AbsoluteNumber<Left>>;
+type SquareCornerGeometryKey<Space extends {
+    row: number;
+    col: number;
+}, Corner extends "nw" | "ne" | "se" | "sw"> = Corner extends "nw" ? `${Space["col"]},${Space["row"]}` : Corner extends "ne" ? `${AddSigned<Space["col"], 1>},${Space["row"]}` : Corner extends "se" ? `${AddSigned<Space["col"], 1>},${AddSigned<Space["row"], 1>}` : `${Space["col"]},${AddSigned<Space["row"], 1>}`;
+type SquareEdgeGeometryKey<Space extends {
+    row: number;
+    col: number;
+}, Side extends "north" | "east" | "south" | "west"> = Side extends "north" ? `${Space["col"]},${Space["row"]}::${AddSigned<Space["col"], 1>},${Space["row"]}` : Side extends "east" ? `${AddSigned<Space["col"], 1>},${Space["row"]}::${AddSigned<Space["col"], 1>},${AddSigned<Space["row"], 1>}` : Side extends "south" ? `${Space["col"]},${AddSigned<Space["row"], 1>}::${AddSigned<Space["col"], 1>},${AddSigned<Space["row"], 1>}` : `${Space["col"]},${Space["row"]}::${Space["col"]},${AddSigned<Space["row"], 1>}`;
+type DerivedSquareEdgeIdOf<BoardLike> = SquareSpaceOf<BoardLike> extends infer Space ? Space extends {
+    row: number;
+    col: number;
+} ? `square-edge:${SquareEdgeGeometryKey<Space, "north">}` | `square-edge:${SquareEdgeGeometryKey<Space, "east">}` | `square-edge:${SquareEdgeGeometryKey<Space, "south">}` | `square-edge:${SquareEdgeGeometryKey<Space, "west">}` : never : never;
+type DerivedSquareVertexIdOf<BoardLike> = SquareSpaceOf<BoardLike> extends infer Space ? Space extends {
+    row: number;
+    col: number;
+} ? `square-vertex:${SquareCornerGeometryKey<Space, "nw">}` | `square-vertex:${SquareCornerGeometryKey<Space, "ne">}` | `square-vertex:${SquareCornerGeometryKey<Space, "se">}` | `square-vertex:${SquareCornerGeometryKey<Space, "sw">}` : never : never;
+type DerivedHexEdgeIdOf<BoardLike> = BoardLike extends {
+    id: infer Id extends string;
+} ? HexEdgeId<Id> : never;
+type DerivedHexVertexIdOf<BoardLike> = BoardLike extends {
+    id: infer Id extends string;
+} ? HexVertexId<Id> : never;
+type DerivedEdgeIdOf<BoardLike> = BoardLike extends {
+    layout: "square";
+} ? DerivedSquareEdgeIdOf<BoardLike> : BoardLike extends {
+    layout: "hex";
+} ? DerivedHexEdgeIdOf<BoardLike> : never;
+type DerivedVertexIdOf<BoardLike> = BoardLike extends {
+    layout: "square";
+} ? DerivedSquareVertexIdOf<BoardLike> : BoardLike extends {
+    layout: "hex";
+} ? DerivedHexVertexIdOf<BoardLike> : never;
+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 TypedSharedContainerHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in SharedBoardId<Manifest>]: {
+        type: "container";
+        boardId: CurrentBoardId;
+        containerId: ContainerIdForBoard<Manifest, CurrentBoardId>;
+    };
+}[SharedBoardId<Manifest>];
+type TypedPerPlayerContainerHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
+        type: "container";
+        boardId: CurrentBoardId;
+        containerId: ContainerIdForBoard<Manifest, CurrentBoardId>;
+    };
+}[PerPlayerBoardId<Manifest>];
+type TypedSharedEdgeHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in SharedBoardId<Manifest>]: {
+        type: "edge";
+        boardId: CurrentBoardId;
+        ref: BoardEdgeRef;
+    };
+}[SharedBoardId<Manifest>];
+type TypedPerPlayerEdgeHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
+        type: "edge";
+        boardId: CurrentBoardId;
+        ref: BoardEdgeRef;
+    };
+}[PerPlayerBoardId<Manifest>];
+type TypedSharedVertexHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in SharedBoardId<Manifest>]: {
+        type: "vertex";
+        boardId: CurrentBoardId;
+        ref: BoardVertexRef;
+    };
+}[SharedBoardId<Manifest>];
+type TypedPerPlayerVertexHomeSpec<Manifest extends GameTopologyManifest> = {
+    [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
+        type: "vertex";
+        boardId: CurrentBoardId;
+        ref: BoardVertexRef;
+    };
+}[PerPlayerBoardId<Manifest>];
+type TypedSharedZoneHomeSpec<Manifest extends GameTopologyManifest> = {
+    type: "zone";
+    zoneId: SharedZoneId<Manifest>;
+};
+type TypedPerPlayerZoneHomeSpec<Manifest extends GameTopologyManifest> = {
+    type: "zone";
+    zoneId: PerPlayerZoneId<Manifest>;
+};
+type TypedPlayerScopedComponentHomeSpec<Manifest extends GameTopologyManifest> = TypedPerPlayerZoneHomeSpec<Manifest> | TypedPerPlayerSpaceHomeSpec<Manifest> | TypedPerPlayerContainerHomeSpec<Manifest> | TypedPerPlayerEdgeHomeSpec<Manifest> | TypedPerPlayerVertexHomeSpec<Manifest>;
+type TypedSharedComponentHomeSpec<Manifest extends GameTopologyManifest> = {
+    type: "detached";
+} | TypedSharedZoneHomeSpec<Manifest> | TypedSharedSpaceHomeSpec<Manifest> | TypedSharedContainerHomeSpec<Manifest> | TypedSharedEdgeHomeSpec<Manifest> | TypedSharedVertexHomeSpec<Manifest> | TypedPieceSlotHomeSpec<Manifest> | TypedDieSlotHomeSpec<Manifest>;
+type TypedComponentHomeSpec<Manifest extends GameTopologyManifest> = TypedSharedComponentHomeSpec<Manifest> | TypedPlayerScopedComponentHomeSpec<Manifest>;
+type TypedSeedLocationSpec<Seed, Manifest extends GameTopologyManifest> = Seed extends {
+    home: infer Home;
+} ? Home extends TypedPlayerScopedComponentHomeSpec<Manifest> ? Omit<Seed, "ownerId" | "home"> & {
+    ownerId: PlayerId<Manifest>;
+    home: TypedPlayerScopedComponentHomeSpec<Manifest>;
+} : Omit<Seed, "ownerId" | "home"> & {
+    ownerId?: PlayerId<Manifest>;
+    home?: TypedComponentHomeSpec<Manifest>;
+} : Omit<Seed, "ownerId" | "home"> & {
+    ownerId?: PlayerId<Manifest>;
+    home?: TypedComponentHomeSpec<Manifest>;
+};
+type TypedVisibilitySpec<Manifest extends GameTopologyManifest> = {
+    faceUp?: boolean;
+    visibleTo?: readonly PlayerId<Manifest>[];
+};
+type TypedVisibility<T, Manifest extends GameTopologyManifest> = T extends {
+    visibility?: unknown;
+} ? Omit<T, "visibility"> & {
+    visibility?: TypedVisibilitySpec<Manifest>;
+} : T;
+type TypedFields<T, Schema, Manifest extends GameTopologyManifest, BoardLike = never> = T extends {
+    fields?: unknown;
+} ? Omit<T, "fields"> & {
+    fields?: SchemaValueForObjectSchema<Schema, Manifest, BoardLike>;
+} : T;
+type TypedBoardContainerHost<Host, BoardLike> = Host extends {
+    type: "space";
+    spaceId: string;
+} ? Omit<Host, "spaceId"> & {
+    spaceId: SpaceIdOf<BoardLike>;
+} : Host;
+type TypedBoardContainer<Container, Manifest extends GameTopologyManifest, BoardLike, ContainerSchema> = Container extends {
+    host: infer Host;
+} ? Omit<TypedFields<TypedAllowedCardSetIds<Container, Manifest>, ContainerSchema, Manifest, BoardLike>, "host"> & {
+    host: TypedBoardContainerHost<Host, BoardLike>;
+} : TypedFields<TypedAllowedCardSetIds<Container, Manifest>, ContainerSchema, Manifest, BoardLike>;
+type TypedBoardRelation<Relation, Manifest extends GameTopologyManifest, BoardLike, RelationSchema> = Relation extends object ? Omit<TypedFields<Relation, RelationSchema, Manifest, BoardLike>, "fromSpaceId" | "toSpaceId"> & {
+    fromSpaceId: SpaceIdOf<BoardLike>;
+    toSpaceId: SpaceIdOf<BoardLike>;
+} : 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<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "relations" | "containers">, SchemaForEntry<Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
+    spaces?: infer Spaces;
+} ? Spaces : never>>, SchemaForEntry<Entry, "spaceFieldsSchema">, Manifest, BoardLike>>, Entry, "relations", TypedBoardRelation<ArrayItem<NonNullable<Entry extends {
+    relations?: infer Relations;
+} ? Relations : never>>, Manifest, BoardLike, SchemaForEntry<Entry, "relationFieldsSchema">>>, Entry, "containers", TypedBoardContainer<ArrayItem<NonNullable<Entry extends {
+    containers?: infer Containers;
+} ? Containers : never>>, Manifest, BoardLike, SchemaForEntry<Entry, "containerFieldsSchema">>>;
+type TypedHexBoardLike<Entry, Manifest extends GameTopologyManifest, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "edges" | "vertices">, SchemaForEntry<Entry, "boardFieldsSchema">, Manifest, BoardLike> & (Entry extends {
+    spaces: infer Spaces;
+} ? {
+    spaces: {
+        [Key in keyof Spaces]: TypedFields<Spaces[Key], SchemaForEntry<Entry, "spaceFieldsSchema">, Manifest, BoardLike>;
+    };
+} : unknown), Entry, "edges", TypedFields<ArrayItem<NonNullable<Entry extends {
+    edges?: infer Edges;
+} ? Edges : never>>, SchemaForEntry<Entry, "edgeFieldsSchema">, Manifest, BoardLike>>, Entry, "vertices", TypedFields<ArrayItem<NonNullable<Entry extends {
+    vertices?: infer Vertices;
+} ? Vertices : never>>, SchemaForEntry<Entry, "vertexFieldsSchema">, Manifest, BoardLike>>;
+type TypedSquareBoardLike<Entry, Manifest extends GameTopologyManifest, BoardLike> = TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedOptionalArray<TypedFields<Omit<Entry, "spaces" | "relations" | "containers" | "edges" | "vertices">, SchemaForEntry<Entry, "boardFieldsSchema">, Manifest, BoardLike>, Entry, "spaces", TypedFields<ArrayItem<NonNullable<Entry extends {
+    spaces?: infer Spaces;
+} ? Spaces : never>>, SchemaForEntry<Entry, "spaceFieldsSchema">, Manifest, BoardLike>>, Entry, "relations", TypedBoardRelation<ArrayItem<NonNullable<Entry extends {
+    relations?: infer Relations;
+} ? Relations : never>>, Manifest, BoardLike, SchemaForEntry<Entry, "relationFieldsSchema">>>, Entry, "containers", TypedBoardContainer<ArrayItem<NonNullable<Entry extends {
+    containers?: infer Containers;
+} ? Containers : never>>, Manifest, BoardLike, SchemaForEntry<Entry, "containerFieldsSchema">>>, Entry, "edges", TypedFields<ArrayItem<NonNullable<Entry extends {
+    edges?: infer Edges;
+} ? Edges : never>>, SchemaForEntry<Entry, "edgeFieldsSchema">, Manifest, BoardLike>>, Entry, "vertices", TypedFields<ArrayItem<NonNullable<Entry extends {
+    vertices?: infer Vertices;
+} ? Vertices : never>>, SchemaForEntry<Entry, "vertexFieldsSchema">, Manifest, BoardLike>>;
+type TypedBoardLikeEntry<Entry, Manifest extends GameTopologyManifest> = Entry extends {
+    layout: "generic";
+} ? TypedGenericBoardLike<Entry, Manifest, Entry> : Entry extends {
+    layout: "hex";
+} ? TypedHexBoardLike<Entry, Manifest, Entry> : Entry extends {
+    layout: "square";
+} ? TypedSquareBoardLike<Entry, Manifest, Entry> : Entry;
+type AuthoredCardType<Card> = Card extends {
+    cardType: infer Category extends string;
+} ? Category : Card extends {
+    type: infer Type extends string;
+} ? Type : never;
+type TypedCard<Card, Manifest extends GameTopologyManifest, CardSchema> = Card extends {
+    type: string;
+} ? Omit<TypedVisibility<Card, Manifest>, "home" | "properties"> & {
+    home?: TypedComponentHomeSpec<Manifest>;
+    properties: CardSchema extends {
+        variants: infer Variants extends Record<string, unknown>;
+        shared?: infer Shared;
+    } ? AuthoredCardType<Card> extends keyof Variants ? SchemaValueForObjectSchema<MergeSharedProperties<Variants[AuthoredCardType<Card>], Shared>, Manifest> : never : SchemaValueForObjectSchema<CardSchema, Manifest>;
+} : Card;
+type TypedCardSet<CardSet, Manifest extends GameTopologyManifest> = CardSet extends {
+    type: "manual";
+    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>;
+type TypedPieceSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends {
+    typeId: infer CurrentTypeId;
+} ? CurrentTypeId extends PieceTypeId<Manifest> ? Omit<TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>, "typeId" | "ownerId" | "home" | "fields"> & {
+    typeId: CurrentTypeId;
+    fields?: SchemaValueForObjectSchema<PieceTypeOf<Manifest, CurrentTypeId> extends {
+        fieldsSchema?: infer FieldsSchema;
+    } ? FieldsSchema : undefined, Manifest>;
+} & Pick<TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>, "ownerId" | "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<TypedVisibility<Seed, Manifest>, Manifest>, "typeId" | "ownerId" | "home" | "fields"> & {
+    typeId: CurrentTypeId;
+    fields?: SchemaValueForObjectSchema<DieTypeOf<Manifest, CurrentTypeId> extends {
+        fieldsSchema?: infer FieldsSchema;
+    } ? FieldsSchema : undefined, Manifest>;
+} & Pick<TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>, "ownerId" | "home"> : Omit<Seed, "typeId"> & {
+    typeId: DieTypeId<Manifest>;
+} : never;
+type TypedTopologyManifest<Manifest extends GameTopologyManifest> = Omit<Manifest, "cardSets" | "zones" | "boards" | "pieceSeeds" | "dieSeeds"> & {
+    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"];
+};
+type TopologyManifestValidation<Manifest> = Manifest extends GameTopologyManifest ? TypedTopologyManifest<Manifest> : GameTopologyManifest;
+type DefinedTopologyManifest<Manifest> = Manifest extends GameTopologyManifest ? Manifest : GameTopologyManifest;
+declare function defineTopologyManifest<const Manifest>(manifest: Manifest & TopologyManifestValidation<NoInfer<Manifest>>): DefinedTopologyManifest<Manifest>;
+
+export { type AuthoredManifest, type BoardRef, type BoardTargetPredicate, type BoundInputBuilders, type BoundTargetPredicate, type CardTargetPredicate, type ChoiceOptionsFactory, type ChoiceTargetOption, type ChoiceTargetPredicate, type CompiledManifest, type ContractTypes, type GameAuthoring, type GameTopologyManifest$1 as GameTopologyManifest, InteractionRule, type ManifestIdsOf, type ManifestTable, type ManyOptions, type PerPlayerBoardRef, type PhaseAuthoring, type PhaseTypes, type PlayerBoardSpaceTarget, type PlayerId$1 as PlayerId, type ReducerBundle, ReducerBundleContract, type ReducerBundleOptions, ReducerDiagnosticsSink, ReducerGameDefinition, ReducerTransaction, type SharedBoardRef, type SparseCounts, type SparseMap, SystemActionEvent, TableQueries, TableQueriesOfState, type TargetContext, type TargetPredicate, type TargetPredicateArgs, type TypedTopologyManifest, asPlayerId, assertCardAllowedInContainer, boardRef, boardRefKey, boardRefSchema, compileManifest, createGame, createReducerBundle, createStateQueries, createTableQueries, defineTopologyManifest, gameEvent, isPerPlayerBoardRef, isPlayerId, isSharedBoardRef, many, materializeManifestTable, memoize, normalizeCommandParams, parseBoardRefKey, perPlayerBoardRef, sharedBoardRef, sparseCounts, sparseMap };