@kuindji/typed-sql 0.1.0 → 0.3.0

package/src/expressions.ts

@@ -60,14 +60,28 @@ export type ExprToObject<
                         ? MaybeNullableRow<RowTypeForTable<ResolveTableKey<CleanIdent<T>, Tables, Aliases, S>, S>, T, Nullable>
                         : ExprKey<E, Tables, Aliases, S> extends infer Key extends string | never
                             ? Key extends string
-                                ? { [K in Key]: ApplyProjectionNull<ExprType<RawExpr, Tables, Aliases, S>, RawExpr, Tables, Aliases, S, Nullable> }
+                                ? { [K in Key]: NeverToUnknown<ApplyProjectionNull<ExprType<RawExpr, Tables, Aliases, S>, RawExpr, Tables, Aliases, S, Nullable>, RawExpr> }
                                 : Record<string, unknown>
                             : Record<string, unknown>
                 : Alias extends string
-                        ? { [K in Alias]: ApplyProjectionNull<ExprType<RawExpr, Tables, Aliases, S>, RawExpr, Tables, Aliases, S, Nullable> }
+                        ? { [K in Alias]: NeverToUnknown<ApplyProjectionNull<ExprType<RawExpr, Tables, Aliases, S>, RawExpr, Tables, Aliases, S, Nullable>, RawExpr> }
                         : Record<string, unknown>
             : Record<string, unknown>;
 
+// A projected QUALIFIED ref that resolves to `never` (e.g. one qualified by a
+// CTE name that the core path collected as a bogus base table — `input_ips.x`
+// in `WITH input_ips(...) ... SELECT input_ips.x ... JOIN ...`) must surface as
+// `unknown` in the ROW type — `never` is validation's reject signal, not a value
+// type, and a `never` property poisons every consumer of the row. An UNQUALIFIED
+// invalid column keeps its `never` field: that visibility is deliberate and
+// pinned by the adversarial cast suite (`not_a_col::text` -> `{ x: never }`).
+type NeverToUnknown<T, E extends string> =
+    [T] extends [never]
+        ? E extends `${string}.${string}`
+            ? unknown
+            : T
+        : T;
+
 // Outer-join nullability for a directly-projected column. `Nullable` is the set
 // of reference qualifiers (aliases / table names) that are nullable due to an
 // outer join (see `NullableRelations`). When the projected expression is a plain
@@ -219,7 +233,14 @@ export type FunctionKeyFromExpr<E extends string> =
 export type IsBoolExpr<CE extends string> =
     CE extends `case ${string}`
         ? false
-        : HasTopLevelCompare<CE>;
+        // Pre-gate: `HasTopLevelCompare`'s only `true` branch requires a
+        // `<`/`>`/`=`/`!` char; if `CE` contains none, the answer is `false` without
+        // the char-walk. Cheap template test short-circuits the common no-comparison
+        // projection (a bare column / function call). Must list all four chars the
+        // walk's true branch matches.
+        : CE extends `${string}${"<" | ">" | "=" | "!"}${string}`
+            ? HasTopLevelCompare<CE>
+            : false;
 
 // Scans for a comparison operator outside parens and outside `'…'`/`"…"` quotes.
 // `->>`, `#>>` and `::` are consumed as units so their `>`/`:` are not mistaken
@@ -474,13 +495,20 @@ export type ExprValid<
     E extends string,
     Tables extends string,
     Aliases extends string,
-    S extends DatabaseSchema
+    S extends DatabaseSchema,
+    LocalRels extends string = never
 > =
     IsIgnorableRuntimeExpr<E> extends true
         ? true
         : ExtractAlias<E> extends { expr: infer RawExpr extends string }
             ? IsIgnorableRuntimeExpr<RawExpr> extends true
             ? true
+            // A ref qualified by a query-local relation (CTE name) has no schema
+            // surface to resolve against — `ExprType` yields `never` and the
+            // token scans reject it. Bless it (lenient contract: the local
+            // relation's output shape is validated where it is defined).
+            : HasLocalQualifier<RawExpr, LocalRels> extends true
+                ? true
             : ExprType<RawExpr, Tables, Aliases, S> extends never
                 ? false
                 : NeedsTokenRefValidation<RawExpr> extends true
@@ -488,6 +516,17 @@ export type ExprValid<
                     : FuncCompoundArgsValid<RawExpr, Tables, Aliases, S>
             : true;
 
+// `true` when E is a qualified ref whose qualifier names a query-local relation.
+// The `[LocalRels] extends [never]` guard keeps the common no-CTE path free.
+type HasLocalQualifier<E extends string, LocalRels extends string> =
+    [LocalRels] extends [never]
+        ? false
+        : E extends `${infer Q}.${string}`
+            ? CleanIdent<Q> extends LocalRels
+                ? true
+                : false
+            : false;
+
 // A function-call (or cast) projection skips the token ref-scan above
 // (`NeedsTokenRefValidation` is false for `${fn}(${args})`), which is why an
 // invalid column hidden inside an aggregate/function argument — `sum(price +
