@geonosis/release 1.4.0 → 2.1.0

package/dist/index.d.ts

@@ -1,3 +1,41 @@
+import { ReportEnvelope } from '@geonosis/ratchet';
+
+type AdoptionVerdict = 'BEHIND' | 'FLOOR UNDECLARED' | 'INCOHERENT' | 'UNJUDGED';
+type AdoptionFinding = {
+    consumer: string;
+    detail: string;
+    name: string;
+    verdict: AdoptionVerdict;
+};
+type AdoptionConsumer = {
+    /** How many specs naming a package of this workspace that consumer's manifests declare. */
+    declared: number;
+    findings: AdoptionFinding[];
+    name: string;
+};
+type AdoptionReport = {
+    considered: number;
+    consumers: AdoptionConsumer[];
+    excused: {
+        path: string;
+        reason: string;
+    }[];
+    /** The registry the current numbers came from, or undefined when they came off this workspace. */
+    registry: string | undefined;
+    versions: Record<string, string>;
+};
+declare const runAdoption: ({ declared, registry, root, }: {
+    declared: {
+        name: string;
+    }[];
+    registry?: string;
+    root: string;
+}) => Promise<AdoptionReport>;
+declare const formatAdoption: (report: AdoptionReport) => string;
+declare const ADOPTION_TOOL = "release-adoption";
+declare const ADOPTION_NEXT = "geonosis-release adoption --json and read `consumers` \u2014 every declared consumer leaves by exactly one door, read or excused, and a release review carries one row per consumer from it (D-061)";
+declare const adoptionEnvelope: (report: AdoptionReport, durationMs: number) => ReportEnvelope;
+
 /** The dialects the gate can route to. A dialect is never sniffed: it is what the repo declared. */
 type Dialect = 'mikro-orm-ts' | 'postgres' | 'sqlite';
 type Phase = 'down' | 'up';
