@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-run/task-scheduler/admission-core/compiled-graph.ts

@@ -0,0 +1,321 @@
+import type { PlannedTask, PlannedTaskGraph } from "../graph.ts";
+
+interface RelationStaticIndexes {
+  readonly reverseDependencies: readonly (readonly number[])[];
+  readonly reverseMutexOccurrences: readonly (readonly number[])[];
+  readonly reverseObservations: readonly (readonly number[])[];
+}
+
+interface ReverseRelationIndexes {
+  readonly reverseDependencies: readonly (readonly number[])[];
+  readonly reverseObservations: readonly (readonly number[])[];
+}
+
+export interface CompiledAdmissionGraph {
+  readonly graph: PlannedTaskGraph;
+  readonly maxParallel: number;
+  readonly mutexSlotById: ReadonlyMap<string, number>;
+  readonly resourceCapacityBySlot: readonly number[];
+  readonly resourceSlotById: ReadonlyMap<string, number>;
+  readonly scopesById: ReadonlyMap<string, PlannedTaskGraph["scopes"][number]>;
+  readonly scopeSlotById: ReadonlyMap<string, number>;
+  readonly scopeSlotsByTerminalTaskSlot: readonly (readonly number[])[];
+  readonly taskById: ReadonlyMap<string, PlannedTask>;
+  readonly taskMutexSlots: readonly (readonly number[])[];
+  readonly taskResourceClaims: readonly (readonly Readonly<{
+    readonly resourceSlot: number;
+    readonly units: number;
+  }>[])[];
+  readonly taskActivatesScope: readonly boolean[];
+  readonly taskScopeSlots: readonly (number | undefined)[];
+  readonly taskSlotsById: ReadonlyMap<string, number>;
+  readonly taskIdsInPublicOrder: readonly string[];
+  readonly taskSlotsInPublicOrder: readonly number[];
+  readonly relationIndexes: RelationStaticIndexes;
+}
+
+interface GraphSlotCatalog {
+  readonly scopesById: ReadonlyMap<string, PlannedTaskGraph["scopes"][number]>;
+  readonly scopeSlotById: ReadonlyMap<string, number>;
+  readonly taskById: ReadonlyMap<string, PlannedTask>;
+  readonly taskSlotsById: ReadonlyMap<string, number>;
+}
+
+interface MutexStaticIndexes {
+  readonly mutexSlotById: ReadonlyMap<string, number>;
+  readonly reverseMutexOccurrences: readonly (readonly number[])[];
+  readonly taskMutexSlots: readonly (readonly number[])[];
+}
+
+interface ResourceStaticIndexes {
+  readonly resourceCapacityBySlot: readonly number[];
+  readonly resourceSlotById: ReadonlyMap<string, number>;
+  readonly taskResourceClaims: CompiledAdmissionGraph["taskResourceClaims"];
+}
+
+interface ScopeStaticIndexes {
+  readonly scopeSlotsByTerminalTaskSlot: readonly (readonly number[])[];
+  readonly taskActivatesScope: readonly boolean[];
+  readonly taskScopeSlots: readonly (number | undefined)[];
+}
+
+interface PublicTaskOrder {
+  readonly taskIdsInPublicOrder: readonly string[];
+  readonly taskSlotsInPublicOrder: readonly number[];
+}
+
+interface CompiledAdmissionGraphParts {
+  readonly catalog: GraphSlotCatalog;
+  readonly graph: PlannedTaskGraph;
+  readonly maxParallel: number;
+  readonly mutexIndexes: MutexStaticIndexes;
+  readonly publicTaskOrder: PublicTaskOrder;
+  readonly relationIndexes: ReverseRelationIndexes;
+  readonly resourceIndexes: ResourceStaticIndexes;
+  readonly scopeIndexes: ScopeStaticIndexes;
+}
+
+/** Compiles a Scheduler-owned normalized graph once for an actual scheduler invocation. */
+export function compilePreparedAdmissionGraph(
+  graph: PlannedTaskGraph,
+  maxParallel: number
+): CompiledAdmissionGraph {
+  assertMaxParallel(maxParallel);
+  const catalog = compileGraphSlotCatalog(graph);
+  const mutexIndexes = compileMutexStaticIndexes(graph);
+  const relationIndexes = compileRelationStaticIndexes(graph, catalog.taskSlotsById);
+  const resourceIndexes = compileResourceStaticIndexes(graph);
+  const scopeIndexes = compileScopeStaticIndexes(graph, catalog);
+  const publicTaskOrder = compilePublicTaskOrder(graph, catalog.taskSlotsById);
+
+  return assembleCompiledAdmissionGraph({
+    catalog,
+    graph,
+    maxParallel,
+    mutexIndexes,
+    publicTaskOrder,
+    relationIndexes,
+    resourceIndexes,
+    scopeIndexes
+  });
+}
+
+function compileResourceStaticIndexes(graph: PlannedTaskGraph): ResourceStaticIndexes {
+  const resourceSlotById = new Map(
+    graph.resourceCapacities.map(({ resourceId }, slot) => [resourceId, slot] as const)
+  );
+  const resourceCapacityBySlot = Object.freeze(graph.resourceCapacities.map(({ units }) => units));
+  const taskResourceClaims = Object.freeze(
+    graph.tasks.map((task) =>
+      Object.freeze(
+        task.resourceClaims.map(({ resourceId, units }) => {
+          const resourceSlot = resourceSlotById.get(resourceId);
+          if (resourceSlot === undefined) {
+            throw new Error(`admission core resource is unknown: ${resourceId}`);
+          }
+          return Object.freeze({ resourceSlot, units });
+        })
+      )
+    )
+  );
+  return { resourceCapacityBySlot, resourceSlotById, taskResourceClaims };
+}
+
+function assertMaxParallel(maxParallel: number): void {
+  if (!Number.isSafeInteger(maxParallel) || maxParallel <= 0) {
+    throw new TypeError("task engine maxParallel must be a positive safe integer");
+  }
+}
+
+/** Creates declaration-slot catalogs without materializing another prepared graph. */
+function compileGraphSlotCatalog(graph: PlannedTaskGraph): GraphSlotCatalog {
+  return {
+    taskSlotsById: new Map(graph.tasks.map((task, slot) => [task.id, slot] as const)),
+    taskById: new Map(graph.tasks.map((task) => [task.id, task] as const)),
+    scopeSlotById: new Map(graph.scopes.map((scope, slot) => [scope.id, slot] as const)),
+    scopesById: new Map(graph.scopes.map((scope) => [scope.id, scope] as const))
+  };
+}
+
+/** Allocates mutex slots by first declaration occurrence, then records every task occurrence. */
+function compileMutexStaticIndexes(graph: PlannedTaskGraph): MutexStaticIndexes {
+  const mutexSlotById = new Map<string, number>();
+  const taskMutexSlots = graph.tasks.map((task) => mutexSlotsForTask(task, mutexSlotById));
+  const reverseMutexOccurrences = Array.from({ length: mutexSlotById.size }, () => [] as number[]);
+
+  for (const [taskSlot, mutexSlots] of taskMutexSlots.entries()) {
+    for (const mutexSlot of mutexSlots) reverseMutexOccurrences[mutexSlot]?.push(taskSlot);
+  }
+
+  return {
+    mutexSlotById,
+    reverseMutexOccurrences: freezeSlotLists(reverseMutexOccurrences),
+    taskMutexSlots: freezeSlotLists(taskMutexSlots)
+  };
+}
+
+function mutexSlotsForTask(task: PlannedTask, mutexSlotById: Map<string, number>): number[] {
+  return task.mutex.map((mutexId) => mutexSlotFor(mutexSlotById, mutexId));
+}
+
+function mutexSlotFor(mutexSlotById: Map<string, number>, mutexId: string): number {
+  const existingSlot = mutexSlotById.get(mutexId);
+  if (existingSlot !== undefined) return existingSlot;
+
+  const nextSlot = mutexSlotById.size;
+  mutexSlotById.set(mutexId, nextSlot);
+  return nextSlot;
+}
+
+/** Reverses relation occurrences while retaining the declared occurrence order for core transitions. */
+function compileRelationStaticIndexes(
+  graph: PlannedTaskGraph,
+  taskSlotsById: ReadonlyMap<string, number>
+): ReverseRelationIndexes {
+  const reverseDependencies = emptyTaskSlotLists(graph);
+  const reverseObservations = emptyTaskSlotLists(graph);
+
+  for (const [taskSlot, task] of graph.tasks.entries()) {
+    appendReverseRelationOccurrences(
+      task.dependsOn,
+      taskSlot,
+      taskSlotsById,
+      reverseDependencies,
+      "dependency"
+    );
+    appendReverseRelationOccurrences(
+      task.observes,
+      taskSlot,
+      taskSlotsById,
+      reverseObservations,
+      "observation"
+    );
+  }
+
+  return {
+    reverseDependencies: freezeSlotLists(reverseDependencies),
+    reverseObservations: freezeSlotLists(reverseObservations)
+  };
+}
+
+function appendReverseRelationOccurrences(
+  sourceTaskIds: readonly string[],
+  targetTaskSlot: number,
+  taskSlotsById: ReadonlyMap<string, number>,
+  reverseSlotsBySourceTask: number[][],
+  relationName: "dependency" | "observation"
+): void {
+  for (const sourceTaskId of sourceTaskIds) {
+    const sourceTaskSlot = taskSlotsById.get(sourceTaskId);
+    if (sourceTaskSlot === undefined) {
+      throw new Error(`admission core ${relationName} is unknown: ${sourceTaskId}`);
+    }
+    reverseSlotsBySourceTask[sourceTaskSlot]?.push(targetTaskSlot);
+  }
+}
+
+/** Associates scope terminals and activation candidates with the existing task slots. */
+function compileScopeStaticIndexes(
+  graph: PlannedTaskGraph,
+  catalog: GraphSlotCatalog
+): ScopeStaticIndexes {
+  const scopeSlotsByTerminalTaskSlot = emptyTaskSlotLists(graph);
+
+  for (const [scopeSlot, scope] of graph.scopes.entries()) {
+    const terminalTaskSlot = catalog.taskSlotsById.get(scope.terminalTaskId);
+    if (terminalTaskSlot === undefined) {
+      throw new Error(`admission core scope terminal is unknown: ${scope.terminalTaskId}`);
+    }
+    scopeSlotsByTerminalTaskSlot[terminalTaskSlot]?.push(scopeSlot);
+  }
+  const taskActivatesScope = graph.tasks.map((task) => {
+    const scopeSlot =
+      task.scopeId === undefined ? undefined : catalog.scopeSlotById.get(task.scopeId);
+    return (
+      scopeSlot !== undefined &&
+      graph.scopes[scopeSlot]?.activationTaskIds.includes(task.id) === true
+    );
+  });
+  const taskScopeSlots = graph.tasks.map((task) =>
+    task.scopeId === undefined ? undefined : catalog.scopeSlotById.get(task.scopeId)
+  );
+
+  return {
+    scopeSlotsByTerminalTaskSlot: freezeSlotLists(scopeSlotsByTerminalTaskSlot),
+    taskActivatesScope: Object.freeze(taskActivatesScope),
+    taskScopeSlots: Object.freeze(taskScopeSlots)
+  };
+}
+
+/** Materializes only the lexical catalog projection; declaration slots remain unchanged. */
+function compilePublicTaskOrder(
+  graph: PlannedTaskGraph,
+  taskSlotsById: ReadonlyMap<string, number>
+): PublicTaskOrder {
+  const taskIdsInPublicOrder = Object.freeze(graph.tasks.map((task) => task.id).sort(compareText));
+  return {
+    taskIdsInPublicOrder,
+    taskSlotsInPublicOrder: Object.freeze(
+      taskIdsInPublicOrder.map((taskId) => {
+        const taskSlot = taskSlotsById.get(taskId);
+        if (taskSlot === undefined) {
+          throw new Error(`admission core task is missing from public order: ${taskId}`);
+        }
+        return taskSlot;
+      })
+    )
+  };
+}
+
+/** Freezes the one compiled graph object after every static compiler stage has completed. */
+function assembleCompiledAdmissionGraph(
+  parts: CompiledAdmissionGraphParts
+): CompiledAdmissionGraph {
+  const {
+    catalog,
+    graph,
+    maxParallel,
+    mutexIndexes,
+    publicTaskOrder,
+    relationIndexes,
+    resourceIndexes,
+    scopeIndexes
+  } = parts;
+  return Object.freeze({
+    graph,
+    maxParallel,
+    mutexSlotById: mutexIndexes.mutexSlotById,
+    resourceCapacityBySlot: resourceIndexes.resourceCapacityBySlot,
+    resourceSlotById: resourceIndexes.resourceSlotById,
+    relationIndexes: Object.freeze({
+      reverseDependencies: relationIndexes.reverseDependencies,
+      reverseMutexOccurrences: mutexIndexes.reverseMutexOccurrences,
+      reverseObservations: relationIndexes.reverseObservations
+    }),
+    scopesById: catalog.scopesById,
+    scopeSlotById: catalog.scopeSlotById,
+    scopeSlotsByTerminalTaskSlot: scopeIndexes.scopeSlotsByTerminalTaskSlot,
+    taskById: catalog.taskById,
+    taskIdsInPublicOrder: publicTaskOrder.taskIdsInPublicOrder,
+    taskMutexSlots: mutexIndexes.taskMutexSlots,
+    taskResourceClaims: resourceIndexes.taskResourceClaims,
+    taskActivatesScope: scopeIndexes.taskActivatesScope,
+    taskScopeSlots: scopeIndexes.taskScopeSlots,
+    taskSlotsById: catalog.taskSlotsById,
+    taskSlotsInPublicOrder: publicTaskOrder.taskSlotsInPublicOrder
+  });
+}
+
+function emptyTaskSlotLists(graph: PlannedTaskGraph): number[][] {
+  return graph.tasks.map(() => []);
+}
+
+function freezeSlotLists(slotLists: number[][]): readonly (readonly number[])[] {
+  return Object.freeze(slotLists.map((slots) => Object.freeze(slots)));
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}

