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

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

@@ -1,150 +0,0 @@
-import type {
-  CollectorState,
-  InputCollector,
-  RandomHelpers,
-  RuntimeRngState,
-  SchemaLike,
-} from "../../model";
-import { nextRandomInt } from "../../rng";
-
-export type RngConsumption = {
-  operation: string;
-  traceEntry: string;
-};
-
-export type MutableRandomHelpers = {
-  random: RandomHelpers;
-  currentRng: () => RuntimeRngState;
-};
-
-export function sampleDieValue(
-  sides: number,
-  rng: RuntimeRngState,
-): {
-  value: number;
-  nextRng: RuntimeRngState;
-  consumption: RngConsumption;
-} {
-  const [offset, nextRng] = nextRandomInt(sides, rng);
-  return {
-    value: offset + 1,
-    nextRng,
-    consumption: {
-      operation: "rollDie",
-      traceEntry: nextRng.trace[nextRng.trace.length - 1] ?? "",
-    },
-  };
-}
-
-export function shuffleWithRng<T>(
-  values: readonly T[],
-  rng: RuntimeRngState,
-  operation:
-    | "shuffleSharedZone"
-    | "shufflePlayerZone"
-    | "randomSubset" = "shuffleSharedZone",
-): {
-  orderedValues: T[];
-  nextRng: RuntimeRngState;
-  consumptions: RngConsumption[];
-} {
-  const orderedValues = [...values];
-  let nextRng = rng;
-  const consumptions: RngConsumption[] = [];
-  for (
-    let lastIndex = orderedValues.length - 1;
-    lastIndex > 0;
-    lastIndex -= 1
-  ) {
-    const [swapIndex, updatedRng] = nextRandomInt(lastIndex + 1, nextRng);
-    consumptions.push({
-      operation,
-      traceEntry: updatedRng.trace[updatedRng.trace.length - 1] ?? "",
-    });
-    nextRng = updatedRng;
-    const current = orderedValues[lastIndex];
-    const swap = orderedValues[swapIndex];
-    if (current === undefined || swap === undefined) {
-      throw new Error(
-        `shuffleWithRng: invalid index (lastIndex=${lastIndex}, swapIndex=${swapIndex}, length=${orderedValues.length})`,
-      );
-    }
-    orderedValues[lastIndex] = swap;
-    orderedValues[swapIndex] = current;
-  }
-  return { orderedValues, nextRng, consumptions };
-}
-
-export function subsetWithRng<T>(
-  values: readonly T[],
-  count: number,
-  rng: RuntimeRngState,
-): {
-  values: readonly T[];
-  nextRng: RuntimeRngState;
-  consumptions: RngConsumption[];
-} {
-  if (!Number.isInteger(count) || count < 0) {
-    throw new Error("random.subset count must be a non-negative integer.");
-  }
-  if (count > values.length) {
-    throw new Error(
-      `random.subset count ${count} exceeds source length ${values.length}.`,
-    );
-  }
-  const shuffled = shuffleWithRng(values, rng, "randomSubset");
-  return {
-    values: shuffled.orderedValues.slice(0, count),
-    nextRng: shuffled.nextRng,
-    consumptions: shuffled.consumptions,
-  };
-}
-
-export function createMutableRandomHelpers(
-  rng: RuntimeRngState,
-): MutableRandomHelpers {
-  let current = rng;
-  return {
-    random: {
-      subset(options) {
-        const sampled = subsetWithRng(options.from, options.count, current);
-        current = sampled.nextRng;
-        return sampled.values;
-      },
-    },
-    currentRng: () => current,
-  };
-}
-
-export function sampleRngCollectorValue(
-  collector: InputCollector<SchemaLike<unknown>, CollectorState, "rng">,
-  rng: RuntimeRngState,
-): { value: unknown; nextRng: RuntimeRngState } {
-  const meta = collector.meta;
-  switch (meta.rng) {
-    case "d6": {
-      const count = meta.count > 0 ? meta.count : 1;
-      const values: number[] = [];
-      let nextRng = rng;
-      for (let i = 0; i < count; i += 1) {
-        const sampled = sampleDieValue(6, nextRng);
-        values.push(sampled.value);
-        nextRng = sampled.nextRng;
-      }
-      return { value: { values }, nextRng };
-    }
-    case "coin": {
-      const [offset, nextRng] = nextRandomInt(2, rng);
-      return {
-        value: { value: offset === 0 ? "heads" : "tails" },
-        nextRng,
-      };
-    }
-    default: {
-      const _exhaustive: never = meta;
-      throw new Error(
-        `Unknown rngInput kind '${String(_exhaustive)}'. Register a sampler in trusted rng-sampler.`,
-      );
-    }
-  }
-}

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

