dreamboard 0.1.21 → 0.1.23

package/dist/runtime-packages/ui-host-runtime/src/sse-manager.ts

@@ -0,0 +1,334 @@
+import type { HostSessionTransport } from "./host-session-transport.js";
+import { defaultHostSessionTransport } from "./host-session-transport.js";
+import type { LoggerLike } from "./logger.js";
+import { consoleLogger } from "./logger.js";
+import { PERF_MARK_NAMES, findActionIdByVersion, recordMark } from "./perf.js";
+import type { HostSessionWireEvent } from "./session-ingress.js";
+
+type HostSessionEventType = HostSessionWireEvent["type"];
+
+type ExtractHostSessionEvent<T extends HostSessionEventType> = Extract<
+  HostSessionWireEvent,
+  { type: T }
+>;
+
+type HostSessionEventHandler<
+  T extends HostSessionEventType = HostSessionEventType,
+> = (data: ExtractHostSessionEvent<T>) => void;
+type ConnectionEventHandler = () => void;
+type ErrorEventHandler = (error: unknown) => void;
+type AnyHostSessionEventHandler = (data: HostSessionWireEvent) => void;
+type EventHandler =
+  | AnyHostSessionEventHandler
+  | ConnectionEventHandler
+  | ErrorEventHandler;
+
+export interface SSEManagerOptions {
+  clientId?: string;
+  logger?: LoggerLike;
+  transport?: Pick<
+    HostSessionTransport,
+    "subscribeToSessionEvents" | "disconnectSessionEvents"
+  >;
+}
+
+export interface SSEConnectOptions {
+  source?: string;
+  playerId?: string;
+}
+
+interface ActiveConnection {
+  connectionAttemptId: string;
+  sessionId: string;
+  playerId?: string;
+  source?: string;
+}
+
+const TAB_ID_SESSION_STORAGE_KEY = "dreamboard.sse.tab-id";
+
+function randomId(): string {
+  if (
+    typeof crypto !== "undefined" &&
+    typeof crypto.randomUUID === "function"
+  ) {
+    return crypto.randomUUID();
+  }
+  return `sse-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+
+function getOrCreateTabId(): string {
+  if (typeof window === "undefined") {
+    return randomId();
+  }
+
+  try {
+    const existing = window.sessionStorage.getItem(TAB_ID_SESSION_STORAGE_KEY);
+    if (existing) {
+      return existing;
+    }
+
+    const created = randomId();
+    window.sessionStorage.setItem(TAB_ID_SESSION_STORAGE_KEY, created);
+    return created;
+  } catch {
+    return randomId();
+  }
+}
+
+function isAbortLikeError(error: unknown): boolean {
+  return error instanceof Error && error.name === "AbortError";
+}
+
+export class SSEManager {
+  private abortController: AbortController | null = null;
+  private activeConnection: ActiveConnection | null = null;
+  private readonly clientId: string;
+  private readonly transport: Pick<
+    HostSessionTransport,
+    "subscribeToSessionEvents" | "disconnectSessionEvents"
+  >;
+  private handlers: Map<string, Set<EventHandler>> = new Map();
+  private anyMessageHandlers: Set<AnyHostSessionEventHandler> = new Set();
+  private isConnected = false;
+  private messageBuffer: HostSessionWireEvent[] = [];
+  private logger: LoggerLike;
+  private pageHideHandler: (() => void) | null = null;
+
+  constructor(options: SSEManagerOptions = {}) {
+    this.clientId = options.clientId ?? getOrCreateTabId();
+    this.logger = options.logger ?? consoleLogger;
+    this.transport = options.transport ?? defaultHostSessionTransport;
+  }
+
+  async connect(sessionId: string, options: SSEConnectOptions) {
+    if (this.abortController) {
+      this.disconnect();
+    }
+
+    this.abortController = new AbortController();
+    const connection: ActiveConnection = {
+      sessionId,
+      playerId: options.playerId,
+      connectionAttemptId: randomId(),
+      source: options.source,
+    };
+    this.activeConnection = connection;
+    this.registerPageHideHandler();
+
+    try {
+      let connected = false;
+      let streamError: unknown = null;
+
+      const stream = (
+        await this.transport.subscribeToSessionEvents({
+          sessionId,
+          clientId: this.clientId,
+          connectionAttemptId: connection.connectionAttemptId,
+          clientSource: options.source,
+          playerId: connection.playerId,
+          signal: this.abortController.signal,
+          onSseError: (error) => {
+            if (
+              this.abortController?.signal.aborted ||
+              isAbortLikeError(error)
+            ) {
+              return;
+            }
+            streamError = error;
+          },
+        })
+      ).stream;
+
+      for await (const event of stream) {
+        if (!event) continue;
+        if (!connected) {
+          connected = true;
+          this.isConnected = true;
+          this.emit("connected", null);
+        }
+
+        const eventType = event.type;
+
+        if (eventType) {
+          // Tier-0 perf: record `t4_sse_received` the moment the SSE
+          // stream yields a gameplay.updated for a version we submitted.
+          // Stitching is done via the version -> actionId map populated
+          // at t3 in runtime-api.
+          if (eventType === "session.gameplayUpdated") {
+            const version = event.gameplay?.version;
+            if (typeof version === "number") {
+              const actionId = findActionIdByVersion(version);
+              if (actionId) {
+                recordMark(actionId, PERF_MARK_NAMES.T4_SSE_RECEIVED, {
+                  extra: { version },
+                });
+              }
+            }
+          }
+          this.emit(eventType, event);
+        } else {
+          this.logger.error("[SSEManager] Received event without type:", event);
+        }
+      }
+
+      if (streamError) {
+        this.logger.error("[SSEManager] SSE error:", streamError);
+        this.emit("error", streamError);
+        this.isConnected = false;
+        this.emit("disconnected", null);
+        return;
+      }
+
+      this.isConnected = false;
+      this.emit("disconnected", null);
+    } catch (error) {
+      if (isAbortLikeError(error)) {
+        return;
+      }
+
+      this.logger.error("[SSEManager] SSE error:", error);
+      this.emit("error", error);
+      this.isConnected = false;
+      this.emit("disconnected", null);
+    } finally {
+      if (
+        this.activeConnection?.connectionAttemptId ===
+        connection.connectionAttemptId
+      ) {
+        this.activeConnection = null;
+        this.unregisterPageHideHandler();
+      }
+    }
+  }
+
+  on<T extends HostSessionEventType>(
+    eventType: T,
+    handler: HostSessionEventHandler<T>,
+  ): () => void;
+  on(
+    eventType: "connected" | "disconnected",
+    handler: ConnectionEventHandler,
+  ): () => void;
+  on(eventType: "error", handler: ErrorEventHandler): () => void;
+  on(eventType: string, handler: EventHandler): () => void {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, new Set());
+    }
+    const handlers = this.handlers.get(eventType);
+    if (handlers) {
+      handlers.add(handler);
+    }
+
+    return () => {
+      this.handlers.get(eventType)?.delete(handler);
+    };
+  }
+
+  onAnyMessage(handler: AnyHostSessionEventHandler): () => void {
+    this.anyMessageHandlers.add(handler);
+
+    if (this.messageBuffer.length > 0) {
+      this.messageBuffer.forEach((message) => {
+        handler(message);
+      });
+    }
+
+    return () => {
+      this.anyMessageHandlers.delete(handler);
+    };
+  }
+
+  private emit(eventType: string, data: HostSessionWireEvent): void;
+  private emit(eventType: "connected" | "disconnected", data: null): void;
+  private emit(eventType: "error", error: unknown): void;
+  private emit(
+    eventType: string,
+    data: HostSessionWireEvent | null | unknown,
+  ): void {
+    const handlers = this.handlers.get(eventType);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        if (eventType === "connected" || eventType === "disconnected") {
+          (handler as ConnectionEventHandler)();
+        } else if (eventType === "error") {
+          (handler as ErrorEventHandler)(data);
+        } else {
+          (handler as AnyHostSessionEventHandler)(data as HostSessionWireEvent);
+        }
+      });
+    }
+
+    if (
+      eventType !== "connected" &&
+      eventType !== "disconnected" &&
+      eventType !== "error"
+    ) {
+      this.messageBuffer.push(data as HostSessionWireEvent);
+
+      this.anyMessageHandlers.forEach((handler) => {
+        handler(data as HostSessionWireEvent);
+      });
+    }
+  }
+
+  disconnect() {
+    const activeConnection = this.activeConnection;
+    if (activeConnection) {
+      this.notifyDisconnect(activeConnection, true);
+    }
+
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.activeConnection = null;
+    this.unregisterPageHideHandler();
+    this.isConnected = false;
+    this.handlers.clear();
+    this.anyMessageHandlers.clear();
+    this.messageBuffer = [];
+  }
+
+  isStreamConnected(): boolean {
+    return this.isConnected;
+  }
+
+  private notifyDisconnect(
+    connection: ActiveConnection,
+    _keepalive: boolean,
+  ): void {
+    const request = this.transport.disconnectSessionEvents({
+      sessionId: connection.sessionId,
+      clientId: this.clientId,
+      connectionAttemptId: connection.connectionAttemptId,
+      playerId: connection.playerId,
+    });
+
+    void request.catch((error) => {
+      this.logger.error("[SSEManager] Failed to notify disconnect:", error);
+    });
+  }
+
+  private registerPageHideHandler(): void {
+    if (typeof window === "undefined" || this.pageHideHandler) {
+      return;
+    }
+
+    this.pageHideHandler = () => {
+      if (this.activeConnection) {
+        this.notifyDisconnect(this.activeConnection, true);
+      }
+    };
+
+    window.addEventListener("pagehide", this.pageHideHandler);
+  }
+
+  private unregisterPageHideHandler(): void {
+    if (typeof window === "undefined" || !this.pageHideHandler) {
+      return;
+    }
+
+    window.removeEventListener("pagehide", this.pageHideHandler);
+    this.pageHideHandler = null;
+  }
+}

package/dist/runtime-packages/ui-host-runtime/src/unified-session-store.ts

@@ -0,0 +1,180 @@
+import { createStore } from "zustand/vanilla";
+import { subscribeWithSelector } from "zustand/middleware";
+import type { StoreApi } from "zustand/vanilla";
+import type { PluginStateSnapshot as UiSdkPluginStateSnapshot } from "@dreamboard/ui-sdk/reducer";
+import type { LoggerLike } from "./logger.js";
+import { consoleLogger } from "./logger.js";
+import type { HostSessionTransport } from "./host-session-transport.js";
+import { defaultHostSessionTransport } from "./host-session-transport.js";
+import type { GameplayViewport } from "./session-model.js";
+import {
+  getGameplayViewport,
+  getSessionContext,
+  resolveControllablePlayerIds,
+} from "./session-model.js";
+import type { SSEManagerLike } from "./session-live-runtime.js";
+import { createSessionIngressController } from "./session-ingress-controller.js";
+import type { SessionIngressControllerActions } from "./session-ingress-controller.js";
+import {
+  createInitialUnifiedSessionState,
+  type UnifiedSessionState,
+} from "./session-state-reducer.js";
+import {
+  selectBootstrapStatus,
+  selectGameplayViewModel,
+  selectGameplayViewport,
+  selectHistory,
+  selectLobbyViewModel,
+  selectPluginSnapshot,
+  selectSessionContext,
+  selectSessionError,
+  selectSessionType,
+} from "./session-projection.js";
+
+export type {
+  GameplayViewport,
+  HistoryState,
+  SessionContext,
+  SessionIdentity,
+  SessionPhase,
+  UnifiedSessionModel,
+} from "./session-model.js";
+export type {
+  BootstrapStatus,
+  GameplayViewModel,
+  LobbyViewModel,
+} from "./session-projection.js";
+export type { SSEManagerLike } from "./session-live-runtime.js";
+export type {
+  ActivityState,
+  ConnectionState,
+  DebugState,
+  HostFeedback,
+  HostFeedbackPayload,
+  HostFeedbackType,
+  Notification,
+  NotificationPayload,
+  NotificationType,
+  SSEEventEntry,
+  UnifiedSessionState,
+} from "./session-state-reducer.js";
+
+export type PluginStateSnapshot = UiSdkPluginStateSnapshot;
+export type GameplayState = GameplayViewport;
+
+export interface UnifiedSessionActions extends SessionIngressControllerActions {
+  getPluginSnapshot: () => PluginStateSnapshot;
+  getRenderableGameplay: () => GameplayViewport | null;
+}
+
+export type UnifiedSessionStore = UnifiedSessionState & UnifiedSessionActions;
+
+export interface CreateUnifiedSessionStoreOptions {
+  createSseManager: () => SSEManagerLike;
+  transport?: HostSessionTransport;
+  logger?: LoggerLike;
+  fallbackToAllSeatsWhenUserIdMissing?: boolean;
+}
+
+let sseEventIdCounter = 0;
+let notificationIdCounter = 0;
+const EMPTY_ARRAY: never[] = [];
+
+function generateNotificationId(): string {
+  return `notif-${++notificationIdCounter}-${Date.now()}`;
+}
+
+export function createUnifiedSessionStore(
+  options: CreateUnifiedSessionStoreOptions,
+): StoreApi<UnifiedSessionStore> {
+  const logger = options.logger ?? consoleLogger;
+  const transport = options.transport ?? defaultHostSessionTransport;
+  const fallbackToAllSeatsWhenUserIdMissing =
+    options.fallbackToAllSeatsWhenUserIdMissing ?? false;
+
+  return createStore<UnifiedSessionStore>()(
+    subscribeWithSelector((_, get, store) => {
+      const controller = createSessionIngressController({
+        store,
+        createSseManager: options.createSseManager,
+        transport,
+        logger,
+        fallbackToAllSeatsWhenUserIdMissing,
+        reducerEnvironment: {
+          fallbackToAllSeatsWhenUserIdMissing,
+          nextEventId: () => ++sseEventIdCounter,
+          nextNotificationId: generateNotificationId,
+          nowMs: () => Date.now(),
+          nowIso: () => new Date().toISOString(),
+        },
+      });
+
+      return {
+        ...createInitialUnifiedSessionState(),
+        ...controller,
+        getPluginSnapshot: () =>
+          selectPluginSnapshot(get(), fallbackToAllSeatsWhenUserIdMissing),
+        getRenderableGameplay: () => getGameplayViewport(get().session),
+      };
+    }),
+  );
+}
+
+export const unifiedSessionSelectors = {
+  sessionType: selectSessionType,
+  bootstrapStatus: selectBootstrapStatus,
+  sessionContext: selectSessionContext,
+  lobby: selectLobbyViewModel,
+  gameplay: selectGameplayViewModel,
+  gameplayViewport: selectGameplayViewport,
+  hasGameplayPayload: (s: UnifiedSessionStore) =>
+    getGameplayViewport(s.session) !== null,
+  history: selectHistory,
+  isConnected: (s: UnifiedSessionStore) => s.connection.isConnected,
+  connectionError: (s: UnifiedSessionStore) => s.connection.error,
+  isLoading: (s: UnifiedSessionStore) =>
+    s.session.type === "loading" || s.session.type === "gameplayLoading",
+  error: selectSessionError,
+  sessionId: (s: UnifiedSessionStore) =>
+    getSessionContext(s.session)?.identity.sessionId ?? null,
+  shortCode: (s: UnifiedSessionStore) =>
+    getSessionContext(s.session)?.identity.shortCode ?? "",
+  gameId: (s: UnifiedSessionStore) =>
+    getSessionContext(s.session)?.identity.gameId ?? null,
+  seats: (s: UnifiedSessionStore) =>
+    getSessionContext(s.session)?.seats ?? EMPTY_ARRAY,
+  canStart: (s: UnifiedSessionStore) =>
+    getSessionContext(s.session)?.canStart ?? false,
+  hostActor: (s: UnifiedSessionStore) =>
+    getSessionContext(s.session)?.hostActor ?? null,
+  isSessionHost: (s: UnifiedSessionStore) =>
+    selectLobbyViewModel(s)?.isSessionHost ?? false,
+  controllablePlayerIds: (s: UnifiedSessionStore) => {
+    const context = getSessionContext(s.session);
+    return context
+      ? resolveControllablePlayerIds(
+          context.switchablePlayerIds,
+          context.seats,
+          context.userId,
+        )
+      : EMPTY_ARRAY;
+  },
+  controllingPlayerId: (s: UnifiedSessionStore) =>
+    s.session.type === "gameplay" ? s.session.perspective.playerId : null,
+  currentPlayerId: (s: UnifiedSessionStore) =>
+    s.session.type === "gameplay"
+      ? s.session.perspective.playerId
+      : s.session.type === "gameplayLoading"
+        ? s.session.requestedPlayerId
+        : s.session.type === "lobby"
+          ? s.session.preferredPlayerId
+          : null,
+  userId: (s: UnifiedSessionStore) =>
+    getSessionContext(s.session)?.userId ?? null,
+  notifications: (s: UnifiedSessionStore) => s.activity.notifications,
+  hostFeedback: (s: UnifiedSessionStore) => s.activity.hostFeedback,
+  sseEvents: (s: UnifiedSessionStore) => s.debug.sseEvents,
+  syncId: (s: UnifiedSessionStore) => s.activity.syncId,
+  activity: (s: UnifiedSessionStore) => s.activity,
+  debug: (s: UnifiedSessionStore) => s.debug,
+};

package/dist/scaffold/assets/static/app/tsconfig.framework.json

@@ -5,8 +5,10 @@
     "moduleResolution": "bundler",
     "strict": true,
     "esModuleInterop": true,
-    "skipLibCheck": true,
+    "skipLibCheck": false,
+    "types": [],
     "declaration": false,
+    "rootDir": "..",
     "outDir": "./dist",
     "paths": {
       "@dreamboard/manifest-contract": ["../shared/manifest-contract.ts"],

package/dist/scaffold/assets/static/ui/tsconfig.framework.json

@@ -6,26 +6,14 @@
     "jsx": "react-jsx",
     "strict": true,
     "esModuleInterop": true,
-    "skipLibCheck": true,
+    "skipLibCheck": false,
+    "types": [],
     "paths": {
-      "@dreamboard/manifest-contract": [
-        "../shared/manifest-contract.ts"
-      ],
-      "@dreamboard/ui-contract": [
-        "../shared/generated/ui-contract.ts"
-      ],
-      "@shared/*": [
-        "../shared/*"
-      ]
+      "@dreamboard/manifest-contract": ["../shared/manifest-contract.ts"],
+      "@dreamboard/ui-contract": ["../shared/generated/ui-contract.ts"],
+      "@shared/*": ["../shared/*"]
     }
   },
-  "include": [
-    "./**/*.ts",
-    "./**/*.tsx",
-    "../shared/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
+  "include": ["./**/*.ts", "./**/*.tsx", "../shared/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dreamboard",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Design board games with AI and turn ideas into playable digital prototypes.",
   "type": "module",
   "bin": {
@@ -9,8 +9,6 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE",
-    "NOTICE",
     "skills"
   ],
   "keywords": [
@@ -44,26 +42,63 @@
     "vite": "^5.4.19",
     "zod": "4.4.3",
     "zustand": "^5.0.4",
-    "@dreamboard/api-client": "npm:@dreamboard-games/api-client@^0.1.2",
-    "@dreamboard/app-sdk": "npm:@dreamboard-games/app-sdk@^0.0.45",
-    "@dreamboard/reducer-contract": "npm:@dreamboard-games/reducer-contract@^7.0.2",
-    "@dreamboard/sdk-types": "npm:@dreamboard-games/sdk-types@^0.1.2",
-    "@dreamboard/testing": "npm:@dreamboard-games/testing@^0.1.3",
-    "@dreamboard/ui-sdk": "npm:@dreamboard-games/ui-sdk@^0.0.46",
-    "@dreamboard/workspace-codegen": "npm:@dreamboard-games/workspace-codegen@^0.1.4",
+    "@dreamboard-games/api-client": "^0.1.0",
+    "@dreamboard-games/sdk-types": "^0.1.0",
+    "@dreamboard-games/ui-sdk": "^0.0.41",
+    "@hookform/resolvers": "^5.2.2",
+    "@radix-ui/react-accordion": "^1.2.12",
+    "@radix-ui/react-alert-dialog": "^1.1.14",
+    "@radix-ui/react-avatar": "^1.1.11",
+    "@radix-ui/react-collapsible": "^1.1.12",
+    "@radix-ui/react-context-menu": "^2.2.16",
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-dropdown-menu": "^2.1.15",
+    "@radix-ui/react-hover-card": "^1.1.15",
+    "@radix-ui/react-label": "^2.1.6",
+    "@radix-ui/react-navigation-menu": "^1.2.13",
+    "@radix-ui/react-popover": "^1.1.13",
+    "@radix-ui/react-progress": "^1.1.7",
+    "@radix-ui/react-radio-group": "^1.3.7",
+    "@radix-ui/react-scroll-area": "^1.2.10",
+    "@radix-ui/react-select": "^2.2.5",
+    "@radix-ui/react-separator": "^1.1.7",
+    "@radix-ui/react-slot": "^1.1.2",
+    "@radix-ui/react-switch": "^1.2.5",
+    "@radix-ui/react-tabs": "^1.1.12",
+    "@radix-ui/react-tooltip": "^1.2.8",
+    "@radix-ui/react-use-controllable-state": "^1.2.2",
+    "@xyflow/react": "^12.9.2",
+    "ai": "^5.0.88",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
+    "embla-carousel-react": "^8.6.0",
+    "framer-motion": "^12.12.1",
+    "motion": "^12.12.2",
+    "nanoid": "^5.1.6",
+    "next-themes": "^0.4.4",
+    "radix-ui": "^1.4.3",
+    "react-dropzone": "^14.3.8",
+    "react-hook-form": "^7.66.0",
+    "react-resizable-panels": "^3.0.6",
+    "react-textarea-autosize": "^8.5.9",
+    "shiki": "^3.15.0",
+    "streamdown": "^1.4.0",
+    "tailwind-merge": "^3.0.1",
+    "tokenlens": "^1.3.1",
+    "use-stick-to-bottom": "^1.1.1",
+    "vaul": "^1.1.2",
     "playwright": "^1.50.1"
   },
   "optionalDependencies": {
     "@napi-rs/keyring": "^1.2.0"
   },
   "dreamboardSdkDependencyRanges": {
-    "@dreamboard/api-client": "npm:@dreamboard-games/api-client@^0.1.2",
-    "@dreamboard/app-sdk": "npm:@dreamboard-games/app-sdk@^0.0.45",
-    "@dreamboard/reducer-contract": "npm:@dreamboard-games/reducer-contract@^7.0.2",
-    "@dreamboard/sdk-types": "npm:@dreamboard-games/sdk-types@^0.1.2",
-    "@dreamboard/testing": "npm:@dreamboard-games/testing@^0.1.3",
-    "@dreamboard/ui-sdk": "npm:@dreamboard-games/ui-sdk@^0.0.46",
-    "@dreamboard/workspace-codegen": "npm:@dreamboard-games/workspace-codegen@^0.1.4"
+    "@dreamboard/api-client": "npm:@dreamboard-games/api-client@^0.1.0",
+    "@dreamboard/app-sdk": "npm:@dreamboard-games/app-sdk@^0.0.41",
+    "@dreamboard/sdk-types": "npm:@dreamboard-games/sdk-types@^0.1.0",
+    "@dreamboard/testing": "npm:@dreamboard-games/testing@^0.1.0",
+    "@dreamboard/ui-sdk": "npm:@dreamboard-games/ui-sdk@^0.0.41"
   },
   "license": "SEE LICENSE IN LICENSE",
   "repository": {