dreamboard 0.1.16 → 0.1.18

package/dist/{chunk-WDTE6OFH.js → chunk-ZLYS5DGK.js}

@@ -14098,6 +14098,9 @@ var ProjectSeatsDynamicRequestSchema = external_exports.object({ "state": Reduce
 var BoardStaticProjectionSchema = external_exports.object({ "view": JsonValueSchema, "hash": external_exports.string().min(1), "manifestVersion": external_exports.string() }).strict();
 
 // ../../packages/app-sdk/src/reducer/per-player.ts
+function asPlayerId(raw) {
+  return raw;
+}
 function perPlayerGet(value, id) {
   for (const [candidate, v] of value.entries) {
     if (candidate === id) {
@@ -14207,6 +14210,45 @@ function resolveDomainChoices(choices, context) {
     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 external_exports.null();
+  }
+  const stringSchema = external_exports.enum(
+    stringValues
+  );
+  if (hasNull) {
+    return external_exports.union([stringSchema, external_exports.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;
@@ -14243,7 +14285,13 @@ function resourceMapInput(options) {
     schema: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()),
     ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
     domain: (state, playerId, q, derived) => {
-      const context = { state, playerId, q, derived };
+      const context = {
+        state,
+        playerId,
+        q,
+        derived,
+        values: {}
+      };
       return {
         type: "resourceMap",
         resources: options.resources.map((resource) => ({
@@ -14263,7 +14311,13 @@ function numberInput(options) {
     schema: external_exports.number(),
     ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
     domain: (state, playerId, q, derived) => {
-      const context = { state, playerId, q, derived };
+      const context = {
+        state,
+        playerId,
+        q,
+        derived,
+        values: {}
+      };
       return {
         type: "boundedNumber",
         min: resolveDomainNumber(options.min, context, 0),
@@ -14274,23 +14328,80 @@ function numberInput(options) {
   };
 }
 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 schema = Array.isArray(options.choices) ? external_exports.enum(
-    options.choices.map((choice) => choice.value)
-  ) : external_exports.string();
+  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) : external_exports.string().nullable();
+  const dynamicDefault = typeof options.defaultValue === "function" ? options.defaultValue : void 0;
   return {
     kind: "form",
     schema,
-    ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
-    domain: (state, playerId, q, derived) => {
-      const context = { state, playerId, q, derived };
+    ...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: resolveDomainChoices(options.choices, context)
+        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) {
@@ -14302,10 +14413,21 @@ function choiceListInput(options) {
   return {
     kind: "form",
     schema: external_exports.array(external_exports.string()),
-    ...staticDefaultValue ? { defaultValue: staticDefaultValue } : {},
+    ...staticDefaultValue !== void 0 ? { defaultValue: staticDefaultValue } : {},
     domain: (state, playerId, q, derived) => {
-      const context = { state, playerId, q, derived };
-      const choices = resolveDomainChoices(options.choices, context);
+      const context = {
+        state,
+        playerId,
+        q,
+        derived,
+        values: {}
+      };
+      const choices = resolveDomainChoices(options.choices, context).map(
+        (choice) => ({
+          ...choice,
+          value: choice.value
+        })
+      );
       return {
         type: "choiceList",
         choices,
@@ -14332,12 +14454,25 @@ function choiceListInput(options) {
           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) => ({
@@ -14346,32 +14481,49 @@ var formInput = Object.assign(baseFormInput, {
   }),
   number: numberInput,
   choice: choiceInput,
-  choiceList: choiceListInput
+  choiceList: choiceListInput,
+  forState: formInputForState
 });
 
 // ../../packages/app-sdk/src/reducer/inputs/boardInput.ts
 function makeBoardCollector(kind) {
   return function collector(options) {
     const target = options.target;
+    const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
     return {
       kind,
       schema: external_exports.string(),
-      eligibleTargets: ((state, playerId, q) => target.eligible({
+      eligibleTargets: ((state, playerId, q, values) => target.eligible({
         state,
         playerId,
-        q
+        q,
+        values
       })),
-      validateTarget: ((state, playerId, q, targetId) => target.validate(
+      validateTarget: ((state, playerId, q, targetId, values) => target.validate(
         {
           state,
           playerId,
-          q
+          q,
+          values
         },
         targetId
       )),
+      ...dependsOn ? { dependsOn } : {},
+      domain: dependsOn ? (state, playerId, q, _derived, values) => ({
+        type: "target",
+        targetKind: target.targetKind,
+        boardId: target.boardId,
+        eligibleTargets: target.eligible({
+          state,
+          playerId,
+          q,
+          values
+        }).map(String)
+      }) : void 0,
       meta: {
         targetKind: target.targetKind,
-        boardId: target.boardId
+        boardId: target.boardId,
+        valueKind: target.valueKind
       }
     };
   };
@@ -14388,12 +14540,13 @@ var DEFAULT_MISSING_CANDIDATE_ISSUE = {
 };
 function createTargetRule(candidates, predicates, options = {}) {
   const missingCandidateIssue = options.missingCandidateIssue ?? DEFAULT_MISSING_CANDIDATE_ISSUE;
-  const validate2 = (ctx, id) => {
-    if (!candidates(ctx).includes(id)) {
+  const equals = options.equals ?? Object.is;
+  const validate2 = (ctx, target) => {
+    if (!candidates(ctx).some((candidate) => equals(candidate, target))) {
       return missingCandidateIssue;
     }
     for (const predicate of predicates) {
-      if (!predicate.test({ ...ctx, targetId: id })) {
+      if (!predicate.test({ ...ctx, targetId: target, target })) {
         return {
           errorCode: predicate.errorCode,
           message: predicate.message
@@ -14405,7 +14558,7 @@ function createTargetRule(candidates, predicates, options = {}) {
   const rule = {
     eligible: (ctx) => candidates(ctx).filter((targetId) => validate2(ctx, targetId) == null),
     validate: validate2,
-    isEligible: (ctx, id) => validate2(ctx, id) == null,
+    isEligible: (ctx, target) => validate2(ctx, target) == null,
     bind: (ctx) => ({
       eligible: () => rule.eligible(ctx),
       validate: (id) => rule.validate(ctx, id),
@@ -14429,7 +14582,7 @@ function candidateIdsForKind(q, boardId, targetKind) {
   if (targetKind === "vertex") {
     return idsFromCollection(q.board.tiled(boardId).vertices);
   }
-  return idsFromCollection(q.board.get(boardId).spaces);
+  return idsFromCollection(q.board.get(boardId)?.spaces);
 }
 function idsFromCollection(collection) {
   if (!collection) return [];
@@ -14456,10 +14609,47 @@ function createBoardTargetBuilder(targetKind, boardId) {
         }
       ),
       boardId,
-      targetKind
+      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);
@@ -14469,7 +14659,10 @@ var boardTarget = {
   edge: makeBoardTargetFactory("edge"),
   vertex: makeBoardTargetFactory("vertex"),
   space: makeBoardTargetFactory("space"),
-  tile: makeBoardTargetFactory("tile")
+  tile: makeBoardTargetFactory("tile"),
+  playerSpace(boardId) {
+    return createPlayerSpaceTargetBuilder(boardId);
+  }
 };
 
 // ../../packages/app-sdk/src/reducer/inputs/cardTarget.ts
@@ -14516,22 +14709,38 @@ var cardTarget = {
 // ../../packages/app-sdk/src/reducer/inputs/cardInput.ts
 function cardInput(options) {
   const target = options.target;
+  const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
   return {
     kind: "card",
     schema: external_exports.string(),
-    eligibleTargets: ((state, playerId, q) => target.eligible({
+    eligibleTargets: ((state, playerId, q, values) => target.eligible({
       state,
       playerId,
-      q
+      q,
+      values
     })),
-    validateTarget: ((state, playerId, q, targetId) => target.validate(
+    validateTarget: ((state, playerId, q, targetId, values) => target.validate(
       {
         state,
         playerId,
-        q
+        q,
+        values
       },
       targetId
     )),
+    ...dependsOn ? { dependsOn } : {},
+    domain: dependsOn ? (state, playerId, q, _derived, values) => ({
+      type: "target",
+      targetKind: target.targetKind,
+      zoneId: target.zoneId,
+      zoneIds: target.zoneIds,
+      eligibleTargets: target.eligible({
+        state,
+        playerId,
+        q,
+        values
+      }).map(String)
+    }) : void 0,
     meta: {
       zoneId: target.zoneId,
       zoneIds: target.zoneIds,
@@ -16223,6 +16432,35 @@ function shuffleWithRng(values, rng, operation = "shuffleSharedZone") {
   }
   return { orderedValues, nextRng, consumptions };
 }
+function subsetWithRng(values, count, rng) {
+  if (!Number.isInteger(count) || count < 0) {
+    throw new Error("random.subset count must be a non-negative integer.");
+  }
+  if (count > values.length) {
+    throw new Error(
+      `random.subset count ${count} exceeds source length ${values.length}.`
+    );
+  }
+  const shuffled = shuffleWithRng(values, rng, "randomSubset");
+  return {
+    values: shuffled.orderedValues.slice(0, count),
+    nextRng: shuffled.nextRng,
+    consumptions: shuffled.consumptions
+  };
+}
+function createMutableRandomHelpers(rng) {
+  let current = rng;
+  return {
+    random: {
+      subset(options) {
+        const sampled = subsetWithRng(options.from, options.count, current);
+        current = sampled.nextRng;
+        return sampled.values;
+      }
+    },
+    currentRng: () => current
+  };
+}
 function sampleRngCollectorValue(collector, rng) {
   const meta = collector.meta;
   switch (meta.rng) {
@@ -16671,6 +16909,126 @@ function createReducerFx(_state) {
 function updateTable(state, nextTable) {
   return { ...state, table: nextTable };
 }
+function computePlayerZoneVisibility(table, zoneId, playerId) {
+  const mode = table.handVisibility[zoneId];
+  if (mode === "all" || mode === "public") {
+    return { faceUp: true };
+  }
+  return { faceUp: false, visibleTo: [playerId] };
+}
+function readPlayerZoneCards(table, zoneId, playerId) {
+  const zone = table.zones.perPlayer[zoneId] ?? table.hands[zoneId];
+  if (!zone) {
+    throw new Error(`Player zone '${zoneId}' does not exist.`);
+  }
+  return perPlayerGet(zone, asPlayerId(playerId)) ?? [];
+}
+function writePlayerZoneCards(table, zoneId, playerId, cards) {
+  const currentZone = table.zones.perPlayer[zoneId];
+  const currentHand = table.hands[zoneId];
+  const player = asPlayerId(playerId);
+  if (currentZone) {
+    table.zones.perPlayer[zoneId] = perPlayerSet(
+      currentZone,
+      player,
+      [...cards]
+    );
+  }
+  if (currentHand) {
+    table.hands[zoneId] = perPlayerSet(
+      currentHand,
+      player,
+      [...cards]
+    );
+  }
+}
+function assertCardAllowedInPlayerZone(table, zoneId, cardId) {
+  const allowedCardSetIds = table.zones.cardSetIdsByZoneId?.[zoneId];
+  if (!allowedCardSetIds || allowedCardSetIds.length === 0) {
+    return;
+  }
+  const card = table.cards[cardId];
+  if (!card) {
+    throw new Error(`Card '${cardId}' does not exist.`);
+  }
+  if (!allowedCardSetIds.includes(card.cardSetId)) {
+    throw new Error(
+      `Card '${cardId}' from set '${card.cardSetId}' is not allowed in player zone '${zoneId}'.`
+    );
+  }
+}
+function rotatePlayerZoneTable(options) {
+  const nextTable = cloneRuntimeTable(options.table);
+  const zoneId = options.zoneId;
+  if (!nextTable.zones.perPlayer[zoneId] && !nextTable.hands[zoneId]) {
+    throw new Error(`Player zone '${zoneId}' does not exist.`);
+  }
+  const players = [...options.players ?? nextTable.playerOrder];
+  if (players.length === 0) {
+    return nextTable;
+  }
+  const playerSet = new Set(nextTable.playerOrder);
+  for (const playerId of players) {
+    if (!playerSet.has(playerId)) {
+      throw new Error(
+        `Cannot rotate player zone '${zoneId}': player '${playerId}' is not in player order.`
+      );
+    }
+  }
+  const selectedByPlayer = /* @__PURE__ */ new Map();
+  for (const playerId of players) {
+    const sourceCards = readPlayerZoneCards(nextTable, zoneId, playerId);
+    const selected = options.cardIdsByPlayer?.[playerId] ?? sourceCards;
+    for (const cardId of selected) {
+      if (!sourceCards.includes(cardId)) {
+        throw new Error(
+          `Cannot rotate player zone '${zoneId}': card '${cardId}' is not in zone for player '${playerId}'.`
+        );
+      }
+      assertCardAllowedInPlayerZone(nextTable, zoneId, cardId);
+    }
+    selectedByPlayer.set(playerId, [...selected]);
+  }
+  const removeByPlayer = /* @__PURE__ */ new Map();
+  for (const playerId of players) {
+    const selected = new Set(selectedByPlayer.get(playerId) ?? []);
+    removeByPlayer.set(
+      playerId,
+      readPlayerZoneCards(nextTable, zoneId, playerId).filter(
+        (cardId) => !selected.has(cardId)
+      )
+    );
+  }
+  const additionsByPlayer = new Map(
+    players.map((playerId) => [playerId, []])
+  );
+  for (const [index, fromPlayerId] of players.entries()) {
+    const offset = options.direction === "left" ? 1 : -1;
+    const recipient = players[(index + offset + players.length) % players.length];
+    additionsByPlayer.get(recipient).push(...selectedByPlayer.get(fromPlayerId) ?? []);
+  }
+  for (const playerId of players) {
+    const remaining = removeByPlayer.get(playerId) ?? [];
+    const additions = additionsByPlayer.get(playerId) ?? [];
+    const nextCards = options.position === "top" ? [...additions, ...remaining] : [...remaining, ...additions];
+    writePlayerZoneCards(nextTable, zoneId, playerId, nextCards);
+    for (const [position, cardId] of nextCards.entries()) {
+      nextTable.componentLocations[cardId] = {
+        type: "InHand",
+        handId: zoneId,
+        playerId,
+        position
+      };
+      nextTable.ownerOfCard[cardId] = playerId;
+      nextTable.visibility[cardId] = computePlayerZoneVisibility(
+        nextTable,
+        zoneId,
+        playerId
+      );
+    }
+  }
+  return nextTable;
+}
 var moveComponentToEdgeInternal = moveComponentToEdge;
 var moveComponentToVertexInternal = moveComponentToVertex;
 var dealCardsFromDeckToHandInternal = dealCardsFromDeckToHand;
@@ -16854,6 +17212,19 @@ function createReducerOps() {
         return updateTable(state, nextTable);
       };
     },
+    rotatePlayerZone(args) {
+      return (state) => {
+        const nextTable = rotatePlayerZoneTable({
+          table: state.table,
+          zoneId: args.zoneId,
+          direction: args.direction,
+          players: args.players,
+          cardIdsByPlayer: args.cardIdsByPlayer,
+          position: args.position ?? "bottom"
+        });
+        return updateTable(state, nextTable);
+      };
+    },
     moveComponentToSpace(args) {
       return (state) => {
         const nextTable = moveComponentToSpace(
@@ -16953,6 +17324,47 @@ function createReducerOps() {
   return impl;
 }
 
+// ../../packages/app-sdk/src/reducer/transaction.ts
+function createReducerTransaction(initialState, ops = createReducerOps()) {
+  let currentState = initialState;
+  let currentQueries = createStateQueries(currentState);
+  const refresh = (nextState) => {
+    currentState = nextState;
+    currentQueries = createStateQueries(currentState);
+    return currentState;
+  };
+  const apply = (op) => refresh(op(currentState));
+  const base = {
+    get state() {
+      return currentState;
+    },
+    get q() {
+      return currentQueries;
+    },
+    apply
+  };
+  return new Proxy(base, {
+    get(target, property, receiver) {
+      if (property in target) {
+        return Reflect.get(target, property, receiver);
+      }
+      const opFactory = ops[property];
+      if (typeof opFactory !== "function") {
+        return void 0;
+      }
+      return (...args) => {
+        const op = opFactory(
+          ...args
+        );
+        return apply(op);
+      };
+    }
+  });
+}
+function createReducerEdit(ops = createReducerOps()) {
+  return (state) => createReducerTransaction(state, ops);
+}
+
 // ../../packages/app-sdk/src/reducer/definition-index.ts
 function phaseEntriesOf(definition) {
   return Object.entries(definition.phases);
@@ -17001,6 +17413,7 @@ function collectReducerDefinitionIndex(definition) {
       cardActionId,
       {
         ...cardAction,
+        __steps: cardAction.__steps,
         inputs: {
           cardId: cardInput({
             target: cardTarget.zones([cardAction.playFrom]).where({
@@ -17078,7 +17491,7 @@ function buildContext(state, manifest) {
     manifest,
     playerOrder: [...state.table.playerOrder],
     activePlayers: [...state.flow.activePlayers],
-    runtime: state.runtime,
+    runtime: publicRuntime(state.runtime),
     setup: state.runtime.setup ? {
       profileId: state.runtime.setup.profileId,
       optionValues: {
@@ -17087,6 +17500,17 @@ function buildContext(state, manifest) {
     } : null
   };
 }
+function publicRuntime(runtime) {
+  const { rng: _rng, ...rest } = runtime;
+  return rest;
+}
+var DISABLED_RANDOM_HELPERS = {
+  subset() {
+    throw new Error(
+      "random helpers are only available in reducer mutation callbacks."
+    );
+  }
+};
 function buildRuntimeArgs(state, manifest, helpers, toDomainState2, extra, options = {}) {
   const domainState = toDomainState2(state);
   const q = options.q ?? createStateQueries(domainState);
@@ -17096,7 +17520,8 @@ function buildRuntimeArgs(state, manifest, helpers, toDomainState2, extra, optio
     fx: options.fx ?? fxForState(state),
     q,
     derived: options.derived ?? createDerivedResolver(domainState, { q }),
-    runtime: state.runtime,
+    runtime: publicRuntime(state.runtime),
+    random: options.random ?? DISABLED_RANDOM_HELPERS,
     ...extra
   };
 }
@@ -17130,13 +17555,16 @@ var runtimeResultHelpers = {
 // ../../packages/app-sdk/src/reducer/bundle/trusted/trusted-state-codec.ts
 function toDomainState(state) {
   const { runtime: _runtime, ...domain } = state;
+  attachPhaseAccessor(domain);
   return domain;
 }
 function toCombinedState(session) {
-  return {
+  const combined = {
     ...session.domain,
     runtime: session.runtime
   };
+  attachPhaseAccessor(combined);
+  return combined;
 }
 function toSessionState(state, toDomain) {
   return {
@@ -17144,6 +17572,19 @@ function toSessionState(state, toDomain) {
     runtime: state.runtime
   };
 }
+function attachPhaseAccessor(state) {
+  if (!state || typeof state !== "object") return;
+  const candidate = state;
+  const phase = candidate.phase;
+  if (!phase || typeof phase !== "object") return;
+  const descriptor = Object.getOwnPropertyDescriptor(phase, "get");
+  if (descriptor && typeof descriptor.value === "function") return;
+  Object.defineProperty(phase, "get", {
+    enumerable: false,
+    configurable: true,
+    value: (phaseName) => candidate.flow?.currentPhase === phaseName ? phase : null
+  });
+}
 
 // ../../packages/app-sdk/src/reducer/bundle/trusted/trusted-setup-profiles.ts
 function resolveTrustedSetupProfiles(definition) {
@@ -17225,7 +17666,8 @@ function createTrustedRuntimeScope(definition) {
   }
   const helpers = {
     ...runtimeResultHelpers,
-    ops: createReducerOps()
+    ops: createReducerOps(),
+    edit: createReducerEdit()
   };
   function fxForState2(state) {
     return fxForState(state);
@@ -17288,24 +17730,31 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
       }
       const parsed = interactions.parseInteractionParams(
         interaction,
-        input.params
+        input.params,
+        { playerId: input.playerId }
       );
       if (!parsed.ok) {
         return rejectResult("invalid-action-params", parsed.message);
       }
-      return normalizeResult(
+      const random = createMutableRandomHelpers(state.runtime.rng);
+      const result = normalizeResult(
         interaction.reduce(
-          scope.buildRuntimeArgs(state, {
-            ...ctx,
-            state: scope.toDomainState(state),
-            input: {
-              playerId: input.playerId,
-              params: parsed.params
-            }
-          })
+          scope.buildRuntimeArgs(
+            state,
+            {
+              ...ctx,
+              state: scope.toDomainState(state),
+              input: {
+                playerId: input.playerId,
+                params: parsed.params
+              }
+            },
+            { random: random.random }
+          )
         ),
         scope.toDomainState(state)
       );
+      return result.type === "accept" ? { ...result, runtimeRng: random.currentRng() } : result;
     }
     if (input.kind === "continuation") {
       const continuation = scope.continuationById(input.continuationId);
@@ -17315,21 +17764,27 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
           `Continuation '${input.continuationId}' was not registered.`
         );
       }
-      return normalizeResult(
+      const random = createMutableRandomHelpers(state.runtime.rng);
+      const result = normalizeResult(
         continuation.reduce(
-          scope.buildRuntimeArgs(state, {
-            ...ctx,
-            state: scope.toDomainState(state),
-            input: {
-              source: "effect",
-              effectKind: input.effectKind,
-              data: input.resumeData,
-              response: input.response
-            }
-          })
+          scope.buildRuntimeArgs(
+            state,
+            {
+              ...ctx,
+              state: scope.toDomainState(state),
+              input: {
+                source: "effect",
+                effectKind: input.effectKind,
+                data: input.resumeData,
+                response: input.response
+              }
+            },
+            { random: random.random }
+          )
         ),
         scope.toDomainState(state)
       );
+      return result.type === "accept" ? { ...result, runtimeRng: random.currentRng() } : result;
     }
     return scope.runtimeHelpers.accept(scope.toDomainState(state));
   }
@@ -17461,14 +17916,19 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
         }
       ])
     );
+    const random = createMutableRandomHelpers(stateWithSubmission.runtime.rng);
     const resolved = normalizeResult(
       resolve(
-        scope.buildRuntimeArgs(stateWithSubmission, {
-          state: scope.toDomainState(stateWithSubmission),
-          submissions: resolvedSubmissions,
-          submittedPlayerIds: [...actors],
-          waitingPlayerIds: []
-        })
+        scope.buildRuntimeArgs(
+          stateWithSubmission,
+          {
+            state: scope.toDomainState(stateWithSubmission),
+            submissions: resolvedSubmissions,
+            submittedPlayerIds: [...actors],
+            waitingPlayerIds: []
+          },
+          { random: random.random }
+        )
       ),
       scope.toDomainState(stateWithSubmission)
     );
@@ -17479,7 +17939,7 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
       type: "accept",
       state: clearSimultaneousCurrent({
         ...resolved.state,
-        runtime: stateWithSubmission.runtime
+        runtime: { ...stateWithSubmission.runtime, rng: random.currentRng() }
       }),
       instructions: resolved.instructions ?? []
     };
@@ -17501,7 +17961,10 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
       type: "accept",
       state: {
         ...result.state,
-        runtime: sampled.state.runtime
+        runtime: {
+          ...sampled.state.runtime,
+          rng: result.runtimeRng ?? sampled.state.runtime.rng
+        }
       },
       instructions: result.instructions ?? []
     };
@@ -17596,6 +18059,48 @@ function withSelection(domain, collector) {
   if (!collector.selection) return domain;
   return { ...domain, selection: collector.selection };
 }
+function finiteValuesForDependency(key, domain) {
+  if (!domain) {
+    throw new Error(
+      `Interaction input '${key}' is declared as a dependency before it has a projected domain.`
+    );
+  }
+  if (domain.type === "target") {
+    if (!domain.eligibleTargets) {
+      throw new Error(
+        `Interaction input '${key}' cannot be used as a dependency because its target domain is not finite.`
+      );
+    }
+    return [...domain.eligibleTargets];
+  }
+  if (domain.type === "choice") {
+    return domain.choices.flatMap(
+      (choice) => choice.value === null ? [] : [choice.value]
+    );
+  }
+  throw new Error(
+    `Interaction input '${key}' cannot be used as a dependency. V1 supports finite target and choice dependencies only.`
+  );
+}
+function cartesianDependencyTuples(dependencies, domainsByKey) {
+  return dependencies.reduce(
+    (tuples, key) => {
+      const values = finiteValuesForDependency(key, domainsByKey[key]);
+      return tuples.flatMap(
+        (tuple) => values.map((value) => ({ ...tuple, [key]: value }))
+      );
+    },
+    [{}]
+  );
+}
+function withoutDependentProjection(domain) {
+  const {
+    dependsOn: _dependsOn,
+    dependentCases: _dependentCases,
+    ...rest
+  } = domain;
+  return rest;
+}
 function unsupportedDefaultInputError(key, collector) {
   return new Error(
     `Interaction input '${key}' uses a '${collector.kind}' collector without a default-renderable domain or target metadata. Use formInput.choice(...), formInput.choiceList(...), formInput.number(...), formInput.resourceMap(...), cardInput(...), or boardInput(...). For custom payloads, use a custom interaction surface with paramsSchema instead of the default InteractionForm.`
@@ -17644,19 +18149,74 @@ function collectInputDomains(interaction, domainState, playerId, eligibleTargets
   const derived = () => derivedLazy ??= createDerivedResolver(domainState, { q: queries() });
   const result = {};
   for (const [key, collector] of Object.entries(collectors)) {
-    if (collector.kind === "rng" || collector.kind === "prompt") {
+    if (collector.kind === "rng") {
+      continue;
+    }
+    if (collector.kind === "prompt") {
+      const optionFactory = collector.meta?.options;
+      if (!optionFactory) continue;
+      result[key] = {
+        type: "choice",
+        choices: optionFactory(domainState, playerId, queries()).map(
+          (option) => ({
+            value: String(option.id),
+            label: option.label ?? String(option.id),
+            ...(() => {
+              const issue = collector.validateTarget?.(
+                domainState,
+                playerId,
+                queries(),
+                String(option.id)
+              );
+              return issue ? {
+                disabled: true,
+                disabledReason: issue.message ?? issue.errorCode
+              } : {};
+            })()
+          })
+        )
+      };
       continue;
     }
     if (collector.domain) {
-      result[key] = withSelection(
+      const dependencies = collector.dependsOn ?? [];
+      const baseDomain = withSelection(
         collector.domain(
           domainState,
           playerId,
           queries(),
-          derived()
+          derived(),
+          {}
         ),
         collector
       );
+      if (dependencies.length === 0) {
+        result[key] = baseDomain;
+        continue;
+      }
+      const dependentCases = cartesianDependencyTuples(
+        dependencies,
+        result
+      ).map((values) => ({
+        when: values,
+        domain: withoutDependentProjection(
+          withSelection(
+            collector.domain?.(
+              domainState,
+              playerId,
+              queries(),
+              derived(),
+              values
+            ),
+            collector
+          )
+        )
+      }));
+      result[key] = {
+        ...baseDomain,
+        dependsOn: dependencies,
+        dependentCases
+      };
       continue;
     }
     const targets = eligibleTargets[key];
@@ -17678,7 +18238,17 @@ function collectInputDomains(interaction, domainState, playerId, eligibleTargets
 }
 function collectInteractionInputs(interaction, domainState, playerId, options = {}) {
   const collectors = interactionInputsOf(interaction);
-  const eligibleTargets = options.includeEligibleTargets === false ? {} : collectEligibleTargets(interaction, domainState, playerId, options);
+  const dependencyKeys = new Set(
+    Object.values(collectors).flatMap((collector) => [
+      ...collector.dependsOn ?? []
+    ])
+  );
+  const collectedEligibleTargets = options.includeEligibleTargets === false && dependencyKeys.size === 0 ? {} : collectEligibleTargets(interaction, domainState, playerId, options);
+  const eligibleTargets = options.includeEligibleTargets === false ? Object.fromEntries(
+    Object.entries(collectedEligibleTargets).filter(
+      ([key]) => dependencyKeys.has(key)
+    )
+  ) : collectedEligibleTargets;
   const domainsByKey = collectInputDomains(
     interaction,
     domainState,
@@ -17693,10 +18263,13 @@ function collectInteractionInputs(interaction, domainState, playerId, options =
   let derivedLazy = options.derived ?? null;
   const derived = () => derivedLazy ??= createDerivedResolver(domainState, { q: queries() });
   return Object.entries(collectors).flatMap(([key, collector]) => {
-    if (collector.kind === "rng" || collector.kind === "prompt") {
+    if (collector.kind === "rng") {
       return [];
     }
     const domain = domainsByKey[key];
+    if (!domain && collector.kind === "prompt") {
+      return [];
+    }
     if (!domain) {
       throw unsupportedDefaultInputError(key, collector);
     }
@@ -17743,7 +18316,7 @@ function collectCardZoneIds(interaction) {
 function collectPromptOptions(interaction, domainState, playerId, queries) {
   for (const collector of Object.values(interaction.inputs)) {
     if (collector.kind !== "prompt") continue;
-    const factory = collector.meta?.eligibleOptions;
+    const factory = collector.meta?.options;
     if (!factory) continue;
     return factory(domainState, playerId, queries).map((option) => ({
       id: String(option.id),
@@ -17769,7 +18342,12 @@ function parseInteractionParams(interaction, rawParams, options = {}) {
   const issues = [];
   for (const [key, collector] of Object.entries(collectors)) {
     if (collector.kind === "rng" && options.skipRng) continue;
-    const rawValue = record[key] === void 0 && "defaultValue" in collector ? collector.defaultValue : record[key];
+    const rawValueBase = record[key] === void 0 && "defaultValue" in collector ? collector.defaultValue : record[key];
+    const rawValue = collector.kind === "board-space" && collector.meta?.valueKind === "player-board-space" && typeof rawValueBase === "string" && options.playerId ? {
+      boardId: collector.meta.boardId,
+      playerId: options.playerId,
+      spaceId: rawValueBase
+    } : rawValueBase;
     const result = collector.schema.safeParse(rawValue);
     if (!result.success) {
       for (const issue of result.error.issues) {
@@ -17831,7 +18409,7 @@ function validateCollectorTargets(interaction, domainState, playerId, params) {
         domainState,
         playerId,
         queries(),
-        String(value)
+        value
       );
       if (issue) {
         return makeValidationError(issue.errorCode, issue.message);
@@ -18043,11 +18621,14 @@ function deriveCommitPolicy(inputs, explicit) {
   if (hasManyCollector) {
     return { mode: "manual" };
   }
+  if (collectors.some(isDefaultRenderableFormCollector)) {
+    return { mode: "manual" };
+  }
   if (collectors.length === 0 || !collectors.some(isTargetCollector2)) {
     return { mode: "manual" };
   }
   return collectors.every(
-    (collector) => isTargetCollector2(collector) || isDefaultRenderableFormCollector(collector) || collector.kind === "rng"
+    (collector) => isTargetCollector2(collector) || collector.kind === "rng"
   ) ? { mode: "autoWhenReady" } : { mode: "manual" };
 }
 function projectInteractionMetadata(interaction) {
@@ -18063,7 +18644,7 @@ function enrichResourceInputPresentation(inputs, manifest) {
   }
   const resources = presentationById;
   const enrichChoice = (choice) => {
-    const presentation = resources[choice.value];
+    const presentation = choice.value === null ? void 0 : resources[choice.value];
     return {
       ...choice,
       label: typeof presentation?.label === "string" && (!choice.label || choice.label === choice.value) ? presentation.label : choice.label || (typeof presentation?.label === "string" ? presentation.label : ""),
@@ -18071,7 +18652,16 @@ function enrichResourceInputPresentation(inputs, manifest) {
     };
   };
   return inputs.map((input) => {
-    if (input.domain.type === "choice" || input.domain.type === "choiceList") {
+    if (input.domain.type === "choice") {
+      return {
+        ...input,
+        domain: {
+          ...input.domain,
+          choices: input.domain.choices.map(enrichChoice)
+        }
+      };
+    }
+    if (input.domain.type === "choiceList") {
       return {
         ...input,
         domain: {
@@ -18191,7 +18781,10 @@ function createInteractionDecisionResolver(scope, stages, authorization) {
     }
     const trustedInteractionId = interactionId;
     const parseForSubmit = mode === "submit";
-    const parsed = parseForSubmit ? parseInteractionParams(interaction, params, { skipRng: true }) : {
+    const parsed = parseForSubmit ? parseInteractionParams(interaction, params, {
+      skipRng: true,
+      playerId
+    }) : {
       ok: true,
       params: prepareInteractionProjectionParams(interaction, params)
     };
@@ -18451,10 +19044,7 @@ function createStageResolver(scope) {
     return allowlist;
   }
   function isInteractionAllowedInStep(state, interaction, projection) {
-    const allowedSteps = [
-      ...interaction.step !== void 0 ? [interaction.step] : [],
-      ...interaction.steps ?? []
-    ];
+    const allowedSteps = interaction.__steps ?? [];
     if (allowedSteps.length === 0) {
       return true;
     }
@@ -18583,16 +19173,15 @@ function resolveContainerRef(table, ref) {
       throw new Error(`Unknown board '${ref.boardId}'.`);
     }
     const space2 = board2?.spaces[ref.spaceId];
-    if (!space2?.zoneId) {
+    if (!space2) {
       throw new Error(
-        `Board space '${ref.spaceId}' on board '${ref.boardId}' has no container zone.`
+        `Unknown board space '${ref.spaceId}' on board '${ref.boardId}'.`
       );
     }
     return {
       kind: "space",
       boardId: board2.id,
-      spaceId: ref.spaceId,
-      zoneId: space2.zoneId
+      spaceId: ref.spaceId
     };
   }
   const board = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId, ref.playerId)];
@@ -18602,16 +19191,15 @@ function resolveContainerRef(table, ref) {
     );
   }
   const space = board?.spaces[ref.spaceId];
-  if (!space?.zoneId) {
+  if (!space) {
     throw new Error(
-      `Board space '${ref.spaceId}' on board '${ref.boardId}' for '${ref.playerId}' has no container zone.`
+      `Unknown board space '${ref.spaceId}' on board '${ref.boardId}' for '${ref.playerId}'.`
     );
   }
   return {
     kind: "space",
     boardId: board.id,
-    spaceId: ref.spaceId,
-    zoneId: space.zoneId
+    spaceId: ref.spaceId
   };
 }
 function readContainerComponents(table, ref) {
@@ -18922,7 +19510,11 @@ function createLifecycleRunner(scope, interactions) {
     }) : safeParseOrThrow(phase.state, {}, `phase:${phaseName}:initialState`);
     return {
       ...state,
-      phase: safeParseOrThrow(phase.state, phaseState, `phase:${phaseName}`),
+      phase: safeParseOrThrow(
+        phase.state,
+        phaseState,
+        `phase:${phaseName}`
+      ),
       flow: {
         ...state.flow,
         currentPhase: phaseName
@@ -18940,12 +19532,17 @@ function createLifecycleRunner(scope, interactions) {
     let nextState = workingState;
     const instructions = [];
     if (phase.enter) {
+      const random = createMutableRandomHelpers(workingState.runtime.rng);
       const entered = normalizeResult(
         phase.enter(
-          scope.buildRuntimeArgs(workingState, {
-            event,
-            state: scope.toDomainState(workingState)
-          })
+          scope.buildRuntimeArgs(
+            workingState,
+            {
+              event,
+              state: scope.toDomainState(workingState)
+            },
+            { random: random.random }
+          )
         ),
         scope.toDomainState(workingState)
       );
@@ -18956,18 +19553,23 @@ function createLifecycleRunner(scope, interactions) {
       }
       nextState = {
         ...entered.state,
-        runtime: workingState.runtime
+        runtime: { ...workingState.runtime, rng: random.currentRng() }
       };
       if (entered.instructions) instructions.push(...entered.instructions);
     }
     const activeStage = interactions.resolveActiveStage(nextState, phaseName);
     if (activeStage?.stage.onEnter) {
+      const random = createMutableRandomHelpers(nextState.runtime.rng);
       const stageEntered = normalizeResult(
         activeStage.stage.onEnter(
-          scope.buildRuntimeArgs(nextState, {
-            event,
-            state: scope.toDomainState(nextState)
-          })
+          scope.buildRuntimeArgs(
+            nextState,
+            {
+              event,
+              state: scope.toDomainState(nextState)
+            },
+            { random: random.random }
+          )
         ),
         scope.toDomainState(nextState)
       );
@@ -18978,7 +19580,7 @@ function createLifecycleRunner(scope, interactions) {
       }
       nextState = {
         ...stageEntered.state,
-        runtime: nextState.runtime
+        runtime: { ...nextState.runtime, rng: random.currentRng() }
       };
       if (stageEntered.instructions) {
         instructions.push(...stageEntered.instructions);
@@ -20031,6 +20633,11 @@ function toWireDispatchResult(result, serializeState) {
 function createReducerBundle(definition) {
   const trustedBundle = createTrustedReducerBundle(definition);
   const codec = createIngressRuntimeCodec(definition);
+  function parseTrustedState(state) {
+    return codec.parseState(
+      state
+    );
+  }
   function parseRuntimePlayerId(playerId) {
     if (typeof playerId !== "string") {
       throw new Error("Expected a string playerId.");
@@ -20063,7 +20670,7 @@ function createReducerBundle(definition) {
       );
     },
     async initializePhase({ state, to }) {
-      const decodedState = codec.parseState(state);
+      const decodedState = parseTrustedState(state);
       return codec.serializeState(
         await trustedBundle.initializePhase({
           state: decodedState,
@@ -20075,7 +20682,7 @@ function createReducerBundle(definition) {
       const validatedWire = codec.parseInput(input);
       const routed = routeInteraction(validatedWire);
       return trustedBundle.validateInput({
-        state: codec.parseState(state),
+        state: parseTrustedState(state),
         input: routed
       });
     },
@@ -20086,7 +20693,7 @@ function createReducerBundle(definition) {
       const validatedWire = codec.parseInput(input);
       const routed = routeInteraction(validatedWire);
       const result = await trustedBundle.reduce({
-        state: codec.parseState(state),
+        state: parseTrustedState(state),
         input: routed
       });
       return toWireReduceResult(
@@ -20101,7 +20708,7 @@ function createReducerBundle(definition) {
       const validatedWire = codec.parseInput(input);
       const routed = routeInteraction(validatedWire);
       const result = await trustedBundle.dispatch({
-        state: codec.parseState(state),
+        state: parseTrustedState(state),
         input: routed
       });
       return toWireDispatchResult(
@@ -20128,7 +20735,7 @@ function createReducerBundle(definition) {
       playerIds,
       viewId = "player"
     }) {
-      const parsedState = codec.parseState(state);
+      const parsedState = parseTrustedState(state);
       const parsedPlayerIds = playerIds.map((pid) => codec.parsePlayerId(pid));
       return trustedBundle.projectSeatsDynamic({
         state: parsedState,
@@ -20137,9 +20744,7 @@ function createReducerBundle(definition) {
       });
     },
     projectSeatViewDynamic({ state, playerId, viewId = "player" }) {
-      const parsedState = codec.parseState(
-        state
-      );
+      const parsedState = parseTrustedState(state);
       return trustedBundle.projectSeatViewDynamic({
         state: parsedState,
         playerId: parseRuntimePlayerId(playerId),
@@ -20168,7 +20773,7 @@ function createReducerBundle(definition) {
           });
         },
         hydrate({ state: snapshot }) {
-          state = codec.parseState(snapshot);
+          state = parseTrustedState(snapshot);
         },
         async dispatch({ input }) {
           const validatedWire = codec.parseInput(
@@ -26225,4 +26830,4 @@ export {
   test_default,
   runDreamboardCli
 };
-//# sourceMappingURL=chunk-WDTE6OFH.js.map
+//# sourceMappingURL=chunk-ZLYS5DGK.js.map