supaschema 0.1.0-rc.1

package/dist/cli.js

@@ -0,0 +1,239 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { checkMigrationSql } from "./check.js";
+import { renderCheckReport } from "./check-reporters.js";
+import { defaultTreeSource, latestMigrationFile, migrationFiles, resolveMigrationsDir, resolveSourceDefaults, } from "./cli-defaults.js";
+import { filterModel, registerDiffCommands } from "./cli-diff.js";
+import { registerReportCommands } from "./cli-reports.js";
+import { registerToolCommands } from "./cli-tools.js";
+import { defaultConfigFile, loadConfig } from "./config.js";
+import { resolveDatabaseUrl } from "./database-url.js";
+import { diagnosticCatalog, formatDiagnostics, hasErrors } from "./diagnostics.js";
+import { selfCheckCatalog } from "./selfcheck.js";
+import { extractSourceModel } from "./source.js";
+import { verifyMigration } from "./verify.js";
+const cliVersion = await readPackageVersion();
+const program = new Command();
+program
+    .name("supaschema")
+    .description("Generate deterministic, replay-safe PostgreSQL/Supabase migrations from SQL trees.")
+    .option("--config <path>", "explicit config file path (.json, .mjs, or .js)")
+    .option("--env <name>", "named environment from config.environments for the database URL")
+    .option("--quiet", "suppress diagnostic output on stderr")
+    .version(cliVersion)
+    .addHelpText("after", `
+Exit codes:
+  0  success
+  1  runtime error (bad arguments, unreadable input, crash)
+  2  diagnostics contained at least one error
+  3  --fail-on-diff was set and the plan contained operations
+`);
+program
+    .command("init")
+    .description("Create supaschema.config.json in the current directory.")
+    .action(async () => {
+    const path = resolve(process.cwd(), "supaschema.config.json");
+    try {
+        await writeFile(path, defaultConfigFile, { flag: "wx" });
+        process.stdout.write(`${path}\n`);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+            process.stderr.write("supaschema.config.json already exists\n");
+            process.exitCode = 1;
+            return;
+        }
+        throw error;
+    }
+});
+program
+    .command("inspect")
+    .option("--from <source>", "source to inspect (default: the config schema tree)")
+    .option("--schema <names>", "comma-separated schema filter")
+    .description("Extract and print a deterministic schema model.")
+    .action(async (options) => {
+    const config = await loadCliConfig();
+    const source = options.from ?? defaultTreeSource(config);
+    const model = filterModel(await extractSourceModel(source, { config }), options.schema);
+    printDiagnostics(model.diagnostics);
+    process.stdout.write(`${JSON.stringify(model, null, 2)}\n`);
+    if (hasErrors(model.diagnostics)) {
+        process.exitCode = 2;
+    }
+});
+registerDiffCommands(program, {
+    cliVersion,
+    loadCliConfig,
+    printDiagnostics,
+    resolveCliDatabaseUrl,
+});
+registerReportCommands(program, { loadCliConfig, printDiagnostics, resolveCliDatabaseUrl });
+registerToolCommands(program, { loadCliConfig, printDiagnostics, resolveCliDatabaseUrl });
+program
+    .command("check")
+    .argument("[migrations...]", "migration files (default: every .sql in config.migrationsDir)")
+    .option("--reporter <name>", "text | github | sarif | json", "text")
+    .description("Validate replay-safety and parser diagnostics for migration files (shell globs expand to a directory gate; `-` reads stdin; zero args checks the migrations directory).")
+    .action(async (migrationArgs, options) => {
+    const config = await loadCliConfig();
+    const migrationPaths = migrationArgs.length > 0
+        ? migrationArgs
+        : await migrationFiles(resolve(process.cwd(), config.migrationsDir));
+    if (migrationPaths.length === 0) {
+        process.stderr.write(`no migrations found in ${config.migrationsDir}\n`);
+        return;
+    }
+    const results = [];
+    for (const migrationPath of migrationPaths) {
+        const sql = migrationPath === "-" ? await readStdin() : await readFile(migrationPath, "utf8");
+        const diagnostics = await checkMigrationSql(sql, { config, cwd: process.cwd() });
+        results.push({ diagnostics, file: migrationPath === "-" ? "<stdin>" : migrationPath });
+    }
+    const reporter = options.reporter;
+    const report = renderCheckReport(reporter, results);
+    if (report.length > 0) {
+        process.stdout.write(report);
+    }
+    if (results.some((entry) => hasErrors(entry.diagnostics))) {
+        process.exitCode = 2;
+        return;
+    }
+    if (reporter === "text") {
+        process.stdout.write(migrationPaths.length > 1 ? `ok (${migrationPaths.length} files)\n` : "ok\n");
+    }
+});
+program
+    .command("verify")
+    .option("--from <source>", "source model before the change (default: database, then git:HEAD)")
+    .option("--to <target>", "source model after the change (default: the config schema tree)")
+    .option("--migration <file>", "migration SQL file to apply twice (default: newest .sql in config.migrationsDir)")
+    .option("--migrations-dir <dir>", "migrations directory (default: config.migrationsDir)")
+    .option("--database-url <url>", "PostgreSQL URL whose role can create temporary databases (default: SUPASCHEMA_DATABASE_URL, then the local Supabase stack from supabase/config.toml)")
+    .option("--ensure-roles", "create missing NOLOGIN roles referenced by grants/policies on the verification server (cluster-level; never dropped)")
+    .option("--ensure-environment", "stub Supabase-provisioned surfaces (auth helpers, cron schema) in the temporary databases (default under adapter supabase-auto)")
+    .option("--keep-databases", "keep the temporary databases after the run and print their names (debugging failed verifies)")
+    .description("Apply from + migration twice and compare against target in temporary databases.")
+    .action(async (options) => {
+    const config = await loadCliConfig();
+    const databaseUrl = await resolveCliDatabaseUrl(options.databaseUrl);
+    if (!databaseUrl) {
+        process.stderr.write("no database URL: pass --database-url, --env, set SUPASCHEMA_DATABASE_URL, or run inside a project with supabase/config.toml\n");
+        process.exitCode = 1;
+        return;
+    }
+    const migrationsDir = resolveMigrationsDir(options.migrationsDir, config);
+    const migrationPath = options.migration ?? (await latestMigrationFile(resolve(process.cwd(), migrationsDir)));
+    if (migrationPath === undefined) {
+        process.stderr.write(`no migration to verify: ${migrationsDir} has no .sql files\n`);
+        process.exitCode = 1;
+        return;
+    }
+    const sources = await resolveSourceDefaults(options, config, () => resolveCliDatabaseUrl(options.databaseUrl));
+    if (sources.notice !== undefined) {
+        process.stderr.write(sources.notice);
+    }
+    if (options.migration === undefined) {
+        process.stderr.write(`defaults: --migration ${migrationPath} (flags override)\n`);
+    }
+    const diagnostics = await verifyMigration({
+        config,
+        databaseUrl,
+        ensureRoles: options.ensureRoles === true,
+        ...(options.ensureEnvironment === true ? { ensureEnvironment: true } : {}),
+        ...(options.keepDatabases === true ? { keepDatabases: true } : {}),
+        from: sources.from,
+        migrationPath,
+        to: sources.to,
+    });
+    printDiagnostics(diagnostics);
+    if (hasErrors(diagnostics)) {
+        process.exitCode = 2;
+        return;
+    }
+    process.stdout.write("ok\n");
+});
+program
+    .command("selfcheck")
+    .option("--database-url <url>", "PostgreSQL URL to extract (default: SUPASCHEMA_DATABASE_URL, then the local Supabase stack from supabase/config.toml)")
+    .description("Re-extract the live catalog's rendered SQL and report identity normalization gaps.")
+    .action(async (options) => {
+    const databaseUrl = await resolveCliDatabaseUrl(options.databaseUrl);
+    if (!databaseUrl) {
+        process.stderr.write("no database URL: pass --database-url, --env, set SUPASCHEMA_DATABASE_URL, or run inside a project with supabase/config.toml\n");
+        process.exitCode = 1;
+        return;
+    }
+    const result = await selfCheckCatalog({ databaseUrl });
+    printDiagnostics(result.diagnostics);
+    process.stdout.write(`selfcheck: ${result.checkedObjects} objects, ${result.mismatches} parity mismatches\n`);
+    if (hasErrors(result.diagnostics)) {
+        process.exitCode = 2;
+    }
+});
+program
+    .command("explain")
+    .argument("<code>", "diagnostic code, e.g. SUPA_PLAN_DESTRUCTIVE_HINT_REQUIRED")
+    .description("Explain a supaschema diagnostic code.")
+    .action((code) => {
+    const summary = diagnosticCatalog[code.toUpperCase()];
+    if (!summary) {
+        process.stderr.write(`unknown diagnostic code "${code}"\n`);
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write(`${code.toUpperCase()}: ${summary}\n`);
+});
+program.parseAsync(process.argv).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});
+async function loadCliConfig() {
+    const globals = program.opts();
+    return loadConfig(process.cwd(), globals.config);
+}
+/**
+ * Database URL precedence: explicit flag, then the named --env entry from
+ * config.environments, then the shared resolver (SUPASCHEMA_DATABASE_URL,
+ * then supabase/config.toml discovery). Environment values support the same
+ * $ENV_NAME indirection as the flag.
+ */
+async function resolveCliDatabaseUrl(explicit) {
+    if (explicit) {
+        return resolveDatabaseUrl(explicit);
+    }
+    const globals = program.opts();
+    if (globals.env) {
+        const config = await loadCliConfig();
+        const entry = config.environments[globals.env];
+        if (!entry) {
+            throw new Error(`--env "${globals.env}" is not defined in config.environments (known: ${Object.keys(config.environments).join(", ") || "none"})`);
+        }
+        return resolveDatabaseUrl(entry.databaseUrl);
+    }
+    return resolveDatabaseUrl();
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function printDiagnostics(diagnostics) {
+    const globals = program.opts();
+    if (globals.quiet || diagnostics.length === 0) {
+        return;
+    }
+    process.stderr.write(`${formatDiagnostics(diagnostics)}\n`);
+}
+async function readPackageVersion() {
+    try {
+        const raw = await readFile(new URL("../package.json", import.meta.url), "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}

package/dist/config-schema-gen.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config-schema-gen.d.ts.map

package/dist/config-schema-gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-schema-gen.d.ts","sourceRoot":"","sources":["../src/config-schema-gen.ts"],"names":[],"mappings":""}

package/dist/config-schema-gen.js

@@ -0,0 +1,11 @@
+import { writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { configJsonSchema } from "./config.js";
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const schema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    title: "supaschema configuration",
+    ...configJsonSchema(),
+};
+await writeFile(resolve(packageRoot, "config-schema.json"), `${JSON.stringify(schema, null, 2)}\n`, "utf8");

package/dist/config.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export declare const supaschemaConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    adapter: z.ZodDefault<z.ZodEnum<{
+        "supabase-auto": "supabase-auto";
+        postgres: "postgres";
+    }>>;
+    cascade: z.ZodDefault<z.ZodLiteral<"never">>;
+    destructiveChanges: z.ZodDefault<z.ZodEnum<{
+        block: "block";
+        "hint-required": "hint-required";
+        allow: "allow";
+    }>>;
+    environments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        databaseUrl: z.ZodString;
+    }, z.core.$strict>>>;
+    excludedGrantRoles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    hints: z.ZodDefault<z.ZodObject<{
+        destructive: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        renames: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strip>>;
+    idempotency: z.ZodDefault<z.ZodLiteral<"required">>;
+    lockTimeout: z.ZodDefault<z.ZodString>;
+    migrationsDir: z.ZodDefault<z.ZodString>;
+    typesFile: z.ZodDefault<z.ZodString>;
+    zodFile: z.ZodDefault<z.ZodString>;
+    normalize: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        deparse: "deparse";
+    }>>;
+    managedSchemas: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    postgresVersion: z.ZodDefault<z.ZodString>;
+    renameDetection: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        "hints-only": "hints-only";
+    }>>;
+    schemaPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    schemas: z.ZodDefault<z.ZodObject<{
+        exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        include: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    statementTimeout: z.ZodDefault<z.ZodString>;
+    transactionMode: z.ZodDefault<z.ZodEnum<{
+        "per-migration": "per-migration";
+        "per-statement": "per-statement";
+    }>>;
+    validators: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type SupaschemaConfig = z.infer<typeof supaschemaConfigSchema>;
+export declare const defaultConfig: SupaschemaConfig;
+export declare function resolveConfig(config?: Partial<SupaschemaConfig>): SupaschemaConfig;
+export declare function loadConfig(cwd?: string, explicitPath?: string): Promise<SupaschemaConfig>;
+export declare const defaultConfigFile: string;
+export declare function configJsonSchema(): Record<string, unknown>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2BxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmCjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,aAAa,EAAE,gBAAmD,CAAC;AAEhF,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,gBAAgB,CAElF;AAID,wBAAsB,UAAU,CAC9B,GAAG,GAAE,MAAsB,EAC3B,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,gBAAgB,CAAC,CAgB3B;AAsDD,eAAO,MAAM,iBAAiB,QAAiD,CAAC;AAEhF,wBAAgB,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE1D"}

package/dist/config.js

@@ -0,0 +1,132 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+const hintsSchema = z
+    .object({
+    destructive: z.array(z.string()).default([]),
+    renames: z
+        .array(z.strictObject({
+        from: z.string(),
+        to: z.string(),
+    }))
+        .default([]),
+})
+    .default({ destructive: [], renames: [] });
+const schemaFilterSchema = z
+    .strictObject({
+    exclude: z.array(z.string()).default([]),
+    include: z.array(z.string()).default([]),
+})
+    .default({ exclude: [], include: [] });
+const environmentSchema = z.strictObject({
+    databaseUrl: z.string(),
+});
+export const supaschemaConfigSchema = z.strictObject({
+    $schema: z.string().optional(),
+    adapter: z.enum(["supabase-auto", "postgres"]).default("supabase-auto"),
+    cascade: z.literal("never").default("never"),
+    destructiveChanges: z.enum(["hint-required", "block", "allow"]).default("hint-required"),
+    environments: z.record(z.string(), environmentSchema).default({}),
+    excludedGrantRoles: z.array(z.string()).default([]),
+    hints: hintsSchema,
+    idempotency: z.literal("required").default("required"),
+    lockTimeout: z.string().default("5s"),
+    migrationsDir: z.string().default("supabase/migrations"),
+    typesFile: z.string().default("database.types.ts"),
+    zodFile: z.string().default("database.zod.ts"),
+    normalize: z.enum(["off", "deparse"]).default("deparse"),
+    managedSchemas: z
+        .array(z.string())
+        .default([
+        "auth",
+        "storage",
+        "realtime",
+        "vault",
+        "extensions",
+        "cron",
+        "net",
+        "supabase_functions",
+        "graphql",
+        "graphql_public",
+    ]),
+    postgresVersion: z.string().default("15+"),
+    renameDetection: z.enum(["hints-only", "off"]).default("hints-only"),
+    schemaPaths: z.array(z.string()).default(["supabase/schemas"]),
+    schemas: schemaFilterSchema,
+    statementTimeout: z.string().default("60s"),
+    transactionMode: z.enum(["per-migration", "per-statement"]).default("per-migration"),
+    validators: z.array(z.string()).default(["internal-parser"]),
+});
+export const defaultConfig = supaschemaConfigSchema.parse({});
+export function resolveConfig(config) {
+    return supaschemaConfigSchema.parse(config ?? {});
+}
+const moduleConfigFiles = ["supaschema.config.mjs", "supaschema.config.js"];
+export async function loadConfig(cwd = process.cwd(), explicitPath) {
+    if (explicitPath) {
+        const path = isAbsolute(explicitPath) ? explicitPath : resolve(cwd, explicitPath);
+        return loadConfigFile(path);
+    }
+    const fromJson = await tryLoadJsonConfig(resolve(cwd, "supaschema.config.json"));
+    if (fromJson) {
+        return fromJson;
+    }
+    for (const candidate of moduleConfigFiles) {
+        const fromModule = await tryLoadModuleConfig(resolve(cwd, candidate));
+        if (fromModule) {
+            return fromModule;
+        }
+    }
+    return defaultConfig;
+}
+async function loadConfigFile(path) {
+    if (path.endsWith(".mjs") || path.endsWith(".js")) {
+        const loaded = await tryLoadModuleConfig(path);
+        if (!loaded) {
+            throw new Error(`config module not found at ${path}`);
+        }
+        return loaded;
+    }
+    const raw = await readFile(path, "utf8");
+    return resolveConfig(JSON.parse(raw));
+}
+async function tryLoadJsonConfig(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        return resolveConfig(JSON.parse(raw));
+    }
+    catch (error) {
+        if (isFileMissing(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function tryLoadModuleConfig(path) {
+    try {
+        const module = (await import(pathToFileURL(path).href));
+        return resolveConfig(module.default ?? {});
+    }
+    catch (error) {
+        if (isFileMissing(error) || isModuleMissing(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function isFileMissing(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function isModuleMissing(error) {
+    return error instanceof Error && "code" in error && error.code === "ERR_MODULE_NOT_FOUND";
+}
+const scaffoldConfig = {
+    $schema: "./node_modules/supaschema/config-schema.json",
+    ...defaultConfig,
+};
+delete scaffoldConfig.environments;
+export const defaultConfigFile = `${JSON.stringify(scaffoldConfig, null, 2)}\n`;
+export function configJsonSchema() {
+    return z.toJSONSchema(supaschemaConfigSchema, { io: "input" });
+}

package/dist/core.d.ts

@@ -0,0 +1,115 @@
+import type { SupaschemaConfig } from "./config.js";
+export type DiagnosticSeverity = "info" | "warning" | "error";
+export type ObjectKind = "schema" | "extension" | "type" | "domain" | "enum" | "sequence" | "table" | "foreign-data-wrapper" | "foreign-server" | "foreign-table" | "constraint" | "index" | "function" | "procedure" | "view" | "materialized-view" | "trigger" | "rls" | "policy" | "grant" | "default-privilege" | "comment";
+export interface ObjectRef {
+    kind: ObjectKind;
+    name: string;
+    schema?: string;
+    signature?: string;
+    table?: string;
+}
+export interface Diagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    ref?: ObjectRef;
+    file?: string;
+    statement?: string;
+    hint?: string;
+    /** Schemas the failing statement references, for schema-filter scoping. */
+    schemas?: string[];
+}
+export interface SchemaObject {
+    ref: ObjectRef;
+    key: string;
+    sql: string;
+    normalizedSql: string;
+    hash: string;
+    ordinal: number;
+    file?: string;
+    dependencies: string[];
+    metadata: Record<string, unknown>;
+}
+export interface TableColumn {
+    name: string;
+    definition: string;
+    type?: string;
+    notNull?: boolean;
+    hasDefault?: boolean;
+    defaultExpression?: string;
+    identity?: boolean;
+    generated?: boolean;
+    hasInlineConstraint?: boolean;
+}
+export interface SchemaModel {
+    source: string;
+    objects: SchemaObject[];
+    diagnostics: Diagnostic[];
+    fingerprint: string;
+    formatVersion?: number;
+}
+export type MigrationOperationKind = "alter" | "create" | "replace" | "drop" | "rename";
+export interface MigrationOperation {
+    kind: MigrationOperationKind;
+    ref: ObjectRef;
+    key: string;
+    before?: SchemaObject;
+    after?: SchemaObject;
+    destructive: boolean;
+    blocked: boolean;
+    diagnostics: Diagnostic[];
+    metadata: Record<string, unknown>;
+}
+export interface MigrationPlan {
+    from: string;
+    to: string;
+    operations: MigrationOperation[];
+    diagnostics: Diagnostic[];
+    fingerprint: string;
+    fromFingerprint: string;
+    toFingerprint: string;
+}
+export interface RenameHint {
+    from: string;
+    to: string;
+}
+export interface SupaschemaHints {
+    destructive?: string[];
+    renames?: RenameHint[];
+}
+export interface ExtractOptions {
+    config?: Partial<SupaschemaConfig>;
+    cwd?: string;
+}
+export interface RenderOptions {
+    config?: Partial<SupaschemaConfig>;
+    includeHeader?: boolean;
+    version?: string;
+}
+export interface CheckOptions {
+    config?: Partial<SupaschemaConfig>;
+    cwd?: string;
+    parse?: boolean;
+}
+export interface VerifyMigrationOptions {
+    databaseUrl: string;
+    from: string;
+    to: string;
+    migrationPath: string;
+    cwd?: string;
+    config?: Partial<SupaschemaConfig>;
+    ensureRoles?: boolean;
+    /**
+     * Stub Supabase-provisioned surfaces (auth schema helpers, cron schema) in
+     * the temporary databases so real-world trees apply against bare
+     * PostgreSQL. Defaults to true under adapter "supabase-auto".
+     */
+    ensureEnvironment?: boolean;
+    /**
+     * Keep the temporary databases after the run and report their names —
+     * a failed verify leaves its evidence inspectable instead of dropped.
+     */
+    keepDatabases?: boolean;
+}
+export type { SupaschemaConfig } from "./config.js";
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAE9D,MAAM,MAAM,UAAU,GAClB,QAAQ,GACR,WAAW,GACX,MAAM,GACN,QAAQ,GACR,MAAM,GACN,UAAU,GACV,OAAO,GACP,sBAAsB,GACtB,gBAAgB,GAChB,eAAe,GACf,YAAY,GACZ,OAAO,GACP,UAAU,GACV,WAAW,GACX,MAAM,GACN,mBAAmB,GACnB,SAAS,GACT,KAAK,GACL,QAAQ,GACR,OAAO,GACP,mBAAmB,GACnB,SAAS,CAAC;AAEd,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,SAAS,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAExF,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,sBAAsB,CAAC;IAC7B,GAAG,EAAE,SAAS,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IAEpB,eAAe,EAAE,MAAM,CAAC;IAExB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEnC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}

package/dist/core.js

@@ -0,0 +1 @@
+export {};

package/dist/corpus.d.ts

@@ -0,0 +1,26 @@
+import type { Diagnostic } from "./core.js";
+export interface CorpusOptions {
+    corpusDir: string;
+    databaseUrl: string;
+}
+export interface CorpusReport {
+    appliedMigrations: string[];
+    driftOperations: number;
+    idempotent: boolean;
+    reconvergenceResidual: string[];
+    stages: string[];
+}
+/**
+ * The corpus oracle: replay a migrations corpus into a disposable database
+ * (an independently-evolved, catalog-noisy state no fixture reconstruction
+ * produces), diff it against the declarative tree, apply the rendered
+ * reconciliation twice, and require the re-diff to converge to zero. Unlike
+ * verify — which compares two databases built from the same models — every
+ * comparison here crosses lanes, so symmetric modeling errors fail loudly.
+ */
+export declare function runCorpus(options: CorpusOptions): Promise<{
+    diagnostics: Diagnostic[];
+    report: CorpusReport;
+}>;
+export declare function renderCorpusReport(report: CorpusReport): string;
+//# sourceMappingURL=corpus.d.ts.map

package/dist/corpus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../src/corpus.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,WAAW,CAAC;AAc9D,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;IACpB,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAID;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC;IAAE,WAAW,EAAE,UAAU,EAAE,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,CAgH9D;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAM/D"}