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

package/src/browser-interaction/attributes.ts

@@ -1,211 +0,0 @@
-import {
-  BROWSER_INTERACTION_ATTRIBUTES,
-  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
-  GAMEPLAY_BROWSER_INTERACTION_SURFACE,
-} from "./constants.js";
-import { encodeCanonicalCandidateValue } from "./canonical.js";
-import {
-  encodeBrowserInteractionEffect,
-  encodeBrowserInteractionEffectPattern,
-} from "./effects.js";
-import type {
-  BrowserInteractionActuatorKind,
-  BrowserInteractionCandidateState,
-  BrowserInteractionEffectPattern,
-  BrowserInteractionIntent,
-  BrowserInteractionPreparationTarget,
-  BrowserInteractionReadiness,
-  BrowserInteractionSurfaceEffect,
-  GameplayBrowserInteractionIntent,
-  GameplaySemanticEffect,
-  GameplaySemanticEffectPattern,
-} from "./types.js";
-
-export type BrowserInteractionAttributeMap = Record<string, string | boolean>;
-
-export interface BrowserInteractionRootAttributesInput {
-  readonly surface: string;
-  readonly scopeId: string;
-  readonly interactionKey: string;
-  readonly interactionId: string;
-  readonly descriptorDigest?: string;
-  readonly draftDigest?: string;
-  readonly readiness: BrowserInteractionReadiness;
-}
-
-export interface BrowserInteractionActuatorAttributesInput {
-  readonly surface: string;
-  readonly scopeId: string;
-  readonly interactionKey: string;
-  readonly interactionId: string;
-  readonly descriptorDigest?: string;
-  readonly draftDigest?: string;
-  readonly intent: BrowserInteractionIntent;
-  readonly inputKey?: string;
-  readonly candidateValue?: unknown;
-  readonly candidateState?: BrowserInteractionCandidateState;
-  readonly enabled?: boolean;
-  readonly actuatorKind: BrowserInteractionActuatorKind;
-  readonly actuatorId?: string;
-  readonly semanticEffects?: readonly BrowserInteractionSurfaceEffect[];
-  readonly acceptedEffectPatterns?: readonly BrowserInteractionEffectPattern[];
-  readonly preparationPatterns?: readonly BrowserInteractionEffectPattern[];
-  readonly prepares?: BrowserInteractionPreparationTarget;
-}
-
-function baseGameplayAttributes(
-  input: Pick<
-    BrowserInteractionRootAttributesInput,
-    "surface" | "scopeId" | "interactionKey" | "interactionId"
-  >,
-): BrowserInteractionAttributeMap {
-  return {
-    [BROWSER_INTERACTION_ATTRIBUTES.protocol]:
-      DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
-    [BROWSER_INTERACTION_ATTRIBUTES.surface]: input.surface,
-    [BROWSER_INTERACTION_ATTRIBUTES.scope]: input.scopeId,
-    [BROWSER_INTERACTION_ATTRIBUTES.interactionKey]: input.interactionKey,
-    [BROWSER_INTERACTION_ATTRIBUTES.interactionId]: input.interactionId,
-  };
-}
-
-export function createBrowserInteractionRootAttributes(
-  input: BrowserInteractionRootAttributesInput,
-): BrowserInteractionAttributeMap {
-  return {
-    ...baseGameplayAttributes(input),
-    [BROWSER_INTERACTION_ATTRIBUTES.role]: "interaction",
-    [BROWSER_INTERACTION_ATTRIBUTES.descriptorDigest]:
-      input.descriptorDigest ?? "",
-    [BROWSER_INTERACTION_ATTRIBUTES.draftDigest]: input.draftDigest ?? "",
-    [BROWSER_INTERACTION_ATTRIBUTES.readiness]: input.readiness,
-  };
-}
-
-export function createBrowserInteractionActuatorAttributes(
-  input: BrowserInteractionActuatorAttributesInput,
-): BrowserInteractionAttributeMap {
-  const attrs: BrowserInteractionAttributeMap = {
-    ...baseGameplayAttributes(input),
-    [BROWSER_INTERACTION_ATTRIBUTES.role]: "actuator",
-    [BROWSER_INTERACTION_ATTRIBUTES.intent]: input.intent,
-    [BROWSER_INTERACTION_ATTRIBUTES.actuatorKind]: input.actuatorKind,
-    [BROWSER_INTERACTION_ATTRIBUTES.enabled]:
-      input.enabled === false ? "false" : "true",
-  };
-  if (input.descriptorDigest) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.descriptorDigest] =
-      input.descriptorDigest;
-  }
-  if (input.draftDigest) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.draftDigest] = input.draftDigest;
-  }
-  if (input.actuatorId) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.actuatorId] = input.actuatorId;
-  }
-  if (input.inputKey) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.inputKey] = input.inputKey;
-  }
-  if ("candidateValue" in input) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.candidateValue] =
-      encodeCanonicalCandidateValue(input.candidateValue);
-  }
-  if (input.candidateState) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.candidateState] = input.candidateState;
-  }
-  if (input.semanticEffects && input.semanticEffects.length > 0) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.semanticEffects] = JSON.stringify(
-      input.semanticEffects.map(encodeBrowserInteractionEffect),
-    );
-  }
-  if (input.acceptedEffectPatterns && input.acceptedEffectPatterns.length > 0) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.acceptedEffectPatterns] =
-      JSON.stringify(
-        input.acceptedEffectPatterns.map(encodeBrowserInteractionEffectPattern),
-      );
-  }
-  if (input.preparationPatterns && input.preparationPatterns.length > 0) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.preparationPatterns] = JSON.stringify(
-      input.preparationPatterns.map(encodeBrowserInteractionEffectPattern),
-    );
-  }
-  if (input.prepares) {
-    attrs[BROWSER_INTERACTION_ATTRIBUTES.preparesIntent] =
-      input.prepares.intent;
-    if (input.prepares.inputKey) {
-      attrs[BROWSER_INTERACTION_ATTRIBUTES.preparesInputKey] =
-        input.prepares.inputKey;
-    }
-    if (input.prepares.candidateValueKey) {
-      attrs[BROWSER_INTERACTION_ATTRIBUTES.preparesCandidateValue] =
-        input.prepares.candidateValueKey;
-    } else if ("candidateValue" in input.prepares) {
-      attrs[BROWSER_INTERACTION_ATTRIBUTES.preparesCandidateValue] =
-        encodeCanonicalCandidateValue(input.prepares.candidateValue);
-    }
-    if (input.prepares.actuatorKind) {
-      attrs[BROWSER_INTERACTION_ATTRIBUTES.preparesActuatorKind] =
-        input.prepares.actuatorKind;
-    }
-  }
-  return attrs;
-}
-
-export type GameplayInteractionRootAttributesInput = Omit<
-  BrowserInteractionRootAttributesInput,
-  "surface"
->;
-
-export type GameplayActuatorAttributesInput = Omit<
-  BrowserInteractionActuatorAttributesInput,
-  | "surface"
-  | "intent"
-  | "semanticEffects"
-  | "acceptedEffectPatterns"
-  | "preparationPatterns"
-> & {
-  readonly intent: GameplayBrowserInteractionIntent;
-  readonly semanticEffects?: readonly GameplaySemanticEffect[];
-  readonly acceptedEffectPatterns?: readonly GameplaySemanticEffectPattern[];
-  readonly preparationPatterns?: readonly GameplaySemanticEffectPattern[];
-};
-
-export function createGameplayInteractionRootAttributes(
-  input: GameplayInteractionRootAttributesInput,
-): BrowserInteractionAttributeMap {
-  return createBrowserInteractionRootAttributes({
-    ...input,
-    surface: GAMEPLAY_BROWSER_INTERACTION_SURFACE,
-  });
-}
-
-export function createGameplayActuatorAttributes(
-  input: GameplayActuatorAttributesInput,
-): BrowserInteractionAttributeMap {
-  return createBrowserInteractionActuatorAttributes({
-    ...input,
-    surface: GAMEPLAY_BROWSER_INTERACTION_SURFACE,
-  });
-}
-
-export function createBrowserInteractionActuatorKey(input: {
-  readonly surface: string;
-  readonly scopeId: string;
-  readonly interactionKey: string;
-  readonly intent: BrowserInteractionIntent;
-  readonly inputKey?: string;
-  readonly candidateValueKey?: string;
-  readonly actuatorKind: BrowserInteractionActuatorKind;
-}): string {
-  return [
-    input.surface,
-    input.scopeId,
-    input.interactionKey,
-    input.intent,
-    input.inputKey ?? "",
-    input.candidateValueKey ?? "",
-    input.actuatorKind,
-  ]
-    .map((part) => encodeURIComponent(part))
-    .join("|");
-}