@@ -587,12 +626,13 @@ export type ExprsValidList<
     Tables extends string,
     Aliases extends string,
     S extends DatabaseSchema,
-    Steps extends any[] = []
+    Steps extends any[] = [],
+    LocalRels extends string = never
 > = Steps["length"] extends 100
     ? true
     : Exprs extends [infer H extends string, ...infer Rest extends string[]]
-        ? ExprValid<H, Tables, Aliases, S> extends true
-            ? ExprsValidList<Rest, Tables, Aliases, S, [any, ...Steps]>
+        ? ExprValid<H, Tables, Aliases, S, LocalRels> extends true
+            ? ExprsValidList<Rest, Tables, Aliases, S, [any, ...Steps], LocalRels>
             : false
         : true;
 

package/src/parsing/extract.ts

@@ -22,7 +22,21 @@ export type ExtractSelectList<N extends string> =
 export type ExtractReturningList<N extends string> =
     FirstTopLevelReturningTail<N>;
 
-export type FirstTopLevelReturningTail<
+// Quote-free fast-path (mirrors `HasReturningQuoteAware`): with no `'` and no `"`
+// every ` returning ` is top-level, so the FIRST one's tail is exact via a single
+// leftmost template match — skipping the ~1200-step walk on every quote-free DML.
+// Only quote-bearing queries take the walk. The fast-path pattern matches the walk's
+// own step-cap fallback, so behavior is unchanged.
+export type FirstTopLevelReturningTail<S extends string> =
+    string extends S
+        ? ""
+        : S extends `${string}'${string}`
+            ? FirstTopLevelReturningTailWalk<S>
+            : S extends `${string}"${string}`
+                ? FirstTopLevelReturningTailWalk<S>
+                : S extends `${string} returning ${infer After}` ? After : "";
+
+type FirstTopLevelReturningTailWalk<
     S extends string,
     InString extends boolean = false,
     InDString extends boolean = false,
@@ -33,16 +47,16 @@ export type FirstTopLevelReturningTail<
         ? S extends `${string} returning ${infer After}` ? After : ""
         : InString extends true
             ? S extends `${infer C}${infer Rest}`
-                ? FirstTopLevelReturningTail<Rest, C extends "'" ? false : true, InDString, [any, ...Steps]>
+                ? FirstTopLevelReturningTailWalk<Rest, C extends "'" ? false : true, InDString, [any, ...Steps]>
                 : ""
             : InDString extends true
                 ? S extends `${infer C}${infer Rest}`
-                    ? FirstTopLevelReturningTail<Rest, InString, C extends `"` ? false : true, [any, ...Steps]>
+                    ? FirstTopLevelReturningTailWalk<Rest, InString, C extends `"` ? false : true, [any, ...Steps]>
                     : ""
                 : S extends ` returning ${infer After}`
                     ? After
                     : S extends `${infer C}${infer Rest}`
-                        ? FirstTopLevelReturningTail<Rest, C extends "'" ? true : false, C extends `"` ? true : false, [any, ...Steps]>
+                        ? FirstTopLevelReturningTailWalk<Rest, C extends "'" ? true : false, C extends `"` ? true : false, [any, ...Steps]>
                         : "";
 
 // Given a string whose first non-skipped char is `(`, consume the first

package/src/parsing/normalize.ts

@@ -24,7 +24,65 @@ import type { NeutralizePgLiterals, RewriteExtractCall, StripComments } from "./
 // length, so the "collapse first to fit the lowercaser under its cap" rationale no
 // longer requires a second collapse afterwards.
 export type NormalizeQuery<S extends string> =
