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

package/dist/{chunk-GKKBPPSW.js → chunk-TXXLS3OI.js}

@@ -1,16 +1,23 @@
 import {
-  createDreamboardUI
-} from "./chunk-U5C6BONG.js";
-import {
+  Board,
   ClientParamSchemaProvider,
+  Dice,
+  Game,
   HandStagingView,
   HandSurfaceView,
+  Interaction,
+  Phase,
+  PlayerRoster,
+  Prompt,
+  PromptInbox,
+  UI,
+  Zone,
   dropTargetIdFor,
   isInteractionAvailable,
   usePluginState,
   useResolvedCardTargetValue,
   useZoneCards
-} from "./chunk-TDSWKVZ4.js";
+} from "./chunk-ADYH6PVT.js";
 import {
   CardFace,
   MobileHandTrayProvider,
@@ -18,144 +25,188 @@ import {
   createResourceCounter,
   useIsMobile,
   useRegisterMobileHand
-} from "./chunk-WYPQ3GG5.js";
+} from "./chunk-QZ6X4B5P.js";
 
-// src/runtime-internal/workspace-contract.ts
-import { Fragment as ReactFragment, createElement, useMemo } from "react";
-import { clsx } from "clsx";
-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;
-  }
+// src/runtime/workspace-contract/index.ts
+import { createElement as createElement6 } from "react";
+
+// src/runtime/ui-contract.ts
+function createDreamboardUI(contract) {
   return {
-    id: cardId,
-    cardType: "hidden",
-    name: "Hidden card",
-    properties: {}
+    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 createWorkspaceUIContract(options) {
-  const baseUI = createDreamboardUI(options.uiContract);
-  const runtimeInteraction = baseUI.Interaction;
-  const runtimeBoard = baseUI.Board;
-  const runtimeZone = baseUI.Zone;
-  const resourceDisplayConfig = options.resourceIds.map((resource) => {
-    const presentation = options.resourcePresentationById?.[resource];
+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(_name) {
     return {
-      type: resource,
-      label: presentation?.label ?? resource,
-      icon: presentation?.icon ?? resource
+      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")
+      }
     };
-  });
-  const resourceCounter = createResourceCounter(
-    resourceDisplayConfig
-  );
+  };
+}
+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]
+        }
+      );
+    }
+  };
+}
+
+// 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 createElement(runtimeInteraction.Routes, {
+    return createElement3(runtimeInteraction.Routes, {
       routes,
       fallback,
       includeUnavailable
     });
   }
