@dreamboard-games/api-client 0.1.0

package/src/zod.gen.ts

@@ -0,0 +1,2705 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { z } from 'zod';
+
+/**
+ * Backend runtime version metadata used by local development hosts.
+ */
+export const zApiVersionResponse = z.object({
+    backendRevision: z.string(),
+    uiSdkVersion: z.string()
+});
+
+export const zGameMetadata = z.object({
+    coverImage: z.optional(z.url()),
+    playTime: z.optional(z.enum([
+        '15-30 minutes',
+        '30-60 minutes',
+        '1-2 hours',
+        '2-3 hours',
+        '3+ hours'
+    ])),
+    ageRange: z.optional(z.enum([
+        '3+',
+        '6+',
+        '8+',
+        '10+',
+        '12+',
+        '14+',
+        '16+',
+        '18+'
+    ])),
+    gameCategory: z.optional(z.enum([
+        'Abstract',
+        'Strategy',
+        'Eurogame',
+        'Ameritrash',
+        'Card Game',
+        'Dice Game',
+        'Party Game',
+        'Cooperative',
+        'Competitive',
+        'Solo',
+        'Family Game',
+        'Wargame',
+        'Tile-Placement',
+        'Worker Placement',
+        'Deck Builder'
+    ])),
+    keyMechanics: z.optional(z.enum([
+        'Area Control',
+        'Set Collection',
+        'Hand Management',
+        'Dice Rolling',
+        'Route Building',
+        'Pick-up and Deliver',
+        'Auction/Bidding',
+        'Hidden Roles',
+        'Bluffing',
+        'Push Your Luck'
+    ]))
+});
+
+/**
+ * Tracks which steps have been completed for a game
+ */
+export const zCompletedSteps = z.object({
+    ruleSaved: z.optional(z.boolean()).default(false),
+    manifestGenerated: z.optional(z.boolean()).default(false),
+    appBuilt: z.optional(z.boolean()).default(false),
+    uiBuilt: z.optional(z.boolean()).default(false)
+});
+
+/**
+ * Development status light shown in the dashboard
+ */
+export const zStepLightStatus = z.enum([
+    'yellow',
+    'green',
+    'red'
+]);
+
+/**
+ * Per-area development lights shown for a game
+ */
+export const zGameCompletionLights = z.object({
+    rules: zStepLightStatus,
+    manifest: zStepLightStatus,
+    phases: zStepLightStatus,
+    ui: zStepLightStatus
+});
+
+export const zGame = z.object({
+    id: z.uuid(),
+    slug: z.string(),
+    name: z.string().min(1).max(255),
+    description: z.optional(z.string()),
+    ruleText: z.optional(z.string()),
+    public: z.boolean().default(false),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+    scriptId: z.optional(z.string()),
+    metadata: z.optional(zGameMetadata),
+    completedSteps: zCompletedSteps,
+    completionLights: zGameCompletionLights,
+    readyToPlay: z.boolean().default(false),
+    initialized: z.boolean().default(false)
+});
+
+/**
+ * Stable machine-readable problem identifier
+ */
+export const zProblemType = z.enum([
+    'urn:dreamboard:problem:action-rejected',
+    'urn:dreamboard:problem:active-job-conflict',
+    'urn:dreamboard:problem:authoring-state-base-missing',
+    'urn:dreamboard:problem:authoring-state-drift',
+    'urn:dreamboard:problem:forbidden',
+    'urn:dreamboard:problem:game-slug-conflict',
+    'urn:dreamboard:problem:internal-error',
+    'urn:dreamboard:problem:resource-not-found',
+    'urn:dreamboard:problem:source-revision-base-missing',
+    'urn:dreamboard:problem:source-revision-drift',
+    'urn:dreamboard:problem:source-revision-not-found',
+    'urn:dreamboard:problem:state-conflict',
+    'urn:dreamboard:problem:too-many-requests',
+    'urn:dreamboard:problem:unauthorized',
+    'urn:dreamboard:problem:validation-failed'
+]);
+
+export const zProblemViolation = z.object({
+    field: z.optional(z.string()),
+    code: z.optional(z.string()),
+    message: z.string()
+});
+
+export const zProblemDetails = z.object({
+    type: zProblemType,
+    title: z.string(),
+    status: z.int(),
+    detail: z.string(),
+    instance: z.optional(z.string()),
+    requestId: z.optional(z.string()),
+    retryable: z.optional(z.boolean()),
+    context: z.optional(z.record(z.string(), z.string())),
+    violations: z.optional(z.array(zProblemViolation)),
+    timestamp: z.optional(z.iso.datetime())
+});
+
+/**
+ * Request to create a new game
+ */
+export const zCreateGameRequest = z.object({
+    slug: z.optional(z.string()),
+    name: z.optional(z.string().max(200)),
+    description: z.optional(z.string().max(1000)),
+    ruleText: z.optional(z.string().max(50000)),
+    enhanceRule: z.optional(z.boolean()).default(false)
+});
+
+/**
+ * Request to extract a structured game spec from rule text.
+ */
+export const zExtractGameSpecRequest = z.object({
+    ruleText: z.string().min(1).max(50000)
+});
+
+/**
+ * Supported player count range for a generated game.
+ */
+export const zGameSpecPlayers = z.object({
+    min: z.int().gte(1).lte(20),
+    max: z.int().gte(1).lte(20)
+});
+
+/**
+ * Component family expected in the generated game.
+ */
+export const zGameSpecComponent = z.enum([
+    'deck',
+    'dice',
+    'board',
+    'resource',
+    'token',
+    'tracker'
+]);
+
+/**
+ * A single component instance in the generated game. Multiple instances of
+ * the same `kind` are allowed (e.g. two decks). `name` is a short label and
+ * `notes` is freeform detail the agent will expand into manifest entries.
+ *
+ */
+export const zGameSpecComponentSpec = z.object({
+    kind: zGameSpecComponent,
+    name: z.string().min(1).max(100),
+    notes: z.optional(z.string().max(500))
+});
+
+/**
+ * Structured game specification submitted by the new-game flow.
+ */
+export const zGameSpecForm = z.object({
+    name: z.string().min(1).max(200),
+    players: zGameSpecPlayers,
+    components: z.array(zGameSpecComponentSpec).max(50),
+    winCondition: z.string().max(2000),
+    additionalRules: z.string().min(1).max(50000)
+});
+
+/**
+ * Structured game spec extracted from rule text.
+ */
+export const zExtractGameSpecResponse = z.object({
+    gameSpec: zGameSpecForm
+});
+
+/**
+ * Supported player-count metadata for the game
+ */
+export const zPlayersDefinition = z.object({
+    minPlayers: z.int().gte(1).lte(10),
+    maxPlayers: z.int().gte(1).lte(10),
+    optimalPlayers: z.optional(z.int().gte(1).lte(10))
+});
+
+export const zPresetCardSetDefinition = z.object({
+    id: z.string().min(1),
+    presetId: z.string().min(1),
+    name: z.string().min(1),
+    type: z.enum(['preset'])
+});
+
+/**
+ * Arbitrary authored JSON value.
+ */
+export const zJsonValue = z.union([
+    z.string(),
+    z.int(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(z.lazy((): any => zJsonValue)),
+    z.record(z.string(), z.lazy((): any => zJsonValue))
+]);
+
+export const zPropertySchema = z.object({
+    type: z.enum([
+        'string',
+        'integer',
+        'number',
+        'boolean',
+        'zoneId',
+        'cardId',
+        'playerId',
+        'boardId',
+        'edgeId',
+        'vertexId',
+        'spaceId',
+        'pieceId',
+        'dieId',
+        'resourceId',
+        'array',
+        'object',
+        'record',
+        'enum'
+    ]),
+    description: z.optional(z.string()),
+    optional: z.optional(z.boolean()).default(false),
+    nullable: z.optional(z.boolean()).default(false),
+    default: z.optional(zJsonValue),
+    get items() {
+        return z.optional(z.lazy((): any => zPropertySchema));
+    },
+    get properties() {
+        return z.optional(z.record(z.string(), z.lazy((): any => zPropertySchema)));
+    },
+    enums: z.optional(z.array(z.string())),
+    get values() {
+        return z.optional(z.lazy((): any => zPropertySchema));
+    }
+});
+
+export const zObjectSchema = z.object({
+    properties: z.record(z.string(), zPropertySchema)
+});
+
+export const zCardPropertySchemaVariants = z.object({
+    shared: z.optional(z.record(z.string(), zPropertySchema)),
+    variants: z.record(z.string(), zObjectSchema)
+});
+
+export const zCardPropertySchema = z.union([
+    zObjectSchema,
+    zCardPropertySchemaVariants
+]);
+
+export const zDetachedHomeSpec = z.object({
+    type: z.enum(['detached'])
+});
+
+export const zZoneHomeSpec = z.object({
+    type: z.enum(['zone']),
+    zoneId: z.string()
+});
+
+export const zSpaceHomeSpec = z.object({
+    type: z.enum(['space']),
+    boardId: z.string(),
+    spaceId: z.string()
+});
+
+export const zContainerHomeSpec = z.object({
+    type: z.enum(['container']),
+    boardId: z.string(),
+    containerId: z.string()
+});
+
+/**
+ * Tiled board edge identified by the spaces that border it
+ */
+export const zBoardEdgeRef = z.object({
+    spaces: z.array(z.string()).min(1).max(2)
+});
+
+export const zEdgeHomeSpec = z.object({
+    type: z.enum(['edge']),
+    boardId: z.string(),
+    ref: zBoardEdgeRef
+});
+
+/**
+ * Tiled board vertex identified by the spaces that touch it
+ */
+export const zBoardVertexRef = z.object({
+    spaces: z.array(z.string()).min(1).max(4)
+});
+
+export const zVertexHomeSpec = z.object({
+    type: z.enum(['vertex']),
+    boardId: z.string(),
+    ref: zBoardVertexRef
+});
+
+export const zPieceSlotHostRef = z.object({
+    kind: z.enum(['piece']),
+    id: z.string()
+});
+
+export const zDieSlotHostRef = z.object({
+    kind: z.enum(['die']),
+    id: z.string()
+});
+
+export const zSlotHostRef = z.union([
+    z.object({
+        kind: z.literal('piece')
+    }).and(zPieceSlotHostRef),
+    z.object({
+        kind: z.literal('die')
+    }).and(zDieSlotHostRef)
+]);
+
+export const zSlotHomeSpec = z.object({
+    type: z.enum(['slot']),
+    host: zSlotHostRef,
+    slotId: z.string()
+});
+
+export const zComponentHomeSpec = z.union([
+    z.object({
+        type: z.literal('detached')
+    }).and(zDetachedHomeSpec),
+    z.object({
+        type: z.literal('zone')
+    }).and(zZoneHomeSpec),
+    z.object({
+        type: z.literal('space')
+    }).and(zSpaceHomeSpec),
+    z.object({
+        type: z.literal('container')
+    }).and(zContainerHomeSpec),
+    z.object({
+        type: z.literal('edge')
+    }).and(zEdgeHomeSpec),
+    z.object({
+        type: z.literal('vertex')
+    }).and(zVertexHomeSpec),
+    z.object({
+        type: z.literal('slot')
+    }).and(zSlotHomeSpec)
+]);
+
+/**
+ * Default authored visibility for a component instance
+ */
+export const zComponentVisibilitySpec = z.object({
+    faceUp: z.optional(z.boolean()).default(true),
+    visibleTo: z.optional(z.array(z.string()))
+});
+
+export const zBoardCard = z.object({
+    type: z.string(),
+    name: z.string(),
+    imageUrl: z.optional(z.string()),
+    text: z.optional(z.string()),
+    count: z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    cardType: z.optional(z.string()),
+    home: z.optional(zComponentHomeSpec),
+    visibility: z.optional(zComponentVisibilitySpec),
+    properties: z.record(z.string(), zJsonValue)
+});
+
+export const zManualCardSetDefinition = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    type: z.enum(['manual']),
+    cardSchema: zCardPropertySchema,
+    cards: z.array(zBoardCard).min(0)
+});
+
+export const zCardSetDefinition = z.union([
+    z.object({
+        type: z.literal('preset')
+    }).and(zPresetCardSetDefinition),
+    z.object({
+        type: z.literal('manual')
+    }).and(zManualCardSetDefinition)
+]);
+
+/**
+ * Whether authored topology exists once for the table or once per player
+ */
+export const zTopologyScope = z.enum(['shared', 'perPlayer']);
+
+/**
+ * Default topology visibility for a zone or slot
+ */
+export const zZoneVisibility = z.enum([
+    'ownerOnly',
+    'public',
+    'hidden'
+]);
+
+/**
+ * Generic authored container that can hold cards, pieces, or dice
+ */
+export const zZoneSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    scope: zTopologyScope,
+    allowedCardSetIds: z.optional(z.array(z.string())),
+    visibility: z.optional(zZoneVisibility).default('public')
+});
+
+/**
+ * Stable authored board space or slot anchor
+ */
+export const zBoardSpaceSpec = z.object({
+    id: z.string(),
+    name: z.optional(z.string()),
+    typeId: z.optional(z.string()),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Named relation between two authored spaces
+ */
+export const zBoardRelationSpec = z.object({
+    id: z.optional(z.string()),
+    typeId: z.string(),
+    fromSpaceId: z.string(),
+    toSpaceId: z.string(),
+    directed: z.optional(z.boolean()).default(false),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+export const zBoardHostSpec = z.object({
+    type: z.enum(['board'])
+});
+
+export const zSpaceHostSpec = z.object({
+    type: z.enum(['space']),
+    spaceId: z.string()
+});
+
+export const zBoardContainerHostSpec = z.union([
+    z.object({
+        type: z.literal('board')
+    }).and(zBoardHostSpec),
+    z.object({
+        type: z.literal('space')
+    }).and(zSpaceHostSpec)
+]);
+
+/**
+ * Authored board-attached or space-attached container/slot
+ */
+export const zBoardContainerSpec = z.object({
+    id: z.string(),
+    name: z.string(),
+    host: zBoardContainerHostSpec,
+    allowedCardSetIds: z.optional(z.array(z.string())),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Reusable authored board topology template
+ */
+export const zGenericBoardTemplateSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    layout: z.enum(['generic']),
+    typeId: z.optional(z.string()),
+    boardFieldsSchema: z.optional(zObjectSchema),
+    spaceFieldsSchema: z.optional(zObjectSchema),
+    relationFieldsSchema: z.optional(zObjectSchema),
+    containerFieldsSchema: z.optional(zObjectSchema),
+    spaces: z.optional(z.array(zBoardSpaceSpec)).default([]),
+    relations: z.optional(z.array(zBoardRelationSpec)).default([]),
+    containers: z.optional(z.array(zBoardContainerSpec)).default([])
+});
+
+/**
+ * Visual orientation for authored hex coordinates
+ */
+export const zHexOrientation = z.enum(['pointy-top', 'flat-top']);
+
+/**
+ * One authored hex space in axial coordinates
+ */
+export const zHexSpaceSpec = z.object({
+    id: z.string(),
+    q: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    r: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    typeId: z.optional(z.string()),
+    label: z.optional(z.string()),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Hex edge identified by two adjacent hex spaces
+ */
+export const zHexEdgeRef = z.object({
+    spaces: z.tuple([z.string(), z.string()])
+});
+
+/**
+ * Authored metadata attached to one derived hex edge
+ */
+export const zHexEdgeSpec = z.object({
+    ref: zHexEdgeRef,
+    typeId: z.optional(z.string()),
+    label: z.optional(z.string()),
+    tags: z.optional(z.array(z.string())),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Hex vertex identified by three touching hex spaces
+ */
+export const zHexVertexRef = z.object({
+    spaces: z.tuple([
+        z.string(),
+        z.string(),
+        z.string()
+    ])
+});
+
+/**
+ * Authored metadata attached to one derived hex vertex
+ */
+export const zHexVertexSpec = z.object({
+    ref: zHexVertexRef,
+    typeId: z.optional(z.string()),
+    label: z.optional(z.string()),
+    tags: z.optional(z.array(z.string())),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Reusable authored hex board topology template
+ */
+export const zHexBoardTemplateSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    layout: z.enum(['hex']),
+    typeId: z.optional(z.string()),
+    orientation: z.optional(zHexOrientation).default('pointy-top'),
+    boardFieldsSchema: z.optional(zObjectSchema),
+    spaceFieldsSchema: z.optional(zObjectSchema),
+    edgeFieldsSchema: z.optional(zObjectSchema),
+    vertexFieldsSchema: z.optional(zObjectSchema),
+    spaces: z.optional(z.array(zHexSpaceSpec)).default([]),
+    edges: z.optional(z.array(zHexEdgeSpec)).default([]),
+    vertices: z.optional(z.array(zHexVertexSpec)).default([])
+});
+
+/**
+ * One authored square space in row/column coordinates
+ */
+export const zSquareSpaceSpec = z.object({
+    id: z.string(),
+    row: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    col: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    typeId: z.optional(z.string()),
+    label: z.optional(z.string()),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Authored metadata attached to one derived square edge
+ */
+export const zSquareEdgeSpec = z.object({
+    ref: zBoardEdgeRef,
+    typeId: z.optional(z.string()),
+    label: z.optional(z.string()),
+    tags: z.optional(z.array(z.string())),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Authored metadata attached to one derived square vertex
+ */
+export const zSquareVertexSpec = z.object({
+    ref: zBoardVertexRef,
+    typeId: z.optional(z.string()),
+    label: z.optional(z.string()),
+    tags: z.optional(z.array(z.string())),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Reusable authored square board topology template
+ */
+export const zSquareBoardTemplateSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    layout: z.enum(['square']),
+    typeId: z.optional(z.string()),
+    boardFieldsSchema: z.optional(zObjectSchema),
+    spaceFieldsSchema: z.optional(zObjectSchema),
+    relationFieldsSchema: z.optional(zObjectSchema),
+    containerFieldsSchema: z.optional(zObjectSchema),
+    edgeFieldsSchema: z.optional(zObjectSchema),
+    vertexFieldsSchema: z.optional(zObjectSchema),
+    spaces: z.optional(z.array(zSquareSpaceSpec)).default([]),
+    relations: z.optional(z.array(zBoardRelationSpec)).default([]),
+    containers: z.optional(z.array(zBoardContainerSpec)).default([]),
+    edges: z.optional(z.array(zSquareEdgeSpec)).default([]),
+    vertices: z.optional(z.array(zSquareVertexSpec)).default([])
+});
+
+export const zBoardTemplateSpec = z.union([
+    z.object({
+        layout: z.literal('generic')
+    }).and(zGenericBoardTemplateSpec),
+    z.object({
+        layout: z.literal('hex')
+    }).and(zHexBoardTemplateSpec),
+    z.object({
+        layout: z.literal('square')
+    }).and(zSquareBoardTemplateSpec)
+]);
+
+/**
+ * Shared or per-player authored board instance shell
+ */
+export const zGenericBoardSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    layout: z.enum(['generic']),
+    typeId: z.optional(z.string()),
+    scope: zTopologyScope,
+    templateId: z.optional(z.string()),
+    boardFieldsSchema: z.optional(zObjectSchema),
+    spaceFieldsSchema: z.optional(zObjectSchema),
+    relationFieldsSchema: z.optional(zObjectSchema),
+    containerFieldsSchema: z.optional(zObjectSchema),
+    fields: z.optional(z.record(z.string(), zJsonValue)),
+    spaces: z.optional(z.array(zBoardSpaceSpec)).default([]),
+    relations: z.optional(z.array(zBoardRelationSpec)).default([]),
+    containers: z.optional(z.array(zBoardContainerSpec)).default([])
+});
+
+/**
+ * Shared or per-player authored hex board instance shell
+ */
+export const zHexBoardSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    layout: z.enum(['hex']),
+    typeId: z.optional(z.string()),
+    scope: zTopologyScope,
+    templateId: z.optional(z.string()),
+    orientation: z.optional(zHexOrientation),
+    boardFieldsSchema: z.optional(zObjectSchema),
+    spaceFieldsSchema: z.optional(zObjectSchema),
+    edgeFieldsSchema: z.optional(zObjectSchema),
+    vertexFieldsSchema: z.optional(zObjectSchema),
+    fields: z.optional(z.record(z.string(), zJsonValue)),
+    spaces: z.optional(z.array(zHexSpaceSpec)).default([]),
+    edges: z.optional(z.array(zHexEdgeSpec)).default([]),
+    vertices: z.optional(z.array(zHexVertexSpec)).default([])
+});
+
+/**
+ * Shared or per-player authored square board instance shell
+ */
+export const zSquareBoardSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    layout: z.enum(['square']),
+    typeId: z.optional(z.string()),
+    scope: zTopologyScope,
+    templateId: z.optional(z.string()),
+    boardFieldsSchema: z.optional(zObjectSchema),
+    spaceFieldsSchema: z.optional(zObjectSchema),
+    relationFieldsSchema: z.optional(zObjectSchema),
+    containerFieldsSchema: z.optional(zObjectSchema),
+    edgeFieldsSchema: z.optional(zObjectSchema),
+    vertexFieldsSchema: z.optional(zObjectSchema),
+    fields: z.optional(z.record(z.string(), zJsonValue)),
+    spaces: z.optional(z.array(zSquareSpaceSpec)).default([]),
+    relations: z.optional(z.array(zBoardRelationSpec)).default([]),
+    containers: z.optional(z.array(zBoardContainerSpec)).default([]),
+    edges: z.optional(z.array(zSquareEdgeSpec)).default([]),
+    vertices: z.optional(z.array(zSquareVertexSpec)).default([])
+});
+
+export const zBoardSpec = z.union([
+    z.object({
+        layout: z.literal('generic')
+    }).and(zGenericBoardSpec),
+    z.object({
+        layout: z.literal('hex')
+    }).and(zHexBoardSpec),
+    z.object({
+        layout: z.literal('square')
+    }).and(zSquareBoardSpec)
+]);
+
+/**
+ * Named authored slot exposed by a piece or die type
+ */
+export const zComponentSlotSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.optional(z.string())
+});
+
+/**
+ * Reusable authored piece type
+ */
+export const zPieceTypeSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    fieldsSchema: z.optional(zObjectSchema),
+    slots: z.optional(z.array(zComponentSlotSpec))
+});
+
+/**
+ * Authored seeded piece inventory or supply definition
+ */
+export const zPieceSeedSpec = z.object({
+    id: z.optional(z.string()),
+    name: z.optional(z.string()),
+    typeId: z.string(),
+    count: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(1),
+    ownerId: z.optional(z.string()),
+    home: z.optional(zComponentHomeSpec),
+    visibility: z.optional(zComponentVisibilitySpec),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Reusable authored die type
+ */
+export const zDieTypeSpec = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_-]*$/),
+    name: z.string(),
+    sides: z.optional(z.int().gte(2).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(6),
+    fieldsSchema: z.optional(zObjectSchema),
+    slots: z.optional(z.array(zComponentSlotSpec))
+});
+
+/**
+ * Authored seeded die inventory or supply definition
+ */
+export const zDieSeedSpec = z.object({
+    id: z.optional(z.string()),
+    name: z.optional(z.string()),
+    typeId: z.string(),
+    count: z.optional(z.int().gte(1).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })).default(1),
+    ownerId: z.optional(z.string()),
+    home: z.optional(zComponentHomeSpec),
+    visibility: z.optional(zComponentVisibilitySpec),
+    fields: z.optional(z.record(z.string(), zJsonValue))
+});
+
+/**
+ * Definition of a game resource type
+ */
+export const zResourceDefinition = z.object({
+    id: z.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+    name: z.string(),
+    icon: z.optional(z.string())
+});
+
+/**
+ * One authored setup option choice
+ */
+export const zSetupOptionChoiceSpec = z.object({
+    id: z.string(),
+    label: z.string(),
+    description: z.optional(z.string())
+});
+
+/**
+ * Authored setup module/variant axis metadata
+ */
+export const zSetupOptionSpec = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.optional(z.string()),
+    choices: z.optional(z.array(zSetupOptionChoiceSpec)).default([])
+});
+
+/**
+ * Reducer-consumed authored setup profile, recipe, or loadout metadata
+ */
+export const zSetupProfileSpec = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.optional(z.string()),
+    optionValues: z.optional(z.record(z.string(), z.string()))
+});
+
+/**
+ * Authoritative topology manifest for reducer-native games
+ */
+export const zGameTopologyManifest = z.object({
+    players: zPlayersDefinition,
+    cardSets: z.array(zCardSetDefinition),
+    zones: z.optional(z.array(zZoneSpec)).default([]),
+    boardTemplates: z.optional(z.array(zBoardTemplateSpec)).default([]),
+    boards: z.optional(z.array(zBoardSpec)).default([]),
+    pieceTypes: z.optional(z.array(zPieceTypeSpec)).default([]),
+    pieceSeeds: z.optional(z.array(zPieceSeedSpec)).default([]),
+    dieTypes: z.optional(z.array(zDieTypeSpec)).default([]),
+    dieSeeds: z.optional(z.array(zDieSeedSpec)).default([]),
+    resources: z.optional(z.array(zResourceDefinition)).default([]),
+    setupOptions: z.optional(z.array(zSetupOptionSpec)).default([]),
+    setupProfiles: z.optional(z.array(zSetupProfileSpec)).default([])
+});
+
+export const zUpdateGameRequest = z.object({
+    name: z.optional(z.string().min(1).max(255)),
+    description: z.optional(z.string()),
+    rule: z.optional(z.string()),
+    public: z.optional(z.boolean()),
+    manifest: z.optional(zGameTopologyManifest),
+    metadata: z.optional(zGameMetadata)
+});
+
+export const zDeleteGameResponse = z.object({
+    deleted: z.boolean()
+});
+
+export const zWorkshopRuleTextResponse = z.object({
+    ruleText: z.string()
+});
+
+export const zGameManifestSummaryDto = z.object({
+    manifestId: z.uuid(),
+    gameId: z.uuid(),
+    userId: z.uuid(),
+    jobId: z.optional(z.uuid()),
+    ruleId: z.uuid(),
+    version: z.int(),
+    current: z.boolean(),
+    createdAt: z.iso.datetime()
+});
+
+export const zFindManifestsResponse = z.object({
+    manifests: z.array(zGameManifestSummaryDto),
+    currentManifestId: z.optional(z.uuid())
+});
+
+export const zSaveManifestRequest = z.object({
+    manifest: zGameTopologyManifest,
+    jobId: z.optional(z.uuid()),
+    ruleId: z.uuid()
+});
+
+export const zSaveManifestResponse = z.object({
+    manifestId: z.uuid(),
+    version: z.int(),
+    gameId: z.uuid(),
+    contentHash: z.string()
+});
+
+export const zGameManifestDto = z.object({
+    manifestId: z.uuid(),
+    gameId: z.uuid(),
+    userId: z.uuid(),
+    jobId: z.optional(z.uuid()),
+    ruleId: z.uuid(),
+    manifest: zGameTopologyManifest,
+    version: z.int(),
+    createdAt: z.iso.datetime(),
+    contentHash: z.string()
+});
+
+/**
+ * Diagnostic severity level
+ */
+export const zCompilationDiagnosticSeverity = z.enum(['error', 'warning']);
+
+/**
+ * Diagnostic tied to a specific project file and source location
+ */
+export const zFileCompilationDiagnostic = z.object({
+    type: z.enum(['file']),
+    file: z.string(),
+    line: z.int().gte(1),
+    column: z.int().gte(1),
+    message: z.string(),
+    severity: zCompilationDiagnosticSeverity,
+    code: z.optional(z.string())
+});
+
+/**
+ * Category of a project-level compilation diagnostic
+ */
+export const zProjectCompilationDiagnosticCategory = z.enum([
+    'configuration',
+    'module_resolution',
+    'project',
+    'system',
+    'source_validation'
+]);
+
+/**
+ * Additional structured context for a project-level diagnostic
+ */
+export const zProjectCompilationDiagnosticContext = z.object({
+    file: z.optional(z.string()),
+    details: z.optional(z.string()),
+    moduleName: z.optional(z.string()),
+    affectedPaths: z.optional(z.array(z.string())),
+    expectedSdkVersion: z.optional(z.string()),
+    actualSdkVersion: z.optional(z.string())
+});
+
+/**
+ * Diagnostic that applies to the project as a whole rather than a specific source location
+ */
+export const zProjectCompilationDiagnostic = z.object({
+    type: z.enum(['project']),
+    category: zProjectCompilationDiagnosticCategory,
+    message: z.string(),
+    severity: zCompilationDiagnosticSeverity,
+    code: z.optional(z.string()),
+    context: z.optional(zProjectCompilationDiagnosticContext)
+});
+
+export const zCompilationDiagnostic = z.union([
+    z.object({
+        type: z.literal('file')
+    }).and(zFileCompilationDiagnostic),
+    z.object({
+        type: z.literal('project')
+    }).and(zProjectCompilationDiagnostic)
+]);
+
+/**
+ * Storage backend type for compiled game artifacts
+ */
+export const zCompiledResultStorageType = z.enum(['local', 'supabase']);
+
+/**
+ * Unified compiled result containing both APP and UI outputs from a single source
+ */
+export const zCompiledResult = z.object({
+    id: z.uuid(),
+    gameId: z.uuid(),
+    userId: z.uuid(),
+    authoringStateId: z.uuid(),
+    manifestId: z.uuid(),
+    ruleId: z.uuid(),
+    compilationRequestId: z.optional(z.string()),
+    parentResultId: z.optional(z.uuid()),
+    lineageRootId: z.optional(z.uuid()),
+    success: z.boolean().default(true),
+    diagnostics: z.optional(z.array(zCompilationDiagnostic)),
+    appStorageType: zCompiledResultStorageType,
+    appStorageKey: z.optional(z.string()),
+    uiStorageType: zCompiledResultStorageType,
+    uiStorageKey: z.optional(z.string()),
+    appFingerprint: z.optional(z.string()),
+    uiFingerprint: z.optional(z.string()),
+    sourceRevisionId: z.uuid(),
+    sdkVersion: z.optional(z.string()),
+    createdAt: z.iso.datetime(),
+    lastModifiedAt: z.iso.datetime()
+});
+
+/**
+ * Response containing a list of compiled results for a game
+ */
+export const zListCompiledResultsResponse = z.object({
+    results: z.array(zCompiledResult)
+});
+
+export const zQueueCompiledResultJobRequest = z.object({
+    authoringStateId: z.uuid()
+});
+
+/**
+ * Accepted compile request response. The compilation continues asynchronously and can be tracked via the returned job ID.
+ */
+export const zQueueCompiledResultJobResponse = z.object({
+    jobId: z.uuid()
+});
+
+/**
+ * How the submitted change set should be applied against the base source revision.
+ */
+export const zSourceChangeMode = z.enum(['incremental', 'replace']);
+
+/**
+ * Upsert a file in the authored source tree.
+ */
+export const zSourceFileUpsert = z.object({
+    kind: z.enum(['upsert']),
+    path: z.string(),
+    contentHash: z.string(),
+    byteSize: z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
+});
+
+/**
+ * Delete a file from the authored source tree.
+ */
+export const zSourcePathDelete = z.object({
+    kind: z.enum(['delete']),
+    path: z.string()
+});
+
+export const zSourceChangeOperation = z.union([
+    z.object({
+        kind: z.literal('upsert')
+    }).and(zSourceFileUpsert),
+    z.object({
+        kind: z.literal('delete')
+    }).and(zSourcePathDelete)
+]);
+
+/**
+ * Request to create a new authored source revision from a change set.
+ */
+export const zCreateSourceRevisionRequest = z.object({
+    baseSourceRevisionId: z.optional(z.uuid()),
+    mode: zSourceChangeMode,
+    changes: z.array(zSourceChangeOperation)
+});
+
+/**
+ * Request to reuse or create a private dev compilation for an exact local workspace fingerprint.
+ */
+export const zEnsureDevCompileRequest = z.object({
+    devFingerprint: z.string(),
+    env: z.string(),
+    sourceRevision: zCreateSourceRevisionRequest,
+    ruleText: z.string(),
+    manifest: zGameTopologyManifest
+});
+
+/**
+ * Response for a fingerprint-backed dev compile ensure request.
+ */
+export const zEnsureDevCompileResponse = z.object({
+    reused: z.boolean(),
+    compiledResult: z.optional(zCompiledResult),
+    jobId: z.optional(z.uuid()),
+    authoringStateId: z.optional(z.uuid())
+});
+
+/**
+ * Response containing authored source files resolved through an authoring state.
+ */
+export const zGameSourcesResponse = z.object({
+    authoringStateId: z.uuid(),
+    files: z.record(z.string(), z.string()),
+    sourceRevisionId: z.uuid(),
+    treeHash: z.string(),
+    manifestId: z.optional(z.uuid()),
+    manifestContentHash: z.optional(z.string()),
+    manifest: z.optional(zGameTopologyManifest),
+    ruleId: z.optional(z.uuid()),
+    ruleText: z.optional(z.string())
+});
+
+/**
+ * Immutable authored source revision for a game.
+ */
+export const zSourceRevision = z.object({
+    id: z.uuid(),
+    gameId: z.uuid(),
+    userId: z.uuid(),
+    parentSourceRevisionId: z.optional(z.uuid()),
+    treeHash: z.string(),
+    fileCount: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    createdAt: z.iso.datetime()
+});
+
+/**
+ * Metadata describing a blob the client may need to upload before finalizing a source revision.
+ */
+export const zSourceBlobUploadDescriptor = z.object({
+    contentHash: z.string(),
+    byteSize: z.int().gte(0).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })
+});
+
+/**
+ * Request upload targets for one or more source blobs.
+ */
+export const zCreateSourceBlobUploadSessionRequest = z.object({
+    blobs: z.array(zSourceBlobUploadDescriptor)
+});
+
+/**
+ * Provider-agnostic direct-upload target for a source blob.
+ */
+export const zSourceBlobUploadTarget = z.object({
+    method: z.string(),
+    url: z.url(),
+    headers: z.record(z.string(), z.string())
+});
+
+/**
+ * Upload instructions for a single source blob.
+ */
+export const zSourceBlobUploadSessionEntry = z.object({
+    contentHash: z.string(),
+    status: z.enum(['exists', 'upload_required']),
+    uploadTarget: z.optional(zSourceBlobUploadTarget)
+});
+
+/**
+ * Direct-upload session for source blobs needed by a source revision.
+ */
+export const zSourceBlobUploadSession = z.object({
+    sessionId: z.string(),
+    expiresAt: z.iso.datetime(),
+    uploads: z.array(zSourceBlobUploadSessionEntry)
+});
+
+/**
+ * Immutable authored workspace checkpoint tying together rule, manifest, and source revision.
+ */
+export const zAuthoringState = z.object({
+    authoringStateId: z.uuid(),
+    gameId: z.uuid(),
+    userId: z.uuid(),
+    parentAuthoringStateId: z.optional(z.uuid()),
+    sourceRevisionId: z.uuid(),
+    sourceTreeHash: z.string(),
+    manifestId: z.uuid(),
+    manifestContentHash: z.string(),
+    ruleId: z.uuid(),
+    createdAt: z.iso.datetime()
+});
+
+/**
+ * Advance the current authoring head to a new immutable state.
+ */
+export const zCreateAuthoringStateRequest = z.object({
+    baseAuthoringStateId: z.optional(z.uuid()),
+    sourceRevisionId: z.uuid(),
+    sourceTreeHash: z.string(),
+    manifestId: z.uuid(),
+    manifestContentHash: z.string(),
+    ruleId: z.uuid()
+});
+
+export const zGameScriptsResponse = z.object({
+    appScripts: z.array(zCompiledResult),
+    uiScripts: z.array(zCompiledResult)
+});
+
+/**
+ * Type of async backend job
+ */
+export const zJobKind = z.enum(['GAME_BUILD', 'COMPILE']);
+
+/**
+ * Status of an async backend job
+ */
+export const zJobStatus = z.enum([
+    'PENDING',
+    'RUNNING',
+    'COMPLETED',
+    'FAILED',
+    'CANCELLED',
+    'INTERRUPTED'
+]);
+
+/**
+ * Summary information about an async backend job
+ */
+export const zJobSummary = z.object({
+    jobId: z.uuid(),
+    gameId: z.uuid(),
+    kind: zJobKind,
+    status: zJobStatus,
+    title: z.string(),
+    createdAt: z.iso.datetime(),
+    startedAt: z.optional(z.iso.datetime())
+});
+
+/**
+ * Response containing the active job for a game, if any
+ */
+export const zActiveJobResponse = z.object({
+    activeJob: z.optional(zJobSummary),
+    hasActiveJob: z.boolean()
+});
+
+/**
+ * Cache result for a specific compile target.
+ */
+export const zCompileJobCacheStatus = z.enum(['hit', 'miss']);
+
+/**
+ * Cache reuse summary for an async compile job.
+ */
+export const zCompileJobCacheSummary = z.object({
+    app: z.optional(zCompileJobCacheStatus),
+    ui: z.optional(zCompileJobCacheStatus)
+});
+
+/**
+ * Arbitrary numeric metrics recorded for a job. Keys are implementation-defined.
+ */
+export const zJobNumericMetrics = z.record(z.string(), z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }));
+
+/**
+ * Status of a user-facing job task
+ */
+export const zJobTaskStatus = z.enum([
+    'PENDING',
+    'RUNNING',
+    'COMPLETED',
+    'FAILED'
+]);
+
+/**
+ * User-facing task progress for an async job
+ */
+export const zJobTaskSummary = z.object({
+    taskKey: z.string(),
+    title: z.string(),
+    status: zJobTaskStatus,
+    latestStatus: z.optional(z.string()),
+    orderIndex: z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' }),
+    startedAt: z.optional(z.iso.datetime()),
+    completedAt: z.optional(z.iso.datetime())
+});
+
+/**
+ * Detailed information for an async backend job
+ */
+export const zJobDetailResponse = z.object({
+    jobId: z.uuid(),
+    gameId: z.uuid(),
+    kind: zJobKind,
+    status: zJobStatus,
+    title: z.string(),
+    errorMessage: z.optional(z.string()),
+    createdAt: z.iso.datetime(),
+    startedAt: z.optional(z.iso.datetime()),
+    completedAt: z.optional(z.iso.datetime()),
+    phase: z.optional(z.string()),
+    queuePosition: z.optional(z.int().min(-2147483648, { error: 'Invalid value: Expected int32 to be >= -2147483648' }).max(2147483647, { error: 'Invalid value: Expected int32 to be <= 2147483647' })),
+    cache: z.optional(zCompileJobCacheSummary),
+    message: z.optional(z.string()),
+    timings: z.optional(zJobNumericMetrics),
+    memory: z.optional(zJobNumericMetrics),
+    tasks: z.array(zJobTaskSummary),
+    createdRuleId: z.optional(z.uuid()),
+    createdManifestId: z.optional(z.uuid()),
+    createdAppScriptId: z.optional(z.uuid()),
+    createdCompiledResultId: z.optional(z.uuid())
+});
+
+/**
+ * Request to create a Cursor Cloud game build run.
+ */
+export const zCreateGameRunRequest = z.object({
+    gameSpec: zGameSpecForm,
+    ruleText: z.optional(z.string().max(50000)),
+    parentJobId: z.optional(z.uuid())
+});
+
+/**
+ * Response for an accepted game build run.
+ */
+export const zCreateGameRunResponse = z.object({
+    jobId: z.uuid(),
+    gameId: z.uuid()
+});
+
+export const zGameRuleSummaryDto = z.object({
+    ruleId: z.uuid(),
+    gameId: z.uuid(),
+    userId: z.uuid(),
+    version: z.int(),
+    createdAt: z.iso.datetime(),
+    preview: z.optional(z.string())
+});
+
+export const zListGameRulesResponse = z.object({
+    rules: z.array(zGameRuleSummaryDto)
+});
+
+export const zCreateGameRuleRequest = z.object({
+    ruleText: z.string().min(1)
+});
+
+export const zCreateGameRuleResponse = z.object({
+    ruleId: z.uuid(),
+    version: z.int(),
+    gameId: z.uuid()
+});
+
+export const zGameRule = z.object({
+    ruleId: z.uuid(),
+    gameId: z.uuid(),
+    userId: z.uuid(),
+    ruleText: z.string(),
+    version: z.int(),
+    createdAt: z.iso.datetime()
+});
+
+export const zCreateSessionRequest = z.object({
+    compiledResultId: z.optional(z.uuid()),
+    seed: z.optional(z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' })),
+    playerCount: z.optional(z.int()),
+    autoAssignSeats: z.optional(z.boolean()),
+    setupProfileId: z.optional(z.string())
+});
+
+/**
+ * Authenticated Supabase user acting in a session.
+ */
+export const zSessionActorAuthUser = z.object({
+    kind: z.enum(['AUTH_USER']),
+    id: z.uuid()
+});
+
+/**
+ * Anonymous demo principal for one demo_sessions row (shared across tabs).
+ */
+export const zSessionActorDemoGuest = z.object({
+    kind: z.enum(['DEMO_GUEST']),
+    demoActorSessionId: z.uuid()
+});
+
+export const zSessionActor = z.union([
+    z.object({
+        kind: z.literal('AUTH_USER')
+    }).and(zSessionActorAuthUser),
+    z.object({
+        kind: z.literal('DEMO_GUEST')
+    }).and(zSessionActorDemoGuest)
+]);
+
+export const zSessionGameSourceUserCompiled = z.object({
+    kind: z.enum(['USER_COMPILED']),
+    ownerUserId: z.uuid(),
+    gameId: z.uuid(),
+    compiledResultId: z.uuid()
+});
+
+export const zSessionGameSourceDemoRevision = z.object({
+    kind: z.enum(['DEMO_REVISION']),
+    slug: z.string(),
+    revisionId: z.uuid()
+});
+
+export const zSessionGameSource = z.union([
+    z.object({
+        kind: z.literal('USER_COMPILED')
+    }).and(zSessionGameSourceUserCompiled),
+    z.object({
+        kind: z.literal('DEMO_REVISION')
+    }).and(zSessionGameSourceDemoRevision)
+]);
+
+export const zCreateSessionResponse = z.object({
+    sessionId: z.uuid(),
+    shortCode: z.string(),
+    hostActor: zSessionActor,
+    gameSource: zSessionGameSource
+});
+
+/**
+ * Request to create a gameplay session by restoring a reducer-native snapshot produced by the CLI scenario harness.
+ */
+export const zCreateSessionFromReducerSnapshotRequest = z.object({
+    compiledResultId: z.uuid(),
+    seed: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    playerCount: z.int(),
+    setupProfileId: z.optional(z.string()),
+    baseId: z.string(),
+    scenarioId: z.string(),
+    reducerState: z.record(z.string(), z.unknown()),
+    reducerStateVersion: z.int(),
+    fingerprintMetadata: z.optional(z.record(z.string(), z.string()))
+});
+
+export const zSessionSnapshotPhase = z.enum([
+    'lobby',
+    'gameplay',
+    'ended'
+]);
+
+export const zHostSessionStatus = z.enum(['active', 'ended']);
+
+/**
+ * Summary of a game state history entry.
+ */
+export const zHistoryEntrySummary = z.object({
+    id: z.string(),
+    version: z.int(),
+    timestamp: z.iso.datetime(),
+    description: z.string(),
+    playerId: z.optional(z.string()),
+    actionType: z.optional(z.string()),
+    isCurrent: z.boolean()
+});
+
+export const zSessionSnapshotHistory = z.object({
+    entries: z.array(zHistoryEntrySummary),
+    currentIndex: z.int(),
+    canGoBack: z.boolean(),
+    canGoForward: z.boolean()
+});
+
+export const zHostSessionContext = z.object({
+    sessionId: z.uuid(),
+    shortCode: z.string(),
+    phase: zSessionSnapshotPhase,
+    status: zHostSessionStatus,
+    hostActor: zSessionActor,
+    gameSource: zSessionGameSource,
+    setupProfileId: z.optional(z.string()),
+    switchablePlayerIds: z.array(z.string()),
+    history: z.optional(zSessionSnapshotHistory)
+});
+
+export const zSeatAssignment = z.object({
+    playerId: z.string(),
+    controllerActor: z.optional(zSessionActor),
+    displayName: z.string(),
+    playerColor: z.optional(z.string()),
+    isHost: z.optional(z.boolean()).default(false)
+});
+
+export const zHostLobbyView = z.object({
+    seats: z.array(zSeatAssignment),
+    canStart: z.boolean(),
+    hostActor: zSessionActor,
+    setupProfileId: z.optional(z.string())
+});
+
+export const zHostLobbySessionSnapshot = z.object({
+    type: z.enum(['lobby']),
+    context: zHostSessionContext,
+    lobby: zHostLobbyView
+});
+
+export const zSimultaneousPhaseSnapshot = z.object({
+    phaseName: z.string(),
+    interactionId: z.string(),
+    actorIds: z.array(z.string()),
+    sealedPlayerIds: z.array(z.string()),
+    pendingPlayerIds: z.array(z.string())
+});
+
+/**
+ * Draft commit policy consumed by default UI surfaces.
+ */
+export const zInteractionCommitPolicy = z.object({
+    mode: z.enum(['manual', 'autoWhenReady'])
+});
+
+export const zResourceMapDomainEntry = z.object({
+    resourceId: z.string(),
+    label: z.optional(z.string()),
+    icon: z.optional(z.string()),
+    min: z.int(),
+    max: z.int()
+});
+
+export const zChoiceDomainOption = z.object({
+    value: z.string(),
+    label: z.string(),
+    icon: z.optional(z.string()),
+    badge: z.optional(z.string()),
+    description: z.optional(z.string()),
+    disabled: z.optional(z.boolean()),
+    disabledReason: z.optional(z.string())
+});
+
+/**
+ * Selection cardinality for an input domain.
+ */
+export const zInputSelection = z.object({
+    mode: z.enum(['single', 'many']),
+    min: z.optional(z.int()),
+    max: z.optional(z.int()),
+    distinct: z.optional(z.boolean())
+});
+
+export const zInputDomain = z.object({
+    type: z.enum([
+        'target',
+        'resourceMap',
+        'boundedNumber',
+        'choice',
+        'choiceList'
+    ]),
+    targetKind: z.optional(z.string()),
+    boardId: z.optional(z.string()),
+    zoneId: z.optional(z.string()),
+    zoneIds: z.optional(z.array(z.string())),
+    eligibleTargets: z.optional(z.array(z.string())),
+    resources: z.optional(z.array(zResourceMapDomainEntry)),
+    min: z.optional(z.number()),
+    max: z.optional(z.number()),
+    step: z.optional(z.number()),
+    choices: z.optional(z.array(zChoiceDomainOption)),
+    selection: z.optional(zInputSelection)
+});
+
+/**
+ * Canonical descriptor for one interaction input collector.
+ */
+export const zInteractionInputDescriptor = z.object({
+    key: z.string(),
+    kind: z.string(),
+    domain: zInputDomain,
+    defaultValue: z.optional(zJsonValue)
+});
+
+export const zInteractionContextOption = z.object({
+    id: z.string(),
+    label: z.string()
+});
+
+export const zInteractionContext = z.object({
+    to: z.string(),
+    title: z.optional(z.string()),
+    payload: z.optional(z.record(z.string(), zJsonValue)),
+    options: z.optional(z.array(zInteractionContextOption))
+});
+
+/**
+ * Authoritative interaction descriptor resolved by the trusted bundle.
+ */
+export const zInteractionDescriptor = z.object({
+    phaseName: z.string(),
+    interactionKey: z.string(),
+    interactionId: z.string(),
+    kind: z.enum(['action', 'prompt']),
+    zoneId: z.optional(z.string()),
+    commit: zInteractionCommitPolicy,
+    inputs: z.array(zInteractionInputDescriptor),
+    cost: z.optional(z.record(z.string(), zJsonValue)),
+    currentResources: z.optional(z.record(z.string(), zJsonValue)),
+    missingResources: z.optional(z.record(z.string(), z.int())),
+    available: z.boolean(),
+    unavailableReason: z.optional(z.string()),
+    context: z.optional(zInteractionContext)
+});
+
+export const zZoneHandles = z.object({
+    cardIds: z.array(z.string()),
+    cardsById: z.record(z.string(), z.string()),
+    playableByCardId: z.record(z.string(), z.array(zInteractionDescriptor))
+});
+
+export const zHostPlayerGameplayView = z.object({
+    version: z.int(),
+    actionSetVersion: z.string(),
+    playerId: z.string(),
+    activePlayers: z.array(z.string()),
+    currentPhase: z.string(),
+    currentStage: z.string(),
+    stageSeats: z.array(z.string()),
+    simultaneousPhase: z.optional(zSimultaneousPhaseSnapshot),
+    view: z.string(),
+    availableInteractions: z.array(zInteractionDescriptor),
+    zones: z.record(z.string(), zZoneHandles),
+    boardStatic: z.optional(z.string()),
+    boardStaticHash: z.optional(z.string())
+});
+
+export const zHostGameplaySessionSnapshot = z.object({
+    type: z.enum(['gameplay']),
+    context: zHostSessionContext,
+    lobby: zHostLobbyView,
+    gameplay: zHostPlayerGameplayView
+});
+
+export const zHostEndedSessionSnapshot = z.object({
+    type: z.enum(['ended']),
+    context: zHostSessionContext,
+    lobby: zHostLobbyView
+});
+
+export const zHostSessionSnapshot = z.union([
+    z.object({
+        type: z.literal('lobby')
+    }).and(zHostLobbySessionSnapshot),
+    z.object({
+        type: z.literal('gameplay')
+    }).and(zHostGameplaySessionSnapshot),
+    z.object({
+        type: z.literal('ended')
+    }).and(zHostEndedSessionSnapshot)
+]);
+
+export const zHostSessionSnapshotReason = z.enum([
+    'load',
+    'start',
+    'switch-player',
+    'resync'
+]);
+
+export const zHostSessionSnapshotEvent = z.object({
+    type: z.enum(['session.snapshot']),
+    reason: zHostSessionSnapshotReason,
+    snapshot: zHostSessionSnapshot
+});
+
+export const zHostSessionLobbyUpdatedEvent = z.object({
+    type: z.enum(['session.lobbyUpdated']),
+    context: zHostSessionContext,
+    lobby: zHostLobbyView
+});
+
+export const zHostSessionEventCausation = z.object({
+    clientActionId: z.optional(z.string())
+});
+
+export const zHostSessionGameplayUpdatedEvent = z.object({
+    type: z.enum(['session.gameplayUpdated']),
+    context: zHostSessionContext,
+    gameplay: zHostPlayerGameplayView,
+    causation: z.optional(zHostSessionEventCausation)
+});
+
+export const zHostSessionHistoryUpdatedEvent = z.object({
+    type: z.enum(['session.historyUpdated']),
+    context: zHostSessionContext
+});
+
+export const zHostSessionEndedEvent = z.object({
+    type: z.enum(['session.ended']),
+    context: zHostSessionContext,
+    lobby: zHostLobbyView
+});
+
+export const zHostSessionErrorEvent = z.object({
+    type: z.enum(['session.error']),
+    sessionId: z.uuid(),
+    code: z.optional(z.string()),
+    message: z.string(),
+    recoverable: z.boolean()
+});
+
+export const zHostSessionEvent = z.union([
+    z.object({
+        type: z.literal('session.snapshot')
+    }).and(zHostSessionSnapshotEvent),
+    z.object({
+        type: z.literal('session.lobbyUpdated')
+    }).and(zHostSessionLobbyUpdatedEvent),
+    z.object({
+        type: z.literal('session.gameplayUpdated')
+    }).and(zHostSessionGameplayUpdatedEvent),
+    z.object({
+        type: z.literal('session.historyUpdated')
+    }).and(zHostSessionHistoryUpdatedEvent),
+    z.object({
+        type: z.literal('session.ended')
+    }).and(zHostSessionEndedEvent),
+    z.object({
+        type: z.literal('session.error')
+    }).and(zHostSessionErrorEvent)
+]);
+
+/**
+ * Log entry from the game engine console output
+ */
+export const zLogMessageDto = z.object({
+    id: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    type: z.string(),
+    message: z.string(),
+    timestamp: z.iso.datetime()
+});
+
+export const zPlayerActionsResponse = z.object({
+    version: z.int(),
+    actionSetVersion: z.string(),
+    actions: z.array(zInteractionDescriptor)
+});
+
+export const zPlayerActionResponse = z.object({
+    version: z.int(),
+    actionSetVersion: z.string(),
+    action: zInteractionDescriptor
+});
+
+export const zPlayerActionTargetsResponse = z.object({
+    version: z.int(),
+    actionSetVersion: z.string(),
+    interactionId: z.string(),
+    inputKey: z.string(),
+    domain: zInputDomain,
+    zoneCardsById: z.optional(z.record(z.string(), z.string()))
+});
+
+export const zPlayerActionRequest = z.object({
+    expectedVersion: z.int(),
+    actionSetVersion: z.string(),
+    inputs: z.record(z.string(), zJsonValue)
+});
+
+export const zPlayerActionValidateResponse = z.object({
+    valid: z.boolean(),
+    version: z.int(),
+    actionSetVersion: z.string(),
+    errorCode: z.optional(z.string()),
+    message: z.optional(z.string()),
+    fieldErrors: z.optional(z.record(z.string(), z.string()))
+});
+
+export const zHostActionSubmitResponse = z.object({
+    success: z.boolean(),
+    version: z.int(),
+    actionSetVersion: z.string(),
+    accepted: z.optional(z.boolean()),
+    errorCode: z.optional(z.string()),
+    message: z.optional(z.string()),
+    event: z.optional(zHostSessionEvent)
+});
+
+/**
+ * Request to update seat settings (display name and/or player color)
+ */
+export const zUpdateSeatRequest = z.object({
+    displayName: z.optional(z.string().min(1).max(30)),
+    playerColor: z.optional(z.string().regex(/^#[0-9A-Fa-f]{6}$/))
+});
+
+/**
+ * Request to restore game state to a previous history point.
+ */
+export const zRestoreHistoryRequest = z.object({
+    entryId: z.string()
+});
+
+export const zRestoreHistoryResponse = z.object({
+    success: z.boolean(),
+    restoredToVersion: z.int(),
+    message: z.optional(z.string())
+});
+
+/**
+ * Public demo game summary.
+ */
+export const zDemoGameSummary = z.object({
+    slug: z.string(),
+    name: z.string(),
+    description: z.optional(z.string()),
+    overview: z.optional(z.string()),
+    thumbnailUrl: z.optional(z.string()),
+    creator: z.optional(z.string()),
+    minPlayers: z.optional(z.int().gte(1)),
+    maxPlayers: z.optional(z.int().gte(1)),
+    playTimeMinMinutes: z.optional(z.int().gte(1)),
+    playTimeMaxMinutes: z.optional(z.int().gte(1)),
+    difficulty: z.optional(z.int().gte(1).lte(5)),
+    mechanics: z.optional(z.array(z.string())),
+    categories: z.optional(z.array(z.string())),
+    heroImageUrl: z.optional(z.string()),
+    estimatedMinutes: z.optional(z.int().gte(1)),
+    demoPlayerCount: z.int().gte(1),
+    registrationStatus: z.enum([
+        'PENDING',
+        'REGISTERING',
+        'REGISTERED',
+        'FAILED'
+    ]),
+    playable: z.boolean()
+});
+
+export const zDemoGameDetails = zDemoGameSummary.and(z.object({
+    activeRevisionId: z.optional(z.uuid()),
+    bundleFingerprint: z.optional(z.string()),
+    error: z.optional(z.string())
+}));
+
+/**
+ * Guest-play session created for a public demo game.
+ */
+export const zDemoSessionResponse = z.object({
+    sessionId: z.uuid(),
+    shortCode: z.string(),
+    demoActorSessionId: z.uuid(),
+    guestSessionSecret: z.string(),
+    seed: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    selectedPlayerId: z.optional(z.string()),
+    gameSource: zSessionGameSource
+});
+
+export const zHistoryUpdatedEvent = z.object({
+    type: z.enum(['history.updated']),
+    history: zSessionSnapshotHistory
+});
+
+/**
+ * Type of parameter accepted by a runtime action
+ */
+export const zParameterType = z.enum([
+    'cardId',
+    'cardType',
+    'playerId',
+    'string',
+    'number',
+    'boolean',
+    'zoneId',
+    'pieceId',
+    'dieId',
+    'boardId',
+    'edgeId',
+    'vertexId',
+    'spaceId',
+    'resourceId'
+]);
+
+/**
+ * Defines a parameter for an action
+ */
+export const zActionParameterDefinition = z.object({
+    name: z.string(),
+    type: zParameterType,
+    required: z.optional(z.boolean()).default(true),
+    array: z.optional(z.boolean()).default(false),
+    minLength: z.optional(z.int().gte(0)),
+    maxLength: z.optional(z.int().gte(0)),
+    cardSetId: z.optional(z.string()),
+    description: z.optional(z.string())
+});
+
+/**
+ * Defines an available player action with metadata and parameter definitions
+ */
+export const zActionDefinition = z.object({
+    actionType: z.string(),
+    displayName: z.string(),
+    description: z.optional(z.string()),
+    parameters: z.array(zActionParameterDefinition),
+    errorCodes: z.optional(z.array(z.string()))
+});
+
+/**
+ * Type of source for the card set
+ */
+export const zCardSetSourceType = z.enum([
+    'preset',
+    'csv',
+    'manual'
+]);
+
+/**
+ * Engine-level structural board layout discriminator
+ */
+export const zBoardLayout = z.enum([
+    'generic',
+    'hex',
+    'square'
+]);
+
+export const zGameManifestResponse = z.object({
+    manifestId: z.uuid(),
+    gameId: z.uuid(),
+    userId: z.uuid(),
+    jobId: z.optional(z.uuid()),
+    manifest: zGameTopologyManifest,
+    version: z.int(),
+    createdAt: z.iso.datetime()
+});
+
+/**
+ * Unique identifier for the game
+ */
+export const zGameId = z.uuid();
+
+/**
+ * URL-safe game slug
+ */
+export const zGameSlug = z.string();
+
+/**
+ * Unique identifier for the game session
+ */
+export const zSessionId = z.uuid();
+
+/**
+ * Unique identifier for the player (e.g., 'player-1')
+ */
+export const zPlayerId = z.string();
+
+export const zHealthCheckData = z.object({
+    body: z.optional(z.never()),
+    path: z.optional(z.never()),
+    query: z.optional(z.never())
+});
+
+/**
+ * Service is healthy
+ */
+export const zHealthCheckResponse = z.string();
+
+export const zGetApiVersionData = z.object({
+    body: z.optional(z.never()),
+    path: z.optional(z.never()),
+    query: z.optional(z.never())
+});
+
+/**
+ * Successfully retrieved backend version metadata
+ */
+export const zGetApiVersionResponse = zApiVersionResponse;
+
+export const zListGamesData = z.object({
+    body: z.optional(z.never()),
+    path: z.optional(z.never()),
+    query: z.optional(z.object({
+        includeNotInitialized: z.optional(z.boolean()).default(false)
+    }))
+});
+
+/**
+ * Successfully retrieved games list
+ */
+export const zListGamesResponse = z.array(zGame);
+
+export const zCreateGameData = z.object({
+    body: zCreateGameRequest,
+    path: z.optional(z.never()),
+    query: z.optional(z.never())
+});
+
+/**
+ * Game created successfully
+ */
+export const zCreateGameResponse = zGame;
+
+export const zExtractGameSpecData = z.object({
+    body: zExtractGameSpecRequest,
+    path: z.optional(z.never()),
+    query: z.optional(z.never())
+});
+
+/**
+ * Structured game spec extracted
+ */
+export const zExtractGameSpecResponse2 = zExtractGameSpecResponse;
+
+export const zDeleteGameData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Game deleted successfully
+ */
+export const zDeleteGameResponse2 = zDeleteGameResponse;
+
+export const zGetGameData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Successfully retrieved game
+ */
+export const zGetGameResponse = zGame;
+
+export const zUpdateGameData = z.object({
+    body: zUpdateGameRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Success message
+ */
+export const zUpdateGameResponse = z.string();
+
+export const zGetGameBySlugData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        slug: z.string()
+    }),
+    query: z.optional(z.object({
+        includeDeleted: z.optional(z.boolean()).default(false)
+    }))
+});
+
+/**
+ * Successfully retrieved game
+ */
+export const zGetGameBySlugResponse = zGame;
+
+export const zQueryWorkshopRulebookData = z.object({
+    body: z.optional(z.never()),
+    path: z.optional(z.never()),
+    query: z.object({
+        title: z.string().min(1)
+    })
+});
+
+/**
+ * Extracted rulebook text for the first valid candidate.
+ */
+export const zQueryWorkshopRulebookResponse = zWorkshopRuleTextResponse;
+
+export const zFindManifestsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.object({
+        limit: z.optional(z.int().gte(1).lte(100)).default(10),
+        ruleId: z.uuid()
+    })
+});
+
+/**
+ * Manifests retrieved successfully
+ */
+export const zFindManifestsResponse2 = zFindManifestsResponse;
+
+export const zSaveManifestData = z.object({
+    body: zSaveManifestRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Manifest saved successfully
+ */
+export const zSaveManifestResponse2 = zSaveManifestResponse;
+
+export const zGetManifestData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        manifestId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Manifest retrieved successfully
+ */
+export const zGetManifestResponse = zGameManifestDto;
+
+export const zGetLatestCompiledResultData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.object({
+        successOnly: z.optional(z.boolean()).default(false)
+    }))
+});
+
+/**
+ * Latest compiled result found
+ */
+export const zGetLatestCompiledResultResponse = zCompiledResult;
+
+export const zListCompiledResultsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.object({
+        limit: z.optional(z.int().gte(1).lte(100)).default(10),
+        authoringStateId: z.optional(z.uuid())
+    }))
+});
+
+/**
+ * Compiled results retrieved successfully
+ */
+export const zListCompiledResultsResponse2 = zListCompiledResultsResponse;
+
+export const zQueueCompiledResultJobData = z.object({
+    body: zQueueCompiledResultJobRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Compile job accepted
+ */
+export const zQueueCompiledResultJobResponse2 = zQueueCompiledResultJobResponse;
+
+export const zEnsureDevCompileData = z.object({
+    body: zEnsureDevCompileRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Existing dev compile reused or cache miss reported
+ */
+export const zEnsureDevCompileResponse2 = zEnsureDevCompileResponse;
+
+export const zGetCompiledResultData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid(),
+        compiledResultId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Compiled result found
+ */
+export const zGetCompiledResultResponse = zCompiledResult;
+
+export const zDownloadGameSourcesData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * ZIP archive containing source files
+ */
+export const zDownloadGameSourcesResponse = z.string();
+
+export const zGetGameSourcesData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.object({
+        authoringStateId: z.optional(z.uuid())
+    }))
+});
+
+/**
+ * Source files retrieved successfully
+ */
+export const zGetGameSourcesResponse = zGameSourcesResponse;
+
+export const zCreateSourceRevisionData = z.object({
+    body: zCreateSourceRevisionRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Source revision created
+ */
+export const zCreateSourceRevisionResponse = zSourceRevision;
+
+export const zCreateSourceBlobUploadSessionData = z.object({
+    body: zCreateSourceBlobUploadSessionRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Upload session created
+ */
+export const zCreateSourceBlobUploadSessionResponse = zSourceBlobUploadSession;
+
+export const zGetAuthoringHeadData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Current authoring head found
+ */
+export const zGetAuthoringHeadResponse = zAuthoringState;
+
+export const zCreateAuthoringStateData = z.object({
+    body: zCreateAuthoringStateRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Authoring state created and promoted to head
+ */
+export const zCreateAuthoringStateResponse = zAuthoringState;
+
+export const zGetGameScriptsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.object({
+        manifestId: z.uuid()
+    })
+});
+
+/**
+ * Game scripts retrieved successfully
+ */
+export const zGetGameScriptsResponse = zGameScriptsResponse;
+
+export const zGetActiveJobData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Active job status (null if no active job)
+ */
+export const zGetActiveJobResponse = zActiveJobResponse;
+
+export const zGetJobData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        jobId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Job details
+ */
+export const zGetJobResponse = zJobDetailResponse;
+
+export const zSubscribeToJobEventsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        jobId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * SSE connection established
+ */
+export const zSubscribeToJobEventsResponse = zJobDetailResponse;
+
+export const zCreateGameRunData = z.object({
+    body: zCreateGameRunRequest,
+    path: z.optional(z.never()),
+    query: z.optional(z.never())
+});
+
+/**
+ * Game build run accepted
+ */
+export const zCreateGameRunResponse2 = zCreateGameRunResponse;
+
+export const zCancelGameRunData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        jobId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+export const zListGameRulesData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.object({
+        limit: z.optional(z.int().gte(1).lte(100)).default(10)
+    }))
+});
+
+/**
+ * Game rules retrieved successfully
+ */
+export const zListGameRulesResponse2 = zListGameRulesResponse;
+
+export const zCreateGameRuleData = z.object({
+    body: zCreateGameRuleRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Game rule created successfully
+ */
+export const zCreateGameRuleResponse2 = zCreateGameRuleResponse;
+
+export const zGetLatestGameRuleData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Latest game rule retrieved successfully
+ */
+export const zGetLatestGameRuleResponse = zGameRule;
+
+export const zGetGameRuleData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        ruleId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Game rule retrieved successfully
+ */
+export const zGetGameRuleResponse = zGameRule;
+
+export const zCreateSessionData = z.object({
+    body: zCreateSessionRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Session created successfully
+ */
+export const zCreateSessionResponse2 = zCreateSessionResponse;
+
+export const zCreateSessionFromReducerSnapshotData = z.object({
+    body: zCreateSessionFromReducerSnapshotRequest,
+    path: z.object({
+        gameId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Session materialized successfully
+ */
+export const zCreateSessionFromReducerSnapshotResponse = zHostSessionSnapshot;
+
+export const zGetSessionByShortCodeData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        shortCode: z.string()
+    }),
+    query: z.optional(z.object({
+        playerId: z.optional(z.string())
+    }))
+});
+
+/**
+ * Session found successfully
+ */
+export const zGetSessionByShortCodeResponse = zHostSessionSnapshot;
+
+export const zGetSessionSnapshotData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid()
+    }),
+    query: z.optional(z.object({
+        playerId: z.optional(z.string())
+    }))
+});
+
+/**
+ * Session snapshot retrieved successfully
+ */
+export const zGetSessionSnapshotResponse = zHostSessionSnapshot;
+
+export const zSubscribeToSessionEventsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid()
+    }),
+    query: z.object({
+        clientId: z.string(),
+        connectionAttemptId: z.string(),
+        clientSource: z.optional(z.string()),
+        playerId: z.optional(z.string())
+    })
+});
+
+/**
+ * Server-Sent Events stream. Each event contains a JSON-serialized HostSessionEvent.
+ *
+ */
+export const zSubscribeToSessionEventsResponse = zHostSessionEvent;
+
+export const zDisconnectSessionEventsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid()
+    }),
+    query: z.object({
+        clientId: z.string(),
+        connectionAttemptId: z.string(),
+        playerId: z.optional(z.string())
+    })
+});
+
+export const zSubscribeToGameLogsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid()
+    }),
+    query: z.optional(z.object({
+        lastLogId: z.optional(z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }))
+    }))
+});
+
+/**
+ * SSE connection established
+ */
+export const zSubscribeToGameLogsResponse = zLogMessageDto;
+
+export const zStartGameData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Game started successfully
+ */
+export const zStartGameResponse = zHostSessionSnapshot;
+
+export const zListPlayerActionsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Current actions returned successfully
+ */
+export const zListPlayerActionsResponse = zPlayerActionsResponse;
+
+export const zDescribePlayerActionData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string(),
+        interactionId: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Action descriptor returned successfully
+ */
+export const zDescribePlayerActionResponse = zPlayerActionResponse;
+
+export const zGetPlayerActionTargetsData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string(),
+        interactionId: z.string(),
+        inputKey: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Input domain returned successfully
+ */
+export const zGetPlayerActionTargetsResponse = zPlayerActionTargetsResponse;
+
+export const zValidatePlayerActionData = z.object({
+    body: zPlayerActionRequest,
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string(),
+        interactionId: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Validation result returned successfully
+ */
+export const zValidatePlayerActionResponse = zPlayerActionValidateResponse;
+
+export const zSubmitPlayerActionData = z.object({
+    body: zPlayerActionRequest,
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string(),
+        interactionId: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Submission result returned successfully
+ */
+export const zSubmitPlayerActionResponse = zHostActionSubmitResponse;
+
+export const zAddSeatData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Seat added successfully
+ */
+export const zAddSeatResponse = zSeatAssignment;
+
+export const zRemoveSeatData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Seat removed successfully
+ */
+export const zRemoveSeatResponse = z.void();
+
+export const zUpdateSeatData = z.object({
+    body: zUpdateSeatRequest,
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Seat updated successfully
+ */
+export const zUpdateSeatResponse = zSeatAssignment;
+
+export const zAssignSeatData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Seat assigned successfully
+ */
+export const zAssignSeatResponse = z.void();
+
+export const zRestoreHistoryData = z.object({
+    body: zRestoreHistoryRequest,
+    path: z.object({
+        sessionId: z.uuid()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Game state restored successfully
+ */
+export const zRestoreHistoryResponse2 = zRestoreHistoryResponse;
+
+export const zUnassignSeatData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        sessionId: z.uuid(),
+        playerId: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Seat unassigned successfully
+ */
+export const zUnassignSeatResponse = z.void();
+
+export const zFetchUiBundleData = z.object({
+    body: z.optional(z.never()),
+    path: z.optional(z.never()),
+    query: z.optional(z.object({
+        gameId: z.optional(z.uuid()),
+        sessionId: z.optional(z.uuid())
+    }))
+});
+
+/**
+ * HTML content of the UI bundle
+ */
+export const zFetchUiBundleResponse = z.string();
+
+export const zListDemoGamesData = z.object({
+    body: z.optional(z.never()),
+    path: z.optional(z.never()),
+    query: z.optional(z.never())
+});
+
+/**
+ * Successfully retrieved demo games
+ */
+export const zListDemoGamesResponse = z.array(zDemoGameSummary);
+
+export const zGetDemoGameData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        slug: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Successfully retrieved demo game metadata
+ */
+export const zGetDemoGameResponse = zDemoGameDetails;
+
+export const zGetDemoGameThumbnailData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        slug: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Successfully retrieved demo thumbnail
+ */
+export const zGetDemoGameThumbnailResponse = z.string();
+
+export const zCreateDemoGameSessionData = z.object({
+    body: z.optional(z.never()),
+    path: z.object({
+        slug: z.string()
+    }),
+    query: z.optional(z.never())
+});
+
+/**
+ * Demo session created successfully
+ */
+export const zCreateDemoGameSessionResponse = zDemoSessionResponse;