@dreamboard-games/sdk 0.2.1-alpha.1 → 0.3.0-alpha.1

package/dist/reducer.d.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod';
-import { C as CardCollection, V as ViewCard } from './cards-Sl3b40Mv.js';
-import { V as ViewSlotOccupant } from './slots-1GPGihk8.js';
-import { R as ReducerBundleContract } from './bundle-CDd5FKeD.js';
+import { CardCollection, ViewCard, ViewSlotOccupant } from './types.js';
+import { a as ReducerBundleContract } from './index.d-BGqVifr_.js';
 
 /**
  * Opaque brand applied to a runtime player identifier.
@@ -2311,6 +2310,7 @@ type EffectContinuationCallable<DataSchema extends AnySchema, State extends {
         currentPhase: string;
     };
 }, Manifest extends ManifestContract<TableOfState<State>>, ContinuationId extends string = string, Kind extends ResumableEffectKind = ResumableEffectKind> = ContinuationCallable<DataSchema, State, Manifest, ContinuationId, Kind>;
+
 /**
  * `rollDie` effect. Resolves a `rollDie` wire effect. `reduce` / `context`
  * are both optional so authors can fire-and-forget a die roll without
@@ -2373,181 +2373,7 @@ type EffectMap<State extends {
         currentPhase: string;
     };
 }, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, EffectDefinition<State, Manifest>>;
-type SimultaneousSubmission<Collectors extends Record<string, InputCollector>, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-}> = {
-    playerId: PlayerIdOfState<State>;
-    params: ParamsOf<Collectors>;
-};
-type SimultaneousResolveArgs<Collectors extends Record<string, InputCollector>, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & RuntimeHelpers<State> & MutationRuntimeHelpers & {
-    state: State;
-    submissions: Record<PlayerIdOfState<State>, SimultaneousSubmission<Collectors, State>>;
-    submittedPlayerIds: PlayerIdOfState<State>[];
-    waitingPlayerIds: PlayerIdOfState<State>[];
-};
-type SimultaneousSubmitSpec<Collectors extends Record<string, InputCollector> = Record<string, InputCollector>, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-} = {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-}, Manifest extends ManifestContract<TableOfState<State>> = ManifestContract<TableOfState<State>>> = Omit<InteractionSpec<Collectors, State, Manifest>, "reduce"> & {
-    /**
-     * Optional compatibility slot for callers that reuse `defineInteraction`.
-     * The simultaneous phase barrier stores submissions and invokes the
-     * phase-level `resolve`; this per-submission reducer is intentionally
-     * ignored when present.
-     */
-    reduce?: InteractionSpec<Collectors, State, Manifest>["reduce"];
-};
-type PhaseDefinitionCommon<PhaseStateSchema extends SchemaLike<object>, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-    phase: object;
-}, Manifest extends ManifestContract<TableOfState<State>>> = {
-    name?: string;
-    state: PhaseStateSchema;
-    initialState?: (ctx: {
-        manifest: Manifest;
-        state: State;
-        playerIds: PlayerIdOfState<State>[];
-        setup: SetupSelectionOfManifest<Manifest> | null;
-    }) => z.infer<PhaseStateSchema>;
-    enter?: BivariantCallback<PhaseEnterArgs<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>, ReducerResult<ScopedPhaseState<State, z.infer<PhaseStateSchema>>> | void>;
-};
-type AutoPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-    phase: object;
-}, Manifest extends ManifestContract<TableOfState<State>>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
-    kind: "auto";
-    actor?: never;
-    actors?: never;
-    submit?: never;
-    canResubmit?: never;
-    resolve?: never;
-    effects?: never;
-    interactions?: never;
-    stages?: never;
-    zones?: never;
-    cardActions?: never;
-};
-type PlayerPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-    phase: object;
-}, Manifest extends ManifestContract<TableOfState<State>>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
-    kind: "player";
-    /**
-     * Default actor selector for interactions in this phase. When omitted the
-     * runtime falls back to `flow.activePlayers`, preserving the existing turn
-     * ownership model. Returning multiple players models simultaneous actors.
-     */
-    actor?: ActorSelector<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
-    actors?: never;
-    submit?: never;
-    canResubmit?: never;
-    resolve?: never;
-    effects?: Effects;
-    interactions?: Interactions;
-    stages?: Stages;
-    zones?: Zones;
-    cardActions?: CardActions;
-};
-type SimultaneousPlayerPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-    phase: object;
-}, Manifest extends ManifestContract<TableOfState<State>>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
-    kind: "simultaneousPlayer";
-    actor?: never;
-    /**
-     * Actor selector for `kind: "simultaneousPlayer"` phases. This is an alias
-     * of `actor` with wording that matches simultaneous submission semantics.
-     */
-    actors: ActorSelector<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
-    /**
-     * Canonical sealed submission interaction for simultaneous phases. It is
-     * projected like a normal interaction, but the trusted runtime stores the
-     * parsed params until every actor has submitted, then calls `resolve`.
-     */
-    submit: SimultaneousSubmitSpec<SubmitCollectors, ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
-    /**
-     * When false or omitted, each actor can submit once per simultaneous
-     * barrier. Set true to allow replacing the sealed submission before every
-     * required actor has submitted.
-     */
-    canResubmit?: boolean;
-    /**
-     * Batch resolver invoked once all simultaneous actors have submitted. The
-     * submitted params are passed together so game state mutates from one
-     * deterministic base state instead of one player at a time.
-     */
-    resolve: BivariantCallback<SimultaneousResolveArgs<SubmitCollectors, ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>, ReducerResult<ScopedPhaseState<State, z.infer<PhaseStateSchema>>>>;
-    effects?: Effects;
-    interactions?: Interactions;
-    stages?: Stages;
-    zones?: Zones;
-    cardActions?: CardActions;
-};
-type PhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-    phase: object;
-}, Manifest extends ManifestContract<TableOfState<State>>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = AutoPhaseDefinition<PhaseStateSchema, State, Manifest> | PlayerPhaseDefinition<PhaseStateSchema, State, Manifest, Effects, Interactions, Stages, Zones, CardActions> | SimultaneousPlayerPhaseDefinition<PhaseStateSchema, State, Manifest, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>;
-type ViewDefinition<State extends {
-    table: RuntimeTableRecord;
-    flow: {
-        currentPhase: string;
-    };
-}, Manifest extends ManifestContract<TableOfState<State>>, Projection = unknown> = {
-    project: (args: ActionContext<State, Manifest> & RuntimeHelpers<State> & {
-        state: State;
-        playerId: PlayerIdOfState<State>;
-        runtime: State extends {
-            runtime: infer RuntimeStateValue;
-        } ? RuntimeStateValue : never;
-    }) => Projection;
-};
-/**
- * Session-scoped, once-per-init view. The `project` callback receives only
- * the authored manifest — the mutable-state helpers (`state`, `playerId`,
- * `runtime`, `fx`, `ops`, `accept`, `reject`, `q`) that `ViewDefinition.project`
- * exposes are structurally absent, so an author cannot accidentally project
- * per-tick state into the payload. The host calls this once per reducer
- * session, caches the result, and merges it back into every seat view on
- * the client. Moving static board topology here is what lets the adapter
- * skip the ~87% of `projectSeatsDynamic` wall time that used to re-serialize
- * manifest-sourced fields on every input.
- */
-type StaticViewDefinition<Manifest extends ManifestContract<RuntimeTableRecord>, Projection = unknown> = {
-    project: (args: {
-        manifest: Manifest;
-        q: StaticViewQueries<Manifest>;
-    }) => Projection;
-};
+
 type InputCollectorKind = "form" | "board-vertex" | "board-edge" | "board-tile" | "board-space" | "card" | "prompt" | "rng";
 type TargetKind = "edge" | "vertex" | "space" | "tile" | "card";
 type BoardInputCollectorKind = Exclude<InputCollectorKind, "form" | "card" | "prompt" | "rng">;
