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

package/dist/reducer.d.ts

@@ -1,520 +1,18 @@
+import { c2 as SchemaLike, a as AnySchema, cH as SystemActionEvent, bW as RuntimeTableRecord, cL as TableQueriesOfState, cK as TableQueries, e as BoardIdOfTable, c as BoardContainerIdOfTable, aF as PlayerIdOfState } from './runtime-RJ5orDJU.js';
+export { h as BoardRef, R as FrameworkErrorCodes, S as GameEvent, T as GameEventDetail, U as GameOutcome, ak as OutcomeResult, al as OutcomeScoreComponent, am as OutcomeStanding, an as OutcomeTieBreak, ao as PerPlayer, ap as PerPlayerBoardRef, aq as PerPlayerSchemaOptions, aD as PlayerId, aO as ReducerAccept, aU as ReducerReject, aV as ReducerResult, aY as ReducerValidationResult, cl as SharedBoardRef, cZ as asPlayerId, c$ as boardRef, d0 as boardRefKey, d1 as boardRefSchema, d7 as isPerPlayer, d8 as isPerPlayerBoardRef, d9 as isPlayerId, da as isSharedBoardRef, dd as parseBoardRefKey, de as perPlayer, df as perPlayerBoardRef, dg as perPlayerEntries, dh as perPlayerGet, di as perPlayerHas, dj as perPlayerKeys, dk as perPlayerMap, dl as perPlayerRequire, dm as perPlayerSchema, dn as perPlayerSet, dp as perPlayerSize, dq as perPlayerValues, ds as sharedBoardRef } from './runtime-RJ5orDJU.js';
+import { y as CollectorState, Z as InputCollector, a4 as InputSelectionDescriptor, z as ContinuationCallable, T as EffectRollDieDefinition, U as EffectShuffleDefinition, V as EffectShufflePlayerZoneDefinition, aH as ReducerGameContractLike, au as PhaseMapOf, bc as ViewMapOf, aI as ReducerGameDefinition } from './views-BpuWcOyN.js';
+export { J as DerivedDefinition, K as DerivedResolver, ad as InteractionRule, an as Op, aJ as ReducerOps, aL as ReducerStateBase, aN as ReducerTransaction, aO as ReducerTransactionOutcome, aX as RotatePlayerZoneArgs, ba as ValidationIssue, bh as createDerivedResolver, bi as createReducerOps, bj as defineDerived, bk as pipe } from './views-BpuWcOyN.js';
+import { o as TargetPredicate, A as AnyReducerGameContract, i as ContractState, h as ContractManifest, a as AuthoredManifest, g as CompiledManifest } from './game-CsZScpcn.js';
+export { B as BoardTargetPredicate, b as BoundInputBuilders, c as BoundTargetPredicate, d as BoundViewBuilders, C as ChoiceOptionsFactory, e as ChoiceTargetOption, f as ChoiceTargetPredicate, j as ContractTypes, D as DefinedInputs, k as DependencyValues, G as GameAuthoring, I as InputFieldRef, M as ManifestIdsOf, l as ManifestTable, P as PhaseAuthoring, m as PhaseTypes, n as PlayerBoardSpaceTarget, T as TargetContext, p as TargetPredicateArgs, q as createGame, s as defineInputs } from './game-CsZScpcn.js';
 import { z } from 'zod';
