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

package/dist/{chunk-533O7C4L.js → chunk-S2JEDVWH.js}

@@ -103,7 +103,7 @@ import {
   spendPlayerResourcesInPlace,
   transferPlayerResources,
   transferPlayerResourcesInPlace
-} from "./chunk-FL67RDID.js";
+} from "./chunk-H6VDGFL5.js";
 import {
   RuntimeJsonSchema,
   assertJsonWithinLimits
@@ -112,7 +112,7 @@ import {
   REDUCER_CONTRACT_VERSION,
   builders_exports,
   zod_exports
-} from "./chunk-2GQIALJL.js";
+} from "./chunk-UGH54WZ2.js";
 
 // src/reducer/diagnostics.ts
 var noopDiagnosticsSink = {
@@ -182,6 +182,121 @@ function summarizeDispatchTrace(trace) {
   });
 }
 
+// src/reducer/table-queries.ts
+function createTableQueries(table) {
+  return {
+    board: {
+      get: (boardId) => getBoard(table, boardId),
+      hex: (boardId) => getHexBoard(table, boardId),
+      square: (boardId) => getSquareBoard(table, boardId),
+      tiled: (boardId) => getTiledBoard(table, boardId),
+      space: (boardId, spaceId) => getSpace(table, boardId, spaceId),
+      hexSpace: (boardId, spaceId) => getHexSpace(table, boardId, spaceId),
+      squareSpace: (boardId, spaceId) => getSquareSpace(table, boardId, spaceId),
+      container: (boardId, containerId) => getContainer(table, boardId, containerId),
+      edge: (boardId, edgeId) => getEdge(table, boardId, edgeId),
+      vertex: (boardId, vertexId) => getVertex(table, boardId, vertexId),
+      byType: (typeId) => getBoardsByTypeId(table, typeId),
+      spacesByType: (boardId, typeId) => getSpacesByTypeId(table, boardId, typeId),
+      edgesByType: (boardId, typeId) => getEdgesByTypeId(table, boardId, typeId),
+      verticesByType: (boardId, typeId) => getVerticesByTypeId(table, boardId, typeId),
+      adjacentSpaces: (boardId, spaceId) => getAdjacentSpaces(table, boardId, spaceId),
+      relatedSpaces: (boardId, spaceId, relationTypeId) => getRelatedSpaces(table, boardId, spaceId, relationTypeId),
+      incidentEdges: (boardId, vertexId) => getIncidentEdges(table, boardId, vertexId),
+      incidentVertices: (boardId, edgeId) => getIncidentVertices(table, boardId, edgeId),
+      spaceEdges: (boardId, spaceId) => getSpaceEdges(table, boardId, spaceId),
+      spaceVertices: (boardId, spaceId) => getSpaceVertices(table, boardId, spaceId),
+      spaceDistance: (boardId, fromSpaceId, toSpaceId) => getSpaceDistance(table, boardId, fromSpaceId, toSpaceId),
+      hexSpaceAt: (boardId, q, r) => getHexSpaceAt(table, boardId, q, r),
+      squareSpaceAt: (boardId, row, col) => getSquareSpaceAt(table, boardId, row, col),
+      squareNeighbors: (boardId, spaceId, options) => getSquareNeighbors(table, boardId, spaceId, options),
+      squareDistance: (boardId, fromSpaceId, toSpaceId, options) => getSquareDistance(table, boardId, fromSpaceId, toSpaceId, options),
+      spaceOccupants: (boardId, spaceId) => getComponentsOnSpace(table, boardId, spaceId),
+      containerOccupants: (boardId, containerId) => getComponentsInContainer(table, boardId, containerId),
+      edgeOccupants: (boardId, edgeId) => getComponentsOnEdge(table, boardId, edgeId),
+      vertexOccupants: (boardId, vertexId) => getComponentsOnVertex(table, boardId, vertexId)
+    },
+    zone: {
+      sharedCards: (zoneId) => getSharedZoneCards(table, zoneId),
+      sharedCardCollection: (zoneId) => getSharedZoneCardCollection(table, zoneId),
+      allSharedCards: () => getAllSharedZoneCards(table),
+      playerCards: (playerId, zoneId) => getPlayerZoneCards(table, playerId, zoneId),
+      playerCardCollection: (playerId, zoneId) => getPlayerZoneCardCollection(table, playerId, zoneId),
+      allPlayerCards: (zoneId) => getAllPlayerZoneCards(table, zoneId)
+    },
+    card: {
+      get: (cardId) => getCard(table, cardId),
+      byIds: (cardIds) => getCardsById(table, cardIds),
+      owner: (cardId) => getCardOwner(table, cardId),
+      visibility: (cardId) => getCardVisibility(table, cardId)
+    },
+    slot: {
+      occupants: (host, slotId) => getSlotOccupants(table, host, slotId),
+      occupantsByHost: (host) => getSlotOccupantsByHost(table, host),
+      pieceOccupants: (hostId, slotId) => getSlotOccupants(table, { kind: "piece", id: hostId }, slotId),
+      pieceOccupantsByHost: (hostId) => getSlotOccupantsByHost(table, { kind: "piece", id: hostId }),
+      dieOccupants: (hostId, slotId) => getSlotOccupants(table, { kind: "die", id: hostId }, slotId),
+      dieOccupantsByHost: (hostId) => getSlotOccupantsByHost(table, { kind: "die", id: hostId })
+    },
+    player: {
+      order: () => getPlayerOrder(table),
+      nextInOrder: (playerId) => getNextPlayerInOrder(table, playerId),
+      resources: (playerId) => getPlayerResources(table, playerId),
+      resource: (playerId, resourceId) => getPlayerResourceAmount(table, playerId, resourceId),
+      resourceTotal: (playerId) => getPlayerResourceTotal(table, playerId),
+      canAfford: (playerId, amounts) => canAffordResources(table, playerId, amounts),
+      missingResources: (playerId, amounts) => getMissingResources(table, playerId, amounts)
+    },
+    component: {
+      data: (componentId) => table.cards[componentId] ?? table.pieces[componentId] ?? table.dice[componentId],
+      location: (componentId) => getComponentLocation(table, componentId),
+      deck: (componentId) => getComponentDeckLocation(table, componentId),
+      hand: (componentId) => getComponentHandLocation(table, componentId),
+      zone: (componentId) => getComponentZoneLocation(table, componentId),
+      space: (componentId) => getComponentSpaceLocation(table, componentId),
+      container: (componentId) => getComponentContainerLocation(table, componentId),
+      edge: (componentId) => getComponentEdgeLocation(table, componentId),
+      vertex: (componentId) => getComponentVertexLocation(table, componentId),
+      slot: (componentId) => getComponentSlotLocation(table, componentId)
+    }
+  };
+}
+function createStateQueries(state) {
+  return createTableQueries(
+    state.table
+  );
+}
+
+// src/reducer/derived.ts
+function defineDerived() {
+  return (def) => def;
+}
+function createDerivedResolver(state, options = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Set();
+  const q = options.q ?? createStateQueries(state);
+  const resolver = (def) => {
+    const typedDef = def;
+    if (cache.has(typedDef)) {
+      return cache.get(typedDef);
+    }
+    if (inflight.has(typedDef)) {
+      throw new Error(
+        `Cyclic derived: '${def.name ?? "<anonymous>"}' depends on itself.`
+      );
+    }
+    inflight.add(typedDef);
+    try {
+      const value = def.compute({ state, q, derived: resolver });
+      cache.set(typedDef, value);
+      return value;
+    } finally {
+      inflight.delete(typedDef);
+    }
+  };
+  return resolver;
+}
+
 // src/reducer/ops.ts
 var reducerOpsInternal = /* @__PURE__ */ Symbol("dreamboard.reducerOpsInternal");
 function getReducerOpsInternal(ops) {
@@ -857,217 +972,6 @@ function createReducerOps() {
   return ops;
 }
 
-// src/reducer/table-queries.ts
-function createTableQueries(table) {
-  return {
-    board: {
-      get: (boardId) => getBoard(table, boardId),
-      hex: (boardId) => getHexBoard(table, boardId),
-      square: (boardId) => getSquareBoard(table, boardId),
-      tiled: (boardId) => getTiledBoard(table, boardId),
-      space: (boardId, spaceId) => getSpace(table, boardId, spaceId),
-      hexSpace: (boardId, spaceId) => getHexSpace(table, boardId, spaceId),
-      squareSpace: (boardId, spaceId) => getSquareSpace(table, boardId, spaceId),
-      container: (boardId, containerId) => getContainer(table, boardId, containerId),
-      edge: (boardId, edgeId) => getEdge(table, boardId, edgeId),
-      vertex: (boardId, vertexId) => getVertex(table, boardId, vertexId),
-      byType: (typeId) => getBoardsByTypeId(table, typeId),
-      spacesByType: (boardId, typeId) => getSpacesByTypeId(table, boardId, typeId),
-      edgesByType: (boardId, typeId) => getEdgesByTypeId(table, boardId, typeId),
-      verticesByType: (boardId, typeId) => getVerticesByTypeId(table, boardId, typeId),
-      adjacentSpaces: (boardId, spaceId) => getAdjacentSpaces(table, boardId, spaceId),
-      relatedSpaces: (boardId, spaceId, relationTypeId) => getRelatedSpaces(table, boardId, spaceId, relationTypeId),
-      incidentEdges: (boardId, vertexId) => getIncidentEdges(table, boardId, vertexId),
-      incidentVertices: (boardId, edgeId) => getIncidentVertices(table, boardId, edgeId),
-      spaceEdges: (boardId, spaceId) => getSpaceEdges(table, boardId, spaceId),
-      spaceVertices: (boardId, spaceId) => getSpaceVertices(table, boardId, spaceId),
-      spaceDistance: (boardId, fromSpaceId, toSpaceId) => getSpaceDistance(table, boardId, fromSpaceId, toSpaceId),
-      hexSpaceAt: (boardId, q, r) => getHexSpaceAt(table, boardId, q, r),
-      squareSpaceAt: (boardId, row, col) => getSquareSpaceAt(table, boardId, row, col),
-      squareNeighbors: (boardId, spaceId, options) => getSquareNeighbors(table, boardId, spaceId, options),
-      squareDistance: (boardId, fromSpaceId, toSpaceId, options) => getSquareDistance(table, boardId, fromSpaceId, toSpaceId, options),
-      spaceOccupants: (boardId, spaceId) => getComponentsOnSpace(table, boardId, spaceId),
-      containerOccupants: (boardId, containerId) => getComponentsInContainer(table, boardId, containerId),
-      edgeOccupants: (boardId, edgeId) => getComponentsOnEdge(table, boardId, edgeId),
-      vertexOccupants: (boardId, vertexId) => getComponentsOnVertex(table, boardId, vertexId)
-    },
-    zone: {
-      sharedCards: (zoneId) => getSharedZoneCards(table, zoneId),
-      sharedCardCollection: (zoneId) => getSharedZoneCardCollection(table, zoneId),
-      allSharedCards: () => getAllSharedZoneCards(table),
-      playerCards: (playerId, zoneId) => getPlayerZoneCards(table, playerId, zoneId),
-      playerCardCollection: (playerId, zoneId) => getPlayerZoneCardCollection(table, playerId, zoneId),
-      allPlayerCards: (zoneId) => getAllPlayerZoneCards(table, zoneId)
-    },
-    card: {
-      get: (cardId) => getCard(table, cardId),
-      byIds: (cardIds) => getCardsById(table, cardIds),
-      owner: (cardId) => getCardOwner(table, cardId),
-      visibility: (cardId) => getCardVisibility(table, cardId)
-    },
-    slot: {
-      occupants: (host, slotId) => getSlotOccupants(table, host, slotId),
-      occupantsByHost: (host) => getSlotOccupantsByHost(table, host),
-      pieceOccupants: (hostId, slotId) => getSlotOccupants(table, { kind: "piece", id: hostId }, slotId),
-      pieceOccupantsByHost: (hostId) => getSlotOccupantsByHost(table, { kind: "piece", id: hostId }),
-      dieOccupants: (hostId, slotId) => getSlotOccupants(table, { kind: "die", id: hostId }, slotId),
-      dieOccupantsByHost: (hostId) => getSlotOccupantsByHost(table, { kind: "die", id: hostId })
-    },
-    player: {
-      order: () => getPlayerOrder(table),
-      nextInOrder: (playerId) => getNextPlayerInOrder(table, playerId),
-      resources: (playerId) => getPlayerResources(table, playerId),
-      resource: (playerId, resourceId) => getPlayerResourceAmount(table, playerId, resourceId),
-      resourceTotal: (playerId) => getPlayerResourceTotal(table, playerId),
-      canAfford: (playerId, amounts) => canAffordResources(table, playerId, amounts),
-      missingResources: (playerId, amounts) => getMissingResources(table, playerId, amounts)
-    },
-    component: {
-      data: (componentId) => table.cards[componentId] ?? table.pieces[componentId] ?? table.dice[componentId],
-      location: (componentId) => getComponentLocation(table, componentId),
-      deck: (componentId) => getComponentDeckLocation(table, componentId),
-      hand: (componentId) => getComponentHandLocation(table, componentId),
-      zone: (componentId) => getComponentZoneLocation(table, componentId),
-      space: (componentId) => getComponentSpaceLocation(table, componentId),
-      container: (componentId) => getComponentContainerLocation(table, componentId),
-      edge: (componentId) => getComponentEdgeLocation(table, componentId),
-      vertex: (componentId) => getComponentVertexLocation(table, componentId),
-      slot: (componentId) => getComponentSlotLocation(table, componentId)
-    }
-  };
-}
-function createStateQueries(state) {
-  return createTableQueries(
-    state.table
-  );
-}
-
-// src/reducer/transaction.ts
-var transactionContext = /* @__PURE__ */ Symbol("dreamboard.reducerTransactionContext");
-function getTransactionContext(host) {
-  const context = host[transactionContext];
-  if (!context) {
-    throw new TypeError("Reducer transaction method called without a receiver");
-  }
-  return context;
-}
-function invalidate(context) {
-  context.currentQueries = null;
-}
-function applyTransactionOp(context, op) {
-  context.currentState = op(context.currentState);
-  invalidate(context);
-  return context.currentState;
-}
-function runInternal(context, key, args) {
-  context.currentState = context.internalOps[key](context.currentState, ...args);
-  invalidate(context);
-  return context.currentState;
-}
-function createReducerTransactionSurface(ops) {
-  const surface = {};
-  const descriptors = {
-    state: {
-      enumerable: true,
-      get() {
-        return getTransactionContext(this).currentState;
-      }
-    },
-    q: {
-      enumerable: true,
-      get() {
-        const context = getTransactionContext(this);
-        context.currentQueries ??= createStateQueries(context.currentState);
-        return context.currentQueries;
-      }
-    },
-    apply: {
-      enumerable: true,
-      get() {
-        const context = getTransactionContext(this);
-        context.applyMethod ??= (op) => applyTransactionOp(context, op);
-        return context.applyMethod;
-      }
-    }
-  };
-  for (const key of Object.keys(ops)) {
-    descriptors[String(key)] = {
-      enumerable: true,
-      get() {
-        const context = getTransactionContext(this);
-        const cacheKey = String(key);
-        context.methodCache[cacheKey] ??= (...args) => runInternal(context, key, args);
-        return context.methodCache[cacheKey];
-      }
-    };
-  }
-  Object.defineProperties(surface, descriptors);
-  return surface;
-}
-function createReducerTransactionFromSurface(initialState, internalOps, surface) {
-  const transaction = Object.create(surface);
-  Object.defineProperty(transaction, transactionContext, {
-    value: {
-      currentState: {
-        ...initialState,
-        table: cloneRuntimeTable(initialState.table)
-      },
-      currentQueries: null,
-      internalOps,
-      methodCache: {}
-    }
-  });
-  return transaction;
-}
-function createReducerTransaction(initialState, ops = createReducerOps()) {
-  const internalOps = getReducerOpsInternal(ops);
-  const surface = createReducerTransactionSurface(ops);
-  return createReducerTransactionFromSurface(
-    initialState,
-    internalOps,
-    surface
-  );
-}
-function createReducerEdit(ops = createReducerOps()) {
-  const internalOps = getReducerOpsInternal(ops);
-  const surface = createReducerTransactionSurface(ops);
-  return (state) => createReducerTransactionFromSurface(
-    state,
-    internalOps,
-    surface
-  );
-}
-
-// src/reducer/derived.ts
-function defineDerived() {
-  return (def) => def;
-}
-function createDerivedResolver(state, options = {}) {
-  const cache = /* @__PURE__ */ new Map();
-  const inflight = /* @__PURE__ */ new Set();
-  const q = options.q ?? createStateQueries(state);
-  const resolver = (def) => {
-    const typedDef = def;
-    if (cache.has(typedDef)) {
-      return cache.get(typedDef);
-    }
-    if (inflight.has(typedDef)) {
-      throw new Error(
-        `Cyclic derived: '${def.name ?? "<anonymous>"}' depends on itself.`
-      );
-    }
-    inflight.add(typedDef);
-    try {
-      const value = def.compute({ state, q, derived: resolver });
-      cache.set(typedDef, value);
-      return value;
-    } finally {
-      inflight.delete(typedDef);
-    }
-  };
-  return resolver;
-}
-
 // src/reducer/contract-fingerprint.ts
 import { z } from "zod";
 function contractFingerprint(source) {
@@ -1332,6 +1236,133 @@ function isStaleContractArtifactError(error) {
   return error instanceof StaleContractArtifactError || typeof error === "object" && error !== null && error.code === "STALE_CONTRACT_ARTIFACT";
 }
 
+// src/reducer/effects.ts
+function buildResume(effect, context) {
+  if (!effect.__continuation) {
+    return void 0;
+  }
+  return effect.__continuation(
+    context ?? {}
+  );
+}
+function invokeEffect(effect, options) {
+  const continuation = buildResume(effect, options.context);
+  if (effect.type === "rollDie") {
+    return continuation === void 0 ? {
+      kind: "engine.rollDie",
+      dieId: options.dieId
+    } : {
+      kind: "engine.rollDie",
+      dieId: options.dieId,
+      continuation
+    };
+  }
+  if (effect.type === "shuffleSharedZone") {
+    return continuation === void 0 ? {
+      kind: "engine.shuffleSharedZone",
+      zoneId: options.zoneId
+    } : {
+      kind: "engine.shuffleSharedZone",
+      zoneId: options.zoneId,
+      continuation
+    };
+  }
+  if (effect.type === "shufflePlayerZone") {
+    return continuation === void 0 ? {
+      kind: "engine.shufflePlayerZone",
+      zoneId: options.zoneId,
+      playerId: options.playerId
+    } : {
+      kind: "engine.shufflePlayerZone",
+      zoneId: options.zoneId,
+      playerId: options.playerId,
+      continuation
+    };
+  }
+  throw new Error(
+    `fx.effect: unsupported effect type '${effect.type}'.`
+  );
+}
+function createReducerFx() {
+  const fx = {
+    transition(to) {
+      return { kind: "flow.transition", to };
+    },
+    effect(effect, options) {
+      return invokeEffect(
+        effect,
+        options
+      );
+    }
+  };
+  return fx;
+}
+
+// src/reducer/bundle/trusted/trusted-runtime-args.ts
+function fxForState() {
+  return createReducerFx();
+}
+function buildContext(state, manifest) {
+  return {
+    currentPhase: state.flow.currentPhase,
+    manifest,
+    playerOrder: [...state.table.playerOrder],
+    activePlayers: [...state.flow.activePlayers],
+    runtime: publicRuntime(state.runtime),
+    setup: state.runtime.setup ? {
+      profileId: state.runtime.setup.profileId,
+      optionValues: {
+        ...state.runtime.setup.optionValues
+      }
+    } : null
+  };
+}
+function publicRuntime(runtime) {
+  const rest = { ...runtime };
+  delete rest.rng;
+  return rest;
+}
+var DISABLED_RANDOM_HELPERS = {
+  integer() {
+    throw new Error(
+      "random helpers are only available in reducer mutation callbacks."
+    );
+  },
+  subset() {
+    throw new Error(
+      "random helpers are only available in reducer mutation callbacks."
+    );
+  }
+};
+var implicitResultSymbol = /* @__PURE__ */ Symbol("dreamboard.implicitResult");
+function implicitResultOf(args) {
+  return args[implicitResultSymbol]();
+}
+function buildRuntimeArgs(state, manifest, helpers, toDomainState2, extra, options = {}) {
+  const domainState = toDomainState2(state);
+  const q = options.q ?? createStateQueries(domainState);
+  const args = {
+    ...buildContext(state, manifest),
+    ...helpers,
+    fx: options.fx ?? fxForState(),
+    q,
+    derived: options.derived ?? createDerivedResolver(domainState, { q }),
+    runtime: publicRuntime(state.runtime),
+    random: options.random ?? DISABLED_RANDOM_HELPERS,
+    ...extra
+  };
+  let transaction;
+  Object.defineProperty(args, "tx", {
+    enumerable: true,
+    get: () => transaction ??= helpers.edit(domainState)
+  });
+  Object.defineProperty(args, implicitResultSymbol, {
+    enumerable: false,
+    value: () => transaction ? transaction.accept() : helpers.accept(domainState)
+  });
+  return args;
+}
+
 // src/reducer/engine/runtime-instruction-engine.ts
 function createRuntimeInstructionEngine({
   reduce,
@@ -1874,34 +1905,186 @@ function isSimultaneousPhase(phase) {
 function simultaneousSubmitInteraction(phase) {
   return phase.submit;
 }
-function resolvePromptToArray(value) {
-  if (value === void 0 || value === null) return [];
-  if (Array.isArray(value)) return value;
-  if (typeof value === "string") return [value];
-  return [];
+function resolvePromptToArray(value) {
+  if (value === void 0 || value === null) return [];
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string") return [value];
+  return [];
+}
+function resolveSimultaneousActors(scope, state, phase, projection) {
+  const selector = phase.actors ?? phase.actor;
+  if (typeof selector === "function") {
+    const selected = selector(
+      scope.buildRuntimeArgs(
+        state,
+        {
+          state: projection?.domainState ?? scope.toDomainState(state)
+        },
+        projection
+      )
+    );
+    const resolved = resolvePromptToArray(selected);
+    if (resolved.length > 0) {
+      return resolved;
+    }
+  }
+  const active = state.flow.activePlayers;
+  if (active.length > 0) {
+    return [...active];
+  }
+  return [...state.table.playerOrder];
+}
+
+// src/reducer/transaction.ts
+var transactionContext = /* @__PURE__ */ Symbol("dreamboard.reducerTransactionContext");
+function createOutcomeMethods(context) {
+  const fx = createReducerFx();
+  const accept = () => ({
+    type: "accept",
+    state: context.currentState,
+    instructions: [...context.instructions],
+    events: [...context.events]
+  });
+  return {
+    emit(...events) {
+      context.events.push(...events);
+    },
+    schedule(...instructions) {
+      context.instructions.push(...instructions);
+    },
+    effect(effect, options) {
+      context.instructions.push(fx.effect(effect, options));
+    },
+    accept,
+    transition(to) {
+      const result = accept();
+      return {
+        ...result,
+        instructions: [
+          ...result.instructions ?? [],
+          fx.transition(to)
+        ]
+      };
+    },
+    endGame(outcome, options) {
+      const result = accept();
+      return {
+        ...result,
+        instructions: options?.transition ? [
+          ...result.instructions ?? [],
+          fx.transition(options.transition)
+        ] : result.instructions,
+        terminal: outcome
+      };
+    },
+    reject(errorCode, message) {
+      return { type: "reject", errorCode, message };
+    }
+  };
+}
+function getTransactionContext(host) {
+  const context = host[transactionContext];
+  if (!context) {
+    throw new TypeError("Reducer transaction method called without a receiver");
+  }
+  return context;
+}
+function invalidate(context) {
+  context.currentQueries = null;
+}
+function applyTransactionOp(context, op) {
+  context.currentState = op(context.currentState);
+  invalidate(context);
+  return context.currentState;
+}
+function runInternal(context, key, args) {
+  context.currentState = context.internalOps[key](context.currentState, ...args);
+  invalidate(context);
+  return context.currentState;
 }
-function resolveSimultaneousActors(scope, state, phase, projection) {
-  const selector = phase.actors ?? phase.actor;
-  if (typeof selector === "function") {
-    const selected = selector(
-      scope.buildRuntimeArgs(
-        state,
-        {
-          state: projection?.domainState ?? scope.toDomainState(state)
-        },
-        projection
-      )
-    );
-    const resolved = resolvePromptToArray(selected);
-    if (resolved.length > 0) {
-      return resolved;
+function createReducerTransactionSurface(ops) {
+  const surface = {};
+  const descriptors = {
+    state: {
+      enumerable: true,
+      get() {
+        return getTransactionContext(this).currentState;
+      }
+    },
+    q: {
+      enumerable: true,
+      get() {
+        const context = getTransactionContext(this);
+        context.currentQueries ??= createStateQueries(context.currentState);
+        return context.currentQueries;
+      }
+    },
+    apply: {
+      enumerable: true,
+      get() {
+        const context = getTransactionContext(this);
+        context.applyMethod ??= (op) => applyTransactionOp(context, op);
+        return context.applyMethod;
+      }
     }
+  };
+  for (const key of [
+    "emit",
+    "schedule",
+    "effect",
+    "accept",
+    "transition",
+    "endGame",
+    "reject"
+  ]) {
+    descriptors[key] = {
+      enumerable: true,
+      get() {
+        const context = getTransactionContext(this);
+        context.outcome ??= createOutcomeMethods(context);
+        return context.outcome[key];
+      }
+    };
   }
-  const active = state.flow.activePlayers;
-  if (active.length > 0) {
-    return [...active];
+  for (const key of Object.keys(ops)) {
+    descriptors[String(key)] = {
+      enumerable: true,
+      get() {
+        const context = getTransactionContext(this);
+        const cacheKey = String(key);
+        context.methodCache[cacheKey] ??= (...args) => runInternal(context, key, args);
+        return context.methodCache[cacheKey];
+      }
+    };
   }
-  return [...state.table.playerOrder];
+  Object.defineProperties(surface, descriptors);
+  return surface;
+}
+function createReducerTransactionFromSurface(initialState, internalOps, surface) {
+  const transaction = Object.create(surface);
+  Object.defineProperty(transaction, transactionContext, {
+    value: {
+      currentState: {
+        ...initialState,
+        table: cloneRuntimeTable(initialState.table)
+      },
+      currentQueries: null,
+      internalOps,
+      methodCache: {},
+      events: [],
+      instructions: []
+    }
+  });
+  return transaction;
+}
+function createReducerEdit(ops = createReducerOps()) {
+  const internalOps = getReducerOpsInternal(ops);
+  const surface = createReducerTransactionSurface(ops);
+  return (state) => createReducerTransactionFromSurface(
+    state,
+    internalOps,
+    surface
+  );
 }
 
 // src/reducer/bundle/trusted/runtime-registry.ts
@@ -1939,119 +2122,6 @@ function collectTrustedRuntimeRegistry(definition) {
   };
 }
 
-// src/reducer/effects.ts
-function buildResume(effect, context) {
-  if (!effect.__continuation) {
-    return void 0;
-  }
-  return effect.__continuation(
-    context ?? {}
-  );
-}
-function invokeEffect(effect, options) {
-  const continuation = buildResume(effect, options.context);
-  if (effect.type === "rollDie") {
-    return continuation === void 0 ? {
-      kind: "engine.rollDie",
-      dieId: options.dieId
-    } : {
-      kind: "engine.rollDie",
-      dieId: options.dieId,
-      continuation
-    };
-  }
-  if (effect.type === "shuffleSharedZone") {
-    return continuation === void 0 ? {
-      kind: "engine.shuffleSharedZone",
-      zoneId: options.zoneId
-    } : {
-      kind: "engine.shuffleSharedZone",
-      zoneId: options.zoneId,
-      continuation
-    };
-  }
-  if (effect.type === "shufflePlayerZone") {
-    return continuation === void 0 ? {
-      kind: "engine.shufflePlayerZone",
-      zoneId: options.zoneId,
-      playerId: options.playerId
-    } : {
-      kind: "engine.shufflePlayerZone",
-      zoneId: options.zoneId,
-      playerId: options.playerId,
-      continuation
-    };
-  }
-  throw new Error(
-    `fx.effect: unsupported effect type '${effect.type}'.`
-  );
-}
-function createReducerFx() {
-  const fx = {
-    transition(to) {
-      return { kind: "flow.transition", to };
-    },
-    effect(effect, options) {
-      return invokeEffect(
-        effect,
-        options
-      );
-    }
-  };
-  return fx;
-}
-
-// src/reducer/bundle/trusted/trusted-runtime-args.ts
-function fxForState() {
-  return createReducerFx();
-}
-function buildContext(state, manifest) {
-  return {
-    currentPhase: state.flow.currentPhase,
-    manifest,
-    playerOrder: [...state.table.playerOrder],
-    activePlayers: [...state.flow.activePlayers],
-    runtime: publicRuntime(state.runtime),
-    setup: state.runtime.setup ? {
-      profileId: state.runtime.setup.profileId,
-      optionValues: {
-        ...state.runtime.setup.optionValues
-      }
-    } : null
-  };
-}
-function publicRuntime(runtime) {
-  const rest = { ...runtime };
-  delete rest.rng;
-  return rest;
-}
-var DISABLED_RANDOM_HELPERS = {
-  integer() {
-    throw new Error(
-      "random helpers are only available in reducer mutation callbacks."
-    );
-  },
-  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);
-  return {
-    ...buildContext(state, manifest),
-    ...helpers,
-    fx: options.fx ?? fxForState(),
-    q,
-    derived: options.derived ?? createDerivedResolver(domainState, { q }),
-    runtime: publicRuntime(state.runtime),
-    random: options.random ?? DISABLED_RANDOM_HELPERS,
-    ...extra
-  };
-}
-
 // src/reducer/bundle/trusted/trusted-runtime-result.ts
 var OUTCOME_STRING_LIMIT = 256;
 var OUTCOME_LABEL_LIMIT = 128;
@@ -2303,9 +2373,17 @@ function rejectResult(errorCode, message) {
     message
   };
 }
-function normalizeResult(result, fallbackState) {
+function normalizeResult(result, implicitResult) {
   if (result === void 0 || result === null) {
-    return acceptResult(fallbackState);
+    result = implicitResult();
+  }
+  if (result.type === "accept") {
+    return {
+      ...result,
+      instructions: [...result.instructions ?? []],
+      events: normalizeGameEvents(result.events),
+      ...result.terminal ? { terminal: normalizeGameOutcome(result.state, result.terminal) } : {}
+    };
   }
   return result;
 }
@@ -2511,22 +2589,21 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
         return rejectResult("invalid-action-params", parsed.message);
       }
       const random = createMutableRandomHelpers(state.runtime.rng);
+      const reduceArgs = scope.buildRuntimeArgs(
+        state,
+        {
+          ...ctx,
+          state: scope.toDomainState(state),
+          input: {
+            playerId: input.playerId,
+            params: parsed.params
+          }
+        },
+        { random: random.random }
+      );
       const result = normalizeResult(
-        interaction.reduce(
-          scope.buildRuntimeArgs(
-            state,
-            {
-              ...ctx,
-              state: scope.toDomainState(state),
-              input: {
-                playerId: input.playerId,
-                params: parsed.params
-              }
-            },
-            { random: random.random }
-          )
-        ),
-        scope.toDomainState(state)
+        interaction.reduce(reduceArgs),
+        () => implicitResultOf(reduceArgs)
       );
       return result.type === "accept" ? {
         ...result,
@@ -2543,24 +2620,23 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
         );
       }
       const random = createMutableRandomHelpers(state.runtime.rng);
+      const continuationArgs = scope.buildRuntimeArgs(
+        state,
+        {
+          ...ctx,
+          state: scope.toDomainState(state),
+          input: {
+            source: "effect",
+            effectKind: input.effectKind,
+            data: input.resumeData,
+            response: input.response
+          }
+        },
+        { random: random.random }
+      );
       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
-              }
-            },
-            { random: random.random }
-          )
-        ),
-        scope.toDomainState(state)
+        continuation.reduce(continuationArgs),
+        () => implicitResultOf(continuationArgs)
       );
       return result.type === "accept" ? {
         ...result,
@@ -2705,20 +2781,19 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
       ])
     );
     const random = createMutableRandomHelpers(stateWithSubmission.runtime.rng);
