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

package/dist/chunk-ZZGN2ATS.js

@@ -1,1941 +0,0 @@
-import {
-  asPlayerId,
-  assumeManifestSchema,
-  cardInput,
-  cardTarget,
-  createManifestGameStateSchema,
-  createManifestRuntimeSchema,
-  createManifestStringLiteralSchema,
-  createTargetRule,
-  createTargetRuleBuilder,
-  isManifestScopedSchema,
-  isPerPlayer,
-  markManifestScopedSchema,
-  perPlayer,
-  perPlayerSchema
-} from "./chunk-H6VDGFL5.js";
-import {
-  buildTypedRecord
-} from "./chunk-5YV2WHJ4.js";
-import {
-  analyzeManifest,
-  materializeManifestTable
-} from "./chunk-Z7QCREWI.js";
-
-// src/reducer/schema-helpers.ts
-import { z } from "zod";
-var sparseSchemas = /* @__PURE__ */ new WeakMap();
-function sparseMap(keySchema, valueSchema) {
-  const schema = z.partialRecord(keySchema, valueSchema);
-  sparseSchemas.set(schema, {
-    keySchema,
-    valueSchema
-  });
-  return schema;
-}
-function sparseCounts(keySchema) {
-  return sparseMap(keySchema, z.number().int().min(0));
-}
-function getZodDef(schema) {
-  const anySchema = schema;
-  const fromInternal = anySchema?._zod?.def;
-  if (fromInternal && typeof fromInternal === "object") {
-    return fromInternal;
-  }
-  const fromLegacy = anySchema?.def;
-  if (fromLegacy && typeof fromLegacy === "object") {
-    return fromLegacy;
-  }
-  return {};
-}
-function unwrapWrappers(schema) {
-  let current = schema;
-  while (true) {
-    const def = getZodDef(current);
-    const innerType = def.innerType;
-    if ((def.type === "nullable" || def.type === "optional" || def.type === "default" || def.type === "readonly" || def.type === "catch") && innerType) {
-      current = innerType;
-      continue;
-    }
-    return current;
-  }
-}
-function isPlainZodString(schema) {
-  return getZodDef(schema).type === "string";
-}
-function isZodArray(schema) {
-  return getZodDef(schema).type === "array";
-}
-function isEnumKeyedRecordSchema(schema) {
-  const def = getZodDef(schema);
-  const keyType = def.keyType;
-  return def.type === "record" && typeof keyType === "object" && keyType !== null && getZodDef(keyType).type === "enum";
-}
-function isSparseMapSchema(schema) {
-  const inner = unwrapWrappers(schema);
-  return typeof inner === "object" && inner !== null && sparseSchemas.has(inner);
-}
-function getSparseSchemaMetadata(schema) {
-  const inner = unwrapWrappers(schema);
-  if (typeof inner !== "object" || inner === null) {
-    return void 0;
-  }
-  return sparseSchemas.get(inner);
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function getObjectShape(schema) {
-  const def = getZodDef(schema);
-  if (def.type !== "object") {
-    return null;
-  }
-  const shape = def.shape;
-  if (typeof shape === "function") {
-    const resolved = shape();
-    return resolved && typeof resolved === "object" ? resolved : null;
-  }
-  return shape && typeof shape === "object" ? shape : null;
-}
-function normalizeSchemaInput(schema, input) {
-  const inner = unwrapWrappers(schema);
-  const sparse = getSparseSchemaMetadata(inner);
-  if (sparse && isPlainObject(input)) {
-    const filtered = Object.fromEntries(
-      Object.entries(input).filter(
-        ([key, value]) => typeof value !== "undefined" && sparse.keySchema.safeParse(key).success
-      ).map(([key, value]) => [
-        key,
-        normalizeSchemaInput(sparse.valueSchema, value)
-      ])
-    );
-    return filtered;
-  }
-  const shape = getObjectShape(inner);
-  if (shape && isPlainObject(input)) {
-    return Object.fromEntries(
-      Object.entries(input).map(([key, value]) => {
-        const fieldSchema = shape[key];
-        return [
-          key,
-          typeof fieldSchema === "undefined" ? value : normalizeSchemaInput(fieldSchema, value)
-        ];
-      })
-    );
-  }
-  const def = getZodDef(inner);
-  if (def.type === "array" && Array.isArray(input) && def.element) {
-    return input.map((value) => normalizeSchemaInput(def.element, value));
-  }
-  return input;
-}
-function normalizeCommandParams(schema, input) {
-  return schema.parse(normalizeSchemaInput(schema, input));
-}
-
-// src/reducer/inputs/defineInputs.ts
-var InputBuilder = class {
-  add(key, collector) {
-    return { key, collector };
-  }
-};
-function defineInputs(define) {
-  const refs = define(new InputBuilder());
-  return Object.fromEntries(
-    Object.entries(refs).map(([key, ref]) => [key, ref.collector])
-  );
-}
-
-// src/reducer/inputs/many.ts
-import { z as z2 } from "zod";
-function normalizeManyOptions(options) {
-  if ("count" in options) {
-    assertNonNegativeInteger(options.count, "many(...).count");
-    return {
-      mode: "many",
-      min: options.count,
-      max: options.count,
-      distinct: options.distinct
-    };
-  }
-  const min = options.min ?? 0;
-  assertNonNegativeInteger(min, "many(...).min");
-  if (options.max !== void 0) {
-    assertNonNegativeInteger(options.max, "many(...).max");
-    if (options.max < min) {
-      throw new Error("many(...).max must be greater than or equal to min.");
-    }
-  }
-  return {
-    mode: "many",
-    min,
-    max: options.max,
-    distinct: options.distinct
-  };
-}
-function assertNonNegativeInteger(value, label) {
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative integer.`);
-  }
-}
-function many(collector, options) {
-  if (collector.kind === "rng") {
-    throw new Error("many(...) cannot wrap rngInput collectors.");
-  }
-  const selection = normalizeManyOptions(options);
-  const rest = { ...collector };
-  delete rest.schema;
-  delete rest.selection;
-  delete rest.defaultValue;
-  return {
-    ...rest,
-    schema: z2.array(
-      collector.schema
-    ),
-    selection
-  };
-}
-
-// src/reducer/inputs/formInput.ts
-import { z as z3 } from "zod";
-function isResourceMapChoiceSource(choices) {
-  return choices === "resourceMap" || typeof choices === "object" && choices !== null && !Array.isArray(choices) && "source" in choices && choices.source === "resourceMap";
-}
-function resolveDomainNumber(value, context, fallback) {
-  if (typeof value === "function") return value(context);
-  return value ?? fallback;
-}
-function resolveDomainChoices(choices, context) {
-  if (isResourceMapChoiceSource(choices)) {
-    return resolveResourceMapChoices(choices, context);
-  }
-  const resolved = typeof choices === "function" ? choices(context) : choices;
-  return resolved.map((choice) => ({
-    value: choice.value,
-    label: choice.label,
-    icon: choice.icon,
-    badge: choice.badge,
-    description: choice.description,
-    disabled: choice.disabled,
-    disabledReason: choice.disabledReason
-  }));
-}
-function resolveDependentDomainChoices(choices, context) {
-  const resolved = typeof choices === "function" ? choices(context) : choices;
-  return resolved.map((choice) => ({
-    value: choice.value,
-    label: choice.label,
-    icon: choice.icon,
-    badge: choice.badge,
-    description: choice.description,
-    disabled: choice.disabled,
-    disabledReason: choice.disabledReason
-  }));
-}
-function choiceValuesInclude(choices, value) {
-  return choices.some((choice) => Object.is(choice.value, value));
-}
-function assertChoiceDefaultInChoices(inputName, choices, defaultValue) {
-  if (choiceValuesInclude(choices, defaultValue)) return;
-  const printable = defaultValue === null ? "null" : `'${defaultValue}'`;
-  throw new Error(
-    `${inputName} defaultValue ${printable} must be one of its choices. If null is a valid value, add an explicit { value: null, label: ... } choice.`
-  );
-}
-function choiceSchema(choices) {
-  const values = choices.map((choice) => choice.value);
-  const stringValues = values.filter(
-    (value) => value !== null
-  );
-  const hasNull = values.some((value) => value === null);
-  if (stringValues.length === 0) {
-    return z3.null();
-  }
-  const stringSchema = z3.enum(
-    stringValues
-  );
-  if (hasNull) {
-    return z3.union([stringSchema, z3.null()]);
-  }
-  return stringSchema;
-}
-function resolveResourceMapChoices(choices, context) {
-  const resources = context.state.table.resources;
-  const firstResourceMap = isPerPlayer(resources) && resources.entries.length > 0 ? resources.entries[0]?.[1] : resources;
-  if (typeof firstResourceMap !== "object" || firstResourceMap === null || Array.isArray(firstResourceMap)) {
-    return [];
-  }
-  const decorate = choices === "resourceMap" ? void 0 : choices.decorate;
-  return Object.keys(firstResourceMap).sort().map((resourceId) => {
-    const label = resourceId;
-    const presentation = decorate?.({ ...context, resourceId, label });
-    return {
-      value: resourceId,
-      label,
-      badge: presentation?.badge,
-      description: presentation?.description,
-      disabled: presentation?.disabled,
-      disabledReason: presentation?.disabledReason
-    };
-  });
-}
-function createFormInput(schema, options) {
-  return {
-    kind: "form",
-    schema,
-    ...options && "defaultValue" in options ? { defaultValue: options.defaultValue } : {}
-  };
-}
-function baseFormInput(schema, options) {
-  return createFormInput(schema, options);
-}
-function resourceMapInput(options) {
-  return {
-    kind: "form",
-    schema: z3.record(z3.string(), z3.number().int().nonnegative()),
-    ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
-    domain: (state, playerId, q, derived) => {
-      const context = {
-        state,
-        playerId,
-        q,
-        derived,
-        values: {}
-      };
-      return {
-        type: "resourceMap",
-        resources: options.resources.map((resource) => ({
-          resourceId: resource.resourceId,
-          label: resource.label,
-          icon: resource.icon,
-          min: resolveDomainNumber(resource.min, context, 0),
-          max: resolveDomainNumber(resource.max, context, 0)
-        }))
-      };
-    }
-  };
-}
-function numberInput(options) {
-  return {
-    kind: "form",
-    schema: z3.number(),
-    ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
-    domain: (state, playerId, q, derived) => {
-      const context = {
-        state,
-        playerId,
-        q,
-        derived,
-        values: {}
-      };
-      return {
-        type: "boundedNumber",
-        min: resolveDomainNumber(options.min, context, 0),
-        max: resolveDomainNumber(options.max, context, 0),
-        step: options.step === void 0 ? void 0 : resolveDomainNumber(options.step, context, 1)
-      };
-    }
-  };
-}
-function choiceInput(options) {
-  const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
-  if (Array.isArray(options.choices) && options.choices.length === 0) {
-    throw new Error("formInput.choice requires at least one choice.");
-  }
-  const staticChoices = Array.isArray(options.choices) ? options.choices : null;
-  const hasStaticDefault = typeof options.defaultValue !== "function";
-  const staticDefault = options.defaultValue;
-  if (staticChoices && hasStaticDefault) {
-    assertChoiceDefaultInChoices(
-      "formInput.choice",
-      staticChoices,
-      staticDefault
-    );
-  }
-  const schema = staticChoices ? choiceSchema(staticChoices) : z3.string().nullable();
-  const dynamicDefault = typeof options.defaultValue === "function" ? options.defaultValue : void 0;
-  return {
-    kind: "form",
-    schema,
-    ...hasStaticDefault ? { defaultValue: staticDefault } : {},
-    ...dependsOn ? { dependsOn } : {},
-    domain: (state, playerId, q, derived, values) => {
-      const context = {
-        state,
-        playerId,
-        q,
-        derived
-      };
-      const choices = dependsOn ? resolveDependentDomainChoices(
-        options.choices,
-        {
-          ...context,
-          values: values ?? {}
-        }
-      ) : resolveDomainChoices(options.choices, {
-        ...context,
-        values: {}
-      });
-      if (hasStaticDefault) {
-        assertChoiceDefaultInChoices(
-          "formInput.choice",
-          choices,
-          staticDefault
-        );
-      }
-      return {
-        type: "choice",
-        choices
-      };
-    },
-    ...dynamicDefault ? {
-      resolveDefaultValue: (state, playerId, q, derived, domain) => {
-        const choices = domain.type === "choice" ? domain.choices.map((choice) => ({
-          value: choice.value,
-          label: choice.label,
-          icon: choice.icon,
-          badge: choice.badge,
-          description: choice.description,
-          disabled: choice.disabled,
-          disabledReason: choice.disabledReason
-        })) : [];
-        const resolved = dynamicDefault({
-          state,
-          playerId,
-          q,
-          derived,
-          values: {},
-          choices
-        });
-        if (resolved === void 0) return void 0;
-        assertChoiceDefaultInChoices("formInput.choice", choices, resolved);
-        return resolved;
-      }
-    } : {}
-  };
-}
-function choiceListInput(options) {
-  if (Array.isArray(options.choices) && options.choices.length === 0) {
-    throw new Error("formInput.choiceList requires at least one choice.");
-  }
-  const staticDefaultValue = Array.isArray(options.defaultValue) ? options.defaultValue : void 0;
-  const dynamicDefaultValue = options.defaultValue === "all" || typeof options.defaultValue === "function" ? options.defaultValue : void 0;
-  return {
-    kind: "form",
-    schema: z3.array(z3.string()),
-    ...staticDefaultValue !== void 0 ? { defaultValue: staticDefaultValue } : {},
-    domain: (state, playerId, q, derived) => {
-      const context = {
-        state,
-        playerId,
-        q,
-        derived,
-        values: {}
-      };
-      const choices = resolveDomainChoices(options.choices, context).map(
-        (choice) => ({
-          ...choice,
-          value: choice.value
-        })
-      );
-      return {
-        type: "choiceList",
-        choices,
-        min: resolveDomainNumber(options.min, context, 0),
-        max: resolveDomainNumber(options.max, context, choices.length)
-      };
-    },
-    ...dynamicDefaultValue ? {
-      resolveDefaultValue: (state, playerId, q, derived, domain) => {
-        const choices = domain.type === "choiceList" ? domain.choices.map((choice) => ({
-          value: choice.value,
-          label: choice.label,
-          icon: choice.icon,
-          badge: choice.badge,
-          description: choice.description,
-          disabled: choice.disabled,
-          disabledReason: choice.disabledReason
-        })) : [];
-        if (dynamicDefaultValue === "all") {
-          return choices.map((choice) => choice.value);
-        }
-        return dynamicDefaultValue({
-          state,
-          playerId,
-          q,
-          derived,
-          values: {},
-          choices
-        });
-      }
-    } : {}
-  };
-}
-function formInputForState() {
-  return Object.assign(
-    ((schema, options) => baseFormInput(schema, options)),
-    {
-      resourceMap: (options) => resourceMapInput(options),
-      resourceChoices: (options) => formInput.resourceChoices(options),
-      number: (options) => numberInput(options),
-      choice: (options) => choiceInput(options),
-      choiceList: (options) => choiceListInput(options)
-    }
-  );
-}
-var formInput = Object.assign(baseFormInput, {
-  resourceMap: resourceMapInput,
-  resourceChoices: (options) => ({
-    source: "resourceMap",
-    ...options
-  }),
-  number: numberInput,
-  choice: choiceInput,
-  choiceList: choiceListInput,
-  forState: formInputForState
-});
-
-// src/reducer/inputs/boardInput.ts
-import { z as z4 } from "zod";
-function makeBoardCollector(kind) {
-  return function collector(options) {
-    const target = options.target;
-    const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
-    return {
-      kind,
-      schema: z4.string(),
-      eligibleTargets: ((state, playerId, q, values) => target.eligible({
-        state,
-        playerId,
-        q,
-        values
-      })),
-      validateTarget: ((state, playerId, q, targetId, values) => target.validate(
-        {
-          state,
-          playerId,
-          q,
-          values
-        },
-        targetId
-      )),
-      ...dependsOn ? { dependsOn } : {},
-      domain: (state, playerId, q, _derived, values) => ({
-        type: "boardTarget",
-        projection: "resolved",
-        targetKind: target.targetKind,
-        boardId: target.boardId,
-        valueKind: target.valueKind,
-        eligibleTargets: target.eligible({
-          state,
-          playerId,
-          q,
-          values
-        }).map(String)
-      }),
-      meta: {
-        targetKind: target.targetKind,
-        boardId: target.boardId,
-        valueKind: target.valueKind
-      }
-    };
-  };
-}
-var vertexInput = makeBoardCollector("board-vertex");
-var edgeInput = makeBoardCollector("board-edge");
-var tileInput = makeBoardCollector("board-tile");
-var spaceInput = makeBoardCollector("board-space");
-function playerSpaceInput(options) {
-  const target = options.target;
-  const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
-  const playerIdSchema = markManifestScopedSchema(
-    z4.string(),
-    "playerId"
-  );
-  return {
-    kind: "board-space",
-    schema: z4.object({
-      boardId: z4.literal(target.boardId),
-      playerId: playerIdSchema,
-      spaceId: z4.string()
-    }),
-    eligibleTargets: ((state, playerId, q, values) => target.eligible({
-      state,
-      playerId,
-      q,
-      values
-    })),
-    validateTarget: ((state, playerId, q, targetValue, values) => target.validate(
-      {
-        state,
-        playerId,
-        q,
-        values
-      },
-      targetValue
-    )),
-    ...dependsOn ? { dependsOn } : {},
-    domain: (state, playerId, q, _derived, values) => ({
-      type: "boardTarget",
-      projection: "resolved",
-      targetKind: target.targetKind,
-      boardId: target.boardId,
-      valueKind: target.valueKind,
-      eligibleTargets: target.eligible({
-        state,
-        playerId,
-        q,
-        values
-      }).map((candidate) => candidate.spaceId)
-    }),
-    meta: {
-      targetKind: target.targetKind,
-      boardId: target.boardId,
-      valueKind: target.valueKind
-    }
-  };
-}
-var boardInput = {
-  vertex: vertexInput,
-  edge: edgeInput,
-  tile: tileInput,
-  space: spaceInput,
-  playerSpace: playerSpaceInput
-};
-
-// src/reducer/inputs/boardTarget.ts
-function candidateIdsForKind(q, boardId, targetKind) {
-  if (targetKind === "edge") {
-    return idsFromCollection(q.board.tiled(boardId).edges);
-  }
-  if (targetKind === "vertex") {
-    return idsFromCollection(q.board.tiled(boardId).vertices);
-  }
-  return idsFromCollection(q.board.get(boardId)?.spaces);
-}
-function idsFromCollection(collection) {
-  if (!collection) return [];
-  const values = Array.isArray(collection) ? collection : Object.values(collection);
-  return values.flatMap((value) => {
-    if (typeof value === "string") return [value];
-    if (typeof value === "object" && value !== null && "id" in value && typeof value.id === "string") {
-      return [value.id];
-    }
-    return [];
-  });
-}
-function createBoardTargetBuilder(targetKind, boardId) {
-  return createTargetRuleBuilder(
-    (predicates) => ({
-      ...createTargetRule(
-        ({ q }) => candidateIdsForKind(q, boardId, targetKind),
-        predicates,
-        {
-          missingCandidateIssue: {
-            errorCode: "BOARD_TARGET_NOT_ELIGIBLE",
-            message: "Board target is not eligible."
-          }
-        }
-      ),
-      boardId,
-      targetKind,
-      valueKind: "board-id"
-    })
-  );
-}
-function createPlayerSpaceTargetBuilder(boardId) {
-  return createTargetRuleBuilder(
-    (predicates) => ({
-      ...createTargetRule(
-        ({ state, q }) => {
-          const spacesForPlayer = (playerId) => candidateIdsForKind(
-            q,
-            `${boardId}:${playerId}`,
-            "space"
-          );
-          return state.table.playerOrder.flatMap(
-            (playerId) => spacesForPlayer(playerId).map((spaceId) => ({
-              boardId,
-              playerId,
-              spaceId
-            }))
-          );
-        },
-        predicates,
-        {
-          missingCandidateIssue: {
-            errorCode: "BOARD_TARGET_NOT_ELIGIBLE",
-            message: "Board target is not eligible."
-          },
-          equals: (left, right) => isPlayerBoardSpaceTarget(left) && isPlayerBoardSpaceTarget(right) && left.boardId === right.boardId && left.playerId === right.playerId && left.spaceId === right.spaceId
-        }
-      ),
-      boardId,
-      targetKind: "space",
-      valueKind: "player-board-space"
-    })
-  );
-}
-function isPlayerBoardSpaceTarget(value) {
-  return typeof value === "object" && value !== null && "boardId" in value && "playerId" in value && "spaceId" in value;
-}
-function makeBoardTargetFactory(targetKind) {
-  return function target(boardId) {
-    return createBoardTargetBuilder(targetKind, boardId);
-  };
-}
-var boardTarget = {
-  edge: makeBoardTargetFactory("edge"),
-  vertex: makeBoardTargetFactory("vertex"),
-  space: makeBoardTargetFactory("space"),
-  tile: makeBoardTargetFactory("tile"),
-  playerSpace(boardId) {
-    return createPlayerSpaceTargetBuilder(boardId);
-  }
-};
-
-// src/reducer/inputs/choiceTarget.ts
-function normalizeOptions(options) {
-  if (typeof options === "function") return options;
-  return () => options;
-}
-function createChoiceTargetBuilder(options) {
-  const optionsFactory = normalizeOptions(options);
-  return createTargetRuleBuilder(
-    (predicates) => {
-      const baseRule = createTargetRule(
-        (ctx) => optionsFactory(ctx.state, ctx.playerId, ctx.q).map(
-          (option) => option.id
-        ),
-        predicates,
-        {
-          missingCandidateIssue: {
-            errorCode: "CHOICE_TARGET_NOT_ELIGIBLE",
-            message: "Choice target is not eligible."
-          }
-        }
-      );
-      return {
-        ...baseRule,
-        targetKind: "choice",
-        options: (ctx) => optionsFactory(ctx.state, ctx.playerId, ctx.q),
-        eligibleOptions: (ctx) => optionsFactory(ctx.state, ctx.playerId, ctx.q).filter(
-          (option) => baseRule.isEligible(ctx, option.id)
-        )
-      };
-    }
-  );
-}
-var choiceTarget = {
-  options(options) {
-    return createChoiceTargetBuilder(options);
-  }
-};
-
-// src/reducer/inputs/promptInput.ts
-function promptInput(options) {
-  const target = options.target;
-  return {
-    kind: "prompt",
-    schema: options.schema,
-    eligibleTargets: target ? ((state, playerId, q) => target.eligible({
-      state,
-      playerId,
-      q
-    })) : void 0,
-    validateTarget: target ? ((state, playerId, q, targetId) => target.validate(
-      {
-        state,
-        playerId,
-        q
-      },
-      targetId
-    )) : void 0,
-    meta: target ? {
-      options: (state, playerId, q) => target.options({
-        state,
-        playerId,
-        q
-      }),
-      eligibleOptions: (state, playerId, q) => target.eligibleOptions({
-        state,
-        playerId,
-        q
-      })
-    } : void 0,
-    domain: (state, playerId, q) => ({
-      type: "choice",
-      choices: target ? target.options({
-        state,
-        playerId,
-        q
-      }).map((option) => ({
-        value: String(option.id),
-        label: option.label ?? String(option.id)
-      })) : []
-    })
-  };
-}
-
-// src/reducer/inputs/rngInput.ts
-import { z as z5 } from "zod";
-function d6(count = 1) {
-  return {
-    kind: "rng",
-    schema: z5.object({
-      values: z5.array(z5.number().int().min(1).max(6)).length(count)
-    }),
-    meta: { rng: "d6", count }
-  };
-}
-function coin() {
-  return {
-    kind: "rng",
-    schema: z5.object({
-      value: z5.enum(["heads", "tails"])
-    }),
-    meta: { rng: "coin" }
-  };
-}
-var rngInput = { d6, coin };
-
-// src/reducer/manifest/compiler.ts
-import { z as z7 } from "zod";
-
-// src/reducer/manifest/schema.ts
-import { z as z6 } from "zod";
-function createTableSchema(analysis, ids) {
-  const unknownRecordSchema = z6.record(z6.string(), z6.unknown());
-  const objectSchema = (schema) => schema && Object.keys(schema.properties).length ? z6.object(
-    Object.fromEntries(
-      Object.entries(schema.properties).map(([key, value]) => [
-        key,
-        propertySchema(value)
-      ])
-    )
-  ) : unknownRecordSchema;
-  function propertySchema(schema) {
-    if (!schema) return z6.unknown();
-    let result;
-    switch (schema.type) {
-      case "string":
-        result = z6.string();
-        break;
-      case "integer":
-        result = z6.number().int();
-        break;
-      case "number":
-        result = z6.number();
-        break;
-      case "boolean":
-        result = z6.boolean();
-        break;
-      case "enum":
-        result = schema.enums?.length ? z6.enum(schema.enums) : z6.string();
-        break;
-      case "array":
-        result = z6.array(propertySchema(schema.items));
-        break;
-      case "record":
-        result = z6.record(z6.string(), propertySchema(schema.values));
-        break;
-      case "object":
-        result = objectSchema({ properties: schema.properties ?? {} });
-        break;
-      default:
-        result = ids[schema.type];
-    }
-    if (schema.nullable) result = result.nullable();
-    if (schema.optional) result = result.optional();
-    if (Object.prototype.hasOwnProperty.call(schema, "default"))
-      result = result.default(schema.default);
-    return result;
-  }
-  const shape = (items, getKey, getSchema) => z6.object(
-    Object.fromEntries(items.map((item) => [getKey(item), getSchema(item)]))
-  );
-  const cardStateByIdSchema = shape(
-    analysis.cardIds,
-    (id) => id,
-    (id) => {
-      const setId = analysis.cardSetIdByCardId.get(id);
-      const type = analysis.cardTypeByCardId.get(id);
-      const schema = analysis.cardSets.find(
-        (set) => set.id === setId
-      ).cardSchema;
-      const properties = schema && "variants" in schema ? objectSchema({
-        properties: {
-          ...schema.shared,
-          ...schema.variants[type]?.properties
-        }
-      }) : objectSchema(schema);
-      return z6.object({
-        componentType: z6.string().optional(),
-        id: z6.literal(id),
-        cardSetId: z6.literal(setId),
-        cardType: z6.literal(type),
-        name: z6.string().optional(),
-        text: z6.string().optional(),
-        properties
-      });
-    }
-  );
-  const pieceStateByIdSchema = shape(
-    analysis.pieceIds,
-    (id) => id,
-    (id) => {
-      const type = analysis.pieceTypeIdByPieceId.get(id);
-      return z6.object({
-        componentType: z6.string().optional(),
-        id: z6.literal(id),
-        pieceTypeId: z6.literal(type),
-        pieceName: z6.string().nullish(),
-        ownerId: ids.playerId.nullish(),
-        properties: objectSchema(analysis.pieceTypeSchemasById.get(type))
-      });
-    }
-  );
-  const dieStateByIdSchema = shape(
-    analysis.dieIds,
-    (id) => id,
-    (id) => {
-      const type = analysis.dieTypeIdByDieId.get(id);
-      return z6.object({
-        componentType: z6.string().optional(),
-        id: z6.literal(id),
-        dieTypeId: z6.literal(type),
-        dieName: z6.string().nullish(),
-        ownerId: ids.playerId.nullish(),
-        sides: z6.literal(
-          analysis.manifest.dieTypes?.find((die) => die.id === type)?.sides ?? 6
-        ),
-        value: z6.number().int().nullish(),
-        properties: objectSchema(analysis.dieTypeSchemasById.get(type))
-      });
-    }
-  );
-  const sharedZoneSchema = shape(
-    analysis.sharedZones,
-    (zone) => zone.id,
-    () => z6.array(ids.cardId)
-  );
-  const playerZoneSchema = shape(
-    analysis.playerZones,
-    (zone) => zone.id,
-    () => perPlayerSchema(z6.array(ids.cardId))
-  );
-  const zoneIdSchema = ids.zoneId;
-  const playerZoneIdSchema = ids.playerZoneId;
-  const slotVariants = analysis.strictSlotHosts.flatMap(
-    (host) => host.slotIds.map(
-      (slotId) => z6.object({
-        type: z6.literal("InSlot"),
-        host: z6.object({ kind: z6.literal(host.kind), id: z6.literal(host.id) }),
-        slotId: z6.literal(slotId),
-        position: z6.number().int().nullish()
-      })
-    )
-  );
-  const slotLocationSchema = slotVariants.length ? z6.union(
-    slotVariants
-  ) : z6.never();
-  const boardSpaceTypeIdSchema = ids.spaceTypeId.nullable().optional();
-  const boardSpaceStateSchema = z6.object({
-    id: ids.spaceId,
-    name: z6.string().nullable().optional(),
-    typeId: boardSpaceTypeIdSchema,
-    fields: unknownRecordSchema,
-    zoneId: z6.string().nullable().optional()
-  });
-  const hexSpaceStateSchema = boardSpaceStateSchema.extend({
-    q: z6.number().int(),
-    r: z6.number().int()
-  });
-  const squareSpaceStateSchema = boardSpaceStateSchema.extend({
-    row: z6.number().int(),
-    col: z6.number().int()
-  });
-  const boardRelationStateSchema = z6.object({
-    id: z6.string().nullable().optional(),
-    typeId: ids.relationTypeId,
-    fromSpaceId: ids.spaceId,
-    toSpaceId: ids.spaceId,
-    directed: z6.boolean(),
-    fields: unknownRecordSchema
-  });
-  const boardContainerStateSchema = z6.object({
-    id: ids.boardContainerId,
-    name: z6.string(),
-    host: z6.discriminatedUnion("type", [
-      z6.object({ type: z6.literal("board") }),
-      z6.object({ type: z6.literal("space"), spaceId: ids.spaceId })
-    ]),
-    allowedCardSetIds: z6.array(ids.cardSetId).optional(),
-    zoneId: z6.string(),
-    fields: unknownRecordSchema
-  });
-  const runtimeGenericBoardStateSchema = z6.object({
-    id: ids.boardId,
-    baseId: ids.boardBaseId,
-    layout: z6.literal("generic"),
-    typeId: ids.boardTypeId.nullable().optional(),
-    scope: z6.enum(["shared", "perPlayer"]),
-    playerId: ids.playerId.nullable().optional(),
-    templateId: z6.string().nullable().optional(),
-    fields: unknownRecordSchema,
-    // T220: per-board state.spaces is loose-keyed by string. See the
-    // codegen-template comment in renderGenericBoardStateSchema for
-    // the rationale; the wire shape is unchanged (additionalProperties
-    // JSON), and the inner id field narrows at parse time.
-    spaces: z6.record(z6.string(), boardSpaceStateSchema),
-    relations: z6.array(boardRelationStateSchema),
-    containers: z6.record(z6.string(), boardContainerStateSchema)
-  });
-  const hexEdgeStateSchema = z6.object({
-    id: ids.edgeId,
-    spaceIds: z6.array(ids.spaceId).min(1).max(2),
-    typeId: ids.edgeTypeId.nullable().optional(),
-    label: z6.string().nullable().optional(),
-    ownerId: ids.playerId.nullable().optional(),
-    fields: unknownRecordSchema
-  });
-  const hexVertexStateSchema = z6.object({
-    id: ids.vertexId,
-    spaceIds: z6.array(ids.spaceId).min(1).max(3),
-    typeId: ids.vertexTypeId.nullable().optional(),
-    label: z6.string().nullable().optional(),
-    ownerId: ids.playerId.nullable().optional(),
-    fields: unknownRecordSchema
-  });
-  const squareVertexStateSchema = z6.object({
-    id: ids.vertexId,
-    spaceIds: z6.array(ids.spaceId).min(1).max(4),
-    typeId: ids.vertexTypeId.nullable().optional(),
-    label: z6.string().nullable().optional(),
-    ownerId: ids.playerId.nullable().optional(),
-    fields: unknownRecordSchema
-  });
-  const runtimeHexBoardStateSchema = runtimeGenericBoardStateSchema.extend({
-    layout: z6.literal("hex"),
-    // T220: loose-keyed by string — see comment above.
-    spaces: z6.record(z6.string(), hexSpaceStateSchema),
-    relations: z6.array(boardRelationStateSchema),
-    containers: z6.object({}),
-    orientation: z6.enum(["pointy-top", "flat-top"]),
-    edges: z6.array(hexEdgeStateSchema),
-    vertices: z6.array(hexVertexStateSchema)
-  });
-  const runtimeSquareBoardStateSchema = runtimeGenericBoardStateSchema.extend({
-    layout: z6.literal("square"),
-    // T220: loose-keyed by string — see comment above.
-    spaces: z6.record(z6.string(), squareSpaceStateSchema),
-    relations: z6.array(boardRelationStateSchema),
-    containers: z6.record(z6.string(), boardContainerStateSchema),
-    edges: z6.array(hexEdgeStateSchema),
-    vertices: z6.array(squareVertexStateSchema)
-  });
-  const boards = analysis.analyzedBoards.flatMap(
-    (board) => board.runtimeBoardIds.map((id) => {
-      const base = {
-        id: board.board.scope === "perPlayer" ? z6.templateLiteral([board.board.id, ":", z6.string().min(1)]) : z6.literal(id),
-        baseId: z6.literal(board.board.id),
-        scope: z6.literal(board.board.scope),
-        fields: objectSchema(board.boardFieldsSchema)
-      };
-      const spaces = boardSpaceStateSchema.extend({
-        fields: objectSchema(board.spaceFieldsSchema)
-      });
-      const relations = z6.array(
-        boardRelationStateSchema.extend({
-          fields: objectSchema(
-            "relationFieldsSchema" in board ? board.relationFieldsSchema : void 0
-          )
-        })
-      );
-      const containers = "containers" in board ? shape(
-        board.containers,
-        (item) => item.id,
-        (item) => boardContainerStateSchema.extend({
-          id: z6.literal(item.id),
-          fields: objectSchema(board.containerFieldsSchema)
-        })
-      ) : z6.object({});
-      if (board.layout === "generic")
-        return {
-          id,
-          scope: board.board.scope,
-          layout: board.layout,
-          schema: runtimeGenericBoardStateSchema.extend({
-            ...base,
-            spaces: z6.record(z6.string(), spaces),
-            relations,
-            containers
-          })
-        };
-      const edges = z6.array(
-        hexEdgeStateSchema.extend({
-          fields: objectSchema(board.edgeFieldsSchema)
-        })
-      );
-      const vertices = z6.array(
-        (board.layout === "hex" ? hexVertexStateSchema : squareVertexStateSchema).extend({ fields: objectSchema(board.vertexFieldsSchema) })
-      );
-      return {
-        id,
-        scope: board.board.scope,
-        layout: board.layout,
-        schema: board.layout === "hex" ? runtimeHexBoardStateSchema.extend({
-          ...base,
-          spaces: z6.record(
-            z6.string(),
-            spaces.extend({ q: z6.number().int(), r: z6.number().int() })
-          ),
-          edges,
-          vertices
-        }) : runtimeSquareBoardStateSchema.extend({
-          ...base,
-          spaces: z6.record(
-            z6.string(),
-            spaces.extend({
-              row: z6.number().int(),
-              col: z6.number().int()
-            })
-          ),
-          relations,
-          containers,
-          edges,
-          vertices
-        })
-      };
-    })
-  );
-  const boardCollection = (entries) => {
-    const shared = entries.filter((board) => board.scope === "shared");
-    const scoped = entries.filter((board) => board.scope === "perPlayer").map((board) => board.schema);
-    return shape(
-      shared,
-      (board) => board.id,
-      (board) => board.schema
-    ).catchall(scoped.length ? z6.union(scoped) : z6.never());
-  };
-  const boardStateByIdSchema = boardCollection(boards);
-  const hexBoardStateByIdSchema = boardCollection(
-    boards.filter((board) => board.layout === "hex")
-  );
-  const squareBoardStateByIdSchema = boardCollection(
-    boards.filter((board) => board.layout === "square")
-  );
-  return z6.object({
-    playerOrder: z6.array(ids.playerId),
-    zones: z6.object({
-      shared: sharedZoneSchema,
-      perPlayer: playerZoneSchema,
-      visibility: z6.record(
-        zoneIdSchema,
-        z6.enum(["all", "ownerOnly", "public", "hidden"])
-      ),
-      cardSetIdsByZoneId: z6.record(zoneIdSchema, z6.array(ids.cardSetId)).optional()
-    }),
-    decks: sharedZoneSchema,
-    hands: playerZoneSchema,
-    handVisibility: z6.record(
-      playerZoneIdSchema,
-      z6.enum(["all", "ownerOnly", "public", "hidden"])
-    ),
-    cards: cardStateByIdSchema,
-    pieces: pieceStateByIdSchema,
-    componentLocations: z6.record(
-      z6.string(),
-      z6.union([
-        z6.object({ type: z6.literal("Detached") }),
-        z6.object({
-          type: z6.literal("InDeck"),
-          deckId: ids.deckId,
-          playedBy: ids.playerId.nullable(),
-          position: z6.number().int().nullable().optional()
-        }),
-        z6.object({
-          type: z6.literal("InHand"),
-          handId: ids.handId,
-          playerId: ids.playerId,
-          position: z6.number().int().nullable().optional()
-        }),
-        z6.object({
-          type: z6.literal("InZone"),
-          zoneId: z6.string(),
-          playedBy: ids.playerId.nullable().optional(),
-          position: z6.number().int().nullable().optional()
-        }),
-        z6.object({
-          type: z6.literal("OnSpace"),
-          boardId: ids.boardId,
-          spaceId: ids.spaceId,
-          position: z6.number().int().nullable().optional()
-        }),
-        z6.object({
-          type: z6.literal("InContainer"),
-          boardId: ids.boardId,
-          containerId: ids.boardContainerId,
-          position: z6.number().int().nullable().optional()
-        }),
-        z6.object({
-          type: z6.literal("OnEdge"),
-          boardId: ids.boardId,
-          edgeId: ids.edgeId,
-          position: z6.number().int().nullable().optional()
-        }),
-        z6.object({
-          type: z6.literal("OnVertex"),
-          boardId: ids.boardId,
-          vertexId: ids.vertexId,
-          position: z6.number().int().nullable().optional()
-        }),
-        slotLocationSchema
-      ])
-    ),
-    ownerOfCard: z6.record(ids.cardId, ids.playerId.nullable()),
-    visibility: z6.record(
-      ids.cardId,
-      z6.object({
-        faceUp: z6.boolean(),
-        visibleTo: z6.array(ids.playerId).nullable().optional()
-      })
-    ),
-    resources: perPlayerSchema(z6.record(ids.resourceId, z6.number().int())),
-    boards: z6.object({
-      byId: boardStateByIdSchema,
-      hex: hexBoardStateByIdSchema,
-      square: squareBoardStateByIdSchema,
-      network: z6.record(z6.string(), unknownRecordSchema).default({}),
-      track: z6.record(z6.string(), unknownRecordSchema).default({})
-    }),
-    dice: dieStateByIdSchema
-  });
-}
-
-// src/reducer/manifest/compiler.ts
-function compileManifest(manifest) {
-  const source = manifest;
-  const analysis = analyzeManifest(source);
-  const initial = materializeManifestTable({
-    manifest: source,
-    playerIds: analysis.playerIds,
-    shuffleItems: (values) => [...values]
-  });
-  const sharedZoneIds = analysis.sharedZones.map((zone) => zone.id).sort();
-  const playerZoneIds = analysis.playerZones.map((zone) => zone.id).sort();
-  const literals = {
-    ...Object.fromEntries(
-      Object.entries(analysis).filter(([key]) => key.endsWith("Ids") || key === "cardTypes").map(([key, value]) => [key, value])
-    ),
-    playerIds: analysis.playerIds.map(asPlayerId),
-    phaseNames: [],
-    boardLayouts: ["generic", "hex", "square"],
-    deckIds: sharedZoneIds,
-    handIds: playerZoneIds,
-    sharedZoneIds,
-    playerZoneIds,
-    resourcePresentationById: analysis.resourcePresentationById,
-    handVisibilityById: Object.fromEntries(
-      playerZoneIds.map((id) => [
-        id,
-        analysis.zoneVisibilityById.get(id) ?? "ownerOnly"
-      ])
-    ),
-    zoneVisibilityById: Object.fromEntries(analysis.zoneVisibilityById),
-    cardSetIdByCardId: Object.fromEntries(analysis.cardSetIdByCardId),
-    cardTypeByCardId: Object.fromEntries(analysis.cardTypeByCardId),
-    setupChoiceIdsByOptionId: Object.fromEntries(
-      analysis.setupChoiceIdsByOptionId
-    ),
-    cardSetIdsBySharedZoneId: Object.fromEntries(analysis.sharedZoneCardSetIds),
-    cardSetIdsByPlayerZoneId: Object.fromEntries(analysis.playerZoneCardSetIds)
-  };
-  const families = [
-    "phaseName",
-    "boardLayout",
-    "setupOptionId",
-    "setupProfileId",
-    "cardSetId",
-    "cardType",
-    "cardId",
-    "deckId",
-    "handId",
-    "sharedZoneId",
-    "playerZoneId",
-    "zoneId",
-    "resourceId",
-    "pieceTypeId",
-    "pieceId",
-    "dieTypeId",
-    "dieId",
-    "boardTypeId",
-    "boardBaseId",
-    "boardId",
-    "boardContainerId",
-    "relationTypeId",
-    "edgeId",
-    "edgeTypeId",
-    "vertexId",
-    "vertexTypeId",
-    "spaceId",
-    "spaceTypeId"
-  ];
-  const ids = {
-    ...Object.fromEntries(
-      families.map((family) => {
-        const values = literals[`${family}s`];
-        return [
-          family,
-          family === "phaseName" ? markManifestScopedSchema(z7.string(), family) : values.length ? createManifestStringLiteralSchema(values, family) : markManifestScopedSchema(z7.never(), family)
-        ];
-      })
-    ),
-    playerId: markManifestScopedSchema(
-      z7.string().min(1).transform(asPlayerId),
-      "playerId"
-    )
-  };
-  const boardIdSchemas = analysis.analyzedBoards.map(
-    (board) => board.board.scope === "perPlayer" ? z7.templateLiteral([board.board.id, ":", z7.string().min(1)]) : z7.literal(board.board.id)
-  );
-  ids.boardId = markManifestScopedSchema(
-    boardIdSchemas.length ? z7.union(boardIdSchemas) : z7.never(),
-    "boardId"
-  );
-  const tableSchema = assumeManifestSchema(
-    createTableSchema(analysis, ids)
-  );
-  const resolvePlayers = (players = analysis.playerIds) => players.map(asPlayerId);
-  const emptyDecks = () => Object.fromEntries(sharedZoneIds.map((id) => [id, []]));
-  const hands = (players) => Object.fromEntries(
-    playerZoneIds.map((id) => [
-      id,
-      perPlayer(resolvePlayers(players), () => [])
-    ])
-  );
-  const defaults = {
-    zones: (players) => ({
-      shared: emptyDecks(),
-      perPlayer: hands(players),
-      visibility: structuredClone(literals.zoneVisibilityById),
-      cardSetIdsByZoneId: Object.fromEntries(analysis.zoneCardSetIdsById)
-    }),
-    decks: emptyDecks,
-    hands,
-    handVisibility: () => structuredClone(literals.handVisibilityById),
-    ownerOfCard: () => Object.fromEntries(analysis.cardIds.map((id) => [id, null])),
-    visibility: () => Object.fromEntries(analysis.cardIds.map((id) => [id, { faceUp: true }])),
-    resources: (players) => perPlayer(
-      resolvePlayers(players),
-      () => Object.fromEntries(analysis.resourceIds.map((id) => [id, 0]))
-    )
-  };
-  const runtimeSchema = createManifestRuntimeSchema({
-    phaseNameSchema: z7.string(),
-    playerIdSchema: ids.playerId,
-    setupProfileIdSchema: ids.setupProfileId
-  });
-  const createInitialTable = (options = {}) => tableSchema.parse(
-    materializeManifestTable({
-      manifest: source,
-      playerIds: options.playerIds ?? analysis.playerIds,
-      shuffleItems: options.shuffleItems ?? ((values) => [...values])
-    })
-  );
-  return {
-    literals,
-    ids,
-    defaults,
-    records: Object.fromEntries(
-      [...families, "playerId"].map((family) => [
-        `${family}s`,
-        (initial2) => buildTypedRecord(
-          literals[`${family}s`],
-          initial2
-        )
-      ])
-    ),
-    tableSchema,
-    runtimeSchema,
-    schemas: { table: tableSchema, runtime: runtimeSchema },
-    staticBoards: initial.boards,
-    setupOptionsById: analysis.setupOptionsById,
-    setupChoiceIdsByOptionId: literals.setupChoiceIdsByOptionId,
-    setupProfilesById: analysis.setupProfilesById,
-    createInitialTable,
-    normalSetup: {
-      minPlayers: source.players.minPlayers,
-      maxPlayers: source.players.maxPlayers,
-      createInitialTable
-    },
-    createGameStateSchema: (config) => createManifestGameStateSchema({
-      ...config,
-      tableSchema,
-      playerIdSchema: ids.playerId,
-      setupProfileIdSchema: ids.setupProfileId
-    })
-  };
-}
-
-// src/reducer/authoring/validation.ts
-var MANIFEST_SCOPED_ID_NAMES = [
-  "playerId",
-  "cardId",
-  "deckId",
-  "handId",
-  "zoneId",
-  "sharedZoneId",
-  "playerZoneId",
-  "boardId",
-  "boardContainerId",
-  "boardTypeId",
-  "boardBaseId",
-  "edgeId",
-  "edgeTypeId",
-  "vertexId",
-  "vertexTypeId",
-  "spaceId",
-  "spaceTypeId",
-  "relationTypeId",
-  "resourceId",
-  "pieceId",
-  "pieceTypeId",
-  "dieId",
-  "dieTypeId",
-  "setupOptionId",
-  "setupProfileId",
-  "cardSetId",
-  "cardType"
-];
-function matchManifestScopedIdName(key) {
-  for (const name of MANIFEST_SCOPED_ID_NAMES) {
-    const capitalized = `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
-    if (key === name || key.endsWith(capitalized)) {
-      return { name, kind: "singular" };
-    }
-    const plural = `${name}s`;
-    const capitalizedPlural = `${capitalized}s`;
-    if (key === plural || key.endsWith(capitalizedPlural)) {
-      return { name, kind: "plural" };
-    }
-  }
-  return null;
-}
-function validateInteractionParamsSchema(schema, context, path) {
-  const inner = unwrapWrappers(schema);
-  if (isEnumKeyedRecordSchema(inner) && !isSparseMapSchema(inner)) {
-    throw new Error(
-      `${context}: ${path} uses an enum-keyed z.record(...), which parses as a total map at runtime. Use sparseMap(...) or sparseCounts(...) from @dreamboard-games/sdk/reducer instead so interaction params stay sparse and match runtime validation.`
-    );
-  }
-  const shape = getObjectShape(inner);
-  if (shape) {
-    for (const [key, fieldSchema] of Object.entries(shape)) {
-      validateInteractionParamsSchema(fieldSchema, context, `${path}.${key}`);
-    }
-    return;
-  }
-  const def = getZodDef(inner);
-  if (def.type === "array" && def.element) {
-    validateInteractionParamsSchema(def.element, context, `${path}[]`);
-    return;
-  }
-  if (def.type === "record" && def.valueType) {
-    validateInteractionParamsSchema(def.valueType, context, `${path}.*`);
-  }
-}
-function validateInteractionInputsSchema(inputs, context) {
-  if (!inputs) return;
-  for (const [key, collector] of Object.entries(inputs)) {
-    validateInteractionParamsSchema(collector.schema, context, `inputs.${key}`);
-  }
-}
-function validateManyCommitPolicy(input) {
-  if (input.commit?.mode !== "autoWhenReady") return;
-  if (Object.values(input.inputs ?? {}).some(
-    (collector) => collector.selection?.mode === "many"
-  )) {
-    throw new Error(
-      `${input.context}: interactions with many(...) inputs must use commit: { mode: "manual" }.`
-    );
-  }
-}
-function validateInteractionLikeDefinition(input, context) {
-  validateInteractionInputsSchema(input.inputs, context);
-  validateManyCommitPolicy({
-    inputs: input.inputs,
-    commit: input.commit,
-    context
-  });
-  if (input.paramsSchema) {
-    validateInteractionParamsSchema(
-      input.paramsSchema,
-      context,
-      "paramsSchema"
-    );
-  }
-}
-function validateStateSchemaIdBranding(schema, scope) {
-  const def = getZodDef(schema);
-  if (def.type !== "object") {
-    return;
-  }
-  const shape = def.shape;
-  if (!shape) {
-    return;
-  }
-  for (const [key, fieldSchema] of Object.entries(shape)) {
-    const match = matchManifestScopedIdName(key);
-    if (!match) {
-      continue;
-    }
-    const inner = unwrapWrappers(fieldSchema);
-    if (match.kind === "singular") {
-      if (isPlainZodString(inner) && !isManifestScopedSchema(inner)) {
-        throw new Error(
-          `defineGameContract: state.${scope}.${key} uses a raw z.string() but its name identifies it as a manifest-scoped '${match.name}'. Use gameContract.schemas.${match.name} (or manifest.ids.${match.name}) so the branded literal union flows through state types.`
-        );
-      }
-      continue;
-    }
-    if (match.kind === "plural" && isZodArray(inner)) {
-      const element = unwrapWrappers(getZodDef(inner).element);
-      if (isPlainZodString(element) && !isManifestScopedSchema(element)) {
-        throw new Error(
-          `defineGameContract: state.${scope}.${key} uses z.array(z.string()) but its name identifies it as manifest-scoped '${match.name}' values. Use z.array(gameContract.schemas.${match.name}) (or manifest.ids.${match.name}) so the branded literal union flows through state types.`
-        );
-      }
-    }
-  }
-}
-function validateDefineGamePhaseNames(definition) {
-  const contractPhaseNames = definition.contract.phaseNames;
-  if (!Array.isArray(contractPhaseNames)) {
-    return;
-  }
-  const declared = new Set(contractPhaseNames);
-  const actual = new Set(Object.keys(definition.phases));
-  const missing = [...declared].filter((name) => !actual.has(name));
-  const extra = [...actual].filter((name) => !declared.has(name));
-  if (missing.length > 0 || extra.length > 0) {
-    const parts = [];
-    if (missing.length > 0) {
-      parts.push(`missing: [${missing.join(", ")}]`);
-    }
-    if (extra.length > 0) {
-      parts.push(`extra: [${extra.join(", ")}]`);
-    }
-    throw new Error(
-      `defineGame: phases record does not match contract.phaseNames (${parts.join(
-        "; "
-      )}). Update contract.phaseNames or the phases record so they agree.`
-    );
-  }
-  if (definition.initialPhase !== void 0 && !declared.has(definition.initialPhase)) {
-    throw new Error(
-      `defineGame: initialPhase '${definition.initialPhase}' is not declared in contract.phaseNames.`
-    );
-  }
-  if (definition.setupProfiles) {
-    for (const [profileId, profile] of Object.entries(
-      definition.setupProfiles
-    )) {
-      const initial = profile?.initialPhase;
-      if (initial !== void 0 && !declared.has(initial)) {
-        throw new Error(
-          `defineGame: setupProfiles.${profileId}.initialPhase '${initial}' is not declared in contract.phaseNames.`
-        );
-      }
-    }
-  }
-}
-function validateDefineGameZoneWiring(definition) {
-  const manifestPlayerZoneIds = new Set(
-    definition.contract.manifest.literals.playerZoneIds ?? []
-  );
-  for (const [phaseName, phase] of Object.entries(definition.phases)) {
-    const phaseRecord = typeof phase === "object" && phase !== null ? phase : null;
-    if (!phaseRecord) continue;
-    if (phaseRecord.zones !== void 0 && !Array.isArray(phaseRecord.zones)) {
-      const zonesRecord = typeof phaseRecord.zones === "object" && phaseRecord.zones !== null ? phaseRecord.zones : null;
-      const hasRemovedZoneSpec = zonesRecord && Object.values(zonesRecord).some(
-        (zone) => typeof zone === "object" && zone !== null && ("cardsFrom" in zone || "playableVia" in zone || "from" in zone)
-      );
-      if (hasRemovedZoneSpec) {
-        throw new Error(
-          `defineGame: phases.${phaseName}.zones uses removed zone spec objects. Use zones: ["manifest-player-zone-id"] and cardActions[*].playFrom instead.`
-        );
-      }
-      throw new Error(
-        `defineGame: phases.${phaseName}.zones must be an array of manifest player zone ids.`
-      );
-    }
-    for (const [index, zoneId] of (phaseRecord.zones ?? []).entries()) {
-      if (typeof zoneId !== "string") {
-        throw new Error(
-          `defineGame: phases.${phaseName}.zones[${index}] must be a manifest player zone id string.`
-        );
-      }
-      if (!manifestPlayerZoneIds.has(zoneId)) {
-        throw new Error(
-          `defineGame: phases.${phaseName}.zones[${index}] '${zoneId}' is not declared in manifest.literals.playerZoneIds.`
-        );
-      }
-    }
-    for (const [actionId, action] of Object.entries(
-      phaseRecord.cardActions ?? {}
-    )) {
-      const actionRecord = typeof action === "object" && action !== null ? action : null;
-      const playFrom = actionRecord?.playFrom;
-      if (typeof playFrom === "string" && !manifestPlayerZoneIds.has(playFrom)) {
-        throw new Error(
-          `defineGame: phases.${phaseName}.cardActions.${actionId}.playFrom '${playFrom}' is not declared in manifest.literals.playerZoneIds.`
-        );
-      }
-    }
-  }
-}
-function validateDefineGameSimultaneousPhases(definition) {
-  for (const [phaseName, phase] of Object.entries(definition.phases)) {
-    const phaseRecord = typeof phase === "object" && phase !== null ? phase : null;
-    if (!phaseRecord || phaseRecord.kind !== "simultaneousPlayer") {
-      continue;
-    }
-    if (!phaseRecord.submit) {
-      throw new Error(
-        `defineGame: phases.${phaseName} is kind 'simultaneousPlayer' but does not declare submit.`
-      );
-    }
-    if (typeof phaseRecord.resolve !== "function") {
-      throw new Error(
-        `defineGame: phases.${phaseName} is kind 'simultaneousPlayer' but does not declare resolve.`
-      );
-    }
-    if (phaseRecord.interactions?.submit) {
-      throw new Error(
-        `defineGame: phases.${phaseName}.interactions.submit conflicts with the reserved simultaneous submit interaction id.`
-      );
-    }
-    validateInteractionInputsSchema(
-      phaseRecord.submit.inputs,
-      "defineInteraction"
-    );
-    validateManyCommitPolicy({
-      inputs: phaseRecord.submit.inputs,
-      commit: phaseRecord.submit.commit,
-      context: `defineGame: phases.${phaseName}.submit`
-    });
-  }
-}
-
-// src/reducer/authoring/interaction.ts
-function defineInteraction() {
-  return (definition) => {
-    validateInteractionLikeDefinition(
-      definition,
-      "defineInteraction"
-    );
-    return definition;
-  };
-}
-function defineInteractionRule() {
-  return (definition) => definition;
-}
-function defineCardAction() {
-  return (definition) => {
-    validateInteractionLikeDefinition(
-      definition,
-      "defineCardAction"
-    );
-    return definition;
-  };
-}
-
-// src/reducer/authoring/phase.ts
-import { z as z8 } from "zod";
-function stepStateSchema(schema, steps) {
-  const stepSchema = z8.enum(steps);
-  const maybeObject = schema;
-  if (typeof maybeObject.extend === "function") {
-    return maybeObject.extend({ step: stepSchema });
-  }
-  return z8.intersection(schema, z8.object({ step: stepSchema }));
-}
-function unwrapStepInteractions(interactions) {
-  if (!interactions) return void 0;
-  return Object.fromEntries(
-    Object.entries(interactions).map(([key, entry]) => [
-      key,
-      {
-        ...entry.interaction,
-        __steps: entry.steps
-      }
-    ])
-  );
-}
-function unwrapStepCardActions(cardActions) {
-  if (!cardActions) return void 0;
-  return Object.fromEntries(
-    Object.entries(cardActions).map(([key, entry]) => [
-      key,
-      {
-        ...entry.action,
-        __steps: entry.steps
-      }
-    ])
-  );
-}
-function definePhase() {
-  return (definition) => {
-    return definition;
-  };
-}
-function defineStepPhase() {
-  return (definition) => {
-    const [initialStep] = definition.steps;
-    const state = stepStateSchema(definition.state, definition.steps);
-    const initialState = definition.initialState ? (ctx) => ({
-      ...definition.initialState?.(ctx),
-      step: initialStep
-    }) : () => ({ step: initialStep });
-    const { steps: _steps, ...rest } = definition;
-    void _steps;
-    const normalized = {
-      ...rest,
-      state,
-      initialState,
-      interactions: unwrapStepInteractions(definition.interactions),
-      cardActions: unwrapStepCardActions(definition.cardActions)
-    };
-    return normalized;
-  };
-}
-
-// src/reducer/authoring/view-stage.ts
-function defineSharedView() {
-  return (definition) => definition;
-}
-function definePlayerView() {
-  return (definition) => definition;
-}
-function defineEmptyView() {
-  return {
-    project: () => ({})
-  };
-}
-function defineStaticView() {
-  return (definition) => definition;
-}
-
-// src/reducer/authoring/contract-authoring.ts
-var PHANTOM_TYPES_MESSAGE = "`.types` is a compile-time carrier: use it only in `typeof` positions.";
-function phantomTypes() {
-  return new Proxy(Object.freeze({}), {
-    get() {
-      throw new TypeError(PHANTOM_TYPES_MESSAGE);
-    }
-  });
-}
-function toPredicateList(where) {
-  if (!where) return [];
-  return Array.isArray(where) ? where : [where];
-}
-function applyWhere(builder, where) {
-  return toPredicateList(where).reduce(
-    (current, predicate) => current.where(predicate),
-    builder
-  );
-}
-function createFusedCardInput() {
-  return ((options) => {
-    const target = applyWhere(
-      cardTarget.zones(options.from),
-      options.where
-    ).build();
-    return cardInput({
-      target,
-      ...options.dependsOn ? { dependsOn: options.dependsOn } : {}
-    });
-  });
-}
-function createFusedBoardInputs() {
-  const fuse = (kind) => (options) => {
-    const target = applyWhere(
-      boardTarget[kind](options.boardId),
-      options.where
-    ).build();
-    return boardInput[kind]({
-      target,
-      ...options.dependsOn ? { dependsOn: options.dependsOn } : {}
-    });
-  };
-  const playerSpace = (options) => boardInput.playerSpace({
-    target: applyWhere(
-      boardTarget.playerSpace(options.boardId),
-      options.where
-    ).build(),
-    ...options.dependsOn ? { dependsOn: options.dependsOn } : {}
-  });
-  return {
-    vertex: fuse("vertex"),
-    edge: fuse("edge"),
-    space: fuse("space"),
-    tile: fuse("tile"),
-    playerSpace
-  };
-}
-function createFusedPromptInput() {
-  return ((options) => promptInput({
-    schema: options.schema,
-    ...options.choices ? {
-      target: applyWhere(
-        choiceTarget.options(
-          options.choices
-        ),
-        options.where
-      ).build()
-    } : {}
-  }));
-}
-function createBoundInputBuilders() {
-  return {
-    board: createFusedBoardInputs(),
-    card: createFusedCardInput(),
-    form: formInput.forState(),
-    prompt: createFusedPromptInput(),
-    rng: rngInput
-  };
-}
-function createPhaseAuthoring(_contract, schema) {
-  return {
-    interaction: (spec) => defineInteraction()(
-      spec
-    ),
-    cardAction: (spec) => defineCardAction()(
-      spec
-    ),
-    rule: (rule) => defineInteractionRule()(
-      rule
-    ),
-    define: (definition) => definePhase()({
-      ...definition,
-      state: schema
-    }),
-    stepPhase: (definition) => defineStepPhase()({
-      ...definition,
-      state: schema
-    }),
-    inputs: createBoundInputBuilders(),
-    types: phantomTypes()
-  };
-}
-function createContractAuthoring(contract) {
-  const phaseCache = /* @__PURE__ */ new Map();
-  const views = {
-    shared: (definition) => defineSharedView()(definition),
-    player: (definition) => definePlayerView()(definition),
-    empty: () => defineEmptyView(),
-    static: (definition) => defineStaticView()(definition)
-  };
-  const assemble = (definition) => defineGameDefinition({
-    contract,
-    ...definition
-  });
-  return {
-    contract,
-    views,
-    types: phantomTypes(),
-    assemble,
-    phase: (name) => {
-      const cached = phaseCache.get(name);
-      if (cached) return cached;
-      const schema = contract.phases[name];
-      const bound = createPhaseAuthoring(contract, schema);
-      phaseCache.set(name, bound);
-      return bound;
-    }
-  };
-}
-
-// src/reducer/authoring/contract.ts
-function validateErrorMap(errors) {
-  if (!errors) return;
-  const codePattern = /^[A-Z][A-Z0-9_]*$/;
-  for (const [code, message] of Object.entries(errors)) {
-    if (!codePattern.test(code)) {
-      throw new Error(
-        `defineGameContract: error code '${code}' must use UPPER_SNAKE_CASE.`
-      );
-    }
-    if (typeof message !== "string" || message.length === 0) {
-      throw new Error(
-        `defineGameContract: error code '${code}' must declare a non-empty default message.`
-      );
-    }
-  }
-}
-function defineGameContract(definition) {
-  validateStateSchemaIdBranding(definition.state.public, "public");
-  validateStateSchemaIdBranding(definition.state.private, "private");
-  validateStateSchemaIdBranding(definition.state.hidden, "hidden");
-  validateErrorMap(definition.errors);
-  const phaseNames = Object.keys(definition.phases);
-  if (phaseNames.length === 0) {
-    throw new Error(
-      "defineGameContract: phases must be a non-empty record of phase schemas."
-    );
-  }
-  for (const name of phaseNames) {
-    if (typeof name !== "string" || name.length === 0) {
-      throw new Error(
-        "defineGameContract: phase names must be non-empty strings."
-      );
-    }
-  }
-  const phaseNameSchema = createManifestStringLiteralSchema(phaseNames);
-  const narrowedManifest = {
-    ...definition.manifest,
-    literals: {
-      ...definition.manifest.literals,
-      phaseNames
-    },
-    ids: {
-      ...definition.manifest.ids,
-      phaseName: phaseNameSchema
-    }
-  };
-  const contract = {
-    manifest: narrowedManifest,
-    state: definition.state,
-    phases: definition.phases,
-    errors: definition.errors,
-    phaseNames,
-    schemas: narrowedManifest.ids
-  };
-  return contract;
-}
-
-// src/reducer/authoring/game.ts
-function defineGameDefinition(definition) {
-  validateDefineGamePhaseNames(definition);
-  validateDefineGameSimultaneousPhases(definition);
-  validateDefineGameZoneWiring(definition);
-  return definition;
-}
-function createGame(model) {
-  const manifest = "literals" in model.manifest ? model.manifest : compileManifest(model.manifest);
-  return createContractAuthoring(defineGameContract({ ...model, manifest }));
-}
-
-export {
-  sparseMap,
-  sparseCounts,
-  normalizeCommandParams,
-  defineInputs,
-  many,
-  compileManifest,
-  defineGameDefinition,
-  createGame
-};
-//# sourceMappingURL=chunk-ZZGN2ATS.js.map