@kuindji/typed-sql 0.1.0 → 0.2.0

package/src/builder/assemble.ts

@@ -15,15 +15,17 @@ import type { RuntimeSelectState } from "./state.js";
 export function assembleSelectSQL(state: RuntimeSelectState): string {
     const parts: string[] = [];
 
-    const cteIds = Object.keys(state.cteSql);
-    if (cteIds.length > 0) {
-        const withParts = cteIds.map(id => state.cteSql[id]).join(", ");
-        parts.push(`WITH ${withParts}`);
-    }
+    // `SELECT` / `SELECT DISTINCT` / `SELECT DISTINCT ON (...)` prefix, shared
+    // by the projected and `*` paths.
+    const distinctPrefix = state.distinctOn
+        ? `SELECT DISTINCT ON (${state.distinctOn})`
+        : state.distinct
+            ? "SELECT DISTINCT"
+            : "SELECT";
 
     const selectIds = Object.keys(state.selectSql);
     if (selectIds.length === 0) {
-        parts.push("SELECT *");
+        parts.push(`${distinctPrefix} *`);
     }
     else {
         const selectFragments: string[] = [];
@@ -36,9 +38,7 @@ export function assembleSelectSQL(state: RuntimeSelectState): string {
         const selectSql = selectFragments.length > 0
             ? selectFragments.join(", ")
             : "*";
-        parts.push(
-            state.distinct ? `SELECT DISTINCT ${selectSql}` : `SELECT ${selectSql}`,
-        );
+        parts.push(`${distinctPrefix} ${selectSql}`);
     }
 
     if (state.fromSql) {
@@ -87,10 +87,6 @@ export function assembleSelectSQL(state: RuntimeSelectState): string {
         parts.push(`OFFSET ${state.offset}`);
     }
 
-    if (state.unionSql) {
-        parts.push(state.unionSql);
-    }
-
     const sql = parts.join(" ");
     const namedParams = state.namedParams;
     if (namedParams && Object.keys(namedParams).length > 0) {

package/src/builder/conditional-sql.ts

@@ -6,7 +6,7 @@
 // (GetReturnType / ValidateSQL).
 import type { DatabaseSchema } from "../schema.js";
 import type { GetReturnType, ValidateSQL } from "../index.js";
-import type { QueryParamValue } from "./params.js";
+import { collectParamValues, expandNamedParams, type QueryParamValue } from "./params.js";
 
 // ============================================================================
 // Runtime (ported from OLD conditional/runtime.ts)
@@ -76,37 +76,19 @@ export function processConditionalSQL(
     return result;
 }
 
-/** Convert :name placeholders to positional $n; return processed SQL + values. */
+/**
+ * Convert :name placeholders to positional $n; return processed SQL + values.
+ * Delegates to the shared scanner-backed expander (params.ts) so a `:name`
+ * inside a string literal, comment, or `::cast` is left alone, and a used param
+ * whose value is `undefined` throws instead of silently passing through.
+ */
 export function processParams(
     sql: string,
     params: Record<string, QueryParamValue>,
 ): ConditionalSQLOutput {
-    // Find all param references in order of first appearance.
-    const paramRegex = /:([a-zA-Z_][a-zA-Z0-9_]*)(?![a-zA-Z0-9_])/g;
-    const usedParams: string[] = [];
-    let match;
-
-    while ((match = paramRegex.exec(sql)) !== null) {
-        const name = match[1];
-        if (name in params && !usedParams.includes(name)) {
-            usedParams.push(name);
-        }
-    }
-
-    // Replace each param with positional placeholder.
-    let processedSql = sql;
-    for (let i = 0; i < usedParams.length; i++) {
-        const name = usedParams[i];
-        const regex = new RegExp(`:${name}(?![a-zA-Z0-9_])`, "g");
-        processedSql = processedSql.replace(regex, `$${i + 1}`);
-    }
-
-    // Extract param values in order.
-    const paramValues = usedParams.map(name => params[name]);
-
     return {
-        sql: processedSql,
-        params: paramValues,
+        sql: expandNamedParams(sql, params),
+        params: collectParamValues(sql, params),
     };
 }
 

package/src/builder/params.ts

@@ -1,4 +1,5 @@
 // src/builder/params.ts
+import { scanPlaceholders, type PlaceholderOccurrence } from "./scanner.js";
 
 /** Runtime parameter value type supported by query builders. */
 export type QueryParamValue = string | number | boolean | null;
@@ -16,23 +17,22 @@ export type QueryParamInput =
     | readonly QueryParamValue[]
     | undefined;
 
-// Ported verbatim from OLD: trailing negative lookahead stops a short param
-// (:te) from clobbering a longer one (:text). Matching the second colon of a
-// ::cast is intentional parity (pinned by params.test.ts).
-const PARAM_REGEX = /:([a-zA-Z_][a-zA-Z0-9_]*)(?![a-zA-Z0-9_])/g;
+// Placeholder detection is delegated to the shared scanner (scanner.ts), so the
+// SELECT / conditional-SQL path skips string literals, comments, dollar-quotes,
+// and `::cast` types exactly like the write builders — a single source of truth
+// for what counts as a real `:name`. Array values still expand UNCONDITIONALLY
+// here (any position), which is the builder's long-standing semantics and
+// differs from the scanner's IN-list-gated expansion used by createSql/mutate.
 
 /** Param names in order of first appearance that are present in `params`. */
 function usedParamNames(
-    sql: string,
+    occ: readonly PlaceholderOccurrence[],
     params: Record<string, QueryParamInput>,
 ): string[] {
     const used: string[] = [];
-    let match: RegExpExecArray | null;
-    PARAM_REGEX.lastIndex = 0;
-    while ((match = PARAM_REGEX.exec(sql)) !== null) {
-        const name = match[1];
-        if (name in params && !used.includes(name)) {
-            used.push(name);
+    for (const o of occ) {
+        if (o.name in params && !used.includes(o.name)) {
+            used.push(o.name);
         }
     }
     return used;
@@ -40,29 +40,35 @@ function usedParamNames(
 
 /**
  * Replace :name placeholders with $n positional placeholders, ordered by
- * first appearance. Array values expand to consecutive placeholders.
+ * first appearance. Array values expand to consecutive placeholders. A `:name`
+ * inside a string literal / comment / `::cast` is not a placeholder.
  */
 export function expandNamedParams(
     sql: string,
     params: Record<string, QueryParamInput>,
 ): string {
-    const used = usedParamNames(sql, params);
-    let out = sql;
+    const occ = scanPlaceholders(sql);
+    const used = usedParamNames(occ, params);
+    // First-appearance starting position for each used name; arrays reserve a
+    // contiguous block, repeats reuse the same block.
+    const startPos = new Map<string, number>();
     let position = 1;
     for (const name of used) {
+        startPos.set(name, position);
         const value = params[name];
-        const regex = new RegExp(`:${name}(?![a-zA-Z0-9_])`, "g");
-        if (Array.isArray(value)) {
-            const placeholders = value
-                .map((_, i) => `$${position + i}`)
-                .join(", ");
-            out = out.replace(regex, placeholders);
-            position += value.length;
-        }
-        else {
-            out = out.replace(regex, `$${position}`);
-            position++;
-        }
+        position += Array.isArray(value) ? value.length : 1;
+    }
+    // Rewrite right-to-left so earlier indices stay valid as we splice.
+    let out = sql;
+    for (let k = occ.length - 1; k >= 0; k--) {
+        const o = occ[k];
+        const p = startPos.get(o.name);
+        if (p === undefined) continue; // not provided → left as literal :name
+        const value = params[o.name];
+        const replacement = Array.isArray(value)
+            ? value.map((_, i) => `$${p + i}`).join(", ")
+            : `$${p}`;
+        out = out.slice(0, o.start) + replacement + out.slice(o.end);
     }
     return out;
 }
@@ -75,7 +81,7 @@ export function collectParamValues(
     sql: string,
     params: Record<string, QueryParamInput>,
 ): QueryParamValue[] {
-    const used = usedParamNames(sql, params);
+    const used = usedParamNames(scanPlaceholders(sql), params);
     const result: QueryParamValue[] = [];
     for (const name of used) {
         const value = params[name];

package/src/builder/select.ts

@@ -155,6 +155,16 @@ export interface SelectQueryBuilder<Schema extends DatabaseSchema, Sql extends S
         id?: Id,
     ): SelectQueryBuilder<Schema, WithOrderBy<Sql, ColsText<Cols>, ResolveId<Id, "order", Sql["orderBys"]>>>;
 
+    /** Emit `SELECT DISTINCT`. Does not change the result column set. */
+    distinct(): SelectQueryBuilder<Schema, Sql>;
+    /**
+     * Emit `SELECT DISTINCT ON (columns)` (PostgreSQL). Does not change the
+     * result column set; pair with a matching ORDER BY for deterministic rows.
+     */
+    distinctOn<const Cols extends string | readonly string[]>(
+        columns: Cols,
+    ): SelectQueryBuilder<Schema, Sql>;
+
     limit<const L extends number>(limit: L): SelectQueryBuilder<Schema, WithLimit<Sql, L>>;
     limitIf<const L extends number>(condition: boolean, limit: L): SelectQueryBuilder<Schema, WithLimit<Sql, L>>;
     offset<const O extends number>(offset: O): SelectQueryBuilder<Schema, WithOffset<Sql, O>>;
@@ -319,6 +329,15 @@ class SelectQueryBuilderImpl<Schema extends DatabaseSchema, Sql extends SqlTag>
         return condition ? this.orderBy(columns, id) : this.next(this._state);
     }
 
+    distinct(): any {
+        return this.next(this.clone({ distinct: true }));
+    }
+
+    distinctOn(columns: string | readonly string[]): any {
+        const cols = Array.isArray(columns) ? columns.join(", ") : (columns as string);
+        return this.next(this.clone({ distinctOn: cols }));
+    }
+
     limit(limit: number): any {
         return this.next(this.clone({ limit }));
     }
@@ -453,7 +472,6 @@ class SelectQueryBuilderImpl<Schema extends DatabaseSchema, Sql extends SqlTag>
 // getParams scans fragments joined by " " BEFORE $n substitution).
 function assembleSelectSQLPreSub(state: RuntimeSelectState): string {
     return [
-        ...Object.values(state.cteSql),
         ...Object.values(state.selectSql).flat(),
         state.fromSql ?? "",
         ...Object.values(state.joinSql),
@@ -461,7 +479,6 @@ function assembleSelectSQLPreSub(state: RuntimeSelectState): string {
         ...Object.values(state.groupBySql),
         ...Object.values(state.havingSql),
         ...Object.values(state.orderBySql),
-        state.unionSql ?? "",
     ].join(" ");
 }
 

package/src/builder/state.ts

@@ -23,11 +23,10 @@ export interface RuntimeSelectState {
     readonly havingSql: { readonly [id: string]: string };
     /** Raw ORDER BY fragments by id (joined with ", "). */
     readonly orderBySql: { readonly [id: string]: string };
-    /** Raw CTE fragments by id. */
-    readonly cteSql: { readonly [id: string]: string };
-    /** Raw UNION fragment (if any). */
-    readonly unionSql?: string;
+    /** SELECT DISTINCT when true (ignored if `distinctOn` is set). */
     readonly distinct: boolean;
+    /** SELECT DISTINCT ON (...) expression list, if set (already joined). */
+    readonly distinctOn?: string;
     readonly limit?: number;
     readonly offset?: number;
     /** Legacy positional params (kept for getParams() fallback). */
@@ -45,9 +44,8 @@ export const EMPTY_RUNTIME_STATE: RuntimeSelectState = {
     groupBySql: {},
     havingSql: {},
     orderBySql: {},
-    cteSql: {},
-    unionSql: undefined,
     distinct: false,
+    distinctOn: undefined,
     limit: undefined,
     offset: undefined,
     params: [],

package/src/expressions.ts

@@ -219,7 +219,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

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

@@ -47,6 +47,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 +69,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 +160,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,33 +177,46 @@ 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.

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}`
             : "";