@zxyycom/vibe-check 0.0.1 → 0.0.3

package/src/project-definition/project-definition-validation.ts

@@ -5,16 +5,32 @@ import { parseOutputs } from "./output-validation.ts";
 import {
   type ProjectDefinitionDiagnostic,
   type ProjectDefinitionValidationResult,
+  type AdmissionPolicy,
+  type CustomAdmissionStrategy,
+  type NormalizedCheck,
+  type SchedulerTerminalEffect,
   type SchedulerPolicy
 } from "./project-definition.ts";
-import { snapshotClosedArray, snapshotClosedRecord } from "../data-boundary/closed-values.ts";
+import {
+  snapshotClosedArray,
+  snapshotClosedPolicyRecord,
+  snapshotClosedRecord
+} from "../data-boundary/closed-values.ts";
+import { snapshotResourceUnitMapping } from "./resource-unit-mapping.ts";
+import { parseProjectChangesConfiguration } from "./project-changes.ts";
 
 type DefinitionValidationResult<T> = Readonly<
   | { readonly ok: true; readonly value: T }
   | { readonly ok: false; readonly error: ProjectDefinitionDiagnostic }
 >;
 
-const PROJECT_DEFINITION_KEYS = ["apiVersion", "checks", "outputs", "scheduler"] as const;
+const PROJECT_DEFINITION_KEYS = [
+  "apiVersion",
+  "changes",
+  "checks",
+  "outputs",
+  "scheduler"
+] as const;
 
 /**
  * Validates one closed Definition before Run can invoke any project callback.
@@ -39,12 +55,25 @@ function parseProjectDefinitionFields(
 ): ProjectDefinitionValidationResult {
   const scheduler = parseScheduler(data.scheduler);
   if (scheduler === undefined) return invalidDefinition("definition.scheduler");
+  const changes = Object.hasOwn(data, "changes")
+    ? parseProjectChangesConfiguration(data.changes)
+    : undefined;
+  if (Object.hasOwn(data, "changes") && changes === undefined) {
+    return invalidDefinition("definition.changes");
+  }
   const checks = snapshotClosedArray(data.checks);
   if (checks === undefined) return invalidDefinition("definition.checks");
   const parsedChecks = parseCheckTreeAuthoring(checks);
   if (parsedChecks === undefined) return invalidDefinition("definition.checks");
-  const tree = resolveParsedCheckTree(parsedChecks, scheduler.maxParallel);
+  const tree = resolveParsedCheckTree(
+    parsedChecks,
+    scheduler.maxParallel,
+    scheduler.resourceCapacities
+  );
   if (tree === undefined) return invalidDefinition("definition.checks");
+  if (!hasOnlyKnownChangeFlagReferences(tree.leaves, changes)) {
+    return invalidDefinition("definition.checks");
+  }
   const outputs = parseOutputs(data.outputs);
   if (outputs === undefined) return invalidDefinition("definition.outputs");
   return Object.freeze({
@@ -52,6 +81,7 @@ function parseProjectDefinitionFields(
     value: {
       apiVersion: "1" as const,
       checks: materializeCheckTreeAuthoring(parsedChecks),
+      ...(changes === undefined ? {} : { changes }),
       outputs,
       scheduler
     },
@@ -59,6 +89,36 @@ function parseProjectDefinitionFields(
   });
 }
 
+function hasOnlyKnownChangeFlagReferences(
+  checks: readonly NormalizedCheck[],
+  changes: ReturnType<typeof parseProjectChangesConfiguration>
+): boolean {
+  return checks.every(
+    (check) =>
+      check.enabledByFlags === undefined ||
+      hasOnlyKnownChangeFlagConditionReferences(check.enabledByFlags.when, changes)
+  );
+}
+
+function hasOnlyKnownChangeFlagConditionReferences(
+  condition: import("../check/check.ts").CheckFlagCondition,
+  changes: ReturnType<typeof parseProjectChangesConfiguration>
+): boolean {
+  if (typeof condition === "string") {
+    const prefix = "vibe-check:change:";
+    return (
+      !condition.startsWith(prefix) ||
+      (changes !== undefined && Object.hasOwn(changes.flags, condition.slice(prefix.length)))
+    );
+  }
+  if (condition.kind === "not") {
+    return hasOnlyKnownChangeFlagConditionReferences(condition.condition, changes);
+  }
+  return condition.conditions.every((child) =>
+    hasOnlyKnownChangeFlagConditionReferences(child, changes)
+  );
+}
+
 function exactProjectDefinition(
   value: unknown
 ): DefinitionValidationResult<Readonly<Record<string, unknown>>> {
@@ -88,29 +148,113 @@ function exactRecord(
 }
 
 function parseScheduler(value: unknown): SchedulerPolicy | undefined {
-  const data = exactKeys(value, ["maxParallel"]);
-  return typeof data?.maxParallel === "number" &&
-    Number.isSafeInteger(data.maxParallel) &&
-    data.maxParallel > 0
-    ? Object.freeze({ maxParallel: data.maxParallel })
-    : undefined;
+  const data = snapshotClosedPolicyRecord(value, {
+    optional: ["admissionPolicy", "terminalEffects", "resourceCapacities"],
+    required: ["maxParallel"]
+  });
+  if (data === undefined) return undefined;
+  const admissionPolicy = Object.hasOwn(data, "admissionPolicy")
+    ? parseAdmissionPolicy(data.admissionPolicy)
+    : Object.freeze({ kind: "static" as const });
+  if (admissionPolicy === undefined) return undefined;
+  const terminalEffects = parseTerminalEffects(data.terminalEffects);
+  if (terminalEffects === undefined) return undefined;
+  const resourceCapacities = snapshotResourceUnitMapping(
+    Object.hasOwn(data, "resourceCapacities") ? data.resourceCapacities : {}
+  );
+  if (resourceCapacities === undefined) return undefined;
+  const maxParallel = positiveSafeInteger(data.maxParallel);
+  if (maxParallel === undefined) return undefined;
+  return Object.freeze({ admissionPolicy, maxParallel, terminalEffects, resourceCapacities });
 }
 
-function exactKeys(
-  value: unknown,
-  keys: readonly string[]
-): Readonly<Record<string, unknown>> | undefined {
+function positiveSafeInteger(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+function parseTerminalEffects(value: unknown): readonly SchedulerTerminalEffect[] | undefined {
+  if (value === undefined) return Object.freeze([]);
+  if (!Array.isArray(value)) return undefined;
+  const hooks: SchedulerTerminalEffect[] = [];
+  for (const hook of value) {
+    if (!isTerminalEffect(hook)) return undefined;
+    hooks.push(hook);
+  }
+  return Object.freeze(hooks);
+}
+
+function isTerminalEffect(value: unknown): value is SchedulerTerminalEffect {
+  return typeof value === "function";
+}
+
+function parseAdmissionPolicy(value: unknown): AdmissionPolicy | undefined {
   const data = snapshotClosedRecord(value);
-  if (data === undefined) return undefined;
-  return Object.keys(data).length === keys.length && keys.every((key) => Object.hasOwn(data, key))
-    ? data
-    : undefined;
+  if (data === undefined || typeof data.kind !== "string") return undefined;
+  switch (data.kind) {
+    case "static":
+      return parseStaticAdmissionPolicy(data);
+    case "custom":
+      return parseCustomAdmissionPolicy(data);
+  }
+  return undefined;
+}
+
+function parseStaticAdmissionPolicy(
+  policy: Readonly<Record<string, unknown>>
+): Extract<AdmissionPolicy, { readonly kind: "static" }> | undefined {
+  return hasExactKeys(policy, ["kind"]) ? Object.freeze({ kind: "static" }) : undefined;
+}
+
+function parseCustomAdmissionPolicy(
+  policy: Readonly<Record<string, unknown>>
+): Extract<AdmissionPolicy, { readonly kind: "custom" }> | undefined {
+  if (!hasExactKeys(policy, ["kind", "strategy"])) return undefined;
+  const strategy = parseCustomAdmissionStrategy(policy.strategy);
+  return strategy === undefined ? undefined : Object.freeze({ kind: "custom", strategy });
+}
+
+function parseCustomAdmissionStrategy(value: unknown): CustomAdmissionStrategy | undefined {
+  const strategy = snapshotClosedRecord(value);
+  if (strategy === undefined || typeof strategy.kind !== "string") return undefined;
+  if (strategy.kind === "simple") {
+    if (!hasExactKeys(strategy, ["kind", "decide"])) return undefined;
+    if (!isSimpleCustomDecision(strategy.decide)) return undefined;
+    return Object.freeze({ kind: "simple" as const, decide: strategy.decide });
+  }
+  if (strategy.kind === "prepared") {
+    if (!hasExactKeys(strategy, ["kind", "prepare"])) return undefined;
+    if (!isPreparedCustomPreparation(strategy.prepare)) return undefined;
+    return Object.freeze({ kind: "prepared" as const, prepare: strategy.prepare });
+  }
+  return undefined;
+}
+
+function isSimpleCustomDecision(
+  value: unknown
+): value is Extract<CustomAdmissionStrategy, { readonly kind: "simple" }>["decide"] {
+  return typeof value === "function";
+}
+
+function isPreparedCustomPreparation(
+  value: unknown
+): value is Extract<CustomAdmissionStrategy, { readonly kind: "prepared" }>["prepare"] {
+  return typeof value === "function";
+}
+
+function hasExactKeys(value: Readonly<Record<string, unknown>>, keys: readonly string[]): boolean {
+  return (
+    Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key))
+  );
 }
 
 function invalidDefinition(path: string): ProjectDefinitionValidationResult {
   return Object.freeze({
     ok: false,
-    error: Object.freeze({ kind: "invalid-project-definition", path, reason: "invalid-value" })
+    error: Object.freeze({
+      kind: "invalid-project-definition",
+      path,
+      reason: "invalid-value"
+    })
   });
 }
 
@@ -119,5 +263,8 @@ function invalid(
   path: string,
   reason: ProjectDefinitionDiagnostic["reason"]
 ): DefinitionValidationResult<never> {
-  return Object.freeze({ ok: false, error: Object.freeze({ kind, path, reason }) });
+  return Object.freeze({
+    ok: false,
+    error: Object.freeze({ kind, path, reason })
+  });
 }

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

@@ -1,49 +1,134 @@
-import { createHash } from "node:crypto";
-
 import { resolveCheckTree, type ResolvedCheckTreeLeaf } from "./check-tree/resolution.ts";
 import type { MeaninglessCheckWarning } from "./check-tree/authoring.ts";
 import type { CheckDescriptor } from "../check/descriptor.ts";
-import type { Check, CheckExecution, CheckPreflight, CheckVisibility } from "../check/check.ts";
-import { DEFAULT_PROJECT_OUTPUTS } from "./output-defaults.ts";
-import { isNonArrayRecord } from "../data-boundary/value-shapes.ts";
+import type {
+  Check,
+  CheckPreparation,
+  CheckResourceClaims,
+  CheckFlagEnablement
+} from "../check/check.ts";
+import type { HandoffProviderIdentity } from "../check/handoff-provider-identity.ts";
+import { DEFAULT_PROJECT_OUTPUTS, resolveProgressRenderingOutput } from "./output-defaults.ts";
+import type {
+  ProgressRenderingOutput,
+  ResolvedProgressRenderingOutput
+} from "./progress-rendering-output.ts";
+import { createDeclarativeProjectSnapshot } from "./declarative-snapshot.ts";
+import {
+  EMPTY_RESOURCE_UNIT_MAPPING,
+  snapshotResourceUnitMapping
+} from "./resource-unit-mapping.ts";
+import {
+  parseProjectChangesConfiguration,
+  type NormalizedProjectChangesConfiguration,
+  type ProjectChangesConfiguration
+} from "./project-changes.ts";
+export { createDeclarativeFingerprint } from "./declarative-snapshot.ts";
 
 /** 一次 Project Run 的明确输出配置。 */
 export interface ProjectOutputs {
   /** `run.json` 与 `records.ndjson` publication。 */
   readonly machinePublication: Readonly<{
-    /** 相对目录以 project root 解析，默认 `artifacts/vibe-check`。 */
+    /** 相对目录从 project root 解析；绝对目录直接作为 target，默认 `artifacts/vibe-check`。 */
     readonly directory: string;
     /** `false` 时本次 Run 不发布 machine output。 */
     readonly enabled: boolean;
   }>;
-  /** 人读 progress rendering。 */
-  readonly progressRendering: Readonly<{
-    /** `false` 时不构造或写入 progress writer。 */
-    readonly enabled: boolean;
-  }>;
+  /** 人读 progress lifecycle 与 preview 配置。 */
+  readonly progressRendering: ProgressRenderingOutput;
   /** 仅供维护者读取的一次 invocation diagnostic log。 */
   readonly diagnosticLogging: Readonly<{
-    /** 相对目录以 project root 解析，默认 `.log/vibe-check`。 */
+    /** 相对目录从 project root 解析；绝对目录直接作为 target，默认 `.log/vibe-check`。 */
     readonly directory: string;
     /** `false` 时不创建 diagnostic writer 或 file。 */
     readonly enabled: boolean;
   }>;
 }
 
