ormbridge 0.4.0 → 0.6.0

package/dist/parsers/sqlalchemy.js

@@ -0,0 +1,3191 @@
+import { singularize, toCamelCase, toPascalCase, toSnakeCase, } from '../naming.js';
+import { describeThrown, err, ok } from '../result.js';
+import { evaluateNode, getPythonParser, lastSegment, } from './pythonSyntax.js';
+// ---------------------------------------------------------------------------
+// Limits and tables of known names
+// ---------------------------------------------------------------------------
+/** Files larger than this are skipped with a warning, so hostile input cannot stall the parser. */
+const MAX_SOURCE_LENGTH = 2_000_000;
+const MAX_WARNINGS = 500;
+const MAX_TYPE_DEPTH = 24;
+const MAX_STRING_ANNOTATION = 400;
+const MAX_ALIAS_DEPTH = 8;
+const MAX_INHERITANCE_DEPTH = 64;
+const MAX_COLUMNS_PER_TABLE = 2000;
+const MAX_RELATIONSHIPS_PER_TABLE = 2000;
+/** SQLAlchemy and dialect column types, keyed by their lower-cased class name. */
+const SA_TYPES = {
+    integer: { type: 'int' },
+    int: { type: 'int' },
+    smallinteger: { type: 'int' },
+    smallint: { type: 'int' },
+    tinyint: { type: 'int' },
+    mediumint: { type: 'int' },
+    biginteger: { type: 'bigInt' },
+    bigint: { type: 'bigInt' },
+    string: { type: 'string', length: true },
+    varchar: { type: 'string', length: true },
+    nvarchar: { type: 'string', length: true },
+    unicode: { type: 'string', length: true },
+    char: { type: 'string', length: true },
+    nchar: { type: 'string', length: true },
+    text: { type: 'text' },
+    unicodetext: { type: 'text' },
+    clob: { type: 'text' },
+    longtext: { type: 'text' },
+    mediumtext: { type: 'text' },
+    tinytext: { type: 'text' },
+    ntext: { type: 'text' },
+    boolean: { type: 'boolean' },
+    bool: { type: 'boolean' },
+    float: { type: 'float' },
+    real: { type: 'float' },
+    double: { type: 'float' },
+    double_precision: { type: 'float' },
+    numeric: { type: 'decimal', numeric: true },
+    decimal: { type: 'decimal', numeric: true },
+    datetime: { type: 'dateTime' },
+    timestamp: { type: 'dateTime' },
+    date: { type: 'date' },
+    time: { type: 'time' },
+    interval: { type: 'duration' },
+    largebinary: { type: 'bytes' },
+    binary: { type: 'bytes' },
+    varbinary: { type: 'bytes' },
+    blob: { type: 'bytes' },
+    bytea: { type: 'bytes' },
+    pickletype: { type: 'bytes' },
+    json: { type: 'json' },
+    jsonb: { type: 'json' },
+    uuid: { type: 'uuid' },
+    guid: { type: 'uuid' },
+    uniqueidentifier: { type: 'uuid' },
+    inet: { type: 'ipAddress' },
+    cidr: { type: 'ipAddress' },
+    hstore: { type: 'hstore' },
+    int4range: { type: 'range', rangeOf: 'int' },
+    int8range: { type: 'range', rangeOf: 'bigInt' },
+    numrange: { type: 'range', rangeOf: 'decimal' },
+    daterange: { type: 'range', rangeOf: 'date' },
+    tsrange: { type: 'range', rangeOf: 'dateTime' },
+    tstzrange: { type: 'range', rangeOf: 'dateTime' },
+};
+/** Python types a `Mapped[...]` annotation or SQLModel field can name without an explicit column type. */
+const PY_TYPES = {
+    int: { type: 'int' },
+    str: { type: 'string' },
+    float: { type: 'float' },
+    bool: { type: 'boolean' },
+    bytes: { type: 'bytes' },
+    bytearray: { type: 'bytes' },
+    datetime: { type: 'dateTime' },
+    date: { type: 'date' },
+    time: { type: 'time' },
+    timedelta: { type: 'duration' },
+    Decimal: { type: 'decimal' },
+    UUID: { type: 'uuid' },
+    IPv4Address: { type: 'ipAddress' },
+    IPv6Address: { type: 'ipAddress' },
+    IPv4Network: { type: 'ipAddress' },
+    IPv6Network: { type: 'ipAddress' },
+};
+/** Calls found among the positional arguments of a column that are not its type. */
+const NON_TYPE_CALLS = new Set([
+    'foreignkey',
+    'identity',
+    'sequence',
+    'computed',
+    'fetchedvalue',
+    'checkconstraint',
+    'foreignkeyconstraint',
+    'uniqueconstraint',
+    'primarykeyconstraint',
+    'index',
+    'defaultclause',
+    'persisted',
+]);
+const ROOT_BASE_NAMES = new Set([
+    'DeclarativeBase',
+    'DeclarativeBaseNoMeta',
+]);
+const ENUM_BASE_NAMES = new Set([
+    'Enum',
+    'IntEnum',
+    'StrEnum',
+    'Flag',
+    'IntFlag',
+    'ReprEnum',
+]);
+const COLLECTION_TYPES = new Set([
+    'list',
+    'set',
+    'sequence',
+    'collection',
+    'mutablesequence',
+    'frozenset',
+    'iterable',
+    'dict',
+    'mapping',
+    'defaultdict',
+    'ordereddict',
+]);
+const ON_ACTION_MAP = {
+    CASCADE: 'cascade',
+    'SET NULL': 'setNull',
+    RESTRICT: 'restrict',
+    'NO ACTION': 'noAction',
+    'SET DEFAULT': 'setDefault',
+};
+/** Mapped-attribute constructors that are not columns or relationships and are not converted. */
+const UNSUPPORTED_ATTRIBUTES = new Set([
+    'column_property',
+    'composite',
+    'synonym',
+    'deferred',
+    'query_expression',
+    'with_polymorphic',
+]);
+/** Constructors that never describe schema (read-only helpers on a model). */
+const IGNORED_ATTRIBUTES = new Set([
+    'association_proxy',
+    'hybrid_property',
+    'hybrid_method',
+    'validates',
+    'reconstructor',
+]);
+const CURRENT_TIMESTAMP_EXPRESSIONS = new Set([
+    'now()',
+    'current_timestamp',
+    'current_timestamp()',
+    'localtimestamp',
+    'localtimestamp()',
+    'getdate()',
+    'sysdatetime()',
+    'sysutcdatetime()',
+    "datetime('now')",
+    "(datetime('now'))",
+    'transaction_timestamp()',
+    'statement_timestamp()',
+    'clock_timestamp()',
+    'current_date',
+    'current_date()',
+    'current_time',
+]);
+const UUID_EXPRESSIONS = new Set([
+    'gen_random_uuid()',
+    'uuid_generate_v4()',
+    'uuid()',
+    'newid()',
+    'uuid_generate_v1()',
+    'newsequentialid()',
+]);
+function warn(ctx, message) {
+    if (ctx.warnings.length < MAX_WARNINGS) {
+        ctx.warnings.push(message);
+    }
+    else {
+        ctx.suppressed += 1;
+    }
+}
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+/** Parses SQLAlchemy and SQLModel model files into the shared IR using tree-sitter (no Python required). */
+export async function parseSqlAlchemy(sources, options) {
+    const parserResult = await getPythonParser();
+    if (!parserResult.ok) {
+        return parserResult;
+    }
+    try {
+        return buildFromSources(parserResult.value, sources, options);
+    }
+    catch (thrown) {
+        return err('PARSE_FAILED', `Failed to read the SQLAlchemy models: ${describeThrown(thrown)}`);
+    }
+}
+function buildFromSources(parser, sources, options) {
+    const ctx = {
+        parser,
+        options,
+        warnings: [],
+        suppressed: 0,
+        classes: new Map(),
+        classList: [],
+        baseVars: new Set(),
+        aliases: new Map(),
+        typeMap: new Map(),
+        tableDefs: [],
+        indexCalls: [],
+        imperative: [],
+        enumInfos: new Map(),
+        enums: [],
+        tables: [],
+        byModel: new Map(),
+        byVar: new Map(),
+        counter: 0,
+        enumClassMemo: new Map(),
+        tablesByName: new Map(),
+        tableDefByVar: new Map(),
+        stubTables: new Map(),
+        metadataSchemas: new Map(),
+        baseVarSchemas: new Map(),
+    };
+    for (const source of sources) {
+        readSource(ctx, source);
+    }
+    buildTables(ctx);
+    applyModuleIndexes(ctx);
+    resolveRelationships(ctx);
+    const models = finalizeAll(ctx);
+    if (ctx.suppressed > 0) {
+        ctx.warnings.push(`${ctx.suppressed} more warnings were left out to keep the output readable.`);
+    }
+    if (models.length === 0) {
+        const checkedPaths = sources
+            .map((source) => source.path)
+            .join(', ');
+        return err('NO_MODELS_FOUND', `No SQLAlchemy or SQLModel models were found in: ${checkedPaths}. A model is a class with a ` +
+            `__tablename__ (or a SQLModel class declared with table=True) that declares mapped columns, ` +
+            `or a Table(...) assigned to a variable.`);
+    }
+    return ok({ models, enums: ctx.enums, warnings: ctx.warnings });
+}
+// ---------------------------------------------------------------------------
+// Reading files
+// ---------------------------------------------------------------------------
+function readSource(ctx, source) {
+    if (typeof source.text !== 'string') {
+        warn(ctx, `${source.path}: the file has no text and was skipped.`);
+        return;
+    }
+    if (source.text.length > MAX_SOURCE_LENGTH) {
+        warn(ctx, `${source.path}: the file is larger than ${MAX_SOURCE_LENGTH} characters and was skipped.`);
+        return;
+    }
+    let tree = null;
+    try {
+        tree = ctx.parser.parse(source.text);
+        if (tree.rootNode.hasError) {
+            warn(ctx, `${source.path}: the file contains Python syntax errors; some models or columns may be missing from the output.`);
+        }
+        for (const statement of tree.rootNode.namedChildren) {
+            readTopLevel(ctx, source.path, statement);
+        }
+    }
+    catch (thrown) {
+        warn(ctx, `${source.path}: the file could not be read completely (${describeThrown(thrown)}).`);
+    }
+    finally {
+        if (tree !== null) {
+            tree.delete();
+        }
+    }
+}
+function readTopLevel(ctx, filePath, statement) {
+    switch (statement.type) {
+        case 'class_definition':
+            readClass(ctx, filePath, statement);
+            return;
+        case 'decorated_definition': {
+            const definition = statement.childForFieldName('definition');
+            if (definition !== null && definition.type === 'class_definition') {
+                readClass(ctx, filePath, definition);
+            }
+            return;
+        }
+        case 'expression_statement':
+            readModuleExpression(ctx, filePath, statement);
+            return;
+        case 'if_statement':
+        case 'try_statement': {
+            // Models are sometimes declared under `if not TYPE_CHECKING:` or after a guarded import.
+            const body = statement.childForFieldName('consequence');
+            if (body !== null) {
+                for (const nested of body.namedChildren) {
+                    readTopLevel(ctx, filePath, nested);
+                }
+            }
+            return;
+        }
+        default:
+            return;
+    }
+}
+function assignmentParts(statement) {
+    const assignment = statement.namedChildren[0];
+    if (assignment === undefined || assignment.type !== 'assignment') {
+        return undefined;
+    }
+    const left = assignment.childForFieldName('left');
+    if (left === null) {
+        return undefined;
+    }
+    return {
+        left,
+        right: assignment.childForFieldName('right'),
+        type: assignment.childForFieldName('type'),
+    };
+}
+function readModuleExpression(ctx, filePath, statement) {
+    const parts = assignmentParts(statement);
+    if (parts === undefined) {
+        const expression = statement.namedChildren[0];
+        if (expression !== undefined && expression.type === 'call') {
+            const value = evaluateNode(expression);
+            if (value.kind === 'call') {
+                const callee = lastSegment(value.callee);
+                if (callee === 'Index') {
+                    ctx.indexCalls.push({ call: value, filePath });
+                }
+                else if (callee === 'map_imperatively') {
+                    readImperative(ctx, value);
+                }
+            }
+        }
+        return;
+    }
+    if (parts.left.type !== 'identifier' || parts.right === null) {
+        return;
+    }
+    const name = parts.left.text;
+    if (parts.right.type === 'call') {
+        const value = evaluateNode(parts.right);
+        if (value.kind !== 'call') {
+            return;
+        }
+        const callee = lastSegment(value.callee);
+        if (callee === 'Table') {
+            ctx.tableDefs.push({ varName: name, call: value, filePath });
+            ctx.tableDefByVar.set(name, value);
+        }
+        else if (callee === 'MetaData') {
+            const schema = stringOf(value.kwargs['schema']);
+            if (schema !== undefined) {
+                ctx.metadataSchemas.set(name, schema);
+            }
+        }
+        else if (callee === 'declarative_base' ||
+            callee === 'automap_base' ||
+            callee === 'generate_base') {
+            ctx.baseVars.add(name);
+            const metadata = value.kwargs['metadata'];
+            const schema = metadata === undefined ? undefined : metadataSchemaOf(ctx, metadata);
+            if (schema !== undefined) {
+                ctx.metadataSchemas.set(`${name}.metadata`, schema);
+                ctx.baseVarSchemas.set(name, schema);
+            }
+        }
+        return;
+    }
+    if (parts.right.type === 'subscript' ||
+        parts.right.type === 'generic_type' ||
+        parts.right.type === 'binary_operator') {
+        const alias = toTypeExpr(ctx, parts.right, 0);
+        if (alias.kind === 'sub' || alias.kind === 'union') {
+            ctx.aliases.set(name, alias);
+        }
+    }
+}
+function readImperative(ctx, call) {
+    const classArg = call.args[0];
+    const tableArg = call.args[1];
+    if (classArg !== undefined &&
+        classArg.kind === 'name' &&
+        tableArg !== undefined &&
+        tableArg.kind === 'name') {
+        ctx.imperative.push({
+            className: lastSegment(classArg.value),
+            tableVar: tableArg.value,
+            hasProperties: call.kwargs['properties'] !== undefined,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Classes
+// ---------------------------------------------------------------------------
+function stringOf(value) {
+    return value !== undefined && value.kind === 'string'
+        ? value.value
+        : undefined;
+}
+function boolOf(value) {
+    return value !== undefined && value.kind === 'bool' ? value.value : undefined;
+}
+function numberOf(value) {
+    return value !== undefined && value.kind === 'number'
+        ? value.value
+        : undefined;
+}
+function readClass(ctx, filePath, node) {
+    const nameNode = node.childForFieldName('name');
+    if (nameNode === null) {
+        return;
+    }
+    const name = nameNode.text;
+    const bases = [];
+    const keywords = {};
+    const superclasses = node.childForFieldName('superclasses');
+    if (superclasses !== null) {
+        for (const child of superclasses.namedChildren) {
+            if (child.type === 'keyword_argument') {
+                const keyNode = child.childForFieldName('name');
+                const valueNode = child.childForFieldName('value');
+                if (keyNode !== null && valueNode !== null) {
+                    keywords[keyNode.text] = evaluateNode(valueNode);
+                }
+            }
+            else if (child.type !== 'comment') {
+                bases.push(child.text.replace(/\s+/g, ''));
+            }
+        }
+    }
+    const raw = {
+        name,
+        filePath,
+        order: ctx.counter,
+        bases,
+        keywords,
+        members: [],
+        isAbstract: false,
+        enumMembers: [],
+    };
+    ctx.counter += 1;
+    const body = node.childForFieldName('body');
+    for (const statement of body === null ? [] : body.namedChildren) {
+        readClassStatement(ctx, raw, statement);
+    }
+    if (ctx.classes.has(name)) {
+        warn(ctx, `Duplicate class name "${name}" (${filePath}); only the first definition was converted.`);
+        return;
+    }
+    ctx.classes.set(name, raw);
+    ctx.classList.push(raw);
+}
+function flattenItems(value) {
+    return value.kind === 'list' ? value.items : [value];
+}
+function readClassStatement(ctx, raw, statement) {
+    if (statement.type === 'decorated_definition') {
+        const definition = statement.childForFieldName('definition');
+        if (definition !== null && definition.type === 'function_definition') {
+            readClassFunction(ctx, raw, definition, statement);
+        }
+        return;
+    }
+    if (statement.type !== 'expression_statement') {
+        return;
+    }
+    const parts = assignmentParts(statement);
+    if (parts === undefined || parts.left.type !== 'identifier') {
+        return;
+    }
+    const name = parts.left.text;
+    const value = parts.right === null ? undefined : evaluateNode(parts.right);
+    const annotationNode = parts.type?.namedChildren[0];
+    if (name === '__tablename__') {
+        raw.tableName = stringOf(value);
+        return;
+    }
+    if (name === '__abstract__') {
+        raw.isAbstract = boolOf(value) === true;
+        return;
+    }
+    if (name === '__table_args__') {
+        if (value !== undefined) {
+            raw.tableArgs = flattenItems(value);
+        }
+        return;
+    }
+    if (name === '__table__') {
+        if (value !== undefined && value.kind === 'call') {
+            raw.tableExpr = value;
+        }
+        return;
+    }
+    if (name === 'impl' && value !== undefined) {
+        raw.impl = value;
+    }
+    if (name === 'metadata' && value !== undefined) {
+        const schema = metadataSchemaOf(ctx, value);
+        if (schema !== undefined) {
+            raw.metadataSchema = schema;
+        }
+        return;
+    }
+    if (name === 'type_annotation_map' && value !== undefined) {
+        if (value.kind === 'dict') {
+            for (const entry of value.entries) {
+                const key = normalizeTypeText(valueText(entry.key));
+                if (key !== '' && !ctx.typeMap.has(key)) {
+                    ctx.typeMap.set(key, entry.value);
+                }
+            }
+        }
+        return;
+    }
+    if (name.startsWith('__')) {
+        return;
+    }
+    raw.enumMembers.push({ name, value });
+    const member = { name };
+    if (annotationNode !== undefined) {
+        member.annotation = toTypeExpr(ctx, annotationNode, 0);
+    }
+    if (value !== undefined) {
+        member.value = value;
+    }
+    raw.members.push(member);
+}
+function metadataSchemaOf(ctx, value) {
+    if (value.kind === 'call' && lastSegment(value.callee) === 'MetaData') {
+        return stringOf(value.kwargs['schema']);
+    }
+    if (value.kind === 'name') {
+        return ctx.metadataSchemas.get(value.value);
+    }
+    return undefined;
+}
+function valueText(value) {
+    switch (value.kind) {
+        case 'name':
+            return value.value;
+        case 'other':
+            return value.text;
+        case 'string':
+            return value.value;
+        case 'call':
+            return value.text;
+        default:
+            return '';
+    }
+}
+function readClassFunction(ctx, raw, definition, decorated) {
+    const nameNode = definition.childForFieldName('name');
+    if (nameNode === null) {
+        return;
+    }
+    const functionName = nameNode.text;
+    const isDeclaredAttr = decorated.namedChildren.some((child) => child.type === 'decorator' && /declared_attr/.test(child.text));
+    if (!isDeclaredAttr) {
+        return;
+    }
+    if (functionName === '__tablename__') {
+        const body = definition.childForFieldName('body');
+        const returned = body?.namedChildren.find((child) => child.type === 'return_statement');
+        const expression = returned?.namedChildren[0];
+        const text = expression === undefined ? '' : expression.text.replace(/\s+/g, '');
+        if (/^cls\.__name__\.lower\(\)$/.test(text)) {
+            raw.tableNameRule = 'lower';
+        }
+        else if (/^cls\.__name__$/.test(text)) {
+            raw.tableNameRule = 'exact';
+        }
+        else if (/__name__/.test(text) && /snake|underscore|re\.sub/.test(text)) {
+            raw.tableNameRule = 'snake';
+        }
+        else if (expression !== undefined && expression.type === 'string') {
+            raw.tableName = stringOf(evaluateNode(expression));
+        }
+        else {
+            warn(ctx, `${raw.name}.__tablename__: the @declared_attr could not be evaluated; the table name is derived from the class name.`);
+            raw.tableNameRule = 'snake';
+        }
+        return;
+    }
+    warn(ctx, `${raw.name}.${functionName}: @declared_attr members are not supported and were skipped.`);
+}
+// ---------------------------------------------------------------------------
+// Type expressions (annotations)
+// ---------------------------------------------------------------------------
+function toTypeExpr(ctx, node, depth) {
+    if (depth > MAX_TYPE_DEPTH) {
+        return { kind: 'other', text: node.text.slice(0, 100) };
+    }
+    const next = depth + 1;
+    switch (node.type) {
+        case 'type':
+        case 'parenthesized_expression': {
+            const inner = node.namedChildren[0];
+            return inner === undefined
+                ? { kind: 'other', text: node.text }
+                : toTypeExpr(ctx, inner, next);
+        }
+        case 'identifier':
+        case 'attribute':
+            return { kind: 'name', name: node.text.replace(/\s+/g, '') };
+        case 'none':
+            return { kind: 'none' };
+        case 'string':
+        case 'concatenated_string': {
+            const value = evaluateNode(node);
+            return value.kind === 'string'
+                ? { kind: 'str', value: value.value }
+                : { kind: 'other', text: node.text.slice(0, 100) };
+        }
+        case 'binary_operator': {
+            const left = node.childForFieldName('left');
+            const right = node.childForFieldName('right');
+            const operator = node.childForFieldName('operator');
+            if (left === null ||
+                right === null ||
+                operator === null ||
+                operator.text !== '|') {
+                return { kind: 'other', text: node.text.slice(0, 100) };
+            }
+            const members = [];
+            for (const side of [left, right]) {
+                const member = toTypeExpr(ctx, side, next);
+                if (member.kind === 'union') {
+                    members.push(...member.members);
+                }
+                else {
+                    members.push(member);
+                }
+            }
+            return { kind: 'union', members };
+        }
+        case 'generic_type': {
+            const baseNode = node.namedChildren[0];
+            const parameters = node.namedChildren.find((child) => child.type === 'type_parameter');
+            if (baseNode === undefined) {
+                return { kind: 'other', text: node.text.slice(0, 100) };
+            }
+            return {
+                kind: 'sub',
+                base: baseNode.text.replace(/\s+/g, ''),
+                args: (parameters === undefined ? [] : parameters.namedChildren).map((child) => toTypeExpr(ctx, child, next)),
+            };
+        }
+        case 'subscript': {
+            const baseNode = node.childForFieldName('value');
+            if (baseNode === null) {
+                return { kind: 'other', text: node.text.slice(0, 100) };
+            }
+            return {
+                kind: 'sub',
+                base: baseNode.text.replace(/\s+/g, ''),
+                args: node
+                    .childrenForFieldName('subscript')
+                    .filter((child) => child.isNamed)
+                    .map((child) => toTypeExpr(ctx, child, next)),
+            };
+        }
+        case 'call':
+            return { kind: 'value', value: evaluateNode(node) };
+        default:
+            return { kind: 'other', text: node.text.slice(0, 100) };
+    }
+}
+/** Parses the text of a string annotation such as "Mapped[list['Post']]" once. */
+function typeFromString(ctx, text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0 || trimmed.length > MAX_STRING_ANNOTATION) {
+        return { kind: 'name', name: trimmed.slice(0, MAX_STRING_ANNOTATION) };
+    }
+    if (/^[A-Za-z_][\w.]*$/.test(trimmed)) {
+        return { kind: 'name', name: trimmed };
+    }
+    let tree = null;
+    try {
+        tree = ctx.parser.parse(trimmed);
+        const statement = tree.rootNode.namedChildren[0];
+        const expression = statement?.namedChildren[0];
+        if (statement === undefined ||
+            statement.type !== 'expression_statement' ||
+            expression === undefined) {
+            return { kind: 'other', text: trimmed };
+        }
+        return toTypeExpr(ctx, expression, MAX_TYPE_DEPTH - 6);
+    }
+    finally {
+        if (tree !== null) {
+            tree.delete();
+        }
+    }
+}
+/** Replaces string forward references by the types they name. */
+function expandStrings(ctx, expression) {
+    return expression.kind === 'str'
+        ? typeFromString(ctx, expression.value)
+        : expression;
+}
+function renderType(expression) {
+    switch (expression.kind) {
+        case 'name':
+            return expression.name;
+        case 'sub':
+            return `${expression.base}[${expression.args.map(renderType).join(',')}]`;
+        case 'union':
+            return expression.members.map(renderType).join('|');
+        case 'str':
+            return expression.value;
+        case 'none':
+            return 'None';
+        case 'value':
+            return valueText(expression.value);
+        case 'other':
+            return expression.text;
+    }
+}
+function normalizeTypeText(text) {
+    return text.replace(/\s+/g, '').replace(/\b\w+\./g, '');
+}
+/** Unwraps Mapped[...], Optional[...], `X | None`, Annotated[...] and aliases. */
+function peelType(ctx, expression, depth = 0) {
+    const result = {
+        core: expression ?? { kind: 'other', text: '' },
+        optional: false,
+        mapped: false,
+        metadata: [],
+    };
+    if (expression === undefined) {
+        return result;
+    }
+    let current = expandStrings(ctx, expression);
+    for (let step = 0; step < MAX_ALIAS_DEPTH + 8; step += 1) {
+        if (depth > MAX_ALIAS_DEPTH) {
+            break;
+        }
+        if (current.kind === 'sub') {
+            const base = lastSegment(current.base);
+            const first = current.args[0];
+            if ((base === 'Mapped' ||
+                base === 'WriteOnlyMapped' ||
+                base === 'DynamicMapped') &&
+                first !== undefined) {
+                result.mapped = true;
+                current = expandStrings(ctx, first);
+                continue;
+            }
+            if (base === 'Optional' && first !== undefined) {
+                result.optional = true;
+                current = expandStrings(ctx, first);
+                continue;
+            }
+            if (base === 'Union') {
+                const members = current.args.map((arg) => expandStrings(ctx, arg));
+                const rest = members.filter((member) => member.kind !== 'none');
+                if (rest.length < members.length) {
+                    result.optional = true;
+                }
+                if (rest.length === 1 && rest[0] !== undefined) {
+                    current = rest[0];
+                    continue;
+                }
+                break;
+            }
+            if (base === 'Annotated' && first !== undefined) {
+                for (const extra of current.args.slice(1)) {
+                    if (extra.kind === 'value' && extra.value.kind === 'call') {
+                        result.metadata.push(extra.value);
+                    }
+                }
+                current = expandStrings(ctx, first);
+                continue;
+            }
+            break;
+        }
+        if (current.kind === 'union') {
+            const rest = current.members
+                .map((member) => expandStrings(ctx, member))
+                .filter((member) => member.kind !== 'none');
+            if (rest.length < current.members.length) {
+                result.optional = true;
+            }
+            if (rest.length === 1 && rest[0] !== undefined) {
+                current = rest[0];
+                continue;
+            }
+            break;
+        }
+        if (current.kind === 'name') {
+            const alias = ctx.aliases.get(current.name);
+            if (alias !== undefined) {
+                const inner = peelType(ctx, alias, depth + 1);
+                result.optional = result.optional || inner.optional;
+                result.mapped = result.mapped || inner.mapped;
+                result.metadata.unshift(...inner.metadata);
+                current = inner.core;
+            }
+        }
+        break;
+    }
+    result.core = current;
+    return result;
+}
+/** The class name a relationship annotation points at, and whether it is a collection. */
+function relationshipAnnotation(ctx, annotation) {
+    if (annotation === undefined) {
+        return { target: undefined, collection: undefined };
+    }
+    let peeled = peelType(ctx, annotation);
+    let collection = false;
+    for (let step = 0; step < 4; step += 1) {
+        const core = peeled.core;
+        if (core.kind === 'sub' &&
+            COLLECTION_TYPES.has(lastSegment(core.base).toLowerCase())) {
+            collection = true;
+            const element = core.args[core.args.length - 1] ?? core.args[0];
+            peeled = peelType(ctx, element);
+            continue;
+        }
+        break;
+    }
+    const core = peeled.core;
+    if (core.kind === 'name') {
+        if (COLLECTION_TYPES.has(lastSegment(core.name).toLowerCase())) {
+            return { target: undefined, collection: true };
+        }
+        return { target: lastSegment(core.name), collection };
+    }
+    return { target: undefined, collection };
+}
+// ---------------------------------------------------------------------------
+// Inheritance and model detection
+// ---------------------------------------------------------------------------
+function resolveBase(ctx, baseName) {
+    return ctx.classes.get(lastSegment(baseName));
+}
+function isEnumClass(ctx, cls, depth = 0) {
+    const memo = ctx.enumClassMemo.get(cls.name);
+    if (memo !== undefined) {
+        return memo;
+    }
+    if (depth > MAX_INHERITANCE_DEPTH) {
+        return false;
+    }
+    let result = false;
+    for (const base of cls.bases) {
+        if (ENUM_BASE_NAMES.has(lastSegment(base))) {
+            result = true;
+            break;
+        }
+        const parent = resolveBase(ctx, base);
+        if (parent !== undefined &&
+            parent !== cls &&
+            isEnumClass(ctx, parent, depth + 1)) {
+            result = true;
+            break;
+        }
+    }
+    ctx.enumClassMemo.set(cls.name, result);
+    return result;
+}
+/** True when the class derives from a declarative base, SQLModel or Flask-SQLAlchemy's db.Model. */
+function derivesFrom(ctx, cls, predicate, visiting = new Set()) {
+    if (visiting.has(cls.name) || visiting.size > MAX_INHERITANCE_DEPTH) {
+        return false;
+    }
+    visiting.add(cls.name);
+    for (const base of cls.bases) {
+        if (predicate(base)) {
+            return true;
+        }
+        const parent = resolveBase(ctx, base);
+        if (parent !== undefined && derivesFrom(ctx, parent, predicate, visiting)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isSqlModelBase(baseName) {
+    return lastSegment(baseName) === 'SQLModel';
+}
+function isFlaskModelBase(baseName) {
+    return /^db\.Model$/.test(baseName);
+}
+function isDeclarativeBase(ctx, baseName) {
+    return (ROOT_BASE_NAMES.has(lastSegment(baseName)) ||
+        ctx.baseVars.has(baseName) ||
+        isSqlModelBase(baseName) ||
+        isFlaskModelBase(baseName));
+}
+/** A class declared directly on DeclarativeBase is the base itself, never a model. */
+function isRootClass(cls) {
+    return cls.bases.some((base) => ROOT_BASE_NAMES.has(lastSegment(base)));
+}
+function inheritedRule(ctx, cls, visiting = new Set()) {
+    if (cls.tableNameRule !== undefined) {
+        return cls.tableNameRule;
+    }
+    if (visiting.has(cls.name) || visiting.size > MAX_INHERITANCE_DEPTH) {
+        return undefined;
+    }
+    visiting.add(cls.name);
+    for (const base of cls.bases) {
+        const parent = resolveBase(ctx, base);
+        if (parent !== undefined) {
+            const rule = inheritedRule(ctx, parent, visiting);
+            if (rule !== undefined) {
+                return rule;
+            }
+        }
+    }
+    return undefined;
+}
+function hasAnyColumns(cls) {
+    return cls.members.length > 0;
+}
+/** Decides how a class maps to a table: its name, or undefined when it is not a model. */
+function tableNameOf(ctx, cls) {
+    if (cls.isAbstract || isEnumClass(ctx, cls) || isRootClass(cls)) {
+        return undefined;
+    }
+    if (cls.keywords['table'] !== undefined) {
+        return boolOf(cls.keywords['table']) === true
+            ? (cls.tableName ?? cls.name.toLowerCase())
+            : undefined;
+    }
+    if (derivesFrom(ctx, cls, isSqlModelBase)) {
+        // A SQLModel class without table=True is a plain data model (a base for table classes).
+        return undefined;
+    }
+    if (cls.tableName !== undefined) {
+        return cls.tableName;
+    }
+    if (cls.tableExpr !== undefined) {
+        return stringOf(cls.tableExpr.args[0]) ?? toSnakeCase(cls.name);
+    }
+    const rule = inheritedRule(ctx, cls);
+    if (rule !== undefined &&
+        derivesFrom(ctx, cls, (base) => isDeclarativeBase(ctx, base)) &&
+        hasAnyColumns(cls)) {
+        return rule === 'lower'
+            ? cls.name.toLowerCase()
+            : rule === 'exact'
+                ? cls.name
+                : toSnakeCase(cls.name);
+    }
+    if (derivesFrom(ctx, cls, isFlaskModelBase) && hasAnyColumns(cls)) {
+        return toSnakeCase(cls.name);
+    }
+    return undefined;
+}
+/** Collects the members of a class and of the mixins and abstract bases it inherits from. */
+function gatherMembers(ctx, cls, gathered, depth) {
+    if (depth > MAX_INHERITANCE_DEPTH || gathered.seen.has(cls.name)) {
+        return;
+    }
+    gathered.seen.add(cls.name);
+    for (const base of cls.bases) {
+        const parent = resolveBase(ctx, base);
+        if (parent === undefined || parent === cls) {
+            continue;
+        }
+        // A concrete table is a parent in joined inheritance: its columns live in its own table.
+        if (tableNameOf(ctx, parent) !== undefined) {
+            continue;
+        }
+        gatherMembers(ctx, parent, gathered, depth + 1);
+    }
+    for (const member of cls.members) {
+        gathered.members.delete(member.name);
+        gathered.members.set(member.name, member);
+    }
+    if (cls.tableArgs !== undefined) {
+        gathered.tableArgs = cls.tableArgs;
+    }
+}
+// ---------------------------------------------------------------------------
+// Building tables
+// ---------------------------------------------------------------------------
+function newTable(ctx, init) {
+    const table = {
+        columns: [],
+        columnIndex: new Map(),
+        fks: [],
+        indexes: [],
+        rels: [],
+        m2m: [],
+        consumed: false,
+        order: ctx.counter,
+        ...init,
+    };
+    ctx.counter += 1;
+    return table;
+}
+function buildTables(ctx) {
+    const imperativeByTable = new Map();
+    for (const mapping of ctx.imperative) {
+        imperativeByTable.set(mapping.tableVar, mapping.className);
+        if (mapping.hasProperties) {
+            warn(ctx, `${mapping.className}: the properties of map_imperatively(...) (relationships, column overrides) are not read.`);
+        }
+    }
+    for (const cls of ctx.classList) {
+        const tableName = tableNameOf(ctx, cls);
+        const parentModel = cls.bases
+            .map((base) => resolveBase(ctx, base))
+            .find((parent) => parent !== undefined &&
+            parent !== cls &&
+            tableNameOf(ctx, parent) !== undefined);
+        if (tableName === undefined) {
+            if (parentModel !== undefined &&
+                !cls.isAbstract &&
+                !isEnumClass(ctx, cls) &&
+                !derivesFrom(ctx, cls, isSqlModelBase) &&
+                cls.members.some((member) => memberLooksMapped(ctx, member))) {
+                warn(ctx, `${cls.name}: single-table inheritance from ${parentModel.name} is not supported; the subclass was skipped.`);
+            }
+            continue;
+        }
+        // Flask-SQLAlchemy and similar: a subclass of a concrete model with no table of its own.
+        if (parentModel !== undefined &&
+            cls.tableName === undefined &&
+            cls.tableExpr === undefined &&
+            cls.keywords['table'] === undefined &&
+            inheritedRule(ctx, cls) === undefined) {
+            warn(ctx, `${cls.name}: single-table inheritance from ${parentModel.name} is not supported; the subclass was skipped.`);
+            continue;
+        }
+        const table = newTable(ctx, {
+            modelName: cls.name,
+            tableName,
+            label: cls.name,
+            cls,
+        });
+        buildClassTable(ctx, table, cls);
+        ctx.byModel.set(cls.name, table);
+        ctx.tables.push(table);
+    }
+    // Module-level Table(...) objects: association tables, imperative mappings or plain tables.
+    for (const definition of ctx.tableDefs) {
+        const tableName = stringOf(definition.call.args[0]);
+        if (tableName === undefined) {
+            warn(ctx, `${definition.varName}: the name of the Table is not a string literal; it was skipped.`);
+            continue;
+        }
+        const mappedClass = imperativeByTable.get(definition.varName);
+        const table = newTable(ctx, {
+            modelName: mappedClass ?? toPascalCase(singularize(toSnakeCase(tableName))),
+            tableName,
+            label: mappedClass ?? tableName,
+            varName: definition.varName,
+        });
+        const schema = stringOf(definition.call.kwargs['schema']);
+        if (schema !== undefined) {
+            table.schema = schema;
+        }
+        buildFromTableCall(ctx, table, definition.call);
+        ctx.byVar.set(definition.varName, table);
+        ctx.tables.push(table);
+        if (!ctx.byModel.has(table.modelName)) {
+            ctx.byModel.set(table.modelName, table);
+        }
+    }
+    for (const table of ctx.tables) {
+        const same = ctx.tablesByName.get(table.tableName) ?? [];
+        same.push(table);
+        ctx.tablesByName.set(table.tableName, same);
+    }
+}
+/** True when a class member declares a column or relationship (so a table-less subclass is worth a warning). */
+function memberLooksMapped(ctx, member) {
+    if (member.value !== undefined && member.value.kind === 'call') {
+        const lowered = lowerCallee(member.value);
+        return (lowered === 'mapped_column' ||
+            lowered === 'column' ||
+            lowered === 'relationship');
+    }
+    return (member.annotation !== undefined && peelType(ctx, member.annotation).mapped);
+}
+function buildFromTableCall(ctx, table, call) {
+    const rest = call.args.slice(2);
+    for (const item of rest) {
+        if (item.kind !== 'call') {
+            continue;
+        }
+        const callee = lastSegment(item.callee);
+        if (callee === 'Column') {
+            const spec = specFromCall(item);
+            addColumn(ctx, table, spec.columnName ?? '', spec, undefined, 'classic');
+        }
+    }
+    for (const item of rest) {
+        if (item.kind === 'call' && lastSegment(item.callee) !== 'Column') {
+            applyTableItem(ctx, table, item);
+        }
+    }
+    if (call.kwargs['autoload_with'] !== undefined) {
+        warn(ctx, `${table.label}: the Table is reflected from a database (autoload_with); no columns are known.`);
+    }
+}
+function buildClassTable(ctx, table, cls) {
+    const gathered = {
+        members: new Map(),
+        tableArgs: undefined,
+        seen: new Set(),
+    };
+    gatherMembers(ctx, cls, gathered, 0);
+    const isSqlModel = derivesFrom(ctx, cls, isSqlModelBase);
+    const defaultSchema = inheritedSchema(ctx, cls);
+    if (defaultSchema !== undefined) {
+        table.schema = defaultSchema;
+    }
+    if (cls.tableExpr !== undefined) {
+        buildFromTableCall(ctx, table, cls.tableExpr);
+        const schema = stringOf(cls.tableExpr.kwargs['schema']);
+        if (schema !== undefined) {
+            table.schema = schema;
+        }
+    }
+    for (const member of gathered.members.values()) {
+        readMember(ctx, table, member, isSqlModel);
+    }
+    if (gathered.tableArgs !== undefined) {
+        for (const item of gathered.tableArgs) {
+            if (item.kind === 'dict') {
+                for (const entry of item.entries) {
+                    if (stringOf(entry.key) === 'schema') {
+                        const schema = stringOf(entry.value);
+                        if (schema !== undefined) {
+                            table.schema = schema;
+                        }
+                    }
+                }
+            }
+            else if (item.kind === 'call') {
+                applyTableItem(ctx, table, item);
+            }
+            else if (item.kind !== 'string') {
+                warn(ctx, `${table.label}.__table_args__: an entry that is not a constraint, index or dict was ignored.`);
+            }
+        }
+    }
+}
+/** The schema of the MetaData a class's base was created with. */
+function inheritedSchema(ctx, cls, visiting = new Set()) {
+    if (cls.metadataSchema !== undefined) {
+        return cls.metadataSchema;
+    }
+    if (visiting.has(cls.name) || visiting.size > MAX_INHERITANCE_DEPTH) {
+        return undefined;
+    }
+    visiting.add(cls.name);
+    for (const base of cls.bases) {
+        const fromVar = ctx.baseVarSchemas.get(base);
+        if (fromVar !== undefined) {
+            return fromVar;
+        }
+        const parent = resolveBase(ctx, base);
+        if (parent !== undefined) {
+            const schema = inheritedSchema(ctx, parent, visiting);
+            if (schema !== undefined) {
+                return schema;
+            }
+        }
+    }
+    return undefined;
+}
+function lowerCallee(call) {
+    return lastSegment(call.callee).toLowerCase();
+}
+function readMember(ctx, table, member, isSqlModel) {
+    const location = `${table.label}.${member.name}`;
+    const value = member.value;
+    if (value !== undefined && value.kind === 'call') {
+        const callee = lastSegment(value.callee);
+        const lowered = callee.toLowerCase();
+        if (lowered === 'relationship' || callee === 'Relationship') {
+            addRelationship(ctx, table, member, value);
+            return;
+        }
+        if (UNSUPPORTED_ATTRIBUTES.has(callee)) {
+            warn(ctx, `${location}: ${callee}(...) is not supported and was skipped.`);
+            return;
+        }
+        if (IGNORED_ATTRIBUTES.has(callee)) {
+            return;
+        }
+        if (lowered === 'mapped_column' || lowered === 'column') {
+            const spec = mergeAnnotationSpec(ctx, specFromCall(value), member.annotation);
+            addColumn(ctx, table, member.name, spec, member.annotation, lowered === 'column' ? 'classic' : 'mapped');
+            return;
+        }
+        if (callee === 'Field') {
+            addSqlModelField(ctx, table, member, value);
+            return;
+        }
+        if (member.annotation !== undefined && isSqlModel) {
+            // SQLModel field with a default produced by a call: `created: datetime = datetime.utcnow()`.
+            addColumn(ctx, table, member.name, mergeAnnotationSpec(ctx, { foreignKeys: [], default: value }, member.annotation), member.annotation, 'sqlmodel');
+            return;
+        }
+        if (member.annotation !== undefined) {
+            const peeled = peelType(ctx, member.annotation);
+            if (peeled.mapped) {
+                warn(ctx, `${location}: ${callee}(...) is not a column or relationship constructor ormbridge reads; the attribute was skipped.`);
+            }
+        }
+        return;
+    }
+    if (member.annotation === undefined) {
+        return;
+    }
+    const peeled = peelType(ctx, member.annotation);
+    if (peeled.mapped) {
+        // `name: Mapped[int]` with no mapped_column(...): a plain column.
+        addColumn(ctx, table, member.name, mergeAnnotationSpec(ctx, { foreignKeys: [] }, member.annotation), member.annotation, 'mapped');
+        return;
+    }
+    if (isSqlModel) {
+        if (/^ClassVar/.test(renderType(member.annotation)) ||
+            isModelReference(ctx, member.annotation)) {
+            return;
+        }
+        const spec = mergeAnnotationSpec(ctx, value === undefined
+            ? { foreignKeys: [] }
+            : { foreignKeys: [], default: value }, member.annotation);
+        addColumn(ctx, table, member.name, spec, member.annotation, 'sqlmodel');
+    }
+}
+/** True when an annotation names another model class (a SQLModel relationship type). */
+function isModelReference(ctx, annotation) {
+    const target = relationshipAnnotation(ctx, annotation).target;
+    if (target === undefined) {
+        return false;
+    }
+    const cls = ctx.classes.get(target);
+    return cls !== undefined && !isEnumClass(ctx, cls);
+}
+// ---------------------------------------------------------------------------
+// Column specifications
+// ---------------------------------------------------------------------------
+function mergeSpecs(base, over) {
+    const merged = {
+        ...base,
+        foreignKeys: [...base.foreignKeys, ...over.foreignKeys],
+    };
+    for (const [key, value] of Object.entries(over)) {
+        if (key !== 'foreignKeys' && value !== undefined) {
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+/** Adds the mapped_column(...) calls found in Annotated[...] aliases beneath the column's own arguments. */
+function mergeAnnotationSpec(ctx, spec, annotation) {
+    const peeled = peelType(ctx, annotation);
+    let merged = { foreignKeys: [] };
+    for (const call of peeled.metadata) {
+        const lowered = lowerCallee(call);
+        if (lowered === 'mapped_column' || lowered === 'column') {
+            merged = mergeSpecs(merged, specFromCall(call));
+        }
+    }
+    return mergeSpecs(merged, spec);
+}
+function specFromCall(call) {
+    const spec = { foreignKeys: [] };
+    call.args.forEach((argument, index) => {
+        if (argument.kind === 'string') {
+            if (index === 0) {
+                spec.columnName = argument.value;
+            }
+            return;
+        }
+        if (argument.kind === 'call') {
+            const lowered = lowerCallee(argument);
+            if (lowered === 'foreignkey') {
+                spec.foreignKeys.push(argument);
+                return;
+            }
+            if (lowered === 'identity' || lowered === 'sequence') {
+                spec.identity = true;
+                return;
+            }
+            if (lowered === 'computed') {
+                spec.computed = argument;
+                return;
+            }
+            if (lowered === 'checkconstraint') {
+                spec.hasCheck = true;
+                return;
+            }
+            if (NON_TYPE_CALLS.has(lowered)) {
+                return;
+            }
+        }
+        if ((argument.kind === 'call' || argument.kind === 'name') &&
+            spec.typeValue === undefined) {
+            spec.typeValue = argument;
+        }
+    });
+    const kwargs = call.kwargs;
+    const name = stringOf(kwargs['name']);
+    if (name !== undefined) {
+        spec.columnName = name;
+    }
+    if (kwargs['type_'] !== undefined) {
+        spec.typeValue = kwargs['type_'];
+    }
+    const flags = [
+        ['primaryKey', 'primary_key'],
+        ['nullable', 'nullable'],
+        ['unique', 'unique'],
+        ['index', 'index'],
+    ];
+    for (const [target, key] of flags) {
+        const flag = boolOf(kwargs[key]);
+        if (flag !== undefined) {
+            spec[target] = flag;
+        }
+    }
+    const autoincrement = kwargs['autoincrement'];
+    if (autoincrement !== undefined) {
+        spec.autoincrement = boolOf(autoincrement) ?? true;
+    }
+    spec.default = kwargs['default'] ?? kwargs['insert_default'];
+    if (kwargs['default_factory'] !== undefined) {
+        spec.default = kwargs['default_factory'];
+    }
+    spec.serverDefault = kwargs['server_default'];
+    spec.onUpdate = kwargs['onupdate'];
+    return stripUndefined(spec);
+}
+function stripUndefined(value) {
+    const cleaned = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (entry !== undefined) {
+            cleaned[key] = entry;
+        }
+    }
+    return cleaned;
+}
+function addSqlModelField(ctx, table, member, call) {
+    const kwargs = call.kwargs;
+    let spec = { foreignKeys: [] };
+    const flags = [
+        ['primaryKey', 'primary_key'],
+        ['nullable', 'nullable'],
+        ['unique', 'unique'],
+        ['index', 'index'],
+    ];
+    for (const [target, key] of flags) {
+        const flag = boolOf(kwargs[key]);
+        if (flag !== undefined) {
+            spec[target] = flag;
+        }
+    }
+    const maxLength = numberOf(kwargs['max_length']);
+    if (maxLength !== undefined) {
+        spec.maxLength = maxLength;
+    }
+    const maxDigits = numberOf(kwargs['max_digits']);
+    if (maxDigits !== undefined) {
+        spec.maxDigits = maxDigits;
+    }
+    const decimalPlaces = numberOf(kwargs['decimal_places']);
+    if (decimalPlaces !== undefined) {
+        spec.decimalPlaces = decimalPlaces;
+    }
+    if (kwargs['foreign_key'] !== undefined) {
+        spec.foreignKeyString = kwargs['foreign_key'];
+    }
+    if (kwargs['ondelete'] !== undefined) {
+        spec.foreignKeyOnDelete = kwargs['ondelete'];
+    }
+    spec.default = kwargs['default'] ?? kwargs['default_factory'];
+    if (kwargs['default_factory'] !== undefined) {
+        spec.default = kwargs['default_factory'];
+    }
+    if (kwargs['sa_type'] !== undefined) {
+        spec.typeValue = kwargs['sa_type'];
+    }
+    const columnKwargs = kwargs['sa_column_kwargs'];
+    if (columnKwargs !== undefined && columnKwargs.kind === 'dict') {
+        const extra = {};
+        for (const entry of columnKwargs.entries) {
+            const key = stringOf(entry.key);
+            if (key !== undefined) {
+                extra[key] = entry.value;
+            }
+        }
+        spec = mergeSpecs(spec, specFromCall({
+            kind: 'call',
+            callee: 'Column',
+            args: [],
+            kwargs: extra,
+            text: '',
+        }));
+    }
+    const columnArgs = kwargs['sa_column_args'];
+    if (columnArgs !== undefined && columnArgs.kind === 'list') {
+        spec = mergeSpecs(spec, specFromCall({
+            kind: 'call',
+            callee: 'Column',
+            args: columnArgs.items,
+            kwargs: {},
+            text: '',
+        }));
+    }
+    const saColumn = kwargs['sa_column'];
+    if (saColumn !== undefined) {
+        if (saColumn.kind === 'call') {
+            // SQLModel uses the Column as it is: the other Field arguments only describe the pydantic field.
+            spec = mergeSpecs({
+                foreignKeys: [],
+                ...(spec.maxLength === undefined
+                    ? {}
+                    : { maxLength: spec.maxLength }),
+                rawColumn: true,
+            }, specFromCall(saColumn));
+        }
+        else {
+            warn(ctx, `${table.label}.${member.name}: sa_column could not be evaluated; the Field arguments were used.`);
+        }
+    }
+    addColumn(ctx, table, member.name, mergeAnnotationSpec(ctx, spec, member.annotation), member.annotation, 'sqlmodel');
+}
+function addColumn(ctx, table, key, spec, annotation, style) {
+    if (key === '') {
+        warn(ctx, `${table.label}: a Column without a name was skipped (the first argument of Column(...) in a Table must be the column name).`);
+        return;
+    }
+    const location = `${table.label}.${key}`;
+    const peeled = peelType(ctx, annotation);
+    if (spec.hasCheck === true) {
+        warn(ctx, `${location}: a CheckConstraint on the column was ignored (check constraints are not part of the shared model).`);
+    }
+    const inferFromForeignKey = spec.typeValue === undefined &&
+        annotation === undefined &&
+        (spec.foreignKeys.length > 0 || spec.foreignKeyString !== undefined);
+    const resolved = inferFromForeignKey
+        ? { type: 'int' }
+        : resolveColumnType(ctx, spec, peeled, table, key, location);
+    const isPrimary = spec.primaryKey === true;
+    const isNullable = isPrimary
+        ? false
+        : (spec.nullable ??
+            (spec.rawColumn !== true && (peeled.mapped || style === 'sqlmodel')
+                ? peeled.optional
+                : true));
+    const field = {
+        name: key,
+        columnName: spec.columnName ?? key,
+        type: resolved.type,
+        isPrimaryKey: isPrimary,
+        isUnique: spec.unique === true,
+        isNullable,
+        isAutoUpdated: false,
+    };
+    if (resolved.maxLength !== undefined) {
+        field.maxLength = resolved.maxLength;
+    }
+    if (resolved.maxDigits !== undefined) {
+        field.maxDigits = resolved.maxDigits;
+    }
+    if (resolved.decimalPlaces !== undefined) {
+        field.decimalPlaces = resolved.decimalPlaces;
+    }
+    if (resolved.enumName !== undefined) {
+        field.enumName = resolved.enumName;
+    }
+    if (resolved.arrayDepth !== undefined) {
+        field.arrayDepth = resolved.arrayDepth;
+    }
+    if (resolved.rangeOf !== undefined) {
+        field.rangeOf = resolved.rangeOf;
+    }
+    if (resolved.unsupportedType !== undefined) {
+        field.unsupportedType = resolved.unsupportedType;
+    }
+    if (spec.maxLength !== undefined && field.maxLength === undefined) {
+        field.maxLength = spec.maxLength;
+    }
+    if (spec.maxDigits !== undefined && field.maxDigits === undefined) {
+        field.maxDigits = spec.maxDigits;
+    }
+    if (spec.decimalPlaces !== undefined && field.decimalPlaces === undefined) {
+        field.decimalPlaces = spec.decimalPlaces;
+    }
+    if (spec.computed !== undefined) {
+        const expression = spec.computed.args[0];
+        field.generated = {
+            expression: expression === undefined ? '' : valueText(expression) || '',
+            isStored: boolOf(spec.computed.kwargs['persisted']) === true,
+        };
+    }
+    applyDefaults(ctx, field, spec, resolved, location);
+    const column = {
+        key,
+        field,
+        ...(inferFromForeignKey ? { inferFromForeignKey: true } : {}),
+        wantsAutoIncrement: spec.identity === true ||
+            spec.autoincrement === true ||
+            (spec.autoincrement !== false &&
+                (resolved.type === 'int' || resolved.type === 'bigInt') &&
+                resolved.arrayDepth === undefined),
+    };
+    if (spec.identity === true || spec.autoincrement === true) {
+        column.wantsAutoIncrement = true;
+        field.default ??= { kind: 'autoIncrement' };
+    }
+    const existing = table.columnIndex.get(key);
+    if (existing !== undefined) {
+        table.columns[existing] = column;
+    }
+    else if (table.columns.length >= MAX_COLUMNS_PER_TABLE) {
+        if (table.capped !== true) {
+            table.capped = true;
+            warn(ctx, `${table.label}: more than ${MAX_COLUMNS_PER_TABLE} columns; the rest were skipped.`);
+        }
+        return;
+    }
+    else {
+        table.columnIndex.set(key, table.columns.length);
+        table.columns.push(column);
+    }
+    // Foreign keys.
+    const foreignKeyCalls = spec.foreignKeys;
+    if (foreignKeyCalls.length > 1) {
+        warn(ctx, `${location}: several ForeignKey(...) arguments on one column; only the first was kept.`);
+    }
+    const first = foreignKeyCalls[0];
+    if (first !== undefined) {
+        addColumnForeignKey(ctx, table, key, first, location);
+    }
+    else if (spec.foreignKeyString !== undefined) {
+        const target = parseFkTarget(ctx, spec.foreignKeyString, table);
+        if (target === undefined) {
+            warn(ctx, `${location}: foreign_key could not be evaluated; the column is kept without a foreign key.`);
+        }
+        else {
+            table.fks.push({
+                columns: [key],
+                target,
+                onDelete: actionOf(ctx, spec.foreignKeyOnDelete, location, 'ondelete'),
+                onUpdate: undefined,
+                name: undefined,
+            });
+        }
+    }
+    if (spec.index === true && spec.unique !== true) {
+        table.indexes.push({
+            columns: [key],
+            isUnique: false,
+            name: undefined,
+            method: undefined,
+            fieldOptions: {},
+        });
+    }
+}
+function addColumnForeignKey(ctx, table, key, call, location) {
+    const targetArgument = call.args[0] ?? call.kwargs['column'];
+    const target = targetArgument === undefined
+        ? undefined
+        : parseFkTarget(ctx, targetArgument, table);
+    if (target === undefined) {
+        warn(ctx, `${location}: the target of ForeignKey(...) could not be evaluated; the column is kept without a foreign key.`);
+        return;
+    }
+    table.fks.push({
+        columns: [key],
+        target,
+        onDelete: actionOf(ctx, call.kwargs['ondelete'], location, 'ondelete'),
+        onUpdate: actionOf(ctx, call.kwargs['onupdate'], location, 'onupdate'),
+        name: stringOf(call.kwargs['name']),
+    });
+}
+function actionOf(ctx, value, location, label) {
+    const text = stringOf(value);
+    if (text === undefined) {
+        return undefined;
+    }
+    const mapped = ON_ACTION_MAP[text.trim().toUpperCase().replace(/_/g, ' ')];
+    if (mapped === undefined) {
+        warn(ctx, `${location}: ${label}="${text}" has no equivalent and was converted to NO ACTION.`);
+        return 'noAction';
+    }
+    return mapped;
+}
+/** Reads the target of ForeignKey("table.column"), ForeignKey(Model.column) or ForeignKey(table.c.column). */
+function parseFkTarget(ctx, value, owner) {
+    if (value.kind === 'string') {
+        const parts = value.value
+            .split('.')
+            .map((part) => part.trim());
+        if (parts.length === 0 || parts.some((part) => part === '')) {
+            return undefined;
+        }
+        if (parts.length === 1) {
+            return { table: parts[0], columns: [] };
+        }
+        if (parts.length === 2) {
+            return { table: parts[0], columns: [parts[1]] };
+        }
+        const column = parts[parts.length - 1];
+        const tableName = parts[parts.length - 2];
+        return {
+            schema: parts.slice(0, -2).join('.'),
+            table: tableName,
+            columns: [column],
+        };
+    }
+    if (value.kind === 'name') {
+        const parts = value.value
+            .split('.')
+            .filter((part) => part !== '__table__' && part !== 'c');
+        if (parts.length !== 2) {
+            return undefined;
+        }
+        const holder = parts[0];
+        const column = parts[1];
+        const viaClass = ctx.classes.get(holder);
+        if (viaClass !== undefined) {
+            const name = tableNameOf(ctx, viaClass);
+            const columnName = attributeColumnName(viaClass, column);
+            return name === undefined
+                ? undefined
+                : { table: name, columns: [columnName] };
+        }
+        const viaVar = ctx.tableDefByVar.get(holder);
+        const varTable = stringOf(viaVar?.args[0]);
+        if (varTable !== undefined) {
+            return { table: varTable, columns: [column] };
+        }
+        if (holder === owner.modelName) {
+            return { table: owner.tableName, columns: [column] };
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/** The database column name of an attribute of a class (mapped_column("name") overrides the attribute name). */
+function attributeColumnName(cls, attribute) {
+    const member = cls.members.find((candidate) => candidate.name === attribute);
+    if (member !== undefined &&
+        member.value !== undefined &&
+        member.value.kind === 'call') {
+        const explicit = stringOf(member.value.args[0]) ?? stringOf(member.value.kwargs['name']);
+        if (explicit !== undefined) {
+            return explicit;
+        }
+    }
+    return attribute;
+}
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+function resolveColumnType(ctx, spec, peeled, table, key, location) {
+    if (spec.typeValue !== undefined) {
+        return resolveSaType(ctx, spec.typeValue, table, key, location, 0);
+    }
+    return resolvePythonType(ctx, peeled, table, key, location);
+}
+function typeNameOf(value) {
+    if (value.kind === 'call') {
+        return lastSegment(value.callee);
+    }
+    if (value.kind === 'name') {
+        return lastSegment(value.value);
+    }
+    return undefined;
+}
+function resolveSaType(ctx, value, table, key, location, depth) {
+    const name = typeNameOf(value);
+    if (name === undefined || depth > MAX_ALIAS_DEPTH) {
+        warn(ctx, `${location}: the column type could not be evaluated.`);
+        return { type: 'unsupported', unsupportedType: valueText(value) };
+    }
+    const args = value.kind === 'call' ? value.args : [];
+    const kwargs = value.kind === 'call' ? value.kwargs : {};
+    const lowered = name.toLowerCase();
+    if (lowered === 'enum') {
+        return resolveEnumType(ctx, args, kwargs, table, key, location);
+    }
+    if (lowered === 'array') {
+        const inner = args[0];
+        if (inner === undefined) {
+            warn(ctx, `${location}: ARRAY(...) has no item type.`);
+            return { type: 'unsupported', unsupportedType: 'ARRAY' };
+        }
+        const element = resolveSaType(ctx, inner, table, key, location, depth + 1);
+        const dimensions = numberOf(kwargs['dimensions']) ?? 1;
+        return {
+            ...element,
+            arrayDepth: (element.arrayDepth ?? 0) + Math.max(1, Math.floor(dimensions)),
+        };
+    }
+    const decorator = ctx.classes.get(name);
+    if (decorator !== undefined) {
+        if (decorator.impl !== undefined) {
+            return resolveSaType(ctx, decorator.impl, table, key, location, depth + 1);
+        }
+        if (isEnumClass(ctx, decorator)) {
+            return resolveEnumType(ctx, [value], kwargs, table, key, location);
+        }
+    }
+    const spec = SA_TYPES[lowered];
+    if (spec === undefined) {
+        warn(ctx, `${location}: the column type ${name} is not known; the column was kept as an unsupported type.`);
+        return {
+            type: 'unsupported',
+            unsupportedType: describeTypeCall(value, name),
+        };
+    }
+    const resolved = { type: spec.type };
+    if (spec.rangeOf !== undefined) {
+        resolved.rangeOf = spec.rangeOf;
+    }
+    if (spec.length === true) {
+        const length = numberOf(args[0]) ?? numberOf(kwargs['length']);
+        if (length !== undefined) {
+            resolved.maxLength = length;
+        }
+    }
+    if (spec.numeric === true) {
+        const precision = numberOf(args[0]) ?? numberOf(kwargs['precision']);
+        const scale = numberOf(args[1]) ?? numberOf(kwargs['scale']);
+        if (precision !== undefined) {
+            resolved.maxDigits = precision;
+        }
+        if (scale !== undefined) {
+            resolved.decimalPlaces = scale;
+        }
+    }
+    return resolved;
+}
+/** `Geometry("POINT")` -> `Geometry(POINT)`: the database type text without quotes. */
+function describeTypeCall(value, name) {
+    if (value.kind !== 'call' || value.args.length === 0) {
+        return name;
+    }
+    const parts = value.args.map((argument) => argument.kind === 'string' ? argument.value : valueText(argument));
+    return `${name}(${parts.join(', ').replace(/["\\]/g, '')})`.slice(0, 100);
+}
+function resolvePythonType(ctx, peeled, table, key, location) {
+    const core = peeled.core;
+    const mapped = ctx.typeMap.get(normalizeTypeText(renderType(core)));
+    if (mapped !== undefined) {
+        return resolveSaType(ctx, mapped, table, key, location, 1);
+    }
+    if (core.kind === 'sub' && lastSegment(core.base) === 'Literal') {
+        const literals = core.args.flatMap((arg) => arg.kind === 'str' ? [{ kind: 'string', value: arg.value }] : []);
+        if (literals.length > 0 && literals.length === core.args.length) {
+            return resolveEnumType(ctx, literals, {}, table, key, location);
+        }
+    }
+    if (core.kind === 'name') {
+        const name = lastSegment(core.name);
+        const cls = ctx.classes.get(name);
+        if (cls !== undefined && isEnumClass(ctx, cls)) {
+            return resolveEnumType(ctx, [{ kind: 'name', value: name }], {}, table, key, location);
+        }
+        const spec = PY_TYPES[name];
+        if (spec !== undefined) {
+            return { type: spec.type };
+        }
+        warn(ctx, `${location}: the Python type ${renderType(core)} has no known column type; the column was kept as an unsupported type (give mapped_column a SQLAlchemy type).`);
+        return { type: 'unsupported', unsupportedType: renderType(core) };
+    }
+    const text = renderType(core);
+    if (text === '') {
+        warn(ctx, `${location}: the column has no type.`);
+        return { type: 'unsupported', unsupportedType: 'unknown' };
+    }
+    warn(ctx, `${location}: the type ${text} has no known column type; the column was kept as an unsupported type.`);
+    return { type: 'unsupported', unsupportedType: text.slice(0, 100) };
+}
+function enumMemberName(value, used) {
+    let name = value
+        .replace(/[^A-Za-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toUpperCase();
+    if (name.length === 0 || /^[0-9]/.test(name)) {
+        name = `V_${name}`;
+    }
+    let candidate = name;
+    let suffix = 2;
+    while (used.has(candidate)) {
+        candidate = `${name}_${suffix}`;
+        suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function resolveEnumType(ctx, args, kwargs, table, key, location) {
+    const explicitName = stringOf(kwargs['name']);
+    const valuesCallable = kwargs['values_callable'];
+    const first = args[0];
+    if (first !== undefined && first.kind === 'name') {
+        const cls = ctx.classes.get(lastSegment(first.value));
+        if (cls === undefined || !isEnumClass(ctx, cls)) {
+            warn(ctx, `${location}: the enum ${first.value} is not defined in the input; the column was kept as a string.`);
+            return { type: 'string' };
+        }
+        const useValues = valuesCallable !== undefined &&
+            /\.value\b|\bvalue\b/.test(valueText(valuesCallable));
+        const known = ctx.enumInfos.get(cls.name);
+        if (known !== undefined) {
+            return { type: 'string', enumName: known.name };
+        }
+        const members = enumMembersOf(ctx, cls);
+        const values = members.map((member) => {
+            const raw = member.value;
+            const stored = useValues && raw !== undefined
+                ? raw.kind === 'string'
+                    ? raw.value
+                    : raw.kind === 'number'
+                        ? String(raw.value)
+                        : member.name
+                : member.name;
+            return { name: member.name, dbValue: stored };
+        });
+        return registerEnum(ctx, cls.name, values, explicitName);
+    }
+    const literals = [];
+    for (const argument of args) {
+        if (argument.kind === 'string') {
+            literals.push(argument.value);
+        }
+    }
+    if (literals.length === 0 || literals.length !== args.length) {
+        warn(ctx, `${location}: the enum values could not be evaluated; the column was kept as a string.`);
+        return { type: 'string' };
+    }
+    const enumName = explicitName === undefined
+        ? `${table.modelName}${toPascalCase(key)}`
+        : toPascalCase(explicitName);
+    const used = new Set();
+    const values = literals.map((literal) => ({
+        name: enumMemberName(literal, used),
+        dbValue: literal,
+    }));
+    return registerEnum(ctx, enumName, values, explicitName);
+}
+function enumMembersOf(ctx, cls) {
+    const members = [];
+    const seen = new Set();
+    const visit = (current, depth) => {
+        if (depth > MAX_INHERITANCE_DEPTH) {
+            return;
+        }
+        for (const base of current.bases) {
+            const parent = resolveBase(ctx, base);
+            if (parent !== undefined && parent !== current) {
+                visit(parent, depth + 1);
+            }
+        }
+        for (const member of current.enumMembers) {
+            if (member.name.startsWith('_') ||
+                seen.has(member.name) ||
+                (member.value !== undefined &&
+                    member.value.kind === 'call' &&
+                    lastSegment(member.value.callee) === 'property')) {
+                continue;
+            }
+            seen.add(member.name);
+            members.push(member);
+        }
+    };
+    visit(cls, 0);
+    return members;
+}
+function registerEnum(ctx, name, values, dbName) {
+    const existing = ctx.enumInfos.get(name);
+    if (existing !== undefined) {
+        return { type: 'string', enumName: existing.name };
+    }
+    ctx.enumInfos.set(name, { name, values });
+    ctx.enums.push({
+        name,
+        values,
+        ...(dbName === undefined || dbName === name ? {} : { dbName }),
+    });
+    return { type: 'string', enumName: name };
+}
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+const NOW_CALLABLES = new Set([
+    'now',
+    'utcnow',
+    'today',
+    'datetime.now',
+    'datetime.utcnow',
+    'datetime.datetime.now',
+    'datetime.datetime.utcnow',
+    'date.today',
+    'datetime.date.today',
+    'timezone.now',
+    'func.now',
+    'func.current_timestamp',
+    'func.getdate',
+    'func.localtimestamp',
+    'sa.func.now',
+    'sa.func.current_timestamp',
+    'sqlalchemy.func.now',
+    'sqlalchemy.func.current_timestamp',
+]);
+/** `datetime.utcnow`, `dt.date.today`, `timezone.now` ... */
+const NOW_NAME_PATTERN = /(?:^|\.)(?:now|utcnow|today|current_timestamp|localtimestamp)$/;
+function stripFuncPrefix(text) {
+    return text.replace(/^(?:sa\.|sqlalchemy\.)?func\./, '');
+}
+function applyDefaults(ctx, field, spec, resolved, location) {
+    if (spec.serverDefault !== undefined) {
+        const converted = convertDefault(ctx, spec.serverDefault, field, resolved, true, location);
+        if (converted !== undefined) {
+            field.default = converted;
+            field.isDbDefault = true;
+        }
+    }
+    if (resolved.enumName !== undefined &&
+        field.default !== undefined &&
+        field.default.kind === 'literal' &&
+        typeof field.default.value === 'string') {
+        const member = enumValueFor(ctx, resolved.enumName, field.default.value);
+        if (member !== undefined) {
+            field.default = member;
+        }
+    }
+    if (field.default === undefined && spec.default !== undefined) {
+        const converted = convertDefault(ctx, spec.default, field, resolved, false, location);
+        if (converted !== undefined) {
+            field.default = converted;
+        }
+    }
+    if (spec.onUpdate !== undefined) {
+        const onUpdate = convertDefault(ctx, spec.onUpdate, field, resolved, false, location);
+        if (onUpdate !== undefined && onUpdate.kind === 'now') {
+            field.isAutoUpdated = true;
+            // The timestamp is set on insert and on every update; the default would only repeat that.
+            if (field.default !== undefined && field.default.kind === 'now') {
+                delete field.default;
+                delete field.isDbDefault;
+            }
+        }
+        else {
+            warn(ctx, `${location}: onupdate is only kept for timestamps (func.now() and datetime callables); it was dropped.`);
+        }
+    }
+}
+function enumValueFor(ctx, enumName, stored) {
+    const info = ctx.enumInfos.get(enumName);
+    if (info === undefined) {
+        return undefined;
+    }
+    const member = info.values.find((candidate) => candidate.dbValue === stored || candidate.name === stored);
+    return member === undefined
+        ? undefined
+        : { kind: 'enumValue', value: member.name };
+}
+function textExpressionDefault(expression, field, isServer) {
+    const trimmed = expression.trim();
+    const unwrapped = trimmed.replace(/^\((.*)\)$/s, '$1').trim();
+    const lowered = unwrapped.toLowerCase();
+    if (CURRENT_TIMESTAMP_EXPRESSIONS.has(lowered)) {
+        return { kind: 'now' };
+    }
+    if (/^current_timestamp\(\d*\)$/.test(lowered) || /^now\(\)$/.test(lowered)) {
+        return { kind: 'now' };
+    }
+    if (UUID_EXPRESSIONS.has(lowered)) {
+        return { kind: 'uuid' };
+    }
+    const quoted = /^'((?:[^']|'')*)'(?:::[\w\s."]+)?$/.exec(unwrapped);
+    if (quoted !== null) {
+        const body = (quoted[1] ?? '').replace(/''/g, "'");
+        if (field.type === 'int' ||
+            field.type === 'bigInt' ||
+            field.type === 'float' ||
+            field.type === 'decimal') {
+            const asNumber = Number(body);
+            if (body.trim() !== '' && !Number.isNaN(asNumber)) {
+                return { kind: 'literal', value: asNumber };
+            }
+        }
+        if (field.type === 'boolean') {
+            if (/^(true|t|1)$/i.test(body)) {
+                return { kind: 'literal', value: true };
+            }
+            if (/^(false|f|0)$/i.test(body)) {
+                return { kind: 'literal', value: false };
+            }
+        }
+        return { kind: 'literal', value: body };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(unwrapped)) {
+        if (field.type === 'boolean') {
+            return { kind: 'literal', value: Number(unwrapped) !== 0 };
+        }
+        return { kind: 'literal', value: Number(unwrapped) };
+    }
+    if (/^(true|false)$/i.test(unwrapped)) {
+        return { kind: 'literal', value: lowered === 'true' };
+    }
+    if (isServer) {
+        return { kind: 'dbExpression', expression: trimmed };
+    }
+    return { kind: 'dbExpression', expression: trimmed };
+}
+function convertDefault(ctx, value, field, resolved, isServer, location) {
+    switch (value.kind) {
+        case 'none':
+            return undefined;
+        case 'bool':
+            return { kind: 'literal', value: value.value };
+        case 'number':
+            return { kind: 'literal', value: value.value };
+        case 'string': {
+            if (resolved.enumName !== undefined) {
+                const member = enumValueFor(ctx, resolved.enumName, value.value);
+                if (member !== undefined) {
+                    return member;
+                }
+            }
+            if (isServer) {
+                return textExpressionDefault(`'${value.value.replace(/'/g, "''")}'`, field, true);
+            }
+            return { kind: 'literal', value: value.value };
+        }
+        case 'list':
+            if (value.items.length === 0) {
+                return { kind: 'literal', value: '[]' };
+            }
+            break;
+        case 'dict':
+            if (value.entries.length === 0) {
+                return { kind: 'literal', value: '{}' };
+            }
+            break;
+        case 'name': {
+            const dotted = value.value;
+            if (dotted === 'uuid.uuid4' ||
+                dotted === 'uuid4' ||
+                dotted === 'uuid.uuid1' ||
+                dotted === 'uuid7' ||
+                dotted === 'uuid.uuid7') {
+                return { kind: 'uuid' };
+            }
+            if (NOW_CALLABLES.has(dotted) || NOW_NAME_PATTERN.test(dotted)) {
+                return { kind: 'now' };
+            }
+            if (dotted === 'dict') {
+                return { kind: 'literal', value: '{}' };
+            }
+            if (dotted === 'list' || dotted === 'set') {
+                return { kind: 'literal', value: '[]' };
+            }
+            const member = enumMemberDefault(ctx, dotted);
+            if (member !== undefined) {
+                return member;
+            }
+            break;
+        }
+        case 'call': {
+            const callee = value.callee;
+            const lowered = lastSegment(callee).toLowerCase();
+            if (lowered === 'text') {
+                const argument = value.args[0];
+                const expression = stringOf(argument);
+                if (expression !== undefined) {
+                    return textExpressionDefault(expression, field, isServer);
+                }
+            }
+            if (/(^|\.)func\./.test(callee) || callee.startsWith('func.')) {
+                const converted = textExpressionDefault(stripFuncPrefix(value.text), field, isServer);
+                if (converted.kind !== 'dbExpression' || isServer) {
+                    return converted;
+                }
+                break;
+            }
+            if ((lowered === 'true' || lowered === 'false') &&
+                value.args.length === 0) {
+                return { kind: 'literal', value: lowered === 'true' };
+            }
+            if (lowered === 'decimal' || lowered === 'int' || lowered === 'float') {
+                const argument = value.args[0];
+                const numeric = argument === undefined
+                    ? undefined
+                    : argument.kind === 'number'
+                        ? argument.value
+                        : argument.kind === 'string' &&
+                            !Number.isNaN(Number(argument.value))
+                            ? Number(argument.value)
+                            : undefined;
+                if (numeric !== undefined) {
+                    return { kind: 'literal', value: numeric };
+                }
+            }
+            if (NOW_CALLABLES.has(callee) || NOW_NAME_PATTERN.test(callee)) {
+                return { kind: 'now' };
+            }
+            if (callee === 'uuid.uuid4' ||
+                callee === 'uuid4' ||
+                callee === 'uuid.uuid1') {
+                return { kind: 'uuid' };
+            }
+            break;
+        }
+        case 'other': {
+            const text = value.text.replace(/\s+/g, ' ');
+            if (/^lambda\s*:/.test(text)) {
+                const body = text.replace(/^lambda\s*:\s*/, '');
+                if (/\b(utcnow|now|today)\s*\(/.test(body) ||
+                    /\bfunc\.now\(/.test(body)) {
+                    return { kind: 'now' };
+                }
+                if (/\buuid[14]?\s*\(/.test(body)) {
+                    return { kind: 'uuid' };
+                }
+                if (body === '{}' || body === 'dict()') {
+                    return { kind: 'literal', value: '{}' };
+                }
+                if (body === '[]' || body === 'list()') {
+                    return { kind: 'literal', value: '[]' };
+                }
+                if (/^-?\d+(\.\d+)?$/.test(body)) {
+                    return { kind: 'literal', value: Number(body) };
+                }
+                const stringBody = /^(['"])(.*)\1$/.exec(body);
+                if (stringBody !== null) {
+                    return { kind: 'literal', value: stringBody[2] ?? '' };
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    warn(ctx, `${location}: ${isServer ? 'server_default' : 'default'}=${valueText(value) || value.kind} is not representable and was dropped.`);
+    return undefined;
+}
+/** `PostStatus.DRAFT` and `PostStatus.DRAFT.value` -> enumValue. */
+function enumMemberDefault(ctx, dotted) {
+    const segments = dotted.split('.');
+    if (segments[segments.length - 1] === 'value') {
+        segments.pop();
+    }
+    const memberName = segments[1];
+    const className = segments[0];
+    if (className === undefined || memberName === undefined) {
+        return undefined;
+    }
+    const info = ctx.enumInfos.get(className);
+    if (info === undefined) {
+        return undefined;
+    }
+    return info.values.some((candidate) => candidate.name === memberName)
+        ? { kind: 'enumValue', value: memberName }
+        : undefined;
+}
+// ---------------------------------------------------------------------------
+// Table constraints and indexes
+// ---------------------------------------------------------------------------
+function findColumn(table, reference) {
+    const index = table.columnIndex.get(reference);
+    if (index !== undefined) {
+        return table.columns[index];
+    }
+    return table.columns.find((column) => column.field.columnName === reference);
+}
+/** A column named in a constraint: a string, `Model.attribute`, or `table.c.column`. */
+function constraintColumn(value) {
+    if (value.kind === 'string') {
+        return { name: value.value };
+    }
+    if (value.kind === 'name') {
+        const parts = value.value.split('.');
+        return { name: parts[parts.length - 1] };
+    }
+    if (value.kind === 'call') {
+        const parts = value.callee.split('.');
+        const method = (parts[parts.length - 1] ?? '').toLowerCase();
+        if ((method === 'desc' || method === 'asc') && parts.length >= 2) {
+            return {
+                name: parts[parts.length - 2],
+                sort: method === 'desc' ? 'desc' : 'asc',
+            };
+        }
+    }
+    return { expression: true };
+}
+function applyTableItem(ctx, table, call) {
+    const callee = lastSegment(call.callee);
+    const lowered = callee.toLowerCase();
+    const label = `${table.label}.__table_args__`;
+    switch (lowered) {
+        case 'index':
+            applyIndex(ctx, table, call, label);
+            return;
+        case 'uniqueconstraint':
+            applyUnique(ctx, table, call, label);
+            return;
+        case 'primarykeyconstraint': {
+            const columns = [];
+            for (const argument of call.args) {
+                const column = constraintColumn(argument);
+                const found = column.name === undefined
+                    ? undefined
+                    : findColumn(table, column.name);
+                if (found === undefined) {
+                    warn(ctx, `${label}: PrimaryKeyConstraint names a column that does not exist; it was ignored.`);
+                    return;
+                }
+                columns.push(found.key);
+            }
+            if (columns.length > 0) {
+                table.pk = columns;
+                const name = stringOf(call.kwargs['name']);
+                if (name !== undefined) {
+                    table.pkName = name;
+                }
+            }
+            return;
+        }
+        case 'foreignkeyconstraint':
+            applyForeignKeyConstraint(ctx, table, call, label);
+            return;
+        case 'checkconstraint':
+            warn(ctx, `${label}: a CheckConstraint${stringOf(call.kwargs['name']) === undefined ? '' : ` ("${stringOf(call.kwargs['name'])}")`} was ignored (check constraints are not part of the shared model).`);
+            return;
+        case 'excludeconstraint':
+            warn(ctx, `${label}: an ExcludeConstraint was ignored.`);
+            return;
+        default:
+            warn(ctx, `${label}: ${callee}(...) is not supported and was ignored.`);
+    }
+}
+function applyForeignKeyConstraint(ctx, table, call, label) {
+    const localArgument = call.args[0] ?? call.kwargs['columns'];
+    const targetArgument = call.args[1] ?? call.kwargs['refcolumns'];
+    if (localArgument === undefined ||
+        targetArgument === undefined ||
+        localArgument.kind !== 'list' ||
+        targetArgument.kind !== 'list') {
+        warn(ctx, `${label}: a ForeignKeyConstraint could not be evaluated and was ignored.`);
+        return;
+    }
+    const local = [];
+    for (const item of localArgument.items) {
+        const found = item.kind === 'string' ? findColumn(table, item.value) : undefined;
+        if (found === undefined) {
+            warn(ctx, `${label}: a ForeignKeyConstraint names a column that does not exist; it was ignored.`);
+            return;
+        }
+        local.push(found.key);
+    }
+    const targets = [];
+    for (const item of targetArgument.items) {
+        const target = parseFkTarget(ctx, item, table);
+        if (target === undefined) {
+            warn(ctx, `${label}: a ForeignKeyConstraint target could not be evaluated and was ignored.`);
+            return;
+        }
+        targets.push(target);
+    }
+    const head = targets[0];
+    if (head === undefined ||
+        targets.length !== local.length ||
+        targets.some((target) => target.table !== head.table)) {
+        warn(ctx, `${label}: a ForeignKeyConstraint with mismatched or mixed targets was ignored.`);
+        return;
+    }
+    table.fks.push({
+        columns: local,
+        target: {
+            ...(head.schema === undefined ? {} : { schema: head.schema }),
+            table: head.table,
+            columns: targets.flatMap((target) => target.columns),
+        },
+        onDelete: actionOf(ctx, call.kwargs['ondelete'], label, 'ondelete'),
+        onUpdate: actionOf(ctx, call.kwargs['onupdate'], label, 'onupdate'),
+        name: stringOf(call.kwargs['name']),
+    });
+}
+function applyUnique(ctx, table, call, label) {
+    const columns = [];
+    for (const argument of call.args) {
+        const column = constraintColumn(argument);
+        const found = column.name === undefined ? undefined : findColumn(table, column.name);
+        if (found === undefined) {
+            warn(ctx, `${label}: a UniqueConstraint names a column that does not exist; it was ignored.`);
+            return;
+        }
+        columns.push(found.key);
+    }
+    if (columns.length === 0) {
+        return;
+    }
+    const name = stringOf(call.kwargs['name']);
+    const only = columns[0];
+    if (columns.length === 1 && only !== undefined) {
+        const column = findColumn(table, only);
+        if (column !== undefined) {
+            column.field.isUnique = true;
+            if (name !== undefined) {
+                column.field.uniqueName = name;
+            }
+        }
+        return;
+    }
+    table.indexes.push({
+        columns,
+        isUnique: true,
+        name,
+        method: undefined,
+        fieldOptions: {},
+    });
+}
+function applyIndex(ctx, table, call, label) {
+    const nameArgument = call.args[0];
+    const name = stringOf(nameArgument) ?? stringOf(call.kwargs['name']);
+    const columns = [];
+    const fieldOptions = {};
+    for (const argument of call.args.slice(nameArgument !== undefined &&
+        (nameArgument.kind === 'string' || nameArgument.kind === 'none')
+        ? 1
+        : 0)) {
+        const column = constraintColumn(argument);
+        const found = column.name === undefined ? undefined : findColumn(table, column.name);
+        if (column.expression === true || found === undefined) {
+            warn(ctx, `${label}: ${name === undefined ? 'an index' : `the index "${name}"`} on an expression or on a column that does not exist was ignored.`);
+            return;
+        }
+        columns.push(found.key);
+        if (column.sort === 'desc') {
+            fieldOptions[found.key] = { sort: 'desc' };
+        }
+    }
+    if (columns.length === 0) {
+        return;
+    }
+    const where = Object.entries(call.kwargs).find(([key]) => /(^|_)where$/.test(key))?.[1];
+    if (where !== undefined) {
+        warn(ctx, `${label}: the partial index${name === undefined ? '' : ` "${name}"`} (with a WHERE clause) was ignored.`);
+        return;
+    }
+    const usingEntry = Object.entries(call.kwargs).find(([key]) => /(^|_)using$/.test(key));
+    const method = stringOf(usingEntry?.[1]);
+    table.indexes.push({
+        columns,
+        isUnique: boolOf(call.kwargs['unique']) === true,
+        name,
+        method,
+        fieldOptions,
+    });
+}
+/** Names an expression refers to first: `Post.title.desc()` -> Post, `func.lower(Post.title)` -> func, Post. */
+function holderNames(value, depth = 0) {
+    if (depth > 4) {
+        return [];
+    }
+    if (value.kind === 'name') {
+        return [(value.value.split('.')[0] ?? '').trim()];
+    }
+    if (value.kind === 'call') {
+        return [
+            (value.callee.split('.')[0] ?? '').trim(),
+            ...value.args.flatMap((argument) => holderNames(argument, depth + 1)),
+        ];
+    }
+    return [];
+}
+/** `Index("name", Model.a, Model.b)` written after the class body. */
+function applyModuleIndexes(ctx) {
+    for (const { call } of ctx.indexCalls) {
+        let table;
+        for (const argument of call.args) {
+            for (const holder of holderNames(argument)) {
+                table = ctx.byModel.get(holder) ?? ctx.byVar.get(holder);
+                if (table !== undefined) {
+                    break;
+                }
+            }
+            if (table !== undefined) {
+                break;
+            }
+        }
+        if (table === undefined) {
+            warn(ctx, `Index(...) at module level could not be matched to a model or table (${call.text.slice(0, 80)}); it was ignored.`);
+            continue;
+        }
+        applyIndex(ctx, table, call, `${table.label}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Relationships
+// ---------------------------------------------------------------------------
+function colRefsOf(value) {
+    if (value === undefined) {
+        return [];
+    }
+    const refs = [];
+    const text = value.kind === 'list' ? '' : valueText(value);
+    if (value.kind === 'list') {
+        for (const item of value.items) {
+            refs.push(...colRefsOf(item));
+        }
+        return refs;
+    }
+    for (const match of text.matchAll(/([A-Za-z_]\w*)(?:\.([A-Za-z_]\w*))?/g)) {
+        const first = match[1] ?? '';
+        const second = match[2];
+        if (first === 'lambda' || first === 'foreign' || first === 'remote') {
+            continue;
+        }
+        refs.push(second === undefined ? { col: first } : { cls: first, col: second });
+    }
+    return refs;
+}
+function relationshipTarget(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    switch (value.kind) {
+        case 'string': {
+            const cleaned = value.value.trim().replace(/^['"]|['"]$/g, '');
+            return /^[\w.]+$/.test(cleaned) ? lastSegment(cleaned) : undefined;
+        }
+        case 'name':
+            return lastSegment(value.value);
+        case 'other': {
+            const lambda = /^lambda\s*:\s*([\w.]+)/.exec(value.text);
+            return lambda === null ? undefined : lastSegment(lambda[1] ?? '');
+        }
+        default:
+            return undefined;
+    }
+}
+function addRelationship(ctx, table, member, call) {
+    let kwargs = { ...call.kwargs };
+    const extra = kwargs['sa_relationship_kwargs'];
+    if (extra !== undefined && extra.kind === 'dict') {
+        for (const entry of extra.entries) {
+            const key = stringOf(entry.key);
+            if (key !== undefined && kwargs[key] === undefined) {
+                kwargs[key] = entry.value;
+            }
+        }
+    }
+    const inner = kwargs['sa_relationship'];
+    let effective = call;
+    if (inner !== undefined && inner.kind === 'call') {
+        effective = inner;
+        kwargs = { ...inner.kwargs, ...kwargs };
+    }
+    const fromAnnotation = relationshipAnnotation(ctx, member.annotation);
+    const targetName = relationshipTarget(effective.args[0]) ??
+        relationshipTarget(kwargs['argument']) ??
+        fromAnnotation.target;
+    const backref = kwargs['backref'];
+    let backrefInfo;
+    if (backref !== undefined) {
+        if (backref.kind === 'string') {
+            backrefInfo = { name: backref.value };
+        }
+        else if (backref.kind === 'call') {
+            const name = stringOf(backref.args[0]);
+            if (name !== undefined) {
+                const uselist = boolOf(backref.kwargs['uselist']);
+                backrefInfo = { name, ...(uselist === undefined ? {} : { uselist }) };
+            }
+        }
+    }
+    const uselist = boolOf(kwargs['uselist']);
+    const rel = {
+        table,
+        key: member.name,
+        order: ctx.counter,
+        targetName,
+        foreignKeys: colRefsOf(kwargs['foreign_keys']),
+        joinRefs: [
+            ...colRefsOf(kwargs['primaryjoin']),
+            ...colRefsOf(kwargs['secondaryjoin']),
+        ],
+        remoteSide: kwargs['remote_side'] !== undefined,
+        viewonly: boolOf(kwargs['viewonly']) === true,
+        synthetic: false,
+    };
+    ctx.counter += 1;
+    const backPopulates = stringOf(kwargs['back_populates']);
+    if (backPopulates !== undefined) {
+        rel.backPopulates = backPopulates;
+    }
+    if (backrefInfo !== undefined) {
+        rel.backref = backrefInfo;
+    }
+    if (kwargs['secondary'] !== undefined) {
+        rel.secondary = kwargs['secondary'];
+    }
+    const linkModel = kwargs['link_model'];
+    if (linkModel !== undefined) {
+        const linkName = relationshipTarget(linkModel);
+        if (linkName !== undefined) {
+            rel.linkModel = linkName;
+        }
+    }
+    if (uselist !== undefined) {
+        rel.uselist = uselist;
+    }
+    const collection = uselist ?? fromAnnotation.collection;
+    if (collection !== undefined) {
+        rel.collection = collection;
+    }
+    if (targetName === undefined) {
+        warn(ctx, `${table.label}.${member.name}: the target model of the relationship could not be determined; it was skipped.`);
+        return;
+    }
+    if (table.rels.length >= MAX_RELATIONSHIPS_PER_TABLE) {
+        if (table.relsCapped !== true) {
+            table.relsCapped = true;
+            warn(ctx, `${table.label}: more than ${MAX_RELATIONSHIPS_PER_TABLE} relationships; the rest were skipped.`);
+        }
+        return;
+    }
+    table.rels.push(rel);
+}
+function tableOfRef(ctx, rel, reference) {
+    return reference.cls === undefined
+        ? rel.table
+        : (ctx.byModel.get(reference.cls) ?? ctx.byVar.get(reference.cls));
+}
+function fkWithColumn(table, key) {
+    return table.fks.find((fk) => fk.columns.includes(key));
+}
+function tableFor(ctx, target) {
+    const matches = (ctx.tablesByName.get(target.table) ?? []).filter((candidate) => target.schema === undefined || candidate.schema === target.schema);
+    if (matches.length === 0 && target.schema !== undefined) {
+        const unqualified = ctx.tablesByName.get(target.table) ?? [];
+        return unqualified.length === 1 ? unqualified[0] : undefined;
+    }
+    if (matches.length <= 1) {
+        return matches[0];
+    }
+    // Prefer a class-mapped table when a Table() variable has the same name.
+    return (matches.find((candidate) => candidate.cls !== undefined) ??
+        matches[0]);
+}
+function fksBetween(ctx, from, to) {
+    return from.fks.filter((fk) => tableFor(ctx, fk.target) === to);
+}
+function resolveRelationships(ctx) {
+    // backref="name" declares the other side implicitly.
+    for (const table of [...ctx.tables]) {
+        for (const rel of [...table.rels]) {
+            if (rel.backref === undefined ||
+                rel.viewonly ||
+                rel.targetName === undefined) {
+                continue;
+            }
+            const target = ctx.byModel.get(rel.targetName);
+            if (target === undefined ||
+                target.rels.some((other) => other.key === rel.backref?.name)) {
+                continue;
+            }
+            const synthetic = {
+                table: target,
+                key: rel.backref.name,
+                order: rel.order + 0.5,
+                targetName: table.modelName,
+                backPopulates: rel.key,
+                foreignKeys: rel.foreignKeys,
+                joinRefs: rel.joinRefs,
+                remoteSide: false,
+                viewonly: false,
+                synthetic: true,
+                ...(rel.secondary === undefined ? {} : { secondary: rel.secondary }),
+                ...(rel.linkModel === undefined ? {} : { linkModel: rel.linkModel }),
+                ...(rel.backref.uselist === undefined
+                    ? {}
+                    : { uselist: rel.backref.uselist, collection: rel.backref.uselist }),
+            };
+            target.rels.push(synthetic);
+        }
+    }
+    // Owning sides first, so reverse sides can find them by name.
+    const reverse = [];
+    const manyToMany = [];
+    for (const table of ctx.tables) {
+        for (const rel of table.rels) {
+            if (rel.viewonly) {
+                continue;
+            }
+            if (rel.secondary !== undefined || rel.linkModel !== undefined) {
+                manyToMany.push(rel);
+                continue;
+            }
+            classifyRelationship(ctx, rel, reverse);
+        }
+    }
+    for (const rel of reverse) {
+        linkReverse(ctx, rel);
+    }
+    linkManyToMany(ctx, manyToMany);
+}
+function sideOf(ctx, rel, target) {
+    const own = rel.table;
+    const hints = rel.foreignKeys.length > 0 ? rel.foreignKeys : [];
+    if (hints.length > 0) {
+        const hinted = hints[0];
+        const holder = hinted === undefined ? undefined : tableOfRef(ctx, rel, hinted);
+        if (holder !== undefined && hinted !== undefined) {
+            const fk = fkWithColumn(holder, hinted.col);
+            if (fk !== undefined) {
+                if (own === target) {
+                    return {
+                        side: rel.remoteSide ? 'owner' : 'reverse',
+                        candidates: [fk],
+                    };
+                }
+                return { side: holder === own ? 'owner' : 'reverse', candidates: [fk] };
+            }
+        }
+    }
+    // primaryjoin hints: columns that carry a foreign key between the two tables.
+    const joinHints = [];
+    for (const reference of rel.joinRefs) {
+        const holder = tableOfRef(ctx, rel, reference);
+        const fk = holder === undefined ? undefined : fkWithColumn(holder, reference.col);
+        if (holder !== undefined &&
+            fk !== undefined &&
+            ((holder === own && tableFor(ctx, fk.target) === target) ||
+                (holder === target && tableFor(ctx, fk.target) === own))) {
+            joinHints.push(fk);
+        }
+    }
+    const firstJoin = joinHints[0];
+    if (firstJoin !== undefined) {
+        const owns = own.fks.includes(firstJoin);
+        if (own === target) {
+            return {
+                side: rel.remoteSide ? 'owner' : 'reverse',
+                candidates: [firstJoin],
+            };
+        }
+        return { side: owns ? 'owner' : 'reverse', candidates: [firstJoin] };
+    }
+    const forward = fksBetween(ctx, own, target);
+    if (own === target) {
+        return { side: rel.remoteSide ? 'owner' : 'reverse', candidates: forward };
+    }
+    const backward = fksBetween(ctx, target, own);
+    if (forward.length > 0 && backward.length === 0) {
+        return { side: 'owner', candidates: forward };
+    }
+    if (backward.length > 0 && forward.length === 0) {
+        return { side: 'reverse', candidates: backward };
+    }
+    if (forward.length > 0 && backward.length > 0) {
+        return rel.collection === true
+            ? { side: 'reverse', candidates: backward }
+            : { side: 'owner', candidates: forward };
+    }
+    return { side: 'none', candidates: [] };
+}
+/** Picks the foreign key a relationship uses when several fit: by name, then by order. */
+function pickForeignKey(rel, candidates, taken) {
+    if (candidates.length <= 1) {
+        return candidates[0];
+    }
+    const stripped = (key) => key.replace(/(_id|Id|ID)$/, '');
+    const byName = candidates.find((fk) => fk.columns.some((column) => column === rel.key || stripped(column) === rel.key));
+    if (byName !== undefined) {
+        return byName;
+    }
+    return candidates.find((fk) => !taken(fk)) ?? candidates[0];
+}
+function classifyRelationship(ctx, rel, reverse) {
+    const location = `${rel.table.label}.${rel.key}`;
+    const target = rel.targetName === undefined ? undefined : ctx.byModel.get(rel.targetName);
+    if (target === undefined) {
+        warn(ctx, `${location}: the relationship points at "${rel.targetName ?? ''}", which is not a model in the input; it was skipped.`);
+        return;
+    }
+    const { side, candidates } = sideOf(ctx, rel, target);
+    if (side === 'none') {
+        warn(ctx, `${location}: no foreign key links ${rel.table.modelName} and ${target.modelName}; the relationship was skipped.`);
+        return;
+    }
+    if (side === 'reverse') {
+        reverse.push(rel);
+        return;
+    }
+    const fk = pickForeignKey(rel, candidates, (candidate) => candidate.ownerName !== undefined);
+    if (fk === undefined) {
+        return;
+    }
+    if (candidates.length > 1 && rel.foreignKeys.length === 0) {
+        warn(ctx, `${location}: several foreign keys link ${rel.table.modelName} and ${target.modelName}; add foreign_keys=[...] to tell them apart.`);
+    }
+    if (fk.ownerName === undefined) {
+        fk.ownerName = rel.key;
+    }
+    const declared = rel.backPopulates ?? rel.backref?.name;
+    if (declared !== undefined && fk.declaredRelatedName === undefined) {
+        fk.declaredRelatedName = declared;
+    }
+    if (rel.uselist === false &&
+        rel.collection === false &&
+        fk.reverseScalar === undefined) {
+        // uselist=False on the owning side is the default for many-to-one; it says nothing about one-to-one.
+    }
+}
+function linkReverse(ctx, rel) {
+    const location = `${rel.table.label}.${rel.key}`;
+    const target = rel.targetName === undefined ? undefined : ctx.byModel.get(rel.targetName);
+    if (target === undefined) {
+        return;
+    }
+    const { candidates } = sideOf(ctx, rel, target);
+    let fk;
+    if (rel.backPopulates !== undefined) {
+        fk = candidates.find((candidate) => candidate.ownerName === rel.backPopulates);
+    }
+    if (fk === undefined) {
+        fk = pickForeignKey(rel, candidates.filter((candidate) => candidate.reverseName === undefined), (candidate) => candidate.reverseName !== undefined);
+    }
+    if (fk === undefined) {
+        warn(ctx, `${location}: the relationship could not be matched to a foreign key of ${target.modelName}; the reverse side was not linked.`);
+        return;
+    }
+    if (fk.reverseName === undefined) {
+        fk.reverseName = rel.key;
+        if (rel.collection === false || rel.uselist === false) {
+            fk.reverseScalar = true;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Many-to-many
+// ---------------------------------------------------------------------------
+function associationTableOf(ctx, rel) {
+    if (rel.linkModel !== undefined) {
+        return ctx.byModel.get(rel.linkModel);
+    }
+    const secondary = rel.secondary;
+    if (secondary === undefined) {
+        return undefined;
+    }
+    if (secondary.kind === 'name') {
+        const variable = secondary.value;
+        return (ctx.byVar.get(variable) ??
+            ctx.byVar.get(lastSegment(variable)) ??
+            ctx.byModel.get(lastSegment(variable)));
+    }
+    if (secondary.kind === 'string') {
+        const name = lastSegment(secondary.value);
+        return ctx.tablesByName.get(name)?.[0];
+    }
+    if (secondary.kind === 'other') {
+        const lambda = /^lambda\s*:\s*([\w.]+)/.exec(secondary.text);
+        if (lambda !== null) {
+            const variable = lambda[1] ?? '';
+            return ctx.byVar.get(variable) ?? ctx.byModel.get(lastSegment(variable));
+        }
+    }
+    return undefined;
+}
+function linkManyToMany(ctx, relations) {
+    const ordered = [...relations].sort((first, second) => first.order - second.order);
+    for (const rel of ordered) {
+        if (rel.folded === true) {
+            continue;
+        }
+        const location = `${rel.table.label}.${rel.key}`;
+        const target = rel.targetName === undefined
+            ? undefined
+            : ctx.byModel.get(rel.targetName);
+        if (target === undefined) {
+            warn(ctx, `${location}: the many-to-many points at "${rel.targetName ?? ''}", which is not a model in the input; it was skipped.`);
+            continue;
+        }
+        const association = associationTableOf(ctx, rel);
+        const secondaryText = rel.linkModel ??
+            (rel.secondary === undefined ? '' : valueText(rel.secondary));
+        if (association === undefined) {
+            warn(ctx, `${location}: the association table ${secondaryText === '' ? '' : `"${secondaryText}" `}is not defined in the input; the many-to-many was kept without checking its columns.`);
+        }
+        else if (!isPureAssociation(ctx, association, rel.table, target)) {
+            if (rel.linkModel !== undefined) {
+                warn(ctx, `${location}: the link model ${association.modelName} has columns besides its two foreign keys, so it stays a model and the many-to-many was skipped.`);
+                continue;
+            }
+            warn(ctx, `${location}: the association table ${association.tableName} has columns besides its two foreign keys; they are not represented.`);
+            association.consumed = true;
+        }
+        else {
+            association.consumed = true;
+        }
+        // Pair with the other side so the relation is written once, with the other name as its reverse.
+        const partner = target.rels.find((other) => other !== rel &&
+            other.folded !== true &&
+            (other.secondary !== undefined || other.linkModel !== undefined) &&
+            ((rel.backPopulates !== undefined && other.key === rel.backPopulates) ||
+                (other.backPopulates === rel.key &&
+                    other.targetName === rel.table.modelName)));
+        if (partner !== undefined) {
+            partner.folded = true;
+        }
+        const relatedName = partner?.key ?? rel.backPopulates ?? rel.backref?.name;
+        rel.table.m2m.push({
+            name: rel.key,
+            kind: 'manyToMany',
+            targetModel: target.modelName,
+            columnName: '',
+            isNullable: false,
+            onDelete: 'cascade',
+            ...(relatedName === undefined ? {} : { relatedName }),
+        });
+    }
+}
+/** True when the table is made of the two foreign keys of a many-to-many and nothing else. */
+function isPureAssociation(ctx, association, first, second) {
+    const keyed = new Set(association.fks.flatMap((fk) => fk.columns));
+    const hasFirst = association.fks.some((fk) => tableFor(ctx, fk.target) === first);
+    const hasSecond = association.fks.some((fk) => tableFor(ctx, fk.target) === second);
+    return (hasFirst &&
+        hasSecond &&
+        association.columns.every((column) => keyed.has(column.key)));
+}
+// ---------------------------------------------------------------------------
+// Finalizing
+// ---------------------------------------------------------------------------
+/** Gives columns declared as `Column("id", ForeignKey("t.id"))` the type of the column they reference. */
+function inferForeignKeyTypes(ctx) {
+    for (const table of ctx.tables) {
+        for (const column of table.columns) {
+            if (column.inferFromForeignKey !== true) {
+                continue;
+            }
+            const fk = table.fks.find((candidate) => candidate.columns.length === 1 && candidate.columns[0] === column.key);
+            const target = fk === undefined ? undefined : tableFor(ctx, fk.target);
+            const referenced = fk === undefined ? undefined : fk.target.columns[0];
+            const source = target === undefined
+                ? undefined
+                : target.columns.find((candidate) => referenced === undefined
+                    ? candidate.field.isPrimaryKey
+                    : candidate.field.columnName === referenced);
+            if (source === undefined) {
+                warn(ctx, `${table.label}.${column.key}: the column has no type and the column its foreign key points at is not known; it was read as an integer.`);
+                continue;
+            }
+            for (const property of [
+                'type',
+                'maxLength',
+                'maxDigits',
+                'decimalPlaces',
+                'enumName',
+                'arrayDepth',
+                'rangeOf',
+                'unsupportedType',
+            ]) {
+                const value = source.field[property];
+                if (value === undefined) {
+                    delete column.field[property];
+                }
+                else {
+                    column.field[property] =
+                        value;
+                }
+            }
+        }
+    }
+}
+function finalizeAll(ctx) {
+    inferForeignKeyTypes(ctx);
+    const warnings = ctx.warnings;
+    const consumed = new Set(ctx.tables.filter((table) => table.consumed));
+    const models = [];
+    const names = new Set();
+    for (const table of ctx.tables) {
+        if (consumed.has(table)) {
+            continue;
+        }
+        if (table.varName !== undefined && table.cls === undefined) {
+            const mapped = ctx.imperative.some((mapping) => mapping.tableVar === table.varName);
+            if (!mapped) {
+                warn(ctx, `${table.tableName}: the Table is not mapped to a class and not used as a secondary table; it is converted as the model ${table.modelName}.`);
+            }
+        }
+        if (names.has(table.modelName)) {
+            warn(ctx, `Two tables are named ${table.modelName}; the second one was skipped.`);
+            continue;
+        }
+        names.add(table.modelName);
+        models.push(finalizeModel(ctx, table));
+    }
+    addStubModels(ctx, models, warnings);
+    return models;
+}
+function stripIdSuffix(key) {
+    return key.replace(/(_id|Id|ID)$/, '');
+}
+function modelNameForTable(ctx, target) {
+    const found = tableFor(ctx, target);
+    if (found !== undefined) {
+        return found.modelName;
+    }
+    const stubName = toPascalCase(singularize(toSnakeCase(target.table)));
+    ctx.stubTables.set(stubName, target.table);
+    return stubName;
+}
+function fieldNameForColumn(target, columnName) {
+    if (target === undefined) {
+        return columnName;
+    }
+    const column = target.columns.find((candidate) => candidate.field.columnName === columnName);
+    return column === undefined ? columnName : column.key;
+}
+function primaryKeyOf(table) {
+    if (table === undefined) {
+        return ['id'];
+    }
+    if (table.pk !== undefined) {
+        return table.pk;
+    }
+    const keys = table.columns
+        .filter((column) => column.field.isPrimaryKey)
+        .map((column) => column.key);
+    return keys.length > 0 ? keys : ['id'];
+}
+function sameList(first, second) {
+    return (first.length === second.length &&
+        first.every((item, index) => item === second[index]));
+}
+function finalizeModel(ctx, table) {
+    const label = table.label;
+    const columns = table.columns;
+    const pkKeys = table.pk ??
+        columns
+            .filter((column) => column.field.isPrimaryKey)
+            .map((column) => column.key);
+    const uniqueKeys = new Set(columns
+        .filter((column) => column.field.isUnique)
+        .map((column) => column.key));
+    for (const index of table.indexes) {
+        const only = index.columns[0];
+        if (index.isUnique && index.columns.length === 1 && only !== undefined) {
+            uniqueKeys.add(only);
+        }
+    }
+    const takenNames = new Set(columns
+        .filter((column) => !table.fks.some((fk) => fk.columns.length === 1 && fk.columns[0] === column.key))
+        .map((column) => column.key));
+    for (const relation of table.m2m) {
+        takenNames.add(relation.name);
+    }
+    const relations = [];
+    const compositeForeignKeys = [];
+    const renamed = new Map();
+    const merged = new Set();
+    for (const fk of table.fks) {
+        const target = tableFor(ctx, fk.target);
+        const targetModel = modelNameForTable(ctx, fk.target);
+        const keyColumns = fk.columns.flatMap((key) => {
+            const column = columns.find((candidate) => candidate.key === key);
+            return column === undefined ? [] : [column];
+        });
+        if (keyColumns.length !== fk.columns.length || keyColumns.length === 0) {
+            warn(ctx, `${label}: the foreign key on (${fk.columns.join(', ')}) names a column that does not exist; it was skipped.`);
+            continue;
+        }
+        const relatedName = fk.reverseName ?? fk.declaredRelatedName;
+        if (fk.columns.length > 1) {
+            const references = fk.target.columns.length > 0
+                ? fk.target.columns.map((name) => fieldNameForColumn(target, name))
+                : primaryKeyOf(target);
+            let name = fk.ownerName ?? toCamelCase(targetModel);
+            while (takenNames.has(name)) {
+                name = `${name}_`;
+            }
+            takenNames.add(name);
+            compositeForeignKeys.push({
+                name,
+                targetModel,
+                fields: fk.columns,
+                references,
+                kind: 'foreignKey',
+                isNullable: keyColumns.some((column) => column.field.isNullable),
+                onDelete: fk.onDelete ?? 'noAction',
+                ...(fk.onUpdate === undefined ? {} : { onUpdate: fk.onUpdate }),
+                ...(relatedName === undefined ? {} : { relatedName }),
+                ...(fk.name === undefined ? {} : { constraintName: fk.name }),
+            });
+            continue;
+        }
+        const backing = keyColumns[0];
+        if (merged.has(backing.key)) {
+            warn(ctx, `${label}: the column "${backing.key}" has more than one foreign key; only the first was kept.`);
+            continue;
+        }
+        const stripped = stripIdSuffix(backing.key);
+        let name = fk.ownerName ??
+            (stripped === '' || takenNames.has(stripped) ? backing.key : stripped);
+        if (takenNames.has(name) && name !== backing.key) {
+            name = backing.key;
+        }
+        takenNames.add(name);
+        merged.add(backing.key);
+        renamed.set(backing.key, name);
+        const isPrimary = pkKeys.length === 1 && pkKeys[0] === backing.key;
+        const referenced = fk.target.columns[0];
+        const referencedField = referenced === undefined
+            ? undefined
+            : fieldNameForColumn(target, referenced);
+        const isOneToOne = isPrimary || uniqueKeys.has(backing.key) || fk.reverseScalar === true;
+        relations.push({
+            name,
+            kind: isOneToOne ? 'oneToOne' : 'foreignKey',
+            targetModel,
+            columnName: backing.field.columnName,
+            isNullable: backing.field.isNullable && !isPrimary,
+            onDelete: fk.onDelete ?? 'noAction',
+            ...(relatedName === undefined ? {} : { relatedName }),
+            ...(referencedField === undefined ||
+                target === undefined ||
+                sameList(primaryKeyOf(target), [referencedField])
+                ? {}
+                : { toField: referencedField }),
+            ...(isPrimary ? { isPrimaryKey: true } : {}),
+            ...(fk.onUpdate === undefined ? {} : { onUpdate: fk.onUpdate }),
+            ...(fk.name === undefined ? {} : { constraintName: fk.name }),
+        });
+    }
+    relations.push(...table.m2m);
+    const fields = columns
+        .filter((column) => !merged.has(column.key))
+        .map((column) => column.field);
+    const fieldByKey = new Map(columns.map((column) => [column.key, column.field]));
+    // Indexes, with columns that became relations renamed.
+    const known = new Set([
+        ...fields.map((field) => field.name),
+        ...relations.map((relation) => relation.name),
+        ...compositeForeignKeys.map((composite) => composite.name),
+    ]);
+    const indexes = [];
+    for (const raw of table.indexes) {
+        const indexNames = raw.columns.map((key) => renamed.get(key) ?? key);
+        if (indexNames.some((name) => !known.has(name) && !fieldByKey.has(name))) {
+            continue;
+        }
+        const onRelation = indexNames.length === 1 &&
+            relations.some((relation) => relation.name === indexNames[0]);
+        if (raw.isUnique && onRelation && raw.name === undefined) {
+            continue;
+        }
+        const single = indexNames.length === 1
+            ? fields.find((field) => field.name === indexNames[0])
+            : undefined;
+        if (raw.isUnique &&
+            raw.name === undefined &&
+            single !== undefined &&
+            !single.isPrimaryKey) {
+            single.isUnique = true;
+            continue;
+        }
+        const fieldOptions = {};
+        for (const [key, option] of Object.entries(raw.fieldOptions)) {
+            fieldOptions[renamed.get(key) ?? key] = option;
+        }
+        indexes.push({
+            fields: indexNames,
+            isUnique: raw.isUnique,
+            ...(raw.name === undefined ? {} : { name: raw.name }),
+            ...(raw.method === undefined ? {} : { method: raw.method }),
+            ...(Object.keys(fieldOptions).length === 0 ? {} : { fieldOptions }),
+        });
+    }
+    // Primary key.
+    let compositePrimaryKey;
+    if (pkKeys.length === 0) {
+        warn(ctx, `${label}: the table has no primary key; SQLAlchemy needs one to map a class, so add primary_key=True to a column.`);
+    }
+    else if (pkKeys.length > 1) {
+        compositePrimaryKey = pkKeys.map((key) => renamed.get(key) ?? key);
+        for (const key of pkKeys) {
+            const field = fieldByKey.get(key);
+            if (field !== undefined) {
+                field.isPrimaryKey = false;
+                field.isUnique = false;
+                field.isNullable = false;
+            }
+        }
+        for (const relation of relations) {
+            delete relation.isPrimaryKey;
+        }
+    }
+    else if (table.pk !== undefined) {
+        const field = fields.find((candidate) => candidate.name === table.pk?.[0]);
+        if (field !== undefined) {
+            field.isPrimaryKey = true;
+            field.isNullable = false;
+        }
+    }
+    // A lone integer primary key counts up unless the column says otherwise.
+    if (pkKeys.length === 1) {
+        const onlyKey = pkKeys[0];
+        const column = columns.find((candidate) => candidate.key === onlyKey);
+        if (column !== undefined &&
+            column.wantsAutoIncrement &&
+            !merged.has(column.key) &&
+            column.field.default === undefined &&
+            column.field.generated === undefined) {
+            column.field.default = { kind: 'autoIncrement' };
+        }
+    }
+    return {
+        name: table.modelName,
+        tableName: table.tableName,
+        appLabel: ctx.options.appLabel,
+        fields,
+        relations,
+        indexes,
+        ...(compositePrimaryKey === undefined ? {} : { compositePrimaryKey }),
+        ...(table.pkName !== undefined && compositePrimaryKey !== undefined
+            ? { primaryKeyName: table.pkName }
+            : {}),
+        ...(table.schema === undefined ? {} : { schema: table.schema }),
+        ...(compositeForeignKeys.length === 0 ? {} : { compositeForeignKeys }),
+    };
+}
+function addStubModels(ctx, models, warnings) {
+    const known = new Set(models.map((model) => model.name));
+    const stubs = [];
+    for (const model of models) {
+        const references = [
+            ...model.relations
+                .filter((relation) => relation.kind !== 'manyToMany')
+                .map((relation) => ({
+                via: relation.name,
+                target: relation.targetModel,
+            })),
+            ...(model.compositeForeignKeys ?? []).map((composite) => ({
+                via: composite.name,
+                target: composite.targetModel,
+            })),
+        ];
+        for (const { via, target } of references) {
+            if (known.has(target)) {
+                continue;
+            }
+            known.add(target);
+            stubs.push({
+                name: target,
+                tableName: ctx.stubTables.get(target) ?? toSnakeCase(target),
+                appLabel: ctx.options.appLabel,
+                fields: [
+                    {
+                        name: 'id',
+                        columnName: 'id',
+                        type: 'int',
+                        isPrimaryKey: true,
+                        isUnique: false,
+                        isNullable: false,
+                        isAutoUpdated: false,
+                        default: { kind: 'autoIncrement' },
+                    },
+                ],
+                relations: [],
+                indexes: [],
+            });
+            warnings.push(`${model.name}.${via} references "${target}", which is not a table in the input. ` +
+                `A stub model with an auto-increment id was generated; replace it with the real definition.`);
+        }
+    }
+    // Many-to-many targets are checked when they are linked, so only foreign keys can dangle.
+    models.push(...stubs);
+}
+//# sourceMappingURL=sqlalchemy.js.map