@dreamboard-games/sdk 0.5.0-alpha.2 → 0.5.0-alpha.21

package/dist/chunk-YT3RPO5J.js

@@ -0,0 +1,635 @@
+import {
+  GameOutcomeSchema,
+  InteractionDescriptorSchema,
+  ProjectedGameEventDetailSchema,
+  ProjectedGameEventSchema,
+  SeatProjectionBundleSchema,
+  SimultaneousPhaseProjectionSchema,
+  SystemActionEventSchema,
+  ViewCardSchema
+} from "./chunk-U6R7FAH4.js";
+import {
+  BoardProjectionSchema,
+  PlayerIdSchema,
+  ProjectedTileSchema,
+  RuntimeJsonSchema,
+  canonicalizePluginRuntimeJson,
+  digestPluginRuntimeJson,
+  immutableCopy
+} from "./chunk-CZRPUWCT.js";
+
+// src/shared/protocol/protocol.ts
+var DREAMBOARD_PLUGIN_PROTOCOL = "dreamboard-plugin";
+var DREAMBOARD_PLUGIN_PROTOCOL_VERSION = 10;
+
+// src/shared/protocol/schema.ts
+import * as z from "zod";
+var GameEventDetailSchema = ProjectedGameEventDetailSchema;
+var SystemActionEventSchema2 = SystemActionEventSchema;
+var GameEventSchema = ProjectedGameEventSchema;
+var SeatProjectionBundleSchema2 = SeatProjectionBundleSchema;
+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),
+  assets: z.record(z.string(), z.instanceof(Blob)).optional()
+}).strict();
+var ZoneHandlesSnapshotSchema = z.object({
+  tiles: z.array(ProjectedTileSchema),
+  cardIds: z.array(z.string()),
+  cardViewsById: z.record(z.string(), ViewCardSchema),
+  cardBacksById: z.record(z.string(), z.string()),
+  playableByCardId: z.record(
+    z.string(),
+    z.array(InteractionDescriptorSchema)
+  )
+}).strict();
+var SimultaneousPhaseSnapshotSchema = SimultaneousPhaseProjectionSchema;
+var GameplayBasisSchema = z.object({
+  sessionId: z.string().min(1),
+  version: z.number().int().nonnegative(),
+  actionSetVersion: z.string().min(1),
+  perspectivePlayerId: PlayerIdSchema
+}).strict();
+var GameOutcomeSchema2 = GameOutcomeSchema;
+var ProjectedViewSchema = z.record(z.string(), RuntimeJsonSchema).superRefine((view, context) => {
+  if (!Object.hasOwn(view, "boards")) return;
+  const boards = BoardProjectionSchema.safeParse(view.boards);
+  if (!boards.success) {
+    for (const issue of boards.error.issues) {
+      context.addIssue({
+        code: "custom",
+        path: ["boards", ...issue.path],
+        message: issue.message
+      });
+    }
+  }
+});
+var SeatFrameSchema = z.object({
+  events: z.array(GameEventSchema).max(32),
+  view: ProjectedViewSchema.nullable(),
+  flow: z.object({
+    currentPhase: z.string().nullable(),
+    activePlayers: z.array(PlayerIdSchema),
+    simultaneousPhase: SimultaneousPhaseSnapshotSchema.nullable()
+  }).strict(),
+  availableInteractions: z.array(InteractionDescriptorSchema),
+  zones: z.record(
+    z.string(),
+    z.record(z.string(), ZoneHandlesSnapshotSchema)
+  )
+}).strict();
+var PluginGameplayFrameSchema = SeatFrameSchema.extend({
+  basis: GameplayBasisSchema
+});
+var InteractionResultSchema = z.discriminatedUnion("accepted", [
+  z.object({
+    type: z.literal("interaction.result"),
+    clientActionId: z.string().min(1),
+    accepted: z.literal(true)
+  }).strict(),
+  z.object({
+    type: z.literal("interaction.result"),
+    clientActionId: z.string().min(1),
+    accepted: z.literal(false),
+    errorCode: z.string().min(1),
+    message: z.string().optional()
+  }).strict()
+]);
+var SubmitInteractionCommandSchema = z.object({
+  type: z.literal("interaction.submit"),
+  clientActionId: z.string().min(1),
+  basis: GameplayBasisSchema,
+  interactionId: z.string().min(1),
+  params: RuntimeJsonSchema
+}).strict();
+var CancelInteractionCommandSchema = SubmitInteractionCommandSchema.omit({ params: true }).extend({ type: z.literal("interaction.cancel") }).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(),
+  InteractionResultSchema
+]);
+var PluginToHostPayloadSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("runtime.ready") }).strict(),
+  z.object({ type: z.literal("runtime.resume") }).strict(),
+  z.object({
+    type: z.literal("runtime.ack"),
+    sequence: z.number().int().nonnegative(),
+    clientReceivedAtMs: z.number().finite().optional(),
+    clientRenderedAtMs: z.number().finite().optional()
+  }).strict(),
+  SubmitInteractionCommandSchema,
+  CancelInteractionCommandSchema,
+  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
+);
+function parsePluginSessionDescriptor(value) {
+  return PluginSessionDescriptorSchema.parse(value);
+}
+function parsePluginGameplayFrame(value) {
+  return PluginGameplayFrameSchema.parse(value);
+}
+function parseHostToPluginEnvelope(value) {
+  return HostToPluginEnvelopeSchema.parse(value);
+}
+function parsePluginToHostEnvelope(value) {
+  return PluginToHostEnvelopeSchema.parse(value);
+}
+
+// src/headless/sources/static.ts
+import { createStore } from "@tanstack/store";
+import * as z2 from "zod";
+var SourceSnapshotSchema = z2.object({
+  me: z2.string().min(1),
+  players: z2.array(PluginPlayerSummarySchema),
+  frame: SeatFrameSchema,
+  version: z2.number().int().nonnegative()
+}).strict();
+function staticSource(input) {
+  const snapshot = immutableCopy(SourceSnapshotSchema.parse(input));
+  if (!snapshot.players.some((player) => player.playerId === snapshot.me))
+    throw new Error("Gameplay seat is absent from session.");
+  const store = createStore(
+    Object.freeze({
+      snapshot,
+      connection: "ready",
+      request: null,
+      failure: null
+    })
+  );
+  return {
+    store: {
+      get: () => store.get(),
+      subscribe: (listener) => store.subscribe(listener)
+    },
+    dispose() {
+      store.setState(
+        (state) => Object.freeze({
+          snapshot: state.snapshot,
+          connection: "closed",
+          request: null,
+          failure: null
+        })
+      );
+    }
+  };
+}
+
+// src/shared/protocol/digest.ts
+function computePluginActionSetVersion(input) {
+  return digestPluginRuntimeJson({
+    digestVersion: "plugin-action-set@6",
+    version: input.version,
+    availableInteractions: input.availableInteractions
+  });
+}
+function digestPluginGameplayFrame(frame) {
+  return digestPluginRuntimeJson({
+    digestVersion: "plugin-gameplay-frame@6",
+    frame
+  });
+}
+function digestPluginCommandRequest(command) {
+  return digestPluginRuntimeJson({
+    digestVersion: "plugin-command-request@6",
+    command
+  });
+}
+
+// src/shared/protocol/projection.ts
+function materializePluginGameplayFrame(input) {
+  const dynamicProjection = SeatProjectionBundleSchema2.parse(
+    canonicalizePluginRuntimeJson(input.dynamicProjection)
+  );
+  if (dynamicProjection.referenceBasis.sessionId !== input.sessionId || dynamicProjection.referenceBasis.version !== input.version) {
+    throw new Error(
+      "Projection reference basis does not match the frame basis."
+    );
+  }
+  const registry = dynamicProjection.interactionsByRef ?? {};
+  const seat = 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 = {
+    events: seat?.events ?? [],
+    basis: {
+      sessionId: input.sessionId,
+      version: input.version,
+      actionSetVersion: input.actionSetVersion,
+      perspectivePlayerId: input.perspectivePlayerId
+    },
+    view: materializeView(seat?.view, seat?.boards),
+    flow: {
+      currentPhase: input.currentPhase,
+      activePlayers: [...input.activePlayers],
+      simultaneousPhase: dynamicProjection.simultaneousPhase ?? null
+    },
+    availableInteractions,
+    zones
+  };
+  return PluginGameplayFrameSchema.parse(frame);
+}
+function materializeView(seatView, seatBoards) {
+  const parts = [
+    seatView,
+    seatBoards === void 0 ? void 0 : { boards: seatBoards }
+  ].filter((part) => part !== void 0 && part !== null);
+  if (parts.length === 0) return null;
+  return Object.assign({}, ...parts);
+}
+function hydrateZones(registry, value, path) {
+  return Object.fromEntries(
+    Object.entries(value).map(([zoneId, hosts]) => [
+      zoneId,
+      Object.fromEntries(
+        Object.entries(hosts).map(([hostId, zone]) => [
+          hostId,
+          {
+            tiles: zone.tiles,
+            cardIds: zone.cardIds,
+            cardViewsById: zone.cardViewsById,
+            cardBacksById: zone.cardBacksById,
+            playableByCardId: Object.fromEntries(
+              Object.entries(zone.playableByCardId).map(([cardId, refs]) => [
+                cardId,
+                hydrateInteractionRefs(
+                  registry,
+                  refs,
+                  `${path}.${zoneId}.${hostId}.playableByCardId.${cardId}`
+                )
+              ])
+            )
+          }
+        ])
+      )
+    ])
+  );
+}
+function hydrateInteractionRefs(registry, value, path) {
+  return value.map((ref, index) => {
+    const descriptor = registry[ref];
+    if (!descriptor) {
+      throw new Error(
+        `Seat projection ${path}[${index}] references '${ref}', which is missing from interactionsByRef.`
+      );
+    }
+    return descriptor;
+  });
+}
+
+// src/headless/sources/lifecycle.ts
+import { createStore as createStore2 } from "@tanstack/store";
+function createSourceLifecycle(options) {
+  let context = options.context ? immutableCopy(options.context) : null;
+  const store = createStore2(
+    Object.freeze({
+      snapshot: null,
+      connection: "connecting",
+      request: null,
+      failure: null
+    })
+  );
+  let session = null;
+  let assetUrls = null;
+  let basis = null;
+  let pending = null;
+  let timer;
+  let recovered = false;
+  let closed = false;
+  const clearTimer = () => {
+    clearTimeout(timer);
+    timer = void 0;
+  };
+  const publish = (state) => {
+    if (state.request) Object.freeze(state.request);
+    store.setState(() => Object.freeze(state));
+  };
+  const recovering = () => {
+    if (closed) return;
+    publish({ ...store.get(), connection: "recovering", failure: null });
+  };
+  const close = (failure) => {
+    if (closed) return;
+    closed = true;
+    clearTimer();
+    for (const url of Object.values(assetUrls ?? {})) URL.revokeObjectURL(url);
+    pending?.reject(failure ?? new Error("Gameplay source disposed."));
+    pending = null;
+    options.close();
+    const snapshot = store.get().snapshot;
+    publish(
+      failure ? {
+        connection: "failed",
+        snapshot,
+        request: null,
+        failure: Object.freeze(failure)
+      } : { connection: "closed", snapshot, request: null, failure: null }
+    );
+  };
+  const fail = (error) => close(error);
+  const arm = () => {
+    clearTimer();
+    timer = setTimeout(() => {
+      if (recovered) {
+        fail(new Error("Gameplay source recovery timed out."));
+        return;
+      }
+      recovered = true;
+      recovering();
+      try {
+        options.recover();
+        if (pending && !pending.accepted) options.send(pending.command);
+        arm();
+      } catch (error) {
+        fail(asError(error));
+      }
+    }, options.timeoutMs ?? 1e4);
+  };
+  const finishBarrier = () => {
+    if (!pending?.accepted) return;
+    const frame = store.get().snapshot;
+    if (!frame || frame.version <= pending.command.basis.version) return;
+    clearTimer();
+    pending = null;
+    publish({
+      snapshot: frame,
+      request: null,
+      connection: "ready",
+      failure: null
+    });
+  };
+  const start = async (operation, interactionId, params) => {
+    const state = store.get();
+    if (closed || state.connection !== "ready" || !basis)
+      return Promise.reject(new Error("Gameplay source is not open."));
+    if (pending)
+      return Promise.reject(
+        new Error("A gameplay interaction is already pending.")
+      );
+    const command = immutableCopy(
+      PluginToHostPayloadSchema.parse({
+        type: operation === "cancel" ? "interaction.cancel" : "interaction.submit",
+        clientActionId: crypto.randomUUID(),
+        basis,
+        interactionId,
+        ...operation === "cancel" ? {} : { params }
+      })
+    );
+    recovered = false;
+    const promise = new Promise((resolve, reject) => {
+      pending = { command, resolve, reject, accepted: false };
+    });
+    publish({
+      ...state,
+      request: {
+        interactionId,
+        operation,
+        phase: "awaiting-result"
+      }
+    });
+    arm();
+    try {
+      options.send(command);
+    } catch (error) {
+      fail(asError(error));
+    }
+    return promise;
+  };
+  const source = {
+    store: {
+      get: () => store.get(),
+      subscribe: (listener) => store.subscribe(listener)
+    },
+    submit: (interactionId, params) => start("submit", interactionId, params),
+    cancel: (interactionId) => start("cancel", interactionId),
+    dispose: () => close(null)
+  };
+  return {
+    source,
+    retry() {
+      if (closed || !pending) return;
+      try {
+        if (pending.accepted) options.recover();
+        else options.send(pending.command);
+      } catch (error) {
+        fail(asError(error));
+      }
+    },
+    fail,
+    recovering,
+    session(value) {
+      if (closed) return;
+      const { assets, ...parsed } = PluginSessionDescriptorSchema.parse(value);
+      if ((context?.sessionId ?? session?.sessionId) && parsed.sessionId !== (context?.sessionId ?? session?.sessionId)) {
+        fail(new Error("Gameplay session changed."));
+        return;
+      }
+      if (context && !parsed.players.some((player) => player.playerId === context.playerId)) {
+        fail(new Error("Gameplay seat is absent from session."));
+        return;
+      }
+      session = immutableCopy(parsed);
+      assetUrls ??= Object.fromEntries(
+        Object.entries(assets ?? {}).map(([path, blob]) => [
+          path,
+          URL.createObjectURL(blob)
+        ])
+      );
+    },
+    frame(value) {
+      if (closed) return;
+      const parsed = PluginGameplayFrameSchema.parse(value);
+      if (!session) {
+        fail(new Error("Gameplay frame arrived before session metadata."));
+        return;
+      }
+      context ??= {
+        sessionId: session.sessionId,
+        playerId: parsed.basis.perspectivePlayerId
+      };
+      if (parsed.basis.sessionId !== context.sessionId) {
+        fail(new Error("Gameplay authority session changed."));
+        return;
+      }
+      const changedSeat = parsed.basis.perspectivePlayerId !== context.playerId;
+      if (changedSeat && !options.followHostSeat) {
+        fail(new Error("Gameplay perspective changed."));
+        return;
+      }
+      if (!session.players.some(
+        (player) => player.playerId === parsed.basis.perspectivePlayerId
+      )) {
+        fail(new Error("Gameplay seat is absent from session."));
+        return;
+      }
+      if (basis && parsed.basis.version < basis.version) return;
+      if (changedSeat) {
+        clearTimer();
+        pending?.reject(new Error("Gameplay perspective changed."));
+        pending = null;
+        recovered = false;
+        context = { ...context, playerId: parsed.basis.perspectivePlayerId };
+      }
+      const { basis: nextBasis, ...frame } = immutableCopy(
+        withCardImageUrls(parsed, assetUrls)
+      );
+      basis = nextBasis;
+      publish({
+        failure: null,
+        request: changedSeat ? null : store.get().request,
+        snapshot: Object.freeze({
+          me: context.playerId,
+          players: session.players,
+          frame: Object.freeze(frame),
+          version: basis.version
+        }),
+        connection: "ready"
+      });
+      finishBarrier();
+    },
+    result(value) {
+      if (closed) return;
+      const result = InteractionResultSchema.parse(value);
+      if (!pending || result.clientActionId !== pending.command.clientActionId || pending.accepted)
+        return;
+      pending.resolve(
+        immutableCopy(
+          result.accepted ? { accepted: true } : {
+            accepted: false,
+            errorCode: result.errorCode,
+            ...result.message === void 0 ? {} : { message: result.message }
+          }
+        )
+      );
+      if (!result.accepted) {
+        clearTimer();
+        pending = null;
+        publish({
+          snapshot: store.get().snapshot,
+          request: null,
+          connection: "ready",
+          failure: null
+        });
+        return;
+      }
+      pending.accepted = true;
+      recovered = false;
+      const state = store.get();
+      publish({
+        connection: state.connection === "recovering" ? "recovering" : "ready",
+        snapshot: state.snapshot,
+        failure: null,
+        request: { ...state.request, phase: "awaiting-frame" }
+      });
+      arm();
+      finishBarrier();
+    }
+  };
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function withCardImageUrls(frame, urls) {
+  if (urls === null || Object.keys(urls).length === 0) return frame;
+  return {
+    ...frame,
+    zones: Object.fromEntries(
+      Object.entries(frame.zones).map(([zoneId, hosts]) => [
+        zoneId,
+        Object.fromEntries(
+          Object.entries(hosts).map(([hostId, zone]) => [
+            hostId,
+            {
+              ...zone,
+              cardViewsById: Object.fromEntries(
+                Object.entries(zone.cardViewsById).map(([cardId, card]) => [
+                  cardId,
+                  {
+                    ...card,
+                    frontImage: card.frontImage === void 0 ? void 0 : urls[card.frontImage] ?? card.frontImage,
+                    backImage: card.backImage === void 0 ? void 0 : urls[card.backImage] ?? card.backImage
+                  }
+                ])
+              ),
+              cardBacksById: Object.fromEntries(
+                Object.entries(zone.cardBacksById).map(([cardId, path]) => [
+                  cardId,
+                  urls[path] ?? path
+                ])
+              )
+            }
+          ])
+        )
+      ])
+    )
+  };
+}
+
+export {
+  DREAMBOARD_PLUGIN_PROTOCOL,
+  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
+  GameEventDetailSchema,
+  SystemActionEventSchema2 as SystemActionEventSchema,
+  GameEventSchema,
+  SeatProjectionBundleSchema2 as SeatProjectionBundleSchema,
+  PluginPlayerSummarySchema,
+  PluginSessionDescriptorSchema,
+  ZoneHandlesSnapshotSchema,
+  SimultaneousPhaseSnapshotSchema,
+  GameplayBasisSchema,
+  GameOutcomeSchema2 as GameOutcomeSchema,
+  SeatFrameSchema,
+  PluginGameplayFrameSchema,
+  InteractionResultSchema,
+  SubmitInteractionCommandSchema,
+  CancelInteractionCommandSchema,
+  HostToPluginPayloadSchema,
+  PluginToHostPayloadSchema,
+  createPluginProtocolEnvelopeSchema,
+  HostToPluginEnvelopeSchema,
+  PluginToHostEnvelopeSchema,
+  parsePluginSessionDescriptor,
+  parsePluginGameplayFrame,
+  parseHostToPluginEnvelope,
+  parsePluginToHostEnvelope,
+  SourceSnapshotSchema,
+  staticSource,
+  createSourceLifecycle,
+  computePluginActionSetVersion,
+  digestPluginGameplayFrame,
+  digestPluginCommandRequest,
+  materializePluginGameplayFrame
+};
+//# sourceMappingURL=chunk-YT3RPO5J.js.map