@intentius/chant 0.13.1 → 0.15.0

package/dist/codegen/fetch.d.ts

@@ -19,11 +19,33 @@ export interface FetchConfig {
  * Permanent failures (e.g. 404, 403) are not retried — they throw on the
  * first response. The returned response is guaranteed `ok`.
  *
+ * When a `Retry-After` header is present on a 429 or 503 response the delay
+ * from that header is used instead of the exponential back-off for that
+ * specific retry, capped at {@link MAX_RETRY_AFTER_MS}.
+ *
  * `init` is passed through to `fetch` on every attempt, so callers that
  * need request headers (e.g. the GitHub API `Accept` header) or an abort
  * signal get retries without duplicating the loop.
+ *
+ * On exhaustion a descriptive {@link TransientFetchError} is thrown rather
+ * than the raw last error so the caller can surface a human-readable message.
  */
 export declare function fetchWithRetry(url: string, retries?: number, backoffMs?: number, init?: RequestInit): Promise<Response>;
+/**
+ * Thrown when {@link fetchWithRetry} exhausts all retry attempts on a
+ * transient failure (429 / 5xx / network error).
+ *
+ * The message is human-readable and actionable: it names the URL, the number
+ * of attempts made, and the last HTTP status (if any) so that an upstream Op
+ * can route it to a report/issue without exposing a raw stack trace.
+ */
+export declare class TransientFetchError extends Error {
+    readonly url: string;
+    readonly retries: number;
+    readonly lastStatus: number | undefined;
+    readonly cause?: Error | undefined;
+    constructor(url: string, retries: number, lastStatus: number | undefined, cause?: Error | undefined);
+}
 /**
  * Fetch a URL with local file caching.
  *

package/dist/codegen/fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/codegen/fetch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,WAAW,WAAW;IAC1B,oBAAoB;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAiBD;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,SAAkB,EACzB,SAAS,SAAqB,EAC9B,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,QAAQ,CAAC,CA2BnB;AAMD;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,UAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BxF;AAID;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAU9B;AAID;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACjC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAyDrB;AAID,MAAM,WAAW,cAAc;IAC7B,kCAAkC;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,UAAQ,GACZ,OAAO,CAAC,MAAM,CAAC,CAoDjB;AAID;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAMtD"}
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/codegen/fetch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,WAAW,WAAW;IAC1B,oBAAoB;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA4CD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,OAAO,SAAkB,EACzB,SAAS,SAAqB,EAC9B,IAAI,CAAC,EAAE,WAAW,GACjB,OAAO,CAAC,QAAQ,CAAC,CA0CnB;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;aAE1B,GAAG,EAAE,MAAM;aACX,OAAO,EAAE,MAAM;aACf,UAAU,EAAE,MAAM,GAAG,SAAS;aAC9B,KAAK,CAAC,EAAE,KAAK;gBAHb,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,KAAK,CAAC,EAAE,KAAK,YAAA;CAUhC;AAMD;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,UAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BxF;AAID;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAU9B;AAID;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,UAAU,EACnB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACjC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAyDrB;AAID,MAAM,WAAW,cAAc;IAC7B,kCAAkC;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,UAAQ,GACZ,OAAO,CAAC,MAAM,CAAC,CAoDjB;AAID;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAMtD"}

package/dist/codegen/lexicon-regen.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Lexicon regen-validate pipeline.
+ *
+ * Given a lexicon root directory, this module:
+ *   1. Runs the prepack chain (generate -> bundle -> validate -> build)
+ *      by invoking `npm run <script>` in the lexicon directory.
+ *   2. Runs `chant lint` on any examples found under `examples/`.
+ *   3. Extracts the generated public API surface.
+ *   4. Diffs the fresh surface against the committed per-lexicon baseline
+ *      (`surface.snapshot.json` at the lexicon root).
+ *   5. Returns { ok, changed, severity, delta, failures } — never throws.
+ *
+ * Supply-chain guarantee:
+ *   All spec fetching happens through the lexicon's own `generate` script,
+ *   which is pinned to the lexicon's existing fetch layer (cached, TTL-based).
+ *   When `force` is true, the cache is bypassed and the spec is re-downloaded.
+ *   This module never executes spec-provided content — it only reads the
+ *   artifacts that the generate script produced.
+ *
+ * Never auto-fix:
+ *   Any failure is captured into `failures` and returned. This module never
+ *   rewrites examples, skips checks, or masks errors.
+ */
+import { type SurfaceDelta, type ChangeSeverity, type SurfaceSnapshot } from "./surface-snapshot.js";
+export interface RegenFailure {
+    /**
+     * Which step failed:
+     * "setup" | "digest-verify" | "generate" | "bundle" | "validate"
+     * | "build" | "lint" | "examples" | "surface-extract" | "surface-diff"
+     */
+    step: string;
+    /** Exit code from the subprocess, if applicable. */
+    exitCode?: number;
+    /** Combined stdout+stderr output captured from the subprocess. */
+    output: string;
+}
+export interface RegenResult {
+    /** True only when all steps passed and (if a baseline exists) the diff completed. */
+    ok: boolean;
+    /** True when the surface changed versus the baseline. */
+    changed: boolean;
+    /** Rolled-up severity of the surface delta. "none" when unchanged. */
+    severity: ChangeSeverity;
+    /** Structured delta: what was added, changed, or removed. */
+    delta: SurfaceDelta;
+    /** Human-readable delta text (empty string when no changes). */
+    deltaText: string;
+    /** Step failures captured during the run. */
+    failures: RegenFailure[];
+    /** Fresh surface snapshot — caller can write this as the new baseline. */
+    freshSnapshot: SurfaceSnapshot | null;
+}
+export interface RegenOptions {
+    /**
+     * Root of the lexicon package (e.g. `/path/to/lexicons/aws`).
+     * Must contain a `package.json` with `generate`, `bundle`, `validate`, `build` scripts.
+     */
+    lexiconDir: string;
+    /**
+     * When true, pass `CHANT_FORCE_FETCH=1` to the generate step so the spec is
+     * re-downloaded from upstream even if the cache is fresh.
+     */
+    force?: boolean;
+    /** Print subprocess output as it runs. Default: false. */
+    verbose?: boolean;
+    /**
+     * Skip the `bundle` step. Useful when testing without a full dist build.
+     * Default: false.
+     */
+    skipBundle?: boolean;
+    /**
+     * Skip the `build` (tsc) step. Useful in test contexts where tsc is not available.
+     * Default: false.
+     */
+    skipBuild?: boolean;
+    /**
+     * Skip running `chant lint` on examples.
+     * Default: false.
+     */
+    skipLint?: boolean;
+    /**
+     * Skip running example deploy harness (npm run deploy / npm run build in each example).
+     * Default: true (examples require live cloud credentials; opt-in only).
+     */
+    skipExamples?: boolean;
+    /**
+     * Path to a SHA-256 digest file pinning the spec cache file.
+     *
+     * When provided, this module verifies the digest of the cached spec file
+     * before invoking `generate`. This is the supply-chain choke point:
+     * untrusted upstream content is verified here before any downstream processing.
+     * The spec file is never executed — only checksummed and then passed to the
+     * lexicon's own generator as data.
+     *
+     * File format (shasum -a 256 style):
+     *   sha256:<64-hex-chars>  <relative-path-to-spec-file>
+     */
+    pinnedDigestPath?: string;
+}
+export declare const SNAPSHOT_FILENAME = "surface.snapshot.json";
+/**
+ * Run the full regen-validate pipeline for a lexicon and return the result.
+ */
+export declare function regenLexicon(opts: RegenOptions): Promise<RegenResult>;
+/**
+ * Write the fresh surface snapshot to the lexicon's committed baseline file.
+ * Call this after a successful regen when the snapshot should be updated.
+ */
+export declare function writeSurfaceSnapshot(lexiconDir: string, snapshot: SurfaceSnapshot): void;
+//# sourceMappingURL=lexicon-regen.d.ts.map

package/dist/codegen/lexicon-regen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicon-regen.d.ts","sourceRoot":"","sources":["../../src/codegen/lexicon-regen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,OAAO,EAML,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAI5B,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,qFAAqF;IACrF,EAAE,EAAE,OAAO,CAAC;IACZ,yDAAyD;IACzD,OAAO,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,QAAQ,EAAE,cAAc,CAAC;IACzB,6DAA6D;IAC7D,KAAK,EAAE,YAAY,CAAC;IACpB,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,0EAA0E;IAC1E,aAAa,EAAE,eAAe,GAAG,IAAI,CAAC;CACvC;AAED,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,0DAA0D;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAID,eAAO,MAAM,iBAAiB,0BAA0B,CAAC;AAEzD;;GAEG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,CAyH3E;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAGxF"}

package/dist/codegen/pinned-upgrade.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Pinned-version upgrade detection for k8s, gcp, docker, gitlab lexicons.
+ *
+ * For each lexicon with a pinned upstream version constant, this module:
+ *   1. Reads the currently pinned version from the source file.
+ *   2. Queries upstream for the latest stable release tag (no pre-release/rc).
+ *   3. Compares using semver ordering. If a newer version exists:
+ *      a. Edits the version constant in the source file.
+ *      b. Invokes regenLexicon to regenerate and surface-diff.
+ *      c. Reverts the constant edit (dry-run mode — never commits the bump).
+ *   4. Returns a structured report per lexicon.
+ *
+ * The upstream-query functions are injectable — pass a mock for unit tests.
+ * The actual HTTP calls use the GitHub Releases/Tags API.
+ *
+ * Design decisions:
+ * - "Latest stable" = highest semver excluding tags containing rc/alpha/beta/preview.
+ * - The bump is always reverted after regen so the working tree is unchanged.
+ *   Only the CLI reporter (#527) actually creates branches/PRs.
+ * - Each lexicon's upstream query is a pure async function: () => Promise<string | null>
+ *   (returns the latest version tag, or null when no stable release is found).
+ */
+import { type RegenResult } from "./lexicon-regen.js";
+import { type UpstreamPin } from "../lexicon.js";
+/**
+ * A pinned, self-upgradable lexicon's name (e.g. "k8s"). Any lexicon whose
+ * plugin declares `upstreamPin` (../lexicon.ts) is eligible — the set is no
+ * longer hard-coded here.
+ */
+export type LexiconId = string;
+export type { UpstreamPin };
+export interface UpgradeCheckResult {
+    /** Lexicon identifier. */
+    lexicon: LexiconId;
+    /** Whether a newer stable upstream version was found. */
+    hasUpgrade: boolean;
+    /** Current pinned version string (e.g. "v1.32.0"). */
+    from: string;
+    /** Latest upstream version string, if one was found (e.g. "v1.33.0"). */
+    to: string | null;
+    /** Regen/surface-diff result — only present when hasUpgrade is true. */
+    validation: RegenResult | null;
+    /** Human-readable error when the upstream query itself failed. */
+    fetchError: string | null;
+}
+/** Injectable upstream version resolver. Returns the latest stable tag or null. */
+export type UpstreamResolver = () => Promise<string | null>;
+export interface CheckPinnedUpgradeOptions {
+    /** Resolved path to the lexicon root (e.g. /repo/lexicons/k8s). */
+    lexiconDir: string;
+    /** Which lexicon to check. */
+    lexicon: LexiconId;
+    /**
+     * Override the upstream resolver (useful in tests to inject mocks).
+     * When omitted the real GitHub API is called.
+     */
+    resolverOverride?: UpstreamResolver;
+    /**
+     * When true, pass force=true to regenLexicon so the spec cache is bypassed.
+     * Default: false (use cached spec for the upgrade check).
+     */
+    force?: boolean;
+    /** Forward to regenLexicon. */
+    verbose?: boolean;
+    /** Forward to regenLexicon — skip tsc step for speed in tests. */
+    skipBuild?: boolean;
+    /** Forward to regenLexicon. */
+    skipBundle?: boolean;
+    /** Forward to regenLexicon. */
+    skipLint?: boolean;
+}
+/**
+ * Parse a version string into numeric segments.
+ *
+ * Strips leading "v" and any build-metadata suffix after "-".
+ * Returns null when the string is not a parseable version.
+ */
+export declare function parseVersion(tag: string): number[] | null;
+/**
+ * Compare two version tuples lexicographically.
+ * Returns -1 when a < b, 0 when equal, +1 when a > b.
+ */
+export declare function compareVersionTuples(a: number[], b: number[]): -1 | 0 | 1;
+/**
+ * Return true when `candidate` is strictly newer than `current`.
+ *
+ * Strips build-metadata suffixes (e.g. "-ee") before comparing so that
+ * "v17.9.0-ee" and "v17.9.0" compare by numeric part only.
+ */
+export declare function isNewer(candidate: string, current: string): boolean;
+/**
+ * Return true when a release tag looks like a pre-release.
+ * Filters out rc, alpha, beta, preview, nightly, dev, canary suffixes.
+ */
+export declare function isPreRelease(tag: string): boolean;
+interface PinLocation {
+    /** Absolute path to the file containing the version constant. */
+    filePath: string;
+    /** Regex that matches the full constant line (must have a capture for the version). */
+    pattern: RegExp;
+    /** Function to build the replacement line given the new version string. */
+    buildReplacement: (newVersion: string, oldVersion: string, line: string) => string;
+}
+/**
+ * Read the current pinned version from a source file using a regex pattern.
+ * Returns null when the pattern is not found.
+ */
+export declare function readPinnedVersion(location: PinLocation): string | null;
+/**
+ * Apply a version bump by replacing the constant in the source file.
+ * Returns the original file content so it can be reverted.
+ */
+export declare function applyVersionBump(location: PinLocation, newVersion: string): string;
+/**
+ * Revert a file to its original content (undo a bump).
+ */
+export declare function revertVersionBump(filePath: string, original: string): void;
+/**
+ * Load a lexicon's `upstreamPin` descriptor from its plugin package
+ * (`@intentius/chant-lexicon-<name>`) — the lexicon's own declaration of where
+ * its version constant lives and which upstream repo to check. Returns null
+ * when the package can't be resolved or declares no `upstreamPin` (i.e. it is
+ * not self-upgradable). Mirrors ../components/capability-plugin-loader.ts's
+ * lexicon-borne loading.
+ */
+export declare function loadUpstreamPin(lexicon: LexiconId): Promise<UpstreamPin | null>;
+/**
+ * Check whether a newer upstream release exists for a pinned lexicon.
+ *
+ * When a newer version is found:
+ *   1. Applies the version bump to the source constant.
+ *   2. Runs regenLexicon (surface-diff pipeline).
+ *   3. Reverts the bump unconditionally.
+ *
+ * The caller receives the full result including the regen validation output
+ * without any lasting change to the working tree.
+ */
+export declare function checkPinnedUpgrade(opts: CheckPinnedUpgradeOptions): Promise<UpgradeCheckResult>;
+/**
+ * Apply a version bump for a lexicon permanently (without reverting).
+ *
+ * Called by LexiconUpgradeOp when it has already decided to commit the bump
+ * to a branch. Returns the absolute path to the modified file so the caller
+ * can stage it with `git add`.
+ *
+ * Unlike `applyVersionBump` (which is generic), this function takes only a
+ * lexicon id and directory — it resolves the pin location from the lexicon's
+ * declared `upstreamPin` descriptor.
+ */
+export declare function applyPinnedVersionBump(lexicon: LexiconId, lexiconDir: string, newVersion: string): Promise<{
+    filePath: string;
+}>;
+//# sourceMappingURL=pinned-upgrade.d.ts.map

package/dist/codegen/pinned-upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinned-upgrade.d.ts","sourceRoot":"","sources":["../../src/codegen/pinned-upgrade.ts"],"names":[],"mappings":"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"}

package/dist/codegen/rolling-upgrade.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Rolling-spec drift detection for aws, azure, and github lexicons.
+ *
+ * These lexicons have no pinned version constant — "latest" is fetched on every
+ * regen. An upgrade means regenerating from current-latest and diffing the
+ * produced API surface against the committed baseline (surface.snapshot.json).
+ * If the surface changed and validation passed, a PR can be opened with the
+ * delta as the review payload.
+ *
+ * This module contains only pure business logic (detecting drift, classifying
+ * it, formatting the report). It calls regenLexicon from #524 for the actual
+ * regen/validate work, and never runs a live regen itself.
+ *
+ * azure extra delta:
+ *   The Azure regen depends on `latestVersionPerProvider`, which picks one API
+ *   version per ARM provider. When new providers appear or existing ones get a
+ *   newer GA/preview version, that shows up in the surface diff. In addition,
+ *   this module computes an `apiVersionDelta` to surface those version changes
+ *   separately, so reviewers can see "Microsoft.Compute moved 2022-03-01 →
+ *   2023-07-01" without reading the raw surface diff.
+ */
+import { type SurfaceDelta, type ChangeSeverity, type SurfaceSnapshot } from "./surface-snapshot.js";
+import { type RegenOptions, type RegenResult } from "./lexicon-regen.js";
+export type RollingLexicon = "aws" | "azure" | "github";
+/**
+ * An API-version change for one Azure ARM provider.
+ * Only populated for the azure lexicon.
+ */
+export interface AzureApiVersionChange {
+    provider: string;
+    before: string | null;
+    after: string | null;
+    /** "added" when provider is new; "updated" when version bumped; "removed" when gone. */
+    kind: "added" | "updated" | "removed";
+}
+/**
+ * The result of a rolling-upgrade check for one lexicon.
+ */
+export interface RollingUpgradeResult {
+    /** Lexicon identifier. */
+    lexicon: RollingLexicon;
+    /** True when the surface changed versus the committed baseline. */
+    hasUpgrade: boolean;
+    /** Severity of the surface delta. "none" when the surface is unchanged. */
+    severity: ChangeSeverity;
+    /** Structured surface delta. */
+    delta: SurfaceDelta;
+    /** Human-readable delta text. Empty when no changes. */
+    deltaText: string;
+    /** Whether regen+validation passed. False means the delta is unreliable. */
+    validationOk: boolean;
+    /** Failures captured during regen. */
+    failures: RegenResult["failures"];
+    /** azure-only: per-provider API version changes. Empty for aws/github. */
+    apiVersionDelta: AzureApiVersionChange[];
+    /** The fresh snapshot produced by the regen. Null when regen failed. */
+    freshSnapshot: SurfaceSnapshot | null;
+}
+/**
+ * Options for checkRollingUpgrade.
+ */
+export interface CheckRollingUpgradeOptions {
+    /** Root of the lexicon package (must contain package.json and surface.snapshot.json). */
+    lexiconDir: string;
+    /** Force re-fetch of the upstream spec (bypass cache). Default: false. */
+    force?: boolean;
+    /** Print subprocess output while running. Default: false. */
+    verbose?: boolean;
+    /**
+     * Override for the regen function — inject a mock in tests.
+     * Defaults to the production regenLexicon.
+     */
+    _regenFn?: (opts: RegenOptions) => Promise<RegenResult>;
+}
+/**
+ * Check whether the rolling spec has drifted since the committed baseline.
+ *
+ * Calls regenLexicon (from #524) to regenerate from current-latest, then diffs
+ * the resulting surface against the committed surface.snapshot.json. Returns
+ * hasUpgrade=true when the surface changed and validation passed.
+ *
+ * For azure, also computes an apiVersionDelta showing which ARM providers gained
+ * a new latest API version since the baseline was snapshotted.
+ *
+ * Never throws — all failures are captured in the result.
+ */
+export declare function checkRollingUpgrade(opts: CheckRollingUpgradeOptions): Promise<RollingUpgradeResult>;
+/**
+ * Compute provider-level additions and removals between two azure snapshots.
+ *
+ * The snapshot resourceType values for azure look like
+ * "Microsoft.Storage/storageAccounts". This function extracts the provider
+ * name (the part before the first "/") and reports which providers appeared,
+ * disappeared, or (when version strings are supplied via diffAzureApiVersions)
+ * bumped their API version.
+ *
+ * Use diffAzureApiVersions when you have access to actual API version strings
+ * (e.g. from the lexicon's latestVersionPerProvider output in a CI run).
+ */
+export declare function computeAzureApiVersionDelta(baseline: SurfaceSnapshot, fresh: SurfaceSnapshot): AzureApiVersionChange[];
+/**
+ * Extract the Azure ARM provider name from a resourceType string.
+ *
+ * Input:  "Microsoft.Storage/storageAccounts"
+ * Output: "Microsoft.Storage"
+ *
+ * Returns null for non-ARM resource types (e.g. empty string or non-Microsoft prefix).
+ */
+export declare function extractAzureProvider(resourceType: string): string | null;
+/**
+ * Diff actual API version strings per provider between two regen runs.
+ *
+ * Use this when the caller has access to the azure lexicon's
+ * latestVersionPerProvider output. Produces a richer delta that includes
+ * version bumps ("updated"), not just provider additions/removals.
+ *
+ * @param baseVersions  Map<provider, apiVersion> from the previous regen.
+ * @param freshVersions Map<provider, apiVersion> from the current regen.
+ */
+export declare function diffAzureApiVersions(baseVersions: Map<string, string>, freshVersions: Map<string, string>): AzureApiVersionChange[];
+/**
+ * Diff two surface snapshots.
+ *
+ * Pure function re-exported for callers that import rolling-upgrade and want to
+ * compute the delta without importing surface-snapshot directly.
+ */
+export declare function diffRollingSurface(baseline: SurfaceSnapshot, fresh: SurfaceSnapshot): SurfaceDelta;
+/**
+ * Classify a delta as an upgrade and determine its severity.
+ *
+ * Pure function — no I/O. Unit-testable with fixture snapshots.
+ * Used by the CLI and the checkRollingUpgrade entry point.
+ */
+export declare function classifyDelta(delta: SurfaceDelta): {
+    hasUpgrade: boolean;
+    severity: ChangeSeverity;
+};
+//# sourceMappingURL=rolling-upgrade.d.ts.map

package/dist/codegen/rolling-upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rolling-upgrade.d.ts","sourceRoot":"","sources":["../../src/codegen/rolling-upgrade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAmC,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAIvG,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;AAExD;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,wFAAwF;IACxF,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,0BAA0B;IAC1B,OAAO,EAAE,cAAc,CAAC;IACxB,mEAAmE;IACnE,UAAU,EAAE,OAAO,CAAC;IACpB,2EAA2E;IAC3E,QAAQ,EAAE,cAAc,CAAC;IACzB,gCAAgC;IAChC,KAAK,EAAE,YAAY,CAAC;IACpB,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,YAAY,EAAE,OAAO,CAAC;IACtB,sCAAsC;IACtC,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IAClC,0EAA0E;IAC1E,eAAe,EAAE,qBAAqB,EAAE,CAAC;IACzC,wEAAwE;IACxE,aAAa,EAAE,eAAe,GAAG,IAAI,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,yFAAyF;IACzF,UAAU,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;CACzD;AAID;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,0BAA0B,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAoC/B;AA6BD;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,eAAe,GACrB,qBAAqB,EAAE,CA6BzB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKxE;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,qBAAqB,EAAE,CAmBzB;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,eAAe,GACrB,YAAY,CAEd;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG;IAClD,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,cAAc,CAAC;CAC1B,CAIA"}

package/dist/codegen/surface-snapshot.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Lexicon API surface snapshot and diff.
+ *
+ * Extracts a stable, serializable representation of a lexicon's public API
+ * surface from the generated lexicon JSON. Diffs a fresh snapshot against a
+ * committed baseline and classifies each change as additive or breaking.
+ *
+ * The surface is derived from the lexicon registry JSON that every lexicon's
+ * `generate` step writes to `src/generated/<name>.json`. Resource and
+ * property-type names, together with their structural metadata (attrs, props,
+ * kind), form the baseline. The generated .d.ts is not used for diffing
+ * because: (a) it is not self-describing without parsing TypeScript, and
+ * (b) the registry JSON already encodes everything a consumer needs.
+ */
+/**
+ * A single entry in the surface snapshot.
+ * "resource" entries carry attrs and props; "property" entries are lightweight.
+ */
+export interface SurfaceEntry {
+    kind: "resource" | "property";
+    /** The cloud-provider resource type string (e.g. "AWS::S3::Bucket"). */
+    resourceType: string;
+    /** Readonly attribute names (resource entries only). */
+    attrs?: string[];
+    /**
+     * Property names with their required flag. Stored as
+     * `name:required` strings (e.g. "BucketName:false", "Tags:false").
+     * Sorting is stable so the snapshot is deterministic.
+     */
+    props?: string[];
+    /** Names that are create-only / immutable after creation. */
+    createOnly?: string[];
+    /**
+     * Whether the resource supports tagging.
+     * Present when known; absent means not known or not applicable.
+     */
+    taggable?: boolean;
+}
+/**
+ * The complete surface snapshot for one lexicon.
+ */
+export interface SurfaceSnapshot {
+    /**
+     * Schema version for forward-compatibility. Bump when the shape changes
+     * in a way that makes old snapshots unreadable by newer tooling.
+     */
+    schemaVersion: 1;
+    /** When this snapshot was generated (ISO 8601 UTC). */
+    generatedAt: string;
+    /**
+     * Per-entry map keyed by the TS export name (e.g. "Bucket",
+     * "Bucket_Tag"). Sorted alphabetically for stable diffs.
+     */
+    entries: Record<string, SurfaceEntry>;
+}
+export type ChangeSeverity = "additive" | "breaking" | "none";
+export interface AddedEntry {
+    name: string;
+    entry: SurfaceEntry;
+}
+export interface RemovedEntry {
+    name: string;
+    entry: SurfaceEntry;
+}
+export interface ChangedEntry {
+    name: string;
+    /** New resourceType (breaking). */
+    resourceTypeChanged?: {
+        before: string;
+        after: string;
+    };
+    /** kind changed from resource to property or vice-versa (breaking). */
+    kindChanged?: {
+        before: string;
+        after: string;
+    };
+    /** Props that were removed (breaking). */
+    removedProps?: string[];
+    /** Props that switched from optional to required (breaking). */
+    nowRequired?: string[];
+    /** Attrs that were removed (breaking). */
+    removedAttrs?: string[];
+    /** Props that were newly added. */
+    addedProps?: string[];
+    /** Props that switched from required to optional (additive). */
+    nowOptional?: string[];
+    /** Attrs that were newly added. */
+    addedAttrs?: string[];
+    /** createOnly set changed. */
+    createOnlyChanged?: {
+        before: string[];
+        after: string[];
+    };
+    /** taggable flag changed. */
+    taggableChanged?: {
+        before?: boolean;
+        after?: boolean;
+    };
+}
+export interface SurfaceDelta {
+    added: AddedEntry[];
+    changed: ChangedEntry[];
+    removed: RemovedEntry[];
+    /**
+     * Rolled-up severity. "none" means no surface changes at all.
+     * "additive" means only new resources / new optional props / new attrs.
+     * "breaking" means any removal or change that could break existing consumers.
+     */
+    severity: ChangeSeverity;
+}
+/**
+ * Extract a surface snapshot from the lexicon JSON and the generated index.d.ts.
+ *
+ * The lexicon JSON contains the resource/property registry (names, kinds,
+ * attrs, createOnly, tagging). The .d.ts provides per-prop names and their
+ * required flags for resource constructor shapes.
+ *
+ * @param lexiconJSON   Contents of `src/generated/<name>.json`
+ * @param typesDTS      Contents of `src/generated/index.d.ts`
+ */
+export declare function extractSurface(lexiconJSON: string, typesDTS: string): SurfaceSnapshot;
+/**
+ * Lightweight extractor: pull constructor prop names and required flags
+ * from a `.d.ts` string.
+ *
+ * Handles the pattern generated by writeConstructor:
+ * ```
+ * export declare class Bucket {
+ *   constructor(props: {
+ *     BucketName?: string;
+ *     Tags: Bucket_Tag[];
+ *   }, attributes?: CFResourceAttributes);
+ * }
+ * ```
+ *
+ * Returns a Map<className, ["PropName:required", ...]>
+ * where each entry is sorted alphabetically.
+ */
+export declare function extractPropsFromDts(dts: string): Map<string, string[]>;
+/**
+ * Diff a fresh snapshot against a committed baseline.
+ *
+ * Classification rules:
+ * - Added entry → additive
+ * - Removed entry → breaking
+ * - Changed entry:
+ *   - resourceType changed → breaking
+ *   - kind changed → breaking
+ *   - prop removed → breaking
+ *   - prop now required (was optional) → breaking
+ *   - attr removed → breaking
+ *   - createOnly changed → breaking (changes immutability contract)
+ *   - taggable: false→undefined or true→false → breaking
+ *   - prop added (optional) → additive
+ *   - prop now optional (was required) → additive
+ *   - attr added → additive
+ *   - taggable: false→true or undefined→true → additive
+ */
+export declare function diffSurface(baseline: SurfaceSnapshot, fresh: SurfaceSnapshot): SurfaceDelta;
+/**
+ * Serialize a snapshot to stable JSON. Suitable for writing to
+ * `surface.snapshot.json` at the lexicon root.
+ */
+export declare function serializeSnapshot(snapshot: SurfaceSnapshot): string;
+/**
+ * Parse a snapshot from JSON.
+ */
+export declare function parseSnapshot(json: string): SurfaceSnapshot;
+/**
+ * Render a surface delta as human-readable text.
+ */
+export declare function formatDelta(delta: SurfaceDelta): string;
+//# sourceMappingURL=surface-snapshot.d.ts.map

package/dist/codegen/surface-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-snapshot.d.ts","sourceRoot":"","sources":["../../src/codegen/surface-snapshot.ts"],"names":[],"mappings":"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"}

package/dist/codegen/version-bump.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 0.x-aware version bumping, shared by the pinned upgrade Op (#549) and the
+ * rolling drift re-baseline (#616). Centralised here so the single source of
+ * truth for the semver rule can't drift between the two callers.
+ */
+/** Surface-change severity that drives a bump. */
+export type BumpSeverity = "additive" | "breaking" | "none";
+/**
+ * Compute a bumped semver from a current version and a surface severity.
+ *
+ * Pre-1.0 (major 0) never auto-promotes to 1.0.0: breaking → minor, additive →
+ * patch. At >= 1.0.0: breaking → major, additive → minor. Returns null for
+ * "none" or a version string that can't be parsed as MAJOR.MINOR.PATCH.
+ */
+export declare function bumpForSeverity(current: string, severity: BumpSeverity): string | null;
+/**
+ * Read a package.json, set its `version`, and write it back — preserving all
+ * other fields, 2-space indent, and a trailing newline.
+ */
+export declare function bumpPackageJsonVersion(packageJsonPath: string, newVersion: string): void;
+//# sourceMappingURL=version-bump.d.ts.map

package/dist/codegen/version-bump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-bump.d.ts","sourceRoot":"","sources":["../../src/codegen/version-bump.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,kDAAkD;AAClD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;AAE5D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,MAAM,GAAG,IAAI,CAStF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAKxF"}