+    const resolveArgs = scope.buildRuntimeArgs(
+      stateWithSubmission,
+      {
+        state: scope.toDomainState(stateWithSubmission),
+        submissions: resolvedSubmissions,
+        submittedPlayerIds: [...actors],
+        waitingPlayerIds: []
+      },
+      { random: random.random }
+    );
     const resolved = normalizeResult(
-      resolve(
-        scope.buildRuntimeArgs(
-          stateWithSubmission,
-          {
-            state: scope.toDomainState(stateWithSubmission),
-            submissions: resolvedSubmissions,
-            submittedPlayerIds: [...actors],
-            waitingPlayerIds: []
-          },
-          { random: random.random }
-        )
-      ),
-      scope.toDomainState(stateWithSubmission)
+      resolve(resolveArgs),
+      () => implicitResultOf(resolveArgs)
     );
     if (resolved.type === "reject") {
       return resolved;
@@ -3142,15 +3217,15 @@ function createInteractionAuthorization(scope) {
       };
     }
     if (interaction.actor) {
-      const resolved = interaction.actor({
-        ...scope.buildRuntimeArgs(
+      const resolved = interaction.actor(
+        scope.buildRuntimeArgs(
           state,
           {
             state: projection?.domainState ?? scope.toDomainState(state)
           },
           projection
         )
-      });
+      );
       return {
         mode: "actors",
         actors: resolvePromptToSet(resolved)
@@ -3166,15 +3241,15 @@ function createInteractionAuthorization(scope) {
       };
     }
     if (phase.actor) {
-      const resolved = phase.actor({
-        ...scope.buildRuntimeArgs(
+      const resolved = phase.actor(
+        scope.buildRuntimeArgs(
           state,
           {
             state: projection?.domainState ?? scope.toDomainState(state)
           },
           projection
         )
-      });
+      );
       return {
         mode: "actors",
         actors: resolvePromptToSet(resolved)
@@ -5021,18 +5096,17 @@ function createLifecycleRunner(scope, interactions) {
     const events = [];
     if (phase.enter) {
       const random = createMutableRandomHelpers(workingState.runtime.rng);
+      const enterArgs = scope.buildRuntimeArgs(
+        workingState,
+        {
+          event,
+          state: scope.toDomainState(workingState)
+        },
+        { random: random.random }
+      );
       const entered = normalizeResult(
-        phase.enter(
-          scope.buildRuntimeArgs(
-            workingState,
-            {
-              event,
-              state: scope.toDomainState(workingState)
-            },
-            { random: random.random }
-          )
-        ),
-        scope.toDomainState(workingState)
+        phase.enter(enterArgs),
+        () => implicitResultOf(enterArgs)
       );
       if (entered.type === "reject") {
         throw new Error(
@@ -5051,18 +5125,17 @@ function createLifecycleRunner(scope, interactions) {
     const activeStage = interactions.resolveActiveStage(nextState, phaseName);
     if (activeStage?.stage.onEnter) {
       const random = createMutableRandomHelpers(nextState.runtime.rng);
+      const stageArgs = scope.buildRuntimeArgs(
+        nextState,
+        {
+          event,
+          state: scope.toDomainState(nextState)
+        },
+        { random: random.random }
+      );
       const stageEntered = normalizeResult(
-        activeStage.stage.onEnter(
-          scope.buildRuntimeArgs(
-            nextState,
-            {
-              event,
-              state: scope.toDomainState(nextState)
-            },
-            { random: random.random }
-          )
-        ),
-        scope.toDomainState(nextState)
+        activeStage.stage.onEnter(stageArgs),
+        () => implicitResultOf(stageArgs)
       );
       if (stageEntered.type === "reject") {
         throw new Error(
@@ -5713,7 +5786,6 @@ function createProjectionBuilder(scope, interactions) {
         schedulerFlow: resolveSchedulerFlowFor(state, projection),
         ...projectionMode === "full" ? { sharedView } : {},
         guidance: resolveGuidanceFor(combinedState),
-        recentEvents: [],
         interactionsByRef: registry.entries(),
         seats
       },
@@ -7078,13 +7150,11 @@ function createReducerBundle(definition, options = {}) {
 
 export {
   noopDiagnosticsSink,
-  createReducerOps,
   createTableQueries,
   createStateQueries,
-  createReducerTransaction,
-  createReducerEdit,
   defineDerived,
   createDerivedResolver,
+  createReducerOps,
   interactionDomainEligibleCount,
   contractFingerprint,
   StaleContractArtifactError,
@@ -7092,4 +7162,4 @@ export {
   createReducerTestingBundle,
   createReducerBundle
 };
-//# sourceMappingURL=chunk-533O7C4L.js.map
+//# sourceMappingURL=chunk-S2JEDVWH.js.map