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

package/src/reducer/bundle/trusted/stage-resolver.ts

@@ -1,87 +0,0 @@
-import type {
-  AnyInteractionSpec,
-  PhaseMapOf,
-  ReducerGameContractLike,
-  StageSpec,
-  ViewMapOf,
-} from "../../model";
-import type {
-  TrustedDomainState,
-  TrustedManifest,
-  TrustedPhaseName,
-  TrustedRuntimeScope,
-  TrustedState,
-} from "./runtime-scope";
-import type { ProjectionContext } from "./projection-context";
-
-export function createStageResolver<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(scope: TrustedRuntimeScope<Contract, Definitions, Views>) {
-  type DomainState = TrustedDomainState<Contract>;
-  type Manifest = TrustedManifest<Contract>;
-  type State = TrustedState<Contract>;
-  type PhaseName = TrustedPhaseName<Contract, Definitions, Views>;
-
-  function resolveActiveStage(
-    state: State,
-    phaseName: PhaseName,
-    projection?: ProjectionContext<DomainState, State>,
-  ): { id: string; stage: StageSpec<DomainState, Manifest> } | null {
-    const stages = scope.stagesForPhase(phaseName);
-    if (stages.length === 0) return null;
-    const domainState = projection?.domainState ?? scope.toDomainState(state);
-    const context = scope.buildContext(state);
-    for (const [stageId, stage] of stages) {
-      const matches = stage.when
-        ? stage.when({
-            ...context,
-            state: domainState,
-          })
-        : true;
-      if (matches) return { id: stageId, stage };
-    }
-    return null;
-  }
-
-  function resolveActiveStageAllowlist(
-    state: State,
-    phaseName: PhaseName,
-    projection?: ProjectionContext<DomainState, State>,
-  ): Set<string> | null {
-    const cacheKey = String(phaseName);
-    if (projection?.stageAllowlists.has(cacheKey)) {
-      return projection.stageAllowlists.get(cacheKey) ?? null;
-    }
-    const activeStage = resolveActiveStage(state, phaseName, projection);
-    const allowlist = activeStage ? new Set(activeStage.stage.allow) : null;
-    projection?.stageAllowlists.set(cacheKey, allowlist);
-    return allowlist;
-  }
-
-  function isInteractionAllowedInStep(
-    state: State,
-    interaction: AnyInteractionSpec<DomainState, Manifest>,
-    projection?: ProjectionContext<DomainState, State>,
-  ): boolean {
-    const allowedSteps = interaction.__steps ?? [];
-    if (allowedSteps.length === 0) {
-      return true;
-    }
-    const currentStep = (
-      (projection?.domainState ?? scope.toDomainState(state)).phase as {
-        step?: unknown;
-      }
-    ).step;
-    return (
-      typeof currentStep === "string" && allowedSteps.includes(currentStep)
-    );
-  }
-
-  return {
-    isInteractionAllowedInStep,
-    resolveActiveStage,
-    resolveActiveStageAllowlist,
-  };
-}

package/src/reducer/bundle/trusted/static-projection.ts

