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

package/dist/chunk-U6R7FAH4.js

@@ -0,0 +1,630 @@
+import {
+  BoardProjectionSchema,
+  BoardSpaceTargetSchema,
+  GENERATED_ID_PREFIX,
+  PlayerIdSchema,
+  PlayerRosterSchema,
+  ProjectedTileSchema,
+  RuntimeJsonSchema,
+  SeatTileRefSchema,
+  __export
+} from "./chunk-CZRPUWCT.js";
+
+// src/shared/domain/cards.ts
+import * as z from "zod";
+var CARD_REFERENCE_PREFIX = "card-ref:";
+var HiddenCardIdSchema = z.string().regex(/^card-ref:sha256:[0-9a-f]{64}$/);
+function isHiddenCardId(id) {
+  return HiddenCardIdSchema.safeParse(id).success;
+}
+function isCardReferenceNamespace(id) {
+  return id.startsWith(CARD_REFERENCE_PREFIX);
+}
+var ViewCardSchema = z.strictObject({
+  id: z.string(),
+  cardType: z.string(),
+  name: z.string().optional(),
+  text: z.string().optional(),
+  /** Manifest asset path; game UIs receive a loadable URL. */
+  frontImage: z.string().optional(),
+  /** Manifest asset path; game UIs receive a loadable URL. */
+  backImage: z.string().optional(),
+  properties: z.record(z.string(), RuntimeJsonSchema)
+});
+
+// src/shared/interaction-schema.ts
+import * as z2 from "zod";
+var InteractionCommitPolicySchema = z2.discriminatedUnion("mode", [
+  z2.object({ mode: z2.literal("manual") }).strict(),
+  z2.object({ mode: z2.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()
+  }).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()
+}).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()),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("tileTarget"),
+    projection: z2.literal("resolved"),
+    targetKind: z2.literal("tile"),
+    zoneIds: z2.array(z2.string()),
+    boardIds: z2.array(z2.string()),
+    eligibleTargets: z2.array(SeatTileRefSchema),
+    ...selection
+  }),
+  z2.discriminatedUnion("valueKind", [
+    z2.strictObject({
+      type: z2.literal("boardTarget"),
+      projection: z2.literal("resolved"),
+      targetKind: z2.enum(["edge", "vertex", "space"]),
+      boardId: z2.string(),
+      valueKind: z2.literal("board-id"),
+      eligibleTargets: z2.array(z2.string()),
+      ...selection
+    }),
+    z2.strictObject({
+      type: z2.literal("boardTarget"),
+      projection: z2.literal("resolved"),
+      targetKind: z2.literal("space"),
+      boardBaseId: z2.string(),
+      valueKind: z2.literal("board-space"),
+      eligibleTargets: z2.array(BoardSpaceTargetSchema),
+      ...selection
+    })
+  ]),
+  z2.strictObject({
+    type: z2.literal("zonePosition"),
+    /** Each zone host a component may be placed in, and how many it holds now. */
+    zones: z2.array(
+      z2.strictObject({
+        zoneId: z2.string(),
+        hostId: z2.string(),
+        size: z2.number().int().nonnegative()
+      })
+    ),
+    ...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()
+      })
+    ),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("boundedNumber"),
+    min: z2.number(),
+    max: z2.number(),
+    step: z2.number().optional(),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("choice"),
+    choices: z2.array(InteractionChoiceOptionSchema),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("choiceList"),
+    choices: z2.array(
+      InteractionChoiceOptionSchema.extend({ value: z2.string() })
+    ),
+    min: z2.number().int().optional(),
+    max: z2.number().int().optional(),
+    ...selection
+  })
+]);
+var InteractionInputDescriptorSchema = z2.object({
+  key: z2.string().min(1),
+  kind: z2.enum([
+    "form",
+    "board-vertex",
+    "board-edge",
+    "tile",
+    "board-space",
+    "card",
+    "position",
+    "rng"
+  ]),
+  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()
+  }).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(),
+  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()
+  }).strict().optional(),
+  availability: InteractionAvailabilitySchema,
+  reasons: z2.array(
+    z2.object({
+      ruleId: z2.string(),
+      errorCode: z2.string()
+    }).strict()
+  ).optional()
+}).strict();
+var InteractionDescriptorSchema = InteractionBaseSchema.extend({
+  kind: z2.literal("action")
+}).strict();
+var ZoneInteractionRefsSchema = z2.strictObject({
+  tiles: z2.array(ProjectedTileSchema),
+  cardIds: z2.array(z2.string()),
+  cardViewsById: z2.record(z2.string(), ViewCardSchema),
+  cardBacksById: z2.record(z2.string(), z2.string()),
+  playableByCardId: z2.record(z2.string(), z2.array(z2.string()))
+});
+
+// src/shared/runtime-schema.ts
+var runtime_schema_exports = {};
+__export(runtime_schema_exports, {
+  AuthoredViewSchema: () => AuthoredViewSchema,
+  BoardProjectionSchema: () => BoardProjectionSchema,
+  DispatchRequestSchema: () => DispatchRequestSchema,
+  DispatchResultAcceptSchema: () => DispatchResultAcceptSchema,
+  DispatchResultRejectSchema: () => DispatchResultRejectSchema,
+  DispatchResultSchema: () => DispatchResultSchema,
+  DispatchTraceAcceptedClientInputSchema: () => DispatchTraceAcceptedClientInputSchema,
+  DispatchTracePhaseEnteredSchema: () => DispatchTracePhaseEnteredSchema,
+  DispatchTraceRngConsumptionSchema: () => DispatchTraceRngConsumptionSchema,
+  DispatchTraceSchema: () => DispatchTraceSchema,
+  EventAudienceSchema: () => EventAudienceSchema,
+  GameEventDetailSchema: () => GameEventDetailSchema,
+  GameEventSchema: () => GameEventSchema,
+  GameInputCancelSchema: () => GameInputCancelSchema,
+  GameInputInteractionSchema: () => GameInputInteractionSchema,
+  GameInputSchema: () => GameInputSchema,
+  GameOutcomeReasonSchema: () => GameOutcomeReasonSchema,
+  GameOutcomeSchema: () => GameOutcomeSchema,
+  GameplayBasisSchema: () => GameplayBasisSchema,
+  InitializeRequestSchema: () => InitializeRequestSchema,
+  InitializeResultSchema: () => InitializeResultSchema,
+  OutcomeResultSchema: () => OutcomeResultSchema,
+  OutcomeScoreComponentSchema: () => OutcomeScoreComponentSchema,
+  OutcomeStandingSchema: () => OutcomeStandingSchema,
+  OutcomeTieBreakSchema: () => OutcomeTieBreakSchema,
+  ProjectRequestSchema: () => ProjectRequestSchema,
+  ProjectedGameEventDetailSchema: () => ProjectedGameEventDetailSchema,
+  ProjectedGameEventSchema: () => ProjectedGameEventSchema,
+  ProjectionTimingMetadataSchema: () => ProjectionTimingMetadataSchema,
+  ReducerContractVersionSchema: () => ReducerContractVersionSchema,
+  ReducerDomainStateSchema: () => ReducerDomainStateSchema,
+  ReducerFlowStateSchema: () => ReducerFlowStateSchema,
+  ReducerRuntimeLogEntryAcceptedClientInputSchema: () => ReducerRuntimeLogEntryAcceptedClientInputSchema,
+  ReducerRuntimeLogEntryPhaseEnteredSchema: () => ReducerRuntimeLogEntryPhaseEnteredSchema,
+  ReducerRuntimeLogEntryRngConsumptionSchema: () => ReducerRuntimeLogEntryRngConsumptionSchema,
+  ReducerRuntimeLogEntrySchema: () => ReducerRuntimeLogEntrySchema,
+  ReducerRuntimeLogEntryStateCommitSchema: () => ReducerRuntimeLogEntryStateCommitSchema,
+  ReducerRuntimeStateSchema: () => ReducerRuntimeStateSchema,
+  ReducerSessionStateSchema: () => ReducerSessionStateSchema,
+  ReferenceBasisSchema: () => ReferenceBasisSchema,
+  RngDrawSchema: () => RngDrawSchema,
+  RngOperationParameterSchema: () => RngOperationParameterSchema,
+  RngOperationSchema: () => RngOperationSchema,
+  RngStateSchema: () => RngStateSchema,
+  RuntimePendingInteractionSchema: () => RuntimePendingInteractionSchema,
+  RuntimeSimultaneousCurrentSchema: () => RuntimeSimultaneousCurrentSchema,
+  RuntimeSimultaneousStateSchema: () => RuntimeSimultaneousStateSchema,
+  RuntimeSimultaneousSubmissionSchema: () => RuntimeSimultaneousSubmissionSchema,
+  SchedulerContinuationDependencySchema: () => SchedulerContinuationDependencySchema,
+  SchedulerFlowAuthorityProjectionSchema: () => SchedulerFlowAuthorityProjectionSchema,
+  SeatProjectionBundleSchema: () => SeatProjectionBundleSchema,
+  SeatProjectionSchema: () => SeatProjectionSchema,
+  SimultaneousPhaseProjectionSchema: () => SimultaneousPhaseProjectionSchema,
+  SystemActionEventSchema: () => SystemActionEventSchema,
+  TransitionRecordSchema: () => TransitionRecordSchema
+});
+import * 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()
+]);
+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),
+  operation: RngOperationSchema
+});
+var RngStateSchema = z3.strictObject({
+  seed: z3.union([
+    z3.number().refine(Number.isInteger, { message: "Expected integer" }),
+    z3.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(PlayerIdSchema)
+});
+var RuntimeSimultaneousSubmissionSchema = z3.strictObject({
+  interactionId: z3.string().min(1),
+  params: RuntimeJsonSchema
+});
+var RuntimeSimultaneousCurrentSchema = z3.strictObject({
+  phaseName: z3.string().min(1),
+  actors: z3.array(PlayerIdSchema),
+  submissions: z3.record(PlayerIdSchema, RuntimeSimultaneousSubmissionSchema)
+});
+var RuntimeSimultaneousStateSchema = z3.strictObject({
+  current: z3.union([RuntimeSimultaneousCurrentSchema, z3.null()])
+});
+var TransitionRecordSchema = z3.strictObject({
+  from: z3.string().min(1),
+  to: z3.string().min(1)
+});
+var ReferenceBasisSchema = z3.strictObject({
+  sessionId: z3.string().min(1),
+  version: z3.number().int().gte(0)
+});
+var RuntimePendingInteractionSchema = z3.strictObject({
+  phaseName: z3.string().min(1),
+  interactionId: z3.string().min(1),
+  values: z3.array(RuntimeJsonSchema).min(1),
+  concealedBasis: ReferenceBasisSchema.optional()
+});
+var GameEventDetailSchema = z3.strictObject({
+  label: z3.string().min(1),
+  value: z3.union([
+    z3.string(),
+    z3.number().finite(),
+    z3.boolean(),
+    z3.strictObject({ kind: z3.literal("tile"), tileId: z3.string().min(1) })
+  ])
+});
+var EventAudienceSchema = z3.discriminatedUnion("kind", [
+  z3.strictObject({ kind: z3.literal("public") }),
+  z3.strictObject({
+    kind: z3.literal("seats"),
+    playerIds: z3.array(PlayerIdSchema).min(1)
+  }).superRefine((audience, context) => {
+    if (new Set(audience.playerIds).size !== audience.playerIds.length)
+      context.addIssue({
+        code: "custom",
+        path: ["playerIds"],
+        message: "Event audience seats must be unique."
+      });
+  })
+]);
+var ProjectedGameEventDetailSchema = GameEventDetailSchema.extend({
+  value: z3.union([
+    z3.string(),
+    z3.number().finite(),
+    z3.boolean(),
+    z3.strictObject({ kind: z3.literal("tile"), ref: SeatTileRefSchema })
+  ])
+});
+var ProjectedGameEventSchema = 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(ProjectedGameEventDetailSchema).max(16).optional()
+});
+var SystemActionEventSchema = ProjectedGameEventSchema.extend({
+  audience: EventAudienceSchema,
+  details: z3.array(GameEventDetailSchema).max(16).optional()
+});
+var GameEventSchema = z3.discriminatedUnion("kind", [
+  SystemActionEventSchema
+]);
+var GameplayBasisSchema = ReferenceBasisSchema.extend({
+  actionSetVersion: z3.string().min(1),
+  perspectivePlayerId: PlayerIdSchema
+});
+var ReducerRuntimeStateSchema = z3.strictObject({
+  events: z3.array(GameEventSchema).max(32),
+  rng: RngStateSchema,
+  pending: z3.record(z3.string(), RuntimePendingInteractionSchema),
+  simultaneous: RuntimeSimultaneousStateSchema,
+  lastTransition: z3.union([TransitionRecordSchema, z3.null()]),
+  options: z3.record(z3.string(), RuntimeJsonSchema)
+});
+var ReducerDomainStateSchema = z3.strictObject({
+  table: RuntimeJsonSchema,
+  publicState: RuntimeJsonSchema,
+  privateState: z3.record(PlayerIdSchema, RuntimeJsonSchema),
+  hiddenState: RuntimeJsonSchema,
+  flow: ReducerFlowStateSchema,
+  phase: RuntimeJsonSchema
+});
+var ReducerSessionStateSchema = z3.strictObject({
+  domain: ReducerDomainStateSchema,
+  runtime: ReducerRuntimeStateSchema
+});
+var GameInputInteractionSchema = z3.strictObject({
+  kind: z3.literal("interaction"),
+  basis: GameplayBasisSchema,
+  playerId: PlayerIdSchema,
+  interactionId: z3.string().min(1),
+  params: RuntimeJsonSchema
+});
+var GameInputCancelSchema = z3.strictObject({
+  kind: z3.literal("interaction.cancel"),
+  basis: GameplayBasisSchema,
+  playerId: PlayerIdSchema,
+  interactionId: z3.string().min(1)
+});
+var GameInputSchema = z3.discriminatedUnion("kind", [
+  GameInputInteractionSchema,
+  GameInputCancelSchema
+]);
+var GameOutcomeReasonSchema = z3.strictObject({
+  code: z3.string().min(1),
+  message: z3.string().min(1).optional()
+});
+var OutcomeResultSchema = z3.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: PlayerIdSchema,
+  rank: z3.number().int().gte(1),
+  result: OutcomeResultSchema,
+  score: z3.number().finite().optional(),
+  scoreBreakdown: z3.array(OutcomeScoreComponentSchema).optional(),
+  tieBreaks: z3.array(OutcomeTieBreakSchema).optional()
+});
+var GameOutcomeSchema = z3.strictObject({
+  reason: GameOutcomeReasonSchema,
+  standings: z3.array(OutcomeStandingSchema).min(1)
+});
+var InitializeResultSchema = z3.strictObject({
+  state: ReducerSessionStateSchema,
+  terminal: GameOutcomeSchema.optional(),
+  events: z3.array(GameEventSchema).optional()
+});
+var InitializeRequestSchema = z3.strictObject({
+  table: RuntimeJsonSchema,
+  playerIds: PlayerRosterSchema,
+  rngSeed: z3.union([
+    z3.number().refine(Number.isInteger, { message: "Expected integer" }),
+    z3.null()
+  ]).optional(),
+  options: z3.record(z3.string(), RuntimeJsonSchema).optional()
+});
+var DispatchRequestSchema = z3.strictObject({
+  referenceBasis: ReferenceBasisSchema,
+  state: ReducerSessionStateSchema,
+  input: GameInputSchema
+});
+var DispatchTraceAcceptedClientInputSchema = z3.strictObject({
+  kind: z3.literal("acceptedClientInput"),
+  input: GameInputSchema
+});
+var DispatchTracePhaseEnteredSchema = z3.strictObject({
+  kind: z3.literal("phaseEntered"),
+  from: z3.string(),
+  to: z3.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 DispatchTraceSchema = z3.discriminatedUnion("kind", [
+  DispatchTraceAcceptedClientInputSchema,
+  DispatchTracePhaseEnteredSchema,
+  DispatchTraceRngConsumptionSchema
+]);
+var DispatchResultRejectSchema = z3.strictObject({
+  kind: z3.literal("reject"),
+  errorCode: z3.string().min(1),
+  message: z3.string().optional()
+});
+var DispatchResultAcceptSchema = z3.strictObject({
+  kind: z3.literal("accept"),
+  state: ReducerSessionStateSchema,
+  terminal: GameOutcomeSchema.optional(),
+  trace: z3.array(DispatchTraceSchema),
+  events: z3.array(GameEventSchema).max(32)
+});
+var DispatchResultSchema = z3.discriminatedUnion("kind", [
+  DispatchResultRejectSchema,
+  DispatchResultAcceptSchema
+]);
+var ReducerRuntimeLogEntryAcceptedClientInputSchema = z3.strictObject({
+  kind: z3.literal("acceptedClientInput"),
+  version: z3.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(),
+  state: ReducerSessionStateSchema
+});
+var ReducerRuntimeLogEntrySchema = z3.discriminatedUnion("kind", [
+  ReducerRuntimeLogEntryAcceptedClientInputSchema,
+  ReducerRuntimeLogEntryPhaseEnteredSchema,
+  ReducerRuntimeLogEntryRngConsumptionSchema,
+  ReducerRuntimeLogEntryStateCommitSchema
+]);
+var AuthoredViewSchema = z3.object({
+  boards: z3.never({
+    error: "The view field 'boards' is reserved for projected board topology."
+  }).optional()
+}).catchall(RuntimeJsonSchema);
+var SeatProjectionSchema = z3.strictObject({
+  events: z3.array(ProjectedGameEventSchema).max(32),
+  view: AuthoredViewSchema.nullable().optional(),
+  boards: BoardProjectionSchema.optional(),
+  availableInteractionRefs: z3.array(z3.string()).optional(),
+  zones: z3.record(z3.string(), z3.record(z3.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({
+  referenceBasis: ReferenceBasisSchema,
+  simultaneousPhase: z3.union([SimultaneousPhaseProjectionSchema, z3.null()]).optional(),
+  schedulerFlow: SchedulerFlowAuthorityProjectionSchema.optional(),
+  interactionsByRef: z3.record(z3.string(), InteractionDescriptorSchema).optional(),
+  seats: z3.record(PlayerIdSchema, SeatProjectionSchema),
+  timing: ProjectionTimingMetadataSchema.optional()
+});
+var ProjectRequestSchema = z3.strictObject({
+  referenceBasis: ReferenceBasisSchema,
+  state: ReducerSessionStateSchema,
+  playerIds: PlayerRosterSchema
+});
+
+// src/shared/domain/board-space-host.ts
+import * as z4 from "zod";
+var hostTuple = z4.tuple([
+  z4.literal("board-space"),
+  z4.string().min(1),
+  z4.string().min(1)
+]);
+function boardSpaceHostId(boardId, spaceId) {
+  hostTuple.parse(["board-space", boardId, spaceId]);
+  return `${GENERATED_ID_PREFIX}${JSON.stringify(["board-space", boardId, spaceId])}`;
+}
+function parseBoardSpaceHostId(value) {
+  if (typeof value !== "string" || !value.startsWith(GENERATED_ID_PREFIX))
+    return null;
+  let candidate;
+  try {
+    candidate = JSON.parse(value.slice(GENERATED_ID_PREFIX.length));
+  } catch {
+    return null;
+  }
+  const parsed = hostTuple.safeParse(candidate);
+  if (!parsed.success) return null;
+  const [, boardId, spaceId] = parsed.data;
+  if (boardSpaceHostId(boardId, spaceId) !== value) return null;
+  return { boardId, spaceId };
+}
+
+export {
+  CARD_REFERENCE_PREFIX,
+  isHiddenCardId,
+  isCardReferenceNamespace,
+  ViewCardSchema,
+  InteractionCommitPolicySchema,
+  InputDomainSchema,
+  InteractionInputDescriptorSchema,
+  InteractionAvailabilitySchema,
+  InteractionDescriptorSchema,
+  RngDrawSchema,
+  ReferenceBasisSchema,
+  ProjectedGameEventDetailSchema,
+  ProjectedGameEventSchema,
+  SystemActionEventSchema,
+  GameEventSchema,
+  ReducerSessionStateSchema,
+  GameInputSchema,
+  GameOutcomeSchema,
+  SimultaneousPhaseProjectionSchema,
+  SeatProjectionBundleSchema,
+  runtime_schema_exports,
+  boardSpaceHostId,
+  parseBoardSpaceHostId
+};
+//# sourceMappingURL=chunk-U6R7FAH4.js.map