breakage 0.8.5 → 0.9.1

package/dist/breakage.d.ts

@@ -1,76 +1,48 @@
+import { a as ReleasePolicyFunction, c as VersionTransition, d as versionDelta, f as versionTransition, i as ReleasePolicy, l as resolveReleaseDelta, n as ReleaseDeltaContext, o as SemverPolicyOptions, r as ReleaseDeltaResolver, s as VersionDelta, t as ReleaseConfig, u as semverPolicy } from "./release-D47BqRuB.js";
 import "simple-git";
-//#region src/baseline.d.ts
-type BaselineOptions = {
-  tagPattern?: string | undefined;
-  baseDirname?: string;
-};
-type BreakagePreludeOptions = BaselineOptions & {
-  out: string;
-};
-type BreakageBaseline = {
-  version: 1;
-  tagPattern: string | null;
-  packageDirectory: string;
-  ref: string;
-  commit: string;
-};
-/** Resolve and fetch a release without running tests or changing the worktree. */
-export declare function breakagePrelude({ out, tagPattern, baseDirname }: BreakagePreludeOptions): Promise<BreakageBaseline>;
-//#endregion
-//#region src/npm/types.d.ts
-type ReleaseIntent = {
-  status: `none`;
-} | {
-  status: `release`;
-  version: string;
-};
-type ReleaseContext = {
-  packageName: string;
-  packageDirectory: string;
-  currentVersion: string;
-};
-type SupportChange = {
-  peer: string;
-  reason: `narrowed-range` | `required-peer`;
-  previous: string | null;
-  current: string | null;
-};
-type ReleaseEvidence = {
-  version: string;
-  delta: string;
-};
-type NpmSuite = {
-  /** Package-relative globs; preserve relative paths inside the stage. */
+import { ConfigInput } from "comline";
+declare const npmSuiteSchema: import("arktype/internal/variants/object.ts").ObjectType<{
   files: string[];
-  /** Run once; 1 means assertion failure, other nonzero codes mean setup failure. */
   command: string;
-};
-type NpmConfig = {
+}, {}>;
+declare const npmConfigSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+  release?: {
+    resolveDelta?: ReleaseDeltaResolver;
+    policy?: ReleasePolicyFunction;
+  };
   packageDirectory?: string;
   artifact: string;
   representatives: string | string[];
   lockfile: string;
   prepareCommand: string;
   installCommand?: string;
-  suites: Record<string, NpmSuite>;
-  /** Currently declared local peers must support and exercise each planned release. */
-  localPeers?: Record<string, {
-    directory: string;
-    artifact: string;
-  }>;
+  suites: {
+    [x: string]: {
+      files: string[];
+      command: string;
+    };
+  };
+  localPeers?: {
+    [x: string]: {
+      directory: string;
+      artifact: string;
+    };
+  };
   baseline: {
     firstRelease: true;
   } | {
     tagPattern?: string;
     baselineFile?: string;
   };
-  releaseIntent?: (context: ReleaseContext) => ReleaseIntent | Promise<ReleaseIntent>;
-  certifyBreaking?: (context: {
-    previousVersion: string;
-    release: ReleaseEvidence;
-    changes: SupportChange[];
-  }) => boolean | Promise<boolean>;
+}, {}>;
+type SupportChange = {
+  peer: string;
+  reason: `narrowed-range` | `required-peer`;
+  previous: string | null;
+  current: string | null;
 };
+type NpmSuite = typeof npmSuiteSchema.infer;
+type NpmConfig = typeof npmConfigSchema.infer;
 type NpmTestSelection = {
   peer: string;
   range: string;
@@ -110,16 +82,193 @@ type NpmReport = {
     representatives: string[];
   }[];
   support: {
-    status: `unchanged` | `certified` | `end-of-support` | `first-release` | `not-checked` | `setup-error`;
+    status: `unchanged` | `breaking-release` | `end-of-support` | `first-release` | `not-checked` | `setup-error`;
     changes: SupportChange[];
     previousVersion?: string;
-    release?: ReleaseEvidence;
+    release?: VersionDelta;
     error?: string;
   };
   errors: string[];
 };
