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

package/dist/chunk-FMM5LVJW.js

@@ -0,0 +1,833 @@
+import {
+  __export
+} from "./chunk-VUWNJXLJ.js";
+
+// src/shared/runtime-json.ts
+import { z } from "zod";
+var RuntimeJsonSchema = z.json();
+
+// src/shared/interaction-schema.ts
+import { z as z2 } from "zod";
+var InteractionCommitPolicySchema = z2.discriminatedUnion("mode", [
+  z2.object({ mode: z2.literal("manual") }).strict(),
+  z2.object({ mode: z2.literal("autoWhenReady") }).strict()
+]);
+var InputSelectionSchema = z2.discriminatedUnion("mode", [
+  z2.object({ mode: z2.literal("single") }).strict(),
+  z2.object({
+    mode: z2.literal("many"),
+    min: z2.number().int(),
+    max: z2.number().int().optional(),
+    distinct: z2.boolean().optional()
+  }).strict()
+]);
+var InteractionChoiceOptionSchema = z2.object({
+  value: z2.string().nullable(),
+  label: z2.string(),
+  icon: z2.string().optional(),
+  badge: z2.string().optional(),
+  description: z2.string().optional(),
+  disabled: z2.boolean().optional(),
+  disabledReason: z2.string().optional()
+}).strict();
+var selection = { selection: InputSelectionSchema.optional() };
+var InputDomainSchema = z2.discriminatedUnion("type", [
+  z2.strictObject({
+    type: z2.literal("cardTarget"),
+    projection: z2.literal("resolved"),
+    targetKind: z2.literal("card"),
+    zoneIds: z2.array(z2.string()),
+    eligibleTargets: z2.array(z2.string()),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("boardTarget"),
+    projection: z2.literal("resolved"),
+    targetKind: z2.enum(["edge", "vertex", "space", "tile"]),
+    boardId: z2.string(),
+    valueKind: z2.enum(["board-id", "player-board-space"]).optional(),
+    eligibleTargets: z2.array(z2.string()),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("resourceMap"),
+    resources: z2.array(
+      z2.strictObject({
+        resourceId: z2.string(),
+        label: z2.string().optional(),
+        icon: z2.string().optional(),
+        min: z2.number(),
+        max: z2.number()
+      })
+    ),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("boundedNumber"),
+    min: z2.number(),
+    max: z2.number(),
+    step: z2.number().optional(),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("choice"),
+    choices: z2.array(InteractionChoiceOptionSchema),
+    ...selection
+  }),
+  z2.strictObject({
+    type: z2.literal("choiceList"),
+    choices: z2.array(
+      InteractionChoiceOptionSchema.extend({ value: z2.string() })
+    ),
+    min: z2.number().int().optional(),
+    max: z2.number().int().optional(),
+    ...selection
+  })
+]);
+var InteractionInputDescriptorSchema = z2.object({
+  key: z2.string().min(1),
+  kind: z2.enum([
+    "form",
+    "board-vertex",
+    "board-edge",
+    "board-tile",
+    "board-space",
+    "card",
+    "rng"
+  ]),
+  domain: InputDomainSchema,
+  defaultValue: RuntimeJsonSchema.optional()
+}).strict();
+var InteractionAvailabilitySchema = z2.discriminatedUnion("status", [
+  z2.object({ status: z2.literal("available") }).strict(),
+  z2.object({ status: z2.literal("notYourTurn"), reason: z2.string() }).strict(),
+  z2.object({
+    status: z2.literal("blocked"),
+    reason: z2.string(),
+    code: z2.string().optional()
+  }).strict()
+]);
+var InteractionBaseSchema = z2.object({
+  phaseName: z2.string().min(1),
+  interactionKey: z2.string().min(1),
+  interactionId: z2.string().min(1),
+  label: z2.string().min(1),
+  help: z2.string().optional(),
+  zoneId: z2.string().optional(),
+  zoneIds: z2.array(z2.string()).optional(),
+  commit: InteractionCommitPolicySchema,
+  descriptorDigest: z2.string().optional(),
+  actorSeat: z2.number().int().optional(),
+  draftDigest: z2.string().optional(),
+  inputs: z2.array(InteractionInputDescriptorSchema),
+  step: z2.object({
+    index: z2.number().int().nonnegative(),
+    total: z2.number().int().positive(),
+    selected: z2.record(z2.string(), RuntimeJsonSchema),
+    canCancel: z2.boolean()
+  }).strict().optional(),
+  availability: InteractionAvailabilitySchema,
+  reasons: z2.array(
+    z2.object({
+      ruleId: z2.string(),
+      errorCode: z2.string()
+    }).strict()
+  ).optional()
+}).strict();
+var InteractionDescriptorSchema = InteractionBaseSchema.extend({
+  kind: z2.literal("action")
+}).strict();
+var ZoneInteractionRefsSchema = z2.strictObject({
+  cardIds: z2.array(z2.string()),
+  cardViewsById: z2.record(z2.string(), z2.string()),
+  playableByCardId: z2.record(z2.string(), z2.array(z2.string()))
+});
+
+// src/shared/runtime-schema.ts
+var runtime_schema_exports = {};
+__export(runtime_schema_exports, {
+  AuthoredViewSchema: () => AuthoredViewSchema,
+  BoardStaticProjectionSchema: () => BoardStaticProjectionSchema,
+  DispatchRequestSchema: () => DispatchRequestSchema,
+  DispatchResultAcceptSchema: () => DispatchResultAcceptSchema,
+  DispatchResultRejectSchema: () => DispatchResultRejectSchema,
+  DispatchResultSchema: () => DispatchResultSchema,
+  DispatchTraceAcceptedClientInputSchema: () => DispatchTraceAcceptedClientInputSchema,
+  DispatchTracePhaseEnteredSchema: () => DispatchTracePhaseEnteredSchema,
+  DispatchTraceRngConsumptionSchema: () => DispatchTraceRngConsumptionSchema,
+  DispatchTraceSchema: () => DispatchTraceSchema,
+  GameEventDetailSchema: () => GameEventDetailSchema,
+  GameEventSchema: () => GameEventSchema,
+  GameInputCancelSchema: () => GameInputCancelSchema,
+  GameInputInteractionSchema: () => GameInputInteractionSchema,
+  GameInputSchema: () => GameInputSchema,
+  GameOutcomeReasonSchema: () => GameOutcomeReasonSchema,
+  GameOutcomeSchema: () => GameOutcomeSchema,
+  InitializeRequestSchema: () => InitializeRequestSchema,
+  InitializeResultSchema: () => InitializeResultSchema,
+  OutcomeResultSchema: () => OutcomeResultSchema,
+  OutcomeScoreComponentSchema: () => OutcomeScoreComponentSchema,
+  OutcomeStandingSchema: () => OutcomeStandingSchema,
+  OutcomeTieBreakSchema: () => OutcomeTieBreakSchema,
+  ProjectRequestSchema: () => ProjectRequestSchema,
+  ProjectionTimingMetadataSchema: () => ProjectionTimingMetadataSchema,
+  ReducerContractVersionSchema: () => ReducerContractVersionSchema,
+  ReducerDomainStateSchema: () => ReducerDomainStateSchema,
+  ReducerFlowStateSchema: () => ReducerFlowStateSchema,
+  ReducerRuntimeLogEntryAcceptedClientInputSchema: () => ReducerRuntimeLogEntryAcceptedClientInputSchema,
+  ReducerRuntimeLogEntryPhaseEnteredSchema: () => ReducerRuntimeLogEntryPhaseEnteredSchema,
+  ReducerRuntimeLogEntryRngConsumptionSchema: () => ReducerRuntimeLogEntryRngConsumptionSchema,
+  ReducerRuntimeLogEntrySchema: () => ReducerRuntimeLogEntrySchema,
+  ReducerRuntimeLogEntryStateCommitSchema: () => ReducerRuntimeLogEntryStateCommitSchema,
+  ReducerRuntimeStateSchema: () => ReducerRuntimeStateSchema,
+  ReducerSessionStateSchema: () => ReducerSessionStateSchema,
+  RngDrawSchema: () => RngDrawSchema,
+  RngOperationParameterSchema: () => RngOperationParameterSchema,
+  RngOperationSchema: () => RngOperationSchema,
+  RngStateSchema: () => RngStateSchema,
+  RuntimePendingInteractionSchema: () => RuntimePendingInteractionSchema,
+  RuntimeSimultaneousCurrentSchema: () => RuntimeSimultaneousCurrentSchema,
+  RuntimeSimultaneousStateSchema: () => RuntimeSimultaneousStateSchema,
+  RuntimeSimultaneousSubmissionSchema: () => RuntimeSimultaneousSubmissionSchema,
+  SchedulerContinuationDependencySchema: () => SchedulerContinuationDependencySchema,
+  SchedulerFlowAuthorityProjectionSchema: () => SchedulerFlowAuthorityProjectionSchema,
+  SeatProjectionBundleSchema: () => SeatProjectionBundleSchema,
+  SeatProjectionSchema: () => SeatProjectionSchema,
+  SimultaneousPhaseProjectionSchema: () => SimultaneousPhaseProjectionSchema,
+  SystemActionEventSchema: () => SystemActionEventSchema,
+  TransitionRecordSchema: () => TransitionRecordSchema
+});
+import { z as z3 } from "zod";
+var ReducerContractVersionSchema = z3.string().regex(new RegExp("^[0-9]+\\.[0-9]+\\.[0-9]+$"));
+var RngOperationParameterSchema = z3.union([
+  z3.string(),
+  z3.number().finite(),
+  z3.boolean()
+]);
+var RngOperationSchema = z3.strictObject({
+  kind: z3.string().min(1),
+  parameters: z3.record(z3.string(), RngOperationParameterSchema)
+});
+var RngDrawSchema = z3.strictObject({
+  index: z3.number().int().gte(0),
+  cursorBefore: z3.number().int().gte(0),
+  cursorAfter: z3.number().int().gte(0),
+  operation: RngOperationSchema
+});
+var RngStateSchema = z3.strictObject({
+  seed: z3.union([
+    z3.number().refine(Number.isInteger, { message: "Expected integer" }),
+    z3.null()
+  ]),
+  cursor: z3.number().int(),
+  trace: z3.array(z3.string()),
+  draws: z3.array(RngDrawSchema).optional()
+});
+var ReducerFlowStateSchema = z3.strictObject({
+  currentPhase: z3.string().min(1),
+  turn: z3.number().int(),
+  round: z3.number().int(),
+  activePlayers: z3.array(z3.string().min(1))
+});
+var RuntimeSimultaneousSubmissionSchema = z3.strictObject({
+  interactionId: z3.string().min(1),
+  params: RuntimeJsonSchema
+});
+var RuntimeSimultaneousCurrentSchema = z3.strictObject({
+  phaseName: z3.string().min(1),
+  actors: z3.array(z3.string().min(1)),
+  submissions: z3.record(z3.string(), RuntimeSimultaneousSubmissionSchema)
+});
+var RuntimeSimultaneousStateSchema = z3.strictObject({
+  current: z3.union([RuntimeSimultaneousCurrentSchema, z3.null()])
+});
+var TransitionRecordSchema = z3.strictObject({
+  from: z3.string().min(1),
+  to: z3.string().min(1)
+});
+var RuntimePendingInteractionSchema = z3.strictObject({
+  phaseName: z3.string().min(1),
+  interactionId: z3.string().min(1),
+  values: z3.array(RuntimeJsonSchema).min(1)
+});
+var GameEventDetailSchema = z3.strictObject({
+  label: z3.string().min(1),
+  value: z3.union([z3.string(), z3.number().finite(), z3.boolean()])
+});
+var SystemActionEventSchema = z3.strictObject({
+  kind: z3.literal("systemAction"),
+  procedureId: z3.string().min(1),
+  title: z3.string().min(1),
+  summary: z3.string().min(1).optional(),
+  details: z3.array(GameEventDetailSchema).max(16).optional()
+});
+var GameEventSchema = z3.discriminatedUnion("kind", [
+  SystemActionEventSchema
+]);
+var ReducerRuntimeStateSchema = z3.strictObject({
+  events: z3.array(GameEventSchema).max(32),
+  rng: RngStateSchema,
+  pending: z3.record(z3.string(), RuntimePendingInteractionSchema),
+  simultaneous: RuntimeSimultaneousStateSchema,
+  lastTransition: z3.union([TransitionRecordSchema, z3.null()]),
+  options: z3.record(z3.string(), RuntimeJsonSchema)
+});
+var ReducerDomainStateSchema = z3.strictObject({
+  table: RuntimeJsonSchema,
+  publicState: RuntimeJsonSchema,
+  privateState: z3.record(z3.string(), RuntimeJsonSchema),
+  hiddenState: RuntimeJsonSchema,
+  flow: ReducerFlowStateSchema,
+  phase: RuntimeJsonSchema
+});
+var ReducerSessionStateSchema = z3.strictObject({
+  domain: ReducerDomainStateSchema,
+  runtime: ReducerRuntimeStateSchema
+});
+var GameInputInteractionSchema = z3.strictObject({
+  kind: z3.literal("interaction"),
+  playerId: z3.string().min(1),
+  interactionId: z3.string().min(1),
+  params: RuntimeJsonSchema
+});
+var GameInputCancelSchema = z3.strictObject({
+  kind: z3.literal("interaction.cancel"),
+  playerId: z3.string().min(1),
+  interactionId: z3.string().min(1)
+});
+var GameInputSchema = z3.discriminatedUnion("kind", [
+  GameInputInteractionSchema,
+  GameInputCancelSchema
+]);
+var GameOutcomeReasonSchema = z3.strictObject({
+  code: z3.string().min(1),
+  message: z3.string().min(1).optional()
+});
+var OutcomeResultSchema = z3.enum([
+  "win",
+  "draw",
+  "loss",
+  "eliminated"
+]);
+var OutcomeScoreComponentSchema = z3.strictObject({
+  id: z3.string().min(1),
+  label: z3.string().min(1),
+  value: z3.number().finite()
+});
+var OutcomeTieBreakSchema = z3.strictObject({
+  id: z3.string().min(1),
+  label: z3.string().min(1),
+  value: z3.union([z3.number().finite(), z3.string()])
+});
+var OutcomeStandingSchema = z3.strictObject({
+  playerId: z3.string().min(1),
+  rank: z3.number().int().gte(1),
+  result: OutcomeResultSchema,
+  score: z3.number().finite().optional(),
+  scoreBreakdown: z3.array(OutcomeScoreComponentSchema).optional(),
+  tieBreaks: z3.array(OutcomeTieBreakSchema).optional()
+});
+var GameOutcomeSchema = z3.strictObject({
+  reason: GameOutcomeReasonSchema,
+  standings: z3.array(OutcomeStandingSchema).min(1)
+});
+var InitializeResultSchema = z3.strictObject({
+  state: ReducerSessionStateSchema,
+  terminal: GameOutcomeSchema.optional(),
+  events: z3.array(GameEventSchema).optional()
+});
+var InitializeRequestSchema = z3.strictObject({
+  table: RuntimeJsonSchema,
+  playerIds: z3.array(z3.string().min(1)),
+  rngSeed: z3.union([
+    z3.number().refine(Number.isInteger, { message: "Expected integer" }),
+    z3.null()
+  ]).optional(),
+  options: z3.record(z3.string(), RuntimeJsonSchema).optional()
+});
+var DispatchRequestSchema = z3.strictObject({
+  state: ReducerSessionStateSchema,
+  input: GameInputSchema
+});
+var DispatchTraceAcceptedClientInputSchema = z3.strictObject({
+  kind: z3.literal("acceptedClientInput"),
+  input: GameInputSchema
+});
+var DispatchTracePhaseEnteredSchema = z3.strictObject({
+  kind: z3.literal("phaseEntered"),
+  from: z3.string(),
+  to: z3.string()
+});
+var DispatchTraceRngConsumptionSchema = z3.strictObject({
+  kind: z3.literal("rngConsumption"),
+  version: z3.literal(2),
+  operation: z3.string().min(1),
+  drawIndex: z3.number().int().gte(0),
+  traceEntry: z3.string()
+});
+var DispatchTraceSchema = z3.discriminatedUnion("kind", [
+  DispatchTraceAcceptedClientInputSchema,
+  DispatchTracePhaseEnteredSchema,
+  DispatchTraceRngConsumptionSchema
+]);
+var DispatchResultRejectSchema = z3.strictObject({
+  kind: z3.literal("reject"),
+  errorCode: z3.string().min(1),
+  message: z3.string().optional()
+});
+var DispatchResultAcceptSchema = z3.strictObject({
+  kind: z3.literal("accept"),
+  state: ReducerSessionStateSchema,
+  terminal: GameOutcomeSchema.optional(),
+  trace: z3.array(DispatchTraceSchema),
+  events: z3.array(GameEventSchema).max(32)
+});
+var DispatchResultSchema = z3.discriminatedUnion("kind", [
+  DispatchResultRejectSchema,
+  DispatchResultAcceptSchema
+]);
+var ReducerRuntimeLogEntryAcceptedClientInputSchema = z3.strictObject({
+  kind: z3.literal("acceptedClientInput"),
+  version: z3.number().int(),
+  input: GameInputSchema
+});
+var ReducerRuntimeLogEntryPhaseEnteredSchema = z3.strictObject({
+  kind: z3.literal("phaseEntered"),
+  from: z3.string(),
+  to: z3.string(),
+  version: z3.number().int()
+});
+var ReducerRuntimeLogEntryRngConsumptionSchema = z3.strictObject({
+  kind: z3.literal("rngConsumption"),
+  version: z3.number().int(),
+  operation: z3.string().min(1),
+  drawIndex: z3.number().int().gte(0).optional(),
+  traceEntry: z3.string()
+});
+var ReducerRuntimeLogEntryStateCommitSchema = z3.strictObject({
+  kind: z3.literal("stateCommit"),
+  version: z3.number().int(),
+  state: ReducerSessionStateSchema
+});
+var ReducerRuntimeLogEntrySchema = z3.discriminatedUnion("kind", [
+  ReducerRuntimeLogEntryAcceptedClientInputSchema,
+  ReducerRuntimeLogEntryPhaseEnteredSchema,
+  ReducerRuntimeLogEntryRngConsumptionSchema,
+  ReducerRuntimeLogEntryStateCommitSchema
+]);
+var AuthoredViewSchema = z3.object({
+  boards: z3.never({
+    error: "The view field 'boards' is reserved for manifest geometry."
+  }).optional()
+}).catchall(RuntimeJsonSchema);
+var SeatProjectionSchema = z3.strictObject({
+  view: AuthoredViewSchema.nullable().optional(),
+  availableInteractionRefs: z3.array(z3.string()).optional(),
+  zones: z3.record(z3.string(), ZoneInteractionRefsSchema).optional()
+});
+var SimultaneousPhaseProjectionSchema = z3.strictObject({
+  phaseName: z3.string().min(1),
+  interactionId: z3.string().min(1),
+  actorIds: z3.array(z3.string().min(1)),
+  sealedPlayerIds: z3.array(z3.string().min(1)),
+  pendingPlayerIds: z3.array(z3.string().min(1))
+});
+var SchedulerContinuationDependencySchema = z3.strictObject({
+  waiterPlayerId: z3.string().min(1),
+  blockerPlayerIds: z3.array(z3.string().min(1))
+});
+var SchedulerFlowAuthorityProjectionSchema = z3.strictObject({
+  version: z3.literal(1),
+  activePlayerIds: z3.array(z3.string().min(1)),
+  pendingPlayerIds: z3.array(z3.string().min(1)),
+  continuationDependencies: z3.array(SchedulerContinuationDependencySchema)
+});
+var ProjectionTimingMetadataSchema = z3.strictObject({
+  resolveAvailableInteractionsMs: z3.number().finite().gte(0),
+  resolveViewMs: z3.number().finite().gte(0),
+  resolveZoneHandlesMs: z3.number().finite().gte(0),
+  descriptorHashMs: z3.number().finite().gte(0)
+});
+var SeatProjectionBundleSchema = z3.strictObject({
+  events: z3.array(GameEventSchema).max(32),
+  simultaneousPhase: z3.union([SimultaneousPhaseProjectionSchema, z3.null()]).optional(),
+  schedulerFlow: SchedulerFlowAuthorityProjectionSchema.optional(),
+  interactionsByRef: z3.record(z3.string(), InteractionDescriptorSchema).optional(),
+  seats: z3.record(z3.string(), SeatProjectionSchema),
+  timing: ProjectionTimingMetadataSchema.optional()
+});
+var ProjectRequestSchema = z3.strictObject({
+  state: ReducerSessionStateSchema,
+  playerIds: z3.array(z3.string().min(1))
+});
+var BoardStaticProjectionSchema = z3.strictObject({
+  view: z3.record(z3.string(), RuntimeJsonSchema),
+  hash: z3.string().min(1),
+  manifestVersion: z3.string()
+});
+
+// src/shared/hex-board.ts
+import {
+  defineHex,
+  Grid,
+  Orientation,
+  fromCoordinates as coordinatesTraversal,
+  rectangle as rectangleTraversal,
+  ring as ringTraversal,
+  spiral as spiralTraversal,
+  line as lineTraversal
+} from "honeycomb-grid";
+var hexagon = (options) => ({ kind: "hexagon", ...options });
+var spiral = (options) => ({ kind: "spiral", ...options });
+var ring = (options) => ({ kind: "ring", ...options });
+var rectangle = (options) => ({ kind: "rectangle", ...options });
+var fromCoordinates = (coordinates) => ({ kind: "coordinates", coordinates });
+var coordinateKey = ({ q, r }) => `${q},${r}`;
+var pointKey = ({ x, y }) => `${Math.round(x * 1e9)},${Math.round(y * 1e9)}`;
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function hexClass(orientation, dimensions = 1) {
+  return defineHex({
+    dimensions,
+    orientation: orientation === "flat" ? Orientation.FLAT : Orientation.POINTY,
+    origin: { x: 0, y: 0 }
+  });
+}
+function hexShapeCoordinates(shape, orientation = "pointy") {
+  const integer = (value, name, minimum) => {
+    if (!Number.isSafeInteger(value) || value < minimum)
+      throw new Error(`${name} must be a safe integer >= ${minimum}.`);
+  };
+  const coordinate = (value) => {
+    integer(value.q, "q", Number.MIN_SAFE_INTEGER);
+    integer(value.r, "r", Number.MIN_SAFE_INTEGER);
+  };
+  if (shape.kind === "coordinates") {
+    shape.coordinates.forEach(coordinate);
+    if (new Set(shape.coordinates.map(coordinateKey)).size !== shape.coordinates.length)
+      throw new Error("Hex shape contains duplicate coordinates.");
+  } else if (shape.kind === "rectangle") {
+    integer(shape.width, "width", 1);
+    integer(shape.height, "height", 1);
+    if (shape.start) coordinate(shape.start);
+  } else {
+    integer(shape.radius, "radius", 0);
+    if (shape.center) coordinate(shape.center);
+  }
+  const Tile = hexClass(orientation);
+  const traversal = shape.kind === "coordinates" ? coordinatesTraversal(...shape.coordinates) : shape.kind === "rectangle" ? rectangleTraversal(shape) : shape.kind === "ring" ? ringTraversal({
+    radius: shape.radius,
+    center: shape.center ?? { q: 0, r: 0 }
+  }) : spiralTraversal({ radius: shape.radius, start: shape.center });
+  return new Grid(Tile, traversal).toArray().map(({ q, r }) => ({ q, r }));
+}
+function createHexBoardGeometry(board) {
+  const spaces = board.spaces.map(({ id, q, r }) => ({ id, q, r })).sort((a, b) => compare(a.id, b.id));
+  const orientation = board.orientation ?? "pointy";
+  const grid = new Grid(hexClass(orientation), spaces);
+  const spacesById = new Map(spaces.map((space) => [space.id, space]));
+  if (spacesById.size !== spaces.length || grid.size !== spaces.length)
+    throw new Error(
+      `Hex board '${board.id}' contains duplicate space IDs or coordinates.`
+    );
+  const spacesByCoordinate = new Map(
+    spaces.map((space) => [coordinateKey(space), space])
+  );
+  const cornerOwners = /* @__PURE__ */ new Map();
+  const edgeOwners = /* @__PURE__ */ new Map();
+  const cornersBySpace = /* @__PURE__ */ new Map();
+  const edgesBySpace = /* @__PURE__ */ new Map();
+  for (const space of spaces) {
+    const corners = grid.getHex(space).corners;
+    const cornerKeys = corners.map(pointKey);
+    cornersBySpace.set(space.id, cornerKeys);
+    const edgeKeys = [];
+    corners.forEach((point, corner) => {
+      const key = cornerKeys[corner];
+      const vertex = cornerOwners.get(key) ?? { point, owners: [] };
+      vertex.owners.push({ id: space.id, corner });
+      cornerOwners.set(key, vertex);
+      const pair = [key, cornerKeys[(corner + 1) % 6]];
+      const edgeKey = [...pair].sort(compare).join("|");
+      const edge = edgeOwners.get(edgeKey) ?? { corners: pair, owners: [] };
+      edge.owners.push({ id: space.id, side: corner });
+      edgeOwners.set(edgeKey, edge);
+      edgeKeys.push(edgeKey);
+    });
+    edgesBySpace.set(space.id, edgeKeys);
+  }
+  const vertexIds = new Map(
+    [...cornerOwners].map(([key, vertex]) => {
+      const owners = [...vertex.owners].sort((a, b) => compare(a.id, b.id));
+      return [
+        key,
+        `${board.id}:vertex:${owners.map((owner) => encodeURIComponent(owner.id)).join("|")}${owners.length < 3 ? `:${owners[0].corner}` : ""}`
+      ];
+    })
+  );
+  const edgeIds = new Map(
+    [...edgeOwners].map(([key, edge]) => {
+      const owners = [...edge.owners].sort((a, b) => compare(a.id, b.id));
+      return [
+        key,
+        `${board.id}:edge:${owners.map((owner) => encodeURIComponent(owner.id)).join("|")}${owners.length === 1 ? `:${owners[0].side}` : ""}`
+      ];
+    })
+  );
+  const edges = [...edgeOwners].map(([key, edge]) => ({
+    id: edgeIds.get(key),
+    spaceIds: edge.owners.map((owner) => owner.id).sort(compare),
+    vertexIds: edge.corners.map((key2) => vertexIds.get(key2)).sort(compare)
+  })).sort((a, b) => compare(a.id, b.id));
+  const vertices = [...cornerOwners].map(([key, vertex]) => ({
+    id: vertexIds.get(key),
+    spaceIds: vertex.owners.map((owner) => owner.id).sort(compare),
+    edgeIds: edges.filter((edge) => edge.vertexIds.includes(vertexIds.get(key))).map((edge) => edge.id)
+  })).sort((a, b) => compare(a.id, b.id));
+  const requireSpace = (id) => {
+    const space = spacesById.get(id);
+    if (!space)
+      throw new Error(`Unknown space '${id}' on board '${board.id}'.`);
+    return space;
+  };
+  const selectedIds = (coordinates) => Array.from(coordinates).flatMap((coordinate) => {
+    const space = spacesByCoordinate.get(coordinateKey(coordinate));
+    return space ? [space.id] : [];
+  });
+  return {
+    edges,
+    vertices,
+    neighbors(id) {
+      requireSpace(id);
+      return edges.filter((edge) => edge.spaceIds.includes(id)).flatMap(
+        (edge) => edge.spaceIds.filter((other) => other !== id)
+      );
+    },
+    distance(from, to) {
+      return grid.distance(requireSpace(from), requireSpace(to));
+    },
+    ring(id, radius) {
+      return selectedIds(
+        new Grid(
+          hexClass(orientation),
+          ringTraversal({ center: requireSpace(id), radius })
+        )
+      );
+    },
+    line(from, to) {
+      return selectedIds(
+        new Grid(
+          hexClass(orientation),
+          lineTraversal({ start: requireSpace(from), stop: requireSpace(to) })
+        )
+      );
+    },
+    edgesOf(id) {
+      requireSpace(id);
+      return edgesBySpace.get(id).map((key) => edgeIds.get(key));
+    },
+    verticesOf(id) {
+      requireSpace(id);
+      return cornersBySpace.get(id).map((key) => vertexIds.get(key));
+    },
+    edgeAt(id, side) {
+      requireSpace(id);
+      const key = edgesBySpace.get(id)[side];
+      if (!key)
+        throw new Error("Hex side must be an integer from 0 through 5.");
+      return edgeIds.get(key);
+    },
+    vertexAt(id, corner) {
+      requireSpace(id);
+      const key = cornersBySpace.get(id)[corner];
+      if (!key)
+        throw new Error("Hex corner must be an integer from 0 through 5.");
+      return vertexIds.get(key);
+    },
+    edge(a, b) {
+      requireSpace(a);
+      requireSpace(b);
+      const edge = edges.find(
+        (edge2) => edge2.spaceIds.length === 2 && edge2.spaceIds.includes(a) && edge2.spaceIds.includes(b)
+      );
+      if (!edge || a === b)
+        throw new Error(`Spaces '${a}' and '${b}' do not share an edge.`);
+      return edge.id;
+    },
+    vertex(a, b, c) {
+      requireSpace(a);
+      requireSpace(b);
+      requireSpace(c);
+      const vertex = vertices.find(
+        (vertex2) => vertex2.spaceIds.length === 3 && [a, b, c].every((id) => vertex2.spaceIds.includes(id))
+      );
+      if (!vertex || (/* @__PURE__ */ new Set([a, b, c])).size !== 3)
+        throw new Error("Spaces do not share exactly one vertex.");
+      return vertex.id;
+    },
+    incidentEdges(vertexId) {
+      const vertex = vertices.find((vertex2) => vertex2.id === vertexId);
+      if (!vertex) throw new Error(`Unknown vertex '${vertexId}'.`);
+      return vertex.edgeIds;
+    },
+    incidentVertices(edgeId) {
+      const edge = edges.find((edge2) => edge2.id === edgeId);
+      if (!edge) throw new Error(`Unknown edge '${edgeId}'.`);
+      return edge.vertexIds;
+    },
+    spacesAt(vertexId) {
+      const vertex = vertices.find((vertex2) => vertex2.id === vertexId);
+      if (!vertex) throw new Error(`Unknown vertex '${vertexId}'.`);
+      return vertex.spaceIds;
+    },
+    spacesAlong(edgeId) {
+      const edge = edges.find((edge2) => edge2.id === edgeId);
+      if (!edge) throw new Error(`Unknown edge '${edgeId}'.`);
+      return edge.spaceIds;
+    },
+    getLayout({
+      hexSize,
+      origin = { x: 0, y: 0 }
+    }) {
+      if (!Number.isFinite(hexSize) || hexSize <= 0)
+        throw new Error("hexSize must be positive and finite.");
+      const scaled = new Grid(hexClass(orientation, hexSize), spaces);
+      const layoutSpaces = spaces.map((space) => {
+        const hex = scaled.getHex(space);
+        return {
+          id: space.id,
+          center: { x: hex.x + origin.x, y: hex.y + origin.y },
+          corners: hex.corners.map((point) => ({
+            x: point.x + origin.x,
+            y: point.y + origin.y
+          }))
+        };
+      });
+      const points = layoutSpaces.flatMap((space) => space.corners);
+      const minX = points.length ? Math.min(...points.map((point) => point.x)) : 0;
+      const minY = points.length ? Math.min(...points.map((point) => point.y)) : 0;
+      const maxX = points.length ? Math.max(...points.map((point) => point.x)) : 0;
+      const maxY = points.length ? Math.max(...points.map((point) => point.y)) : 0;
+      const vertexPoints = new Map(
+        [...cornerOwners].map(([key, vertex]) => [
+          vertexIds.get(key),
+          {
+            x: vertex.point.x * hexSize + origin.x,
+            y: vertex.point.y * hexSize + origin.y
+          }
+        ])
+      );
+      return {
+        viewBox: { x: minX, y: minY, width: maxX - minX, height: maxY - minY },
+        spaces: layoutSpaces,
+        edges: edges.map((edge) => ({
+          id: edge.id,
+          from: vertexPoints.get(edge.vertexIds[0]),
+          to: vertexPoints.get(edge.vertexIds[1])
+        })),
+        vertices: vertices.map((vertex) => ({
+          id: vertex.id,
+          center: vertexPoints.get(vertex.id)
+        })),
+        pointToSpace(point) {
+          const hex = scaled.pointToHex(
+            { x: point.x - origin.x, y: point.y - origin.y },
+            { allowOutside: false }
+          );
+          return hex ? spacesByCoordinate.get(coordinateKey(hex))?.id : void 0;
+        }
+      };
+    }
+  };
+}
+function resolveHexSpaces(board) {
+  const excluded = new Set((board.exclude ?? []).map(coordinateKey));
+  const coordinates = hexShapeCoordinates(
+    board.shape,
+    board.orientation
+  ).filter((coordinate) => !excluded.has(coordinateKey(coordinate)));
+  const known = new Set(coordinates.map(coordinateKey));
+  for (const key of Object.keys(board.spaces ?? {})) {
+    if (!known.has(key))
+      throw new Error(
+        `Hex board '${board.id}' overrides coordinate '${key}' outside its shape.`
+      );
+  }
+  return coordinates.map((coordinate) => {
+    const key = coordinateKey(coordinate);
+    return {
+      ...coordinate,
+      ...board.spaces?.[key],
+      id: board.spaces?.[key]?.id ?? key
+    };
+  }).sort((a, b) => compare(a.id, b.id));
+}
+
+// src/shared/protocol/json.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
+function canonicalizePluginRuntimeJson(value) {
+  return canonicalizeJson(
+    RuntimeJsonSchema.parse(omitOptionalProperties(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") return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalizeJson(item));
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => [key, canonicalizeJson(item)])
+  );
+}
+function omitOptionalProperties(value) {
+  if (Array.isArray(value)) return value.map(omitOptionalProperties);
+  if (value !== null && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, omitOptionalProperties(item)])
+    );
+  }
+  return value;
+}
+function sha256Hex(input) {
+  return bytesToHex(sha256(utf8ToBytes(input)));
+}
+
+export {
+  RuntimeJsonSchema,
+  InteractionCommitPolicySchema,
+  InputDomainSchema,
+  InteractionInputDescriptorSchema,
+  InteractionAvailabilitySchema,
+  InteractionDescriptorSchema,
+  RngDrawSchema,
+  GameEventDetailSchema,
+  SystemActionEventSchema,
+  GameEventSchema,
+  ReducerSessionStateSchema,
+  GameInputSchema,
+  GameOutcomeSchema,
+  SimultaneousPhaseProjectionSchema,
+  SeatProjectionBundleSchema,
+  BoardStaticProjectionSchema,
+  runtime_schema_exports,
+  hexagon,
+  spiral,
+  ring,
+  rectangle,
+  fromCoordinates,
+  createHexBoardGeometry,
+  resolveHexSpaces,
+  canonicalizePluginRuntimeJson,
+  encodeCanonicalPluginRuntimeJson,
+  digestPluginRuntimeJson
+};
+//# sourceMappingURL=chunk-FMM5LVJW.js.map