-    RewriteExtractCall<Trim<RemoveTrailingSemicolon<LowercaseOutsideQuotes<CollapseSpaces<ReplaceWhitespace<StripComments<NeutralizePgLiterals<S>>>>>>>>;
+    RewriteExtractCall<Trim<RemoveTrailingSemicolon<CollapseDotSpaces<LowercaseOutsideQuotes<CollapseSpaces<ReplaceWhitespace<StripComments<NeutralizePgLiterals<S>>>>>>>>>;
+
+// Collapse whitespace around the `.` qualifier separator: `X .Y` / `X. Y` /
+// `X . Y` -> `X.Y`. PostgreSQL allows whitespace around the qualifier dot
+// (`tbl . col` === `tbl.col`); the normalizer's ReplaceWhitespace+CollapseSpaces
+// turns a multi-line qualified ref (`tbl\n  .col`) into `tbl .col`, which would
+// otherwise tokenize as the orphan `.col` plus a bare `tbl` that the
+// unqualified-column check then rejects as a (non-existent) column. Rejoining the
+// dot lets `tbl.col` resolve normally.
+//
+// CHEAP PRE-GATE: the overwhelmingly common query has no spaced dot, so a single
+// `" ."` / `". "` membership test short-circuits to identity in ~1 instantiation.
+export type CollapseDotSpaces<S extends string> =
+    S extends `${string} .${string}`
+        ? MaybeCollapseDotSpaces<S>
+        : S extends `${string}. ${string}`
+            ? MaybeCollapseDotSpaces<S>
+            : S;
+
+// Single-quoted literals are already blanked to '' by NeutralizePgLiterals, so
+// only a double-quoted identifier could host a spaced dot (`"a . b"`). With no
+// `"` present the quote-unaware ladder is provably safe; otherwise defer to a
+// quote-aware walk that collapses dots only OUTSIDE double-quoted spans.
+type MaybeCollapseDotSpaces<S extends string> =
+    S extends `${string}"${string}`
+        ? CollapseDotSpacesQuoteAware<S, false, "", []>
+        : CollapseDotSpacesWalk<S>;
+
+// O(spaced dots), not O(chars): `${infer A}` jumps a whole non-matching run per
+// step, so a string with no further spaced dot exits in one instantiation. Step
+// cap is a runaway backstop, far under TS's recursion ceiling.
+type CollapseDotSpacesWalk<S extends string, Steps extends any[] = []> =
+    Steps["length"] extends 400
+        ? S
+        : S extends `${infer A} . ${infer B}`
+            ? CollapseDotSpacesWalk<`${A}.${B}`, [any, ...Steps]>
+            : S extends `${infer A} .${infer B}`
+                ? CollapseDotSpacesWalk<`${A}.${B}`, [any, ...Steps]>
+                : S extends `${infer A}. ${infer B}`
+                    ? CollapseDotSpacesWalk<`${A}.${B}`, [any, ...Steps]>
+                    : S;
+
+// Quote-aware tier: copy `"..."` identifier spans verbatim, collapse spaced dots
+// only in the runs OUTSIDE them, so a column literally named `"a . b"` is never
+// corrupted. Depth is O(double-quote boundaries).
+type CollapseDotSpacesQuoteAware<
+    S extends string,
+    InDQ extends boolean,
+    Acc extends string,
+    Steps extends any[]
+> = Steps["length"] extends 400
+    ? `${Acc}${S}`
+    : InDQ extends true
+        ? S extends `${infer P}"${infer R}`
+            ? CollapseDotSpacesQuoteAware<R, false, `${Acc}${P}"`, [any, ...Steps]>
+            : `${Acc}${S}`
+        : S extends `${infer P}"${infer R}`
+            ? CollapseDotSpacesQuoteAware<R, true, `${Acc}${CollapseDotSpacesWalk<P>}"`, [any, ...Steps]>
+            : `${Acc}${CollapseDotSpacesWalk<S>}`;
 
 // Quote-aware lowercasing: SQL keywords/identifiers are case-insensitive, but
 // single-quoted string literals and double-quoted identifiers keep their exact
@@ -47,6 +105,20 @@ type LowercaseOutsideQuotesDrive<R> =
         ? LowercaseOutsideQuotesDrive<LowercaseOutsideQuotesWorker<S, Q1, Q2, Acc, []>>
         : R;
 
+// Segment-jump, not per-char. Each step advances a whole quote-bounded run:
+// outside quotes it jumps to the LEFTMOST of `'`/`"`, lowercasing the run before
+// it in a single `Lowercase<…>` intrinsic; inside a quote it copies verbatim to
+// the matching close-quote. Cost is O(quote boundaries), not O(chars) — the old
+// per-char walk emitted one instantiation per character on every NormalizeQuery.
+// The `Steps` cap now counts JUMPS (a handful even for report-scale queries), so
+// 450 is far past any real query yet still yields `{ __c }` for the driver before
+// TS's recursion ceiling on a pathologically quote-dense input.
+//
+// Exact-equivalent to the walk it replaces: `''` escapes toggle single-quote
+// state twice (exit on the first `'`, the second is re-seen outside with an empty
+// prefix and re-enters); an unterminated quote at EOF copies the rest verbatim
+// (`${Acc}${S}`); a `"` inside a single-quoted run never flips state (the
+// in-single branch only scans for `'`, and vice-versa).
 type LowercaseOutsideQuotesWorker<
     S extends string,
     InSingleQuote extends boolean,
@@ -55,25 +127,26 @@ type LowercaseOutsideQuotesWorker<
     Steps extends any[]
 > = Steps["length"] extends 450
     ? { __c: [S, InSingleQuote, InDoubleQuote, Acc] }
