@kuindji/typed-sql 0.3.0 → 0.4.0

package/src/parsing/extract.ts

@@ -36,28 +36,40 @@ export type FirstTopLevelReturningTail<S extends string> =
                 ? FirstTopLevelReturningTailWalk<S>
                 : S extends `${string} returning ${infer After}` ? After : "";
 
+// Quote-jump twin of `HasReturningQuoteAwareWalk` (validation/dispatch.ts):
+// find the leftmost ` returning `; if no quote opens before it, its tail is the
+// answer. Otherwise jump the leftmost quote span whole (`'…'` or `"…"`,
+// whichever opens first — the other quote kind inside the span is data) and
+// re-test the remainder. O(quote spans) instead of O(chars); an unterminated
+// quote swallows the rest, exactly like the old walk-to-EOF inside a literal.
 type FirstTopLevelReturningTailWalk<
     S extends string,
-    InString extends boolean = false,
-    InDString extends boolean = false,
     Steps extends any[] = []
 > = string extends S
     ? ""
-    : Steps["length"] extends 1200
+    : Steps["length"] extends 400
         ? S extends `${string} returning ${infer After}` ? After : ""
-        : InString extends true
-            ? S extends `${infer C}${infer Rest}`
-                ? FirstTopLevelReturningTailWalk<Rest, C extends "'" ? false : true, InDString, [any, ...Steps]>
+        : S extends `${infer Before} returning ${infer After}`
+            ? Before extends `${string}'${string}` | `${string}"${string}`
+                ? FtrtQuoteJump<S, Steps>
+                : After
+            : "";
+
+type FtrtQuoteJump<S extends string, Steps extends any[]> =
+    S extends `${infer P}'${infer R}`
+        ? P extends `${string}"${string}`
+            ? FtrtDQuoteJump<S, Steps>
+            : R extends `${string}'${infer R2}`
+                ? FirstTopLevelReturningTailWalk<R2, [any, ...Steps]>
                 : ""
-            : InDString extends true
-                ? S extends `${infer C}${infer Rest}`
-                    ? FirstTopLevelReturningTailWalk<Rest, InString, C extends `"` ? false : true, [any, ...Steps]>
-                    : ""
-                : S extends ` returning ${infer After}`
-                    ? After
-                    : S extends `${infer C}${infer Rest}`
-                        ? FirstTopLevelReturningTailWalk<Rest, C extends "'" ? true : false, C extends `"` ? true : false, [any, ...Steps]>
-                        : "";
+        : FtrtDQuoteJump<S, Steps>;
+
+type FtrtDQuoteJump<S extends string, Steps extends any[]> =
+    S extends `${string}"${infer R}`
+        ? R extends `${string}"${infer R2}`
+            ? FirstTopLevelReturningTailWalk<R2, [any, ...Steps]>
+            : ""
+        : "";
 
 // Given a string whose first non-skipped char is `(`, consume the first
 // balanced parenthesised group (quote-aware) and return its inner content plus
@@ -72,6 +84,15 @@ type FirstTopLevelReturningTailWalk<
 // every CHUNK steps and a driver that re-invokes it with a fresh step counter —
 // resetting TS's per-chain tail-recursion count, so arbitrarily long groups split
 // losslessly. Mirrors the `SplitTopLevel` worker/driver above.
+//
+// Struct-jump, not per-char (the old walk minted one growing-`Acc` string PER
+// CHARACTER across entire CTE/subquery bodies). Each step advances to the
+// LEFTMOST of the three state chars `'` `(` `)` (double quotes were never
+// tracked here — preserved), copying the whole run before it in a single mint;
+// inside a `'…'` literal it jumps straight to the closing quote (`''` escapes
+// exit+re-enter across two jumps; an unterminated quote at EOF copies the rest
+// verbatim). The `Steps` cap counts JUMPS and yields `{ __c: [...] }` to the
+// driver, so arbitrarily paren-dense inputs still complete losslessly.
 type SplitBalancedParenWorker<
     S extends string,
     Depth extends any[] = [],
@@ -80,23 +101,42 @@ type SplitBalancedParenWorker<
     Steps extends any[] = []
 > = Steps["length"] extends 350
     ? { __c: [S, Depth, Acc, InString] }
