@seriousgaming/sdk-tools 0.0.0-stage → 1.0.0-alpha.1

package/dist/host/surfaces.d.ts

@@ -0,0 +1,42 @@
+/**
+ * What each kind of surface is, in protocol terms.
+ *
+ * §12.6 fixes the set of messages a surface must receive before it may paint.
+ * Holding that as a table rather than as four near-identical components is what
+ * makes a new surface kind an entry here instead of a new host implementation.
+ */
+/**
+ * A surface the host can mount, named by what the specification calls it.
+ *
+ * `game` and `waiting-room` are both **player** surfaces (§6.14): a waiting room
+ * is a player UI in a different display context, not a reduced one, so every
+ * gate that asks 'is this a player surface?' admits both.
+ */
+export type SurfaceKind = 'game' | 'session' | 'setup' | 'scenario-editor' | 'waiting-room' | 'presentation';
+export interface SurfaceDescriptor {
+    /**
+     * Messages that must all arrive before the guest paints (§12.6). The guest
+     * enforces this for itself; the host carries the list so it can fail loudly
+     * when an embedder builds an incomplete initial batch, rather than leaving
+     * the frame stuck on its loading state with nothing to say why.
+     */
+    readonly required: readonly string[];
+    /**
+     * Messages the host sends in the initial batch that do not block painting.
+     * Listed so `initialBatch` can order them after the required ones.
+     */
+    readonly alsoSent: readonly string[];
+    /** True for the player surfaces: game and waiting room (§6.14). */
+    readonly isPlayerSurface: boolean;
+}
+export declare const SURFACES: Record<SurfaceKind, SurfaceDescriptor>;
+/**
+ * An observer render receives no `setParticipant` (§13.3): the wrapper opens on
+ * `setViewerRole: 'observer'` instead, so the surface still paints with a null
+ * participant. Only the player surfaces have an observer render at all.
+ */
+export declare function requiredMessagesFor(surface: SurfaceKind, options?: {
+    observer?: boolean;
+}): readonly string[];
+/** True for the surfaces a participant sits in front of (§6.14). */
+export declare function isPlayerSurface(surface: SurfaceKind): boolean;

