@zxyycom/vibe-check 0.0.1 → 0.0.2

package/src/project-definition/check-tree/check-fields-authoring.ts

@@ -0,0 +1,227 @@
+import type { CheckDescriptor } from "../../check/descriptor.ts";
+import {
+  type CheckVisibility,
+  type CheckFlagEnablement,
+  type CheckFlagEnablementMode,
+  type CheckExecution,
+  type CheckPreflight
+} from "../../check/check.ts";
+import { validateCheckDescriptor } from "../../check/descriptor-validation.ts";
+import { snapshotJsonObject } from "../../check/options-snapshot.ts";
+import { snapshotClosedRecord } from "../../data-boundary/closed-values.ts";
+import { parseUniqueIdentifiers } from "./collection-authoring.ts";
+
+export type TrustedDataParser = (this: void, ...parameters: never[]) => unknown;
+
+export interface CheckAuthoringData extends Readonly<Record<string, unknown>> {
+  readonly checkId: string;
+  readonly displayName: string;
+}
+
+export interface ParsedCheckFields {
+  readonly definition: CheckDescriptor | null;
+  readonly enabledByFlags: CheckFlagEnablement | null;
+  readonly execution: CheckExecution | null;
+  readonly options: object | null;
+  readonly parseData: TrustedDataParser | null;
+  readonly preflight: CheckPreflight | null;
+  readonly visibility: CheckVisibility | null;
+}
+
+export interface ParsedCheckFieldPrelude {
+  readonly enabledByFlags: CheckFlagEnablement | null;
+  readonly execution: CheckExecution | null;
+  readonly parseData: TrustedDataParser | null;
+  readonly preflight: CheckPreflight | null;
+}
+
+interface ParsedFlagEnablementControl extends Readonly<Record<string, unknown>> {
+  readonly flags: unknown;
+  readonly mode: CheckFlagEnablementMode;
+  readonly propagateDependsOn?: true;
+}
+
+const CHECK_KEYS = [
+  "admissionPriority",
+  "checkId",
+  "checks",
+  "dependsOn",
+  "displayName",
+  "enabledByFlags",
+  "execution",
+  "maxParallel",
+  "mutex",
+  "options",
+  "observes",
+  "parseData",
+  "preflight",
+  "resourceClaims",
+  "visibility"
+] as const;
+const FLAG_ENABLEMENT_KEYS = ["flags", "mode", "propagateDependsOn"] as const;
+
+const CONTAINER_CHECK_FIELDS: ParsedCheckFields = Object.freeze({
+  definition: null,
+  enabledByFlags: null,
+  execution: null,
+  options: null,
+  parseData: null,
+  preflight: null,
+  visibility: null
+});
+
+export function parseCheckAuthoringData(value: unknown): CheckAuthoringData | undefined {
+  const data = snapshotClosedRecord(value);
+  return data !== undefined && hasValidCheckIdentity(data) ? data : undefined;
+}
+
+function hasValidCheckIdentity(
+  data: Readonly<Record<string, unknown>>
+): data is CheckAuthoringData {
+  return (
+    hasOnlyCheckKeys(data) &&
+    typeof data.checkId === "string" &&
+    data.checkId.length > 0 &&
+    typeof data.displayName === "string" &&
+    data.displayName.length > 0
+  );
+}
+
+export function parseCheckFieldPrelude(
+  data: CheckAuthoringData
+): ParsedCheckFieldPrelude | undefined {
+  const execution = parseExecution(data);
+  if (execution === undefined) return undefined;
+  const parseData = parseDataParser(data);
+  if (parseData === undefined) return undefined;
+  const preflight = parsePreflight(data);
+  if (preflight === undefined) return undefined;
+  const enabledByFlags = parseEnabledByFlags(data);
+  return enabledByFlags === undefined
+    ? undefined
+    : Object.freeze({ enabledByFlags, execution, parseData, preflight });
+}
+
+export function parseCheckFields(
+  data: CheckAuthoringData,
+  prelude: ParsedCheckFieldPrelude
+): ParsedCheckFields | undefined {
+  if (prelude.execution === null) {
+    return Object.hasOwn(data, "options") ||
+      Object.hasOwn(data, "enabledByFlags") ||
+      Object.hasOwn(data, "visibility") ||
+      prelude.parseData !== null ||
+      prelude.preflight !== null
+      ? undefined
+      : CONTAINER_CHECK_FIELDS;
+  }
+  const definition = parseDefinition(data);
+  if (definition === undefined) return undefined;
+  const options = parseOptions(data);
+  if (options === undefined) return undefined;
+  const visibility = parseVisibility(data);
+  if (visibility === undefined) return undefined;
+  return Object.freeze({
+    definition,
+    enabledByFlags: prelude.enabledByFlags,
+    execution: prelude.execution,
+    options,
+    parseData: prelude.parseData,
+    preflight: prelude.preflight,
+    visibility
+  });
+}
+
+function hasOnlyCheckKeys(data: Readonly<Record<string, unknown>>): boolean {
+  return Object.keys(data).every((key) => CHECK_KEYS.some((checkKey) => checkKey === key));
+}
+
+function parseExecution(data: CheckAuthoringData): CheckExecution | null | undefined {
+  if (!Object.hasOwn(data, "execution")) return null;
+  return isTrustedFunction<CheckExecution>(data.execution) ? data.execution : undefined;
+}
+
+function parseDataParser(data: CheckAuthoringData): TrustedDataParser | null | undefined {
+  if (!Object.hasOwn(data, "parseData") || data.parseData === undefined) return null;
+  return isTrustedFunction<TrustedDataParser>(data.parseData) ? data.parseData : undefined;
+}
+
+function parsePreflight(data: CheckAuthoringData): CheckPreflight | null | undefined {
+  if (!Object.hasOwn(data, "preflight")) return null;
+  return isTrustedFunction<CheckPreflight>(data.preflight) ? data.preflight : undefined;
+}
+
+function isTrustedFunction<FunctionType extends (...parameters: never[]) => unknown>(
+  value: unknown
+): value is FunctionType {
+  return typeof value === "function";
+}
+
+function parseDefinition(data: CheckAuthoringData): CheckDescriptor | undefined {
+  const definition = validateCheckDescriptor({
+    checkId: data.checkId,
+    displayName: data.displayName
+  });
+  return definition.ok ? definition.value : undefined;
+}
+
+function parseOptions(data: CheckAuthoringData): object | undefined {
+  if (!Object.hasOwn(data, "options")) return Object.freeze({});
+  const options = snapshotClosedRecord(data.options);
+  if (options === undefined) return undefined;
+  return snapshotJsonObject(options);
+}
+
+function parseEnabledByFlags(data: CheckAuthoringData): CheckFlagEnablement | null | undefined {
+  if (!Object.hasOwn(data, "enabledByFlags")) return null;
+  const control = parseFlagEnablementControl(data.enabledByFlags);
+  if (control === undefined) return undefined;
+  const flags = parseUniqueIdentifiers(control.flags);
+  return flags === undefined ? undefined : canonicalFlagEnablement(control, flags);
+}
+
+function parseFlagEnablementControl(value: unknown): ParsedFlagEnablementControl | undefined {
+  const control = snapshotClosedRecord(value);
+  if (control === undefined || !hasOnlyFlagEnablementKeys(control)) return undefined;
+  return hasFlagEnablementFields(control) ? control : undefined;
+}
+
+function hasFlagEnablementFields(
+  control: Readonly<Record<string, unknown>>
+): control is ParsedFlagEnablementControl {
+  if (!Object.hasOwn(control, "flags") || !Object.hasOwn(control, "mode")) return false;
+  if (!isCheckFlagEnablementMode(control.mode)) return false;
+  return !Object.hasOwn(control, "propagateDependsOn") || control.propagateDependsOn === true;
+}
+
+function canonicalFlagEnablement(
+  control: ParsedFlagEnablementControl,
+  flags: readonly string[]
+): CheckFlagEnablement | undefined {
+  const [firstFlag, ...remainingFlags] = [...flags].sort();
+  if (firstFlag === undefined) return undefined;
+  const canonicalFlags: [string, ...string[]] = [firstFlag, ...remainingFlags];
+  return Object.freeze({
+    flags: Object.freeze(canonicalFlags),
+    mode: control.mode,
+    ...(control.propagateDependsOn === true ? { propagateDependsOn: true as const } : {})
+  });
+}
+
+function hasOnlyFlagEnablementKeys(control: Readonly<Record<string, unknown>>): boolean {
+  return Object.keys(control).every((key) =>
+    FLAG_ENABLEMENT_KEYS.some((allowed) => allowed === key)
+  );
+}
+
+function isCheckFlagEnablementMode(value: unknown): value is CheckFlagEnablementMode {
+  return value === "all" || value === "any" || value === "none" || value === "not-all";
+}
+
+function parseVisibility(data: CheckAuthoringData): CheckVisibility | undefined {
+  if (!Object.hasOwn(data, "visibility")) return "always";
+  const visibility = data.visibility;
+  return visibility === undefined || visibility === "always" || visibility === "attention"
+    ? (visibility ?? "always")
+    : undefined;
+}