@@ -1,120 +0,0 @@
-import type {
-  AnyContinuationCallable,
-  BaseGameStateOfContract,
-  ManifestContractOf,
-  PhaseMapOf,
-  PhaseNamesOfDefinition,
-  ReducerGameContractLike,
-  ReducerGameDefinition,
-  ViewMapOf,
-} from "../../model";
-import {
-  collectReducerDefinitionIndex,
-  type ReducerDefinitionPhaseIndex,
-  type ReducerIndexedCardActionEntry,
-  type ReducerIndexedInteractionEntry,
-  type ReducerIndexedPhase,
-  type ReducerIndexedStageEntry,
-  type ReducerIndexedZoneEntry,
-} from "../../definition-index";
-
-export type TrustedErasedPhase<Contract extends ReducerGameContractLike> =
-  ReducerIndexedPhase<Contract>;
-
-export type TrustedInteractionEntry<Contract extends ReducerGameContractLike> =
-  ReducerIndexedInteractionEntry<Contract>;
-
-export type TrustedCardActionEntry<Contract extends ReducerGameContractLike> =
-  ReducerIndexedCardActionEntry<Contract>;
-
-export type TrustedStageEntry<Contract extends ReducerGameContractLike> =
-  ReducerIndexedStageEntry<Contract>;
-
-export type TrustedZoneEntry<Contract extends ReducerGameContractLike> =
-  ReducerIndexedZoneEntry<Contract>;
-
-export type TrustedContinuationRegistry<
-  Contract extends ReducerGameContractLike,
-> = ReadonlyMap<
-  string,
-  AnyContinuationCallable<BaseGameStateOfContract<Contract>>
->;
-
-export interface TrustedPhaseRegistry<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
-> extends Omit<
-  ReducerDefinitionPhaseIndex<Contract, Definitions, Views>,
-  "effects"
-> {}
-
-export interface TrustedRuntimeRegistry<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
-> {
-  readonly phaseEntries: ReadonlyArray<
-    readonly [
-      PhaseNamesOfDefinition<
-        ReducerGameDefinition<Contract, Definitions, Views>
-      >,
-      TrustedErasedPhase<Contract>,
-    ]
-  >;
-  readonly phasesByName: ReadonlyMap<
-    PhaseNamesOfDefinition<ReducerGameDefinition<Contract, Definitions, Views>>,
-    TrustedPhaseRegistry<Contract, Definitions, Views>
-  >;
-  readonly continuationsById: TrustedContinuationRegistry<Contract>;
-  readonly effectsById: ReadonlyMap<
-    string,
-    { readonly id: string; readonly type: string }
-  >;
-}
-
-export function collectTrustedRuntimeRegistry<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(
-  definition: ReducerGameDefinition<Contract, Definitions, Views>,
-): TrustedRuntimeRegistry<Contract, Definitions, Views> {
-  type State = BaseGameStateOfContract<Contract>;
-  type PhaseName = PhaseNamesOfDefinition<
-    ReducerGameDefinition<Contract, Definitions, Views>
-  >;
-
-  const index = collectReducerDefinitionIndex(definition);
-  const phasesByName = new Map<
-    PhaseName,
-    TrustedPhaseRegistry<Contract, Definitions, Views>
-  >();
-  const continuationsById = new Map<string, AnyContinuationCallable<State>>();
-  const effectsById = new Map<
-    string,
-    { readonly id: string; readonly type: string }
-  >();
-
-  for (const phaseIndex of index.phasesByName.values()) {
-    const { effects: _effects, ...trustedPhase } = phaseIndex;
-    phasesByName.set(phaseIndex.phaseName, trustedPhase);
-    for (const [, effect] of phaseIndex.effects) {
-      effectsById.set(effect.id, { id: effect.id, type: effect.type });
-      if (effect.continuation) {
-        const continuationId = effect.continuation.id ?? effect.id;
-        continuationsById.set(
-          continuationId,
-          effect.continuation as AnyContinuationCallable<State>,
-        );
-      }
-    }
-  }
-
-  return {
-    phaseEntries: index.phaseEntries,
-    phasesByName,
-    continuationsById,
-    effectsById,
-  };
-}

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