package/src/project-run/task-scheduler/admission-core/core.ts

@@ -0,0 +1,278 @@
+import type {
+  AdmissionGraph,
+  AdmissionGraphInput,
+  AdmissionRejectionReason,
+  AdmissionSelectionValidation,
+  AdmissionSelectionValidationRejectionReason,
+  AdmissionSettlementOutcome,
+  AdmissionState,
+  AdmissionTransitionResult
+} from "../../../project-definition/scheduler-policy.ts";
+import { compileAdmissionGraphInput } from "./input.ts";
+import { catalogForCore, inspectionForCore, schedulerInspectionForCore } from "./projection.ts";
+import {
+  admitTaskForCore,
+  createAdmissionCoreFromSchedulerSnapshot,
+  createInitialAdmissionCoreState,
+  nextForcedTaskForCore,
+  settleForcedTaskForCore,
+  settleTaskForCore,
+  type AdmissionCoreState
+} from "./selection.ts";
+import {
+  admissionCandidatesForCore,
+  isCoreComplete,
+  requiredTaskForCore,
+  requiredTaskSlotForCore,
+  scopeToActivateForCore,
+  selectionRejectionForPendingTask,
+  statusForCore,
+  type AdmissionCoreSelection
+} from "./selection-query.ts";
+import type { SchedulerSettlementKind } from "../scheduler-decision-model.ts";
+
+export { compilePreparedAdmissionGraph } from "./compiled-graph.ts";
+export type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+export {
+  admissionCandidatesForCore,
+  createAdmissionCoreFromSchedulerSnapshot,
+  createInitialAdmissionCoreState,
+  schedulerInspectionForCore,
+  scopeToActivateForCore
+};
+export type { AdmissionCoreSelection, AdmissionCoreState };
+
+export type AdmissionCoreEffect =
+  | Readonly<{ readonly kind: "admitted"; readonly taskId: string }>
+  | Readonly<{
+      readonly dependencyIds?: readonly string[];
+      readonly kind: "settled";
+      readonly settlementKind: SchedulerSettlementKind;
+      readonly taskId: string;
+    }>;
+
+export interface AdmissionCoreTransition {
+  /** The immutable post-state for each corresponding canonical effect. */
+  readonly effectStates: readonly AdmissionCoreState[];
+  readonly effects: readonly AdmissionCoreEffect[];
+  readonly state: AdmissionCoreState;
+}
+
+/** 在 exact boundary validation 和一次 static compile 后创建 standalone public factory。 */
+export function createAdmissionGraph(input: AdmissionGraphInput): AdmissionGraph {
+  const compiled = compileAdmissionGraphInput(input);
+  return Object.freeze({
+    initialState: Object.freeze(function initialState(this: void): AdmissionState {
+      return admissionStateForCore(createInitialAdmissionCoreState(compiled));
+    })
+  });
+}
+
+/** The canonical select action used by both the public opaque handle and the real shell. */
+export function selectAdmissionCore(
+  state: AdmissionCoreState,
+  taskId: string
+): Readonly<
+  | { readonly accepted: true; readonly transition: AdmissionCoreTransition }
+  | { readonly accepted: false; readonly reason: AdmissionSelectionValidationRejectionReason }
+> {
+  const validation = validateAdmissionCoreSelection(state, taskId);
+  if (!validation.accepted) return Object.freeze({ accepted: false, reason: validation.reason });
+  const next = admitTaskForCore(state, requiredTaskSlotForCore(state, taskId));
+  return Object.freeze({
+    accepted: true,
+    transition: freezeTransition(next, [Object.freeze({ kind: "admitted", taskId })], [next])
+  });
+}
+
+/** The public binary settlement action. Runtime outcome validation intentionally precedes ID checks. */
+export function settleAdmissionCore(
+  state: AdmissionCoreState,
+  taskId: string,
+  outcome: unknown
+): Readonly<
+  | { readonly accepted: true; readonly transition: AdmissionCoreTransition }
+  | { readonly accepted: false; readonly reason: AdmissionRejectionReason }
+> {
+  if (outcome !== "satisfied" && outcome !== "unsatisfied") {
+    return Object.freeze({
+      accepted: false,
+      reason: Object.freeze({ kind: "invalid-settlement-outcome" })
+    });
+  }
+  return settleRunningAdmissionCore(
+    state,
+    taskId,
+    outcome === "satisfied" ? "completed" : "prerequisite-unsatisfied"
+  );
+}
+
+/** Applies a real running Task settlement through the same reducer, retaining private exact kinds. */
+export function settleRunningAdmissionCore(
+  state: AdmissionCoreState,
+  taskId: string,
+  settlementKind: Extract<
+    SchedulerSettlementKind,
+    "completed" | "prerequisite-unsatisfied" | "failed"
+  >
+): Readonly<
+  | { readonly accepted: true; readonly transition: AdmissionCoreTransition }
+  | { readonly accepted: false; readonly reason: AdmissionRejectionReason }
+> {
+  if (isCoreComplete(state)) {
+    return Object.freeze({ accepted: false, reason: Object.freeze({ kind: "state-complete" }) });
+  }
+  const taskSlot = state.compiled.taskSlotsById.get(taskId);
+  if (taskSlot === undefined) {
+    return Object.freeze({ accepted: false, reason: Object.freeze({ kind: "unknown-task" }) });
+  }
+  const status = statusForCore(state, taskSlot);
+  if (status.kind !== "running") {
+    return Object.freeze({
+      accepted: false,
+      reason: Object.freeze({
+        kind: "not-running",
+        status: status.kind === "pending" ? "pending" : "settled"
+      })
+    });
+  }
+  const settled = settleTaskForCore(state, taskSlot, settlementKind);
+  const directEffect = Object.freeze({ kind: "settled" as const, settlementKind, taskId });
+  return Object.freeze({
+    accepted: true,
+    transition: reconcileForcedBlocks(settled, [directEffect], [settled])
+  });
+}
+
+/** Private cancellation stays in the reducer/effect owner but has no public AdmissionState action. */
+export function cancelPendingAdmissionCore(state: AdmissionCoreState): AdmissionCoreTransition {
+  let next = state;
+  const effects: AdmissionCoreEffect[] = [];
+  const effectStates: AdmissionCoreState[] = [];
+  for (const [slot, task] of state.compiled.graph.tasks.entries()) {
+    if (statusForCore(next, slot).kind !== "pending") continue;
+    next = settleTaskForCore(next, slot, "cancelled-before-start");
+    effects.push(
+      Object.freeze({ kind: "settled", settlementKind: "cancelled-before-start", taskId: task.id })
+    );
+    effectStates.push(next);
+  }
+  return freezeTransition(next, effects, effectStates);
+}
+
+/** Reconciles forced dependency blocks before the real shell publishes its next decision boundary. */
+export function reconcileAdmissionCore(state: AdmissionCoreState): AdmissionCoreTransition {
+  return reconcileForcedBlocks(state, [], []);
+}
+
+export function validateAdmissionCoreSelection(
+  state: AdmissionCoreState,
+  taskId: string
+): AdmissionSelectionValidation {
+  if (isCoreComplete(state)) return rejectedValidation(Object.freeze({ kind: "state-complete" }));
+  const taskSlot = state.compiled.taskSlotsById.get(taskId);
+  if (taskSlot === undefined) return rejectedValidation(Object.freeze({ kind: "unknown-task" }));
+  const status = statusForCore(state, taskSlot);
+  if (status.kind !== "pending") {
+    return rejectedValidation(
+      Object.freeze({
+        kind: "not-pending",
+        status: status.kind === "running" ? "running" : "settled"
+      })
+    );
+  }
+  const reason = selectionRejectionForPendingTask(state, taskSlot);
+  return reason === undefined ? ACCEPTED_SELECTION : rejectedValidation(reason);
+}
+
+/** Constructs the frozen opaque public wrapper. Projection work remains lazy until its getter is read. */
+export function admissionStateForCore(core: AdmissionCoreState): AdmissionState {
+  const select = Object.freeze(function select(
+    this: void,
+    taskId: string
+  ): AdmissionTransitionResult {
+    const selection = selectAdmissionCore(core, taskId);
+    return selection.accepted
+      ? Object.freeze({ accepted: true, state: admissionStateForCore(selection.transition.state) })
+      : Object.freeze({ accepted: false, reason: selection.reason });
+  });
+  const settle = Object.freeze(function settle(
+    this: void,
+    taskId: string,
+    outcome: AdmissionSettlementOutcome
+  ): AdmissionTransitionResult {
+    const settlement = settleAdmissionCore(core, taskId, outcome);
+    return settlement.accepted
+      ? Object.freeze({ accepted: true, state: admissionStateForCore(settlement.transition.state) })
+      : Object.freeze({ accepted: false, reason: settlement.reason });
+  });
+  const validateSelection = Object.freeze(function validateSelection(
+    this: void,
+    taskId: string
+  ): AdmissionSelectionValidation {
+    return validateAdmissionCoreSelection(core, taskId);
+  });
+  return Object.freeze({
+    get catalog() {
+      return catalogForCore(core);
+    },
+    get inspection() {
+      return inspectionForCore(core);
+    },
+    select,
+    settle,
+    validateSelection
+  } satisfies AdmissionState);
+}
+
+const ACCEPTED_SELECTION: AdmissionSelectionValidation = Object.freeze({ accepted: true });
+
+function reconcileForcedBlocks(
+  state: AdmissionCoreState,
+  initialEffects: readonly AdmissionCoreEffect[],
+  initialEffectStates: readonly AdmissionCoreState[]
+): AdmissionCoreTransition {
+  let next = state;
+  const effects = [...initialEffects];
+  const effectStates = [...initialEffectStates];
+  while (true) {
+    const forcedTaskSlot = nextForcedTaskForCore(next);
+    if (forcedTaskSlot === undefined) return freezeTransition(next, effects, effectStates);
+    const task = requiredTaskForCore(next, forcedTaskSlot);
+    const dependencyIds = task.dependsOn.filter((taskId) => {
+      const status = statusForCore(next, requiredTaskSlotForCore(next, taskId));
+      return status.kind === "settled" && status.settlementKind !== "completed";
+    });
+    next = settleForcedTaskForCore(next, forcedTaskSlot);
+    effects.push(
+      Object.freeze({
+        dependencyIds: Object.freeze(dependencyIds),
+        kind: "settled",
+        settlementKind: "blocked",
+        taskId: task.id
+      })
+    );
+    effectStates.push(next);
+  }
+}
+
+function freezeTransition(
+  state: AdmissionCoreState,
+  effects: readonly AdmissionCoreEffect[],
+  effectStates: readonly AdmissionCoreState[]
+): AdmissionCoreTransition {
+  if (effects.length !== effectStates.length) {
+    throw new Error("admission core transition effects must have matching immutable post-states");
+  }
+  return Object.freeze({
+    effectStates: Object.freeze([...effectStates]),
+    effects: Object.freeze([...effects]),
+    state
+  });
+}
+
+function rejectedValidation(
+  reason: AdmissionSelectionValidationRejectionReason
+): AdmissionSelectionValidation {
+  return Object.freeze({ accepted: false, reason });
+}