-    : S extends `${infer C}${infer Rest}`
-        ? C extends "'"
-            ? InDoubleQuote extends true
-                ? LowercaseOutsideQuotesWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                : InSingleQuote extends true
-                    ? LowercaseOutsideQuotesWorker<Rest, false, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                    : LowercaseOutsideQuotesWorker<Rest, true, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-            : C extends `"`
-                ? InSingleQuote extends true
-                    ? LowercaseOutsideQuotesWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                    : InDoubleQuote extends true
-                        ? LowercaseOutsideQuotesWorker<Rest, InSingleQuote, false, `${Acc}${C}`, [any, ...Steps]>
-                        : LowercaseOutsideQuotesWorker<Rest, InSingleQuote, true, `${Acc}${C}`, [any, ...Steps]>
-                : InSingleQuote extends true
-                    ? LowercaseOutsideQuotesWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                    : InDoubleQuote extends true
-                        ? LowercaseOutsideQuotesWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                        : LowercaseOutsideQuotesWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${Lowercase<C>}`, [any, ...Steps]>
-        : Acc;
+    : InSingleQuote extends true
+        ? S extends `${infer P}'${infer R}`
+            ? LowercaseOutsideQuotesWorker<R, false, InDoubleQuote, `${Acc}${P}'`, [any, ...Steps]>
+            : `${Acc}${S}`
+        : InDoubleQuote extends true
+            ? S extends `${infer P}"${infer R}`
+                ? LowercaseOutsideQuotesWorker<R, InSingleQuote, false, `${Acc}${P}"`, [any, ...Steps]>
+                : `${Acc}${S}`
+            : S extends `${infer P}'${infer R}`
+                ? P extends `${string}"${string}`
+                    // a `"` precedes the first `'` → the double quote is leftmost
+                    ? S extends `${infer P2}"${infer R2}`
+                        ? LowercaseOutsideQuotesWorker<R2, InSingleQuote, true, `${Acc}${Lowercase<P2>}"`, [any, ...Steps]>
+                        : `${Acc}${Lowercase<S>}`
+                    // `'` is the leftmost quote
+                    : LowercaseOutsideQuotesWorker<R, true, InDoubleQuote, `${Acc}${Lowercase<P>}'`, [any, ...Steps]>
+                // no `'` remains → only a `"` could open a verbatim run
+                : S extends `${infer P2}"${infer R2}`
+                    ? LowercaseOutsideQuotesWorker<R2, InSingleQuote, true, `${Acc}${Lowercase<P2>}"`, [any, ...Steps]>
+                    : `${Acc}${Lowercase<S>}`;
 
 // ---------------------------------------------------------------------------
 // Param-name-preserving lowercaser (write/raw builder path only).
@@ -145,6 +218,15 @@ type ReadParamIdent<S extends string, Acc extends string = "", N extends any[] =
         : ReadParamIdent<R, `${Acc}${C}`, [any, ...N]>
     : { name: Acc; rest: S };
 
+// Segment-jump sibling of `LowercaseOutsideQuotesWorker`, with the extra
+// outside-quote rule that a lone `:` opens a case-PRESERVED `:name` param and
+// `::` is a cast unit. Outside quotes it is therefore a leftmost-of-THREE jump
+// (`'` / `"` / `:`): split on the first `:`; if a quote occurs in the run BEFORE
+// it, the quote is leftmost so defer to `LcKeepQuoteJump` (the same leftmost-of-2
+// quote logic as the plain worker); otherwise the colon is leftmost — lowercase
+// the run, then consume `::` or read the verbatim param ident, exactly as the old
+// per-char branch did. In/out-of-quote verbatim copies and the `''`/unterminated
+// edges match `LowercaseOutsideQuotesWorker`.
 type LcKeepWorker<
     S extends string,
     InSingleQuote extends boolean,
@@ -153,38 +235,51 @@ type LcKeepWorker<
     Steps extends any[]
 > = Steps["length"] extends 450
     ? { __c: [S, InSingleQuote, InDoubleQuote, Acc] }
