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

package/src/browser-interaction/schemas.ts

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import {
+  BROWSER_INTERACTION_ACTUATOR_KINDS,
+  BROWSER_INTERACTION_CANDIDATE_STATES,
+  BROWSER_INTERACTION_READINESS_VALUES,
+  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_NAME,
+  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
+  GAMEPLAY_BROWSER_INTERACTION_SURFACE,
+} from "./constants.js";
+
+const jsonValueSchema: z.ZodType<unknown> = z.lazy(() =>
+  z.union([
+    z.null(),
+    z.boolean(),
+    z.number().finite(),
+    z.string(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
+  ]),
+);
+
+export const browserInteractionEffectSchema = z
+  .object({
+    kind: z.string().min(1),
+  })
+  .catchall(jsonValueSchema);
+
+export const browserInteractionEffectPatternSchema = z.union([
+  z.object({
+    kind: z.literal("exact"),
+    effect: browserInteractionEffectSchema,
+  }),
+  z.object({
+    kind: z.literal("match"),
+    effectKind: z.string().min(1),
+    fields: z.record(z.string(), jsonValueSchema).optional(),
+    scalar: z
+      .object({
+        field: z.string().min(1),
+        min: z.number().finite().optional(),
+        max: z.number().finite().optional(),
+        integer: z.boolean().optional(),
+      })
+      .optional(),
+  }),
+]);
+
+export const gameplaySemanticEffectSchema = z.union([
+  z.object({
+    kind: z.literal("setCandidate"),
+    inputKey: z.string(),
+    candidateValue: jsonValueSchema,
+    beforeSelected: z.boolean(),
+    afterSelected: z.boolean(),
+  }),
+  z.object({
+    kind: z.literal("adjustResource"),
+    inputKey: z.string(),
+    resourceKey: jsonValueSchema,
+    delta: z.union([z.literal(-1), z.literal(1)]),
+  }),
+  z.object({
+    kind: z.literal("setScalar"),
+    inputKey: z.string(),
+    value: z.number().finite(),
+  }),
+  z.object({
+    kind: z.literal("commit"),
+  }),
+  z.object({
+    kind: z.literal("invoke"),
+  }),
+]);
+
+export const browserInteractionDiagnosticSchema = z.object({
+  code: z.string(),
+  severity: z.enum(["error", "warning"]),
+  message: z.string(),
+  surface: z.string().optional(),
+  scopeId: z.string().optional(),
+  interactionKey: z.string().optional(),
+  intent: z.string().optional(),
+  actuatorId: z.string().optional(),
+});
+
+export const browserInteractionActuatorSchema = z.object({
+  actuatorId: z.string(),
+  intent: z.string(),
+  inputKey: z.string().optional(),
+  candidateValue: jsonValueSchema.optional(),
+  candidateValueKey: z.string().optional(),
+  candidateState: z.enum(BROWSER_INTERACTION_CANDIDATE_STATES).optional(),
+  enabled: z.boolean(),
+  actuatorKind: z.enum(BROWSER_INTERACTION_ACTUATOR_KINDS),
+  semanticEffects: z.array(browserInteractionEffectSchema),
+  acceptedEffectPatterns: z.array(browserInteractionEffectPatternSchema),
+  preparationPatterns: z.array(browserInteractionEffectPatternSchema),
+  prepares: z
+    .object({
+      intent: z.string(),
+      inputKey: z.string().optional(),
+      candidateValue: jsonValueSchema.optional(),
+      candidateValueKey: z.string().optional(),
+      actuatorKind: z.enum(BROWSER_INTERACTION_ACTUATOR_KINDS).optional(),
+    })
+    .optional(),
+  diagnostics: z.array(browserInteractionDiagnosticSchema),
+});
+
+export const browserGameplayInteractionSchema = z.object({
+  interactionKey: z.string(),
+  interactionId: z.string(),
+  descriptorDigest: z.string().optional(),
+  draftDigest: z.string().optional(),
+  readiness: z.enum(BROWSER_INTERACTION_READINESS_VALUES),
+  actuators: z.array(browserInteractionActuatorSchema),
+  diagnostics: z.array(browserInteractionDiagnosticSchema),
+});
+
+export const browserGameplaySurfaceSnapshotSchema = z.object({
+  surface: z.literal(GAMEPLAY_BROWSER_INTERACTION_SURFACE),
+  scopeId: z.string(),
+  interactions: z.array(browserGameplayInteractionSchema),
+  diagnostics: z.array(browserInteractionDiagnosticSchema),
+});
+
+export const browserSemanticSurfaceSnapshotSchema = z.object({
+  surface: z.string(),
+  scopeId: z.string(),
+  interactions: z.array(browserGameplayInteractionSchema),
+  diagnostics: z.array(browserInteractionDiagnosticSchema),
+});
+
+export const browserUnknownSurfaceSnapshotSchema = z.object({
+  surface: z.string(),
+  scopeId: z.string(),
+  diagnostics: z.array(browserInteractionDiagnosticSchema),
+});
+
+export const browserInteractionSnapshotSchema = z.object({
+  protocol: z.object({
+    name: z.literal(DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_NAME),
+    version: z.literal(DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION),
+  }),
+  surfaces: z.array(
+    z.union([
+      browserSemanticSurfaceSnapshotSchema,
+      browserUnknownSurfaceSnapshotSchema,
+    ]),
+  ),
+  diagnostics: z.array(browserInteractionDiagnosticSchema),
+});

package/src/browser-interaction/types.ts

@@ -0,0 +1,304 @@
+import type {
+  BROWSER_INTERACTION_ACTUATOR_KINDS,
+  BROWSER_INTERACTION_CANDIDATE_STATES,
+  BROWSER_INTERACTION_READINESS_VALUES,
+  BROWSER_INTERACTION_RECORD_ROLES,
+  GAMEPLAY_BROWSER_INTERACTION_EFFECT_KINDS,
+  GAMEPLAY_BROWSER_INTERACTION_INTENTS,
+  GAMEPLAY_BROWSER_INTERACTION_SURFACE,
+} from "./constants.js";
+import type { CanonicalBrowserInteractionValue } from "./canonical.js";
+
+export type BrowserInteractionSurface = string;
+export type BrowserInteractionIntent = string;
+export type BrowserInteractionRole =
+  (typeof BROWSER_INTERACTION_RECORD_ROLES)[number];
+export type GameplayBrowserInteractionSurface =
+  typeof GAMEPLAY_BROWSER_INTERACTION_SURFACE;
+export type GameplayBrowserInteractionIntent =
+  (typeof GAMEPLAY_BROWSER_INTERACTION_INTENTS)[number];
+export type GameplayBrowserInteractionEffectKind =
+  (typeof GAMEPLAY_BROWSER_INTERACTION_EFFECT_KINDS)[number];
+export type BrowserInteractionReadiness =
+  (typeof BROWSER_INTERACTION_READINESS_VALUES)[number];
+export type BrowserInteractionCandidateState =
+  (typeof BROWSER_INTERACTION_CANDIDATE_STATES)[number];
+export type BrowserInteractionActuatorKind =
+  (typeof BROWSER_INTERACTION_ACTUATOR_KINDS)[number];
+
+export interface BrowserInteractionProtocolIdentity {
+  readonly name: "dreamboard-browser-interaction";
+  readonly version: "2.0.0";
+}
+
+export type BrowserInteractionSurfaceEffect = {
+  readonly kind: string;
+  readonly [key: string]: CanonicalBrowserInteractionValue;
+};
+
+export interface BrowserInteractionScalarPattern {
+  readonly field: string;
+  readonly min?: number;
+  readonly max?: number;
+  readonly integer?: boolean;
+}
+
+export type BrowserInteractionEffectPattern<
+  Effect extends BrowserInteractionSurfaceEffect =
+    BrowserInteractionSurfaceEffect,
+> =
+  | {
+      readonly kind: "exact";
+      readonly effect: Effect;
+    }
+  | {
+      readonly kind: "match";
+      readonly effectKind: Effect["kind"] & string;
+      readonly fields?: Readonly<
+        Record<string, CanonicalBrowserInteractionValue>
+      >;
+      readonly scalar?: BrowserInteractionScalarPattern;
+    };
+
+export type GameplaySemanticEffect =
+  | {
+      readonly kind: "setCandidate";
+      readonly inputKey: string;
+      readonly candidateValue: CanonicalBrowserInteractionValue;
+      readonly beforeSelected: boolean;
+      readonly afterSelected: boolean;
+    }
+  | {
+      readonly kind: "adjustResource";
+      readonly inputKey: string;
+      readonly resourceKey: CanonicalBrowserInteractionValue;
+      readonly delta: -1 | 1;
+    }
+  | {
+      readonly kind: "setScalar";
+      readonly inputKey: string;
+      readonly value: number;
+    }
+  | {
+      readonly kind: "commit";
+    }
+  | {
+      readonly kind: "invoke";
+    };
+
+export type GameplaySemanticEffectPattern =
+  BrowserInteractionEffectPattern<GameplaySemanticEffect>;
+
+export interface BrowserInteractionDiagnostic {
+  readonly code:
+    | "ambiguous-actuator"
+    | "ambiguous-effect-match"
+    | "ambiguous-preparation-pattern"
+    | "disabled-effect-actuator"
+    | "duplicate-accepted-effect-pattern-match"
+    | "duplicate-enabled-actuator"
+    | "duplicate-enabled-effect-actuator"
+    | "effect-actuator-kind-incompatibility"
+    | "effect-intent-incompatibility"
+    | "invalid-candidate"
+    | "invalid-effect-payload"
+    | "invalid-effect-pattern"
+    | "invalid-protocol"
+    | "invalid-record"
+    | "invalid-scalar-argument"
+    | "missing-effect"
+    | "orphan-actuator"
+    | "preparation-cycle"
+    | "surface-intent-collision"
+    | "unknown-surface-effect"
+    | "unknown-intent"
+    | "unknown-surface"
+    | "unavailable-actuator";
+  readonly severity: "error" | "warning";
+  readonly message: string;
+  readonly surface?: BrowserInteractionSurface;
+  readonly scopeId?: string;
+  readonly interactionKey?: string;
+  readonly intent?: BrowserInteractionIntent;
+  readonly actuatorId?: string;
+}
+
+export interface BrowserInteractionRawRecord {
+  readonly attributes: Readonly<
+    Record<string, string | boolean | null | undefined>
+  >;
+}
+
+export interface BrowserInteractionPreparationTarget {
+  readonly intent: BrowserInteractionIntent;
+  readonly inputKey?: string;
+  readonly candidateValue?: CanonicalBrowserInteractionValue;
+  readonly candidateValueKey?: string;
+  readonly actuatorKind?: BrowserInteractionActuatorKind;
+}
+
+export interface BrowserInteractionActuator {
+  readonly actuatorId: string;
+  readonly intent: BrowserInteractionIntent;
+  readonly descriptorDigest?: string;
+  readonly draftDigest?: string;
+  readonly inputKey?: string;
+  readonly candidateValue?: CanonicalBrowserInteractionValue;
+  readonly candidateValueKey?: string;
+  readonly candidateState?: BrowserInteractionCandidateState;
+  readonly enabled: boolean;
+  readonly actuatorKind: BrowserInteractionActuatorKind;
+  readonly semanticEffects: readonly BrowserInteractionSurfaceEffect[];
+  readonly acceptedEffectPatterns: readonly BrowserInteractionEffectPattern[];
+  readonly preparationPatterns: readonly BrowserInteractionEffectPattern[];
+  readonly prepares?: BrowserInteractionPreparationTarget;
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+}
+
+export interface BrowserInteractionEntity {
+  readonly interactionKey: string;
+  readonly interactionId: string;
+  readonly descriptorDigest?: string;
+  readonly draftDigest?: string;
+  readonly readiness: BrowserInteractionReadiness;
+  readonly actuators: readonly BrowserInteractionActuator[];
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+}
+
+export type BrowserGameplayInteraction = BrowserInteractionEntity;
+
+export interface BrowserInteractionSemanticSurfaceSnapshot<
+  Surface extends BrowserInteractionSurface = BrowserInteractionSurface,
+> {
+  readonly surface: Surface;
+  readonly scopeId: string;
+  readonly interactions: readonly BrowserInteractionEntity[];
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+}
+
+export type BrowserSemanticSurfaceSnapshot<
+  Surface extends BrowserInteractionSurface = BrowserInteractionSurface,
+> = BrowserInteractionSemanticSurfaceSnapshot<Surface>;
+
+export interface BrowserGameplaySurfaceSnapshot {
+  readonly surface: GameplayBrowserInteractionSurface;
+  readonly scopeId: string;
+  readonly interactions: readonly BrowserGameplayInteraction[];
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+}
+
+export interface BrowserInteractionUnknownSurfaceSnapshot {
+  readonly surface: BrowserInteractionSurface;
+  readonly scopeId: string;
+  readonly interactions?: never;
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+}
+
+export type BrowserInteractionSurfaceSnapshot =
+  | BrowserGameplaySurfaceSnapshot
+  | BrowserInteractionSemanticSurfaceSnapshot
+  | BrowserInteractionUnknownSurfaceSnapshot;
+
+export interface BrowserInteractionSnapshot {
+  readonly protocol: BrowserInteractionProtocolIdentity;
+  readonly surfaces: readonly BrowserInteractionSurfaceSnapshot[];
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+}
+
+export interface BrowserInteractionSurfaceDefinition<
+  Surface extends BrowserInteractionSurface = BrowserInteractionSurface,
+  Intent extends BrowserInteractionIntent = BrowserInteractionIntent,
+  EffectKind extends string = string,
+> {
+  readonly surface: Surface;
+  readonly intents: readonly Intent[];
+  readonly effectKinds?: readonly EffectKind[];
+}
+
+export interface BrowserInteractionRegistry {
+  readonly surfaces: ReadonlyMap<
+    BrowserInteractionSurface,
+    BrowserInteractionSurfaceDefinition
+  >;
+}
+
+export interface BrowserInteractionIntentRequest {
+  readonly surface: BrowserInteractionSurface;
+  readonly scopeId?: string;
+  readonly interactionKey?: string;
+  readonly interactionId?: string;
+  readonly intent: BrowserInteractionIntent;
+  readonly inputKey?: string;
+  readonly candidateValue?: unknown;
+  readonly candidateValueKey?: string;
+  readonly actuatorKind?: BrowserInteractionActuatorKind;
+  readonly allowDisabled?: boolean;
+}
+
+export interface BrowserInteractionEffectRequest<
+  Effect extends BrowserInteractionSurfaceEffect =
+    BrowserInteractionSurfaceEffect,
+> {
+  readonly surface: BrowserInteractionSurface;
+  readonly scopeId?: string;
+  readonly interactionKey?: string;
+  readonly interactionId?: string;
+  readonly effect: Effect;
+  readonly allowDisabled?: boolean;
+}
+
+export type GameplayBrowserInteractionEffectRequest =
+  BrowserInteractionEffectRequest<GameplaySemanticEffect>;
+
+export interface BrowserInteractionResolutionSuccess {
+  readonly ok: true;
+  readonly actuator: BrowserInteractionActuator;
+  readonly surface: BrowserInteractionSurface;
+  readonly scopeId: string;
+  readonly interactionKey: string;
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+}
+
+export interface BrowserInteractionResolutionFailure {
+  readonly ok: false;
+  readonly code:
+    | "ambiguous"
+    | "invalid-snapshot"
+    | "not-found"
+    | "preparation-required"
+    | "unavailable";
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+  readonly preparation?: readonly BrowserInteractionActuator[];
+}
+
+export type BrowserInteractionResolution =
+  | BrowserInteractionResolutionSuccess
+  | BrowserInteractionResolutionFailure;
+
+export interface BrowserInteractionEffectResolutionSuccess {
+  readonly ok: true;
+  readonly actuator: BrowserInteractionActuator;
+  readonly surface: BrowserInteractionSurface;
+  readonly scopeId: string;
+  readonly interactionKey: string;
+  readonly match: "exact" | "accepted-pattern";
+  readonly effect: BrowserInteractionSurfaceEffect;
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+}
+
+export interface BrowserInteractionEffectResolutionFailure {
+  readonly ok: false;
+  readonly code:
+    | "ambiguous"
+    | "invalid-effect"
+    | "invalid-snapshot"
+    | "not-found"
+    | "preparation-required"
+    | "unavailable";
+  readonly diagnostics: readonly BrowserInteractionDiagnostic[];
+  readonly preparation?: readonly BrowserInteractionActuator[];
+}
+
+export type BrowserInteractionEffectResolution =
+  | BrowserInteractionEffectResolutionSuccess
+  | BrowserInteractionEffectResolutionFailure;

package/src/browser-interaction.ts

@@ -0,0 +1 @@
+export * from "./browser-interaction/index.js";

package/src/generated/reducer-contract/wire.ts

@@ -11,7 +11,7 @@ export type ContinuationToken = { "id": string; "data": JsonValue };
 
 export type ContinuationMap = Record<string, ContinuationToken>;
 
-export type JsonValue = Record<string, unknown> | Array<unknown> | string | number | boolean | null;
+export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
 
 export type ReducerSetupSelection = { "profileId": string; "optionValues": Record<string, string | null> };
 

package/src/generated/reducer-contract/zod.ts

@@ -8,7 +8,9 @@ export const ReducerContractVersionSchema = z.string().regex(new RegExp("^[0-9]+
 
 export const EffectIdSchema = z.string().min(1);
 
-export const JsonValueSchema = z.union([z.record(z.string(), z.unknown()), z.array(z.unknown()), z.string(), z.number(), z.boolean(), z.null()]);
+let JsonValueSchemaInternal: z.ZodType<unknown>;
+JsonValueSchemaInternal = z.lazy(() => z.union([z.record(z.string(), JsonValueSchemaInternal), z.array(JsonValueSchemaInternal), z.string(), z.number(), z.boolean(), z.null()]));
+export const JsonValueSchema = JsonValueSchemaInternal;
 
 export const ContinuationTokenSchema = z.object({ "id": z.string().min(1), "data": JsonValueSchema }).strict();
 

package/src/package-set.ts

@@ -1,4 +1,4 @@
-export const DREAMBOARD_SDK_VERSION = "0.2.0";
+export const DREAMBOARD_SDK_VERSION = "0.2.1-alpha.1";
 
 export const DREAMBOARD_SDK_PACKAGES = {
   "@dreamboard-games/sdk": DREAMBOARD_SDK_VERSION,

package/src/reducer/bundle/ingress-bundle.ts

@@ -320,7 +320,7 @@ export function createReducerBundle<
     }: Wire.InitializeRequest) {
       const { table: parsedTable, playerIds: parsedPlayerIds } =
         codec.parseInitialTable(
-          table as Parameters<typeof codec.parseInitialTable>[0],
+          table as unknown as Parameters<typeof codec.parseInitialTable>[0],
           playerIds,
         );
       return codec.serializeState(

package/src/reducer/bundle/trusted/interaction-types.ts

@@ -54,6 +54,9 @@ type InteractionDescriptorBaseShape<
   interactionKey: `${PhaseName}.${InteractionId}`;
   interactionId: InteractionId;
   commit: InteractionCommitPolicyShape;
+  descriptorDigest?: string;
+  actorSeat?: number;
+  draftDigest?: string;
   zoneId?: ZoneId;
   zoneIds?: readonly ZoneId[];
   inputs: InteractionInputDescriptorShape[];