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

package/dist/chunk-O6M6PN4E.js

@@ -0,0 +1,1225 @@
+import {
+  BROWSER_INTERACTION_ATTRIBUTES,
+  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
+  GAMEPLAY_BROWSER_INTERACTION_SURFACE
+} from "./chunk-WUIVY2KE.js";
+
+// ../plugin-runtime-contract/dist/chunk-LCXQNYOL.js
+function canonicalizePluginRuntimeJson(value) {
+  assertRuntimeJson(value);
+  return canonicalizeJson(value);
+}
+function encodeCanonicalPluginRuntimeJson(value) {
+  return JSON.stringify(canonicalizePluginRuntimeJson(value));
+}
+function digestPluginRuntimeJson(value) {
+  return `sha256:${sha256Hex(encodeCanonicalPluginRuntimeJson(value))}`;
+}
+function canonicalizeJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("canonical JSON contains a non-finite number");
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalizeJson(item));
+  }
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => [key, canonicalizeJson(item)])
+  );
+}
+function assertRuntimeJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("runtime JSON contains a non-finite number");
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach(assertRuntimeJson);
+    return;
+  }
+  if (typeof value === "object") {
+    Object.values(value).forEach((item) => {
+      if (item !== void 0) {
+        assertRuntimeJson(item);
+      }
+    });
+    return;
+  }
+  throw new Error(`runtime JSON contains unsupported ${typeof value} value`);
+}
+var SHA256_K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function sha256Hex(input) {
+  const bytes = utf8Bytes(input);
+  const bitLength = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+  for (let shift = 56; shift >= 0; shift -= 8) {
+    bytes.push(Math.floor(bitLength / 2 ** shift) & 255);
+  }
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const words = new Array(64);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) {
+      const index = offset + i * 4;
+      words[i] = (bytes[index] ?? 0) << 24 | (bytes[index + 1] ?? 0) << 16 | (bytes[index + 2] ?? 0) << 8 | (bytes[index + 3] ?? 0);
+    }
+    for (let i = 16; i < 64; i += 1) {
+      const s0 = rightRotate(words[i - 15] ?? 0, 7) ^ rightRotate(words[i - 15] ?? 0, 18) ^ (words[i - 15] ?? 0) >>> 3;
+      const s1 = rightRotate(words[i - 2] ?? 0, 17) ^ rightRotate(words[i - 2] ?? 0, 19) ^ (words[i - 2] ?? 0) >>> 10;
+      words[i] = (words[i - 16] ?? 0) + s0 + (words[i - 7] ?? 0) + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let i = 0; i < 64; i += 1) {
+      const s1 = rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + (SHA256_K[i] ?? 0) + (words[i] ?? 0) >>> 0;
+      const s0 = rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rightRotate(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function utf8Bytes(input) {
+  const bytes = [];
+  for (let i = 0; i < input.length; i += 1) {
+    const code = input.charCodeAt(i);
+    if (code < 128) {
+      bytes.push(code);
+    } else if (code < 2048) {
+      bytes.push(192 | code >> 6, 128 | code & 63);
+    } else if (code >= 55296 && code <= 56319) {
+      const next = input.charCodeAt(i += 1);
+      const point = 65536 + ((code & 1023) << 10 | next & 1023);
+      bytes.push(
+        240 | point >> 18,
+        128 | point >> 12 & 63,
+        128 | point >> 6 & 63,
+        128 | point & 63
+      );
+    } else {
+      bytes.push(
+        224 | code >> 12,
+        128 | code >> 6 & 63,
+        128 | code & 63
+      );
+    }
+  }
+  return bytes;
+}
+function computePluginActionSetVersion(input) {
+  return digestPluginRuntimeJson({
+    digestVersion: "plugin-action-set@3",
+    gameVersion: input.gameVersion,
+    availableInteractions: input.availableInteractions
+  });
+}
+function digestPluginGameplayFrame(frame) {
+  return digestPluginRuntimeJson({
+    digestVersion: "plugin-gameplay-frame@3",
+    frame
+  });
+}
+
+// ../plugin-runtime-contract/dist/chunk-MKR6YUC7.js
+import { z } from "zod";
+var DREAMBOARD_PLUGIN_PROTOCOL = "dreamboard-plugin";
+var DREAMBOARD_PLUGIN_PROTOCOL_VERSION = 3;
+var RuntimeJsonSchema = z.lazy(
+  () => z.union([
+    z.null(),
+    z.boolean(),
+    z.number().finite(),
+    z.string(),
+    z.array(RuntimeJsonSchema),
+    z.record(z.string(), RuntimeJsonSchema)
+  ])
+);
+var BoardStaticProjectionSchema = z.object({
+  view: RuntimeJsonSchema,
+  hash: z.string().optional(),
+  manifestVersion: z.string().optional()
+}).strict();
+var SeatProjectionBundleSchema = z.object({
+  currentStage: z.string().nullable().optional(),
+  stageSeats: z.array(z.string()).optional(),
+  simultaneousPhase: z.unknown().nullable().optional(),
+  interactionsByRef: z.record(z.string(), z.unknown()).optional(),
+  seats: z.record(
+    z.string(),
+    z.object({
+      view: z.unknown().optional(),
+      availableInteractionRefs: z.array(z.string()).optional(),
+      zones: z.unknown().optional()
+    }).strict()
+  )
+}).strict();
+var PlayerIdSchema = z.string().min(1);
+var PluginPlayerSummarySchema = z.object({
+  playerId: PlayerIdSchema,
+  displayName: z.string(),
+  color: z.string().optional()
+}).strict();
+var PluginSessionDescriptorSchema = z.object({
+  sessionId: z.string().min(1),
+  players: z.array(PluginPlayerSummarySchema)
+}).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.lazy(
+  () => z.object({
+    when: z.record(z.string(), z.string()),
+    domain: InputDomainSchema
+  }).strict()
+);
+var InputDomainDependenciesSchema = 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: InputDomainDependenciesSchema.optional()
+}).catchall(RuntimeJsonSchema);
+var InteractionChoiceOptionSchema = z.object({
+  value: z.string().nullable(),
+  label: z.string(),
+  icon: z.string().optional(),
+  badge: z.string().optional(),
+  description: z.string().optional(),
+  disabled: z.boolean().optional(),
+  disabledReason: z.string().optional()
+}).strict();
+var InteractionInputDescriptorSchema = z.object({
+  key: z.string().min(1),
+  kind: z.string().min(1),
+  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().min(1),
+  interactionKey: z.string().min(1),
+  interactionId: z.string().min(1),
+  zoneId: z.string().optional(),
+  zoneIds: z.array(z.string()).optional(),
+  commit: InteractionCommitPolicySchema,
+  descriptorDigest: z.string().optional(),
+  actorSeat: z.number().int().optional(),
+  draftDigest: z.string().optional(),
+  inputs: z.array(InteractionInputDescriptorSchema),
+  cost: z.record(z.string(), RuntimeJsonSchema).optional(),
+  currentResources: z.record(z.string(), RuntimeJsonSchema).optional(),
+  availability: InteractionAvailabilitySchema,
+  reasons: z.array(
+    z.object({
+      ruleId: z.string(),
+      errorCode: z.string()
+    }).strict()
+  ).optional()
+}).strict();
+var InteractionContextSchema = z.object({
+  to: z.string().min(1),
+  title: z.string().optional(),
+  payload: z.record(z.string(), RuntimeJsonSchema).optional(),
+  options: z.array(
+    z.object({
+      id: z.string(),
+      label: z.string().optional()
+    }).strict()
+  ).optional()
+}).strict();
+var InteractionDescriptorSchema = z.discriminatedUnion("kind", [
+  InteractionBaseSchema.extend({ kind: z.literal("action") }).strict(),
+  InteractionBaseSchema.extend({
+    kind: z.literal("prompt"),
+    context: InteractionContextSchema
+  }).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 SimultaneousPhaseSnapshotSchema = z.object({
+  phaseName: z.string().min(1),
+  interactionId: z.string().min(1),
+  actorIds: z.array(PlayerIdSchema),
+  sealedPlayerIds: z.array(PlayerIdSchema),
+  pendingPlayerIds: z.array(PlayerIdSchema)
+}).strict();
+var PluginGameplayFrameSchema = z.object({
+  gameVersion: z.number().int().nonnegative(),
+  actionSetVersion: z.string().min(1),
+  perspectivePlayerId: PlayerIdSchema.nullable(),
+  view: RuntimeJsonSchema.nullable(),
+  flow: z.object({
+    currentPhase: z.string().nullable(),
+    currentStage: z.string().nullable(),
+    activePlayers: z.array(PlayerIdSchema),
+    simultaneousPhase: SimultaneousPhaseSnapshotSchema.nullable()
+  }).strict(),
+  availableInteractions: z.array(InteractionDescriptorSchema),
+  zones: z.record(z.string(), ZoneHandlesSnapshotSchema)
+}).strict();
+var ValidationResultSchema = z.object({
+  valid: z.boolean(),
+  errorCode: z.string().optional(),
+  message: z.string().optional()
+}).strict();
+var SubmissionResultSchema = z.discriminatedUnion("accepted", [
+  z.object({ accepted: z.literal(true) }).strict(),
+  z.object({
+    accepted: z.literal(false),
+    errorCode: z.string().min(1),
+    message: z.string().optional()
+  }).strict()
+]);
+var PluginInteractionBasisSchema = z.object({
+  gameVersion: z.number().int().nonnegative(),
+  actionSetVersion: z.string().min(1),
+  perspectivePlayerId: PlayerIdSchema.nullable()
+}).strict();
+var ValidateInteractionCommandSchema = z.object({
+  type: z.literal("interaction.validate"),
+  requestId: z.string().min(1),
+  basis: PluginInteractionBasisSchema,
+  interactionId: z.string().min(1),
+  params: RuntimeJsonSchema
+}).strict();
+var SubmitInteractionCommandSchema = z.object({
+  type: z.literal("interaction.submit"),
+  requestId: z.string().min(1),
+  basis: PluginInteractionBasisSchema,
+  interactionId: z.string().min(1),
+  params: RuntimeJsonSchema
+}).strict();
+var HostToPluginPayloadSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("runtime.init"),
+    session: PluginSessionDescriptorSchema
+  }).strict(),
+  z.object({
+    type: z.literal("gameplay.frame"),
+    frame: PluginGameplayFrameSchema
+  }).strict(),
+  z.object({
+    type: z.literal("interaction.validation-result"),
+    requestId: z.string().min(1),
+    result: ValidationResultSchema
+  }).strict(),
+  z.object({
+    type: z.literal("interaction.submit-result"),
+    requestId: z.string().min(1),
+    result: SubmissionResultSchema
+  }).strict()
+]);
+var PluginToHostPayloadSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("runtime.ready") }).strict(),
+  z.object({
+    type: z.literal("runtime.ack"),
+    sequence: z.number().int().nonnegative(),
+    clientReceivedAtMs: z.number().finite().optional(),
+    clientRenderedAtMs: z.number().finite().optional()
+  }).strict(),
+  ValidateInteractionCommandSchema,
+  SubmitInteractionCommandSchema,
+  z.object({
+    type: z.literal("runtime.error"),
+    message: z.string(),
+    code: z.string().optional()
+  }).strict()
+]);
+function createPluginProtocolEnvelopeSchema(payloadSchema) {
+  return z.object({
+    protocol: z.literal(DREAMBOARD_PLUGIN_PROTOCOL),
+    version: z.literal(DREAMBOARD_PLUGIN_PROTOCOL_VERSION),
+    channelId: z.string().min(1),
+    sequence: z.number().int().nonnegative(),
+    payload: payloadSchema
+  }).strict();
+}
+var HostToPluginEnvelopeSchema = createPluginProtocolEnvelopeSchema(
+  HostToPluginPayloadSchema
+);
+var PluginToHostEnvelopeSchema = createPluginProtocolEnvelopeSchema(
+  PluginToHostPayloadSchema
+);
+var PluginProtocolFrameSchema = z.object({
+  id: z.string().min(1),
+  frame: PluginGameplayFrameSchema,
+  projectionDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/)
+}).strict();
+var PluginProtocolStepSchema = z.discriminatedUnion("kind", [
+  z.object({
+    id: z.string().min(1),
+    kind: z.literal("host.frame"),
+    frameId: z.string().min(1)
+  }).strict(),
+  z.object({
+    id: z.string().min(1),
+    kind: z.literal("client.validate"),
+    fromFrameId: z.string().min(1),
+    requestDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    response: ValidationResultSchema
+  }).strict(),
+  z.object({
+    id: z.string().min(1),
+    kind: z.literal("client.submit"),
+    fromFrameId: z.string().min(1),
+    requestDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    response: SubmissionResultSchema
+  }).strict()
+]);
+var PluginProtocolTapeSchema = z.object({
+  session: PluginSessionDescriptorSchema,
+  frames: z.array(PluginProtocolFrameSchema),
+  steps: z.array(PluginProtocolStepSchema)
+}).strict();
+
+// ../plugin-runtime-contract/dist/index.js
+function materializePluginGameplayFrame(input) {
+  const dynamicProjection = SeatProjectionBundleSchema.parse(
+    input.dynamicProjection
+  );
+  const staticProjection = input.staticProjection == null ? null : BoardStaticProjectionSchema.parse(
+    input.staticProjection
+  );
+  const registry = parseInteractionRegistry(
+    dynamicProjection.interactionsByRef
+  );
+  const seat = input.perspectivePlayerId == null ? null : dynamicProjection.seats[input.perspectivePlayerId] ?? null;
+  const availableInteractions = seat == null ? [] : hydrateInteractionRefs(
+    registry,
+    seat.availableInteractionRefs,
+    "availableInteractionRefs"
+  );
+  const zones = seat?.zones == null ? {} : hydrateZones(registry, seat.zones, "zones");
+  const frame = {
+    gameVersion: input.gameVersion,
+    actionSetVersion: input.actionSetVersion,
+    perspectivePlayerId: input.perspectivePlayerId,
+    view: composeProjectionView(staticProjection, seat?.view),
+    flow: {
+      currentPhase: input.currentPhase,
+      currentStage: dynamicProjection.currentStage ?? null,
+      activePlayers: [...input.activePlayers],
+      simultaneousPhase: dynamicProjection.simultaneousPhase ?? null
+    },
+    availableInteractions,
+    zones
+  };
+  return PluginGameplayFrameSchema.parse(frame);
+}
+function parseInteractionRegistry(value) {
+  if (value == null) return {};
+  if (!isRecord(value)) {
+    throw new Error("Seat projection interactionsByRef must be an object.");
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([ref, descriptor]) => [
+      ref,
+      InteractionDescriptorSchema.parse(descriptor)
+    ])
+  );
+}
+function hydrateZones(registry, value, path) {
+  if (!isRecord(value)) {
+    throw new Error(`Seat projection ${path} must be an object.`);
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([zoneId, zoneValue]) => [
+      zoneId,
+      hydrateZone(registry, zoneValue, `${path}.${zoneId}`)
+    ])
+  );
+}
+function hydrateZone(registry, value, path) {
+  if (!isRecord(value)) {
+    throw new Error(`Seat projection ${path} must be an object.`);
+  }
+  const cardIds = arrayOfStrings(value.cardIds, `${path}.cardIds`);
+  const cardViewsById = stringRecord(
+    value.cardViewsById,
+    `${path}.cardViewsById`
+  );
+  if (!isRecord(value.playableByCardId)) {
+    throw new Error(
+      `Seat projection ${path}.playableByCardId must be an object.`
+    );
+  }
+  const playableByCardId = Object.fromEntries(
+    Object.entries(value.playableByCardId).map(([cardId, refs]) => [
+      cardId,
+      hydrateInteractionRefs(
+        registry,
+        refs,
+        `${path}.playableByCardId.${cardId}`
+      )
+    ])
+  );
+  return ZoneHandlesSnapshotSchema.parse({
+    cardIds,
+    cardViewsById,
+    playableByCardId
+  });
+}
+function hydrateInteractionRefs(registry, value, path) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Seat projection ${path} must be an array of refs.`);
+  }
+  return value.map((ref, index) => {
+    if (typeof ref !== "string") {
+      throw new Error(
+        `Seat projection ${path}[${index}] must be a ref string.`
+      );
+    }
+    const descriptor = registry[ref];
+    if (!descriptor) {
+      throw new Error(
+        `Seat projection ${path}[${index}] references '${ref}', which is missing from interactionsByRef.`
+      );
+    }
+    return descriptor;
+  });
+}
+function composeProjectionView(staticProjection, dynamicView) {
+  const normalizedDynamicView = dynamicView === void 0 ? null : dynamicView;
+  if (staticProjection == null) {
+    return normalizedDynamicView;
+  }
+  if (normalizedDynamicView == null) {
+    return staticProjection.view;
+  }
+  if (isRecord(staticProjection.view) && isRecord(normalizedDynamicView)) {
+    return {
+      ...staticProjection.view,
+      ...normalizedDynamicView
+    };
+  }
+  return {
+    static: staticProjection.view,
+    dynamic: normalizedDynamicView
+  };
+}
+function arrayOfStrings(value, path) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`Seat projection ${path} must be an array of strings.`);
+  }
+  return value;
+}
+function stringRecord(value, path) {
+  if (!isRecord(value)) {
+    throw new Error(`Seat projection ${path} must be an object.`);
+  }
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item !== "string") {
+      throw new Error(`Seat projection ${path}.${key} must be a string.`);
+    }
+    result[key] = item;
+  }
+  return result;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+
+// src/runtime/context/PluginGameplayFrameContext.tsx
+import {
+  createContext,
+  useContext,
+  useMemo as useMemo2,
+  useSyncExternalStore as useSyncExternalStore2
+} from "react";
+
+// src/runtime/hooks/useRuntimeSnapshotSelector.ts
+import { useCallback, useMemo, useSyncExternalStore } from "react";
+function defaultRuntimeSnapshotEquality(left, right) {
+  return Object.is(left, right);
+}
+function useRuntimeSnapshotSelector(subscribe, getSnapshot, getServerSnapshot, selector, equalityFn = defaultRuntimeSnapshotEquality) {
+  const cache = useMemo(
+    () => ({ current: null, selector, equalityFn }),
+    [equalityFn, selector]
+  );
+  const getSelectedFromSnapshot = useCallback(
+    (snapshot) => {
+      const cached = cache.current;
+      if (cached && cached.snapshot === snapshot) {
+        return cached.selection;
+      }
+      const nextSelection = selector(snapshot);
+      if (cached && equalityFn(cached.selection, nextSelection)) {
+        cache.current = {
+          snapshot,
+          selection: cached.selection
+        };
+        return cached.selection;
+      }
+      cache.current = {
+        snapshot,
+        selection: nextSelection
+      };
+      return nextSelection;
+    },
+    [cache, equalityFn, selector]
+  );
+  const getSelectedSnapshot = useCallback(
+    () => getSelectedFromSnapshot(getSnapshot()),
+    [getSelectedFromSnapshot, getSnapshot]
+  );
+  const getSelectedServerSnapshot = useCallback(
+    () => selector(getServerSnapshot()),
+    [getServerSnapshot, selector]
+  );
+  const subscribeSelected = useCallback(
+    (onStoreChange) => subscribe(() => {
+      const previous = cache.current;
+      const nextSelection = getSelectedSnapshot();
+      if (!previous || !equalityFn(previous.selection, nextSelection)) {
+        onStoreChange();
+      }
+    }),
+    [cache, equalityFn, getSelectedSnapshot, subscribe]
+  );
+  return useSyncExternalStore(
+    subscribeSelected,
+    getSelectedSnapshot,
+    getSelectedServerSnapshot
+  );
+}
+
+// src/runtime/context/PluginGameplayFrameContext.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var PluginGameplayFrameStoreContext = createContext(null);
+var PluginGameplayFrameContext = createContext(
+  null
+);
+function DefaultLoadingScreen() {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        height: "100%",
+        width: "100%",
+        color: "#666"
+      },
+      children: /* @__PURE__ */ jsxs("div", { style: { textAlign: "center" }, children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              width: "40px",
+              height: "40px",
+              border: "3px solid #e0e0e0",
+              borderTopColor: "#666",
+              borderRadius: "50%",
+              animation: "spin 1s linear infinite",
+              margin: "0 auto 12px"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx("style", { children: `@keyframes spin { to { transform: rotate(360deg); } }` }),
+        /* @__PURE__ */ jsx("p", { children: "Loading game view..." })
+      ] })
+    }
+  );
+}
+function PluginGameplayFrameProvider({
+  runtime,
+  children,
+  loadingComponent = /* @__PURE__ */ jsx(DefaultLoadingScreen, {})
+}) {
+  const storeApi = useMemo2(() => {
+    let current = runtime.getFrame();
+    return {
+      subscribe: (onStoreChange) => runtime.subscribeFrame(() => {
+        current = runtime.getFrame();
+        onStoreChange();
+      }),
+      getSnapshot: () => current,
+      getServerSnapshot: () => current
+    };
+  }, [runtime]);
+  return /* @__PURE__ */ jsx(
+    PluginGameplayFrameStoreProvider,
+    {
+      store: storeApi,
+      loadingComponent,
+      children
+    }
+  );
+}
+function PluginGameplayFrameStoreProvider({
+  store,
+  children,
+  loadingComponent
+}) {
+  const frame = useSyncExternalStore2(
+    store.subscribe,
+    store.getSnapshot,
+    store.getServerSnapshot
+  );
+  if (!frame) {
+    return /* @__PURE__ */ jsx(Fragment, { children: loadingComponent });
+  }
+  return /* @__PURE__ */ jsx(PluginGameplayFrameStoreContext.Provider, { value: store, children: /* @__PURE__ */ jsxs(PluginGameplayFrameContext.Provider, { value: frame, children: [
+    /* @__PURE__ */ jsx(SemanticGameplayFrameMarker, { frame }),
+    children
+  ] }) });
+}
+function usePluginGameplayFrameSelector(selector, equalityFn = defaultRuntimeSnapshotEquality) {
+  const store = useContext(PluginGameplayFrameStoreContext);
+  if (!store) {
+    throw new Error(
+      "usePluginGameplayFrameSelector must be used within PluginGameplayFrameProvider."
+    );
+  }
+  return useRuntimeSnapshotSelector(
+    store.subscribe,
+    store.getSnapshot,
+    store.getServerSnapshot,
+    (frame) => selector(requirePluginGameplayFrame(frame)),
+    equalityFn
+  );
+}
+function useAuthoredPluginGameplayFrameSelector(selector, equalityFn = defaultRuntimeSnapshotEquality) {
+  return usePluginGameplayFrameSelector(
+    (frame) => selector(frame),
+    equalityFn
+  );
+}
+function requirePluginGameplayFrame(frame) {
+  if (!frame) {
+    throw new Error("Plugin gameplay frame is not available.");
+  }
+  return frame;
+}
+var GAMEPLAY_BROWSER_SCOPE_ID = "runtime";
+var BROWSER_PROJECTION_DIGEST_ATTRIBUTE = "data-dreamboard-projection-digest";
+function SemanticGameplayFrameMarker({
+  frame
+}) {
+  const digest = digestPluginGameplayFrame(frame);
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      "aria-hidden": "true",
+      style: { display: "none" },
+      ...{
+        [BROWSER_INTERACTION_ATTRIBUTES.protocol]: DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
+        [BROWSER_INTERACTION_ATTRIBUTES.surface]: GAMEPLAY_BROWSER_INTERACTION_SURFACE,
+        [BROWSER_INTERACTION_ATTRIBUTES.scope]: GAMEPLAY_BROWSER_SCOPE_ID,
+        [BROWSER_INTERACTION_ATTRIBUTES.role]: "projection",
+        [BROWSER_PROJECTION_DIGEST_ATTRIBUTE]: digest
+      }
+    }
+  );
+}
+
+// src/runtime/context/InteractionDraftContext.tsx
+import { createContext as createContext2, useContext as useContext2, useMemo as useMemo3 } from "react";
+import { useStore } from "zustand";
+import { createStore } from "zustand/vanilla";
+import { useShallow } from "zustand/shallow";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var EMPTY_DRAFT = Object.freeze({});
+function omitRecordKey(record, key) {
+  const next = { ...record };
+  delete next[key];
+  return next;
+}
+function createInteractionUiStore() {
+  const store = createStore()(() => ({
+    drafts: {},
+    arms: {},
+    submitting: {},
+    pendingInteractionKey: null,
+    pendingInteractionRevision: 0
+  }));
+  const api = {
+    getDraft(interactionId) {
+      return store.getState().drafts[interactionId] ?? EMPTY_DRAFT;
+    },
+    setInput(interactionId, key, value) {
+      store.setState((prev) => {
+        const current = prev.drafts[interactionId];
+        if (current && current[key] === value) return prev;
+        return {
+          ...prev,
+          drafts: {
+            ...prev.drafts,
+            [interactionId]: { ...current ?? {}, [key]: value }
+          }
+        };
+      });
+    },
+    clearInput(interactionId, key) {
+      store.setState((prev) => {
+        const current = prev.drafts[interactionId];
+        if (!current) return prev;
+        if (key === void 0) {
+          return { ...prev, drafts: omitRecordKey(prev.drafts, interactionId) };
+        }
+        if (!(key in current)) return prev;
+        const remainingKeys = omitRecordKey(current, key);
+        if (Object.keys(remainingKeys).length === 0) {
+          return { ...prev, drafts: omitRecordKey(prev.drafts, interactionId) };
+        }
+        return {
+          ...prev,
+          drafts: { ...prev.drafts, [interactionId]: remainingKeys }
+        };
+      });
+    },
+    clearAll() {
+      store.setState((prev) => {
+        if (Object.keys(prev.drafts).length === 0 && Object.keys(prev.arms).length === 0 && Object.keys(prev.submitting).length === 0 && prev.pendingInteractionKey === null) {
+          return prev;
+        }
+        return {
+          drafts: {},
+          arms: {},
+          submitting: {},
+          pendingInteractionKey: null,
+          pendingInteractionRevision: prev.pendingInteractionRevision + 1
+        };
+      });
+    },
+    getArmed(surface) {
+      return store.getState().arms[surface] ?? null;
+    },
+    arm(surface, interactionId) {
+      store.setState((prev) => {
+        const current = prev.arms[surface] ?? null;
+        if (current === interactionId) return prev;
+        if (interactionId === null) {
+          return { ...prev, arms: omitRecordKey(prev.arms, surface) };
+        }
+        return { ...prev, arms: { ...prev.arms, [surface]: interactionId } };
+      });
+    },
+    getPendingInteraction() {
+      return store.getState().pendingInteractionKey;
+    },
+    setPendingInteraction(interactionId) {
+      store.setState((prev) => {
+        if (prev.pendingInteractionKey === interactionId) {
+          return interactionId === null ? prev : {
+            ...prev,
+            pendingInteractionRevision: prev.pendingInteractionRevision + 1
+          };
+        }
+        return {
+          ...prev,
+          pendingInteractionKey: interactionId,
+          pendingInteractionRevision: prev.pendingInteractionRevision + 1
+        };
+      });
+    },
+    getPendingInteractionRevision() {
+      return store.getState().pendingInteractionRevision;
+    },
+    isSubmitting(interactionId) {
+      return store.getState().submitting[interactionId] === true;
+    },
+    claimSubmitting(interactionId) {
+      let claimed = false;
+      store.setState((prev) => {
+        if (prev.submitting[interactionId] === true) return prev;
+        claimed = true;
+        return {
+          ...prev,
+          submitting: { ...prev.submitting, [interactionId]: true }
+        };
+      });
+      return claimed;
+    },
+    setSubmitting(interactionId, submitting) {
+      store.setState((prev) => {
+        const current = prev.submitting[interactionId] === true;
+        if (current === submitting) return prev;
+        if (!submitting) {
+          return {
+            ...prev,
+            submitting: omitRecordKey(prev.submitting, interactionId)
+          };
+        }
+        return {
+          ...prev,
+          submitting: { ...prev.submitting, [interactionId]: true }
+        };
+      });
+    }
+  };
+  return Object.assign(store, api);
+}
+var InteractionUiCtx = createContext2(null);
+function InteractionUiProvider({
+  children,
+  store
+}) {
+  const ownedStore = useMemo3(() => createInteractionUiStore(), []);
+  return /* @__PURE__ */ jsx2(InteractionUiCtx.Provider, { value: store ?? ownedStore, children });
+}
+function useInteractionUiStore() {
+  const ctx = useContext2(InteractionUiCtx);
+  const fallback = useMemo3(() => createInteractionUiStore(), []);
+  return ctx ?? fallback;
+}
+function useInteractionDraft(interactionId) {
+  const store = useInteractionUiStore();
+  useStore(
+    store,
+    useShallow(
+      (state) => state.drafts[interactionId] ?? EMPTY_DRAFT
+    )
+  );
+  return store.getDraft(interactionId);
+}
+function useArmedInteraction(surface) {
+  const store = useInteractionUiStore();
+  return useStore(store, (state) => state.arms[surface] ?? null);
+}
+function usePendingInteractionKey() {
+  const store = useInteractionUiStore();
+  const subscribed = useStore(
+    store,
+    (state) => state.pendingInteractionKey ?? null
+  );
+  return store.getPendingInteraction() ?? subscribed;
+}
+function usePendingInteractionRevision() {
+  const store = useInteractionUiStore();
+  const subscribed = useStore(
+    store,
+    (state) => state.pendingInteractionRevision
+  );
+  return Math.max(store.getPendingInteractionRevision(), subscribed);
+}
+function useInteractionSubmitting(interactionId) {
+  const store = useInteractionUiStore();
+  return useStore(
+    store,
+    (state) => state.submitting[interactionId] === true
+  );
+}
+
+// src/runtime/context/PluginSessionContext.tsx
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useMemo as useMemo4,
+  useSyncExternalStore as useSyncExternalStore3
+} from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var PluginSessionContext = createContext3(
+  null
+);
+var PluginSessionDescriptorContext = createContext3(null);
+function sessionStateFromClient(runtime) {
+  const session = runtime.getSession();
+  const frame = runtime.getFrame();
+  return {
+    status: session ? "ready" : "loading",
+    sessionId: session?.sessionId ?? null,
+    controllingPlayerId: frame?.perspectivePlayerId ?? null
+  };
+}
+function pluginSessionStatesEqual(left, right) {
+  if (left.status !== right.status || left.sessionId !== right.sessionId || left.controllingPlayerId !== right.controllingPlayerId) {
+    return false;
+  }
+  return true;
+}
+function pluginSessionDescriptorsEqual(left, right) {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  if (left.sessionId !== right.sessionId || left.players.length !== right.players.length) {
+    return false;
+  }
+  return left.players.every((player, index) => {
+    const next = right.players[index];
+    return player.playerId === next?.playerId && player.displayName === next.displayName && player.color === next.color;
+  });
+}
+function PluginSessionProvider({
+  runtime,
+  children
+}) {
+  const sessionStore = useMemo4(
+    () => {
+      let current = sessionStateFromClient(runtime);
+      return {
+        subscribe: (onStoreChange) => {
+          const refresh = () => {
+            const next = sessionStateFromClient(runtime);
+            if (pluginSessionStatesEqual(current, next)) {
+              return;
+            }
+            current = next;
+            onStoreChange();
+          };
+          const unsubscribeSession = runtime.subscribeSession(refresh);
+          const unsubscribeFrame = runtime.subscribeFrame(refresh);
+          return () => {
+            unsubscribeFrame();
+            unsubscribeSession();
+          };
+        },
+        getSnapshot: () => current,
+        getServerSnapshot: () => current
+      };
+    },
+    [runtime]
+  );
+  const descriptorStore = useMemo4(
+    () => {
+      let current = runtime.getSession();
+      return {
+        subscribe: (onStoreChange) => {
+          const refresh = () => {
+            const next = runtime.getSession();
+            if (pluginSessionDescriptorsEqual(current, next)) {
+              return;
+            }
+            current = next;
+            onStoreChange();
+          };
+          const unsubscribeSession = runtime.subscribeSession(refresh);
+          return () => {
+            unsubscribeSession();
+          };
+        },
+        getSnapshot: () => current,
+        getServerSnapshot: () => current
+      };
+    },
+    [runtime]
+  );
+  const sessionState = useSyncExternalStore3(
+    sessionStore.subscribe,
+    sessionStore.getSnapshot,
+    sessionStore.getServerSnapshot
+  );
+  const sessionDescriptor = useSyncExternalStore3(
+    descriptorStore.subscribe,
+    descriptorStore.getSnapshot,
+    descriptorStore.getServerSnapshot
+  );
+  return /* @__PURE__ */ jsx3(PluginSessionContext.Provider, { value: sessionState, children: /* @__PURE__ */ jsx3(PluginSessionDescriptorContext.Provider, { value: sessionDescriptor, children }) });
+}
+function usePluginSession() {
+  const context = useContext3(PluginSessionContext);
+  if (context === null) {
+    throw new Error(
+      "usePluginSession must be used within a PluginSessionContext.Provider (provided by RuntimeContext)"
+    );
+  }
+  return context;
+}
+function useOptionalPluginSessionDescriptor() {
+  return useContext3(PluginSessionDescriptorContext);
+}
+function usePluginSessionDescriptor() {
+  const descriptor = useOptionalPluginSessionDescriptor();
+  if (!descriptor) {
+    throw new Error(
+      "usePluginSessionDescriptor must be used within PluginSessionProvider."
+    );
+  }
+  return descriptor;
+}
+
+// src/runtime/context/RuntimeContext.tsx
+import { createContext as createContext4, useContext as useContext4, useState, useEffect } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var RuntimeContext = createContext4(null);
+function useRuntimeContext() {
+  const context = useContext4(RuntimeContext);
+  if (!context) {
+    throw new Error(
+      "useRuntimeContext must be used within a RuntimeContext.Provider"
+    );
+  }
+  return context;
+}
+
+export {
+  computePluginActionSetVersion,
+  DREAMBOARD_PLUGIN_PROTOCOL,
+  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
+  RuntimeJsonSchema,
+  HostToPluginEnvelopeSchema,
+  PluginProtocolFrameSchema,
+  PluginProtocolStepSchema,
+  PluginProtocolTapeSchema,
+  materializePluginGameplayFrame,
+  defaultRuntimeSnapshotEquality,
+  PluginGameplayFrameProvider,
+  usePluginGameplayFrameSelector,
+  useAuthoredPluginGameplayFrameSelector,
+  InteractionUiProvider,
+  useInteractionUiStore,
+  useInteractionDraft,
+  useArmedInteraction,
+  usePendingInteractionKey,
+  usePendingInteractionRevision,
+  useInteractionSubmitting,
+  PluginSessionProvider,
+  usePluginSession,
+  usePluginSessionDescriptor,
+  RuntimeContext,
+  useRuntimeContext
+};
+//# sourceMappingURL=chunk-O6M6PN4E.js.map