package/src/browser-interaction/canonical.ts

@@ -1,77 +0,0 @@
-export type CanonicalBrowserInteractionValue =
-  | null
-  | boolean
-  | number
-  | string
-  | readonly CanonicalBrowserInteractionValue[]
-  | { readonly [key: string]: CanonicalBrowserInteractionValue };
-
-function assertCanonicalValue(
-  value: unknown,
-): asserts value is CanonicalBrowserInteractionValue {
-  if (value === null) return;
-  switch (typeof value) {
-    case "boolean":
-    case "string":
-      return;
-    case "number":
-      if (Number.isFinite(value)) return;
-      break;
-    case "object":
-      if (Array.isArray(value)) {
-        value.forEach(assertCanonicalValue);
-        return;
-      }
-      if (Object.getPrototypeOf(value) !== Object.prototype) break;
-      for (const [key, item] of Object.entries(value)) {
-        if (item === undefined) {
-          throw new Error(
-            `Browser interaction candidate '${key}' cannot be undefined.`,
-          );
-        }
-        assertCanonicalValue(item);
-      }
-      return;
-  }
-  throw new Error(
-    `Browser interaction candidates must be JSON-serializable primitives, arrays or plain objects. Received ${typeof value}.`,
-  );
-}
-
-function canonicalizeValue(
-  value: CanonicalBrowserInteractionValue,
-): CanonicalBrowserInteractionValue {
-  if (Array.isArray(value)) {
-    return value.map(canonicalizeValue);
-  }
-  if (value && typeof value === "object") {
-    const objectValue = value as {
-      readonly [key: string]: CanonicalBrowserInteractionValue;
-    };
-    return Object.fromEntries(
-      Object.keys(objectValue)
-        .sort()
-        .map((key) => [key, canonicalizeValue(objectValue[key])]),
-    );
-  }
-  return value;
-}
-
-export function encodeCanonicalCandidateValue(value: unknown): string {
-  assertCanonicalValue(value);
-  return JSON.stringify(canonicalizeValue(value));
-}
-
-export function decodeCanonicalCandidateValue(
-  encoded: string,
-): CanonicalBrowserInteractionValue {
-  const parsed = JSON.parse(encoded) as unknown;
-  assertCanonicalValue(parsed);
-  return canonicalizeValue(parsed);
-}
-
-export function compareStableJson(a: unknown, b: unknown): number {
-  const encodedA = encodeCanonicalCandidateValue(a);
-  const encodedB = encodeCanonicalCandidateValue(b);
-  return encodedA.localeCompare(encodedB);
-}

