Speed up bang redirects on the hot path.

Minify the service worker, reuse the inlined hot map without cloning when possible, and resolve common queries synchronously so SPA/Edge/SW spend less time before the 302.

Author: danielsebesta

api/go.ts

@@ -4,42 +4,19 @@
  */
 
 import { inflateBangs } from "../shared/bang-compact";
-import { HOT_BANGS } from "../shared/bangs-hot.generated";
-import { searxSearchTemplate } from "../shared/searx";
+import { cookieValue } from "../shared/cookie";
+import { INLINE_HOT_MAP, withPrefsOverlays } from "../shared/hot-redirect";
 import { normalizeBangPrefix } from "../shared/share-prefs";
-import {
-  buildBangMap,
-  ensureEssentialBangs,
-  resolveBangRedirectUrl,
-  type Bang,
-} from "../src/redirect";
+import { resolveBangRedirectUrl, type Bang } from "../src/redirect";
 
 export const config = {
   runtime: "edge",
 };
 
-const HOT_MAP = ensureEssentialBangs(
-  buildBangMap(inflateBangs([...HOT_BANGS])),
-);
-
-function cookieValue(
-  header: string | null,
-  name: string,
-): string | null {
-  if (!header) return null;
-  const match = header.match(new RegExp(`(?:^|; )${name}=([^;]*)`));
-  if (!match?.[1]) return null;
-  try {
-    return decodeURIComponent(match[1]);
-  } catch {
-    return match[1];
-  }
-}
-
 function parseCustomBangs(raw: string | null): Bang[] {
   if (!raw) return [];
   try {
-    const data = JSON.parse(raw) as unknown;
+    const data: unknown = JSON.parse(raw);
     if (!Array.isArray(data)) return [];
     return inflateBangs(
       data.slice(0, 40).map((item) => {
@@ -86,18 +63,10 @@ export default async function handler(request: Request): Promise<Response> {
   const searxHost = cookieValue(cookie, "searx-instance") ?? "";
   const custom = parseCustomBangs(cookieValue(cookie, "custom-bangs"));
 
-  const map = ensureEssentialBangs(new Map(HOT_MAP));
-  for (const bang of custom) map.set(bang.t, bang);
-  if (searxHost) {
-    for (const t of ["searx", "searxng"]) {
-      map.set(t, {
-        t,
-        d: searxHost,
-        u: searxSearchTemplate(searxHost),
-        s: "SearxNG",
-      });
-    }
-  }
+  const map = withPrefsOverlays(INLINE_HOT_MAP, {
+    customBangs: custom,
+    customSearxUrl: searxHost,
+  });
 
   const target = resolveBangRedirectUrl(q, map, defaultBang, { bangPrefix });
   if (!target) return serveSpa(request);

shared/cookie.ts

@@ -0,0 +1,30 @@
+/**
+ * Fast cookie helpers — avoid allocating a RegExp per lookup on the redirect hot path.
+ */
+
+export function cookieValue(
+  header: string | null | undefined,
+  name: string,
+): string | null {
+  if (!header) return null;
+  const needle = `${name}=`;
+  let start = 0;
+  while (start < header.length) {
+    const at = header.indexOf(needle, start);
+    if (at === -1) return null;
+    if (at !== 0 && header.charCodeAt(at - 1) !== 32 /* space */ && header.charCodeAt(at - 1) !== 59 /* ; */) {
+      start = at + 1;
+      continue;
+    }
+    const valueStart = at + needle.length;
+    const valueEnd = header.indexOf(";", valueStart);
+    const raw =
+      valueEnd === -1 ? header.slice(valueStart) : header.slice(valueStart, valueEnd);
+    try {
+      return decodeURIComponent(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return null;
+}

shared/hot-redirect.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { cookieValue } from "./cookie";
+import {
+  canResolveWithMap,
+  INLINE_HOT_MAP,
+  withPrefsOverlays,
+} from "./hot-redirect";
+
+describe("cookieValue", () => {
+  it("reads first and middle cookies", () => {
+    expect(cookieValue("default-bang=g", "default-bang")).toBe("g");
+    expect(
+      cookieValue("a=1; default-bang=searx; b=2", "default-bang"),
+    ).toBe("searx");
+  });
+
+  it("decodes URI components", () => {
+    expect(cookieValue("x=%21", "x")).toBe("!");
+  });
+
+  it("avoids substring false positives", () => {
+    expect(cookieValue("xdefault-bang=g", "default-bang")).toBeNull();
+    expect(cookieValue("foo=default-bang=g", "default-bang")).toBeNull();
+  });
+});
+
+describe("withPrefsOverlays", () => {
+  it("returns the same Map when overlays are empty", () => {
+    const base = new Map(INLINE_HOT_MAP);
+    expect(withPrefsOverlays(base, {})).toBe(base);
+    expect(withPrefsOverlays(INLINE_HOT_MAP, { customBangs: [] })).toBe(
+      INLINE_HOT_MAP,
+    );
+  });
+
+  it("clones when custom bangs are present", () => {
+    const custom = [
+      {
+        t: "mycustom",
+        u: "https://example.com/?q={{{s}}}",
+        d: "example.com",
+      },
+    ];
+    const next = withPrefsOverlays(INLINE_HOT_MAP, { customBangs: custom });
+    expect(next).not.toBe(INLINE_HOT_MAP);
+    expect(next.get("mycustom")?.d).toBe("example.com");
+    expect(INLINE_HOT_MAP.has("mycustom")).toBe(false);
+  });
+});
+
+describe("canResolveWithMap", () => {
+  it("allows default searches and hot bangs", () => {
+    expect(canResolveWithMap("kočky", INLINE_HOT_MAP)).toBe(true);
+    expect(canResolveWithMap("!g cats", INLINE_HOT_MAP)).toBe(true);
+    expect(canResolveWithMap("cats !g", INLINE_HOT_MAP)).toBe(true);
+  });
+
+  it("rejects rare bangs missing from hot", () => {
+    expect(canResolveWithMap("!zzznomatchxyz hello", INLINE_HOT_MAP)).toBe(
+      false,
+    );
+  });
+});

shared/hot-redirect.ts

@@ -0,0 +1,75 @@
+/**
+ * Shared redirect hot path: inlined top bangs + zero-copy overlays when possible.
+ */
+import { inflateBangs } from "./bang-compact";
+import { HOT_BANGS } from "./bangs-hot.generated";
+import { searxSearchTemplate } from "./searx";
+import {
+  buildBangMap,
+  ensureEssentialBangs,
+  extractBangTrigger,
+  longestTriggerPrefix,
+  type Bang,
+} from "../src/redirect";
+
+/** Built once at module load — never mutate. */
+export const INLINE_HOT_MAP: ReadonlyMap<string, Bang> = ensureEssentialBangs(
+  buildBangMap(inflateBangs([...HOT_BANGS])),
+);
+
+export type HotOverlayPrefs = {
+  customBangs?: readonly Bang[];
+  customSearxUrl?: string;
+};
+
+/**
+ * Apply custom bangs / Searx host on top of a base map.
+ * Returns the same Map instance when overlays are empty (zero clone).
+ */
+export function withPrefsOverlays(
+  base: ReadonlyMap<string, Bang>,
+  prefs: HotOverlayPrefs,
+): Map<string, Bang> {
+  const customs = prefs.customBangs;
+  const host = prefs.customSearxUrl?.trim() ?? "";
+  const hasCustoms = Boolean(customs && customs.length > 0);
+
+  let needsSearx = false;
+  if (host) {
+    const template = searxSearchTemplate(host);
+    const cur = base.get("searxng") ?? base.get("searx");
+    needsSearx = !cur || cur.u !== template;
+  }
+
+  if (!hasCustoms && !needsSearx) {
+    return base instanceof Map ? base : new Map(base);
+  }
+
+  const map = ensureEssentialBangs(new Map(base));
+  if (customs) {
+    for (const bang of customs) map.set(bang.t, bang);
+  }
+  if (needsSearx && host) {
+    const u = searxSearchTemplate(host);
+    for (const t of ["searx", "searxng"] as const) {
+      map.set(t, { t, d: host, u, s: "SearxNG" });
+    }
+  }
+  return map;
+}
+
+/**
+ * True when `query` can be resolved correctly from `map` alone
+ * (no need to await the full catalog for a rare bang).
+ */
+export function canResolveWithMap(
+  query: string,
+  map: ReadonlyMap<string, Bang>,
+  bangPrefix = "!",
+): boolean {
+  const hint = extractBangTrigger(query, bangPrefix);
+  if (!hint) return true;
+  if (map.has(hint)) return true;
+  if (longestTriggerPrefix(hint, map as Map<string, Bang>)) return true;
+  return false;
+}

src/main.ts

@@ -19,6 +19,11 @@ import {
   saveCustomBangs,
   validateBangInput,
 } from "./custom-bangs";
+import {
+  canResolveWithMap,
+  withPrefsOverlays,
+  INLINE_HOT_MAP,
+} from "../shared/hot-redirect";
 import {
   type Bang,
   ensureEssentialBangs,
@@ -1269,6 +1274,26 @@ function renderLanding(
   }
 }
 
+/** Sync redirect from inlined hot map — no catalog await (SPA fallback). */
+function trySyncHotRedirect(query: string): string | null {
+  const bangPrefix = getBangPrefix();
+  const map = withPrefsOverlays(INLINE_HOT_MAP, {
+    customBangs: loadCustomBangs(),
+    customSearxUrl: getSearxInstanceHost(),
+  });
+  if (!canResolveWithMap(query, map, bangPrefix)) return null;
+  const url = resolveBangRedirectUrl(
+    query,
+    map,
+    getDefaultBangTrigger(),
+    resolveOptions(),
+  );
+  if (!url) return null;
+  // Own a copy — never expose the shared INLINE_HOT_MAP to later SPA mutations.
+  bangMap = map === INLINE_HOT_MAP ? new Map(map) : map;
+  return url;
+}
+
 async function boot() {
   const app = document.querySelector<HTMLDivElement>("#app")!;
   const query =
@@ -1279,6 +1304,18 @@ async function boot() {
     clearShareHash();
   }
 
+  // Fast path: common bangs / default search without waiting on IDB/network.
+  if (query) {
+    const syncUrl = trySyncHotRedirect(query);
+    if (syncUrl) {
+      void syncPrefsToIdb();
+      pushHistory(query);
+      void recordBangUsage(usageTriggerForQuery(query));
+      window.location.replace(syncUrl);
+      return;
+    }
+  }
+
   let baseMap: Map<string, Bang>;
   try {
     if (!query) {

src/redirect.ts

@@ -90,7 +90,7 @@ function bangDomain(bang: Bang): string {
 /** Longest trigger in `bangMap` that is a prefix of `token` (case-insensitive). */
 export function longestTriggerPrefix(
   token: string,
-  bangMap: Map<string, Bang>,
+  bangMap: ReadonlyMap<string, Bang>,
 ): string | null {
   const lower = token.toLowerCase();
   let best: string | null = null;