package/src/project-definition/check-tree/collection-authoring.ts

@@ -0,0 +1,13 @@
+import { snapshotClosedArray } from "../../data-boundary/closed-values.ts";
+
+/** Snapshots one closed array as unique, non-empty authored identifiers. */
+export function parseUniqueIdentifiers(value: unknown): readonly string[] | undefined {
+  const items = snapshotClosedArray(value);
+  if (items === undefined) return undefined;
+  const identifiers: string[] = [];
+  for (const item of items) {
+    if (typeof item !== "string" || item.length === 0) return undefined;
+    if (!identifiers.includes(item)) identifiers.push(item);
+  }
+  return Object.freeze(identifiers);
+}

package/src/project-definition/check-tree/materialization.ts

@@ -13,13 +13,20 @@ function materializeChecks(checks: readonly ParsedCheck[]): readonly Check[] {
 function materializeCheck(check: ParsedCheck): Check {
   const checks = materializeChecks(check.checks);
   const dependsOn = materializeCollection(check.dependsOn);
+  const enabledByFlags = check.enabledByFlags;
   const mutex = materializeCollection(check.mutex);
+  const observes = materializeCollection(check.observes);
   const visibility = check.visibility;
   const preflight = check.preflight;
   const scheduling = {
+    ...(check.admissionPriority === undefined
+      ? {}
+      : { admissionPriority: check.admissionPriority }),
     ...(dependsOn === undefined ? {} : { dependsOn }),
     ...(check.maxParallel === undefined ? {} : { maxParallel: check.maxParallel }),
-    ...(mutex === undefined ? {} : { mutex })
+    ...(mutex === undefined ? {} : { mutex }),
+    ...(observes === undefined ? {} : { observes }),
+    ...(check.resourceClaims === undefined ? {} : { resourceClaims: check.resourceClaims })
   };
   if (
     check.definition === null ||
@@ -38,6 +45,7 @@ function materializeCheck(check: ParsedCheck): Check {
     checkId: check.checkId,
     checks,
     displayName: check.displayName,
+    ...(enabledByFlags === null ? {} : { enabledByFlags }),
     execution: check.execution,
     ...(check.parseData === null ? {} : { parseData: check.parseData }),
     options: check.options,

package/src/project-definition/check-tree/resolution.ts

@@ -1,5 +1,10 @@
 import type { CheckDescriptor } from "../../check/descriptor.ts";
-import type { CheckExecution, CheckPreflight, CheckVisibility } from "../../check/check.ts";
+import type {
+  CheckExecution,
+  CheckFlagEnablement,
+  CheckPreflight,
+  CheckVisibility
+} from "../../check/check.ts";
 import {
   parseCheckTreeAuthoring,
   type MeaninglessCheckWarning,
@@ -7,17 +12,22 @@ import {
   type ParsedCheckCollection,
   type ParsedCheckTree
 } from "./authoring.ts";
+import { EMPTY_RESOURCE_UNIT_MAPPING, type ResourceUnitMapping } from "../resource-unit-mapping.ts";
 
 export type { Check, InheritableCheckCollection } from "../../check/check.ts";
 
 export interface ResolvedCheckTreeLeaf {
+  readonly admissionPriority: number;
   readonly definition: CheckDescriptor;
   readonly dependsOn: readonly string[];
+  readonly enabledByFlags?: CheckFlagEnablement;
   readonly execution: CheckExecution;
   readonly maxParallel: number;
   readonly mutex: readonly string[];
+  readonly observes: readonly string[];
   readonly options: object;
   readonly preflight?: CheckPreflight;
+  readonly resourceClaims: ResourceUnitMapping;
   readonly visibility: CheckVisibility;
 }
 
@@ -27,9 +37,12 @@ export interface ResolvedCheckTree {
 }
 
 interface InheritedScheduling {
+  readonly admissionPriority: number;
   readonly dependsOn: readonly string[];
   readonly maxParallel: number;
   readonly mutex: readonly string[];
+  readonly observes: readonly string[];
+  readonly resourceClaims: ResourceUnitMapping;
 }
 
 /**
@@ -39,37 +52,70 @@ interface InheritedScheduling {
  */
 export function resolveCheckTree(
   value: unknown,
-  rootMaxParallel: number
+  rootMaxParallel: number,
+  resourceCapacities: ResourceUnitMapping = EMPTY_RESOURCE_UNIT_MAPPING
 ): ResolvedCheckTree | undefined {
   const parsed = parseCheckTreeAuthoring(value);
-  return parsed === undefined ? undefined : resolveParsedCheckTree(parsed, rootMaxParallel);
+  return parsed === undefined
+    ? undefined
+    : resolveParsedCheckTree(parsed, rootMaxParallel, resourceCapacities);
 }
 
 export function resolveParsedCheckTree(
   parsed: ParsedCheckTree,
-  rootMaxParallel: number
+  rootMaxParallel: number,
+  resourceCapacities: ResourceUnitMapping = EMPTY_RESOURCE_UNIT_MAPPING
 ): ResolvedCheckTree | undefined {
   if (!Number.isSafeInteger(rootMaxParallel) || rootMaxParallel <= 0) return undefined;
   const leaves: ResolvedCheckTreeLeaf[] = [];
   const root: InheritedScheduling = Object.freeze({
+    admissionPriority: 0,
     dependsOn: Object.freeze([]),
     maxParallel: rootMaxParallel,
-    mutex: Object.freeze([])
+    mutex: Object.freeze([]),
+    observes: Object.freeze([]),
+    resourceClaims: EMPTY_RESOURCE_UNIT_MAPPING
   });
-  for (const check of parsed.checks) flattenCheck(check, root, leaves);
+  for (const check of parsed.checks) {
+    if (!flattenCheck(check, root, resourceCapacities, leaves)) return undefined;
+  }
   return Object.freeze({ leaves: Object.freeze(leaves), warnings: parsed.warnings });
 }
 
 function flattenCheck(
   check: ParsedCheck,
   inherited: InheritedScheduling,
+  resourceCapacities: ResourceUnitMapping,
   leaves: ResolvedCheckTreeLeaf[]
-): void {
-  const scheduling: InheritedScheduling = Object.freeze({
+): boolean {
+  const scheduling = resolveScheduling(check, inherited);
+  if (!claimsFitCapacities(scheduling.resourceClaims, resourceCapacities)) return false;
+  const leaf = resolvedLeafFor(check, scheduling);
+  if (leaf !== undefined) leaves.push(leaf);
+  for (const child of check.checks) {
+    if (!flattenCheck(child, scheduling, resourceCapacities, leaves)) return false;
+  }
+  return true;
+}
+
+function resolveScheduling(
+  check: ParsedCheck,
+  inherited: InheritedScheduling
+): InheritedScheduling {
+  return Object.freeze({
+    admissionPriority: check.admissionPriority ?? inherited.admissionPriority,
     dependsOn: resolveCollection(inherited.dependsOn, check.dependsOn),
     maxParallel: check.maxParallel ?? inherited.maxParallel,
-    mutex: resolveCollection(inherited.mutex, check.mutex)
+    mutex: resolveCollection(inherited.mutex, check.mutex),
+    observes: resolveCollection(inherited.observes, check.observes),
+    resourceClaims: check.resourceClaims ?? inherited.resourceClaims
   });
+}
+
+function resolvedLeafFor(
+  check: ParsedCheck,
+  scheduling: InheritedScheduling
+): ResolvedCheckTreeLeaf | undefined {
   const visibility = check.visibility;
   if (
     check.execution !== null &&
@@ -77,20 +123,32 @@ function flattenCheck(
     check.options !== null &&
     visibility !== null
   ) {
-    leaves.push(
-      Object.freeze({
-        definition: check.definition,
-        dependsOn: scheduling.dependsOn,
-        execution: check.execution,
-        maxParallel: scheduling.maxParallel,
-        mutex: scheduling.mutex,
-        options: check.options,
-        ...(check.preflight === null ? {} : { preflight: check.preflight }),
-        visibility
-      })
-    );
+    return Object.freeze({
+      admissionPriority: scheduling.admissionPriority,
+      definition: check.definition,
+      dependsOn: scheduling.dependsOn,
+      ...(check.enabledByFlags === null ? {} : { enabledByFlags: check.enabledByFlags }),
+      execution: check.execution,
+      maxParallel: scheduling.maxParallel,
+      mutex: scheduling.mutex,
+      observes: scheduling.observes,
+      options: check.options,
+      ...(check.preflight === null ? {} : { preflight: check.preflight }),
+      resourceClaims: scheduling.resourceClaims,
+      visibility
+    });
   }
-  for (const child of check.checks) flattenCheck(child, scheduling, leaves);
+  return undefined;
+}
+
+function claimsFitCapacities(
+  claims: ResourceUnitMapping,
+  capacities: ResourceUnitMapping
+): boolean {
+  return Object.entries(claims).every(
+    ([resourceId, units]) =>
+      Object.hasOwn(capacities, resourceId) && units <= (capacities[resourceId] ?? 0)
+  );
 }
 
 function resolveCollection(

package/src/project-definition/check-tree/scheduling-authoring.ts

@@ -0,0 +1,114 @@
+import {
+  isInheritedCheckCollection,
+  snapshotInheritedCheckCollection,
+  type InheritedCheckCollection
+} from "../../check/check.ts";
+import { parseUniqueIdentifiers } from "./collection-authoring.ts";
+import { snapshotResourceUnitMapping, type ResourceUnitMapping } from "../resource-unit-mapping.ts";
+
+export type ParsedCheckCollection = Readonly<
+  | { readonly kind: "exact"; readonly values: readonly string[] }
+  | {
+      readonly kind: "inherit";
+      readonly add: readonly string[];
+      readonly remove: readonly string[];
+    }
+>;
+
+export type ParsedCheckScheduling = Readonly<{
+  readonly admissionPriority: number | undefined;
+  readonly dependsOn: ParsedCheckCollection | undefined;
+  readonly maxParallel: number | undefined;
+  readonly mutex: ParsedCheckCollection | undefined;
+  readonly observes: ParsedCheckCollection | undefined;
+  readonly resourceClaims: ResourceUnitMapping | undefined;
+}>;
+
+/** Parses the closed relation, priority, and capacity fields for one authored Check. */
+export function parseCheckScheduling(
+  data: Readonly<Record<string, unknown>>
+): ParsedCheckScheduling | undefined {
+  const dependsOn = parseCollection(data, "dependsOn");
+  const mutex = parseCollection(data, "mutex");
+  const observes = parseCollection(data, "observes");
+  const admissionPriority = parseAdmissionPriority(data.admissionPriority);
+  const maxParallel = parseMaxParallel(data.maxParallel);
+  const resourceClaims =
+    data.resourceClaims === undefined
+      ? undefined
+      : snapshotResourceUnitMapping(data.resourceClaims);
+  if (dependsOn === null || mutex === null || observes === null) return undefined;
+  if (
+    admissionPriority === null ||
+    maxParallel === null ||
+    (data.resourceClaims !== undefined && resourceClaims === undefined)
+  ) {
+    return undefined;
+  }
+  return resolvedScheduling({
+    admissionPriority,
+    dependsOn,
+    maxParallel,
+    mutex,
+    observes,
+    resourceClaims
+  });
+}
+
+function resolvedScheduling(
+  scheduling: Readonly<{
+    readonly admissionPriority: number | undefined;
+    readonly dependsOn: ParsedCheckCollection | undefined;
+    readonly maxParallel: number | undefined;
+    readonly mutex: ParsedCheckCollection | undefined;
+    readonly observes: ParsedCheckCollection | undefined;
+    readonly resourceClaims: ResourceUnitMapping | undefined;
+  }>
+): ParsedCheckScheduling {
+  return Object.freeze({
+    admissionPriority: scheduling.admissionPriority,
+    dependsOn: scheduling.dependsOn ?? undefined,
+    maxParallel: scheduling.maxParallel,
+    mutex: scheduling.mutex ?? undefined,
+    observes: scheduling.observes ?? undefined,
+    resourceClaims: scheduling.resourceClaims
+  });
+}
+
+function parseAdmissionPriority(value: unknown): number | null | undefined {
+  if (value === undefined) return undefined;
+  return typeof value === "number" && Number.isSafeInteger(value) ? value : null;
+}
+
+function parseMaxParallel(value: unknown): number | null | undefined {
+  if (value === undefined) return undefined;
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+
+function parseCollection(
+  data: Readonly<Record<string, unknown>>,
+  field: "dependsOn" | "mutex" | "observes"
+): ParsedCheckCollection | null | undefined {
+  if (!Object.hasOwn(data, field)) return undefined;
+  const value = data[field];
+  if (isInheritedCheckCollection(value)) return parseInheritedCollection(value);
+  const values = parseUniqueIdentifiers(value);
+  return values === undefined ? null : Object.freeze({ kind: "exact", values });
+}
+
+function parseInheritedCollection(
+  value: InheritedCheckCollection<unknown>
+): ParsedCheckCollection | null {
+  const data = snapshotInheritedCheckCollection(value);
+  if (data === undefined || !hasExactInheritedKeys(data)) return null;
+  const add = data.add === undefined ? Object.freeze([]) : parseUniqueIdentifiers(data.add);
+  const remove =
+    data.remove === undefined ? Object.freeze([]) : parseUniqueIdentifiers(data.remove);
+  if (add === undefined || remove === undefined) return null;
+  return Object.freeze({ kind: "inherit", add, remove });
+}
+
+function hasExactInheritedKeys(data: Readonly<Record<string, unknown>>): boolean {
+  const keys = Object.keys(data);
+  return keys.length > 0 && keys.every((key) => key === "add" || key === "remove");
+}

package/src/project-definition/declarative-snapshot.ts

@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+
+import type { AdmissionPolicy, DeclarativeSchedulerPolicy } from "./scheduler-policy.ts";
+import type {
+  DeclarativeProjectOutputs,
+  DeclarativeProjectSnapshot,
+  NormalizedCheck,
+  ProjectDefinition
+} from "./project-definition.ts";
+import { resolveProgressRenderingOutput } from "./output-defaults.ts";
+import { isNonArrayRecord } from "../data-boundary/value-shapes.ts";
+
+/**
+ * Produces the immutable, callback-free Definition identity consumed by fingerprinting.
+ */
+export function createDeclarativeProjectSnapshot(
+  definition: ProjectDefinition,
+  checks: readonly NormalizedCheck[]
+): DeclarativeProjectSnapshot {
+  const declarations = checks
+    .map(({ execution: _execution, preflight: _preflight, ...declaration }) => declaration)
+    .sort((left, right) => compareText(left.definition.checkId, right.definition.checkId));
+  return deepFreeze({
+    apiVersion: definition.apiVersion,
+    checks: declarations,
+    outputs: declarativeOutputs(definition),
+    scheduler: Object.freeze({
+      admissionPolicy: declarativeAdmissionPolicy(definition.scheduler.admissionPolicy),
+      maxParallel: definition.scheduler.maxParallel,
+      resourceCapacities: definition.scheduler.resourceCapacities
+    })
+  });
+}
+
+function declarativeOutputs(definition: ProjectDefinition): DeclarativeProjectOutputs {
+  const progressRendering = resolveProgressRenderingOutput(definition.outputs.progressRendering);
+  return Object.freeze({
+    diagnosticLogging: definition.outputs.diagnosticLogging,
+    machinePublication: definition.outputs.machinePublication,
+    progressRendering: Object.freeze({
+      enabled: progressRendering.enabled,
+      formatter: progressRendering.formatter === null ? "default" : "custom",
+      messagePreviewLimit: progressRendering.messagePreviewLimit,
+      recordPreviewLimit: progressRendering.recordPreviewLimit,
+      textPreviewCodePointLimit: progressRendering.textPreviewCodePointLimit
+    })
+  });
+}
+
+/** Generates the stable SHA-256 fingerprint for one declarative Definition snapshot. */
+export function createDeclarativeFingerprint(snapshot: DeclarativeProjectSnapshot): string {
+  return createHash("sha256").update(stableJson(snapshot)).digest("hex");
+}
+
+function declarativeAdmissionPolicy(
+  policy: AdmissionPolicy
+): DeclarativeSchedulerPolicy["admissionPolicy"] {
+  if (policy.kind === "custom") {
+    return Object.freeze({
+      kind: "custom" as const,
+      strategy: Object.freeze({ kind: policy.strategy.kind })
+    });
+  }
+  return Object.freeze({ kind: "static" as const });
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+
+function deepFreeze<T>(value: T): T {
+  if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+  for (const item of Object.values(value)) deepFreeze(item);
+  return Object.freeze(value);
+}
+
+function stableJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (isNonArrayRecord(value))
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
+      .join(",")}}`;
+  return JSON.stringify(value);
+}

package/src/project-definition/output-defaults.ts

@@ -1,6 +1,37 @@
+import type {
+  ProgressRenderingOutput,
+  ResolvedProgressRenderingOutput
+} from "./progress-rendering-output.ts";
+
 /** Default Run-owned output values applied when a Project Definition omits an override. */
 export const DEFAULT_PROJECT_OUTPUTS = Object.freeze({
   machinePublication: Object.freeze({ directory: "artifacts/vibe-check", enabled: true }),
-  progressRendering: Object.freeze({ enabled: true }),
+  progressRendering: Object.freeze({
+    enabled: true,
+    formatter: null,
+    messagePreviewLimit: 5,
+    recordPreviewLimit: 5,
+    textPreviewCodePointLimit: 240
+  }),
   diagnosticLogging: Object.freeze({ directory: ".log/vibe-check", enabled: false })
 } as const);
+
+/** Materializes compatible progress authoring into the single renderer-ready policy. */
+export function resolveProgressRenderingOutput(
+  output: Partial<ProgressRenderingOutput>
+): ResolvedProgressRenderingOutput {
+  const {
+    enabled = DEFAULT_PROJECT_OUTPUTS.progressRendering.enabled,
+    formatter = DEFAULT_PROJECT_OUTPUTS.progressRendering.formatter,
+    messagePreviewLimit = DEFAULT_PROJECT_OUTPUTS.progressRendering.messagePreviewLimit,
+    recordPreviewLimit = DEFAULT_PROJECT_OUTPUTS.progressRendering.recordPreviewLimit,
+    textPreviewCodePointLimit = DEFAULT_PROJECT_OUTPUTS.progressRendering.textPreviewCodePointLimit
+  } = output;
+  return Object.freeze({
+    enabled,
+    formatter,
+    messagePreviewLimit,
+    recordPreviewLimit,
+    textPreviewCodePointLimit
+  });
+}