package/src/browser-interaction/constants.ts

@@ -1,77 +0,0 @@
-export const DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_NAME =
-  "dreamboard-browser-interaction" as const;
-
-export const DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION = "2.0.0" as const;
-
-export const BROWSER_INTERACTION_ATTRIBUTES = {
-  protocol: "data-dreamboard-browser-protocol",
-  surface: "data-dreamboard-browser-surface",
-  scope: "data-dreamboard-browser-scope",
-  role: "data-dreamboard-browser-role",
-  intent: "data-dreamboard-browser-intent",
-  interactionKey: "data-dreamboard-interaction-key",
-  interactionId: "data-dreamboard-interaction-id",
-  descriptorDigest: "data-dreamboard-descriptor-digest",
-  draftDigest: "data-dreamboard-draft-digest",
-  readiness: "data-dreamboard-readiness",
-  inputKey: "data-dreamboard-input-key",
-  candidateValue: "data-dreamboard-candidate-value",
-  candidateState: "data-dreamboard-candidate-state",
-  actuatorKind: "data-dreamboard-actuator-kind",
-  enabled: "data-dreamboard-actuator-enabled",
-  actuatorId: "data-dreamboard-actuator-id",
-  semanticEffects: "data-dreamboard-semantic-effects",
-  acceptedEffectPatterns: "data-dreamboard-accepted-effect-patterns",
-  preparationPatterns: "data-dreamboard-preparation-patterns",
-  preparesIntent: "data-dreamboard-prepares-intent",
-  preparesInputKey: "data-dreamboard-prepares-input-key",
-  preparesCandidateValue: "data-dreamboard-prepares-candidate-value",
-  preparesActuatorKind: "data-dreamboard-prepares-actuator-kind",
-  diagnostic: "data-dreamboard-browser-diagnostic",
-} as const;
-
-export const BROWSER_INTERACTION_RECORD_ROLES = [
-  "interaction",
-  "actuator",
-] as const;
-
-export const GAMEPLAY_BROWSER_INTERACTION_SURFACE = "gameplay" as const;
-
-export const GAMEPLAY_BROWSER_INTERACTION_INTENTS = [
-  "arm",
-  "reveal",
-  "invoke",
-  "select",
-  "toggle",
-  "increment",
-  "decrement",
-  "fill",
-  "submit",
-] as const;
-
-export const GAMEPLAY_BROWSER_INTERACTION_EFFECT_KINDS = [
-  "setCandidate",
-  "adjustResource",
-  "setScalar",
-  "commit",
-  "invoke",
-] as const;
-
-export const BROWSER_INTERACTION_READINESS_VALUES = [
-  "ready",
-  "blocked",
-  "unavailable",
-] as const;
-
-export const BROWSER_INTERACTION_CANDIDATE_STATES = [
-  "selected",
-  "unselected",
-  "mixed",
-] as const;
-
-export const BROWSER_INTERACTION_ACTUATOR_KINDS = [
-  "click",
-  "fill",
-  "keyboard",
-  "pointer",
-] as const;

