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

package/src/runtime-internal/utils/browser-interaction-effects.ts

@@ -0,0 +1,240 @@
+import {
+  gameplayAdjustResourceEffect,
+  gameplayCommitEffect,
+  gameplayInvokeEffect,
+  gameplaySetCandidateEffect,
+  gameplaySetScalarEffect,
+  type CanonicalBrowserInteractionValue,
+  type GameplayBrowserInteractionIntent,
+  type GameplaySemanticEffect,
+  type GameplaySemanticEffectPattern,
+} from "../../browser-interaction/index.js";
+import type {
+  InteractionDescriptor,
+  InteractionInputDescriptor,
+  InputDomain,
+} from "../types/plugin-state.js";
+import {
+  inputByKey,
+  isTargetDomain,
+  resolveInputDomain,
+} from "./interaction-inputs.js";
+
+export function gameplayCandidateMetadata(input: {
+  readonly descriptor: Pick<InteractionDescriptor, "inputs">;
+  readonly draftValues: Readonly<Record<string, unknown>>;
+  readonly inputKey: string;
+  readonly candidateValue: unknown;
+  readonly intent: Extract<
+    GameplayBrowserInteractionIntent,
+    "select" | "toggle"
+  >;
+}): {
+  readonly semanticEffects: readonly GameplaySemanticEffect[];
+} {
+  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 as CanonicalBrowserInteractionValue,
+        beforeSelected,
+        afterSelected,
+      }),
+    ],
+  };
+}
+
+export function gameplayResourceMetadata(input: {
+  readonly inputKey: string;
+  readonly resourceKey: unknown;
+  readonly delta: -1 | 1;
+}): {
+  readonly semanticEffects: readonly GameplaySemanticEffect[];
+} {
+  return {
+    semanticEffects: [
+      gameplayAdjustResourceEffect({
+        inputKey: input.inputKey,
+        resourceKey: input.resourceKey as CanonicalBrowserInteractionValue,
+        delta: input.delta,
+      }),
+    ],
+  };
+}
+
+export function gameplayScalarStepMetadata(input: {
+  readonly inputKey: string;
+  readonly value: number;
+}): {
+  readonly semanticEffects: readonly GameplaySemanticEffect[];
+} {
+  return {
+    semanticEffects: [
+      gameplaySetScalarEffect({
+        inputKey: input.inputKey,
+        value: input.value,
+      }),
+    ],
+  };
+}
+
+export function gameplayScalarFillMetadata(input: {
+  readonly inputKey: string;
+  readonly domain: Extract<InputDomain, { type: "boundedNumber" }>;
+}): {
+  readonly acceptedEffectPatterns: readonly GameplaySemanticEffectPattern[];
+} {
+  return {
+    acceptedEffectPatterns: [
+      boundedScalarPattern(input.inputKey, input.domain),
+    ],
+  };
+}
+
+export function gameplaySubmitMetadata(input: {
+  readonly descriptor: Pick<InteractionDescriptor, "commit">;
+  readonly explicitParams?: boolean;
+}): {
+  readonly intent: Extract<
+    GameplayBrowserInteractionIntent,
+    "invoke" | "submit"
+  >;
+  readonly semanticEffects: readonly GameplaySemanticEffect[];
+} {
+  const invoke =
+    input.explicitParams === true || input.descriptor.commit.mode !== "manual";
+  return invoke
+    ? { intent: "invoke", semanticEffects: [gameplayInvokeEffect()] }
+    : { intent: "submit", semanticEffects: [gameplayCommitEffect()] };
+}
+
+export function gameplayPreparationPatternsForDescriptor(
+  descriptor: Pick<InteractionDescriptor, "inputs">,
+  draftValues: Readonly<Record<string, unknown>>,
+): readonly GameplaySemanticEffectPattern[] {
+  const patterns: GameplaySemanticEffectPattern[] = [];
+  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: string,
+  domain: Extract<InputDomain, { type: "boundedNumber" }>,
+): GameplaySemanticEffectPattern {
+  const min = domain.min ?? 0;
+  const max = domain.max;
+  return {
+    kind: "match",
+    effectKind: "setScalar",
+    fields: { inputKey },
+    scalar: {
+      field: "value",
+      min,
+      ...(max !== undefined && Number.isFinite(max) ? { max } : {}),
+      ...(scalarIsInteger(domain) ? { integer: true } : {}),
+    },
+  };
+}
+
+function resolvedInputByKey(
+  descriptor: Pick<InteractionDescriptor, "inputs">,
+  inputKey: string,
+  draftValues: Readonly<Record<string, unknown>>,
+): InteractionInputDescriptor | undefined {
+  const input = inputByKey(descriptor, inputKey);
+  return input ? resolveInputDomain(input, draftValues) : undefined;
+}
+
+function isCandidateSelected(
+  currentValue: unknown,
+  candidateValue: unknown,
+  input: InteractionInputDescriptor,
+): boolean {
+  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: InteractionInputDescriptor): boolean {
+  if (input.domain.type === "choiceList") return true;
+  return (
+    isTargetDomain(input.domain) && input.domain.selection?.mode === "many"
+  );
+}
+
+function valueArrayIncludes(currentValue: unknown, candidateValue: unknown) {
+  return (
+    Array.isArray(currentValue) &&
+    currentValue.some((item) => String(item) === String(candidateValue))
+  );
+}
+
+function scalarIsInteger(
+  domain: Extract<InputDomain, { type: "boundedNumber" }>,
+): boolean {
+  const step = domain.step ?? 1;
+  return (
+    Number.isInteger(step) &&
+    Number.isInteger(domain.min ?? 0) &&
+    (domain.max === undefined || Number.isInteger(domain.max))
+  );
+}
+
+function dedupePatterns(
+  patterns: readonly GameplaySemanticEffectPattern[],
+): readonly GameplaySemanticEffectPattern[] {
+  const seen = new Set<string>();
+  const result: GameplaySemanticEffectPattern[] = [];
+  for (const pattern of patterns) {
+    const key = JSON.stringify(pattern);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(pattern);
+  }
+  return result;
+}