-import { V as GeneratedManifestContractLike, bV as RuntimeTableRecord, cC as StateDefinition, c1 as SchemaLike, ac as ManifestContractOf, N as ErrorCodeOfContract, af as ManifestIdSchema, aT as ReducerManifestContract, aG as PlayerIdOfState, cL as TableQueriesOfState, o as CardIdOfState, ab as ManifestContract, cJ as TableOfState, cj as SetupSelectionOfManifest, cU as TiledVertexIdOfTable, cI as TableOfManifest, cM as TiledBoardIdOfTable, cO as TiledEdgeIdOfTable, cS as TiledSpaceIdOfTable, n as CardIdOfManifest, O as ExactManifestContractOf, av as PhaseNameOfContract, aI as PlayerZoneIdOfManifest, az as PhaseSchemasOfContract, a as AnySchema, cH as SystemActionEvent, cK as TableQueries, e as BoardIdOfTable, c as BoardContainerIdOfTable } from './runtime-C7Z2acNU.js';
-export { h as BoardRef, R as FrameworkErrorCodes, S as GameEvent, T as GameEventDetail, U as GameOutcome, al as OutcomeResult, am as OutcomeScoreComponent, an as OutcomeStanding, ao as OutcomeTieBreak, ap as PerPlayer, aq as PerPlayerBoardRef, ar as PerPlayerSchemaOptions, aE as PlayerId, aP as ReducerAccept, aQ as ReducerAcceptOptions, aU as ReducerReject, aV as ReducerResult, aY as ReducerValidationResult, ck 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-C7Z2acNU.js';
-import { j as BaseGameStateOfContract, aq as PhaseDefinition, aB as PlayerViewDefinition, aZ as SharedViewDefinition, aG as ReducerGameContract, Z as InputCollector, y as CollectorState, K as DerivedResolver, ba as ValidationIssue, b9 as TargetKind, a4 as InputSelectionDescriptor, a1 as InputDomainDescriptor, n as BoardTargetDomainDescriptor, l as BoardInputCollectorMeta, f as AnyInteractionSpec, d as AnyCardActionSpec, R as EffectMap, aY as ScopedPhaseState, b4 as StageMap, ay as PhaseZoneList, C as CardActionMap, au as PhaseMapOf, bc as ViewMapOf, aI as ReducerGameDefinition, W as EmptyViewDefinition, b7 as StaticViewDefinition, af as InteractionSpec, p as CardActionSpec, ad as InteractionRule, aa as InteractionMap, z as ContinuationCallable, T as EffectRollDieDefinition, U as EffectShuffleDefinition, V as EffectShufflePlayerZoneDefinition, b6 as StageSpec, aH as ReducerGameContractLike } from './views-D2Cfzr3h.js';
-export { J as DerivedDefinition, X as GameStateOf, Y as InitialStateCallbacks, an as Op, aF as ReducerEdit, aJ as ReducerOps, aL as ReducerStateBase, aN as ReducerTransaction, aW as RotatePlayerZoneArgs, bh as createDerivedResolver, bi as createReducerEdit, bj as createReducerOps, bk as createReducerTransaction, bl as defineDerived, bm as pipe } from './views-D2Cfzr3h.js';
-import { a as ReducerBundleContract } from './index.d-Bw8AOcgp.js';
+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-CVaSqPgX.js';
-
-type AnyReducerGameContract = {
-    manifest: GeneratedManifestContractLike<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 ReducerPhaseDefinition<Contract extends AnyReducerGameContract, PhaseStateSchema extends SchemaLike<object>> = PhaseDefinition<PhaseStateSchema, ContractState<Contract>, ContractManifest<Contract>>;
-type ReducerSharedViewDefinition<Contract extends AnyReducerGameContract, Projection = unknown> = SharedViewDefinition<ContractState<Contract>, ContractManifest<Contract>, Projection>;
-type ReducerPlayerViewDefinition<Contract extends AnyReducerGameContract, SharedProjection = unknown, Projection = unknown> = PlayerViewDefinition<ContractState<Contract>, ContractManifest<Contract>, SharedProjection, Projection>;
-
-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;
-};
-declare function defineGameContract<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>(definition: ReducerGameContractInput<Table, Manifest, PublicSchema, PrivateSchema, HiddenSchema, Phases, Errors>): 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)[];
-    /**
-     * Ergonomic shortcut to the manifest-backed Zod id schemas. Equivalent to
-     * `definition.manifest.ids`. Prefer `gameContract.schemas.playerId` etc.
-     * over re-importing the generated `ids` namespace so that every authored
-     * schema is anchored to the same SDK-guided source.
-     */
-    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 BoundTargetRule<Target> = {
-    readonly eligible: () => readonly Target[];
-    readonly validate: (target: Target) => ValidationIssue | null;
-    readonly isEligible: (target: Target) => boolean;
-};
-type TargetRule<State extends CollectorState, Target> = {
-    readonly eligible: (ctx: TargetContext<State>) => readonly Target[];
-    readonly validate: (ctx: TargetContext<State>, target: Target) => ValidationIssue | null;
-    readonly isEligible: (ctx: TargetContext<State>, target: Target) => boolean;
-    readonly bind: (ctx: TargetContext<State>) => BoundTargetRule<Target>;
-};
-type TargetRuleBuilder<State extends CollectorState, Target, Rule extends TargetRule<State, Target>> = {
-    readonly where: (predicate: TargetPredicate<State, Target>) => TargetRuleBuilder<State, Target, Rule>;
-    readonly build: () => Rule;
-};
-
-type BoardTargetPredicate<State extends CollectorState, Target> = TargetPredicate<State, Target>;
-type BoardTargetRule<State extends CollectorState, Target> = TargetRule<State, Target> & {
-    readonly boardId: string;
-    readonly targetKind: TargetKind;
-    readonly valueKind: "board-id" | "player-board-space";
-};
-type BoardTargetBuilder<State extends CollectorState, Target> = TargetRuleBuilder<State, Target, BoardTargetRule<State, Target>>;
-type PlayerBoardSpaceTarget<BoardId extends string, SpaceId extends string, PlayerId extends string> = {
-    readonly boardId: BoardId;
-    readonly playerId: PlayerId;
-    readonly spaceId: SpaceId;
-};
-declare const boardTarget: {
-    edge: <State extends CollectorState, Id extends string>(boardId: string) => BoardTargetBuilder<State, Id>;
-    vertex: <State extends CollectorState, Id extends string>(boardId: string) => BoardTargetBuilder<State, Id>;
-    space: <State extends CollectorState, Id extends string>(boardId: string) => BoardTargetBuilder<State, Id>;
-    tile: <State extends CollectorState, Id extends string>(boardId: string) => BoardTargetBuilder<State, Id>;
-    playerSpace<State extends CollectorState, BoardId extends string, SpaceId extends string>(boardId: BoardId): BoardTargetBuilder<State, PlayerBoardSpaceTarget<BoardId, SpaceId, PlayerIdOfState<State>>>;
-};
-
-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>;
-}>;
-declare function playerSpaceInput<State extends CollectorState = CollectorState, BoardId extends string = string, SpaceId extends string = string, PlayerId extends string = string>(options: {
-    target: BoardTargetRule<State, PlayerBoardSpaceTarget<BoardId, SpaceId, PlayerId>>;
-    dependsOn?: readonly InputFieldRef<string, unknown>[];
-}): InputCollector<PlayerSpaceInputSchema<BoardId, SpaceId, PlayerId>, State, "board-space">;
-declare const boardInput: {
-    vertex: <State extends CollectorState = CollectorState, Id extends string = string>(options: {
-        target: BoardTargetRule<State, Id>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }) => {
-        readonly kind: "board-vertex";
-        readonly schema: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
-        readonly defaultValue?: Id | undefined;
-        readonly selection?: InputSelectionDescriptor;
-        readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
-        readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
-        readonly dependsOn?: readonly string[];
-        readonly resolveDefaultValue?: ((state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, domain: InputDomainDescriptor) => Id | undefined) | undefined;
-    } & {
-        readonly domain: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, unknown>>) => BoardTargetDomainDescriptor;
-    } & {
-        readonly meta: BoardInputCollectorMeta;
-    };
-    edge: <State extends CollectorState = CollectorState, Id extends string = string>(options: {
-        target: BoardTargetRule<State, Id>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }) => {
-        readonly kind: "board-edge";
-        readonly schema: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
-        readonly defaultValue?: Id | undefined;
-        readonly selection?: InputSelectionDescriptor;
-        readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
-        readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
-        readonly dependsOn?: readonly string[];
-        readonly resolveDefaultValue?: ((state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, domain: InputDomainDescriptor) => Id | undefined) | undefined;
-    } & {
-        readonly domain: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, unknown>>) => BoardTargetDomainDescriptor;
-    } & {
-        readonly meta: BoardInputCollectorMeta;
-    };
-    tile: <State extends CollectorState = CollectorState, Id extends string = string>(options: {
-        target: BoardTargetRule<State, Id>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }) => {
-        readonly kind: "board-tile";
-        readonly schema: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
-        readonly defaultValue?: Id | undefined;
-        readonly selection?: InputSelectionDescriptor;
-        readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
-        readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
-        readonly dependsOn?: readonly string[];
-        readonly resolveDefaultValue?: ((state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, domain: InputDomainDescriptor) => Id | undefined) | undefined;
-    } & {
-        readonly domain: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, unknown>>) => BoardTargetDomainDescriptor;
-    } & {
-        readonly meta: BoardInputCollectorMeta;
-    };
-    space: <State extends CollectorState = CollectorState, Id extends string = string>(options: {
-        target: BoardTargetRule<State, Id>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }) => {
-        readonly kind: "board-space";
-        readonly schema: z.ZodType<Id, unknown, z.core.$ZodTypeInternals<Id, unknown>>;
-        readonly defaultValue?: Id | undefined;
-        readonly selection?: InputSelectionDescriptor;
-        readonly eligibleTargets?: (state: CollectorState, playerId: string, q: unknown, values?: Readonly<Record<string, unknown>>) => ReadonlyArray<unknown>;
-        readonly validateTarget?: (state: CollectorState, playerId: string, q: unknown, targetId: unknown, values?: Readonly<Record<string, unknown>>) => ValidationIssue | null | undefined;
-        readonly dependsOn?: readonly string[];
-        readonly resolveDefaultValue?: ((state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, domain: InputDomainDescriptor) => Id | undefined) | undefined;
-    } & {
-        readonly domain: (state: CollectorState, playerId: string, q: unknown, derived: DerivedResolver, values?: Readonly<Record<string, unknown>>) => BoardTargetDomainDescriptor;
-    } & {
-        readonly meta: BoardInputCollectorMeta;
-    };
-    playerSpace: typeof playerSpaceInput;
-};
+import './protocol-dYgafTYY.js';
 
 type CardTargetPredicate<State extends CollectorState, Id extends string> = TargetPredicate<State, Id>;
