@dreamboard-games/sdk 0.2.0 → 0.2.1-alpha.1

package/dist/infrastructure/reducer-bundle-abi.js

@@ -4,7 +4,7 @@ import {
 import {
   REDUCER_CONTRACT_VERSION,
   zod_exports
-} from "../chunk-VFTAA4WO.js";
+} from "../chunk-MKXPVOUT.js";
 import "../chunk-PZ5AY32C.js";
 export {
   REDUCER_CONTRACT_VERSION,

package/dist/package-set.d.ts

@@ -1,6 +1,6 @@
-declare const DREAMBOARD_SDK_VERSION = "0.2.0";
+declare const DREAMBOARD_SDK_VERSION = "0.2.1-alpha.1";
 declare const DREAMBOARD_SDK_PACKAGES: {
-    readonly "@dreamboard-games/sdk": "0.2.0";
+    readonly "@dreamboard-games/sdk": "0.2.1-alpha.1";
 };
 type DreamboardSdkPackageName = keyof typeof DREAMBOARD_SDK_PACKAGES;
 type DreamboardSdkPackageSet = {

package/dist/package-set.js

@@ -2,7 +2,7 @@ import {
   DREAMBOARD_SDK_PACKAGES,
   DREAMBOARD_SDK_PACKAGE_SET,
   DREAMBOARD_SDK_VERSION
-} from "./chunk-WN74KVNY.js";
+} from "./chunk-PEI3FIL2.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DREAMBOARD_SDK_PACKAGES,

package/dist/reducer.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { C as CardCollection, V as ViewCard } from './cards-Sl3b40Mv.js';
 import { V as ViewSlotOccupant } from './slots-1GPGihk8.js';
-import { R as ReducerBundleContract } from './bundle-TIZcw8LB.js';
+import { R as ReducerBundleContract } from './bundle-CDd5FKeD.js';
 
 /**
  * Opaque brand applied to a runtime player identifier.

package/dist/reducer.js

@@ -1,7 +1,7 @@
 import {
   REDUCER_CONTRACT_VERSION,
   ReducerSessionStateSchema
-} from "./chunk-VFTAA4WO.js";
+} from "./chunk-MKXPVOUT.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/reducer/model/manifest.ts
@@ -6837,14 +6837,18 @@ function createProjectionBuilder(scope, interactions) {
     const byRef = {};
     const byHash = /* @__PURE__ */ new Map();
     return {
-      add(descriptor) {
-        const fingerprint = stableStringify(descriptor);
+      add(descriptor, actorSeat) {
+        const enriched = descriptorWithBrowserReplayDigests(
+          descriptor,
+          actorSeat
+        );
+        const fingerprint = stableStringify(enriched);
         const existing = byHash.get(fingerprint);
         if (existing) return existing;
-        const base = typeof descriptor.interactionId === "string" && descriptor.interactionId.length > 0 ? descriptor.interactionId : "interaction";
+        const base = typeof enriched.interactionId === "string" && enriched.interactionId.length > 0 ? enriched.interactionId : "interaction";
         const ref = `${base}:${fnv1a64(fingerprint)}`;
         byHash.set(fingerprint, ref);
-        byRef[ref] = descriptor;
+        byRef[ref] = enriched;
         return ref;
       },
       entries() {
@@ -6852,7 +6856,7 @@ function createProjectionBuilder(scope, interactions) {
       }
     };
   }
-  function resolveZoneHandlesFor(combinedState, playerId, projection, registry) {
+  function resolveZoneHandlesFor(combinedState, playerId, actorSeat, projection, registry) {
     const phaseName = combinedState.flow.currentPhase;
     const zoneIds = new Set(scope.zonesForPhase(phaseName).map(String));
     for (const [, interaction] of scope.interactionEntriesForPhase(phaseName)) {
@@ -6907,10 +6911,13 @@ function createProjectionBuilder(scope, interactions) {
             continue;
           }
           perCard.push(
-            registry.add({
-              ...decision.descriptor,
-              zoneId
-            })
+            registry.add(
+              {
+                ...decision.descriptor,
+                zoneId
+              },
+              actorSeat
+            )
           );
         }
         playableByCardId[cardId] = perCard;
@@ -6990,16 +6997,17 @@ function createProjectionBuilder(scope, interactions) {
     });
     const registry = createDescriptorRegistry();
     const seats = {};
-    for (const playerId of playerIds) {
+    for (const [actorSeat, playerId] of playerIds.entries()) {
       const availableInteractionRefs = interactions.resolveAvailableInteractionsFor(combinedState, playerId, {
         projection
-      }).map((descriptor) => registry.add(descriptor));
+      }).map((descriptor) => registry.add(descriptor, actorSeat));
       seats[playerId] = {
         ...projectionMode === "full" ? {
           view: resolveViewFor(combinedState, playerId, viewId, projection),
           zones: resolveZoneHandlesFor(
             combinedState,
             playerId,
+            actorSeat,
             projection,
             registry
           )
@@ -7036,6 +7044,126 @@ function createProjectionBuilder(scope, interactions) {
     resolveZoneHandlesFor
   };
 }
+function descriptorWithBrowserReplayDigests(descriptor, actorSeat) {
+  const descriptorDigestValue = descriptor.descriptorDigest ?? interactionDescriptorDigest(descriptor);
+  return {
+    ...descriptor,
+    descriptorDigest: descriptorDigestValue,
+    actorSeat,
+    draftDigest: descriptor.draftDigest ?? interactionDraftDigest({
+      actorSeat,
+      descriptor,
+      descriptorDigest: descriptorDigestValue
+    })
+  };
+}
+function interactionDescriptorDigest(descriptor) {
+  return hashJson({
+    commitMode: descriptor.commit.mode,
+    defaults: toDescriptorDigestJson(defaultsForDescriptor(descriptor)),
+    inputKeys: descriptor.inputs.map((input) => input.key),
+    inputs: descriptor.inputs.map((input) => ({
+      key: input.key,
+      kind: input.kind,
+      domain: toDescriptorDigestJson(input.domain),
+      defaultValue: input.defaultValue === void 0 ? null : toDescriptorDigestJson(input.defaultValue)
+    })),
+    interactionId: descriptor.interactionId,
+    interactionKey: descriptor.interactionKey,
+    stableIdentity: `${descriptor.interactionKey}:${descriptor.interactionId}`
+  });
+}
+function interactionDraftDigest({
+  actorSeat,
+  descriptor,
+  descriptorDigest
+}) {
+  return hashJson({
+    digestVersion: "interaction-draft@2",
+    actorSeat,
+    descriptorDigest,
+    emitted: false,
+    interactionId: descriptor.interactionId,
+    interactionKey: descriptor.interactionKey,
+    values: defaultsForDescriptor(descriptor)
+  });
+}
+function toDescriptorDigestJson(value) {
+  const canonical = toCanonicalJson(value);
+  return normalizeOrderInsensitiveDescriptorFields(canonical);
+}
+function normalizeOrderInsensitiveDescriptorFields(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeOrderInsensitiveDescriptorFields);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => {
+      const normalized = normalizeOrderInsensitiveDescriptorFields(item);
+      if ((key === "eligibleTargets" || key === "dependentCases") && Array.isArray(normalized)) {
+        return [
+          key,
+          [...normalized].sort(
+            (left, right) => compareCanonicalJson(canonicalJson(left), canonicalJson(right))
+          )
+        ];
+      }
+      return [key, normalized];
+    })
+  );
+}
+function defaultsForDescriptor(descriptor) {
+  return Object.fromEntries(
+    descriptor.inputs.flatMap(
+      (input) => input.defaultValue === void 0 ? [] : [[input.key, toCanonicalJson(input.defaultValue)]]
+    )
+  );
+}
+function toCanonicalJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toCanonicalJson(item));
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, toCanonicalJson(item)])
+    );
+  }
+  return null;
+}
+function hashJson(value) {
+  return `sha256:${sha256Hex(canonicalJson(value))}`;
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalizeJson(value));
+}
+function canonicalizeJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("canonical JSON contains a non-finite number");
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalizeJson(item));
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalizeJson(item)])
+  );
+}
+function compareCanonicalJson(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
 function stableStringify(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
@@ -7055,6 +7183,171 @@ function fnv1a64(value) {
   }
   return hash.toString(16).padStart(16, "0");
 }
+var SHA256_K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function sha256Hex(input) {
+  const bytes = utf8Bytes(input);
+  const bitLength = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+  for (let shift = 56; shift >= 0; shift -= 8) {
+    bytes.push(Math.floor(bitLength / 2 ** shift) & 255);
+  }
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const words = new Array(64);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const base = offset + index * 4;
+      words[index] = (bytes[base] << 24 | bytes[base + 1] << 16 | bytes[base + 2] << 8 | bytes[base + 3]) >>> 0;
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + SHA256_K[index] + words[index] >>> 0;
+      const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, shift) {
+  return value >>> shift | value << 32 - shift;
+}
+function utf8Bytes(input) {
+  const bytes = [];
+  for (let index = 0; index < input.length; index += 1) {
+    let codePoint = input.charCodeAt(index);
+    if (codePoint >= 55296 && codePoint <= 56319 && index + 1 < input.length) {
+      const low = input.charCodeAt(index + 1);
+      if (low >= 56320 && low <= 57343) {
+        codePoint = 65536 + (codePoint - 55296 << 10) + (low - 56320);
+        index += 1;
+      }
+    }
+    if (codePoint < 128) {
+      bytes.push(codePoint);
+    } else if (codePoint < 2048) {
+      bytes.push(192 | codePoint >>> 6, 128 | codePoint & 63);
+    } else if (codePoint < 65536) {
+      bytes.push(
+        224 | codePoint >>> 12,
+        128 | codePoint >>> 6 & 63,
+        128 | codePoint & 63
+      );
+    } else {
+      bytes.push(
+        240 | codePoint >>> 18,
+        128 | codePoint >>> 12 & 63,
+        128 | codePoint >>> 6 & 63,
+        128 | codePoint & 63
+      );
+    }
+  }
+  return bytes;
+}
 
 // src/reducer/bundle/trusted/static-projection.ts
 function stableStringify2(value) {