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

package/dist/reducer.js

@@ -3,15 +3,22 @@ import {
   contractFingerprint,
   createDerivedResolver,
   createReducerBundle,
-  createReducerEdit,
   createReducerOps,
-  createReducerTransaction,
   createStateQueries,
   createTableQueries,
   defineDerived,
   isStaleContractArtifactError,
   noopDiagnosticsSink
-} from "./chunk-533O7C4L.js";
+} from "./chunk-S2JEDVWH.js";
+import {
+  compileManifest,
+  createGame,
+  defineInputs,
+  many,
+  normalizeCommandParams,
+  sparseCounts,
+  sparseMap
+} from "./chunk-ZZGN2ATS.js";
 import {
   FrameworkErrorCodes,
   asPlayerId,
@@ -19,17 +26,10 @@ import {
   boardRef,
   boardRefKey,
   boardRefSchema,
-  cardInput,
-  cardTarget,
-  createManifestStringLiteralSchema,
-  createTargetRule,
-  createTargetRuleBuilder,
-  isManifestScopedSchema,
   isPerPlayer,
   isPerPlayerBoardRef,
   isPlayerId,
   isSharedBoardRef,
-  markManifestScopedSchema,
   parseBoardRefKey,
   perPlayer,
   perPlayerBoardRef,
@@ -45,1267 +45,15 @@ import {
   perPlayerValues,
   setActivePlayers,
   sharedBoardRef
-} from "./chunk-FL67RDID.js";
+} from "./chunk-H6VDGFL5.js";
+import "./chunk-5YV2WHJ4.js";
 import "./chunk-PF7L4BMG.js";
-import "./chunk-2GQIALJL.js";
+import "./chunk-Z7QCREWI.js";
+import "./chunk-UGH54WZ2.js";
 import "./chunk-PZ5AY32C.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/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/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/inputs/formInput.ts
-import { z as z2 } 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 z2.null();
-  }
-  const stringSchema = z2.enum(
-    stringValues
-  );
-  if (hasNull) {
-    return z2.union([stringSchema, z2.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: z2.record(z2.string(), z2.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: z2.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) : z2.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: z2.array(z2.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/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/boardInput.ts
-import { z as z3 } from "zod";
-function makeBoardCollector(kind) {
-  return function collector(options) {
-    const target = options.target;
-    const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
-    return {
-      kind,
-      schema: z3.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(
-    z3.string(),
-    "playerId"
-  );
-  return {
-    kind: "board-space",
-    schema: z3.object({
-      boardId: z3.literal(target.boardId),
-      playerId: playerIdSchema,
-      spaceId: z3.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 z4 } from "zod";
-function d6(count = 1) {
-  return {
-    kind: "rng",
-    schema: z4.object({
-      values: z4.array(z4.number().int().min(1).max(6)).length(count)
-    }),
-    meta: { rng: "d6", count }
-  };
-}
-function coin() {
-  return {
-    kind: "rng",
-    schema: z4.object({
-      value: z4.enum(["heads", "tails"])
-    }),
-    meta: { rng: "coin" }
-  };
-}
-var rngInput = { d6, coin };
-
-// src/reducer/inputs/many.ts
-import { z as z5 } 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: z5.array(
-      collector.schema
-    ),
-    selection
-  };
-}
-
-// src/reducer/authoring/game.ts
-function defineGame(definition) {
-  validateDefineGamePhaseNames(definition);
-  validateDefineGameSimultaneousPhases(definition);
-  validateDefineGameZoneWiring(definition);
-  return definition;
-}
-
-// 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 z6 } from "zod";
-function stepStateSchema(schema, steps) {
-  const stepSchema = z6.enum(steps);
-  const maybeObject = schema;
-  if (typeof maybeObject.extend === "function") {
-    return maybeObject.extend({ step: stepSchema });
-  }
-  return z6.intersection(schema, z6.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;
-}
-function defineStage() {
-  return (definition) => definition;
-}
-function definePhaseStage() {
-  return (definition) => definition;
-}
-
-// src/reducer/authoring/contract-authoring.ts
-function createBoundInputBuilders() {
-  return {
-    board: boardInput,
-    boardTarget,
-    card: cardInput,
-    cardTarget,
-    choiceTarget,
-    form: formInput.forState(),
-    prompt: promptInput,
-    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()
-  };
-}
-function createContractAuthoring(contract) {
-  const phaseCache = /* @__PURE__ */ new Map();
-  return {
-    contract,
-    game: (definition) => defineGame({ contract, ...definition }),
-    sharedView: (definition) => defineSharedView()(definition),
-    playerView: (definition) => definePlayerView()(definition),
-    emptyView: () => defineEmptyView(),
-    staticView: (definition) => defineStaticView()(definition),
-    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/effect.ts
-import { z as z7 } from "zod";
+import { z } from "zod";
 function createContinuationCallable(definition) {
   const continuation = ((data) => {
     return {
@@ -1334,11 +82,11 @@ function defineEffect() {
           contextSchema: definition.context
         };
       }
-      const contextSchema = definition.context ?? z7.object({});
+      const contextSchema = definition.context ?? z.object({});
       const continuation = createContinuationCallable({
         id: definition.id,
         data: contextSchema,
-        response: z7.unknown(),
+        response: z.unknown(),
         effectKind,
         reduce: definition.reduce
       });
@@ -1379,40 +127,20 @@ export {
   StaleContractArtifactError,
   asPlayerId,
   assertCardAllowedInContainer,
-  boardInput,
   boardRef,
   boardRefKey,
   boardRefSchema,
-  boardTarget,
-  cardInput,
-  cardTarget,
-  choiceTarget,
+  compileManifest,
   contractFingerprint,
-  createContractAuthoring,
   createDerivedResolver,
+  createGame,
   createReducerBundle,
-  createReducerEdit,
   createReducerOps,
-  createReducerTransaction,
   createStateQueries,
   createTableQueries,
-  defineCardAction,
   defineDerived,
   defineEffect,
-  defineEmptyView,
-  defineGame,
-  defineGameContract,
   defineInputs,
-  defineInteraction,
-  defineInteractionRule,
-  definePhase,
-  definePhaseStage,
-  definePlayerView,
-  defineSharedView,
-  defineStage,
-  defineStaticView,
-  defineStepPhase,
-  formInput,
   gameEvent,
   isPerPlayer,
   isPerPlayerBoardRef,
@@ -1436,8 +164,6 @@ export {
   perPlayerSize,
   perPlayerValues,
   pipe,
-  promptInput,
-  rngInput,
   setActivePlayers,
   sharedBoardRef,
   sparseCounts,