-type CardTargetRule<State extends CollectorState, Id extends string, ZoneIds extends readonly string[] = readonly string[]> = TargetRule<State, Id> & {
-    readonly zoneIds: ZoneIds;
-    readonly zoneId: ZoneIds[number];
-    readonly targetKind: "card";
-};
-type CardTargetBuilder<State extends CollectorState, Id extends string, ZoneIds extends readonly string[] = readonly string[]> = TargetRuleBuilder<State, Id, CardTargetRule<State, Id, ZoneIds>>;
-declare const cardTarget: {
-    zones<State extends CollectorState, Id extends string = CardIdOfState<State>, const ZoneIds extends readonly string[] = readonly string[]>(zoneIds: ZoneIds): CardTargetBuilder<State, Id, ZoneIds>;
-};
-
-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>;
-type ChoiceTargetRule<State extends CollectorState, Id extends string> = TargetRule<State, Id> & {
-    readonly targetKind: "choice";
-    readonly options: (ctx: TargetContext<State>) => ReadonlyArray<ChoiceTargetOption<Id>>;
-    readonly eligibleOptions: (ctx: TargetContext<State>) => ReadonlyArray<ChoiceTargetOption<Id>>;
-};
-type ChoiceTargetBuilder<State extends CollectorState, Id extends string> = TargetRuleBuilder<State, Id, ChoiceTargetRule<State, Id>>;
-declare const choiceTarget: {
-    options<State extends CollectorState, Id extends string>(options: ReadonlyArray<ChoiceTargetOption<Id>> | ChoiceOptionsFactory<State, Id>): ChoiceTargetBuilder<State, Id>;
-};
-
-/**
- * `cardInput` produces a collector backed by one built `cardTarget` rule.
- * The submitted value is a manifest-branded card id.
- *
- * The target rule feeds server-authoritative eligible-card projection, submit
- * validation, and tests through its `bind({ state, playerId, q })` helper.
- */
-declare function cardInput<State extends CollectorState = CollectorState, Id extends string = CardIdOfState<State>, const ZoneIds extends readonly string[] = readonly string[]>(options: {
-    target: CardTargetRule<State, Id, ZoneIds>;
-    dependsOn?: readonly InputFieldRef<string, unknown>[];
-}): InputCollector<z.ZodType<Id>, State, "card"> & {
-    readonly meta: {
-        readonly zoneId: ZoneIds[number];
-        readonly zoneIds: ZoneIds;
-        readonly targetKind: "card";
-    };
-};
-
-type SchemaStringValue<Schema extends SchemaLike<unknown>> = Extract<Schema extends z.ZodType<infer V> ? V : never, string>;
-/**
- * `promptInput` marks an interaction as a prompt delivered to a player's
- * inbox. The submitted value is validated by the supplied Zod schema.
- *
- * Static or free-form prompts need only `schema`. Finite dynamic choices use
- * a built `choiceTarget.options(...).build()` rule so projected options and
- * submit validation share one source of truth.
- */
-declare function promptInput<Schema extends SchemaLike<unknown>, State extends CollectorState = CollectorState>(options: {
-    schema: Schema;
-    target?: ChoiceTargetRule<State, SchemaStringValue<Schema>>;
-}): InputCollector<Schema, State, "prompt">;
-
-/**
- * `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;
@@ -545,161 +43,6 @@ 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 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"];
-};
-declare function definePhase<Contract extends AnyReducerGameContract>(): <PhaseStateSchema extends SchemaLike<object>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<ContractState<Contract>, ContractManifest<Contract>> = Record<string, never>, Interactions extends Record<string, AnyInteractionSpec<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>>> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>> = Record<string, never>, const Zones extends PhaseZoneList<ContractManifest<Contract>> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>> = Record<string, never>>(definition: PhaseDefinition<PhaseStateSchema, ContractState<Contract>, ContractManifest<Contract>, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>) => PhaseDefinition<PhaseStateSchema, ContractState<Contract>, ContractManifest<Contract>, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>;
-declare function defineStepPhase<Contract extends AnyReducerGameContract>(): <const Steps extends readonly [string, ...string[]], PhaseStateSchema extends SchemaLike<object>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<ContractState<Contract>, ContractManifest<Contract>> = Record<string, never>, Interactions extends StepPhaseInteractionMap<Steps[number], ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>> = Record<string, never>, const Zones extends PhaseZoneList<ContractManifest<Contract>> = readonly [], CardActions extends StepPhaseCardActionMap<Steps[number], ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>> = Record<string, never>>(definition: Omit<PhaseDefinition<PhaseStateSchema, ContractState<Contract>, ContractManifest<Contract>, SubmitCollectors, Effects, UnwrappedStepInteractions<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>, Interactions>, Stages, Zones, UnwrappedStepCardActions<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>, CardActions>>, "state" | "initialState" | "interactions" | "cardActions"> & {
-    steps: Steps;
-    state: PhaseStateSchema;
-    initialState?: (ctx: {
-        manifest: ContractManifest<Contract>;
-        state: ContractState<Contract>;
-        playerIds: PlayerIdOfState<ContractState<Contract>>[];
-        setup: SetupSelectionOfManifest<ContractManifest<Contract>> | null;
-    }) => z.infer<PhaseStateSchema>;
-    interactions?: Interactions;
-    cardActions?: CardActions;
-}) => PhaseDefinition<SchemaLike<StepPhaseState<PhaseStateSchema, Steps>>, ContractState<Contract>, ContractManifest<Contract>, SubmitCollectors, Effects, UnwrappedStepInteractions<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>, Interactions>, Stages, Zones, UnwrappedStepCardActions<ScopedPhaseState<ContractState<Contract>, StepPhaseState<PhaseStateSchema, Steps>>, ContractManifest<Contract>, CardActions>>;
-
-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>>>;
-type BoundBoardInputs<Contract extends ContractWithPhases> = {
-    vertex<Id extends string = TiledVertexIdOfTable<BoundTable<Contract>, TiledBoardIdOfTable<BoundTable<Contract>>>>(options: {
-        target: BoardTargetRule<BoundState<Contract>, Id>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }): InputCollector<z.ZodType<Id>, BoundState<Contract>, "board-vertex">;
-    edge<Id extends string = TiledEdgeIdOfTable<BoundTable<Contract>, TiledBoardIdOfTable<BoundTable<Contract>>>>(options: {
-        target: BoardTargetRule<BoundState<Contract>, Id>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }): InputCollector<z.ZodType<Id>, BoundState<Contract>, "board-edge">;
-    tile<Id extends string = string>(options: {
-        target: BoardTargetRule<BoundState<Contract>, Id>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }): InputCollector<z.ZodType<Id>, BoundState<Contract>, "board-tile">;
-    space<Id extends string = TiledSpaceIdOfTable<BoundTable<Contract>, TiledBoardIdOfTable<BoundTable<Contract>>>>(options: {
-        target: BoardTargetRule<BoundState<Contract>, Id>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }): InputCollector<z.ZodType<Id>, BoundState<Contract>, "board-space">;
-    playerSpace<BoardId extends string = string, SpaceId extends string = string, PlayerId extends string = PlayerIdOfState<BoundState<Contract>>>(options: {
-        target: BoardTargetRule<BoundState<Contract>, PlayerBoardSpaceTarget<BoardId, SpaceId, PlayerId>>;
-        dependsOn?: readonly InputFieldRef<string, unknown>[];
-    }): InputCollector<PlayerSpaceInputSchema<BoardId, SpaceId, PlayerId>, BoundState<Contract>, "board-space">;
-};
-type BoundCardInput<Contract extends ContractWithPhases> = <Id extends string = CardIdOfManifest<BoundManifest<Contract>>, const ZoneIds extends readonly string[] = readonly string[]>(options: {
-    target: CardTargetRule<BoundState<Contract>, Id, ZoneIds>;
-    dependsOn?: readonly InputFieldRef<string, unknown>[];
-}) => InputCollector<z.ZodType<Id>, BoundState<Contract>, "card"> & {
-    readonly meta: {
-        readonly zoneId: ZoneIds[number];
-        readonly zoneIds: ZoneIds;
-        readonly targetKind: "card";
-    };
-};
-type BoundPromptInput<Contract extends ContractWithPhases> = <Schema extends SchemaLike<unknown>>(options: {
-    schema: Schema;
-    target?: ChoiceTargetRule<BoundState<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 BoundChoiceTarget<Contract extends ContractWithPhases> = {
-    options<Id extends string>(options: ReadonlyArray<ChoiceTargetOption<Id>> | ChoiceOptionsFactory<BoundState<Contract>, Id>): ChoiceTargetBuilder<BoundState<Contract>, Id>;
-};
-type BoundBoardTarget<Contract extends ContractWithPhases> = {
-    edge<Id extends string = string>(boardId: string): BoardTargetBuilder<BoundState<Contract>, Id>;
-    vertex<Id extends string = string>(boardId: string): BoardTargetBuilder<BoundState<Contract>, Id>;
-    space<Id extends string = string>(boardId: string): BoardTargetBuilder<BoundState<Contract>, Id>;
-    tile<Id extends string = string>(boardId: string): BoardTargetBuilder<BoundState<Contract>, Id>;
-    playerSpace<BoardId extends string, SpaceId extends string, PlayerId extends string = PlayerIdOfState<BoundState<Contract>>>(boardId: BoardId): BoardTargetBuilder<BoundState<Contract>, PlayerBoardSpaceTarget<BoardId, SpaceId, PlayerId>>;
-};
-type BoundCardTarget<Contract extends ContractWithPhases> = {
-    zones<Id extends string = CardIdOfState<BoundState<Contract>>, const ZoneIds extends readonly string[] = readonly string[]>(zoneIds: ZoneIds): CardTargetBuilder<BoundState<Contract>, Id, ZoneIds>;
-};
-type BoundInputBuilders<Contract extends ContractWithPhases> = {
-    readonly board: BoundBoardInputs<Contract>;
-    readonly boardTarget: BoundBoardTarget<Contract>;
-    readonly card: BoundCardInput<Contract>;
-    readonly cardTarget: BoundCardTarget<Contract>;
-    readonly choiceTarget: BoundChoiceTarget<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>>, "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>, "state">): PhaseDefinition<PhaseStateSchema, BoundState<Contract>, BoundManifest<Contract>, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>;
-    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>>;
-    readonly inputs: BoundInputBuilders<Contract>;
-};
-type ContractAuthoring<Contract extends ContractWithPhases> = {
-    readonly contract: Contract;
-    game<Definitions extends PhaseMapOf<Contract>, Views extends ViewMapOf<Contract>>(definition: Omit<ReducerGameDefinition<Contract, Definitions, Views>, "contract">): ReducerGameDefinition<Contract, Definitions, Views>;
-    sharedView<Projection>(definition: SharedViewDefinition<BoundState<Contract>, BoundManifest<Contract>, Projection>): SharedViewDefinition<BoundState<Contract>, BoundManifest<Contract>, Projection>;
-    playerView<SharedProjection = unknown, Projection = unknown>(definition: PlayerViewDefinition<BoundState<Contract>, BoundManifest<Contract>, SharedProjection, Projection>): PlayerViewDefinition<BoundState<Contract>, BoundManifest<Contract>, SharedProjection, Projection>;
-    emptyView(): EmptyViewDefinition<BoundState<Contract>, BoundManifest<Contract>>;
-    staticView<Projection>(definition: StaticViewDefinition<ExactManifestContractOf<Contract>, Projection>): StaticViewDefinition<ExactManifestContractOf<Contract>, Projection>;
-    phase<Name extends PhaseNameOfContract<Contract>>(name: Name): PhaseAuthoring<Contract, PhaseSchemasOfContract<Contract>[Name]>;
-};
-declare function createContractAuthoring<const Contract extends ContractWithPhases>(contract: Contract): ContractAuthoring<Contract>;
-
 type EffectRollDieInput<Contract extends AnyReducerGameContract, Id extends string, ContextSchema extends AnySchema> = {
     type: "rollDie";
     id: Id;
@@ -724,29 +67,6 @@ declare function defineEffect<Contract extends AnyReducerGameContract>(): {
     <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>>;
 };
 
-declare function defineGame<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>;
-
-declare function defineInteraction<Contract extends AnyReducerGameContract, PhaseState extends PhaseStateInput = SchemaLike<object>>(): <Collectors extends Record<string, InputCollector>>(definition: InteractionSpec<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>, ContractErrorCode<Contract>>) => InteractionSpec<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>, ContractErrorCode<Contract>>;
-declare function defineInteractionRule<Contract extends AnyReducerGameContract, PhaseState extends PhaseStateInput = SchemaLike<object>>(): <Collectors extends Record<string, InputCollector> = Record<string, InputCollector>>(definition: InteractionRule<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>, ContractErrorCode<Contract>>) => InteractionRule<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>, ContractErrorCode<Contract>>;
-declare function defineCardAction<Contract extends AnyReducerGameContract, PhaseState extends PhaseStateInput>(): <Collectors extends Record<string, InputCollector> = Record<string, never>, const PlayFrom extends PlayerZoneIdOfManifest<ContractManifest<Contract>> = PlayerZoneIdOfManifest<ContractManifest<Contract>>>(definition: CardActionSpec<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>, PlayFrom, ContractErrorCode<Contract>>) => CardActionSpec<Collectors, ScopedPhaseState<ContractState<Contract>, InferPhaseState<PhaseState>>, ContractManifest<Contract>, PlayFrom, ContractErrorCode<Contract>>;
-
-declare function defineSharedView<Contract extends AnyReducerGameContract>(): <Projection>(definition: SharedViewDefinition<ContractState<Contract>, ContractManifest<Contract>, Projection>) => SharedViewDefinition<ContractState<Contract>, ContractManifest<Contract>, Projection>;
-declare function definePlayerView<Contract extends AnyReducerGameContract>(): <SharedProjection = unknown, Projection = unknown>(definition: PlayerViewDefinition<ContractState<Contract>, ContractManifest<Contract>, SharedProjection, Projection>) => PlayerViewDefinition<ContractState<Contract>, ContractManifest<Contract>, SharedProjection, Projection>;
-declare function defineEmptyView<Contract extends AnyReducerGameContract>(): EmptyViewDefinition<ContractState<Contract>, ContractManifest<Contract>>;
-/**
- * Factory for the session-scoped static view (see {@link StaticViewDefinition}).
- * Kept separate from dynamic view helpers because the argument shape is
- * structurally different: it exposes only the manifest and generated static
- * queries, with no `state`, `playerId`, `runtime`, `fx`, `ops`, or
- * `accept/reject`. That shape is what prevents authors from accidentally
- * projecting per-tick state into the once-per-session payload.
- */
-declare function defineStaticView<Contract extends AnyReducerGameContract>(): <Projection>(definition: StaticViewDefinition<ExactManifestContractOf<Contract>, Projection>) => StaticViewDefinition<ExactManifestContractOf<Contract>, Projection>;
-declare function defineStage<Contract extends AnyReducerGameContract>(): (definition: StageSpec<ContractState<Contract>, ContractManifest<Contract>>) => StageSpec<ContractState<Contract>, ContractManifest<Contract>>;
-declare function definePhaseStage<Contract extends AnyReducerGameContract, PhaseStateSchema extends SchemaLike<object>>(): (definition: StageSpec<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>>) => StageSpec<ScopedPhaseState<ContractState<Contract>, z.infer<PhaseStateSchema>>, ContractManifest<Contract>>;
-
 declare const gameEvent: {
     systemAction(event: Omit<SystemActionEvent, "kind">): SystemActionEvent;
 };