-    : S extends `${infer C}${infer Rest}`
-        ? C extends "'"
-            ? InDoubleQuote extends true
-                ? LcKeepWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                : InSingleQuote extends true
-                    ? LcKeepWorker<Rest, false, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                    : LcKeepWorker<Rest, true, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-            : C extends `"`
-                ? InSingleQuote extends true
-                    ? LcKeepWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                    : InDoubleQuote extends true
-                        ? LcKeepWorker<Rest, InSingleQuote, false, `${Acc}${C}`, [any, ...Steps]>
-                        : LcKeepWorker<Rest, InSingleQuote, true, `${Acc}${C}`, [any, ...Steps]>
-                : InSingleQuote extends true
-                    ? LcKeepWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                    : InDoubleQuote extends true
-                        ? LcKeepWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${C}`, [any, ...Steps]>
-                        // outside quotes: a lone `:` begins a named param (case-
-                        // preserved); `::` is a cast operator consumed as a unit.
-                        : C extends ":"
-                            ? Rest extends `:${infer R2}`
-                                ? LcKeepWorker<R2, InSingleQuote, InDoubleQuote, `${Acc}::`, [any, ...Steps]>
-                                : ReadParamIdent<Rest> extends { name: infer Nm extends string; rest: infer Rr extends string }
-                                    ? LcKeepWorker<Rr, InSingleQuote, InDoubleQuote, `${Acc}:${Nm}`, [any, ...Steps]>
-                                    : LcKeepWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}:`, [any, ...Steps]>
-                        : LcKeepWorker<Rest, InSingleQuote, InDoubleQuote, `${Acc}${Lowercase<C>}`, [any, ...Steps]>
-        : Acc;
+    : InSingleQuote extends true
+        ? S extends `${infer P}'${infer R}`
+            ? LcKeepWorker<R, false, InDoubleQuote, `${Acc}${P}'`, [any, ...Steps]>
+            : `${Acc}${S}`
+        : InDoubleQuote extends true
+            ? S extends `${infer P}"${infer R}`
+                ? LcKeepWorker<R, InSingleQuote, false, `${Acc}${P}"`, [any, ...Steps]>
+                : `${Acc}${S}`
+            : S extends `${infer Pc}:${infer Rc}`
+                // a quote before the first `:` → the quote is leftmost
+                ? Pc extends `${string}'${string}`
+                    ? LcKeepQuoteJump<S, InSingleQuote, InDoubleQuote, Acc, Steps>
+                    : Pc extends `${string}"${string}`
+                        ? LcKeepQuoteJump<S, InSingleQuote, InDoubleQuote, Acc, Steps>
+                        // colon is leftmost: `::` cast unit, else verbatim `:name`
+                        : Rc extends `:${infer R2}`
+                            ? LcKeepWorker<R2, InSingleQuote, InDoubleQuote, `${Acc}${Lowercase<Pc>}::`, [any, ...Steps]>
+                            : ReadParamIdent<Rc> extends { name: infer Nm extends string; rest: infer Rr extends string }
+                                ? LcKeepWorker<Rr, InSingleQuote, InDoubleQuote, `${Acc}${Lowercase<Pc>}:${Nm}`, [any, ...Steps]>
+                                : LcKeepWorker<Rc, InSingleQuote, InDoubleQuote, `${Acc}${Lowercase<Pc>}:`, [any, ...Steps]>
+                // no `:` remains → only quotes (or nothing) left
+                : LcKeepQuoteJump<S, InSingleQuote, InDoubleQuote, Acc, Steps>;
+
+// Leftmost-of-2 quote jump (identical shape to the plain worker's outside-quote
+// branch) that hands the continuation back to `LcKeepWorker`.
+type LcKeepQuoteJump<
+    S extends string,
+    InSingleQuote extends boolean,
+    InDoubleQuote extends boolean,
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}'${infer R}`
+    ? P extends `${string}"${string}`
+        ? S extends `${infer P2}"${infer R2}`
+            ? LcKeepWorker<R2, InSingleQuote, true, `${Acc}${Lowercase<P2>}"`, [any, ...Steps]>
+            : `${Acc}${Lowercase<S>}`
+        : LcKeepWorker<R, true, InDoubleQuote, `${Acc}${Lowercase<P>}'`, [any, ...Steps]>
+    : S extends `${infer P2}"${infer R2}`
+        ? LcKeepWorker<R2, InSingleQuote, true, `${Acc}${Lowercase<P2>}"`, [any, ...Steps]>
+        : `${Acc}${Lowercase<S>}`;
 
 // NormalizeQuery variant that preserves `:name` param case — used by the
 // write/raw builder param extraction (ExtractParams) only.
 export type NormalizeQueryKeepParams<S extends string> =
-    RewriteExtractCall<Trim<RemoveTrailingSemicolon<LowercaseOutsideQuotesKeepParams<CollapseSpaces<ReplaceWhitespace<StripComments<NeutralizePgLiterals<S>>>>>>>>;
+    RewriteExtractCall<Trim<RemoveTrailingSemicolon<CollapseDotSpaces<LowercaseOutsideQuotesKeepParams<CollapseSpaces<ReplaceWhitespace<StripComments<NeutralizePgLiterals<S>>>>>>>>>;
 
 // Convert every `\n` / `\t` / `\r` to a space. OCCURRENCE-based (like
 // `CollapseSpaces`): each step splits at the FIRST remaining line break, so the

package/src/parsing/pg-literals.ts

@@ -206,15 +206,19 @@ export type RewriteExtractRewriteOne<Pre extends string, AfterOpen extends strin
         : `${Pre} extract(${AfterOpen}`;
 
 // True when `S` contains an odd number of single quotes — i.e. its end is inside