package/src/browser-interaction/effects.ts

@@ -1,176 +0,0 @@
-import {
-  decodeCanonicalCandidateValue,
-  encodeCanonicalCandidateValue,
-  type CanonicalBrowserInteractionValue,
-} from "./canonical.js";
-import type {
-  BrowserInteractionEffectPattern,
-  BrowserInteractionSurfaceEffect,
-  GameplaySemanticEffect,
-} from "./types.js";
-
-export function encodeBrowserInteractionEffect(
-  effect: BrowserInteractionSurfaceEffect,
-): string {
-  return encodeCanonicalCandidateValue(effect);
-}
-
-export function decodeBrowserInteractionEffect(
-  encoded: string,
-): BrowserInteractionSurfaceEffect {
-  const decoded = decodeCanonicalCandidateValue(encoded);
-  if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
-    throw new Error("Browser interaction effect must be a canonical object.");
-  }
-  const decodedObject = decoded as {
-    readonly [key: string]: CanonicalBrowserInteractionValue;
-  };
-  const kind = decodedObject.kind;
-  if (typeof kind !== "string" || kind.length === 0) {
-    throw new Error("Browser interaction effect requires a string kind.");
-  }
-  return decodedObject as BrowserInteractionSurfaceEffect;
-}
-
-export function encodeBrowserInteractionEffectPattern(
-  pattern: BrowserInteractionEffectPattern,
-): string {
-  return encodeCanonicalCandidateValue(pattern);
-}
-
-export function decodeBrowserInteractionEffectPattern(
-  encoded: string,
-): BrowserInteractionEffectPattern {
-  const decoded = decodeCanonicalCandidateValue(encoded);
-  assertBrowserInteractionEffectPattern(decoded);
-  return decoded;
-}
-
-export function browserInteractionEffectPatternMatches(
-  pattern: BrowserInteractionEffectPattern,
-  effect: BrowserInteractionSurfaceEffect,
-): boolean {
-  switch (pattern.kind) {
-    case "exact":
-      return (
-        encodeBrowserInteractionEffect(pattern.effect) ===
-        encodeBrowserInteractionEffect(effect)
-      );
-    case "match": {
-      if (effect.kind !== pattern.effectKind) return false;
-      for (const [field, expected] of Object.entries(pattern.fields ?? {})) {
-        const actual = effect[field];
-        if (actual === undefined) return false;
-        if (
-          encodeCanonicalCandidateValue(actual) !==
-          encodeCanonicalCandidateValue(expected)
-        ) {
-          return false;
-        }
-      }
-      const scalar = pattern.scalar;
-      if (scalar) {
-        const actual = effect[scalar.field];
-        if (typeof actual !== "number" || !Number.isFinite(actual)) {
-          return false;
-        }
-        if (scalar.integer === true && !Number.isInteger(actual)) {
-          return false;
-        }
-        if (scalar.min !== undefined && actual < scalar.min) {
-          return false;
-        }
-        if (scalar.max !== undefined && actual > scalar.max) {
-          return false;
-        }
-      }
-      return true;
-    }
-  }
-}
-
-export function assertBrowserInteractionEffectPattern(
-  value: unknown,
-): asserts value is BrowserInteractionEffectPattern {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Browser interaction effect pattern must be an object.");
-  }
-  const pattern = value as {
-    readonly [key: string]: unknown;
-  };
-  if (pattern.kind === "exact") {
-    decodeBrowserInteractionEffect(
-      encodeCanonicalCandidateValue(pattern.effect),
-    );
-    return;
-  }
-  if (pattern.kind === "match") {
-    if (
-      typeof pattern.effectKind !== "string" ||
-      pattern.effectKind.length === 0
-    ) {
-      throw new Error(
-        "Browser interaction match pattern requires an effectKind.",
-      );
-    }
-    if (pattern.fields !== undefined) {
-      if (
-        !pattern.fields ||
-        typeof pattern.fields !== "object" ||
-        Array.isArray(pattern.fields)
-      ) {
-        throw new Error(
-          "Browser interaction match pattern fields must be an object.",
-        );
-      }
-    }
-    if (pattern.scalar !== undefined) {
-      if (
-        !pattern.scalar ||
-        typeof pattern.scalar !== "object" ||
-        Array.isArray(pattern.scalar) ||
-        typeof (pattern.scalar as { readonly field?: unknown }).field !==
-          "string" ||
-        (pattern.scalar as { readonly field: string }).field.length === 0
-      ) {
-        throw new Error(
-          "Browser interaction scalar pattern requires a scalar field.",
-        );
-      }
-    }
-    return;
-  }
-  throw new Error("Unknown browser interaction effect pattern kind.");
-}
-
-export function gameplaySetCandidateEffect(input: {
-  readonly inputKey: string;
-  readonly candidateValue: CanonicalBrowserInteractionValue;
-  readonly beforeSelected: boolean;
-  readonly afterSelected: boolean;
-}): GameplaySemanticEffect {
-  return { kind: "setCandidate", ...input };
-}
-
-export function gameplayAdjustResourceEffect(input: {
-  readonly inputKey: string;
-  readonly resourceKey: CanonicalBrowserInteractionValue;
-  readonly delta: -1 | 1;
-}): GameplaySemanticEffect {
-  return { kind: "adjustResource", ...input };
-}
-
-export function gameplaySetScalarEffect(input: {
-  readonly inputKey: string;
-  readonly value: number;
-}): GameplaySemanticEffect {
-  return { kind: "setScalar", ...input };
-}
-
-export function gameplayCommitEffect(): GameplaySemanticEffect {
-  return { kind: "commit" };
-}
-
-export function gameplayInvokeEffect(): GameplaySemanticEffect {
-  return { kind: "invoke" };
-}