@@ -821,4 +141,7 @@ declare function setActivePlayers<State extends {
     };
 }>(state: State, activePlayers: PlayerIdOfState<State>[]): State;
 
-export { type BoardTargetBuilder, type BoardTargetPredicate, type BoardTargetRule, type BoundInputBuilders, type BoundTargetRule, type CardTargetBuilder, type CardTargetPredicate, type CardTargetRule, type ChoiceOptionsFactory, type ChoiceTargetBuilder, type ChoiceTargetOption, type ChoiceTargetPredicate, type ChoiceTargetRule, type ContractAuthoring, type ContractFingerprint, type ContractWithPhases, type DefinedInputs, type DependencyValues, DerivedResolver, ErrorCodeOfContract, type InputFieldRef, InteractionRule, type ManyOptions, type PhaseAuthoring, PhaseMapOf, type PlayerBoardSpaceTarget, type ReducerBundle, type ReducerBundleOptions, ReducerDiagnosticsSink, ReducerGameContract, ReducerGameDefinition, type ReducerPhaseDefinition, type ReducerPlayerViewDefinition, type ReducerSharedViewDefinition, type SparseCounts, type SparseMap, SystemActionEvent, TableQueries, TableQueriesOfState, type TargetContext, type TargetPredicate, type TargetPredicateArgs, type TargetRule, type TargetRuleBuilder, ValidationIssue, assertCardAllowedInContainer, boardInput, boardTarget, cardInput, cardTarget, choiceTarget, contractFingerprint, createContractAuthoring, createReducerBundle, createStateQueries, createTableQueries, defineCardAction, defineEffect, defineEmptyView, defineGame, defineGameContract, defineInputs, defineInteraction, defineInteractionRule, definePhase, definePhaseStage, definePlayerView, defineSharedView, defineStage, defineStaticView, defineStepPhase, formInput, gameEvent, many, normalizeCommandParams, promptInput, rngInput, setActivePlayers, sparseCounts, sparseMap };
+/** 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 };