package/dist/host/theme.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The `contrastText` every theme colour carries (§12.3).
+ *
+ * A host sends a text colour for each palette colour, meeting WCAG AA (4.5:1)
+ * against it, so a game drawing text on a theme colour need not work one out.
+ * Black or white always reaches at least 4.58:1 against any opaque colour, so
+ * the requirement can always be met, and an author's own choice is kept when
+ * it meets it too.
+ *
+ * Platform-facing: exported from
+ * `@seriousgaming/sdk-tools/host`.
+ */
+import type { ThemeColorRole, ThemeContrastText, UserInterfaceTheme } from '@seriousgaming/sdk/ui';
+/** The roles a theme sends, in the order §12.3 lists them. */
+export declare const THEME_COLOR_ROLES: readonly ThemeColorRole[];
+/** The WCAG AA minimum for normal text. */
+export declare const AA_CONTRAST = 4.5;
+interface Rgba {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** Read a CSS hex or `rgb()` / `rgba()` colour, or null for anything else. */
+export declare function parseColour(value: string): Rgba | null;
+/** WCAG 2 relative luminance of an opaque colour. */
+export declare function relativeLuminance({ r, g, b }: Rgba): number;
+/** WCAG 2 contrast ratio between two opaque colours, from 1 to 21. */
+export declare function contrastRatio(a: Rgba, b: Rgba): number;
+/**
+ * The text colour to draw on `colour`, as an opaque `#rrggbb`.
+ *
+ * `preferred` is an author's choice, kept (made opaque by painting it over
+ * the colour, as the browser would) when it meets AA; otherwise black or
+ * white, whichever contrasts more. A translucent colour is measured as drawn
+ * on white. A colour that is neither hex nor `rgb()` cannot be measured, and
+ * gets black.
+ */
+export declare function contrastTextFor(colour: string, preferred?: string): string;
+/** One mode's colours before a host has given them their text colours. */
+export type ModeColoursInput = Record<ThemeColorRole, string> & {
+    contrastText?: Partial<ThemeContrastText>;
+};
+/** A theme before a host has given its colours their text colours. */
+export interface ThemeInput {
+    mode: 'light' | 'dark';
+    light: ModeColoursInput;
+    dark: ModeColoursInput;
+}
+/**
+ * The `setTheme` payload for a theme: every colour of both modes given its
+ * `contrastText`, keeping any the author supplied that meet AA.
+ */
+export declare function withContrastText(theme: ThemeInput): UserInterfaceTheme;
+export {};

package/dist/host.js

@@ -0,0 +1,583 @@
+// cli/host/protocol.ts
+var UI_PROTOCOL_VERSION = 4;
+
+// cli/host/surfaces.ts
+var SURFACES = {
+  game: {
+    required: [
+      "stateChanged",
+      "setSettings",
+      "setTheme",
+      "setLocale",
+      "setAssetUrls",
+      "setParticipant"
+    ],
+    alsoSent: [
+      "setTimer",
+      "setViewerRole",
+      "setOwnTeam",
+      "setOwnTeamJoinLink",
+      "setParticipantList",
+      "setTeamList",
+      "setRunKind",
+      "setRoundProcessing",
+      "setCrossTeamData",
+      "themePreferenceChanged"
+    ],
+    isPlayerSurface: true
+  },
+  "waiting-room": {
+    required: [
+      "stateChanged",
+      "setSettings",
+      "setTheme",
+      "setLocale",
+      "setAssetUrls",
+      "setParticipant"
+    ],
+    alsoSent: [
+      "setTimer",
+      "setViewerRole",
+      "setOwnTeam",
+      "setOwnTeamJoinLink",
+      "setParticipantList",
+      "setTeamList",
+      "setRunKind",
+      "setCrossTeamData",
+      "themePreferenceChanged"
+    ],
+    isPlayerSurface: true
+  },
+  session: {
+    required: [
+      "setSessionMeta",
+      "setSessionData",
+      "setSettings",
+      "setTheme",
+      "setLocale",
+      "setAssetUrls",
+      "setTeamConfiguration"
+    ],
+    alsoSent: [
+      "setTeamList",
+      "setParticipantList",
+      "setTeamLinks",
+      "setAvailableOverlays",
+      "setRunKind",
+      "setWalkthroughLink",
+      "themePreferenceChanged"
+    ],
+    isPlayerSurface: false
+  },
+  presentation: {
+    // `setPresentation` carries a `null` session when there is none, so a
+    // presentation is the one surface a host can mount without one.
+    required: ["setPresentation", "setSettings", "setTheme", "setLocale", "setAssetUrls"],
+    alsoSent: ["themePreferenceChanged"],
+    isPlayerSurface: false
+  },
+  // The two settings editors (§6.5) share a wrapper and a batch. Neither is
+  // told which slot it is: each is its own bundle, so it knows.
+  setup: {
+    required: ["setSettings", "setTheme", "setLocale", "setAssetUrls"],
+    alsoSent: ["themePreferenceChanged"],
+    isPlayerSurface: false
+  },
+  "scenario-editor": {
+    required: ["setSettings", "setTheme", "setLocale", "setAssetUrls"],
+    alsoSent: ["themePreferenceChanged"],
+    isPlayerSurface: false
+  }
+};
+function requiredMessagesFor(surface, options = {}) {
+  const { required, isPlayerSurface: isPlayerSurface2 } = SURFACES[surface];
+  if (!options.observer || !isPlayerSurface2) return required;
+  return required.filter((type) => type !== "setParticipant");
+}
+function isPlayerSurface(surface) {
+  return SURFACES[surface].isPlayerSurface;
+}
+
+// cli/host/host-channel.ts
+var ADAPTER_REQUESTS = /* @__PURE__ */ new Set([
+  "callEndpoint",
+  "uploadBlob",
+  "getPastState",
+  "getAllTeamsParticipants"
+]);
+var HostChannel = class {
+  options;
+  host;
+  logger;
+  port = null;
+  readyListener = null;
+  loadListener = null;
+  handshakeTimer = null;
+  disposed = false;
+  /**
+   * Last payload sent per message type, serialised.
+   *
+   * `setState` compares against this so an unchanged slice is not re-pushed.
+   * At a large cohort the session payload is the thing that grows, and
+   * re-sending a whole snapshot because one team's tick moved is the cost
+   * §12.4.2 warns about.
+   */
+  lastSent = /* @__PURE__ */ new Map();
+  /**
+   * The last value of each state message, in the order the types were first
+   * sent, replayed whole on every reconnect (§12.7 step 3).
+   *
+   * A reloading frame has seen nothing, and the embedder has no reason to
+   * push again: its state has not changed, only the frame under it. Without
+   * this the guest re-handshakes into silence and blocks its first paint for
+   * good, which is what a surface fixed after a crash used to do (#564).
+   *
+   * Only the state slices are kept. A one-shot the host sent once, such as a
+   * validator's refusal or an asset-auth request, belongs to the moment it
+   * happened, and replaying it would show the new frame a rejection of a
+   * submission it never made.
+   */
+  sticky = /* @__PURE__ */ new Map();
+  /** One-shot messages queued until the handshake completes, flushed in order. */
+  outbound = [];
+  /** In-flight host → guest requests, keyed by `requestId`. */
+  pending = /* @__PURE__ */ new Map();
+  requestCounter = 0;
+  constructor(options) {
+    this.options = options;
+    this.host = options.window ?? globalThis.window;
+    this.logger = options.logger ?? console;
+    this.listenForReady();
+  }
+  /** True once the guest has handshaked and the port is open. */
+  get connected() {
+    return this.port !== null;
+  }
+  // -----------------------------------------------------------------------
+  // Sending
+  // -----------------------------------------------------------------------
+  /**
+   * Push one message, queueing it until the handshake completes.
+   *
+   * Queueing rather than dropping is what lets an embedder build the initial
+   * batch as soon as it mounts the frame, without racing the guest's `ready`.
+   */
+  send(message) {
+    if (this.disposed) return;
+    this.lastSent.set(message.type, stableStringify(message));
+    if (this.port) this.port.postMessage(message);
+    else this.outbound.push(message);
+  }
+  /**
+   * Push a state slice: delivered now if the guest is listening, and kept so
+   * a frame that reloads is told the same thing again.
+   */
+  sendState(message) {
+    if (this.disposed) return;
+    this.sticky.set(message.type, message);
+    this.lastSent.set(message.type, stableStringify(message));
+    this.port?.postMessage(message);
+  }
+  /**
+   * Push a message only when its payload differs from the last one sent of
+   * that type. Returns true when it went out.
+   */
+  sendIfChanged(message) {
+    if (this.disposed) return false;
+    if (this.lastSent.get(message.type) === stableStringify(message)) return false;
+    this.sendState(message);
+    return true;
+  }
+  /**
+   * Send the initial batch (§12.6), verifying it carries every message the
+   * surface blocks its first paint on.
+   *
+   * The guest enforces the same list for itself by simply not painting. That
+   * failure mode is a frame stuck on its loading state with nothing to say
+   * why, which is a bad afternoon; failing here names the missing message.
+   */
+  sendInitialBatch(messages) {
+    const required = requiredMessagesFor(this.options.surface, {
+      observer: this.options.observer
+    });
+    const supplied = new Set(messages.map((message) => message.type));
+    const missing = required.filter((type) => !supplied.has(type));
+    if (missing.length > 0) {
+      throw new Error(
+        `Initial batch for a "${this.options.surface}" surface is missing ${missing.join(", ")}. The guest blocks its first paint on ${required.join(", ")}.`
+      );
+    }
+    for (const message of messages) this.sendState(message);
+  }
+  /**
+   * Send a request the guest answers, resolving when it does.
+   *
+   * Only `refreshAssetAuth` uses this today (§16.4): the host hands the frame
+   * a token and the frame reports back whether redeeming it worked.
+   */
+  request(message, timeoutMs = 3e4) {
+    const requestId = `host-${++this.requestCounter}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error(`Guest did not answer "${message.type}" in ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pending.set(requestId, {
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+      this.send({ ...message, requestId });
+    });
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.clearHandshakeTimer();
+    if (this.readyListener) {
+      this.host.removeEventListener("message", this.readyListener);
+      this.readyListener = null;
+    }
+    if (this.loadListener) {
+      this.options.iframe.removeEventListener?.("load", this.loadListener);
+      this.loadListener = null;
+    }
+    this.closePort();
+    this.rejectPending("Channel disposed");
+    this.options.onTeardown?.("disposed");
+  }
+  // -----------------------------------------------------------------------
+  // Handshake
+  // -----------------------------------------------------------------------
+  listenForReady() {
+    const listener = (event) => {
+      if (this.disposed) return;
+      const data = event.data;
+      if (!data || data.type !== "ready") return;
+      if (event.source !== this.options.iframe.contentWindow) return;
+      if (event.origin !== this.options.iframeOrigin) {
+        this.logger.warn(
+          `[${this.options.uiIdentifier}] ignoring a handshake from ${event.origin}; this frame is pinned to ${this.options.iframeOrigin}`
+        );
+        return;
+      }
+      const peerVersion = data.protocolVersion;
+      if (typeof peerVersion === "number" && peerVersion !== UI_PROTOCOL_VERSION) {
+        this.logger.warn(
+          `[${this.options.uiIdentifier}] host\u2194iframe protocol version mismatch: iframe ${peerVersion}, host ${UI_PROTOCOL_VERSION}`
+        );
+      }
+      this.connect();
+    };
+    this.readyListener = listener;
+    this.host.addEventListener("message", listener);
+    this.armHandshakeTimer();
+    this.listenForLoads();
+  }
+  /**
+   * Bound every document the frame loads, not only the first.
+   *
+   * A frame that connected and then replaced its own document leaves the
+   * host holding a port nobody answers, so `connected` alone proves nothing.
+   * A document's `ready` may land either side of its `load`, so a live port
+   * is pinged as well: a `pong` shows the document that handshaked is still
+   * the one in the frame, and a fresh `ready` shows a reload.
+   */
+  listenForLoads() {
+    const { iframe } = this.options;
+    if (!iframe.addEventListener) return;
+    const listener = () => {
+      if (this.disposed) return;
+      this.armHandshakeTimer();
+      this.port?.postMessage({ type: "ping" });
+    };
+    this.loadListener = listener;
+    iframe.addEventListener("load", listener);
+  }
+  armHandshakeTimer() {
+    this.clearHandshakeTimer();
+    const timeoutMs = this.options.handshakeTimeoutMs ?? 1e4;
+    this.handshakeTimer = setTimeout(() => {
+      this.handshakeTimer = null;
+      if (this.disposed) return;
+      this.closePort();
+      this.options.onTeardown?.("handshake-timeout");
+    }, timeoutMs);
+  }
+  /**
+   * Open a fresh port and hand the guest its end.
+   *
+   * Runs on every `ready`, not only the first: a reload or HMR re-announces,
+   * and §12.7 requires the old port closed, a new channel created, and the
+   * whole initial batch re-sent rather than the live port re-identified.
+   */
+  connect() {
+    this.closePort();
+    this.rejectPending("Connection reset");
+    this.lastSent.clear();
+    const replay = [...this.sticky.values()];
+    const channel = new MessageChannel();
+    this.port = channel.port1;
+    this.port.onmessage = (event) => this.receive(event.data);
+    this.port.start();
+    this.clearHandshakeTimer();
+    this.options.iframe.contentWindow?.postMessage(
+      {
+        type: "init",
+        protocolVersion: UI_PROTOCOL_VERSION,
+        sessionKey: this.options.sessionKey
+      },
+      this.options.iframeOrigin,
+      [channel.port2]
+    );
+    for (const message of replay) this.sendState(message);
+    const queued = this.outbound;
+    this.outbound = [];
+    for (const message of queued) this.port.postMessage(message);
+    this.options.onConnect?.();
+  }
+  closePort() {
+    if (!this.port) return;
+    this.port.onmessage = null;
+    this.port.close();
+    this.port = null;
+  }
+  clearHandshakeTimer() {
+    if (this.handshakeTimer === null) return;
+    clearTimeout(this.handshakeTimer);
+    this.handshakeTimer = null;
+  }
+  rejectPending(reason) {
+    for (const { reject } of this.pending.values()) reject(new Error(reason));
+    this.pending.clear();
+  }
+  // -----------------------------------------------------------------------
+  // Receiving
+  // -----------------------------------------------------------------------
+  receive(message) {
+    if (!message || typeof message.type !== "string") return;
+    switch (message.type) {
+      case "pong":
+        this.clearHandshakeTimer();
+        return;
+      case "refreshAssetAuth:response": {
+        const { requestId, ok, error } = message;
+        if (typeof requestId !== "string") return;
+        const waiting = this.pending.get(requestId);
+        this.pending.delete(requestId);
+        if (ok) waiting?.resolve();
+        else waiting?.reject(new Error(error ?? "Asset auth refresh failed"));
+        return;
+      }
+    }
+    if (ADAPTER_REQUESTS.has(message.type)) {
+      void this.answer(message);
+      return;
+    }
+    this.options.onMessage?.(message);
+  }
+  /**
+   * Run one guest request against the adapter and frame the answer.
+   *
+   * A throwing adapter becomes an `ok: false` response on the same
+   * `requestId`, never an unhandled rejection and never a dropped request:
+   * the guest's promise has to settle either way or the surface waits forever.
+   */
+  async answer(message) {
+    const requestId = message.requestId;
+    if (typeof requestId !== "string") {
+      this.logger.warn(
+        `[${this.options.uiIdentifier}] dropped a "${message.type}" with no requestId`
+      );
+      return;
+    }
+    const responseType = `${message.type}:response`;
+    try {
+      const result = await this.dispatch(message);
+      this.send({ type: responseType, requestId, ok: true, ...result });
+    } catch (error) {
+      this.send(
+        message.type === "callEndpoint" ? { type: responseType, requestId, ok: false, ...endpointFailureOf(error) } : {
+          type: responseType,
+          requestId,
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+    }
+  }
+  /** Route one request to its adapter method and shape the success payload. */
+  async dispatch(message) {
+    const adapter = this.options.adapter;
+    const origin = {
+      uiIdentifier: this.options.uiIdentifier,
+      ...this.options.origin
+    };
+    switch (message.type) {
+      case "callEndpoint": {
+        if (!adapter?.callEndpoint) throw new Error("This host serves no endpoints");
+        const response = await adapter.callEndpoint(
+          {
+            endpointIdentifier: String(message.endpointIdentifier),
+            request: message.request
+          },
+          origin
+        );
+        return { response };
+      }
+      case "uploadBlob": {
+        if (!adapter?.uploadBlob) throw new Error("This host stores no blobs");
+        const reference = await adapter.uploadBlob(
+          {
+            data: message.data,
+            name: String(message.name),
+            mimeType: String(message.mimeType)
+          },
+          origin
+        );
+        return { reference };
+      }
+      case "getPastState": {
+        if (!adapter?.getPastState) throw new Error("This host serves no past state");
+        const entries = await adapter.getPastState(
+          message.query,
+          origin
+        );
+        return { entries };
+      }
+      case "getAllTeamsParticipants": {
+        const participants = await adapter?.getAllTeamsParticipants?.(origin) ?? [];
+        return { participants };
+      }
+      default:
+        throw new Error(`Unroutable request "${message.type}"`);
+    }
+  }
+};
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  const entries = Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`);
+  return `{${entries.join(",")}}`;
+}
+function endpointFailureOf(error) {
+  const failure = typeof error === "object" && error !== null ? error.failure : void 0;
+  if (typeof failure === "object" && failure !== null && typeof failure.outcome?.kind === "string" && Array.isArray(failure.applied)) {
+    return failure;
+  }
+  return {
+    outcome: {
+      kind: "error",
+      message: error instanceof Error ? error.message : String(error)
+    },
+    applied: []
+  };
+}
+
+// cli/host/theme.ts
+var THEME_COLOR_ROLES = [
+  "primary",
+  "secondary",
+  "success",
+  "error",
+  "warning",
+  "info"
+];
+var AA_CONTRAST = 4.5;
+function parseColour(value) {
+  const text = value.trim().toLowerCase();
+  const hex = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.exec(text);
+  if (hex) {
+    let digits = hex[1];
+    if (digits.length <= 4) digits = [...digits].map((digit) => digit + digit).join("");
+    const channel = (at) => parseInt(digits.slice(at, at + 2), 16);
+    return {
+      r: channel(0),
+      g: channel(2),
+      b: channel(4),
+      a: digits.length === 8 ? channel(6) / 255 : 1
+    };
+  }
+  const functional = /^rgba?\(([^)]*)\)$/.exec(text);
+  if (functional) {
+    const parts = functional[1].split(/[\s,/]+/).filter(Boolean);
+    if (parts.length !== 3 && parts.length !== 4) return null;
+    const [r, g, b] = parts.slice(0, 3).map(
+      (part) => part.endsWith("%") ? parseFloat(part) / 100 * 255 : parseFloat(part)
+    );
+    const alpha = parts[3];
+    const a = alpha === void 0 ? 1 : alpha.endsWith("%") ? parseFloat(alpha) / 100 : parseFloat(alpha);
+    if ([r, g, b, a].some((n) => !Number.isFinite(n))) return null;
+    return { r: clamp(r, 255), g: clamp(g, 255), b: clamp(b, 255), a: clamp(a, 1) };
+  }
+  return null;
+}
+function clamp(value, max) {
+  return Math.min(max, Math.max(0, value));
+}
+function composite(top, bottom) {
+  const mix = (over, under) => over * top.a + under * (1 - top.a);
+  return { r: mix(top.r, bottom.r), g: mix(top.g, bottom.g), b: mix(top.b, bottom.b), a: 1 };
+}
+function relativeLuminance({ r, g, b }) {
+  const linear = (channel) => {
+    const c = channel / 255;
+    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
+}
+function contrastRatio(a, b) {
+  const [light, dark] = [relativeLuminance(a), relativeLuminance(b)].sort((x, y) => y - x);
+  return (light + 0.05) / (dark + 0.05);
+}
+function toHex({ r, g, b }) {
+  const byte = (n) => Math.round(n).toString(16).padStart(2, "0");
+  return `#${byte(r)}${byte(g)}${byte(b)}`;
+}
+var BLACK = { r: 0, g: 0, b: 0, a: 1 };
+var WHITE = { r: 255, g: 255, b: 255, a: 1 };
+function contrastTextFor(colour, preferred) {
+  const parsed = parseColour(colour);
+  if (!parsed) return toHex(BLACK);
+  const background = parsed.a < 1 ? composite(parsed, WHITE) : parsed;
+  const author = preferred === void 0 ? null : parseColour(preferred);
+  if (author) {
+    const painted = composite(author, background);
+    if (contrastRatio(painted, background) >= AA_CONTRAST) return toHex(painted);
+  }
+  return contrastRatio(BLACK, background) >= contrastRatio(WHITE, background) ? toHex(BLACK) : toHex(WHITE);
+}
+function modeWithContrast(colours) {
+  const contrastText = Object.fromEntries(
+    THEME_COLOR_ROLES.map((role) => [
+      role,
+      contrastTextFor(colours[role], colours.contrastText?.[role])
+    ])
+  );
+  const roles = Object.fromEntries(
+    THEME_COLOR_ROLES.map((role) => [role, colours[role]])
+  );
+  return { ...roles, contrastText };
+}
+function withContrastText(theme) {
+  return {
+    mode: theme.mode,
+    light: modeWithContrast(theme.light),
+    dark: modeWithContrast(theme.dark)
+  };
+}
+export {
+  HostChannel,
+  SURFACES,
+  THEME_COLOR_ROLES,
+  UI_PROTOCOL_VERSION,
+  contrastTextFor,
+  isPlayerSurface,
+  requiredMessagesFor,
+  withContrastText
+};

package/dist/prompts/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Public exports for the prompts module
+ * Provides interactive prompts for building JSON schema properties
+ */
+export { promptForSchemaProperty, promptForSchemaProperties, editSchemaProperty, reviewSchemaProperties, } from './schema-builder.js';
+export { validatePropertyName, validateNumberValue, validateMaximumValue, PASCAL_CASE_PATTERN, } from './validators.js';
+export type { PropertySchema, NumberPropertyDefaults, StringPropertyDefaults, BooleanPropertyDefaults, PropertyContext, PromptPropertyOptions, PromptPropertiesOptions, EditPropertyOptions, EditPropertyResult, ReviewPropertiesOptions, ReviewPropertiesResult, } from './types.js';