@geonosis/release 1.3.0 → 2.0.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { ReportEnvelope } from '@geonosis/ratchet';
+
 /** 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 +14,45 @@ 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, and how that one is installed. */
+type SmokeSnapshotConfig = {
+    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 +61,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 +244,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 +372,178 @@ 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[];
+type SnapshotRecord = {
+    at: string;
+    bytes: number;
+    commands: Record<SmokePhase, Command>;
+    excluded: string[];
+    files: number;
+    from: string;
+    lockfile: string;
+    manager: Manager;
+    manifests: {
+        path: string;
+        versions: Record<string, string>;
+    }[];
+    name: string;
+};
+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 = {
+    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;
+type SmokeSkip = {
+    name: string;
+    why: string;
+};
+type SmokeSweep = {
+    comparisons: SmokeComparison[];
+    skipped: SmokeSkip[];
+};
+/**
+ * Every snapshot the release expects, read in turn.
+ *
+ * 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: {
+    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: {
+        install?: string;
+        name: string;
+    }[];
+}) => SmokeSweep;
+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 +579,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 { BASELINE_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 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 SmokeSkip, type SmokeSweep, type SnapshotRecord, type Verdict, WHY_VERSION_IDENTITY, addSqlIn, askRegistry, censusOf, compareToBaseline, declaredIn, driftBetween, formatBaseline, formatDeployed, formatMigrations, formatPlan, formatProve, formatPublished, formatSchema, formatSmoke, formatSnapshot, formatSweep, formatVerdict, markersIn, packRc, parseJsonc, parseReleaseConfig, parseToml, promisedButNotPacked, prove, proveOver, readBaseline, readDeployed, readReleaseConfig, readSnapshot, readWrangler, recordBaseline, refusalsIn, registryPathOf, rewriteManifests, runDeployed, runMigrations, runPlan, runPublished, runSchema, runSmoke, runSnapshot, smokeEnvelope, snapshotDir, statementsOf, sweepEnvelope, sweepSmoke };

package/dist/index.js

@@ -1,62 +1,126 @@
 import {
+  BASELINE_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,
+  askRegistry,
+  censusOf,
+  compareToBaseline,
   declaredIn,
   driftBetween,
+  formatBaseline,
   formatDeployed,
   formatMigrations,
   formatPlan,
   formatProve,
+  formatPublished,
+  formatSchema,
+  formatSmoke,
+  formatSnapshot,
+  formatSweep,
   formatVerdict,
   markersIn,
+  packRc,
   parseJsonc,
   parseReleaseConfig,
   parseToml,
+  promisedButNotPacked,
   prove,
   proveOver,
+  readBaseline,
   readDeployed,
   readReleaseConfig,
+  readSnapshot,
   readWrangler,
+  recordBaseline,
   refusalsIn,
+  registryPathOf,
+  rewriteManifests,
   runDeployed,
   runMigrations,
   runPlan,
-  statementsOf
-} from "./chunk-D5IC766I.js";
+  runPublished,
+  runSchema,
+  runSmoke,
+  runSnapshot,
+  smokeEnvelope,
+  snapshotDir,
+  statementsOf,
+  sweepEnvelope,
+  sweepSmoke
+} from "./chunk-KQIWTXQP.js";
 export {
+  BASELINE_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,
+  askRegistry,
+  censusOf,
+  compareToBaseline,
   declaredIn,
   driftBetween,
+  formatBaseline,
   formatDeployed,
   formatMigrations,
   formatPlan,
   formatProve,
+  formatPublished,
+  formatSchema,
+  formatSmoke,
+  formatSnapshot,
+  formatSweep,
   formatVerdict,
   markersIn,
+  packRc,
   parseJsonc,
   parseReleaseConfig,
   parseToml,
+  promisedButNotPacked,
   prove,
   proveOver,
+  readBaseline,
   readDeployed,
   readReleaseConfig,
+  readSnapshot,
   readWrangler,
+  recordBaseline,
   refusalsIn,
+  registryPathOf,
+  rewriteManifests,
   runDeployed,
   runMigrations,
   runPlan,
-  statementsOf
+  runPublished,
+  runSchema,
+  runSmoke,
+  runSnapshot,
+  smokeEnvelope,
+  snapshotDir,
+  statementsOf,
+  sweepEnvelope,
+  sweepSmoke
 };