@@ -1,336 +0,0 @@
-import { createDerivedResolver } from "../../derived";
-import type { DerivedResolver } from "../../derived";
-import { createReducerFx } from "../../effects";
-import { createReducerOps } from "../../ops";
-import { createReducerEdit } from "../../transaction";
-import { createStateQueries } from "../../table-queries";
-import type { TrustedRuntimeInput } from "../../core/types";
-import type { RuntimeInstructionForState } from "../../core/runtime-instruction";
-import type {
-  ActionContext,
-  AnyContinuationCallable,
-  AnyInteractionSpec,
-  BaseGameSessionOfContract,
-  BaseGameStateOfContract,
-  ManifestContractOf,
-  PhaseMapOf,
-  PhaseNamesOfDefinition,
-  PlayerIdOfState,
-  PlayerZoneIdOfManifest,
-  RandomHelpers,
-  ReducerGameContractLike,
-  ReducerGameDefinition,
-  StageSpec,
-  TableQueriesOfState,
-  ViewMapOf,
-} from "../../model";
-import {
-  collectTrustedRuntimeRegistry,
-  type TrustedErasedPhase,
-  type TrustedCardActionEntry,
-  type TrustedInteractionEntry,
-  type TrustedPhaseRegistry,
-  type TrustedRuntimeRegistry,
-} from "./runtime-registry";
-import {
-  buildContext as buildTrustedContext,
-  buildRuntimeArgs as buildTrustedRuntimeArgs,
-  fxForState as trustedFxForState,
-} from "./trusted-runtime-args";
-import {
-  normalizeResult,
-  rejectResult,
-  runtimeResultHelpers,
-} from "./trusted-runtime-result";
-import {
-  toCombinedState as codecToCombinedState,
-  toDomainState as codecToDomainState,
-  toSessionState as codecToSessionState,
-} from "./trusted-state-codec";
-import {
-  resolveDefaultInitialPhase,
-  resolveTrustedSetupProfiles,
-} from "./trusted-setup-profiles";
-
-export { normalizeResult, rejectResult } from "./trusted-runtime-result";
-
-export type TrustedDefinition<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
-> = ReducerGameDefinition<Contract, Definitions, Views>;
-
-export type TrustedDomainState<Contract extends ReducerGameContractLike> =
-  BaseGameStateOfContract<Contract>;
-
-export type TrustedSessionState<Contract extends ReducerGameContractLike> =
-  BaseGameSessionOfContract<Contract>;
-
-export type TrustedState<Contract extends ReducerGameContractLike> =
-  TrustedDomainState<Contract> & {
-    runtime: TrustedSessionState<Contract>["runtime"];
-  };
-
-export type TrustedManifest<Contract extends ReducerGameContractLike> =
-  ManifestContractOf<Contract>;
-
-export type TrustedPhaseName<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
-> = PhaseNamesOfDefinition<TrustedDefinition<Contract, Definitions, Views>>;
-
-export type TrustedPlayerId<Contract extends ReducerGameContractLike> =
-  PlayerIdOfState<TrustedDomainState<Contract>>;
-
-export type TrustedInput<Contract extends ReducerGameContractLike> =
-  TrustedRuntimeInput<TrustedPlayerId<Contract>>;
-
-export type { TrustedErasedPhase } from "./runtime-registry";
-
-export interface TrustedRuntimeHelpers<
-  Contract extends ReducerGameContractLike,
-> {
-  accept: (
-    state: TrustedDomainState<Contract>,
-    instructions?: Array<
-      RuntimeInstructionForState<TrustedDomainState<Contract>>
-    >,
-  ) => {
-    type: "accept";
-    state: TrustedDomainState<Contract>;
-    instructions: Array<
-      RuntimeInstructionForState<TrustedDomainState<Contract>>
-    >;
-  };
-  reject: typeof rejectResult;
-  ops: ReturnType<typeof createReducerOps<TrustedDomainState<Contract>>>;
-  edit: ReturnType<typeof createReducerEdit<TrustedDomainState<Contract>>>;
-}
-
-export interface TrustedRuntimeScope<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
-> {
-  definition: TrustedDefinition<Contract, Definitions, Views>;
-  registry: TrustedRuntimeRegistry<Contract, Definitions, Views>;
-  phaseEntries: ReadonlyArray<
-    readonly [
-      TrustedPhaseName<Contract, Definitions, Views>,
-      TrustedErasedPhase<Contract>,
-    ]
-  >;
-  defaultInitialPhase: TrustedPhaseName<Contract, Definitions, Views>;
-  manifestSetupProfilesById: TrustedManifest<Contract>["setupProfilesById"];
-  reducerSetupProfiles: NonNullable<
-    TrustedDefinition<Contract, Definitions, Views>["setupProfiles"]
-  >;
-  runtimeHelpers: TrustedRuntimeHelpers<Contract>;
-  toDomainState(state: TrustedState<Contract>): TrustedDomainState<Contract>;
-  toCombinedState(
-    session: TrustedSessionState<Contract>,
-  ): TrustedState<Contract>;
-  toSessionState(state: TrustedState<Contract>): TrustedSessionState<Contract>;
-  phaseRegistryByName(
-    phaseName: TrustedPhaseName<Contract, Definitions, Views>,
-  ): TrustedPhaseRegistry<Contract, Definitions, Views> | undefined;
-  phaseByName(
-    phaseName: TrustedPhaseName<Contract, Definitions, Views>,
-  ): TrustedErasedPhase<Contract>;
-  findInteractionInPhase(
-    phaseName: TrustedPhaseName<Contract, Definitions, Views>,
-    interactionId: string,
-  ):
-    | AnyInteractionSpec<
-        TrustedDomainState<Contract>,
-        TrustedManifest<Contract>
-      >
-    | undefined;
-  interactionEntriesForPhase(
-    phaseName: TrustedPhaseName<Contract, Definitions, Views>,
-  ): ReadonlyArray<TrustedInteractionEntry<Contract>>;
-  stagesForPhase(
-    phaseName: TrustedPhaseName<Contract, Definitions, Views>,
-  ): ReadonlyArray<
-    readonly [
-      string,
-      StageSpec<TrustedDomainState<Contract>, TrustedManifest<Contract>>,
-    ]
-  >;
-  zonesForPhase(
-    phaseName: TrustedPhaseName<Contract, Definitions, Views>,
-  ): ReadonlyArray<PlayerZoneIdOfManifest<TrustedManifest<Contract>>>;
-  cardActionEntriesForPhase(
-    phaseName: TrustedPhaseName<Contract, Definitions, Views>,
-  ): ReadonlyArray<TrustedCardActionEntry<Contract>>;
-  continuationById(
-    id: string,
-  ): AnyContinuationCallable<TrustedDomainState<Contract>> | undefined;
-  fxForState(
-    state: TrustedState<Contract>,
-  ): ReturnType<typeof createReducerFx<TrustedState<Contract>>>;
-  buildContext(
-    state: TrustedState<Contract>,
-  ): ActionContext<TrustedDomainState<Contract>, TrustedManifest<Contract>>;
-  buildRuntimeArgs<Extra extends object>(
-    state: TrustedState<Contract>,
-    extra: Extra,
-    options?: {
-      q?: TableQueriesOfState<TrustedDomainState<Contract>>;
-      derived?: DerivedResolver;
-      fx?: ReturnType<typeof createReducerFx<TrustedState<Contract>>>;
-      random?: RandomHelpers;
-    },
-  ): ActionContext<TrustedDomainState<Contract>, TrustedManifest<Contract>> &
-    TrustedRuntimeHelpers<Contract> & {
-      fx: ReturnType<typeof createReducerFx<TrustedState<Contract>>>;
-      q: ReturnType<typeof createStateQueries<TrustedDomainState<Contract>>>;
-      derived: ReturnType<
-        typeof createDerivedResolver<TrustedDomainState<Contract>>
-      >;
-      runtime: Omit<TrustedState<Contract>["runtime"], "rng">;
-      random: RandomHelpers;
-    } & Extra;
-}
-
-export function createTrustedRuntimeScope<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(
-  definition: TrustedDefinition<Contract, Definitions, Views>,
-): TrustedRuntimeScope<Contract, Definitions, Views> {
-  type DomainState = TrustedDomainState<Contract>;
-  type SessionState = TrustedSessionState<Contract>;
-  type State = TrustedState<Contract>;
-  type Manifest = TrustedManifest<Contract>;
-  type PhaseName = TrustedPhaseName<Contract, Definitions, Views>;
-  const registry = collectTrustedRuntimeRegistry(definition);
-  const { phaseEntries } = registry;
-  const defaultInitialPhase = resolveDefaultInitialPhase(
-    definition.initialPhase as PhaseName | undefined,
-    phaseEntries,
-  );
-  const { manifestSetupProfilesById, reducerSetupProfiles } =
-    resolveTrustedSetupProfiles(definition);
-
-  function toDomainState(state: State): DomainState {
-    return codecToDomainState<State, DomainState>(state);
-  }
-
-  function toCombinedState(session: SessionState): State {
-    return codecToCombinedState<SessionState, State>(session);
-  }
-
-  function toSessionState(state: State): SessionState {
-    return codecToSessionState<State, DomainState, SessionState>(
-      state,
-      toDomainState,
-    );
-  }
-
-  function phaseRegistryByName(
-    phaseName: PhaseName,
-  ): TrustedPhaseRegistry<Contract, Definitions, Views> | undefined {
-    return registry.phasesByName.get(phaseName);
-  }
-
-  function phaseByName(phaseName: PhaseName): TrustedErasedPhase<Contract> {
-    const phaseRegistry = phaseRegistryByName(phaseName);
-    if (!phaseRegistry) {
-      throw new Error(`Unknown reducer phase '${phaseName}'.`);
-    }
-    return phaseRegistry.phase;
-  }
-
-  function findInteractionInPhase(
-    phaseName: PhaseName,
-    interactionId: string,
-  ): AnyInteractionSpec<DomainState, Manifest> | undefined {
-    const found = interactionEntriesForPhase(phaseName).find(
-      ([id]) => id === interactionId,
-    );
-    return found?.[1];
-  }
-
-  function interactionEntriesForPhase(phaseName: PhaseName) {
-    return phaseRegistryByName(phaseName)?.interactions ?? [];
-  }
-
-  function stagesForPhase(phaseName: PhaseName) {
-    return phaseRegistryByName(phaseName)?.stages ?? [];
-  }
-
-  function zonesForPhase(phaseName: PhaseName) {
-    return phaseRegistryByName(phaseName)?.zones ?? [];
-  }
-
-  function cardActionEntriesForPhase(phaseName: PhaseName) {
-    return phaseRegistryByName(phaseName)?.cardActions ?? [];
-  }
-
-  function continuationById(id: string) {
-    return registry.continuationsById.get(id);
-  }
-
-  const helpers: TrustedRuntimeHelpers<Contract> = {
-    ...runtimeResultHelpers,
-    ops: createReducerOps<DomainState>(),
-    edit: createReducerEdit<DomainState>(),
-  };
-
-  function fxForState(state: State) {
-    return trustedFxForState<Contract>(state);
-  }
-
-  function buildContext(state: State): ActionContext<DomainState, Manifest> {
-    return buildTrustedContext<Contract>(state, definition.contract.manifest);
-  }
-
-  function buildRuntimeArgs<Extra extends object>(
-    state: State,
-    extra: Extra,
-    options?: {
-      q?: TableQueriesOfState<DomainState>;
-      derived?: DerivedResolver;
-      fx?: ReturnType<typeof createReducerFx<State>>;
-      random?: RandomHelpers;
-    },
-  ) {
-    return buildTrustedRuntimeArgs<Contract, Extra>(
-      state,
-      definition.contract.manifest,
-      helpers,
-      toDomainState,
-      extra,
-      options,
-    );
-  }
-
-  return {
-    definition,
-    registry,
-    phaseEntries,
-    defaultInitialPhase,
-    manifestSetupProfilesById,
-    reducerSetupProfiles: reducerSetupProfiles as NonNullable<
-      TrustedDefinition<Contract, Definitions, Views>["setupProfiles"]
-    >,
-    runtimeHelpers: helpers,
-    toDomainState,
-    toCombinedState,
-    toSessionState,
-    phaseRegistryByName,
-    phaseByName,
-    findInteractionInPhase,
-    interactionEntriesForPhase,
-    stagesForPhase,
-    zonesForPhase,
-    cardActionEntriesForPhase,
-    continuationById,
-    fxForState,
-    buildContext,
-    buildRuntimeArgs,
-  };
-}

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