-    : S extends `${infer C}${infer Rest}`
-        ? C extends "'"
-            ? SplitBalancedParenWorker<Rest, Depth, `${Acc}${C}`, InString extends true ? false : true, [any, ...Steps]>
-            : InString extends true
-                ? SplitBalancedParenWorker<Rest, Depth, `${Acc}${C}`, InString, [any, ...Steps]>
-                : C extends "("
-                    ? Depth["length"] extends 0
-                        ? SplitBalancedParenWorker<Rest, [any], Acc, InString, [any, ...Steps]>
-                        : SplitBalancedParenWorker<Rest, [any, ...Depth], `${Acc}${C}`, InString, [any, ...Steps]>
-                    : C extends ")"
-                        ? Depth extends [any, ...infer D extends any[]]
-                            ? D["length"] extends 0
-                                ? { inner: Acc; rest: Rest }
-                                : SplitBalancedParenWorker<Rest, D, `${Acc}${C}`, InString, [any, ...Steps]>
-                            : { inner: Acc; rest: Rest }
-                        : SplitBalancedParenWorker<Rest, Depth, `${Acc}${C}`, InString, [any, ...Steps]>
-        : { inner: Acc; rest: "" };
+    : InString extends true
+        ? S extends `${infer P}'${infer R}`
+            ? SplitBalancedParenWorker<R, Depth, `${Acc}${P}'`, false, [any, ...Steps]>
+            : { inner: `${Acc}${S}`; rest: "" }
+        : S extends `${infer P}'${infer R}`
+            ? P extends `${string}(${string}` | `${string})${string}`
+                ? SbpParenJump<S, Depth, Acc, Steps>
+                : SplitBalancedParenWorker<R, Depth, `${Acc}${P}'`, true, [any, ...Steps]>
+            : SbpParenJump<S, Depth, Acc, Steps>;
+
+// Leftmost of `(` / `)` (the caller guarantees no `'` occurs before either).
+type SbpParenJump<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}(${infer R}`
+    ? P extends `${string})${string}`
+        ? SbpCloseJump<S, Depth, Acc, Steps>
+        : Depth["length"] extends 0
+            // the group-opening `(` itself is consumed, not copied into `inner`
+            ? SplitBalancedParenWorker<R, [any], `${Acc}${P}`, false, [any, ...Steps]>
+            : SplitBalancedParenWorker<R, [any, ...Depth], `${Acc}${P}(`, false, [any, ...Steps]>
+    : SbpCloseJump<S, Depth, Acc, Steps>;
+
+type SbpCloseJump<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P})${infer R}`
+    ? Depth extends [any, any, ...infer D extends any[]]
+        ? SplitBalancedParenWorker<R, [any, ...D], `${Acc}${P})`, false, [any, ...Steps]>
+        // depth ≤ 1: this `)` closes the group (or is an unmatched top-level `)`)
+        : { inner: `${Acc}${P}`; rest: R }
+    : { inner: `${Acc}${S}`; rest: "" };
 
 export type SplitBalancedParen<S extends string> =
     SplitBalancedParenDrive<SplitBalancedParenWorker<S>>;

package/src/parsing/normalize.ts

@@ -295,18 +295,64 @@ export type ReplaceWhitespace<S extends string> =
         ? ReplaceWhitespaceRuns<S>
         : S;
 
-type ReplaceWhitespaceRuns<S extends string, Steps extends any[] = []> =
+// Acc-carrying worker: the finished prefix moves into `Acc` and is NEVER
+// rescanned or reminted (the old form rebuilt the FULL string once per line
+// break and re-matched it from the start). Because consumed segments leave the
+// scan, the worker must take the LEFTMOST of `\n`/`\t`/`\r` each step — the
+// old rebuild-and-rescan form got that for free by always re-matching `\n`
+// first over the whole string. Same pairwise-narrowing cascade as
+// `MtcStructJump`. The step cap counts whitespace RUNS (each consumed whole by
+// `ConsumeWsRun`), so it covers at least as much input as the old
+// per-occurrence cap; on cap the remainder is left as-is, as before.
+type ReplaceWhitespaceRuns<S extends string, Acc extends string = "", Steps extends any[] = []> =
     string extends S
         ? S
         : Steps["length"] extends 1500
-            ? S
+            ? `${Acc}${S}`
             : S extends `${infer A}\n${infer B}`
-                ? ReplaceWhitespaceRuns<`${A} ${B}`, [any, ...Steps]>
-                : S extends `${infer A}\t${infer B}`
-                    ? ReplaceWhitespaceRuns<`${A} ${B}`, [any, ...Steps]>
-                    : S extends `${infer A}\r${infer B}`
-                        ? ReplaceWhitespaceRuns<`${A} ${B}`, [any, ...Steps]>
-                        : S;
+                ? A extends `${string}\t${string}` | `${string}\r${string}`
+                    ? RwrTabCr<S, Acc, Steps>
+                    : ReplaceWhitespaceRuns<ConsumeWsRun<B>, `${Acc}${A} `, [any, ...Steps]>
+                : RwrTabCr<S, Acc, Steps>;
+
+// Leftmost of `\t` / `\r` (caller ruled out an earlier `\n`).
+type RwrTabCr<S extends string, Acc extends string, Steps extends any[]> =
+    S extends `${infer A}\t${infer B}`
+        ? A extends `${string}\r${string}`
+            ? S extends `${infer A2}\r${infer B2}`
+                ? ReplaceWhitespaceRuns<ConsumeWsRun<B2>, `${Acc}${A2} `, [any, ...Steps]>
+                : `${Acc}${S}`
+            : ReplaceWhitespaceRuns<ConsumeWsRun<B>, `${Acc}${A} `, [any, ...Steps]>
+        : S extends `${infer A2}\r${infer B2}`
+            ? ReplaceWhitespaceRuns<ConsumeWsRun<B2>, `${Acc}${A2} `, [any, ...Steps]>
+            : `${Acc}${S}`;
+
+// Eat the whole whitespace run FOLLOWING a consumed line break before the full
+// string is rebuilt. A formatted query's `\n␣␣␣␣` indentation otherwise survives
+// as a multi-space run that costs `ReplaceWhitespaceRuns` extra full-string
+// remints (one per `\n` of a blank line) plus one more full remint per run in
+// `CollapseSpaces`. Peeling here works on the TAIL only — far cheaper mints —
+// and leaves `CollapseSpaces` a no-op for these runs. Equivalence: both forms
+// reduce every whitespace run that touches a line break to a single space, and
+// runs NOT touching a line break are still collapsed by the unchanged
+// `CollapseSpaces` pass. A capped-out leftover (`\t`/`\n`/`\r` beyond the
+// budget) is still caught by the outer loop's own branches.
+type ConsumeWsRun<S extends string, Steps extends any[] = []> =
+    Steps["length"] extends 64
+        ? S
+        : S extends `                ${infer R}`   // 16 spaces
+            ? ConsumeWsRun<R, [any, ...Steps]>
+            : S extends `    ${infer R}`           // 4 spaces
+                ? ConsumeWsRun<R, [any, ...Steps]>
+                : S extends ` ${infer R}`
+                    ? ConsumeWsRun<R, [any, ...Steps]>
+                    : S extends `\t${infer R}`
+                        ? ConsumeWsRun<R, [any, ...Steps]>
+                        : S extends `\n${infer R}`
+                            ? ConsumeWsRun<R, [any, ...Steps]>
+                            : S extends `\r${infer R}`
+                                ? ConsumeWsRun<R, [any, ...Steps]>
+                                : S;
 
 // Cheap "is this string longer than ~500 chars" check: drop 10 chars per step
 // for up to 50 steps. If content survives all 50 drops the string exceeds the

package/src/parsing/pg-literals.ts

@@ -170,16 +170,38 @@ export type RewriteExtractCall<S extends string> =
             : RewriteExtractWalk<S>
         : S;
 
-export type RewriteExtractWalk<S extends string, Steps extends any[] = []> =
-    Steps["length"] extends 24
-        ? S
-        : S extends `${infer Pre} extract(${infer AfterOpen}`
-            ? SplitBalancedParen<`(${AfterOpen}`> extends { inner: infer Inner extends string; rest: infer Rest extends string }
-                ? Inner extends `${infer _Field} from ${infer Source}`
-                    ? `${RewriteExtractWalk<Pre, [any, ...Steps]>} extract(${Trim<Source>})${RewriteExtractWalk<Rest, [any, ...Steps]>}`
-                    : `${RewriteExtractWalk<Pre, [any, ...Steps]>} extract(${Inner})${RewriteExtractWalk<Rest, [any, ...Steps]>}`
-                : S
-            : S;
+// Tail-recursive accumulator walk + chunked driver. Template matching is
+// LEFTMOST, so `Pre` can never contain another ` extract(` — it is appended to
+// `Acc` verbatim and only `Rest` is recursed. (The previous version recursed
+// into BOTH `Pre` and `Rest` building a nested template, so its step cap had to
+// stay tiny — 24 — and a 50-projection report query with 25+ EXTRACTs bailed
+// half-rewritten: the surviving inner ` from ` tokens then fed the tables
+// collector bogus sources like `min(ua.col`, flipping ValidateSQL to a false
+// rejection.) The driver re-invokes the worker with a fresh step counter every
+// 64 rewrites, so any realistic number of EXTRACTs completes losslessly.
+export type RewriteExtractWalk<S extends string> =
+    RewExDrive<RewExWorker<S>>;
+
+type RewExDrive<R> =
+    [R] extends [never]
+        ? never
+        : R extends { __c: [infer S extends string, infer Acc extends string] }
+            ? RewExDrive<RewExWorker<S, Acc, []>>
+            : R;
+
+type RewExWorker<
+    S extends string,
+    Acc extends string = "",
+    Steps extends any[] = []
+> = Steps["length"] extends 64
+    ? { __c: [S, Acc] }
+    : S extends `${infer Pre} extract(${infer AfterOpen}`
+        ? SplitBalancedParen<`(${AfterOpen}`> extends { inner: infer Inner extends string; rest: infer Rest extends string }
+            ? Inner extends `${infer _Field} from ${infer Source}`
+                ? RewExWorker<Rest, `${Acc}${Pre} extract(${Trim<Source>})`, [any, ...Steps]>
+                : RewExWorker<Rest, `${Acc}${Pre} extract(${Inner})`, [any, ...Steps]>
+            : `${Acc}${S}`
+        : `${Acc}${S}`;
 
 // As `RewriteExtractWalk`, but an ` extract(` whose prefix has an odd number of
 // single quotes sits INSIDE a string literal and is left verbatim (the literal's

package/src/parsing/split.ts

@@ -13,6 +13,15 @@ import type { SqlReserved } from "./tokenize.js";
 // `{ __c: [...] }` marker. `SplitTopLevel` (the driver below) re-invokes the
 // worker on the remainder with a fresh step counter, which resets TS's internal
 // tail-recursion count per chunk — so arbitrarily long lists split losslessly.
+// Segment-jump, not per-char (the old walk minted one growing-`Cur` string PER
+// CHARACTER and the tail at every step). Each step advances to the LEFTMOST of
+// the five state chars `,` `'` `"` `(` `)`, copying the whole run before it into
+// `Cur` in a single mint; inside a quote it jumps straight to the closing quote
+// (the other quote kind inside a span is data, preserving the old InQ/InDQ
+// suppression; `''` escapes exit+re-enter across two jumps; an unterminated
+// quote at EOF copies the rest verbatim). The `Steps` cap counts JUMPS and
+// yields `{ __c: [...] }` to the driver as before. Mirrors `MtcStructJump`
+// (tokenize.ts) and `SbpParenJump` (extract.ts).
 type SplitTopLevelWorker<
     S extends string,
     Depth extends any[] = [],
@@ -21,36 +30,89 @@ type SplitTopLevelWorker<
     Steps extends any[] = [],
     InQ extends boolean = false,
     InDQ extends boolean = false
-> = Steps["length"] extends 450
+// CHUNK = 120 JUMPS, not chars: since the round-7 struct-jump rewrite each
+// jump costs ~4 conditional evaluations through the StlStructJump* helper
+// chain, so the old 450-jump chunk could burn >1000 tail counts inside ONE
+// chunk (TS2589) on a 50-projection select list. 120 jumps ≈ 500 tail counts.
+> = Steps["length"] extends 120
     ? { __c: [S, Depth, Acc, Cur, InQ, InDQ] }
     : string extends CleanIdent<S>
         ? [...Acc, `${Cur}string`]
-        : S extends `${infer C}${infer Rest}`
-        ? C extends "'"
-            // A single quote toggles "inside string literal": commas, parens and
-            // path braces inside a '...' literal are kept verbatim, not split.
-            // Suppressed while inside a double-quoted identifier.
-            ? InDQ extends true
-                ? SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-                : SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ extends true ? false : true, InDQ>
-            : InQ extends true
-                ? SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-            : C extends `"`
-                // A double quote toggles "inside quoted identifier": commas and
-                // parens inside `"..."` are part of the identifier, kept verbatim.
-                ? SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ extends true ? false : true>
+        : InQ extends true
+            ? S extends `${infer P}'${infer R}`
+                ? SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P}'`, [any, ...Steps], false, InDQ>
+                : [...Acc, `${Cur}${S}`]
             : InDQ extends true
-                ? SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-            : C extends "("
-                ? SplitTopLevelWorker<Rest, [any, ...Depth], Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-                : C extends ")"
-                    ? SplitTopLevelWorker<Rest, Depth extends [any, ...infer D] ? D : [], Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-                    : C extends ","
-                        ? Depth["length"] extends 0
-                            ? SplitTopLevelWorker<Rest, Depth, [...Acc, Cur], "", [any, ...Steps], InQ, InDQ>
-                            : SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-                        : SplitTopLevelWorker<Rest, Depth, Acc, `${Cur}${C}`, [any, ...Steps], InQ, InDQ>
-        : [...Acc, Cur];
+                ? S extends `${infer P}"${infer R}`
+                    ? SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P}"`, [any, ...Steps], InQ, false>
+                    : [...Acc, `${Cur}${S}`]
+                : S extends `${infer P},${infer R}`
+                    // a structural char in the run before the first comma → it is
+                    // leftmost; defer to the struct jump
+                    ? StlHasStruct<P> extends true
+                        ? StlStructJump<S, Depth, Acc, Cur, Steps>
+                        : Depth["length"] extends 0
+                            ? SplitTopLevelWorker<R, Depth, [...Acc, `${Cur}${P}`], "", [any, ...Steps], false, false>
+                            : SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P},`, [any, ...Steps], false, false>
+                    : StlHasStruct<S> extends true
+                        ? StlStructJump<S, Depth, Acc, Cur, Steps>
+                        : [...Acc, `${Cur}${S}`];
+
+type StlHasStruct<S extends string> =
+    S extends `${string}'${string}` ? true
+    : S extends `${string}"${string}` ? true
+    : S extends `${string}(${string}` ? true
+    : S extends `${string})${string}` ? true
+    : false;
+
+// Leftmost of `'` / `"` / `(` / `)` (the caller guarantees at least one occurs
+// before any comma). Pairwise narrowing: split on a candidate; if an
+// earlier-class char appears in its prefix, that one is leftmost instead.
+type StlStructJump<
+    S extends string,
+    Depth extends any[],
+    Acc extends string[],
+    Cur extends string,
+    Steps extends any[]
+> = S extends `${infer P}'${infer R}`
+    ? P extends `${string}"${string}` | `${string}(${string}` | `${string})${string}`
+        ? StlStructJump2<S, Depth, Acc, Cur, Steps>
+        : SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P}'`, [any, ...Steps], true, false>
+    : StlStructJump2<S, Depth, Acc, Cur, Steps>;
+
+type StlStructJump2<
+    S extends string,
+    Depth extends any[],
+    Acc extends string[],
+    Cur extends string,
+    Steps extends any[]
+> = S extends `${infer P}"${infer R}`
+    ? P extends `${string}(${string}` | `${string})${string}`
+        ? StlStructJump3<S, Depth, Acc, Cur, Steps>
+        : SplitTopLevelWorker<R, Depth, Acc, `${Cur}${P}"`, [any, ...Steps], false, true>
+    : StlStructJump3<S, Depth, Acc, Cur, Steps>;
+
+type StlStructJump3<
+    S extends string,
+    Depth extends any[],
+    Acc extends string[],
+    Cur extends string,
+    Steps extends any[]
+> = S extends `${infer P}(${infer R}`
+    ? P extends `${string})${string}`
+        ? StlCloseJump<S, Depth, Acc, Cur, Steps>
+        : SplitTopLevelWorker<R, [any, ...Depth], Acc, `${Cur}${P}(`, [any, ...Steps], false, false>
+    : StlCloseJump<S, Depth, Acc, Cur, Steps>;
+
+type StlCloseJump<
+    S extends string,
+    Depth extends any[],
+    Acc extends string[],
+    Cur extends string,
+    Steps extends any[]
+> = S extends `${infer P})${infer R}`
+    ? SplitTopLevelWorker<R, Depth extends [any, ...infer D] ? D : [], Acc, `${Cur}${P})`, [any, ...Steps], false, false>
+    : [...Acc, `${Cur}${S}`];
 
 // Driver: run the worker chunk-by-chunk until it returns the finished `string[]`.
 // Each `{ __c: state }` yield is fed back with a fresh step counter, so no single
