@dreamboard-games/sdk 0.5.0-alpha.7 → 0.5.0-alpha.9

package/dist/{chunk-K75F5UIJ.js → chunk-FUYMFUXO.js}

@@ -1,104 +1,120 @@
 import {
   PlayerBoardSpaceTargetSchema,
   __export
-} from "./chunk-3JXUL4VN.js";
+} from "./chunk-DPRHGA2C.js";
 
 // src/shared/runtime-json.ts
-import { z } from "zod";
+import * as z from "zod";
+import { en } from "zod/locales";
+z.config(en());
 var RuntimeJsonSchema = z.json();
 
+// src/shared/domain/cards.ts
+import * as z2 from "zod";
+var ViewCardSchema = z2.strictObject({
+  id: z2.string(),
+  cardType: z2.string(),
+  name: z2.string().optional(),
+  text: z2.string().optional(),
+  /** Manifest asset path; game UIs receive a loadable URL. */
+  frontImage: z2.string().optional(),
+  /** Manifest asset path; game UIs receive a loadable URL. */
+  backImage: z2.string().optional(),
+  properties: z2.record(z2.string(), RuntimeJsonSchema)
+});
+
 // src/shared/interaction-schema.ts
-import { z as z2 } from "zod";
-var InteractionCommitPolicySchema = z2.discriminatedUnion("mode", [
-  z2.object({ mode: z2.literal("manual") }).strict(),
-  z2.object({ mode: z2.literal("autoWhenReady") }).strict()
+import * as z3 from "zod";
+var InteractionCommitPolicySchema = z3.discriminatedUnion("mode", [
+  z3.object({ mode: z3.literal("manual") }).strict(),
+  z3.object({ mode: z3.literal("autoWhenReady") }).strict()
 ]);
-var InputSelectionSchema = z2.discriminatedUnion("mode", [
-  z2.object({ mode: z2.literal("single") }).strict(),
-  z2.object({
-    mode: z2.literal("many"),
-    min: z2.number().int(),
-    max: z2.number().int().optional(),
-    distinct: z2.boolean().optional()
+var InputSelectionSchema = z3.discriminatedUnion("mode", [
+  z3.object({ mode: z3.literal("single") }).strict(),
+  z3.object({
+    mode: z3.literal("many"),
+    min: z3.number().int(),
+    max: z3.number().int().optional(),
+    distinct: z3.boolean().optional()
   }).strict()
 ]);
-var InteractionChoiceOptionSchema = z2.object({
-  value: z2.string().nullable(),
-  label: z2.string(),
-  icon: z2.string().optional(),
-  badge: z2.string().optional(),
-  description: z2.string().optional(),
-  disabled: z2.boolean().optional(),
-  disabledReason: z2.string().optional()
+var InteractionChoiceOptionSchema = z3.object({
+  value: z3.string().nullable(),
+  label: z3.string(),
+  icon: z3.string().optional(),
+  badge: z3.string().optional(),
+  description: z3.string().optional(),
+  disabled: z3.boolean().optional(),
+  disabledReason: z3.string().optional()
 }).strict();
 var selection = { selection: InputSelectionSchema.optional() };
-var InputDomainSchema = z2.discriminatedUnion("type", [
-  z2.strictObject({
-    type: z2.literal("cardTarget"),
-    projection: z2.literal("resolved"),
-    targetKind: z2.literal("card"),
-    zoneIds: z2.array(z2.string()),
-    eligibleTargets: z2.array(z2.string()),
+var InputDomainSchema = z3.discriminatedUnion("type", [
+  z3.strictObject({
+    type: z3.literal("cardTarget"),
+    projection: z3.literal("resolved"),
+    targetKind: z3.literal("card"),
+    zoneIds: z3.array(z3.string()),
+    eligibleTargets: z3.array(z3.string()),
     ...selection
   }),
-  z2.discriminatedUnion("valueKind", [
-    z2.strictObject({
-      type: z2.literal("boardTarget"),
-      projection: z2.literal("resolved"),
-      targetKind: z2.enum(["edge", "vertex", "space", "tile"]),
-      boardId: z2.string(),
-      valueKind: z2.literal("board-id"),
-      eligibleTargets: z2.array(z2.string()),
+  z3.discriminatedUnion("valueKind", [
+    z3.strictObject({
+      type: z3.literal("boardTarget"),
+      projection: z3.literal("resolved"),
+      targetKind: z3.enum(["edge", "vertex", "space", "tile"]),
+      boardId: z3.string(),
+      valueKind: z3.literal("board-id"),
+      eligibleTargets: z3.array(z3.string()),
       ...selection
     }),
-    z2.strictObject({
-      type: z2.literal("boardTarget"),
-      projection: z2.literal("resolved"),
-      targetKind: z2.literal("space"),
-      boardId: z2.string(),
-      valueKind: z2.literal("player-board-space"),
-      eligibleTargets: z2.array(PlayerBoardSpaceTargetSchema),
+    z3.strictObject({
+      type: z3.literal("boardTarget"),
+      projection: z3.literal("resolved"),
+      targetKind: z3.literal("space"),
+      boardId: z3.string(),
+      valueKind: z3.literal("player-board-space"),
+      eligibleTargets: z3.array(PlayerBoardSpaceTargetSchema),
       ...selection
     })
   ]),
-  z2.strictObject({
-    type: z2.literal("resourceMap"),
-    resources: z2.array(
-      z2.strictObject({
-        resourceId: z2.string(),
-        label: z2.string().optional(),
-        icon: z2.string().optional(),
-        min: z2.number(),
-        max: z2.number()
+  z3.strictObject({
+    type: z3.literal("resourceMap"),
+    resources: z3.array(
+      z3.strictObject({
+        resourceId: z3.string(),
+        label: z3.string().optional(),
+        icon: z3.string().optional(),
+        min: z3.number(),
+        max: z3.number()
       })
     ),
     ...selection
   }),
-  z2.strictObject({
-    type: z2.literal("boundedNumber"),
-    min: z2.number(),
-    max: z2.number(),
-    step: z2.number().optional(),
+  z3.strictObject({
+    type: z3.literal("boundedNumber"),
+    min: z3.number(),
+    max: z3.number(),
+    step: z3.number().optional(),
     ...selection
   }),
-  z2.strictObject({
-    type: z2.literal("choice"),
-    choices: z2.array(InteractionChoiceOptionSchema),
+  z3.strictObject({
+    type: z3.literal("choice"),
+    choices: z3.array(InteractionChoiceOptionSchema),
     ...selection
   }),
-  z2.strictObject({
-    type: z2.literal("choiceList"),
-    choices: z2.array(
-      InteractionChoiceOptionSchema.extend({ value: z2.string() })
+  z3.strictObject({
+    type: z3.literal("choiceList"),
+    choices: z3.array(
+      InteractionChoiceOptionSchema.extend({ value: z3.string() })
     ),
-    min: z2.number().int().optional(),
-    max: z2.number().int().optional(),
+    min: z3.number().int().optional(),
+    max: z3.number().int().optional(),
     ...selection
   })
 ]);
-var InteractionInputDescriptorSchema = z2.object({
-  key: z2.string().min(1),
-  kind: z2.enum([
+var InteractionInputDescriptorSchema = z3.object({
+  key: z3.string().min(1),
+  kind: z3.enum([
     "form",
     "board-vertex",
     "board-edge",
@@ -110,50 +126,50 @@ var InteractionInputDescriptorSchema = z2.object({
   domain: InputDomainSchema,
   defaultValue: RuntimeJsonSchema.optional()
 }).strict();
-var InteractionAvailabilitySchema = z2.discriminatedUnion("status", [
-  z2.object({ status: z2.literal("available") }).strict(),
-  z2.object({ status: z2.literal("notYourTurn"), reason: z2.string() }).strict(),
-  z2.object({
-    status: z2.literal("blocked"),
-    reason: z2.string(),
-    code: z2.string().optional()
+var InteractionAvailabilitySchema = z3.discriminatedUnion("status", [
+  z3.object({ status: z3.literal("available") }).strict(),
+  z3.object({ status: z3.literal("notYourTurn"), reason: z3.string() }).strict(),
+  z3.object({
+    status: z3.literal("blocked"),
+    reason: z3.string(),
+    code: z3.string().optional()
   }).strict()
 ]);
-var InteractionBaseSchema = z2.object({
-  phaseName: z2.string().min(1),
-  interactionKey: z2.string().min(1),
-  interactionId: z2.string().min(1),
-  label: z2.string().min(1),
-  help: z2.string().optional(),
-  zoneId: z2.string().optional(),
-  zoneIds: z2.array(z2.string()).optional(),
+var InteractionBaseSchema = z3.object({
+  phaseName: z3.string().min(1),
+  interactionKey: z3.string().min(1),
+  interactionId: z3.string().min(1),
+  label: z3.string().min(1),
+  help: z3.string().optional(),
+  zoneId: z3.string().optional(),
+  zoneIds: z3.array(z3.string()).optional(),
   commit: InteractionCommitPolicySchema,
-  descriptorDigest: z2.string().optional(),
-  actorSeat: z2.number().int().optional(),
-  draftDigest: z2.string().optional(),
-  inputs: z2.array(InteractionInputDescriptorSchema),
-  step: z2.object({
-    index: z2.number().int().nonnegative(),
-    total: z2.number().int().positive(),
-    selected: z2.record(z2.string(), RuntimeJsonSchema),
-    canCancel: z2.boolean()
+  descriptorDigest: z3.string().optional(),
+  actorSeat: z3.number().int().optional(),
+  draftDigest: z3.string().optional(),
+  inputs: z3.array(InteractionInputDescriptorSchema),
+  step: z3.object({
+    index: z3.number().int().nonnegative(),
+    total: z3.number().int().positive(),
+    selected: z3.record(z3.string(), RuntimeJsonSchema),
+    canCancel: z3.boolean()
   }).strict().optional(),
   availability: InteractionAvailabilitySchema,
-  reasons: z2.array(
-    z2.object({
-      ruleId: z2.string(),
-      errorCode: z2.string()
+  reasons: z3.array(
+    z3.object({
+      ruleId: z3.string(),
+      errorCode: z3.string()
     }).strict()
   ).optional()
 }).strict();
 var InteractionDescriptorSchema = InteractionBaseSchema.extend({
-  kind: z2.literal("action")
+  kind: z3.literal("action")
 }).strict();
-var ZoneInteractionRefsSchema = z2.strictObject({
-  cardIds: z2.array(z2.string()),
-  cardViewsById: z2.record(z2.string(), z2.string()),
-  cardBacksById: z2.record(z2.string(), z2.string()),
-  playableByCardId: z2.record(z2.string(), z2.array(z2.string()))
+var ZoneInteractionRefsSchema = z3.strictObject({
+  cardIds: z3.array(z3.string()),
+  cardViewsById: z3.record(z3.string(), ViewCardSchema),
+  cardBacksById: z3.record(z3.string(), z3.string()),
+  playableByCardId: z3.record(z3.string(), z3.array(z3.string()))
 });
 
 // src/shared/runtime-schema.ts
@@ -210,275 +226,275 @@ __export(runtime_schema_exports, {
   SystemActionEventSchema: () => SystemActionEventSchema,
   TransitionRecordSchema: () => TransitionRecordSchema
 });
-import { z as z3 } from "zod";
-var ReducerContractVersionSchema = z3.string().regex(new RegExp("^[0-9]+\\.[0-9]+\\.[0-9]+$"));
-var RngOperationParameterSchema = z3.union([
-  z3.string(),
-  z3.number().finite(),
-  z3.boolean()
+import * as z4 from "zod";
+var ReducerContractVersionSchema = z4.string().regex(new RegExp("^[0-9]+\\.[0-9]+\\.[0-9]+$"));
+var RngOperationParameterSchema = z4.union([
+  z4.string(),
+  z4.number().finite(),
+  z4.boolean()
 ]);
-var RngOperationSchema = z3.strictObject({
-  kind: z3.string().min(1),
-  parameters: z3.record(z3.string(), RngOperationParameterSchema)
-});
-var RngDrawSchema = z3.strictObject({
-  index: z3.number().int().gte(0),
-  cursorBefore: z3.number().int().gte(0),
-  cursorAfter: z3.number().int().gte(0),
+var RngOperationSchema = z4.strictObject({
+  kind: z4.string().min(1),
+  parameters: z4.record(z4.string(), RngOperationParameterSchema)
+});
+var RngDrawSchema = z4.strictObject({
+  index: z4.number().int().gte(0),
+  cursorBefore: z4.number().int().gte(0),
+  cursorAfter: z4.number().int().gte(0),
   operation: RngOperationSchema
 });
-var RngStateSchema = z3.strictObject({
-  seed: z3.union([
-    z3.number().refine(Number.isInteger, { message: "Expected integer" }),
-    z3.null()
+var RngStateSchema = z4.strictObject({
+  seed: z4.union([
+    z4.number().refine(Number.isInteger, { message: "Expected integer" }),
+    z4.null()
   ]),
-  cursor: z3.number().int(),
-  trace: z3.array(z3.string()),
-  draws: z3.array(RngDrawSchema).optional()
-});
-var ReducerFlowStateSchema = z3.strictObject({
-  currentPhase: z3.string().min(1),
-  turn: z3.number().int(),
-  round: z3.number().int(),
-  activePlayers: z3.array(z3.string().min(1))
-});
-var RuntimeSimultaneousSubmissionSchema = z3.strictObject({
-  interactionId: z3.string().min(1),
+  cursor: z4.number().int(),
+  trace: z4.array(z4.string()),
+  draws: z4.array(RngDrawSchema).optional()
+});
+var ReducerFlowStateSchema = z4.strictObject({
+  currentPhase: z4.string().min(1),
+  turn: z4.number().int(),
+  round: z4.number().int(),
+  activePlayers: z4.array(z4.string().min(1))
+});
+var RuntimeSimultaneousSubmissionSchema = z4.strictObject({
+  interactionId: z4.string().min(1),
   params: RuntimeJsonSchema
 });
-var RuntimeSimultaneousCurrentSchema = z3.strictObject({
-  phaseName: z3.string().min(1),
-  actors: z3.array(z3.string().min(1)),
-  submissions: z3.record(z3.string(), RuntimeSimultaneousSubmissionSchema)
+var RuntimeSimultaneousCurrentSchema = z4.strictObject({
+  phaseName: z4.string().min(1),
+  actors: z4.array(z4.string().min(1)),
+  submissions: z4.record(z4.string(), RuntimeSimultaneousSubmissionSchema)
 });
-var RuntimeSimultaneousStateSchema = z3.strictObject({
-  current: z3.union([RuntimeSimultaneousCurrentSchema, z3.null()])
+var RuntimeSimultaneousStateSchema = z4.strictObject({
+  current: z4.union([RuntimeSimultaneousCurrentSchema, z4.null()])
 });
-var TransitionRecordSchema = z3.strictObject({
-  from: z3.string().min(1),
-  to: z3.string().min(1)
+var TransitionRecordSchema = z4.strictObject({
+  from: z4.string().min(1),
+  to: z4.string().min(1)
 });
-var RuntimePendingInteractionSchema = z3.strictObject({
-  phaseName: z3.string().min(1),
-  interactionId: z3.string().min(1),
-  values: z3.array(RuntimeJsonSchema).min(1)
+var RuntimePendingInteractionSchema = z4.strictObject({
+  phaseName: z4.string().min(1),
+  interactionId: z4.string().min(1),
+  values: z4.array(RuntimeJsonSchema).min(1)
 });
-var GameEventDetailSchema = z3.strictObject({
-  label: z3.string().min(1),
-  value: z3.union([z3.string(), z3.number().finite(), z3.boolean()])
+var GameEventDetailSchema = z4.strictObject({
+  label: z4.string().min(1),
+  value: z4.union([z4.string(), z4.number().finite(), z4.boolean()])
 });
-var SystemActionEventSchema = z3.strictObject({
-  kind: z3.literal("systemAction"),
-  procedureId: z3.string().min(1),
-  title: z3.string().min(1),
-  summary: z3.string().min(1).optional(),
-  details: z3.array(GameEventDetailSchema).max(16).optional()
+var SystemActionEventSchema = z4.strictObject({
+  kind: z4.literal("systemAction"),
+  procedureId: z4.string().min(1),
+  title: z4.string().min(1),
+  summary: z4.string().min(1).optional(),
+  details: z4.array(GameEventDetailSchema).max(16).optional()
 });
-var GameEventSchema = z3.discriminatedUnion("kind", [
+var GameEventSchema = z4.discriminatedUnion("kind", [
   SystemActionEventSchema
 ]);
-var ReducerRuntimeStateSchema = z3.strictObject({
-  events: z3.array(GameEventSchema).max(32),
+var ReducerRuntimeStateSchema = z4.strictObject({
+  events: z4.array(GameEventSchema).max(32),
   rng: RngStateSchema,
-  pending: z3.record(z3.string(), RuntimePendingInteractionSchema),
+  pending: z4.record(z4.string(), RuntimePendingInteractionSchema),
   simultaneous: RuntimeSimultaneousStateSchema,
-  lastTransition: z3.union([TransitionRecordSchema, z3.null()]),
-  options: z3.record(z3.string(), RuntimeJsonSchema)
+  lastTransition: z4.union([TransitionRecordSchema, z4.null()]),
+  options: z4.record(z4.string(), RuntimeJsonSchema)
 });
-var ReducerDomainStateSchema = z3.strictObject({
+var ReducerDomainStateSchema = z4.strictObject({
   table: RuntimeJsonSchema,
   publicState: RuntimeJsonSchema,
-  privateState: z3.record(z3.string(), RuntimeJsonSchema),
+  privateState: z4.record(z4.string(), RuntimeJsonSchema),
   hiddenState: RuntimeJsonSchema,
   flow: ReducerFlowStateSchema,
   phase: RuntimeJsonSchema
 });
-var ReducerSessionStateSchema = z3.strictObject({
+var ReducerSessionStateSchema = z4.strictObject({
   domain: ReducerDomainStateSchema,
   runtime: ReducerRuntimeStateSchema
 });
-var GameInputInteractionSchema = z3.strictObject({
-  kind: z3.literal("interaction"),
-  playerId: z3.string().min(1),
-  interactionId: z3.string().min(1),
+var GameInputInteractionSchema = z4.strictObject({
+  kind: z4.literal("interaction"),
+  playerId: z4.string().min(1),
+  interactionId: z4.string().min(1),
   params: RuntimeJsonSchema
 });
-var GameInputCancelSchema = z3.strictObject({
-  kind: z3.literal("interaction.cancel"),
-  playerId: z3.string().min(1),
-  interactionId: z3.string().min(1)
+var GameInputCancelSchema = z4.strictObject({
+  kind: z4.literal("interaction.cancel"),
+  playerId: z4.string().min(1),
+  interactionId: z4.string().min(1)
 });
-var GameInputSchema = z3.discriminatedUnion("kind", [
+var GameInputSchema = z4.discriminatedUnion("kind", [
   GameInputInteractionSchema,
   GameInputCancelSchema
 ]);
-var GameOutcomeReasonSchema = z3.strictObject({
-  code: z3.string().min(1),
-  message: z3.string().min(1).optional()
+var GameOutcomeReasonSchema = z4.strictObject({
+  code: z4.string().min(1),
+  message: z4.string().min(1).optional()
 });
-var OutcomeResultSchema = z3.enum([
+var OutcomeResultSchema = z4.enum([
   "win",
   "draw",
   "loss",
   "eliminated"
 ]);
-var OutcomeScoreComponentSchema = z3.strictObject({
-  id: z3.string().min(1),
-  label: z3.string().min(1),
-  value: z3.number().finite()
-});
-var OutcomeTieBreakSchema = z3.strictObject({
-  id: z3.string().min(1),
-  label: z3.string().min(1),
-  value: z3.union([z3.number().finite(), z3.string()])
-});
-var OutcomeStandingSchema = z3.strictObject({
-  playerId: z3.string().min(1),
-  rank: z3.number().int().gte(1),
+var OutcomeScoreComponentSchema = z4.strictObject({
+  id: z4.string().min(1),
+  label: z4.string().min(1),
+  value: z4.number().finite()
+});
+var OutcomeTieBreakSchema = z4.strictObject({
+  id: z4.string().min(1),
+  label: z4.string().min(1),
+  value: z4.union([z4.number().finite(), z4.string()])
+});
+var OutcomeStandingSchema = z4.strictObject({
+  playerId: z4.string().min(1),
+  rank: z4.number().int().gte(1),
   result: OutcomeResultSchema,
-  score: z3.number().finite().optional(),
-  scoreBreakdown: z3.array(OutcomeScoreComponentSchema).optional(),
-  tieBreaks: z3.array(OutcomeTieBreakSchema).optional()
+  score: z4.number().finite().optional(),
+  scoreBreakdown: z4.array(OutcomeScoreComponentSchema).optional(),
+  tieBreaks: z4.array(OutcomeTieBreakSchema).optional()
 });
-var GameOutcomeSchema = z3.strictObject({
+var GameOutcomeSchema = z4.strictObject({
   reason: GameOutcomeReasonSchema,
-  standings: z3.array(OutcomeStandingSchema).min(1)
+  standings: z4.array(OutcomeStandingSchema).min(1)
 });
-var InitializeResultSchema = z3.strictObject({
+var InitializeResultSchema = z4.strictObject({
   state: ReducerSessionStateSchema,
   terminal: GameOutcomeSchema.optional(),
-  events: z3.array(GameEventSchema).optional()
+  events: z4.array(GameEventSchema).optional()
 });
-var InitializeRequestSchema = z3.strictObject({
+var InitializeRequestSchema = z4.strictObject({
   table: RuntimeJsonSchema,
-  playerIds: z3.array(z3.string().min(1)),
-  rngSeed: z3.union([
-    z3.number().refine(Number.isInteger, { message: "Expected integer" }),
-    z3.null()
+  playerIds: z4.array(z4.string().min(1)),
+  rngSeed: z4.union([
+    z4.number().refine(Number.isInteger, { message: "Expected integer" }),
+    z4.null()
   ]).optional(),
-  options: z3.record(z3.string(), RuntimeJsonSchema).optional()
+  options: z4.record(z4.string(), RuntimeJsonSchema).optional()
 });
-var DispatchRequestSchema = z3.strictObject({
+var DispatchRequestSchema = z4.strictObject({
   state: ReducerSessionStateSchema,
   input: GameInputSchema
 });
-var DispatchTraceAcceptedClientInputSchema = z3.strictObject({
-  kind: z3.literal("acceptedClientInput"),
+var DispatchTraceAcceptedClientInputSchema = z4.strictObject({
+  kind: z4.literal("acceptedClientInput"),
   input: GameInputSchema
 });
-var DispatchTracePhaseEnteredSchema = z3.strictObject({
-  kind: z3.literal("phaseEntered"),
-  from: z3.string(),
-  to: z3.string()
+var DispatchTracePhaseEnteredSchema = z4.strictObject({
+  kind: z4.literal("phaseEntered"),
+  from: z4.string(),
+  to: z4.string()
 });
-var DispatchTraceRngConsumptionSchema = z3.strictObject({
-  kind: z3.literal("rngConsumption"),
-  version: z3.literal(2),
-  operation: z3.string().min(1),
-  drawIndex: z3.number().int().gte(0),
-  traceEntry: z3.string()
+var DispatchTraceRngConsumptionSchema = z4.strictObject({
+  kind: z4.literal("rngConsumption"),
+  version: z4.literal(2),
+  operation: z4.string().min(1),
+  drawIndex: z4.number().int().gte(0),
+  traceEntry: z4.string()
 });
-var DispatchTraceSchema = z3.discriminatedUnion("kind", [
+var DispatchTraceSchema = z4.discriminatedUnion("kind", [
   DispatchTraceAcceptedClientInputSchema,
   DispatchTracePhaseEnteredSchema,
   DispatchTraceRngConsumptionSchema
 ]);
-var DispatchResultRejectSchema = z3.strictObject({
-  kind: z3.literal("reject"),
-  errorCode: z3.string().min(1),
-  message: z3.string().optional()
+var DispatchResultRejectSchema = z4.strictObject({
+  kind: z4.literal("reject"),
+  errorCode: z4.string().min(1),
+  message: z4.string().optional()
 });
-var DispatchResultAcceptSchema = z3.strictObject({
-  kind: z3.literal("accept"),
+var DispatchResultAcceptSchema = z4.strictObject({
+  kind: z4.literal("accept"),
   state: ReducerSessionStateSchema,
   terminal: GameOutcomeSchema.optional(),
-  trace: z3.array(DispatchTraceSchema),
-  events: z3.array(GameEventSchema).max(32)
+  trace: z4.array(DispatchTraceSchema),
+  events: z4.array(GameEventSchema).max(32)
 });
-var DispatchResultSchema = z3.discriminatedUnion("kind", [
+var DispatchResultSchema = z4.discriminatedUnion("kind", [
   DispatchResultRejectSchema,
   DispatchResultAcceptSchema
 ]);
-var ReducerRuntimeLogEntryAcceptedClientInputSchema = z3.strictObject({
-  kind: z3.literal("acceptedClientInput"),
-  version: z3.number().int(),
+var ReducerRuntimeLogEntryAcceptedClientInputSchema = z4.strictObject({
+  kind: z4.literal("acceptedClientInput"),
+  version: z4.number().int(),
   input: GameInputSchema
 });
-var ReducerRuntimeLogEntryPhaseEnteredSchema = z3.strictObject({
-  kind: z3.literal("phaseEntered"),
-  from: z3.string(),
-  to: z3.string(),
-  version: z3.number().int()
-});
-var ReducerRuntimeLogEntryRngConsumptionSchema = z3.strictObject({
-  kind: z3.literal("rngConsumption"),
-  version: z3.number().int(),
-  operation: z3.string().min(1),
-  drawIndex: z3.number().int().gte(0).optional(),
-  traceEntry: z3.string()
-});
-var ReducerRuntimeLogEntryStateCommitSchema = z3.strictObject({
-  kind: z3.literal("stateCommit"),
-  version: z3.number().int(),
+var ReducerRuntimeLogEntryPhaseEnteredSchema = z4.strictObject({
+  kind: z4.literal("phaseEntered"),
+  from: z4.string(),
+  to: z4.string(),
+  version: z4.number().int()
+});
+var ReducerRuntimeLogEntryRngConsumptionSchema = z4.strictObject({
+  kind: z4.literal("rngConsumption"),
+  version: z4.number().int(),
+  operation: z4.string().min(1),
+  drawIndex: z4.number().int().gte(0).optional(),
+  traceEntry: z4.string()
+});
+var ReducerRuntimeLogEntryStateCommitSchema = z4.strictObject({
+  kind: z4.literal("stateCommit"),
+  version: z4.number().int(),
   state: ReducerSessionStateSchema
 });
-var ReducerRuntimeLogEntrySchema = z3.discriminatedUnion("kind", [
+var ReducerRuntimeLogEntrySchema = z4.discriminatedUnion("kind", [
   ReducerRuntimeLogEntryAcceptedClientInputSchema,
   ReducerRuntimeLogEntryPhaseEnteredSchema,
   ReducerRuntimeLogEntryRngConsumptionSchema,
   ReducerRuntimeLogEntryStateCommitSchema
 ]);
-var AuthoredViewSchema = z3.object({
-  boards: z3.never({
+var AuthoredViewSchema = z4.object({
+  boards: z4.never({
     error: "The view field 'boards' is reserved for manifest geometry."
   }).optional()
 }).catchall(RuntimeJsonSchema);
-var SeatProjectionSchema = z3.strictObject({
+var SeatProjectionSchema = z4.strictObject({
   view: AuthoredViewSchema.nullable().optional(),
-  availableInteractionRefs: z3.array(z3.string()).optional(),
-  zones: z3.record(z3.string(), ZoneInteractionRefsSchema).optional(),
+  availableInteractionRefs: z4.array(z4.string()).optional(),
+  zones: z4.record(z4.string(), ZoneInteractionRefsSchema).optional(),
   /** Resource balances by player that this seat may see. */
-  resources: z3.record(z3.string(), z3.record(z3.string(), z3.number().int())).optional()
-});
-var SimultaneousPhaseProjectionSchema = z3.strictObject({
-  phaseName: z3.string().min(1),
-  interactionId: z3.string().min(1),
-  actorIds: z3.array(z3.string().min(1)),
-  sealedPlayerIds: z3.array(z3.string().min(1)),
-  pendingPlayerIds: z3.array(z3.string().min(1))
-});
-var SchedulerContinuationDependencySchema = z3.strictObject({
-  waiterPlayerId: z3.string().min(1),
-  blockerPlayerIds: z3.array(z3.string().min(1))
-});
-var SchedulerFlowAuthorityProjectionSchema = z3.strictObject({
-  version: z3.literal(1),
-  activePlayerIds: z3.array(z3.string().min(1)),
-  pendingPlayerIds: z3.array(z3.string().min(1)),
-  continuationDependencies: z3.array(SchedulerContinuationDependencySchema)
-});
-var ProjectionTimingMetadataSchema = z3.strictObject({
-  resolveAvailableInteractionsMs: z3.number().finite().gte(0),
-  resolveViewMs: z3.number().finite().gte(0),
-  resolveZoneHandlesMs: z3.number().finite().gte(0),
-  descriptorHashMs: z3.number().finite().gte(0)
-});
-var SeatProjectionBundleSchema = z3.strictObject({
-  events: z3.array(GameEventSchema).max(32),
-  simultaneousPhase: z3.union([SimultaneousPhaseProjectionSchema, z3.null()]).optional(),
+  resources: z4.record(z4.string(), z4.record(z4.string(), z4.number().int())).optional()
+});
+var SimultaneousPhaseProjectionSchema = z4.strictObject({
+  phaseName: z4.string().min(1),
+  interactionId: z4.string().min(1),
+  actorIds: z4.array(z4.string().min(1)),
+  sealedPlayerIds: z4.array(z4.string().min(1)),
+  pendingPlayerIds: z4.array(z4.string().min(1))
+});
+var SchedulerContinuationDependencySchema = z4.strictObject({
+  waiterPlayerId: z4.string().min(1),
+  blockerPlayerIds: z4.array(z4.string().min(1))
+});
+var SchedulerFlowAuthorityProjectionSchema = z4.strictObject({
+  version: z4.literal(1),
+  activePlayerIds: z4.array(z4.string().min(1)),
+  pendingPlayerIds: z4.array(z4.string().min(1)),
+  continuationDependencies: z4.array(SchedulerContinuationDependencySchema)
+});
+var ProjectionTimingMetadataSchema = z4.strictObject({
+  resolveAvailableInteractionsMs: z4.number().finite().gte(0),
+  resolveViewMs: z4.number().finite().gte(0),
+  resolveZoneHandlesMs: z4.number().finite().gte(0),
+  descriptorHashMs: z4.number().finite().gte(0)
+});
+var SeatProjectionBundleSchema = z4.strictObject({
+  events: z4.array(GameEventSchema).max(32),
+  simultaneousPhase: z4.union([SimultaneousPhaseProjectionSchema, z4.null()]).optional(),
   schedulerFlow: SchedulerFlowAuthorityProjectionSchema.optional(),
-  interactionsByRef: z3.record(z3.string(), InteractionDescriptorSchema).optional(),
-  seats: z3.record(z3.string(), SeatProjectionSchema),
+  interactionsByRef: z4.record(z4.string(), InteractionDescriptorSchema).optional(),
+  seats: z4.record(z4.string(), SeatProjectionSchema),
   timing: ProjectionTimingMetadataSchema.optional()
 });
-var ProjectRequestSchema = z3.strictObject({
+var ProjectRequestSchema = z4.strictObject({
   state: ReducerSessionStateSchema,
-  playerIds: z3.array(z3.string().min(1))
+  playerIds: z4.array(z4.string().min(1))
 });
-var BoardStaticProjectionSchema = z3.strictObject({
-  view: z3.record(z3.string(), RuntimeJsonSchema),
-  hash: z3.string().min(1),
-  manifestVersion: z3.string()
+var BoardStaticProjectionSchema = z4.strictObject({
+  view: z4.record(z4.string(), RuntimeJsonSchema),
+  hash: z4.string().min(1),
+  manifestVersion: z4.string()
 });
 
 // src/shared/hex-board.ts
@@ -818,6 +834,7 @@ function sha256Hex(input) {
 
 export {
   RuntimeJsonSchema,
+  ViewCardSchema,
   InteractionCommitPolicySchema,
   InputDomainSchema,
   InteractionInputDescriptorSchema,
@@ -845,4 +862,4 @@ export {
   encodeCanonicalPluginRuntimeJson,
   digestPluginRuntimeJson
 };
-//# sourceMappingURL=chunk-K75F5UIJ.js.map
+//# sourceMappingURL=chunk-FUYMFUXO.js.map