ormbridge 0.0.0-stage → 0.2.0

package/dist/parsers/laravel.js

@@ -0,0 +1,2824 @@
+import { basename } from 'node:path';
+import { singularize, toPascalCase, toSnakeCase } from '../naming.js';
+import { err, ok } from '../result.js';
+import { argumentNodes, collectDeclarations, evaluateNode, getPhpParser, lastNameSegment, readEnumDeclaration, resolveClassName, } from './phpSyntax.js';
+// ---------------------------------------------------------------------------
+// Static tables
+// ---------------------------------------------------------------------------
+/** Framework classes an Eloquent model may extend, as fully qualified names. */
+const MODEL_BASE_CLASSES = new Set([
+    'Illuminate\\Database\\Eloquent\\Model',
+    'Illuminate\\Foundation\\Auth\\User',
+    'Illuminate\\Database\\Eloquent\\Relations\\Pivot',
+    'Illuminate\\Database\\Eloquent\\Relations\\MorphPivot',
+]);
+/** Short base class names accepted when the import cannot be resolved (for example a file read on its own). */
+const MODEL_BASE_SHORT_NAMES = new Set([
+    'Model',
+    'Authenticatable',
+    'Pivot',
+    'MorphPivot',
+]);
+const RELATION_METHODS = new Set([
+    'hasOne',
+    'hasMany',
+    'belongsTo',
+    'belongsToMany',
+    'hasOneThrough',
+    'hasManyThrough',
+    'morphTo',
+    'morphOne',
+    'morphMany',
+    'morphToMany',
+    'morphedByMany',
+    'hasOneOfMany',
+    'latestOfMany',
+    'oldestOfMany',
+]);
+const RELATION_RETURN_TYPES = new Set([
+    'HasOne',
+    'HasMany',
+    'BelongsTo',
+    'BelongsToMany',
+    'HasOneThrough',
+    'HasManyThrough',
+    'MorphTo',
+    'MorphOne',
+    'MorphMany',
+    'MorphToMany',
+    'Relation',
+]);
+/** Methods that may follow a relationship call without changing which rows it relates. */
+const HARMLESS_RELATION_MODIFIERS = new Set([
+    'withPivot',
+    'withTimestamps',
+    'as',
+    'using',
+    'withDefault',
+    'withoutGlobalScopes',
+    'withoutGlobalScope',
+    'orderBy',
+    'orderByDesc',
+    'latest',
+    'oldest',
+    'withCount',
+    'with',
+    'withTrashed',
+    'onlyTrashed',
+    'select',
+    'addSelect',
+    'distinct',
+    'limit',
+    'take',
+    'inRandomOrder',
+    'cascadeOnDelete',
+]);
+const ON_DELETE_ACTIONS = {
+    cascade: 'cascade',
+    'set null': 'setNull',
+    restrict: 'restrict',
+    'no action': 'noAction',
+    'set default': 'setDefault',
+};
+const GEOMETRY_TYPES = new Set([
+    'geometry',
+    'geography',
+    'point',
+    'lineString',
+    'polygon',
+    'geometryCollection',
+    'multiPoint',
+    'multiLineString',
+    'multiPolygon',
+    'multiPolygonZ',
+]);
+/** `DB::` helpers that run SQL the parser cannot interpret. */
+const RAW_SQL_METHODS = new Set([
+    'statement',
+    'unprepared',
+]);
+/** Blueprint methods that change nothing the IR represents. */
+const IGNORED_TABLE_METHODS = new Set([
+    'engine',
+    'charset',
+    'collation',
+    'comment',
+    'temporary',
+]);
+/** Schema methods that change nothing the IR represents. */
+const IGNORED_SCHEMA_METHODS = new Set([
+    'disableForeignKeyConstraints',
+    'enableForeignKeyConstraints',
+    'defaultStringLength',
+    'defaultMorphKeyType',
+    'morphUsingUuids',
+    'morphUsingUlids',
+]);
+/** Column modifiers that change nothing the IR represents. */
+const IGNORED_COLUMN_MODIFIERS = new Set([
+    'unsigned',
+    'comment',
+    'after',
+    'first',
+    'charset',
+    'collation',
+    'invisible',
+    'algorithm',
+    'language',
+    'deferrable',
+    'initiallyImmediate',
+    'notValid',
+    'lock',
+]);
+const CONTROL_STATEMENTS = new Set([
+    'if_statement',
+    'foreach_statement',
+    'for_statement',
+    'while_statement',
+    'do_statement',
+    'switch_statement',
+    'try_statement',
+]);
+const CLAUSE_STATEMENTS = new Set([
+    'else_clause',
+    'else_if_clause',
+    'catch_clause',
+    'finally_clause',
+    'case_statement',
+    'default_statement',
+    'switch_block',
+    'colon_block',
+]);
+const UNCOUNTABLE_NOUNS = new Set([
+    'audio',
+    'bison',
+    'cattle',
+    'chassis',
+    'compensation',
+    'data',
+    'deer',
+    'education',
+    'emoji',
+    'equipment',
+    'evidence',
+    'feedback',
+    'firmware',
+    'fish',
+    'furniture',
+    'gold',
+    'hardware',
+    'information',
+    'knowledge',
+    'media',
+    'metadata',
+    'money',
+    'moose',
+    'news',
+    'nutrition',
+    'offspring',
+    'police',
+    'rain',
+    'rice',
+    'series',
+    'sheep',
+    'software',
+    'staff',
+    'species',
+    'swine',
+    'traffic',
+    'wheat',
+]);
+const IRREGULAR_PLURALS = {
+    person: 'people',
+    man: 'men',
+    woman: 'women',
+    child: 'children',
+    foot: 'feet',
+    tooth: 'teeth',
+    goose: 'geese',
+    mouse: 'mice',
+    ox: 'oxen',
+    quiz: 'quizzes',
+    move: 'moves',
+    sex: 'sexes',
+};
+// ---------------------------------------------------------------------------
+// Small helpers
+// ---------------------------------------------------------------------------
+function pushWarning(warnings, message) {
+    if (!warnings.includes(message)) {
+        warnings.push(message);
+    }
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function sameList(first, second) {
+    return (first.length === second.length &&
+        first.every((item, index) => item === second[index]));
+}
+function pluralizeWord(word) {
+    const lower = word.toLowerCase();
+    if (UNCOUNTABLE_NOUNS.has(lower)) {
+        return word;
+    }
+    const irregular = IRREGULAR_PLURALS[lower];
+    if (irregular !== undefined) {
+        return irregular;
+    }
+    const rules = [
+        [/(s)tatus$/i, '$1tatuses'],
+        [/(alias)$/i, '$1es'],
+        [/(matr|vert|ind)(ix|ex)$/i, '$1ices'],
+        [/(octop|vir)us$/i, '$1i'],
+        [/(ax|test)is$/i, '$1es'],
+        [/(x|ch|ss|sh)$/i, '$1es'],
+        [/([^aeiouy]|qu)y$/i, '$1ies'],
+        [/(?:([^f])fe|([lr])f)$/i, '$1$2ves'],
+        [/(lea)f$/i, '$1ves'],
+        [/sis$/i, 'ses'],
+        [/([ti])um$/i, '$1a'],
+        [/(buffal|tomat|potat|her)o$/i, '$1oes'],
+        [/(us|as)$/i, '$1es'],
+        [/s$/i, 's'],
+    ];
+    for (const [pattern, replacement] of rules) {
+        if (pattern.test(word)) {
+            return word.replace(pattern, replacement);
+        }
+    }
+    return `${word}s`;
+}
+/** Laravel's `Str::snake`: every capital starts a new word, so `APIKey` becomes `a_p_i_key`. */
+function eloquentSnake(name) {
+    return name.replace(/(.)(?=[A-Z])/g, '$1_').toLowerCase();
+}
+/** Pluralizes the last word of a snake_case name, like Laravel's `Str::plural`. */
+function pluralizeSnake(snakeName) {
+    const parts = snakeName.split('_');
+    const last = parts[parts.length - 1] ?? '';
+    parts[parts.length - 1] = pluralizeWord(last);
+    return parts.join('_');
+}
+/** The table Eloquent assumes for a model without `$table`: `UserProfile` becomes `user_profiles`. */
+function conventionalTableName(className) {
+    return pluralizeSnake(eloquentSnake(className));
+}
+/** The name Laravel gives an index when the migration does not: `posts_title_index`. */
+function conventionalIndexName(table, columns, type) {
+    return `${table}_${columns.join('_')}_${type}`
+        .toLowerCase()
+        .replace(/[-.]/g, '_');
+}
+/** Flattens `$a->b()->c()` or `A::b()->c()` into its root and calls. */
+function readChain(expression) {
+    const links = [];
+    let current = expression;
+    for (;;) {
+        if (current.type === 'member_call_expression' ||
+            current.type === 'nullsafe_member_call_expression') {
+            const nameNode = current.childForFieldName('name');
+            const objectNode = current.childForFieldName('object');
+            if (nameNode === null || objectNode === null) {
+                return undefined;
+            }
+            links.unshift({
+                name: nameNode.text,
+                args: argumentNodes(current.childForFieldName('arguments')),
+                node: current,
+            });
+            current = objectNode;
+        }
+        else if (current.type === 'scoped_call_expression') {
+            const nameNode = current.childForFieldName('name');
+            const scopeNode = current.childForFieldName('scope');
+            if (nameNode === null || scopeNode === null) {
+                return undefined;
+            }
+            links.unshift({
+                name: nameNode.text,
+                args: argumentNodes(current.childForFieldName('arguments')),
+                node: current,
+            });
+            return { root: scopeNode, isStatic: true, links };
+        }
+        else if (current.type === 'parenthesized_expression') {
+            const inner = current.namedChildren[0];
+            if (inner === undefined) {
+                return undefined;
+            }
+            current = inner;
+        }
+        else {
+            return { root: current, isStatic: false, links };
+        }
+    }
+}
+function rootName(chain) {
+    return chain.root.text.replace(/\s+/g, '').replace(/^\\/, '');
+}
+function isFacade(chain, facade) {
+    const name = rootName(chain);
+    return (chain.isStatic &&
+        (name === facade || name === `Illuminate\\Support\\Facades\\${facade}`));
+}
+function evaluateArgument(node) {
+    if (node.type === 'scoped_call_expression') {
+        const chain = readChain(node);
+        const first = chain?.links[0];
+        if (chain !== undefined && first !== undefined) {
+            const scope = rootName(chain);
+            const lastScope = lastNameSegment(scope);
+            if (lastScope === 'DB' && first.name === 'raw') {
+                const sql = first.args[0]
+                    ? evaluateArgument(first.args[0].node)
+                    : undefined;
+                if (sql !== undefined && sql.kind === 'string') {
+                    return { kind: 'raw', sql: sql.value };
+                }
+                return { kind: 'other', text: node.text };
+            }
+            if ((lastScope === 'Carbon' || lastScope === 'CarbonImmutable') &&
+                first.name === 'now') {
+                return { kind: 'now' };
+            }
+        }
+    }
+    if (node.type === 'function_call_expression') {
+        const functionNode = node.childForFieldName('function');
+        if (functionNode !== null && functionNode.text === 'now') {
+            return { kind: 'now' };
+        }
+    }
+    if (node.type === 'object_creation_expression') {
+        const evaluated = evaluateNode(node);
+        if (evaluated.kind === 'new' &&
+            lastNameSegment(evaluated.className) === 'Expression') {
+            const sql = evaluated.args[0];
+            if (sql !== undefined && sql.kind === 'string') {
+                return { kind: 'raw', sql: sql.value };
+            }
+        }
+        return evaluated;
+    }
+    return evaluateNode(node);
+}
+function argumentAt(args, index, name) {
+    if (name !== undefined) {
+        const named = args.find((candidate) => candidate.name === name);
+        if (named !== undefined) {
+            return named;
+        }
+    }
+    return args.filter((candidate) => candidate.name === undefined)[index];
+}
+/** Reads a string argument. `undefined` means absent; `null` means present but not a literal string. */
+function stringArgument(args, index, name) {
+    const argument = argumentAt(args, index, name);
+    if (argument === undefined) {
+        return undefined;
+    }
+    const value = evaluateArgument(argument.node);
+    return value.kind === 'string' ? value.value : null;
+}
+/** Reads an integer argument (`undefined` when absent, `null` when not a literal number). */
+function numberArgument(args, index, name) {
+    const argument = argumentAt(args, index, name);
+    if (argument === undefined) {
+        return undefined;
+    }
+    const value = evaluateArgument(argument.node);
+    return value.kind === 'number' ? value.value : null;
+}
+/** Reads a boolean argument (`undefined` when absent, `null` when not a literal boolean). */
+function booleanArgument(args, index, name) {
+    const argument = argumentAt(args, index, name);
+    if (argument === undefined) {
+        return undefined;
+    }
+    const value = evaluateArgument(argument.node);
+    return value.kind === 'bool' ? value.value : null;
+}
+/** Reads a string or an array of strings. `null` when something in it is not a literal string. */
+function stringListArgument(argument) {
+    if (argument === undefined) {
+        return undefined;
+    }
+    const value = evaluateArgument(argument.node);
+    if (value.kind === 'string') {
+        return [value.value];
+    }
+    if (value.kind === 'array') {
+        const items = [];
+        for (const item of value.items) {
+            if (item.value.kind !== 'string') {
+                return null;
+            }
+            items.push(item.value.value);
+        }
+        return items;
+    }
+    return null;
+}
+/** All string arguments of a call: `dropColumn('a', 'b')` and `dropColumn(['a', 'b'])` both give `['a', 'b']`. */
+function allStringArguments(args) {
+    const names = [];
+    for (const argument of args) {
+        const list = stringListArgument(argument);
+        if (list === null || list === undefined) {
+            return null;
+        }
+        names.push(...list);
+    }
+    return names;
+}
+/** Fully qualified class name from `Foo::class` or a class-name string. */
+function classReference(value, ctx, ownerFqn) {
+    if (value.kind === 'classRef') {
+        const lowered = value.name.toLowerCase();
+        return lowered === 'self' || lowered === 'static'
+            ? ownerFqn
+            : resolveClassName(value.name, ctx);
+    }
+    if (value.kind === 'string' && /^\\?[A-Za-z_][\w\\]*$/.test(value.value)) {
+        return resolveClassName(value.value, ctx);
+    }
+    return undefined;
+}
+function shorten(text, length = 60) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > length ? `${flat.slice(0, length - 3)}...` : flat;
+}
+// ---------------------------------------------------------------------------
+// Migration replay
+// ---------------------------------------------------------------------------
+const NOW_SQL = /^(now\(\)|current_timestamp(\(\d*\))?|getdate\(\)|sysdate|systimestamp|localtimestamp(\(\d*\))?|datetime\('now'\)|\(datetime\('now'\)\))$/i;
+const UUID_SQL = /^(uuid_generate_v[14]\(\)|gen_random_uuid\(\)|uuid\(\)|newid\(\)|newsequentialid\(\)|sys_guid\(\))$/i;
+function newColumn(name, type, overrides = {}) {
+    return {
+        name,
+        type,
+        isNullable: false,
+        hasExplicitLength: false,
+        isAutoIncrement: false,
+        isAutoUpdated: false,
+        ...overrides,
+    };
+}
+function emptyTable(name, isPartial) {
+    return {
+        name,
+        columns: new Map(),
+        indexes: [],
+        foreignKeys: [],
+        primaryKey: undefined,
+        isPartial,
+    };
+}
+function actionFromText(text) {
+    return ON_DELETE_ACTIONS[text.trim().toLowerCase()];
+}
+function addIndex(table, definition) {
+    const existing = table.indexes.find((candidate) => sameList(candidate.columns, definition.columns) &&
+        candidate.isUnique === definition.isUnique &&
+        candidate.kind === definition.kind);
+    if (existing === undefined) {
+        table.indexes.push(definition);
+    }
+    else if (definition.name !== undefined) {
+        existing.name = definition.name;
+    }
+}
+function addForeignKey(table, definition) {
+    const position = table.foreignKeys.findIndex((candidate) => sameList(candidate.columns, definition.columns));
+    if (position >= 0) {
+        table.foreignKeys.splice(position, 1, definition);
+    }
+    else {
+        table.foreignKeys.push(definition);
+    }
+}
+function removeColumn(table, columnName) {
+    table.columns.delete(columnName);
+    table.indexes = table.indexes
+        .map((index) => ({
+        ...index,
+        columns: index.columns.filter((name) => name !== columnName),
+    }))
+        .filter((index) => index.columns.length > 0);
+    table.foreignKeys = table.foreignKeys.filter((key) => !key.columns.includes(columnName));
+    if (table.primaryKey?.includes(columnName) === true) {
+        const remaining = table.primaryKey.filter((name) => name !== columnName);
+        table.primaryKey = remaining.length > 0 ? remaining : undefined;
+    }
+}
+function renameColumn(table, from, to) {
+    const rebuilt = new Map();
+    for (const [name, column] of table.columns) {
+        if (name === from) {
+            rebuilt.set(to, { ...column, name: to });
+        }
+        else {
+            rebuilt.set(name, column);
+        }
+    }
+    table.columns = rebuilt;
+    const rename = (names) => names.map((name) => (name === from ? to : name));
+    for (const index of table.indexes) {
+        index.columns = rename(index.columns);
+    }
+    for (const key of table.foreignKeys) {
+        key.columns = rename(key.columns);
+    }
+    if (table.primaryKey !== undefined) {
+        table.primaryKey = rename(table.primaryKey);
+    }
+}
+/** Converts the argument of `default()` for a column; undefined means no default (or one that could not be read). */
+function convertDefault(value, column, table, warnings) {
+    switch (value.kind) {
+        case 'null':
+            return undefined;
+        case 'bool':
+            return { kind: 'literal', value: value.value };
+        case 'number':
+            return column.type === 'string' || column.type === 'text'
+                ? { kind: 'literal', value: String(value.value) }
+                : { kind: 'literal', value: value.value };
+        case 'now':
+            return { kind: 'now' };
+        case 'string':
+            return convertTextDefault(value.value, column);
+        case 'raw': {
+            let sql = value.sql.trim();
+            while (sql.startsWith('(') && sql.endsWith(')')) {
+                sql = sql.slice(1, -1).trim();
+            }
+            if (NOW_SQL.test(sql)) {
+                return { kind: 'now' };
+            }
+            if (UUID_SQL.test(sql)) {
+                return { kind: 'uuid' };
+            }
+            if (/^-?\d+(\.\d+)?$/.test(sql)) {
+                return { kind: 'literal', value: Number(sql) };
+            }
+            if (/^(true|false)$/i.test(sql)) {
+                return { kind: 'literal', value: sql.toLowerCase() === 'true' };
+            }
+            const quoted = /^'((?:[^']|'')*)'$/.exec(sql);
+            if (quoted !== null) {
+                return convertTextDefault((quoted[1] ?? '').replace(/''/g, "'"), column);
+            }
+            return { kind: 'dbExpression', expression: sql };
+        }
+        default:
+            warnings.push(`${table}.${column.name}: the default value (${shorten(describeValue(value))}) cannot be evaluated statically and was ignored.`);
+            return undefined;
+    }
+}
+function describeValue(value) {
+    switch (value.kind) {
+        case 'other':
+            return value.text;
+        case 'array':
+            return 'an array';
+        case 'classRef':
+            return `${value.name}::class`;
+        case 'constant':
+            return `${value.owner}::${value.name}`;
+        default:
+            return value.kind;
+    }
+}
+function convertTextDefault(text, column) {
+    const trimmed = text.trim();
+    switch (column.type) {
+        case 'dateTime':
+        case 'date':
+        case 'time':
+            if (NOW_SQL.test(trimmed) || /^current_(date|time)$/i.test(trimmed)) {
+                return { kind: 'now' };
+            }
+            break;
+        case 'uuid':
+        case 'string':
+            if (UUID_SQL.test(trimmed)) {
+                return { kind: 'uuid' };
+            }
+            break;
+        case 'boolean':
+            if (/^(1|true)$/i.test(trimmed)) {
+                return { kind: 'literal', value: true };
+            }
+            if (/^(0|false)$/i.test(trimmed)) {
+                return { kind: 'literal', value: false };
+            }
+            break;
+        case 'int':
+        case 'bigInt':
+        case 'float':
+        case 'decimal':
+            if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+                return { kind: 'literal', value: Number(trimmed) };
+            }
+            break;
+        default:
+            break;
+    }
+    return { kind: 'literal', value: text };
+}
+const INTEGER_METHODS = {
+    integer: 'int',
+    tinyInteger: 'int',
+    smallInteger: 'int',
+    mediumInteger: 'int',
+    bigInteger: 'bigInt',
+    unsignedInteger: 'int',
+    unsignedTinyInteger: 'int',
+    unsignedSmallInteger: 'int',
+    unsignedMediumInteger: 'int',
+    unsignedBigInteger: 'bigInt',
+};
+const INCREMENT_METHODS = {
+    increments: 'int',
+    integerIncrements: 'int',
+    tinyIncrements: 'int',
+    smallIncrements: 'int',
+    mediumIncrements: 'int',
+    bigIncrements: 'bigInt',
+};
+const TEXT_METHODS = new Set([
+    'text',
+    'tinyText',
+    'mediumText',
+    'longText',
+]);
+const DATE_METHODS = {
+    date: 'date',
+    dateTime: 'dateTime',
+    dateTimeTz: 'dateTime',
+    timestamp: 'dateTime',
+    timestampTz: 'dateTime',
+    time: 'time',
+    timeTz: 'time',
+};
+/** Methods that create a pair of `created_at` / `updated_at` columns. */
+const TIMESTAMP_PAIR_METHODS = new Set([
+    'timestamps',
+    'timestampsTz',
+    'nullableTimestamps',
+    'datetimes',
+    'datetimesTz',
+]);
+const SOFT_DELETE_METHODS = new Set([
+    'softDeletes',
+    'softDeletesTz',
+    'softDeletesDatetime',
+]);
+/** `morphs`-style methods: [type of the id column, nullable]. */
+const MORPH_METHODS = {
+    morphs: { id: 'int', nullable: false },
+    nullableMorphs: { id: 'int', nullable: true },
+    uuidMorphs: { id: 'uuid', nullable: false },
+    nullableUuidMorphs: { id: 'uuid', nullable: true },
+    ulidMorphs: { id: 'ulid', nullable: false },
+    nullableUlidMorphs: { id: 'ulid', nullable: true },
+};
+/** Looks at the first call of a Blueprint statement and creates the columns or runs the table command. */
+function startCall(table, first, mctx) {
+    const warnings = mctx.state.warnings;
+    const method = first.name;
+    const args = first.args;
+    const skip = (what) => {
+        pushWarning(warnings, `${table.name}: ${method}() ${what}; the call was skipped.`);
+        return undefined;
+    };
+    /** The column name argument, or the fallback; null when it is not a literal. */
+    const columnName = (fallback) => {
+        const given = stringArgument(args, 0, 'column');
+        if (given === undefined) {
+            return fallback ?? null;
+        }
+        return given;
+    };
+    const single = (type, fallback, overrides = {}) => {
+        const name = columnName(fallback);
+        if (name === null) {
+            return skip('has a column name that is not a string literal');
+        }
+        return {
+            columns: [newColumn(name, type, overrides)],
+            change: false,
+        };
+    };
+    const primaryTarget = (type, fallback) => {
+        const target = single(type, fallback, {
+            isAutoIncrement: true,
+            default: { kind: 'autoIncrement' },
+        });
+        const created = target?.columns[0];
+        if (created !== undefined) {
+            table.primaryKey = [created.name];
+        }
+        return target;
+    };
+    // Columns --------------------------------------------------------------
+    if (method === 'id') {
+        return primaryTarget('bigInt', 'id');
+    }
+    const incrementType = INCREMENT_METHODS[method];
+    if (incrementType !== undefined) {
+        return primaryTarget(incrementType, undefined);
+    }
+    const integerType = INTEGER_METHODS[method];
+    if (integerType !== undefined) {
+        const autoIncrement = booleanArgument(args, 1, 'autoIncrement') === true;
+        return autoIncrement
+            ? primaryTarget(integerType, undefined)
+            : single(integerType, undefined);
+    }
+    if (method === 'string' || method === 'char') {
+        const length = numberArgument(args, 1, 'length');
+        if (length === null) {
+            pushWarning(warnings, `${table.name}: the length of ${method}() is not a number literal; the default length 255 was used.`);
+        }
+        return single('string', undefined, {
+            maxLength: typeof length === 'number' ? length : 255,
+            hasExplicitLength: typeof length === 'number',
+        });
+    }
+    if (TEXT_METHODS.has(method)) {
+        return single('text', undefined);
+    }
+    if (method === 'boolean') {
+        return single('boolean', undefined);
+    }
+    if (method === 'decimal' || method === 'unsignedDecimal') {
+        const total = numberArgument(args, 1, 'total');
+        const places = numberArgument(args, 2, 'places');
+        return single('decimal', undefined, {
+            maxDigits: typeof total === 'number' ? total : 8,
+            decimalPlaces: typeof places === 'number' ? places : 2,
+        });
+    }
+    if (method === 'float' || method === 'double') {
+        return single('float', undefined);
+    }
+    const dateType = DATE_METHODS[method];
+    if (dateType !== undefined) {
+        return single(dateType, undefined);
+    }
+    if (method === 'year') {
+        return single('int', undefined);
+    }
+    if (TIMESTAMP_PAIR_METHODS.has(method)) {
+        return {
+            columns: [
+                newColumn('created_at', 'dateTime', { isNullable: true }),
+                newColumn('updated_at', 'dateTime', { isNullable: true }),
+            ],
+            change: false,
+        };
+    }
+    if (SOFT_DELETE_METHODS.has(method)) {
+        return single('dateTime', 'deleted_at', { isNullable: true });
+    }
+    if (method === 'rememberToken') {
+        return {
+            columns: [
+                newColumn('remember_token', 'string', {
+                    isNullable: true,
+                    maxLength: 100,
+                    hasExplicitLength: true,
+                }),
+            ],
+            change: false,
+        };
+    }
+    if (method === 'uuid') {
+        return single('uuid', 'uuid');
+    }
+    if (method === 'ulid') {
+        const length = numberArgument(args, 1, 'length');
+        return single('string', 'ulid', {
+            maxLength: typeof length === 'number' ? length : 26,
+            hasExplicitLength: true,
+        });
+    }
+    if (method === 'json' || method === 'jsonb') {
+        return single('json', undefined);
+    }
+    if (method === 'binary') {
+        return single('bytes', undefined);
+    }
+    if (method === 'ipAddress') {
+        return single('ipAddress', 'ip_address');
+    }
+    if (method === 'macAddress') {
+        const target = single('string', 'mac_address', {
+            maxLength: 17,
+            hasExplicitLength: true,
+        });
+        if (target !== undefined) {
+            pushWarning(warnings, `${table.name}.${target.columns[0]?.name ?? 'mac_address'}: macAddress() has no equivalent and was converted to a string column of length 17.`);
+        }
+        return target;
+    }
+    if (method === 'enum' || method === 'set') {
+        const values = stringListArgument(argumentAt(args, 1, 'allowed'));
+        const name = columnName(undefined);
+        if (name === null) {
+            return skip('has a column name that is not a string literal');
+        }
+        if (values === null || values === undefined) {
+            return skip('has allowed values that are not string literals');
+        }
+        if (method === 'set') {
+            pushWarning(warnings, `${table.name}.${name}: set() columns have no equivalent and were kept as unsupported columns.`);
+            return {
+                columns: [
+                    newColumn(name, 'unsupported', {
+                        unsupportedType: `set(${values.map((value) => `'${value}'`).join(',')})`,
+                    }),
+                ],
+                change: false,
+            };
+        }
+        return {
+            columns: [newColumn(name, 'string', { enumValues: values })],
+            change: false,
+        };
+    }
+    if (GEOMETRY_TYPES.has(method) || method === 'vector') {
+        const target = single('unsupported', undefined, {
+            unsupportedType: method.toLowerCase(),
+        });
+        if (target !== undefined) {
+            pushWarning(warnings, `${table.name}.${target.columns[0]?.name ?? method}: the ${method}() column type has no equivalent and was kept as an unsupported column.`);
+        }
+        return target;
+    }
+    if (method === 'foreignId' ||
+        method === 'foreignUuid' ||
+        method === 'foreignUlid') {
+        const type = method === 'foreignId'
+            ? 'bigInt'
+            : method === 'foreignUuid'
+                ? 'uuid'
+                : 'string';
+        const target = single(type, undefined, method === 'foreignUlid' ? { maxLength: 26, hasExplicitLength: true } : {});
+        if (target !== undefined) {
+            target.foreignIdColumn = target.columns[0];
+        }
+        return target;
+    }
+    if (method === 'foreignIdFor') {
+        const model = args[0]
+            ? evaluateArgument(args[0].node)
+            : undefined;
+        const modelName = model !== undefined && model.kind === 'classRef'
+            ? model.name
+            : model !== undefined && model.kind === 'string'
+                ? model.value
+                : undefined;
+        if (modelName === undefined) {
+            return skip('was not given a model class');
+        }
+        const explicit = stringArgument(args, 1, 'column');
+        const name = explicit ?? `${eloquentSnake(lastNameSegment(modelName))}_id`;
+        const column = newColumn(name, 'bigInt');
+        return {
+            columns: [column],
+            foreignIdColumn: column,
+            foreignIdModel: modelName,
+            change: false,
+        };
+    }
+    const morph = MORPH_METHODS[method];
+    if (morph !== undefined) {
+        const name = columnName(undefined);
+        if (name === null) {
+            return skip('has a name that is not a string literal');
+        }
+        const typeColumn = newColumn(`${name}_type`, 'string', {
+            maxLength: 255,
+            hasExplicitLength: true,
+            isNullable: morph.nullable,
+        });
+        const idColumn = morph.id === 'int'
+            ? newColumn(`${name}_id`, 'bigInt', { isNullable: morph.nullable })
+            : morph.id === 'uuid'
+                ? newColumn(`${name}_id`, 'uuid', { isNullable: morph.nullable })
+                : newColumn(`${name}_id`, 'string', {
+                    maxLength: 26,
+                    hasExplicitLength: true,
+                    isNullable: morph.nullable,
+                });
+        const indexName = stringArgument(args, 1, 'indexName');
+        addIndex(table, {
+            columns: [typeColumn.name, idColumn.name],
+            isUnique: false,
+            ...(typeof indexName === 'string' ? { name: indexName } : {}),
+        });
+        pushWarning(warnings, `${table.name}: ${method}('${name}') creates the columns ${typeColumn.name} and ${idColumn.name}; polymorphic relations are not represented, so they were kept as plain columns.`);
+        return { columns: [typeColumn, idColumn], change: false };
+    }
+    // Indexes and keys -------------------------------------------------------
+    if (method === 'index' ||
+        method === 'unique' ||
+        method === 'primary' ||
+        method === 'fullText' ||
+        method === 'spatialIndex') {
+        const columns = stringListArgument(argumentAt(args, 0, 'columns'));
+        if (columns === null || columns === undefined) {
+            return skip('has columns that are not string literals');
+        }
+        if (method === 'spatialIndex') {
+            pushWarning(warnings, `${table.name}: the spatial index on (${columns.join(', ')}) has no equivalent and was ignored.`);
+            return undefined;
+        }
+        if (method === 'primary') {
+            table.primaryKey = columns;
+            return undefined;
+        }
+        const name = stringArgument(args, 1, 'name');
+        addIndex(table, {
+            columns,
+            isUnique: method === 'unique',
+            ...(method === 'fullText' ? { kind: 'fulltext' } : {}),
+            ...(typeof name === 'string' ? { name } : {}),
+        });
+        return undefined;
+    }
+    if (method === 'foreign') {
+        const columns = stringListArgument(argumentAt(args, 0, 'columns'));
+        if (columns === null || columns === undefined) {
+            return skip('has columns that are not string literals');
+        }
+        const name = stringArgument(args, 1, 'name');
+        const foreignKey = {
+            columns,
+            refColumns: [],
+            ...(typeof name === 'string' ? { name } : {}),
+        };
+        addForeignKey(table, foreignKey);
+        return { columns: [], foreignKey, change: false };
+    }
+    // Changes to existing columns and keys ----------------------------------
+    return runDropOrRename(table, first, mctx);
+}
+/** `dropColumn`, `renameColumn`, `dropIndex` and friends. */
+function runDropOrRename(table, first, mctx) {
+    const warnings = mctx.state.warnings;
+    const method = first.name;
+    const args = first.args;
+    const missing = (what) => {
+        pushWarning(warnings, `${table.name}: ${method}() ${what}; the call was skipped.`);
+    };
+    switch (method) {
+        case 'dropColumn':
+        case 'dropColumns': {
+            const names = allStringArguments(args);
+            if (names === null) {
+                missing('has column names that are not string literals');
+                return undefined;
+            }
+            for (const name of names) {
+                removeColumn(table, name);
+            }
+            return undefined;
+        }
+        case 'renameColumn': {
+            const from = stringArgument(args, 0, 'from');
+            const to = stringArgument(args, 1, 'to');
+            if (typeof from !== 'string' || typeof to !== 'string') {
+                missing('has names that are not string literals');
+            }
+            else if (!table.columns.has(from)) {
+                if (!table.isPartial) {
+                    pushWarning(warnings, `${table.name}.${from}: renameColumn() refers to a column that does not exist at this point; the call was skipped.`);
+                }
+            }
+            else {
+                renameColumn(table, from, to);
+            }
+            return undefined;
+        }
+        case 'dropTimestamps':
+        case 'dropTimestampsTz':
+            removeColumn(table, 'created_at');
+            removeColumn(table, 'updated_at');
+            return undefined;
+        case 'dropSoftDeletes':
+        case 'dropSoftDeletesTz': {
+            const name = stringArgument(args, 0, 'column');
+            removeColumn(table, typeof name === 'string' ? name : 'deleted_at');
+            return undefined;
+        }
+        case 'dropRememberToken':
+            removeColumn(table, 'remember_token');
+            return undefined;
+        case 'dropMorphs': {
+            const name = stringArgument(args, 0, 'name');
+            if (typeof name !== 'string') {
+                missing('has a name that is not a string literal');
+            }
+            else {
+                removeColumn(table, `${name}_type`);
+                removeColumn(table, `${name}_id`);
+            }
+            return undefined;
+        }
+        case 'dropConstrainedForeignId':
+        case 'dropForeignIdFor':
+        case 'dropConstrainedForeignIdFor': {
+            const nameArg = args[0]
+                ? evaluateArgument(args[0].node)
+                : undefined;
+            const column = nameArg === undefined
+                ? undefined
+                : nameArg.kind === 'string' && method === 'dropConstrainedForeignId'
+                    ? nameArg.value
+                    : nameArg.kind === 'classRef'
+                        ? `${eloquentSnake(lastNameSegment(nameArg.name))}_id`
+                        : undefined;
+            if (column === undefined) {
+                missing('was not given a column or model it can resolve');
+            }
+            else {
+                removeColumn(table, column);
+            }
+            return undefined;
+        }
+        case 'dropPrimary':
+            table.primaryKey = undefined;
+            return undefined;
+        case 'dropIndex':
+        case 'dropUnique':
+        case 'dropFullText':
+        case 'dropSpatialIndex': {
+            const target = stringListArgument(args[0]);
+            if (target === null || target === undefined) {
+                missing('has an index name or columns that are not string literals');
+                return undefined;
+            }
+            const type = method === 'dropUnique'
+                ? 'unique'
+                : method === 'dropFullText'
+                    ? 'fulltext'
+                    : 'index';
+            const isColumnList = args[0] !== undefined &&
+                evaluateArgument(args[0].node).kind === 'array';
+            const wanted = isColumnList
+                ? conventionalIndexName(table.name, target, type)
+                : (target[0] ?? '');
+            const before = table.indexes.length;
+            table.indexes = table.indexes.filter((index) => {
+                const indexType = index.kind === 'fulltext'
+                    ? 'fulltext'
+                    : index.isUnique
+                        ? 'unique'
+                        : 'index';
+                const name = index.name ??
+                    conventionalIndexName(table.name, index.columns, indexType);
+                return name !== wanted;
+            });
+            if (table.indexes.length === before && !table.isPartial) {
+                pushWarning(warnings, `${table.name}: ${method}() could not find the index "${wanted}"; the call was skipped.`);
+            }
+            return undefined;
+        }
+        case 'dropForeign': {
+            const target = stringListArgument(args[0]);
+            if (target === null || target === undefined) {
+                missing('has a constraint name or columns that are not string literals');
+                return undefined;
+            }
+            const isColumnList = args[0] !== undefined &&
+                evaluateArgument(args[0].node).kind === 'array';
+            const before = table.foreignKeys.length;
+            table.foreignKeys = table.foreignKeys.filter((key) => isColumnList
+                ? !sameList(key.columns, target)
+                : (key.name ??
+                    conventionalIndexName(table.name, key.columns, 'foreign')) !==
+                    target[0]);
+            if (table.foreignKeys.length === before && !table.isPartial) {
+                pushWarning(warnings, `${table.name}: dropForeign() could not find the foreign key ${target.join(', ')}; the call was skipped.`);
+            }
+            return undefined;
+        }
+        case 'renameIndex': {
+            const from = stringArgument(args, 0, 'from');
+            const to = stringArgument(args, 1, 'to');
+            if (typeof from !== 'string' || typeof to !== 'string') {
+                missing('has names that are not string literals');
+                return undefined;
+            }
+            const index = table.indexes.find((candidate) => (candidate.name ??
+                conventionalIndexName(table.name, candidate.columns, candidate.kind === 'fulltext'
+                    ? 'fulltext'
+                    : candidate.isUnique
+                        ? 'unique'
+                        : 'index')) === from);
+            if (index !== undefined) {
+                index.name = to;
+            }
+            return undefined;
+        }
+        default:
+            if (IGNORED_TABLE_METHODS.has(method)) {
+                return undefined;
+            }
+            pushWarning(warnings, `${table.name}: the Blueprint call ${method}() is not understood and was ignored.`);
+            return undefined;
+    }
+}
+/** Applies the calls chained after a column definition (`->nullable()->default(0)->unique()`). */
+function applyModifiers(table, target, links, mctx) {
+    const warnings = mctx.state.warnings;
+    for (const link of links) {
+        const name = link.name;
+        const label = target.columns.length === 1 && target.columns[0] !== undefined
+            ? `${table.name}.${target.columns[0].name}`
+            : table.name;
+        const setAction = (field, action) => {
+            if (target.foreignKey === undefined) {
+                pushWarning(warnings, `${label}: ${name}() was used without a foreign key definition and was ignored.`);
+            }
+            else {
+                target.foreignKey[field] = action;
+            }
+        };
+        switch (name) {
+            case 'nullable': {
+                const flag = booleanArgument(link.args, 0, 'value');
+                for (const column of target.columns) {
+                    column.isNullable = flag !== false;
+                }
+                break;
+            }
+            case 'default': {
+                const argument = argumentAt(link.args, 0, 'value');
+                for (const column of target.columns) {
+                    if (argument === undefined) {
+                        continue;
+                    }
+                    const converted = convertDefault(evaluateArgument(argument.node), column, table.name, warnings);
+                    if (converted === undefined) {
+                        delete column.default;
+                    }
+                    else {
+                        column.default = converted;
+                    }
+                }
+                break;
+            }
+            case 'useCurrent':
+                for (const column of target.columns) {
+                    column.default = { kind: 'now' };
+                }
+                break;
+            case 'useCurrentOnUpdate':
+                for (const column of target.columns) {
+                    column.isAutoUpdated = true;
+                }
+                break;
+            case 'autoIncrement':
+                for (const column of target.columns) {
+                    column.isAutoIncrement = true;
+                    column.default = { kind: 'autoIncrement' };
+                }
+                break;
+            case 'unique':
+            case 'index':
+            case 'fullText':
+            case 'primary':
+            case 'spatialIndex': {
+                const indexName = stringArgument(link.args, 0, 'indexName');
+                for (const column of target.columns) {
+                    if (name === 'primary') {
+                        table.primaryKey = [column.name];
+                    }
+                    else if (name === 'spatialIndex') {
+                        pushWarning(warnings, `${table.name}.${column.name}: the spatial index has no equivalent and was ignored.`);
+                    }
+                    else {
+                        addIndex(table, {
+                            columns: [column.name],
+                            isUnique: name === 'unique',
+                            ...(name === 'fullText' ? { kind: 'fulltext' } : {}),
+                            ...(typeof indexName === 'string' ? { name: indexName } : {}),
+                        });
+                    }
+                }
+                break;
+            }
+            case 'storedAs':
+            case 'virtualAs': {
+                const expression = link.args[0]
+                    ? evaluateArgument(link.args[0].node)
+                    : undefined;
+                const text = expression === undefined
+                    ? undefined
+                    : expression.kind === 'string'
+                        ? expression.value
+                        : expression.kind === 'raw'
+                            ? expression.sql
+                            : undefined;
+                for (const column of target.columns) {
+                    if (text === undefined) {
+                        pushWarning(warnings, `${table.name}.${column.name}: the expression of ${name}() is not a string literal and was ignored.`);
+                    }
+                    else {
+                        column.generated = {
+                            expression: text,
+                            isStored: name === 'storedAs',
+                        };
+                    }
+                }
+                break;
+            }
+            case 'generatedAs':
+            case 'always':
+                pushWarning(warnings, `${label}: identity columns (${name}()) have no equivalent and were ignored.`);
+                break;
+            case 'change':
+                target.change = true;
+                break;
+            case 'constrained': {
+                const column = target.foreignIdColumn;
+                if (column === undefined) {
+                    pushWarning(warnings, `${label}: constrained() can only follow foreignId(), foreignUuid(), foreignUlid() or foreignIdFor(); it was ignored.`);
+                    break;
+                }
+                const tableArgument = stringArgument(link.args, 0, 'table');
+                const columnArgument = stringArgument(link.args, 1, 'column');
+                const indexName = stringArgument(link.args, 2, 'indexName');
+                const foreignKey = {
+                    columns: [column.name],
+                    refColumns: [
+                        typeof columnArgument === 'string' ? columnArgument : 'id',
+                    ],
+                    ...(typeof tableArgument === 'string'
+                        ? { refTable: tableArgument }
+                        : target.foreignIdModel !== undefined
+                            ? { refModel: target.foreignIdModel }
+                            : { refTable: pluralizeSnake(column.name.replace(/_id$/, '')) }),
+                    ...(typeof indexName === 'string' ? { name: indexName } : {}),
+                };
+                target.foreignKey = foreignKey;
+                addForeignKey(table, foreignKey);
+                break;
+            }
+            case 'references': {
+                const columns = stringListArgument(argumentAt(link.args, 0, 'columns'));
+                const own = target.columns.map((column) => column.name);
+                if (target.foreignKey === undefined) {
+                    if (own.length === 0) {
+                        pushWarning(warnings, `${label}: references() was used without a foreign key definition and was ignored.`);
+                        break;
+                    }
+                    target.foreignKey = { columns: own, refColumns: [] };
+                    addForeignKey(table, target.foreignKey);
+                }
+                if (columns === null || columns === undefined) {
+                    pushWarning(warnings, `${label}: references() was given columns that are not string literals; 'id' was assumed.`);
+                    target.foreignKey.refColumns = ['id'];
+                }
+                else {
+                    target.foreignKey.refColumns = columns;
+                }
+                break;
+            }
+            case 'on': {
+                const referenced = stringArgument(link.args, 0, 'table');
+                if (target.foreignKey === undefined || typeof referenced !== 'string') {
+                    pushWarning(warnings, `${label}: on() ${target.foreignKey === undefined ? 'was used without a foreign key definition' : 'was given a table that is not a string literal'} and was ignored.`);
+                }
+                else {
+                    target.foreignKey.refTable = referenced;
+                }
+                break;
+            }
+            case 'onDelete':
+            case 'onUpdate': {
+                const text = stringArgument(link.args, 0, 'action');
+                const action = typeof text === 'string' ? actionFromText(text) : undefined;
+                if (action === undefined) {
+                    pushWarning(warnings, `${label}: ${name}(${text === undefined || text === null ? '...' : `'${text}'`}) is not a supported referential action and was ignored.`);
+                }
+                else {
+                    setAction(name, action);
+                }
+                break;
+            }
+            case 'cascadeOnDelete':
+                setAction('onDelete', 'cascade');
+                break;
+            case 'restrictOnDelete':
+                setAction('onDelete', 'restrict');
+                break;
+            case 'nullOnDelete':
+                setAction('onDelete', 'setNull');
+                break;
+            case 'noActionOnDelete':
+                setAction('onDelete', 'noAction');
+                break;
+            case 'cascadeOnUpdate':
+                setAction('onUpdate', 'cascade');
+                break;
+            case 'restrictOnUpdate':
+                setAction('onUpdate', 'restrict');
+                break;
+            case 'nullOnUpdate':
+                setAction('onUpdate', 'setNull');
+                break;
+            case 'noActionOnUpdate':
+                setAction('onUpdate', 'noAction');
+                break;
+            default:
+                if (!IGNORED_COLUMN_MODIFIERS.has(name)) {
+                    pushWarning(warnings, `${label}: the column modifier ${name}() is not understood and was ignored.`);
+                }
+                break;
+        }
+    }
+}
+function commitColumns(table, target, mctx) {
+    for (const column of target.columns) {
+        const existing = table.columns.get(column.name);
+        if (target.change) {
+            if (existing === undefined && !table.isPartial) {
+                pushWarning(mctx.state.warnings, `${table.name}.${column.name}: change() modifies a column that does not exist at this point; it was added instead.`);
+            }
+        }
+        else if (existing !== undefined && !table.isPartial) {
+            pushWarning(mctx.state.warnings, `${table.name}.${column.name}: the column is defined more than once; the later definition replaced the earlier one.`);
+        }
+        table.columns.set(column.name, column);
+    }
+}
+function runTableCall(table, links, mctx) {
+    const first = links[0];
+    if (first === undefined) {
+        return;
+    }
+    mctx.touched.push(table.name);
+    const target = startCall(table, first, mctx);
+    if (target === undefined) {
+        return;
+    }
+    applyModifiers(table, target, links.slice(1), mctx);
+    commitColumns(table, target, mctx);
+}
+// -- Statement walking --------------------------------------------------------
+function nestedStatements(node) {
+    const found = [];
+    for (const child of node.namedChildren) {
+        if (CLAUSE_STATEMENTS.has(child.type)) {
+            found.push(...nestedStatements(child));
+        }
+        else if (child.type === 'compound_statement' ||
+            child.type.endsWith('_statement')) {
+            found.push(child);
+        }
+    }
+    return found;
+}
+function controlLabel(node) {
+    switch (node.type) {
+        case 'if_statement':
+            return 'a conditional';
+        case 'switch_statement':
+            return 'a switch';
+        case 'try_statement':
+            return 'a try block';
+        default:
+            return 'a loop';
+    }
+}
+function forEachStatement(nodes, handle, onControl) {
+    for (const node of nodes) {
+        if (node.type === 'comment') {
+            continue;
+        }
+        if (node.type === 'compound_statement') {
+            forEachStatement(node.namedChildren, handle, onControl);
+        }
+        else if (CONTROL_STATEMENTS.has(node.type)) {
+            onControl(node, () => forEachStatement(nestedStatements(node), handle, onControl));
+        }
+        else {
+            handle(node);
+        }
+    }
+}
+/** The expression of an expression statement (or the node itself for an arrow function body). */
+function statementExpression(statement) {
+    if (statement.type === 'expression_statement') {
+        return statement.namedChildren.find((child) => child.type !== 'comment');
+    }
+    return statement.type.endsWith('_expression') ? statement : undefined;
+}
+function warnRawSql(chain, mctx, statementText) {
+    const first = chain.links[0];
+    if (first === undefined || !RAW_SQL_METHODS.has(first.name)) {
+        return;
+    }
+    const sqlArgument = first.args[0]
+        ? evaluateArgument(first.args[0].node)
+        : undefined;
+    const sql = sqlArgument !== undefined && sqlArgument.kind === 'string'
+        ? sqlArgument.value
+        : undefined;
+    const tableMatch = sql === undefined
+        ? null
+        : /\b(?:alter\s+table|create\s+table(?:\s+if\s+not\s+exists)?|drop\s+table(?:\s+if\s+exists)?|truncate(?:\s+table)?|rename\s+table|create\s+(?:unique\s+)?index\s+\S+\s+on|drop\s+index\s+\S+\s+on|comment\s+on\s+(?:table|column))\s+[`"']?([A-Za-z0-9_.]+)/i.exec(sql);
+    const tableName = tableMatch?.[1];
+    pushWarning(mctx.state.warnings, `${mctx.file}: the raw SQL statement "${shorten(sql ?? statementText)}"${tableName === undefined ? '' : ` on the table "${tableName}"`} is not interpreted; the rebuilt schema may differ from the real database.`);
+    if (tableName !== undefined) {
+        mctx.touched.push(tableName);
+    }
+}
+function runBlueprint(argument, table, mctx) {
+    if (argument === undefined) {
+        pushWarning(mctx.state.warnings, `${table.name}: no Blueprint callback was found; the table has no columns.`);
+        return;
+    }
+    const closure = argument.node;
+    if (closure.type !== 'anonymous_function_creation_expression' &&
+        closure.type !== 'anonymous_function' &&
+        closure.type !== 'arrow_function') {
+        pushWarning(mctx.state.warnings, `${table.name}: the Blueprint callback is not an inline closure, so its columns could not be read.`);
+        return;
+    }
+    const parameter = closure
+        .childForFieldName('parameters')
+        ?.namedChildren.find((child) => child.type === 'simple_parameter');
+    const variable = parameter?.childForFieldName('name')?.text ?? '$table';
+    const body = closure.childForFieldName('body');
+    if (body === null) {
+        return;
+    }
+    const statements = body.type === 'compound_statement' ? body.namedChildren : [body];
+    forEachStatement(statements, (statement) => {
+        const expression = statementExpression(statement);
+        if (expression === undefined) {
+            return;
+        }
+        const chain = readChain(expression);
+        if (chain === undefined) {
+            return;
+        }
+        if (!chain.isStatic && chain.root.text === variable) {
+            runTableCall(table, chain.links, mctx);
+        }
+        else if (isFacade(chain, 'DB')) {
+            warnRawSql(chain, mctx, statement.text);
+        }
+    }, (statement, descend) => describeControlFlow(statement, descend, mctx));
+}
+function describeControlFlow(statement, descend, mctx) {
+    const before = mctx.touched.length;
+    descend();
+    const tables = unique(mctx.touched.slice(before));
+    pushWarning(mctx.state.warnings, `${mctx.file}: ${controlLabel(statement)} contains schema changes; it was applied as if it always ran` +
+        (tables.length > 0
+            ? ` (tables: ${tables.join(', ')}), so the result may differ from the real database.`
+            : ', so the result may differ from the real database.'));
+}
+function runSchemaCall(chain, mctx) {
+    const state = mctx.state;
+    const links = chain.links[0]?.name === 'connection' ? chain.links.slice(1) : chain.links;
+    const call = links[0];
+    if (call === undefined) {
+        return;
+    }
+    const method = call.name;
+    const tableNameOf = () => {
+        const name = stringArgument(call.args, 0, 'table');
+        if (typeof name !== 'string') {
+            pushWarning(state.warnings, `${mctx.file}: Schema::${method}() was given a table name that is not a string literal; the call was skipped.`);
+            return undefined;
+        }
+        return name;
+    };
+    switch (method) {
+        case 'create':
+        case 'table': {
+            const name = tableNameOf();
+            if (name === undefined) {
+                return;
+            }
+            let table = state.tables.get(name);
+            if (method === 'create') {
+                if (table !== undefined && !table.isPartial) {
+                    pushWarning(state.warnings, `${name}: Schema::create() ran for a table that already exists (in ${mctx.file}); the earlier definition was replaced.`);
+                }
+                state.tables.delete(name);
+                table = emptyTable(name, false);
+                state.tables.set(name, table);
+            }
+            else if (table === undefined) {
+                table = emptyTable(name, true);
+                state.tables.set(name, table);
+            }
+            mctx.touched.push(name);
+            runBlueprint(argumentAt(call.args, 1, 'callback'), table, mctx);
+            return;
+        }
+        case 'drop':
+        case 'dropIfExists': {
+            const name = tableNameOf();
+            if (name !== undefined) {
+                mctx.touched.push(name);
+                state.tables.delete(name);
+            }
+            return;
+        }
+        case 'rename': {
+            const from = stringArgument(call.args, 0, 'from');
+            const to = stringArgument(call.args, 1, 'to');
+            if (typeof from !== 'string' || typeof to !== 'string') {
+                pushWarning(state.warnings, `${mctx.file}: Schema::rename() was given table names that are not string literals; the call was skipped.`);
+                return;
+            }
+            const table = state.tables.get(from);
+            mctx.touched.push(from, to);
+            if (table === undefined) {
+                return;
+            }
+            const rebuilt = new Map();
+            for (const [name, existing] of state.tables) {
+                if (name === from) {
+                    rebuilt.set(to, { ...existing, name: to });
+                }
+                else {
+                    rebuilt.set(name, existing);
+                }
+            }
+            state.tables = rebuilt;
+            for (const other of state.tables.values()) {
+                for (const key of other.foreignKeys) {
+                    if (key.refTable === from) {
+                        key.refTable = to;
+                    }
+                }
+            }
+            return;
+        }
+        case 'dropColumns': {
+            const name = tableNameOf();
+            const columns = stringListArgument(argumentAt(call.args, 1, 'columns'));
+            const table = name === undefined ? undefined : state.tables.get(name);
+            if (columns === null || columns === undefined) {
+                pushWarning(state.warnings, `${mctx.file}: Schema::dropColumns() was given columns that are not string literals; the call was skipped.`);
+            }
+            else if (table !== undefined) {
+                mctx.touched.push(table.name);
+                for (const column of columns) {
+                    removeColumn(table, column);
+                }
+            }
+            return;
+        }
+        default:
+            if (!IGNORED_SCHEMA_METHODS.has(method) &&
+                !method.startsWith('has') &&
+                !method.startsWith('get')) {
+                pushWarning(state.warnings, `${mctx.file}: Schema::${method}() is not interpreted and was ignored.`);
+            }
+            return;
+    }
+}
+function replayMigration(migration, state) {
+    const mctx = {
+        state,
+        file: migration.file,
+        touched: [],
+    };
+    const statements = migration.up.namedChildren;
+    forEachStatement(statements, (statement) => {
+        const expression = statementExpression(statement);
+        if (expression === undefined) {
+            return;
+        }
+        const chain = readChain(expression);
+        if (chain === undefined) {
+            return;
+        }
+        if (isFacade(chain, 'Schema')) {
+            runSchemaCall(chain, mctx);
+        }
+        else if (isFacade(chain, 'DB')) {
+            warnRawSql(chain, mctx, statement.text);
+        }
+    }, (statement, descend) => describeControlFlow(statement, descend, mctx));
+}
+function declarationBody(node) {
+    const body = node.childForFieldName('body');
+    if (body !== null) {
+        return body;
+    }
+    return node.namedChildren.find((child) => child.type === 'declaration_list');
+}
+function methodName(method) {
+    return method.childForFieldName('name')?.text ?? '';
+}
+/** A class is a migration when its `up()` method calls `Schema::`. */
+function readMigration(node, ctx) {
+    const body = declarationBody(node);
+    if (body === undefined) {
+        return undefined;
+    }
+    const up = body.namedChildren.find((member) => member.type === 'method_declaration' && methodName(member) === 'up');
+    const upBody = up?.childForFieldName('body') ?? null;
+    if (upBody === null || !/\bSchema\s*::/.test(upBody.text)) {
+        return undefined;
+    }
+    return { file: basename(ctx.path), ctx, up: upBody };
+}
+function propertyValue(element) {
+    const initializer = element.namedChildren.find((child) => child.type === 'property_initializer');
+    return initializer?.namedChildren[0];
+}
+function castsFromArray(node) {
+    const casts = new Map();
+    if (node === undefined) {
+        return casts;
+    }
+    const value = evaluateNode(node);
+    if (value.kind !== 'array') {
+        return casts;
+    }
+    for (const item of value.items) {
+        if (item.key !== undefined && item.key.kind === 'string') {
+            casts.set(item.key.value, item.value);
+        }
+    }
+    return casts;
+}
+function relationFromMethod(method, owner, warnings) {
+    const name = methodName(method);
+    const body = method.childForFieldName('body');
+    const returnType = method.namedChildren.find((child) => child.type === 'named_type' ||
+        child.type === 'optional_type' ||
+        child.type === 'union_type');
+    const declaresRelation = returnType !== undefined &&
+        RELATION_RETURN_TYPES.has(lastNameSegment(returnType.text.replace(/^\?/, '')));
+    if (body === null) {
+        return undefined;
+    }
+    const returned = body.namedChildren.find((child) => child.type === 'return_statement');
+    const expression = returned?.namedChildren[0];
+    const chain = expression === undefined ? undefined : readChain(expression);
+    const first = chain?.links[0];
+    if (chain === undefined ||
+        first === undefined ||
+        chain.isStatic ||
+        chain.root.text !== '$this' ||
+        !RELATION_METHODS.has(first.name)) {
+        if (declaresRelation) {
+            warnings.push(`${owner.name}::${name}(): the relationship method could not be analysed (it does not simply return a $this->hasMany()-style call); the relation was skipped.`);
+        }
+        return undefined;
+    }
+    const extraModifiers = chain.links
+        .slice(1)
+        .map((link) => link.name)
+        .filter((modifier) => !HARMLESS_RELATION_MODIFIERS.has(modifier));
+    const call = first.name;
+    const optionalString = (index, parameter) => {
+        const text = stringArgument(first.args, index, parameter);
+        if (text === null) {
+            warnings.push(`${owner.name}::${name}(): the ${parameter} argument of ${call}() is not a string literal and was ignored.`);
+            return undefined;
+        }
+        return text;
+    };
+    const relatedArgument = argumentAt(first.args, 0, 'related');
+    const relatedFqn = relatedArgument === undefined
+        ? undefined
+        : classReference(evaluateArgument(relatedArgument.node), owner.ctx, owner.fqn);
+    const base = {
+        name,
+        call,
+        kind: 'morph',
+        ...(relatedFqn === undefined ? {} : { relatedFqn }),
+        extraModifiers,
+    };
+    switch (call) {
+        case 'hasOne':
+        case 'hasMany': {
+            const foreignKey = optionalString(1, 'foreignKey');
+            const otherKey = optionalString(2, 'localKey');
+            return {
+                ...base,
+                kind: call,
+                ...(foreignKey === undefined ? {} : { foreignKey }),
+                ...(otherKey === undefined ? {} : { otherKey }),
+            };
+        }
+        case 'belongsTo': {
+            const foreignKey = optionalString(1, 'foreignKey');
+            const otherKey = optionalString(2, 'ownerKey');
+            return {
+                ...base,
+                kind: 'belongsTo',
+                ...(foreignKey === undefined ? {} : { foreignKey }),
+                ...(otherKey === undefined ? {} : { otherKey }),
+            };
+        }
+        case 'belongsToMany': {
+            const tableArgument = argumentAt(first.args, 1, 'table');
+            let pivotTable;
+            let pivotModelFqn;
+            if (tableArgument !== undefined) {
+                const value = evaluateArgument(tableArgument.node);
+                if (value.kind === 'classRef') {
+                    pivotModelFqn = classReference(value, owner.ctx, owner.fqn);
+                }
+                else if (value.kind === 'string') {
+                    pivotTable = value.value;
+                }
+                else {
+                    warnings.push(`${owner.name}::${name}(): the table argument of belongsToMany() is not a string literal and was ignored.`);
+                }
+            }
+            const foreignKey = optionalString(2, 'foreignPivotKey');
+            const relatedPivotKey = optionalString(3, 'relatedPivotKey');
+            const parentKey = optionalString(4, 'parentKey');
+            const relatedKey = optionalString(5, 'relatedKey');
+            return {
+                ...base,
+                kind: 'belongsToMany',
+                ...(pivotTable === undefined ? {} : { pivotTable }),
+                ...(pivotModelFqn === undefined ? {} : { pivotModelFqn }),
+                ...(foreignKey === undefined ? {} : { foreignKey }),
+                ...(relatedPivotKey === undefined ? {} : { relatedPivotKey }),
+                ...(parentKey === undefined ? {} : { parentKey }),
+                ...(relatedKey === undefined ? {} : { relatedKey }),
+            };
+        }
+        case 'hasOneThrough':
+        case 'hasManyThrough':
+        case 'hasOneOfMany':
+        case 'latestOfMany':
+        case 'oldestOfMany':
+            return { ...base, kind: 'through' };
+        default:
+            return base;
+    }
+}
+function readModelClass(node, ctx, warnings) {
+    const nameNode = node.childForFieldName('name');
+    const body = declarationBody(node);
+    if (nameNode === null || body === undefined) {
+        return undefined;
+    }
+    const fqn = ctx.namespace === '' ? nameNode.text : `${ctx.namespace}\\${nameNode.text}`;
+    const model = {
+        name: nameNode.text,
+        fqn,
+        ctx,
+        isAbstract: node.namedChildren.some((child) => child.type === 'abstract_modifier'),
+        casts: new Map(),
+        traits: [],
+        relations: [],
+    };
+    const baseClause = node.namedChildren.find((child) => child.type === 'base_clause');
+    const baseName = baseClause?.namedChildren[0];
+    if (baseName !== undefined) {
+        model.parentFqn = resolveClassName(baseName.text.replace(/\s+/g, ''), ctx);
+    }
+    for (const member of body.namedChildren) {
+        if (member.type === 'use_declaration') {
+            for (const used of member.namedChildren) {
+                if (used.type === 'name' || used.type === 'qualified_name') {
+                    model.traits.push(resolveClassName(used.text.replace(/\s+/g, ''), ctx));
+                }
+            }
+        }
+        else if (member.type === 'const_declaration') {
+            for (const element of member.namedChildren) {
+                if (element.type !== 'const_element') {
+                    continue;
+                }
+                const constName = element.namedChildren[0]?.text;
+                const valueNode = element.namedChildren[1];
+                if (valueNode === undefined) {
+                    continue;
+                }
+                const value = evaluateNode(valueNode);
+                const text = value.kind === 'string'
+                    ? value.value
+                    : value.kind === 'null'
+                        ? null
+                        : undefined;
+                if (text === undefined) {
+                    continue;
+                }
+                if (constName === 'CREATED_AT') {
+                    model.createdAt = text;
+                }
+                else if (constName === 'UPDATED_AT') {
+                    model.updatedAt = text;
+                }
+                else if (constName === 'DELETED_AT' && text !== null) {
+                    model.deletedAt = text;
+                }
+            }
+        }
+        else if (member.type === 'property_declaration') {
+            readModelProperty(member, model, warnings);
+        }
+        else if (member.type === 'method_declaration') {
+            const memberName = methodName(member);
+            const isStatic = member.namedChildren.some((child) => child.type === 'static_modifier');
+            const visibility = member.namedChildren.find((child) => child.type === 'visibility_modifier')?.text;
+            if (memberName === 'casts') {
+                const returned = member
+                    .childForFieldName('body')
+                    ?.namedChildren.find((child) => child.type === 'return_statement');
+                for (const [key, value] of castsFromArray(returned?.namedChildren[0])) {
+                    model.casts.set(key, value);
+                }
+            }
+            else if (memberName === 'uniqueIds') {
+                const returned = member
+                    .childForFieldName('body')
+                    ?.namedChildren.find((child) => child.type === 'return_statement');
+                const list = returned?.namedChildren[0] === undefined
+                    ? undefined
+                    : evaluateNode(returned.namedChildren[0]);
+                if (list !== undefined && list.kind === 'array') {
+                    model.uniqueIds = list.items.flatMap((item) => item.value.kind === 'string' ? [item.value.value] : []);
+                }
+            }
+            else if (!isStatic &&
+                (visibility === undefined || visibility === 'public')) {
+                const relation = relationFromMethod(member, model, warnings);
+                if (relation !== undefined) {
+                    model.relations.push(relation);
+                }
+            }
+        }
+    }
+    return model;
+}
+function readModelProperty(declaration, model, warnings) {
+    if (declaration.namedChildren.some((child) => child.type === 'static_modifier')) {
+        return;
+    }
+    for (const element of declaration.namedChildren) {
+        if (element.type !== 'property_element') {
+            continue;
+        }
+        const name = element.namedChildren[0]?.text.replace(/^\$/, '');
+        const valueNode = propertyValue(element);
+        if (name === undefined || valueNode === undefined) {
+            continue;
+        }
+        if (name === 'casts') {
+            for (const [key, value] of castsFromArray(valueNode)) {
+                model.casts.set(key, value);
+            }
+            continue;
+        }
+        const value = evaluateNode(valueNode);
+        switch (name) {
+            case 'table':
+            case 'primaryKey':
+            case 'keyType':
+                if (value.kind === 'string') {
+                    if (name === 'table') {
+                        model.table = value.value;
+                    }
+                    else if (name === 'primaryKey') {
+                        model.primaryKey = value.value;
+                    }
+                    else {
+                        model.keyType = value.value;
+                    }
+                }
+                else {
+                    warnings.push(`${model.name}: $${name} is not a string literal and was ignored.`);
+                }
+                break;
+            case 'incrementing':
+            case 'timestamps':
+                if (value.kind === 'bool') {
+                    if (name === 'timestamps') {
+                        model.timestamps = value.value;
+                    }
+                    else {
+                        model.incrementing = value.value;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+}
+function discover(sources, parser, warnings) {
+    const found = { migrations: [], models: [], enums: new Map() };
+    const classNodes = [];
+    for (const source of sources) {
+        const tree = parser.parse(source.text);
+        if (tree.rootNode.hasError) {
+            warnings.push(`${source.path}: the file contains PHP syntax errors; some migrations, models or columns may be missing from the output.`);
+        }
+        for (const { ctx, node } of collectDeclarations(tree.rootNode, source.path, true)) {
+            if (node.type === 'enum_declaration') {
+                const info = readEnumDeclaration(node, ctx, warnings);
+                if (info !== undefined && !found.enums.has(info.fqn)) {
+                    found.enums.set(info.fqn, info);
+                }
+                continue;
+            }
+            const migration = readMigration(node, ctx);
+            if (migration !== undefined) {
+                found.migrations.push({
+                    key: basename(source.path).replace(/\.php$/i, ''),
+                    migration,
+                });
+            }
+            else if (node.type === 'class_declaration') {
+                classNodes.push({ node, ctx });
+            }
+        }
+    }
+    // A class is a model when it extends an Eloquent base class, directly or through another model.
+    const candidates = [];
+    for (const { node, ctx } of classNodes) {
+        const model = readModelClass(node, ctx, warnings);
+        if (model !== undefined && model.parentFqn !== undefined) {
+            candidates.push(model);
+        }
+    }
+    const projectClasses = new Set(candidates.map((model) => model.fqn));
+    const isBase = (model) => {
+        const parent = model.parentFqn;
+        if (parent === undefined) {
+            return false;
+        }
+        if (MODEL_BASE_CLASSES.has(parent)) {
+            return true;
+        }
+        // A short name that did not resolve to a class of the project (the import is missing, or the file is read on its own).
+        return (MODEL_BASE_SHORT_NAMES.has(lastNameSegment(parent)) &&
+            !projectClasses.has(parent));
+    };
+    const accepted = new Map();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const model of candidates) {
+            if (accepted.has(model.fqn)) {
+                continue;
+            }
+            if (isBase(model) ||
+                (model.parentFqn !== undefined && accepted.has(model.parentFqn))) {
+                accepted.set(model.fqn, model);
+                changed = true;
+            }
+        }
+    }
+    found.models = candidates.filter((model) => accepted.has(model.fqn));
+    return found;
+}
+// ---------------------------------------------------------------------------
+// Models resolved through their parents
+// ---------------------------------------------------------------------------
+function resolveModel(model, all) {
+    const chain = [];
+    const seen = new Set();
+    let current = model;
+    while (current !== undefined && !seen.has(current.fqn)) {
+        chain.push(current);
+        seen.add(current.fqn);
+        current =
+            current.parentFqn === undefined ? undefined : all.get(current.parentFqn);
+    }
+    const firstDefined = (read) => {
+        for (const cls of chain) {
+            const value = read(cls);
+            if (value !== undefined) {
+                return value;
+            }
+        }
+        return undefined;
+    };
+    const casts = new Map();
+    for (const cls of [...chain].reverse()) {
+        for (const [key, value] of cls.casts) {
+            casts.set(key, value);
+        }
+    }
+    const traits = chain.flatMap((cls) => cls.traits);
+    const hasTrait = (...names) => traits.some((trait) => names.includes(lastNameSegment(trait)));
+    const timestamps = firstDefined((cls) => cls.timestamps);
+    const createdAt = firstDefined((cls) => cls.createdAt);
+    const updatedAt = firstDefined((cls) => cls.updatedAt);
+    const primaryKey = firstDefined((cls) => cls.primaryKey);
+    const keyType = firstDefined((cls) => cls.keyType);
+    const incrementing = firstDefined((cls) => cls.incrementing);
+    const uniqueIds = firstDefined((cls) => cls.uniqueIds);
+    return {
+        source: model,
+        table: model.table ?? conventionalTableName(model.name),
+        ...(primaryKey === undefined ? {} : { primaryKey }),
+        ...(keyType === undefined ? {} : { keyType }),
+        ...(incrementing === undefined ? {} : { incrementing }),
+        timestamps: timestamps ?? true,
+        createdAt: createdAt === undefined ? 'created_at' : createdAt,
+        updatedAt: updatedAt === undefined ? 'updated_at' : updatedAt,
+        deletedAt: firstDefined((cls) => cls.deletedAt) ?? 'deleted_at',
+        ...(uniqueIds === undefined ? {} : { uniqueIds }),
+        casts,
+        usesSoftDeletes: hasTrait('SoftDeletes'),
+        usesUuids: hasTrait('HasUuids', 'HasVersion4Uuids', 'HasVersion7Uuids'),
+        usesUlids: hasTrait('HasUlids'),
+    };
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+/**
+ * Parses a Laravel project into the shared IR. The schema is rebuilt by replaying
+ * the migrations in file-name order (the source of truth for columns, indexes and
+ * foreign keys); Eloquent models contribute relation names, casts to backed enums,
+ * custom table names and timestamps handling.
+ */
+export async function parseLaravel(sources, options) {
+    const parserResult = await getPhpParser();
+    if (!parserResult.ok) {
+        return parserResult;
+    }
+    const warnings = [];
+    const found = discover(sources, parserResult.value, warnings);
+    if (found.migrations.length === 0) {
+        const checkedPaths = sources
+            .map((source) => source.path)
+            .join(', ');
+        return err('NO_MODELS_FOUND', `No Laravel migrations were found in: ${checkedPaths}. A migration is a class whose up() method calls Schema::create() or Schema::table(); ` +
+            `Laravel keeps its schema in migrations, so pass the database/migrations directory (or the project root) together with the models.`);
+    }
+    const ordered = [...found.migrations].sort((first, second) => first.key < second.key ? -1 : first.key > second.key ? 1 : 0);
+    const hasPrefix = (key) => /^\d{4}_\d{2}_\d{2}_\d{6}_/.test(key);
+    if (ordered.length > 1) {
+        for (const entry of ordered) {
+            if (!hasPrefix(entry.key)) {
+                warnings.push(`${entry.migration.file}: the migration file name has no timestamp prefix (YYYY_MM_DD_HHMMSS_); migrations were ordered by file name.`);
+            }
+        }
+    }
+    const state = { tables: new Map(), warnings };
+    for (const entry of ordered) {
+        replayMigration(entry.migration, state);
+    }
+    const schema = buildSchema(state, found, options);
+    if (schema.models.length === 0) {
+        return err('NO_MODELS_FOUND', `The Laravel migrations in ${sources.map((source) => source.path).join(', ')} leave no tables behind ` +
+            `(every table is dropped again, or only altered without being created).`);
+    }
+    return ok(schema);
+}
+function singlePrimaryKey(table) {
+    return table?.primaryKey?.length === 1 ? table.primaryKey[0] : undefined;
+}
+function buildSchema(state, found, options) {
+    const warnings = state.warnings;
+    // Tables -----------------------------------------------------------------
+    const live = new Map();
+    for (const table of state.tables.values()) {
+        if (table.isPartial) {
+            warnings.push(`${table.name}: the table is altered by the migrations but never created in the provided files; it was skipped.`);
+        }
+        else {
+            live.set(table.name, table);
+        }
+    }
+    // Models -----------------------------------------------------------------
+    const classesByFqn = new Map(found.models.map((model) => [
+        model.fqn,
+        model,
+    ]));
+    const effectiveByFqn = new Map();
+    const effectiveByTable = new Map();
+    for (const model of found.models) {
+        if (model.isAbstract) {
+            continue;
+        }
+        const effective = resolveModel(model, classesByFqn);
+        if (!live.has(effective.table)) {
+            warnings.push(`${model.name}: the model maps to the table "${effective.table}", which no migration creates; the model was skipped.`);
+            continue;
+        }
+        const taken = effectiveByTable.get(effective.table);
+        if (taken !== undefined) {
+            warnings.push(`${model.name}: the table "${effective.table}" is already used by the model ${taken.source.name}; ${model.name} was ignored.`);
+            continue;
+        }
+        effectiveByTable.set(effective.table, effective);
+        effectiveByFqn.set(model.fqn, effective);
+    }
+    const keyName = (effective) => effective.primaryKey ?? singlePrimaryKey(live.get(effective.table)) ?? 'id';
+    // Pivot tables -------------------------------------------------------------
+    const uses = [];
+    for (const effective of effectiveByTable.values()) {
+        const owner = effective.source;
+        for (const method of owner.relations) {
+            if (method.kind !== 'belongsToMany') {
+                continue;
+            }
+            const related = method.relatedFqn === undefined
+                ? undefined
+                : effectiveByFqn.get(method.relatedFqn);
+            if (related === undefined) {
+                warnings.push(`${owner.name}::${method.name}(): the related class is not a model with a table in the provided files; the relation was skipped.`);
+                continue;
+            }
+            const pivotModel = method.pivotModelFqn === undefined
+                ? undefined
+                : effectiveByFqn.get(method.pivotModelFqn);
+            const table = method.pivotTable ??
+                pivotModel?.table ??
+                [eloquentSnake(owner.name), eloquentSnake(related.source.name)]
+                    .sort()
+                    .join('_');
+            const ownerColumn = method.foreignKey ??
+                `${eloquentSnake(owner.name)}_${keyName(effective)}`;
+            const relatedColumn = method.relatedPivotKey ??
+                `${eloquentSnake(related.source.name)}_${keyName(related)}`;
+            const pivot = live.get(table);
+            if (pivot === undefined) {
+                warnings.push(`${owner.name}::${method.name}(): the pivot table "${table}" is not created by the migrations; the relation was skipped.`);
+                continue;
+            }
+            if (!pivot.columns.has(ownerColumn) ||
+                !pivot.columns.has(relatedColumn)) {
+                warnings.push(`${owner.name}::${method.name}(): the pivot table "${table}" has no column "${pivot.columns.has(ownerColumn) ? relatedColumn : ownerColumn}"; the relation was skipped.`);
+                continue;
+            }
+            if (method.parentKey !== undefined || method.relatedKey !== undefined) {
+                warnings.push(`${owner.name}::${method.name}(): the parentKey / relatedKey arguments (keys other than the primary key) are not represented.`);
+            }
+            const extraColumns = [...pivot.columns.keys()].filter((name) => name !== ownerColumn &&
+                name !== relatedColumn &&
+                !(name === 'id' && pivot.primaryKey?.join() === 'id') &&
+                name !== 'created_at' &&
+                name !== 'updated_at');
+            const isFoldable = extraColumns.length === 0;
+            if (!isFoldable) {
+                warnings.push(`${owner.name}::${method.name}(): the pivot table "${table}" has extra columns (${extraColumns.join(', ')}), so it was kept as a model and the relation was not converted to a many-to-many field.`);
+            }
+            uses.push({
+                owner: effective,
+                related,
+                method,
+                table,
+                ownerColumn,
+                relatedColumn,
+                isFoldable,
+            });
+        }
+    }
+    const folded = new Set();
+    for (const table of unique(uses.map((use) => use.table))) {
+        if (uses
+            .filter((use) => use.table === table)
+            .every((use) => use.isFoldable)) {
+            folded.add(table);
+        }
+    }
+    // Names ------------------------------------------------------------------
+    const modelNames = new Map();
+    const takenNames = new Set();
+    for (const table of live.keys()) {
+        const preferred = effectiveByTable.get(table)?.source.name ??
+            toPascalCase(singularize(table));
+        let name = preferred === '' ? 'Model' : preferred;
+        while (takenNames.has(name)) {
+            name = `${name}Table`;
+        }
+        takenNames.add(name);
+        modelNames.set(table, name);
+    }
+    const tableForClassName = (className) => {
+        const short = lastNameSegment(className);
+        for (const [table, effective] of effectiveByTable) {
+            if (effective.source.name === short) {
+                return table;
+            }
+        }
+        return conventionalTableName(short);
+    };
+    // Foreign key candidates -------------------------------------------------
+    const candidates = new Map();
+    const candidatesOf = (table) => {
+        let map = candidates.get(table);
+        if (map === undefined) {
+            map = new Map();
+            candidates.set(table, map);
+        }
+        return map;
+    };
+    const isTarget = (table) => live.has(table) && !folded.has(table);
+    for (const table of live.values()) {
+        if (folded.has(table.name)) {
+            continue;
+        }
+        for (const key of table.foreignKeys) {
+            const column = key.columns[0];
+            if (key.columns.length !== 1 || column === undefined) {
+                warnings.push(`${table.name}: the composite foreign key (${key.columns.join(', ')}) is not supported; its columns were kept as plain columns.`);
+                continue;
+            }
+            if (!table.columns.has(column)) {
+                continue;
+            }
+            const referenced = key.refTable ??
+                (key.refModel === undefined
+                    ? undefined
+                    : tableForClassName(key.refModel));
+            if (referenced === undefined) {
+                warnings.push(`${table.name}.${column}: the foreign key does not name a referenced table; the column was kept as a plain column.`);
+                continue;
+            }
+            if (!isTarget(referenced)) {
+                warnings.push(`${table.name}.${column}: the foreign key references the table "${referenced}", which no migration creates; the column was kept as a plain column.`);
+                continue;
+            }
+            candidatesOf(table.name).set(column, {
+                column,
+                targetTable: referenced,
+                targetColumn: key.refColumns[0] ?? 'id',
+                foreignKey: key,
+            });
+        }
+    }
+    for (const effective of effectiveByTable.values()) {
+        const owner = effective.source;
+        for (const method of owner.relations) {
+            if (method.kind === 'morph' || method.kind === 'through') {
+                warnings.push(method.kind === 'morph'
+                    ? `${owner.name}::${method.name}(): the polymorphic relation (${method.call}) is not represented; its columns, if any, were kept as plain columns.`
+                    : `${owner.name}::${method.name}(): the ${method.call} relation is derived from other relations and was not converted.`);
+                continue;
+            }
+            if (method.extraModifiers.length > 0) {
+                warnings.push(`${owner.name}::${method.name}(): the relation is further constrained by ${method.extraModifiers.join(', ')}(); the constraint is not represented.`);
+            }
+            if (method.kind === 'belongsToMany') {
+                continue;
+            }
+            const related = method.relatedFqn === undefined
+                ? undefined
+                : effectiveByFqn.get(method.relatedFqn);
+            if (related === undefined) {
+                warnings.push(`${owner.name}::${method.name}(): the related class is not a model with a table in the provided files; the relation was skipped.`);
+                continue;
+            }
+            if (method.kind === 'belongsTo') {
+                const ownerKey = method.otherKey ?? keyName(related);
+                const column = method.foreignKey ?? `${eloquentSnake(method.name)}_${ownerKey}`;
+                const table = live.get(effective.table);
+                if (table === undefined || !table.columns.has(column)) {
+                    warnings.push(`${owner.name}::${method.name}(): belongsTo uses the column "${column}", which the table "${effective.table}" does not have; the relation was skipped.`);
+                    continue;
+                }
+                if (!isTarget(related.table)) {
+                    continue;
+                }
+                const existing = candidatesOf(effective.table).get(column);
+                if (existing === undefined) {
+                    candidatesOf(effective.table).set(column, {
+                        column,
+                        targetTable: related.table,
+                        targetColumn: ownerKey,
+                        name: method.name,
+                    });
+                }
+                else {
+                    existing.name = method.name;
+                    if (existing.targetTable !== related.table) {
+                        warnings.push(`${owner.name}::${method.name}(): belongsTo points at "${related.table}" but the foreign key on ${effective.table}.${column} references "${existing.targetTable}"; the foreign key was used.`);
+                    }
+                }
+                continue;
+            }
+            // hasOne / hasMany: the foreign key lives on the related table.
+            const column = method.foreignKey ??
+                `${eloquentSnake(owner.name)}_${keyName(effective)}`;
+            const localKey = method.otherKey ?? keyName(effective);
+            const relatedTable = live.get(related.table);
+            if (relatedTable === undefined || !isTarget(related.table)) {
+                continue;
+            }
+            if (!relatedTable.columns.has(column)) {
+                warnings.push(`${owner.name}::${method.name}(): ${method.call} uses the column "${column}", which the table "${related.table}" does not have; the relation was skipped.`);
+                continue;
+            }
+            const existing = candidatesOf(related.table).get(column);
+            const reverse = {
+                name: method.name,
+                many: method.kind === 'hasMany',
+            };
+            if (existing === undefined) {
+                candidatesOf(related.table).set(column, {
+                    column,
+                    targetTable: effective.table,
+                    targetColumn: localKey,
+                    reverse,
+                });
+            }
+            else if (existing.targetTable !== effective.table) {
+                warnings.push(`${owner.name}::${method.name}(): ${method.call} expects ${related.table}.${column} to reference "${effective.table}" but it references "${existing.targetTable}"; the reverse name was not applied.`);
+            }
+            else if (existing.reverse === undefined) {
+                existing.reverse = reverse;
+            }
+        }
+    }
+    // Pivot tables kept as models still need their relations.
+    for (const use of uses) {
+        if (folded.has(use.table)) {
+            continue;
+        }
+        const pairs = [
+            [use.ownerColumn, use.owner],
+            [use.relatedColumn, use.related],
+        ];
+        for (const [column, target] of pairs) {
+            if (!candidatesOf(use.table).has(column) && isTarget(target.table)) {
+                candidatesOf(use.table).set(column, {
+                    column,
+                    targetTable: target.table,
+                    targetColumn: keyName(target),
+                });
+            }
+        }
+    }
+    // Enums ------------------------------------------------------------------
+    const enums = new Map();
+    const findEnum = (className, model) => {
+        const resolved = resolveClassName(className, model.ctx);
+        const exact = found.enums.get(resolved);
+        if (exact !== undefined) {
+            return exact;
+        }
+        const short = [...found.enums.values()].filter((info) => info.name === lastNameSegment(className));
+        return short.length === 1 ? short[0] : undefined;
+    };
+    const registerEnum = (info) => {
+        if (!enums.has(info.name)) {
+            enums.set(info.name, { name: info.name, values: info.values });
+        }
+    };
+    const synthesizeEnum = (modelName, column) => {
+        const values = [];
+        const seen = new Set();
+        (column.enumValues ?? []).forEach((value, position) => {
+            let name = toPascalCase(value);
+            if (name === '' || /^\d/.test(name)) {
+                name = `Value${position + 1}`;
+            }
+            while (seen.has(name)) {
+                name = `${name}_`;
+            }
+            seen.add(name);
+            values.push({ name, dbValue: value });
+        });
+        let enumName = `${modelName}${toPascalCase(column.name)}`;
+        while (enums.has(enumName)) {
+            enumName = `${enumName}_`;
+        }
+        enums.set(enumName, { name: enumName, values });
+        return enumName;
+    };
+    // Models -----------------------------------------------------------------
+    const models = [];
+    for (const table of live.values()) {
+        if (folded.has(table.name)) {
+            continue;
+        }
+        models.push(buildModel({
+            table,
+            modelName: modelNames.get(table.name) ?? table.name,
+            effective: effectiveByTable.get(table.name),
+            candidates: candidates.get(table.name) ?? new Map(),
+            modelNames,
+            live,
+            enums,
+            findEnum,
+            registerEnum,
+            synthesizeEnum,
+            warnings,
+            appLabel: options.appLabel,
+        }));
+    }
+    addManyToMany(models, uses, folded, modelNames, live, warnings);
+    const referenced = new Set();
+    for (const model of models) {
+        for (const field of model.fields) {
+            if (field.enumName !== undefined) {
+                referenced.add(field.enumName);
+            }
+        }
+    }
+    return {
+        models,
+        enums: [...enums.values()].filter((entry) => referenced.has(entry.name)),
+        warnings,
+    };
+}
+function buildModel(input) {
+    const { table, effective, warnings } = input;
+    const primaryKey = table.primaryKey ?? [];
+    const relationColumns = new Set(input.candidates.keys());
+    const uniqueSingles = new Set();
+    for (const index of table.indexes) {
+        const only = index.columns[0];
+        if (index.isUnique &&
+            index.kind === undefined &&
+            index.columns.length === 1 &&
+            only !== undefined) {
+            uniqueSingles.add(only);
+        }
+    }
+    if (primaryKey.length === 1 && primaryKey[0] !== undefined) {
+        uniqueSingles.add(primaryKey[0]);
+    }
+    // Fields -----------------------------------------------------------------
+    const fields = [];
+    for (const column of table.columns.values()) {
+        if (relationColumns.has(column.name)) {
+            continue;
+        }
+        fields.push(buildField(column, table, effective, input));
+    }
+    const usedNames = new Set(fields.map((field) => field.name));
+    // Relations --------------------------------------------------------------
+    const relationNames = new Map();
+    const relations = [];
+    for (const column of table.columns.values()) {
+        const candidate = input.candidates.get(column.name);
+        if (candidate === undefined) {
+            continue;
+        }
+        let name = candidate.name ?? column.name.replace(/_id$/, '');
+        if (name === '') {
+            name = column.name;
+        }
+        while (usedNames.has(name)) {
+            name = `${name}_rel`;
+        }
+        usedNames.add(name);
+        relationNames.set(column.name, name);
+        const isPrimary = primaryKey.length === 1 && primaryKey[0] === column.name;
+        const targetTable = input.live.get(candidate.targetTable);
+        const targetKey = singlePrimaryKey(targetTable) ?? 'id';
+        const kind = candidate.reverse?.many === false ||
+            (candidate.reverse === undefined && uniqueSingles.has(column.name))
+            ? 'oneToOne'
+            : 'foreignKey';
+        const relation = {
+            name,
+            kind,
+            targetModel: input.modelNames.get(candidate.targetTable) ?? candidate.targetTable,
+            columnName: column.name,
+            isNullable: column.isNullable && !isPrimary,
+            onDelete: candidate.foreignKey?.onDelete ?? 'noAction',
+            ...(candidate.reverse === undefined
+                ? {}
+                : { relatedName: candidate.reverse.name }),
+            ...(candidate.targetColumn === targetKey
+                ? {}
+                : { toField: candidate.targetColumn }),
+            ...(isPrimary ? { isPrimaryKey: true } : {}),
+            ...(candidate.foreignKey?.onUpdate === undefined
+                ? {}
+                : { onUpdate: candidate.foreignKey.onUpdate }),
+        };
+        relations.push(relation);
+    }
+    const irName = (column) => relationNames.get(column) ?? column;
+    // Primary key ------------------------------------------------------------
+    let compositePrimaryKey;
+    if (primaryKey.length > 1) {
+        compositePrimaryKey = primaryKey.map(irName);
+    }
+    else if (primaryKey.length === 0) {
+        warnings.push(`${table.name}: the table has no primary key.`);
+    }
+    // Indexes ----------------------------------------------------------------
+    const indexes = [];
+    for (const index of table.indexes) {
+        const missing = index.columns.filter((name) => !table.columns.has(name));
+        if (missing.length > 0) {
+            warnings.push(`${table.name}: the ${index.isUnique ? 'unique constraint' : 'index'} on (${index.columns.join(', ')}) refers to "${missing.join('", "')}", which is not a column of the table; it was skipped.`);
+            continue;
+        }
+        const type = index.kind === 'fulltext'
+            ? 'fulltext'
+            : index.isUnique
+                ? 'unique'
+                : 'index';
+        const conventional = conventionalIndexName(table.name, index.columns, type);
+        const explicitName = index.name !== undefined && index.name !== conventional
+            ? index.name
+            : undefined;
+        const names = index.columns.map(irName);
+        const only = index.columns[0];
+        if (index.isUnique &&
+            index.kind === undefined &&
+            explicitName === undefined &&
+            index.columns.length === 1 &&
+            only !== undefined) {
+            const field = fields.find((candidate) => candidate.columnName === only);
+            if (field !== undefined) {
+                if (!field.isPrimaryKey) {
+                    field.isUnique = true;
+                }
+                continue;
+            }
+            if (relationNames.has(only)) {
+                // The relation is one-to-one already; nothing else to record.
+                continue;
+            }
+        }
+        indexes.push({
+            fields: names,
+            isUnique: index.isUnique,
+            ...(explicitName === undefined ? {} : { name: explicitName }),
+            ...(index.kind === undefined ? {} : { kind: index.kind }),
+        });
+    }
+    // Soft deletes -----------------------------------------------------------
+    if (effective !== undefined &&
+        effective.usesSoftDeletes &&
+        !table.columns.has(effective.deletedAt)) {
+        warnings.push(`${effective.source.name}: the model uses SoftDeletes but the table "${table.name}" has no "${effective.deletedAt}" column.`);
+    }
+    return {
+        name: input.modelName,
+        tableName: table.name,
+        appLabel: input.appLabel,
+        fields,
+        relations,
+        indexes,
+        ...(compositePrimaryKey === undefined ? {} : { compositePrimaryKey }),
+    };
+}
+function buildField(column, table, effective, input) {
+    const { warnings } = input;
+    const label = `${table.name}.${column.name}`;
+    const isPrimary = table.primaryKey?.length === 1 && table.primaryKey[0] === column.name;
+    const field = {
+        name: column.name,
+        columnName: column.name,
+        type: column.type,
+        isPrimaryKey: isPrimary,
+        isUnique: false,
+        isNullable: column.isNullable && !isPrimary,
+        isAutoUpdated: column.isAutoUpdated,
+    };
+    if (column.default !== undefined) {
+        field.default = column.default;
+    }
+    if (column.type === 'string' && column.maxLength !== undefined) {
+        field.maxLength = column.maxLength;
+    }
+    if (column.type === 'decimal') {
+        field.maxDigits = column.maxDigits ?? 8;
+        field.decimalPlaces = column.decimalPlaces ?? 2;
+    }
+    if (column.unsupportedType !== undefined) {
+        field.unsupportedType = column.unsupportedType;
+    }
+    if (column.generated !== undefined) {
+        field.generated = column.generated;
+    }
+    // Eloquent behaviour for this column.
+    if (effective !== undefined) {
+        if (effective.timestamps &&
+            field.type === 'dateTime' &&
+            column.name === effective.updatedAt) {
+            field.isAutoUpdated = true;
+        }
+        if (effective.timestamps &&
+            field.type === 'dateTime' &&
+            column.name === effective.createdAt &&
+            field.default === undefined) {
+            field.default = { kind: 'now' };
+        }
+        const generatesId = effective.uniqueIds === undefined
+            ? isPrimary
+            : effective.uniqueIds.includes(column.name);
+        if (generatesId && field.default === undefined) {
+            if (effective.usesUuids &&
+                (field.type === 'uuid' || field.type === 'string')) {
+                field.default = { kind: 'uuid' };
+            }
+            else if (effective.usesUlids && field.type === 'string') {
+                field.default = { kind: 'clientGenerated', generator: 'ulid' };
+            }
+        }
+        const cast = effective.casts.get(column.name);
+        if (cast !== undefined) {
+            applyCast(field, column, cast, effective, label, input);
+        }
+    }
+    // A column that refreshes on every save is also set when the row is created, which is
+    // how the other formats spell it (`auto_now`, `@updatedAt`): no separate default.
+    if (field.isAutoUpdated && field.default?.kind === 'now') {
+        delete field.default;
+    }
+    // An `enum` column without a backed enum cast becomes an enum of its own.
+    if (column.enumValues !== undefined && field.enumName === undefined) {
+        field.enumName = input.synthesizeEnum(input.modelName, column);
+        delete field.maxLength;
+    }
+    if (field.enumName !== undefined) {
+        if (!column.hasExplicitLength) {
+            delete field.maxLength;
+        }
+        convertEnumDefault(field, input.enums.get(field.enumName), label, warnings);
+    }
+    return field;
+}
+function convertEnumDefault(field, enumeration, label, warnings) {
+    const current = field.default;
+    if (enumeration === undefined ||
+        current === undefined ||
+        current.kind !== 'literal') {
+        return;
+    }
+    const match = enumeration.values.find((value) => value.dbValue === String(current.value));
+    if (match === undefined) {
+        warnings.push(`${label}: the default "${String(current.value)}" is not a value of the enum "${enumeration.name}"; it was kept as a literal.`);
+        return;
+    }
+    field.default = { kind: 'enumValue', value: match.name };
+}
+function applyCast(field, column, cast, effective, label, input) {
+    if (cast.kind === 'classRef' ||
+        (cast.kind === 'string' && /\\/.test(cast.value))) {
+        const className = cast.kind === 'classRef'
+            ? cast.name
+            : cast.kind === 'string'
+                ? cast.value
+                : '';
+        const info = input.findEnum(className, effective.source);
+        if (info === undefined) {
+            return;
+        }
+        if (info.backing !== 'string') {
+            input.warnings.push(`${label}: the cast to the ${info.backing === 'int' ? 'int-backed' : 'non-backed'} enum ${info.name} is not supported; the column keeps its ${field.type} type.`);
+            return;
+        }
+        if (field.type !== 'string' && field.type !== 'text') {
+            input.warnings.push(`${label}: the cast to the enum ${info.name} was ignored because the column is of type ${field.type}.`);
+            return;
+        }
+        if (column.enumValues !== undefined) {
+            const allowed = info.values.map((value) => value.dbValue);
+            const differing = column.enumValues.filter((value) => !allowed.includes(value));
+            if (differing.length > 0) {
+                input.warnings.push(`${label}: the enum() values (${differing.join(', ')}) are not cases of ${info.name}.`);
+            }
+        }
+        input.registerEnum(info);
+        field.type = 'string';
+        field.enumName = info.name;
+        return;
+    }
+    if (cast.kind !== 'string') {
+        return;
+    }
+    const [base, parameter] = cast.value.toLowerCase().split(':', 2);
+    switch (base) {
+        case 'boolean':
+        case 'bool':
+            if (field.type === 'int' || field.type === 'bigInt') {
+                field.type = 'boolean';
+                convertBooleanDefault(field);
+            }
+            break;
+        case 'array':
+        case 'json':
+        case 'object':
+        case 'collection':
+            if (field.type === 'string' || field.type === 'text') {
+                field.type = 'json';
+                delete field.maxLength;
+            }
+            break;
+        case 'decimal': {
+            const places = Number(parameter);
+            if (field.type === 'decimal' &&
+                parameter !== undefined &&
+                Number.isInteger(places)) {
+                field.decimalPlaces = places;
+            }
+            break;
+        }
+        case 'date':
+        case 'immutable_date':
+            if (field.type === 'string' || field.type === 'text') {
+                field.type = 'date';
+                delete field.maxLength;
+            }
+            break;
+        case 'datetime':
+        case 'immutable_datetime':
+        case 'custom_datetime':
+        case 'immutable_custom_datetime':
+            if (field.type === 'string' || field.type === 'text') {
+                field.type = 'dateTime';
+                delete field.maxLength;
+            }
+            break;
+        default:
+            break;
+    }
+}
+function convertBooleanDefault(field) {
+    if (field.default?.kind === 'literal') {
+        const value = field.default.value;
+        if (value === 0 || value === 1) {
+            field.default = { kind: 'literal', value: value === 1 };
+        }
+    }
+}
+function addManyToMany(models, uses, folded, modelNames, live, warnings) {
+    const consumed = new Set();
+    const ordered = uses
+        .filter((use) => folded.has(use.table))
+        .sort((first, second) => {
+        const firstKey = `${first.owner.source.name}.${first.method.name}`;
+        const secondKey = `${second.owner.source.name}.${second.method.name}`;
+        return firstKey < secondKey ? -1 : firstKey > secondKey ? 1 : 0;
+    });
+    for (const use of ordered) {
+        if (consumed.has(use)) {
+            continue;
+        }
+        consumed.add(use);
+        const mirror = ordered.find((candidate) => !consumed.has(candidate) &&
+            candidate.table === use.table &&
+            candidate.owner === use.related &&
+            candidate.related === use.owner &&
+            candidate.ownerColumn === use.relatedColumn &&
+            candidate.relatedColumn === use.ownerColumn);
+        if (mirror !== undefined) {
+            consumed.add(mirror);
+        }
+        const ownerModel = models.find((model) => model.tableName === use.owner.table);
+        const ownerName = modelNames.get(use.owner.table) ?? use.owner.table;
+        const relatedName = modelNames.get(use.related.table) ?? use.related.table;
+        if (ownerModel === undefined) {
+            continue;
+        }
+        const relation = {
+            name: use.method.name,
+            kind: 'manyToMany',
+            targetModel: relatedName,
+            columnName: `${toSnakeCase(use.method.name)}_id`,
+            isNullable: false,
+            onDelete: 'cascade',
+            ...(mirror === undefined ? {} : { relatedName: mirror.method.name }),
+        };
+        ownerModel.relations.push(relation);
+        // Join tables are derived by the other formats; say what does not survive.
+        const isSelf = use.owner === use.related;
+        const expectedTable = `${use.owner.table}_${use.method.name}`;
+        const expectedOwner = `${isSelf ? 'from_' : ''}${toSnakeCase(ownerName)}_id`;
+        const expectedRelated = `${isSelf ? 'to_' : ''}${toSnakeCase(relatedName)}_id`;
+        if (use.table !== expectedTable ||
+            use.ownerColumn !== expectedOwner ||
+            use.relatedColumn !== expectedRelated) {
+            warnings.push(`${ownerName}.${use.method.name}: the pivot table "${use.table}" (columns ${use.ownerColumn}, ${use.relatedColumn}) is not preserved by name; ` +
+                `formats that derive join tables will use "${expectedTable}" (columns ${expectedOwner}, ${expectedRelated}).`);
+        }
+        const pivot = live.get(use.table);
+        if (pivot !== undefined) {
+            if (pivot.columns.has('created_at') || pivot.columns.has('updated_at')) {
+                warnings.push(`${ownerName}.${use.method.name}: the timestamp columns of the pivot table "${use.table}" are not represented in the many-to-many field.`);
+            }
+            const customActions = pivot.foreignKeys
+                .filter((key) => key.onDelete !== undefined &&
+                key.onDelete !== 'cascade' &&
+                (sameList(key.columns, [use.ownerColumn]) ||
+                    sameList(key.columns, [use.relatedColumn])))
+                .map((key) => key.columns.join(', '));
+            if (customActions.length > 0) {
+                warnings.push(`${ownerName}.${use.method.name}: the foreign keys of the pivot table "${use.table}" on (${customActions.join('; ')}) do not cascade on delete; many-to-many join tables always do.`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=laravel.js.map