@syncular/typegen 0.15.48 → 0.17.0

package/README.md

@@ -15,6 +15,10 @@ syncular init [--manifest-dir <dir>]
 
 `generate` reads `<dir>/syncular.json` plus its migrations directory and
 writes the migration lock, IR JSON, and configured generated modules.
+QueryIR version 4 includes positional table-relation boundaries for every
+physical SQL statement. Generated TypeScript descriptors expose these as
+`relationPlans` for remote query registration. Regenerate existing query
+modules before upgrading the server.
 `--check` regenerates in memory and exits 1 unless every output on disk matches
 **byte-exactly**. `--watch` regenerates on any change under the manifest dir
 (Bun's recursive `fs.watch`, debounced; it skips the write when outputs are

package/dist/emit-queries-rust.js

@@ -675,7 +675,7 @@ function emitSupport(clientCrate) {
         '        ));',
         '    }',
         '    hex.as_bytes()',
-        '        .chunks_exact(2)',
+        '        .chunks(2)',
         '        .map(|pair| {',
         '            let pair = std::str::from_utf8(pair)',
         '                .map_err(|_| decode_error(query, column, "bytes", "non-ASCII $bytes envelope"))?;',

package/dist/emit-queries.js

@@ -223,14 +223,14 @@ function emitSyqlQuery(query, hash) {
             : `raw?: ${Params}`;
     const validated = hasParams ? `${query.name}Validate(raw)` : undefined;
     const statementType = hasParams
-        ? `{ sql: string; bind: (params: ${Params}) => QueryValue[] }`
-        : '{ sql: string; bind: () => QueryValue[] }';
-    lines.push(`const ${query.name}Statements: ${statementType}[] = [`);
+        ? `QueryRelationPlan & { bind: (params: ${Params}) => QueryValue[] }`
+        : 'QueryRelationPlan & { bind: () => QueryValue[] }';
+    lines.push(`const ${query.name}Statements: (${statementType})[] = [`);
     for (const statement of metadata.plan.statements) {
         const binds = statement.binds
             .map((bind) => syqlBindExpr(query, bind, 'params'))
             .join(', ');
-        lines.push(`  { sql: ${quote(statement.positionalSql)}, bind: (${hasParams ? 'params' : ''}) => [${binds}] },`);
+        lines.push(`  { sql: ${quote(statement.positionalSql)}, relations: ${JSON.stringify(statement.relations)}, bind: (${hasParams ? 'params' : ''}) => [${binds}] },`);
     }
     lines.push('];');
     const sort = inputs.find((input) => input.kind === 'sort');
@@ -272,6 +272,7 @@ function emitSyqlQuery(query, hash) {
         lines.push(`  sqlFor: (params: ${Params}) => ${query.name}Select(params).sql,`);
     }
     lines.push(`  tables: ${query.name}Tables,`);
+    lines.push(`  relationPlans: ${query.name}Statements,`);
     lines.push(`  resultColumns: [${query.columns.map((column) => `{ name: ${quote(column.langName)}, type: ${quote(column.type)}, nullable: ${column.nullable} }`).join(', ')}],`);
     const reactiveUsesParams = query.reactive.dependencies.some((dependency) => dependency.scopes.some((scope) => scope.params.length > 0));
     lines.push(`  dependencies: (${reactiveUsesParams ? 'params' : ''}) => [`);
@@ -360,6 +361,7 @@ function emitQuery(query, hash) {
     lines.push(`  sql: ${sqlConst},`);
     lines.push(`  mapRow: ${query.name}MapRow,`);
     lines.push(`  tables: ${query.name}Tables,`);
+    lines.push(`  relationPlans: [{ sql: ${sqlConst}, relations: ${JSON.stringify(query.relations)} }],`);
     lines.push(`  resultColumns: [${query.columns.map((column) => `{ name: ${quote(column.langName)}, type: ${quote(column.type)}, nullable: ${column.nullable} }`).join(', ')}],`);
     const reactiveUsesParams = query.reactive.dependencies.some((dependency) => dependency.scopes.some((scope) => scope.params.length > 0));
     lines.push(`  dependencies: (${reactiveUsesParams ? 'params' : ''}) => [`);
@@ -468,6 +470,11 @@ export function emitQueriesModule(queries, hash, irVersion) {
         " *  `@syncular/react`'s `useQuery`. `Row` is the projection row",
         ' *  type; `Params` is `undefined` for a param-less query. `sqlFor`',
         ' *  selects a checked revision-1 SYQL physical statement when needed. */',
+        'export interface QueryRelationPlan {',
+        '  readonly sql: string;',
+        '  readonly relations: readonly { readonly table: string; readonly start: number; readonly end: number; readonly alias?: string }[];',
+        '}',
+        '',
         'export interface NamedQuery<Row, Params = undefined> {',
         '  readonly id: string;',
         '  readonly hasParams: boolean;',
@@ -475,6 +482,7 @@ export function emitQueriesModule(queries, hash, irVersion) {
         '  readonly mapRow: (row: Readonly<Record<string, unknown>>) => Row;',
         '  readonly tables: readonly string[];',
         '  readonly resultColumns: readonly QueryResultColumn[];',
+        '  readonly relationPlans: readonly QueryRelationPlan[];',
         '  readonly bind: (params: Params) => readonly QueryValue[];',
         '  readonly sqlFor?: (params: Params) => string;',
         '  readonly dependencies: (params: Params) => readonly QueryDependency[];',

package/dist/query-ir.js

@@ -1,13 +1,14 @@
 /** Serialize analyzed queries as the deterministic QueryIR JSON document. */
 export function serializeQueryIr(queries) {
     const doc = {
-        queryIrVersion: 3,
+        queryIrVersion: 4,
         queries: queries.map((query) => ({
             name: query.name,
             file: query.file,
             sourceSql: query.sourceSql,
             sql: query.sql,
             positionalSql: query.positionalSql,
+            relations: query.relations,
             params: query.params.map((param) => ({
                 name: param.name,
                 langName: param.langName,
@@ -89,6 +90,7 @@ export function serializeQueryIr(queries) {
                                     : { activationMask: statement.activationMask }),
                                 sql: statement.sql,
                                 positionalSql: statement.positionalSql,
+                                relations: statement.relations,
                                 binds: statement.binds.map((bind) => ({ ...bind })),
                             })),
                         },

package/dist/query.d.ts

@@ -135,6 +135,7 @@ export interface QuerySyqlStatement {
     readonly sql: string;
     readonly positionalSql: string;
     readonly binds: readonly QuerySyqlPlanBind[];
+    readonly relations: readonly QueryRelation[];
 }
 /** The target-neutral physical plan every emitter must implement exactly. */
 export interface QuerySyqlExecutionPlan {
@@ -154,6 +155,13 @@ export interface QuerySyqlMetadata {
     readonly plan: QuerySyqlExecutionPlan;
     readonly identity?: readonly string[];
 }
+/** Physical relation boundaries in the exact positional SQL statement. */
+export interface QueryRelation {
+    readonly table: string;
+    readonly start: number;
+    readonly end: number;
+    readonly alias?: string;
+}
 export interface AnalyzedQuery {
     /** camelCase function name (path-derived, or a `-- name:` override). */
     readonly name: string;
@@ -168,6 +176,7 @@ export interface AnalyzedQuery {
     readonly sql: string;
     /** The lowered SQL with `:name` rewritten to positional `?`. */
     readonly positionalSql: string;
+    readonly relations: readonly QueryRelation[];
     /** Params in first-occurrence (positional) order. */
     readonly params: readonly QueryParam[];
     /** Result columns in SELECT order. */
@@ -219,6 +228,9 @@ export declare function stripCommentsAndStrings(sql: string): string;
 export declare function toPositionalSql(sql: string): string;
 export interface TableRef {
     readonly table: string;
+    readonly start: number;
+    readonly end: number;
+    readonly explicitAlias?: string;
     /** Alias (or the table name when un-aliased). */
     readonly alias: string;
     /** True when an enclosing flat join chain can null-extend this relation. */

package/dist/query.js

@@ -62,6 +62,7 @@
  * for the query shapes this tier supports.
  */
 import { TypegenError } from './errors.js';
+import { isSyqlTrivia, lexSyqlSqlSource } from './syql-lexer.js';
 import { lowerProjection, mainVerbAfterWith } from './lower.js';
 import { buildNamingMap } from './naming.js';
 /** The SQL decltype keyword → §2.4 type map (mirrors sql.ts TYPE_MAP so a
@@ -450,6 +451,7 @@ const RESERVED_ALIAS = new Set([
     'inner',
     'left',
     'right',
+    'full',
     'outer',
     'natural',
     'join',
@@ -457,179 +459,192 @@ const RESERVED_ALIAS = new Set([
     'using',
     'limit',
     'having',
+    'union',
+    'intersect',
+    'except',
+    'offset',
+    'window',
+    'indexed',
+    'not',
 ]);
-const RESERVED_ALIAS_PATTERN = [...RESERVED_ALIAS].join('|');
-const TABLE_REF_RE = new RegExp(`\\b(FROM|(?:NATURAL\\s+)?(?:(LEFT|RIGHT|FULL)(?:\\s+OUTER)?|INNER|CROSS)?\\s*JOIN)\\s+((?:\\(\\s*)*)(${IDENT})(?:\\s+(?:AS\\s+)?((?!(?:${RESERVED_ALIAS_PATTERN})\\b)${IDENT}))?`, 'gi');
-function parenthesisDepthAt(sql, index) {
-    let depth = 0;
-    for (let cursor = 0; cursor < index; cursor += 1) {
-        if (sql[cursor] === '(')
-            depth += 1;
-        else if (sql[cursor] === ')')
-            depth = Math.max(0, depth - 1);
-    }
-    return depth;
-}
-function matchingParenthesis(sql, open) {
-    let depth = 0;
-    for (let cursor = open; cursor < sql.length; cursor += 1) {
-        if (sql[cursor] === '(')
-            depth += 1;
-        else if (sql[cursor] === ')') {
-            depth -= 1;
-            if (depth === 0)
-                return cursor;
-        }
-    }
-    return sql.length;
+function sqlIdentifier(token) {
+    if (token?.kind === 'identifier')
+        return token.text;
+    if (token?.kind !== 'quoted-identifier')
+        return undefined;
+    const quote = token.text[0];
+    const value = token.text.slice(1, -1);
+    return quote === '[' ? value : value.split(`${quote}${quote}`).join(quote);
 }
-function hasCommaJoinedSchemaTable(sql, ir) {
-    const cleaned = stripCommentsAndStrings(sql);
-    const known = new Set(ir.tables.flatMap((table) => [
-        table.name.toLowerCase(),
-        ...table.ftsIndexes.map((index) => index.name.toLowerCase()),
+export function scanTableRefs(sql, ir) {
+    const tokens = lexSyqlSqlSource('query SQL', sql).filter((token) => !isSyqlTrivia(token) && token.kind !== 'eof');
+    const known = new Map(ir.tables.flatMap((table) => [
+        [table.name.toLowerCase(), table.name],
+        ...table.ftsIndexes.map((index) => [index.name.toLowerCase(), index.name]),
     ]));
+    const closes = new Map();
+    const parents = [];
+    const depths = [];
+    const stack = [];
+    tokens.forEach((token, index) => {
+        if (token.text === ')') {
+            const open = stack.pop();
+            if (open !== undefined)
+                closes.set(open, index);
+        }
+        parents[index] = stack.at(-1) ?? -1;
+        depths[index] = stack.length;
+        if (token.text === '(')
+            stack.push(index);
+    });
     const activeFromDepths = new Set();
     const clauseEnders = new Set([
-        'WHERE',
-        'GROUP',
-        'HAVING',
-        'ORDER',
-        'LIMIT',
-        'WINDOW',
-        'UNION',
-        'EXCEPT',
-        'INTERSECT',
-        'RETURNING',
+        'where',
+        'group',
+        'having',
+        'order',
+        'limit',
+        'window',
+        'union',
+        'except',
+        'intersect',
+        'returning',
     ]);
-    let depth = 0;
-    let cursor = 0;
-    /** The previous significant token: an uppercased word or a single
-     * punctuation character. Distinguishes a table-source group — a `(` after
-     * FROM, JOIN, `,` or another `(` — from a function call or parenthesized
-     * expression, whose `(` follows an identifier or an operator. */
-    let previous;
-    const nextIdentifier = (start) => {
-        let index = start;
-        while (index < cleaned.length &&
-            (/\s/.test(cleaned[index]) || cleaned[index] === '(')) {
-            index += 1;
+    for (const [index, token] of tokens.entries()) {
+        const depth = depths[index] ?? 0;
+        const word = token.kind === 'identifier' ? token.text.toLowerCase() : undefined;
+        if (word === 'in' && sqlIdentifier(tokens[index + 1]) !== undefined) {
+            throw new TypegenError('query SQL', 'table-name IN expressions are unsupported; use an explicit SELECT subquery');
         }
-        const match = /^[A-Za-z_][A-Za-z0-9_]*/.exec(cleaned.slice(index));
-        return match?.[0];
-    };
-    while (cursor < cleaned.length) {
-        const char = cleaned[cursor];
-        if (/\s/.test(char)) {
-            cursor += 1;
-            continue;
-        }
-        if (char === '(') {
-            const opensTableSource = previous === 'FROM' ||
-                previous === 'JOIN' ||
-                previous === ',' ||
-                previous === '(';
-            const next = nextIdentifier(cursor + 1);
-            if (opensTableSource &&
-                activeFromDepths.has(depth) &&
-                next !== undefined &&
-                known.has(next.toLowerCase())) {
+        if (word === 'from')
+            activeFromDepths.add(depth);
+        else if (word !== undefined && clauseEnders.has(word))
+            activeFromDepths.delete(depth);
+        else if (token.text === ')')
+            activeFromDepths.delete(depth + 1);
+        else if (token.text === '(' && activeFromDepths.has(depth)) {
+            const previous = tokens[index - 1]?.text.toLowerCase();
+            const next = tokens[index + 1];
+            if (previous !== undefined &&
+                ['from', 'join', ',', '('].includes(previous) &&
+                !(next?.kind === 'identifier' &&
+                    ['select', 'with', 'values'].includes(next.text.toLowerCase()))) {
                 activeFromDepths.add(depth + 1);
             }
-            depth += 1;
-            previous = '(';
-            cursor += 1;
-            continue;
         }
-        if (char === ')') {
-            activeFromDepths.delete(depth);
-            depth = Math.max(0, depth - 1);
-            previous = ')';
-            cursor += 1;
-            continue;
-        }
-        if (char === ',' && activeFromDepths.has(depth)) {
-            const next = nextIdentifier(cursor + 1);
-            if (next !== undefined && known.has(next.toLowerCase()))
-                return true;
-            previous = ',';
-            cursor += 1;
-            continue;
+        else if (token.text === ',' && activeFromDepths.has(depth)) {
+            throw new TypegenError('query SQL', 'comma-separated table sources are unsupported because reactive proof requires every relation; use an explicit JOIN ... ON clause');
         }
-        if (/[A-Za-z_]/.test(char)) {
-            let end = cursor + 1;
-            while (end < cleaned.length &&
-                /[A-Za-z0-9_]/.test(cleaned[end])) {
-                end += 1;
-            }
-            const word = cleaned.slice(cursor, end).toUpperCase();
-            if (word === 'FROM')
-                activeFromDepths.add(depth);
-            else if (clauseEnders.has(word))
-                activeFromDepths.delete(depth);
-            previous = word;
-            cursor = end;
+    }
+    const ctes = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (token?.kind !== 'identifier' || token.text.toLowerCase() !== 'with')
             continue;
+        const scopeEnd = closes.get(parents[index] ?? -1) ?? tokens.length;
+        let cursor = index + 1;
+        if (tokens[cursor]?.text.toLowerCase() === 'recursive')
+            cursor += 1;
+        for (;;) {
+            const name = sqlIdentifier(tokens[cursor]);
+            if (name === undefined)
+                break;
+            cursor += 1;
+            if (tokens[cursor]?.text === '(')
+                cursor = (closes.get(cursor) ?? scopeEnd) + 1;
+            if (tokens[cursor]?.text.toLowerCase() !== 'as')
+                break;
+            cursor += 1;
+            if (tokens[cursor]?.text.toLowerCase() === 'not')
+                cursor += 1;
+            if (tokens[cursor]?.text.toLowerCase() === 'materialized')
+                cursor += 1;
+            if (tokens[cursor]?.text !== '(')
+                break;
+            ctes.push({ name: name.toLowerCase(), start: index, end: scopeEnd });
+            cursor = (closes.get(cursor) ?? scopeEnd) + 1;
+            if (tokens[cursor]?.text !== ',')
+                break;
+            cursor += 1;
         }
-        previous = char;
-        cursor += 1;
     }
-    return false;
-}
-export function scanTableRefs(sql, ir) {
-    const cleaned = stripCommentsAndStrings(sql);
-    const known = new Map(ir.tables.flatMap((table) => [
-        [table.name.toLowerCase(), table.name],
-        ...table.ftsIndexes.map((index) => [index.name.toLowerCase(), index.name]),
-    ]));
-    const nullableGroups = [
-        ...cleaned.matchAll(/\b(?:LEFT|FULL)(?:\s+OUTER)?\s+JOIN\s*(\()/gi),
-    ].map((match) => {
-        const open = (match.index ?? 0) + match[0].lastIndexOf('(');
-        return { open, close: matchingParenthesis(cleaned, open) };
-    });
     const refs = [];
     const relationStartByDepth = new Map();
-    for (const m of cleaned.matchAll(TABLE_REF_RE)) {
-        const operator = m[1].toUpperCase();
-        const outerKind = m[2]?.toUpperCase();
-        const rawTable = m[4];
-        const operatorDepth = parenthesisDepthAt(cleaned, m.index ?? 0);
-        const relativeTableIndex = m[0]
-            .toLowerCase()
-            .indexOf(rawTable.toLowerCase(), m[1].length);
-        const tableIndex = (m.index ?? 0) + Math.max(m[1].length, relativeTableIndex);
-        const tableDepth = parenthesisDepthAt(cleaned, tableIndex);
-        if (operator === 'FROM') {
+    const nullableGroups = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (token?.kind !== 'identifier')
+            continue;
+        const operator = token.text.toLowerCase();
+        if (operator !== 'from' && operator !== 'join')
+            continue;
+        let outerKind;
+        if (operator === 'join') {
+            let previous = index - 1;
+            if (tokens[previous]?.text.toLowerCase() === 'outer')
+                previous -= 1;
+            if (tokens[previous]?.kind === 'identifier')
+                outerKind = tokens[previous]?.text.toLowerCase();
+        }
+        const operatorDepth = depths[index] ?? 0;
+        let cursor = index + 1;
+        if (operator === 'from')
             relationStartByDepth.set(operatorDepth, refs.length);
-            relationStartByDepth.set(tableDepth, refs.length);
+        if (outerKind === 'right' || outerKind === 'full') {
+            for (let prior = relationStartByDepth.get(operatorDepth) ?? refs.length; prior < refs.length; prior += 1) {
+                const ref = refs[prior];
+                if (ref !== undefined)
+                    refs[prior] = { ...ref, nullable: true };
+            }
         }
-        else if (tableDepth > operatorDepth &&
-            !relationStartByDepth.has(tableDepth)) {
-            relationStartByDepth.set(tableDepth, refs.length);
+        if ((outerKind === 'left' || outerKind === 'full') &&
+            tokens[cursor]?.text === '(') {
+            nullableGroups.push({
+                start: cursor,
+                end: closes.get(cursor) ?? tokens.length,
+            });
         }
-        if (outerKind === 'RIGHT' || outerKind === 'FULL') {
-            const relationStart = relationStartByDepth.get(operatorDepth) ?? refs.length;
-            for (let index = relationStart; index < refs.length; index += 1) {
-                const prior = refs[index];
-                if (prior !== undefined && !prior.nullable) {
-                    refs[index] = { ...prior, nullable: true };
-                }
-            }
+        while (tokens[cursor]?.text === '(')
+            cursor += 1;
+        const tableToken = tokens[cursor];
+        if (tableToken?.kind === 'identifier' &&
+            ['select', 'with', 'values'].includes(tableToken.text.toLowerCase()))
+            continue;
+        const rawTable = sqlIdentifier(tableToken);
+        if (rawTable === undefined || tableToken === undefined) {
+            throw new TypegenError('query SQL', 'cannot resolve table relation');
         }
+        if (tokens[cursor + 1]?.text === '.') {
+            throw new TypegenError('query SQL', 'schema-qualified relations are unsupported; use application table names');
+        }
+        if (ctes.some((cte) => cte.name === rawTable.toLowerCase() &&
+            cursor > cte.start &&
+            cursor < cte.end))
+            continue;
         const table = known.get(rawTable.toLowerCase());
         if (table === undefined)
-            continue; // e.g. a derived SELECT/CTE name
-        let alias = m[5];
-        if (alias !== undefined && RESERVED_ALIAS.has(alias.toLowerCase())) {
-            alias = undefined;
-        }
+            throw new TypegenError('query SQL', `unresolved table relation ${JSON.stringify(rawTable)}`);
+        const tableDepth = depths[cursor] ?? operatorDepth;
+        if (operator === 'from' || !relationStartByDepth.has(tableDepth))
+            relationStartByDepth.set(tableDepth, refs.length);
+        let aliasToken = tokens[cursor + 1];
+        if (aliasToken?.kind === 'identifier' &&
+            aliasToken.text.toLowerCase() === 'as')
+            aliasToken = tokens[cursor + 2];
+        const explicitAlias = aliasToken?.kind === 'quoted-identifier' ||
+            (aliasToken?.kind === 'identifier' &&
+                !RESERVED_ALIAS.has(aliasToken.text.toLowerCase()))
+            ? sqlIdentifier(aliasToken)
+            : undefined;
         refs.push({
             table,
-            alias: alias ?? table,
-            nullable: outerKind === 'LEFT' ||
-                outerKind === 'FULL' ||
-                nullableGroups.some((group) => tableIndex > group.open && tableIndex < group.close),
+            start: tableToken.span.start.offset,
+            end: tableToken.span.end.offset,
+            alias: explicitAlias ?? table,
+            ...(explicitAlias === undefined ? {} : { explicitAlias }),
+            nullable: outerKind === 'left' ||
+                outerKind === 'full' ||
+                nullableGroups.some((group) => cursor > group.start && cursor < group.end),
         });
     }
     return refs;
@@ -1063,9 +1078,6 @@ export function analyzeStatement(name, location, statementText, ir, db, naming =
     if (sourceSql.length === 0) {
         throw new TypegenError(file, 'query file is empty');
     }
-    if (hasCommaJoinedSchemaTable(sourceSql, ir)) {
-        throw new TypegenError(file, 'comma-separated table sources are unsupported because reactive proof requires every relation; use an explicit JOIN ... ON clause');
-    }
     // SELECT-only (the read tier). A `WITH` is allowed when its main statement
     // is a SELECT (SQLite also allows WITH … INSERT/UPDATE/DELETE — writes).
     const firstKeyword = /^\s*([A-Za-z]+)/.exec(stripCommentsAndStrings(statementText).trimStart())?.[1];
@@ -1207,6 +1219,12 @@ export function analyzeStatement(name, location, statementText, ir, db, naming =
         sourceSql,
         sql,
         positionalSql: toPositionalSql(sql),
+        relations: scanTableRefs(toPositionalSql(sql), ir).map((ref) => ({
+            table: ref.table,
+            start: ref.start,
+            end: ref.end,
+            ...(ref.explicitAlias === undefined ? {} : { alias: ref.explicitAlias }),
+        })),
         params,
         columns,
         tables,

package/dist/syql-lowering.js

@@ -309,6 +309,7 @@ function lowerStatement(validated, ir, db, naming, sql, sortProfile, activationM
             ...(activationMask === undefined ? {} : { activationMask }),
             sql: namedSql,
             positionalSql: analyzed.positionalSql,
+            relations: analyzed.relations,
             binds: bindNames.map((name) => planBind(name, owners, conditionBinds, query.conditions, validated.limit, query)),
         },
         analysis: { ...analyzed, sourceSql: namedSql, sql: namedSql },

package/dist/syql-validator.js

@@ -303,7 +303,15 @@ class Validator {
         const activeStructure = this.#inspect(activeSql, location);
         this.#validateStatementShape(activeSql, activeStructure, logical.declaration, location);
         this.#validateDeterminism(activeSql, logical.declaration.statement.span);
-        const refs = scanTableRefs(activeSql, this.#ir);
+        let refs;
+        try {
+            refs = scanTableRefs(activeSql, this.#ir);
+        }
+        catch (error) {
+            // Preserve SQLite's source-spanned diagnostics for invalid relations.
+            this.#validateSqlite(activeSql, logical, []);
+            this.#fail('SYQL6002_INVALID_SQL', logical.declaration.statement.span, error instanceof Error ? error.message : String(error));
+        }
         this.#validatePortableProfile(activeSql, logical.declaration.statement.span, refs);
         this.#validateSqlite(activeSql, logical, refs);
         const bindSymbols = this.#bindSymbols(logical.declaration);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/typegen",
-  "version": "0.15.48",
+  "version": "0.17.0",
   "description": "Syncular schema-to-TypeScript type generator and the `syncular` CLI",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -56,9 +56,9 @@
     "!dist/**/*.test.d.ts"
   ],
   "dependencies": {
-    "@syncular/core": "0.15.48"
+    "@syncular/core": "0.17.0"
   },
   "devDependencies": {
-    "@syncular/server": "0.15.48"
+    "@syncular/server": "0.17.0"
   }
 }

package/src/emit-queries-rust.ts

@@ -892,7 +892,7 @@ function emitSupport(clientCrate: string): string {
     '        ));',
     '    }',
     '    hex.as_bytes()',
-    '        .chunks_exact(2)',
+    '        .chunks(2)',
     '        .map(|pair| {',
     '            let pair = std::str::from_utf8(pair)',
     '                .map_err(|_| decode_error(query, column, "bytes", "non-ASCII $bytes envelope"))?;',

package/src/emit-queries.ts

@@ -314,15 +314,15 @@ function emitSyqlQuery(query: AnalyzedQuery, hash: string): string {
       : `raw?: ${Params}`;
   const validated = hasParams ? `${query.name}Validate(raw)` : undefined;
   const statementType = hasParams
-    ? `{ sql: string; bind: (params: ${Params}) => QueryValue[] }`
-    : '{ sql: string; bind: () => QueryValue[] }';
-  lines.push(`const ${query.name}Statements: ${statementType}[] = [`);
+    ? `QueryRelationPlan & { bind: (params: ${Params}) => QueryValue[] }`
+    : 'QueryRelationPlan & { bind: () => QueryValue[] }';
+  lines.push(`const ${query.name}Statements: (${statementType})[] = [`);
   for (const statement of metadata.plan.statements) {
     const binds = statement.binds
       .map((bind) => syqlBindExpr(query, bind, 'params'))
       .join(', ');
     lines.push(
-      `  { sql: ${quote(statement.positionalSql)}, bind: (${hasParams ? 'params' : ''}) => [${binds}] },`,
+      `  { sql: ${quote(statement.positionalSql)}, relations: ${JSON.stringify(statement.relations)}, bind: (${hasParams ? 'params' : ''}) => [${binds}] },`,
     );
   }
   lines.push('];');
@@ -399,6 +399,7 @@ function emitSyqlQuery(query: AnalyzedQuery, hash: string): string {
     );
   }
   lines.push(`  tables: ${query.name}Tables,`);
+  lines.push(`  relationPlans: ${query.name}Statements,`);
   lines.push(
     `  resultColumns: [${query.columns.map((column) => `{ name: ${quote(column.langName)}, type: ${quote(column.type)}, nullable: ${column.nullable} }`).join(', ')}],`,
   );
@@ -540,6 +541,9 @@ function emitQuery(query: AnalyzedQuery, hash: string): string {
   lines.push(`  sql: ${sqlConst},`);
   lines.push(`  mapRow: ${query.name}MapRow,`);
   lines.push(`  tables: ${query.name}Tables,`);
+  lines.push(
+    `  relationPlans: [{ sql: ${sqlConst}, relations: ${JSON.stringify(query.relations)} }],`,
+  );
   lines.push(
     `  resultColumns: [${query.columns.map((column) => `{ name: ${quote(column.langName)}, type: ${quote(column.type)}, nullable: ${column.nullable} }`).join(', ')}],`,
   );
@@ -683,6 +687,11 @@ export function emitQueriesModule(
       " *  `@syncular/react`'s `useQuery`. `Row` is the projection row",
       ' *  type; `Params` is `undefined` for a param-less query. `sqlFor`',
       ' *  selects a checked revision-1 SYQL physical statement when needed. */',
+      'export interface QueryRelationPlan {',
+      '  readonly sql: string;',
+      '  readonly relations: readonly { readonly table: string; readonly start: number; readonly end: number; readonly alias?: string }[];',
+      '}',
+      '',
       'export interface NamedQuery<Row, Params = undefined> {',
       '  readonly id: string;',
       '  readonly hasParams: boolean;',
@@ -690,6 +699,7 @@ export function emitQueriesModule(
       '  readonly mapRow: (row: Readonly<Record<string, unknown>>) => Row;',
       '  readonly tables: readonly string[];',
       '  readonly resultColumns: readonly QueryResultColumn[];',
+      '  readonly relationPlans: readonly QueryRelationPlan[];',
       '  readonly bind: (params: Params) => readonly QueryValue[];',
       '  readonly sqlFor?: (params: Params) => string;',
       '  readonly dependencies: (params: Params) => readonly QueryDependency[];',

package/src/query-ir.ts

@@ -14,13 +14,14 @@ import type { AnalyzedQuery } from './query';
 /** Serialize analyzed queries as the deterministic QueryIR JSON document. */
 export function serializeQueryIr(queries: readonly AnalyzedQuery[]): string {
   const doc = {
-    queryIrVersion: 3,
+    queryIrVersion: 4,
     queries: queries.map((query) => ({
       name: query.name,
       file: query.file,
       sourceSql: query.sourceSql,
       sql: query.sql,
       positionalSql: query.positionalSql,
+      relations: query.relations,
       params: query.params.map((param) => ({
         name: param.name,
         langName: param.langName,
@@ -101,6 +102,7 @@ export function serializeQueryIr(queries: readonly AnalyzedQuery[]): string {
                     : { activationMask: statement.activationMask }),
                   sql: statement.sql,
                   positionalSql: statement.positionalSql,
+                  relations: statement.relations,
                   binds: statement.binds.map((bind) => ({ ...bind })),
                 })),
               },

package/src/query.ts

@@ -62,6 +62,7 @@
  * for the query shapes this tier supports.
  */
 import { TypegenError } from './errors';
+import { isSyqlTrivia, lexSyqlSqlSource, type SyqlToken } from './syql-lexer';
 import type { IrColumn, IrColumnType, IrDocument, IrTable } from './ir';
 import { lowerProjection, mainVerbAfterWith } from './lower';
 import { buildNamingMap, type NamingMode, type NamingTarget } from './naming';
@@ -245,6 +246,7 @@ export interface QuerySyqlStatement {
   readonly sql: string;
   readonly positionalSql: string;
   readonly binds: readonly QuerySyqlPlanBind[];
+  readonly relations: readonly QueryRelation[];
 }
 
 /** The target-neutral physical plan every emitter must implement exactly. */
@@ -267,6 +269,14 @@ export interface QuerySyqlMetadata {
   readonly identity?: readonly string[];
 }
 
+/** Physical relation boundaries in the exact positional SQL statement. */
+export interface QueryRelation {
+  readonly table: string;
+  readonly start: number;
+  readonly end: number;
+  readonly alias?: string;
+}
+
 export interface AnalyzedQuery {
   /** camelCase function name (path-derived, or a `-- name:` override). */
   readonly name: string;
@@ -281,6 +291,7 @@ export interface AnalyzedQuery {
   readonly sql: string;
   /** The lowered SQL with `:name` rewritten to positional `?`. */
   readonly positionalSql: string;
+  readonly relations: readonly QueryRelation[];
   /** Params in first-occurrence (positional) order. */
   readonly params: readonly QueryParam[];
   /** Result columns in SELECT order. */
@@ -692,6 +703,9 @@ export function toPositionalSql(sql: string): string {
 
 export interface TableRef {
   readonly table: string;
+  readonly start: number;
+  readonly end: number;
+  readonly explicitAlias?: string;
   /** Alias (or the table name when un-aliased). */
   readonly alias: string;
   /** True when an enclosing flat join chain can null-extend this relation. */
@@ -709,6 +723,7 @@ const RESERVED_ALIAS = new Set([
   'inner',
   'left',
   'right',
+  'full',
   'outer',
   'natural',
   'join',
@@ -716,197 +731,215 @@ const RESERVED_ALIAS = new Set([
   'using',
   'limit',
   'having',
+  'union',
+  'intersect',
+  'except',
+  'offset',
+  'window',
+  'indexed',
+  'not',
 ]);
-const RESERVED_ALIAS_PATTERN = [...RESERVED_ALIAS].join('|');
-const TABLE_REF_RE = new RegExp(
-  `\\b(FROM|(?:NATURAL\\s+)?(?:(LEFT|RIGHT|FULL)(?:\\s+OUTER)?|INNER|CROSS)?\\s*JOIN)\\s+((?:\\(\\s*)*)(${IDENT})(?:\\s+(?:AS\\s+)?((?!(?:${RESERVED_ALIAS_PATTERN})\\b)${IDENT}))?`,
-  'gi',
-);
-
-function parenthesisDepthAt(sql: string, index: number): number {
-  let depth = 0;
-  for (let cursor = 0; cursor < index; cursor += 1) {
-    if (sql[cursor] === '(') depth += 1;
-    else if (sql[cursor] === ')') depth = Math.max(0, depth - 1);
-  }
-  return depth;
+function sqlIdentifier(token: SyqlToken | undefined): string | undefined {
+  if (token?.kind === 'identifier') return token.text;
+  if (token?.kind !== 'quoted-identifier') return undefined;
+  const quote = token.text[0];
+  const value = token.text.slice(1, -1);
+  return quote === '[' ? value : value.split(`${quote}${quote}`).join(quote);
 }
 
-function matchingParenthesis(sql: string, open: number): number {
-  let depth = 0;
-  for (let cursor = open; cursor < sql.length; cursor += 1) {
-    if (sql[cursor] === '(') depth += 1;
-    else if (sql[cursor] === ')') {
-      depth -= 1;
-      if (depth === 0) return cursor;
-    }
-  }
-  return sql.length;
-}
-
-function hasCommaJoinedSchemaTable(sql: string, ir: IrDocument): boolean {
-  const cleaned = stripCommentsAndStrings(sql);
-  const known = new Set(
+export function scanTableRefs(sql: string, ir: IrDocument): TableRef[] {
+  const tokens = lexSyqlSqlSource('query SQL', sql).filter(
+    (token) => !isSyqlTrivia(token) && token.kind !== 'eof',
+  );
+  const known = new Map(
     ir.tables.flatMap((table) => [
-      table.name.toLowerCase(),
-      ...table.ftsIndexes.map((index) => index.name.toLowerCase()),
+      [table.name.toLowerCase(), table.name] as const,
+      ...table.ftsIndexes.map(
+        (index) => [index.name.toLowerCase(), index.name] as const,
+      ),
     ]),
   );
+  const closes = new Map<number, number>();
+  const parents: number[] = [];
+  const depths: number[] = [];
+  const stack: number[] = [];
+  tokens.forEach((token, index) => {
+    if (token.text === ')') {
+      const open = stack.pop();
+      if (open !== undefined) closes.set(open, index);
+    }
+    parents[index] = stack.at(-1) ?? -1;
+    depths[index] = stack.length;
+    if (token.text === '(') stack.push(index);
+  });
   const activeFromDepths = new Set<number>();
   const clauseEnders = new Set([
-    'WHERE',
-    'GROUP',
-    'HAVING',
-    'ORDER',
-    'LIMIT',
-    'WINDOW',
-    'UNION',
-    'EXCEPT',
-    'INTERSECT',
-    'RETURNING',
+    'where',
+    'group',
+    'having',
+    'order',
+    'limit',
+    'window',
+    'union',
+    'except',
+    'intersect',
+    'returning',
   ]);
-  let depth = 0;
-  let cursor = 0;
-  /** The previous significant token: an uppercased word or a single
-   * punctuation character. Distinguishes a table-source group — a `(` after
-   * FROM, JOIN, `,` or another `(` — from a function call or parenthesized
-   * expression, whose `(` follows an identifier or an operator. */
-  let previous: string | undefined;
-  const nextIdentifier = (start: number): string | undefined => {
-    let index = start;
-    while (
-      index < cleaned.length &&
-      (/\s/.test(cleaned[index] as string) || cleaned[index] === '(')
-    ) {
-      index += 1;
-    }
-    const match = /^[A-Za-z_][A-Za-z0-9_]*/.exec(cleaned.slice(index));
-    return match?.[0];
-  };
-
-  while (cursor < cleaned.length) {
-    const char = cleaned[cursor] as string;
-    if (/\s/.test(char)) {
-      cursor += 1;
-      continue;
+  for (const [index, token] of tokens.entries()) {
+    const depth = depths[index] ?? 0;
+    const word =
+      token.kind === 'identifier' ? token.text.toLowerCase() : undefined;
+    if (word === 'in' && sqlIdentifier(tokens[index + 1]) !== undefined) {
+      throw new TypegenError(
+        'query SQL',
+        'table-name IN expressions are unsupported; use an explicit SELECT subquery',
+      );
     }
-    if (char === '(') {
-      const opensTableSource =
-        previous === 'FROM' ||
-        previous === 'JOIN' ||
-        previous === ',' ||
-        previous === '(';
-      const next = nextIdentifier(cursor + 1);
+    if (word === 'from') activeFromDepths.add(depth);
+    else if (word !== undefined && clauseEnders.has(word))
+      activeFromDepths.delete(depth);
+    else if (token.text === ')') activeFromDepths.delete(depth + 1);
+    else if (token.text === '(' && activeFromDepths.has(depth)) {
+      const previous = tokens[index - 1]?.text.toLowerCase();
+      const next = tokens[index + 1];
       if (
-        opensTableSource &&
-        activeFromDepths.has(depth) &&
-        next !== undefined &&
-        known.has(next.toLowerCase())
+        previous !== undefined &&
+        ['from', 'join', ',', '('].includes(previous) &&
+        !(
+          next?.kind === 'identifier' &&
+          ['select', 'with', 'values'].includes(next.text.toLowerCase())
+        )
       ) {
         activeFromDepths.add(depth + 1);
       }
-      depth += 1;
-      previous = '(';
-      cursor += 1;
-      continue;
+    } else if (token.text === ',' && activeFromDepths.has(depth)) {
+      throw new TypegenError(
+        'query SQL',
+        'comma-separated table sources are unsupported because reactive proof requires every relation; use an explicit JOIN ... ON clause',
+      );
     }
-    if (char === ')') {
-      activeFromDepths.delete(depth);
-      depth = Math.max(0, depth - 1);
-      previous = ')';
-      cursor += 1;
+  }
+  const ctes: { name: string; start: number; end: number }[] = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token?.kind !== 'identifier' || token.text.toLowerCase() !== 'with')
       continue;
-    }
-    if (char === ',' && activeFromDepths.has(depth)) {
-      const next = nextIdentifier(cursor + 1);
-      if (next !== undefined && known.has(next.toLowerCase())) return true;
-      previous = ',';
+    const scopeEnd = closes.get(parents[index] ?? -1) ?? tokens.length;
+    let cursor = index + 1;
+    if (tokens[cursor]?.text.toLowerCase() === 'recursive') cursor += 1;
+    for (;;) {
+      const name = sqlIdentifier(tokens[cursor]);
+      if (name === undefined) break;
+      cursor += 1;
+      if (tokens[cursor]?.text === '(')
+        cursor = (closes.get(cursor) ?? scopeEnd) + 1;
+      if (tokens[cursor]?.text.toLowerCase() !== 'as') break;
+      cursor += 1;
+      if (tokens[cursor]?.text.toLowerCase() === 'not') cursor += 1;
+      if (tokens[cursor]?.text.toLowerCase() === 'materialized') cursor += 1;
+      if (tokens[cursor]?.text !== '(') break;
+      ctes.push({ name: name.toLowerCase(), start: index, end: scopeEnd });
+      cursor = (closes.get(cursor) ?? scopeEnd) + 1;
+      if (tokens[cursor]?.text !== ',') break;
       cursor += 1;
-      continue;
-    }
-    if (/[A-Za-z_]/.test(char)) {
-      let end = cursor + 1;
-      while (
-        end < cleaned.length &&
-        /[A-Za-z0-9_]/.test(cleaned[end] as string)
-      ) {
-        end += 1;
-      }
-      const word = cleaned.slice(cursor, end).toUpperCase();
-      if (word === 'FROM') activeFromDepths.add(depth);
-      else if (clauseEnders.has(word)) activeFromDepths.delete(depth);
-      previous = word;
-      cursor = end;
-      continue;
     }
-    previous = char;
-    cursor += 1;
   }
-  return false;
-}
-
-export function scanTableRefs(sql: string, ir: IrDocument): TableRef[] {
-  const cleaned = stripCommentsAndStrings(sql);
-  const known = new Map(
-    ir.tables.flatMap((table) => [
-      [table.name.toLowerCase(), table.name] as const,
-      ...table.ftsIndexes.map(
-        (index) => [index.name.toLowerCase(), index.name] as const,
-      ),
-    ]),
-  );
-  const nullableGroups = [
-    ...cleaned.matchAll(/\b(?:LEFT|FULL)(?:\s+OUTER)?\s+JOIN\s*(\()/gi),
-  ].map((match) => {
-    const open = (match.index ?? 0) + match[0].lastIndexOf('(');
-    return { open, close: matchingParenthesis(cleaned, open) };
-  });
   const refs: TableRef[] = [];
   const relationStartByDepth = new Map<number, number>();
-  for (const m of cleaned.matchAll(TABLE_REF_RE)) {
-    const operator = (m[1] as string).toUpperCase();
-    const outerKind = m[2]?.toUpperCase();
-    const rawTable = m[4] as string;
-    const operatorDepth = parenthesisDepthAt(cleaned, m.index ?? 0);
-    const relativeTableIndex = m[0]
-      .toLowerCase()
-      .indexOf(rawTable.toLowerCase(), (m[1] as string).length);
-    const tableIndex =
-      (m.index ?? 0) + Math.max((m[1] as string).length, relativeTableIndex);
-    const tableDepth = parenthesisDepthAt(cleaned, tableIndex);
-    if (operator === 'FROM') {
+  const nullableGroups: { start: number; end: number }[] = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token?.kind !== 'identifier') continue;
+    const operator = token.text.toLowerCase();
+    if (operator !== 'from' && operator !== 'join') continue;
+    let outerKind: string | undefined;
+    if (operator === 'join') {
+      let previous = index - 1;
+      if (tokens[previous]?.text.toLowerCase() === 'outer') previous -= 1;
+      if (tokens[previous]?.kind === 'identifier')
+        outerKind = tokens[previous]?.text.toLowerCase();
+    }
+    const operatorDepth = depths[index] ?? 0;
+    let cursor = index + 1;
+    if (operator === 'from')
       relationStartByDepth.set(operatorDepth, refs.length);
-      relationStartByDepth.set(tableDepth, refs.length);
-    } else if (
-      tableDepth > operatorDepth &&
-      !relationStartByDepth.has(tableDepth)
+    if (outerKind === 'right' || outerKind === 'full') {
+      for (
+        let prior = relationStartByDepth.get(operatorDepth) ?? refs.length;
+        prior < refs.length;
+        prior += 1
+      ) {
+        const ref = refs[prior];
+        if (ref !== undefined) refs[prior] = { ...ref, nullable: true };
+      }
+    }
+    if (
+      (outerKind === 'left' || outerKind === 'full') &&
+      tokens[cursor]?.text === '('
     ) {
-      relationStartByDepth.set(tableDepth, refs.length);
+      nullableGroups.push({
+        start: cursor,
+        end: closes.get(cursor) ?? tokens.length,
+      });
     }
-    if (outerKind === 'RIGHT' || outerKind === 'FULL') {
-      const relationStart =
-        relationStartByDepth.get(operatorDepth) ?? refs.length;
-      for (let index = relationStart; index < refs.length; index += 1) {
-        const prior = refs[index];
-        if (prior !== undefined && !prior.nullable) {
-          refs[index] = { ...prior, nullable: true };
-        }
-      }
+    while (tokens[cursor]?.text === '(') cursor += 1;
+    const tableToken = tokens[cursor];
+    if (
+      tableToken?.kind === 'identifier' &&
+      ['select', 'with', 'values'].includes(tableToken.text.toLowerCase())
+    )
+      continue;
+    const rawTable = sqlIdentifier(tableToken);
+    if (rawTable === undefined || tableToken === undefined) {
+      throw new TypegenError('query SQL', 'cannot resolve table relation');
     }
-    const table = known.get(rawTable.toLowerCase());
-    if (table === undefined) continue; // e.g. a derived SELECT/CTE name
-    let alias = m[5];
-    if (alias !== undefined && RESERVED_ALIAS.has(alias.toLowerCase())) {
-      alias = undefined;
+    if (tokens[cursor + 1]?.text === '.') {
+      throw new TypegenError(
+        'query SQL',
+        'schema-qualified relations are unsupported; use application table names',
+      );
     }
+    if (
+      ctes.some(
+        (cte) =>
+          cte.name === rawTable.toLowerCase() &&
+          cursor > cte.start &&
+          cursor < cte.end,
+      )
+    )
+      continue;
+    const table = known.get(rawTable.toLowerCase());
+    if (table === undefined)
+      throw new TypegenError(
+        'query SQL',
+        `unresolved table relation ${JSON.stringify(rawTable)}`,
+      );
+    const tableDepth = depths[cursor] ?? operatorDepth;
+    if (operator === 'from' || !relationStartByDepth.has(tableDepth))
+      relationStartByDepth.set(tableDepth, refs.length);
+    let aliasToken = tokens[cursor + 1];
+    if (
+      aliasToken?.kind === 'identifier' &&
+      aliasToken.text.toLowerCase() === 'as'
+    )
+      aliasToken = tokens[cursor + 2];
+    const explicitAlias =
+      aliasToken?.kind === 'quoted-identifier' ||
+      (aliasToken?.kind === 'identifier' &&
+        !RESERVED_ALIAS.has(aliasToken.text.toLowerCase()))
+        ? sqlIdentifier(aliasToken)
+        : undefined;
     refs.push({
       table,
-      alias: alias ?? table,
+      start: tableToken.span.start.offset,
+      end: tableToken.span.end.offset,
+      alias: explicitAlias ?? table,
+      ...(explicitAlias === undefined ? {} : { explicitAlias }),
       nullable:
-        outerKind === 'LEFT' ||
-        outerKind === 'FULL' ||
+        outerKind === 'left' ||
+        outerKind === 'full' ||
         nullableGroups.some(
-          (group) => tableIndex > group.open && tableIndex < group.close,
+          (group) => cursor > group.start && cursor < group.end,
         ),
     });
   }
@@ -1486,13 +1519,6 @@ export function analyzeStatement(
   if (sourceSql.length === 0) {
     throw new TypegenError(file, 'query file is empty');
   }
-  if (hasCommaJoinedSchemaTable(sourceSql, ir)) {
-    throw new TypegenError(
-      file,
-      'comma-separated table sources are unsupported because reactive proof requires every relation; use an explicit JOIN ... ON clause',
-    );
-  }
-
   // SELECT-only (the read tier). A `WITH` is allowed when its main statement
   // is a SELECT (SQLite also allows WITH … INSERT/UPDATE/DELETE — writes).
   const firstKeyword = /^\s*([A-Za-z]+)/.exec(
@@ -1695,6 +1721,12 @@ export function analyzeStatement(
     sourceSql,
     sql,
     positionalSql: toPositionalSql(sql),
+    relations: scanTableRefs(toPositionalSql(sql), ir).map((ref) => ({
+      table: ref.table,
+      start: ref.start,
+      end: ref.end,
+      ...(ref.explicitAlias === undefined ? {} : { alias: ref.explicitAlias }),
+    })),
     params,
     columns,
     tables,

package/src/syql-lowering.ts

@@ -470,6 +470,7 @@ function lowerStatement(
       ...(activationMask === undefined ? {} : { activationMask }),
       sql: namedSql,
       positionalSql: analyzed.positionalSql,
+      relations: analyzed.relations,
       binds: bindNames.map((name) =>
         planBind(
           name,

package/src/syql-validator.ts

@@ -450,7 +450,18 @@ class Validator {
       location,
     );
     this.#validateDeterminism(activeSql, logical.declaration.statement.span);
-    const refs = scanTableRefs(activeSql, this.#ir);
+    let refs: TableRef[];
+    try {
+      refs = scanTableRefs(activeSql, this.#ir);
+    } catch (error) {
+      // Preserve SQLite's source-spanned diagnostics for invalid relations.
+      this.#validateSqlite(activeSql, logical, []);
+      this.#fail(
+        'SYQL6002_INVALID_SQL',
+        logical.declaration.statement.span,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
     this.#validatePortableProfile(
       activeSql,
       logical.declaration.statement.span,