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

package/dist/runtime.js

@@ -1,844 +1,140 @@
 import {
   createWorkspaceUIContract
-} from "./chunk-3K362ZKR.js";
-import {
-  InteractionUiProvider,
-  RuntimeProvider,
-  RuntimeSemanticProjectionMarker,
-  usePluginSession
-} from "./chunk-CZMFAS3E.js";
-import "./chunk-XJYUSD5F.js";
+} from "./chunk-6JQFGSLD.js";
+import "./chunk-WOWFONLZ.js";
+import "./chunk-FWVV2X74.js";
 import "./chunk-T3ZKNUZ7.js";
 import {
   GameSkeleton
-} from "./chunk-7W6TQO3X.js";
+} from "./chunk-45FI6XII.js";
 import "./chunk-VDXOF4FW.js";
-import "./chunk-MALRKLRR.js";
 import {
-  RuntimeJsonSchema,
-  TRANSPORT_JSON_LIMITS,
-  assertJsonWithinLimits
-} from "./chunk-AEUXCFGM.js";
+  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/plugin-protocol.ts
-import { z } from "zod";
-var DREAMBOARD_PLUGIN_PROTOCOL = "dreamboard-plugin";
-var DREAMBOARD_PLUGIN_PROTOCOL_VERSION = 2;
-var PluginEnvelopeBaseSchema = z.object({
-  protocol: z.literal(DREAMBOARD_PLUGIN_PROTOCOL),
-  version: z.literal(DREAMBOARD_PLUGIN_PROTOCOL_VERSION),
-  channelId: z.string().min(32).max(256)
-}).strict();
-var PlayerIdSchema = z.string();
-var RuntimeRecordSchema = z.record(z.string(), RuntimeJsonSchema);
-var NullableRuntimeJsonSchema = RuntimeJsonSchema.nullable();
-var SeatAssignmentSchema = z.object({
-  playerId: PlayerIdSchema,
-  controllerUserId: z.string().optional(),
-  displayName: z.string(),
-  playerColor: z.string().optional(),
-  isHost: z.boolean().optional()
-}).strict();
-var LobbyStateSchema = z.object({
-  seats: z.array(SeatAssignmentSchema),
-  canStart: z.boolean(),
-  hostUserId: z.string()
-}).strict();
-var NotificationPayloadSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("YOUR_TURN"),
-    activePlayers: z.array(PlayerIdSchema)
-  }).strict(),
-  z.object({
-    type: z.literal("PROMPT_OPENED"),
-    promptId: z.string(),
-    promptInstanceId: z.string(),
-    targetPlayer: PlayerIdSchema,
-    title: z.string().optional()
-  }).strict(),
-  z.object({
-    type: z.literal("ACTION_EXECUTED"),
-    playerId: PlayerIdSchema,
-    actionType: z.string()
-  }).strict(),
-  z.object({
-    type: z.literal("ACTION_REJECTED"),
-    reason: z.string(),
-    targetPlayer: z.string().optional()
-  }).strict(),
-  z.object({
-    type: z.literal("TURN_CHANGED"),
-    previousPlayers: z.array(PlayerIdSchema),
-    currentPlayers: z.array(PlayerIdSchema)
-  }).strict(),
-  z.object({
-    type: z.literal("STATE_CHANGED"),
-    newState: z.string()
-  }).strict(),
-  z.object({
-    type: z.literal("GAME_ENDED"),
-    winner: z.string().optional(),
-    finalScores: z.record(z.string(), z.number().finite()),
-    reason: z.string()
-  }).strict(),
-  z.object({
-    type: z.literal("ERROR"),
-    message: z.string(),
-    code: z.string().optional()
-  }).strict()
-]);
-var NotificationSchema = z.object({
-  id: z.string(),
-  type: z.enum([
-    "YOUR_TURN",
-    "PROMPT_OPENED",
-    "ACTION_EXECUTED",
-    "ACTION_REJECTED",
-    "TURN_CHANGED",
-    "STATE_CHANGED",
-    "GAME_ENDED",
-    "ERROR"
-  ]),
-  payload: NotificationPayloadSchema,
-  timestamp: z.number().finite(),
-  read: z.boolean()
-}).strict();
-var PluginSessionStateSchema = z.object({
-  sessionId: z.string().nullable(),
-  controllablePlayerIds: z.array(PlayerIdSchema),
-  controllingPlayerId: PlayerIdSchema.nullable(),
-  userId: z.string().nullable()
-}).strict();
-var HistoryEntrySummarySchema = z.object({
-  id: z.string(),
-  version: z.number().int(),
-  timestamp: z.string(),
-  description: z.string(),
-  playerId: PlayerIdSchema.optional(),
-  actionType: z.string().optional(),
-  isCurrent: z.boolean()
-}).strict();
-var HistoryStateSchema = z.object({
-  entries: z.array(HistoryEntrySummarySchema),
-  currentIndex: z.number().int(),
-  canGoBack: z.boolean(),
-  canGoForward: z.boolean()
-}).strict();
-var SimultaneousPhaseSchema = z.object({
-  phaseName: z.string(),
-  interactionId: z.string(),
-  actorIds: z.array(PlayerIdSchema),
-  sealedPlayerIds: z.array(PlayerIdSchema),
-  pendingPlayerIds: z.array(PlayerIdSchema)
-}).strict();
-var InteractionCommitPolicySchema = z.discriminatedUnion("mode", [
-  z.object({ mode: z.literal("manual") }).strict(),
-  z.object({ mode: z.literal("autoWhenReady") }).strict()
-]);
-var InputSelectionSchema = z.discriminatedUnion("mode", [
-  z.object({ mode: z.literal("single") }).strict(),
-  z.object({
-    mode: z.literal("many"),
-    min: z.number().int(),
-    max: z.number().int().optional(),
-    distinct: z.boolean().optional()
-  }).strict()
-]);
-var InputDomainDependencyCaseSchema = z.object({
-  when: z.record(z.string(), z.string()),
-  domain: RuntimeRecordSchema
-}).strict();
-var InputDomainResolverSchema = z.discriminatedUnion("mode", [
-  z.object({
-    mode: z.literal("eager"),
-    dependentCases: z.array(InputDomainDependencyCaseSchema)
-  }).strict(),
-  z.object({
-    mode: z.literal("lazy"),
-    dependsOn: z.array(z.string()),
-    resolver: z.object({
-      interactionKey: z.string().optional(),
-      inputKey: z.string()
-    }).strict()
-  }).strict()
-]);
-var InputDomainSchema = z.object({
-  type: z.string(),
-  selection: InputSelectionSchema.optional(),
-  dependencies: InputDomainResolverSchema.optional()
-}).catchall(RuntimeJsonSchema);
-var InteractionInputDescriptorSchema = z.object({
-  key: z.string(),
-  kind: z.string(),
-  domain: InputDomainSchema,
-  defaultValue: RuntimeJsonSchema.optional()
-}).strict();
-var InteractionAvailabilitySchema = z.discriminatedUnion("status", [
-  z.object({ status: z.literal("available") }).strict(),
-  z.object({ status: z.literal("notYourTurn"), reason: z.string() }).strict(),
-  z.object({
-    status: z.literal("insufficientResources"),
-    reason: z.string(),
-    missingResources: z.record(z.string(), z.number().finite())
-  }).strict(),
-  z.object({
-    status: z.literal("blocked"),
-    reason: z.string(),
-    code: z.string().optional()
-  }).strict()
-]);
-var InteractionBaseSchema = z.object({
-  phaseName: z.string(),
-  interactionKey: z.string(),
-  interactionId: z.string(),
-  commit: InteractionCommitPolicySchema,
-  descriptorDigest: z.string().optional(),
-  actorSeat: z.number().int().optional(),
-  draftDigest: z.string().optional(),
-  zoneId: z.string().optional(),
-  zoneIds: z.array(z.string()).optional(),
-  inputs: z.array(InteractionInputDescriptorSchema),
-  cost: RuntimeRecordSchema.optional(),
-  currentResources: RuntimeRecordSchema.optional(),
-  availability: InteractionAvailabilitySchema,
-  reasons: z.array(
-    z.object({
-      ruleId: z.string(),
-      errorCode: z.string()
-    }).strict()
-  ).optional()
-}).strict();
-var InteractionDescriptorSchema = z.discriminatedUnion("kind", [
-  InteractionBaseSchema.extend({ kind: z.literal("action") }).strict(),
-  InteractionBaseSchema.extend({
-    kind: z.literal("prompt"),
-    context: z.object({
-      to: z.string(),
-      title: z.string().optional(),
-      payload: RuntimeRecordSchema.optional(),
-      options: z.array(
-        z.object({
-          id: z.string(),
-          label: z.string().optional()
-        }).strict()
-      ).optional()
-    }).strict()
-  }).strict()
-]);
-var ZoneHandlesSnapshotSchema = z.object({
-  cardIds: z.array(z.string()),
-  cardViewsById: z.record(z.string(), z.string()),
-  playableByCardId: z.record(
-    z.string(),
-    z.array(InteractionDescriptorSchema)
-  )
-}).strict();
-var GameplaySnapshotSchema = z.object({
-  currentPhase: z.string().nullable(),
-  currentStage: z.string().nullable(),
-  activePlayers: z.array(PlayerIdSchema),
-  simultaneousPhase: SimultaneousPhaseSchema.nullable().optional(),
-  availableInteractions: z.array(InteractionDescriptorSchema),
-  zones: z.record(z.string(), ZoneHandlesSnapshotSchema)
-}).strict();
-var PluginStateSnapshotSchema = z.object({
-  view: NullableRuntimeJsonSchema,
-  gameplay: GameplaySnapshotSchema,
-  lobby: LobbyStateSchema.nullable(),
-  notifications: z.array(NotificationSchema),
-  session: PluginSessionStateSchema,
-  history: HistoryStateSchema.nullable(),
-  syncId: z.number().int()
-}).strict();
-var InitPayloadSchema = z.object({
-  type: z.literal("init"),
-  sessionId: z.string(),
-  controllablePlayerIds: z.array(z.string()),
-  controllingPlayerId: z.string(),
-  userId: z.string().nullable(),
-  state: PluginStateSnapshotSchema.optional()
-}).strict();
-var PingPayloadSchema = z.object({ type: z.literal("ping") }).strict();
-var StateSyncPayloadSchema = z.object({
-  type: z.literal("state-sync"),
-  syncId: z.number().int(),
-  state: PluginStateSnapshotSchema
-}).strict();
-var ValidateInteractionResultPayloadSchema = 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()
-  }).strict()
-}).strict();
-var SubmitResultPayloadSchema = z.object({
-  type: z.literal("submit-result"),
-  messageId: z.string(),
-  accepted: z.boolean(),
-  errorCode: z.string().nullable().optional(),
-  message: z.string().nullable().optional()
-}).strict();
-var HostToPluginPayloadSchema = z.discriminatedUnion("type", [
-  InitPayloadSchema,
-  PingPayloadSchema,
-  StateSyncPayloadSchema,
-  ValidateInteractionResultPayloadSchema,
-  SubmitResultPayloadSchema
-]);
-var HostToPluginEnvelopeSchema = PluginEnvelopeBaseSchema.extend({
-  payload: HostToPluginPayloadSchema
-}).strict();
-var PluginInitEnvelopeSchema = PluginEnvelopeBaseSchema.extend({
-  payload: InitPayloadSchema
-}).strict();
-function assertTransportEnvelopeWithinLimits(value) {
-  assertJsonWithinLimits(value, TRANSPORT_JSON_LIMITS, "Plugin message");
-}
-function createPluginEnvelope(payload, channel) {
-  return {
-    protocol: DREAMBOARD_PLUGIN_PROTOCOL,
-    version: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
-    channelId: channel.channelId,
-    payload
-  };
-}
-
-// src/runtime/api/createPluginRuntimeAPI.ts
-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;
+// 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 disconnected = false;
-  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 postToHost = (payload) => {
-    if (channel === null || disconnected) {
-      throw new Error("Plugin runtime is not initialized.");
-    }
-    channel.hostWindow.postMessage(
-      createPluginEnvelope(payload, channel),
-      channel.hostOrigin
-    );
-  };
-  const rejectPendingRequests = () => {
-    pendingValidations.forEach((resolve) => {
-      resolve({
-        valid: false,
-        errorCode: "runtime-disconnected",
-        message: "Plugin runtime disconnected"
-      });
-    });
-    pendingValidations.clear();
-    pendingSubmissions.forEach((pending) => {
-      pending.reject(
-        createSubmissionError(
-          "runtime-disconnected",
-          "Plugin runtime disconnected"
-        )
-      );
-    });
-    pendingSubmissions.clear();
-  };
-  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) => {
-    if (channel === null || disconnected) {
-      reject(
-        createSubmissionError(
-          "runtime-not-initialized",
-          "Plugin runtime is not initialized."
-        )
-      );
-      return;
-    }
-    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 {
-      }
-    }
-    try {
-      postToHost({ ...payload, messageId, clientSubmittedAtMs });
-    } catch (error) {
-      pendingSubmissions.delete(messageId);
-      reject(
-        createSubmissionError(
-          "runtime-not-initialized",
-          error instanceof Error ? error.message : "Plugin runtime is not initialized."
-        )
-      );
-      return;
-    }
-    setTimeout(() => {
-      const pending = pendingSubmissions.get(messageId);
-      if (!pending) {
-        return;
-      }
-      pendingSubmissions.delete(messageId);
-      pending.reject(
-        createSubmissionError(
-          "submission-timeout",
-          "Submission request timed out"
-        )
-      );
-    }, 1e4);
-  });
-  const applyInitMessage = (message) => {
-    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();
-    if (message.state) {
-      applyStateSyncMessage({
-        type: "state-sync",
-        syncId: message.state.syncId,
-        state: message.state
-      });
-    }
-  };
-  const applyStateSyncMessage = (message) => {
-    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();
-    postToHost({
-      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 {
-          }
-        }
-        if (!disconnected && channel !== null) {
-          postToHost({
-            type: "state-rendered",
-            syncId: message.syncId,
-            clientReceivedAtMs,
-            clientRenderedAtMs
-          });
-        }
-      };
-      if (typeof requestAnimationFrame === "function") {
-        requestAnimationFrame(send);
-      } else {
-        queueMicrotask(send);
-      }
-    };
-    queueMicrotask(schedulePostRender);
-  };
-  const handleMessage = (event) => {
-    if (disconnected || event.source !== window.parent) {
-      return;
-    }
-    try {
-      assertTransportEnvelopeWithinLimits(event.data);
-    } catch (error) {
-      emitDiagnostic({
-        type: "runtimeLog",
-        level: "warn",
-        message: "[Plugin RuntimeAPI] Rejected oversized or non-JSON message:",
-        details: [error instanceof Error ? error.name : "unknown"]
-      });
-      return;
-    }
-    if (channel === null) {
-      const initResult = PluginInitEnvelopeSchema.safeParse(event.data);
-      if (!initResult.success) {
-        return;
-      }
-      channel = {
-        channelId: initResult.data.channelId,
-        hostOrigin: event.origin,
-        hostWindow: window.parent
-      };
-      applyInitMessage(initResult.data.payload);
-      postToHost({ type: "ready" });
-      return;
-    }
-    if (event.source !== channel.hostWindow || event.origin !== channel.hostOrigin) {
-      return;
-    }
-    const parseResult = HostToPluginEnvelopeSchema.safeParse(event.data);
-    if (!parseResult.success || parseResult.data.channelId !== channel.channelId) {
-      const rawPayload = event.data?.payload;
-      if (typeof rawPayload?.type === "string") {
-        emitDiagnostic({
-          type: "runtimeLog",
-          level: "warn",
-          message: "[Plugin RuntimeAPI] Invalid message received:",
-          details: [rawPayload.type]
-        });
-      }
-      return;
-    }
-    const message = parseResult.data.payload;
-    switch (message.type) {
-      case "init": {
-        break;
-      }
-      case "ping": {
-        postToHost({ type: "pong" });
-        break;
-      }
-      case "state-sync": {
-        applyStateSyncMessage(message);
-        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
-          });
+  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
-            )
-          );
-        }
-        break;
-      }
-    }
-  };
-  window.addEventListener("message", handleMessage);
-  const sendErrorToParent = (message, code, stack) => {
-    emitDiagnostic({
-      type: "internalError",
-      code,
-      message,
-      ...stack ? { stack } : {}
-    });
-    if (channel !== null && !disconnected) {
-      postToHost({
-        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);
-      };
-    },
-    validateInteraction: async (playerId, interactionId, params) => {
-      return new Promise((resolve) => {
-        if (channel === null || disconnected) {
-          resolve({
-            valid: false,
-            errorCode: "runtime-not-initialized",
-            message: "Plugin runtime is not initialized."
-          });
+        if (envelope.channelId !== channel.channelId || event.origin !== channel.hostOrigin || event.source !== channel.hostWindow) {
+          options.onInvalidMessage?.("channel-mismatch", event.data);
           return;
         }
-        const messageId = `validate-${++validationIdCounter}`;
-        pendingValidations.set(messageId, resolve);
-        try {
-          postToHost({
-            type: "validate-interaction",
-            playerId,
-            interactionId,
-            params,
-            messageId
-          });
-        } catch {
-          pendingValidations.delete(messageId);
-          resolve({
-            valid: false,
-            errorCode: "runtime-not-initialized",
-            message: "Plugin runtime is not initialized."
-          });
-          return;
-        }
-        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;
-      disconnected = true;
-      channel = null;
-      sessionStateListeners.clear();
-      stateListeners.clear();
-      rejectPendingRequests();
-      currentStateSnapshot = null;
-    },
-    switchPlayer: (playerId) => {
-      postToHost({ type: "switch-player", playerId });
-    },
-    restoreHistory: (entryId) => {
-      postToHost({ type: "restore-history", entryId });
-    },
-    markNotificationRead: (notificationId) => {
-      postToHost({ type: "mark-notification-read", notificationId });
-    },
-    setDiagnosticHandler: (handler) => {
-      onDiagnostic = handler;
-    },
-    emitDiagnostic,
-    _subscribeToSessionState: (listener) => {
-      sessionStateListeners.add(listener);
-      listener({ ...sessionState });
+        onMessage(envelope);
+      };
+      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;
       }
@@ -894,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