package/src/runtime-internal/utils/interaction-draft-digest.ts

@@ -0,0 +1,252 @@
+import type { InteractionDescriptor } from "../types/plugin-state.js";
+
+type CanonicalJson =
+  | null
+  | boolean
+  | number
+  | string
+  | CanonicalJson[]
+  | { [key: string]: CanonicalJson };
+
+export function interactionDraftDigestForValues(
+  descriptor: InteractionDescriptor,
+  values: Readonly<Record<string, unknown>>,
+): string | undefined {
+  if (
+    descriptor.descriptorDigest === undefined ||
+    descriptor.actorSeat === undefined ||
+    descriptor.draftDigest === undefined
+  ) {
+    return undefined;
+  }
+  const defaults = defaultsForDescriptor(descriptor);
+  return draftDigest({
+    actorSeat: descriptor.actorSeat,
+    descriptorDigest: descriptor.descriptorDigest,
+    interactionId: descriptor.interactionId,
+    interactionKey: descriptor.interactionKey,
+    values: {
+      ...defaults,
+      ...(toCanonicalJson(values) as Record<string, CanonicalJson>),
+    },
+  });
+}
+
+function draftDigest({
+  actorSeat,
+  descriptorDigest,
+  interactionId,
+  interactionKey,
+  values,
+}: {
+  actorSeat: number;
+  descriptorDigest: string;
+  interactionId: string;
+  interactionKey: string;
+  values: CanonicalJson;
+}): string {
+  return hashJson({
+    digestVersion: "interaction-draft@2",
+    actorSeat,
+    descriptorDigest,
+    emitted: false,
+    interactionId,
+    interactionKey,
+    values,
+  });
+}
+
+function defaultsForDescriptor(
+  descriptor: InteractionDescriptor,
+): Record<string, CanonicalJson> {
+  return Object.fromEntries(
+    descriptor.inputs.flatMap((input) =>
+      input.defaultValue === undefined
+        ? []
+        : [[input.key, toCanonicalJson(input.defaultValue)]],
+    ),
+  );
+}
+
+function toCanonicalJson(value: unknown): CanonicalJson {
+  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 as Record<string, unknown>)
+        .filter(([, item]) => item !== undefined)
+        .map(([key, item]) => [key, toCanonicalJson(item)]),
+    );
+  }
+  return null;
+}
+
+function hashJson(value: CanonicalJson): string {
+  return `sha256:${sha256Hex(canonicalJson(value))}`;
+}
+
+function canonicalJson(value: CanonicalJson): string {
+  return JSON.stringify(canonicalizeJson(value));
+}
+
+function canonicalizeJson(value: CanonicalJson): CanonicalJson {
+  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 sha256Hex(input: string): string {
+  const bytes = utf8Bytes(input);
+  const bitLength = bytes.length * 8;
+  bytes.push(0x80);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+  for (let shift = 56; shift >= 0; shift -= 8) {
+    bytes.push(Math.floor(bitLength / 2 ** shift) & 0xff);
+  }
+
+  let h0 = 0x6a09e667;
+  let h1 = 0xbb67ae85;
+  let h2 = 0x3c6ef372;
+  let h3 = 0xa54ff53a;
+  let h4 = 0x510e527f;
+  let h5 = 0x9b05688c;
+  let h6 = 0x1f83d9ab;
+  let h7 = 0x5be0cd19;
+
+  const words = new Array<number>(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 utf8Bytes(input: string): number[] {
+  return Array.from(new TextEncoder().encode(input));
+}
+
+function rightRotate(value: number, bits: number): number {
+  return (value >>> bits) | (value << (32 - bits));
+}
+
+function ch(x: number, y: number, z: number): number {
+  return (x & y) ^ (~x & z);
+}
+
+function maj(x: number, y: number, z: number): number {
+  return (x & y) ^ (x & z) ^ (y & z);
+}
+
+function bigSigma0(x: number): number {
+  return rightRotate(x, 2) ^ rightRotate(x, 13) ^ rightRotate(x, 22);
+}
+
+function bigSigma1(x: number): number {
+  return rightRotate(x, 6) ^ rightRotate(x, 11) ^ rightRotate(x, 25);
+}
+
+function smallSigma0(x: number): number {
+  return rightRotate(x, 7) ^ rightRotate(x, 18) ^ (x >>> 3);
+}
+
+function smallSigma1(x: number): number {
+  return rightRotate(x, 17) ^ rightRotate(x, 19) ^ (x >>> 10);
+}
+
+const K = [
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+  0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+  0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+  0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+  0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+  0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+  0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+  0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+  0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];