-  const withInteractionRoot = (interaction, children) => createElement(runtimeInteraction.Root, {
-    interaction,
-    children
-  });
-  function createFormInputSlot(input, interaction) {
-    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() {
-    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(kind) {
-    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)
-    };
-  }
   function useInteractionFormSurface(interaction) {
     const validInputs = options.formInputKeysForInteraction(interaction);
     const slot = Object.fromEntries(
       [...validInputs].map((input) => [
         input,
-        createFormInputSlot(input, interaction)
+        createFormInputSlot(ctx, input, interaction)
       ])
     );
     return {
       Root: ({ children }) => withInteractionRoot(interaction, children),
       Form: (props) => withInteractionRoot(
         interaction,
-        createElement(baseUI.Interaction.Form, props)
+        createElement3(baseUI.Interaction.Form, props)
       ),
       Dialog: (props) => withInteractionRoot(
         interaction,
-        createElement(baseUI.Interaction.Dialog, props)
+        createElement3(baseUI.Interaction.Dialog, props)
       ),
       State: (props) => withInteractionRoot(
         interaction,
-        createElement(baseUI.Interaction.State, props)
+        createElement3(baseUI.Interaction.State, props)
       ),
       Arm: (props) => withInteractionRoot(
         interaction,
-        createElement(baseUI.Interaction.Trigger, props)
+        createElement3(baseUI.Interaction.Trigger, props)
       ),
       Submit: (props) => withInteractionRoot(
         interaction,
-        createElement(baseUI.Interaction.Submit, props)
+        createElement3(baseUI.Interaction.Submit, props)
       ),
       Field: ({ input, ...props }) => withInteractionRoot(
         interaction,
-        createElement(baseUI.Interaction.Field, {
+        createElement3(baseUI.Interaction.Field, {
           ...props,
           input
         })
@@ -163,41 +214,95 @@ function createWorkspaceUIContract(options) {
       slot
     };
   }
-  function useBoardSurface(_name) {
-    return {
-      Root: ({ children }) => createElement(baseUI.Board.Root, { children }),
-      Space: (props) => createElement(runtimeBoard.SpaceTarget, props),
-      slot: {
-        space: createBoardTargetInputSlot("space"),
-        playerSpace: createBoardTargetInputSlot("space"),
-        edge: createBoardTargetInputSlot("edge"),
-        vertex: createBoardTargetInputSlot("vertex"),
-        tile: createBoardTargetInputSlot("tile")
-      }
-    };
+  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
+}) {
+  function resolveSurfaceDescriptor(name, descriptor) {
+    switch (descriptor.kind) {
+      case "board":
+        return Board2.useSurface(name);
+      case "hand":
+        return Zone2.useHand(name, {
+          zone: descriptor.zone,
+          role: descriptor.role,
+          label: descriptor.label,
+          order: descriptor.order
+        });
+      case "pile":
+        return Zone2.usePile(name, { zone: descriptor.zone });
+      case "piles":
+        return Object.fromEntries(
+          descriptor.zones.map((zone) => [
+            zone,
+            Zone2.usePile(String(zone), { zone })
+          ])
+        );
+      case "cardCollection":
+        return Zone2.useCardCollection(name, {
+          zones: descriptor.zones,
+          mode: descriptor.mode
+        });
+      case "form":
+        return useInteractionFormSurface(descriptor.interaction);
+      case "forms":
+        return Object.fromEntries(
+          Object.entries(descriptor.interactions).map(([key, interaction]) => [
+            key,
+            useInteractionFormSurface(interaction)
+          ])
+        );
+    }
   }
-  function createZoneCardsComponent(zones) {
-    return ({
-      empty,
-      children,
-      ...props
-    }) => createElement(
-      ReactFragment,
-      null,
-      ...zones.map(
-        (zone) => createElement(baseUI.Zone.Root, {
-          key: zone,
-          zone,
-          children: createElement(runtimeZone.List, {
-            ...props,
-            empty,
-            children
-          })
-        })
-      )
+  function resolveSurfaceSpec(spec) {
+    return Object.fromEntries(
+      Object.entries(spec).map(([key, value]) => [
+        key,
+        isSurfaceDescriptor(value) ? resolveSurfaceDescriptor(key, value) : resolveSurfaceSpec(value)
+      ])
     );
   }
-  function createHandCardsComponent(options2) {
+  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 { createElement as createElement4, useMemo } from "react";
+import { clsx } from "clsx";
+function createHandPieces(ctx) {
+  const { baseUI } = ctx;
+  function createHandCardsComponent(options) {
     return ({
       empty,
       children,
@@ -213,8 +318,8 @@ function createWorkspaceUIContract(options) {
       renderActions,
       onSelectionSummary,
       ...props
-    }) => createElement(baseUI.Zone.Root, {
-      zone: options2.zone,
+    }) => 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
@@ -222,9 +327,9 @@ function createWorkspaceUIContract(options) {
       // pins the outermost hand element to the available width and breaks the
       // cycle for every author layout.
       className: "w-full min-w-0",
-      children: createElement(GeneratedHandCards, {
+      children: createElement4(GeneratedHandCards, {
         ...props,
-        hand: options2,
+        hand: options,
         className,
         empty,
         children,
@@ -276,7 +381,7 @@ function createWorkspaceUIContract(options) {
       });
     }, [dropTargets]);
     const content = useMemo(
-      () => createElement(HandSurfaceView, {
+      () => createElement4(HandSurfaceView, {
         zone: hand.zone,
         cards: items,
         renderCard: (card, state, _index) => children(card, state),
@@ -337,7 +442,7 @@ function createWorkspaceUIContract(options) {
         count,
         active,
         autoOpen,
-        content: createElement(baseUI.Zone.Root, {
+        content: createElement4(baseUI.Zone.Root, {
           zone: hand.zone,
           children: content
         })
@@ -358,94 +463,7 @@ function createWorkspaceUIContract(options) {
     useRegisterMobileHand(registration);
     return isMobile ? null : content;
   }
-  function createZoneCardComponent() {
-    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) => createElement(CardFace, {
-        card: viewCard,
-        selected: state.selected,
-        disabled: state.disabled || !state.eligible,
-        faceDown,
-        size: "sm",
-        children
-      });
-      const match = usePluginState((state) => {
-        const candidates = state.gameplay.zones[zone]?.playableByCardId[cardId] ?? [];
-        for (const descriptor of candidates) {
-          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 createElement(
-          "div",
-          {
-            ...props,
-            className: clsx("relative inline-flex", className),
-            "data-dreamboard-zone-card": "",
-            "data-card-id": cardId,
-            "data-zone": zone,
-            "data-interactive": false
-          },
-          createElement(CardFace, {
-            card: viewCard,
-            faceDown,
-            size: "sm",
-            children
-          })
-        );
-      }
-      return createElement(baseUI.Zone.Root, {
-        zone,
-        children: createElement(runtimeInteraction.Root, {
-          interaction: match.descriptor.interactionKey,
-          children: createElement(runtimeInteraction.CardInput, {
-            ...props,
-            className: clsx(DEFAULT_ZONE_CARD_CLASS, className),
-            input: match.input.key,
-            unsafeCardId: cardId,
-            children: renderCardFace
-          })
-        })
-      });
-    };
-  }
-  const Board = {
-    surface(board) {
-      return { kind: "board", board };
-    },
-    useSurface: useBoardSurface,
-    HexView({ board: boardId, ...props }) {
-      return createElement(
-        baseUI.Board.HexView,
-        {
-          ...props,
-          board: options.hexStaticBoards[boardId]
-        }
-      );
-    },
-    HexGrid({ board: boardId, ...props }) {
-      return createElement(
-        baseUI.Board.HexGrid,
-        {
-          ...props,
-          board: options.hexStaticBoards[boardId]
-        }
-      );
-    }
-  };
-  function createStagingComponent(options2) {
+  function createStagingComponent(options) {
     return ({
       children,
       label,
@@ -453,8 +471,8 @@ function createWorkspaceUIContract(options) {
       cardSize,
       ariaLabel,
       className
-    }) => createElement(HandStagingView, {
-      zone: options2.zone,
+    }) => createElement4(HandStagingView, {
+      zone: options.zone,
       renderCard: (card) => children(card),
       renderEmptySlot,
       label,
@@ -463,9 +481,113 @@ function createWorkspaceUIContract(options) {
       className
     });
   }
-  const Zone = {
-    hand(zone, options2) {
-      return { kind: "hand", zone, ...options2 };
+  return { createHandCardsComponent, createStagingComponent };
+}
+
+// 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 = usePluginState((state) => {
+      const candidates = state.gameplay.zones[zone]?.playableByCardId[cardId] ?? [];
+      for (const descriptor of candidates) {
+        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 } = createHandPieces(ctx);
+  return {
+    hand(zone, options) {
+      return { kind: "hand", zone, ...options };
     },
     pile(zone) {
       return { kind: "pile", zone };
@@ -473,8 +595,8 @@ function createWorkspaceUIContract(options) {
     piles(zones) {
       return { kind: "piles", zones };
     },
-    collection(zones, options2 = {}) {
-      return { kind: "cardCollection", zones, mode: options2.mode };
+    collection(zones, options = {}) {
+      return { kind: "cardCollection", zones, mode: options.mode };
     },
     useHand(_name, zoneOptions) {
       const handComponentOptions = {
@@ -486,113 +608,87 @@ function createWorkspaceUIContract(options) {
       };
       return {
         Hand: createHandCardsComponent(handComponentOptions),
-        Card: createZoneCardComponent(),
+        Card: createZoneCardComponent(ctx),
         Staging: createStagingComponent(handComponentOptions),
-        slot: { card: createCardInputSlot() }
+        slot: { card: createCardInputSlot(ctx) }
       };
     },
     usePile(_name, zoneOptions) {
       return {
-        Pile: createZoneCardsComponent([zoneOptions.zone]),
-        Card: createZoneCardComponent()
+        Pile: createZoneCardsComponent(ctx, [zoneOptions.zone]),
+        Card: createZoneCardComponent(ctx)
       };
     },
     useCardCollection(_name, zoneOptions) {
       void zoneOptions.mode;
       return {
-        Collection: createZoneCardsComponent(zoneOptions.zones),
-        Card: createZoneCardComponent(),
-        slot: { card: createCardInputSlot() }
+        Collection: createZoneCardsComponent(ctx, zoneOptions.zones),
+        Card: createZoneCardComponent(ctx),
+        slot: { card: createCardInputSlot(ctx) }
       };
     }
   };
-  const Interaction = {
-    State: baseUI.Interaction.State,
-    Dialog: baseUI.Interaction.Dialog,
-    useForm: useInteractionFormSurface,
-    form(interaction) {
-      return { kind: "form", interaction };
-    },
-    forms(interactions) {
-      return { kind: "forms", interactions };
-    },
-    Routes: InteractionRoutes
+}
+
+// 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 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
+    })
   };
-  function isPlainObject(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-  }
-  function isSurfaceDescriptor(value) {
-    return isPlainObject(value) && typeof value.kind === "string";
-  }
-  function resolveSurfaceDescriptor(name, descriptor) {
-    switch (descriptor.kind) {
-      case "board":
-        return Board.useSurface(name);
-      case "hand":
-        return Zone.useHand(name, {
-          zone: descriptor.zone,
-          role: descriptor.role,
-          label: descriptor.label,
-          order: descriptor.order
-        });
-      case "pile":
-        return Zone.usePile(name, { zone: descriptor.zone });
-      case "piles":
-        return Object.fromEntries(
-          descriptor.zones.map((zone) => [
-            zone,
-            Zone.usePile(String(zone), { zone })
-          ])
-        );
-      case "cardCollection":
-        return Zone.useCardCollection(name, {
-          zones: descriptor.zones,
-          mode: descriptor.mode
-        });
-      case "form":
-        return useInteractionFormSurface(descriptor.interaction);
-      case "forms":
-        return Object.fromEntries(
-          Object.entries(descriptor.interactions).map(([key, interaction]) => [
-            key,
-            useInteractionFormSurface(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);
+  const resourceDisplayConfig = options.resourceIds.map((resource) => {
+    const presentation = options.resourcePresentationById?.[resource];
+    return {
+      type: resource,
+      label: presentation?.label ?? resource,
+      icon: presentation?.icon ?? resource
     };
-  }
-  const UI = {
+  });
+  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 }) => createElement(ClientParamSchemaProvider, {
+    Root: ({ children, ...props }) => createElement6(ClientParamSchemaProvider, {
       schemas: options.clientParamSchemasByPhase,
-      children: createElement(ToastProvider, {
-        children: createElement(MobileHandTrayProvider, {
-          children: createElement(baseUI.Root, { ...props, children })
+      children: createElement6(ToastProvider, {
+        children: createElement6(MobileHandTrayProvider, {
+          children: createElement6(baseUI.Root, { ...props, children })
         })
       })
     }),
     defineSurfaces,
-    Interaction,
-    Board,
-    Zone,
+    Interaction: Interaction2,
+    Board: Board2,
+    Zone: Zone2,
     ResourceCounter: resourceCounter
   };
-  return UI;
+  return UI2;
 }
 
 export {
   createWorkspaceUIContract
 };
-//# sourceMappingURL=chunk-GKKBPPSW.js.map
+//# sourceMappingURL=chunk-TXXLS3OI.js.map