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

package/dist/{chunk-QLG6VEMW.js → chunk-WUIVY2KE.js}

@@ -1,6 +1,13 @@
+import {
+  BROWSER_ATTRIBUTE_JSON_LIMITS,
+  RuntimeJsonSchema,
+  assertJsonWithinLimits,
+  parseBrowserAttributeJson
+} from "./chunk-PF7L4BMG.js";
+
 // src/browser-interaction/constants.ts
 var DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_NAME = "dreamboard-browser-interaction";
-var DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION = "2.0.0";
+var DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION = "3.0.0";
 var BROWSER_INTERACTION_ATTRIBUTES = {
   protocol: "data-dreamboard-browser-protocol",
   surface: "data-dreamboard-browser-surface",
@@ -18,6 +25,8 @@ var BROWSER_INTERACTION_ATTRIBUTES = {
   actuatorKind: "data-dreamboard-actuator-kind",
   enabled: "data-dreamboard-actuator-enabled",
   actuatorId: "data-dreamboard-actuator-id",
+  pointerTargetId: "data-dreamboard-pointer-target-id",
+  pointerTargetEnabled: "data-dreamboard-pointer-target-enabled",
   semanticEffects: "data-dreamboard-semantic-effects",
   acceptedEffectPatterns: "data-dreamboard-accepted-effect-patterns",
   preparationPatterns: "data-dreamboard-preparation-patterns",
@@ -29,7 +38,8 @@ var BROWSER_INTERACTION_ATTRIBUTES = {
 };
 var BROWSER_INTERACTION_RECORD_ROLES = [
   "interaction",
-  "actuator"
+  "actuator",
+  "pointer-target"
 ];
 var GAMEPLAY_BROWSER_INTERACTION_SURFACE = "gameplay";
 var GAMEPLAY_BROWSER_INTERACTION_INTENTS = [
@@ -110,11 +120,13 @@ function canonicalizeValue(value) {
   return value;
 }
 function encodeCanonicalCandidateValue(value) {
+  parseBrowserAttributeJson(value);
   assertCanonicalValue(value);
   return JSON.stringify(canonicalizeValue(value));
 }
 function decodeCanonicalCandidateValue(encoded) {
   const parsed = JSON.parse(encoded);
+  parseBrowserAttributeJson(parsed);
   assertCanonicalValue(parsed);
   return canonicalizeValue(parsed);
 }
@@ -308,6 +320,23 @@ function createBrowserInteractionActuatorAttributes(input) {
   }
   return attrs;
 }
+function createBrowserInteractionPointerTargetAttributes(input) {
+  const attrs = {
+    ...baseGameplayAttributes(input),
+    [BROWSER_INTERACTION_ATTRIBUTES.role]: "pointer-target",
+    [BROWSER_INTERACTION_ATTRIBUTES.pointerTargetId]: input.targetId,
+    [BROWSER_INTERACTION_ATTRIBUTES.pointerTargetEnabled]: input.enabled === false ? "false" : "true"
+  };
+  if (input.descriptorDigest) {
+    attrs[BROWSER_INTERACTION_ATTRIBUTES.descriptorDigest] = input.descriptorDigest;
+  }
+  if (input.acceptedEffectPatterns.length > 0) {
+    attrs[BROWSER_INTERACTION_ATTRIBUTES.acceptedEffectPatterns] = JSON.stringify(
+      input.acceptedEffectPatterns.map(encodeBrowserInteractionEffectPattern)
+    );
+  }
+  return attrs;
+}
 function createGameplayInteractionRootAttributes(input) {
   return createBrowserInteractionRootAttributes({
     ...input,
@@ -320,6 +349,12 @@ function createGameplayActuatorAttributes(input) {
     surface: GAMEPLAY_BROWSER_INTERACTION_SURFACE
   });
 }
+function createGameplayPointerTargetAttributes(input) {
+  return createBrowserInteractionPointerTargetAttributes({
+    ...input,
+    surface: GAMEPLAY_BROWSER_INTERACTION_SURFACE
+  });
+}
 function createBrowserInteractionActuatorKey(input) {
   return [
     input.surface,
@@ -428,7 +463,7 @@ function normalizeBrowserInteractionRecords(records, options = {}) {
       );
       continue;
     }
-    if (!surface || !scopeId || role !== "interaction" && role !== "actuator") {
+    if (!surface || !scopeId || role !== "interaction" && role !== "actuator" && role !== "pointer-target") {
       diagnostics.push(
         diagnosticFor({
           code: "invalid-record",
@@ -484,6 +519,38 @@ function normalizeBrowserInteractionRecords(records, options = {}) {
       );
       continue;
     }
+    if (role === "pointer-target") {
+      const pointerTarget = parseGameplayPointerTarget(attributes, {
+        surface,
+        scopeId,
+        interactionKey,
+        interactionId
+      });
+      if (pointerTarget.diagnostics.length > 0) {
+        interaction.diagnostics.push(...pointerTarget.diagnostics);
+        diagnostics.push(...pointerTarget.diagnostics);
+      }
+      const registered2 = registry.surfaces.get(surface);
+      if (registered2?.effectKinds) {
+        for (const pattern of pointerTarget.acceptedEffectPatterns) {
+          const effectKind = pattern.kind === "exact" ? pattern.effect.kind : pattern.effectKind;
+          if (!registered2.effectKinds.includes(effectKind)) {
+            const diagnostic = diagnosticFor({
+              code: "unknown-surface-effect",
+              message: `Unknown browser interaction effect '${effectKind}' for surface '${surface}'.`,
+              surface,
+              scopeId,
+              interactionKey,
+              targetId: pointerTarget.targetId
+            });
+            interaction.diagnostics.push(diagnostic);
+            diagnostics.push(diagnostic);
+          }
+        }
+      }
+      interaction.pointerTargets.push(pointerTarget);
+      continue;
+    }
     const actuator = parseGameplayActuator(attributes, {
       surface,
       scopeId,
@@ -549,10 +616,12 @@ function normalizeBrowserInteractionRecords(records, options = {}) {
   for (const surface of surfaces.values()) {
     if (surface.kind !== "semantic") continue;
     for (const interaction of surface.interactions.values()) {
-      if (interaction.rootSeen || interaction.actuators.length === 0) continue;
+      if (interaction.rootSeen || interaction.actuators.length === 0 && interaction.pointerTargets.length === 0) {
+        continue;
+      }
       const diagnostic = diagnosticFor({
         code: "orphan-actuator",
-        message: "Browser interaction actuators require a rendered semantic root.",
+        message: "Browser interaction actuators and pointer targets require a rendered semantic root.",
         surface: surface.surface,
         scopeId: surface.scopeId,
         interactionKey: interaction.interactionKey
@@ -583,6 +652,7 @@ function validateBrowserInteractionSnapshot(snapshot) {
     if (!isSemanticSurfaceSnapshot(surface)) continue;
     for (const interaction of surface.interactions) {
       const enabledByKey = /* @__PURE__ */ new Map();
+      const enabledTargetsByKey = /* @__PURE__ */ new Map();
       for (const actuator of interaction.actuators) {
         if (!actuator.enabled) continue;
         const key = actuatorIdentityKey({
@@ -595,6 +665,18 @@ function validateBrowserInteractionSnapshot(snapshot) {
         group.push(actuator);
         enabledByKey.set(key, group);
       }
+      for (const pointerTarget of interaction.pointerTargets) {
+        if (!pointerTarget.enabled) continue;
+        const key = pointerTargetIdentityKey({
+          surface: surface.surface,
+          scopeId: surface.scopeId,
+          interactionKey: interaction.interactionKey,
+          pointerTarget
+        });
+        const group = enabledTargetsByKey.get(key) ?? [];
+        group.push(pointerTarget);
+        enabledTargetsByKey.set(key, group);
+      }
       for (const [key, actuators] of enabledByKey) {
         if (actuators.length > 1) {
           diagnostics.push(
@@ -610,6 +692,20 @@ function validateBrowserInteractionSnapshot(snapshot) {
           );
         }
       }
+      for (const [key, pointerTargets] of enabledTargetsByKey) {
+        if (pointerTargets.length > 1) {
+          diagnostics.push(
+            diagnosticFor({
+              code: "duplicate-enabled-pointer-target",
+              message: `Duplicate enabled pointer target for '${key}'.`,
+              surface: surface.surface,
+              scopeId: surface.scopeId,
+              interactionKey: interaction.interactionKey,
+              targetId: pointerTargets[0]?.targetId
+            })
+          );
+        }
+      }
       diagnostics.push(
         ...diagnosticsForPreparationCycles(surface, interaction),
         ...diagnosticsForPreparationPatternAmbiguity(surface, interaction),
@@ -622,8 +718,21 @@ function validateBrowserInteractionSnapshot(snapshot) {
 }
 function diagnosticsForInvalidAcceptedPatterns(surface, interaction) {
   const diagnostics = [];
-  for (const actuator of interaction.actuators) {
-    for (const pattern of actuator.acceptedEffectPatterns) {
+  for (const record of [
+    ...interaction.actuators.map((actuator) => ({
+      patterns: actuator.acceptedEffectPatterns,
+      intent: actuator.intent,
+      actuatorId: actuator.actuatorId,
+      targetId: void 0
+    })),
+    ...interaction.pointerTargets.map((pointerTarget) => ({
+      patterns: pointerTarget.acceptedEffectPatterns,
+      intent: void 0,
+      actuatorId: void 0,
+      targetId: pointerTarget.targetId
+    }))
+  ]) {
+    for (const pattern of record.patterns) {
       if (pattern.kind === "match" && Object.keys(pattern.fields ?? {}).length === 0 && pattern.scalar === void 0) {
         diagnostics.push(
           diagnosticFor({
@@ -632,8 +741,9 @@ function diagnosticsForInvalidAcceptedPatterns(surface, interaction) {
             surface: surface.surface,
             scopeId: surface.scopeId,
             interactionKey: interaction.interactionKey,
-            intent: actuator.intent,
-            actuatorId: actuator.actuatorId
+            intent: record.intent,
+            actuatorId: record.actuatorId,
+            targetId: record.targetId
           })
         );
       }
@@ -795,6 +905,42 @@ function parseGameplayActuator(attributes, context) {
     diagnostics: diagnostics.sort(compareDiagnostic)
   };
 }
+function parseGameplayPointerTarget(attributes, context) {
+  const diagnostics = [];
+  const targetId = text(
+    attributes,
+    BROWSER_INTERACTION_ATTRIBUTES.pointerTargetId
+  );
+  const enabled = parseEnabled(
+    attributes[BROWSER_INTERACTION_ATTRIBUTES.pointerTargetEnabled]
+  );
+  const acceptedEffectPatterns = parseEffectPatternList(
+    attributes,
+    BROWSER_INTERACTION_ATTRIBUTES.acceptedEffectPatterns,
+    context,
+    "pointer-target",
+    diagnostics
+  );
+  if (!targetId) {
+    diagnostics.push(
+      diagnosticFor({
+        code: "invalid-record",
+        message: "Browser interaction pointer target records require a target id.",
+        ...context
+      })
+    );
+  }
+  return {
+    targetId,
+    descriptorDigest: optionalText(
+      attributes,
+      BROWSER_INTERACTION_ATTRIBUTES.descriptorDigest
+    ),
+    enabled,
+    acceptedEffectPatterns,
+    diagnostics: diagnostics.sort(compareDiagnostic)
+  };
+}
 function parseEffectList(attributes, attribute, context, intent, diagnostics) {
   const encodedList = optionalText(attributes, attribute);
   if (encodedList === void 0) return [];
@@ -875,6 +1021,7 @@ function getInteraction(surface, interactionKey, interactionId) {
     readiness: "ready",
     rootSeen: false,
     actuators: [],
+    pointerTargets: [],
     diagnostics: []
   };
   surface.interactions.set(interactionKey, next);
@@ -897,6 +1044,7 @@ function finalizeSurface(surface) {
     draftDigest: interaction.draftDigest,
     readiness: interaction.readiness,
     actuators: interaction.actuators.sort(compareActuator),
+    pointerTargets: interaction.pointerTargets.sort(comparePointerTarget),
     diagnostics: interaction.diagnostics.sort(compareDiagnostic)
   })).sort((a, b) => a.interactionKey.localeCompare(b.interactionKey));
   return {
@@ -1038,6 +1186,14 @@ function actuatorIdentityKey(input) {
     actuatorKind: input.actuator.actuatorKind
   });
 }
+function pointerTargetIdentityKey(input) {
+  return [
+    input.surface,
+    input.scopeId,
+    input.interactionKey,
+    input.pointerTarget.targetId
+  ].map((part) => encodeURIComponent(part)).join("|");
+}
 function isSemanticSurfaceSnapshot(surface) {
   return "interactions" in surface;
 }
@@ -1096,6 +1252,9 @@ function compareSurface(a, b) {
 function compareActuator(a, b) {
   return a.actuatorId.localeCompare(b.actuatorId);
 }
+function comparePointerTarget(a, b) {
+  return a.targetId.localeCompare(b.targetId);
+}
 function compareDiagnostic(a, b) {
   return a.code.localeCompare(b.code) || (a.surface ?? "").localeCompare(b.surface ?? "") || (a.scopeId ?? "").localeCompare(b.scopeId ?? "") || (a.interactionKey ?? "").localeCompare(b.interactionKey ?? "") || (a.intent ?? "").localeCompare(b.intent ?? "") || (a.actuatorId ?? "").localeCompare(b.actuatorId ?? "") || a.message.localeCompare(b.message);
 }
@@ -1314,6 +1473,93 @@ function resolveBrowserInteractionEffect(snapshot, request) {
     ]
   };
 }
+function resolveBrowserPointerTarget(snapshot, request) {
+  const snapshotDiagnostics = [
+    ...snapshot.diagnostics,
+    ...validateBrowserInteractionSnapshot(snapshot)
+  ];
+  if (snapshotDiagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return {
+      ok: false,
+      code: "invalid-snapshot",
+      diagnostics: snapshotDiagnostics
+    };
+  }
+  const effectDiagnostics = validateEffectRequest(request.effect, request);
+  if (effectDiagnostics.length > 0) {
+    return {
+      ok: false,
+      code: "invalid-effect",
+      diagnostics: effectDiagnostics
+    };
+  }
+  const surfaces = matchingSurfaces(snapshot, request);
+  const matches = collectPointerTargetMatches(surfaces, request).filter(
+    (match) => match.pointerTarget.acceptedEffectPatterns.some(
+      (pattern) => browserInteractionEffectPatternMatches(pattern, request.effect)
+    )
+  );
+  const enabledMatches = matches.filter((match) => match.pointerTarget.enabled);
+  const actionableMatches = request.allowDisabled === true ? matches : enabledMatches;
+  if (actionableMatches.length === 1) {
+    const match = actionableMatches[0];
+    if (!match) throw new Error("unreachable browser pointer target match");
+    return {
+      ok: true,
+      pointerTarget: match.pointerTarget,
+      surface: match.surface.surface,
+      scopeId: match.surface.scopeId,
+      interactionKey: match.interaction.interactionKey,
+      match: "accepted-pattern",
+      effect: request.effect,
+      diagnostics: []
+    };
+  }
+  if (actionableMatches.length > 1) {
+    return {
+      ok: false,
+      code: "ambiguous",
+      diagnostics: actionableMatches.map(
+        (match) => diagnosticFor2({
+          code: "ambiguous-pointer-target",
+          message: "Browser interaction effect matched multiple pointer targets.",
+          surface: match.surface.surface,
+          scopeId: match.surface.scopeId,
+          interactionKey: match.interaction.interactionKey,
+          targetId: match.pointerTarget.targetId
+        })
+      )
+    };
+  }
+  if (matches.length > 0 && enabledMatches.length === 0) {
+    return {
+      ok: false,
+      code: "unavailable",
+      diagnostics: [
+        diagnosticFor2({
+          code: "disabled-pointer-target",
+          message: "Browser interaction pointer target exists but is not enabled.",
+          surface: request.surface,
+          scopeId: request.scopeId,
+          interactionKey: request.interactionKey
+        })
+      ]
+    };
+  }
+  return {
+    ok: false,
+    code: "not-found",
+    diagnostics: [
+      diagnosticFor2({
+        code: "missing-effect",
+        message: "Browser interaction effect is not accepted by any pointer target.",
+        surface: request.surface,
+        scopeId: request.scopeId,
+        interactionKey: request.interactionKey
+      })
+    ]
+  };
+}
 function actuatorMatchesRequest(actuator, request, candidateValueKey) {
   return actuator.intent === request.intent && (request.inputKey === void 0 || actuator.inputKey === request.inputKey) && (candidateValueKey === void 0 || actuator.candidateValueKey === candidateValueKey) && (request.actuatorKind === void 0 || actuator.actuatorKind === request.actuatorKind);
 }
@@ -1401,6 +1647,23 @@ function collectInteractionMatches(surfaces, request) {
     })
   );
 }
+function collectPointerTargetMatches(surfaces, request) {
+  return surfaces.flatMap(
+    (surface) => surface.interactions.flatMap((interaction) => {
+      if (request.interactionKey !== void 0 && interaction.interactionKey !== request.interactionKey) {
+        return [];
+      }
+      if (request.interactionId !== void 0 && interaction.interactionId !== request.interactionId) {
+        return [];
+      }
+      return interaction.pointerTargets.map((pointerTarget) => ({
+        surface,
+        interaction,
+        pointerTarget
+      }));
+    })
+  );
+}
 function effectSuccess(match, effect, kind) {
   return {
     ok: true,
@@ -1507,18 +1770,37 @@ function diagnosticFor2(input) {
   return { severity: "error", ...input };
 }
 
+// src/browser-interaction/dom.ts
+function readBrowserInteractionSnapshot(root) {
+  const protocol = BROWSER_INTERACTION_ATTRIBUTES.protocol;
+  const role = BROWSER_INTERACTION_ATTRIBUTES.role;
+  const selector = [
+    `[${protocol}="${DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION}"][${role}="interaction"]`,
+    `[${protocol}="${DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION}"][${role}="actuator"]`,
+    `[${protocol}="${DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION}"][${role}="pointer-target"]`
+  ].join(",");
+  const records = [...root.querySelectorAll(selector)].map((element) => ({
+    attributes: Object.fromEntries(
+      [...element.attributes].map((attribute) => [
+        attribute.name,
+        attribute.value
+      ])
+    )
+  }));
+  return normalizeBrowserInteractionRecords(records);
+}
+
 // src/browser-interaction/schemas.ts
 import { z } from "zod";
-var jsonValueSchema = z.lazy(
-  () => z.union([
-    z.null(),
-    z.boolean(),
-    z.number().finite(),
-    z.string(),
-    z.array(jsonValueSchema),
-    z.record(z.string(), jsonValueSchema)
-  ])
-);
+var jsonValueSchema = z.preprocess((value) => {
+  if (value === void 0) return value;
+  assertJsonWithinLimits(
+    value,
+    BROWSER_ATTRIBUTE_JSON_LIMITS,
+    "Browser interaction attribute"
+  );
+  return value;
+}, RuntimeJsonSchema);
 var browserInteractionEffectSchema = z.object({
   kind: z.string().min(1)
 }).catchall(jsonValueSchema);
@@ -1573,7 +1855,8 @@ var browserInteractionDiagnosticSchema = z.object({
   scopeId: z.string().optional(),
   interactionKey: z.string().optional(),
   intent: z.string().optional(),
-  actuatorId: z.string().optional()
+  actuatorId: z.string().optional(),
+  targetId: z.string().optional()
 });
 var browserInteractionActuatorSchema = z.object({
   actuatorId: z.string(),
@@ -1596,6 +1879,13 @@ var browserInteractionActuatorSchema = z.object({
   }).optional(),
   diagnostics: z.array(browserInteractionDiagnosticSchema)
 });
+var browserInteractionPointerTargetSchema = z.object({
+  targetId: z.string(),
+  enabled: z.boolean(),
+  acceptedEffectPatterns: z.array(browserInteractionEffectPatternSchema),
+  descriptorDigest: z.string().optional(),
+  diagnostics: z.array(browserInteractionDiagnosticSchema)
+});
 var browserGameplayInteractionSchema = z.object({
   interactionKey: z.string(),
   interactionId: z.string(),
@@ -1603,6 +1893,7 @@ var browserGameplayInteractionSchema = z.object({
   draftDigest: z.string().optional(),
   readiness: z.enum(BROWSER_INTERACTION_READINESS_VALUES),
   actuators: z.array(browserInteractionActuatorSchema),
+  pointerTargets: z.array(browserInteractionPointerTargetSchema),
   diagnostics: z.array(browserInteractionDiagnosticSchema)
 });
 var browserGameplaySurfaceSnapshotSchema = z.object({
@@ -1663,8 +1954,10 @@ export {
   gameplayInvokeEffect,
   createBrowserInteractionRootAttributes,
   createBrowserInteractionActuatorAttributes,
+  createBrowserInteractionPointerTargetAttributes,
   createGameplayInteractionRootAttributes,
   createGameplayActuatorAttributes,
+  createGameplayPointerTargetAttributes,
   createBrowserInteractionActuatorKey,
   defineBrowserInteractionSurface,
   gameplayBrowserInteractionSurface,
@@ -1673,19 +1966,23 @@ export {
   normalizeBrowserInteractionRecords,
   validateBrowserInteractionSnapshot,
   actuatorIdentityKey,
+  pointerTargetIdentityKey,
   isSemanticSurfaceSnapshot,
   targetIdentityKey,
   resolveBrowserInteractionIntent,
   resolveBrowserInteractionEffect,
+  resolveBrowserPointerTarget,
+  readBrowserInteractionSnapshot,
   browserInteractionEffectSchema,
   browserInteractionEffectPatternSchema,
   gameplaySemanticEffectSchema,
   browserInteractionDiagnosticSchema,
   browserInteractionActuatorSchema,
+  browserInteractionPointerTargetSchema,
   browserGameplayInteractionSchema,
   browserGameplaySurfaceSnapshotSchema,
   browserSemanticSurfaceSnapshotSchema,
   browserUnknownSurfaceSnapshotSchema,
   browserInteractionSnapshotSchema
 };
-//# sourceMappingURL=chunk-QLG6VEMW.js.map
+//# sourceMappingURL=chunk-WUIVY2KE.js.map