@@ -2766,6 +2592,7 @@ type EngineSampledCollectorKeys<Collectors extends Record<string, InputCollector
 type ClientParamsOf<Collectors extends Record<string, InputCollector>> = {
     [K in keyof Collectors as K extends EngineSampledCollectorKeys<Collectors> ? never : K]: Collectors[K] extends InputCollector<infer S> ? S extends SchemaLike<infer V> ? V : never : never;
 };
+
 type InteractionReduceInput<Collectors extends Record<string, InputCollector>, State extends {
     table: RuntimeTableRecord;
     flow: {
@@ -3012,6 +2839,184 @@ type StageMap<State extends {
 }, Manifest extends ManifestContract<TableOfState<State>>> = Record<string, StageSpec<State, Manifest>>;
 type PhaseZoneList<Manifest extends ManifestContract<RuntimeTableRecord>> = readonly PlayerZoneIdOfManifest<Manifest>[];
 
+type SimultaneousSubmission<Collectors extends Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}> = {
+    playerId: PlayerIdOfState<State>;
+    params: ParamsOf<Collectors>;
+};
+type SimultaneousResolveArgs<Collectors extends Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>> = ActionContext<State, Manifest> & RuntimeHelpers<State> & MutationRuntimeHelpers & {
+    state: State;
+    submissions: Record<PlayerIdOfState<State>, SimultaneousSubmission<Collectors, State>>;
+    submittedPlayerIds: PlayerIdOfState<State>[];
+    waitingPlayerIds: PlayerIdOfState<State>[];
+};
+type SimultaneousSubmitSpec<Collectors extends Record<string, InputCollector> = Record<string, InputCollector>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+} = {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>> = ManifestContract<TableOfState<State>>> = Omit<InteractionSpec<Collectors, State, Manifest>, "reduce"> & {
+    /**
+     * Optional compatibility slot for callers that reuse `defineInteraction`.
+     * The simultaneous phase barrier stores submissions and invokes the
+     * phase-level `resolve`; this per-submission reducer is intentionally
+     * ignored when present.
+     */
+    reduce?: InteractionSpec<Collectors, State, Manifest>["reduce"];
+};
+
+type PhaseDefinitionCommon<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>> = {
+    name?: string;
+    state: PhaseStateSchema;
+    initialState?: (ctx: {
+        manifest: Manifest;
+        state: State;
+        playerIds: PlayerIdOfState<State>[];
+        setup: SetupSelectionOfManifest<Manifest> | null;
+    }) => z.infer<PhaseStateSchema>;
+    enter?: BivariantCallback<PhaseEnterArgs<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>, ReducerResult<ScopedPhaseState<State, z.infer<PhaseStateSchema>>> | void>;
+};
+type AutoPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
+    kind: "auto";
+    actor?: never;
+    actors?: never;
+    submit?: never;
+    canResubmit?: never;
+    resolve?: never;
+    effects?: never;
+    interactions?: never;
+    stages?: never;
+    zones?: never;
+    cardActions?: never;
+};
+type PlayerPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
+    kind: "player";
+    /**
+     * Default actor selector for interactions in this phase. When omitted the
+     * runtime falls back to `flow.activePlayers`, preserving the existing turn
+     * ownership model. Returning multiple players models simultaneous actors.
+     */
+    actor?: ActorSelector<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
+    actors?: never;
+    submit?: never;
+    canResubmit?: never;
+    resolve?: never;
+    effects?: Effects;
+    interactions?: Interactions;
+    stages?: Stages;
+    zones?: Zones;
+    cardActions?: CardActions;
+};
+type SimultaneousPlayerPhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = PhaseDefinitionCommon<PhaseStateSchema, State, Manifest> & {
+    kind: "simultaneousPlayer";
+    actor?: never;
+    /**
+     * Actor selector for `kind: "simultaneousPlayer"` phases. This is an alias
+     * of `actor` with wording that matches simultaneous submission semantics.
+     */
+    actors: ActorSelector<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
+    /**
+     * Canonical sealed submission interaction for simultaneous phases. It is
+     * projected like a normal interaction, but the trusted runtime stores the
+     * parsed params until every actor has submitted, then calls `resolve`.
+     */
+    submit: SimultaneousSubmitSpec<SubmitCollectors, ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>;
+    /**
+     * When false or omitted, each actor can submit once per simultaneous
+     * barrier. Set true to allow replacing the sealed submission before every
+     * required actor has submitted.
+     */
+    canResubmit?: boolean;
+    /**
+     * Batch resolver invoked once all simultaneous actors have submitted. The
+     * submitted params are passed together so game state mutates from one
+     * deterministic base state instead of one player at a time.
+     */
+    resolve: BivariantCallback<SimultaneousResolveArgs<SubmitCollectors, ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest>, ReducerResult<ScopedPhaseState<State, z.infer<PhaseStateSchema>>>>;
+    effects?: Effects;
+    interactions?: Interactions;
+    stages?: Stages;
+    zones?: Zones;
+    cardActions?: CardActions;
+};
+type PhaseDefinition<PhaseStateSchema extends SchemaLike<object>, State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+    phase: object;
+}, Manifest extends ManifestContract<TableOfState<State>>, SubmitCollectors extends Record<string, InputCollector> = Record<string, InputCollector>, Effects extends EffectMap<State, Manifest> = Record<string, never>, Interactions extends InteractionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Stages extends StageMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>, Zones extends PhaseZoneList<Manifest> = readonly [], CardActions extends CardActionMap<ScopedPhaseState<State, z.infer<PhaseStateSchema>>, Manifest> = Record<string, never>> = AutoPhaseDefinition<PhaseStateSchema, State, Manifest> | PlayerPhaseDefinition<PhaseStateSchema, State, Manifest, Effects, Interactions, Stages, Zones, CardActions> | SimultaneousPlayerPhaseDefinition<PhaseStateSchema, State, Manifest, SubmitCollectors, Effects, Interactions, Stages, Zones, CardActions>;
+
+type ViewDefinition<State extends {
+    table: RuntimeTableRecord;
+    flow: {
+        currentPhase: string;
+    };
+}, Manifest extends ManifestContract<TableOfState<State>>, Projection = unknown> = {
+    project: (args: ActionContext<State, Manifest> & RuntimeHelpers<State> & {
+        state: State;
+        playerId: PlayerIdOfState<State>;
+        runtime: State extends {
+            runtime: infer RuntimeStateValue;
+        } ? RuntimeStateValue : never;
+    }) => Projection;
+};
+/**
+ * Session-scoped, once-per-init view. The `project` callback receives only
+ * the authored manifest — the mutable-state helpers (`state`, `playerId`,
+ * `runtime`, `fx`, `ops`, `accept`, `reject`, `q`) that `ViewDefinition.project`
+ * exposes are structurally absent, so an author cannot accidentally project
+ * per-tick state into the payload. The host calls this once per reducer
+ * session, caches the result, and merges it back into every seat view on
+ * the client. Moving static board topology here is what lets the adapter
+ * skip the ~87% of `projectSeatsDynamic` wall time that used to re-serialize
+ * manifest-sourced fields on every input.
+ */
+type StaticViewDefinition<Manifest extends ManifestContract<RuntimeTableRecord>, Projection = unknown> = {
+    project: (args: {
+        manifest: Manifest;
+        q: StaticViewQueries<Manifest>;
+    }) => Projection;
+};
+
 /**
  * Structural upper bound for reducer game contracts accepted by the
  * authoring-level `define*` factories. The `manifest` slot admits any
@@ -3771,12 +3776,13 @@ declare function seedSharedBoardSpace<Manifest extends GeneratedManifestContract
     componentIds?: readonly (CardIdOfManifest<Manifest> | PieceIdOfManifest<Manifest> | DieIdOfManifest<Manifest>)[];
 }): SetupBootstrapStep<Manifest>;
 
+declare function assertCardAllowedInContainer<Table extends RuntimeTableRecord, BoardId extends BoardIdOfTable<NoInfer<Table>>, ContainerId extends BoardContainerIdOfTable<NoInfer<Table>, BoardId>>(table: Table, boardId: BoardId, containerId: ContainerId, componentId: string): void;
+
 declare function setActivePlayers<State extends {
     flow: {
         activePlayers: PlayerIdOfState<State>[];
     };
 }>(state: State, activePlayers: PlayerIdOfState<State>[]): State;
-declare function assertCardAllowedInContainer<Table extends RuntimeTableRecord, BoardId extends BoardIdOfTable<NoInfer<Table>>, ContainerId extends BoardContainerIdOfTable<NoInfer<Table>, BoardId>>(table: Table, boardId: BoardId, containerId: ContainerId, componentId: string): void;
 
 declare function createTableQueries<Table extends RuntimeTableRecord>(table: Table): TableQueries<Table>;
 declare function createStateQueries<State extends {