@dreamboard-games/sdk 0.4.0-alpha.0 → 0.4.0-alpha.2

package/dist/runtime.js

@@ -1,490 +1,140 @@
 import {
   createWorkspaceUIContract
-} from "./chunk-4G7552LO.js";
-import {
-  InteractionUiProvider,
-  RuntimeProvider,
-  RuntimeSemanticProjectionMarker,
-  usePluginSession
-} from "./chunk-P7F4L2FF.js";
-import "./chunk-2LDZ5C3T.js";
+} from "./chunk-6JQFGSLD.js";
+import "./chunk-WOWFONLZ.js";
+import "./chunk-FWVV2X74.js";
 import "./chunk-T3ZKNUZ7.js";
 import {
   GameSkeleton
-} from "./chunk-Q5O7GPVY.js";
+} from "./chunk-45FI6XII.js";
 import "./chunk-VDXOF4FW.js";
-import "./chunk-QLG6VEMW.js";
+import {
+  PluginRuntimeBoundary,
+  createPluginRuntimeClient
+} from "./chunk-K5ZRJTZZ.js";
+import {
+  DREAMBOARD_PLUGIN_PROTOCOL,
+  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
+  HostToPluginEnvelopeSchema
+} from "./chunk-O6M6PN4E.js";
+import "./chunk-WUIVY2KE.js";
+import "./chunk-PF7L4BMG.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/runtime/hooks/usePluginRuntime.ts
 import { useState, useEffect, useRef } from "react";
 
