@dreamboard-games/sdk 0.4.0-alpha.6 → 0.4.0-alpha.7

package/dist/chunk-UUQNOGZV.js

@@ -1,1266 +0,0 @@
-import {
-  BROWSER_INTERACTION_ATTRIBUTES,
-  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
-  GAMEPLAY_BROWSER_INTERACTION_SURFACE
-} from "./chunk-WHR5UW3F.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-E4Y6SAWF.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 SetupGuidanceStepSchema = z.object({
-  id: z.string().min(1),
-  label: z.string().min(1),
-  description: z.string().optional()
-}).strict();
-var GameGuidanceProjectionSchema = z.object({
-  phase: z.object({
-    id: z.string().min(1),
-    label: z.string().min(1),
-    summary: z.string().optional(),
-    objective: z.string().optional()
-  }).strict(),
-  setup: z.object({
-    profileId: z.string().min(1),
-    name: z.string().min(1),
-    summary: z.string().optional(),
-    steps: z.array(SetupGuidanceStepSchema)
-  }).strict().optional()
-}).strict();
-var GameEventDetailSchema = z.object({
-  label: z.string().min(1),
-  value: z.union([z.string(), z.number().finite(), z.boolean()])
-}).strict();
-var SystemActionEventSchema = z.object({
-  kind: z.literal("systemAction"),
-  procedureId: z.string().min(1),
-  title: z.string().min(1),
-  summary: z.string().optional(),
-  details: z.array(GameEventDetailSchema).optional()
-}).strict();
-var GameEventSchema = z.discriminatedUnion("kind", [
-  SystemActionEventSchema
-]);
-var ProjectedGameEventSchema = GameEventSchema.and(
-  z.object({
-    version: z.number().int().nonnegative(),
-    index: z.number().int().nonnegative()
-  }).strict()
-);
-var SeatProjectionBundleSchema = z.object({
-  currentStage: z.string().nullable().optional(),
-  stageSeats: z.array(z.string()).optional(),
-  simultaneousPhase: z.unknown().nullable().optional(),
-  guidance: GameGuidanceProjectionSchema.nullable().optional(),
-  recentEvents: z.array(ProjectedGameEventSchema).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),
-  label: z.string().min(1),
-  help: z.string().optional(),
-  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),
-  guidance: GameGuidanceProjectionSchema.nullable().optional(),
-  recentEvents: z.array(ProjectedGameEventSchema),
-  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,
-    guidance: dynamicProjection.guidance ?? null,
-    recentEvents: [...dynamicProjection.recentEvents ?? []],
-    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-UUQNOGZV.js.map