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

package/dist/game-CsZScpcn.d.ts

@@ -1,763 +0,0 @@
-import { aT as ReducerManifestContractLike, bW as RuntimeTableRecord, cD as StateDefinition, c2 as SchemaLike, ab as ManifestContractOf, N as ErrorCodeOfContract, ae as ManifestIdSchema, aS as ReducerManifestContract, aF as PlayerIdOfState, cL as TableQueriesOfState, aa as ManifestContract, cJ as TableOfState, cU as TiledVertexIdOfTable, cI as TableOfManifest, cM as TiledBoardIdOfTable, cO as TiledEdgeIdOfTable, cS as TiledSpaceIdOfTable, n as CardIdOfManifest, O as ExactManifestContractOf, au as PhaseNameOfContract, aH as PlayerZoneIdOfManifest, ck as SetupSelectionOfManifest, ay as PhaseSchemasOfContract, bt as RuntimeHexBoardState, bE as RuntimeRecord, bB as RuntimePayload, aD as PlayerId, bR as RuntimeSquareBoardState, bq as RuntimeGenericBoardState, bj as RuntimeBoardState, ao as PerPlayer, bk as RuntimeCardData, bD as RuntimePieceData, bp as RuntimeDieData } from './runtime-RJ5orDJU.js';
-import { z } from 'zod';
-import { j as BaseGameStateOfContract, aG as ReducerGameContract, Z as InputCollector, y as CollectorState, K as DerivedResolver, f as AnyInteractionSpec, d as AnyCardActionSpec, aZ as SharedViewDefinition, aB as PlayerViewDefinition, W as EmptyViewDefinition, b7 as StaticViewDefinition, aN as ReducerTransaction, au as PhaseMapOf, bc as ViewMapOf, aI as ReducerGameDefinition, af as InteractionSpec, aY as ScopedPhaseState, p as CardActionSpec, ad as InteractionRule, R as EffectMap, aa as InteractionMap, b4 as StageMap, ay as PhaseZoneList, C as CardActionMap, aq as PhaseDefinition } from './views-BpuWcOyN.js';
-import { GameTopologyManifest, ObjectSchema, PropertySchema } from './types.js';
-
-type AnyReducerGameContract = {
-    manifest: ReducerManifestContractLike<RuntimeTableRecord>;
-    state: StateDefinition<SchemaLike<object>, SchemaLike<object>, SchemaLike<object>>;
-};
-type PhaseStateInput = SchemaLike<object> | object;
-type InferPhaseState<Input extends PhaseStateInput> = Input extends SchemaLike<infer Output> ? Output extends object ? Output : object : Input extends object ? Input : object;
-type ContractState<Contract extends AnyReducerGameContract> = BaseGameStateOfContract<Contract>;
-type ContractManifest<Contract extends AnyReducerGameContract> = ManifestContractOf<Contract>;
-type ContractErrorCode<Contract extends AnyReducerGameContract> = ErrorCodeOfContract<Contract>;
-
-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 `fx.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> = {
-    manifest: Manifest;
-    state: StateDefinition<PublicSchema, PrivateSchema, HiddenSchema>;
-    phases: Phases;
-    errors?: Errors;
-};
-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> = ReducerGameContract<Table, NarrowManifestPhaseNames<Manifest, readonly (keyof Phases & string)[]>, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors> & {
-    readonly phases: Phases;
-    readonly errors: Errors;
-    readonly phaseNames: readonly (keyof Phases & string)[];
-    readonly schemas: ManifestIdSchemasOf<NarrowManifestPhaseNames<Manifest, readonly (keyof Phases & string)[]>["ids"]>;
-};
-
-type InputFieldRef<Key extends string = string, Value = unknown, Collector extends InputCollector = InputCollector> = {
-    readonly key: Key;
-    readonly collector: Collector;
-    readonly __value?: Value;
-};
-type RefValue<Ref> = Ref extends InputFieldRef<string, infer Value, InputCollector> ? Value : never;
-type CollectorOfRef<Ref> = Ref extends InputFieldRef<string, unknown, infer Collector> ? Collector : never;
-type CollectorValue<Collector> = Collector extends InputCollector<infer Schema> ? z.infer<Schema> : never;
-type DependencyValues<Dependencies extends readonly InputFieldRef<string, unknown, InputCollector>[]> = {
-    readonly [Ref in Dependencies[number] as Ref["key"]]: RefValue<Ref>;
-};
-type DefinedInputRefs = Record<string, InputFieldRef<string, unknown, InputCollector>>;
-type DefinedInputs<Refs extends DefinedInputRefs> = {
-    readonly [Key in keyof Refs]: CollectorOfRef<Refs[Key]>;
-};
-declare class InputBuilder {
-    add<const Key extends string, Collector extends InputCollector<SchemaLike<unknown>>>(key: Key, collector: Collector): InputFieldRef<Key, CollectorValue<Collector>, Collector>;
-}
-/**
- * Define an interaction's inputs with typed field references. Field refs can be
- * passed to dependent input domains, and the returned collector map preserves
- * the original key/value types for interaction params.
- */
-declare function defineInputs<const Refs extends DefinedInputRefs>(define: (input: InputBuilder) => Refs): DefinedInputs<Refs>;
-
-type DomainContext<State extends CollectorState, Values extends Readonly<Record<string, unknown>> = Record<string, never>> = {
-    state: State;
-    playerId: PlayerIdOfState<State>;
-    q: TableQueriesOfState<State>;
-    derived: DerivedResolver;
-    values: Values;
-};
-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 DependentDomainChoices<Value extends ChoiceValue, State extends CollectorState, Dependencies extends readonly InputFieldRef<string, unknown>[]> = ReadonlyArray<DomainChoice<Value>> | ((context: DomainContext<State, DependencyValues<Dependencies>>) => 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, Values extends Readonly<Record<string, unknown>> = Record<string, never>> = (context: DomainContext<State, Values> & {
-    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<const Dependencies extends readonly InputFieldRef<string, unknown>[], Value extends ChoiceValue = string, State extends CollectorState = CollectorState>(options: {
-    dependsOn: Dependencies;
-    choices: DependentDomainChoices<Value, State, Dependencies>;
-    defaultValue: Value;
-}): InputCollector<SchemaLike<Value>, State, "form"> & {
-    readonly defaultValue: Value;
-};
-declare function choiceInput<const Dependencies extends readonly InputFieldRef<string, unknown>[], Value extends ChoiceValue = string, State extends CollectorState = CollectorState>(options: {
-    dependsOn: Dependencies;
-    choices: DependentDomainChoices<Value, State, Dependencies>;
-    defaultValue: ChoiceDefaultResolver<Value, State, DependencyValues<Dependencies>>;
-}): InputCollector<SchemaLike<Value>, State, "form">;
-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 choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState, const Dependencies extends readonly InputFieldRef<string, unknown>[] = readonly InputFieldRef<string, unknown>[]>(options: {
-    dependsOn: Dependencies;
-    choices: DependentDomainChoices<Value, State, Dependencies>;
-    defaultValue: Value;
-}): InputCollector<SchemaLike<Value>, State, "form"> & {
-    readonly defaultValue: Value;
-};
-declare function choiceInput<Value extends ChoiceValue, State extends CollectorState = CollectorState, const Dependencies extends readonly InputFieldRef<string, unknown>[] = readonly InputFieldRef<string, unknown>[]>(options: {
-    dependsOn: Dependencies;
-    choices: DependentDomainChoices<Value, State, Dependencies>;
-    defaultValue: ChoiceDefaultResolver<Value, State, DependencyValues<Dependencies>>;
-}): 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, const Dependencies extends readonly InputFieldRef<string, unknown>[]>(options: {
-        dependsOn: Dependencies;
-        choices: DependentDomainChoices<Value, State, Dependencies>;
-        defaultValue: Value;
-    }): InputCollector<SchemaLike<Value>, State, "form"> & {
-        readonly defaultValue: Value;
-    };
-    choice<Value extends ChoiceValue, const Dependencies extends readonly InputFieldRef<string, unknown>[]>(options: {
-        dependsOn: Dependencies;
-        choices: DependentDomainChoices<Value, State, Dependencies>;
-        defaultValue: ChoiceDefaultResolver<Value, State, DependencyValues<Dependencies>>;
-    }): InputCollector<SchemaLike<Value>, State, "form">;
-    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>;
-    values?: Readonly<Record<string, unknown>>;
-};
-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 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 StepPhaseState<PhaseStateSchema extends SchemaLike<object>, Steps extends readonly string[]> = z.infer<PhaseStateSchema> & {
-    step: Steps[number];
-};
-type StepPhaseInteractionEntry<Step extends string, Interaction> = {
-    steps: readonly Step[];
-    interaction: Interaction;
-};
-type StepPhaseCardActionEntry<Step extends string, Action> = {
-    steps: readonly Step[];
-    action: Action;
-};
-type StepPhaseInteractionMap<Step extends string, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, StepPhaseInteractionEntry<Step, AnyInteractionSpec<State, Manifest>>>;
-type StepPhaseCardActionMap<Step extends string, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-}, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, StepPhaseCardActionEntry<Step, AnyCardActionSpec<State, Manifest>>>;
-type UnwrappedStepInteractions<State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-}, Manifest extends ManifestContract<TableOfState<State>>, Interactions extends Record<string, StepPhaseInteractionEntry<string, AnyInteractionSpec<State, Manifest>>>> = {
-    [Key in keyof Interactions]: Interactions[Key]["interaction"];
-};
-type UnwrappedStepCardActions<State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-}, Manifest extends ManifestContract<TableOfState<State>>, CardActions extends Record<string, StepPhaseCardActionEntry<string, AnyCardActionSpec<State, Manifest>>>> = {
-    [Key in keyof CardActions]: CardActions[Key]["action"];
-};
-
-type ContractWithPhases = AnyReducerGameContract & {
-    readonly phases: Record<string, SchemaLike<object>>;
-};
-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>;
-    dependsOn?: readonly InputFieldRef<string, unknown>[];
-};
-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>>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }): 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>;
-    dependsOn?: readonly InputFieldRef<string, unknown>[];
-}) => BoundCardCollector<Contract, Id, ZoneIds>;
-/**
- * Prompt collector. `choices` names the option domain (a list or a factory
- * over state) and `where` filters it; the target rule is built internally.
- */
-type BoundPromptInput<Contract extends ContractWithPhases> = <Schema extends SchemaLike<unknown>>(options: {
-    schema: Schema;
-    choices?: ReadonlyArray<ChoiceTargetOption<Extract<Schema extends z.ZodType<infer Value> ? Value : never, string>>> | ChoiceOptionsFactory<BoundState<Contract>, Extract<Schema extends z.ZodType<infer Value> ? Value : never, string>>;
-    where?: BoundWhere<Contract, Extract<Schema extends z.ZodType<infer Value> ? Value : never, string>>;
-}) => InputCollector<Schema, BoundState<Contract>, "prompt">;
-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 prompt: BoundPromptInput<Contract>;
-    readonly rng: BoundRngInputs<Contract>;
-};
-type StepPhaseInput<Contract extends ContractWithPhases, PhaseStateSchema extends SchemaLike<object>, Steps extends readonly [string, ...string[]], SubmitCollectors extends Record<string, InputCollector>, Effects extends EffectMap<BoundState<Contract>, BoundManifest<Contract>>, Interactions extends StepPhaseInteractionMap<Steps[number], ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>>, Stages extends StageMap<ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>>, Zones extends PhaseZoneList<BoundManifest<Contract>>, CardActions extends StepPhaseCardActionMap<Steps[number], ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>>> = Omit<PhaseDefinition<PhaseStateSchema, BoundState<Contract>, BoundManifest<Contract>, SubmitCollectors, Effects, UnwrappedStepInteractions<ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>, Interactions>, Stages, Zones, UnwrappedStepCardActions<ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>, CardActions>, ContractErrorCode<Contract>>, "state" | "initialState" | "interactions" | "cardActions"> & {
-    steps: Steps;
-    state?: never;
-    initialState?: (ctx: {
-        manifest: BoundManifest<Contract>;
-        state: BoundState<Contract>;
-        playerIds: PlayerIdOfState<BoundState<Contract>>[];
-        setup: SetupSelectionOfManifest<BoundManifest<Contract>> | null;
-    }) => InferPhaseState<PhaseStateSchema>;
-    interactions?: Interactions;
-    cardActions?: CardActions;
-};
-type PhaseAuthoring<Contract extends ContractWithPhases, PhaseStateSchema extends SchemaLike<object>> = {
-    interaction<Collectors extends Record<string, InputCollector>>(spec: InteractionSpec<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, ContractErrorCode<Contract>>): InteractionSpec<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, ContractErrorCode<Contract>>;
-    cardAction<Collectors extends Record<string, InputCollector> = Record<string, never>, const PlayFrom extends PlayerZoneIdOfManifest<BoundManifest<Contract>> = PlayerZoneIdOfManifest<BoundManifest<Contract>>>(spec: CardActionSpec<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, PlayFrom, ContractErrorCode<Contract>>): CardActionSpec<Collectors, BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>, PlayFrom, ContractErrorCode<Contract>>;
-    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>, Effects extends EffectMap<BoundState<Contract>, BoundManifest<Contract>> = Record<string, never>, Interactions extends InteractionMap<BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>> = Record<string, never>, Stages extends StageMap<BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>> = Record<string, never>, const Zones extends PhaseZoneList<BoundManifest<Contract>> = readonly [], CardActions extends CardActionMap<BoundPhaseState<Contract, PhaseStateSchema>, BoundManifest<Contract>> = Record<string, never>>(definition: Omit<PhaseDefinition<PhaseStateSchema, BoundState<Contract>, BoundManifest<Contract>, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions, ContractErrorCode<Contract>>, "state">): PhaseDefinition<PhaseStateSchema, BoundState<Contract>, BoundManifest<Contract>, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions, ContractErrorCode<Contract>>;
-    stepPhase<const Steps extends readonly [string, ...string[]], SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<BoundState<Contract>, BoundManifest<Contract>> = Record<string, never>, Interactions extends StepPhaseInteractionMap<Steps[number], ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>> = Record<string, never>, const Zones extends PhaseZoneList<BoundManifest<Contract>> = readonly [], CardActions extends StepPhaseCardActionMap<Steps[number], ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>> = Record<string, never>>(definition: StepPhaseInput<Contract, PhaseStateSchema, Steps, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>): PhaseDefinition<SchemaLike<StepPhaseState<PhaseStateSchema, Steps>>, BoundState<Contract>, BoundManifest<Contract>, SubmitCollectors, Effects, UnwrappedStepInteractions<ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>, Interactions>, Stages, Zones, UnwrappedStepCardActions<ScopedPhaseState<BoundState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, BoundManifest<Contract>, CardActions>, ContractErrorCode<Contract>>;
-    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 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>>;
-};
-/**
- * View factories bound to the contract's state and manifest. Grouped under
- * `game.views` so the assembled `views: { shared, player }` map reads the same
- * way it is authored.
- */
-type BoundViewBuilders<Contract extends ContractWithPhases> = {
-    shared<Projection>(definition: SharedViewDefinition<BoundState<Contract>, BoundManifest<Contract>, Projection>): SharedViewDefinition<BoundState<Contract>, BoundManifest<Contract>, Projection>;
-    player<SharedProjection = unknown, Projection = unknown>(definition: PlayerViewDefinition<BoundState<Contract>, BoundManifest<Contract>, SharedProjection, Projection>): PlayerViewDefinition<BoundState<Contract>, BoundManifest<Contract>, SharedProjection, Projection>;
-    empty(): EmptyViewDefinition<BoundState<Contract>, BoundManifest<Contract>>;
-    static<Projection>(definition: StaticViewDefinition<ExactManifestContractOf<Contract>, Projection>): StaticViewDefinition<ExactManifestContractOf<Contract>, Projection>;
-};
-/**
- * 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;
-    readonly views: BoundViewBuilders<Contract>;
-    /** Compile-time only. Reading any member at runtime throws. */
-    readonly types: ContractTypes<Contract>;
-    /** Assemble the final game definition from phases and views. */
-    assemble<Definitions extends PhaseMapOf<Contract>, Views extends ViewMapOf<Contract>>(definition: Omit<ReducerGameDefinition<Contract, Definitions, Views>, "contract"> & {
-        phases: NoUndeclaredPhases<Contract, Definitions>;
-    }): ReducerGameDefinition<Contract, Definitions, Views>;
-    phase<Name extends PhaseNameOfContract<Contract>>(name: Name): PhaseAuthoring<Contract, PhaseSchemasOfContract<Contract>[Name]>;
-};
-
-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>;
-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 BoardLike<M> = Boards<M> extends infer B ? B extends unknown ? ResolveBoard<M, B> : never : never;
-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;
-    phaseName: string;
-    boardLayout: "generic" | "hex" | "square";
-    setupOptionId: Id<Entries<M, "setupOptions">>;
-    setupProfileId: Id<Entries<M, "setupProfiles">>;
-    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<BoardLike<M>, "typeId">, string>;
-    boardBaseId: Id<Boards<M>>;
-    boardId: RuntimeBoardId<Boards<M>>;
-    boardContainerId: Id<Entry<Get<BoardLike<M>, "containers">>>;
-    relationTypeId: Extract<Get<Entry<Get<BoardLike<M>, "relations">>, "typeId">, string>;
-    edgeId: string;
-    edgeTypeId: Extract<Get<Entry<Get<BoardLike<M>, "edges">>, "typeId">, string>;
-    vertexId: string;
-    vertexTypeId: Extract<Get<Entry<Get<BoardLike<M>, "vertices">>, "typeId">, string>;
-    spaceId: Id<Entry<Get<BoardLike<M>, "spaces">>>;
-    spaceTypeId: Extract<Get<Entry<Get<BoardLike<M>, "spaces">>, "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>;
-};
-type ObjectFields<S, M> = [S] extends [never] ? RuntimeRecord : ObjectSchema extends S ? RuntimeRecord : S extends {
-    properties: infer P;
-} ? ObjectProperties<P, M> : RuntimeRecord;
-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 ResolveBoard<M, B> = B & (B extends {
-    templateId: infer I;
-} ? Omit<Extract<Entries<M, "boardTemplates">, {
-    id: I;
-}>, keyof B> : unknown);
-type BoardField<B, K extends PropertyKey, M> = ObjectFields<Get<B, K>, M>;
-type BoardParts<M, B> = {
-    id: RuntimeBoardId<B>;
-    baseId: Id<B>;
-    fields: BoardField<ResolveBoard<M, B>, "boardFieldsSchema", M>;
-    spaces: Record<Id<Entry<Get<ResolveBoard<M, B>, "spaces">>>, (B extends {
-        layout: "hex";
-    } ? {
-        q: number;
-        r: number;
-    } : B extends {
-        layout: "square";
-    } ? {
-        row: number;
-        col: number;
-    } : unknown) & {
-        id: Id<Entry<Get<ResolveBoard<M, B>, "spaces">>>;
-        name?: string | null;
-        typeId?: string | null;
-        fields: BoardField<ResolveBoard<M, B>, "spaceFieldsSchema", M>;
-        zoneId?: string | null;
-    }>;
-};
-type BoardState<M, B> = B extends {
-    layout: "hex";
-} ? Omit<RuntimeHexBoardState, "id" | "baseId" | "fields"> & BoardParts<M, B> : B extends {
-    layout: "square";
-} ? Omit<RuntimeSquareBoardState, "id" | "baseId" | "fields"> & BoardParts<M, B> : Omit<RuntimeGenericBoardState, "id" | "baseId" | "fields"> & 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>;
-    track: Record<string, RuntimeRecord>;
-};
-type ManifestTable<M> = AuthoredManifest extends M ? RuntimeTableRecord : Omit<RuntimeTableRecord, "playerOrder" | "decks" | "hands" | "cards" | "pieces" | "dice" | "boards" | "resources"> & {
-    boards: InferredBoards<M>;
-    playerOrder: PlayerId[];
-    decks: Record<ManifestIdsOf<M>["deckId"], ManifestIdsOf<M>["cardId"][]>;
-    hands: Record<ManifestIdsOf<M>["handId"], PerPlayer<ManifestIdsOf<M>["cardId"][]>>;
-    cards: Record<ManifestIdsOf<M>["cardId"], CardState<M>>;
-    pieces: Record<ManifestIdsOf<M>["pieceId"], RuntimePieceData>;
-    dice: Record<ManifestIdsOf<M>["dieId"], RuntimeDieData>;
-    resources: PerPlayer<Record<ManifestIdsOf<M>["resourceId"], number>>;
-};
-type CompiledManifest<M extends AuthoredManifest> = Omit<ReducerManifestContract<ManifestTable<M>, string, PlayerId, ManifestIdsOf<M>["deckId"], ManifestIdsOf<M>["handId"], ManifestIdsOf<M>["cardId"]>, "ids" | "literals" | "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 keyof ManifestIdsOf<M> 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>;
-};
-
-declare function defineGameDefinition<const Contract extends AnyReducerGameContract, Definitions extends PhaseMapOf<Contract>, Views extends ViewMapOf<Contract>>(definition: {
-    contract: Contract;
-} & Omit<ReducerGameDefinition<NoInfer<Contract>, Definitions, Views>, "contract">): ReducerGameDefinition<Contract, Definitions, Views>;
-/**
- * Creates the bound authoring object for a model without assembling the game.
- *
- * This is the module-level primitive behind {@link defineGame}: the returned
- * value is the type leaf (`typeof game.types.State`), the factory namespace
- * (`game.phase(name)`, `game.views.*`), 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>(model: {
-    manifest: Manifest;
-    state: {
-        public: PublicSchema;
-        private: PrivateSchema;
-        hidden: HiddenSchema;
-    };
-    phases: Phases;
-    errors?: Errors;
-}): GameAuthoring<DefinedGameContract<ManifestTable<Manifest>, CompiledManifest<Manifest>, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors>>;
-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>(model: ReducerGameContractInput<Table, Manifest, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors>): GameAuthoring<DefinedGameContract<Table, Manifest, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors>>;
-
-export { type AnyReducerGameContract as A, type BoardTargetPredicate as B, type ChoiceOptionsFactory as C, type DefinedInputs as D, type GameAuthoring as G, type InputFieldRef as I, type ManifestIdsOf as M, type PhaseAuthoring as P, type TargetContext as T, type AuthoredManifest as a, type BoundInputBuilders as b, type BoundTargetPredicate as c, type BoundViewBuilders as d, type ChoiceTargetOption as e, type ChoiceTargetPredicate as f, type CompiledManifest as g, type ContractManifest as h, type ContractState as i, type ContractTypes as j, type DependencyValues as k, type ManifestTable as l, type PhaseTypes as m, type PlayerBoardSpaceTarget as n, type TargetPredicate as o, type TargetPredicateArgs as p, createGame as q, defineGameDefinition as r, defineInputs as s };