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

package/dist/{chunk-TDSWKVZ4.js → chunk-ZABVH7AO.js}

@@ -1,3 +1,15 @@
+import {
+  BROWSER_INTERACTION_ATTRIBUTES,
+  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
+  GAMEPLAY_BROWSER_INTERACTION_SURFACE,
+  createGameplayActuatorAttributes,
+  createGameplayInteractionRootAttributes,
+  gameplayAdjustResourceEffect,
+  gameplayCommitEffect,
+  gameplayInvokeEffect,
+  gameplaySetCandidateEffect,
+  gameplaySetScalarEffect
+} from "./chunk-QLG6VEMW.js";
 import {
   CardDragSurface,
   CardDropTargetView,
@@ -17,7 +29,7 @@ import {
   useChromeSuppression,
   useTheme,
   useThemeCssVars
-} from "./chunk-WYPQ3GG5.js";
+} from "./chunk-WG4JQL3S.js";
 
 // src/runtime-internal/primitives/ui.tsx
 import { Fragment, jsx } from "react/jsx-runtime";
@@ -293,9 +305,376 @@ function RuntimeProvider({
   return /* @__PURE__ */ jsx3(RuntimeContext.Provider, { value: runtime, children: /* @__PURE__ */ jsx3(PluginSessionContext.Provider, { value: sessionState, children }) });
 }
 
+// src/runtime-internal/utils/semantic-projection-digest.ts
+var AUTHORIZED_SEAT_PROJECTION_DIGEST_VERSION = "authorized-seat-projection@2";
+function semanticProjectionDigestForState(state) {
+  const actorPlayerId = state.session.controllingPlayerId;
+  if (!actorPlayerId) {
+    return null;
+  }
+  const seatOrder = state.lobby?.seats.map((seat) => seat.playerId) ?? [];
+  if (!seatOrder.includes(actorPlayerId)) {
+    return null;
+  }
+  return hashJson(semanticSeatProjection(state, state.gameplay, seatOrder));
+}
+function semanticSeatProjection(state, gameplay, seatOrder) {
+  const playerToSeat = new Map(
+    seatOrder.map((playerId, index) => [playerId, index])
+  );
+  const actorPlayerId = state.session.controllingPlayerId;
+  const actorSeat = actorPlayerId ? playerToSeat.get(actorPlayerId) : void 0;
+  if (actorSeat === void 0) {
+    throw new Error(
+      `authorized projection player ${actorPlayerId ?? "__none__"} is not present in seat order`
+    );
+  }
+  return {
+    digestVersion: AUTHORIZED_SEAT_PROJECTION_DIGEST_VERSION,
+    actorSeat,
+    currentStage: gameplay.currentStage ?? null,
+    stageSeats: gameplay.activePlayers.map(
+      (playerId) => canonicalizeSeatReference(playerId, playerToSeat)
+    ),
+    view: canonicalizeSemanticProjectionValue(state.view, playerToSeat),
+    zones: canonicalizeSemanticProjectionValue(gameplay.zones ?? {}, playerToSeat),
+    availableInteractions: gameplay.availableInteractions.map(
+      (descriptor) => semanticInteractionDescriptor(descriptor, playerToSeat)
+    )
+  };
+}
+function semanticInteractionDescriptor(descriptor, playerToSeat) {
+  const inputs = descriptor.inputs.map(
+    (input) => semanticInteractionInput(input, playerToSeat)
+  );
+  const { defaults, defaultProvenance } = collectDefaults(descriptor.inputs);
+  return {
+    interactionKey: descriptor.interactionKey,
+    interactionId: descriptor.interactionId,
+    stableIdentity: canonicalizeSemanticProjectionValue(
+      `${descriptor.interactionKey}:${descriptor.interactionId}`,
+      playerToSeat
+    ),
+    kind: descriptor.kind,
+    surface: descriptor.zoneId ?? descriptor.zoneIds?.find((zoneId) => typeof zoneId === "string") ?? null,
+    commitMode: descriptor.commit.mode === "autoWhenReady" ? "autoWhenReady" : "manual",
+    status: descriptor.availability.status ?? null,
+    available: descriptor.availability.status === "available",
+    inputs,
+    defaults: canonicalizeSemanticProjectionValue(defaults, playerToSeat),
+    defaultProvenance
+  };
+}
+function semanticInteractionInput(input, playerToSeat) {
+  const domain = asRecord(input.domain);
+  const selection = asRecord(domain.selection);
+  return {
+    key: input.key,
+    kind: input.kind,
+    domain: canonicalizeSemanticProjectionValue(input.domain, playerToSeat),
+    defaultValue: input.defaultValue === void 0 ? null : canonicalizeSemanticProjectionValue(input.defaultValue, playerToSeat),
+    defaultProvenance: input.defaultValue === void 0 ? null : "input",
+    selectionMode: stringField(selection, "mode"),
+    min: numberField(domain),
+    max: numberField(domain, "max")
+  };
+}
+function collectDefaults(inputs) {
+  const defaults = {};
+  const defaultProvenance = {};
+  for (const input of inputs) {
+    if (input.defaultValue !== void 0) {
+      defaults[input.key] = toCanonicalJson(input.defaultValue);
+      defaultProvenance[input.key] = "input";
+    }
+  }
+  return { defaults, defaultProvenance };
+}
+function canonicalizeSemanticProjectionValue(value, playerToSeat) {
+  if (value === null || typeof value === "boolean" || typeof value === "number") {
+    return toCanonicalJson(value);
+  }
+  if (typeof value === "string") {
+    return canonicalizeSeatReference(value, playerToSeat);
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => canonicalizeSemanticProjectionValue(item, playerToSeat)
+    );
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(
+        ([key, item]) => item !== void 0 && !SEMANTIC_PROJECTION_TRANSPORT_FIELDS.has(key)
+      ).map(([key, item]) => [
+        canonicalizeObjectKey(key, playerToSeat),
+        canonicalizeSemanticProjectionProperty(key, item, playerToSeat)
+      ])
+    );
+  }
+  return null;
+}
+function canonicalizeSemanticProjectionProperty(key, value, playerToSeat) {
+  const canonicalValue = canonicalizeSemanticProjectionValue(value, playerToSeat);
+  if ((key === "eligibleTargets" || key === "dependentCases") && Array.isArray(canonicalValue)) {
+    return [...canonicalValue].sort(
+      (left, right) => compareJson(canonicalJson(left), canonicalJson(right))
+    );
+  }
+  return canonicalValue;
+}
+function canonicalizeSeatReference(value, playerToSeat) {
+  const seat = playerToSeat.get(value);
+  return seat === void 0 ? value : { $seat: seat };
+}
+function canonicalizeObjectKey(key, playerToSeat) {
+  const seat = playerToSeat.get(key);
+  return seat === void 0 ? key : `$seat:${seat}`;
+}
+var SEMANTIC_PROJECTION_TRANSPORT_FIELDS = /* @__PURE__ */ new Set([
+  "availableInteractionRefs",
+  "board",
+  "cursor",
+  "etag",
+  "hydratedAt",
+  "hydrationCursor",
+  "hydrationSequence",
+  "interactionRef",
+  "interactionRefs",
+  "lastEventId",
+  "receivedAt",
+  "sequence",
+  "serverTime",
+  "snapshotVersion",
+  "transportSequence",
+  "transportVersion",
+  "updatedAt"
+]);
+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 (isRecord(value)) {
+    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]) => compareJson(left, right)).map(([key, item]) => [key, canonicalizeJson(item)])
+  );
+}
+function compareJson(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : {};
+}
+function stringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function numberField(record, key = "min") {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+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 ch2 = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch2 + SHA256_K[index] + words[index] >>> 0;
+      const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const maj2 = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj2 >>> 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((value) => value.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function utf8Bytes(input) {
+  return Array.from(new TextEncoder().encode(input));
+}
+
 // src/runtime-internal/context/PluginStateContext.tsx
 import { Fragment as Fragment2, jsx as jsx4, jsxs } from "react/jsx-runtime";
 var PluginStateContext = createContext4(null);
+var GAMEPLAY_BROWSER_SCOPE_ID = "runtime";
+var BROWSER_PROJECTION_DIGEST_ATTRIBUTE = "data-dreamboard-projection-digest";
+function RuntimeSemanticProjectionMarker() {
+  const state = usePluginState((snapshot) => snapshot);
+  return /* @__PURE__ */ jsx4(SemanticProjectionMarker, { state });
+}
+function SemanticProjectionMarker({
+  state
+}) {
+  const digest = semanticProjectionDigestForState(state);
+  if (!digest) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx4(
+    "span",
+    {
+      "aria-hidden": "true",
+      style: { display: "none" },
+      ...{
+        [BROWSER_INTERACTION_ATTRIBUTES.protocol]: DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
+        [BROWSER_INTERACTION_ATTRIBUTES.surface]: GAMEPLAY_BROWSER_INTERACTION_SURFACE,
+        [BROWSER_INTERACTION_ATTRIBUTES.scope]: GAMEPLAY_BROWSER_SCOPE_ID,
+        [BROWSER_INTERACTION_ATTRIBUTES.role]: "projection",
+        [BROWSER_PROJECTION_DIGEST_ATTRIBUTE]: digest
+      }
+    }
+  );
+}
 function usePluginState(selector) {
   const runtime = useRuntimeContext();
   const subscribe = (onStoreChange) => {
@@ -2373,6 +2752,373 @@ function validationErrorFromUnknown(error, fallbackMessage = "Interaction submis
   return new ValidationError(errorCode, message);
 }
 
+// src/runtime-internal/utils/interaction-draft-digest.ts
+function interactionDraftDigestForValues(descriptor, values) {
+  if (descriptor.descriptorDigest === void 0 || descriptor.actorSeat === void 0 || descriptor.draftDigest === void 0) {
+    return void 0;
+  }
+  const defaults = defaultsForDescriptor(descriptor);
+  return draftDigest({
+    actorSeat: descriptor.actorSeat,
+    descriptorDigest: descriptor.descriptorDigest,
+    interactionId: descriptor.interactionId,
+    interactionKey: descriptor.interactionKey,
+    values: {
+      ...defaults,
+      ...toCanonicalJson2(values)
+    }
+  });
+}
+function draftDigest({
+  actorSeat,
+  descriptorDigest,
+  interactionId,
+  interactionKey,
+  values
+}) {
+  return hashJson2({
+    digestVersion: "interaction-draft@2",
+    actorSeat,
+    descriptorDigest,
+    emitted: false,
+    interactionId,
+    interactionKey,
+    values
+  });
+}
+function defaultsForDescriptor(descriptor) {
+  return Object.fromEntries(
+    descriptor.inputs.flatMap(
+      (input) => input.defaultValue === void 0 ? [] : [[input.key, toCanonicalJson2(input.defaultValue)]]
+    )
+  );
+}
+function toCanonicalJson2(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) => toCanonicalJson2(item));
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, toCanonicalJson2(item)])
+    );
+  }
+  return null;
+}
+function hashJson2(value) {
+  return `sha256:${sha256Hex2(canonicalJson2(value))}`;
+}
+function canonicalJson2(value) {
+  return JSON.stringify(canonicalizeJson2(value));
+}
+function canonicalizeJson2(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) => canonicalizeJson2(item));
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalizeJson2(item)])
+  );
+}
+function sha256Hex2(input) {
+  const bytes = utf8Bytes2(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 i = 0; i < 16; i += 1) {
+      words[i] = (bytes[offset + i * 4] ?? 0) << 24 | (bytes[offset + i * 4 + 1] ?? 0) << 16 | (bytes[offset + i * 4 + 2] ?? 0) << 8 | (bytes[offset + i * 4 + 3] ?? 0);
+    }
+    for (let i = 16; i < 64; i += 1) {
+      words[i] = smallSigma1(words[i - 2] ?? 0) + (words[i - 7] ?? 0) + smallSigma0(words[i - 15] ?? 0) + (words[i - 16] ?? 0) >>> 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 i = 0; i < 64; i += 1) {
+      const t1 = h + bigSigma1(e) + ch(e, f, g) + K[i] + (words[i] ?? 0) >>> 0;
+      const t2 = bigSigma0(a) + maj(a, b, c) >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 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 utf8Bytes2(input) {
+  return Array.from(new TextEncoder().encode(input));
+}
+function rightRotate(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function ch(x, y, z) {
+  return x & y ^ ~x & z;
+}
+function maj(x, y, z) {
+  return x & y ^ x & z ^ y & z;
+}
+function bigSigma0(x) {
+  return rightRotate(x, 2) ^ rightRotate(x, 13) ^ rightRotate(x, 22);
+}
+function bigSigma1(x) {
+  return rightRotate(x, 6) ^ rightRotate(x, 11) ^ rightRotate(x, 25);
+}
+function smallSigma0(x) {
+  return rightRotate(x, 7) ^ rightRotate(x, 18) ^ x >>> 3;
+}
+function smallSigma1(x) {
+  return rightRotate(x, 17) ^ rightRotate(x, 19) ^ x >>> 10;
+}
+var 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
+];
+
+// src/runtime-internal/utils/browser-interaction-effects.ts
+function gameplayCandidateMetadata(input) {
+  const inputDescriptor = resolvedInputByKey(
+    input.descriptor,
+    input.inputKey,
+    input.draftValues
+  );
+  if (!inputDescriptor) return { semanticEffects: [] };
+  const currentValue = input.draftValues[input.inputKey];
+  const beforeSelected = isCandidateSelected(
+    currentValue,
+    input.candidateValue,
+    inputDescriptor
+  );
+  const afterSelected = input.intent === "toggle" && isManySelection(inputDescriptor) ? !beforeSelected : true;
+  return {
+    semanticEffects: [
+      gameplaySetCandidateEffect({
+        inputKey: input.inputKey,
+        candidateValue: input.candidateValue,
+        beforeSelected,
+        afterSelected
+      })
+    ]
+  };
+}
+function gameplayResourceMetadata(input) {
+  return {
+    semanticEffects: [
+      gameplayAdjustResourceEffect({
+        inputKey: input.inputKey,
+        resourceKey: input.resourceKey,
+        delta: input.delta
+      })
+    ]
+  };
+}
+function gameplayScalarStepMetadata(input) {
+  return {
+    semanticEffects: [
+      gameplaySetScalarEffect({
+        inputKey: input.inputKey,
+        value: input.value
+      })
+    ]
+  };
+}
+function gameplayScalarFillMetadata(input) {
+  return {
+    acceptedEffectPatterns: [
+      boundedScalarPattern(input.inputKey, input.domain)
+    ]
+  };
+}
+function gameplaySubmitMetadata(input) {
+  const invoke = input.explicitParams === true || input.descriptor.commit.mode !== "manual";
+  return invoke ? { intent: "invoke", semanticEffects: [gameplayInvokeEffect()] } : { intent: "submit", semanticEffects: [gameplayCommitEffect()] };
+}
+function gameplayPreparationPatternsForDescriptor(descriptor, draftValues) {
+  const patterns = [];
+  for (const rawInput of descriptor.inputs) {
+    const input = resolveInputDomain(rawInput, draftValues);
+    switch (input.domain.type) {
+      case "choice":
+      case "choiceList":
+      case "cardTarget":
+      case "boardTarget":
+        patterns.push({
+          kind: "match",
+          effectKind: "setCandidate",
+          fields: { inputKey: input.key }
+        });
+        break;
+      case "resourceMap":
+        patterns.push({
+          kind: "match",
+          effectKind: "adjustResource",
+          fields: { inputKey: input.key }
+        });
+        break;
+      case "boundedNumber":
+        patterns.push(boundedScalarPattern(input.key, input.domain));
+        break;
+    }
+  }
+  return dedupePatterns(patterns);
+}
+function boundedScalarPattern(inputKey, domain) {
+  const min = domain.min ?? 0;
+  const max = domain.max;
+  return {
+    kind: "match",
+    effectKind: "setScalar",
+    fields: { inputKey },
+    scalar: {
+      field: "value",
+      min,
+      ...max !== void 0 && Number.isFinite(max) ? { max } : {},
+      ...scalarIsInteger(domain) ? { integer: true } : {}
+    }
+  };
+}
+function resolvedInputByKey(descriptor, inputKey, draftValues) {
+  const input = inputByKey(descriptor, inputKey);
+  return input ? resolveInputDomain(input, draftValues) : void 0;
+}
+function isCandidateSelected(currentValue, candidateValue, input) {
+  if (isTargetDomain(input.domain) && input.domain.selection?.mode === "many") {
+    return valueArrayIncludes(currentValue, candidateValue);
+  }
+  if (input.domain.type === "choiceList") {
+    return valueArrayIncludes(currentValue, candidateValue);
+  }
+  return String(currentValue) === String(candidateValue);
+}
+function isManySelection(input) {
+  if (input.domain.type === "choiceList") return true;
+  return isTargetDomain(input.domain) && input.domain.selection?.mode === "many";
+}
+function valueArrayIncludes(currentValue, candidateValue) {
+  return Array.isArray(currentValue) && currentValue.some((item) => String(item) === String(candidateValue));
+}
+function scalarIsInteger(domain) {
+  const step = domain.step ?? 1;
+  return Number.isInteger(step) && Number.isInteger(domain.min ?? 0) && (domain.max === void 0 || Number.isInteger(domain.max));
+}
+function dedupePatterns(patterns) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const pattern of patterns) {
+    const key = JSON.stringify(pattern);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(pattern);
+  }
+  return result;
+}
+
 // src/runtime-internal/hooks/useBoardInteractions.ts
 var BoardInteractionConflictError = class extends Error {
   name = "BoardInteractionConflictError";
@@ -2527,7 +3273,7 @@ function useBoardInteractions(options = {}) {
           return [];
         }
         if (!isInteractionAvailable(descriptor)) return [];
-        const draft = store.getDraft(descriptor.interactionKey);
+        const draft = drafts[descriptor.interactionKey] ?? {};
         const inputKey = inputKeyForTarget(
           descriptor,
           targetKind,
@@ -2536,11 +3282,7 @@ function useBoardInteractions(options = {}) {
         );
         if (!inputKey) return [];
         const input = inputByTarget(descriptor, targetKind, targetId, draft);
-        if (input && !isTargetSelectable(
-          input,
-          store.getDraft(descriptor.interactionKey),
-          targetId
-        )) {
+        if (input && !isTargetSelectable(input, draft, targetId)) {
           return [];
         }
         const targets = eligibleTargetsForInput(descriptor, inputKey, draft);
@@ -2555,7 +3297,7 @@ function useBoardInteractions(options = {}) {
       });
       return matches;
     },
-    [armedIds, interactions, store]
+    [armedIds, drafts, interactions]
   );
   const selectByKind = useCallback3(
     async (targetKind, targetId, extraInputs, interactionKeys) => {
@@ -2605,10 +3347,18 @@ function useBoardInteractions(options = {}) {
         pending,
         conflict,
         conflictInteractionKeys: conflict ? candidates.map((candidate) => candidate.descriptor.interactionKey) : void 0,
-        unavailableReason: candidateUnavailableReason(selected, conflict)
+        unavailableReason: candidateUnavailableReason(selected, conflict),
+        browserAttributes: selected ? boardTargetBrowserAttributes({
+          descriptor: selected.descriptor,
+          inputKey: selected.inputKey,
+          targetKind,
+          targetId,
+          enabled: eligible2 && !!controllingPlayerId,
+          draft: drafts[selected.descriptor.interactionKey] ?? {}
+        }) : void 0
       };
     },
-    [controllingPlayerId, pendingInteractionKey, resolveTargetMatches]
+    [controllingPlayerId, drafts, pendingInteractionKey, resolveTargetMatches]
   );
   const targetLayers = useMemo8(() => {
     const createLayer = (targetKind) => (layerOptions = {}) => {
@@ -2721,6 +3471,43 @@ function isTargetSelectable(input, draft, targetId) {
 function missingInputsForDraft(descriptor, draft) {
   return [...getInteractionDraftReadiness(descriptor, draft).missingInputs];
 }
+var GAMEPLAY_BROWSER_SCOPE_ID2 = "runtime";
+function boardTargetBrowserAttributes({
+  descriptor,
+  inputKey,
+  targetKind,
+  targetId,
+  enabled,
+  draft
+}) {
+  return createGameplayActuatorAttributes({
+    scopeId: GAMEPLAY_BROWSER_SCOPE_ID2,
+    interactionKey: descriptor.interactionKey,
+    interactionId: descriptor.interactionId,
+    intent: "select",
+    enabled,
+    actuatorKind: "click",
+    actuatorId: `board:${targetKind}:${targetId}`,
+    ...descriptor.descriptorDigest !== void 0 ? { descriptorDigest: descriptor.descriptorDigest } : {},
+    ...descriptor.draftDigest !== void 0 ? { draftDigest: interactionDraftDigestForValues(descriptor, draft) } : {},
+    inputKey,
+    candidateValue: targetId,
+    candidateState: isBoardTargetSelected(draft[inputKey], targetId) ? "selected" : "unselected",
+    semanticEffects: gameplayCandidateMetadata({
+      descriptor,
+      draftValues: draft,
+      inputKey,
+      candidateValue: targetId,
+      intent: "select"
+    }).semanticEffects
+  });
+}
+function isBoardTargetSelected(value, targetId) {
+  if (Array.isArray(value)) {
+    return value.some((item) => String(item) === targetId);
+  }
+  return value !== void 0 && String(value) === targetId;
+}
 function selectDispatchCandidate(matches, targetKind, targetId) {
   if (matches.length === 0) return null;
   const armed = matches.filter((match) => match.armed);
@@ -2882,6 +3669,7 @@ function UnambiguousBoardTarget({
   return renderPrimitive("button", {
     type: "button",
     ...props,
+    ...targetState.browserAttributes,
     children,
     disabled: isDisabled,
     "aria-disabled": isDisabled,
@@ -2929,9 +3717,18 @@ function ExplicitBoardTarget({
   const eligibleTargets = inputKey ? eligibleTargetsForInput(descriptor, inputKey, draft) : void 0;
   const eligible = inputDescriptor !== void 0 && inputDescriptor.domain.type === "boardTarget" && isResolvedTargetDomain(inputDescriptor.domain) && inputDescriptor.domain.targetKind === kind && (eligibleTargets ?? inputDescriptor.domain.eligibleTargets).includes(value);
   const isDisabled = disabled ?? (!isInteractionAvailable(descriptor) || !eligible);
+  const browserAttributes = inputKey ? boardTargetBrowserAttributes2({
+    descriptor,
+    inputKey,
+    targetKind: kind,
+    targetId: value,
+    enabled: !isDisabled,
+    draft
+  }) : void 0;
   return renderPrimitive("button", {
     type: "button",
     ...props,
+    ...browserAttributes,
     children,
     disabled: isDisabled,
     "aria-disabled": isDisabled,
@@ -2990,6 +3787,43 @@ function UnavailableBoardTarget({
 function resolveExtraInputs(extraInputs, targetId) {
   return typeof extraInputs === "function" ? extraInputs(targetId) : extraInputs ?? {};
 }
+var GAMEPLAY_BROWSER_SCOPE_ID3 = "runtime";
+function boardTargetBrowserAttributes2({
+  descriptor,
+  inputKey,
+  targetKind,
+  targetId,
+  enabled,
+  draft
+}) {
+  return createGameplayActuatorAttributes({
+    scopeId: GAMEPLAY_BROWSER_SCOPE_ID3,
+    interactionKey: descriptor.interactionKey,
+    interactionId: descriptor.interactionId,
+    intent: "select",
+    enabled,
+    actuatorKind: "click",
+    actuatorId: `board:${targetKind}:${targetId}`,
+    ...descriptor.descriptorDigest !== void 0 ? { descriptorDigest: descriptor.descriptorDigest } : {},
+    ...descriptor.draftDigest !== void 0 ? { draftDigest: interactionDraftDigestForValues(descriptor, draft) } : {},
+    inputKey,
+    candidateValue: targetId,
+    candidateState: isBoardTargetSelected2(draft[inputKey], targetId) ? "selected" : "unselected",
+    semanticEffects: gameplayCandidateMetadata({
+      descriptor,
+      draftValues: draft,
+      inputKey,
+      candidateValue: targetId,
+      intent: "select"
+    }).semanticEffects
+  });
+}
+function isBoardTargetSelected2(value, targetId) {
+  if (Array.isArray(value)) {
+    return value.some((item) => String(item) === targetId);
+  }
+  return value !== void 0 && String(value) === targetId;
+}
 var Board = {
   Root: BoardRoot,
   State: BoardState,
@@ -3285,6 +4119,64 @@ import {
 import * as AccordionPrimitive from "@radix-ui/react-accordion";
 import { Fragment as Fragment7, jsx as jsx11, jsxs as jsxs3 } from "react/jsx-runtime";
 var EMPTY_FIELD_ERRORS = [];
+var GAMEPLAY_BROWSER_SCOPE_ID4 = "runtime";
+function gameplayInteractionRootAttributes({
+  descriptor,
+  draftValues,
+  ready,
+  available
+}) {
+  return createGameplayInteractionRootAttributes({
+    scopeId: GAMEPLAY_BROWSER_SCOPE_ID4,
+    interactionKey: descriptor.interactionKey,
+    interactionId: descriptor.interactionId,
+    ...descriptor.descriptorDigest !== void 0 ? { descriptorDigest: descriptor.descriptorDigest } : {},
+    ...descriptor.draftDigest !== void 0 ? {
+      draftDigest: interactionDraftDigestForValues(
+        descriptor,
+        draftValues ?? {}
+      )
+    } : {},
+    readiness: available ? ready ? "ready" : "blocked" : "unavailable"
+  });
+}
+function gameplayActuatorAttributes({
+  descriptor,
+  inputKey,
+  intent,
+  candidateValue,
+  candidateState,
+  semanticEffects,
+  acceptedEffectPatterns,
+  preparationPatterns,
+  draftValues,
+  enabled,
+  actuatorKind,
+  actuatorId
+}) {
+  return createGameplayActuatorAttributes({
+    scopeId: GAMEPLAY_BROWSER_SCOPE_ID4,
+    interactionKey: descriptor.interactionKey,
+    interactionId: descriptor.interactionId,
+    intent,
+    enabled,
+    actuatorKind,
+    actuatorId,
+    ...descriptor.descriptorDigest !== void 0 ? { descriptorDigest: descriptor.descriptorDigest } : {},
+    ...descriptor.draftDigest !== void 0 ? {
+      draftDigest: interactionDraftDigestForValues(
+        descriptor,
+        draftValues ?? {}
+      )
+    } : {},
+    ...inputKey !== void 0 ? { inputKey } : {},
+    ...candidateValue !== void 0 ? { candidateValue } : {},
+    ...candidateState !== void 0 ? { candidateState } : {},
+    ...semanticEffects !== void 0 ? { semanticEffects } : {},
+    ...acceptedEffectPatterns !== void 0 ? { acceptedEffectPatterns } : {},
+    ...preparationPatterns !== void 0 ? { preparationPatterns } : {}
+  });
+}
 function InteractionForm({
   descriptor,
   handle,
@@ -3342,6 +4234,34 @@ function InteractionForm({
   ];
   const isDisabled = disabled || pending || !isInteractionAvailable(descriptor);
   const useAccordion = accordion && visibleInputs.length > 0;
+  const rootBrowserAttributes = gameplayInteractionRootAttributes({
+    descriptor,
+    draftValues: handle.values,
+    ready: handle.isReady,
+    available: !isDisabled
+  });
+  const armBrowserAttributes = gameplayActuatorAttributes({
+    descriptor,
+    draftValues: handle.values,
+    intent: "arm",
+    enabled: !isDisabled,
+    actuatorKind: "click",
+    actuatorId: "arm",
+    preparationPatterns: gameplayPreparationPatternsForDescriptor(
+      descriptor,
+      handle.values
+    )
+  });
+  const submitMetadata = gameplaySubmitMetadata({ descriptor });
+  const submitBrowserAttributes = gameplayActuatorAttributes({
+    descriptor,
+    draftValues: handle.values,
+    intent: submitMetadata.intent,
+    enabled: !isDisabled && handle.isReady,
+    actuatorKind: "click",
+    actuatorId: "submit",
+    semanticEffects: submitMetadata.semanticEffects
+  });
   useEffect6(() => {
     setAccordionOpen(defaultOpen);
   }, [defaultOpen, descriptor.interactionId]);
@@ -3489,6 +4409,7 @@ function InteractionForm({
                 size: "sm",
                 disabled: isDisabled,
                 className: "h-9 px-3 text-sm",
+                ...submitBrowserAttributes,
                 ...buttonProps,
                 children: pending ? "Submitting..." : children ?? submitLabel ?? fallbackLabel
               }
@@ -3503,6 +4424,7 @@ function InteractionForm({
             size: "sm",
             disabled: isDisabled,
             className: "h-9 px-3 text-sm",
+            ...submitBrowserAttributes,
             children: pending ? "Submitting..." : submitLabel ?? fallbackLabel
           }
         )
@@ -3521,6 +4443,7 @@ function InteractionForm({
       "data-interaction-id": descriptor.interactionId,
       onSubmit: (event) => void submit(event),
       style: containerStyle,
+      ...rootBrowserAttributes,
       children: useAccordion ? /* @__PURE__ */ jsx11(
         AccordionPrimitive.Root,
         {
@@ -3532,6 +4455,7 @@ function InteractionForm({
             /* @__PURE__ */ jsx11(AccordionPrimitive.Header, { style: { margin: 0 }, children: /* @__PURE__ */ jsxs3(
               AccordionPrimitive.Trigger,
               {
+                ...armBrowserAttributes,
                 style: {
                   alignItems: "center",
                   appearance: "none",
@@ -3613,6 +4537,24 @@ function createInteractionInputSlot({
     const selected = selection?.mode === "many" ? Array.isArray(currentValue) && currentValue.map(String).includes(targetValue) : currentValue !== void 0 && String(currentValue) === targetValue;
     const isDisabled = disabled || !eligible;
     const dataAttribute = kind === "card" ? { "data-dreamboard-interaction-card-slot": "" } : { "data-dreamboard-interaction-target-slot": "" };
+    const browserAttributes = gameplayActuatorAttributes({
+      descriptor,
+      draftValues: handle.values,
+      inputKey: input.key,
+      intent: selection?.mode === "many" ? "toggle" : "select",
+      candidateValue: targetValue,
+      candidateState: selected ? "selected" : "unselected",
+      enabled: !isDisabled,
+      actuatorKind: "click",
+      actuatorId: `${kind}:${input.key}:${targetValue}`,
+      semanticEffects: gameplayCandidateMetadata({
+        descriptor,
+        draftValues: handle.values,
+        inputKey: input.key,
+        candidateValue: targetValue,
+        intent: selection?.mode === "many" ? "toggle" : "select"
+      }).semanticEffects
+    });
     return /* @__PURE__ */ jsx11(
       "button",
       {
@@ -3627,6 +4569,7 @@ function createInteractionInputSlot({
         "data-selected": selected || void 0,
         "data-disabled": isDisabled || void 0,
         ...dataAttribute,
+        ...browserAttributes,
         ...buttonProps,
         onClick: () => {
           if (isDisabled) return;
@@ -3655,6 +4598,24 @@ function createInteractionInputSlot({
     Default: ({ children }) => {
       const hasDefault = "defaultValue" in input;
       const isDisabled = disabled || !hasDefault;
+      const browserAttributes = gameplayActuatorAttributes({
+        descriptor,
+        draftValues: handle.values,
+        inputKey: input.key,
+        intent: "select",
+        candidateValue: input.defaultValue,
+        candidateState: "unselected",
+        enabled: !isDisabled,
+        actuatorKind: "click",
+        actuatorId: `default:${input.key}`,
+        semanticEffects: hasDefault ? gameplayCandidateMetadata({
+          descriptor,
+          draftValues: handle.values,
+          inputKey: input.key,
+          candidateValue: input.defaultValue,
+          intent: "select"
+        }).semanticEffects : void 0
+      });
       return /* @__PURE__ */ jsx11(
         "button",
         {
@@ -3664,6 +4625,7 @@ function createInteractionInputSlot({
           "data-dreamboard-interaction-default-slot": "",
           "data-input-name": input.key,
           "data-disabled": isDisabled || void 0,
+          ...browserAttributes,
           onClick: () => {
             if (isDisabled) return;
             handle.setInput(input.key, input.defaultValue);
@@ -3893,6 +4855,8 @@ function decodeChoiceSelectValue(value) {
   return value === NULL_CHOICE_SELECT_VALUE ? null : value;
 }
 function ChoiceField({
+  descriptor,
+  handle,
   input,
   value,
   setValue,
@@ -3923,15 +4887,34 @@ function ChoiceField({
             },
             children: choices.map((choice) => {
               const selected = value === choice.value;
+              const isDisabled = disabled || choice.disabled;
               return /* @__PURE__ */ jsx11(
                 ThemedButton,
                 {
                   type: "button",
                   variant: selected ? "primary" : "secondary",
                   size: "sm",
-                  disabled: disabled || choice.disabled,
+                  disabled: isDisabled,
                   "aria-pressed": selected,
                   title: choice.disabledReason ?? choice.description,
+                  ...gameplayActuatorAttributes({
+                    descriptor,
+                    draftValues: handle.values,
+                    inputKey: input.key,
+                    intent: "select",
+                    candidateValue: choice.value,
+                    candidateState: selected ? "selected" : "unselected",
+                    enabled: !isDisabled,
+                    actuatorKind: "click",
+                    actuatorId: `choice:${input.key}:${choiceRenderKey(choice)}`,
+                    semanticEffects: gameplayCandidateMetadata({
+                      descriptor,
+                      draftValues: handle.values,
+                      inputKey: input.key,
+                      candidateValue: choice.value,
+                      intent: "select"
+                    }).semanticEffects
+                  }),
                   onClick: () => setValue(choice.value),
                   className: "h-8 px-3 text-sm",
                   children: /* @__PURE__ */ jsx11(ChoiceOptionLabel, { choice })
@@ -3959,7 +4942,28 @@ function ChoiceField({
             value: encodeChoiceSelectValue(value),
             onValueChange: (next) => setValue(decodeChoiceSelectValue(next)),
             children: [
-              /* @__PURE__ */ jsx11(SelectTrigger, { id: controlId, size: "sm", className: "w-full bg-white", children: /* @__PURE__ */ jsx11("span", { "data-slot": "select-value", children: selectedChoice ? /* @__PURE__ */ jsx11(ChoiceOptionLabel, { choice: selectedChoice }) : /* @__PURE__ */ jsx11("span", { style: { color: theme.semantic.text.muted }, children: "Choose..." }) }) }),
+              /* @__PURE__ */ jsx11(
+                SelectTrigger,
+                {
+                  id: controlId,
+                  size: "sm",
+                  className: "w-full bg-white",
+                  ...gameplayActuatorAttributes({
+                    descriptor,
+                    draftValues: handle.values,
+                    inputKey: input.key,
+                    intent: "reveal",
+                    enabled: !disabled,
+                    actuatorKind: "click",
+                    actuatorId: `choice-reveal:${input.key}`,
+                    preparationPatterns: gameplayPreparationPatternsForDescriptor(
+                      { inputs: [input] },
+                      handle.values
+                    )
+                  }),
+                  children: /* @__PURE__ */ jsx11("span", { "data-slot": "select-value", children: selectedChoice ? /* @__PURE__ */ jsx11(ChoiceOptionLabel, { choice: selectedChoice }) : /* @__PURE__ */ jsx11("span", { style: { color: theme.semantic.text.muted }, children: "Choose..." }) })
+                }
+              ),
               /* @__PURE__ */ jsx11(
                 SelectContent,
                 {
@@ -3973,6 +4977,24 @@ function ChoiceField({
                       value: choiceRenderKey(choice),
                       textValue: choice.label,
                       disabled: choice.disabled,
+                      ...gameplayActuatorAttributes({
+                        descriptor,
+                        draftValues: handle.values,
+                        inputKey: input.key,
+                        intent: "select",
+                        candidateValue: choice.value,
+                        candidateState: value === choice.value ? "selected" : "unselected",
+                        enabled: !disabled && !choice.disabled,
+                        actuatorKind: "click",
+                        actuatorId: `choice:${input.key}:${choiceRenderKey(choice)}`,
+                        semanticEffects: gameplayCandidateMetadata({
+                          descriptor,
+                          draftValues: handle.values,
+                          inputKey: input.key,
+                          candidateValue: choice.value,
+                          intent: "select"
+                        }).semanticEffects
+                      }),
                       children: /* @__PURE__ */ jsx11(ChoiceOptionLabel, { choice })
                     },
                     choiceRenderKey(choice)
@@ -3988,6 +5010,8 @@ function ChoiceField({
   );
 }
 function ChoiceListField({
+  descriptor,
+  handle,
   input,
   value,
   setValue,
@@ -4029,15 +5053,34 @@ function ChoiceListField({
       children: /* @__PURE__ */ jsx11("span", { style: { display: "flex", flexWrap: "wrap", gap: theme.space[1] }, children: (domain.choices ?? []).map((choice) => {
         const value2 = choice.value;
         const checked = selected.has(value2);
+        const isDisabled = disabled || choice.disabled || !checked && selected.size >= max;
         return /* @__PURE__ */ jsx11(
           ThemedButton,
           {
             type: "button",
             variant: checked ? "primary" : "secondary",
             size: "sm",
-            disabled: disabled || choice.disabled || !checked && selected.size >= max,
+            disabled: isDisabled,
             "aria-pressed": checked,
             title: choice.disabledReason ?? choice.description,
+            ...gameplayActuatorAttributes({
+              descriptor,
+              draftValues: handle.values,
+              inputKey: input.key,
+              intent: "toggle",
+              candidateValue: value2,
+              candidateState: checked ? "selected" : "unselected",
+              enabled: !isDisabled,
+              actuatorKind: "click",
+              actuatorId: `choice-list:${input.key}:${value2}`,
+              semanticEffects: gameplayCandidateMetadata({
+                descriptor,
+                draftValues: handle.values,
+                inputKey: input.key,
+                candidateValue: value2,
+                intent: "toggle"
+              }).semanticEffects
+            }),
             onClick: () => toggle(value2),
             className: "h-8 px-3 text-sm",
             children: /* @__PURE__ */ jsx11(ChoiceOptionLabel, { choice })
@@ -4049,6 +5092,8 @@ function ChoiceListField({
   );
 }
 function ResourceMapField({
+  descriptor,
+  handle,
   input,
   value,
   setValue,
@@ -4058,7 +5103,7 @@ function ResourceMapField({
   domain
 }) {
   const theme = useTheme();
-  const current = isRecord(value) ? value : {};
+  const current = isRecord2(value) ? value : {};
   const update = (resourceId, delta, min, max) => {
     const previous = numberOrZero(current[resourceId]);
     const next = Math.max(min, Math.min(max, previous + delta));
@@ -4109,6 +5154,21 @@ function ResourceMapField({
                 {
                   label: `Decrease ${resource.label ?? resource.resourceId}`,
                   disabled: disabled || amount <= min,
+                  browserAttributes: gameplayActuatorAttributes({
+                    descriptor,
+                    draftValues: handle.values,
+                    inputKey: input.key,
+                    intent: "decrement",
+                    candidateValue: resource.resourceId,
+                    enabled: !(disabled || amount <= min),
+                    actuatorKind: "click",
+                    actuatorId: `resource-decrement:${input.key}:${resource.resourceId}`,
+                    semanticEffects: gameplayResourceMetadata({
+                      inputKey: input.key,
+                      resourceKey: resource.resourceId,
+                      delta: -1
+                    }).semanticEffects
+                  }),
                   onClick: () => update(resource.resourceId, -1, min, max),
                   children: "-"
                 }
@@ -4129,6 +5189,21 @@ function ResourceMapField({
                 {
                   label: `Increase ${resource.label ?? resource.resourceId}`,
                   disabled: disabled || amount >= max,
+                  browserAttributes: gameplayActuatorAttributes({
+                    descriptor,
+                    draftValues: handle.values,
+                    inputKey: input.key,
+                    intent: "increment",
+                    candidateValue: resource.resourceId,
+                    enabled: !(disabled || amount >= max),
+                    actuatorKind: "click",
+                    actuatorId: `resource-increment:${input.key}:${resource.resourceId}`,
+                    semanticEffects: gameplayResourceMetadata({
+                      inputKey: input.key,
+                      resourceKey: resource.resourceId,
+                      delta: 1
+                    }).semanticEffects
+                  }),
                   onClick: () => update(resource.resourceId, 1, min, max),
                   children: "+"
                 }
@@ -4142,6 +5217,8 @@ function ResourceMapField({
   ) });
 }
 function BoundedNumberField({
+  descriptor,
+  handle,
   input,
   value,
   setValue,
@@ -4178,6 +5255,19 @@ function BoundedNumberField({
               {
                 label: `Decrease ${input.key}`,
                 disabled: disabled || current <= min,
+                browserAttributes: gameplayActuatorAttributes({
+                  descriptor,
+                  draftValues: handle.values,
+                  inputKey: input.key,
+                  intent: "decrement",
+                  enabled: !(disabled || current <= min),
+                  actuatorKind: "click",
+                  actuatorId: `bounded-decrement:${input.key}`,
+                  semanticEffects: gameplayScalarStepMetadata({
+                    inputKey: input.key,
+                    value: Math.max(min, Math.min(max, current - step))
+                  }).semanticEffects
+                }),
                 onClick: () => update(current - step),
                 children: "-"
               }
@@ -4192,6 +5282,19 @@ function BoundedNumberField({
                 step,
                 value: current,
                 disabled,
+                ...gameplayActuatorAttributes({
+                  descriptor,
+                  draftValues: handle.values,
+                  inputKey: input.key,
+                  intent: "fill",
+                  enabled: !disabled,
+                  actuatorKind: "fill",
+                  actuatorId: `bounded-fill:${input.key}`,
+                  acceptedEffectPatterns: gameplayScalarFillMetadata({
+                    inputKey: input.key,
+                    domain
+                  }).acceptedEffectPatterns
+                }),
                 onChange: (event) => update(Number(event.target.value)),
                 className: "h-9 w-[8ch] px-2 text-center text-sm md:text-sm"
               }
@@ -4201,6 +5304,19 @@ function BoundedNumberField({
               {
                 label: `Increase ${input.key}`,
                 disabled: disabled || current >= max,
+                browserAttributes: gameplayActuatorAttributes({
+                  descriptor,
+                  draftValues: handle.values,
+                  inputKey: input.key,
+                  intent: "increment",
+                  enabled: !(disabled || current >= max),
+                  actuatorKind: "click",
+                  actuatorId: `bounded-increment:${input.key}`,
+                  semanticEffects: gameplayScalarStepMetadata({
+                    inputKey: input.key,
+                    value: Math.max(min, Math.min(max, current + step))
+                  }).semanticEffects
+                }),
                 onClick: () => update(current + step),
                 children: "+"
               }
@@ -4234,6 +5350,7 @@ function targetSelectionLabel(domain) {
 function StepperButton({
   label,
   disabled,
+  browserAttributes,
   onClick,
   children
 }) {
@@ -4245,6 +5362,7 @@ function StepperButton({
       size: "sm",
       "aria-label": label,
       disabled,
+      ...browserAttributes,
       onClick,
       className: "h-8 w-8 text-sm",
       children
@@ -4263,7 +5381,7 @@ function labelForInput(input) {
 function humanize(key) {
   return key.replace(/Id$/, "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function numberOrZero(value) {
@@ -4341,6 +5459,38 @@ function humanizeInteraction(value) {
   const leaf = parts[parts.length - 1] ?? value;
   return leaf.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/^./, (first) => first.toUpperCase());
 }
+var GAMEPLAY_BROWSER_SCOPE_ID5 = "runtime";
+function gameplayActuatorAttributes2({
+  descriptor,
+  inputKey,
+  intent,
+  candidateValue,
+  candidateState,
+  semanticEffects,
+  acceptedEffectPatterns,
+  preparationPatterns,
+  enabled,
+  actuatorKind,
+  actuatorId
+}) {
+  return createGameplayActuatorAttributes({
+    scopeId: GAMEPLAY_BROWSER_SCOPE_ID5,
+    interactionKey: descriptor.interactionKey,
+    interactionId: descriptor.interactionId,
+    intent,
+    enabled,
+    actuatorKind,
+    actuatorId,
+    ...descriptor.descriptorDigest !== void 0 ? { descriptorDigest: descriptor.descriptorDigest } : {},
+    ...descriptor.draftDigest !== void 0 ? { draftDigest: descriptor.draftDigest } : {},
+    ...inputKey !== void 0 ? { inputKey } : {},
+    ...candidateValue !== void 0 ? { candidateValue } : {},
+    ...candidateState !== void 0 ? { candidateState } : {},
+    ...semanticEffects !== void 0 ? { semanticEffects } : {},
+    ...acceptedEffectPatterns !== void 0 ? { acceptedEffectPatterns } : {},
+    ...preparationPatterns !== void 0 ? { preparationPatterns } : {}
+  });
+}
 function useInteractionPrimitiveContext() {
   const value = useContext9(InteractionContext);
   if (!value) {
@@ -4378,7 +5528,20 @@ function ResolvedInteractionRoot({
     () => ({ interaction, descriptor, handle }),
     [descriptor, handle, interaction]
   );
-  return /* @__PURE__ */ jsx13(InteractionContext.Provider, { value, children });
+  const available = isInteractionAvailable(descriptor);
+  const rootAttributes = createGameplayInteractionRootAttributes({
+    scopeId: GAMEPLAY_BROWSER_SCOPE_ID5,
+    interactionKey: descriptor.interactionKey,
+    interactionId: descriptor.interactionId,
+    ...descriptor.descriptorDigest !== void 0 ? { descriptorDigest: descriptor.descriptorDigest } : {},
+    ...descriptor.draftDigest !== void 0 ? { draftDigest: descriptor.draftDigest } : {},
+    readiness: available ? handle.isReady ? "ready" : "blocked" : "unavailable"
+  });
+  return /* @__PURE__ */ jsx13(InteractionContext.Provider, { value, children: renderPrimitive("span", {
+    ...rootAttributes,
+    style: { display: "contents" },
+    children
+  }) });
 }
 function InteractionRoot({
   interaction,
@@ -4554,6 +5717,17 @@ function InteractionTrigger({
   return renderPrimitive("button", {
     type: "button",
     ...props,
+    ...descriptor ? gameplayActuatorAttributes2({
+      descriptor,
+      intent: "arm",
+      enabled: !isDisabled,
+      actuatorKind: "click",
+      actuatorId: "primitive-trigger",
+      preparationPatterns: gameplayPreparationPatternsForDescriptor(
+        descriptor,
+        handle?.values ?? {}
+      )
+    }) : {},
     disabled: isDisabled,
     "aria-disabled": isDisabled,
     "data-dreamboard-interaction-trigger": "",
@@ -4633,11 +5807,20 @@ function InteractionSubmit({
   const gameActionError = useGameActionError();
   const isSubmitting = handle?.status === "submitting";
   const hasExplicitParams = params !== void 0;
+  const submitMetadata = descriptor ? gameplaySubmitMetadata({ descriptor, explicitParams: hasExplicitParams }) : null;
   const available = isInteractionAvailable(descriptor);
   const isDisabled = disabled === true || !available || !hasExplicitParams && !handle?.isReady || isSubmitting;
   return renderPrimitive("button", {
     type: "button",
     ...props,
+    ...descriptor ? gameplayActuatorAttributes2({
+      descriptor,
+      intent: submitMetadata?.intent ?? "submit",
+      enabled: !isDisabled,
+      actuatorKind: "click",
+      actuatorId: "primitive-submit",
+      semanticEffects: submitMetadata?.semanticEffects
+    }) : {},
     disabled: isDisabled,
     "aria-disabled": isDisabled,
     "data-dreamboard-interaction-submit": "",
@@ -4677,9 +5860,27 @@ function InteractionInput({
   const { descriptor, handle } = useInteractionPrimitiveContext();
   const value = handle?.draft[name];
   const isDisabled = disabled === true || !isInteractionAvailable(descriptor);
+  const inputDescriptor = descriptor ? inputByKey(descriptor, name) : void 0;
+  const resolvedInputDescriptor = inputDescriptor && handle ? resolveInputDomain(
+    inputDescriptor,
+    handle.values
+  ) : void 0;
+  const scalarFillMetadata = resolvedInputDescriptor?.domain.type === "boundedNumber" ? gameplayScalarFillMetadata({
+    inputKey: name,
+    domain: resolvedInputDescriptor.domain
+  }) : void 0;
   return renderPrimitive("input", {
     ...props,
     name,
+    ...descriptor ? gameplayActuatorAttributes2({
+      descriptor,
+      inputKey: name,
+      intent: "fill",
+      enabled: !isDisabled,
+      actuatorKind: "fill",
+      actuatorId: `primitive-input:${name}`,
+      acceptedEffectPatterns: scalarFillMetadata?.acceptedEffectPatterns
+    }) : {},
     disabled: isDisabled,
     "aria-disabled": isDisabled,
     "data-dreamboard-interaction-input": "",
@@ -4802,6 +6003,23 @@ function InteractionCardInput({
     type: "button",
     ...props,
     children: renderedChildren,
+    ...descriptor ? gameplayActuatorAttributes2({
+      descriptor,
+      inputKey: input,
+      intent: selection?.mode === "many" ? "toggle" : "select",
+      candidateValue: cardId,
+      candidateState: isSelected ? "selected" : "unselected",
+      enabled: !isDisabled,
+      actuatorKind: "click",
+      actuatorId: `primitive-card:${input}:${cardId ?? "missing"}`,
+      semanticEffects: cardId !== void 0 ? gameplayCandidateMetadata({
+        descriptor,
+        draftValues: liveDraft,
+        inputKey: input,
+        candidateValue: cardId,
+        intent: selection?.mode === "many" ? "toggle" : "select"
+      }).semanticEffects : void 0
+    }) : {},
     disabled: isDisabled,
     "aria-disabled": isDisabled,
     "aria-pressed": isSelected,
@@ -5309,6 +6527,7 @@ export {
   UI,
   usePluginSession,
   RuntimeProvider,
+  RuntimeSemanticProjectionMarker,
   usePluginState,
   InteractionUiProvider,
   isInteractionAvailable,
@@ -5398,4 +6617,4 @@ export {
   DiceValues,
   Dice
 };
-//# sourceMappingURL=chunk-TDSWKVZ4.js.map
+//# sourceMappingURL=chunk-ZABVH7AO.js.map