-//#endregion
-//#region src/npm/check.d.ts
+type NpmArchiveRequest = {
+  packageName: string;
+  directory: string;
+  artifact: string;
+};
+type NpmPrepareContext = {
+  rootDirectory: string;
+  archives: NpmArchiveRequest[];
+};
+type NpmMatrixLabelContext = {
+  packageName: string;
+  representative: string;
+  description?: string;
+  peers: Record<string, NpmPeerEvidence>;
+};
+declare const npmMatrixConfigSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+  configs: string | string[];
+  prepare: string | ((context: NpmPrepareContext) => void | Promise<void>);
+  label?: (context: NpmMatrixLabelContext) => string;
+}, {}>;
+type NpmMatrixConfig = typeof npmMatrixConfigSchema.infer;
+declare const npmPlanSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+  formatVersion: 1;
+  id: string;
+  runId: string;
+  commit: string;
+  configs: string[];
+  packages: {
+    config: string;
+    directory: string;
+    name: string;
+    configDigest: string;
+    inputDigest: string;
+    audit: NpmReport;
+    releases: {
+      context: {
+        packageName: string;
+        packageDirectory: string;
+        currentVersion: string;
+        baseline?: {
+          version: string;
+          ref?: string;
+          commit?: string;
+        };
+      };
+      transition?: {
+        previousVersion: string;
+        version: string;
+        delta: "major" | "minor" | "none" | "patch" | "premajor" | "preminor" | "prepatch" | "prerelease" | "release";
+      };
+    }[];
+  }[];
+  environments: {
+    id: string;
+    label: string;
+    packageName: string;
+    representative: string;
+    suites: string[];
+    peers: {
+      [x: string]: {
+        version: string;
+        source: "candidate" | "installed";
+      };
+    };
+  }[];
+  archives: {
+    path: string;
+    file: string;
+    sha256: string;
+  }[];
+}, {}>;
+type NpmPlan = typeof npmPlanSchema.infer;
+declare const npmReceiptSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+  formatVersion: 1;
+  planId: string;
+  id: string;
+  exitCode: 0 | 1 | 2;
+  report?: NpmReport;
+  error?: string;
+}, {}>;
+type NpmReceipt = typeof npmReceiptSchema.infer;
+type NpmVerification = {
+  exitCode: 0 | 1 | 2;
+  errors: string[];
+  environments: number;
+};
+/** Pure receipt verification; runner-local installation paths are diagnostic only. */
+export declare function verifyNpmReceipts(value: unknown, receipts: readonly unknown[]): NpmVerification;
+/** The complete config, with no fields exposed to argv by this loader. */
+declare const configOptions: {
+  description: string;
+  optionsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    tagPattern?: string | undefined;
+    baselineFile?: string | undefined;
+    testPattern?: string;
+    testCommand?: string;
+    test?: string;
+    baseDirname?: string;
+    verbose?: boolean | undefined;
+    out?: string;
+    release?: {
+      resolveDelta?: ReleaseDeltaResolver;
+      policy?: ReleasePolicyFunction;
+    };
+    npm?: {
+      release?: {
+        resolveDelta?: ReleaseDeltaResolver;
+        policy?: ReleasePolicyFunction;
+      };
+      packageDirectory?: string;
+      artifact: string;
+      representatives: string | string[];
+      lockfile: string;
+      prepareCommand: string;
+      installCommand?: string;
+      suites: {
+        [x: string]: {
+          files: string[];
+          command: string;
+        };
+      };
+      localPeers?: {
+        [x: string]: {
+          directory: string;
+          artifact: string;
+        };
+      };
+      baseline: {
+        firstRelease: true;
+      } | {
+        tagPattern?: string;
+        baselineFile?: string;
+      };
+    };
+    npmMatrix?: {
+      configs: string | string[];
+      prepare: string | ((context: NpmPrepareContext) => void | Promise<void>);
+      label?: (context: NpmMatrixLabelContext) => string;
+    };
+  }, {}>;
+  optionConfigs: {
+    tagPattern: import("comline").ConfigOnlyOption;
+    baselineFile: import("comline").ConfigOnlyOption;
+    testPattern: import("comline").ConfigOnlyOption;
+    testCommand: import("comline").ConfigOnlyOption;
+    test: import("comline").ConfigOnlyOption;
+    baseDirname: import("comline").ConfigOnlyOption;
+    verbose: import("comline").ConfigOnlyOption;
+    out: import("comline").ConfigOnlyOption;
+    release: import("comline").ConfigOnlyOption;
+    npm: import("comline").ConfigOnlyOption;
+    npmMatrix: import("comline").ConfigOnlyOption;
+  };
+};
+type BreakageConfig = ConfigInput<typeof configOptions>;
+/** Share the root release model with npm checks unless they supply their own. */
+export declare function defineConfig(config: BreakageConfig): BreakageConfig;
+/** Use Comline's module loading and full-schema validation for programmatic and npm consumers. */
+export declare function loadConfig(filename: string): Promise<BreakageConfig>;
+type CommandResult = {
+  code: number;
+  output: string;
+};
+type BaselineOptions = {
+  tagPattern?: string | undefined;
+  baseDirname?: string;
+};
+type BreakagePreludeOptions = BaselineOptions & {
+  out: string;
+};
+type BreakageBaseline = {
+  version: 1;
+  tagPattern: string | null;
+  packageDirectory: string;
+  ref: string;
+  commit: string;
+};
+/** Resolve and fetch a release without running tests or changing the worktree. */
+export declare function breakagePrelude({ out, tagPattern, baseDirname }: BreakagePreludeOptions): Promise<BreakageBaseline>;
 export declare function npmCheck(config: NpmConfig, options?: {
   baseDirectory?: string;
   coverageOnly?: boolean;
@@ -128,19 +277,40 @@ export declare function npmTest(config: NpmConfig, selection: NpmTestSelection,
   baseDirectory?: string;
 }): Promise<NpmReport>;
 export declare function formatNpmReport(report: NpmReport): string;
-//#endregion
-//#region src/breakage.d.ts
+type NpmMatrixLocation = {
+  rootDirectory?: string;
+  bundleDirectory?: string;
+};
+/** Audit all configured packages and prepare one immutable, portable archive bundle. */
+export declare function npmPlan(config: NpmMatrixConfig, options?: NpmMatrixLocation): Promise<NpmPlan>;
+/** Execute exactly one audited environment, producing failure evidence whenever the plan is valid. */
+export declare function npmExecute(value: unknown, id: string, options?: NpmMatrixLocation): Promise<NpmReceipt>;
+/** Verify source/config/archive identities and then require all planned execution receipts. */
+export declare function npmVerify(value: unknown, receipts: readonly unknown[], options?: NpmMatrixLocation): Promise<NpmVerification>;
+export declare function npmMatrix(value: unknown): {
+  include: {
+    id: string;
+    label: string;
+    packageName: string;
+    representative: string;
+  }[];
+};
 export type BreakageOptions = {
   tagPattern?: string | undefined;
   baselineFile?: string | undefined;
   testPattern: string;
-  testCommand: string;
-  certifyCommand: string;
+  testCommand?: string;
+  /** Shell command. Do not combine with testCommand. */
+  test?: string;
+  release?: ReleaseConfig;
   baseDirname?: string;
   verbose?: boolean | undefined;
 };
 export type BreakageOutcome = {
   gitWasClean: false;
+} | {
+  gitWasClean: true;
+  setupError: string;
 } | {
   gitWasClean: true;
   lastReleaseFound: false;
@@ -156,6 +326,7 @@ export type BreakageOutcome = {
   testsWereFound: true;
   testsFound: string[];
   breakingChangesFound: false;
+  release?: VersionDelta;
 } | {
   gitWasClean: true;
   lastReleaseFound: true;
@@ -164,13 +335,10 @@ export type BreakageOutcome = {
   testsFound: string[];
   breakingChangesFound: true;
   testResult: string;
-  breakingChangesCertified: boolean;
-  certificationStdout: string;
-  certificationStderr: string;
+  release?: VersionDelta;
 };
-export declare function breakage({ tagPattern, baselineFile, testPattern, testCommand, certifyCommand, baseDirname, verbose }: BreakageOptions): Promise<BreakageOutcome & {
+export declare function breakage(options: BreakageOptions): Promise<BreakageOutcome & {
   summary: string;
 }>;
-//#endregion
-export type { BreakageBaseline, BreakagePreludeOptions, NpmConfig, NpmPeerEvidence, NpmReport, NpmRepresentativeResult, NpmSuite, NpmSuiteResult, NpmTestSelection, ReleaseContext, ReleaseEvidence, ReleaseIntent, SupportChange };
+export { type BreakageBaseline, type BreakageConfig, type BreakagePreludeOptions, type CommandResult, type NpmArchiveRequest, type NpmConfig, type NpmMatrixConfig, type NpmMatrixLabelContext, type NpmMatrixLocation, type NpmPeerEvidence, type NpmPlan, type NpmPrepareContext, type NpmReceipt, type NpmReport, type NpmRepresentativeResult, type NpmSuite, type NpmSuiteResult, type NpmTestSelection, type NpmVerification, type ReleaseConfig, type ReleaseDeltaContext, type ReleaseDeltaResolver, type ReleasePolicy, type ReleasePolicyFunction, type SemverPolicyOptions, type SupportChange, type VersionDelta, type VersionTransition, resolveReleaseDelta, semverPolicy, versionDelta, versionTransition };
 //# sourceMappingURL=breakage.d.ts.map

package/dist/breakage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"breakage.d.ts","names":[],"sources":["../src/baseline.ts","../src/npm/types.ts","../src/npm/check.ts","../src/breakage.ts"],"mappings":";;KAUY;EACX;EACA;;KAGW,yBAAyB;EAAoB;;KAE7C;EACX;EACA;EACA;EACA;EACA;;;wBAoBqB,kBACrB,KACA,YACA,eACE,yBAAyB,QAAQ;;;KC9CxB;EACP;;EACA;EAAmB;;KAEZ;EACX;EACA;EACA;;KAGW;EACX;EACA;EACA;EACA;;KAGW;EACX;EACA;;KAGW;;EAEX;;EAEA;;KAGW;EACX;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ,eAAe;;EAEvB,aAAa;IAAiB;IAAmB;;EACjD;IACK;;IACA;IAAqB;;EAC1B,iBACC,SAAS,mBACL,gBAAgB,QAAQ;EAC7B,mBAAmB;IAClB;IACA,SAAS;IACT,SAAS;kBACM;;KAGL;EACP;EAAc;;EACd;;KAEO;EACX;EACA;EACA;EACA;;KAGW;EACX;EACA;EACA;;KAGW;EACX;EACA;EAMA,OAAO,eAAe;EACtB,QAAQ;EACR;EACA;;KAGW;EACX;IAAW;IAAc;;EACzB;EACA;EACA,iBAAiB;EACjB;IAAY;IAAc;IAAa;;EACvC;IACC;IAOA,SAAS;IACT;IACA,UAAU;IACV;;EAED;;;;wBC+RqB,SACrB,QAAQ,WACR;EAAW;EAAwB;IACjC,QAAQ;wBAQW,QACrB,QAAQ,WACR,WAAW,kBACX;EAAW;IACT,QAAQ;wBASK,gBAAgB,QAAQ;;;YC/X5B;EACX;EACA;EACA;EACA;EACA;EACA;EACA;;YAGW;EACP;;EAEF;EACA;;EAGA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;wBAGmB,WACrB,YACA,cACA,aACA,aACA,gBACA,aACA,WACE,kBAAkB,QAAQ;EAAoB"}
+{"version":3,"file":"breakage.d.ts","names":["_$___release_ts0.ReleaseDeltaResolver","_$___release_ts0.ReleasePolicyFunction","_$__release_ts0.ReleaseDeltaResolver","_$__release_ts0.ReleasePolicyFunction","_$__npm_matrix_model_ts0.NpmPrepareContext","_$__npm_matrix_model_ts0.NpmMatrixLabelContext"],"sources":["../src/npm/config.ts","../src/npm/types.ts","../src/npm/matrix-model.ts","../src/config.ts","../src/task.ts","../src/baseline.ts","../src/npm/check.ts","../src/npm/matrix.ts","../src/breakage.ts"],"mappings":";;;cAQa,8DAAc;;;;cAKd,+DAAe;;I,eAAfA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCXD;EACX;EACA;EACA;EACA;;KAGW,kBAAA,eAAuD;KACvD,mBAAA,gBAAyD;KAEzD;EACP;EAAc;;EACd;;KAEO;EACX;EACA;EACA;EACA;;KAGW;EACX;EACA;EACA;;KAGW;EACX;EACA;EAMA,OAAO,eAAe;EACtB,QAAQ;EACR;EACA;;KAGW;EACX;IAAW;IAAc;;EACzB;EACA;EACA,iBAAiB;EACjB;IAAY;IAAc;IAAa;;EACvC;IACC;IAOA,SAAS;IACT;IACA,UAAU;IACV;;EAED;;KCzDW;EACX;EACA;EACA;;KAEW;EACX;EACA,UAAU;;KAEC;EACX;EACA;EACA;EACA,OAAO,eAAe;;cAEV,qEAAqB;;EAIF,oBAAA,SAAA,6BAA6B;EAEpB,SAAA,SAAA;;KAE7B,yBAAyB,sBAAsB;cAiD9C,6DAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsCd,iBAAiB,cAAc;cAC9B,gEAAgB;;;;;;;;KASjB,oBAAoB,iBAAiB;KACrC;EACX;EACA;EACA;;;wBAwKe,kBACf,gBACA,+BACE;;cCnQU;;;;;;;;;;;;M,eAAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAaD,iBAAiB,mBAAmB;;wBAGhC,aAAa,QAAQ,iBAAiB;;wBA8DhC,WAAW,mBAAmB,QAAQ;KCpHhD;EAAkB;EAAc;;KCOhC;EACX;EACA;;KAGW,yBAAyB;EAAoB;;KAE7C;EACX;EACA;EACA;EACA;EACA;;;wBAoBqB,kBACrB,KACA,YACA,eACE,yBAAyB,QAAQ;wBC4Vd,SACrB,QAAQ,WACR;EAAW;EAAwB;IACjC,QAAQ;wBAQW,QACrB,QAAQ,WACR,WAAW,kBACX;EAAW;IACT,QAAQ;wBAwBK,gBAAgB,QAAQ;KC5X5B;EACX;EACA;;;wBAsOqB,QACrB,QAAQ,iBACR,UAAS,oBACP,QAAQ;;wBAyPW,WACrB,gBACA,YACA,UAAS,oBACP,QAAQ;;wBAmEW,UACrB,gBACA,8BACA,UAAS,oBACP,QAAQ;wBAUK,UAAU;EACzB;IACC;IACA;IACA;IACA;;;YC3iBU;EACX;EACA;EACA;EACA;;EAEA;EACA,UAAU;EACV;EACA;;YAGW;EACP;;EACA;EAAmB;;EAErB;EACA;;EAGA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;EACA;EACA,UAAU;;EAGV;EACA;EACA;EACA;EACA;EACA;EACA;EACA,UAAU;;wBAGS,SACrB,SAAS,kBACP,QAAQ;EAAoB"}

package/dist/breakage.js

@@ -1 +1,3 @@
-export { t as breakage, c as breakagePrelude, n as formatNpmReport, r as npmCheck, i as npmTest } from "./breakage-B7dJsgcu.js";
+import { a as npmVerify, b as breakagePrelude, c as npmCheck, g as loadConfig, h as defineConfig, i as npmPlan, l as npmTest, n as npmExecute, r as npmMatrix, s as formatNpmReport, t as breakage, v as verifyNpmReceipts } from "./breakage-DJiIiLzL.js";
+import { i as semverPolicy, o as versionDelta, r as resolveReleaseDelta, s as versionTransition } from "./release-BsdIDT4g.js";
+export { breakage, breakagePrelude, defineConfig, formatNpmReport, loadConfig, npmCheck, npmExecute, npmMatrix, npmPlan, npmTest, npmVerify, resolveReleaseDelta, semverPolicy, verifyNpmReceipts, versionDelta, versionTransition };