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

package/dist/chunk-EVCLTY4Q.js

@@ -1,935 +0,0 @@
-import {
-  createClientParamSchemasByPhase
-} from "./chunk-PN5O6GG2.js";
-import {
-  Board,
-  ClientParamSchemaProvider,
-  Dice,
-  Game,
-  HandStagingView,
-  HandSurfaceView,
-  Interaction,
-  Phase,
-  PlayerRoster,
-  Prompt,
-  PromptInbox,
-  UI,
-  Zone,
-  dropTargetIdFor,
-  isInteractionAvailable,
-  useResolvedCardTargetValue,
-  useZoneCards
-} from "./chunk-LR3ZTWQF.js";
-import {
-  useAuthoredPluginGameplayFrameSelector
-} from "./chunk-GDPKTBUR.js";
-import {
-  CardFace,
-  Dialog,
-  DialogContent,
-  DialogDescription,
-  DialogHeader,
-  DialogTitle,
-  DialogTrigger,
-  MobileHandTrayProvider,
-  ToastProvider,
-  createResourceCounter,
-  useIsMobile,
-  useRegisterMobileHand
-} from "./chunk-32PFKDV7.js";
-
-// src/runtime/workspace-contract/index.ts
-import { Fragment, createElement as createElement6 } from "react";
-
-// src/runtime/ui-contract.ts
-function createDreamboardUI(contract) {
-  return {
-    contract,
-    Root: UI.Root,
-    Game,
-    Interaction,
-    Prompt,
-    PromptInbox,
-    PlayerRoster,
-    Dice,
-    Phase,
-    Zone,
-    Board
-  };
-}
-
-// src/runtime/workspace-contract/board.ts
-import { createElement as createElement2 } from "react";
-
-// src/runtime/workspace-contract/slots.ts
-import { Fragment as ReactFragment, createElement } from "react";
-function CardSlotValue({
-  children
-}) {
-  const value = useResolvedCardTargetValue();
-  return createElement(ReactFragment, null, children(value));
-}
-function createFormInputSlot(ctx, input, interaction) {
-  const { baseUI, withInteractionRoot } = ctx;
-  return {
-    Field: (props) => {
-      const field = createElement(baseUI.Interaction.Field, {
-        ...props,
-        input
-      });
-      return interaction ? withInteractionRoot(interaction, field) : field;
-    },
-    Options: () => null,
-    Value: ({
-      children
-    }) => createElement(ReactFragment, null, children(void 0)),
-    Default: ({ children }) => createElement(ReactFragment, null, children)
-  };
-}
-function createCardInputSlot(ctx) {
-  const { runtimeInteraction } = ctx;
-  return {
-    Card: ({ value, ...props }) => createElement(runtimeInteraction.CardInput, {
-      ...props,
-      input: "cardId",
-      unsafeCardId: value
-    }),
-    Cards: () => null,
-    Value: ({
-      children
-    }) => createElement(CardSlotValue, { children }),
-    Default: ({ children }) => createElement(ReactFragment, null, children)
-  };
-}
-function createBoardTargetInputSlot(ctx, kind) {
-  const { runtimeBoard } = ctx;
-  const Target = ({
-    value,
-    ...props
-  }) => {
-    if (kind === "edge") {
-      return createElement(runtimeBoard.EdgeTarget, { ...props, value });
-    }
-    if (kind === "vertex") {
-      return createElement(runtimeBoard.VertexTarget, { ...props, value });
-    }
-    return createElement(runtimeBoard.SpaceTarget, { ...props, value });
-  };
-  return {
-    Target,
-    Value: ({
-      children
-    }) => createElement(ReactFragment, null, children(void 0)),
-    Default: ({ children }) => createElement(ReactFragment, null, children)
-  };
-}
-
-// src/runtime/workspace-contract/board.ts
-function createUseBoardSurface(ctx) {
-  const { baseUI, runtimeBoard } = ctx;
-  return function useBoardSurface() {
-    return {
-      Root: ({ children }) => createElement2(baseUI.Board.Root, { children }),
-      Space: (props) => createElement2(runtimeBoard.SpaceTarget, props),
-      slot: {
-        space: createBoardTargetInputSlot(ctx, "space"),
-        playerSpace: createBoardTargetInputSlot(ctx, "space"),
-        edge: createBoardTargetInputSlot(ctx, "edge"),
-        vertex: createBoardTargetInputSlot(ctx, "vertex"),
-        tile: createBoardTargetInputSlot(ctx, "tile")
-      }
-    };
-  };
-}
-function createBoardNamespace(ctx) {
-  const { options, baseUI } = ctx;
-  const useBoardSurface = createUseBoardSurface(ctx);
-  return {
-    surface(board) {
-      return { kind: "board", board };
-    },
-    useSurface: useBoardSurface,
-    HexView({ board: boardId, ...props }) {
-      return createElement2(
-        baseUI.Board.HexView,
-        {
-          ...props,
-          board: options.hexStaticBoards[boardId]
-        }
-      );
-    },
-    HexGrid({ board: boardId, ...props }) {
-      return createElement2(
-        baseUI.Board.HexGrid,
-        {
-          ...props,
-          board: options.hexStaticBoards[boardId]
-        }
-      );
-    },
-    SquareGrid({ board: boardId, ...props }) {
-      return createElement2(
-        baseUI.Board.SquareGrid,
-        {
-          ...props,
-          board: options.squareStaticBoards?.[boardId]
-        }
-      );
-    }
-  };
-}
-
-// src/runtime/workspace-contract/forms.ts
-import { createElement as createElement3 } from "react";
-function createInteractionForms(ctx) {
-  const { options, baseUI, runtimeInteraction, withInteractionRoot } = ctx;
-  function InteractionRoutes({
-    routes,
-    fallback,
-    includeUnavailable
-  }) {
-    return createElement3(runtimeInteraction.Routes, {
-      routes,
-      fallback,
-      includeUnavailable
-    });
-  }
-  function GeneratedFormDialog({
-    title,
-    description,
-    trigger,
-    children,
-    contentClassName,
-    overlayClassName,
-    showCloseButton,
-    defaultOpen,
-    onStateChange
-  }) {
-    return createElement3(baseUI.Interaction.Dialog, {
-      defaultOpen,
-      onStateChange,
-      children: (state) => createElement3(
-        Dialog,
-        { open: state.open, onOpenChange: state.setOpen },
-        trigger ? createElement3(DialogTrigger, {
-          asChild: true,
-          children: trigger
-        }) : null,
-        createElement3(
-          DialogContent,
-          {
-            className: contentClassName,
-            overlayClassName,
-            showCloseButton
-          },
-          createElement3(
-            DialogHeader,
-            null,
-            createElement3(DialogTitle, null, title),
-            description ? createElement3(DialogDescription, null, description) : null
-          ),
-          children
-        )
-      )
-    });
-  }
-  function useInteractionFormSurface(interaction) {
-    const validInputs = options.formInputKeysForInteraction(interaction);
-    const slot = Object.fromEntries(
-      [...validInputs].map((input) => [
-        input,
-        createFormInputSlot(ctx, input, interaction)
-      ])
-    );
-    return {
-      Root: ({ children }) => withInteractionRoot(interaction, children),
-      Form: (props) => withInteractionRoot(
-        interaction,
-        createElement3(baseUI.Interaction.Form, props)
-      ),
-      Dialog: (props) => withInteractionRoot(
-        interaction,
-        createElement3(GeneratedFormDialog, props)
-      ),
-      State: (props) => withInteractionRoot(
-        interaction,
-        createElement3(baseUI.Interaction.State, props)
-      ),
-      Arm: (props) => withInteractionRoot(
-        interaction,
-        createElement3(baseUI.Interaction.Trigger, props)
-      ),
-      Submit: (props) => withInteractionRoot(
-        interaction,
-        createElement3(baseUI.Interaction.Submit, props)
-      ),
-      Field: ({ input, ...props }) => withInteractionRoot(
-        interaction,
-        createElement3(baseUI.Interaction.Field, {
-          ...props,
-          input
-        })
-      ),
-      slot
-    };
-  }
-  const Interaction2 = {
-    State: baseUI.Interaction.State,
-    Dialog: baseUI.Interaction.Dialog,
-    useForm: useInteractionFormSurface,
-    form(interaction) {
-      return { kind: "form", interaction };
-    },
-    forms(interactions) {
-      return { kind: "forms", interactions };
-    },
-    Routes: InteractionRoutes
-  };
-  return { Interaction: Interaction2, useInteractionFormSurface };
-}
-
-// src/runtime/workspace-contract/surfaces.ts
-function isPlainObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isSurfaceDescriptor(value) {
-  return isPlainObject(value) && typeof value.kind === "string";
-}
-function createSurfaceResolvers({
-  Board: Board2,
-  Zone: Zone2,
-  useInteractionFormSurface
-}) {
-  const boardSurface = Board2.useSurface;
-  const zoneHandSurface = Zone2.useHand;
-  const zonePileSurface = Zone2.usePile;
-  const zoneCardCollectionSurface = Zone2.useCardCollection;
-  const interactionFormSurface = useInteractionFormSurface;
-  function resolveSurfaceDescriptor(name, descriptor) {
-    switch (descriptor.kind) {
-      case "board":
-        return boardSurface(name);
-      case "hand":
-        return zoneHandSurface(name, {
-          zone: descriptor.zone,
-          role: descriptor.role,
-          label: descriptor.label,
-          order: descriptor.order
-        });
-      case "pile":
-        return zonePileSurface(name, { zone: descriptor.zone });
-      case "piles":
-        return Object.fromEntries(
-          descriptor.zones.map((zone) => [
-            zone,
-            zonePileSurface(String(zone), { zone })
-          ])
-        );
-      case "cardCollection":
-        return zoneCardCollectionSurface(name, {
-          zones: descriptor.zones,
-          mode: descriptor.mode
-        });
-      case "form":
-        return interactionFormSurface(descriptor.interaction);
-      case "forms":
-        return Object.fromEntries(
-          Object.entries(descriptor.interactions).map(([key, interaction]) => [
-            key,
-            interactionFormSurface(interaction)
-          ])
-        );
-    }
-  }
-  function resolveSurfaceSpec(spec) {
-    return Object.fromEntries(
-      Object.entries(spec).map(([key, value]) => [
-        key,
-        isSurfaceDescriptor(value) ? resolveSurfaceDescriptor(key, value) : resolveSurfaceSpec(value)
-      ])
-    );
-  }
-  function defineSurfaces(spec) {
-    return function useDefinedSurfaces() {
-      return resolveSurfaceSpec(spec);
-    };
-  }
-  return { defineSurfaces, resolveSurfaceSpec, resolveSurfaceDescriptor };
-}
-
-// src/runtime/workspace-contract/zones.ts
-import { Fragment as ReactFragment2, createElement as createElement5 } from "react";
-import { clsx as clsx2 } from "clsx";
-
-// src/runtime/workspace-contract/hand.ts
-import { Children, createElement as createElement4, isValidElement, useMemo } from "react";
-import { clsx } from "clsx";
-function createHandPieces(ctx) {
-  const { baseUI } = ctx;
-  function HandCardsSlot({
-    children
-  }) {
-    void children;
-    return createElement4("template", { "data-dreamboard-hand-cards-slot": "" });
-  }
-  function HandSummarySlot({
-    children
-  }) {
-    void children;
-    return createElement4("template", {
-      "data-dreamboard-hand-summary-slot": ""
-    });
-  }
-  function HandActionsSlot({
-    children
-  }) {
-    void children;
-    return createElement4("template", {
-      "data-dreamboard-hand-actions-slot": ""
-    });
-  }
-  function renderHandSlot(slot, summary) {
-    return typeof slot === "function" ? slot(summary) : slot;
-  }
-  function createHandCardsComponent(options) {
-    return ({
-      empty,
-      children,
-      className,
-      layout,
-      mobileInteraction,
-      cardSize,
-      ariaLabel,
-      dropTargets,
-      renderDropTargets,
-      onCardIntent,
-      onSelectionSummary,
-      ...props
-    }) => {
-      const slots = collectHandSlots(children);
-      const renderCard = typeof children === "function" ? children : slots.cards?.children;
-      if (!renderCard) {
-        throw new Error(
-          "Generated hand surfaces require exactly one <hand.Cards> slot."
-        );
-      }
-      const summaryRenderer = slots.summary ? (summary) => renderHandSlot(slots.summary.children, summary) : void 0;
-      const actionsRenderer = slots.actions ? (summary) => renderHandSlot(slots.actions.children, summary) : void 0;
-      return createElement4(baseUI.Zone.Root, {
-        zone: options.zone,
-        // Fill the author's container instead of shrink-wrapping to the fan's
-        // own measured width. Without a definite width here, a centering parent
-        // sizes to the cards row, the hand measures that, recomputes a new fan
-        // width, and the layout chases itself (a ResizeObserver loop). `w-full`
-        // pins the outermost hand element to the available width and breaks the
-        // cycle for every author layout.
-        className: "w-full min-w-0",
-        children: createElement4(GeneratedHandCards, {
-          ...props,
-          hand: options,
-          className,
-          empty,
-          children: renderCard,
-          layout,
-          mobileInteraction,
-          cardSize,
-          ariaLabel,
-          dropTargets,
-          renderDropTargets,
-          onCardIntent,
-          summarySlot: summaryRenderer,
-          actionsSlot: actionsRenderer,
-          onSelectionSummary
-        })
-      });
-    };
-  }
-  function collectHandSlots(children) {
-    const slots = {};
-    if (typeof children === "function") return slots;
-    for (const child of Children.toArray(children)) {
-      if (!isValidElement(child)) continue;
-      if (child.type === HandCardsSlot) {
-        if (slots.cards) {
-          throw new Error("Only one <hand.Cards> slot may be rendered.");
-        }
-        slots.cards = child.props;
-      } else if (child.type === HandSummarySlot) {
-        if (slots.summary) {
-          throw new Error("Only one <hand.Summary> slot may be rendered.");
-        }
-        slots.summary = child.props;
-      } else if (child.type === HandActionsSlot) {
-        if (slots.actions) {
-          throw new Error("Only one <hand.Actions> slot may be rendered.");
-        }
-        slots.actions = child.props;
-      }
-    }
-    return slots;
-  }
-  function GeneratedHandCards({
-    hand,
-    empty,
-    children,
-    className,
-    sort,
-    layout,
-    mobileInteraction,
-    cardSize,
-    ariaLabel,
-    dropTargets,
-    renderDropTargets,
-    onCardIntent,
-    summarySlot,
-    actionsSlot,
-    onSelectionSummary
-  }) {
-    const isMobile = useIsMobile();
-    const { items, count } = useZoneCards({ sort });
-    const handClassName = clsx("min-h-[112px]", className);
-    const resolvedDropTargets = useMemo(() => {
-      if (!dropTargets || dropTargets.length === 0) return void 0;
-      return dropTargets.map((dt) => {
-        const value = dt.target.kind === "card" ? dt.target.card : dt.target.target;
-        return {
-          targetId: dropTargetIdFor(dt.target.kind, value),
-          label: dt.label,
-          render: dt.render,
-          className: dt.className,
-          role: dt.role,
-          order: dt.order
-        };
-      });
-    }, [dropTargets]);
-    const content = useMemo(
-      () => createElement4(HandSurfaceView, {
-        zone: hand.zone,
-        cards: items,
-        renderCard: (card, state) => children(card, state),
-        layout,
-        mobileInteraction,
-        dropTargets: resolvedDropTargets,
-        renderDropTargets,
-        cardSize,
-        renderEmpty: empty !== void 0 ? () => empty : void 0,
-        ariaLabel,
-        onIntentRouted: onCardIntent ? (intent) => onCardIntent(intent) : void 0,
-        summarySlot,
-        actionsSlot,
-        onSelectionSummary,
-        className: handClassName
-      }),
-      [
-        ariaLabel,
-        cardSize,
-        children,
-        empty,
-        hand.zone,
-        handClassName,
-        items,
-        layout,
-        mobileInteraction,
-        onCardIntent,
-        onSelectionSummary,
-        actionsSlot,
-        renderDropTargets,
-        summarySlot,
-        resolvedDropTargets
-      ]
-    );
-    const active = items.some(
-      (item) => !item.hidden && item.interactions.some(
-        (descriptor) => isInteractionAvailable(descriptor)
-      )
-    );
-    const autoOpen = items.some(
-      (item) => !item.hidden && item.interactions.some(
-        (descriptor) => isInteractionAvailable(descriptor) && descriptor.inputs.some(
-          (input) => input.domain.type === "cardTarget" && input.domain.selection?.mode === "many"
-        )
-      )
-    );
-    const version = items.map(
-      (item) => item.hidden ? `${item.id}:hidden` : `${item.id}:${item.cardType}:${JSON.stringify(item.properties)}`
-    ).join("|");
-    const registration = useMemo(
-      () => ({
-        id: `${hand.name}:${hand.zone}`,
-        zone: hand.zone,
-        label: hand.label,
-        role: hand.role,
-        order: hand.order,
-        version,
-        count,
-        active,
-        autoOpen,
-        content: createElement4(baseUI.Zone.Root, {
-          zone: hand.zone,
-          children: content
-        })
-      }),
-      [
-        active,
-        autoOpen,
-        content,
-        count,
-        hand.label,
-        hand.name,
-        hand.order,
-        hand.role,
-        hand.zone,
-        version
-      ]
-    );
-    useRegisterMobileHand(registration);
-    return isMobile ? null : content;
-  }
-  function createStagingComponent(options) {
-    return ({
-      children,
-      label,
-      renderEmptySlot,
-      cardSize,
-      ariaLabel,
-      className
-    }) => createElement4(HandStagingView, {
-      zone: options.zone,
-      renderCard: (card) => children(card),
-      renderEmptySlot,
-      label,
-      cardSize,
-      ariaLabel,
-      className
-    });
-  }
-  return {
-    createHandCardsComponent,
-    createStagingComponent,
-    HandCardsSlot,
-    HandSummarySlot,
-    HandActionsSlot
-  };
-}
-
-// src/runtime/workspace-contract/zones.ts
-var DEFAULT_ZONE_CARD_CLASS = "group relative border-0 bg-transparent p-0 transition-transform enabled:cursor-pointer enabled:hover:-translate-y-2 data-[selected=true]:-translate-y-3 disabled:cursor-not-allowed data-[eligible=false]:opacity-45 data-[eligible=false]:grayscale data-[eligible=false]:hover:translate-y-0 data-[card-available=false]:opacity-45 data-[card-available=false]:grayscale";
-function cardRenderItemToViewCard(card, cardId) {
-  if (card && typeof card === "object" && "hidden" in card && card.hidden === false) {
-    return card;
-  }
-  return {
-    id: cardId,
-    cardType: "hidden",
-    name: "Hidden card",
-    properties: {}
-  };
-}
-function createZoneCardsComponent(ctx, zones) {
-  const { baseUI, runtimeZone } = ctx;
-  return ({
-    empty,
-    children,
-    ...props
-  }) => createElement5(
-    ReactFragment2,
-    null,
-    ...zones.map(
-      (zone) => createElement5(baseUI.Zone.Root, {
-        key: zone,
-        zone,
-        children: createElement5(runtimeZone.List, {
-          ...props,
-          empty,
-          children
-        })
-      })
-    )
-  );
-}
-function createZoneCardComponent(ctx) {
-  const { options, baseUI, runtimeInteraction } = ctx;
-  return ({
-    card,
-    children,
-    className,
-    ...props
-  }) => {
-    const cardId = options.cardIdFromZoneCard(card);
-    const zone = options.zoneIdFromZoneCard(card);
-    const viewCard = cardRenderItemToViewCard(card, cardId);
-    const faceDown = !!card && typeof card === "object" && "hidden" in card && card.hidden === true;
-    const renderCardFace = (state) => createElement5(CardFace, {
-      card: viewCard,
-      selected: state.selected,
-      disabled: state.disabled || !state.eligible,
-      faceDown,
-      size: "sm",
-      children
-    });
-    const match = useAuthoredPluginGameplayFrameSelector((frame) => {
-      const candidates = frame.zones[zone]?.playableByCardId[cardId] ?? [];
-      const orderedCandidates = [...candidates].sort((left, right) => {
-        const leftAvailable = left.availability.status === "available";
-        const rightAvailable = right.availability.status === "available";
-        return leftAvailable === rightAvailable ? 0 : leftAvailable ? -1 : 1;
-      });
-      for (const descriptor of orderedCandidates) {
-        const input = descriptor.inputs.find(
-          (candidateInput) => candidateInput.domain.type === "cardTarget" && candidateInput.domain.projection === "resolved" && candidateInput.domain.eligibleTargets.includes(cardId)
-        );
-        if (input) return { descriptor, input };
-      }
-      return null;
-    });
-    if (!match) {
-      return createElement5(
-        "div",
-        {
-          ...props,
-          className: clsx2("relative inline-flex", className),
-          "data-dreamboard-zone-card": "",
-          "data-card-id": cardId,
-          "data-zone": zone,
-          "data-interactive": false
-        },
-        createElement5(CardFace, {
-          card: viewCard,
-          faceDown,
-          size: "sm",
-          children
-        })
-      );
-    }
-    return createElement5(baseUI.Zone.Root, {
-      zone,
-      children: createElement5(runtimeInteraction.Root, {
-        interaction: match.descriptor.interactionKey,
-        children: createElement5(runtimeInteraction.CardInput, {
-          ...props,
-          className: clsx2(DEFAULT_ZONE_CARD_CLASS, className),
-          input: match.input.key,
-          unsafeCardId: cardId,
-          children: renderCardFace
-        })
-      })
-    });
-  };
-}
-function createZoneNamespace(ctx) {
-  const {
-    createHandCardsComponent,
-    createStagingComponent,
-    HandCardsSlot,
-    HandSummarySlot,
-    HandActionsSlot
-  } = createHandPieces(ctx);
-  return {
-    hand(zone, options) {
-      return { kind: "hand", zone, ...options };
-    },
-    pile(zone) {
-      return { kind: "pile", zone };
-    },
-    piles(zones) {
-      return { kind: "piles", zones };
-    },
-    collection(zones, options = {}) {
-      return { kind: "cardCollection", zones, mode: options.mode };
-    },
-    useHand(_name, zoneOptions) {
-      const handComponentOptions = {
-        name: _name,
-        zone: zoneOptions.zone,
-        role: zoneOptions.role,
-        label: zoneOptions.label,
-        order: zoneOptions.order
-      };
-      return {
-        Hand: createHandCardsComponent(handComponentOptions),
-        Cards: HandCardsSlot,
-        Summary: HandSummarySlot,
-        Actions: HandActionsSlot,
-        Card: createZoneCardComponent(ctx),
-        Staging: createStagingComponent(handComponentOptions),
-        slot: { card: createCardInputSlot(ctx) }
-      };
-    },
-    usePile(_name, zoneOptions) {
-      return {
-        Pile: createZoneCardsComponent(ctx, [zoneOptions.zone]),
-        Card: createZoneCardComponent(ctx)
-      };
-    },
-    useCardCollection(_name, zoneOptions) {
-      void zoneOptions.mode;
-      return {
-        Collection: createZoneCardsComponent(ctx, zoneOptions.zones),
-        Card: createZoneCardComponent(ctx),
-        slot: { card: createCardInputSlot(ctx) }
-      };
-    }
-  };
-}
-
-// src/runtime/workspace-contract/game-ui-contract.ts
-function createGameUiContract(options) {
-  const uiContract = {
-    interactions: {},
-    inputs: {},
-    prompts: {},
-    promptOptions: {},
-    players: {},
-    zones: {},
-    cards: {},
-    phases: {},
-    boardTargets: {}
-  };
-  const clientParamSchemasByPhase = createClientParamSchemasByPhase(
-    options.game
-  );
-  const formInputKeysForInteraction = (interaction) => {
-    const [phase, id] = interaction.split(".", 2);
-    const phaseSpec = phase ? options.game.phases?.[phase] : void 0;
-    const phaseRecord = phaseSpec;
-    const spec = (id ? phaseRecord?.interactions?.[id] : void 0) ?? (id ? phaseRecord?.cardActions?.[id] : void 0) ?? (id === "submit" ? phaseRecord?.submit : void 0);
-    return new Set(
-      Object.entries(spec?.inputs ?? {}).filter(
-        ([, collector]) => collector.kind === "form" || collector.kind === "prompt"
-      ).map(([input]) => input)
-    );
-  };
-  const UI2 = createWorkspaceUIContract({
-    uiContract,
-    clientParamSchemasByPhase,
-    formInputKeysForInteraction,
-    resourceIds: options.resourceIds,
-    resourcePresentationById: options.resourcePresentationById,
-    hexStaticBoards: options.hexStaticBoards,
-    squareStaticBoards: options.squareStaticBoards,
-    cardIdFromZoneCard: (card) => card.id,
-    zoneIdFromZoneCard: (card) => card.zone
-  });
-  return { uiContract, UI: UI2, clientParamSchemasByPhase };
-}
-
-// src/runtime/workspace-contract/index.ts
-function createWorkspaceUIContract(options) {
-  const baseUI = createDreamboardUI(options.uiContract);
-  const runtimeInteraction = baseUI.Interaction;
-  const runtimeBoard = baseUI.Board;
-  const runtimeZone = baseUI.Zone;
-  const runtimeGameRoot = baseUI.Game.Root;
-  const runtimePhaseSwitch = baseUI.Phase.Switch;
-  const ctx = {
-    options,
-    // The context carries the contract-erased view of the UI: every consumer
-    // already neutralizes key genericity (`as never` inputs/zones), exactly as
-    // the original single-file factory did with its `Runtime*` casts.
-    baseUI,
-    runtimeInteraction,
-    runtimeBoard,
-    runtimeZone,
-    withInteractionRoot: (interaction, children) => createElement6(runtimeInteraction.Root, {
-      interaction,
-      children
-    })
-  };
-  const resourceDisplayConfig = options.resourceIds.map((resource) => {
-    const presentation = options.resourcePresentationById?.[resource];
-    return {
-      type: resource,
-      label: presentation?.label ?? resource,
-      icon: presentation?.icon ?? resource
-    };
-  });
-  const resourceCounter = createResourceCounter(
-    resourceDisplayConfig
-  );
-  const { Interaction: Interaction2, useInteractionFormSurface } = createInteractionForms(ctx);
-  const Board2 = createBoardNamespace(ctx);
-  const Zone2 = createZoneNamespace(ctx);
-  const { defineSurfaces } = createSurfaceResolvers({
-    Board: Board2,
-    Zone: Zone2,
-    useInteractionFormSurface
-  });
-  const UI2 = {
-    ...baseUI,
-    Root: ({ children, ...props }) => createElement6(ClientParamSchemaProvider, {
-      schemas: options.clientParamSchemasByPhase,
-      children: createElement6(ToastProvider, {
-        children: createElement6(MobileHandTrayProvider, {
-          children: createElement6(baseUI.Root, { ...props, children })
-        })
-      })
-    }),
-    defineSurfaces,
-    defineGameUI({
-      useSurfaces,
-      interactionRoutes,
-      phases,
-      renderInteractions,
-      fallback,
-      includeUnavailableInteractions
-    }) {
-      function DefinedGameUIFrame({ game }) {
-        const surfaces = useSurfaces();
-        const phaseRoutes = Object.fromEntries(
-          Object.entries(phases).map(([phase, render]) => [
-            phase,
-            () => render({ game, surfaces })
-          ])
-        );
-        const routeMap = interactionRoutes?.({ game, surfaces });
-        return createElement6(
-          Fragment,
-          null,
-          routeMap ? createElement6(runtimeInteraction.Routes, {
-            routes: routeMap,
-            includeUnavailable: includeUnavailableInteractions
-          }) : null,
-          createElement6(runtimePhaseSwitch, {
-            routes: phaseRoutes,
-            fallback
-          }),
-          renderInteractions?.({ game, surfaces }) ?? null
-        );
-      }
-      return function DefinedGameUI(props) {
-        return createElement6(UI2.Root, {
-          ...props,
-          children: createElement6(runtimeGameRoot, {
-            children: (rawGame) => createElement6(DefinedGameUIFrame, {
-              game: rawGame
-            })
-          })
-        });
-      };
-    },
-    Interaction: Interaction2,
-    Board: Board2,
-    Zone: Zone2,
-    ResourceCounter: resourceCounter
-  };
-  return UI2;
-}
-
-// src/runtime/workspace-contract/create-game-ui.ts
-function createGameUi(game) {
-  const manifest = game.contract.manifest;
-  return createGameUiContract({
-    game,
-    resourceIds: manifest.literals.resourceIds,
-    resourcePresentationById: manifest.literals.resourcePresentationById,
-    hexStaticBoards: manifest.staticBoards?.hex ?? {},
-    squareStaticBoards: manifest.staticBoards?.square ?? {}
-  });
-}
-
-export {
-  createGameUiContract,
-  createWorkspaceUIContract,
-  createGameUi
-};
-//# sourceMappingURL=chunk-EVCLTY4Q.js.map