@zxyycom/vibe-check 0.0.2 → 0.0.3

package/src/check/flag-enablement.ts

@@ -0,0 +1,76 @@
+/** 一个递归 flag presence 条件表达式。字符串是唯一 leaf；operator 保留 author child 顺序和 multiplicity。 */
+export type CheckFlagCondition =
+  | string
+  | Readonly<{
+      readonly kind: "all" | "any" | "none" | "not-all" | "exactly-one";
+      readonly conditions: readonly [CheckFlagCondition, ...CheckFlagCondition[]];
+    }>
+  | Readonly<{
+      readonly kind: "not";
+      readonly condition: CheckFlagCondition;
+    }>;
+
+type CheckFlagConditionSetKind = "all" | "any" | "none" | "not-all" | "exactly-one";
+type NonEmptyFlagConditions = readonly [CheckFlagCondition, ...CheckFlagCondition[]];
+type CheckFlagConditionSet<Kind extends CheckFlagConditionSetKind> = Readonly<{
+  readonly kind: Kind;
+  readonly conditions: NonEmptyFlagConditions;
+}>;
+type CheckFlagNegation = Readonly<{
+  readonly kind: "not";
+  readonly condition: CheckFlagCondition;
+}>;
+
+/** 构造 `all` 条件；Definition 仍负责 validation、snapshot 与 freeze。 */
+export function all(...conditions: NonEmptyFlagConditions): CheckFlagConditionSet<"all"> {
+  return conditionSet("all", conditions);
+}
+
+/** 构造 `any` 条件；Definition 仍负责 validation、snapshot 与 freeze。 */
+export function any(...conditions: NonEmptyFlagConditions): CheckFlagConditionSet<"any"> {
+  return conditionSet("any", conditions);
+}
+
+/** 构造 `none` 条件；Definition 仍负责 validation、snapshot 与 freeze。 */
+export function none(...conditions: NonEmptyFlagConditions): CheckFlagConditionSet<"none"> {
+  return conditionSet("none", conditions);
+}
+
+/** 构造 `not-all` 条件；Definition 仍负责 validation、snapshot 与 freeze。 */
+export function notAll(...conditions: NonEmptyFlagConditions): CheckFlagConditionSet<"not-all"> {
+  return conditionSet("not-all", conditions);
+}
+
+/** 构造 `exactly-one` 条件；Definition 仍负责 validation、snapshot 与 freeze。 */
+export function exactlyOne(
+  ...conditions: NonEmptyFlagConditions
+): CheckFlagConditionSet<"exactly-one"> {
+  return conditionSet("exactly-one", conditions);
+}
+
+/** 构造 `not` 条件；Definition 仍负责 validation、snapshot 与 freeze。 */
+export function not(condition: CheckFlagCondition): CheckFlagNegation {
+  return { condition, kind: "not" };
+}
+
+/** 为一个已声明的 project change ID 生成保留 flag token。 */
+export function changeFlag<const Id extends string>(id: Id): `vibe-check:change:${Id}` {
+  return `vibe-check:change:${id}`;
+}
+
+function conditionSet<Kind extends CheckFlagConditionSetKind>(
+  kind: Kind,
+  conditions: NonEmptyFlagConditions
+): CheckFlagConditionSet<Kind> {
+  return { kind, conditions };
+}
+
+/** executable Check 的 flag 选择控制。 */
+export interface CheckFlagEnablement {
+  readonly when: CheckFlagCondition;
+  /**
+   * 条件命中时是否启动本 Check 的传递 `dependsOn` prerequisite；省略时只选择直接命中 Check。
+   * `observes` 不参与此选择，且 dependency 自己的 flag 条件不会阻止已启动 prerequisite。
+   */
+  readonly propagateDependsOn?: true;
+}

package/src/check/handoff-provider-identity.ts