@@ -70,55 +132,157 @@ type SplitTopLevelDrive<R> =
 // Quote-aware on BOTH single quotes (`'...'` string literals) and double quotes
 // (`"..."` quoted identifiers): a ` from ` token sitting inside a double-quoted
 // output alias (`id as "came from import"`) is part of the identifier, not the
-// SELECT/FROM boundary, so it must not split the list. `InString` tracks single
-// quotes; `InDString` tracks double quotes. Parens and the ` from ` boundary are
-// only honoured when outside BOTH kinds of quote.
-export type ExtractBeforeFromTopLevel<
+// SELECT/FROM boundary, so it must not split the list. Parens and the ` from `
+// boundary are only honoured when outside BOTH kinds of quote.
+// Struct-jump, not per-char (the old walk minted a growing `Acc` PER CHARACTER
+// over every subquery select-list). At depth 0 each step advances to the
+// LEFTMOST of `'` `"` `(` `)` ` from ` (pairwise narrowing, multi-char keyword
+// checked last); at depth > 0 the ` from ` candidate is dropped (a nested FROM
+// is not the boundary). Quote spans are jumped quote-to-quote (the other quote
+// kind inside a span is data, preserving the old InString/InDString
+// suppression; an unterminated quote swallows the rest, as the old
+// walk-to-EOF did).
+//
+// CHUNKED worker/driver (mirrors `SplitTopLevel`): each jump costs ~4-5
+// conditional evaluations through the EbftJump* helper chain, so a single
+// recursion chain crosses TS's 1000 tail-count budget at ~200+ jumps — a
+// 50-projection SELECT list of quoted/parenthesised expressions gets there
+// (TS2589). The worker yields its state every 120 jumps and the driver
+// re-invokes it with a fresh step counter, so arbitrarily long select lists
+// complete losslessly. (The pre-chunking version bailed to a lenient
+// `ExtractBefore<S, " from ">` at a 350-jump cap — and blew TS2589 before
+// ever reaching it on exactly the queries the cap was meant to protect.)
+export type ExtractBeforeFromTopLevel<S extends string> =
+    EbftDrive<EbftWorker<S>>;
+
+type EbftDrive<R> =
+    [R] extends [never]
+        ? never
+        : R extends { __c: [infer S extends string, infer Depth extends any[], infer Acc extends string] }
+            ? EbftDrive<EbftWorker<S, Depth, Acc, []>>
+            : R;
+
+type EbftWorker<
     S extends string,
     Depth extends any[] = [],
