jazz-tools 2.0.0-alpha.50 → 2.0.0-alpha.52

package/dist/cli.js

@@ -1,15 +1,10 @@
 #!/usr/bin/env node
 // CLI for jazz-tools schema tooling
 import { existsSync, readFileSync, realpathSync } from "fs";
-import { access, mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
-import { basename, dirname, join, resolve } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-import { build } from "esbuild";
-import { schemaDefinitionToAst } from "./migrations.js";
-import { loadCompiledSchema } from "./schema-loader.js";
-import { collectMissingExplicitPolicyDiagnostics } from "./schema-permissions.js";
-import { encodePublishedMigrationValue, fetchPermissionsHead, fetchSchemaConnectivity, fetchSchemaHashes, fetchStoredWasmSchema, publishStoredSchema, publishStoredPermissions, publishStoredMigration, } from "./runtime/schema-fetch.js";
-import { toValue } from "./runtime/value-converter.js";
+import { readFile } from "fs/promises";
+import { basename, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { createMigration as createCatalogueMigration, deploy as deployCatalogue, exportSchema as exportCatalogueSchema, getCurrentSchemaHash, getPermissionsStatus, pushMigration as pushCatalogueMigration, shortSchemaHash, validateProject, } from "./dev/catalogue.js";
 const PERMISSIONS_LIFECYCLE_NOTE = "Permission-only changes do not create schema hashes or require migrations.";
 function parseArgs() {
     const args = process.argv.slice(2);
@@ -30,60 +25,28 @@ function parseArgs() {
     }
     return { command, options: { jazzBin, schemaDir } };
 }
-let importCounter = 0;
-async function bundleToTempFile(filePath) {
-    const sourceDir = dirname(resolve(filePath));
-    const outFile = join(sourceDir, `.jazz-bundle-${++importCounter}.mjs`);
-    await build({
-        entryPoints: [resolve(filePath)],
-        bundle: true,
-        format: "esm",
-        platform: "node",
-        outfile: outFile,
-        packages: "external",
-    });
-    return outFile;
-}
-async function pathExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 export async function validate(options) {
-    const compiled = await loadCompiledSchema(options.schemaDir);
-    const tableCount = compiled.schema.tables.length;
-    console.log(`Loaded structural schema from ${compiled.schemaFile}.`);
-    if (compiled.permissionsFile) {
-        console.log(`Loaded current permissions from ${compiled.permissionsFile}.`);
+    const result = await validateProject(options);
+    console.log(`Loaded structural schema from ${result.schemaFile}.`);
+    if (result.permissionsFile) {
+        console.log(`Loaded current permissions from ${result.permissionsFile}.`);
         console.log(PERMISSIONS_LIFECYCLE_NOTE);
         console.log("Use `jazz-tools permissions status <appId>` or `jazz-tools deploy <appId>` for auth publication.");
     }
-    for (const diagnostic of collectMissingExplicitPolicyDiagnostics(compiled.schema.tables.map((table) => table.name), compiled.permissions)) {
-        console.warn(`\x1b[33m${diagnostic.message}\x1b[0m`);
+    for (const warning of result.warnings) {
+        console.warn(`\x1b[33m${warning}\x1b[0m`);
     }
-    console.log(`Validated ${tableCount} table${tableCount === 1 ? "" : "s"} in schema.ts.`);
+    console.log(`Validated ${result.tableCount} table${result.tableCount === 1 ? "" : "s"} in schema.ts.`);
 }
 export async function exportSchema(options) {
-    if (options.schemaHash) {
-        const schema = await resolveExportedSchemaByHash(options);
-        process.stdout.write(`${JSON.stringify(schema, null, 2)}\n`);
-        return;
-    }
-    const currentSchema = await loadCurrentSchema(options.schemaDir);
-    await ensureLocalSnapshot(options.schemaDir, options.migrationsDir, currentSchema);
-    process.stdout.write(`${JSON.stringify(currentSchema.schema, null, 2)}\n`);
+    const result = await exportCatalogueSchema(options);
+    process.stdout.write(`${JSON.stringify(result.schema, null, 2)}\n`);
 }
 export async function schemaHash(options) {
-    const compiled = await loadCompiledSchema(options.schemaDir);
-    console.log(`Loaded structural schema from ${compiled.schemaFile}.`);
-    const hash = await computeSchemaHash(compiled.wasmSchema);
-    console.log(`Current schema hash: ${shortSchemaHash(hash)}`);
+    const result = await getCurrentSchemaHash(options);
+    console.log(`Loaded structural schema from ${result.schemaFile}.`);
+    console.log(`Current schema hash: ${shortSchemaHash(result.hash)}`);
 }
-const SHORT_SCHEMA_HASH_LENGTH = 12;
 // Framework bundlers (Vite, SvelteKit, Next.js, Expo) expose public env vars
 // under their own prefix so the client bundle can read them. The CLI often
 // runs in the same project, so accept those prefixed names as fallbacks for
@@ -221,131 +184,6 @@ function resolvePermissionsOptions(args) {
         schemaDir,
     };
 }
-function normalizeSchemaHashInput(hash, label) {
-    const normalized = hash.trim().toLowerCase();
-    if (!/^[0-9a-f]{12,64}$/.test(normalized)) {
-        throw new Error(`${label} must be a 12-64 character lowercase hex schema hash.`);
-    }
-    return normalized;
-}
-function shortSchemaHash(hash) {
-    return normalizeSchemaHashInput(hash, "schema hash").slice(0, SHORT_SCHEMA_HASH_LENGTH);
-}
-function hashMatchesFullSchema(hash, fullHash) {
-    return fullHash.startsWith(normalizeSchemaHashInput(hash, "schema hash"));
-}
-function resolveKnownSchemaHash(hash, label, knownHashes) {
-    const normalized = normalizeSchemaHashInput(hash, label);
-    if (normalized.length === 64) {
-        if (!knownHashes.includes(normalized)) {
-            throw new Error(`No stored schema found for ${label} ${normalized}.`);
-        }
-        return normalized;
-    }
-    const matches = knownHashes.filter((candidate) => candidate.startsWith(normalized));
-    if (matches.length === 0) {
-        throw new Error(`No stored schema found for ${label} prefix ${normalized}.`);
-    }
-    if (matches.length > 1) {
-        throw new Error(`${label} prefix ${normalized} is ambiguous: ${matches
-            .map((candidate) => shortSchemaHash(candidate))
-            .join(", ")}`);
-    }
-    return matches[0];
-}
-function defaultMigrationsDir(schemaDir) {
-    return join(schemaDir, "migrations");
-}
-function resolvedMigrationsDir(schemaDir, migrationsDir) {
-    return migrationsDir ?? defaultMigrationsDir(schemaDir);
-}
-function snapshotsDirForMigrations(migrationsDir) {
-    return join(migrationsDir, "snapshots");
-}
-function snapshotsDir(schemaDir, migrationsDir) {
-    return snapshotsDirForMigrations(resolvedMigrationsDir(schemaDir, migrationsDir));
-}
-// Supports both millisecond and microsecond-precision timestamps
-function looksLikeSnapshotFileName(fileName) {
-    return /^(?:\d{8,17}T\d{6}-)?[0-9a-f]{12}\.json$/i.test(fileName);
-}
-async function readSnapshotEntry(dir, fileName) {
-    if (!looksLikeSnapshotFileName(fileName)) {
-        return null;
-    }
-    const filePath = join(dir, fileName);
-    const schema = JSON.parse(await readFile(filePath, "utf8"));
-    return {
-        hash: await computeSchemaHash(schema),
-        fileName,
-        filePath,
-        schema,
-    };
-}
-async function listSnapshotEntries(dir) {
-    if (!(await pathExists(dir))) {
-        return [];
-    }
-    const files = await readdir(dir);
-    return (await Promise.all(files.map((fileName) => readSnapshotEntry(dir, fileName)))).filter((entry) => entry !== null);
-}
-async function listLocalSnapshotEntries(schemaDir, migrationsDir) {
-    return listSnapshotEntries(snapshotsDir(schemaDir, migrationsDir));
-}
-async function listSnapshotEntriesForMigrations(migrationsDir) {
-    return listSnapshotEntries(snapshotsDirForMigrations(migrationsDir));
-}
-async function resolveLocalSnapshotEntry(schemaDir, migrationsDir, hash, label) {
-    const entries = await listLocalSnapshotEntries(schemaDir, migrationsDir);
-    if (entries.length === 0) {
-        return null;
-    }
-    const fullHash = normalizeSchemaHashInput(hash, label);
-    if (fullHash.length === 64) {
-        return entries.find((entry) => entry.hash === fullHash) ?? null;
-    }
-    const matches = entries.filter((entry) => hashMatchesFullSchema(fullHash, entry.hash));
-    if (matches.length === 0) {
-        return null;
-    }
-    if (matches.length > 1) {
-        throw new Error(`${label} prefix ${fullHash} is ambiguous: ${matches
-            .map((entry) => shortSchemaHash(entry.hash))
-            .join(", ")}`);
-    }
-    return matches[0];
-}
-async function loadLocalSnapshotSchema(schemaDir, migrationsDir, hash, label) {
-    const entry = await resolveLocalSnapshotEntry(schemaDir, migrationsDir, hash, label);
-    if (!entry) {
-        return null;
-    }
-    return {
-        hash: entry.hash,
-        schema: entry.schema,
-    };
-}
-async function writeSnapshotSchema(schemaDir, migrationsDir, hash, schema, timestamp = createTimestamp()) {
-    const dir = snapshotsDir(schemaDir, migrationsDir);
-    await mkdir(dir, { recursive: true });
-    const filePath = join(dir, snapshotFilename(hash, timestamp));
-    await writeFile(filePath, `${JSON.stringify(schema, null, 2)}\n`);
-    return filePath;
-}
-async function ensureLocalSnapshot(schemaDir, migrationsDir, schema) {
-    const entries = await listLocalSnapshotEntries(schemaDir, migrationsDir);
-    if (entries.some((entry) => entry.hash === schema.hash)) {
-        return null;
-    }
-    return writeSnapshotSchema(schemaDir, migrationsDir, schema.hash, schema.schema);
-}
-async function writeSnapshotSchemaForMigrations(migrationsDir, fileName, schema) {
-    const dir = snapshotsDirForMigrations(migrationsDir);
-    await mkdir(dir, { recursive: true });
-    const filePath = join(dir, fileName);
-    await writeFile(filePath, `${JSON.stringify(schema, null, 2)}\n`);
-    return filePath;
-}
 function requireSchemaExportServerValue(value, kind) {
     if (value) {
         return value;
@@ -368,921 +206,153 @@ function requireMigrationServerOptions(options) {
         adminSecret: requireSchemaExportServerValue(options.adminSecret, "adminSecret"),
     };
 }
-async function resolveExportedSchemaByHash(options) {
-    const schemaHash = normalizeSchemaHashInput(options.schemaHash, "schema hash");
-    const local = await loadLocalSnapshotSchema(options.schemaDir, options.migrationsDir, schemaHash, "schema hash");
-    if (local) {
-        return local.schema;
-    }
-    const serverUrl = requireSchemaExportServerValue(options.serverUrl ?? resolveEnvVar(SERVER_URL_ENV_VARS), "serverUrl");
-    const adminSecret = requireSchemaExportServerValue(options.adminSecret ?? process.env.JAZZ_ADMIN_SECRET, "adminSecret");
-    const appId = requireAppId(options.appId);
-    const resolvedHash = schemaHash.length === 64
-        ? schemaHash
-        : resolveKnownSchemaHash(schemaHash, "schema hash", (await fetchSchemaHashes(serverUrl, { appId, adminSecret })).hashes);
-    const storedSchema = await fetchStoredWasmSchema(serverUrl, {
-        appId,
-        adminSecret,
-        schemaHash: resolvedHash,
-    });
-    await writeSnapshotSchema(options.schemaDir, options.migrationsDir, resolvedHash, storedSchema.schema, createSnapshotTimestampFromPublishedAt(storedSchema.publishedAt));
-    return storedSchema.schema;
-}
-let wasmModulePromise = null;
-async function loadCliWasmModule() {
-    if (!wasmModulePromise) {
-        wasmModulePromise = import("./runtime/client.js").then(({ loadWasmModule }) => loadWasmModule());
-    }
-    return wasmModulePromise;
-}
-async function computeSchemaHash(schema) {
-    const wasmModule = await loadCliWasmModule();
-    const runtime = new wasmModule.WasmRuntime(JSON.stringify(schema), "jazz-tools-cli", "dev", "main", null, null);
-    try {
-        return runtime.getSchemaHash();
-    }
-    finally {
-        if (typeof runtime.free === "function") {
-            runtime.free();
-        }
-    }
-}
-function columnTypeSignature(columnType) {
-    return JSON.stringify(columnType);
-}
-function columnsEqual(left, right) {
-    return (left.name === right.name &&
-        left.nullable === right.nullable &&
-        left.references === right.references &&
-        left.merge_strategy === right.merge_strategy &&
-        columnTypeSignature(left.column_type) === columnTypeSignature(right.column_type));
-}
-function indexedColumnsEqual(left, right) {
-    if (!left && !right) {
-        return true;
-    }
-    if (!left || !right || left.length !== right.length) {
-        return false;
-    }
-    const leftColumns = [...left].sort();
-    const rightColumns = [...right].sort();
-    return leftColumns.every((column, index) => column === rightColumns[index]);
-}
-function tableSchemasEqual(left, right) {
-    if (!left || !right) {
-        return false;
-    }
-    if (left.columns.length !== right.columns.length) {
-        return false;
-    }
-    if (!indexedColumnsEqual(left.indexed_columns, right.indexed_columns)) {
-        return false;
-    }
-    const leftColumns = [...left.columns].sort((a, b) => a.name.localeCompare(b.name));
-    const rightColumns = [...right.columns].sort((a, b) => a.name.localeCompare(b.name));
-    return leftColumns.every((column, index) => columnsEqual(column, rightColumns[index]));
-}
-function tableSchemasRequireRowTransform(left, right) {
-    if (!left || !right) {
-        return true;
-    }
-    const leftColumnNames = left.columns.map((column) => column.name).sort();
-    const rightColumnNames = right.columns.map((column) => column.name).sort();
-    if (leftColumnNames.length !== rightColumnNames.length) {
-        return true;
-    }
-    for (const [index, columnName] of leftColumnNames.entries()) {
-        if (columnName !== rightColumnNames[index]) {
-            return true;
-        }
-    }
-    const leftColumns = new Map(left.columns.map((column) => [column.name, column]));
-    const rightColumns = new Map(right.columns.map((column) => [column.name, column]));
-    return leftColumnNames.some((columnName) => {
-        const leftColumn = leftColumns.get(columnName);
-        const rightColumn = rightColumns.get(columnName);
-        return (leftColumn.nullable !== rightColumn.nullable ||
-            leftColumn.references !== rightColumn.references ||
-            columnTypeSignature(leftColumn.column_type) !== columnTypeSignature(rightColumn.column_type));
-    });
-}
-function wasmSchemasEqual(left, right) {
-    const leftTableNames = Object.keys(left).sort();
-    const rightTableNames = Object.keys(right).sort();
-    if (leftTableNames.length !== rightTableNames.length) {
-        return false;
-    }
-    return leftTableNames.every((tableName, index) => {
-        if (tableName !== rightTableNames[index]) {
-            return false;
-        }
-        return tableSchemasEqual(left[tableName], right[tableName]);
-    });
-}
-function schemaTransitionRequiresRowTransform(fromSchema, toSchema) {
-    const fromTableNames = Object.keys(fromSchema).sort();
-    const toTableNames = Object.keys(toSchema).sort();
-    if (fromTableNames.length !== toTableNames.length) {
-        return true;
-    }
-    for (const [index, tableName] of fromTableNames.entries()) {
-        if (tableName !== toTableNames[index]) {
-            return true;
-        }
-    }
-    return fromTableNames.some((tableName) => tableSchemasRequireRowTransform(fromSchema[tableName], toSchema[tableName]));
-}
-function changedTableNames(fromSchema, toSchema) {
-    const names = new Set([...Object.keys(fromSchema), ...Object.keys(toSchema)]);
-    return [...names].filter((tableName) => !tableSchemasEqual(fromSchema[tableName], toSchema[tableName]));
-}
-function detectPossibleTableRenames(fromSchema, toSchema) {
-    const removedTables = Object.keys(fromSchema)
-        .filter((tableName) => !toSchema[tableName])
-        .sort();
-    const addedTables = Object.keys(toSchema)
-        .filter((tableName) => !fromSchema[tableName])
-        .sort();
-    const matches = removedTables
-        .map((oldTableName) => {
-        const candidateAddedTables = addedTables.filter((newTableName) => tableSchemasEqual(fromSchema[oldTableName], toSchema[newTableName]));
-        return candidateAddedTables.length === 1
-            ? [oldTableName, candidateAddedTables[0]]
-            : undefined;
-    })
-        .filter((match) => match !== undefined);
-    return matches.flatMap(([oldTableName, newTableName], i) => {
-        const isDuplicateNewTableMatch = matches.some(([_, otherNewTableName], j) => {
-            return i !== j && newTableName === otherNewTableName;
-        });
-        return !isDuplicateNewTableMatch ? [{ oldTableName, newTableName }] : [];
-    });
-}
-function ensurePermissionsProject(compiled) {
-    if (!compiled.permissions || !compiled.permissionsFile) {
-        throw new Error("No permissions found for this app. Create a permissions.ts file before using permissions commands.");
-    }
-    return compiled;
-}
-/**
- * If the provided schema exists in the server, returns its hash. Otherwise, throws an error.
- */
-async function resolveStoredStructuralSchemaHashOrThrow(appId, serverUrl, adminSecret, wasmSchema) {
-    const hash = await resolveStoredStructuralSchemaHash(appId, serverUrl, adminSecret, wasmSchema);
-    if (!hash) {
-        throw new Error("No stored structural schema matches the local schema.ts. Publish the structural schema before pushing permissions.");
-    }
-    return hash;
-}
-async function resolveStoredStructuralSchemaHash(appId, serverUrl, adminSecret, wasmSchema) {
-    const { hashes } = await fetchSchemaHashes(serverUrl, { appId, adminSecret });
-    const storedSchemas = await Promise.all(hashes.map(async (hash) => ({
-        hash,
-        schema: (await fetchStoredWasmSchema(serverUrl, { appId, adminSecret, schemaHash: hash }))
-            .schema,
-    })));
-    const match = storedSchemas.find(({ schema }) => wasmSchemasEqual(schema, wasmSchema));
-    return match?.hash ?? null;
-}
-function pickWitnessSchema(schema, tableNames) {
-    const uniqueTableNames = [...new Set(tableNames)];
-    return Object.fromEntries(uniqueTableNames
-        .filter((tableName) => schema[tableName])
-        .map((tableName) => [tableName, schema[tableName]]));
-}
-function indentBlock(text, indent) {
-    const prefix = " ".repeat(indent);
-    return text
-        .split("\n")
-        .map((line) => (line.length === 0 ? line : `${prefix}${line}`))
-        .join("\n");
-}
-function baseBuilderExpression(columnType, references) {
-    switch (columnType.type) {
-        case "Text":
-            return "s.string()";
-        case "Boolean":
-            return "s.boolean()";
-        case "Integer":
-            return "s.int()";
-        case "Double":
-            return "s.float()";
-        case "Timestamp":
-            return "s.timestamp()";
-        case "Bytea":
-            return "s.bytes()";
-        case "Json":
-            return columnType.schema ? `s.json(${JSON.stringify(columnType.schema)})` : "s.json()";
-        case "Enum":
-            return `s.enum(${columnType.variants.map((variant) => JSON.stringify(variant)).join(", ")})`;
-        case "Uuid":
-            if (!references) {
-                throw new Error("Migration stub generation does not yet support bare UUID columns.");
-            }
-            return `s.ref(${JSON.stringify(references)})`;
-        case "Array":
-            return `s.array(${baseBuilderExpression(columnType.element, references)})`;
-        case "BigInt":
-            throw new Error("Migration stub generation does not yet support BIGINT columns.");
-        case "Row":
-            throw new Error("Migration stub generation does not yet support row-valued columns.");
-    }
-}
-function builderExpressionForColumn(column) {
-    const base = baseBuilderExpression(column.column_type, column.references);
-    const withOptional = column.nullable ? `${base}.optional()` : base;
-    if (column.merge_strategy === "Counter") {
-        return `${withOptional}.merge("counter")`;
-    }
-    return withOptional;
-}
-function sqlTypeToWasmColumnType(sqlType) {
-    if (typeof sqlType === "string") {
-        switch (sqlType) {
-            case "TEXT":
-                return { type: "Text" };
-            case "BOOLEAN":
-                return { type: "Boolean" };
-            case "INTEGER":
-                return { type: "Integer" };
-            case "REAL":
-                return { type: "Double" };
-            case "TIMESTAMP":
-                return { type: "Timestamp" };
-            case "UUID":
-                return { type: "Uuid" };
-            case "BYTEA":
-                return { type: "Bytea" };
-        }
-    }
-    if (sqlType.kind === "ENUM") {
-        return {
-            type: "Enum",
-            variants: [...sqlType.variants],
-        };
-    }
-    if (sqlType.kind === "JSON") {
-        return {
-            type: "Json",
-            schema: sqlType.schema,
-        };
-    }
-    return {
-        type: "Array",
-        element: sqlTypeToWasmColumnType(sqlType.element),
-    };
-}
-function serializeForwardLenses(forward) {
-    return forward.map((tableLens) => ({
-        table: tableLens.table,
-        added: tableLens.added,
-        removed: tableLens.removed,
-        renamedFrom: tableLens.renamedFrom,
-        operations: tableLens.operations.map((op) => {
-            if (op.type === "rename") {
-                return op;
-            }
-            const columnType = sqlTypeToWasmColumnType(op.sqlType);
-            const value = encodePublishedMigrationValue(toValue(op.value, columnType));
-            return {
-                type: op.type,
-                column: op.column,
-                column_type: columnType,
-                value,
-            };
-        }),
-    }));
-}
-function renderSchemaWitness(schema) {
-    const tableEntries = Object.entries(schema)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([tableName, tableSchema]) => {
-        const columnLines = tableSchema.columns.map((column) => `${JSON.stringify(column.name)}: ${builderExpressionForColumn(column)},`);
-        return `${JSON.stringify(tableName)}: s.table({\n${indentBlock(columnLines.join("\n"), 2)}\n})`;
-    });
-    if (tableEntries.length === 0) {
-        return "{}";
-    }
-    return `{\n${indentBlock(tableEntries.join(",\n"), 2)}\n}`;
-}
-function renderArrayElementExpression(columnType, references) {
-    return baseBuilderExpression(columnType, references);
-}
-function renderAddOperationExpression(column, defaultExpression) {
-    switch (column.column_type.type) {
-        case "Text":
-            return `s.add.string({ default: ${defaultExpression} })`;
-        case "Boolean":
-            return `s.add.boolean({ default: ${defaultExpression} })`;
-        case "Integer":
-            return `s.add.int({ default: ${defaultExpression} })`;
-        case "Double":
-            return `s.add.float({ default: ${defaultExpression} })`;
-        case "Timestamp":
-            return `s.add.timestamp({ default: ${defaultExpression} })`;
-        case "Bytea":
-            return `s.add.bytes({ default: ${defaultExpression} })`;
-        case "Json":
-            return column.column_type.schema
-                ? `s.add.json({ default: ${defaultExpression}, schema: ${JSON.stringify(column.column_type.schema)} })`
-                : `s.add.json({ default: ${defaultExpression} })`;
-        case "Enum":
-            return `s.add.enum(${column.column_type.variants
-                .map((variant) => JSON.stringify(variant))
-                .join(", ")}, { default: ${defaultExpression} })`;
-        case "Uuid":
-            if (column.references) {
-                return `s.add.ref(${JSON.stringify(column.references)}, { default: ${defaultExpression} })`;
-            }
-            return `s.add.ref("TODO_TABLE", { default: ${defaultExpression} })`;
-        case "Array":
-            return `s.add.array({ of: ${renderArrayElementExpression(column.column_type.element, column.references)}, default: ${defaultExpression} })`;
-        case "BigInt":
-            throw new Error("Migration stub generation does not yet support BIGINT columns.");
-        case "Row":
-            throw new Error("Migration stub generation does not yet support row-valued columns.");
-    }
-}
-function renderDropOperationExpression(column, defaultExpression) {
-    switch (column.column_type.type) {
-        case "Text":
-            return `s.drop.string({ backwardsDefault: ${defaultExpression} })`;
-        case "Boolean":
-            return `s.drop.boolean({ backwardsDefault: ${defaultExpression} })`;
-        case "Integer":
-            return `s.drop.int({ backwardsDefault: ${defaultExpression} })`;
-        case "Double":
-            return `s.drop.float({ backwardsDefault: ${defaultExpression} })`;
-        case "Timestamp":
-            return `s.drop.timestamp({ backwardsDefault: ${defaultExpression} })`;
-        case "Bytea":
-            return `s.drop.bytes({ backwardsDefault: ${defaultExpression} })`;
-        case "Json":
-            return column.column_type.schema
-                ? `s.drop.json({ backwardsDefault: ${defaultExpression}, schema: ${JSON.stringify(column.column_type.schema)} })`
-                : `s.drop.json({ backwardsDefault: ${defaultExpression} })`;
-        case "Enum":
-            return `s.drop.enum(${column.column_type.variants
-                .map((variant) => JSON.stringify(variant))
-                .join(", ")}, { backwardsDefault: ${defaultExpression} })`;
-        case "Uuid":
-            if (column.references) {
-                return `s.drop.ref(${JSON.stringify(column.references)}, { backwardsDefault: ${defaultExpression} })`;
-            }
-            return `s.drop.ref("TODO_TABLE", { backwardsDefault: ${defaultExpression} })`;
-        case "Array":
-            return `s.drop.array({ of: ${renderArrayElementExpression(column.column_type.element, column.references)}, backwardsDefault: ${defaultExpression} })`;
-        case "BigInt":
-            throw new Error("Migration stub generation does not yet support BIGINT columns.");
-        case "Row":
-            throw new Error("Migration stub generation does not yet support row-valued columns.");
-    }
-}
-function inferTableSuggestions(tableName, fromTable, toTable) {
-    const fromColumns = new Map(fromTable.columns.map((column) => [column.name, column]));
-    const toColumns = new Map(toTable.columns.map((column) => [column.name, column]));
-    const comments = [];
-    const properties = [];
-    const removedColumns = [...fromColumns.keys()].filter((name) => !toColumns.has(name));
-    const addedColumns = [...toColumns.keys()].filter((name) => !fromColumns.has(name));
-    if (removedColumns.length === 1 && addedColumns.length === 1) {
-        const removed = fromColumns.get(removedColumns[0]);
-        const added = toColumns.get(addedColumns[0]);
-        if (removed.nullable === added.nullable &&
-            removed.references === added.references &&
-            columnTypeSignature(removed.column_type) === columnTypeSignature(added.column_type)) {
-            comments.push(`Possible rename detected: ${JSON.stringify(removed.name)} -> ${JSON.stringify(added.name)}.`);
-        }
-    }
-    for (const columnName of addedColumns) {
-        const column = toColumns.get(columnName);
-        if (column.nullable) {
-            properties.push(`${JSON.stringify(columnName)}: ${renderAddOperationExpression(column, "null")},`);
-        }
-        else {
-            comments.push(`Added required column ${JSON.stringify(columnName)} needs an explicit default.`);
-        }
-    }
-    for (const columnName of removedColumns) {
-        const column = fromColumns.get(columnName);
-        if (column.nullable) {
-            properties.push(`${JSON.stringify(columnName)}: ${renderDropOperationExpression(column, "null")},`);
-        }
-        else {
-            comments.push(`Removed required column ${JSON.stringify(columnName)} needs an explicit backwardsDefault.`);
-        }
-    }
-    return {
-        tableName,
-        comments,
-        properties,
-    };
-}
-function renderMigrationBody(fromSchema, toSchema) {
-    const renameSuggestions = detectPossibleTableRenames(fromSchema, toSchema);
-    const renamedOldTables = new Set(renameSuggestions.map((suggestion) => suggestion.oldTableName));
-    const renamedNewTables = new Set(renameSuggestions.map((suggestion) => suggestion.newTableName));
-    const addedTables = Object.keys(toSchema)
-        .filter((tableName) => !fromSchema[tableName])
-        .sort();
-    const removedTables = Object.keys(fromSchema)
-        .filter((tableName) => !toSchema[tableName])
-        .sort();
-    const explicitAddedTables = addedTables.filter((tableName) => !renamedNewTables.has(tableName));
-    const explicitRemovedTables = removedTables.filter((tableName) => !renamedOldTables.has(tableName));
-    const changedTables = changedTableNames(fromSchema, toSchema);
-    const migratableTables = changedTables.filter((tableName) => fromSchema[tableName] !== undefined && toSchema[tableName] !== undefined);
-    const witnessFromTables = [...migratableTables, ...explicitRemovedTables];
-    const witnessToTables = [...migratableTables, ...explicitAddedTables];
-    for (const renameSuggestion of renameSuggestions) {
-        witnessFromTables.push(renameSuggestion.oldTableName);
-        witnessToTables.push(renameSuggestion.newTableName);
-    }
-    const witnessFrom = pickWitnessSchema(fromSchema, witnessFromTables);
-    const witnessTo = pickWitnessSchema(toSchema, witnessToTables);
-    const lines = [];
-    for (const tableName of migratableTables) {
-        const fromTable = fromSchema[tableName];
-        const toTable = toSchema[tableName];
-        const suggestion = inferTableSuggestions(tableName, fromTable, toTable);
-        lines.push(`${JSON.stringify(tableName)}: {`);
-        for (const comment of suggestion.comments) {
-            lines.push(`  // TODO: ${comment}`);
-        }
-        for (const property of suggestion.properties) {
-            lines.push(`  ${property}`);
-        }
-        if (suggestion.comments.length === 0 && suggestion.properties.length === 0) {
-            lines.push("  // TODO: No safe migration steps were inferred automatically.");
-        }
-        lines.push("},");
-        lines.push("");
-    }
-    if (lines.length === 0) {
-        if (renameSuggestions.length === 0 &&
-            explicitAddedTables.length === 0 &&
-            explicitRemovedTables.length === 0) {
-            lines.push(changedTables.length === 0
-                ? "// TODO: No schema differences were detected."
-                : "// TODO: No column-level migration steps were required for the detected schema changes.");
-        }
-    }
-    return {
-        migrateBody: lines.length > 0 ? lines.join("\n").trimEnd() : undefined,
-        createTablesBody: explicitAddedTables.length > 0
-            ? explicitAddedTables.map((tableName) => `${JSON.stringify(tableName)}: true,`).join("\n")
-            : undefined,
-        dropTablesBody: explicitRemovedTables.length > 0
-            ? explicitRemovedTables.map((tableName) => `${JSON.stringify(tableName)}: true,`).join("\n")
-            : undefined,
-        renameTablesBody: renameSuggestions.length > 0
-            ? renameSuggestions
-                .map((renameSuggestion) => `${renameSuggestion.newTableName}: s.renameTableFrom(${JSON.stringify(renameSuggestion.oldTableName)}),`)
-                .join("\n")
-            : undefined,
-        witnessFrom,
-        witnessTo,
-    };
-}
 async function packageVersion() {
     const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
     return packageJson.version ?? "unknown";
 }
-function createTimestamp(now = new Date()) {
-    const year = now.getUTCFullYear();
-    const month = String(now.getUTCMonth() + 1).padStart(2, "0");
-    const day = String(now.getUTCDate()).padStart(2, "0");
-    const hours = String(now.getUTCHours()).padStart(2, "0");
-    const minutes = String(now.getUTCMinutes()).padStart(2, "0");
-    const seconds = String(now.getUTCSeconds()).padStart(2, "0");
-    return `${year}${month}${day}T${hours}${minutes}${seconds}`;
-}
-function createSnapshotTimestampFromPublishedAt(publishedAt, fallbackNow = new Date()) {
-    if (typeof publishedAt !== "number" || !Number.isFinite(publishedAt) || publishedAt < 0) {
-        return createTimestamp(fallbackNow);
-    }
-    return createTimestamp(new Date(publishedAt));
-}
-function normalizeMigrationName(name) {
-    const normalized = name
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-    if (normalized.length === 0) {
-        throw new Error("Migration name must contain at least one ASCII letter or digit after normalization.");
-    }
-    return normalized;
-}
-function migrationFilename(migrationsDir, fromHash, toHash, name = "unnamed", timestamp = createTimestamp()) {
-    return join(migrationsDir, `${timestamp}-${name}-${shortSchemaHash(fromHash)}-${shortSchemaHash(toHash)}.ts`);
-}
-function snapshotFilename(hash, timestamp = createTimestamp()) {
-    return `${timestamp}-${shortSchemaHash(hash)}.json`;
-}
-function renderMigrationStub(input) {
-    const rendered = renderMigrationBody(input.fromSchema, input.toSchema);
-    const sections = [];
-    if (rendered.renameTablesBody) {
-        sections.push(`  renameTables: {\n${indentBlock(rendered.renameTablesBody, 4)}\n  },`);
-    }
-    if (rendered.createTablesBody) {
-        sections.push(`  createTables: {\n${indentBlock(rendered.createTablesBody, 4)}\n  },`);
-    }
-    if (rendered.dropTablesBody) {
-        sections.push(`  dropTables: {\n${indentBlock(rendered.dropTablesBody, 4)}\n  },`);
-    }
-    if (rendered.migrateBody) {
-        sections.push(`  migrate: {\n${indentBlock(rendered.migrateBody, 4)}\n  },`);
-    }
-    sections.push(`  fromHash: ${JSON.stringify(shortSchemaHash(input.fromHash))},`);
-    sections.push(`  toHash: ${JSON.stringify(shortSchemaHash(input.toHash))},`);
-    sections.push(`  from: ${renderSchemaWitness(rendered.witnessFrom)},`);
-    sections.push(`  to: ${renderSchemaWitness(rendered.witnessTo)},`);
-    return `import { schema as s } from "jazz-tools";
-
-export default s.defineMigration({
-${sections.join("\n")}
-});
-`;
-}
-function isDefinedMigration(value) {
-    if (typeof value !== "object" || value === null) {
-        return false;
-    }
-    const candidate = value;
-    return (typeof candidate.fromHash === "string" &&
-        typeof candidate.toHash === "string" &&
-        typeof candidate.from === "object" &&
-        candidate.from !== null &&
-        typeof candidate.to === "object" &&
-        candidate.to !== null &&
-        Array.isArray(candidate.forward));
-}
-async function loadDefinedMigration(filePath) {
-    const outFile = await bundleToTempFile(filePath);
-    try {
-        const loaded = (await import(pathToFileURL(outFile).href));
-        const migration = unwrapMigrationExport(loaded.default ?? loaded.migration);
-        if (!isDefinedMigration(migration)) {
-            throw new Error(`Invalid migration export in ${basename(filePath)}. Export default defineMigration(...).`);
-        }
-        return migration;
-    }
-    finally {
-        await rm(outFile, { force: true }).catch(() => undefined);
-    }
-}
-function unwrapMigrationExport(value) {
-    let current = value;
-    while (typeof current === "object" &&
-        current !== null &&
-        "default" in current &&
-        Object.keys(current).length === 1) {
-        current = current.default;
-    }
-    return current;
-}
-async function findMigrationFile(migrationsDir, fromHash, toHash) {
-    if (!(await pathExists(migrationsDir))) {
-        throw new Error(`No migration file found in ${migrationsDir} for ${fromHash} -> ${toHash}.`);
-    }
-    const fromShortHash = shortSchemaHash(fromHash);
-    const toShortHash = shortSchemaHash(toHash);
-    const files = await readdir(migrationsDir);
-    const matches = files
-        .filter((file) => file.endsWith(".ts"))
-        .filter((file) => file.includes(`-${fromShortHash}-${toShortHash}.ts`) ||
-        file.includes(`-${fromHash}-${toHash}.ts`));
-    if (matches.length === 0) {
-        throw new Error(`No migration file found in ${migrationsDir} for ${fromHash} -> ${toHash}.`);
-    }
-    if (matches.length > 1) {
-        throw new Error(`Multiple migration files found for ${fromHash} -> ${toHash}: ${matches.join(", ")}`);
-    }
-    return join(migrationsDir, matches[0]);
-}
-function isCommittedSnapshotFileName(fileName) {
-    return /^\d{8}T\d{6}-[0-9a-f]{12}\.json$/i.test(fileName);
-}
-async function loadLatestCommittedSnapshot(migrationsDir) {
-    const entries = await listSnapshotEntriesForMigrations(migrationsDir);
-    const latest = entries
-        .filter((entry) => isCommittedSnapshotFileName(entry.fileName))
-        .sort((left, right) => left.fileName.localeCompare(right.fileName))
-        .at(-1);
-    if (!latest) {
-        return null;
-    }
-    return {
-        hash: latest.hash,
-        schema: latest.schema,
-    };
-}
-async function ensureCommittedSnapshot(migrationsDir, schema, timestamp) {
-    const entries = await listSnapshotEntriesForMigrations(migrationsDir);
-    if (entries.some((entry) => entry.hash === schema.hash && isCommittedSnapshotFileName(entry.fileName))) {
-        return null;
-    }
-    return writeSnapshotSchemaForMigrations(migrationsDir, snapshotFilename(schema.hash, timestamp), schema.schema);
-}
-async function loadCurrentSchema(schemaDir) {
-    const compiled = await loadCompiledSchema(schemaDir);
-    return {
-        hash: await computeSchemaHash(compiled.wasmSchema),
-        schema: compiled.wasmSchema,
-    };
-}
-async function resolveHistoricalSchema(migrationsDir, hash, label, appId, serverUrl, adminSecret) {
-    const localEntries = await listSnapshotEntriesForMigrations(migrationsDir);
-    const normalized = normalizeSchemaHashInput(hash, label);
-    const localFullHash = normalized.length === 64
-        ? localEntries.find((entry) => entry.hash === normalized)?.hash
-        : (() => {
-            const matches = localEntries.filter((entry) => entry.hash.startsWith(normalized));
-            if (matches.length === 0) {
-                return null;
-            }
-            if (matches.length > 1) {
-                throw new Error(`${label} prefix ${normalized} is ambiguous: ${matches
-                    .map((entry) => shortSchemaHash(entry.hash))
-                    .join(", ")}`);
-            }
-            return matches[0].hash;
-        })();
-    if (localFullHash) {
-        return {
-            hash: localFullHash,
-            schema: localEntries.find((entry) => entry.hash === localFullHash).schema,
-        };
-    }
-    const resolvedHash = normalized.length === 64
-        ? normalized
-        : resolveKnownSchemaHash(normalized, label, (await fetchSchemaHashes(requireSchemaExportServerValue(serverUrl, "serverUrl"), {
-            appId: requireAppId(appId),
-            adminSecret: requireSchemaExportServerValue(adminSecret, "adminSecret"),
-        })).hashes);
-    const resolvedAppId = requireAppId(appId);
-    const resolvedServerUrl = requireSchemaExportServerValue(serverUrl, "serverUrl");
-    const resolvedAdminSecret = requireSchemaExportServerValue(adminSecret, "adminSecret");
-    try {
-        const storedSchema = await fetchStoredWasmSchema(resolvedServerUrl, {
-            appId: resolvedAppId,
-            adminSecret: resolvedAdminSecret,
-            schemaHash: resolvedHash,
-        });
-        await writeSnapshotSchemaForMigrations(migrationsDir, snapshotFilename(resolvedHash, createSnapshotTimestampFromPublishedAt(storedSchema.publishedAt)), storedSchema.schema);
-        return { hash: resolvedHash, schema: storedSchema.schema };
-    }
-    catch (error) {
-        if (error instanceof Error && /Schema fetch failed: 404/i.test(error.message)) {
-            throw new Error(`No stored schema found for ${label} ${resolvedHash}.`);
-        }
-        throw error;
-    }
-}
 export async function createMigration(options) {
-    const explicitHashFlow = Boolean(options.fromHash || options.toHash);
-    await mkdir(options.migrationsDir, { recursive: true });
-    const currentSchema = !explicitHashFlow || !options.toHash ? await loadCurrentSchema(options.schemaDir) : null;
-    let fromSchema;
-    let toSchema;
-    let shouldWriteCommittedSnapshot = false;
-    const timestamp = createTimestamp();
-    if (explicitHashFlow) {
-        if (options.fromHash) {
-            fromSchema = await resolveHistoricalSchema(options.migrationsDir, options.fromHash, "fromHash", options.appId, options.serverUrl, options.adminSecret);
-        }
-        else {
-            const latest = await loadLatestCommittedSnapshot(options.migrationsDir);
-            if (!latest) {
-                throw new Error("No committed snapshot found. Provide --fromHash or run `jazz-tools migrations create` once to create an initial snapshot.");
-            }
-            fromSchema = latest;
-        }
-        toSchema = options.toHash
-            ? await resolveHistoricalSchema(options.migrationsDir, options.toHash, "toHash", options.appId, options.serverUrl, options.adminSecret)
-            : currentSchema;
-        shouldWriteCommittedSnapshot = !options.toHash;
-    }
-    else {
-        const latest = await loadLatestCommittedSnapshot(options.migrationsDir);
-        if (!latest) {
-            const snapshotPath = await ensureCommittedSnapshot(options.migrationsDir, currentSchema, timestamp);
-            console.log(`Wrote initial schema snapshot: ${snapshotPath}`);
+    const result = await createCatalogueMigration(options);
+    switch (result.status) {
+        case "initial-snapshot":
+            console.log("Wrote initial schema snapshot: " + result.snapshotPath);
             console.log("No migration created because there was no previous local schema baseline.");
             return null;
-        }
-        if (latest.hash === currentSchema.hash) {
+        case "unchanged":
             console.log("No structural schema changes detected.");
             return null;
+        case "migration-not-required": {
+            const version = await packageVersion();
+            console.log("No reviewed migration file needed because this schema change does not require row transformations.");
+            console.log("Next step: Run npx jazz-tools@" +
+                version +
+                " migrations push " +
+                (options.appId ?? "<appId>") +
+                " " +
+                shortSchemaHash(result.fromHash) +
+                " " +
+                shortSchemaHash(result.toHash));
+            return null;
         }
-        fromSchema = latest;
-        toSchema = currentSchema;
-        shouldWriteCommittedSnapshot = true;
-    }
-    if (fromSchema.hash === toSchema.hash) {
-        console.log("No structural schema changes detected.");
-        return null;
-    }
-    if (!schemaTransitionRequiresRowTransform(fromSchema.schema, toSchema.schema)) {
-        if (shouldWriteCommittedSnapshot) {
-            await ensureCommittedSnapshot(options.migrationsDir, toSchema, timestamp);
+        case "generated": {
+            const version = await packageVersion();
+            console.log("Generated: " + result.filePath);
+            console.log("");
+            console.log("Migration stubs are only for structural schema changes.");
+            console.log(PERMISSIONS_LIFECYCLE_NOTE);
+            console.log("");
+            console.log("Next steps:");
+            console.log("1. Fill in migrate.");
+            if (result.needsRename) {
+                console.log("2. Rename the file by replacing 'unnamed'.");
+            }
+            console.log((result.needsRename ? "3" : "2") +
+                ". Run npx jazz-tools@" +
+                version +
+                " migrations push " +
+                (options.appId ?? "<appId>") +
+                " " +
+                shortSchemaHash(result.fromHash) +
+                " " +
+                shortSchemaHash(result.toHash));
+            return result.filePath;
         }
-        const version = await packageVersion();
-        console.log("No reviewed migration file needed because this schema change does not require row transformations.");
-        console.log(`Next step: Run npx jazz-tools@${version} migrations push ${options.appId ?? "<appId>"} ${shortSchemaHash(fromSchema.hash)} ${shortSchemaHash(toSchema.hash)}`);
-        return null;
     }
-    const filePath = migrationFilename(options.migrationsDir, fromSchema.hash, toSchema.hash, options.name ? normalizeMigrationName(options.name) : undefined, timestamp);
-    if (await pathExists(filePath)) {
-        throw new Error(`Migration stub already exists: ${filePath}`);
-    }
-    const stub = renderMigrationStub({
-        fromHash: fromSchema.hash,
-        toHash: toSchema.hash,
-        fromSchema: fromSchema.schema,
-        toSchema: toSchema.schema,
-    });
-    await writeFile(filePath, stub);
-    if (shouldWriteCommittedSnapshot) {
-        await ensureCommittedSnapshot(options.migrationsDir, toSchema, timestamp);
-    }
-    const version = await packageVersion();
-    console.log(`Generated: ${filePath}`);
-    console.log("");
-    console.log("Migration stubs are only for structural schema changes.");
-    console.log(PERMISSIONS_LIFECYCLE_NOTE);
-    console.log("");
-    console.log("Next steps:");
-    console.log("1. Fill in migrate.");
-    if (!options.name) {
-        console.log("2. Rename the file by replacing 'unnamed'.");
-    }
-    console.log(`${options.name ? "2" : "3"}. Run npx jazz-tools@${version} migrations push ${options.appId ?? "<appId>"} ${shortSchemaHash(fromSchema.hash)} ${shortSchemaHash(toSchema.hash)}`);
-    return filePath;
 }
 export async function pushMigration(options) {
     const { appId, serverUrl, adminSecret } = requireMigrationServerOptions(options);
-    const { hashes } = await fetchSchemaHashes(serverUrl, {
+    const result = await pushCatalogueMigration({
         appId,
+        serverUrl,
         adminSecret,
+        migrationsDir: options.migrationsDir,
+        fromHash: options.fromHash,
+        toHash: options.toHash,
     });
-    const fromHash = resolveKnownSchemaHash(options.fromHash, "fromHash", hashes);
-    const toHash = resolveKnownSchemaHash(options.toHash, "toHash", hashes);
-    let filePath = null;
-    try {
-        filePath = await findMigrationFile(options.migrationsDir, fromHash, toHash);
-    }
-    catch (error) {
-        if (!(error instanceof Error) ||
-            !error.message.startsWith(`No migration file found in ${options.migrationsDir}`)) {
-            throw error;
-        }
-    }
-    if (!filePath) {
-        const fromSchema = await resolveHistoricalSchema(options.migrationsDir, fromHash, "fromHash", appId, serverUrl, adminSecret);
-        const toSchema = await resolveHistoricalSchema(options.migrationsDir, toHash, "toHash", appId, serverUrl, adminSecret);
-        if (schemaTransitionRequiresRowTransform(fromSchema.schema, toSchema.schema)) {
-            throw new Error(`No migration file found in ${options.migrationsDir} for ${fromHash} -> ${toHash}. Run \`jazz-tools migrations create ${appId} --fromHash ${shortSchemaHash(fromHash)} --toHash ${shortSchemaHash(toHash)}\` first.`);
-        }
-        await publishStoredMigration(serverUrl, {
-            appId,
-            adminSecret,
-            fromHash,
-            toHash,
-            forward: [],
-        });
-        console.log(`Pushed migration ${shortSchemaHash(fromHash)} -> ${shortSchemaHash(toHash)} without a reviewed migration file because no row transformations are required.`);
+    if (result.filePath) {
+        console.log(`Pushed migration ${shortSchemaHash(result.fromHash)} -> ${shortSchemaHash(result.toHash)} from ${basename(result.filePath)}.`);
         return;
     }
-    const migration = await loadDefinedMigration(filePath);
-    if (!hashMatchesFullSchema(migration.fromHash, fromHash) ||
-        !hashMatchesFullSchema(migration.toHash, toHash)) {
-        throw new Error(`Migration ${basename(filePath)} exports ${migration.fromHash} -> ${migration.toHash}, expected ${shortSchemaHash(fromHash)} -> ${shortSchemaHash(toHash)}.`);
-    }
-    schemaDefinitionToAst(migration.from);
-    schemaDefinitionToAst(migration.to);
-    if (migration.forward.length === 0) {
-        const fromSchema = await resolveHistoricalSchema(options.migrationsDir, fromHash, "fromHash", appId, serverUrl, adminSecret);
-        const toSchema = await resolveHistoricalSchema(options.migrationsDir, toHash, "toHash", appId, serverUrl, adminSecret);
-        if (schemaTransitionRequiresRowTransform(fromSchema.schema, toSchema.schema)) {
-            throw new Error(`Migration ${basename(filePath)} has no steps. Fill in migrate before push.`);
-        }
-    }
-    const forward = migration.forward.length === 0 ? [] : serializeForwardLenses(migration.forward);
-    await publishStoredMigration(serverUrl, {
-        appId,
-        adminSecret,
-        fromHash,
-        toHash,
-        forward,
-    });
-    console.log(`Pushed migration ${shortSchemaHash(fromHash)} -> ${shortSchemaHash(toHash)} from ${basename(filePath)}.`);
+    console.log(`Pushed migration ${shortSchemaHash(result.fromHash)} -> ${shortSchemaHash(result.toHash)} without a reviewed migration file because no row transformations are required.`);
 }
 function describePermissionsHead(head) {
     return `v${head.version} on ${shortSchemaHash(head.schemaHash)}`;
 }
+function logDeployWarning(message) {
+    if (message.startsWith("Warning: table ")) {
+        console.warn(`\x1b[33m${message}\x1b[0m`);
+        return;
+    }
+    if (message.startsWith("Warning: ")) {
+        console.warn(message);
+        return;
+    }
+    console.warn(`Warning: ${message}`);
+}
 export async function permissionsStatus(options) {
-    const compiled = ensurePermissionsProject(await loadCompiledSchema(options.schemaDir));
-    const localSchemaHash = await resolveStoredStructuralSchemaHashOrThrow(options.appId, options.serverUrl, options.adminSecret, compiled.wasmSchema);
-    const { head } = await fetchPermissionsHead(options.serverUrl, {
-        appId: options.appId,
-        adminSecret: options.adminSecret,
-    });
-    console.log(`Loaded structural schema from ${compiled.schemaFile}.`);
-    console.log(`Loaded current permissions from ${compiled.permissionsFile}.`);
-    console.log(`Local structural schema matches stored hash ${shortSchemaHash(localSchemaHash)}.`);
+    const result = await getPermissionsStatus(options);
+    console.log(`Loaded structural schema from ${result.schemaFile}.`);
+    console.log(`Loaded current permissions from ${result.permissionsFile}.`);
+    console.log(`Local structural schema matches stored hash ${shortSchemaHash(result.localSchemaHash)}.`);
     console.log(PERMISSIONS_LIFECYCLE_NOTE);
-    if (!head) {
+    if (!result.head) {
         console.log("Server has no published permissions head yet.");
         console.log("Next push will publish version 1.");
         return;
     }
-    console.log(`Server permissions head is ${describePermissionsHead(head)}.`);
-    if (head.schemaHash === localSchemaHash) {
+    console.log(`Server permissions head is ${describePermissionsHead(result.head)}.`);
+    if (result.head.schemaHash === result.localSchemaHash) {
         console.log("Current server permissions already target this structural schema.");
     }
     else {
-        console.log(`Current server permissions target ${shortSchemaHash(head.schemaHash)}; pushing will retarget the head to ${shortSchemaHash(localSchemaHash)}.`);
+        console.log(`Current server permissions target ${shortSchemaHash(result.head.schemaHash)}; pushing will retarget the head to ${shortSchemaHash(result.localSchemaHash)}.`);
     }
-    console.log(`Next push will require parent bundle ${head.bundleObjectId}.`);
+    console.log(`Next push will require parent bundle ${result.head.bundleObjectId}.`);
 }
 export async function deploy(options) {
-    const compiled = await loadCompiledSchema(options.schemaDir);
-    console.log(`Loaded current schema from ${compiled.schemaFile}.`);
-    for (const diagnostic of collectMissingExplicitPolicyDiagnostics(compiled.schema.tables.map((table) => table.name), compiled.permissions)) {
-        console.warn(`\x1b[33m${diagnostic.message}\x1b[0m`);
-    }
-    let localSchemaHash = await resolveStoredStructuralSchemaHash(options.appId, options.serverUrl, options.adminSecret, compiled.wasmSchema);
-    if (!localSchemaHash) {
-        const publishedSchema = await publishStoredSchema(options.serverUrl, {
-            appId: options.appId,
-            adminSecret: options.adminSecret,
-            schema: compiled.wasmSchema,
-        });
-        localSchemaHash = publishedSchema.hash;
-        console.log(`Published the current schema as ${shortSchemaHash(localSchemaHash)}.`);
-    }
-    else {
-        console.log(`The current schema is already stored in the server as ${shortSchemaHash(localSchemaHash)}; skipping publish.`);
-    }
-    if (!compiled.permissions || !compiled.permissionsFile) {
-        console.log("No permissions.ts found; skipping permissions publish.");
-        return;
-    }
-    console.log(`Loaded current permissions from ${compiled.permissionsFile}.`);
-    const { head: currentHead } = await fetchPermissionsHead(options.serverUrl, {
-        appId: options.appId,
-        adminSecret: options.adminSecret,
-    });
-    if (currentHead && currentHead.schemaHash !== localSchemaHash) {
-        const fromShortHash = shortSchemaHash(currentHead.schemaHash);
-        const toShortHash = shortSchemaHash(localSchemaHash);
-        try {
-            const { connected } = await fetchSchemaConnectivity(options.serverUrl, {
-                appId: options.appId,
-                adminSecret: options.adminSecret,
-                fromHash: currentHead.schemaHash,
-                toHash: localSchemaHash,
-            });
-            if (!connected) {
-                await pushMigration({
-                    appId: options.appId,
-                    serverUrl: options.serverUrl,
-                    adminSecret: options.adminSecret,
-                    migrationsDir: options.migrationsDir,
-                    fromHash: currentHead.schemaHash,
-                    toHash: localSchemaHash,
-                });
+    const result = await deployCatalogue({
+        ...options,
+        onEvent: (event) => {
+            switch (event.type) {
+                case "schema-loaded":
+                    console.log(`Loaded current schema from ${event.schemaFile}.`);
+                    break;
+                case "warning":
+                    logDeployWarning(event.message);
+                    break;
+                case "schema-published":
+                    console.log(`Published the current schema as ${shortSchemaHash(event.hash)}.`);
+                    break;
+                case "schema-skipped":
+                    console.log(`The current schema is already stored in the server as ${shortSchemaHash(event.hash)}; skipping publish.`);
+                    break;
+                case "permissions-skipped":
+                    console.log("No permissions.ts found; skipping permissions publish.");
+                    break;
+                case "permissions-loaded":
+                    console.log(`Loaded current permissions from ${event.permissionsFile}.`);
+                    break;
+                case "migration-published":
+                    if (event.filePath) {
+                        console.log(`Pushed migration ${shortSchemaHash(event.fromHash)} -> ${shortSchemaHash(event.toHash)} from ${basename(event.filePath)}.`);
+                    }
+                    else {
+                        console.log(`Pushed migration ${shortSchemaHash(event.fromHash)} -> ${shortSchemaHash(event.toHash)} without a reviewed migration file because no row transformations are required.`);
+                    }
+                    break;
+                case "permissions-published":
+                    break;
             }
-        }
-        catch (error) {
-            const migrationMissingPrefix = `No migration file found in ${options.migrationsDir}`;
-            if (!(error instanceof Error) || !error.message.startsWith(migrationMissingPrefix)) {
-                throw error;
-            }
-            const message = `The new permissions schema ${toShortHash} is not connected to the previous permissions schema ${fromShortHash} on the server. Reads and writes may fail until you push a migration. Run \`jazz-tools migrations create ${options.appId} --fromHash ${fromShortHash} --toHash ${toShortHash}\` to create a migration and then re-run this command.`;
-            if (options.noVerify) {
-                console.warn(`Warning: ${message}`);
-            }
-            else {
-                throw Error(message);
-            }
-        }
-    }
-    const { head: publishedHead } = await publishStoredPermissions(options.serverUrl, {
-        appId: options.appId,
-        adminSecret: options.adminSecret,
-        schemaHash: localSchemaHash,
-        permissions: compiled.permissions,
-        expectedParentBundleObjectId: currentHead?.bundleObjectId ?? null,
+        },
     });
-    const nextHead = publishedHead ?? {
-        schemaHash: localSchemaHash,
-        version: currentHead ? currentHead.version + 1 : 1,
-        parentBundleObjectId: currentHead?.bundleObjectId ?? null,
-        bundleObjectId: currentHead?.bundleObjectId ?? "",
+    if (!result.permissions) {
+        return;
+    }
+    const previousHead = result.permissions.previousHead;
+    const nextHead = result.permissions.head ?? {
+        schemaHash: result.permissions.schemaHash,
+        version: previousHead ? previousHead.version + 1 : 1,
+        parentBundleObjectId: previousHead?.bundleObjectId ?? null,
+        bundleObjectId: previousHead?.bundleObjectId ?? "",
     };
     console.log(`Published permissions as ${describePermissionsHead(nextHead)}.`);
 }