@@ -0,0 +1,34 @@
+declare const HANDOFF_PROVIDER_IDENTITY_BRAND: unique symbol;
+
+/** Opaque same-package identity retained only by Definition and invocation execution. */
+export type HandoffProviderIdentity = Readonly<{
+  readonly [HANDOFF_PROVIDER_IDENTITY_BRAND]: true;
+}>;
+
+const handoffProviderIdentities = new WeakMap<object, HandoffProviderIdentity>();
+
+class HandoffProviderIdentityValue implements HandoffProviderIdentity {
+  declare readonly [HANDOFF_PROVIDER_IDENTITY_BRAND]: true;
+}
+
+/** Registers the identity that makes a `handoff: true` Check authentic to this package runtime. */
+export function registerHandoffProviderIdentity(value: object): void {
+  handoffProviderIdentities.set(value, Object.freeze(new HandoffProviderIdentityValue()));
+}
+
+/** Returns the same-package identity registered by `defineCheck`. */
+export function getDefinedHandoffProviderIdentity(
+  value: unknown
+): HandoffProviderIdentity | undefined {
+  return typeof value === "object" && value !== null
+    ? handoffProviderIdentities.get(value)
+    : undefined;
+}
+
+/** Preserves a Definition-validated provider identity during materialization. */
+export function bindHandoffProviderIdentity(
+  value: object,
+  identity: HandoffProviderIdentity
+): void {
+  handoffProviderIdentities.set(value, identity);
+}

package/src/check/inherited-collection.ts