-    InString extends boolean = false,
     Acc extends string = "",
-    Steps extends any[] = [],
-    InDString extends boolean = false
-> = Steps["length"] extends 350
-    ? `${Acc}${ExtractBefore<S, " from ">}`
-    : InString extends true
-        ? S extends `${infer C}${infer Rest}`
-            ? C extends "'"
-                ? ExtractBeforeFromTopLevel<Rest, Depth, false, `${Acc}${C}`, [any, ...Steps], InDString>
-                : ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], InDString>
-            : Acc
-        : InDString extends true
-            ? S extends `${infer C}${infer Rest}`
-                ? C extends `"`
-                    ? ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], false>
-                    : ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], true>
-                : Acc
-            : Depth["length"] extends 0
-                ? S extends ` from ${string}`
-                    ? Acc
-                    : S extends `${infer C}${infer Rest}`
-                        ? C extends "'"
-                            ? ExtractBeforeFromTopLevel<Rest, Depth, true, `${Acc}${C}`, [any, ...Steps], InDString>
-                            : C extends `"`
-                                ? ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], true>
-                                : C extends "("
-                                    ? ExtractBeforeFromTopLevel<Rest, [any, ...Depth], InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                                    : C extends ")"
-                                        ? ExtractBeforeFromTopLevel<Rest, Depth extends [any, ...infer D] ? D : [], InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                                        : ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                        : Acc
-                : S extends `${infer C}${infer Rest}`
-                    ? C extends "'"
-                        ? ExtractBeforeFromTopLevel<Rest, Depth, true, `${Acc}${C}`, [any, ...Steps], InDString>
-                        : C extends `"`
-                            ? ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], true>
-                            : C extends "("
-                                ? ExtractBeforeFromTopLevel<Rest, [any, ...Depth], InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                                : C extends ")"
-                                    ? ExtractBeforeFromTopLevel<Rest, Depth extends [any, ...infer D] ? D : [], InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                                    : ExtractBeforeFromTopLevel<Rest, Depth, InString, `${Acc}${C}`, [any, ...Steps], InDString>
-                    : Acc;
+    Steps extends any[] = []
+> = Steps["length"] extends 120
+    ? { __c: [S, Depth, Acc] }
+    : Depth["length"] extends 0
+        ? EbftJumpTop<S, Depth, Acc, Steps>
+        : EbftJumpNested<S, Depth, Acc, Steps>;
+
+// inside `'…'`: resume after the closing quote (any depth; quotes ignore depth)
+type EbftQuoteClose<
+    R extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = R extends `${infer Span}'${infer R2}`
+    ? EbftWorker<R2, Depth, `${Acc}${Span}'`, [any, ...Steps]>
+    : `${Acc}${R}`;
+
+type EbftDQuoteClose<
+    R extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = R extends `${infer Span}"${infer R2}`
+    ? EbftWorker<R2, Depth, `${Acc}${Span}"`, [any, ...Steps]>
+    : `${Acc}${R}`;
+
+type EbftJumpTop<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}'${infer R}`
+    ? P extends `${string}"${string}` | `${string}(${string}` | `${string})${string}` | `${string} from ${string}`
+        ? EbftJumpTop2<S, Depth, Acc, Steps>
+        : EbftQuoteClose<R, Depth, `${Acc}${P}'`, Steps>
+    : EbftJumpTop2<S, Depth, Acc, Steps>;
+
+type EbftJumpTop2<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}"${infer R}`
+    ? P extends `${string}(${string}` | `${string})${string}` | `${string} from ${string}`
+        ? EbftJumpTop3<S, Depth, Acc, Steps>
+        : EbftDQuoteClose<R, Depth, `${Acc}${P}"`, Steps>
+    : EbftJumpTop3<S, Depth, Acc, Steps>;
+
+type EbftJumpTop3<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}(${infer R}`
+    ? P extends `${string})${string}` | `${string} from ${string}`
+        ? EbftJumpTop4<S, Depth, Acc, Steps>
+        : EbftWorker<R, [any, ...Depth], `${Acc}${P}(`, [any, ...Steps]>
+    : EbftJumpTop4<S, Depth, Acc, Steps>;
+
+type EbftJumpTop4<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P})${infer R}`
+    ? P extends `${string} from ${string}`
+        ? EbftJumpTop5<S, Acc>
+        // an unmatched `)` at depth 0 stays at depth 0 (pop of empty = empty)
+        : EbftWorker<R, [], `${Acc}${P})`, [any, ...Steps]>
+    : EbftJumpTop5<S, Acc>;
+
+type EbftJumpTop5<S extends string, Acc extends string> =
+    S extends `${infer P} from ${string}`
+        ? `${Acc}${P}`
+        : `${Acc}${S}`;
+
+type EbftJumpNested<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}'${infer R}`
+    ? P extends `${string}"${string}` | `${string}(${string}` | `${string})${string}`
+        ? EbftJumpNested2<S, Depth, Acc, Steps>
+        : EbftQuoteClose<R, Depth, `${Acc}${P}'`, Steps>
+    : EbftJumpNested2<S, Depth, Acc, Steps>;
+
+type EbftJumpNested2<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}"${infer R}`
+    ? P extends `${string}(${string}` | `${string})${string}`
+        ? EbftJumpNested3<S, Depth, Acc, Steps>
+        : EbftDQuoteClose<R, Depth, `${Acc}${P}"`, Steps>
+    : EbftJumpNested3<S, Depth, Acc, Steps>;
+
+type EbftJumpNested3<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P}(${infer R}`
+    ? P extends `${string})${string}`
+        ? EbftJumpNested4<S, Depth, Acc, Steps>
+        : EbftWorker<R, [any, ...Depth], `${Acc}${P}(`, [any, ...Steps]>
+    : EbftJumpNested4<S, Depth, Acc, Steps>;
+
+type EbftJumpNested4<
+    S extends string,
+    Depth extends any[],
+    Acc extends string,
+    Steps extends any[]
+> = S extends `${infer P})${infer R}`
+    ? EbftWorker<R, Depth extends [any, ...infer D] ? D : [], `${Acc}${P})`, [any, ...Steps]>
+    : `${Acc}${S}`;
 
 // Simple comma split (no paren awareness)