-// an unterminated single-quoted string literal. Bounded; on bail returns the
-// best-effort parity so far.
+// an unterminated single-quoted string literal. Marker-jump: each step hops to the
+// next `'` (the `${infer _Pre}` skips a whole run of non-quote chars at once) and
+// flips the parity, so the depth is the NUMBER OF QUOTES — a handful — not the
+// string length. `${infer _Pre}'${infer R}` matches the LEFTMOST `'`, so quotes are
+// counted in order, exactly as the old per-char toggle did. Bounded against a
+// pathological quote-dense string; on bail returns the best-effort parity so far.
 export type OddSingleQuotes<S extends string, Flag extends boolean = false, Steps extends any[] = []> =
     string extends S
         ? false
         : Steps["length"] extends 400
             ? Flag
-            : S extends `${infer C}${infer R}`
-                ? OddSingleQuotes<R, C extends "'" ? (Flag extends true ? false : true) : Flag, [any, ...Steps]>
+            : S extends `${infer _Pre}'${infer R}`
+                ? OddSingleQuotes<R, Flag extends true ? false : true, [any, ...Steps]>
                 : Flag;
 
 // Strip `/* ... */` block comments AND `-- ...` line comments before any other
@@ -277,13 +281,20 @@ export type StripCommentsWalk<
 
 // Skip a line comment body, returning the tail starting at the first newline
 // (which is kept so words on either side of the comment can't merge). A comment
-// that runs to the end of the string yields `""`. Bounded against runaway.
-export type LineCommentTail<S extends string, Steps extends any[] = []> =
-    Steps["length"] extends 1000
-        ? S
-        : S extends `${infer C}${infer Rest}`
-            ? C extends "\n" | "\r"
-                ? S
-                : LineCommentTail<Rest, [any, ...Steps]>
+// that runs to the end of the string yields `""`.
+//
+// Marker-jump: locate the first `\n`/`\r` with template matching instead of a
+// per-char walk. `${infer Pre}\n${infer After}` finds the LEFTMOST `\n`; if its
+// prefix `Pre` itself holds a `\r`, that `\r` is the earlier newline, so the tail
+// starts there (`\r${PreB}\n${After}`). With no `\n`, fall back to the leftmost
+// `\r`; with neither, the comment runs to EOF → `""`. No recursion (and so no step
+// cap): a 1000-char single-line comment is now ~2 template instantiations.
+export type LineCommentTail<S extends string> =
+    S extends `${infer Pre}\n${infer After}`
+        ? Pre extends `${infer _PreA}\r${infer PreB}`
+            ? `\r${PreB}\n${After}`
+            : `\n${After}`
+        : S extends `${infer _P}\r${infer After}`
+            ? `\r${After}`
             : "";
 

package/src/parsing/tokenize.ts

@@ -1,9 +1,9 @@
 // Tokenization, sentinels, operators, and SQL keyword sets.
-import type { CollapseSpaces, FilterEmpty, MapClean, MapCleanLoose, ReplaceAll, Split } from "./string-utils.js";
+import type { CleanIdent, CleanLooseToken, CollapseSpaces, ReplaceAll, Split, Trim, TrimPunctuation } from "./string-utils.js";
 import type { ExceedsLengthBudget, HasLineBreaks } from "./normalize.js";
 // Tokenization & parsing helpers
 
-export type Tokenize<N extends string> = FilterEmpty<MapClean<Split<N, " ">>>;
+export type Tokenize<N extends string> = CleanFilterTokens<Split<N, " ">>;
 
 // Sentinel token standing in for a TOP-LEVEL comma. It survives `MapClean`
 // (no stripped punctuation, non-empty identifier) whereas a bare `,` does not,
@@ -64,12 +64,12 @@ export type TokenizeTables<N extends string> =
         ? Tokenize<N>
         : ExceedsLengthBudget<N> extends true
             ? Tokenize<N>
-            : FilterEmpty<MapClean<RestoreDQuotedSpaces<Split<MaybeMarkDQuotedSpaces<MarkTopLevelCommas<N>>, " ">>>>;
+            : RestoreCleanFilterTokens<Split<MaybeMarkDQuotedSpaces<MarkTopLevelCommas<N>>, " ">>;
 
 export type TokenizeLoose<N extends string> =
-    FilterEmpty<MapCleanLoose<RestoreDQuotedSpaces<
+    RestoreCleanLooseFilterTokens<
         Split<CollapseSpaces<RestoreWildcards<PadOperators<ProtectWildcards<MaybeMarkDQuotedSpaces<MaybeStripDQuotedPunct<N>>>>>>, " ">
-    >>> extends infer Toks extends string[]
+    > extends infer Toks extends string[]
         ? N extends `${string}distinct ${string}`
             ? DropDistinctFrom<Toks>
             : Toks
@@ -168,12 +168,45 @@ export type MarkDQuotedSpaces<
                     : MarkDQuotedSpaces<Rest, InDQ, `${Acc}${C}`, [any, ...Steps]>
             : Acc;
 
