@syncular/typegen 0.6.0 → 0.8.0

package/dist/syql-parser.js

@@ -2,7 +2,6 @@
 import { isSyqlTrivia, lexSyqlSource, SyqlFrontendError, } from './syql-lexer.js';
 import { parseSyqlEmbeddedTemplate, } from './syql-template-parser.js';
 const CAMEL_IDENT_RE = /^[a-z][A-Za-z0-9]*$/;
-const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const INTEGER_LITERAL_RE = /^(?:0|[1-9][0-9]*)$/;
 const BASE_TYPES = new Set([
     'string',
@@ -17,29 +16,29 @@ const BASE_TYPES = new Set([
 const RESERVED_NAMES = new Set([
     'as',
     'blob_ref',
+    'bool',
     'boolean',
     'by',
     'bytes',
-    'cover',
     'crdt',
     'default',
     'float',
+    'false',
     'from',
-    'identity',
     'import',
     'in',
     'integer',
     'json',
     'max',
     'null',
-    'page',
+    'limit',
+    'present',
     'predicate',
     'query',
-    'scope',
     'sort',
-    'sql',
     'string',
-    'switch',
+    'sync',
+    'true',
     'when',
 ]);
 function spanBetween(start, end) {
@@ -89,14 +88,14 @@ class Parser {
                 declarations.push(declaration);
                 predicates.push(declaration);
             }
-            else if (keyword.text === 'query') {
-                const declaration = this.#parseQuery();
+            else if (keyword.text === 'query' || keyword.text === 'sync') {
+                const declaration = this.#parseQuery(keyword.text === 'sync');
                 this.#claimName(fileNames, declaration.name, declaration.nameSpan, 'declaration');
                 declarations.push(declaration);
                 queries.push(declaration);
             }
             else {
-                this.#fail('SYQL2008_INVALID_MEMBER', keyword, `expected import, predicate, or query; found ${JSON.stringify(keyword.text)}`);
+                this.#fail('SYQL2008_INVALID_MEMBER', keyword, `expected import, predicate, query, or sync query; found ${JSON.stringify(keyword.text)}`);
             }
         }
         const first = this.#tokens[0];
@@ -201,41 +200,64 @@ class Parser {
             nameSpan: name.span,
         };
     }
-    #parseQuery() {
-        const start = this.#expectText('query');
+    #parseQuery(sync) {
+        const start = sync ? this.#expectText('sync') : this.#peek();
+        this.#expectText('query');
         const name = this.#parseCamelName('query name');
         const parsedParameters = this.#parseQueryParameters();
-        const publicNames = parsedParameters.publicNames;
-        this.#expectText('{');
-        if (this.#peek().text !== 'sql') {
-            this.#fail('SYQL2008_INVALID_MEMBER', this.#peek(), 'a query body must begin with exactly one sql { ... } section');
-        }
-        const sql = this.#parseSqlSection();
-        let sort;
-        let page;
-        let identity;
-        if (this.#peek().text === 'sort') {
-            sort = this.#parseSortSection(publicNames);
-        }
-        if (this.#peek().text === 'page') {
-            page = this.#parsePageDeclaration(publicNames);
-        }
-        if (this.#peek().text === 'identity') {
-            identity = this.#parseIdentityDeclaration();
-        }
-        if (this.#peek().text !== '}') {
-            this.#fail('SYQL2008_INVALID_MEMBER', this.#peek(), `unexpected or out-of-order query member ${JSON.stringify(this.#peek().text)}`);
+        let syncBy;
+        if (this.#peek().text === 'by') {
+            const by = this.#take();
+            if (!sync) {
+                this.#fail('SYQL2012_INVALID_QUERY_BODY', by, '`by table.scope` is valid only on a sync query');
+            }
+            const qualifier = this.#expectKind('identifier', 'sync table or alias');
+            this.#expectText('.');
+            const column = this.#expectKind('identifier', 'sync scope column');
+            syncBy = {
+                qualifier: qualifier.text,
+                column: column.text,
+                span: spanBetween(qualifier, column),
+            };
+        }
+        const declaredRanges = new Set(parsedParameters.parameters.flatMap((parameter) => parameter.kind === 'range' ? [parameter.name] : []));
+        const body = this.#parseQueryBody(parsedParameters.publicNames, declaredRanges);
+        const implicitRanges = this.#rangeShorthandNames(body.statement.tokens, declaredRanges);
+        const parameters = parsedParameters.parameters.map((parameter) => {
+            if (!implicitRanges.has(parameter.name))
+                return parameter;
+            if (parameter.kind === 'group') {
+                this.#fail('SYQL2011_INVALID_PARAMETER', this.#tokenAt(parameter.nameSpan), `range shorthand :${parameter.name} must name a scalar query input`);
+            }
+            if (parameter.kind === 'range')
+                return parameter;
+            if (parameter.default !== undefined) {
+                this.#fail('SYQL2011_INVALID_PARAMETER', this.#tokenAt(parameter.nameSpan), `range input ${parameter.name} cannot have a boolean default`);
+            }
+            return {
+                kind: 'range',
+                name: parameter.name,
+                optional: parameter.optional,
+                ...(parameter.type === undefined ? {} : { type: parameter.type }),
+                span: parameter.span,
+                nameSpan: parameter.nameSpan,
+            };
+        });
+        for (const parameter of parameters) {
+            if (parameter.kind === 'range' && !implicitRanges.has(parameter.name)) {
+                this.#fail('SYQL2011_INVALID_PARAMETER', this.#tokenAt(parameter.nameSpan), `range input ${parameter.name} must be used as BETWEEN :${parameter.name}`);
+            }
         }
-        const close = this.#expectText('}');
         return {
             kind: 'query',
             name: name.text,
-            parameters: parsedParameters.parameters,
-            sql,
-            ...(sort === undefined ? {} : { sort }),
-            ...(page === undefined ? {} : { page }),
-            ...(identity === undefined ? {} : { identity }),
-            span: spanBetween(start, close),
+            sync,
+            ...(syncBy === undefined ? {} : { syncBy }),
+            parameters,
+            statement: body.statement,
+            ...(body.sort === undefined ? {} : { sort: body.sort }),
+            ...(body.limit === undefined ? {} : { limit: body.limit }),
+            span: spanBetween(start, body.close),
             nameSpan: name.span,
         };
     }
@@ -250,7 +272,13 @@ class Parser {
                 const optional = this.#peek().text === '?';
                 if (optional)
                     this.#take();
-                if (optional && this.#peek().text === '(') {
+                if (optional &&
+                    this.#peek().text === ':' &&
+                    this.#peekSignificantAfter(1)?.text === '{') {
+                    this.#take();
+                    if (this.#peek().text !== '{') {
+                        this.#fail('SYQL2011_INVALID_PARAMETER', this.#peek(), 'an optional structured input must use `name?: { ... }`');
+                    }
                     if (publicNames.has(name.text)) {
                         this.#duplicate(name, 'public query input');
                     }
@@ -278,10 +306,10 @@ class Parser {
                         if (this.#peek().text !== ',')
                             break;
                         this.#take();
-                        if (this.#peek().text === ')')
+                        if (this.#peek().text === '}')
                             break;
                     }
-                    const groupClose = this.#expectText(')');
+                    const groupClose = this.#expectText('}');
                     if (members.length < 2) {
                         this.#fail('SYQL2011_INVALID_PARAMETER', name, `group ${name.text} must contain at least two members`);
                     }
@@ -302,15 +330,21 @@ class Parser {
                     if (this.#peek().text === ':') {
                         const colon = this.#take();
                         const typeName = this.#expectKind('identifier', 'parameter type');
-                        if (typeName.text === 'switch') {
-                            if (!optional) {
-                                this.#fail('SYQL2011_INVALID_PARAMETER', typeName, `switch ${name.text} must use the exact optional form ${name.text}?: switch`);
+                        if (typeName.text === 'range') {
+                            if (bindNames.has(name.text)) {
+                                this.#duplicate(name, 'query bind');
                             }
+                            bindNames.add(name.text);
+                            this.#expectText('<');
+                            const elementName = this.#expectKind('identifier', 'range element type');
+                            const type = this.#parseValueTypeAfterName(colon, elementName);
+                            const close = this.#expectText('>');
                             parameters.push({
-                                kind: 'switch',
+                                kind: 'range',
                                 name: name.text,
-                                optional: true,
-                                span: spanBetween(name, typeName),
+                                optional,
+                                type,
+                                span: spanBetween(name, close),
                                 nameSpan: name.span,
                             });
                         }
@@ -320,12 +354,26 @@ class Parser {
                                 this.#duplicate(name, 'query bind');
                             }
                             bindNames.add(name.text);
+                            let end = type.span.end;
+                            let defaultValue;
+                            if (this.#peek().text === '=') {
+                                this.#take();
+                                const value = this.#expectText('false');
+                                if (type.base !== 'boolean' || type.nullable || optional) {
+                                    this.#fail('SYQL2011_INVALID_PARAMETER', value, 'only a non-optional bool parameter may declare `= false`');
+                                }
+                                defaultValue = false;
+                                end = value.span.end;
+                            }
                             parameters.push({
                                 kind: 'value',
                                 name: name.text,
                                 optional,
                                 type,
-                                span: spanFromPositions(this.#file, name.span.start, type.span.end),
+                                ...(defaultValue === undefined
+                                    ? {}
+                                    : { default: defaultValue }),
+                                span: spanFromPositions(this.#file, name.span.start, end),
                                 nameSpan: name.span,
                             });
                         }
@@ -356,17 +404,201 @@ class Parser {
         this.#expectText(')');
         return { parameters, publicNames, bindNames };
     }
-    #parseSqlSection() {
-        const start = this.#expectText('sql');
-        const block = this.#parseTemplateBlock('sql section', 'statement');
+    #parseQueryBody(publicNames, declaredRanges) {
+        const open = this.#expectText('{');
+        const bodyStart = this.#index;
+        let cursor = bodyStart;
+        let braceDepth = 1;
+        let parenDepth = 0;
+        let terminatorIndex;
+        while (cursor < this.#tokens.length) {
+            const token = this.#tokens[cursor];
+            if (token.kind === 'eof') {
+                this.#fail('SYQL2001_EXPECTED_TOKEN', token, 'expected ; and } to close query body');
+            }
+            if (token.text === '(')
+                parenDepth += 1;
+            else if (token.text === ')')
+                parenDepth -= 1;
+            else if (token.text === '{')
+                braceDepth += 1;
+            else if (token.text === '}') {
+                if (braceDepth === 1) {
+                    this.#fail('SYQL2012_INVALID_QUERY_BODY', token, 'a query statement must end with a semicolon');
+                }
+                braceDepth -= 1;
+            }
+            else if (token.text === ';' && braceDepth === 1 && parenDepth === 0) {
+                terminatorIndex = cursor;
+                break;
+            }
+            cursor += 1;
+        }
+        const terminator = this.#tokens[terminatorIndex];
+        let dynamicSortIndex;
+        let dynamicLimitIndex;
+        braceDepth = 1;
+        parenDepth = 0;
+        for (cursor = bodyStart; cursor < terminatorIndex; cursor += 1) {
+            const token = this.#tokens[cursor];
+            if (isSyqlTrivia(token))
+                continue;
+            if (token.text === '(')
+                parenDepth += 1;
+            else if (token.text === ')')
+                parenDepth -= 1;
+            if (braceDepth === 1 && parenDepth === 0) {
+                const lower = token.text.toLowerCase();
+                if (lower === 'order' &&
+                    this.#significantTextAfter(cursor, 1) === 'by' &&
+                    this.#significantTextAfter(cursor, 3) === 'default' &&
+                    this.#significantTextAfter(cursor, 5) === '{') {
+                    dynamicSortIndex ??= cursor;
+                }
+                else if (lower === 'limit' &&
+                    this.#significantTextAfter(cursor, 2) === 'default' &&
+                    this.#significantTextAfter(cursor, 4) === 'max') {
+                    dynamicLimitIndex ??= cursor;
+                }
+            }
+            if (token.text === '{')
+                braceDepth += 1;
+            else if (token.text === '}')
+                braceDepth -= 1;
+        }
+        if (dynamicSortIndex !== undefined &&
+            dynamicLimitIndex !== undefined &&
+            dynamicLimitIndex < dynamicSortIndex) {
+            this.#fail('SYQL2012_INVALID_QUERY_BODY', this.#tokens[dynamicLimitIndex], 'dynamic ORDER BY must precede dynamic LIMIT');
+        }
+        const sqlEnd = Math.min(dynamicSortIndex ?? Number.MAX_SAFE_INTEGER, dynamicLimitIndex ?? Number.MAX_SAFE_INTEGER, terminatorIndex);
+        const statementTokens = this.#tokens.slice(bodyStart, sqlEnd);
+        const rangeNames = this.#rangeShorthandNames(statementTokens, declaredRanges);
+        const statement = this.#makeTemplate(statementTokens, 'query statement', 'statement', rangeNames, open.span.end);
+        let sort;
+        let limit;
+        this.#index = sqlEnd;
+        if (dynamicSortIndex !== undefined) {
+            sort = this.#parseInlineSort(publicNames);
+        }
+        if (dynamicLimitIndex !== undefined) {
+            limit = this.#parseLimitDeclaration(publicNames);
+        }
+        const end = this.#expectText(';');
+        if (end !== terminator) {
+            this.#fail('SYQL2012_INVALID_QUERY_BODY', end, 'unexpected query member before the statement terminator');
+        }
+        const close = this.#expectText('}');
+        return {
+            statement,
+            ...(sort === undefined ? {} : { sort }),
+            ...(limit === undefined ? {} : { limit }),
+            close,
+        };
+    }
+    #rangeShorthandNames(tokens, declaredRanges = new Set()) {
+        const significant = tokens.filter((token) => !isSyqlTrivia(token));
+        const names = new Set();
+        const clauseEnd = new Set([
+            'group',
+            'having',
+            'order',
+            'limit',
+            'offset',
+            'window',
+            'union',
+            'intersect',
+            'except',
+        ]);
+        for (let index = 0; index < significant.length; index += 1) {
+            const token = significant[index];
+            if (token.kind !== 'identifier' || token.text.toLowerCase() !== 'between')
+                continue;
+            const bind = significant[index + 1];
+            if (bind?.kind !== 'bind')
+                continue;
+            const name = bind.text.slice(1);
+            const next = significant[index + 2];
+            const afterNext = significant[index + 3];
+            let conjunctStart = index - 1;
+            while (conjunctStart >= 0 &&
+                !(significant[conjunctStart]?.kind === 'identifier' &&
+                    significant[conjunctStart]?.text.toLowerCase() === 'and')) {
+                conjunctStart -= 1;
+            }
+            const controlledByRange = significant
+                .slice(conjunctStart + 1, index)
+                .some((candidate, candidateIndex, conjunct) => {
+                if (candidate.kind !== 'identifier' ||
+                    candidate.text.toLowerCase() !== 'when' ||
+                    conjunct[candidateIndex + 1]?.text !== '(') {
+                    return false;
+                }
+                let depth = 0;
+                for (let controlIndex = candidateIndex + 1; controlIndex < conjunct.length; controlIndex += 1) {
+                    const control = conjunct[controlIndex];
+                    if (control.text === '(')
+                        depth += 1;
+                    else if (control.text === ')') {
+                        depth -= 1;
+                        if (depth === 0)
+                            return false;
+                    }
+                    else if (depth > 0 &&
+                        control.kind === 'identifier' &&
+                        control.text === name) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+            const endsRange = declaredRanges.has(name) ||
+                controlledByRange ||
+                next === undefined ||
+                next.text === '}' ||
+                (next.kind === 'identifier' &&
+                    clauseEnd.has(next.text.toLowerCase())) ||
+                (next.kind === 'identifier' &&
+                    next.text.toLowerCase() === 'and' &&
+                    afterNext?.kind === 'identifier' &&
+                    afterNext.text === 'when');
+            if (endsRange)
+                names.add(name);
+        }
+        return names;
+    }
+    #makeTemplate(tokens, label, mode, rangeNames = new Set(), fallbackStart) {
+        const semantic = tokens.filter((token) => !isSyqlTrivia(token));
+        if (semantic.length === 0) {
+            this.#fail('SYQL2006_EMPTY_TEMPLATE', semantic[0] ?? this.#peek(), `${label} must not be empty`);
+        }
+        const first = tokens[0] ?? semantic[0];
+        const last = tokens[tokens.length - 1] ?? semantic[semantic.length - 1];
+        const start = first?.span.start ?? fallbackStart ?? this.#peek().span.start;
+        const end = last?.span.end ?? start;
+        const span = spanFromPositions(this.#file, start, end);
         return {
-            kind: 'sql',
-            body: block.template,
-            span: spanBetween(start, block.close),
+            text: this.#source.slice(start.offset, end.offset),
+            tokens,
+            tree: parseSyqlEmbeddedTemplate(this.#file, tokens, span, mode, rangeNames),
+            span,
         };
     }
-    #parseSortSection(publicNames) {
-        const start = this.#expectText('sort');
+    #significantTextAfter(index, count) {
+        let remaining = count;
+        for (let cursor = index + 1; cursor < this.#tokens.length; cursor += 1) {
+            const token = this.#tokens[cursor];
+            if (isSyqlTrivia(token))
+                continue;
+            remaining -= 1;
+            if (remaining === 0)
+                return token.text.toLowerCase();
+        }
+        return undefined;
+    }
+    #parseInlineSort(publicNames) {
+        const start = this.#expectText('order');
+        this.#expectText('by');
         const control = this.#parseCamelName('sort control');
         if (publicNames.has(control.text)) {
             this.#duplicate(control, 'public query input');
@@ -386,17 +618,37 @@ class Parser {
                 this.#duplicate(profileName, 'sort profile');
             }
             profileNames.add(profileName.text);
-            const order = this.#parseTemplateBlock('sort profile', 'order');
+            this.#expectText(':');
+            const contentStart = this.#index;
+            let cursor = contentStart;
+            let depth = 0;
+            while (cursor < this.#tokens.length) {
+                const token = this.#tokens[cursor];
+                if (token.kind === 'eof' || token.text === '}') {
+                    this.#fail('SYQL2001_EXPECTED_TOKEN', token, 'expected ; after sort profile');
+                }
+                if (token.text === '(')
+                    depth += 1;
+                else if (token.text === ')')
+                    depth -= 1;
+                else if (token.text === ';' && depth === 0)
+                    break;
+                cursor += 1;
+            }
+            const end = this.#tokens[cursor];
+            const orderTokens = this.#tokens.slice(contentStart, cursor);
+            const order = this.#makeTemplate(orderTokens, 'sort profile', 'order');
+            this.#index = cursor + 1;
             profiles.push({
                 name: profileName.text,
-                order: order.template,
-                span: spanBetween(profileName, order.close),
+                order,
+                span: spanBetween(profileName, end),
                 nameSpan: profileName.span,
             });
         }
         const close = this.#expectText('}');
         if (profiles.length === 0) {
-            this.#fail('SYQL2008_INVALID_MEMBER', close, 'a sort section must contain at least one profile');
+            this.#fail('SYQL2008_INVALID_MEMBER', close, 'a dynamic ORDER BY must contain at least one profile');
         }
         if (!profileNames.has(defaultProfile.text)) {
             this.#fail('SYQL2008_INVALID_MEMBER', defaultProfile, `default sort profile ${JSON.stringify(defaultProfile.text)} is not declared`);
@@ -410,60 +662,39 @@ class Parser {
             controlSpan: control.span,
         };
     }
-    #parsePageDeclaration(publicNames) {
-        const start = this.#expectText('page');
-        const control = this.#parseCamelName('page control');
+    #parseLimitDeclaration(publicNames) {
+        const start = this.#expectText('limit');
+        const control = this.#parseCamelName('limit control');
         if (publicNames.has(control.text)) {
             this.#duplicate(control, 'public query input');
         }
         publicNames.add(control.text);
         this.#expectText('default');
-        const defaultToken = this.#parseInteger('page default');
+        const defaultToken = this.#parseInteger('limit default');
         this.#expectText('max');
-        const maxToken = this.#parseInteger('page maximum');
-        const end = this.#expectText(';');
+        const maxToken = this.#parseInteger('limit maximum');
         const defaultSize = Number(defaultToken.text);
         const maxSize = Number(maxToken.text);
         if (defaultSize < 1 || defaultSize > maxSize || maxSize > 2_147_483_647) {
-            this.#fail('SYQL2010_INVALID_PAGE_RANGE', defaultToken, `page bounds must satisfy 1 <= default <= max <= 2147483647; found default ${defaultSize}, max ${maxSize}`);
+            this.#fail('SYQL2010_INVALID_PAGE_RANGE', defaultToken, `limit bounds must satisfy 1 <= default <= max <= 2147483647; found default ${defaultSize}, max ${maxSize}`);
         }
         return {
-            kind: 'page',
+            kind: 'limit',
             control: control.text,
             defaultSize,
             maxSize,
-            span: spanBetween(start, end),
+            span: spanBetween(start, maxToken),
             controlSpan: control.span,
         };
     }
-    #parseIdentityDeclaration() {
-        const start = this.#expectText('identity');
-        this.#expectText('by');
-        const fields = [];
-        const names = new Set();
-        for (;;) {
-            const field = this.#expectKind('identifier', 'identity result name');
-            if (!IDENT_RE.test(field.text)) {
-                this.#fail('SYQL2002_INVALID_NAME', field, `invalid identity result name ${JSON.stringify(field.text)}`);
-            }
-            if (names.has(field.text))
-                this.#duplicate(field, 'identity field');
-            names.add(field.text);
-            fields.push(field.text);
-            if (this.#peek().text !== ',')
-                break;
-            this.#take();
-        }
-        const end = this.#expectText(';');
-        return { kind: 'identity', fields, span: spanBetween(start, end) };
-    }
     #parseTypeAnnotation() {
         const colon = this.#expectText(':');
         const name = this.#expectKind('identifier', 'value type');
         return this.#parseValueTypeAfterName(colon, name);
     }
     #parseValueTypeAfterName(colon, name) {
-        if (!BASE_TYPES.has(name.text)) {
+        const base = name.text === 'bool' ? 'boolean' : name.text;
+        if (name.text === 'boolean' || !BASE_TYPES.has(base)) {
             this.#fail('SYQL2011_INVALID_PARAMETER', name, `unknown value type ${JSON.stringify(name.text)}`);
         }
         let end = name;
@@ -474,7 +705,7 @@ class Parser {
             nullable = true;
         }
         return {
-            base: name.text,
+            base: base,
             nullable,
             span: spanBetween(colon, end),
         };
@@ -561,6 +792,20 @@ class Parser {
         }
         return this.#tokens[index];
     }
+    #peekSignificantAfter(count) {
+        let index = this.#index;
+        let remaining = count;
+        while (index < this.#tokens.length) {
+            const token = this.#tokens[index];
+            index += 1;
+            if (isSyqlTrivia(token))
+                continue;
+            if (remaining === 0)
+                return token;
+            remaining -= 1;
+        }
+        return undefined;
+    }
     #take() {
         while (this.#index < this.#tokens.length &&
             isSyqlTrivia(this.#tokens[this.#index])) {
@@ -580,6 +825,9 @@ class Parser {
         }
         return undefined;
     }
+    #tokenAt(span) {
+        return (this.#tokens.find((token) => token.span.start.offset === span.start.offset) ?? this.#peek());
+    }
     #expectText(text) {
         const token = this.#take();
         if (token.text !== text) {

package/dist/syql-semantics.d.ts

@@ -8,7 +8,6 @@
 import { type SyqlSourceSpan } from './syql-lexer.js';
 import type { SyqlModuleGraph } from './syql-modules.js';
 import type { SyqlPredicateDeclaration, SyqlQueryDeclaration, SyqlQueryParameter, SyqlSyntaxFile, SyqlValueType } from './syql-parser.js';
-import type { SyqlReactiveDirective } from './syql-template-parser.js';
 export type SyqlSemanticErrorCode = 'SYQL5001_UNKNOWN_PREDICATE' | 'SYQL5002_PREDICATE_CYCLE' | 'SYQL5003_PREDICATE_ARITY' | 'SYQL5004_CLOSED_PREDICATE' | 'SYQL5005_UNUSED_PREDICATE_PARAMETER' | 'SYQL5006_UNDECLARED_BIND' | 'SYQL5007_UNUSED_INPUT' | 'SYQL5008_INVALID_CONTROL' | 'SYQL5009_MISSING_DOMINANCE' | 'SYQL5010_UNUSED_CONTROL' | 'SYQL5011_TYPE_CONFLICT';
 export interface SyqlResolvedPredicate {
     readonly id: string;
@@ -40,16 +39,12 @@ export interface SyqlLogicalPredicateNode {
 export interface SyqlLogicalWhenNode {
     readonly kind: 'when';
     readonly controls: readonly string[];
+    readonly explicitPresence: readonly boolean[];
     readonly controlSpans: readonly SyqlSourceSpan[];
     readonly body: readonly SyqlLogicalTemplateNode[];
     readonly span: SyqlSourceSpan;
 }
-export interface SyqlLogicalReactiveNode {
-    readonly kind: 'scope' | 'cover';
-    readonly directive: SyqlReactiveDirective;
-    readonly span: SyqlSourceSpan;
-}
-export type SyqlLogicalTemplateNode = SyqlLogicalSqlNode | SyqlLogicalPredicateNode | SyqlLogicalWhenNode | SyqlLogicalReactiveNode;
+export type SyqlLogicalTemplateNode = SyqlLogicalSqlNode | SyqlLogicalPredicateNode | SyqlLogicalWhenNode;
 export interface SyqlLogicalInput {
     readonly parameter: SyqlQueryParameter;
     /** Type declared in source or constrained by annotated predicate formals. */
@@ -70,6 +65,8 @@ export interface SyqlSemanticProgram {
     readonly predicates: readonly SyqlResolvedPredicate[];
     readonly queries: readonly SyqlLogicalQuery[];
 }
+export declare function syqlRangeStartBind(name: string): string;
+export declare function syqlRangeEndBind(name: string): string;
 /** Resolve and statically validate a complete reachable SYQL module graph. */
 export declare function analyzeSyqlSemantics(graph: SyqlModuleGraph): SyqlSemanticProgram;
 /** Losslessly render expanded SQL/predicate nodes, retaining `when` markers. */