@@ -1,97 +0,0 @@
-import type {
-  AnyInteractionSpec,
-  PhaseMapOf,
-  ReducerGameContractLike,
-  ViewMapOf,
-} from "../../model";
-import type { ProjectionContext } from "./projection-context";
-import type {
-  TrustedDomainState,
-  TrustedManifest,
-  TrustedPlayerId,
-  TrustedRuntimeScope,
-  TrustedState,
-} from "./runtime-scope";
-
-export const SIMULTANEOUS_SUBMIT_INTERACTION_ID = "submit";
-
-type ErasedPhase<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
-> = ReturnType<
-  TrustedRuntimeScope<Contract, Definitions, Views>["phaseByName"]
->;
-
-export function isSimultaneousPhase<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(phase: ErasedPhase<Contract, Definitions, Views>): boolean {
-  return phase.kind === "simultaneousPlayer";
-}
-
-export function simultaneousSubmitInteraction<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(
-  phase: ErasedPhase<Contract, Definitions, Views>,
-):
-  | AnyInteractionSpec<TrustedDomainState<Contract>, TrustedManifest<Contract>>
-  | undefined {
-  return (phase as { submit?: unknown }).submit as
-    | AnyInteractionSpec<
-        TrustedDomainState<Contract>,
-        TrustedManifest<Contract>
-      >
-    | undefined;
-}
-
-function resolvePromptToArray<PlayerId extends string>(
-  value: unknown,
-): PlayerId[] {
-  if (value === undefined || value === null) return [];
-  if (Array.isArray(value)) return value as PlayerId[];
-  if (typeof value === "string") return [value as PlayerId];
-  return [];
-}
-
-export function resolveSimultaneousActors<
-  Contract extends ReducerGameContractLike,
-  Definitions extends PhaseMapOf<Contract>,
-  Views extends ViewMapOf<Contract>,
->(
-  scope: TrustedRuntimeScope<Contract, Definitions, Views>,
-  state: TrustedState<Contract>,
-  phase: ErasedPhase<Contract, Definitions, Views>,
-  projection?: ProjectionContext<
-    TrustedDomainState<Contract>,
-    TrustedState<Contract>
-  >,
-): TrustedPlayerId<Contract>[] {
-  type PlayerId = TrustedPlayerId<Contract>;
-  const selector =
-    (phase as { actors?: unknown; actor?: unknown }).actors ??
-    (phase as { actor?: unknown }).actor;
-  if (typeof selector === "function") {
-    const selected = selector(
-      scope.buildRuntimeArgs(
-        state,
-        {
-          state: projection?.domainState ?? scope.toDomainState(state),
-        },
-        projection,
-      ),
-    );
-    const resolved = resolvePromptToArray<PlayerId>(selected);
-    if (resolved.length > 0) {
-      return resolved;
-    }
-  }
-  const active = state.flow.activePlayers as PlayerId[];
-  if (active.length > 0) {
-    return [...active];
-  }
-  return [...(state.table.playerOrder as PlayerId[])];
-}