@syncular/typegen 0.15.47 → 0.16.1

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/index.d.ts

@@ -25,6 +25,7 @@ export * from './query.js';
 export * from './query-ir.js';
 export * from './sql.js';
 export * from './syql-ast.js';
+export * from './syql-diagnostics.js';
 export * from './syql-lexer.js';
 export * from './syql-lowering.js';
 export * from './syql-modules.js';

package/dist/index.js

@@ -25,6 +25,7 @@ export * from './query.js';
 export * from './query-ir.js';
 export * from './sql.js';
 export * from './syql-ast.js';
+export * from './syql-diagnostics.js';
 export * from './syql-lexer.js';
 export * from './syql-lowering.js';
 export * from './syql-modules.js';

package/dist/lsp.js

@@ -7,6 +7,7 @@ import { formatSyql } from './fmt.js';
 import { buildIr, loadMigrations, loadQueries, makeQueryDb } from './generate.js';
 import { MANIFEST_FILENAME, parseManifest } from './manifest.js';
 import { lockedMigrationNames, readMigrationLock } from './migration-lock.js';
+import { syqlDiagnosticRemedy } from './syql-diagnostics.js';
 import { SyqlFrontendError } from './syql-lexer.js';
 import { lowerSyqlQuery } from './syql-lowering.js';
 import { buildSyqlModuleGraph } from './syql-modules.js';
@@ -294,14 +295,23 @@ export class SyqlLanguageServer {
         const message = error instanceof Error ? error.message : String(error);
         if (error instanceof SyqlFrontendError &&
             resolve(error.sourceFile) === file) {
+            const remedy = syqlDiagnosticRemedy(error.code);
             return {
                 range: spanRange(text, error.span),
                 severity: 1,
                 source: 'syncular',
                 code: error.code,
+                ...(remedy === undefined ? {} : { data: { remedy } }),
                 message: error.detail,
             };
         }
+        const projectContextError = this.#context(pathToFileURL(file).href).kind === 'error';
+        const code = error instanceof SyqlFrontendError
+            ? error.code
+            : projectContextError
+                ? 'SYQL9001_PROJECT_CONTEXT'
+                : undefined;
+        const remedy = code === undefined ? undefined : syqlDiagnosticRemedy(code);
         return {
             range: {
                 start: { line: 0, character: 0 },
@@ -312,8 +322,9 @@ export class SyqlLanguageServer {
             },
             severity: 1,
             source: 'syncular',
-            ...(error instanceof SyqlFrontendError ? { code: error.code } : {}),
-            message: this.#context(pathToFileURL(file).href).kind === 'error'
+            ...(code === undefined ? {} : { code }),
+            ...(remedy === undefined ? {} : { data: { remedy } }),
+            message: projectContextError
                 ? `SYQL9001_PROJECT_CONTEXT: ${message}`
                 : message,
         };

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,