package/src/browser-interaction/index.ts

@@ -1,111 +0,0 @@
-export {
-  BROWSER_INTERACTION_ACTUATOR_KINDS,
-  BROWSER_INTERACTION_ATTRIBUTES,
-  BROWSER_INTERACTION_CANDIDATE_STATES,
-  BROWSER_INTERACTION_READINESS_VALUES,
-  BROWSER_INTERACTION_RECORD_ROLES,
-  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_NAME,
-  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
-  GAMEPLAY_BROWSER_INTERACTION_EFFECT_KINDS,
-  GAMEPLAY_BROWSER_INTERACTION_INTENTS,
-  GAMEPLAY_BROWSER_INTERACTION_SURFACE,
-} from "./constants.js";
-export {
-  compareStableJson,
-  decodeCanonicalCandidateValue,
-  encodeCanonicalCandidateValue,
-  type CanonicalBrowserInteractionValue,
-} from "./canonical.js";
-export {
-  assertBrowserInteractionEffectPattern,
-  browserInteractionEffectPatternMatches,
-  decodeBrowserInteractionEffect,
-  decodeBrowserInteractionEffectPattern,
-  encodeBrowserInteractionEffect,
-  encodeBrowserInteractionEffectPattern,
-  gameplayAdjustResourceEffect,
-  gameplayCommitEffect,
-  gameplayInvokeEffect,
-  gameplaySetCandidateEffect,
-  gameplaySetScalarEffect,
-} from "./effects.js";
-export {
-  createBrowserInteractionActuatorAttributes,
-  createBrowserInteractionActuatorKey,
-  createBrowserInteractionRootAttributes,
-  createGameplayActuatorAttributes,
-  createGameplayInteractionRootAttributes,
-  type BrowserInteractionActuatorAttributesInput,
-  type BrowserInteractionAttributeMap,
-  type BrowserInteractionRootAttributesInput,
-  type GameplayActuatorAttributesInput,
-  type GameplayInteractionRootAttributesInput,
-} from "./attributes.js";
-export {
-  createBrowserInteractionRegistry,
-  defaultBrowserInteractionRegistry,
-  defineBrowserInteractionSurface,
-  gameplayBrowserInteractionSurface,
-} from "./registry.js";
-export {
-  actuatorIdentityKey,
-  isSemanticSurfaceSnapshot,
-  normalizeBrowserInteractionRecords,
-  targetIdentityKey,
-  validateBrowserInteractionSnapshot,
-  type NormalizeBrowserInteractionRecordsOptions,
-} from "./normalize.js";
-export {
-  resolveBrowserInteractionEffect,
-  resolveBrowserInteractionIntent,
-} from "./resolve.js";
-export {
-  browserInteractionEffectPatternSchema,
-  browserInteractionEffectSchema,
-  browserGameplayInteractionSchema,
-  browserGameplaySurfaceSnapshotSchema,
-  browserInteractionActuatorSchema,
-  browserInteractionDiagnosticSchema,
-  browserInteractionSnapshotSchema,
-  browserSemanticSurfaceSnapshotSchema,
-  browserUnknownSurfaceSnapshotSchema,
-  gameplaySemanticEffectSchema,
-} from "./schemas.js";
-export type {
-  BrowserGameplayInteraction,
-  BrowserGameplaySurfaceSnapshot,
-  BrowserInteractionActuator,
-  BrowserInteractionActuatorKind,
-  BrowserInteractionCandidateState,
-  BrowserInteractionDiagnostic,
-  BrowserInteractionEffectPattern,
-  BrowserInteractionEffectRequest,
-  BrowserInteractionEffectResolution,
-  BrowserInteractionEffectResolutionFailure,
-  BrowserInteractionEffectResolutionSuccess,
-  BrowserInteractionEntity,
-  BrowserInteractionIntent,
-  BrowserInteractionIntentRequest,
-  BrowserInteractionPreparationTarget,
-  BrowserInteractionProtocolIdentity,
-  BrowserInteractionRawRecord,
-  BrowserInteractionReadiness,
-  BrowserInteractionRegistry,
-  BrowserInteractionResolution,
-  BrowserInteractionResolutionFailure,
-  BrowserInteractionResolutionSuccess,
-  BrowserInteractionScalarPattern,
-  BrowserInteractionSemanticSurfaceSnapshot,
-  BrowserInteractionSnapshot,
-  BrowserInteractionSurfaceEffect,
-  BrowserInteractionSurface,
-  BrowserInteractionSurfaceDefinition,
-  BrowserInteractionSurfaceSnapshot,
-  BrowserInteractionUnknownSurfaceSnapshot,
-  GameplayBrowserInteractionEffectKind,
-  GameplayBrowserInteractionEffectRequest,
-  GameplayBrowserInteractionIntent,
-  GameplayBrowserInteractionSurface,
-  GameplaySemanticEffect,
-  GameplaySemanticEffectPattern,
-} from "./types.js";