@dreamboard-games/sdk 0.4.0-alpha.7 → 0.4.0-alpha.8

package/dist/reducer.js

@@ -133,7 +133,7 @@ import {
   REDUCER_CONTRACT_VERSION,
   builders_exports,
   zod_exports
-} from "./chunk-TGMXBRKY.js";
+} from "./chunk-3BLN5POZ.js";
 import {
   RuntimeJsonSchema,
   assertJsonWithinLimits
@@ -1316,9 +1316,17 @@ function defineStepPhase() {
 }
 
 // src/reducer/authoring/view-stage.ts
-function defineView() {
+function defineSharedView() {
   return (definition) => definition;
 }
+function definePlayerView() {
+  return (definition) => definition;
+}
+function defineEmptyView() {
+  return {
+    project: () => ({})
+  };
+}
 function defineStaticView() {
   return (definition) => definition;
 }
@@ -1369,7 +1377,9 @@ function createContractAuthoring(contract) {
   return {
     contract,
     game: (definition) => defineGame({ contract, ...definition }),
-    view: (definition) => defineView()(definition),
+    sharedView: (definition) => defineSharedView()(definition),
+    playerView: (definition) => definePlayerView()(definition),
+    emptyView: () => defineEmptyView(),
     staticView: (definition) => defineStaticView()(definition),
     phase: (name) => {
       const cached = phaseCache.get(name);
@@ -5598,23 +5608,25 @@ function createProjectionContext(options) {
 
 // src/reducer/bundle/trusted/projection-builder.ts
 function createProjectionBuilder(scope, interactions) {
-  function createDescriptorRegistry() {
+  function createDescriptorRegistry(timing) {
     const byRef = {};
     const byHash = /* @__PURE__ */ new Map();
     return {
       add(descriptor, actorSeat) {
-        const enriched = descriptorWithBrowserReplayDigests(
-          descriptor,
-          actorSeat
-        );
-        const fingerprint = stableStringify(enriched);
-        const existing = byHash.get(fingerprint);
-        if (existing) return existing;
-        const base = typeof enriched.interactionId === "string" && enriched.interactionId.length > 0 ? enriched.interactionId : "interaction";
-        const ref = `${base}:${fnv1a64(fingerprint)}`;
-        byHash.set(fingerprint, ref);
-        byRef[ref] = enriched;
-        return ref;
+        return measureProjectionTiming(timing, "descriptorHashMs", () => {
+          const enriched = descriptorWithBrowserReplayDigests(
+            descriptor,
+            actorSeat
+          );
+          const fingerprint = stableStringify(enriched);
+          const existing = byHash.get(fingerprint);
+          if (existing) return existing;
+          const base = typeof enriched.interactionId === "string" && enriched.interactionId.length > 0 ? enriched.interactionId : "interaction";
+          const ref = `${base}:${fnv1a64(fingerprint)}`;
+          byHash.set(fingerprint, ref);
+          byRef[ref] = enriched;
+          return ref;
+        });
       },
       entries() {
         return byRef;
@@ -5772,12 +5784,20 @@ function createProjectionBuilder(scope, interactions) {
       pendingPlayerIds
     };
   }
-  function resolveViewFor(combinedState, playerId, viewId, projection) {
-    const views = scope.definition.views;
-    const view = views?.[viewId];
-    if (!view) {
-      return null;
-    }
+  function resolveSharedViewFor(combinedState, projection) {
+    const view = scope.definition.views.shared;
+    const viewArgs = {
+      ...scope.buildContext(combinedState),
+      ...scope.runtimeHelpers,
+      fx: projection.fx,
+      q: projection.q,
+      derived: projection.derived,
+      state: projection.domainState
+    };
+    return view.project(viewArgs);
+  }
+  function resolvePlayerViewFor(combinedState, playerId, sharedView, projection) {
+    const view = scope.definition.views.player;
     const viewArgs = {
       ...scope.buildContext(combinedState),
       ...scope.runtimeHelpers,
@@ -5785,14 +5805,14 @@ function createProjectionBuilder(scope, interactions) {
       q: projection.q,
       derived: projection.derived,
       state: projection.domainState,
-      playerId
+      playerId,
+      shared: sharedView
     };
     return view.project(viewArgs);
   }
   function projectSeatsDynamic({
     state,
     playerIds,
-    viewId = "player",
     projectionMode = "full"
   }) {
     const combinedState = scope.toCombinedState(state);
@@ -5800,57 +5820,105 @@ function createProjectionBuilder(scope, interactions) {
       combinedState,
       domainState: scope.toDomainState(combinedState)
     });
-    const registry = createDescriptorRegistry();
+    const timing = createProjectionTimingMetadata();
+    const registry = createDescriptorRegistry(timing);
     const seats = {};
+    const sharedView = projectionMode === "full" ? measureProjectionTiming(
+      timing,
+      "resolveViewMs",
+      () => resolveSharedViewFor(combinedState, projection)
+    ) : void 0;
     for (const [actorSeat, playerId] of playerIds.entries()) {
-      const availableInteractionRefs = interactions.resolveAvailableInteractionsFor(combinedState, playerId, {
-        projection
-      }).map((descriptor) => registry.add(descriptor, actorSeat));
-      seats[playerId] = {
-        ...projectionMode === "full" ? {
-          view: resolveViewFor(combinedState, playerId, viewId, projection),
-          zones: resolveZoneHandlesFor(
+      const availableInteractions = measureProjectionTiming(
+        timing,
+        "resolveAvailableInteractionsMs",
+        () => interactions.resolveAvailableInteractionsFor(
+          combinedState,
+          playerId,
+          {
+            projection
+          }
+        )
+      );
+      const availableInteractionRefs = availableInteractions.map(
+        (descriptor) => registry.add(descriptor, actorSeat)
+      );
+      const fullProjection = projectionMode === "full" ? {
+        view: measureProjectionTiming(
+          timing,
+          "resolveViewMs",
+          () => resolvePlayerViewFor(
+            combinedState,
+            playerId,
+            sharedView,
+            projection
+          )
+        ),
+        zones: measureProjectionTiming(
+          timing,
+          "resolveZoneHandlesMs",
+          () => resolveZoneHandlesFor(
             combinedState,
             playerId,
             actorSeat,
             projection,
             registry
           )
-        } : {},
+        )
+      } : {};
+      seats[playerId] = {
+        ...fullProjection,
         availableInteractionRefs
       };
     }
-    return {
-      currentStage: resolveCurrentStageFor(combinedState, projection),
-      stageSeats: resolveStageSeatsFor(state),
-      simultaneousPhase: resolveSimultaneousPhaseFor(state),
-      guidance: resolveGuidanceFor(combinedState),
-      recentEvents: [],
-      interactionsByRef: registry.entries(),
-      seats
-    };
-  }
-  function projectSeatViewDynamic({
-    state,
-    playerId,
-    viewId = "player"
-  }) {
-    const combinedState = scope.toCombinedState(state);
-    const projection = createProjectionContext({
-      combinedState,
-      domainState: scope.toDomainState(combinedState)
-    });
-    return resolveViewFor(combinedState, playerId, viewId, projection);
+    return withProjectionTiming(
+      {
+        currentStage: resolveCurrentStageFor(combinedState, projection),
+        stageSeats: resolveStageSeatsFor(state),
+        simultaneousPhase: resolveSimultaneousPhaseFor(state),
+        ...projectionMode === "full" ? { sharedView } : {},
+        guidance: resolveGuidanceFor(combinedState),
+        recentEvents: [],
+        interactionsByRef: registry.entries(),
+        seats
+      },
+      timing
+    );
   }
   return {
     projectSeatsDynamic,
-    projectSeatViewDynamic,
     resolveCurrentStageFor,
     resolveStageSeatsFor,
-    resolveViewFor,
+    resolvePlayerViewFor,
+    resolveSharedViewFor,
     resolveZoneHandlesFor
   };
 }
+function createProjectionTimingMetadata() {
+  return {
+    resolveAvailableInteractionsMs: 0,
+    resolveViewMs: 0,
+    resolveZoneHandlesMs: 0,
+    descriptorHashMs: 0
+  };
+}
+function measureProjectionTiming(timing, field, block) {
+  const startedAt = performance.now();
+  try {
+    return block();
+  } finally {
+    timing[field] += performance.now() - startedAt;
+  }
+}
+function withProjectionTiming(projection, timing) {
+  Object.defineProperty(projection, "timing", {
+    value: timing,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return projection;
+}
 function descriptorWithBrowserReplayDigests(descriptor, actorSeat) {
   const descriptorDigestValue = descriptor.descriptorDigest ?? interactionDescriptorDigest(descriptor);
   return {
@@ -6384,9 +6452,6 @@ function createTrustedReducerBundle(definition, options = {}) {
     },
     projectSeatsDynamic(input) {
       return projection.projectSeatsDynamic(input);
-    },
-    projectSeatViewDynamic(input) {
-      return projection.projectSeatViewDynamic(input);
     }
   };
 }
@@ -7234,30 +7299,17 @@ function createReducerBundle(definition, options = {}) {
     projectStatic() {
       return trustedBundle.projectStatic();
     },
-    /**
-     * Wire-side passthrough for per-tick seat projection. The seat views carry
-     * only the fields produced by `defineView`; static topology, when present,
-     * was served once via `projectStatic` and is re-merged on the client.
-     */
     projectSeatsDynamic({
       state,
       playerIds,
-      viewId = "player"
+      projectionMode
     }) {
       const parsedState = parseTrustedState(state);
       const parsedPlayerIds = playerIds.map((pid) => codec.parsePlayerId(pid));
       return trustedBundle.projectSeatsDynamic({
         state: parsedState,
         playerIds: parsedPlayerIds,
-        viewId
-      });
-    },
-    projectSeatViewDynamic({ state, playerId, viewId = "player" }) {
-      const parsedState = parseTrustedState(state);
-      return trustedBundle.projectSeatViewDynamic({
-        state: parsedState,
-        playerId: parseRuntimePlayerId(playerId),
-        viewId
+        projectionMode: projectionMode ?? void 0
       });
     },
     createInProcessRuntime() {
@@ -7307,21 +7359,14 @@ function createReducerBundle(definition, options = {}) {
             trace: toWireDispatchTrace(result)
           };
         },
-        projectSeatViewDynamic({ playerId, viewId = "player" }) {
-          return trustedBundle.projectSeatViewDynamic({
-            state: requireState(),
-            playerId: parseRuntimePlayerId(playerId),
-            viewId
-          });
-        },
-        projectSeatsDynamic({ playerIds, viewId = "player" }) {
+        projectSeatsDynamic({ playerIds, projectionMode }) {
           const parsedPlayerIds = playerIds.map(
             (pid) => parseRuntimePlayerId(pid)
           );
           return trustedBundle.projectSeatsDynamic({
             state: requireState(),
             playerIds: parsedPlayerIds,
-            viewId
+            projectionMode: projectionMode ?? void 0
           });
         },
         explainInteraction({ playerId, interactionId }) {
@@ -7376,6 +7421,7 @@ export {
   defineCardAction,
   defineDerived,
   defineEffect,
+  defineEmptyView,
   defineGame,
   defineGameContract,
   defineInputs,
@@ -7383,10 +7429,11 @@ export {
   defineInteractionRule,
   definePhase,
   definePhaseStage,
+  definePlayerView,
+  defineSharedView,
   defineStage,
   defineStaticView,
   defineStepPhase,
-  defineView,
   formInput,
   gameEvent,
   isPerPlayer,