@@ -12,6 +50,49 @@ type MigrationDir = {
 type ProofConfig = {
     mustAssertVersion?: boolean;
 };
+/** One domain's shipped migrations, and the tables that are ITS to name. */
+type SchemaDomain = {
+    dir: string;
+    name: string;
+    tables: string[];
+};
+type SchemaConfig = {
+    domains: SchemaDomain[];
+    sessionVariables: string[];
+};
+type SchemaFinding = {
+    line: number;
+    path: string;
+    why: string;
+};
+type SchemaReport = {
+    dirs: string[];
+    files: string[];
+    findings: SchemaFinding[];
+    ok: boolean;
+    read: number;
+    unreadable: {
+        path: string;
+        why: string;
+    }[];
+};
+/**
+ * One consumer tree a release must be read against, how that one is installed, and the commands
+ * that are ITS gates when the three script names are not what that tree calls them.
+ */
+type SmokeSnapshotConfig = {
+    commands?: Partial<Record<'doctor' | 'lint' | 'typecheck', string>>;
+    install?: string;
+    name: string;
+};
+/**
+ * What the release check asks of consumers. Law 6: a repo that names no snapshot gets no sweep —
+ * and is told so, rather than passing over nothing.
+ */
+type SmokeConfig = {
+    exclude?: string[];
+    snapshots?: SmokeSnapshotConfig[];
+};
 /**
  * Law 6: every directory, dialect, secret name and worker is an OPTION. The defaults are empty, and
  * a command that needs one it has not got refuses with 2 rather than measuring nothing and
@@ -20,7 +101,10 @@ type ProofConfig = {
 type ReleaseConfig = {
     migrations?: MigrationDir[];
     proof?: ProofConfig;
+    /** Absent when the repo never declared the block — which is not the same as declaring it empty. */
+    schema?: SchemaConfig;
     secrets?: string[];
+    smoke?: SmokeConfig;
     steps?: string[];
     workers?: string[];
     wrangler?: string[];
@@ -200,6 +284,106 @@ declare const prove: (cwd: string, stub?: string) => Promise<ProveOutcome>;
 declare const formatProve: (outcome: ProveOutcome) => string;
 declare const formatVerdict: (verdict: Verdict) => string;
 
+type PublishedVerdict = 'ABSENT' | 'BEHIND' | 'MATCH' | 'UNREACHABLE';
+type PublishedLine = {
+    at: string;
+    latest: string | undefined;
+    local: string;
+    name: string;
+    verdict: PublishedVerdict;
+    why: string;
+};
+type PublishedReport = {
+    considered: number;
+    excused: {
+        path: string;
+        reason: string;
+    }[];
+    lines: PublishedLine[];
+    ok: boolean;
+    registry: string;
+    sweeps: number;
+    unreachable: number;
+    waitedMs: number;
+};
+type Local = {
+    at: string;
+    name: string;
+    version: string;
+};
+type Census = {
+    excused: {
+        path: string;
+        reason: string;
+    }[];
+    locals: Local[];
+};
+/**
+ * Every workspace in the tree, split into the ones a publish is a claim about and the ones it is
+ * not. Both halves are kept: a check that quietly dropped the manifests it skipped could not say
+ * what its denominator was, and "21 of 21" over a tree of 22 is exactly the sample that announced
+ * a release the group had not finished (#147).
+ */
+declare const censusOf: (root: string) => Census;
+declare const EXISTS_BUT = "exists but no version matching";
+/**
+ * #147 — the release is not the publish exiting zero; it is the GROUP resolving from npm.
+ *
+ * Every workspace, every sweep, with no sampling: the one entry point nobody checked is the one a
+ * consumer's bump reads, and it fails in their tree as a nested duplicate rather than as an error
+ * anyone here would see.
+ */
+declare const runPublished: ({ pollMs, registry, root, waitSeconds, }: {
+    pollMs?: number;
+    registry?: string;
+    root: string;
+    waitSeconds?: number;
+}) => Promise<PublishedReport>;
+declare const formatPublished: (report: PublishedReport) => string;
+
+/**
+ * What a registry says about one package name.
+ *
+ * Three answers and not two, because a release check and a bump act differently on each: `absent`
+ * is the ~4-minute window in which a name published a moment ago still 404s, `present` with the
+ * wanted version missing is a manager's cached manifest or a publish that left a package out, and
+ * `unreachable` is not a verdict about the package at all.
+ */
+type RegistryAnswer = {
+    kind: 'absent';
+    name: string;
+} | {
+    kind: 'present';
+    latest: string | undefined;
+    name: string;
+    versions: string[];
+} | {
+    kind: 'unreachable';
+    name: string;
+    why: string;
+};
+declare const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+/** `@scope/name` → `@scope%2fname`, which is how a registry addresses a scoped packument. */
+declare const registryPathOf: (name: string) => string;
+/**
+ * The registry asked over HTTP, and never through the package manager.
+ *
+ * `npm view` and `bun pm view` answer out of the MANAGER's manifest cache, which is the thing that
+ * lied: a consumer's bump aborted on "no version matching 1.4.0" minutes after 1.4.0 was published,
+ * because bun had cached the packument from before it (measured 2026-09-01, #147). A check whose
+ * job is to catch a stale read must not be reading the same cache.
+ */
+declare const askRegistry: ({ name, registry, timeoutMs, }: {
+    name: string;
+    registry?: string;
+    timeoutMs?: number;
+}) => Promise<RegistryAnswer>;
+
+declare const runSchema: ({ root }: {
+    root: string;
+}) => SchemaReport;
+declare const formatSchema: (report: SchemaReport) => string;
+
 type Request = {
     step: 'promote';
     versionId: string;
@@ -228,6 +412,215 @@ declare class Runner {
     close(): void;
 }
 
+/**
+ * Where a consumer's bytes live while the release is being read against them.
+ *
+ * D-048: a consumer tree is private, and a copy of one that reaches a commit cannot be taken back.
+ * The directory is under `.geonosis/`, which every repo in this kit's orbit already ignores, and
+ * `smoke snapshot` asks git — in the tree it is about to write into — whether that is still true
+ * before it copies a single file.
+ */
+declare const SNAPSHOTS_DIR = ".geonosis/consumer-snapshots";
+/** The managers a snapshot can be installed with here, each measured on this machine. */
+type Manager = 'bun' | 'pnpm';
+/**
+ * Directories a consumer builds or installs into. They are excluded by name at every depth: the
+ * snapshot is the SOURCE of a tree, and the install the smoke runs is the thing under test.
+ */
+declare const EXCLUDED_DIRS: string[];
+/** What a phase runs: a script of theirs, a binary their install put there, or nothing at all. */
+type Command = {
+    exec: string;
+} | {
+    run: string;
+} | {
+    why: string;
+};
+type SmokePhase = 'doctor' | 'lint' | 'typecheck';
+declare const PHASES: SmokePhase[];
+/** Where the source tree stood, or the sentence saying why nothing here could say. */
+type RecordedCommit = {
+    sha: string;
+} | {
+    why: string;
+};
+type SnapshotRecord = {
+    at: string;
+    bytes: number;
+    /** Absent in a recording taken before this was recorded at all. */
+    commit?: RecordedCommit;
+    commands: Record<SmokePhase, Command>;
+    excluded: string[];
+    files: number;
+    from: string;
+    lockfile: string;
+    manager: Manager;
+    manifests: {
+        path: string;
+        versions: Record<string, string>;
+    }[];
+    name: string;
+};
+/** git asked in THEIR tree, and only ever asked: law 5 forbids this tool writing a byte there. */
+declare const headOf: (from: string) => RecordedCommit;
+declare const snapshotDir: (root: string, name: string) => string;
+declare const readSnapshot: (root: string, name: string) => SnapshotRecord;
+type SnapshotInput = {
+    exclude?: string[];
+    from: string;
+    name: string;
+    named: Partial<Record<SmokePhase, string>>;
+    replace: boolean;
+    root: string;
+};
+declare const runSnapshot: (input: SnapshotInput) => SnapshotRecord;
+declare const formatSnapshot: (record: SnapshotRecord) => string;
+
+/** What a phase did, or the sentence saying there was nothing of theirs to do it with. */
+type PhaseOutcome = {
+    code: number;
+    command: string;
+    lines: string[];
+    ok: boolean;
+    phase: SmokePhase;
+} | {
+    phase: SmokePhase;
+    why: string;
+};
+type Packed = {
+    files: string[];
+    name: string;
+    tarball: string;
+    version: string;
+};
+type SmokeBaseline = {
+    at: string;
+    packed: {
+        name: string;
+        version: string;
+    }[];
+    phases: PhaseOutcome[];
+    rc: string;
+};
+type SmokeComparison = {
+    broken: {
+        lines: string[];
+        phase: SmokePhase;
+    }[];
+    findings: string[];
+    known: SmokePhase[];
+    mended: SmokePhase[];
+    name: string;
+    ok: boolean;
+    outcomes: PhaseOutcome[];
+    refused: {
+        phase: SmokePhase;
+        why: string;
+    }[];
+};
+declare const BASELINE_FILE = "baseline.json";
+/**
+ * The tarballs, because a tarball is what a consumer installs.
+ *
+ * Escape (1) lived exactly here: the declarations were in the tree, the build made them, and the
+ * `files` list did not carry them — so every kit test passed and the first consumer import was
+ * TS7016. Nothing short of packing can see that.
+ */
+declare const packRc: (rc: string, into: string) => Packed[];
+/**
+ * A tarball that promises declarations and does not carry them, read off the pack itself.
+ *
+ * The consumer's compiler says the same thing one import later — but only about the packages that
+ * consumer imports. This says it about every package in the release.
+ */
+declare const promisedButNotPacked: (rc: string, packed: Packed[]) => string[];
+/** The snapshot's manifests, pointed at the tarballs instead of at the versions they name. */
+declare const rewriteManifests: (tree: string, manifests: string[], packed: Packed[]) => {
+    name: string;
+    path: string;
+}[];
+type RunInput = {
+    commands?: Partial<Record<SmokePhase, string>>;
+    install?: string;
+    name: string;
+    rc?: string;
+    root: string;
+};
+declare const recordBaseline: (input: RunInput) => SmokeBaseline;
+declare const readBaseline: (root: string, name: string) => SmokeBaseline;
+declare const compareToBaseline: (name: string, baseline: SmokeBaseline, outcomes: PhaseOutcome[], findings: string[]) => SmokeComparison;
+declare const runSmoke: (input: RunInput) => SmokeComparison;
+/**
+ * What the sweep can say about WHEN a recording was taken: that its source has moved on, or that
+ * the question cannot be asked of it at all.
+ */
+type SweepNote = {
+    stale: string;
+} | {
+    undated: string;
+};
+/** One declared consumer's turn in the sweep, in the order the repo declared it. */
+type SweepEntry = {
+    comparison: SmokeComparison;
+    name: string;
+    note?: SweepNote;
+} | {
+    name: string;
+    why: string;
+};
+type SmokeSweep = {
+    entries: SweepEntry[];
+};
+type WantedSnapshot = {
+    commands?: Partial<Record<SmokePhase, string>>;
+    install?: string;
+    name: string;
+};
+/**
+ * Where a consumer tree that has never been recorded lives on THIS machine.
+ *
+ * A never-recorded name has no `from` to look at, so the paths are declared here — uncommitted,
+ * under the directory D-048 already keeps out of git, because a machine's checkout layout is one
+ * developer's and not the repo's.
+ */
+declare const CONSUMER_TREES_FILE = ".geonosis/consumer-trees.local.json";
+/**
+ * Every snapshot the release expects, read in turn, in the order the repo declared them.
+ *
+ * A tree that is not on this machine is SKIPPED with the sentence saying so — a laptop without the
+ * consumer trees must not fail, it must say what it could not ask. The skip is not free: its three
+ * commands stay in the envelope's denominator as excused, so a sweep that asked nothing cannot be
+ * read as a sweep that asked everything.
+ */
+declare const sweepSmoke: (input: {
+    /** Declared names this run is excused from reading, each said out loud on the command line. */
+    absent?: string[];
+    rc?: string;
+    root: string;
+    /**
+     * Whether an absent snapshot is a skip. It is when the repo NAMED the set and this laptop has
+     * some of it; it is not when a caller asked for one tree by name — that question was asked and
+     * has to be answered, not stepped around.
+     */
+    skipMissing: boolean;
+    wanted: WantedSnapshot[];
+}) => SmokeSweep;
+declare const comparisonsIn: (sweep: SmokeSweep) => SmokeComparison[];
+declare const formatSweep: (sweep: SmokeSweep) => string;
+declare const sweepEnvelope: (sweep: SmokeSweep, durationMs: number) => ReportEnvelope;
+declare const formatSmoke: (comparison: SmokeComparison) => string;
+declare const formatBaseline: (name: string, baseline: SmokeBaseline) => string;
+declare const SMOKE_TOOL = "release-smoke";
+declare const SMOKE_NEXT = "geonosis-release smoke run --snapshot <name> --json and read `outcomes` \u2014 every phase the snapshot named leaves by exactly one door: read, excused with the sentence saying there was nothing of theirs to run, or refused because this run and the baseline are not comparable";
+/**
+ * The three commands as a census.
+ *
+ * The denominator is what the SNAPSHOT named, not what this run managed to do: a smoke that skipped
+ * the doctor because the bin was not installed and reported OK over two commands is the shape this
+ * whole workstream exists to catch.
+ */
+declare const smokeEnvelope: (comparison: SmokeComparison, durationMs: number) => ReportEnvelope;
+
 type Extracted = {
     line: number;
     sql: string;
@@ -263,4 +656,4 @@ declare const statementsOf: (sql: string) => string;
 /** One refusal per verb per file, at the line of that verb's first occurrence. */
 declare const refusalsIn: (path: string, body: string, firstLine?: number) => Refusal[];
 
-export { DEPLOYED_FILE, type Declared, type Deployed, type DeployedReport, type Dialect, type Drift, type MigrationDir, type MigrationsReport, NARROWING, NOTHING_SAYS, PLANTS, type Phase, type PlanReport, type ProveOutcome, type Refusal, type ReleaseConfig, Runner, STEPS, type Verdict, WHY_VERSION_IDENTITY, addSqlIn, declaredIn, driftBetween, formatDeployed, formatMigrations, formatPlan, formatProve, formatVerdict, markersIn, parseJsonc, parseReleaseConfig, parseToml, prove, proveOver, readDeployed, readReleaseConfig, readWrangler, refusalsIn, runDeployed, runMigrations, runPlan, statementsOf };
+export { ADOPTION_NEXT, ADOPTION_TOOL, type AdoptionConsumer, type AdoptionFinding, type AdoptionReport, type AdoptionVerdict, BASELINE_FILE, CONSUMER_TREES_FILE, type Command, DEFAULT_REGISTRY, DEPLOYED_FILE, type Declared, type Deployed, type DeployedReport, type Dialect, type Drift, EXCLUDED_DIRS, EXISTS_BUT, type Manager, type MigrationDir, type MigrationsReport, NARROWING, NOTHING_SAYS, PHASES, PLANTS, type Packed, type Phase, type PhaseOutcome, type PlanReport, type ProveOutcome, type PublishedLine, type PublishedReport, type PublishedVerdict, type RecordedCommit, type Refusal, type RegistryAnswer, type ReleaseConfig, Runner, SMOKE_NEXT, SMOKE_TOOL, SNAPSHOTS_DIR, STEPS, type SchemaConfig, type SchemaDomain, type SchemaFinding, type SchemaReport, type SmokeBaseline, type SmokeComparison, type SmokePhase, type SmokeSweep, type SnapshotRecord, type SweepEntry, type SweepNote, type Verdict, WHY_VERSION_IDENTITY, type WantedSnapshot, addSqlIn, adoptionEnvelope, askRegistry, censusOf, compareToBaseline, comparisonsIn, declaredIn, driftBetween, formatAdoption, formatBaseline, formatDeployed, formatMigrations, formatPlan, formatProve, formatPublished, formatSchema, formatSmoke, formatSnapshot, formatSweep, formatVerdict, headOf, markersIn, packRc, parseJsonc, parseReleaseConfig, parseToml, promisedButNotPacked, prove, proveOver, readBaseline, readDeployed, readReleaseConfig, readSnapshot, readWrangler, recordBaseline, refusalsIn, registryPathOf, rewriteManifests, runAdoption, runDeployed, runMigrations, runPlan, runPublished, runSchema, runSmoke, runSnapshot, smokeEnvelope, snapshotDir, statementsOf, sweepEnvelope, sweepSmoke };

package/dist/index.js

@@ -1,62 +1,142 @@
 import {
+  ADOPTION_NEXT,
+  ADOPTION_TOOL,
+  BASELINE_FILE,
+  CONSUMER_TREES_FILE,
+  DEFAULT_REGISTRY,
   DEPLOYED_FILE,
+  EXCLUDED_DIRS,
+  EXISTS_BUT,
   NARROWING,
   NOTHING_SAYS,
+  PHASES,
   PLANTS,
   Runner,
+  SMOKE_NEXT,
+  SMOKE_TOOL,
+  SNAPSHOTS_DIR,
   STEPS,
   WHY_VERSION_IDENTITY,
   addSqlIn,
+  adoptionEnvelope,
+  askRegistry,
+  censusOf,
+  compareToBaseline,
+  comparisonsIn,
   declaredIn,
   driftBetween,
+  formatAdoption,
+  formatBaseline,
   formatDeployed,
   formatMigrations,
   formatPlan,
   formatProve,
+  formatPublished,
+  formatSchema,
+  formatSmoke,
+  formatSnapshot,
+  formatSweep,
   formatVerdict,
+  headOf,
   markersIn,
+  packRc,
   parseJsonc,
   parseReleaseConfig,
   parseToml,
+  promisedButNotPacked,
   prove,
   proveOver,
+  readBaseline,
   readDeployed,
   readReleaseConfig,
+  readSnapshot,
   readWrangler,
+  recordBaseline,
   refusalsIn,
+  registryPathOf,
+  rewriteManifests,
+  runAdoption,
   runDeployed,
   runMigrations,
   runPlan,
-  statementsOf
-} from "./chunk-D5IC766I.js";
+  runPublished,
+  runSchema,
+  runSmoke,
+  runSnapshot,
+  smokeEnvelope,
+  snapshotDir,
+  statementsOf,
+  sweepEnvelope,
+  sweepSmoke
+} from "./chunk-MZWAN6WT.js";
 export {
+  ADOPTION_NEXT,
+  ADOPTION_TOOL,
+  BASELINE_FILE,
+  CONSUMER_TREES_FILE,
+  DEFAULT_REGISTRY,
   DEPLOYED_FILE,
+  EXCLUDED_DIRS,
+  EXISTS_BUT,
   NARROWING,
   NOTHING_SAYS,
+  PHASES,
   PLANTS,
   Runner,
+  SMOKE_NEXT,
+  SMOKE_TOOL,
+  SNAPSHOTS_DIR,
   STEPS,
   WHY_VERSION_IDENTITY,
   addSqlIn,
+  adoptionEnvelope,
+  askRegistry,
+  censusOf,
+  compareToBaseline,
+  comparisonsIn,
   declaredIn,
   driftBetween,
+  formatAdoption,
+  formatBaseline,
   formatDeployed,
   formatMigrations,
   formatPlan,
   formatProve,
+  formatPublished,
+  formatSchema,
+  formatSmoke,
+  formatSnapshot,
+  formatSweep,
   formatVerdict,
+  headOf,
   markersIn,
+  packRc,
   parseJsonc,
   parseReleaseConfig,
   parseToml,
+  promisedButNotPacked,
   prove,
   proveOver,
+  readBaseline,
   readDeployed,
   readReleaseConfig,
+  readSnapshot,
   readWrangler,
+  recordBaseline,
   refusalsIn,
+  registryPathOf,
+  rewriteManifests,
+  runAdoption,
   runDeployed,
   runMigrations,
   runPlan,
-  statementsOf
+  runPublished,
+  runSchema,
+  runSmoke,
+  runSnapshot,
+  smokeEnvelope,
+  snapshotDir,
+  statementsOf,
+  sweepEnvelope,
+  sweepSmoke
 };