-// Restore the space sentinel to a real space in each token of a token list, so a
-// quoted identifier that survived the space-split as one token (`"Order ID"`,
-// `"user alias".id`) is cleaned to its true value (`order id`, `"user alias".id`).
-export type RestoreDQuotedSpaces<Tokens extends string[], Acc extends string[] = []> =
+// Fused token post-passes: one walk instead of the old
+// `FilterEmpty<MapClean<RestoreDQuotedSpaces<…>>>` three-walk chain. Each pass was
+// an independent element-wise map/filter, so composing them per token yields the
+// identical list (ordering preserved) while building the result spine once.
+//
+// The DQuote-space sentinel restore (`ReplaceAll<H, DQuoteSpaceSentinel, " ">`) lets
+// a quoted identifier that survived the space-split as one token (`"Order ID"`,
+// `"user alias".id`) clean to its true value. `CleanFilterTokens` is the no-restore
+// variant (plain `Tokenize`, which never marks sentinels).
+//
+// MapClean maps each token to `CleanIdent<H> extends "" ? "" : TrimPunctuation<Trim<H>>`
+// and FilterEmpty drops the `""`s. Since `CleanIdent = Lowercase<Unquote<TrimPunctuation<
+// Trim<S>>>>`, a non-empty `CleanIdent<H>` guarantees a non-empty `TrimPunctuation<Trim<H>>`,
+// so the kept value is never empty — the empty-token filter collapses to the single
+// `CleanIdent<H> extends ""` test. (The loose variant keeps an explicit empty filter
+// because `CleanLooseToken` can return `""` for a non-operator empty ident.)
+export type CleanFilterTokens<Tokens extends string[], Acc extends string[] = []> =
     Tokens extends [infer H extends string, ...infer R extends string[]]
-        ? RestoreDQuotedSpaces<R, [...Acc, ReplaceAll<H, DQuoteSpaceSentinel, " ">]>
+        ? CleanIdent<H> extends ""
+            ? CleanFilterTokens<R, Acc>
+            : CleanFilterTokens<R, [...Acc, TrimPunctuation<Trim<H>>]>
+        : Acc;
+
+export type RestoreCleanFilterTokens<Tokens extends string[], Acc extends string[] = []> =
+    Tokens extends [infer H0 extends string, ...infer R extends string[]]
+        ? ReplaceAll<H0, DQuoteSpaceSentinel, " "> extends infer H extends string
+            ? CleanIdent<H> extends ""
+                ? RestoreCleanFilterTokens<R, Acc>
+                : RestoreCleanFilterTokens<R, [...Acc, TrimPunctuation<Trim<H>>]>
+            : never
+        : Acc;
+
+export type RestoreCleanLooseFilterTokens<Tokens extends string[], Acc extends string[] = []> =
+    Tokens extends [infer H0 extends string, ...infer R extends string[]]
+        ? CleanLooseToken<ReplaceAll<H0, DQuoteSpaceSentinel, " ">> extends infer M extends string
+            ? M extends ""
+                ? RestoreCleanLooseFilterTokens<R, Acc>
+                : RestoreCleanLooseFilterTokens<R, [...Acc, M]>
+            : never
         : Acc;
 
 // A validation-only view of a query: blank the CONTENTS of every single-quoted
@@ -198,26 +231,26 @@ export type ValidationScanView<S extends string> =
         ? MaybeMarkDQuotedSpaces<BlankSingleQuotedLiterals<S>>
         : MaybeMarkDQuotedSpaces<S>;
 
+// Pairwise marker-jump: hop to the opening `'`, then to its closing `'`, emitting
+// the verbatim prefix plus a blanked body `''`, and recurse on the tail. The `''`
+// SQL escape pairs LEFTMOST exactly as the old per-char toggle did (`'it''s'` →
+// `''''`); an UNTERMINATED opener (no closing `'`) is closed off with an appended
+// `'`, matching the old EOF-in-string branch (`${Acc}'`), so `…'xyz` → `…''`. Depth
+// is now the NUMBER OF LITERALS (a handful), not the string length (≤600 before).
+// Step cap retained purely as a runaway backstop for a pathological quote storm.
 export type BlankSingleQuotedLiterals<
     S extends string,
-    InString extends boolean = false,
     Acc extends string = "",
     Steps extends any[] = []
 > = string extends S
     ? S
-    : Steps["length"] extends 600
+    : Steps["length"] extends 300
         ? `${Acc}${S}`