-/** 定义级的 Check 调度预算。 */
-export interface SchedulerPolicy {
-  readonly maxParallel: number;
+export type {
+  ProgressPreviewFormatter,
+  ProgressRenderingOutput,
+  ResolvedProgressRenderingOutput
+} from "./progress-rendering-output.ts";
+
+/** 已解析的 Run outputs；只在 Product invocation 内部使用。 */
+export interface ResolvedProjectOutputs extends Omit<ProjectOutputs, "progressRendering"> {
+  readonly progressRendering: ResolvedProgressRenderingOutput;
 }
-/** 已补齐默认 outputs、可交给 run 执行的项目定义。 */
+
+/** callback-free Definition output 投影；仅供 declarative fingerprint 使用。 */
+export interface DeclarativeProjectOutputs extends Omit<ProjectOutputs, "progressRendering"> {
+  readonly progressRendering: Readonly<{
+    readonly enabled: boolean;
+    readonly formatter: "custom" | "default";
+    readonly messagePreviewLimit: number;
+    readonly recordPreviewLimit: number;
+    readonly textPreviewCodePointLimit: number;
+  }>;
+}
+
+export type {
+  AdmissionPolicy,
+  AdmissionPolicyContext,
+  AdmissionPolicyMeasurement,
+  AdmissionProposal,
+  AdmissionCatalog,
+  AdmissionGraph,
+  AdmissionGraphInput,
+  AdmissionInspection,
+  AdmissionNonSelectableTask,
+  AdmissionRejectionReason,
+  AdmissionScopeLifecycle,
+  AdmissionSelectionRejectionReason,
+  AdmissionSelectionValidation,
+  AdmissionSelectionValidationRejectionReason,
+  AdmissionSettlementOutcome,
+  AdmissionSettledTask,
+  AdmissionState,
+  AdmissionTransitionResult,
+  CustomAdmissionPreparationContext,
+  CustomAdmissionStrategy,
+  PreparedCustomAdmissionStrategy,
+  SchedulerDecisionMeasurementCumulative,
+  SchedulerGraphSnapshot,
+  SchedulerMeasurementActionObservation,
+  SchedulerMeasurementActionObservationInterval,
+  SchedulerMeasurementAdmission,
+  SchedulerMeasurementContext,
+  SchedulerMeasurementEffect,
+  SchedulerTerminalEffect,
+  SchedulerMeasurementIntervalContribution,
+  SchedulerMeasurementPeakCounts,
+  SchedulerMeasurementTiming,
+  SchedulerMeasurementTimingFacts,
+  SchedulerMeasurementTimingUnavailableReason,
+  SchedulerPolicy,
+  SchedulerRawMeasurement
+} from "./scheduler-policy.ts";
+import type {
+  AdmissionPolicy,
+  DeclarativeSchedulerPolicy,
+  SchedulerPolicy
+} from "./scheduler-policy.ts";
+
+/**
+ * `defineConfig(...)` 形成的可重复运行项目定义：声明检查内容、调度方式与默认输出。
+ *
+ * 本次 root、flags、signal、Check 产物与日志目标以及显式 aggregation 交给 `run` 的第二个参数；
+ * 其中的 output overrides 只改变当前调用，不修改这里的默认值。
+ */
 export interface ProjectDefinition {
   readonly apiVersion: "1";
   readonly checks: readonly Check[];
+  /** 可选的静态 Git comparison 与本次 Run 的 change-flag regions。 */
+  readonly changes?: ProjectChangesConfiguration;
   readonly outputs: ProjectOutputs;
   readonly scheduler: SchedulerPolicy;
 }
 type ProjectDefinitionInput = Readonly<{
   apiVersion?: "1";
   checks?: readonly Check[];
+  changes?: ProjectChangesConfiguration;
   outputs?: Partial<{
     machinePublication: Partial<ProjectOutputs["machinePublication"]>;
     progressRendering: Partial<ProjectOutputs["progressRendering"]>;
@@ -66,28 +151,41 @@ export type ProjectDefinitionValidationResult = Readonly<
   | { readonly ok: false; readonly error: ProjectDefinitionDiagnostic }
 >;
 export interface NormalizedCheckDeclaration {
+  readonly admissionPriority: number;
   readonly definition: CheckDescriptor;
   readonly dependsOn: readonly string[];
+  /** Definition 已验证、snapshot 并冻结的单一 recursive flag-condition control。 */
+  readonly enabledByFlags?: CheckFlagEnablement;
   readonly maxParallel: number;
   readonly mutex: readonly string[];
+  readonly observes: readonly string[];
   readonly options: object;
-  readonly visibility: CheckVisibility;
+  readonly resourceClaims: CheckResourceClaims;
+  readonly omitQuietPassedRow: boolean;
 }
 export interface NormalizedCheck extends NormalizedCheckDeclaration {
-  readonly execution: CheckExecution;
-  readonly preflight?: CheckPreflight;
+  readonly execute: NonNullable<Check["execute"]>;
+  readonly handoff?: HandoffProviderIdentity;
+  readonly prepare?: CheckPreparation;
 }
 export interface DeclarativeProjectSnapshot {
   readonly apiVersion: "1";
   readonly checks: readonly NormalizedCheckDeclaration[];
-  readonly outputs: ProjectOutputs;
-  readonly scheduler: SchedulerPolicy;
+  readonly changes?: NormalizedProjectChangesConfiguration;
+  readonly outputs: DeclarativeProjectOutputs;
+  readonly scheduler: DeclarativeSchedulerPolicy;
 }
 export interface NormalizedProjectDefinition {
   readonly checks: readonly NormalizedCheck[];
+  readonly changes?: NormalizedProjectChangesConfiguration;
   readonly declarative: DeclarativeProjectSnapshot;
   readonly definitionWarnings: readonly DefinitionWarning[];
+  /** Runtime scheduler policy；custom callback 保留在此处。 */
+  readonly scheduler: SchedulerPolicy;
 }
+const STATIC_ADMISSION_POLICY: AdmissionPolicy = Object.freeze({
+  kind: "static"
+});
 /** 使用 Product 默认输出创建普通 Project Definition。 */
 export function defineConfig<const T extends ProjectDefinitionInput>(
   value: T & Record<Exclude<keyof T, keyof ProjectDefinitionInput>, never>
@@ -95,6 +193,7 @@ export function defineConfig<const T extends ProjectDefinitionInput>(
   return {
     apiVersion: value.apiVersion ?? "1",
     checks: value.checks ?? [],
+    ...(value.changes === undefined ? {} : { changes: value.changes }),
     outputs: {
       machinePublication: {
         directory:
@@ -104,11 +203,7 @@ export function defineConfig<const T extends ProjectDefinitionInput>(
           value.outputs?.machinePublication?.enabled ??
           DEFAULT_PROJECT_OUTPUTS.machinePublication.enabled
       },
-      progressRendering: {
-        enabled:
-          value.outputs?.progressRendering?.enabled ??
-          DEFAULT_PROJECT_OUTPUTS.progressRendering.enabled
-      },
+      progressRendering: resolveProgressRenderingOutput(value.outputs?.progressRendering ?? {}),
       diagnosticLogging: {
         directory:
           value.outputs?.diagnosticLogging?.directory ??
@@ -118,67 +213,82 @@ export function defineConfig<const T extends ProjectDefinitionInput>(
           DEFAULT_PROJECT_OUTPUTS.diagnosticLogging.enabled
       }
     },
-    scheduler: { maxParallel: value.scheduler?.maxParallel ?? 4 }
+    scheduler: {
+      admissionPolicy: value.scheduler?.admissionPolicy ?? STATIC_ADMISSION_POLICY,
+      maxParallel: value.scheduler?.maxParallel ?? 4,
+      terminalEffects: value.scheduler?.terminalEffects ?? [],
+      resourceCapacities: value.scheduler?.resourceCapacities ?? EMPTY_RESOURCE_UNIT_MAPPING
+    }
   };
 }
 export function normalizeProjectDefinition(
   definition: ProjectDefinition
 ): NormalizedProjectDefinition {
-  const tree = resolveCheckTree(definition.checks, definition.scheduler.maxParallel);
+  const scheduler = normalizeSchedulerPolicy(definition.scheduler);
+  const tree = resolveCheckTree(
+    definition.checks,
+    scheduler.maxParallel,
+    scheduler.resourceCapacities
+  );
   if (tree === undefined)
     throw new TypeError("Project Definition Check tree failed closed normalization");
   const checks = Object.freeze(tree.leaves.map(normalizeCheck));
+  const changes =
+    definition.changes === undefined
+      ? undefined
+      : parseProjectChangesConfiguration(definition.changes);
+  if (definition.changes !== undefined && changes === undefined) {
+    throw new TypeError("Project Definition changes failed closed normalization");
+  }
+  const { changes: _authoredChanges, ...baseDefinition } = definition;
+  const normalizedDefinition = Object.freeze({
+    ...baseDefinition,
+    ...(changes === undefined ? {} : { changes }),
+    scheduler
+  });
   return Object.freeze({
     checks,
-    declarative: freezeDeclarativeSnapshot(definition, checks),
-    definitionWarnings: tree.warnings
+    ...(changes === undefined ? {} : { changes }),
+    declarative: createDeclarativeProjectSnapshot(normalizedDefinition, checks),
+    definitionWarnings: tree.warnings,
+    scheduler
   });
 }
 function normalizeCheck(leaf: ResolvedCheckTreeLeaf): NormalizedCheck {
   return Object.freeze({
+    admissionPriority: leaf.admissionPriority,
     definition: leaf.definition,
     dependsOn: leaf.dependsOn,
-    execution: leaf.execution,
+    ...(leaf.enabledByFlags === undefined ? {} : { enabledByFlags: leaf.enabledByFlags }),
+    execute: leaf.execute,
+    ...(leaf.handoff === undefined ? {} : { handoff: leaf.handoff }),
     maxParallel: leaf.maxParallel,
     mutex: leaf.mutex,
+    observes: leaf.observes,
     options: leaf.options,
-    ...(leaf.preflight === undefined ? {} : { preflight: leaf.preflight }),
-    visibility: leaf.visibility
+    ...(leaf.prepare === undefined ? {} : { prepare: leaf.prepare }),
+    resourceClaims: leaf.resourceClaims,
+    omitQuietPassedRow: leaf.omitQuietPassedRow
   });
 }
-export function createDeclarativeFingerprint(snapshot: DeclarativeProjectSnapshot): string {
-  return createHash("sha256").update(stableJson(snapshot)).digest("hex");
-}
-function freezeDeclarativeSnapshot(
-  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: definition.outputs,
-    scheduler: definition.scheduler
+function normalizeSchedulerPolicy(policy: SchedulerPolicy): SchedulerPolicy {
+  const resourceCapacities = snapshotResourceUnitMapping(policy.resourceCapacities);
+  if (resourceCapacities === undefined) {
+    throw new TypeError("Project Definition scheduler resource capacities failed normalization");
+  }
+  let admissionPolicy: AdmissionPolicy;
+  if (policy.admissionPolicy.kind === "static") {
+    admissionPolicy = STATIC_ADMISSION_POLICY;
+  } else {
+    admissionPolicy = Object.freeze({
+      kind: "custom" as const,
+      strategy: Object.freeze({ ...policy.admissionPolicy.strategy })
+    });
+  }
+  return Object.freeze({
+    admissionPolicy,
+    maxParallel: policy.maxParallel,
+    terminalEffects: Object.freeze([...policy.terminalEffects]),
+    resourceCapacities
   });
 }
-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/resource-unit-mapping.ts

@@ -0,0 +1,25 @@
+import { snapshotClosedRecord } from "../data-boundary/closed-values.ts";
+
+export type ResourceUnitMapping = Readonly<Record<string, number>>;
+
+export const EMPTY_RESOURCE_UNIT_MAPPING: ResourceUnitMapping = Object.freeze({});
+
+/** Snapshots a canonical closed resource-to-positive-units mapping. */
+export function snapshotResourceUnitMapping(value: unknown): ResourceUnitMapping | undefined {
+  const data = snapshotClosedRecord(value);
+  if (data === undefined) return undefined;
+  const entries: [string, number][] = [];
+  for (const resourceId of Object.keys(data).sort()) {
+    const units = data[resourceId];
+    if (
+      resourceId.trim().length === 0 ||
+      typeof units !== "number" ||
+      !Number.isSafeInteger(units) ||
+      units <= 0
+    ) {
+      return undefined;
+    }
+    entries.push([resourceId, units]);
+  }
+  return Object.freeze(Object.fromEntries(entries));
+}