From 3752127971129f712c731be56fbf20dc34527810 Mon Sep 17 00:00:00 2001
From: collin-thomas <collin.inbox@gmail.com>
Date: Thu, 12 Nov 2026 08:16:04 -0700
Subject: [PATCH 1/4] Scan a page's scripts without lowercasing a copy of it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

scanScripts lowercased the whole page to find tag names in any case. That
copied the page on every scan, which the language server runs per
keystroke, and most of the scan's time went to the copy. Unicode
lowercasing can also lengthen a string ("İ" becomes two characters), so
every offset after one pointed past the real text: a block after "İ" came
back with "</" on its end.

Tag names are now compared in place, in ASCII case, as an HTML parser
compares them.

Also adds a temporary probe that prints growth readings on CI for the
linear-time case that keeps failing there; it is removed before merge.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 lsp/src/typescript-blocks.test.ts       | 19 +++++++++++
 lsp/src/typescript-blocks.ts            | 43 +++++++++++++++++--------
 lsp/src/zz-ci-probe.linear-time.test.ts | 32 ++++++++++++++++++
 3 files changed, 80 insertions(+), 14 deletions(-)
 create mode 100644 lsp/src/zz-ci-probe.linear-time.test.ts

diff --git a/lsp/src/typescript-blocks.test.ts b/lsp/src/typescript-blocks.test.ts
index 63698670..2b577f51 100644
--- a/lsp/src/typescript-blocks.test.ts
+++ b/lsp/src/typescript-blocks.test.ts
@@ -169,6 +169,25 @@ describe("extractTypeScriptBlocks", () => {
     ).toEqual([]);
   });
 
