@dreamboard-games/cli 0.1.30-alpha.0 → 0.1.30-alpha.2

package/dist/runtime-packages/ui-host-runtime/src/gameplay-authority-transport.ts

@@ -1,626 +0,0 @@
-import {
-  GameplayAuthorityRecoveringError,
-  connectGameplayAuthority,
-  type CommandAcceptedFrame,
-  type GameplayAuthorityClient,
-  type GameplayAuthorityWebSocketFactory,
-  type ServerGameplayFrame,
-} from "@dreamboard-games/gameplay-authority-client";
-import fastJsonPatch, { type Operation } from "fast-json-patch";
-import {
-  createGameplayCapability,
-  type CreateGameplayCapabilityData,
-  type GameplayCapabilityResponse,
-  type HostPlayerGameplayView,
-  type HostSessionContext,
-} from "@dreamboard-games/api-client";
-import {
-  defaultHostSessionTransport,
-  type HostSessionTransport,
-} from "./host-session-transport.js";
-import type {
-  HostActionSubmitWireResponse,
-  HostSessionWireSnapshot,
-  HostSessionWireEvent,
-} from "./session-ingress.js";
-import type { GameplayViewport, SessionContext } from "./session-model.js";
-
-export type GameplayCapabilityRequester = (
-  options: Parameters<typeof createGameplayCapability>[0],
-) => ReturnType<typeof createGameplayCapability>;
-
-export type GameplayAuthorityAcceptedMapper = (input: {
-  frame: CommandAcceptedFrame;
-  capability: GameplayCapabilityResponse;
-  submit: SubmitAuthorityInteractionInput;
-  wireContext?: HostSessionContext | null;
-}) => HostActionSubmitWireResponse | Promise<HostActionSubmitWireResponse>;
-
-export interface SubmitAuthorityInteractionInput {
-  sessionId: string;
-  playerId: string;
-  interactionId: string;
-  expectedVersion: number;
-  actionSetVersion: string;
-  params: unknown;
-  clientActionId?: string | null;
-}
-
-export interface GameplayAuthorityTransportOptions {
-  fallbackTransport?: HostSessionTransport;
-  capabilityRequester?: GameplayCapabilityRequester;
-  webSocketFactory?: GameplayAuthorityWebSocketFactory;
-  mapAcceptedFrame?: GameplayAuthorityAcceptedMapper;
-  getCurrentSessionContext?: () => SessionContext | null;
-  getCurrentGameplay?: () => GameplayViewport | null;
-  openTimeoutMs?: number;
-  requestTimeoutMs?: number;
-  randomClientActionId?: () => string;
-}
-
-const DEFAULT_OPEN_TIMEOUT_MS = 5_000;
-const DEFAULT_REQUEST_TIMEOUT_MS = 10_000;
-const { applyPatch, deepClone } = fastJsonPatch;
-
-export function createGameplayAuthorityTransport(
-  options: GameplayAuthorityTransportOptions = {},
-): HostSessionTransport {
-  const fallback = options.fallbackTransport ?? defaultHostSessionTransport;
-  const requester = options.capabilityRequester ?? createGameplayCapability;
-  const webSocketFactory = options.webSocketFactory;
-  const openTimeoutMs = options.openTimeoutMs ?? DEFAULT_OPEN_TIMEOUT_MS;
-  const requestTimeoutMs =
-    options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-  const connections = createGameplayAuthorityConnectionRegistry({
-    requester,
-    webSocketFactory,
-    openTimeoutMs,
-    requestTimeoutMs,
-  });
-
-  return {
-    ...fallback,
-    async submitInteraction(input) {
-      const clientActionId =
-        input.clientActionId ??
-        options.randomClientActionId?.() ??
-        crypto.randomUUID();
-      for (let attempt = 0; attempt < 2; attempt += 1) {
-        const connection = await connections.get({
-          sessionId: input.sessionId,
-          playerId: input.playerId,
-        });
-        try {
-          const frame = await connection.client
-            .submitCommand({
-              clientActionId,
-              expectedVersion: input.expectedVersion,
-              actionSetVersion: input.actionSetVersion,
-              interactionId: input.interactionId,
-              inputs: asInputs(input.params),
-            })
-            .catch((error: unknown) => {
-              throw mapGameplayAuthorityRecoveringError(error);
-            });
-          if (frame.type === "command.rejected") {
-            return {
-              success: false,
-              accepted: false,
-              version: frame.currentVersion ?? input.expectedVersion,
-              actionSetVersion: input.actionSetVersion,
-              errorCode: frame.errorCode,
-              message: frame.message,
-              clientActionId: frame.clientActionId ?? clientActionId,
-            };
-          }
-          if (frame.type !== "command.accepted") {
-            throw new Error("Unexpected gameplay authority frame.");
-          }
-
-          const mapAcceptedFrame =
-            options.mapAcceptedFrame ??
-            (options.getCurrentSessionContext
-              ? async (
-                  mapperInput: Parameters<GameplayAuthorityAcceptedMapper>[0],
-                ) =>
-                  mapGameplayAuthorityAcceptedFrame({
-                    ...mapperInput,
-                    context: options.getCurrentSessionContext?.() ?? null,
-                    wireContext: await loadFreshAuthorityContext({
-                      fallback,
-                      sessionId: input.sessionId,
-                      playerId: input.playerId,
-                    }),
-                  })
-              : null);
-          if (!mapAcceptedFrame) {
-            throw new Error(
-              "Gameplay authority accepted frame mapping is not configured.",
-            );
-          }
-
-          return mapAcceptedFrame({
-            frame,
-            capability: connection.capability,
-            submit: { ...input, clientActionId },
-          });
-        } catch (error) {
-          connections.close(connection);
-          if (attempt === 0 && isGameplaySocketClosedError(error)) {
-            continue;
-          }
-          throw error;
-        }
-      }
-      throw new Error("Gameplay authority submit retry exhausted.");
-    },
-    async subscribeToSessionEvents(input) {
-      if (!input.playerId) {
-        return fallback.subscribeToSessionEvents(input);
-      }
-      return {
-        stream: streamGameplayAuthorityEvents({
-          input,
-          connections,
-          getCurrentSessionContext: options.getCurrentSessionContext,
-          fallback,
-        }),
-      };
-    },
-    async restoreHistory(input) {
-      const context = options.getCurrentSessionContext?.() ?? null;
-      const gameplay = options.getCurrentGameplay?.() ?? null;
-      const entry = context?.history?.entries.find(
-        (candidate) => candidate.id === input.entryId,
-      );
-      if (!context) {
-        throw new Error("Cannot restore history without session context.");
-      }
-      const playerId = context.switchablePlayerIds[0];
-      if (!gameplay) {
-        throw new Error("Cannot restore history without current gameplay.");
-      }
-      if (!playerId) {
-        throw new Error("Cannot restore history without a session player.");
-      }
-      if (!entry) {
-        throw new Error("Cannot restore unknown history entry.");
-      }
-
-      const restoreId = options.randomClientActionId?.() ?? crypto.randomUUID();
-      const connection = await connections.get({
-        sessionId: input.sessionId,
-        playerId,
-      });
-
-      try {
-        const frame = await connection.client
-          .restoreHistory({
-            restoreId,
-            targetGeneration: entry.generation,
-            targetVersion: entry.version,
-          })
-          .catch((error: unknown) => {
-            throw mapGameplayAuthorityRecoveringError(error);
-          });
-        if (frame.type === "history.restoreRejected") {
-          throw new Error(frame.message);
-        }
-        if (frame.type !== "history.restored") {
-          throw new Error("Unexpected gameplay authority restore frame.");
-        }
-        return mapGameplayAuthorityRestoredFrame({
-          frame,
-          context,
-          wireContext: await loadFreshAuthorityContext({
-            fallback,
-            sessionId: input.sessionId,
-            playerId,
-          }),
-        });
-      } catch (error) {
-        connections.close(connection);
-        throw error;
-      }
-    },
-    async validateInteraction(input) {
-      if (!options.getCurrentGameplay) {
-        return fallback.validateInteraction(input);
-      }
-      return validateFromCurrentGameplay({
-        input,
-        gameplay: options.getCurrentGameplay(),
-      });
-    },
-    async disconnectSessionEvents(input) {
-      if (input.playerId) {
-        connections.closeByScope(input.sessionId, input.playerId);
-        return;
-      }
-      connections.closeByScope(input.sessionId);
-      await fallback.disconnectSessionEvents(input);
-    },
-  };
-}
-
-interface GameplayAuthorityConnection {
-  key: string;
-  sessionId: string;
-  playerId: string;
-  capability: GameplayCapabilityResponse;
-  client: GameplayAuthorityClient;
-}
-
-function createGameplayAuthorityConnectionRegistry(options: {
-  requester: GameplayCapabilityRequester;
-  webSocketFactory?: GameplayAuthorityWebSocketFactory;
-  openTimeoutMs: number;
-  requestTimeoutMs: number;
-}) {
-  const connections = new Map<string, Promise<GameplayAuthorityConnection>>();
-
-  return {
-    async get(input: {
-      sessionId: string;
-      playerId: string;
-    }): Promise<GameplayAuthorityConnection> {
-      const key = gameplayAuthorityConnectionKey(input);
-      const existing = connections.get(key);
-      if (existing) {
-        return existing;
-      }
-
-      const pending = openGameplayAuthorityConnection({
-        ...input,
-        key,
-        ...options,
-      });
-      connections.set(key, pending);
-      try {
-        return await pending;
-      } catch (error) {
-        connections.delete(key);
-        throw error;
-      }
-    },
-    close(connection: GameplayAuthorityConnection): void {
-      connections.delete(connection.key);
-      connection.client.close();
-    },
-    closeByScope(sessionId: string, playerId?: string): void {
-      for (const [key, pending] of connections) {
-        if (!keyMatchesScope(key, sessionId, playerId)) continue;
-        connections.delete(key);
-        void pending
-          .then((connection) => connection.client.close())
-          .catch(() => undefined);
-      }
-    },
-  };
-}
-
-function isGameplaySocketClosedError(error: unknown): boolean {
-  return error instanceof Error && error.message === "gameplay socket closed";
-}
-
-async function openGameplayAuthorityConnection(input: {
-  key: string;
-  sessionId: string;
-  playerId: string;
-  requester: GameplayCapabilityRequester;
-  webSocketFactory?: GameplayAuthorityWebSocketFactory;
-  openTimeoutMs: number;
-  requestTimeoutMs: number;
-}): Promise<GameplayAuthorityConnection> {
-  const capability = await requestCapability(input.requester, {
-    path: { sessionId: input.sessionId, playerId: input.playerId },
-  });
-  const client = await connectGameplayAuthority({
-    websocketUrl: capability.websocketUrl,
-    capabilityToken: capability.token,
-    webSocketFactory: input.webSocketFactory,
-    openTimeoutMs: input.openTimeoutMs,
-    requestTimeoutMs: input.requestTimeoutMs,
-  });
-  return {
-    key: input.key,
-    sessionId: input.sessionId,
-    playerId: input.playerId,
-    capability,
-    client,
-  };
-}
-
-function gameplayAuthorityConnectionKey(input: {
-  sessionId: string;
-  playerId: string;
-}): string {
-  return `${input.sessionId}\u0000${input.playerId}`;
-}
-
-function keyMatchesScope(
-  key: string,
-  sessionId: string,
-  playerId?: string,
-): boolean {
-  const [keySessionId, keyPlayerId] = key.split("\u0000");
-  return keySessionId === sessionId && (!playerId || keyPlayerId === playerId);
-}
-
-export function mapGameplayAuthorityAcceptedFrame(input: {
-  frame: CommandAcceptedFrame;
-  capability: GameplayCapabilityResponse;
-  submit: SubmitAuthorityInteractionInput;
-  context: SessionContext | null;
-  wireContext?: HostSessionContext | null;
-}): HostActionSubmitWireResponse {
-  if (!input.context) {
-    throw new Error("Cannot map authority update without session context.");
-  }
-  if (input.frame.update.kind !== "snapshot") {
-    throw new Error("Authority delta updates are not supported yet.");
-  }
-  const gameplay = input.frame.update.view as HostPlayerGameplayView;
-  return {
-    success: true,
-    accepted: true,
-    durabilityStatus: "COMMITTED",
-    version: input.frame.version,
-    actionSetVersion: gameplay.actionSetVersion,
-    clientActionId: input.frame.clientActionId,
-    update: {
-      type: "session.gameplayUpdated",
-      context: input.wireContext ?? toHostSessionContext(input.context),
-      gameplay,
-      causation: { clientActionId: input.frame.clientActionId },
-    },
-  };
-}
-
-function toHostSessionContext(context: SessionContext): HostSessionContext {
-  return {
-    sessionId: context.identity.sessionId,
-    shortCode: context.identity.shortCode,
-    phase: "gameplay",
-    status: context.status,
-    hostActor: context.hostActor,
-    gameSource: context.gameSource,
-    setupProfileId: context.setupProfileId ?? undefined,
-    switchablePlayerIds: context.switchablePlayerIds,
-    history: context.history ?? undefined,
-  };
-}
-
-async function* streamGameplayAuthorityEvents(options: {
-  input: Parameters<HostSessionTransport["subscribeToSessionEvents"]>[0];
-  connections: ReturnType<typeof createGameplayAuthorityConnectionRegistry>;
-  getCurrentSessionContext?: () => SessionContext | null;
-  fallback: HostSessionTransport;
-}): AsyncGenerator<HostSessionWireEvent | null | undefined> {
-  const playerId = options.input.playerId;
-  if (!playerId) return;
-  const connection = await options.connections.get({
-    sessionId: options.input.sessionId,
-    playerId,
-  });
-  const frameIterator = connection.client.frames(options.input.signal);
-  let lastProjectedView: HostPlayerGameplayView | null = null;
-  let lastGeneration: number | null = null;
-  let lastVersion: number | null = null;
-
-  try {
-    connection.client.resume();
-
-    for await (const frame of frameIterator) {
-      if (frame.type === "authority.recovering") {
-        throw recoveringProblem(frame.message, frame.retryAfterMs);
-      }
-      if (frame.type === "session.snapshot") {
-        lastProjectedView = frame.update.view as HostPlayerGameplayView;
-        lastGeneration = frame.generation;
-        lastVersion = frame.version;
-        yield mapGameplayAuthoritySnapshotFrame({
-          frame,
-          context: options.getCurrentSessionContext?.() ?? null,
-          wireContext: await loadFreshAuthorityContext({
-            fallback: options.fallback,
-            sessionId: options.input.sessionId,
-            playerId,
-          }),
-        });
-        continue;
-      }
-      if (frame.type === "session.delta") {
-        const delta = applyGameplayAuthorityDelta({
-          frame,
-          previousView: lastProjectedView,
-          previousGeneration: lastGeneration,
-          previousVersion: lastVersion,
-        });
-        lastProjectedView = delta.view;
-        lastGeneration = delta.generation;
-        lastVersion = delta.version;
-        yield gameplayUpdatedEvent({
-          context: options.getCurrentSessionContext?.() ?? null,
-          wireContext: await loadFreshAuthorityContext({
-            fallback: options.fallback,
-            sessionId: options.input.sessionId,
-            playerId,
-          }),
-          gameplay: delta.view,
-        });
-      }
-    }
-  } finally {
-    await frameIterator.return?.(undefined);
-    options.connections.close(connection);
-  }
-}
-
-function mapGameplayAuthoritySnapshotFrame(input: {
-  frame: Extract<ServerGameplayFrame, { type: "session.snapshot" }>;
-  context: SessionContext | null;
-  wireContext?: HostSessionContext | null;
-}): HostSessionWireEvent {
-  if (!input.context) {
-    throw new Error("Cannot map authority snapshot without session context.");
-  }
-  return gameplayUpdatedEvent({
-    context: input.context,
-    wireContext: input.wireContext,
-    gameplay: input.frame.update.view as HostPlayerGameplayView,
-  });
-}
-
-function mapGameplayAuthorityRestoredFrame(input: {
-  frame: Extract<ServerGameplayFrame, { type: "history.restored" }>;
-  context: SessionContext | null;
-  wireContext?: HostSessionContext | null;
-}): HostSessionWireEvent {
-  if (!input.context) {
-    throw new Error("Cannot map authority restore without session context.");
-  }
-  return gameplayUpdatedEvent({
-    context: input.context,
-    wireContext: input.wireContext,
-    gameplay: input.frame.update.view as HostPlayerGameplayView,
-  });
-}
-
-function gameplayUpdatedEvent(input: {
-  context: SessionContext | null;
-  wireContext?: HostSessionContext | null;
-  gameplay: HostPlayerGameplayView;
-}): HostSessionWireEvent {
-  if (!input.context) {
-    throw new Error(
-      "Cannot map authority gameplay update without session context.",
-    );
-  }
-  return {
-    type: "session.gameplayUpdated",
-    context: input.wireContext ?? toHostSessionContext(input.context),
-    gameplay: input.gameplay,
-  };
-}
-
-async function loadFreshAuthorityContext(input: {
-  fallback: HostSessionTransport;
-  sessionId: string;
-  playerId: string;
-}): Promise<HostSessionWireSnapshot["context"]> {
-  const snapshot = await input.fallback.loadSessionSnapshot({
-    sessionId: input.sessionId,
-    requestedPlayerId: input.playerId,
-  });
-  return snapshot.context;
-}
-
-function applyGameplayAuthorityDelta(input: {
-  frame: Extract<ServerGameplayFrame, { type: "session.delta" }>;
-  previousView: HostPlayerGameplayView | null;
-  previousGeneration: number | null;
-  previousVersion: number | null;
-}): {
-  generation: number;
-  version: number;
-  view: HostPlayerGameplayView;
-} {
-  const update = input.frame.update;
-  if (!input.previousView) {
-    throw new Error("Authority delta arrived before a base snapshot.");
-  }
-  if (
-    input.previousGeneration !== update.generation ||
-    input.previousVersion !== update.baseVersion
-  ) {
-    throw new Error(
-      "Authority delta base does not match current gameplay snapshot.",
-    );
-  }
-
-  return {
-    generation: update.generation,
-    version: update.version,
-    view: applyPatch(
-      deepClone(input.previousView),
-      update.patch as Operation[],
-      true,
-      false,
-      true,
-    ).newDocument as HostPlayerGameplayView,
-  };
-}
-
-function validateFromCurrentGameplay(input: {
-  input: Parameters<HostSessionTransport["validateInteraction"]>[0];
-  gameplay: GameplayViewport | null;
-}) {
-  const gameplay = input.gameplay;
-  if (!gameplay) {
-    return {
-      valid: false,
-      errorCode: "runtime-unavailable",
-      message: "No renderable gameplay snapshot is available.",
-    };
-  }
-
-  const descriptor = gameplay.availableInteractions.find(
-    (candidate) =>
-      candidate.interactionId === input.input.interactionId ||
-      candidate.interactionKey === input.input.interactionId,
-  );
-  if (!descriptor) {
-    return {
-      valid: false,
-      errorCode: "interaction-unavailable",
-      message: "Interaction is not available.",
-    };
-  }
-  if (descriptor.availability.status !== "available") {
-    return {
-      valid: false,
-      errorCode: "interaction-unavailable",
-      message:
-        descriptor.availability.reason ?? "Interaction is not available.",
-    };
-  }
-  return { valid: true };
-}
-
-async function requestCapability(
-  requester: GameplayCapabilityRequester,
-  options: Pick<CreateGameplayCapabilityData, "path">,
-): Promise<GameplayCapabilityResponse> {
-  const result = await requester(options);
-  if ("error" in result && result.error) {
-    throw result.error;
-  }
-  if (!result.data) {
-    throw new Error("Failed to create gameplay capability.");
-  }
-  return result.data;
-}
-
-function asInputs(params: unknown): Record<string, unknown> {
-  return params && typeof params === "object" && !Array.isArray(params)
-    ? (params as Record<string, unknown>)
-    : {};
-}
-
-function recoveringProblem(detail: string, retryAfterMs: number) {
-  return {
-    title: "Session recovering",
-    status: 503,
-    detail,
-    retryable: true,
-    context: { retryAfterMs },
-  };
-}
-
-function mapGameplayAuthorityRecoveringError(error: unknown): unknown {
-  if (error instanceof GameplayAuthorityRecoveringError) {
-    return recoveringProblem(error.message, error.retryAfterMs);
-  }
-  return error;
-}

package/dist/runtime-packages/ui-host-runtime/src/host-controls.tsx

@@ -1 +0,0 @@
-export * from "./components/host-controls.js";

package/dist/runtime-packages/ui-host-runtime/src/host-feedback.tsx

@@ -1 +0,0 @@
-export * from "./components/host-feedback.js";