-// src/runtime/api/createPluginRuntimeAPI.ts
-import { z } from "zod";
-var InitMessageSchema = z.object({
-  type: z.literal("init"),
-  sessionId: z.string(),
-  controllablePlayerIds: z.array(z.string()),
-  controllingPlayerId: z.string(),
-  userId: z.string().nullable()
-});
-var PingMessageSchema = z.object({
-  type: z.literal("ping")
-});
-var StateSyncMessageSchema = z.object({
-  type: z.literal("state-sync"),
-  syncId: z.number(),
-  state: z.custom((data) => {
-    return typeof data === "object" && data !== null && "session" in data && "notifications" in data;
-  })
-});
-var ValidateInteractionResultMessageSchema = z.object({
-  type: z.literal("validate-interaction-result"),
-  messageId: z.string(),
-  result: z.object({
-    valid: z.boolean(),
-    errorCode: z.string().nullable().optional(),
-    message: z.string().nullable().optional()
-  })
-});
-var SubmitResultMessageSchema = z.object({
-  type: z.literal("submit-result"),
-  messageId: z.string(),
-  accepted: z.boolean(),
-  errorCode: z.string().nullable().optional(),
-  message: z.string().nullable().optional()
-});
-var MainToPluginMessageSchema = z.discriminatedUnion("type", [
-  InitMessageSchema,
-  PingMessageSchema,
-  StateSyncMessageSchema,
-  ValidateInteractionResultMessageSchema,
-  SubmitResultMessageSchema
-]);
-var mintClientActionId = () => {
-  const cryptoLike = globalThis.crypto;
-  if (cryptoLike?.randomUUID) {
-    try {
-      return cryptoLike.randomUUID();
-    } catch {
-    }
-  }
-  const rand = Math.random().toString(16).slice(2);
-  return `cid-${Date.now().toString(16)}-${rand}`;
-};
-var PLUGIN_RUNTIME_SINGLETON_KEY = "__dreamboardPluginRuntimeApi";
-function createPluginRuntimeAPI(options = {}) {
-  const existingRuntime = globalThis[PLUGIN_RUNTIME_SINGLETON_KEY];
-  if (existingRuntime) {
-    existingRuntime.setDiagnosticHandler?.(options.onDiagnostic);
-    return existingRuntime;
-  }
-  let onDiagnostic = options.onDiagnostic;
-  const emitDiagnostic = (event) => {
-    if (onDiagnostic) {
-      try {
-        onDiagnostic(event);
-        return;
-      } catch {
-      }
-    }
-    switch (event.type) {
-      case "runtimeLog": {
-        const args = [event.message, ...event.details ?? []];
-        if (event.level === "warn") {
-          console.warn(...args);
-        } else if (event.level === "error") {
-          console.error(...args);
-        } else {
-          console.log(...args);
-        }
-        break;
-      }
-      case "internalError":
-        console.error(
-          `[Plugin RuntimeAPI] ${event.code}:`,
-          event.message,
-          event.stack ?? ""
-        );
-        break;
-      default: {
-        const _exhaustive = event;
-        return _exhaustive;
-      }
-    }
-  };
-  let currentStateSnapshot = null;
-  const stateListeners = /* @__PURE__ */ new Set();
-  const sessionState = {
-    status: "loading",
-    sessionId: null,
-    controllablePlayerIds: [],
-    controllingPlayerId: null,
-    userId: null
-  };
-  const sessionStateListeners = /* @__PURE__ */ new Set();
-  const pendingValidations = /* @__PURE__ */ new Map();
-  let validationIdCounter = 0;
-  const pendingSubmissions = /* @__PURE__ */ new Map();
-  let submitIdCounter = 0;
-  const notifySessionStateChange = () => {
-    sessionStateListeners.forEach((listener) => {
-      try {
-        listener({ ...sessionState });
-      } catch {
-      }
-    });
-  };
-  const notifyStateListeners = () => {
-    if (!currentStateSnapshot) return;
-    const snapshot = currentStateSnapshot;
-    stateListeners.forEach((listener) => {
-      try {
-        listener(snapshot);
-      } catch {
-      }
-    });
-  };
-  const createSubmissionError = (errorCode, message) => {
-    const error = new Error(message ?? "Submission failed");
-    error.name = "SubmissionError";
-    error.errorCode = errorCode;
-    return error;
-  };
-  const submitViaParent = (payload) => new Promise((resolve, reject) => {
-    const messageId = `submit-${++submitIdCounter}`;
-    pendingSubmissions.set(messageId, { resolve, reject });
-    const clientSubmittedAtMs = Date.now();
-    if (payload.clientActionId && typeof performance !== "undefined") {
-      try {
-        performance.mark(`dreamboard.t0_click.${payload.clientActionId}`, {
-          detail: { clientActionId: payload.clientActionId }
-        });
-      } catch {
-      }
-    }
-    window.parent.postMessage(
-      { ...payload, messageId, clientSubmittedAtMs },
-      "*"
-    );
-    setTimeout(() => {
-      const pending = pendingSubmissions.get(messageId);
-      if (!pending) {
-        return;
-      }
-      pendingSubmissions.delete(messageId);
-      pending.reject(
-        createSubmissionError(
-          "submission-timeout",
-          "Submission request timed out"
-        )
-      );
-    }, 1e4);
-  });
-  const handleMessage = (event) => {
-    const rawMessage = event.data;
-    const parseResult = MainToPluginMessageSchema.safeParse(rawMessage);
-    if (!parseResult.success) {
-      if (rawMessage?.type && typeof rawMessage.type === "string") {
-        emitDiagnostic({
-          type: "runtimeLog",
-          level: "warn",
-          message: "[Plugin RuntimeAPI] Invalid message received:",
-          details: [rawMessage.type]
-        });
-      }
-      return;
-    }
-    const message = parseResult.data;
-    switch (message.type) {
-      case "init": {
-        emitDiagnostic({
-          type: "runtimeLog",
-          level: "log",
-          message: "[Plugin RuntimeAPI] Received init message"
-        });
-        sessionState.status = "ready";
-        sessionState.sessionId = message.sessionId;
-        sessionState.controllablePlayerIds = message.controllablePlayerIds;
-        sessionState.controllingPlayerId = message.controllingPlayerId;
-        sessionState.userId = message.userId;
-        notifySessionStateChange();
-        window.parent.postMessage({ type: "ready" }, "*");
-        break;
-      }
-      case "ping": {
-        window.parent.postMessage({ type: "pong" }, "*");
-        break;
-      }
-      case "state-sync": {
-        emitDiagnostic({
-          type: "runtimeLog",
-          level: "log",
-          message: "[Plugin RuntimeAPI] Received state-sync, syncId:",
-          details: [message.syncId]
-        });
-        const clientReceivedAtMs = Date.now();
-        if (typeof performance !== "undefined") {
-          try {
-            performance.mark(
-              `dreamboard.t7_state_sync_received.sync-${message.syncId}`,
-              { detail: { syncId: message.syncId } }
-            );
-          } catch {
-          }
-        }
-        currentStateSnapshot = message.state;
-        if (message.state.session) {
-          sessionState.sessionId = message.state.session.sessionId;
-          sessionState.controllablePlayerIds = message.state.session.controllablePlayerIds;
-          sessionState.controllingPlayerId = message.state.session.controllingPlayerId;
-          sessionState.userId = message.state.session.userId;
-          sessionState.status = "ready";
-          notifySessionStateChange();
-        }
-        notifyStateListeners();
-        window.parent.postMessage(
-          {
-            type: "state-ack",
-            syncId: message.syncId,
-            clientReceivedAtMs
-          },
-          "*"
-        );
-        const schedulePostRender = () => {
-          const send = () => {
-            const clientRenderedAtMs = Date.now();
-            if (typeof performance !== "undefined") {
-              try {
-                performance.mark(
-                  `dreamboard.t8_render_commit.sync-${message.syncId}`,
-                  { detail: { syncId: message.syncId } }
-                );
-              } catch {
-              }
-            }
-            window.parent.postMessage(
-              {
-                type: "state-rendered",
-                syncId: message.syncId,
-                clientReceivedAtMs,
-                clientRenderedAtMs
-              },
-              "*"
-            );
-          };
-          if (typeof requestAnimationFrame === "function") {
-            requestAnimationFrame(send);
-          } else {
-            queueMicrotask(send);
-          }
-        };
-        queueMicrotask(schedulePostRender);
-        break;
-      }
-      case "validate-interaction-result": {
-        const resolver = pendingValidations.get(message.messageId);
-        if (resolver) {
-          pendingValidations.delete(message.messageId);
-          resolver({
-            valid: message.result.valid,
-            errorCode: message.result.errorCode ?? void 0,
-            message: message.result.message ?? void 0
-          });
+// src/runtime/browser/post-message-transport.ts
+function createPostMessagePluginTransport(options = {}) {
+  const targetWindow = options.targetWindow ?? window;
+  const parentWindow = options.parentWindow ?? targetWindow.parent;
+  let channel = null;
+  let outboundSequence = 0;
+  return {
+    start(onMessage) {
+      const handleMessage = (event) => {
+        if (event.source !== parentWindow) {
+          return;
         }
-        break;
-      }
-      case "submit-result": {
-        const pending = pendingSubmissions.get(message.messageId);
-        if (!pending) {
-          break;
+        const parseResult = HostToPluginEnvelopeSchema.safeParse(event.data);
+        if (!parseResult.success) {
+          options.onInvalidMessage?.("invalid-envelope", event.data);
+          return;
         }
-        if (typeof performance !== "undefined") {
-          try {
-            performance.mark(`dreamboard.t3b_ack.${message.messageId}`, {
-              detail: { messageId: message.messageId }
-            });
-          } catch {
+        const envelope = parseResult.data;
+        if (!channel) {
+          if (envelope.payload.type !== "runtime.init") {
+            return;
           }
+          channel = {
+            channelId: envelope.channelId,
+            hostOrigin: event.origin,
+            hostWindow: event.source
+          };
         }
-        pendingSubmissions.delete(message.messageId);
-        if (message.accepted) {
-          pending.resolve();
-        } else {
-          pending.reject(
-            createSubmissionError(
-              message.errorCode ?? void 0,
-              message.message ?? void 0
-            )
-          );
+        if (envelope.channelId !== channel.channelId || event.origin !== channel.hostOrigin || event.source !== channel.hostWindow) {
+          options.onInvalidMessage?.("channel-mismatch", event.data);
+          return;
         }
-        break;
-      }
-    }
-  };
-  window.addEventListener("message", handleMessage);
-  const sendErrorToParent = (message, code, stack) => {
-    emitDiagnostic({
-      type: "internalError",
-      code,
-      message,
-      ...stack ? { stack } : {}
-    });
-    window.parent.postMessage(
-      {
-        type: "error",
-        message: stack ? `${message}
-${stack}` : message,
-        code
-      },
-      "*"
-    );
-  };
-  window.onerror = (message, source, lineno, colno, error) => {
-    const errorMessage = typeof message === "string" ? message : error?.message || "Unknown error";
-    const location = source ? ` at ${source}:${lineno}:${colno}` : "";
-    sendErrorToParent(errorMessage + location, "UNCAUGHT_ERROR", error?.stack);
-    return false;
-  };
-  window.onunhandledrejection = (event) => {
-    const reason = event.reason;
-    const message = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : JSON.stringify(reason);
-    const stack = reason instanceof Error ? reason.stack : void 0;
-    sendErrorToParent(message, "UNHANDLED_REJECTION", stack);
-  };
-  emitDiagnostic({
-    type: "runtimeLog",
-    level: "log",
-    message: "[Plugin RuntimeAPI] Initialized (state-sync architecture)"
-  });
-  const runtime = {
-    // State-sync methods
-    getSnapshot: () => currentStateSnapshot,
-    subscribeToState: (listener) => {
-      stateListeners.add(listener);
-      if (currentStateSnapshot) {
-        try {
-          listener(currentStateSnapshot);
-        } catch {
-        }
-      }
-      return () => {
-        stateListeners.delete(listener);
+        onMessage(envelope);
       };
-    },
-    validateInteraction: async (playerId, interactionId, params) => {
-      return new Promise((resolve) => {
-        const messageId = `validate-${++validationIdCounter}`;
-        pendingValidations.set(messageId, resolve);
-        window.parent.postMessage(
-          {
-            type: "validate-interaction",
-            playerId,
-            interactionId,
-            params,
-            messageId
-          },
-          "*"
-        );
-        setTimeout(() => {
-          if (pendingValidations.has(messageId)) {
-            pendingValidations.delete(messageId);
-            resolve({
-              valid: false,
-              errorCode: "validation-timeout",
-              message: "Validation request timed out"
-            });
-          }
-        }, 1e4);
-      });
-    },
-    submitInteraction: async (playerId, interactionId, params) => submitViaParent({
-      type: "interaction",
-      playerId,
-      interactionId,
-      params,
-      clientActionId: mintClientActionId()
-    }),
-    getSessionState: () => ({ ...sessionState }),
-    disconnect: () => {
-      window.removeEventListener("message", handleMessage);
-      window.onerror = null;
-      window.onunhandledrejection = null;
-      sessionStateListeners.clear();
-      stateListeners.clear();
-      pendingValidations.clear();
-      pendingSubmissions.clear();
-      currentStateSnapshot = null;
-    },
-    switchPlayer: (playerId) => {
-      window.parent.postMessage({ type: "switch-player", playerId }, "*");
-    },
-    restoreHistory: (entryId) => {
-      window.parent.postMessage({ type: "restore-history", entryId }, "*");
-    },
-    setDiagnosticHandler: (handler) => {
-      onDiagnostic = handler;
-    },
-    emitDiagnostic,
-    _subscribeToSessionState: (listener) => {
-      sessionStateListeners.add(listener);
-      listener({ ...sessionState });
+      targetWindow.addEventListener("message", handleMessage);
       return () => {
-        sessionStateListeners.delete(listener);
+        targetWindow.removeEventListener("message", handleMessage);
+        channel = null;
       };
+    },
+    send(payload) {
+      if (!channel) {
+        throw new Error("Plugin transport is not initialized.");
+      }
+      channel.hostWindow.postMessage(
+        {
+          protocol: DREAMBOARD_PLUGIN_PROTOCOL,
+          version: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
+          channelId: channel.channelId,
+          sequence: ++outboundSequence,
+          payload
+        },
+        channel.hostOrigin
+      );
     }
   };
-  globalThis[PLUGIN_RUNTIME_SINGLETON_KEY] = runtime;
-  return runtime;
 }
 
 // src/runtime/hooks/usePluginRuntime.ts
-function hasProjectedView(snapshot) {
-  return snapshot !== null && snapshot !== void 0 && snapshot.view !== null && snapshot.view !== void 0;
+function hasProjectedView(runtime) {
+  const frame = runtime.getFrame();
+  return frame !== null && frame.view !== null && typeof frame.view !== "undefined";
 }
 function usePluginRuntime(options = {}) {
   const { timeout = 1e4, onDiagnostic } = options;
   const [runtime] = useState(
-    () => createPluginRuntimeAPI({ onDiagnostic })
+    () => createPluginRuntimeClient({
+      transport: createPostMessagePluginTransport({
+        onInvalidMessage: (reason, value) => onDiagnostic?.({
+          type: "runtimeLog",
+          level: "warn",
+          message: `[PluginRuntime] Ignored invalid host message: ${reason}`,
+          details: [value]
+        })
+      })
+    })
   );
-  const [isReady, setIsReady] = useState(() => {
-    const snapshot = runtime.getSnapshot?.();
-    return hasProjectedView(snapshot);
-  });
+  const [isReady, setIsReady] = useState(() => hasProjectedView(runtime));
   const [error, setError] = useState(null);
   const hasBeenReadyRef = useRef(false);
   if (isReady) hasBeenReadyRef.current = true;
   useEffect(() => {
-    runtime.setDiagnosticHandler?.(onDiagnostic);
-  }, [runtime, onDiagnostic]);
+    void onDiagnostic;
+  }, [onDiagnostic]);
   useEffect(() => {
-    const markReadyFromSnapshot = () => {
-      const currentSnapshot = runtime.getSnapshot?.();
-      if (!hasProjectedView(currentSnapshot)) {
+    const markReadyFromFrame = () => {
+      if (!hasProjectedView(runtime)) {
         return false;
       }
       setError(null);
       setIsReady(true);
       return true;
     };
-    if (markReadyFromSnapshot()) {
+    if (markReadyFromFrame()) {
       return;
     }
     const timeoutId = setTimeout(() => {
-      if (!markReadyFromSnapshot()) {
+      if (!markReadyFromFrame()) {
         setError(
-          `Timed out waiting for the initial projected view after ${timeout}ms. Ensure the host sends a reducer-native state-sync with a seat view.`
+          `Timed out waiting for the initial projected view after ${timeout}ms. Ensure the host sends a gameplay frame with a seat view.`
         );
       }
     }, timeout);
     const pollId = setInterval(() => {
-      if (markReadyFromSnapshot()) {
+      if (markReadyFromFrame()) {
         clearInterval(pollId);
         clearTimeout(timeoutId);
       }
     }, 100);
-    const unsubscribe = runtime.subscribeToState?.((state) => {
-      if (!hasProjectedView(state)) {
+    const unsubscribe = runtime.subscribeFrame(() => {
+      if (!hasProjectedView(runtime)) {
         setIsReady(false);
         return;
       }
@@ -540,19 +190,13 @@ function PluginRuntime({
       }
     );
   }
-  return /* @__PURE__ */ jsx(RuntimeProvider, { runtime, children: /* @__PURE__ */ jsx(SessionScopedInteractionUiProvider, { children }) });
-}
-function SessionScopedInteractionUiProvider({
-  children
-}) {
-  const { controllingPlayerId } = usePluginSession();
-  return /* @__PURE__ */ jsxs(InteractionUiProvider, { children: [
-    /* @__PURE__ */ jsx(RuntimeSemanticProjectionMarker, {}),
-    children
-  ] }, controllingPlayerId ?? "__no_player__");
+  return /* @__PURE__ */ jsx(PluginRuntimeBoundary, { runtime, children });
 }
 export {
   PluginRuntime,
+  PluginRuntimeBoundary,
+  createPluginRuntimeClient,
+  createPostMessagePluginTransport,
   createWorkspaceUIContract
 };
 //# sourceMappingURL=runtime.js.map