dreamboard 0.1.21 → 0.1.23

package/dist/scaffold/assets/static/ui/App.tsx

@@ -1,22 +0,0 @@
-import { Phase, PromptInbox } from "@dreamboard/ui-contract";
-
-function SetupPhase() {
-  return (
-    <main>
-      <PromptInbox.Root>
-        <PromptInbox.Empty>No available prompts.</PromptInbox.Empty>
-        <PromptInbox.Items />
-      </PromptInbox.Root>
-    </main>
-  );
-}
-
-export default function App() {
-  return (
-    <Phase.Switch
-      routes={{
-        setup: () => <SetupPhase />,
-      }}
-    />
-  );
-}

package/dist/src-CUL7EGGG.js

@@ -1,634 +0,0 @@
-#!/usr/bin/env node
-import {
-  createUnifiedSessionStore
-} from "./chunk-EYYWGWTO.js";
-import "./chunk-D4HDZEJT.js";
-
-// ../../packages/testing/src/definitions.ts
-function defineBase(definition) {
-  return definition;
-}
-function defineScenario(definition) {
-  return definition;
-}
-
-// ../../packages/testing/src/create-expect-api.ts
-import { isDeepStrictEqual } from "util";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function matchPartial(actual, expected, path = "value") {
-  if (!isRecord(expected)) {
-    return isDeepStrictEqual(actual, expected) ? null : `${path} does not match`;
-  }
-  if (!isRecord(actual)) {
-    return `${path} is not an object`;
-  }
-  for (const [key, expectedValue] of Object.entries(expected)) {
-    const actualValue = actual[key];
-    if (!(key in actual)) {
-      return `${path}.${key} is missing`;
-    }
-    const mismatch = matchPartial(actualValue, expectedValue, `${path}.${key}`);
-    if (mismatch) {
-      return mismatch;
-    }
-  }
-  return null;
-}
-function asDescriptorList(actual) {
-  if (!Array.isArray(actual)) {
-    throw new Error("Expected interaction descriptor array.");
-  }
-  return actual;
-}
-function findInteraction(descriptors, interactionId) {
-  return descriptors.find(
-    (descriptor) => descriptor.interactionId === interactionId
-  ) ?? null;
-}
-function assertDescriptorMatches(descriptor, opts) {
-  if (!opts) {
-    return;
-  }
-  const mismatch = matchPartial(descriptor, opts, "interaction");
-  if (mismatch) {
-    throw new Error(mismatch);
-  }
-}
-function createSubmissionErrorMatcher(actual, expected) {
-  const resolvePromise = () => {
-    if (typeof actual === "function") {
-      return Promise.resolve().then(() => actual());
-    }
-    return Promise.resolve(actual);
-  };
-  return resolvePromise().then(() => {
-    throw new Error("Expected promise to reject.");
-  }).catch((error) => {
-    if (!(error instanceof Error)) {
-      throw new Error("Expected rejection to be an Error.");
-    }
-    if (expected.errorCode !== void 0 && error.errorCode !== expected.errorCode) {
-      throw new Error(
-        `Expected rejection errorCode '${expected.errorCode}', received '${error.errorCode ?? "undefined"}'.`
-      );
-    }
-    if (typeof expected.message === "string" && error.message !== expected.message) {
-      throw new Error(
-        `Expected rejection message '${expected.message}', received '${error.message}'.`
-      );
-    }
-    if (expected.message instanceof RegExp && !expected.message.test(error.message)) {
-      throw new Error(
-        `Expected rejection message '${error.message}' to match ${String(expected.message)}.`
-      );
-    }
-  });
-}
-function assertLength(actual, expected) {
-  if (actual === null || actual === void 0 || typeof actual.length !== "number") {
-    throw new Error("toHaveLength expects a value with a numeric length.");
-  }
-  const length = actual.length;
-  if (length !== expected) {
-    throw new Error(`Expected length ${expected}, received ${length}.`);
-  }
-}
-function assertThrown(actual, predicate) {
-  if (typeof actual !== "function") {
-    throw new Error("toThrow expects a function.");
-  }
-  try {
-    actual();
-  } catch (error) {
-    if (!(error instanceof Error)) {
-      throw new Error("Thrown value is not an Error.");
-    }
-    if (predicate === void 0) {
-      return;
-    }
-    if (typeof predicate === "string" && error.message !== predicate) {
-      throw new Error(
-        `Expected thrown message '${predicate}', received '${error.message}'.`
-      );
-    }
-    if (predicate instanceof RegExp && !predicate.test(error.message)) {
-      throw new Error(
-        `Expected thrown message '${error.message}' to match ${String(predicate)}.`
-      );
-    }
-    if (typeof predicate === "function" && !predicate(error)) {
-      throw new Error("Thrown error did not satisfy predicate.");
-    }
-    return;
-  }
-  throw new Error("Expected function to throw.");
-}
-function createExpectApi(options = {}) {
-  const buildMatchers = (actual) => ({
-    toBe: (expected) => {
-      if (actual !== expected) {
-        throw new Error(
-          `Expected '${String(actual)}' to be '${String(expected)}'.`
-        );
-      }
-    },
-    toEqual: (expected) => {
-      if (!isDeepStrictEqual(actual, expected)) {
-        throw new Error("Expected values to be deeply equal.");
-      }
-    },
-    toMatchObject: (expected) => {
-      const mismatch = matchPartial(actual, expected);
-      if (mismatch) {
-        throw new Error(mismatch);
-      }
-    },
-    toBeDefined: () => {
-      if (actual === void 0) {
-        throw new Error("Expected value to be defined.");
-      }
-    },
-    toBeUndefined: () => {
-      if (actual !== void 0) {
-        throw new Error(
-          `Expected value to be undefined, but received '${String(actual)}'.`
-        );
-      }
-    },
-    toBeNull: () => {
-      if (actual !== null) {
-        throw new Error(
-          `Expected value to be null, but received '${String(actual)}'.`
-        );
-      }
-    },
-    toContain: (expected) => {
-      if (Array.isArray(actual)) {
-        if (!actual.includes(expected)) {
-          throw new Error("Expected array to contain value.");
-        }
-        return;
-      }
-      if (typeof actual === "string") {
-        if (!actual.includes(String(expected))) {
-          throw new Error("Expected string to contain value.");
-        }
-        return;
-      }
-      throw new Error("toContain expects an array or string actual value.");
-    },
-    toContainEqual: (expected) => {
-      if (!Array.isArray(actual)) {
-        throw new Error("toContainEqual expects an array actual value.");
-      }
-      if (!actual.some((value) => isDeepStrictEqual(value, expected))) {
-        throw new Error("Expected array to contain an equal value.");
-      }
-    },
-    toHaveLength: (expected) => {
-      assertLength(actual, expected);
-    },
-    toBeGreaterThan: (expected) => {
-      if (typeof actual !== "number") {
-        throw new Error("toBeGreaterThan expects a number actual value.");
-      }
-      if (actual <= expected) {
-        throw new Error(`Expected ${actual} to be > ${expected}.`);
-      }
-    },
-    toBeGreaterThanOrEqual: (expected) => {
-      if (typeof actual !== "number") {
-        throw new Error(
-          "toBeGreaterThanOrEqual expects a number actual value."
-        );
-      }
-      if (actual < expected) {
-        throw new Error(`Expected ${actual} to be >= ${expected}.`);
-      }
-    },
-    toThrow: (predicate) => {
-      assertThrown(actual, predicate);
-    },
-    toMatchSnapshot: (filename) => {
-      if (!options.matchSnapshot) {
-        throw new Error(
-          "Snapshot matching is not configured for this expect API."
-        );
-      }
-      options.matchSnapshot(filename, actual);
-    },
-    toRejectWith: (expected) => createSubmissionErrorMatcher(actual, expected),
-    toHaveInteraction: (interactionId, opts) => {
-      const descriptors = asDescriptorList(actual);
-      const descriptor = findInteraction(descriptors, interactionId);
-      if (!descriptor) {
-        throw new Error(`Expected interaction '${interactionId}' to exist.`);
-      }
-      assertDescriptorMatches(descriptor, opts);
-    },
-    toBeGatedBy: (reason, opts) => {
-      const descriptor = Array.isArray(actual) ? (() => {
-        if (!opts?.interactionId) {
-          throw new Error(
-            "toBeGatedBy on a descriptor array requires opts.interactionId."
-          );
-        }
-        return findInteraction(
-          asDescriptorList(actual),
-          opts.interactionId
-        );
-      })() : actual;
-      if (!descriptor) {
-        throw new Error("Expected interaction descriptor to exist.");
-      }
-      if (descriptor.available !== false) {
-        throw new Error("Expected interaction to be unavailable.");
-      }
-      if (descriptor.unavailableReason !== reason) {
-        throw new Error(
-          `Expected unavailableReason '${reason}', received '${descriptor.unavailableReason ?? "undefined"}'.`
-        );
-      }
-    },
-    toBeActiveFor: (playerId, opts) => {
-      const descriptor = Array.isArray(actual) ? (() => {
-        if (!opts?.interactionId) {
-          throw new Error(
-            "toBeActiveFor on a descriptor array requires opts.interactionId."
-          );
-        }
-        return findInteraction(
-          asDescriptorList(actual),
-          opts.interactionId
-        );
-      })() : actual;
-      if (!descriptor) {
-        throw new Error("Expected interaction descriptor to exist.");
-      }
-      if (descriptor.context?.to !== playerId) {
-        throw new Error(
-          `Expected interaction to target '${playerId}', received '${descriptor.context?.to ?? "undefined"}'.`
-        );
-      }
-      if (descriptor.available !== true) {
-        throw new Error("Expected interaction to be available.");
-      }
-    },
-    not: {
-      toHaveInteraction: (interactionId) => {
-        const descriptors = asDescriptorList(actual);
-        if (findInteraction(descriptors, interactionId)) {
-          throw new Error(
-            `Expected interaction '${interactionId}' to be absent.`
-          );
-        }
-      }
-    }
-  });
-  return (actual) => buildMatchers(actual);
-}
-
-// ../../packages/testing/src/create-test-runtime.ts
-function cloneState(value) {
-  return structuredClone(value);
-}
-function createSubmissionError(errorCode, message) {
-  const error = new Error(message ?? "Interaction rejected");
-  error.name = "SubmissionError";
-  error.errorCode = errorCode;
-  return error;
-}
-function readFlowState(state) {
-  const flow = state.domain?.flow ?? {};
-  return {
-    currentPhase: flow.currentPhase ?? null,
-    activePlayers: Array.isArray(flow.activePlayers) ? flow.activePlayers : []
-  };
-}
-function buildSeatAssignments(playerIds, userId, displayNameByPlayerId) {
-  const actor = userId != null ? { kind: "AUTH_USER", id: userId } : void 0;
-  return playerIds.map((playerId) => ({
-    playerId,
-    controllerActor: actor,
-    displayName: displayNameByPlayerId?.[playerId] ?? playerId
-  }));
-}
-function resolvePlayerIds(options) {
-  if (options.explicitPlayerIds && options.explicitPlayerIds.length > 0) {
-    return [...options.explicitPlayerIds];
-  }
-  return Array.from(
-    { length: options.baseState.fingerprint.players },
-    (_, index) => `player-${index + 1}`
-  );
-}
-function createStubSseManager() {
-  return {
-    connect: () => void 0,
-    disconnect: () => void 0,
-    on: () => () => void 0,
-    onAnyMessage: () => () => void 0
-  };
-}
-function buildGameplaySnapshot(options) {
-  const projection = options.bundle.projectSeatsDynamic({
-    state: options.state,
-    playerIds: [options.playerId]
-  });
-  const flow = readFlowState(options.state);
-  if (options.expectedPhase && flow.currentPhase !== options.expectedPhase) {
-    throw new Error(
-      `Expected base '${options.baseId}' to be in phase '${options.expectedPhase}', received '${flow.currentPhase ?? "null"}'.`
-    );
-  }
-  const seats = projection.seats ?? {};
-  const seat = seats[options.playerId];
-  return {
-    version: options.version,
-    actionSetVersion: `${options.version}:test`,
-    playerId: options.playerId,
-    activePlayers: flow.activePlayers,
-    currentPhase: flow.currentPhase ?? "",
-    currentStage: projection.currentStage ?? "",
-    stageSeats: projection.stageSeats ?? [],
-    view: JSON.stringify(seat?.view ?? null),
-    availableInteractions: seat?.availableInteractions ?? [],
-    zones: seat?.zones ?? {},
-    boardStatic: options.staticProjection ? JSON.stringify(options.staticProjection.view) : void 0,
-    boardStaticHash: options.staticProjection?.hash
-  };
-}
-function createHostContext(options) {
-  return {
-    sessionId: options.sessionId,
-    shortCode: options.sessionId,
-    phase: options.phase,
-    status: "active",
-    hostActor: options.hostActor,
-    gameSource: {
-      kind: "USER_COMPILED",
-      ownerUserId: options.userId,
-      gameId: options.gameId,
-      compiledResultId: "00000000-0000-0000-0000-000000000000"
-    },
-    switchablePlayerIds: options.switchablePlayerIds,
-    history: {
-      entries: [],
-      currentIndex: -1,
-      canGoBack: false,
-      canGoForward: false
-    }
-  };
-}
-function createRuntimeSessionContext(options) {
-  return {
-    identity: {
-      sessionId: options.sessionId,
-      shortCode: options.sessionId,
-      gameId: options.gameId
-    },
-    userId: options.userId,
-    seats: options.seats,
-    canStart: options.canStart,
-    hostActor: options.hostActor,
-    switchablePlayerIds: options.switchablePlayerIds,
-    history: {
-      entries: [],
-      currentIndex: -1,
-      canGoBack: false,
-      canGoForward: false
-    }
-  };
-}
-function gameplayViewportFromSnapshot(snapshot) {
-  return {
-    version: snapshot.version,
-    actionSetVersion: snapshot.actionSetVersion,
-    activePlayers: snapshot.activePlayers,
-    currentPhase: snapshot.currentPhase,
-    currentStage: snapshot.currentStage,
-    stageSeats: snapshot.stageSeats,
-    simultaneousPhase: snapshot.simultaneousPhase ?? null,
-    view: JSON.parse(snapshot.view),
-    availableInteractions: snapshot.availableInteractions,
-    zones: snapshot.zones,
-    boardStatic: snapshot.boardStatic ? JSON.parse(snapshot.boardStatic) : null,
-    boardStaticHash: snapshot.boardStaticHash ?? null
-  };
-}
-function createTestRuntime(options) {
-  const baseState = options.baseStates[options.baseId];
-  if (!baseState) {
-    throw new Error(`Unknown test base '${options.baseId}'.`);
-  }
-  let currentState = cloneState(baseState.snapshot);
-  const playerIds = resolvePlayerIds({
-    baseState,
-    explicitPlayerIds: options.playerIds
-  });
-  const userId = options.userId ?? "test-user";
-  const sessionId = options.sessionId ?? "test-session";
-  const gameId = options.gameId ?? "test-game";
-  const seats = buildSeatAssignments(
-    playerIds,
-    userId,
-    options.displayNameByPlayerId
-  );
-  const storeApi = createUnifiedSessionStore({
-    createSseManager: createStubSseManager,
-    // Test runtimes keep `userId` present so the unified store derives
-    // controllable player ids from seat assignments whenever the
-    // incoming snapshot omits `controllablePlayerIds`.
-    fallbackToAllSeatsWhenUserIdMissing: false
-  });
-  const hostActor = { kind: "AUTH_USER", id: userId };
-  const lobbySnapshot = {
-    type: "lobby",
-    context: createHostContext({
-      sessionId,
-      userId,
-      gameId,
-      phase: "lobby",
-      hostActor,
-      switchablePlayerIds: playerIds
-    }),
-    lobby: {
-      seats,
-      canStart: true,
-      hostActor
-    }
-  };
-  const setSessionState = (input) => {
-    const context = createRuntimeSessionContext({
-      sessionId,
-      userId,
-      gameId,
-      hostActor,
-      switchablePlayerIds: playerIds,
-      seats,
-      canStart: true
-    });
-    storeApi.setState((state) => ({
-      ...state,
-      session: input.gameplay ? {
-        type: "gameplay",
-        context,
-        perspective: { playerId: input.selectedPlayerId },
-        gameplay: gameplayViewportFromSnapshot(input.gameplay)
-      } : {
-        type: "lobby",
-        context,
-        preferredPlayerId: input.selectedPlayerId || null
-      },
-      connection: { ...state.connection, error: null },
-      activity: {
-        ...state.activity,
-        syncId: state.activity.syncId + 1,
-        lastSyncTimestamp: Date.now()
-      }
-    }));
-  };
-  setSessionState({
-    selectedPlayerId: playerIds[0] ?? ""
-  });
-  let version = 0;
-  let currentPlayerId = playerIds[0] ?? "";
-  const staticProjection = options.bundle.projectStatic?.() ?? null;
-  const applyCurrentState = () => {
-    version += 1;
-    const snapshot = buildGameplaySnapshot({
-      state: currentState,
-      bundle: options.bundle,
-      staticProjection,
-      playerId: currentPlayerId,
-      version,
-      expectedPhase: version === 1 ? options.phase : void 0,
-      baseId: options.baseId
-    });
-    setSessionState({
-      selectedPlayerId: currentPlayerId,
-      gameplay: snapshot
-    });
-  };
-  applyCurrentState();
-  const stateListeners = /* @__PURE__ */ new Set();
-  const sessionListeners = /* @__PURE__ */ new Set();
-  let lastPluginSnapshot = storeApi.getState().getPluginSnapshot();
-  let lastSessionState = {
-    ...lastPluginSnapshot.session,
-    status: "ready"
-  };
-  storeApi.subscribe((state, previous) => {
-    const nextPluginSnapshot = state.getPluginSnapshot();
-    if (nextPluginSnapshot !== lastPluginSnapshot) {
-      lastPluginSnapshot = nextPluginSnapshot;
-      for (const listener of stateListeners) {
-        listener(nextPluginSnapshot);
-      }
-    }
-    const previousSession = previous.getPluginSnapshot().session;
-    const nextSession = nextPluginSnapshot.session;
-    const controllingPlayerChanged = nextSession.controllingPlayerId !== previousSession.controllingPlayerId;
-    const controllableIdsChanged = nextSession.controllablePlayerIds.join("\0") !== previousSession.controllablePlayerIds.join("\0");
-    if (controllingPlayerChanged || controllableIdsChanged) {
-      lastSessionState = {
-        ...nextPluginSnapshot.session,
-        status: "ready"
-      };
-      for (const listener of sessionListeners) {
-        listener(lastSessionState);
-      }
-    }
-  });
-  const validate = async (playerId, interactionId, params = {}) => {
-    const result = await options.bundle.validateInput({
-      state: currentState,
-      input: {
-        kind: "interaction",
-        playerId,
-        interactionId,
-        params
-      }
-    });
-    return {
-      valid: result.valid,
-      errorCode: result.errorCode,
-      message: result.message
-    };
-  };
-  const submit = async (playerId, interactionId, params = {}) => {
-    const validation = await validate(playerId, interactionId, params);
-    if (!validation.valid) {
-      throw createSubmissionError(validation.errorCode, validation.message);
-    }
-    const result = await options.bundle.dispatch({
-      state: currentState,
-      input: {
-        kind: "interaction",
-        playerId,
-        interactionId,
-        params
-      }
-    });
-    if (result.kind === "reject") {
-      throw createSubmissionError(result.errorCode, result.message);
-    }
-    currentState = cloneState(result.state);
-    applyCurrentState();
-  };
-  const setControllingPlayer = (playerId) => {
-    if (!playerIds.includes(playerId)) {
-      throw new Error(`Unknown controlling player '${playerId}'.`);
-    }
-    currentPlayerId = playerId;
-    storeApi.getState().selectPlayer(playerId);
-    applyCurrentState();
-  };
-  const runtime = {
-    validateInteraction: validate,
-    submitInteraction: submit,
-    getSessionState: () => ({ ...lastSessionState }),
-    disconnect: () => void 0,
-    switchPlayer: (playerId) => {
-      setControllingPlayer(playerId);
-    },
-    getSnapshot: () => lastPluginSnapshot,
-    subscribeToState: (listener) => {
-      stateListeners.add(listener);
-      return () => {
-        stateListeners.delete(listener);
-      };
-    },
-    _subscribeToSessionState: (listener) => {
-      sessionListeners.add(listener);
-      return () => {
-        sessionListeners.delete(listener);
-      };
-    }
-  };
-  return {
-    runtime,
-    getSnapshot: () => lastPluginSnapshot,
-    players: () => [...playerIds],
-    seat: (index) => {
-      if (!Number.isInteger(index) || index < 0 || index >= playerIds.length) {
-        throw new Error(
-          `seat(${index}) is out of range; base '${options.baseId}' has ${playerIds.length} player(s).`
-        );
-      }
-      return playerIds[index];
-    },
-    submit,
-    validate,
-    setControllingPlayer
-  };
-}
-export {
-  createExpectApi,
-  createTestRuntime,
-  defineBase,
-  defineScenario
-};
-//# sourceMappingURL=src-CUL7EGGG.js.map