+  it("matches tag names in any ASCII case, as an HTML parser does", () => {
+    const html =
+      '<SCRIPT type="text/typescript">let a = 1;</Script ><TEXTAREA><script type="text/typescript">let b;</script></TextArea><sCrIpT type="text/typescript">let c = 1;</SCRIPT>';
+    expect(extractTypeScriptBlocks(html).map((block) => block.content)).toEqual(
+      ["let a = 1;", "let c = 1;"],
+    );
+  });
+
+  it("places a block after text whose lowercase is longer, such as a dotted capital I", () => {
+    // "İ".toLowerCase() is two characters: offsets taken from a lowercased copy of the page land past the block.
+    const before = "<p>İstanbul İzmir</p>\n";
+    const html = `${before}<script type="text/typescript">const city: string = "x";</script>`;
+    const [block] = extractTypeScriptBlocks(html);
+    expect(block.content).toBe('const city: string = "x";');
+    expect(html.slice(block.contentStart, block.contentStart + block.content.length)).toBe(block.content);
+    const [script] = extractPageScopeScripts(html.replace("text/typescript", "text/javascript"));
+    expect(script.content).toBe('const city: string = "x";');
+  });
+
   it("skips the scan when the file never mentions text/typescript", () => {
     expect(mayHaveTypeScriptBlocks("<script>let a;</script>")).toBe(false);
     expect(mayHaveTypeScriptBlocks('<script type="Text/TypeScript">')).toBe(
diff --git a/lsp/src/typescript-blocks.ts b/lsp/src/typescript-blocks.ts
index b656d839..fe14aa23 100644
--- a/lsp/src/typescript-blocks.ts
+++ b/lsp/src/typescript-blocks.ts
@@ -78,13 +78,25 @@ function findOpenTagEnd(html: string, from: number): number {
   return -1;
 }
 
-/** The index of `</name` (followed by a tag-name end) at or after `from`, or -1. */
-function findCloseTag(lower: string, from: number, name: string): number {
-  const needle = `</${name}`;
-  for (let at = lower.indexOf(needle, from); at >= 0;) {
-    if (isTagNameEnd(lower[at + needle.length])) return at;
-    at = lower.indexOf(needle, at + 1);
-  }
+/**
+ * Whether `html` holds `name` (lowercase ASCII letters) at `at`, in any ASCII case, as an HTML parser compares tag
+ * names. Setting bit 0x20 lowercases an ASCII letter and leaves every other code unequal to a lowercase letter.
+ */
+function hasTagNameAt(html: string, at: number, name: string): boolean {
+  if (at + name.length > html.length) return false;
+  for (let k = 0; k < name.length; k++)
+    if ((html.charCodeAt(at + k) | 0x20) !== name.charCodeAt(k)) return false;
+  return true;
+}
+
+/** The index of `</name` (any ASCII case, followed by a tag-name end) at or after `from`, or -1. */
+function findCloseTag(html: string, from: number, name: string): number {
+  for (let at = html.indexOf("</", from); at >= 0; at = html.indexOf("</", at + 2))
+    if (
+      hasTagNameAt(html, at + 2, name) &&
+      isTagNameEnd(html[at + 2 + name.length])
+    )
+      return at;
   return -1;
 }
 
@@ -105,16 +117,19 @@ interface ScriptElement {
 /**
  * Every `<script>` element of an HTML file, in source order. A script inside an HTML comment or another raw-text
  * element, and one whose tag or element never closes, is not one.
+ *
+ * Tag names are compared in place, in ASCII case only. Lowercasing the page instead copied all of it on every scan
+ * (the language server scans on each keystroke), and Unicode lowercasing can change a string's length ("İ" becomes
+ * two characters), which moved every offset after it.
  */
 function scanScripts(html: string): ScriptElement[] {
   const scripts: ScriptElement[] = [];
-  const lower = html.toLowerCase();
   let i = 0;
   while (i < html.length) {
-    const lt = lower.indexOf("<", i);
+    const lt = html.indexOf("<", i);
     if (lt < 0) break;
-    if (lower.startsWith("<!--", lt)) {
-      const end = lower.indexOf("-->", lt + 4);
+    if (html.startsWith("<!--", lt)) {
+      const end = html.indexOf("-->", lt + 4);
       // An unclosed comment runs to the end of the file, as in a browser.
       if (end < 0) break;
       i = end + 3;
@@ -122,8 +137,8 @@ function scanScripts(html: string): ScriptElement[] {
     }
     const name = RAW_TEXT_ELEMENTS.find(
       (candidate) =>
-        lower.startsWith(candidate, lt + 1) &&
-        isTagNameEnd(lower[lt + 1 + candidate.length]),
+        hasTagNameAt(html, lt + 1, candidate) &&
+        isTagNameEnd(html[lt + 1 + candidate.length]),
     );
     if (!name) {
       i = lt + 1;
@@ -132,7 +147,7 @@ function scanScripts(html: string): ScriptElement[] {
     const tagEnd = findOpenTagEnd(html, lt + 1 + name.length);
     if (tagEnd < 0) break;
     const contentStart = tagEnd + 1;
-    const close = findCloseTag(lower, contentStart, name);
+    const close = findCloseTag(html, contentStart, name);
     // An element that never closes swallows the rest of the file; nothing after it is a tag.
     if (close < 0) break;
     if (name === "script") {
diff --git a/lsp/src/zz-ci-probe.linear-time.test.ts b/lsp/src/zz-ci-probe.linear-time.test.ts
new file mode 100644
index 00000000..bfe1939a
--- /dev/null
+++ b/lsp/src/zz-ci-probe.linear-time.test.ts
@@ -0,0 +1,32 @@
+/** TEMPORARY: prints growth readings on CI for the flaky "quote that never ends" scan. Removed before merge. */
+import { it } from "vitest";
+import { extractPageScopeScripts } from "./typescript-blocks.js";
+import { LINEAR_TIME_TIMEOUT_MS, growthOf } from "./linear-time.test.util.js";
+
+const page = (n: number) => `text/javascript <script type="${"a".repeat(n)}`;
+const work: Record<string, (html: string) => unknown> = {
+  "new scan": extractPageScopeScripts,
+  "page-sized toLowerCase (what the old scan paid)": (html) => html.toLowerCase(),
+  "native indexOf pass": (html) => html.indexOf("\u0001"),
+};
+it(
+  "CI probe",
+  () => {
+    const lines: string[] = [];
+    for (const smallChars of [256_000, 1_000_000, 4_000_000]) {
+      const small = page(smallChars);
+      const large = page(4 * smallChars);
+      for (const [label, run] of Object.entries(work)) {
+        const readings = Array.from({ length: 5 }, () =>
+          growthOf(
+            () => run(small),
+            () => run(large),
+          ).toFixed(1),
+        );
+        lines.push(`PROBE ${smallChars / 1000}k vs ${(4 * smallChars) / 1000}k | ${label}: ${readings.join(" ")}`);
+      }
+    }
+    process.stderr.write(`${lines.join("\n")}\n`);
+  },
+  LINEAR_TIME_TIMEOUT_MS * 4,
+);

From a397ec73c0f301ff826d0efc0de734f87579807d Mon Sep 17 00:00:00 2001
From: collin-thomas <collin.inbox@gmail.com>
Date: Thu, 12 Nov 2026 08:18:53 -0700
Subject: [PATCH 2/4] Format the scanner change from the repo root

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 lsp/src/typescript-blocks.test.ts       | 8 ++++++--
 lsp/src/typescript-blocks.ts            | 6 +++++-
 lsp/src/zz-ci-probe.linear-time.test.ts | 7 +++++--
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/lsp/src/typescript-blocks.test.ts b/lsp/src/typescript-blocks.test.ts
index 2b577f51..29901206 100644
--- a/lsp/src/typescript-blocks.test.ts
+++ b/lsp/src/typescript-blocks.test.ts
@@ -183,8 +183,12 @@ describe("extractTypeScriptBlocks", () => {
     const html = `${before}<script type="text/typescript">const city: string = "x";</script>`;
     const [block] = extractTypeScriptBlocks(html);
     expect(block.content).toBe('const city: string = "x";');
-    expect(html.slice(block.contentStart, block.contentStart + block.content.length)).toBe(block.content);
-    const [script] = extractPageScopeScripts(html.replace("text/typescript", "text/javascript"));
+    expect(
+      html.slice(block.contentStart, block.contentStart + block.content.length),
+    ).toBe(block.content);
+    const [script] = extractPageScopeScripts(
+      html.replace("text/typescript", "text/javascript"),
+    );
     expect(script.content).toBe('const city: string = "x";');
   });
 
diff --git a/lsp/src/typescript-blocks.ts b/lsp/src/typescript-blocks.ts
index fe14aa23..b236f3cc 100644
--- a/lsp/src/typescript-blocks.ts
+++ b/lsp/src/typescript-blocks.ts
@@ -91,7 +91,11 @@ function hasTagNameAt(html: string, at: number, name: string): boolean {
 
 /** The index of `</name` (any ASCII case, followed by a tag-name end) at or after `from`, or -1. */
 function findCloseTag(html: string, from: number, name: string): number {
-  for (let at = html.indexOf("</", from); at >= 0; at = html.indexOf("</", at + 2))
+  for (
+    let at = html.indexOf("</", from);
+    at >= 0;
+    at = html.indexOf("</", at + 2)
+  )
     if (
       hasTagNameAt(html, at + 2, name) &&
       isTagNameEnd(html[at + 2 + name.length])
diff --git a/lsp/src/zz-ci-probe.linear-time.test.ts b/lsp/src/zz-ci-probe.linear-time.test.ts
index bfe1939a..56983a34 100644
--- a/lsp/src/zz-ci-probe.linear-time.test.ts
+++ b/lsp/src/zz-ci-probe.linear-time.test.ts
@@ -6,7 +6,8 @@ import { LINEAR_TIME_TIMEOUT_MS, growthOf } from "./linear-time.test.util.js";
 const page = (n: number) => `text/javascript <script type="${"a".repeat(n)}`;
 const work: Record<string, (html: string) => unknown> = {
   "new scan": extractPageScopeScripts,
-  "page-sized toLowerCase (what the old scan paid)": (html) => html.toLowerCase(),
+  "page-sized toLowerCase (what the old scan paid)": (html) =>
+    html.toLowerCase(),
   "native indexOf pass": (html) => html.indexOf("\u0001"),
 };
 it(
@@ -23,7 +24,9 @@ it(
             () => run(large),
           ).toFixed(1),
         );
-        lines.push(`PROBE ${smallChars / 1000}k vs ${(4 * smallChars) / 1000}k | ${label}: ${readings.join(" ")}`);
+        lines.push(
+          `PROBE ${smallChars / 1000}k vs ${(4 * smallChars) / 1000}k | ${label}: ${readings.join(" ")}`,
+        );
       }
     }
     process.stderr.write(`${lines.join("\n")}\n`);

From 25907773ae4650a022394cb1f17d4288336fdcdc Mon Sep 17 00:00:00 2001
From: collin-thomas <collin.inbox@gmail.com>
Date: Thu, 12 Nov 2026 08:28:52 -0700
Subject: [PATCH 3/4] Measure the memory-bound scan check against reading its
 texts

The "quote that never ends" check times one native search over 4 MB and
16 MB of text, so its growth is the CPU's cost of reading memory, which
changes where an input stops fitting a cache. Where that is depends on the
runner: a plain search read 5.2 to 5.6 at 1 MB against 4 MB on one CI
runner, and this check read 12.2 to 16.6 at 4 MB against 16 MB on others,
for linear work.

It is now taken over the growth of a native search over the same two
texts, which pays the same cost of reading them. A linear scan reads about
1 and a scan that rescans the text reads about 3.3 here; the bar is 2.

The probe now also prints these ratios, with a quadratic control.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../typescript-service.linear-time.test.ts    | 50 ++++++++++++++-----
 lsp/src/zz-ci-probe.linear-time.test.ts       | 27 +++++++---
 2 files changed, 58 insertions(+), 19 deletions(-)

diff --git a/lsp/src/typescript-service.linear-time.test.ts b/lsp/src/typescript-service.linear-time.test.ts
index 2ede2541..16a01c94 100644
--- a/lsp/src/typescript-service.linear-time.test.ts
+++ b/lsp/src/typescript-service.linear-time.test.ts
@@ -22,14 +22,26 @@ afterAll(() => fixture.remove());
 // cross it for some fixtures: 8,000/32,000 unclosed-comment units are 56 KB/224 KB.
 const SMALL_SCAN_CHARACTERS = 256_000;
 // A fixture that is one long run of text is scanned by a native search at memory speed, so its cost per character
-// is the cost of a cache miss. At 256 KB against 1 MB the small input fits a CI runner's per-core cache and the
-// large one does not, and linear work measured a growth of 12.6 there. At 4 MB against 16 MB both are past it.
+// is the CPU's cost of reading memory, which changes where an input stops fitting a cache. Where that is depends on
+// the runner: the same linear search read 3.0 at 256 KB against 1 MB, 5.2 to 5.6 at 1 MB against 4 MB and 4.4 at 4 MB
+// against 16 MB on one CI runner, and checks of it at 4 MB against 16 MB read 12.2 to 16.6 on others. So such a
+// check is measured against a native search over the same two texts (`MEMORY_BOUND_REFERENCE`), which pays the same
+// cost of reading them: a linear scan grows about as much as it does (1), and work that rescans the text for each
+// character about four times as much. Both texts stay past the large-object boundary, and large enough that each run
+// is a few milliseconds of reading.
 const MEMORY_BOUND_SCAN_CHARACTERS = 4_000_000;
+/** One native pass over all of `text`: U+0001 never occurs in the fixtures. */
+const MEMORY_BOUND_REFERENCE = (text: string) => text.indexOf("\u0001");
+/** How much more a memory-bound scan grows than reading its texts does. Linear reads about 1, quadratic about 4. */
+const MAX_GROWTH_OVER_READING = 2;
 const scanGrowth = (
   html: (count: number) => string,
   scan: (text: string) => unknown,
-  smallCharacters = SMALL_SCAN_CHARACTERS,
+  memoryBound = false,
 ): number => {
+  const smallCharacters = memoryBound
+    ? MEMORY_BOUND_SCAN_CHARACTERS
+    : SMALL_SCAN_CHARACTERS;
   const prefixLength = html(0).length;
   const unitLength = html(1).length - prefixLength;
   expect(unitLength).toBeGreaterThan(0);
@@ -38,12 +50,25 @@ const scanGrowth = (
   const large = html(4 * smallCount);
   expect(small.length).toBeGreaterThanOrEqual(smallCharacters);
   expect(large.length - prefixLength).toBe(4 * (small.length - prefixLength));
-  return growthOf(
+  if (memoryBound) expect(large.includes("\u0001")).toBe(false);
+  const growth = growthOf(
     () => scan(small),
     () => scan(large),
   );
+  if (!memoryBound) return growth;
+  return (
+    growth /
+    growthOf(
+      () => MEMORY_BOUND_REFERENCE(small),
+      () => MEMORY_BOUND_REFERENCE(large),
+    )
+  );
 };
 
+/** The bar a scan's growth must stay under: over reading its texts for a memory-bound one, 8 otherwise. */
+const maxScanGrowth = (memoryBound = false) =>
+  memoryBound ? MAX_GROWTH_OVER_READING : 8;
+
 /** A page of `count` client blocks, each with a little typed code. */
 const pageOf = (count: number, edited: string) =>
   Array.from(
@@ -86,7 +111,8 @@ describe("TypeScript block diagnostics: linear time", () => {
     LINEAR_TIME_TIMEOUT_MS,
   );
 
-  const scans: Array<[string, (n: number) => string, number?]> = [
+  // The third entry marks a memory-bound fixture (see MEMORY_BOUND_SCAN_CHARACTERS).
+  const scans: Array<[string, (n: number) => string, boolean?]> = [
     [
       "script tags that never close",
       (n) => `text/typescript ${'<script type="text/typescript">'.repeat(n)}`,
@@ -98,7 +124,7 @@ describe("TypeScript block diagnostics: linear time", () => {
     [
       "a quote that never ends",
       (n) => `text/typescript <script type="${"a".repeat(n)}`,
-      MEMORY_BOUND_SCAN_CHARACTERS,
+      true,
     ],
     [
       "many comments",
@@ -121,24 +147,24 @@ describe("TypeScript block diagnostics: linear time", () => {
 
   it.each(scans)(
     "finds blocks in linear time with %s",
-    (_label, html, smallCharacters) => {
+    (_label, html, memoryBound) => {
       expect(
-        scanGrowth(html, extractTypeScriptBlocks, smallCharacters),
-      ).toBeLessThan(8);
+        scanGrowth(html, extractTypeScriptBlocks, memoryBound),
+      ).toBeLessThan(maxScanGrowth(memoryBound));
     },
     LINEAR_TIME_TIMEOUT_MS,
   );
 
   it.each(scans)(
     "finds the page's classic scripts in linear time with %s",
-    (_label, html, smallCharacters) => {
+    (_label, html, memoryBound) => {
       expect(
         scanGrowth(
           (n) => html(n).replaceAll("text/typescript", "text/javascript"),
           extractPageScopeScripts,
-          smallCharacters,
+          memoryBound,
         ),
-      ).toBeLessThan(8);
+      ).toBeLessThan(maxScanGrowth(memoryBound));
     },
     LINEAR_TIME_TIMEOUT_MS,
   );
diff --git a/lsp/src/zz-ci-probe.linear-time.test.ts b/lsp/src/zz-ci-probe.linear-time.test.ts
index 56983a34..dc166807 100644
--- a/lsp/src/zz-ci-probe.linear-time.test.ts
+++ b/lsp/src/zz-ci-probe.linear-time.test.ts
@@ -4,28 +4,41 @@ import { extractPageScopeScripts } from "./typescript-blocks.js";
 import { LINEAR_TIME_TIMEOUT_MS, growthOf } from "./linear-time.test.util.js";
 
 const page = (n: number) => `text/javascript <script type="${"a".repeat(n)}`;
+const reference = (html: string) => html.indexOf("\u0001");
+// Quadratic control: a full rescan from each 1M-character offset, so 4x the text is about 16x the reading.
+const quadratic = (html: string) => {
+  let found = 0;
+  for (let at = 0; at < html.length; at += 1_000_000)
+    found += html.indexOf("\u0001", at);
+  return found;
+};
 const work: Record<string, (html: string) => unknown> = {
   "new scan": extractPageScopeScripts,
   "page-sized toLowerCase (what the old scan paid)": (html) =>
     html.toLowerCase(),
-  "native indexOf pass": (html) => html.indexOf("\u0001"),
+  "quadratic control": quadratic,
 };
 it(
   "CI probe",
   () => {
     const lines: string[] = [];
-    for (const smallChars of [256_000, 1_000_000, 4_000_000]) {
+    for (const smallChars of [1_000_000, 4_000_000]) {
       const small = page(smallChars);
       const large = page(4 * smallChars);
       for (const [label, run] of Object.entries(work)) {
-        const readings = Array.from({ length: 5 }, () =>
-          growthOf(
+        const readings = Array.from({ length: 5 }, () => {
+          const growth = growthOf(
             () => run(small),
             () => run(large),
-          ).toFixed(1),
-        );
+          );
+          const base = growthOf(
+            () => reference(small),
+            () => reference(large),
+          );
+          return `${growth.toFixed(1)}/${base.toFixed(1)}=${(growth / base).toFixed(2)}`;
+        });
         lines.push(
-          `PROBE ${smallChars / 1000}k vs ${(4 * smallChars) / 1000}k | ${label}: ${readings.join(" ")}`,
+          `PROBE ${smallChars / 1000}k vs ${(4 * smallChars) / 1000}k | ${label}: ${readings.join("  ")}`,
         );
       }
     }

From 72ffcc234f0bf79ba00ccfcaa003fbdb34f2d806 Mon Sep 17 00:00:00 2001
From: collin-thomas <collin.inbox@gmail.com>
Date: Thu, 12 Nov 2026 08:51:56 -0700
Subject: [PATCH 4/4] Remove the temporary CI probe

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 lsp/src/zz-ci-probe.linear-time.test.ts | 48 -------------------------
 1 file changed, 48 deletions(-)
 delete mode 100644 lsp/src/zz-ci-probe.linear-time.test.ts

diff --git a/lsp/src/zz-ci-probe.linear-time.test.ts b/lsp/src/zz-ci-probe.linear-time.test.ts
deleted file mode 100644
index dc166807..00000000
--- a/lsp/src/zz-ci-probe.linear-time.test.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-/** TEMPORARY: prints growth readings on CI for the flaky "quote that never ends" scan. Removed before merge. */
-import { it } from "vitest";
-import { extractPageScopeScripts } from "./typescript-blocks.js";
-import { LINEAR_TIME_TIMEOUT_MS, growthOf } from "./linear-time.test.util.js";
-
-const page = (n: number) => `text/javascript <script type="${"a".repeat(n)}`;
-const reference = (html: string) => html.indexOf("\u0001");
-// Quadratic control: a full rescan from each 1M-character offset, so 4x the text is about 16x the reading.
-const quadratic = (html: string) => {
-  let found = 0;
-  for (let at = 0; at < html.length; at += 1_000_000)
-    found += html.indexOf("\u0001", at);
-  return found;
-};
-const work: Record<string, (html: string) => unknown> = {
-  "new scan": extractPageScopeScripts,
-  "page-sized toLowerCase (what the old scan paid)": (html) =>
-    html.toLowerCase(),
-  "quadratic control": quadratic,
-};
-it(
-  "CI probe",
-  () => {
-    const lines: string[] = [];
-    for (const smallChars of [1_000_000, 4_000_000]) {
-      const small = page(smallChars);
-      const large = page(4 * smallChars);
-      for (const [label, run] of Object.entries(work)) {
-        const readings = Array.from({ length: 5 }, () => {
-          const growth = growthOf(
-            () => run(small),
-            () => run(large),
-          );
-          const base = growthOf(
-            () => reference(small),
-            () => reference(large),
-          );
-          return `${growth.toFixed(1)}/${base.toFixed(1)}=${(growth / base).toFixed(2)}`;
-        });
-        lines.push(
-          `PROBE ${smallChars / 1000}k vs ${(4 * smallChars) / 1000}k | ${label}: ${readings.join("  ")}`,
-        );
-      }
-    }
-    process.stderr.write(`${lines.join("\n")}\n`);
-  },
-  LINEAR_TIME_TIMEOUT_MS * 4,
-);