@@ -82,7 +82,7 @@ function snapshotInheritedCollectionEntry(
 ): InheritedCollectionEntry {
   if (!isDataDescriptor(descriptor)) return "invalid";
   if (key === INHERITED_CHECK_COLLECTION) {
-    return descriptor.enumerable || descriptor.value !== true ? "invalid" : "marker";
+    return descriptor.enumerable === true || descriptor.value !== true ? "invalid" : "marker";
   }
   if (typeof key !== "string" || descriptor.enumerable !== true) return "invalid";
   Object.defineProperty(snapshot, key, {

package/src/check/project-changes.ts

@@ -0,0 +1,14 @@
+/** 已配置的 project change preparation 产生的 file-centric evidence。 */
+export type ProjectChanges = Readonly<
+  | {
+      readonly ok: true;
+      readonly files: readonly Readonly<{
+        readonly path: string;
+        readonly flags: readonly string[];
+      }>[];
+    }
+  | {
+      readonly ok: false;
+      readonly reason: Readonly<{ readonly code: string }>;
+    }
+>;

package/src/check/project-context.ts

@@ -0,0 +1,11 @@
+import type { ProjectChanges } from "./project-changes.ts";
+
+/** 每次 Run 共享、冻结的 caller project context。 */
+export interface CheckProjectContext {
+  /** 本次 Run 使用的绝对项目根目录。 */
+  readonly root: string;
+  /** 已去重、排序的 invocation-effective flags（caller flags 与派生 change flags）。 */
+  readonly flags: readonly string[];
+  /** 只在当前 Project Definition 配置 change preparation 时存在。 */
+  readonly changes?: ProjectChanges;
+}

package/src/check-settlement/facts.ts

@@ -8,7 +8,7 @@ export type {
 } from "../data-boundary/canonical-data.ts";
 export type { CheckDescriptor, CheckOutcome };
 
-/** A Core Check has exactly one terminal outcome and no execution bookkeeping. */
+/** Core Check 恰有一个 terminal outcome，不携带 execution bookkeeping。 */
 export interface CoreCheck extends CheckDescriptor {
   readonly outcome: CheckOutcome;
 }

package/src/check-settlement/record-store.ts

@@ -26,7 +26,7 @@ export class CoreRecordStore {
     if (id === undefined || data === undefined) return this.#reject(slot, "record-invalid");
 
     let records = this.#recordsByCheckId.get(slot.checkId);
-    if (records?.has(id)) return this.#reject(slot, "record-conflict");
+    if (records?.has(id) === true) return this.#reject(slot, "record-conflict");
     if (records === undefined) {
       records = new Map<string, CoreRecord>();
       this.#recordsByCheckId.set(slot.checkId, records);

package/src/data-boundary/canonical-data.ts

@@ -9,20 +9,38 @@ export type {
 const encoder = new TextEncoder();
 
 /**
- * Materializes arbitrary author data without property reads or JSON hooks.
- * The returned graph is detached, prototype-safe, and deeply frozen before it
- * becomes a Core fact. Canonical text order is applied explicitly at serialization.
+ * 将输入规范化为独立且递归冻结的 canonical JSON 对象副本。
+ *
+ * 递归内容只接受普通对象或 null-prototype 对象、标准无空洞数组和有限 JSON 基本值；仅当顶层结果是
+ * 非数组对象时返回该副本。输出对象使用 null prototype，输出对象和数组均独立于输入且递归冻结。不调用
+ * getter 或 `toJSON`；无效输入、循环引用或反射失败返回 `undefined`。反射 Proxy 时仍可能执行其 trap，
+ * 不隔离 trap 的副作用。
  */
 export function canonicalizeJsonObject(value: unknown): CanonicalJsonObject | undefined {
   const canonical = canonicalize(value, new Set<object>());
   return canonical !== undefined && isCanonicalJsonObject(canonical) ? canonical : undefined;
 }
 
+/**
+ * 将输入规范化为独立且递归冻结的 canonical JSON 值副本。
+ *
+ * 接受 `null`、boolean、string、有限 number、普通对象或 null-prototype 对象，以及标准无空洞数组；
+ * `-0` 转换为 `0`，输出对象使用 null prototype。拒绝存取器、稀疏数组、不可枚举的自有属性、非有限
+ * number 和其它 prototype。不调用 getter 或 `toJSON`；无效输入、循环引用或反射失败返回 `undefined`。
+ * 反射 Proxy 时仍可能执行其 trap，不隔离 trap 的副作用。`CanonicalJsonPrimitive` 的 `number` 在
+ * TypeScript 中仍可表示 `NaN`，有限性只能由本函数在运行时检查。
+ */
 export function canonicalizeJsonValue(value: unknown): CanonicalJsonValue | undefined {
   return canonicalize(value, new Set<object>());
 }
 
-/** Serializes detached canonical JSON with explicit lexical object-key ordering. */
+/**
+ * 规范化输入后生成确定性的无额外空白 JSON 文本。
+ *
+ * 对象键按固定的 lexical `<` 顺序输出，不承诺遵循外部 canonical-JSON 标准。即使同一对象已经过
+ * 规范化，`JSON.stringify` 仍按 ECMAScript 的整数索引键顺序输出，不能替代本函数。输入规则与 Proxy
+ * 边界同 `canonicalizeJsonValue`；无效输入或无法反射的 Proxy 均抛出 `TypeError`。
+ */
 export function canonicalJsonText(value: unknown): string {
   const canonical = canonicalizeJsonValue(value);
   if (canonical === undefined) {
@@ -31,7 +49,12 @@ export function canonicalJsonText(value: unknown): string {
   return canonicalText(canonical);
 }
 
-/** Emits canonical UTF-8 JSON without invoking author getters or `toJSON`. */
+/**
+ * 规范化输入后生成与 `canonicalJsonText` 相同的确定性 UTF-8 JSON 字节。
+ *
+ * 函数自行完成规范化与固定键排序，不要求调用方先取得 canonical JSON 值。输入规则、Proxy 边界和
+ * `TypeError` 失败方式与 `canonicalJsonText` 相同。
+ */
 export function canonicalJsonBytes(value: unknown): Uint8Array {
   return encoder.encode(canonicalJsonText(value));
 }
@@ -79,7 +102,7 @@ function denseCanonicalArrayLength(value: readonly unknown[]): number | undefine
   if (Object.getPrototypeOf(value) !== Array.prototype) return undefined;
   const keys = Reflect.ownKeys(value);
   const lengthDescriptor = Object.getOwnPropertyDescriptor(value, "length");
-  if (!isDataDescriptor(lengthDescriptor) || lengthDescriptor.enumerable) return undefined;
+  if (!isDataDescriptor(lengthDescriptor) || lengthDescriptor.enumerable === true) return undefined;
   const length = lengthDescriptor.value;
   if (
     typeof length !== "number" ||
@@ -140,8 +163,6 @@ function canonicalizeObject(
 
 type DataDescriptor = Omit<PropertyDescriptor, "get" | "set" | "value"> &
   Readonly<{
-    get?: undefined;
-    set?: undefined;
     value: unknown;
   }>;
 
@@ -173,7 +194,13 @@ function canonicalText(value: CanonicalJsonValue): string {
   }
   return `{${Object.keys(value)
     .sort(compareText)
-    .map((key) => `${JSON.stringify(key)}:${canonicalText(value[key])}`)
+    .map((key) => {
+      const entry = value[key];
+      if (entry === undefined) {
+        throw new TypeError(`Canonical JSON object is missing declared key: ${key}`);
+      }
+      return `${JSON.stringify(key)}:${canonicalText(entry)}`;
+    })
     .join(",")}}`;
 }
 

package/src/data-boundary/canonical-json.ts

@@ -1,11 +1,28 @@
-/** Package-private static shape for Product's detached canonical JSON facts. */
+/**
+ * Canonical JSON 基本值的静态结构类型。
+ *
+ * TypeScript 的 `number` 无法在静态层区分有限值与 `NaN` / `Infinity`；因此此类型不能证明值已经由
+ * canonical API 规范化。运行时只接受有限 number，并将 `-0` 转换为 `0`。
+ */
 export type CanonicalJsonPrimitive = boolean | null | number | string;
 
+/**
+ * Canonical JSON 值的递归只读静态结构类型。
+ *
+ * 它描述基本值、数组和对象能够如何组合，便于声明参数和结果；不证明值已经通过 canonical API 的
+ * 运行时规范化、递归冻结或循环检查。
+ */
 export type CanonicalJsonValue =
   | CanonicalJsonPrimitive
   | readonly CanonicalJsonValue[]
   | CanonicalJsonObject;
 
+/**
+ * Canonical JSON 对象的只读静态结构类型。
+ *
+ * 该类型不证明值来自 canonical API。API 实际返回的对象使用 null prototype，没有继承的对象方法；
+ * 检查属性时使用 `Object.hasOwn`，不要调用 `value.hasOwnProperty`。
+ */
 export interface CanonicalJsonObject {
   readonly [key: string]: CanonicalJsonValue;
 }

package/src/data-boundary/closed-values.ts

@@ -15,6 +15,7 @@ function ownDataShape(value: object): OwnDataShape | undefined {
   if (
     keys.some((key) => {
       const descriptor = descriptors[key];
+      if (descriptor === undefined) return true;
       return descriptor.get !== undefined || descriptor.set !== undefined;
     })
   )
@@ -60,19 +61,30 @@ export function snapshotClosedRecord(
     const shape = ownDataShape(value);
     if (
       shape === undefined ||
-      shape.keys.some((key) => shape.descriptors[key].enumerable !== true)
+      shape.keys.some((key) => shape.descriptors[key]?.enumerable !== true)
     ) {
       return undefined;
     }
-    return Object.freeze(
-      Object.fromEntries(shape.keys.map((key) => [key, shape.descriptors[key].value as unknown]))
-    );
+    const entries = shape.keys.map((key) => {
+      const descriptor = shape.descriptors[key];
+      if (descriptor === undefined) throw new TypeError(`Missing own descriptor: ${key}`);
+      return [key, descriptor.value as unknown] as const;
+    });
+    return Object.freeze(Object.fromEntries(entries));
   } catch {
     return undefined;
   }
 }
 
-/** Snapshots a closed plain record only when it has exactly the declared own keys. */
+/**
+ * 取得字段集合恰好匹配调用方字段表的闭合普通记录外层浅快照。
+ *
+ * 输入必须是使用 `Object.prototype` 或 null prototype 的非数组对象，且每个自有属性都是可枚举数据属性。
+ * 调用方持有的 `keys` 必须是稳定、无重复的字符串列表；缺字段、多字段、symbol 键、存取器或不可枚举属性
+ * 均返回 `undefined`。成功结果是使用 `Object.prototype` 的冻结浅副本：只固定外层字段，保留 callback、
+ * `undefined` 与嵌套对象或数组的原引用，调用方仍须逐字段验证。这不是 JSON 验证器；不调用 getter，
+ * 但反射 Proxy 可能执行其 trap，反射失败时返回 `undefined`。
+ */
 export function snapshotExactClosedRecord(
   value: unknown,
   keys: readonly string[]
@@ -94,12 +106,20 @@ function closedArrayItems(shape: OwnDataShape, length: number): readonly unknown
   const items: unknown[] = [];
   for (let index = 0; index < length; index += 1) {
     const descriptor = shape.descriptors[String(index)];
-    if (descriptor === undefined || descriptor.enumerable !== true) return undefined;
+    if (descriptor?.enumerable !== true) return undefined;
     items.push(descriptor.value as unknown);
   }
   return Object.freeze(items);
 }
 
+/**
+ * 取得标准无空洞数组的外层浅快照。
+ *
+ * 输入必须使用 `Array.prototype`，除标准 `length` 和可枚举索引外没有其它自有属性，也不能包含存取器；
+ * 稀疏数组、额外属性或其它不符合条件的输入返回 `undefined`。成功结果是冻结浅副本，只固定数组结构，
+ * 保留 callback、`undefined` 与嵌套值的原引用，不检查元素的业务类型或 JSON 合法性。不调用存取器，
+ * 但反射 Proxy 可能执行其 trap，反射失败时返回 `undefined`。
+ */
 export function snapshotClosedArray(value: unknown): readonly unknown[] | undefined {
   try {
     if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return undefined;

package/src/data-boundary/config-glob.ts

@@ -0,0 +1,17 @@
+import { minimatch } from "minimatch";
+
+import { toSlashPath } from "./project-path.ts";
+
+/**
+ * Product config glob's single matcher boundary. Candidates use slash form;
+ * dot paths participate only when an explicit glob matches them.
+ */
+export function matchesAnyConfigGlob(
+  candidatePath: string,
+  configGlobs: readonly string[]
+): boolean {
+  const normalizedCandidatePath = toSlashPath(candidatePath);
+  return configGlobs.some((configGlob) =>
+    minimatch(normalizedCandidatePath, configGlob, { dot: true })
+  );
+}

package/src/data-boundary/project-path.ts

@@ -0,0 +1,21 @@
+/** Converts a host path spelling to the Product's slash-path form. */
+export function toSlashPath(filePath: string): string {
+  return filePath.replace(/\\/g, "/");
+}
+
+/** Recognizes one stable project-root-relative slash path. */
+export function isNormalizedProjectRelativePath(value: unknown): value is string {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.startsWith("/") ||
+    value.includes("\\") ||
+    value.includes("\u0000") ||
+    /^[A-Za-z]:/u.test(value)
+  ) {
+    return false;
+  }
+  return value
+    .split("/")
+    .every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}

package/src/index.ts

@@ -4,9 +4,25 @@
  *
  * @packageDocumentation
  */
-export { cacheJsonByKey } from "./cache/cache-json-by-key.ts";
-export type { CacheJsonByKeyOptions, CacheJsonByKeyResult } from "./cache/cache-json-by-key.ts";
+export { cacheJsonByKey } from "./package-tools/cache/cache-json-by-key.ts";
+export type {
+  CacheJsonByKeyOptions,
+  CacheJsonByKeyResult
+} from "./package-tools/cache/cache-json-by-key.ts";
+export {
+  canonicalizeJsonObject,
+  canonicalizeJsonValue,
+  canonicalJsonBytes,
+  canonicalJsonText
+} from "./data-boundary/canonical-data.ts";
+export type {
+  CanonicalJsonObject,
+  CanonicalJsonPrimitive,
+  CanonicalJsonValue
+} from "./data-boundary/canonical-data.ts";
+export { snapshotClosedArray, snapshotExactClosedRecord } from "./data-boundary/closed-values.ts";
 export { duplicateDetection } from "./package-checks/duplicate-detection/default-check.ts";
+export type { PackageCheckAuthoringOptions } from "./package-checks/check-authoring.ts";
 export { parseDuplicateDetectionData } from "./package-checks/duplicate-detection/final-data.ts";
 export type { DuplicateDetectionFinalData } from "./package-checks/duplicate-detection/final-data.ts";
 export type {
@@ -83,10 +99,28 @@ export type {
   JsonValidationRecordReason,
   JsonValidationUnavailableCode
 } from "./package-checks/json-validation/json-validation.ts";
+export { commandCheck } from "./package-checks/command-check/command-check.ts";
+export type {
+  AfterCommand,
+  AfterCommandContext,
+  AfterCommandExecution,
+  CommandCheck,
+  CommandCheckEnvironment,
+  CommandCheckWithAfterCommand,
+  CommandEnvironmentContext,
+  CommandEnvironmentResolver,
+  CompletedCommand,
+  CommandCheckFinalData,
+  CommandCheckInput,
+  CommandCheckOutput,
+  CommandCheckUnavailableReasonCode,
+  TypedCommandCheck
+} from "./package-checks/command-check/command-check.ts";
 export { maintenanceReminders } from "./package-checks/maintenance-reminders/maintenance-reminders.ts";
 export type {
   MaintenanceReminder,
   MaintenanceReminderOptions,
+  MaintenanceRemindersInput,
   MaintenanceRemindersUnavailableCode
 } from "./package-checks/maintenance-reminders/maintenance-reminders.ts";
 export { parseMaintenanceRemindersData } from "./package-checks/maintenance-reminders/final-data.ts";
@@ -95,6 +129,21 @@ export type {
   MaintenanceReminderUnavailableReason,
   MaintenanceRemindersFinalData
 } from "./package-checks/maintenance-reminders/final-data.ts";
+export { markdownLint } from "./package-checks/markdown-lint/default-check.ts";
+export { parseMarkdownLintData } from "./package-checks/markdown-lint/final-data.ts";
+export type { MarkdownLintFinalData } from "./package-checks/markdown-lint/final-data.ts";
+export type {
+  MarkdownLintFindingIdentity,
+  MarkdownLintFindingWaiver,
+  MarkdownLintOptions,
+  MarkdownLintRuleName,
+  ResolvedMarkdownLintOptions
+} from "./package-checks/markdown-lint/options.ts";
+export type {
+  MarkdownLintFindingWaiverAuditRecordData,
+  MarkdownLintRecordData
+} from "./package-checks/markdown-lint/records.ts";
+export type { MarkdownLintUnavailableReason } from "./package-checks/markdown-lint/execution.ts";
 export { markdownLinkValidation } from "./package-checks/markdown-link-validation/default-check.ts";
 export { parseMarkdownLinkValidationData } from "./package-checks/markdown-link-validation/final-data.ts";
 export type { MarkdownLinkValidationFinalData } from "./package-checks/markdown-link-validation/final-data.ts";
@@ -106,8 +155,8 @@ export type { MarkdownLinkValidationUnavailableReason } from "./package-checks/m
 export type { MarkdownLinkValidationRecordData } from "./package-checks/markdown-link-validation/records.ts";
 export type { MarkdownLinkFindingReason } from "./package-checks/markdown-link-validation/local-resolver.ts";
 export type { FindingPolicy } from "./package-checks/code-quality-findings/policy.ts";
-export { reconcileFindingWaivers } from "./finding-waivers/reconciliation.ts";
-export { presentCheckFindings } from "./check/finding-presentation.ts";
+export { reconcileFindingWaivers } from "./package-tools/finding-waivers/reconciliation.ts";
+export { presentCheckFindings } from "./package-tools/finding-presentation/finding-presentation.ts";
 export type {
   FindingWaiver,
   FindingWaiverAudit,
@@ -115,7 +164,7 @@ export type {
   MaterializedFindingWaiver,
   ReconciledFinding,
   ReconcileFindingWaiversOptions
-} from "./finding-waivers/reconciliation.ts";
+} from "./package-tools/finding-waivers/reconciliation.ts";
 export { defaultProjectFileSelection } from "./package-checks/project-files/configuration.ts";
 export { collectProjectFiles } from "./package-checks/project-files/public-collection.ts";
 export type { CollectProjectFilesOptions } from "./package-checks/project-files/public-collection.ts";
@@ -125,25 +174,31 @@ export type {
   ProjectFileSource
 } from "./package-checks/project-files/configuration.ts";
 export { defineCheck, inherit } from "./check/check.ts";
+export { all, any, changeFlag, exactlyOne, none, not, notAll } from "./check/flag-enablement.ts";
 export type {
   Check,
   CheckDependencies,
   CheckExecution,
   CheckExecutionContext,
-  CheckPreflight,
-  CheckPreflightResult,
+  CheckFlagCondition,
+  CheckFlagEnablement,
+  CheckPreparation,
+  CheckPreparationResult,
+  CheckProjectContext,
   CheckResourceClaims,
   CheckOutcome,
+  ProjectChanges,
   CheckResult,
   CheckUnavailableReason,
   InheritableCheckCollection
 } from "./check/check.ts";
-export { defineAdmissionPolicy, defineConfig } from "./project-definition/project-definition.ts";
-export { createLearnedCriticalPathStrategy } from "./learned-critical-path/strategy.ts";
+export { defineAdmissionPolicy } from "./package-tools/admission-policy/define-admission-policy.ts";
+export { defineConfig } from "./project-definition/project-definition.ts";
+export { createLearnedCriticalPathStrategy } from "./package-tools/learned-critical-path/strategy.ts";
 export type {
   LearnedCriticalPathObservation,
   LearnedCriticalPathStrategyOptions
-} from "./learned-critical-path/strategy.ts";
+} from "./package-tools/learned-critical-path/strategy.ts";
 export { createAdmissionGraph } from "./project-run/task-scheduler/admission-core/core.ts";
 export type {
   AdmissionPolicy,
@@ -173,7 +228,7 @@ export type {
   SchedulerDecisionMeasurementCumulative,
   SchedulerGraphSnapshot,
   SchedulerMeasurementContext,
-  SchedulerMeasurementHook,
+  SchedulerTerminalEffect,
   SchedulerMeasurementIntervalContribution,
   SchedulerMeasurementActionObservationInterval,
   SchedulerMeasurementActionObservation,
@@ -181,6 +236,12 @@ export type {
   SchedulerRawMeasurement,
   SchedulerPolicy
 } from "./project-definition/project-definition.ts";
+export type {
+  ProjectChangeFlagRegion,
+  ProjectChangeSource,
+  ProjectChangesConfiguration
+} from "./project-definition/project-changes.ts";
+export type { CoreCheck } from "./check-settlement/facts.ts";
 export type {
   CheckAggregate,
   CheckAggregation,

package/src/machine-output/v4/atomic-publication.ts

@@ -104,5 +104,7 @@ function removePaths(paths: readonly string[]): void {
       firstFailure ??= error;
     }
   }
-  if (firstFailure !== undefined) throw firstFailure;
+  if (firstFailure === undefined) return;
+  if (firstFailure instanceof Error) throw firstFailure;
+  throw new Error("publication cleanup failed", { cause: firstFailure });
 }