@@ -1,116 +0,0 @@
-import type {
-  ManifestContract,
-  PhaseMapOf,
-  ReducerGameContractLike,
-  RuntimeTableRecord,
-  StaticViewQueries,
-  ViewMapOf,
-} from "../../model";
-import type { TrustedRuntimeScope } from "./runtime-scope";
-
-function stableStringify(value: unknown): string {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-  const entries = Object.entries(value as Record<string, unknown>)
-    .filter(([, v]) => v !== undefined)
-    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-  return `{${entries
-    .map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`)
-    .join(",")}}`;
-}
-
-function hashProjection(input: string): string {
-  let h = 0x811c9dc5;
-  for (let i = 0; i < input.length; i += 1) {
-    h ^= input.charCodeAt(i);
-    h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
-  }
-  return h.toString(16).padStart(8, "0");
-}
-
-function readManifestVersion(manifest: unknown): string {
-  const m = manifest as { version?: unknown; literals?: unknown };
-  if (typeof m.version === "string" && m.version.length > 0) {
-    return m.version;
-  }
-  if (m.literals && typeof m.literals === "object") {
-    return hashProjection(stableStringify(m.literals));
-  }
-  return "0";
-}
-
-function createStaticViewQueries<
-  Manifest extends ManifestContract<RuntimeTableRecord>,
->(manifest: Manifest): StaticViewQueries<Manifest> {
-  const staticBoards = manifest.staticBoards ?? {
-    byId: {},
-    hex: {},
-    square: {},
-  };
-  const requireBoard = (
-    boards: Record<string, unknown>,
-    boardId: string,
-    layout: "board" | "hex" | "square",
-  ) => {
-    const board = boards[boardId];
-    if (!board) {
-      throw new Error(`Unknown static ${layout} board '${boardId}'.`);
-    }
-    return board;
-  };
-
-  return {
-    board: {
-      get: (boardId) =>
-        requireBoard(
-          staticBoards.byId as Record<string, unknown>,
-          boardId,
-          "board",
-        ) as never,
-      hex: (boardId) =>
-        requireBoard(
-          staticBoards.hex as Record<string, unknown>,
-          boardId,
-          "hex",
-        ) as never,
-      square: (boardId) =>
-        requireBoard(
-          staticBoards.square as Record<string, unknown>,
-          boardId,
-          "square",
-        ) as never,
-    },
-  };
-}
-
-export function createStaticProjectionBuilder<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(scope: TrustedRuntimeScope<Contract, Definitions, Views>) {
-  return {
-    projectStatic(): {
-      view: unknown;
-      hash: string;
-      manifestVersion: string;
-    } | null {
-      const staticView = scope.definition.staticView;
-      if (!staticView) return null;
-      const manifest = scope.definition.contract.manifest;
-      const view = staticView.project({
-        manifest,
-        q: createStaticViewQueries(manifest),
-      });
-      const serialized = stableStringify(view);
-      return {
-        view: JSON.parse(serialized) as unknown,
-        hash: hashProjection(serialized),
-        manifestVersion: readManifestVersion(manifest),
-      };
-    },
-  };
-}

package/src/reducer/bundle/trusted/trusted-runtime-args.ts

@@ -1,97 +0,0 @@
-import { createDerivedResolver } from "../../derived";
-import type { DerivedResolver } from "../../derived";
-import { createReducerFx } from "../../effects";
-import { createStateQueries } from "../../table-queries";
-import type {
-  ActionContext,
-  BaseGameStateOfContract,
-  ManifestContractOf,
-  PlayerIdOfState,
-  RandomHelpers,
-  ReducerGameContractLike,
-  TableQueriesOfState,
-} from "../../model";
-import type { TrustedRuntimeHelpers, TrustedState } from "./runtime-scope";
-
-export function fxForState<Contract extends ReducerGameContractLike>(
-  state: TrustedState<Contract>,
-) {
-  return createReducerFx<TrustedState<Contract>>(state);
-}
-
-export function buildContext<Contract extends ReducerGameContractLike>(
-  state: TrustedState<Contract>,
-  manifest: ManifestContractOf<Contract>,
-): ActionContext<
-  BaseGameStateOfContract<Contract>,
-  ManifestContractOf<Contract>
-> {
-  type DomainState = BaseGameStateOfContract<Contract>;
-  type PlayerId = PlayerIdOfState<DomainState>;
-  type Manifest = ManifestContractOf<Contract>;
-  return {
-    currentPhase: state.flow.currentPhase as ActionContext<
-      DomainState,
-      Manifest
-    >["currentPhase"],
-    manifest,
-    playerOrder: [...state.table.playerOrder] as PlayerId[],
-    activePlayers: [...state.flow.activePlayers] as PlayerId[],
-    runtime: publicRuntime(state.runtime),
-    setup: (state.runtime.setup
-      ? {
-          profileId: state.runtime.setup.profileId,
-          optionValues: {
-            ...state.runtime.setup.optionValues,
-          },
-        }
-      : null) as ActionContext<DomainState, Manifest>["setup"],
-  };
-}
-
-function publicRuntime<Runtime extends { rng?: unknown }>(
-  runtime: Runtime,
-): Omit<Runtime, "rng"> {
-  const { rng: _rng, ...rest } = runtime;
-  return rest;
-}
-
-const DISABLED_RANDOM_HELPERS: RandomHelpers = {
-  subset() {
-    throw new Error(
-      "random helpers are only available in reducer mutation callbacks.",
-    );
-  },
-};
-
-export function buildRuntimeArgs<
-  Contract extends ReducerGameContractLike,
-  Extra extends object,
->(
-  state: TrustedState<Contract>,
-  manifest: ManifestContractOf<Contract>,
-  helpers: TrustedRuntimeHelpers<Contract>,
-  toDomainState: (
-    state: TrustedState<Contract>,
-  ) => BaseGameStateOfContract<Contract>,
-  extra: Extra,
-  options: {
-    q?: TableQueriesOfState<BaseGameStateOfContract<Contract>>;
-    derived?: DerivedResolver;
-    fx?: ReturnType<typeof createReducerFx<TrustedState<Contract>>>;
-    random?: RandomHelpers;
-  } = {},
-) {
-  const domainState = toDomainState(state);
-  const q = options.q ?? createStateQueries(domainState);
-  return {
-    ...buildContext(state, manifest),
-    ...helpers,
-    fx: options.fx ?? fxForState(state),
-    q,
-    derived: options.derived ?? createDerivedResolver(domainState, { q }),
-    runtime: publicRuntime(state.runtime),
-    random: options.random ?? DISABLED_RANDOM_HELPERS,
-    ...extra,
-  };
-}

package/src/reducer/bundle/trusted/trusted-runtime-result.ts

@@ -1,39 +0,0 @@
-import type { RuntimeInstructionForState } from "../../core/runtime-instruction";
-import type { ReducerReject, ReducerResult } from "../../model";
-
-export function acceptResult<State>(
-  state: State,
-  instructions: Array<RuntimeInstructionForState<State>> = [],
-) {
-  return {
-    type: "accept" as const,
-    state,
-    instructions,
-  };
-}
-
-export function rejectResult(
-  errorCode: string,
-  message?: string,
-): ReducerReject {
-  return {
-    type: "reject",
-    errorCode,
-    message,
-  };
-}
-
-export function normalizeResult<State>(
-  result: ReducerResult<State> | void,
-  fallbackState: State,
-): ReducerResult<State> {
-  if (result === undefined || result === null) {
-    return acceptResult(fallbackState);
-  }
-  return result;
-}
-
-export const runtimeResultHelpers = {
-  accept: acceptResult,
-  reject: rejectResult,
-};

package/src/reducer/bundle/trusted/trusted-setup-profiles.ts

@@ -1,43 +0,0 @@
-import type {
-  PhaseMapOf,
-  ReducerGameContractLike,
-  ReducerGameDefinition,
-  ViewMapOf,
-} from "../../model";
-
-export function resolveTrustedSetupProfiles<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(definition: ReducerGameDefinition<Contract, Definitions, Views>) {
-  const manifestSetupProfilesById =
-    definition.contract.manifest.setupProfilesById;
-  const manifestSetupProfileIds = Object.keys(manifestSetupProfilesById).sort();
-  const reducerSetupProfiles = definition.setupProfiles ?? {};
-  const reducerSetupProfileIds = Object.keys(reducerSetupProfiles).sort();
-  if (
-    manifestSetupProfileIds.length !== reducerSetupProfileIds.length ||
-    manifestSetupProfileIds.some(
-      (profileId, index) => reducerSetupProfileIds[index] !== profileId,
-    )
-  ) {
-    throw new Error(
-      `Reducer setupProfiles must exactly match manifest setupProfiles. Manifest=[${manifestSetupProfileIds.join(", ")}], reducer=[${reducerSetupProfileIds.join(", ")}].`,
-    );
-  }
-  return {
-    manifestSetupProfilesById,
-    reducerSetupProfiles,
-  };
-}
-
-export function resolveDefaultInitialPhase<PhaseName extends string>(
-  explicitInitialPhase: PhaseName | undefined,
-  phaseEntries: ReadonlyArray<readonly [PhaseName, unknown]>,
-): PhaseName {
-  const defaultInitialPhase = explicitInitialPhase ?? phaseEntries[0]?.[0];
-  if (!defaultInitialPhase) {
-    throw new Error("Reducer-native games must define at least one phase.");
-  }
-  return defaultInitialPhase;
-}

package/src/reducer/bundle/trusted/trusted-state-codec.ts

@@ -1,48 +0,0 @@
-export function toDomainState<State extends { runtime: unknown }, DomainState>(
-  state: State,
-): DomainState {
-  const { runtime: _runtime, ...domain } = state;
-  attachPhaseAccessor(domain);
-  return domain as DomainState;
-}
-
-export function toCombinedState<
-  SessionState extends { domain: unknown; runtime: unknown },
-  State,
->(session: SessionState): State {
-  const combined = {
-    ...(session.domain as object),
-    runtime: session.runtime,
-  };
-  attachPhaseAccessor(combined);
-  return combined as State;
-}
-
-export function toSessionState<
-  State extends { runtime: unknown },
-  DomainState,
-  SessionState,
->(state: State, toDomain: (state: State) => DomainState): SessionState {
-  return {
-    domain: toDomain(state),
-    runtime: state.runtime,
-  } as SessionState;
-}
-
-function attachPhaseAccessor(state: unknown): void {
-  if (!state || typeof state !== "object") return;
-  const candidate = state as {
-    flow?: { currentPhase?: unknown };
-    phase?: unknown;
-  };
-  const phase = candidate.phase;
-  if (!phase || typeof phase !== "object") return;
-  const descriptor = Object.getOwnPropertyDescriptor(phase, "get");
-  if (descriptor && typeof descriptor.value === "function") return;
-  Object.defineProperty(phase, "get", {
-    enumerable: false,
-    configurable: true,
-    value: (phaseName: string) =>
-      candidate.flow?.currentPhase === phaseName ? phase : null,
-  });
-}

package/src/reducer/bundle/trusted-bundle.ts

@@ -1,97 +0,0 @@
-import type { TrustedReducerBundle } from "./types";
-import type {
-  PhaseMapOf,
-  ReducerGameContractLike,
-  ReducerGameDefinition,
-  ViewMapOf,
-} from "../model";
-import { createTrustedInstructionRunner } from "./trusted/instruction-runner";
-import { createInteractionResolver } from "./trusted/interaction-resolver";
-import { createLifecycleRunner } from "./trusted/lifecycle-runner";
-import { createProjectionBuilder } from "./trusted/projection-builder";
-import { createTrustedRuntimeScope } from "./trusted/runtime-scope";
-import { createStaticProjectionBuilder } from "./trusted/static-projection";
-
-export function createTrustedReducerBundle<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(
-  definition: ReducerGameDefinition<Contract, Definitions, Views>,
-): TrustedReducerBundle<Contract, Definitions, Views> {
-  const scope = createTrustedRuntimeScope(definition);
-  const interactions = createInteractionResolver(scope);
-  const lifecycle = createLifecycleRunner(scope, interactions);
-  const instructions = createTrustedInstructionRunner(
-    scope,
-    interactions,
-    lifecycle,
-  );
-  const staticProjection = createStaticProjectionBuilder(scope);
-  const projection = createProjectionBuilder(scope, interactions);
-
-  return {
-    async initialize(input) {
-      return lifecycle.initializeSession(input, instructions.drainInstructions);
-    },
-    async initializePhase({ state, to }) {
-      const initialized = lifecycle.initializePhaseResult(
-        scope.toCombinedState(state),
-        to,
-      );
-      return scope.toSessionState(
-        instructions.drainInstructions(
-          initialized.state,
-          initialized.instructions,
-        ),
-      );
-    },
-    async validateInput({ state, input }) {
-      return interactions.validateClientInput(
-        scope.toCombinedState(state),
-        input,
-      );
-    },
-    async reduce({ state, input }) {
-      const combinedState = scope.toCombinedState(state);
-      const reject = interactions.validateOrReject(combinedState, input);
-      if (reject) {
-        return reject;
-      }
-      const result = instructions.reduceOnce(combinedState, input);
-      if (result.type === "reject") {
-        return result;
-      }
-      return {
-        type: "accept" as const,
-        state: scope.toSessionState(result.state),
-        instructions: result.instructions ?? [],
-      };
-    },
-    async dispatch({ state, input }) {
-      const combinedState = scope.toCombinedState(state);
-      const reject = interactions.validateOrReject(combinedState, input);
-      if (reject) {
-        return reject;
-      }
-      const result = instructions.dispatch(combinedState, input);
-      if (result.type === "reject") {
-        return result;
-      }
-      return {
-        type: "accept" as const,
-        state: scope.toSessionState(result.state),
-        trace: result.trace,
-      };
-    },
-    projectStatic() {
-      return staticProjection.projectStatic();
-    },
-    projectSeatsDynamic(input) {
-      return projection.projectSeatsDynamic(input);
-    },
-    projectSeatViewDynamic(input) {
-      return projection.projectSeatViewDynamic(input);
-    },
-  };
-}

package/src/reducer/bundle/types.ts

@@ -1,171 +0,0 @@
-import type { DispatchTraceEntry, TrustedRuntimeInput } from "../core/types";
-import type {
-  BaseGameStateOfContract,
-  BaseGameSessionOfContract,
-  ManifestContractOf,
-  PhaseMapOf,
-  PhaseNamesOfDefinition,
-  PlayerIdOfState,
-  ReducerGameContractLike,
-  ReducerGameDefinition,
-  ReducerReject,
-  ReducerValidationResult,
-  RuntimeSetupSelectionInput,
-  ViewMapOf,
-} from "../model";
-import type { RuntimeInstructionForState } from "../core/runtime-instruction";
-import type { ReducerBundleContract } from "../../infrastructure/reducer-contract/bundle.js";
-
-type TrustedSessionState<Contract extends ReducerGameContractLike> =
-  BaseGameSessionOfContract<Contract>;
-
-type TrustedCombinedState<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-> = BaseGameStateOfContract<Contract> & {
-  runtime: TrustedSessionState<Contract>["runtime"];
-};
-
-type TrustedPlayerId<
-  Contract extends ReducerGameContractLike,
-  _Definitions extends PhaseMapOf<Contract>,
-> = PlayerIdOfState<BaseGameStateOfContract<Contract>>;
-
-export type TrustedReducerBundle<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
-> = {
-  initialize(input: {
-    table: BaseGameStateOfContract<Contract>["table"];
-    playerIds: TrustedPlayerId<Contract, Definitions>[];
-    rngSeed?: number | null;
-    setup?: RuntimeSetupSelectionInput<ManifestContractOf<Contract>> | null;
-  }): Promise<TrustedSessionState<Contract>>;
-  initializePhase(input: {
-    state: TrustedSessionState<Contract>;
-    to: PhaseNamesOfDefinition<
-      ReducerGameDefinition<Contract, Definitions, Views>
-    >;
-  }): Promise<TrustedSessionState<Contract>>;
-  validateInput(input: {
-    state: TrustedSessionState<Contract>;
-    input: TrustedRuntimeInput<TrustedPlayerId<Contract, Definitions>>;
-  }): Promise<ReducerValidationResult>;
-  reduce(input: {
-    state: TrustedSessionState<Contract>;
-    input: TrustedRuntimeInput<TrustedPlayerId<Contract, Definitions>>;
-  }): Promise<
-    | ReducerReject
-    | {
-        type: "accept";
-        state: TrustedSessionState<Contract>;
-        instructions: RuntimeInstructionForState<
-          TrustedCombinedState<Contract, Definitions>
-        >[];
-      }
-  >;
-  dispatch(input: {
-    state: TrustedSessionState<Contract>;
-    input: TrustedRuntimeInput<TrustedPlayerId<Contract, Definitions>>;
-  }): Promise<
-    | ReducerReject
-    | {
-        type: "accept";
-        state: TrustedSessionState<Contract>;
-        trace: DispatchTraceEntry<
-          TrustedCombinedState<Contract, Definitions>,
-          TrustedPlayerId<Contract, Definitions>
-        >[];
-      }
-  >;
-  projectStatic(): {
-    view: unknown;
-    hash: string;
-    manifestVersion: string;
-  } | null;
-  projectSeatsDynamic(input: {
-    state: TrustedSessionState<Contract>;
-    playerIds: TrustedPlayerId<Contract, Definitions>[];
-    viewId?: string;
-    projectionMode?: "full" | "actionsOnly";
-  }): {
-    currentStage: string | null;
-    stageSeats: string[];
-    simultaneousPhase: {
-      phaseName: string;
-      interactionId: string;
-      actorIds: string[];
-      sealedPlayerIds: string[];
-      pendingPlayerIds: string[];
-    } | null;
-    seats: Record<
-      string,
-      {
-        view?: unknown;
-        availableInteractionRefs: unknown;
-        zones?: unknown;
-      }
-    >;
-    interactionsByRef: Record<string, unknown>;
-  };
-  projectSeatViewDynamic(input: {
-    state: TrustedSessionState<Contract>;
-    playerId: TrustedPlayerId<Contract, Definitions>;
-    viewId?: string;
-  }): unknown;
-};
-
-export type ReducerBundle = ReducerBundleContract & {
-  createInProcessRuntime(): {
-    initialize(input: {
-      table: unknown;
-      playerIds: string[];
-      rngSeed?: number | null;
-      setup?: unknown;
-    }): Promise<void>;
-    hydrate(input: { state: unknown }): void;
-    dispatch(input: {
-      input: unknown;
-    }): Promise<
-      | { kind: "accept" }
-      | { kind: "accept"; state: unknown; trace: unknown[] }
-      | { kind: "reject"; errorCode: string; message?: string }
-    >;
-    projectSeatViewDynamic(input: {
-      playerId: unknown;
-      viewId?: string;
-    }): unknown;
-    projectSeatsDynamic(input: {
-      playerIds: unknown[];
-      viewId?: string;
-      projectionMode?: "full" | "actionsOnly";
-    }): {
-      currentStage: string | null;
-      stageSeats: string[];
-      simultaneousPhase: {
-        phaseName: string;
-        interactionId: string;
-        actorIds: string[];
-        sealedPlayerIds: string[];
-        pendingPlayerIds: string[];
-      } | null;
-      seats: Record<
-        string,
-        {
-          view?: unknown;
-          availableInteractionRefs: unknown;
-          zones?: unknown;
-        }
-      >;
-      interactionsByRef: Record<string, unknown>;
-    };
-    snapshot(): unknown;
-    unsafeState(): unknown;
-  };
-  projectSeatViewDynamic(input: {
-    state: unknown;
-    playerId: unknown;
-    viewId?: string;
-  }): unknown;
-};

package/src/reducer/bundle.ts

@@ -1,2 +0,0 @@
-export { createReducerBundle } from "./bundle/ingress-bundle";
-export type { ReducerBundle } from "./bundle/types";