@dreamboard-games/sdk 0.2.1-alpha.0 → 0.3.0-alpha.1

package/src/types/authoring.ts

@@ -1,1282 +0,0 @@
-import type {
-  BoardEdgeRef,
-  BoardVertexRef,
-  DieTypeSpec as ApiDieTypeSpec,
-  GameTopologyManifest as ApiGameTopologyManifest,
-  JsonValue,
-  PropertySchema,
-} from "./contracts.js";
-
-type DieTypeSpec = Omit<ApiDieTypeSpec, "sides"> & {
-  sides?: ApiDieTypeSpec["sides"];
-};
-
-type DeepReadonly<T> = T extends (...args: readonly unknown[]) => unknown
-  ? T
-  : T extends readonly (infer Item)[]
-    ? ReadonlyArray<DeepReadonly<Item>>
-    : T extends object
-      ? { readonly [Key in keyof T]: DeepReadonly<T[Key]> }
-      : T;
-
-type GameTopologyManifest = DeepReadonly<
-  Omit<ApiGameTopologyManifest, "dieTypes"> & {
-    dieTypes?: readonly DieTypeSpec[];
-  }
->;
-
-type ArrayItem<T> = T extends readonly (infer Item)[] ? Item : never;
-type EntryId<T> = T extends { id: infer Id extends string } ? Id : never;
-type IdsOf<T> = EntryId<ArrayItem<NonNullable<T>>>;
-type RuntimeRecord = Record<string, JsonValue>;
-
-type CardSetId<Manifest extends GameTopologyManifest> = IdsOf<
-  Manifest["cardSets"]
->;
-type ZoneId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["zones"]>;
-type BoardId<Manifest extends GameTopologyManifest> = IdsOf<Manifest["boards"]>;
-type PerPlayerZoneId<Manifest extends GameTopologyManifest> = EntryId<
-  Extract<ArrayItem<NonNullable<Manifest["zones"]>>, { scope: "perPlayer" }>
->;
-type SharedZoneId<Manifest extends GameTopologyManifest> = Exclude<
-  ZoneId<Manifest>,
-  PerPlayerZoneId<Manifest>
->;
-type PerPlayerBoardId<Manifest extends GameTopologyManifest> = EntryId<
-  Extract<ArrayItem<NonNullable<Manifest["boards"]>>, { scope: "perPlayer" }>
->;
-type SharedBoardId<Manifest extends GameTopologyManifest> = Exclude<
-  BoardId<Manifest>,
-  PerPlayerBoardId<Manifest>
->;
-type ResourceId<Manifest extends GameTopologyManifest> = IdsOf<
-  Manifest["resources"]
->;
-type PieceTypeId<Manifest extends GameTopologyManifest> = IdsOf<
-  Manifest["pieceTypes"]
->;
-type DieTypeId<Manifest extends GameTopologyManifest> = IdsOf<
-  Manifest["dieTypes"]
->;
-type PieceSeedOf<Manifest extends GameTopologyManifest> = ArrayItem<
-  NonNullable<Manifest["pieceSeeds"]>
->;
-type DieSeedOf<Manifest extends GameTopologyManifest> = ArrayItem<
-  NonNullable<Manifest["dieSeeds"]>
->;
-type SetupOptionId<Manifest extends GameTopologyManifest> = IdsOf<
-  Manifest["setupOptions"]
->;
-type ManualCardSetOf<Manifest extends GameTopologyManifest> = Extract<
-  ArrayItem<NonNullable<Manifest["cardSets"]>>,
-  { type: "manual" }
->;
-type CardOf<Manifest extends GameTopologyManifest> =
-  ManualCardSetOf<Manifest> extends infer CardSet
-    ? CardSet extends { cards: infer Cards extends readonly unknown[] }
-      ? ArrayItem<Cards>
-      : never
-    : never;
-
-type BoardOf<
-  Manifest extends GameTopologyManifest,
-  CurrentBoardId extends BoardId<Manifest>,
-> = Extract<ArrayItem<NonNullable<Manifest["boards"]>>, { id: CurrentBoardId }>;
-type BoardTemplateOf<
-  Manifest extends GameTopologyManifest,
-  CurrentTemplateId extends string,
-> = Extract<
-  ArrayItem<NonNullable<Manifest["boardTemplates"]>>,
-  { id: CurrentTemplateId }
->;
-type ResolvedBoardLikeOf<
-  Manifest extends GameTopologyManifest,
-  CurrentBoardId extends BoardId<Manifest>,
-> =
-  | BoardOf<Manifest, CurrentBoardId>
-  | (BoardOf<Manifest, CurrentBoardId> extends {
-      templateId: infer CurrentTemplateId extends string;
-    }
-      ? BoardTemplateOf<Manifest, CurrentTemplateId>
-      : never);
-
-type SpaceIdOf<BoardLike> = IdsOf<
-  BoardLike extends { spaces?: infer Spaces } ? Spaces : never
->;
-type ContainerIdOf<BoardLike> = IdsOf<
-  BoardLike extends { containers?: infer Containers } ? Containers : never
->;
-type SpaceOf<BoardLike> = ArrayItem<
-  NonNullable<BoardLike extends { spaces?: infer Spaces } ? Spaces : never>
->;
-type SquareSpaceOf<BoardLike> = Extract<
-  SpaceOf<BoardLike>,
-  { row: number; col: number }
->;
-type HexSpaceOf<BoardLike> = Extract<
-  SpaceOf<BoardLike>,
-  { q: number; r: number }
->;
-type BoardEntryOf<Manifest extends GameTopologyManifest> = ArrayItem<
-  NonNullable<Manifest["boards"]>
->;
-type TemplateForBoardEntry<
-  Manifest extends GameTopologyManifest,
-  Entry,
-> = Entry extends {
-  templateId: infer TemplateId extends string;
-  layout: infer Layout;
-}
-  ? Extract<BoardTemplateOf<Manifest, TemplateId>, { layout: Layout }>
-  : never;
-type BoardLikeForEntry<Manifest extends GameTopologyManifest, Entry> =
-  Entry extends BoardEntryOf<Manifest>
-    ? Entry extends { id: infer CurrentBoardId extends BoardId<Manifest> }
-      ? ResolvedBoardLikeOf<Manifest, CurrentBoardId>
-      : Entry
-    : Entry;
-
-type SpaceIdForBoard<
-  Manifest extends GameTopologyManifest,
-  CurrentBoardId extends BoardId<Manifest>,
-> = SpaceIdOf<ResolvedBoardLikeOf<Manifest, CurrentBoardId>>;
-type ContainerIdForBoard<
-  Manifest extends GameTopologyManifest,
-  CurrentBoardId extends BoardId<Manifest>,
-> = ContainerIdOf<ResolvedBoardLikeOf<Manifest, CurrentBoardId>>;
-
-type RuntimeIdsFromCount<BaseId extends string, Count> = Count extends number
-  ? number extends Count
-    ? BaseId | `${BaseId}-${number}`
-    : Count extends 1
-      ? BaseId
-      : `${BaseId}-${OneTo<Count>}`
-  : BaseId;
-
-type CardRuntimeId<Card> = Card extends { type: infer TypeId extends string }
-  ? RuntimeIdsFromCount<
-      TypeId,
-      Card extends { count: infer Count extends number } ? Count : never
-    >
-  : never;
-type SeedRuntimeId<Seed> = Seed extends { typeId: infer TypeId extends string }
-  ? RuntimeIdsFromCount<
-      Seed extends { id: infer Id extends string } ? Id : TypeId,
-      Seed extends { count: infer Count extends number } ? Count : never
-    >
-  : never;
-type CardId<Manifest extends GameTopologyManifest> = CardRuntimeId<
-  CardOf<Manifest>
->;
-type PieceId<Manifest extends GameTopologyManifest> = SeedRuntimeId<
-  PieceSeedOf<Manifest>
->;
-type DieId<Manifest extends GameTopologyManifest> = SeedRuntimeId<
-  DieSeedOf<Manifest>
->;
-
-type PieceTypeOf<
-  Manifest extends GameTopologyManifest,
-  CurrentTypeId extends PieceTypeId<Manifest>,
-> = Extract<
-  ArrayItem<NonNullable<Manifest["pieceTypes"]>>,
-  { id: CurrentTypeId }
->;
-type DieTypeOf<
-  Manifest extends GameTopologyManifest,
-  CurrentTypeId extends DieTypeId<Manifest>,
-> = Extract<
-  ArrayItem<NonNullable<Manifest["dieTypes"]>>,
-  { id: CurrentTypeId }
->;
-type SlotIdOf<TypeSpec> = IdsOf<
-  TypeSpec extends { slots?: infer Slots } ? Slots : never
->;
-type SlotIdForPieceType<
-  Manifest extends GameTopologyManifest,
-  CurrentTypeId extends PieceTypeId<Manifest>,
-> = SlotIdOf<PieceTypeOf<Manifest, CurrentTypeId>>;
-type SlotIdForDieType<
-  Manifest extends GameTopologyManifest,
-  CurrentTypeId extends DieTypeId<Manifest>,
-> = SlotIdOf<DieTypeOf<Manifest, CurrentTypeId>>;
-
-type SingletonExplicitSeed<Seed> = Seed extends { id: infer _Id extends string }
-  ? Seed extends { count: infer Count extends number }
-    ? Count extends 1
-      ? Seed
-      : never
-    : Seed
-  : never;
-type TypedPieceSlotHostSeed<Manifest extends GameTopologyManifest> =
-  SingletonExplicitSeed<PieceSeedOf<Manifest>> extends infer Seed
-    ? Seed extends { typeId: infer CurrentTypeId extends PieceTypeId<Manifest> }
-      ? [SlotIdForPieceType<Manifest, CurrentTypeId>] extends [never]
-        ? never
-        : Seed
-      : never
-    : never;
-type TypedDieSlotHostSeed<Manifest extends GameTopologyManifest> =
-  SingletonExplicitSeed<DieSeedOf<Manifest>> extends infer Seed
-    ? Seed extends { typeId: infer CurrentTypeId extends DieTypeId<Manifest> }
-      ? [SlotIdForDieType<Manifest, CurrentTypeId>] extends [never]
-        ? never
-        : Seed
-      : never
-    : never;
-
-type TypedPieceSlotHomeSpec<Manifest extends GameTopologyManifest> =
-  TypedPieceSlotHostSeed<Manifest> extends infer Seed
-    ? Seed extends {
-        id: infer HostId extends string;
-        typeId: infer CurrentTypeId extends PieceTypeId<Manifest>;
-      }
-      ? {
-          type: "slot";
-          host: {
-            kind: "piece";
-            id: HostId;
-          };
-          slotId: SlotIdForPieceType<Manifest, CurrentTypeId>;
-        }
-      : never
-    : never;
-type TypedDieSlotHomeSpec<Manifest extends GameTopologyManifest> =
-  TypedDieSlotHostSeed<Manifest> extends infer Seed
-    ? Seed extends {
-        id: infer HostId extends string;
-        typeId: infer CurrentTypeId extends DieTypeId<Manifest>;
-      }
-      ? {
-          type: "slot";
-          host: {
-            kind: "die";
-            id: HostId;
-          };
-          slotId: SlotIdForDieType<Manifest, CurrentTypeId>;
-        }
-      : never
-    : never;
-
-type RequiredSchemaKeys<Properties extends Readonly<Record<string, unknown>>> =
-  {
-    [Key in keyof Properties]: Properties[Key] extends { optional: true }
-      ? never
-      : Properties[Key] extends { default: unknown }
-        ? never
-        : Key;
-  }[keyof Properties];
-type OptionalSchemaKeys<Properties extends Readonly<Record<string, unknown>>> =
-  {
-    [Key in keyof Properties]: Properties[Key] extends { optional: true }
-      ? Key
-      : Properties[Key] extends { default: unknown }
-        ? Key
-        : never;
-  }[keyof Properties];
-
-type SchemaValueFromObjectProperties<
-  Properties extends Readonly<Record<string, unknown>>,
-  Manifest extends GameTopologyManifest,
-  BoardLike = never,
-> = keyof Properties extends never
-  ? RuntimeRecord
-  : {
-      [Key in RequiredSchemaKeys<Properties>]: SchemaValueForProperty<
-        Properties[Key],
-        Manifest,
-        BoardLike
-      >;
-    } & {
-      [Key in OptionalSchemaKeys<Properties>]?: SchemaValueForProperty<
-        Properties[Key],
-        Manifest,
-        BoardLike
-      >;
-    };
-
-type SchemaValueForObjectSchema<
-  Schema,
-  Manifest extends GameTopologyManifest,
-  BoardLike = never,
-> = Schema extends {
-  properties: infer Properties extends Readonly<Record<string, unknown>>;
-}
-  ? SchemaValueFromObjectProperties<Properties, Manifest, BoardLike>
-  : RuntimeRecord;
-
-type MergeSharedProperties<Variant, Shared> = Variant extends {
-  properties: infer VariantProperties extends Readonly<Record<string, unknown>>;
-}
-  ? {
-      properties: Shared extends Readonly<Record<string, unknown>>
-        ? Omit<Shared, keyof VariantProperties> & VariantProperties
-        : VariantProperties;
-    }
-  : Variant;
-
-type BaseSchemaValueForProperty<
-  Schema,
-  Manifest extends GameTopologyManifest,
-  BoardLike = never,
-> = Schema extends { type: "string" }
-  ? string
-  : Schema extends { type: "integer" | "number" }
-    ? number
-    : Schema extends { type: "boolean" }
-      ? boolean
-      : Schema extends { type: "zoneId" }
-        ? ZoneId<Manifest>
-        : Schema extends { type: "cardId" }
-          ? CardId<Manifest>
-          : Schema extends { type: "playerId" }
-            ? PlayerId<Manifest>
-            : Schema extends { type: "boardId" }
-              ? BoardId<Manifest>
-              : Schema extends { type: "spaceId" }
-                ? [BoardLike] extends [never]
-                  ? string
-                  : SpaceIdOf<BoardLike>
-                : Schema extends { type: "edgeId" }
-                  ? [BoardLike] extends [never]
-                    ? string
-                    : DerivedEdgeIdOf<BoardLike>
-                  : Schema extends { type: "vertexId" }
-                    ? [BoardLike] extends [never]
-                      ? string
-                      : DerivedVertexIdOf<BoardLike>
-                    : Schema extends { type: "pieceId" }
-                      ? PieceId<Manifest>
-                      : Schema extends { type: "dieId" }
-                        ? DieId<Manifest>
-                        : Schema extends { type: "resourceId" }
-                          ? ResourceId<Manifest>
-                          : Schema extends { type: "enum" }
-                            ? Schema extends {
-                                enums: infer Values extends readonly string[];
-                              }
-                              ? Values[number]
-                              : string
-                            : Schema extends { type: "array" }
-                              ? ReadonlyArray<
-                                  SchemaValueForProperty<
-                                    Schema extends {
-                                      items?: infer Items;
-                                    }
-                                      ? Items
-                                      : undefined,
-                                    Manifest,
-                                    BoardLike
-                                  >
-                                >
-                              : Schema extends { type: "object" }
-                                ? SchemaValueForObjectSchema<
-                                    Schema extends {
-                                      properties?: infer Properties extends
-                                        Record<string, unknown>;
-                                    }
-                                      ? {
-                                          properties: Properties;
-                                        }
-                                      : undefined,
-                                    Manifest,
-                                    BoardLike
-                                  >
-                                : Schema extends { type: "record" }
-                                  ? Record<
-                                      string,
-                                      SchemaValueForProperty<
-                                        Schema extends {
-                                          values?: infer Values;
-                                        }
-                                          ? Values
-                                          : undefined,
-                                        Manifest,
-                                        BoardLike
-                                      >
-                                    >
-                                  : RuntimeRecord;
-
-type SchemaValueForProperty<
-  Schema,
-  Manifest extends GameTopologyManifest,
-  BoardLike = never,
-> = Schema extends { nullable: true }
-  ? BaseSchemaValueForProperty<Schema, Manifest, BoardLike> | null
-  : BaseSchemaValueForProperty<Schema, Manifest, BoardLike>;
-
-type BuildTuple<
-  Length extends number,
-  Accumulator extends unknown[] = [],
-> = Accumulator["length"] extends Length
-  ? Accumulator
-  : BuildTuple<Length, [...Accumulator, unknown]>;
-
-type EnumerateInternal<
-  Length extends number,
-  Accumulator extends number[] = [],
-> = Accumulator["length"] extends Length
-  ? Accumulator[number]
-  : EnumerateInternal<Length, [...Accumulator, Accumulator["length"]]>;
-
-type AddOne<Count extends number> = [...BuildTuple<Count>, unknown]["length"] &
-  number;
-type OneTo<Count extends number> = Exclude<EnumerateInternal<AddOne<Count>>, 0>;
-type PlayerId<Manifest extends GameTopologyManifest> =
-  Manifest["players"]["maxPlayers"] extends infer MaxPlayers extends number
-    ? `player-${OneTo<MaxPlayers>}`
-    : `player-${number}`;
-
-type ToNumber<Input extends string> =
-  Input extends `${infer Value extends number}` ? Value : never;
-type AbsoluteNumber<Count extends number> =
-  `${Count}` extends `-${infer Value extends number}` ? Value : Count;
-type IsNegative<Count extends number> = `${Count}` extends `-${string}`
-  ? true
-  : false;
-type Negate<Count extends number> = Count extends 0
-  ? 0
-  : ToNumber<`${`${Count}` extends `-${infer Value extends number}`
-      ? Value
-      : `-${Count}`}`>;
-type AddPositive<Left extends number, Right extends number> = number extends
-  | Left
-  | Right
-  ? number
-  : [...BuildTuple<Left>, ...BuildTuple<Right>]["length"] & number;
-type ComparePositive<
-  Left extends number,
-  Right extends number,
-> = Left extends Right
-  ? "equal"
-  : number extends Left | Right
-    ? "unknown"
-    : BuildTuple<Left> extends [...BuildTuple<Right>, ...infer Rest]
-      ? Rest extends []
-        ? "equal"
-        : "greater"
-      : "less";
-type SubtractPositive<
-  Left extends number,
-  Right extends number,
-> = number extends Left | Right
-  ? number
-  : BuildTuple<Left> extends [...BuildTuple<Right>, ...infer Rest]
-    ? Rest["length"] & number
-    : never;
-type AddSigned<Left extends number, Right extends number> = number extends
-  | Left
-  | Right
-  ? number
-  : IsNegative<Left> extends IsNegative<Right>
-    ? IsNegative<Left> extends true
-      ? Negate<AddPositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>>>
-      : AddPositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>>
-    : ComparePositive<
-          AbsoluteNumber<Left>,
-          AbsoluteNumber<Right>
-        > extends "equal"
-      ? 0
-      : ComparePositive<
-            AbsoluteNumber<Left>,
-            AbsoluteNumber<Right>
-          > extends "greater"
-        ? IsNegative<Left> extends true
-          ? Negate<
-              SubtractPositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>>
-            >
-          : SubtractPositive<AbsoluteNumber<Left>, AbsoluteNumber<Right>>
-        : IsNegative<Right> extends true
-          ? Negate<
-              SubtractPositive<AbsoluteNumber<Right>, AbsoluteNumber<Left>>
-            >
-          : SubtractPositive<AbsoluteNumber<Right>, AbsoluteNumber<Left>>;
-type MultiplyByThree<Count extends number> = AddSigned<
-  Count,
-  AddSigned<Count, Count>
->;
-type CharRank<Character extends string> = Character extends ","
-  ? 0
-  : Character extends "-"
-    ? 1
-    : Character extends "0"
-      ? 2
-      : Character extends "1"
-        ? 3
-        : Character extends "2"
-          ? 4
-          : Character extends "3"
-            ? 5
-            : Character extends "4"
-              ? 6
-              : Character extends "5"
-                ? 7
-                : Character extends "6"
-                  ? 8
-                  : Character extends "7"
-                    ? 9
-                    : Character extends "8"
-                      ? 10
-                      : Character extends "9"
-                        ? 11
-                        : never;
-type CompareCharacters<
-  Left extends string,
-  Right extends string,
-> = Left extends Right
-  ? "equal"
-  : ComparePositive<CharRank<Left>, CharRank<Right>> extends "less"
-    ? "less"
-    : "greater";
-type CompareStrings<
-  Left extends string,
-  Right extends string,
-> = Left extends `${infer LeftHead}${infer LeftTail}`
-  ? Right extends `${infer RightHead}${infer RightTail}`
-    ? LeftHead extends RightHead
-      ? CompareStrings<LeftTail, RightTail>
-      : CompareCharacters<LeftHead, RightHead>
-    : "greater"
-  : Right extends ""
-    ? "equal"
-    : "less";
-type SortPair<Left extends string, Right extends string> =
-  CompareStrings<Left, Right> extends "greater"
-    ? `${Right}::${Left}`
-    : `${Left}::${Right}`;
-type SquareCornerGeometryKey<
-  Space extends { row: number; col: number },
-  Corner extends "nw" | "ne" | "se" | "sw",
-> = Corner extends "nw"
-  ? `${Space["col"]},${Space["row"]}`
-  : Corner extends "ne"
-    ? `${AddSigned<Space["col"], 1>},${Space["row"]}`
-    : Corner extends "se"
-      ? `${AddSigned<Space["col"], 1>},${AddSigned<Space["row"], 1>}`
-      : `${Space["col"]},${AddSigned<Space["row"], 1>}`;
-type SquareEdgeGeometryKey<
-  Space extends { row: number; col: number },
-  Side extends "north" | "east" | "south" | "west",
-> = Side extends "north"
-  ? `${Space["col"]},${Space["row"]}::${AddSigned<Space["col"], 1>},${Space["row"]}`
-  : Side extends "east"
-    ? `${AddSigned<Space["col"], 1>},${Space["row"]}::${AddSigned<
-        Space["col"],
-        1
-      >},${AddSigned<Space["row"], 1>}`
-    : Side extends "south"
-      ? `${Space["col"]},${AddSigned<Space["row"], 1>}::${AddSigned<
-          Space["col"],
-          1
-        >},${AddSigned<Space["row"], 1>}`
-      : `${Space["col"]},${Space["row"]}::${Space["col"]},${AddSigned<
-          Space["row"],
-          1
-        >}`;
-type HexCornerGeometryKey<
-  Space extends { q: number; r: number },
-  Corner extends "ne-e" | "e-se" | "se-sw" | "sw-w" | "w-nw" | "nw-ne",
-> = `${AddSigned<
-  MultiplyByThree<Space["q"]>,
-  Corner extends "ne-e"
-    ? 2
-    : Corner extends "e-se"
-      ? 1
-      : Corner extends "se-sw"
-        ? -1
-        : Corner extends "sw-w"
-          ? -2
-          : Corner extends "w-nw"
-            ? -1
-            : 1
->},${AddSigned<
-  MultiplyByThree<Negate<AddSigned<Space["q"], Space["r"]>>>,
-  Corner extends "ne-e"
-    ? -1
-    : Corner extends "e-se"
-      ? -2
-      : Corner extends "se-sw"
-        ? -1
-        : Corner extends "sw-w"
-          ? 1
-          : Corner extends "w-nw"
-            ? 2
-            : 1
->},${AddSigned<
-  MultiplyByThree<Space["r"]>,
-  Corner extends "ne-e"
-    ? -1
-    : Corner extends "e-se"
-      ? 1
-      : Corner extends "se-sw"
-        ? 2
-        : Corner extends "sw-w"
-          ? 1
-          : Corner extends "w-nw"
-            ? -1
-            : -2
->}`;
-type HexEdgeGeometryKey<
-  Space extends { q: number; r: number },
-  Side extends "e" | "ne" | "nw" | "w" | "sw" | "se",
-> = SortPair<
-  HexCornerGeometryKey<
-    Space,
-    Side extends "e"
-      ? "ne-e"
-      : Side extends "ne"
-        ? "nw-ne"
-        : Side extends "nw"
-          ? "w-nw"
-          : Side extends "w"
-            ? "sw-w"
-            : Side extends "sw"
-              ? "se-sw"
-              : "e-se"
-  >,
-  HexCornerGeometryKey<
-    Space,
-    Side extends "e"
-      ? "e-se"
-      : Side extends "ne"
-        ? "ne-e"
-        : Side extends "nw"
-          ? "nw-ne"
-          : Side extends "w"
-            ? "w-nw"
-            : Side extends "sw"
-              ? "sw-w"
-              : "se-sw"
-  >
->;
-type DerivedSquareEdgeIdOf<BoardLike> =
-  SquareSpaceOf<BoardLike> extends infer Space
-    ? Space extends { row: number; col: number }
-      ?
-          | `square-edge:${SquareEdgeGeometryKey<Space, "north">}`
-          | `square-edge:${SquareEdgeGeometryKey<Space, "east">}`
-          | `square-edge:${SquareEdgeGeometryKey<Space, "south">}`
-          | `square-edge:${SquareEdgeGeometryKey<Space, "west">}`
-      : never
-    : never;
-type DerivedSquareVertexIdOf<BoardLike> =
-  SquareSpaceOf<BoardLike> extends infer Space
-    ? Space extends { row: number; col: number }
-      ?
-          | `square-vertex:${SquareCornerGeometryKey<Space, "nw">}`
-          | `square-vertex:${SquareCornerGeometryKey<Space, "ne">}`
-          | `square-vertex:${SquareCornerGeometryKey<Space, "se">}`
-          | `square-vertex:${SquareCornerGeometryKey<Space, "sw">}`
-      : never
-    : never;
-type DerivedHexEdgeIdOf<BoardLike> =
-  HexSpaceOf<BoardLike> extends infer Space
-    ? Space extends { q: number; r: number }
-      ?
-          | `hex-edge:${HexEdgeGeometryKey<Space, "e">}`
-          | `hex-edge:${HexEdgeGeometryKey<Space, "ne">}`
-          | `hex-edge:${HexEdgeGeometryKey<Space, "nw">}`
-          | `hex-edge:${HexEdgeGeometryKey<Space, "w">}`
-          | `hex-edge:${HexEdgeGeometryKey<Space, "sw">}`
-          | `hex-edge:${HexEdgeGeometryKey<Space, "se">}`
-      : never
-    : never;
-type DerivedHexVertexIdOf<BoardLike> =
-  HexSpaceOf<BoardLike> extends infer Space
-    ? Space extends { q: number; r: number }
-      ?
-          | `hex-vertex:${HexCornerGeometryKey<Space, "ne-e">}`
-          | `hex-vertex:${HexCornerGeometryKey<Space, "e-se">}`
-          | `hex-vertex:${HexCornerGeometryKey<Space, "se-sw">}`
-          | `hex-vertex:${HexCornerGeometryKey<Space, "sw-w">}`
-          | `hex-vertex:${HexCornerGeometryKey<Space, "w-nw">}`
-          | `hex-vertex:${HexCornerGeometryKey<Space, "nw-ne">}`
-      : never
-    : never;
-type DerivedEdgeIdOf<BoardLike> = BoardLike extends { layout: "square" }
-  ? DerivedSquareEdgeIdOf<BoardLike>
-  : BoardLike extends { layout: "hex" }
-    ? DerivedHexEdgeIdOf<BoardLike>
-    : never;
-type DerivedVertexIdOf<BoardLike> = BoardLike extends { layout: "square" }
-  ? DerivedSquareVertexIdOf<BoardLike>
-  : BoardLike extends { layout: "hex" }
-    ? DerivedHexVertexIdOf<BoardLike>
-    : never;
-
-type SetupOptionChoiceId<Option> = IdsOf<
-  Option extends { choices?: infer Choices } ? Choices : never
->;
-type SetupOptionOf<Manifest extends GameTopologyManifest> = ArrayItem<
-  NonNullable<Manifest["setupOptions"]>
->;
-type SetupOptionChoiceIdFor<
-  Manifest extends GameTopologyManifest,
-  OptionId extends SetupOptionId<Manifest>,
-> = SetupOptionChoiceId<Extract<SetupOptionOf<Manifest>, { id: OptionId }>>;
-
-type TypedSharedSpaceHomeSpec<Manifest extends GameTopologyManifest> = {
-  [CurrentBoardId in SharedBoardId<Manifest>]: {
-    type: "space";
-    boardId: CurrentBoardId;
-    spaceId: SpaceIdForBoard<Manifest, CurrentBoardId>;
-  };
-}[SharedBoardId<Manifest>];
-
-type TypedPerPlayerSpaceHomeSpec<Manifest extends GameTopologyManifest> = {
-  [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
-    type: "space";
-    boardId: CurrentBoardId;
-    spaceId: SpaceIdForBoard<Manifest, CurrentBoardId>;
-  };
-}[PerPlayerBoardId<Manifest>];
-
-type TypedSharedContainerHomeSpec<Manifest extends GameTopologyManifest> = {
-  [CurrentBoardId in SharedBoardId<Manifest>]: {
-    type: "container";
-    boardId: CurrentBoardId;
-    containerId: ContainerIdForBoard<Manifest, CurrentBoardId>;
-  };
-}[SharedBoardId<Manifest>];
-
-type TypedPerPlayerContainerHomeSpec<Manifest extends GameTopologyManifest> = {
-  [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
-    type: "container";
-    boardId: CurrentBoardId;
-    containerId: ContainerIdForBoard<Manifest, CurrentBoardId>;
-  };
-}[PerPlayerBoardId<Manifest>];
-
-type TypedSharedEdgeHomeSpec<Manifest extends GameTopologyManifest> = {
-  [CurrentBoardId in SharedBoardId<Manifest>]: {
-    type: "edge";
-    boardId: CurrentBoardId;
-    ref: BoardEdgeRef;
-  };
-}[SharedBoardId<Manifest>];
-
-type TypedPerPlayerEdgeHomeSpec<Manifest extends GameTopologyManifest> = {
-  [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
-    type: "edge";
-    boardId: CurrentBoardId;
-    ref: BoardEdgeRef;
-  };
-}[PerPlayerBoardId<Manifest>];
-
-type TypedSharedVertexHomeSpec<Manifest extends GameTopologyManifest> = {
-  [CurrentBoardId in SharedBoardId<Manifest>]: {
-    type: "vertex";
-    boardId: CurrentBoardId;
-    ref: BoardVertexRef;
-  };
-}[SharedBoardId<Manifest>];
-
-type TypedPerPlayerVertexHomeSpec<Manifest extends GameTopologyManifest> = {
-  [CurrentBoardId in PerPlayerBoardId<Manifest>]: {
-    type: "vertex";
-    boardId: CurrentBoardId;
-    ref: BoardVertexRef;
-  };
-}[PerPlayerBoardId<Manifest>];
-
-type TypedSharedZoneHomeSpec<Manifest extends GameTopologyManifest> = {
-  type: "zone";
-  zoneId: SharedZoneId<Manifest>;
-};
-
-type TypedPerPlayerZoneHomeSpec<Manifest extends GameTopologyManifest> = {
-  type: "zone";
-  zoneId: PerPlayerZoneId<Manifest>;
-};
-
-type TypedPlayerScopedComponentHomeSpec<Manifest extends GameTopologyManifest> =
-
-    | TypedPerPlayerZoneHomeSpec<Manifest>
-    | TypedPerPlayerSpaceHomeSpec<Manifest>
-    | TypedPerPlayerContainerHomeSpec<Manifest>
-    | TypedPerPlayerEdgeHomeSpec<Manifest>
-    | TypedPerPlayerVertexHomeSpec<Manifest>;
-
-type TypedSharedComponentHomeSpec<Manifest extends GameTopologyManifest> =
-  | { type: "detached" }
-  | TypedSharedZoneHomeSpec<Manifest>
-  | TypedSharedSpaceHomeSpec<Manifest>
-  | TypedSharedContainerHomeSpec<Manifest>
-  | TypedSharedEdgeHomeSpec<Manifest>
-  | TypedSharedVertexHomeSpec<Manifest>
-  | TypedPieceSlotHomeSpec<Manifest>
-  | TypedDieSlotHomeSpec<Manifest>;
-
-type TypedComponentHomeSpec<Manifest extends GameTopologyManifest> =
-  | TypedSharedComponentHomeSpec<Manifest>
-  | TypedPlayerScopedComponentHomeSpec<Manifest>;
-
-type TypedSeedLocationSpec<
-  Seed,
-  Manifest extends GameTopologyManifest,
-> = Seed extends { home: infer Home }
-  ? Home extends TypedPlayerScopedComponentHomeSpec<Manifest>
-    ? Omit<Seed, "ownerId" | "home"> & {
-        ownerId: PlayerId<Manifest>;
-        home: TypedPlayerScopedComponentHomeSpec<Manifest>;
-      }
-    : Omit<Seed, "ownerId" | "home"> & {
-        ownerId?: PlayerId<Manifest>;
-        home?: TypedComponentHomeSpec<Manifest>;
-      }
-  : Omit<Seed, "ownerId" | "home"> & {
-      ownerId?: PlayerId<Manifest>;
-      home?: TypedComponentHomeSpec<Manifest>;
-    };
-
-type TypedVisibilitySpec<Manifest extends GameTopologyManifest> = {
-  faceUp?: boolean;
-  visibleTo?: readonly PlayerId<Manifest>[];
-};
-type TypedVisibility<T, Manifest extends GameTopologyManifest> = T extends {
-  visibility?: unknown;
-}
-  ? Omit<T, "visibility"> & {
-      visibility?: TypedVisibilitySpec<Manifest>;
-    }
-  : T;
-type TypedFields<
-  T,
-  Schema,
-  Manifest extends GameTopologyManifest,
-  BoardLike = never,
-> = T extends { fields?: unknown }
-  ? Omit<T, "fields"> & {
-      fields?: SchemaValueForObjectSchema<Schema, Manifest, BoardLike>;
-    }
-  : T;
-type TypedBoardContainerHost<Host, BoardLike> = Host extends {
-  type: "space";
-  spaceId: string;
-}
-  ? Omit<Host, "spaceId"> & {
-      spaceId: SpaceIdOf<BoardLike>;
-    }
-  : Host;
-type TypedBoardContainer<
-  Container,
-  Manifest extends GameTopologyManifest,
-  BoardLike,
-  ContainerSchema,
-> = Container extends { host: infer Host }
-  ? Omit<
-      TypedFields<
-        TypedAllowedCardSetIds<Container, Manifest>,
-        ContainerSchema,
-        Manifest,
-        BoardLike
-      >,
-      "host"
-    > & {
-      host: TypedBoardContainerHost<Host, BoardLike>;
-    }
-  : TypedFields<
-      TypedAllowedCardSetIds<Container, Manifest>,
-      ContainerSchema,
-      Manifest,
-      BoardLike
-    >;
-type TypedBoardRelation<
-  Relation,
-  Manifest extends GameTopologyManifest,
-  BoardLike,
-  RelationSchema,
-> = Relation extends object
-  ? Omit<
-      TypedFields<Relation, RelationSchema, Manifest, BoardLike>,
-      "fromSpaceId" | "toSpaceId"
-    > & {
-      fromSpaceId: SpaceIdOf<BoardLike>;
-      toSpaceId: SpaceIdOf<BoardLike>;
-    }
-  : Relation;
-type TypedOptionalArray<
-  Base,
-  Source,
-  Key extends string,
-  Item,
-> = Source extends { [Property in Key]?: readonly unknown[] }
-  ? Base & {
-      [Property in Key]?: ReadonlyArray<Item>;
-    }
-  : Base;
-type EffectiveSchemaForEntry<
-  Manifest extends GameTopologyManifest,
-  Entry,
-  Key extends string,
-> = Key extends keyof Entry
-  ? Entry[Key]
-  : TemplateForBoardEntry<Manifest, Entry> extends infer Template
-    ? Key extends keyof Template
-      ? Template[Key]
-      : undefined
-    : undefined;
-type TypedGenericBoardLike<
-  Entry,
-  Manifest extends GameTopologyManifest,
-  BoardLike,
-> = TypedOptionalArray<
-  TypedOptionalArray<
-    TypedOptionalArray<
-      TypedFields<
-        Omit<Entry, "spaces" | "relations" | "containers">,
-        EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">,
-        Manifest,
-        BoardLike
-      >,
-      Entry,
-      "spaces",
-      TypedFields<
-        ArrayItem<
-          NonNullable<Entry extends { spaces?: infer Spaces } ? Spaces : never>
-        >,
-        EffectiveSchemaForEntry<Manifest, Entry, "spaceFieldsSchema">,
-        Manifest,
-        BoardLike
-      >
-    >,
-    Entry,
-    "relations",
-    TypedBoardRelation<
-      ArrayItem<
-        NonNullable<
-          Entry extends { relations?: infer Relations } ? Relations : never
-        >
-      >,
-      Manifest,
-      BoardLike,
-      EffectiveSchemaForEntry<Manifest, Entry, "relationFieldsSchema">
-    >
-  >,
-  Entry,
-  "containers",
-  TypedBoardContainer<
-    ArrayItem<
-      NonNullable<
-        Entry extends { containers?: infer Containers } ? Containers : never
-      >
-    >,
-    Manifest,
-    BoardLike,
-    EffectiveSchemaForEntry<Manifest, Entry, "containerFieldsSchema">
-  >
->;
-type TypedHexBoardLike<
-  Entry,
-  Manifest extends GameTopologyManifest,
-  BoardLike,
-> = TypedOptionalArray<
-  TypedOptionalArray<
-    TypedOptionalArray<
-      TypedFields<
-        Omit<Entry, "spaces" | "edges" | "vertices">,
-        EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">,
-        Manifest,
-        BoardLike
-      >,
-      Entry,
-      "spaces",
-      TypedFields<
-        ArrayItem<
-          NonNullable<Entry extends { spaces?: infer Spaces } ? Spaces : never>
-        >,
-        EffectiveSchemaForEntry<Manifest, Entry, "spaceFieldsSchema">,
-        Manifest,
-        BoardLike
-      >
-    >,
-    Entry,
-    "edges",
-    TypedFields<
-      ArrayItem<
-        NonNullable<Entry extends { edges?: infer Edges } ? Edges : never>
-      >,
-      EffectiveSchemaForEntry<Manifest, Entry, "edgeFieldsSchema">,
-      Manifest,
-      BoardLike
-    >
-  >,
-  Entry,
-  "vertices",
-  TypedFields<
-    ArrayItem<
-      NonNullable<
-        Entry extends { vertices?: infer Vertices } ? Vertices : never
-      >
-    >,
-    EffectiveSchemaForEntry<Manifest, Entry, "vertexFieldsSchema">,
-    Manifest,
-    BoardLike
-  >
->;
-type TypedSquareBoardLike<
-  Entry,
-  Manifest extends GameTopologyManifest,
-  BoardLike,
-> = TypedOptionalArray<
-  TypedOptionalArray<
-    TypedOptionalArray<
-      TypedOptionalArray<
-        TypedOptionalArray<
-          TypedFields<
-            Omit<
-              Entry,
-              "spaces" | "relations" | "containers" | "edges" | "vertices"
-            >,
-            EffectiveSchemaForEntry<Manifest, Entry, "boardFieldsSchema">,
-            Manifest,
-            BoardLike
-          >,
-          Entry,
-          "spaces",
-          TypedFields<
-            ArrayItem<
-              NonNullable<
-                Entry extends { spaces?: infer Spaces } ? Spaces : never
-              >
-            >,
-            EffectiveSchemaForEntry<Manifest, Entry, "spaceFieldsSchema">,
-            Manifest,
-            BoardLike
-          >
-        >,
-        Entry,
-        "relations",
-        TypedBoardRelation<
-          ArrayItem<
-            NonNullable<
-              Entry extends { relations?: infer Relations } ? Relations : never
-            >
-          >,
-          Manifest,
-          BoardLike,
-          EffectiveSchemaForEntry<Manifest, Entry, "relationFieldsSchema">
-        >
-      >,
-      Entry,
-      "containers",
-      TypedBoardContainer<
-        ArrayItem<
-          NonNullable<
-            Entry extends { containers?: infer Containers } ? Containers : never
-          >
-        >,
-        Manifest,
-        BoardLike,
-        EffectiveSchemaForEntry<Manifest, Entry, "containerFieldsSchema">
-      >
-    >,
-    Entry,
-    "edges",
-    TypedFields<
-      ArrayItem<
-        NonNullable<Entry extends { edges?: infer Edges } ? Edges : never>
-      >,
-      EffectiveSchemaForEntry<Manifest, Entry, "edgeFieldsSchema">,
-      Manifest,
-      BoardLike
-    >
-  >,
-  Entry,
-  "vertices",
-  TypedFields<
-    ArrayItem<
-      NonNullable<
-        Entry extends { vertices?: infer Vertices } ? Vertices : never
-      >
-    >,
-    EffectiveSchemaForEntry<Manifest, Entry, "vertexFieldsSchema">,
-    Manifest,
-    BoardLike
-  >
->;
-type TypedBoardLikeEntry<
-  Entry,
-  Manifest extends GameTopologyManifest,
-> = Entry extends { layout: "generic" }
-  ? TypedGenericBoardLike<Entry, Manifest, BoardLikeForEntry<Manifest, Entry>>
-  : Entry extends { layout: "hex" }
-    ? TypedHexBoardLike<Entry, Manifest, BoardLikeForEntry<Manifest, Entry>>
-    : Entry extends { layout: "square" }
-      ? TypedSquareBoardLike<
-          Entry,
-          Manifest,
-          BoardLikeForEntry<Manifest, Entry>
-        >
-      : Entry;
-
-type TypedCard<
-  Card,
-  Manifest extends GameTopologyManifest,
-  CardSchema,
-> = Card extends { type: infer CardType extends string }
-  ? Omit<TypedVisibility<Card, Manifest>, "home" | "properties"> & {
-      home?: TypedComponentHomeSpec<Manifest>;
-      properties: CardSchema extends {
-        variants: infer Variants extends Record<string, unknown>;
-        shared?: infer Shared;
-      }
-        ? CardType extends keyof Variants
-          ? SchemaValueForObjectSchema<
-              MergeSharedProperties<Variants[CardType], Shared>,
-              Manifest
-            >
-          : never
-        : SchemaValueForObjectSchema<CardSchema, Manifest>;
-    }
-  : Card;
-
-type TypedCardSet<
-  CardSet,
-  Manifest extends GameTopologyManifest,
-> = CardSet extends {
-  type: "manual";
-  cardSchema: infer CardSchema;
-  cards: infer Cards extends readonly unknown[];
-}
-  ? Omit<CardSet, "cards"> & {
-      cards: ReadonlyArray<TypedCard<ArrayItem<Cards>, Manifest, CardSchema>>;
-    }
-  : CardSet;
-
-type TypedAllowedCardSetIds<
-  T,
-  Manifest extends GameTopologyManifest,
-> = T extends object
-  ? Omit<T, "allowedCardSetIds"> & {
-      allowedCardSetIds?: readonly CardSetId<Manifest>[];
-    }
-  : T;
-
-type TypedZone<
-  Zone,
-  Manifest extends GameTopologyManifest,
-> = TypedAllowedCardSetIds<Zone, Manifest>;
-
-type TypedPieceSeed<
-  Seed,
-  Manifest extends GameTopologyManifest,
-> = Seed extends { typeId: infer CurrentTypeId }
-  ? CurrentTypeId extends PieceTypeId<Manifest>
-    ? Omit<
-        TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>,
-        "typeId" | "ownerId" | "home" | "fields"
-      > & {
-        typeId: CurrentTypeId;
-        fields?: SchemaValueForObjectSchema<
-          PieceTypeOf<Manifest, CurrentTypeId> extends {
-            fieldsSchema?: infer FieldsSchema;
-          }
-            ? FieldsSchema
-            : undefined,
-          Manifest
-        >;
-      } & Pick<
-          TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>,
-          "ownerId" | "home"
-        >
-    : Omit<Seed, "typeId"> & {
-        typeId: PieceTypeId<Manifest>;
-      }
-  : never;
-
-type TypedDieSeed<Seed, Manifest extends GameTopologyManifest> = Seed extends {
-  typeId: infer CurrentTypeId;
-}
-  ? CurrentTypeId extends DieTypeId<Manifest>
-    ? Omit<
-        TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>,
-        "typeId" | "ownerId" | "home" | "fields"
-      > & {
-        typeId: CurrentTypeId;
-        fields?: SchemaValueForObjectSchema<
-          DieTypeOf<Manifest, CurrentTypeId> extends {
-            fieldsSchema?: infer FieldsSchema;
-          }
-            ? FieldsSchema
-            : undefined,
-          Manifest
-        >;
-      } & Pick<
-          TypedSeedLocationSpec<TypedVisibility<Seed, Manifest>, Manifest>,
-          "ownerId" | "home"
-        >
-    : Omit<Seed, "typeId"> & {
-        typeId: DieTypeId<Manifest>;
-      }
-  : never;
-
-type TypedSetupOptionValues<Manifest extends GameTopologyManifest> = Partial<{
-  [OptionId in SetupOptionId<Manifest>]: SetupOptionChoiceIdFor<
-    Manifest,
-    OptionId
-  >;
-}>;
-
-type TypedSetupProfile<
-  Profile,
-  Manifest extends GameTopologyManifest,
-> = Profile extends object
-  ? Omit<Profile, "optionValues"> & {
-      optionValues?: TypedSetupOptionValues<Manifest>;
-    }
-  : Profile;
-
-export type TypedTopologyManifest<Manifest extends GameTopologyManifest> = Omit<
-  Manifest,
-  | "cardSets"
-  | "zones"
-  | "boardTemplates"
-  | "boards"
-  | "pieceSeeds"
-  | "dieSeeds"
-  | "setupProfiles"
-> & {
-  cardSets: ReadonlyArray<
-    TypedCardSet<ArrayItem<Manifest["cardSets"]>, Manifest>
-  >;
-  zones?: Manifest["zones"] extends readonly unknown[]
-    ? ReadonlyArray<TypedZone<ArrayItem<Manifest["zones"]>, Manifest>>
-    : Manifest["zones"];
-  boardTemplates?: Manifest["boardTemplates"] extends readonly unknown[]
-    ? ReadonlyArray<
-        TypedBoardLikeEntry<ArrayItem<Manifest["boardTemplates"]>, Manifest>
-      >
-    : Manifest["boardTemplates"];
-  boards: Manifest["boards"] extends readonly unknown[]
-    ? ReadonlyArray<
-        TypedBoardLikeEntry<ArrayItem<Manifest["boards"]>, Manifest>
-      >
-    : Manifest["boards"];
-  pieceSeeds?: Manifest["pieceSeeds"] extends readonly unknown[]
-    ? ReadonlyArray<TypedPieceSeed<ArrayItem<Manifest["pieceSeeds"]>, Manifest>>
-    : Manifest["pieceSeeds"];
-  dieSeeds?: Manifest["dieSeeds"] extends readonly unknown[]
-    ? ReadonlyArray<TypedDieSeed<ArrayItem<Manifest["dieSeeds"]>, Manifest>>
-    : Manifest["dieSeeds"];
-  setupProfiles?: Manifest["setupProfiles"] extends readonly unknown[]
-    ? ReadonlyArray<
-        TypedSetupProfile<ArrayItem<Manifest["setupProfiles"]>, Manifest>
-      >
-    : Manifest["setupProfiles"];
-};
-
-type TopologyManifestValidation<Manifest> =
-  Manifest extends GameTopologyManifest
-    ? TypedTopologyManifest<Manifest>
-    : GameTopologyManifest;
-
-type DefinedTopologyManifest<Manifest> = Manifest extends GameTopologyManifest
-  ? Manifest
-  : GameTopologyManifest;
-
-export function defineTopologyManifest<const Manifest>(
-  manifest: Manifest & TopologyManifestValidation<NoInfer<Manifest>>,
-): DefinedTopologyManifest<Manifest> {
-  return manifest as DefinedTopologyManifest<Manifest>;
-}