-        : InString extends true
-            ? S extends `${infer C}${infer R}`
-                ? C extends "'"
-                    ? BlankSingleQuotedLiterals<R, false, `${Acc}'`, [any, ...Steps]>
-                    : BlankSingleQuotedLiterals<R, true, Acc, [any, ...Steps]>
-                : `${Acc}'`
-            : S extends `${infer C}${infer R}`
-                ? C extends "'"
-                    ? BlankSingleQuotedLiterals<R, true, `${Acc}'`, [any, ...Steps]>
-                    : BlankSingleQuotedLiterals<R, false, `${Acc}${C}`, [any, ...Steps]>
-                : Acc;
+        : S extends `${infer Pre}'${infer Rest}`
+            ? Rest extends `${infer _Lit}'${infer After}`
+                ? BlankSingleQuotedLiterals<After, `${Acc}${Pre}''`, [any, ...Steps]>
+                : `${Acc}${Pre}''`
+            : `${Acc}${S}`;
 
 export type OperatorToken =
     | "(" | ")" | "," | "=" | "<" | ">" | "+" | "-" | "*" | "/" | "|" | "&" | "!" | "?"

package/src/tables.ts

@@ -70,7 +70,17 @@ export type CollectTables<
             // the bare `lateral` nor the function name is mistaken for a table.
             ? Next extends "lateral"
                 ? CollectTables<Rest, S, Acc, true, InDelete>
-                : CollectTables<Rest, S, Acc | TableKeyFromToken<Next, S>, true, InDelete>
+                // A parenthesised FROM/JOIN source — a subquery (`from (select ...)`)
+                // or VALUES list (`from (values ...)`) — has its `(` stripped by
+                // `TokenizeTables`, leaving a leading SQL keyword (`select`/`values`)
+                // as the source token. That keyword is NOT a base table; collecting it
+                // fabricates a bogus `public.select`/`public.values` key that fails the
+                // existence check. A real (unquoted) table is never a SQL keyword, so
+                // skipping keyword sources here is safe; the source's `) AS alias` is
+                // handled leniently in qualified-ref validation.
+                : Next extends SqlKeyword
+                    ? CollectTables<Rest, S, Acc, true, InDelete>
+                    : CollectTables<Rest, S, Acc | TableKeyFromToken<Next, S>, true, InDelete>
             : T extends "update"
                 ? Next extends "set"
                     ? CollectTables<Rest, S, Acc, false, InDelete>
@@ -87,7 +97,16 @@ export type CollectTables<
                             : CollectTables<[Next, ...Rest], S, Acc, InList, InDelete>
                         : T extends CommaSep
                             ? InList extends true
-                                ? CollectTables<Rest, S, Acc | TableKeyFromToken<Next, S>, true, InDelete>
+                                // `UPDATE t SET a = (select ... from x), b = ...` — the
+                                // subquery's parens are stripped by tokenization, so its
+                                // `from x` leaves `InList` on and the TOP-LEVEL SET comma
+                                // would collect the next SET column (`b`) as a table. A
+                                // FROM-source name is never followed by `=`, so a comma
+                                // whose candidate source is followed by `=` is a SET-list
+                                // separator: skip it and leave source-list mode.
+                                ? Rest extends ["=", ...infer Rest2 extends string[]]
+                                    ? CollectTables<Rest2, S, Acc, false, InDelete>
+                                    : CollectTables<Rest, S, Acc | TableKeyFromToken<Next, S>, true, InDelete>
                                 : CollectTables<[Next, ...Rest], S, Acc, false, InDelete>
                             : T extends "as"
                                 ? CollectTables<[Next, ...Rest], S, Acc, InList, InDelete>
@@ -125,14 +144,26 @@ export type CollectAliases<
             // modifier so it is never parsed as an aliased table source.
             ? Next extends "lateral"
                 ? CollectAliases<Rest, S, Acc, true, InDelete>
-                : ParseAliasSource<Next, Rest, S, Acc, InDelete>
+                // Mirror `CollectTables`: a parenthesised subquery/VALUES source has
+                // its `(` stripped, leaving a leading SQL keyword token. It is not a
+                // base-table source, so skip it rather than register a garbage alias
+                // from the keyword + the next token.
+                : Next extends SqlKeyword
+                    ? CollectAliases<Rest, S, Acc, true, InDelete>
+                    : ParseAliasSource<Next, Rest, S, Acc, InDelete>
             : T extends "using"
                 ? InDelete extends true
                     ? ParseAliasSource<Next, Rest, S, Acc, InDelete>
                     : CollectAliases<[Next, ...Rest], S, Acc, InList, InDelete>
                 : T extends CommaSep
                     ? InList extends true
-                        ? ParseAliasSource<Next, Rest, S, Acc, InDelete>
+                        // Mirror `CollectTables`: a comma whose candidate source is
+                        // followed by `=` is an UPDATE SET-list separator (the SET
+                        // subquery's `from` left `InList` on), not another aliased
+                        // FROM source.
+                        ? Rest extends ["=", ...infer Rest2 extends string[]]
+                            ? CollectAliases<Rest2, S, Acc, false, InDelete>
+                            : ParseAliasSource<Next, Rest, S, Acc, InDelete>
                         : CollectAliases<[Next, ...Rest], S, Acc, false, InDelete>
                     : T extends "as"
                         ? CollectAliases<[Next, ...Rest], S, Acc, InList, InDelete>