diff --git a/.changeset/ultracite-8-formatting.md b/.changeset/ultracite-8-formatting.md
new file mode 100644
index 0000000..2ce4c2d
--- /dev/null
+++ b/.changeset/ultracite-8-formatting.md
@@ -0,0 +1,4 @@
+---
+---
+
+Formatting only: apply the blank-line spacing that ultracite 8 enforces and write the Redis field pattern with `\w`. No change in behaviour, so no release.
diff --git a/apps/web/app/changelog/rss.xml/route.ts b/apps/web/app/changelog/rss.xml/route.ts
index 240f3e6..0fc6400 100644
--- a/apps/web/app/changelog/rss.xml/route.ts
+++ b/apps/web/app/changelog/rss.xml/route.ts
@@ -12,6 +12,7 @@ const escapeXml = (value: string): string =>
 
 const handler = () => {
   const entries = getChangelogEntries();
+
   const items = entries
     .map(
       (entry) => `    <item>
@@ -23,6 +24,7 @@ const handler = () => {
     </item>`
     )
     .join("\n");
+
   const lastBuildDate = entries[0]?.data.date.toUTCString() ?? "";
 
   const feed = `<?xml version="1.0" encoding="UTF-8"?>
diff --git a/apps/web/app/layout.tsx b/apps/web/app/layout.tsx
index a08b6a2..f104fb2 100644
--- a/apps/web/app/layout.tsx
+++ b/apps/web/app/layout.tsx
@@ -8,6 +8,7 @@ import { fonts } from "@/lib/fonts";
 import { url } from "@/lib/url";
 
 const siteName = "VecStore SDK";
+
 const siteDescription =
   "A unified vector store SDK for TypeScript. One filter language across Qdrant, pgvector, Pinecone, Supabase, Upstash Vector, Cloudflare Vectorize, and Redis, so you can switch providers without rewriting queries.";
 
diff --git a/apps/web/app/llms.txt/route.ts b/apps/web/app/llms.txt/route.ts
index 9cdf0fc..3e37531 100644
--- a/apps/web/app/llms.txt/route.ts
+++ b/apps/web/app/llms.txt/route.ts
@@ -5,6 +5,7 @@ export const revalidate = false;
 
 const handler = async () => {
   const pages = await Promise.all(source.getPages().map(getLLMText));
+
   return new Response(pages.join("\n\n"), {
     headers: { "Content-Type": "text/plain" },
   });
diff --git a/apps/web/app/og/docs/[...slug]/route.ts b/apps/web/app/og/docs/[...slug]/route.ts
index a97ece4..55bfc61 100644
--- a/apps/web/app/og/docs/[...slug]/route.ts
+++ b/apps/web/app/og/docs/[...slug]/route.ts
@@ -13,10 +13,12 @@ const backgrounds = path.join(process.cwd(), "app", "og", "docs", "[...slug]");
 
 const readBackground = (slugs: readonly string[]) => {
   const [group, name] = slugs;
+
   const provider =
     group === "providers" && providerIds.some((id) => id === name)
       ? name
       : undefined;
+
   const file = provider ? `background-${provider}.png` : "background.png";
 
   return readFile(path.join(backgrounds, file));
diff --git a/apps/web/components/brand-menu.tsx b/apps/web/components/brand-menu.tsx
index 528c3f3..c6530fe 100644
--- a/apps/web/components/brand-menu.tsx
+++ b/apps/web/components/brand-menu.tsx
@@ -15,15 +15,19 @@ const MENU_GAP = 8;
 
 const serialize = (svg: SVGSVGElement): string => {
   const clone = svg.cloneNode(true);
+
   if (!(clone instanceof SVGSVGElement)) {
     return "";
   }
+
   const ink = document.documentElement.classList.contains("dark")
     ? "#ededed"
     : "#171717";
+
   clone.removeAttribute("class");
   clone.removeAttribute("aria-hidden");
   clone.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+
   return new XMLSerializer()
     .serializeToString(clone)
     .replaceAll("currentColor", ink);
@@ -44,7 +48,9 @@ const CopyTile = ({
     if (status === "idle") {
       return;
     }
+
     const timer = window.setTimeout(() => setStatus("idle"), COPIED_MS);
+
     return () => window.clearTimeout(timer);
   }, [status]);
 
@@ -53,9 +59,11 @@ const CopyTile = ({
       className="text-gray-1000 hover:bg-gray-alpha-100 flex min-w-0 flex-col gap-2 rounded-md p-2 text-left text-[14px] transition-colors"
       onClick={async (event) => {
         event.stopPropagation();
+
         if (!svgRef.current) {
           return;
         }
+
         try {
           await navigator.clipboard.writeText(serialize(svgRef.current));
           setStatus("copied");
@@ -98,18 +106,23 @@ export const BrandMenu = ({ children }: { readonly children: ReactNode }) => {
 
   useEffect(() => {
     const anchor = anchorRef.current?.closest("a") ?? anchorRef.current;
+
     if (!anchor) {
       return;
     }
+
     anchor.setAttribute("aria-haspopup", "menu");
     anchor.setAttribute("aria-controls", menuId);
+
     const handle = (event: Event) => {
       event.preventDefault();
       const rect = anchor.getBoundingClientRect();
       setPosition({ left: rect.left, top: rect.bottom + MENU_GAP });
       setOpen(true);
     };
+
     anchor.addEventListener("contextmenu", handle);
+
     return () => anchor.removeEventListener("contextmenu", handle);
   }, [menuId]);
 
@@ -122,11 +135,14 @@ export const BrandMenu = ({ children }: { readonly children: ReactNode }) => {
     if (!open) {
       return;
     }
+
     menuRef.current?.querySelector<HTMLElement>("[role=menuitem]")?.focus();
+
     const close = (event: Event) => {
       if (event instanceof KeyboardEvent && event.key !== "Escape") {
         return;
       }
+
       if (
         event instanceof PointerEvent &&
         event.target instanceof Node &&
@@ -134,11 +150,14 @@ export const BrandMenu = ({ children }: { readonly children: ReactNode }) => {
       ) {
         return;
       }
+
       setOpen(false);
       (anchorRef.current?.closest("a") ?? anchorRef.current)?.focus();
     };
+
     document.addEventListener("keydown", close);
     document.addEventListener("pointerdown", close);
+
     return () => {
       document.removeEventListener("keydown", close);
       document.removeEventListener("pointerdown", close);
@@ -148,34 +167,44 @@ export const BrandMenu = ({ children }: { readonly children: ReactNode }) => {
   const moveFocus = (event: KeyboardEvent<HTMLDivElement>) => {
     if (event.key === "Tab") {
       setOpen(false);
+
       return;
     }
+
     const items = [
       ...(menuRef.current?.querySelectorAll<HTMLElement>("[role=menuitem]") ??
         []),
     ];
+
     const active = document.activeElement;
     const index = active instanceof HTMLElement ? items.indexOf(active) : -1;
+
     const resolveTarget = (): HTMLElement | undefined => {
       switch (event.key) {
         case "ArrowDown": {
           return items.at((index + 1) % items.length);
         }
+
         case "ArrowUp": {
           return items.at((index - 1 + items.length) % items.length);
         }
+
         case "End": {
           return items.at(-1);
         }
+
         case "Home": {
           return items[0];
         }
+
         default: {
           return undefined;
         }
       }
     };
+
     const target = resolveTarget();
+
     if (target) {
       event.preventDefault();
       target.focus();
diff --git a/apps/web/components/docs/sidebar-items.tsx b/apps/web/components/docs/sidebar-items.tsx
index a46869c..dcee151 100644
--- a/apps/web/components/docs/sidebar-items.tsx
+++ b/apps/web/components/docs/sidebar-items.tsx
@@ -24,16 +24,19 @@ const containsPath = (
     if (node.type === "page") {
       return node.url === pathname;
     }
+
     if (node.type === "folder") {
       return (
         node.index?.url === pathname || containsPath(node.children, pathname)
       );
     }
+
     return false;
   });
 
 export const Item = ({ item }: { readonly item: PageTreeItem }) => {
   const pathname = usePathname();
+
   return (
     <SidebarItem
       active={pathname === item.url}
diff --git a/apps/web/components/landing/copy-command.tsx b/apps/web/components/landing/copy-command.tsx
index 108694f..22a7c9e 100644
--- a/apps/web/components/landing/copy-command.tsx
+++ b/apps/web/components/landing/copy-command.tsx
@@ -19,6 +19,7 @@ export const CopyCommand = ({
   const [copied, onCopy] = useCopyButton(() =>
     navigator.clipboard.writeText(command)
   );
+
   const Icon = copied ? CheckIcon : CopyIcon;
 
   return (
diff --git a/apps/web/components/landing/demo.tsx b/apps/web/components/landing/demo.tsx
index 44b5195..55b94e0 100644
--- a/apps/web/components/landing/demo.tsx
+++ b/apps/web/components/landing/demo.tsx
@@ -47,6 +47,7 @@ export const Demo = async () => {
           await renderCode(provider.snippet(example.filterCode)),
         ])
       );
+
       return {
         code: Object.fromEntries(entries),
         expression: example.expression,
@@ -56,6 +57,7 @@ export const Demo = async () => {
       };
     })
   );
+
   const providers = demoProviders.map(({ id, label }) => ({ id, label }));
 
   return <HeroDemo examples={examples} providers={providers} />;
diff --git a/apps/web/components/landing/hero-demo.tsx b/apps/web/components/landing/hero-demo.tsx
index e6c6ca1..fd1628f 100644
--- a/apps/web/components/landing/hero-demo.tsx
+++ b/apps/web/components/landing/hero-demo.tsx
@@ -52,15 +52,19 @@ export const HeroDemo = ({ providers, examples }: HeroDemoProps) => {
   useLayoutEffect(() => {
     const measure = () => {
       const tab = tabRefs.current[exampleIndex];
+
       if (tab) {
         setIndicator({ left: tab.offsetLeft, width: tab.offsetWidth });
       }
     };
+
     measure();
     const observer = new ResizeObserver(measure);
+
     if (listRef.current) {
       observer.observe(listRef.current);
     }
+
     return () => observer.disconnect();
   }, [exampleIndex]);
   const example = examples[exampleIndex] ?? examples[0];
@@ -77,6 +81,7 @@ export const HeroDemo = ({ providers, examples }: HeroDemoProps) => {
 
   const selectProvider = (id: string) => {
     const index = providers.findIndex((item) => item.id === id);
+
     if (index !== -1) {
       setProviderIndex(index);
     }
@@ -103,6 +108,7 @@ export const HeroDemo = ({ providers, examples }: HeroDemoProps) => {
           />
           {examples.map((item, index) => {
             const active = index === exampleIndex;
+
             return (
               <button
                 aria-selected={active}
diff --git a/apps/web/components/landing/store/canvas.tsx b/apps/web/components/landing/store/canvas.tsx
index 798bb1e..98f8880 100644
--- a/apps/web/components/landing/store/canvas.tsx
+++ b/apps/web/components/landing/store/canvas.tsx
@@ -59,6 +59,7 @@ interface StoreCanvasProps {
 
 const originOf = (slot: number) => {
   const cell = slot % CELLS.length;
+
   return [
     ((cell % 3) - 1) * PITCH,
     (1 - Math.floor(cell / 3)) * PITCH,
@@ -68,6 +69,7 @@ const originOf = (slot: number) => {
 
 const depthOf = (slot: number, query: StoreQuery) => {
   const [x, y, z] = originOf(slot);
+
   return modelDepth(x, y, z, query.tiltX, query.tiltY);
 };
 
@@ -90,12 +92,15 @@ const themeOf = (dark: boolean) => ({
 
 const readPalette = (probe: CanvasRenderingContext2D) => {
   const styles = getComputedStyle(document.documentElement);
+
   const parse = (token: string) => {
     probe.fillStyle = styles.getPropertyValue(token).trim() || "#888888";
     probe.fillRect(0, 0, 1, 1);
     const [red, green, blue] = probe.getImageData(0, 0, 1, 1).data;
+
     return [red / 255, green / 255, blue / 255];
   };
+
   return {
     core: parse(CORE_TOKEN),
     dark: document.documentElement.classList.contains("dark"),
@@ -114,45 +119,59 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
 
   useEffect(() => {
     const canvas = canvasRef.current;
+
     const probe = document
       .createElement("canvas")
       .getContext("2d", { willReadFrequently: true });
+
     if (!(canvas && probe && "gpu" in navigator)) {
       return;
     }
+
     let disposed = false;
     let stop: (() => void) | undefined;
     let palette = readPalette(probe);
+
     const observer = new MutationObserver(() => {
       palette = readPalette(probe);
     });
+
     observer.observe(document.documentElement, { attributeFilter: ["class"] });
 
     const run = async () => {
       const gpu = await init();
+
       if (disposed) {
         gpu.dispose();
+
         return;
       }
+
       const view = surface(gpu, canvas, {
         alphaMode: "premultiplied",
         clearColor: [0, 0, 0, 0],
         dpr: [1, 2],
       });
+
       const stage = target(gpu, {
         format: "rgba16float",
         msaa: true,
         size: view.size,
       });
+
       const mesh = cellMesh();
       const instances = new Float32Array(SLOTS * INSTANCE_FLOATS);
+
       const modelLights = Array.from({ length: MAX_LIGHTS }, () => [
         0, 0, 0, 0,
       ]);
+
       const screenLights = Array.from({ length: MAX_LIGHTS }, () => [
         0, 0, 0, 0,
       ]);
+
       const colors = Array.from({ length: MAX_LIGHTS }, () => [0, 0, 0, 0]);
+
       const cellGeometry = geometry(gpu, {
         buffers: [
           {
@@ -175,6 +194,7 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
         ],
         indices: mesh.indices,
       });
+
       const pool = effect(gpu, glowShader, {
         blend: "premultiplied",
         set: {
@@ -187,6 +207,7 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
           },
         },
       });
+
       const cubes = draw(gpu, {
         blend: "premultiplied",
         cull: "back",
@@ -204,6 +225,7 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
         },
         shader: sceneShader,
       });
+
       const composite = effect(gpu, bloomShader, {
         blend: "premultiplied",
         set: {
@@ -230,12 +252,15 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
       const order = [...Array.from({ length: SLOTS }).keys()];
       let frameIndex = 0;
       const stage3d = stageBody(pool, cubes);
+
       const loop = frameLoop(gpu, (frame) => {
         const query = queryRef.current;
         const [width, height] = view.size;
+
         if (stage.size[0] !== width || stage.size[1] !== height) {
           stage.resize([width, height]);
         }
+
         const aspect = width / Math.max(height, 1);
         const matrix = viewProjection(aspect, query.tiltX, query.tiltY);
         const hues = spectrumRef.current ? palette.hues : undefined;
@@ -245,15 +270,19 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
         let count = 0;
         let centreU = 0;
         let centreV = 0;
+
         for (const slot of modelLights) {
           slot.fill(0);
         }
+
         for (const slot of screenLights) {
           slot.fill(0);
         }
+
         for (const slot of colors) {
           slot.fill(0);
         }
+
         for (const [position, slot] of order.entries()) {
           const layer = Math.floor(slot / CELLS.length);
           const cell = slot % CELLS.length;
@@ -270,6 +299,7 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
           instances[base + 5] = green;
           instances[base + 6] = blue;
           instances[base + 7] = lit ? 1 : 0;
+
           if (lit && count < MAX_LIGHTS) {
             const screen = project(matrix, x, y, z);
             screenLights[count][0] = screen.x * 0.5 * aspect;
@@ -288,6 +318,7 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
             count += 1;
           }
         }
+
         cellGeometry.buffers[1].write(instances);
         frameIndex = (frameIndex + 1) % 64;
         const lightU = count > 0 ? centreU / count : 0.5;
@@ -344,6 +375,7 @@ export const StoreCanvas = ({ queryRef, spectrum }: StoreCanvasProps) => {
         stop?.();
       }
     };
+
     start();
 
     return () => {
diff --git a/apps/web/components/landing/store/mesh.ts b/apps/web/components/landing/store/mesh.ts
index cd3855b..53679b9 100644
--- a/apps/web/components/landing/store/mesh.ts
+++ b/apps/web/components/landing/store/mesh.ts
@@ -3,27 +3,32 @@ const RING = CORNER_SEGMENTS * 4;
 const HALF = 0.5;
 const RADIUS = 0.14;
 const DEPTH = 0.055;
+
 const CORNERS = [
   [HALF - RADIUS, HALF - RADIUS],
   [-(HALF - RADIUS), HALF - RADIUS],
   [-(HALF - RADIUS), -(HALF - RADIUS)],
   [HALF - RADIUS, -(HALF - RADIUS)],
 ];
+
 const RADIANS = Math.PI / 180;
 const FOV = 30 * RADIANS;
 const DISTANCE = -10.4;
 
 const ringPoints = () => {
   const points: [number, number, number, number][] = [];
+
   for (const [corner, center] of CORNERS.entries()) {
     for (let step = 0; step < CORNER_SEGMENTS; step += 1) {
       const angle =
         (corner * Math.PI) / 2 + (step / (CORNER_SEGMENTS - 1)) * (Math.PI / 2);
+
       const nx = Math.cos(angle);
       const ny = Math.sin(angle);
       points.push([center[0] + nx * RADIUS, center[1] + ny * RADIUS, nx, ny]);
     }
   }
+
   return points;
 };
 
@@ -31,6 +36,7 @@ export const cellMesh = () => {
   const ring = ringPoints();
   const vertices: number[] = [];
   const indices: number[] = [];
+
   const push = (
     x: number,
     y: number,
@@ -40,18 +46,24 @@ export const cellMesh = () => {
     nz: number
   ) => {
     vertices.push(x, y, z, nx, ny, nz);
+
     return vertices.length / 6 - 1;
   };
 
   const front = push(0, 0, DEPTH, 0, 0, 1);
+
   for (const [x, y] of ring) {
     push(x, y, DEPTH, 0, 0, 1);
   }
+
   const back = push(0, 0, -DEPTH, 0, 0, -1);
+
   for (const [x, y] of ring) {
     push(x, y, -DEPTH, 0, 0, -1);
   }
+
   const side = vertices.length / 6;
+
   for (const [x, y, nx, ny] of ring) {
     push(x, y, DEPTH, nx, ny, 0);
     push(x, y, -DEPTH, nx, ny, 0);
@@ -80,15 +92,19 @@ export const cellMesh = () => {
 
 const multiply = (a: number[], b: number[]) => {
   const out: number[] = Array.from({ length: 16 }, () => 0);
+
   for (let column = 0; column < 4; column += 1) {
     for (let row = 0; row < 4; row += 1) {
       let sum = 0;
+
       for (let k = 0; k < 4; k += 1) {
         sum += a[k * 4 + row] * b[column * 4 + k];
       }
+
       out[column * 4 + row] = sum;
     }
   }
+
   return out;
 };
 
@@ -96,6 +112,7 @@ const perspective = (aspect: number) => {
   const focal = 1 / Math.tan(FOV / 2);
   const near = 0.1;
   const far = 40;
+
   return [
     focal / aspect,
     0,
@@ -138,12 +155,14 @@ const translation = (z: number) => [
 const rotationX = (radians: number) => {
   const c = Math.cos(radians);
   const s = Math.sin(radians);
+
   return [1, 0, 0, 0, 0, c, s, 0, 0, -s, c, 0, 0, 0, 0, 1];
 };
 
 const rotationY = (radians: number) => {
   const c = Math.cos(radians);
   const s = Math.sin(radians);
+
   return [c, 0, -s, 0, 0, 1, 0, 0, s, 0, c, 0, 0, 0, 0, 1];
 };
 
@@ -153,10 +172,12 @@ export const viewProjection = (
   tiltY: number
 ) => {
   const camera = multiply(perspective(aspect), translation(DISTANCE));
+
   const model = multiply(
     rotationX(tiltX * RADIANS),
     rotationY(tiltY * RADIANS)
   );
+
   return multiply(camera, model);
 };
 
@@ -165,6 +186,7 @@ export const project = (matrix: number[], x: number, y: number, z: number) => {
   const clipY = matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13];
   const clipW = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
   const safe = Math.abs(clipW) < 0.0001 ? 0.0001 : clipW;
+
   return { x: clipX / safe, y: clipY / safe };
 };
 
@@ -172,6 +194,7 @@ export const cameraPosition = (tiltX: number, tiltY: number) => {
   const rx = tiltX * RADIANS;
   const ry = tiltY * RADIANS;
   const distance = -DISTANCE;
+
   return [
     -Math.sin(ry) * Math.cos(rx) * distance,
     Math.sin(rx) * distance,
@@ -189,5 +212,6 @@ export const modelDepth = (
   const rx = tiltX * RADIANS;
   const ry = tiltY * RADIANS;
   const rotated = -Math.sin(ry) * x + Math.cos(ry) * z;
+
   return Math.sin(rx) * y + Math.cos(rx) * rotated;
 };
diff --git a/apps/web/components/landing/store/query.ts b/apps/web/components/landing/store/query.ts
index 35c9775..09d6140 100644
--- a/apps/web/components/landing/store/query.ts
+++ b/apps/web/components/landing/store/query.ts
@@ -2,6 +2,7 @@ export const CELLS = [0, 1, 2, 3, 4, 5, 6, 7, 8];
 export const LAYERS = [1, 0, -1];
 export const LAYER_FADE = [1, 0.62, 0.34];
 export const MARK = new Set([0, 4, 8]);
+
 export const SPECTRUM = [
   "--color-pink-700",
   "--color-purple-700",
@@ -42,6 +43,7 @@ export const queryFrom = (
   const queryX = 1 + x * SPREAD;
   const queryY = 1 + y * SPREAD;
   const lit: number[] = [];
+
   for (const [layer] of LAYERS.entries()) {
     for (const cell of CELLS) {
       const distance = Math.hypot(
@@ -49,11 +51,13 @@ export const queryFrom = (
         Math.floor(cell / 3) - queryY,
         layer * DEPTH_COST
       );
+
       if (distance < NEAR) {
         lit.push(layer * CELLS.length + cell);
       }
     }
   }
+
   return { lit, tiltX: REST_X - y * SWING_X, tiltY: REST_Y + x * SWING_Y };
 };
 
diff --git a/apps/web/components/landing/store/stack.tsx b/apps/web/components/landing/store/stack.tsx
index 9ab5015..06c9986 100644
--- a/apps/web/components/landing/store/stack.tsx
+++ b/apps/web/components/landing/store/stack.tsx
@@ -12,6 +12,7 @@ import type { StoreQuery } from "./query";
 const StoreCanvas = dynamic(
   async () => {
     const loaded = await import("./canvas");
+
     return loaded.StoreCanvas;
   },
   { ssr: false }
@@ -33,12 +34,14 @@ export const StoreStack = ({
 
   useEffect(() => {
     const scene = sceneRef.current;
+
     if (
       !scene ||
       window.matchMedia("(prefers-reduced-motion: reduce)").matches
     ) {
       return;
     }
+
     let frame = 0;
 
     const onMove = (event: PointerEvent) => {
@@ -53,6 +56,7 @@ export const StoreStack = ({
     };
 
     window.addEventListener("pointermove", onMove);
+
     return () => {
       cancelAnimationFrame(frame);
       window.removeEventListener("pointermove", onMove);
diff --git a/apps/web/components/provider-icon.tsx b/apps/web/components/provider-icon.tsx
index d3a2a72..8930bd2 100644
--- a/apps/web/components/provider-icon.tsx
+++ b/apps/web/components/provider-icon.tsx
@@ -18,21 +18,27 @@ export const ProviderIcon = ({ id, ...props }: ProviderIconProps) => {
     case "qdrant": {
       return <QdrantIcon {...props} />;
     }
+
     case "pgvector": {
       return <PgvectorIcon {...props} />;
     }
+
     case "supabase": {
       return <SupabaseIcon {...props} />;
     }
+
     case "upstash": {
       return <UpstashIcon {...props} />;
     }
+
     case "vectorize": {
       return <VectorizeIcon {...props} />;
     }
+
     case "redis": {
       return <RedisIcon {...props} />;
     }
+
     default: {
       return <PineconeIcon {...props} />;
     }
diff --git a/apps/web/components/search-dialog.tsx b/apps/web/components/search-dialog.tsx
index a89f835..9786f59 100644
--- a/apps/web/components/search-dialog.tsx
+++ b/apps/web/components/search-dialog.tsx
@@ -63,6 +63,7 @@ export const SiteSearchDialog = (props: SharedProps) => {
   const { search, setSearch, query } = useDocsSearch({
     client: fetchClient({ api: "/api/search" }),
   });
+
   const results = query.data === "empty" ? null : query.data;
 
   return (
diff --git a/apps/web/lib/get-llm-text.ts b/apps/web/lib/get-llm-text.ts
index c1688fb..41235f8 100644
--- a/apps/web/lib/get-llm-text.ts
+++ b/apps/web/lib/get-llm-text.ts
@@ -4,5 +4,6 @@ type Page = (typeof source)["$inferPage"];
 
 export const getLLMText = async (page: Page): Promise<string> => {
   const processed = await page.data.getText("processed");
+
   return `# ${page.data.title} (${page.url})\n\n${processed}`;
 };
diff --git a/bun.lock b/bun.lock
index 0f05df3..fe42c68 100644
--- a/bun.lock
+++ b/bun.lock
@@ -20,7 +20,7 @@
         "publint": "0.3.25",
         "turbo": "^2.11.8",
         "typescript": "^7",
-        "ultracite": "7.11.1",
+        "ultracite": "8.0.1",
       },
     },
     "apps/web": {
@@ -1025,7 +1025,7 @@
 
     "emojilib": ["emojilib@2.4.0", "", {}, "sha512-5U0rVMU5Y2n2+ykNLQqMoqklN9ICBT/KsvC1Gz6vqHbz2AXXGkG+Pm5rMWk/8Vjrr/mY9985Hi8DYzn1F09Nyw=="],
 
-    "empathic": ["empathic@2.0.1", "", {}, "sha512-YGRs8knHhKHVShLkFET/rWAU8kmHbOV5LwN938RHI0pljAJ1Gf6SzXsSmRaEzcXTtOOmVqJ5+WtQPL5uigY50Q=="],
+    "empathic": ["empathic@2.1.0", "", {}, "sha512-AnfC1ATldl49/cvZdLPDjBfrRNwbDO05aibiOtzQu3qtlbJtomNLhF30HEtn/7iBz50dlMECqATo3fG0LrdEgw=="],
 
     "enhanced-resolve": ["enhanced-resolve@5.24.5", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-L1l8TNvomm6UVW5B253AGxQagSQr+vGwhMlrrfRS2qmhx46AMpMVJKQYLvWYbysTMY8VoicOvzHzoHMbyzB+4A=="],
 
@@ -1411,7 +1411,7 @@
 
     "magic-string": ["magic-string@1.4.3", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.6.0" } }, "sha512-z12OxmaPGE0F4xlpGdjuAUckipLpQlTAuAmyGhNoD7ODpYUzvDfvtxUbjM/jwznyP178oju/KDdyi220wNJ0RQ=="],
 
-    "magicast": ["magicast@0.5.4", "", { "dependencies": { "@babel/parser": "^7.29.7", "@babel/types": "^7.29.7", "source-map-js": "^1.2.1" } }, "sha512-llBEhWm1SacoRwgHUoQJYtwp4PBLF4faQi5TCpIGyGs9n4y5+juI0tDgyKIfpqxckRHaHzouUEph3THklWh03w=="],
+    "magicast": ["magicast@0.5.5", "", { "dependencies": { "@babel/parser": "^7.29.7", "@babel/types": "^7.29.7", "source-map-js": "^1.2.1" } }, "sha512-UicdXN8zQ3JHlxVq+28afMXPr1z7WNY6+7EJnzTdQWkTAlMLF5fNCCKxJHBQwGaNGR11581EiQmQzx73+MvszA=="],
 
     "markdown-extensions": ["markdown-extensions@2.0.0", "", {}, "sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q=="],
 
@@ -1625,7 +1625,7 @@
 
     "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
 
-    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
+    "path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
 
     "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="],
 
@@ -1819,7 +1819,7 @@
 
     "stop-iteration-iterator": ["stop-iteration-iterator@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "internal-slot": "^1.1.0" } }, "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ=="],
 
-    "string-width": ["string-width@8.2.2", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg=="],
+    "string-width": ["string-width@8.3.0", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-ZbmZM0JCihQN91dWnxoipT2KOEyHqEyfRXUyjuRhW8b/xnqPDoq4gWEVApTVa9db2wN8mmoikgFBbjh71+cGeQ=="],
 
     "string.prototype.includes": ["string.prototype.includes@2.0.1", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.3" } }, "sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg=="],
 
@@ -1905,7 +1905,7 @@
 
     "ufo": ["ufo@1.6.4", "", {}, "sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA=="],
 
-    "ultracite": ["ultracite@7.11.1", "", { "dependencies": { "@clack/prompts": "^1.7.0", "cli-truncate": "^6.1.1", "commander": "^15.0.0", "deepmerge": "^4.3.1", "empathic": "^2.0.1", "execa": "^10.0.1", "fast-glob": "^3.3.3", "find-workspaces": "^0.3.1", "jsonc-parser": "^3.3.1", "log-update": "^8.0.0", "magicast": "^0.5.4", "nypm": "^0.6.9", "resolve.exports": "^2.0.3", "semver": "^7.8.5", "string-width": "^8.2.2", "yaml": "^2.9.0", "zod": "^4.5.4" }, "peerDependencies": { "@biomejs/biome": "^2.5.0", "eslint": "^10.0.0", "oxfmt": ">=0.40.0", "oxlint": "^1.79.0", "prettier": "^3.0.0", "stylelint": "^17.0.0" }, "optionalPeers": ["@biomejs/biome", "eslint", "oxfmt", "oxlint", "prettier", "stylelint"], "bin": { "ultracite": "dist/index.js" } }, "sha512-NHqXD/fpNpLyAWCU3AOfRppVvXtxVk0D+oWrEOUXOveAiQCoyCnx+vL34Fa/rnFPY2piYfdqNhghp/J04uQ6JQ=="],
+    "ultracite": ["ultracite@8.0.1", "", { "dependencies": { "@clack/prompts": "^1.8.1", "cli-truncate": "^6.1.1", "commander": "^15.0.0", "deepmerge": "^4.3.1", "empathic": "^2.1.0", "execa": "^10.0.1", "fast-glob": "^3.3.3", "find-workspaces": "^0.3.1", "jsonc-parser": "^3.3.1", "log-update": "^8.0.0", "magicast": "^0.5.5", "npm-run-path": "^6.0.0", "nypm": "^0.6.10", "resolve.exports": "^2.0.3", "semver": "^7.8.5", "string-width": "^8.3.0", "which-command": "^0.1.0", "yaml": "^2.9.1", "zod": "^4.6.5" }, "peerDependencies": { "@biomejs/biome": "^2.5.0", "eslint": "^10.9.0", "oxfmt": ">=0.71.0 <1", "oxlint": "^1.86.0", "prettier": "^3.5.3", "stylelint": "^17.0.0" }, "optionalPeers": ["@biomejs/biome", "eslint", "oxfmt", "oxlint", "prettier", "stylelint"], "bin": { "ultracite": "dist/index.js" } }, "sha512-4XtB3My7o/O8uveSBPjMO6aPwkO7LEGDf2RCuR4jMVSJ4JByLNIb8+xpCR5M+HssgPrl0aSTQ/40od80ItmiqQ=="],
 
     "unbox-primitive": ["unbox-primitive@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "has-bigints": "^1.0.2", "has-symbols": "^1.1.0", "which-boxed-primitive": "^1.1.1" } }, "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw=="],
 
@@ -2043,12 +2043,16 @@
 
     "cli-table3/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
 
+    "cli-truncate/string-width": ["string-width@8.2.2", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg=="],
+
     "cliui/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
 
     "cliui/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
 
     "cliui/wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
 
+    "cross-spawn/path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
+
     "eslint/escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="],
 
     "eslint/espree": ["espree@11.2.0", "", { "dependencies": { "acorn": "^8.16.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^5.0.1" } }, "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw=="],
@@ -2077,7 +2081,7 @@
 
     "fumadocs-ui/cn": ["cn@0.4.0", "", { "bin": { "cn": "bin/cn.mjs" } }, "sha512-qOAeUhPwPzBxx6jaeQdo646XIKliKHc2j1ZF7Ngb1o0pJZKH5gq8FkA0aVdUdPFUDXNXyUCXpCtoJISo6dhizg=="],
 
-    "magicast/source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+    "log-update/string-width": ["string-width@8.2.2", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg=="],
 
     "marked-terminal/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="],
 
@@ -2091,8 +2095,6 @@
 
     "node-exports-info/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
 
-    "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="],
-
     "parse-entities/@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="],
 
     "parse5-htmlparser2-tree-adapter/parse5": ["parse5@6.0.1", "", {}, "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw=="],
@@ -2109,14 +2111,14 @@
 
     "tsdown/cac": ["cac@7.1.0", "", {}, "sha512-LMDU/U2yA4IPIY8KT0NsNPWEYZvAMkbgyspxJ6btJaYV+WMDOHAZCmB0lsTObiHaRS1V/ztKAl7+TSkTqXyeoA=="],
 
-    "tsdown/empathic": ["empathic@2.1.0", "", {}, "sha512-AnfC1ATldl49/cvZdLPDjBfrRNwbDO05aibiOtzQu3qtlbJtomNLhF30HEtn/7iBz50dlMECqATo3fG0LrdEgw=="],
+    "ultracite/@clack/prompts": ["@clack/prompts@1.8.1", "", { "dependencies": { "@clack/core": "1.5.1", "fast-string-width": "^3.0.2", "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-dlT1m5e/0yUL0kRNcQn7yGLVThkgbB0Ga/1AmfDDC/8ik6AIiSf2QLQO2zPYvefsHP0aFgxO93cVLCCfDp7kzQ=="],
 
     "ultracite/commander": ["commander@15.0.0", "", {}, "sha512-z67u4ZhzCL/Tydu1lJARtEZYWbWaN7oYLHbsuzocr6y4N6WZAagG3RQ4FW61V1/0+jImpj293XfrcYnd1qxtPg=="],
 
-    "ultracite/yaml": ["yaml@2.9.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA=="],
-
     "wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="],
 
+    "wrap-ansi/string-width": ["string-width@8.2.2", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg=="],
+
     "yargs/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
 
     "yuku-analyzer/yuku-ast": ["yuku-ast@0.17.0", "", { "dependencies": { "@yuku-toolchain/types": "^0.17.0" } }, "sha512-htIzp3bLNdBtOSh8L8pJ7nkTft2kw/C3ghTToSg3FKtzi0YGkvAdEUUza9c744tnbeXtKUMEupFOYHuVNXn1yQ=="],
@@ -2169,6 +2171,8 @@
 
     "next/postcss/source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
 
+    "ultracite/@clack/prompts/@clack/core": ["@clack/core@1.5.1", "", { "dependencies": { "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-iHTrHA8MtVuLl2TfZySmcKv1qO2PoyC9Z7pfSDozEuV5vtY3/wcOPKJXlqJ5Oq2Cx5DDGQGAMVx6HZfRRoVEbQ=="],
+
     "yargs/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
 
     "yargs/string-width/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
diff --git a/oxlint.config.ts b/oxlint.config.ts
index a9f449a..9c403d4 100644
--- a/oxlint.config.ts
+++ b/oxlint.config.ts
@@ -12,5 +12,11 @@ export default defineConfig({
   extends: [core, react, next, nextJsPlugins, antiSlop, jsPlugins],
   ignorePatterns: core.ignorePatterns,
   jsPlugins: jsPlugins.jsPlugins,
+  rules: {
+    // React effects bail out early with a bare `return;` and otherwise return
+    // a cleanup. unicorn/no-useless-undefined forbids the explicit
+    // `return undefined;` that this rule would need instead.
+    "sonarjs/no-inconsistent-returns": "off",
+  },
   settings: jsPluginSettings,
 });
diff --git a/package.json b/package.json
index 1b9dd9f..4597f83 100644
--- a/package.json
+++ b/package.json
@@ -35,7 +35,7 @@
     "publint": "0.3.25",
     "turbo": "^2.11.8",
     "typescript": "^7",
-    "ultracite": "7.11.1"
+    "ultracite": "8.0.1"
   },
   "devEngines": {
     "packageManager": {
diff --git a/packages/vecstore-sdk/scripts/check-exports.ts b/packages/vecstore-sdk/scripts/check-exports.ts
index ae8e224..e85f6c7 100644
--- a/packages/vecstore-sdk/scripts/check-exports.ts
+++ b/packages/vecstore-sdk/scripts/check-exports.ts
@@ -16,8 +16,11 @@ const PROVIDER_PACKAGES = [
 
 type ExportTarget =
   (typeof packageJson.exports)[keyof typeof packageJson.exports];
+
 type ImportableTarget = Extract<ExportTarget, { import: string }>;
+
 type ExportEntry = readonly [string, ExportTarget];
+
 type ImportableEntry = readonly [string, ImportableTarget];
 
 const hasImportField = (entry: ExportEntry): entry is ImportableEntry =>
@@ -34,6 +37,7 @@ const checkEntryExports = async ([
 ]: ImportableEntry): Promise<void> => {
   const file = fileURLToPath(new URL(target.import, root));
   const loaded = await import(file);
+
   if (Object.keys(loaded).length === 0) {
     throw new Error(
       `${subpath} resolved to ${target.import} but exports nothing`
@@ -41,6 +45,7 @@ const checkEntryExports = async ([
   }
 
   const source = readFileSync(file, "utf-8");
+
   for (const name of PROVIDER_PACKAGES) {
     if (
       source.includes(`from "${name}"`) ||
diff --git a/packages/vecstore-sdk/src/errors.ts b/packages/vecstore-sdk/src/errors.ts
index a728d4b..9580472 100644
--- a/packages/vecstore-sdk/src/errors.ts
+++ b/packages/vecstore-sdk/src/errors.ts
@@ -61,9 +61,11 @@ export const errorMessage = (cause: unknown): string => {
   if (cause instanceof Error) {
     return cause.message;
   }
+
   if (isString(cause)) {
     return cause;
   }
+
   return "Unknown error";
 };
 
diff --git a/packages/vecstore-sdk/src/filter/pgvector.ts b/packages/vecstore-sdk/src/filter/pgvector.ts
index 9e8bd9d..468f23c 100644
--- a/packages/vecstore-sdk/src/filter/pgvector.ts
+++ b/packages/vecstore-sdk/src/filter/pgvector.ts
@@ -29,19 +29,23 @@ const containsAny = (
     `${column} @> ${param(JSON.stringify({ [field]: value }))}::jsonb`,
     `${column} @> ${param(JSON.stringify({ [field]: [value] }))}::jsonb`,
   ]);
+
   return `(${clauses.join(" OR ")})`;
 };
 
 const compileNode = (filter: Filter, column: string, param: Param): string => {
   const fieldPath = (field: string): string =>
     `(${column}->${param(field)}::text)`;
+
   switch (filter.kind) {
     case "eq": {
       return containsAny(column, filter.field, [filter.value], param);
     }
+
     case "ne": {
       return `NOT ${containsAny(column, filter.field, [filter.value], param)}`;
     }
+
     case "gt":
     case "gte":
     case "lt":
@@ -49,33 +53,43 @@ const compileNode = (filter: Filter, column: string, param: Param): string => {
       const path = fieldPath(filter.field);
       const operator = RANGE_OPERATORS[filter.kind];
       const value = `${param(JSON.stringify(filter.value))}::jsonb`;
+
       return `(${path} IS NOT NULL AND jsonb_typeof(${path}) = 'number' AND ${path} ${operator} ${value})`;
     }
+
     case "in": {
       return containsAny(column, filter.field, filter.values, param);
     }
+
     case "nin": {
       return `NOT ${containsAny(column, filter.field, filter.values, param)}`;
     }
+
     case "exists": {
       const path = fieldPath(filter.field);
+
       return `(${path} IS NOT NULL AND jsonb_typeof(${path}) <> 'null')`;
     }
+
     case "and": {
       return `(${filter.filters
         .map((child) => compileNode(child, column, param))
         .join(" AND ")})`;
     }
+
     case "or": {
       return `(${filter.filters
         .map((child) => compileNode(child, column, param))
         .join(" OR ")})`;
     }
+
     case "not": {
       return `NOT (${compileNode(filter.filter, column, param)})`;
     }
+
     default: {
       const exhaustive: never = filter;
+
       return exhaustive;
     }
   }
@@ -88,10 +102,14 @@ export const compilePgvectorFilter = (
   const column = options.column ?? "metadata";
   const startIndex = options.startIndex ?? 1;
   const params: string[] = [];
+
   const param: Param = (value) => {
     params.push(value);
+
     return `$${startIndex + params.length - 1}`;
   };
+
   const text = compileNode(filter, column, param);
+
   return { params, text };
 };
diff --git a/packages/vecstore-sdk/src/filter/pinecone.ts b/packages/vecstore-sdk/src/filter/pinecone.ts
index e08d892..4c96997 100644
--- a/packages/vecstore-sdk/src/filter/pinecone.ts
+++ b/packages/vecstore-sdk/src/filter/pinecone.ts
@@ -25,12 +25,15 @@ const membership = (
   exclude: boolean
 ): PineconeFilter => {
   const list = values.filter(isStringOrNumber);
+
   if (list.length === values.length) {
     return { [field]: exclude ? { $nin: list } : { $in: list } };
   }
+
   const clauses = values.map((value): PineconeFilter => ({
     [field]: exclude ? { $ne: value } : { $eq: value },
   }));
+
   return exclude ? { $and: clauses } : { $or: clauses };
 };
 
@@ -48,6 +51,7 @@ const COMPARISONS: Record<
 
 const comparison = (filter: RangeFilter, negated: boolean): PineconeFilter => {
   const [operator, negatedOperator] = COMPARISONS[filter.kind];
+
   return {
     [filter.field]: (negated ? negatedOperator : operator)(filter.value),
   };
@@ -64,37 +68,49 @@ const compile = (filter: Filter, negated: boolean): PineconeFilter => {
     case "eq": {
       return equality(filter.field, filter.value, negated);
     }
+
     case "ne": {
       return equality(filter.field, filter.value, !negated);
     }
+
     case "gt":
     case "gte":
     case "lt":
     case "lte": {
       return comparison(filter, negated);
     }
+
     case "in": {
       return membership(filter.field, filter.values, negated);
     }
+
     case "nin": {
       return membership(filter.field, filter.values, !negated);
     }
+
     case "exists": {
       return { [filter.field]: { $exists: !negated } };
     }
+
     case "and": {
       const clauses = filter.filters.map((child) => compile(child, negated));
+
       return negated ? { $or: clauses } : { $and: clauses };
     }
+
     case "or": {
       const clauses = filter.filters.map((child) => compile(child, negated));
+
       return negated ? { $and: clauses } : { $or: clauses };
     }
+
     case "not": {
       return compile(filter.filter, !negated);
     }
+
     default: {
       const exhaustive: never = filter;
+
       return exhaustive;
     }
   }
diff --git a/packages/vecstore-sdk/src/filter/qdrant.ts b/packages/vecstore-sdk/src/filter/qdrant.ts
index 4c49581..b485f9f 100644
--- a/packages/vecstore-sdk/src/filter/qdrant.ts
+++ b/packages/vecstore-sdk/src/filter/qdrant.ts
@@ -72,14 +72,18 @@ const membership = (
   exclude: boolean
 ): QdrantCondition => {
   const list = [...values];
+
   if (isStringList(list) || isIntegerList(list)) {
     const condition: QdrantMatchCondition = {
       key: field,
       match: { any: list },
     };
+
     return exclude ? { must_not: [condition] } : condition;
   }
+
   const conditions = list.map((value) => equalsCondition(field, value));
+
   return exclude ? { must_not: conditions } : { should: conditions };
 };
 
@@ -88,41 +92,54 @@ const toCondition = (filter: Filter): QdrantCondition => {
     case "eq": {
       return equalsCondition(filter.field, filter.value);
     }
+
     case "ne": {
       return { must_not: [equalsCondition(filter.field, filter.value)] };
     }
+
     case "gt": {
       return { key: filter.field, range: { gt: filter.value } };
     }
+
     case "gte": {
       return { key: filter.field, range: { gte: filter.value } };
     }
+
     case "lt": {
       return { key: filter.field, range: { lt: filter.value } };
     }
+
     case "lte": {
       return { key: filter.field, range: { lte: filter.value } };
     }
+
     case "in": {
       return membership(filter.field, filter.values, false);
     }
+
     case "nin": {
       return membership(filter.field, filter.values, true);
     }
+
     case "exists": {
       return { must_not: [{ is_empty: { key: filter.field } }] };
     }
+
     case "and": {
       return { must: filter.filters.map(toCondition) };
     }
+
     case "or": {
       return { should: filter.filters.map(toCondition) };
     }
+
     case "not": {
       return { must_not: [toCondition(filter.filter)] };
     }
+
     default: {
       const exhaustive: never = filter;
+
       return exhaustive;
     }
   }
@@ -137,5 +154,6 @@ const isQdrantFilter = (
 
 export const compileQdrantFilter = (filter: Filter): QdrantFilter => {
   const condition = toCondition(filter);
+
   return isQdrantFilter(condition) ? condition : { must: [condition] };
 };
diff --git a/packages/vecstore-sdk/src/filter/redis.ts b/packages/vecstore-sdk/src/filter/redis.ts
index cc2d4d3..11cd583 100644
--- a/packages/vecstore-sdk/src/filter/redis.ts
+++ b/packages/vecstore-sdk/src/filter/redis.ts
@@ -29,7 +29,7 @@ export interface RedisFilterProblem {
 
 export type RedisFilterResult = Result<string, RedisFilterProblem>;
 
-export const REDIS_FIELD_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+export const REDIS_FIELD_PATTERN = /^[A-Za-z_]\w*$/u;
 
 export const REDIS_RESERVED_FIELDS: ReadonlySet<string> = new Set([
   "namespace",
@@ -117,10 +117,13 @@ const typeOfField = (
   if (REDIS_RESERVED_FIELDS.has(field)) {
     return err(reservedField(field));
   }
+
   if (!REDIS_FIELD_PATTERN.test(field)) {
     return err(malformedField(field));
   }
+
   const type = types.get(field);
+
   return type === undefined ? err(unknownField(field)) : ok(type);
 };
 
@@ -128,6 +131,7 @@ const tagValue = (field: string, value: Scalar): RedisFilterResult => {
   if (isNumber(value)) {
     return err(tagHoldsNoNumber(field));
   }
+
   return ok(isString(value) ? value : String(value));
 };
 
@@ -135,6 +139,7 @@ const numericValue = (field: string, value: Scalar): RedisFilterResult => {
   if (!isNumber(value)) {
     return err(numericHoldsOnlyNumbers(field));
   }
+
   return Number.isFinite(value)
     ? ok(String(value))
     : err(finiteNumbersOnly(field, value));
@@ -150,9 +155,12 @@ const equality = (
 ): RedisFilterResult => {
   if (type === "numeric") {
     const number = numericValue(field, value);
+
     return number.ok ? ok(numericMatch(field, number.value)) : number;
   }
+
   const tag = tagValue(field, value);
+
   return tag.ok ? ok(redisTagClause(field, tag.value)) : tag;
 };
 
@@ -164,11 +172,15 @@ const comparison = (
   if (type === "tag") {
     return err(rangeNeedsNumeric(field));
   }
+
   const number = numericValue(field, filter.value);
+
   if (!number.ok) {
     return number;
   }
+
   const [start, end] = RANGE_BOUNDS[filter.kind](number.value);
+
   return ok(`@${field}:[${start} ${end}]`);
 };
 
@@ -177,13 +189,17 @@ const tagMembership = (
   values: NonEmpty<Scalar>
 ): RedisFilterResult => {
   const tags: string[] = [];
+
   for (const value of values) {
     const tag = tagValue(field, value);
+
     if (!tag.ok) {
       return tag;
     }
+
     tags.push(escapeRedisTag(tag.value));
   }
+
   return ok(`@${field}:{${tags.join(" | ")}}`);
 };
 
@@ -192,13 +208,17 @@ const numericMembership = (
   values: NonEmpty<Scalar>
 ): RedisFilterResult => {
   const matches: string[] = [];
+
   for (const value of values) {
     const number = numericValue(field, value);
+
     if (!number.ok) {
       return number;
     }
+
     matches.push(numericMatch(field, number.value));
   }
+
   return ok(`(${matches.join(" | ")})`);
 };
 
@@ -213,12 +233,14 @@ const leafClause = (
     case "ne": {
       return equality(filter.field, type, filter.value);
     }
+
     case "in":
     case "nin": {
       return type === "tag"
         ? tagMembership(filter.field, filter.values)
         : numericMembership(filter.field, filter.values);
     }
+
     default: {
       return comparison(filter.field, type, filter);
     }
@@ -236,13 +258,17 @@ const compileLeaf = (
   negated: boolean
 ): RedisFilterResult => {
   const type = typeOfField(filter.field, types);
+
   if (!type.ok) {
     return type;
   }
+
   const clause = leafClause(filter, type.value);
+
   if (!clause.ok) {
     return clause;
   }
+
   return ok(
     isNegatedLeaf(filter) === negated ? clause.value : negate(clause.value)
   );
@@ -260,14 +286,19 @@ const compileGroup = (
   compile: CompileNode
 ): RedisFilterResult => {
   const clauses: string[] = [];
+
   for (const child of filter.filters) {
     const compiled = compile(child, types, false);
+
     if (!compiled.ok) {
       return compiled;
     }
+
     clauses.push(compiled.value);
   }
+
   const separator = filter.kind === "and" ? " " : " | ";
+
   return ok(`(${clauses.join(separator)})`);
 };
 
@@ -277,10 +308,13 @@ const compileExists = (
   negated: boolean
 ): RedisFilterResult => {
   const type = typeOfField(field, types);
+
   if (!type.ok) {
     return type;
   }
+
   const clause = `ismissing(@${field})`;
+
   return ok(negated ? clause : `-${clause}`);
 };
 
@@ -296,22 +330,29 @@ const compileNode: CompileNode = (filter, types, negated) => {
     case "nin": {
       return compileLeaf(filter, types, negated);
     }
+
     case "exists": {
       return compileExists(filter.field, types, negated);
     }
+
     case "and":
     case "or": {
       const group = compileGroup(filter, types, compileNode);
+
       if (!group.ok) {
         return group;
       }
+
       return ok(negated ? negate(group.value) : group.value);
     }
+
     case "not": {
       return compileNode(filter.filter, types, !negated);
     }
+
     default: {
       const exhaustive: never = filter;
+
       return exhaustive;
     }
   }
diff --git a/packages/vecstore-sdk/src/filter/upstash.ts b/packages/vecstore-sdk/src/filter/upstash.ts
index 41ce9f6..0ca32cf 100644
--- a/packages/vecstore-sdk/src/filter/upstash.ts
+++ b/packages/vecstore-sdk/src/filter/upstash.ts
@@ -15,6 +15,7 @@ const identifier = (field: string): string => {
   if (IDENTIFIER_PATTERN.test(field)) {
     return field;
   }
+
   throw filterError(
     `Upstash cannot filter on the metadata field "${field}". Field names must match ${IDENTIFIER_PATTERN.source}.`
   );
@@ -26,12 +27,15 @@ const stringLiteral = (value: string): string => {
       `Upstash filter values cannot contain a backslash, received "${value}".`
     );
   }
+
   if (!value.includes("'")) {
     return `'${value}'`;
   }
+
   if (!value.includes('"')) {
     return `"${value}"`;
   }
+
   throw filterError(
     `Upstash filter values cannot contain both quote characters, received "${value}".`
   );
@@ -41,6 +45,7 @@ const numberLiteral = (value: number): string => {
   if (Number.isFinite(value)) {
     return String(value);
   }
+
   throw filterError(
     `Upstash filter values must be finite numbers, received ${String(value)}.`
   );
@@ -50,9 +55,11 @@ const literal = (value: Scalar): string => {
   if (isString(value)) {
     return stringLiteral(value);
   }
+
   if (isNumber(value)) {
     return numberLiteral(value);
   }
+
   return value ? "true" : "false";
 };
 
@@ -69,6 +76,7 @@ const equality = (field: string, value: Scalar, negated: boolean): string =>
 const comparison = (filter: RangeFilter, negated: boolean): string => {
   const [operator, negatedOperator] = COMPARISONS[filter.kind];
   const selected = negated ? negatedOperator : operator;
+
   return `${identifier(filter.field)} ${selected} ${numberLiteral(filter.value)}`;
 };
 
@@ -79,6 +87,7 @@ const membership = (
 ): string => {
   const operator = exclude ? "NOT IN" : "IN";
   const list = values.map(literal).join(", ");
+
   return `${identifier(field)} ${operator} (${list})`;
 };
 
@@ -87,38 +96,51 @@ const compile = (filter: Filter, negated: boolean): string => {
     case "eq": {
       return equality(filter.field, filter.value, negated);
     }
+
     case "ne": {
       return equality(filter.field, filter.value, !negated);
     }
+
     case "gt":
     case "gte":
     case "lt":
     case "lte": {
       return comparison(filter, negated);
     }
+
     case "in": {
       return membership(filter.field, filter.values, negated);
     }
+
     case "nin": {
       return membership(filter.field, filter.values, !negated);
     }
+
     case "exists": {
       const operator = negated ? "HAS NOT FIELD" : "HAS FIELD";
+
       return `${operator} ${identifier(filter.field)}`;
     }
+
     case "and": {
       const clauses = filter.filters.map((child) => compile(child, negated));
+
       return `(${clauses.join(negated ? " OR " : " AND ")})`;
     }
+
     case "or": {
       const clauses = filter.filters.map((child) => compile(child, negated));
+
       return `(${clauses.join(negated ? " AND " : " OR ")})`;
     }
+
     case "not": {
       return compile(filter.filter, !negated);
     }
+
     default: {
       const exhaustive: never = filter;
+
       return exhaustive;
     }
   }
diff --git a/packages/vecstore-sdk/src/filter/vectorize.ts b/packages/vecstore-sdk/src/filter/vectorize.ts
index c8c3ad4..e784fa7 100644
--- a/packages/vecstore-sdk/src/filter/vectorize.ts
+++ b/packages/vecstore-sdk/src/filter/vectorize.ts
@@ -136,6 +136,7 @@ const leafClause = (filter: LeafFilter, negated: boolean): Clause => {
         filter.value
       );
     }
+
     case "ne": {
       return comparisonClause(
         filter.field,
@@ -143,6 +144,7 @@ const leafClause = (filter: LeafFilter, negated: boolean): Clause => {
         filter.value
       );
     }
+
     case "in": {
       return collectionClause(
         filter.field,
@@ -150,6 +152,7 @@ const leafClause = (filter: LeafFilter, negated: boolean): Clause => {
         filter.values
       );
     }
+
     case "nin": {
       return collectionClause(
         filter.field,
@@ -157,8 +160,10 @@ const leafClause = (filter: LeafFilter, negated: boolean): Clause => {
         filter.values
       );
     }
+
     default: {
       const [operator, negatedOperator] = COMPARISONS[filter.kind];
+
       return comparisonClause(
         filter.field,
         negated ? negatedOperator : operator,
@@ -183,29 +188,39 @@ const clausesOf = (
     case "nin": {
       return ok([leafClause(filter, negated)]);
     }
+
     case "exists": {
       return err(noExistsOperator);
     }
+
     case "and":
     case "or": {
       if ((filter.kind === "and") === negated) {
         return err(noOrOperator);
       }
+
       const clauses: Clause[] = [];
+
       for (const child of filter.filters) {
         const compiled = clausesOf(child, negated);
+
         if (!compiled.ok) {
           return compiled;
         }
+
         clauses.push(...compiled.value);
       }
+
       return ok(clauses);
     }
+
     case "not": {
       return clausesOf(filter.filter, !negated);
     }
+
     default: {
       const exhaustive: never = filter;
+
       return exhaustive;
     }
   }
@@ -218,11 +233,14 @@ const insert = <Operator, Value>(
   value: Value
 ): boolean => {
   const operators = groups.get(field) ?? new Map<Operator, Value>();
+
   if (operators.has(operator)) {
     return false;
   }
+
   operators.set(operator, value);
   groups.set(field, operators);
+
   return true;
 };
 
@@ -231,34 +249,44 @@ const merge = (clauses: readonly Clause[]): VectorizeFilterResult => {
     string,
     Map<VectorizeComparisonOperator, Scalar>
   >();
+
   const collections = new Map<
     string,
     Map<VectorizeCollectionOperator, Scalar[]>
   >();
+
   for (const clause of clauses) {
     if (clause.kind === "comparison") {
       if (collections.has(clause.field)) {
         return err(mixedOperators(clause.field));
       }
+
       if (!insert(comparisons, clause.field, clause.operator, clause.value)) {
         return err(repeatedOperator(clause.field, clause.operator));
       }
+
       continue;
     }
+
     if (comparisons.has(clause.field)) {
       return err(mixedOperators(clause.field));
     }
+
     if (!insert(collections, clause.field, clause.operator, clause.values)) {
       return err(repeatedOperator(clause.field, clause.operator));
     }
   }
+
   const conditions: [string, VectorizeCondition][] = [];
+
   for (const [field, operators] of comparisons) {
     conditions.push([field, Object.fromEntries(operators)]);
   }
+
   for (const [field, operators] of collections) {
     conditions.push([field, Object.fromEntries(operators)]);
   }
+
   return ok(Object.fromEntries(conditions));
 };
 
@@ -266,5 +294,6 @@ export const compileVectorizeFilter = (
   filter: Filter
 ): VectorizeFilterResult => {
   const clauses = clausesOf(filter, false);
+
   return clauses.ok ? merge(clauses.value) : clauses;
 };
diff --git a/packages/vecstore-sdk/src/index.ts b/packages/vecstore-sdk/src/index.ts
index 84c7eff..5e3c7ff 100644
--- a/packages/vecstore-sdk/src/index.ts
+++ b/packages/vecstore-sdk/src/index.ts
@@ -9,6 +9,7 @@ export type {
   UnsupportedError,
   VecstoreError,
 } from "./errors";
+
 export type {
   AndFilter,
   EqFilter,
@@ -27,6 +28,7 @@ export type {
   RangeFilter,
   Scalar,
 } from "./filter/ast";
+
 export {
   and,
   eq,
@@ -41,8 +43,11 @@ export {
   notIn,
   or,
 } from "./filter/ast";
+
 export type { Err, Ok, Result } from "./result";
+
 export { err, ok } from "./result";
+
 export type {
   DeleteSelector,
   FetchOptions,
diff --git a/packages/vecstore-sdk/src/internal/collections.ts b/packages/vecstore-sdk/src/internal/collections.ts
index a41607d..8095be0 100644
--- a/packages/vecstore-sdk/src/internal/collections.ts
+++ b/packages/vecstore-sdk/src/internal/collections.ts
@@ -1,8 +1,10 @@
 export const chunk = <T>(items: readonly T[], size: number): T[][] => {
   const chunks: T[][] = [];
+
   for (let start = 0; start < items.length; start += size) {
     chunks.push(items.slice(start, start + size));
   }
+
   return chunks;
 };
 
@@ -10,9 +12,11 @@ export const lastById = <T extends { readonly id: string }>(
   records: readonly T[]
 ): T[] => {
   const byId = new Map<string, T>();
+
   for (const record of records) {
     byId.set(record.id, record);
   }
+
   return [...byId.values()];
 };
 
@@ -22,12 +26,15 @@ export const sortByIds = <T extends { readonly id: string }>(
 ): T[] => {
   const byId = new Map(records.map((record) => [record.id, record]));
   const ordered: T[] = [];
+
   for (const id of ids) {
     const record = byId.get(id);
+
     if (record !== undefined) {
       ordered.push(record);
     }
   }
+
   return ordered;
 };
 
@@ -50,13 +57,17 @@ export const mapBatches = async <T, R>({
   const results: R[] = Array.from({ length: batches.length });
   let next = 0;
   let failed = false;
+
   const worker = async (): Promise<void> => {
     const position = next;
+
     if (failed || position >= batches.length) {
       return;
     }
+
     next += 1;
     const batch = batches[position];
+
     if (batch !== undefined) {
       try {
         results[position] = await action(batch);
@@ -65,17 +76,22 @@ export const mapBatches = async <T, R>({
         throw error;
       }
     }
+
     await worker();
   };
+
   const workers = Array.from(
     { length: Math.min(concurrency, batches.length) },
     () => worker()
   );
+
   const outcomes = await Promise.allSettled(workers);
+
   for (const outcome of outcomes) {
     if (outcome.status === "rejected") {
       throw outcome.reason;
     }
   }
+
   return results;
 };
diff --git a/packages/vecstore-sdk/src/internal/delete-selector.ts b/packages/vecstore-sdk/src/internal/delete-selector.ts
index 66c21b5..d288b3f 100644
--- a/packages/vecstore-sdk/src/internal/delete-selector.ts
+++ b/packages/vecstore-sdk/src/internal/delete-selector.ts
@@ -14,14 +14,17 @@ export const deleteSelectorError = (
   if (!isObjectLike(selector)) {
     return invalidArgument(provider, `${SELECTOR_RULE}.`);
   }
+
   if ("ids" in selector) {
     return isStringArray(selector.ids) && selector.ids.length > 0
       ? undefined
       : invalidArgument(provider, `${SELECTOR_RULE}. Received no usable ids.`);
   }
+
   if ("filter" in selector) {
     return filterError(provider, selector.filter);
   }
+
   return "all" in selector && selector.all === true
     ? undefined
     : invalidArgument(
diff --git a/packages/vecstore-sdk/src/internal/filter.ts b/packages/vecstore-sdk/src/internal/filter.ts
index 8363413..4e6975b 100644
--- a/packages/vecstore-sdk/src/internal/filter.ts
+++ b/packages/vecstore-sdk/src/internal/filter.ts
@@ -27,6 +27,7 @@ const leafProblem = (filter: LeafFilter): string | undefined => {
         ? undefined
         : `"${filter.kind}" on "${filter.field}" needs ${VALUE_RULE}, received ${String(filter.value)}.`;
     }
+
     case "gt":
     case "gte":
     case "lt":
@@ -35,17 +36,21 @@ const leafProblem = (filter: LeafFilter): string | undefined => {
         ? undefined
         : `"${filter.kind}" on "${filter.field}" needs a finite number, received ${String(filter.value)}.`;
     }
+
     case "in":
     case "nin": {
       return isScalarList(filter.values)
         ? undefined
         : `"${filter.kind}" on "${filter.field}" needs a non-empty list where every value is ${VALUE_RULE}.`;
     }
+
     case "exists": {
       return undefined;
     }
+
     default: {
       const exhaustive: never = filter;
+
       return exhaustive;
     }
   }
@@ -55,23 +60,29 @@ const filterProblem = (filter: Filter): string | undefined => {
   if (!isObjectLike(filter)) {
     return "A filter must be an object built with the filter helpers.";
   }
+
   switch (filter.kind) {
     case "and":
     case "or": {
       if (!isNonEmptyList(filter.filters)) {
         return `"${filter.kind}" needs at least one filter.`;
       }
+
       for (const child of filter.filters) {
         const problem = filterProblem(child);
+
         if (problem !== undefined) {
           return problem;
         }
       }
+
       return undefined;
     }
+
     case "not": {
       return filterProblem(filter.filter);
     }
+
     case "eq":
     case "ne":
     case "gt":
@@ -85,8 +96,10 @@ const filterProblem = (filter: Filter): string | undefined => {
         ? leafProblem(filter)
         : `"${filter.kind}" needs a field name.`;
     }
+
     default: {
       const exhaustive: never = filter;
+
       return `Unknown filter ${JSON.stringify(exhaustive)}.`;
     }
   }
@@ -97,5 +110,6 @@ export const filterError = (
   filter: Filter
 ): VecstoreError | undefined => {
   const problem = filterProblem(filter);
+
   return problem === undefined ? undefined : invalidArgument(provider, problem);
 };
diff --git a/packages/vecstore-sdk/src/internal/metadata.ts b/packages/vecstore-sdk/src/internal/metadata.ts
index e708bd2..72cd8a3 100644
--- a/packages/vecstore-sdk/src/internal/metadata.ts
+++ b/packages/vecstore-sdk/src/internal/metadata.ts
@@ -35,5 +35,6 @@ export const reservedKeyError = (
       }
     }
   }
+
   return undefined;
 };
diff --git a/packages/vecstore-sdk/src/internal/network.ts b/packages/vecstore-sdk/src/internal/network.ts
index c014758..c8846f3 100644
--- a/packages/vecstore-sdk/src/internal/network.ts
+++ b/packages/vecstore-sdk/src/internal/network.ts
@@ -27,6 +27,7 @@ export const isNetworkFailure = (cause: unknown): boolean => {
   if (!(cause instanceof Error)) {
     return false;
   }
+
   return (
     carriesNetworkCode(cause) ||
     carriesNetworkCode(cause.cause) ||
diff --git a/packages/vecstore-sdk/src/internal/postgres.ts b/packages/vecstore-sdk/src/internal/postgres.ts
index 7e43e8e..b1618ed 100644
--- a/packages/vecstore-sdk/src/internal/postgres.ts
+++ b/packages/vecstore-sdk/src/internal/postgres.ts
@@ -67,25 +67,33 @@ export const normalizePostgresError = (
   if (isNetworkFailure(cause) || isDriverConnectionFailure(cause)) {
     return connection(provider, cause);
   }
+
   if (!hasCode(cause)) {
     return providerError(provider, cause);
   }
+
   const { code } = cause;
+
   if (code === UNDEFINED_TABLE) {
     return notFound(provider, index, cause);
   }
+
   if (code === DUPLICATE_TABLE) {
     return alreadyExists(provider, index, cause);
   }
+
   if (isConnectionCode(code)) {
     return connection(provider, cause);
   }
+
   if (isAuthCode(code)) {
     return unauthorized(provider, cause);
   }
+
   if (isArgumentCode(code)) {
     return invalidArgument(provider, cause.message, cause);
   }
+
   return providerError(provider, cause);
 };
 
@@ -118,7 +126,9 @@ const rowVector = (row: PostgresRow): number[] => {
   if (!isString(row.embedding)) {
     return [];
   }
+
   const parsed = JSON.parse(row.embedding);
+
   return isNumberArray(parsed) ? parsed : [];
 };
 
@@ -141,8 +151,10 @@ export const toScoredRecord = (
 
 const IDENTIFIER_LIMIT_BYTES = 63;
 const INDEX_SUFFIX = "_embedding_idx";
+
 export const MAX_INDEX_NAME_BYTES =
   IDENTIFIER_LIMIT_BYTES - INDEX_SUFFIX.length;
+
 export const DOLLAR_TAG = "$vecstore$";
 const nameEncoder = new TextEncoder();
 
@@ -151,17 +163,20 @@ export const indexNameError = (
   name: string
 ): VecstoreError | undefined => {
   const nameBytes = nameEncoder.encode(name).length;
+
   if (nameBytes > MAX_INDEX_NAME_BYTES) {
     return invalidArgument(
       provider,
       `An index name can be at most ${MAX_INDEX_NAME_BYTES} bytes on ${provider}, because Postgres truncates identifiers at ${IDENTIFIER_LIMIT_BYTES} bytes and the adapter appends "${INDEX_SUFFIX}" to it. Received ${nameBytes} bytes.`
     );
   }
+
   if (name.includes(DOLLAR_TAG)) {
     return invalidArgument(
       provider,
       `An index name cannot contain "${DOLLAR_TAG}" on ${provider}, because createIndex uses it to quote the statement that creates the table. Received "${name}".`
     );
   }
+
   return undefined;
 };
diff --git a/packages/vecstore-sdk/src/internal/query-options.ts b/packages/vecstore-sdk/src/internal/query-options.ts
index 8b02c09..3bd441b 100644
--- a/packages/vecstore-sdk/src/internal/query-options.ts
+++ b/packages/vecstore-sdk/src/internal/query-options.ts
@@ -13,6 +13,7 @@ export const queryOptionsError = (
       `topK must be a positive integer, got ${String(query.topK)}`
     );
   }
+
   return query.filter === undefined
     ? undefined
     : filterError(provider, query.filter);
diff --git a/packages/vecstore-sdk/src/internal/uuid.ts b/packages/vecstore-sdk/src/internal/uuid.ts
index 542dfbe..4b486fb 100644
--- a/packages/vecstore-sdk/src/internal/uuid.ts
+++ b/packages/vecstore-sdk/src/internal/uuid.ts
@@ -25,6 +25,7 @@ export const deterministicUuid = (namespace: string, name: string): string => {
     .update(`${namespace}${SEPARATOR}${name}`, "utf-8")
     .digest()
     .subarray(0, UUID_BYTES);
+
   hash.writeUInt8(
     (hash.readUInt8(VERSION_BYTE) % LOW_NIBBLE) + VERSION_8,
     VERSION_BYTE
@@ -34,5 +35,6 @@ export const deterministicUuid = (namespace: string, name: string): string => {
     VARIANT_BYTE
   );
   const hex = hash.toString("hex");
+
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 };
diff --git a/packages/vecstore-sdk/src/pgvector/index.ts b/packages/vecstore-sdk/src/pgvector/index.ts
index 1ac5b9f..8ac7904 100644
--- a/packages/vecstore-sdk/src/pgvector/index.ts
+++ b/packages/vecstore-sdk/src/pgvector/index.ts
@@ -76,6 +76,7 @@ const DISTANCE_OPERATORS: Record<Metric, string> = {
 
 const HNSW_METHOD = "USING hnsw";
 const ITERATIVE_SCAN_MINOR = 8;
+
 const ITERATIVE_SCAN_SETTING =
   "set_config('hnsw.iterative_scan', CASE WHEN current_setting('hnsw.iterative_scan', true) IN ('strict_order', 'relaxed_order') THEN current_setting('hnsw.iterative_scan', true) ELSE 'strict_order' END, true)";
 
@@ -100,6 +101,7 @@ interface SearchProfile {
 
 const supportsIterativeScan = (version: string): boolean => {
   const [major = 0, minor = 0] = version.split(".").map(Number);
+
   return major > 0 || minor >= ITERATIVE_SCAN_MINOR;
 };
 
@@ -123,18 +125,23 @@ const distanceExpression = (metric: Metric, vectorParam: string): string =>
 
 const scoreExpression = (metric: Metric, vectorParam: string): string => {
   const distance = distanceExpression(metric, vectorParam);
+
   switch (metric) {
     case "cosine": {
       return `1 - (${distance})`;
     }
+
     case "dot": {
       return `-(${distance})`;
     }
+
     case "euclidean": {
       return distance;
     }
+
     default: {
       const exhaustive: never = metric;
+
       return exhaustive;
     }
   }
@@ -166,12 +173,15 @@ const resolveProfile = async (
     context.schema === undefined
       ? [context.name]
       : [context.name, context.schema];
+
   const { rows } = await context.client.query(
     `SELECT indexdef, (SELECT extversion FROM pg_extension WHERE extname = 'vector') AS extversion FROM pg_indexes WHERE tablename = $1 AND schemaname = ${schemaPredicate(context.schema, "$2")}`,
     params
   );
+
   for (const row of rows.filter(isIndexDefinitionRow)) {
     const metric = metricFromIndexDef(row.indexdef);
+
     if (metric !== undefined) {
       return {
         iterativeScan:
@@ -181,6 +191,7 @@ const resolveProfile = async (
       };
     }
   }
+
   return DEFAULT_PROFILE;
 };
 
@@ -194,6 +205,7 @@ const searchRows = async (
 ): Promise<object[]> => {
   try {
     const { rows } = await context.client.query(text, params);
+
     return rows;
   } catch (error) {
     context.forget();
@@ -207,6 +219,7 @@ const upsertStatement = (
   batch: readonly VectorRecord[]
 ): PgStatement => {
   const params: PgParam[] = [];
+
   const rows = batch.map((record, rowIndex) => {
     const base = rowIndex * UPSERT_COLUMNS;
     params.push(
@@ -215,8 +228,10 @@ const upsertStatement = (
       vectorLiteral(record.vector),
       JSON.stringify(record.metadata ?? {})
     );
+
     return `($${base + 1}, $${base + 2}, $${base + 3}::vector, $${base + 4}::jsonb)`;
   });
+
   return {
     params,
     text: `INSERT INTO ${table} (id, namespace, embedding, metadata) VALUES ${rows.join(", ")} ON CONFLICT (namespace, id) DO UPDATE SET embedding = EXCLUDED.embedding, metadata = EXCLUDED.metadata`,
@@ -233,27 +248,34 @@ const createIndex = (
   return {
     delete: (selector: DeleteSelector) => {
       const rejected = deleteSelectorError(PROVIDER, selector);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       return run(name, async () => {
         if ("ids" in selector) {
           await client.query(
             `DELETE FROM ${table} WHERE namespace = $1 AND id = ANY($2::text[])`,
             [namespace, [...selector.ids]]
           );
+
           return;
         }
+
         if ("filter" in selector) {
           const filter = compilePgvectorFilter(selector.filter, {
             startIndex: 2,
           });
+
           await client.query(
             `DELETE FROM ${table} WHERE namespace = $1 AND ${filter.text}`,
             [namespace, ...filter.params]
           );
+
           return;
         }
+
         await client.query(`DELETE FROM ${table} WHERE namespace = $1`, [
           namespace,
         ]);
@@ -265,16 +287,20 @@ const createIndex = (
         if (ids.length === 0) {
           return [];
         }
+
         const vectorColumn = fetchOptions.includeVector
           ? ", embedding::text AS embedding"
           : "";
+
         const { rows } = await client.query(
           `SELECT id, metadata${vectorColumn} FROM ${table} WHERE namespace = $1 AND id = ANY($2::text[])`,
           [namespace, [...ids]]
         );
+
         const records = rows.flatMap((row) =>
           isPostgresRow(row) ? [toVectorRecord(row)] : []
         );
+
         return sortByIds(ids, records);
       }),
 
@@ -284,44 +310,58 @@ const createIndex = (
 
     query: (query: QueryOptions) => {
       const invalid = queryOptionsError(PROVIDER, query);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(name, async () => {
         const { iterativeScan, metric } = await context.profile();
         const params: PgParam[] = [namespace, vectorLiteral(query.vector)];
+
         const filter: PgvectorSql | undefined =
           query.filter === undefined
             ? undefined
             : compilePgvectorFilter(query.filter, {
                 startIndex: params.length + 1,
               });
+
         if (filter !== undefined) {
           params.push(...filter.params);
         }
+
         params.push(query.topK);
+
         const scoped =
           filter === undefined
             ? "namespace = $1"
             : `namespace = $1 AND ${filter.text}`;
+
         const where = iterativeScan
           ? `${scoped} AND tuning.scan IS NOT NULL`
           : scoped;
+
         const vectorColumn = query.includeVector
           ? "embedding::text AS embedding,"
           : "";
+
         const distance = distanceExpression(metric, "$2");
         const score = `${scoreExpression(metric, "$2")} AS score`;
+
         const columns = iterativeScan
           ? `${score}, ${distance} AS distance`
           : score;
+
         const search = `SELECT id, metadata, ${vectorColumn} ${columns} FROM ${table} WHERE ${where} ORDER BY ${distance} LIMIT $${params.length}`;
+
         const rows = await searchRows(
           context,
           iterativeScan ? withIterativeScan(search) : search,
           params
         );
+
         const includeMetadata = query.includeMetadata ?? true;
+
         return rows.flatMap((row) =>
           isPostgresRow(row)
             ? [
@@ -341,6 +381,7 @@ const createIndex = (
         await mapBatches({
           action: (batch) => {
             const statement = upsertStatement(table, namespace, batch);
+
             return client.query(statement.text, statement.params);
           },
           items: lastById(records),
@@ -354,15 +395,19 @@ export const createPgvectorStore = <Client extends PgQueryable>(
   options: PgvectorStoreOptions<Client>
 ): VectorStore<Client> => {
   const { client, schema } = options;
+
   const tableRef = (name: string): string =>
     schema === undefined
       ? quoteIdent(name)
       : `${quoteIdent(schema)}.${quoteIdent(name)}`;
+
   const profiles = new Map<string, Promise<SearchProfile>>();
   const profileKey = (name: string): string => `${schema ?? ""}.${name}`;
+
   const forgetProfile = (name: string): void => {
     profiles.delete(profileKey(name));
   };
+
   const lookup = async (
     target: ProfileTarget,
     key: string
@@ -374,18 +419,24 @@ export const createPgvectorStore = <Client extends PgQueryable>(
       throw error;
     }
   };
+
   const profileFor = (target: ProfileTarget): Promise<SearchProfile> => {
     const key = profileKey(target.name);
     const cached = profiles.get(key);
+
     if (cached !== undefined) {
       return cached;
     }
+
     const pending = lookup(target, key);
     profiles.set(key, pending);
+
     return pending;
   };
+
   const context = (name: string): TableContext => {
     const target: ProfileTarget = { client, name, schema };
+
     return {
       ...target,
       forget: () => forgetProfile(name),
@@ -398,9 +449,11 @@ export const createPgvectorStore = <Client extends PgQueryable>(
     createIndex: (spec: IndexSpec) => {
       const invalid =
         indexSpecError(PROVIDER, spec) ?? indexNameError(PROVIDER, spec.name);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(spec.name, async () => {
         forgetProfile(spec.name);
         const table = tableRef(spec.name);
@@ -428,10 +481,12 @@ export const createPgvectorStore = <Client extends PgQueryable>(
     listIndexes: () =>
       run("", async () => {
         const params: PgParam[] = schema === undefined ? [] : [schema];
+
         const { rows } = await client.query(
           `SELECT c.relname AS name FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace JOIN pg_attribute a ON a.attrelid = c.oid JOIN pg_type t ON t.oid = a.atttypid WHERE c.relkind = 'r' AND a.attname = 'embedding' AND t.typname = 'vector' AND n.nspname = ${schemaPredicate(schema, "$1")} ORDER BY c.relname`,
           params
         );
+
         return rows.flatMap((row) => (isNamedRow(row) ? [row.name] : []));
       }),
 
diff --git a/packages/vecstore-sdk/src/pinecone/index.ts b/packages/vecstore-sdk/src/pinecone/index.ts
index de3052c..a6884a9 100644
--- a/packages/vecstore-sdk/src/pinecone/index.ts
+++ b/packages/vecstore-sdk/src/pinecone/index.ts
@@ -122,6 +122,7 @@ const PROVIDER = "pinecone";
 const UPSERT_BATCH = 100;
 const FETCH_BATCH = 1000;
 const ID_BATCH = 1000;
+
 const DEFAULT_SPEC: PineconeIndexSpec = {
   serverless: { cloud: "aws", region: "us-east-1" },
 };
@@ -156,24 +157,31 @@ export const normalizePineconeError = (
   context: ErrorContext
 ): VecstoreError => {
   const name = cause instanceof Error ? cause.name : "";
+
   if (name === "PineconeNotFoundError") {
     return notFound(PROVIDER, context.index, cause);
   }
+
   if (name === "PineconeConflictError") {
     return alreadyExists(PROVIDER, context.index, cause);
   }
+
   if (name === "PineconeAuthorizationError") {
     return unauthorized(PROVIDER, cause);
   }
+
   if (CONNECTION_ERRORS.has(name)) {
     return connection(PROVIDER, cause);
   }
+
   if (INVALID_ARGUMENT_ERRORS.has(name)) {
     if (context.feature !== undefined && name === "PineconeBadRequestError") {
       return unsupported(PROVIDER, context.feature, errorMessage(cause));
     }
+
     return invalidArgument(PROVIDER, errorMessage(cause), cause);
   }
+
   return providerError(PROVIDER, cause);
 };
 
@@ -230,12 +238,15 @@ const createIndex = (
   const target = client.index({ name });
   const scope = namespaceArgs(options.namespace);
   const context: ErrorContext = { index: name };
+
   return {
     delete: (selector: DeleteSelector) => {
       const rejected = deleteSelectorError(PROVIDER, selector);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       if ("ids" in selector) {
         return run(context, async () => {
           await mapBatches({
@@ -245,6 +256,7 @@ const createIndex = (
           });
         });
       }
+
       if ("filter" in selector) {
         return run({ ...context, feature: "deleteByFilter" }, () =>
           target.deleteMany({
@@ -253,20 +265,24 @@ const createIndex = (
           })
         );
       }
+
       return run(context, () => target.deleteAll(scope));
     },
 
     fetch: (ids, fetchOptions: FetchOptions = {}) =>
       run(context, async () => {
         const includeVector = fetchOptions.includeVector ?? false;
+
         const responses = await mapBatches({
           action: (batch) => target.fetch({ ...scope, ids: batch }),
           items: ids,
           size: FETCH_BATCH,
         });
+
         const records = responses.flatMap((response) =>
           recordsOf(response, includeVector)
         );
+
         return sortByIds(ids, records);
       }),
 
@@ -276,12 +292,15 @@ const createIndex = (
 
     query: (query: QueryOptions) => {
       const invalid = queryOptionsError(PROVIDER, query);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(context, async () => {
         const includeMetadata = query.includeMetadata ?? true;
         const includeVector = query.includeVector ?? false;
+
         const response = await target.query({
           ...scope,
           filter:
@@ -293,6 +312,7 @@ const createIndex = (
           topK: query.topK,
           vector: [...query.vector],
         });
+
         return response.matches.map((match) =>
           toScoredRecord(match, includeMetadata, includeVector)
         );
@@ -318,12 +338,15 @@ export const createPineconeStore = <
 ): VectorStore<Client> => {
   const { client } = options;
   const spec = options.indexSpec ?? DEFAULT_SPEC;
+
   return {
     createIndex: (indexSpec: IndexSpec) => {
       const invalid = indexSpecError(PROVIDER, indexSpec);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run({ index: indexSpec.name }, async () => {
         await client.createIndex({
           dimension: indexSpec.dimension,
@@ -342,6 +365,7 @@ export const createPineconeStore = <
     listIndexes: () =>
       run({ index: "" }, async () => {
         const response = await client.listIndexes();
+
         return (response.indexes ?? []).map((index) => index.name);
       }),
 
diff --git a/packages/vecstore-sdk/src/qdrant/index.ts b/packages/vecstore-sdk/src/qdrant/index.ts
index 734e96f..ebe0ca9 100644
--- a/packages/vecstore-sdk/src/qdrant/index.ts
+++ b/packages/vecstore-sdk/src/qdrant/index.ts
@@ -129,6 +129,7 @@ const RESERVED_KEYS: ReadonlySet<string> = new Set([
   QDRANT_ID_KEY,
   QDRANT_NAMESPACE_KEY,
 ]);
+
 const ID_NAMESPACE = "vecstore-sdk/qdrant/point-id";
 const PROVIDER = "qdrant";
 const UPSERT_BATCH = 500;
@@ -156,6 +157,7 @@ const payloadEntries = (point: QdrantStoredPoint): MetadataEntry[] =>
 
 const fromPoint = (point: QdrantStoredPoint): string => {
   const stored = payloadEntries(point).find(([key]) => key === QDRANT_ID_KEY);
+
   return stored !== undefined && isString(stored[1])
     ? stored[1]
     : String(point.id);
@@ -168,7 +170,9 @@ const inNamespace = (namespace: string, point: QdrantStoredPoint): boolean => {
   const stored = payloadEntries(point).find(
     ([key]) => key === QDRANT_NAMESPACE_KEY
   );
+
   const reported = stored !== undefined && isString(stored[1]) ? stored[1] : "";
+
   return reported === namespace;
 };
 
@@ -181,12 +185,15 @@ const toPayload = (
   pointId: string
 ): Record<string, MetadataValue> => {
   const entries: MetadataEntry[] = Object.entries(record.metadata ?? {});
+
   if (pointId !== record.id) {
     entries.push([QDRANT_ID_KEY, record.id]);
   }
+
   if (namespace !== "") {
     entries.push([QDRANT_NAMESPACE_KEY, namespace]);
   }
+
   return Object.fromEntries(entries);
 };
 
@@ -205,6 +212,7 @@ export const scopeQdrantFilter = (
   filter?: Filter
 ): QdrantFilter => {
   const scope = namespaceCondition(namespace ?? "");
+
   return {
     must: filter === undefined ? [scope] : [scope, compileQdrantFilter(filter)],
   };
@@ -252,9 +260,11 @@ const isConnectionFailure = (cause: unknown): boolean => {
   if (!(cause instanceof Error)) {
     return false;
   }
+
   if (cause.name === "QdrantClientTimeoutError") {
     return true;
   }
+
   return isNetworkFailure(cause);
 };
 
@@ -265,30 +275,37 @@ export const normalizeQdrantError = (
   if (cause instanceof Error && cause.name === MISSING_COLLECTION_ERROR) {
     return notFound(PROVIDER, index, cause);
   }
+
   if (isHttpFailure(cause)) {
     switch (cause.status) {
       case HTTP_NOT_FOUND: {
         return notFound(PROVIDER, index, cause);
       }
+
       case HTTP_CONFLICT: {
         return alreadyExists(PROVIDER, index, cause);
       }
+
       case HTTP_BAD_REQUEST:
       case HTTP_UNPROCESSABLE: {
         return invalidArgument(PROVIDER, failureMessage(cause), cause);
       }
+
       case HTTP_UNAUTHORIZED:
       case HTTP_FORBIDDEN: {
         return unauthorized(PROVIDER, cause);
       }
+
       default: {
         return providerError(PROVIDER, cause);
       }
     }
   }
+
   if (isConnectionFailure(cause)) {
     return connection(PROVIDER, cause);
   }
+
   return providerError(PROVIDER, cause);
 };
 
@@ -302,12 +319,15 @@ const createIndex = (
 ): VectorIndex => {
   const namespace = options.namespace ?? "";
   const invalid = namespaceError(PROVIDER, namespace);
+
   return {
     delete: (selector: DeleteSelector): VecResult<void> => {
       const rejected = invalid ?? deleteSelectorError(PROVIDER, selector);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       return run(name, async () => {
         if ("ids" in selector) {
           const pointIds = selector.ids.map((id) => toPointId(namespace, id));
@@ -322,8 +342,10 @@ const createIndex = (
             items: pointIds,
             size: ID_BATCH,
           });
+
           return;
         }
+
         const filter = "filter" in selector ? selector.filter : undefined;
         await client.delete(name, {
           filter: scopeQdrantFilter(options.namespace, filter),
@@ -339,11 +361,14 @@ const createIndex = (
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(name, async () => {
         if (ids.length === 0) {
           return [];
         }
+
         const pointIds = ids.map((id) => toPointId(namespace, id));
+
         const responses = await mapBatches({
           action: (batch) =>
             client.retrieve(name, {
@@ -354,7 +379,9 @@ const createIndex = (
           items: pointIds,
           size: ID_BATCH,
         });
+
         const records: VectorRecord[] = [];
+
         for (const point of responses.flat()) {
           if (inNamespace(namespace, point)) {
             records.push({
@@ -364,6 +391,7 @@ const createIndex = (
             });
           }
         }
+
         return sortByIds(ids, records);
       });
     },
@@ -376,12 +404,16 @@ const createIndex = (
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       const invalidQuery = queryOptionsError(PROVIDER, query);
+
       if (invalidQuery !== undefined) {
         return Promise.resolve(err(invalidQuery));
       }
+
       return run(name, async () => {
         const includeMetadata = query.includeMetadata ?? true;
+
         const response = await client.query(name, {
           filter: scopeQdrantFilter(options.namespace, query.filter),
           limit: query.topK,
@@ -389,6 +421,7 @@ const createIndex = (
           with_payload: true,
           with_vector: query.includeVector ?? false,
         });
+
         return response.points.map((point): ScoredRecord => ({
           id: fromPoint(point),
           metadata: includeMetadata ? readMetadata(point) : undefined,
@@ -401,21 +434,26 @@ const createIndex = (
     upsert: (records): VecResult<void> => {
       const rejected =
         invalid ?? reservedKeyError(PROVIDER, records, RESERVED_KEYS);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       return run(name, async () => {
         if (records.length === 0) {
           return;
         }
+
         const points = lastById(records).map((record): QdrantPoint => {
           const id = toPointId(namespace, record.id);
+
           return {
             id,
             payload: toPayload(namespace, record, id),
             vector: [...record.vector],
           };
         });
+
         await mapBatches({
           action: (batch) => client.upsert(name, { points: batch, wait: true }),
           items: points,
@@ -430,12 +468,15 @@ export const createQdrantStore = <Client extends QdrantClientLike>(
   options: QdrantStoreOptions<Client>
 ): VectorStore<Client> => {
   const { client } = options;
+
   return {
     createIndex: (spec: IndexSpec) => {
       const invalid = indexSpecError(PROVIDER, spec);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(spec.name, async () => {
         await client.createCollection(spec.name, {
           vectors: {
@@ -443,6 +484,7 @@ export const createQdrantStore = <Client extends QdrantClientLike>(
             size: spec.dimension,
           },
         });
+
         try {
           await client.createPayloadIndex(spec.name, {
             field_name: QDRANT_NAMESPACE_KEY,
@@ -462,6 +504,7 @@ export const createQdrantStore = <Client extends QdrantClientLike>(
     deleteIndex: (name) =>
       run(name, async () => {
         const deleted = await client.deleteCollection(name);
+
         if (!deleted) {
           throw missingCollection(name);
         }
@@ -472,6 +515,7 @@ export const createQdrantStore = <Client extends QdrantClientLike>(
     listIndexes: () =>
       run("", async () => {
         const response = await client.getCollections();
+
         return response.collections.map((collection) => collection.name);
       }),
 
diff --git a/packages/vecstore-sdk/src/redis/index.ts b/packages/vecstore-sdk/src/redis/index.ts
index 603d2c2..f9a8e2a 100644
--- a/packages/vecstore-sdk/src/redis/index.ts
+++ b/packages/vecstore-sdk/src/redis/index.ts
@@ -196,8 +196,10 @@ const NOT_FOUND_PATTERN = /unknown index name|no such index/iu;
 const ALREADY_EXISTS_PATTERN = /index already exists/iu;
 const UNAUTHORIZED_PATTERN = /noauth|wrongpass|noperm|unauthenticated/iu;
 const UNKNOWN_COMMAND_PATTERN = /unknown command/iu;
+
 const INVALID_ARGUMENT_PATTERN =
   /syntax error|invalid|bad|wrong number of arguments|not a number|dimension|expected/iu;
+
 const SOCKET_TIMEOUT_PREFIX = "Socket timeout";
 
 const CONNECTION_MESSAGES: ReadonlySet<string> = new Set([
@@ -228,9 +230,11 @@ const isConnectionFailure = (cause: unknown): boolean => {
   if (!(cause instanceof Error)) {
     return false;
   }
+
   if (hasCode(cause) && CONNECTION_CODES.has(cause.code)) {
     return true;
   }
+
   return (
     CONNECTION_MESSAGES.has(cause.message) ||
     cause.message.startsWith(SOCKET_TIMEOUT_PREFIX)
@@ -244,22 +248,29 @@ export const normalizeRedisError = (
   if (isConnectionFailure(cause)) {
     return connection(PROVIDER, cause);
   }
+
   const message = errorMessage(cause);
+
   if (UNKNOWN_COMMAND_PATTERN.test(message)) {
     return unsupported(PROVIDER, "queryEngine", MODULES_MESSAGE);
   }
+
   if (ALREADY_EXISTS_PATTERN.test(message)) {
     return alreadyExists(PROVIDER, index, cause);
   }
+
   if (NOT_FOUND_PATTERN.test(message)) {
     return notFound(PROVIDER, index, cause);
   }
+
   if (UNAUTHORIZED_PATTERN.test(message)) {
     return unauthorized(PROVIDER, cause);
   }
+
   if (INVALID_ARGUMENT_PATTERN.test(message)) {
     return invalidArgument(PROVIDER, message, cause);
   }
+
   return providerError(PROVIDER, cause);
 };
 
@@ -273,9 +284,11 @@ const redisFieldError = (field: RedisMetadataField): string | undefined => {
   if (REDIS_RESERVED_FIELDS.has(field.field)) {
     return `The Redis adapter keeps "${field.field}" for itself. Rename the metadata field.`;
   }
+
   if (!REDIS_FIELD_PATTERN.test(field.field)) {
     return `Redis cannot name a field "${field.field}". A field name must match ${REDIS_FIELD_PATTERN.source}.`;
   }
+
   return undefined;
 };
 
@@ -324,9 +337,11 @@ export const redisSchema = (
       },
     ],
   ];
+
   for (const field of fields) {
     entries.push([`${METADATA_PATH}.${field.field}`, fieldDefinition(field)]);
   }
+
   return Object.fromEntries(entries);
 };
 
@@ -336,10 +351,13 @@ export const scopeRedisFilter = (
   filter?: Filter
 ): Result<string, RedisFilterProblem> => {
   const scope = redisTagClause(REDIS_NAMESPACE_FIELD, namespace);
+
   if (filter === undefined) {
     return ok(scope);
   }
+
   const compiled = compileRedisFilter(filter, fields);
+
   return compiled.ok ? ok(`${scope} ${compiled.value}`) : compiled;
 };
 
@@ -351,6 +369,7 @@ export const redisKeyPrefix = (
 
 const toBlob = (vector: readonly number[]): Buffer => {
   const floats = Float32Array.from(vector);
+
   return Buffer.from(floats.buffer, floats.byteOffset, floats.byteLength);
 };
 
@@ -367,6 +386,7 @@ const typeName = (value: MetadataValue): string => {
   if (isNumber(value)) {
     return "a number";
   }
+
   return isString(value) ? "a string" : "a boolean or a list";
 };
 
@@ -375,6 +395,7 @@ const holdsWrongType = (
   value: MetadataValue
 ): boolean => {
   const numeric = isNumber(value);
+
   return type === "numeric" ? !numeric : numeric;
 };
 
@@ -383,20 +404,25 @@ const redisMetadataError = (
   fields: readonly RedisMetadataField[]
 ): string | undefined => {
   const metadata = Object.entries(record.metadata ?? {});
+
   for (const field of fields) {
     const entry = metadata.find(([key]) => key === field.field);
+
     if (entry !== undefined && holdsWrongType(field.type, entry[1])) {
       return `Redis leaves a whole document out of the index when a field holds a value its schema has no room for. Record "${record.id}" carries ${typeName(entry[1])} in "${field.field}", which the schema declares as ${field.type}.`;
     }
   }
+
   return undefined;
 };
 
 const jsonEntries = (value: RedisJsonValue): [string, RedisJsonValue][] => {
   if (Array.isArray(value)) {
     const [first] = value;
+
     return first === undefined ? [] : jsonEntries(first);
   }
+
   return isObjectLike(value) && !(value instanceof Date)
     ? Object.entries(value)
     : [];
@@ -411,10 +437,13 @@ const jsonVector = (value: RedisJsonValue): number[] => {
   if (isNumberArray(value)) {
     return value;
   }
+
   if (Array.isArray(value)) {
     const [first] = value;
+
     return isNumberArray(first) ? first : [];
   }
+
   return [];
 };
 
@@ -425,6 +454,7 @@ const parseJsonText = (source: string | undefined): RedisJsonValue => {
   if (source === undefined) {
     return null;
   }
+
   try {
     return JSON.parse(source);
   } catch {
@@ -438,6 +468,7 @@ const projection = (
 ): string | undefined => {
   const entry = Object.entries(document.value).find(([key]) => key === field);
   const value: unknown = entry?.[1];
+
   return isString(value) ? value : undefined;
 };
 
@@ -445,11 +476,15 @@ const distanceOf = (document: RedisSearchDocument): number => {
   const entry = Object.entries(document.value).find(
     ([key]) => key === REDIS_DISTANCE_FIELD
   );
+
   const value: unknown = entry?.[1];
+
   if (isNumber(value)) {
     return value;
   }
+
   const parsed = isString(value) ? Number(value) : Number.NaN;
+
   return Number.isNaN(parsed) ? 0 : parsed;
 };
 
@@ -461,12 +496,15 @@ const queryReturn = (
   includeVector: boolean
 ): string[] => {
   const fields = [REDIS_DISTANCE_FIELD];
+
   if (includeMetadata) {
     fields.push(METADATA_PATH);
   }
+
   if (includeVector) {
     fields.push(VECTOR_PATH);
   }
+
   return fields;
 };
 
@@ -479,12 +517,15 @@ const toScoredRecord = (
   if (!document.id.startsWith(prefix)) {
     return undefined;
   }
+
   const metadata = includeMetadata
     ? jsonMetadata(parseJsonText(projection(document, METADATA_PATH)))
     : undefined;
+
   const vector = includeVector
     ? jsonVector(parseJsonText(projection(document, VECTOR_PATH)))
     : undefined;
+
   return {
     id: document.id.slice(prefix.length),
     metadata,
@@ -499,6 +540,7 @@ const toVectorRecord = (
   includeVector: boolean
 ): VectorRecord => {
   const entries = jsonEntries(stored);
+
   return {
     id,
     metadata: jsonMetadata(jsonField(entries, METADATA_KEY)),
@@ -528,15 +570,19 @@ const deletePage = async (
     LIMIT: { from: 0, size: DELETE_PAGE },
     RETURN: [],
   });
+
   const keys: string[] = [];
+
   for (const document of page.documents) {
     if (document.id.startsWith(context.prefix)) {
       keys.push(document.id);
     }
   }
+
   if (keys.length > 0) {
     await context.client.unlink(keys);
   }
+
   return { seen: page.documents.length, unlinked: keys.length };
 };
 
@@ -545,6 +591,7 @@ const deleteMatches = async (
   prefilter: string
 ): Promise<void> => {
   const page = await deletePage(context, prefilter);
+
   if (page.unlinked > 0 && page.seen === DELETE_PAGE) {
     await deleteMatches(context, prefilter);
   }
@@ -555,9 +602,11 @@ const deleteByFilter = (
   filter?: Filter
 ): VecResult<void> => {
   const prefilter = scopeRedisFilter(context.namespace, context.fields, filter);
+
   if (!prefilter.ok) {
     return Promise.resolve(err(toVecstoreError(prefilter.error)));
   }
+
   return run(context.name, () => deleteMatches(context, prefilter.value));
 };
 
@@ -568,6 +617,7 @@ const queryIndex = async (
 ): Promise<ScoredRecord[]> => {
   const includeMetadata = query.includeMetadata ?? true;
   const includeVector = query.includeVector ?? false;
+
   const reply = await context.client.ft.search(
     context.name,
     knnQuery(prefilter, query.topK),
@@ -579,7 +629,9 @@ const queryIndex = async (
       SORTBY: { BY: REDIS_DISTANCE_FIELD, DIRECTION: "ASC" },
     }
   );
+
   const records: ScoredRecord[] = [];
+
   for (const document of reply.documents) {
     const record = toScoredRecord(
       document,
@@ -587,10 +639,12 @@ const queryIndex = async (
       includeMetadata,
       includeVector
     );
+
     if (record !== undefined) {
       records.push(record);
     }
   }
+
   return records;
 };
 
@@ -600,19 +654,24 @@ const fetchRecords = async (
   includeVector: boolean
 ): Promise<VectorRecord[]> => {
   const keys = ids.map((id) => `${context.prefix}${id}`);
+
   const batches = await mapBatches({
     action: (batch) => context.client.json.mGet(batch, ROOT_PATH),
     items: keys,
     size: WRITE_BATCH,
   });
+
   const stored = batches.flat();
   const records: VectorRecord[] = [];
+
   for (const [position, id] of ids.entries()) {
     const value = stored[position];
+
     if (value !== null && value !== undefined) {
       records.push(toVectorRecord(id, value, includeVector));
     }
   }
+
   return sortByIds(ids, records);
 };
 
@@ -622,9 +681,11 @@ const writeBatch = async (
   position: number
 ): Promise<void> => {
   const batch = batches[position];
+
   if (batch === undefined) {
     return;
   }
+
   await Promise.all(
     batch.map((record) =>
       context.client.json.set(
@@ -648,10 +709,12 @@ const metadataError = (
 ): string | undefined => {
   for (const record of records) {
     const message = redisMetadataError(record, fields);
+
     if (message !== undefined) {
       return message;
     }
   }
+
   return undefined;
 };
 
@@ -664,6 +727,7 @@ const createIndex = (
 ): VectorIndex => {
   const namespace = options.namespace ?? DEFAULT_NAMESPACE;
   const nameMessage = redisIndexNameError(name);
+
   const context: IndexContext = {
     client,
     fields,
@@ -671,15 +735,19 @@ const createIndex = (
     namespace,
     prefix: redisKeyPrefix(keyPrefix, name, namespace),
   };
+
   return {
     delete: (selector: DeleteSelector) => {
       if (nameMessage !== undefined) {
         return Promise.resolve(err(invalidArgument(PROVIDER, nameMessage)));
       }
+
       const rejected = deleteSelectorError(PROVIDER, selector);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       if ("ids" in selector) {
         return run(name, async () => {
           const keys = selector.ids.map((id) => `${context.prefix}${id}`);
@@ -690,6 +758,7 @@ const createIndex = (
           });
         });
       }
+
       return deleteByFilter(
         context,
         "filter" in selector ? selector.filter : undefined
@@ -700,10 +769,12 @@ const createIndex = (
       if (nameMessage !== undefined) {
         return Promise.resolve(err(invalidArgument(PROVIDER, nameMessage)));
       }
+
       return run(name, async () => {
         if (ids.length === 0) {
           return [];
         }
+
         return await fetchRecords(
           context,
           ids,
@@ -720,14 +791,19 @@ const createIndex = (
       if (nameMessage !== undefined) {
         return Promise.resolve(err(invalidArgument(PROVIDER, nameMessage)));
       }
+
       const invalidQuery = queryOptionsError(PROVIDER, query);
+
       if (invalidQuery !== undefined) {
         return Promise.resolve(err(invalidQuery));
       }
+
       const prefilter = scopeRedisFilter(namespace, fields, query.filter);
+
       if (!prefilter.ok) {
         return Promise.resolve(err(toVecstoreError(prefilter.error)));
       }
+
       return run(name, () => queryIndex(context, query, prefilter.value));
     },
 
@@ -735,14 +811,18 @@ const createIndex = (
       if (nameMessage !== undefined) {
         return Promise.resolve(err(invalidArgument(PROVIDER, nameMessage)));
       }
+
       const message = metadataError(records, fields);
+
       if (message !== undefined) {
         return Promise.resolve(err(invalidArgument(PROVIDER, message)));
       }
+
       return run(name, async () => {
         if (records.length === 0) {
           return;
         }
+
         await upsertRecords(context, records);
       });
     },
@@ -756,22 +836,29 @@ export const createRedisStore = <Client extends RedisClientLike>(
   const fields = options.metadataFields ?? [];
   const keyPrefix = options.keyPrefix ?? DEFAULT_KEY_PREFIX;
   const algorithm = options.algorithm ?? DEFAULT_ALGORITHM;
+
   return {
     createIndex: (spec: IndexSpec) => {
       const invalid = indexSpecError(PROVIDER, spec);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       const nameMessage = redisIndexNameError(spec.name);
+
       if (nameMessage !== undefined) {
         return Promise.resolve(err(invalidArgument(PROVIDER, nameMessage)));
       }
+
       for (const field of fields) {
         const message = redisFieldError(field);
+
         if (message !== undefined) {
           return Promise.resolve(err(invalidArgument(PROVIDER, message)));
         }
       }
+
       return run(spec.name, async () => {
         await client.ft.create(
           spec.name,
@@ -795,11 +882,13 @@ export const createRedisStore = <Client extends RedisClientLike>(
     listIndexes: () =>
       run("", async () => {
         const names: string[] = [];
+
         for (const name of await client.ft._list()) {
           if (isString(name)) {
             names.push(name);
           }
         }
+
         return names;
       }),
 
diff --git a/packages/vecstore-sdk/src/supabase/index.ts b/packages/vecstore-sdk/src/supabase/index.ts
index ae89554..6012c73 100644
--- a/packages/vecstore-sdk/src/supabase/index.ts
+++ b/packages/vecstore-sdk/src/supabase/index.ts
@@ -147,6 +147,7 @@ export const normalizeSupabaseError = (
   if (hasNoResponse(cause) || isFetchFailure(cause)) {
     return connection(PROVIDER, cause);
   }
+
   if (hasCode(cause)) {
     if (cause.code === MISSING_FUNCTION) {
       return unsupported(
@@ -155,10 +156,12 @@ export const normalizeSupabaseError = (
         `${context.fn} is not installed. ${INSTALL_HINT}.`
       );
     }
+
     if (JWT_CODES.has(cause.code)) {
       return unauthorized(PROVIDER, cause);
     }
   }
+
   return normalizePostgresError(PROVIDER, cause, context.index);
 };
 
@@ -176,9 +179,11 @@ const invoke = async (
   call: SupabaseCall
 ): Promise<readonly object[]> => {
   const response = await client.rpc(call.fn, call.args);
+
   if (response.error !== null && response.error !== undefined) {
     throw rpcFailure(response.error, response.status);
   }
+
   return response.data ?? [];
 };
 
@@ -218,12 +223,14 @@ const deleteCall = (
       fn: "vecstore_delete",
     };
   }
+
   if ("filter" in selector) {
     return {
       args: { ...scope, ids: null, match_filter: selector.filter },
       fn: "vecstore_delete",
     };
   }
+
   return {
     args: { ...scope, ids: null, match_filter: null },
     fn: "vecstore_delete",
@@ -239,6 +246,7 @@ const createIndexHandle = (
     ...target,
     match_namespace: options.namespace ?? DEFAULT_NAMESPACE,
   };
+
   const context = (fn: SupabaseCall["fn"]): CallContext => ({
     fn,
     index: target.index_name,
@@ -247,9 +255,11 @@ const createIndexHandle = (
   return {
     delete: (selector: DeleteSelector) => {
       const rejected = deleteSelectorError(PROVIDER, selector);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       return run(context("vecstore_delete"), async () => {
         await invoke(client, deleteCall(scope, selector));
       });
@@ -270,6 +280,7 @@ const createIndexHandle = (
           items: ids,
           size: FETCH_BATCH,
         });
+
         return sortByIds(ids, readRecords(pages.flat()));
       }),
 
@@ -279,12 +290,15 @@ const createIndexHandle = (
 
     query: (query: QueryOptions) => {
       const invalid = queryOptionsError(PROVIDER, query);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(context("vecstore_query"), async () => {
         const includeVector = query.includeVector ?? false;
         const includeMetadata = query.includeMetadata ?? true;
+
         const rows = await invoke(client, {
           args: {
             ...scope,
@@ -295,6 +309,7 @@ const createIndexHandle = (
           },
           fn: "vecstore_query",
         });
+
         return readScored(rows, includeMetadata, includeVector);
       });
     },
@@ -319,6 +334,7 @@ export const createSupabaseStore = <Client extends SupabaseClientLike>(
 ): VectorStore<Client> => {
   const { client } = options;
   const schema = options.schema ?? null;
+
   const target = (name: string): SupabaseIndexTarget => ({
     index_name: name,
     index_schema: schema,
@@ -328,9 +344,11 @@ export const createSupabaseStore = <Client extends SupabaseClientLike>(
     createIndex: (spec: IndexSpec) => {
       const invalid =
         indexSpecError(PROVIDER, spec) ?? indexNameError(PROVIDER, spec.name);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(
         { fn: "vecstore_create_index", index: spec.name },
         async () => {
@@ -360,6 +378,7 @@ export const createSupabaseStore = <Client extends SupabaseClientLike>(
           args: { index_schema: schema },
           fn: "vecstore_list_indexes",
         });
+
         return readNames(rows);
       }),
 
diff --git a/packages/vecstore-sdk/src/upstash/index.ts b/packages/vecstore-sdk/src/upstash/index.ts
index e6e824a..d1cb030 100644
--- a/packages/vecstore-sdk/src/upstash/index.ts
+++ b/packages/vecstore-sdk/src/upstash/index.ts
@@ -140,6 +140,7 @@ const SIMILARITIES: Record<Metric, UpstashSimilarity> = {
 const NOT_FOUND_PATTERN = /not found|does not exist|no such/iu;
 const ALREADY_EXISTS_PATTERN = /already exists/iu;
 const UNAUTHORIZED_PATTERN = /unauthorized|forbidden|invalid token/iu;
+
 const INVALID_ARGUMENT_PATTERN =
   /dimension|invalid|malformed|parse|must be|too large|exceed/iu;
 
@@ -159,6 +160,7 @@ const isConnectionFailure = (cause: unknown): boolean => {
   if (!(cause instanceof Error) || cause.name === "UpstashError") {
     return false;
   }
+
   return (
     isNetworkFailure(cause) ||
     cause.message === "fetch failed" ||
@@ -172,31 +174,41 @@ export const normalizeUpstashError = (
   index: string
 ): VecstoreError => {
   const name = cause instanceof Error ? cause.name : "";
+
   if (isUpstashFilterError(cause) || name === ARGUMENT_ERROR) {
     return invalidArgument(PROVIDER, errorMessage(cause), cause);
   }
+
   if (name === CONFLICT_ERROR) {
     return alreadyExists(PROVIDER, index, cause);
   }
+
   if (name === MISSING_ERROR) {
     return notFound(PROVIDER, index, cause);
   }
+
   if (isConnectionFailure(cause)) {
     return connection(PROVIDER, cause);
   }
+
   const message = errorMessage(cause);
+
   if (UNAUTHORIZED_PATTERN.test(message)) {
     return unauthorized(PROVIDER, cause);
   }
+
   if (NOT_FOUND_PATTERN.test(message)) {
     return notFound(PROVIDER, index, cause);
   }
+
   if (ALREADY_EXISTS_PATTERN.test(message)) {
     return alreadyExists(PROVIDER, index, cause);
   }
+
   if (INVALID_ARGUMENT_PATTERN.test(message)) {
     return invalidArgument(PROVIDER, message, cause);
   }
+
   return providerError(PROVIDER, cause);
 };
 
@@ -216,6 +228,7 @@ export const scopeUpstashFilter = (
   filter?: Filter
 ): string => {
   const scope = namespaceFilter(namespace ?? DEFAULT_NAMESPACE);
+
   return compileUpstashFilter(
     filter === undefined ? scope : and(scope, filter)
   );
@@ -230,6 +243,7 @@ const requireUrlSafe = (label: string, value: string): void => {
       `Upstash puts the ${label} straight into the request path, where "." and ".." are read as path segments instead of names. Received "${value}".`
     );
   }
+
   if (encodeURIComponent(value) !== value) {
     throw taggedError(
       ARGUMENT_ERROR,
@@ -245,9 +259,11 @@ const STORED_ID_PATTERN = /^[^/]+\/(?<length>\d+)\/(?<id>[\s\S]*)$/u;
 
 const looksLikeStoredId = (id: string): boolean => {
   const groups = STORED_ID_PATTERN.exec(id)?.groups;
+
   if (groups?.id === undefined || groups.length === undefined) {
     return false;
   }
+
   return groups.id.length === Number(groups.length);
 };
 
@@ -262,6 +278,7 @@ const collidingIdError = (
       );
     }
   }
+
   return undefined;
 };
 
@@ -270,12 +287,14 @@ const toStoredRecord = (
   record: VectorRecord
 ): UpstashRecordLike => {
   const entries: MetadataEntry[] = Object.entries(record.metadata ?? {});
+
   if (namespace !== DEFAULT_NAMESPACE) {
     entries.push(
       [UPSTASH_ID_KEY, record.id],
       [UPSTASH_NAMESPACE_KEY, namespace]
     );
   }
+
   return {
     id: toStoredId(namespace, record.id),
     metadata: Object.fromEntries(entries),
@@ -292,6 +311,7 @@ const readStoredId = (record: UpstashResultRecord): string => {
   const stored = metadataEntries(record).find(
     ([key]) => key === UPSTASH_ID_KEY
   );
+
   return stored !== undefined && isString(stored[1])
     ? stored[1]
     : String(record.id);
@@ -301,6 +321,7 @@ const readStoredNamespace = (record: UpstashResultRecord): string => {
   const stored = metadataEntries(record).find(
     ([key]) => key === UPSTASH_NAMESPACE_KEY
   );
+
   return stored !== undefined && isString(stored[1])
     ? stored[1]
     : DEFAULT_NAMESPACE;
@@ -341,6 +362,7 @@ const INDEX_LABEL = "index name";
 const scopeError = (namespace: string): VecstoreError | undefined => {
   try {
     scopeUpstashFilter(namespace);
+
     return undefined;
   } catch (error) {
     return invalidArgument(
@@ -353,6 +375,7 @@ const scopeError = (namespace: string): VecstoreError | undefined => {
 
 const metadataNamespace = (index: string): string => {
   requireUrlSafe(INDEX_LABEL, index);
+
   return index;
 };
 
@@ -365,6 +388,7 @@ const metadataDeletableIds = async (
   if (namespace !== DEFAULT_NAMESPACE) {
     return [...storedIds];
   }
+
   const responses = await mapBatches({
     action: (batch) =>
       client.fetch(batch, {
@@ -374,12 +398,15 @@ const metadataDeletableIds = async (
     items: storedIds,
     size: ID_BATCH,
   });
+
   const owned: string[] = [];
+
   for (const record of responses.flat()) {
     if (record !== null && readStoredNamespace(record) === DEFAULT_NAMESPACE) {
       owned.push(record.id);
     }
   }
+
   return owned;
 };
 
@@ -415,11 +442,15 @@ const nativeNamespace = (index: string, namespace: string): string => {
       `In native namespace mode the adapter joins the index name and the namespace with "${NAMESPACE_SEPARATOR}", so an index name cannot contain it. Received "${index}".`
     );
   }
+
   requireUrlSafe(INDEX_LABEL, index);
+
   if (namespace === DEFAULT_NAMESPACE) {
     return index;
   }
+
   requireUrlSafe("namespace", namespace);
+
   return `${index}${NAMESPACE_SEPARATOR}${namespace}`;
 };
 
@@ -461,12 +492,14 @@ const describeSpecMismatch = (
   if (info.dimension !== spec.dimension) {
     return `The Upstash index has dimension ${info.dimension}, but "${spec.name}" asked for ${spec.dimension}. Dimension is fixed when the Upstash index is created.`;
   }
+
   if (
     spec.metric !== undefined &&
     SIMILARITIES[spec.metric] !== info.similarityFunction
   ) {
     return `The Upstash index uses the ${info.similarityFunction} similarity function, but "${spec.name}" asked for ${spec.metric}. The similarity function is fixed when the Upstash index is created.`;
   }
+
   return undefined;
 };
 
@@ -483,60 +516,77 @@ const createIndex = (
   options: IndexOptions
 ): VectorIndex => {
   const namespace = options.namespace ?? DEFAULT_NAMESPACE;
+
   const scope = (): UpstashNamespaceOptions => ({
     namespace: layout.upstashNamespace(name, namespace),
   });
+
   const invalid = layout.namespaceError?.(namespace);
+
   const upsertRejection = (
     records: readonly VectorRecord[]
   ): VecstoreError | undefined => {
     if (invalid !== undefined) {
       return invalid;
     }
+
     const reserved = reservedKeyError(PROVIDER, records, layout.reservedKeys);
+
     if (reserved !== undefined) {
       return reserved;
     }
+
     if (layout.emulatesNamespace && namespace === DEFAULT_NAMESPACE) {
       return collidingIdError(records);
     }
+
     return undefined;
   };
+
   return {
     delete: (selector: DeleteSelector): VecResult<void> => {
       const rejected = invalid ?? deleteSelectorError(PROVIDER, selector);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       return run(name, async () => {
         if ("ids" in selector) {
           const stored = selector.ids.map((id) =>
             layout.storedId(namespace, id)
           );
+
           const ids = await layout.deletableIds(
             client,
             name,
             namespace,
             stored
           );
+
           if (ids.length === 0) {
             return;
           }
+
           const target = scope();
           await mapBatches({
             action: (batch) => client.delete({ ids: batch }, target),
             items: ids,
             size: ID_BATCH,
           });
+
           return;
         }
+
         if ("filter" in selector) {
           await client.delete(
             { filter: layout.compileFilter(namespace, selector.filter) },
             scope()
           );
+
           return;
         }
+
         await layout.clear(client, name, namespace);
       });
     },
@@ -548,10 +598,12 @@ const createIndex = (
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(name, async () => {
         const includeVectors = fetchOptions.includeVector ?? false;
         const target = scope();
         const storedIds = ids.map((id) => layout.storedId(namespace, id));
+
         const responses = await mapBatches({
           action: (batch) =>
             client.fetch(batch, {
@@ -562,7 +614,9 @@ const createIndex = (
           items: storedIds,
           size: ID_BATCH,
         });
+
         const records: VectorRecord[] = [];
+
         for (const record of responses.flat()) {
           if (record !== null && layout.holds(namespace, record)) {
             records.push({
@@ -572,6 +626,7 @@ const createIndex = (
             });
           }
         }
+
         return sortByIds(ids, records);
       });
     },
@@ -584,12 +639,16 @@ const createIndex = (
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       const invalidQuery = queryOptionsError(PROVIDER, query);
+
       if (invalidQuery !== undefined) {
         return Promise.resolve(err(invalidQuery));
       }
+
       return run(name, async () => {
         const includeMetadata = query.includeMetadata ?? true;
+
         const matches = await client.query(
           {
             filter:
@@ -603,6 +662,7 @@ const createIndex = (
           },
           scope()
         );
+
         return matches.map((match): ScoredRecord => ({
           id: layout.readId(match),
           metadata: includeMetadata ? layout.readMetadata(match) : undefined,
@@ -614,14 +674,18 @@ const createIndex = (
 
     upsert: (records): VecResult<void> => {
       const rejected = upsertRejection(records);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       return run(name, async () => {
         const target = scope();
+
         const stored = lastById(records).map((record) =>
           layout.storedRecord(namespace, record)
         );
+
         await mapBatches({
           action: (batch) => client.upsert(batch, target),
           items: stored,
@@ -637,19 +701,25 @@ export const createUpstashStore = <Client extends UpstashIndexLike>(
 ): VectorStore<Client> => {
   const { client } = options;
   const layout = LAYOUTS[options.namespaceMode ?? "metadata"];
+
   return {
     createIndex: (spec: IndexSpec) => {
       const invalid = indexSpecError(PROVIDER, spec);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(spec.name, async () => {
         const info = await client.info();
         const mismatch = describeSpecMismatch(spec, info);
+
         if (mismatch !== undefined) {
           throw taggedError(ARGUMENT_ERROR, mismatch);
         }
+
         const existing = await client.listNamespaces();
+
         if (existing.some((found) => layout.owns(spec.name, found))) {
           throw taggedError(
             CONFLICT_ERROR,
@@ -663,12 +733,14 @@ export const createUpstashStore = <Client extends UpstashIndexLike>(
       run(name, async () => {
         const existing = await client.listNamespaces();
         const owned = existing.filter((found) => layout.owns(name, found));
+
         if (owned.length === 0) {
           throw taggedError(
             MISSING_ERROR,
             `The Upstash index has no namespace for "${name}".`
           );
         }
+
         await mapBatches({
           action: (batch) => dropNamespaces(client, batch),
           items: owned,
@@ -684,6 +756,7 @@ export const createUpstashStore = <Client extends UpstashIndexLike>(
         const existing = await client.listNamespaces();
         const names = new Set(existing.map((found) => layout.indexOf(found)));
         names.delete(DEFAULT_NAMESPACE);
+
         return [...names];
       }),
 
diff --git a/packages/vecstore-sdk/src/vectorize/index.ts b/packages/vecstore-sdk/src/vectorize/index.ts
index 10ac6b4..410c635 100644
--- a/packages/vecstore-sdk/src/vectorize/index.ts
+++ b/packages/vecstore-sdk/src/vectorize/index.ts
@@ -150,9 +150,11 @@ const refineBadRequest = (
   if (ALREADY_EXISTS_PATTERN.test(message)) {
     return alreadyExists(PROVIDER, index, cause);
   }
+
   if (NOT_FOUND_PATTERN.test(message)) {
     return notFound(PROVIDER, index, cause);
   }
+
   return invalidArgument(PROVIDER, message, cause);
 };
 
@@ -161,24 +163,31 @@ export const normalizeVectorizeError = (
   index: string
 ): VecstoreError => {
   const message = errorMessage(cause);
+
   if (!isHttpFailure(cause)) {
     return CONNECTION_PATTERN.test(message)
       ? connection(PROVIDER, cause)
       : providerError(PROVIDER, cause);
   }
+
   const { status } = cause;
+
   if (status === HTTP_NOT_FOUND) {
     return notFound(PROVIDER, index, cause);
   }
+
   if (status === HTTP_CONFLICT) {
     return alreadyExists(PROVIDER, index, cause);
   }
+
   if (status === HTTP_UNAUTHORIZED || status === HTTP_FORBIDDEN) {
     return unauthorized(PROVIDER, cause);
   }
+
   if (status === HTTP_BAD_REQUEST || status === HTTP_UNPROCESSABLE) {
     return refineBadRequest(cause, index, message);
   }
+
   return providerError(PROVIDER, cause);
 };
 
@@ -194,6 +203,7 @@ const compileFilter = (
   filter: Filter
 ): Result<VectorizeFilter, VecstoreError> => {
   const compiled = compileVectorizeFilter(filter);
+
   return compiled.ok ? compiled : err(toVecstoreError(compiled.error));
 };
 
@@ -221,6 +231,7 @@ const readId = (record: VectorizeStoredVector): string => {
   const stored = metadataEntries(record).find(
     ([key]) => key === VECTORIZE_ID_KEY
   );
+
   return stored !== undefined && isString(stored[1]) ? stored[1] : record.id;
 };
 
@@ -237,6 +248,7 @@ const belongsToNamespace = (
   const reported = isString(record.namespace)
     ? record.namespace
     : DEFAULT_NAMESPACE;
+
   return reported === namespace;
 };
 
@@ -251,9 +263,11 @@ const nativeNamespace = (namespace: string): string | undefined =>
 const toLine = (namespace: string, record: VectorRecord): string => {
   const id = toVectorizeId(namespace, record.id);
   const entries: MetadataEntry[] = Object.entries(record.metadata ?? {});
+
   if (id !== record.id) {
     entries.push([VECTORIZE_ID_KEY, record.id]);
   }
+
   return JSON.stringify({
     id,
     metadata: Object.fromEntries(entries),
@@ -275,16 +289,20 @@ const deletableIds = async (
   if (namespace !== DEFAULT_NAMESPACE) {
     return [...ids];
   }
+
   const response = await indexes.getByIDs(name, {
     account_id: accountId,
     ids: [...ids],
   });
+
   const owned: string[] = [];
+
   for (const found of isUnknownArray(response) ? response : []) {
     if (isStoredVector(found) && belongsToNamespace(namespace, found)) {
       owned.push(found.id);
     }
   }
+
   return owned;
 };
 
@@ -296,12 +314,15 @@ const createIndex = (
 ): VectorIndex => {
   const namespace = options.namespace ?? DEFAULT_NAMESPACE;
   const invalid = namespaceError(PROVIDER, namespace);
+
   return {
     delete: (selector: DeleteSelector): VecResult<void> => {
       const rejected = invalid ?? deleteSelectorError(PROVIDER, selector);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       if ("ids" in selector) {
         return run(name, async () => {
           const stored = selector.ids.map((id) => toVectorizeId(namespace, id));
@@ -314,6 +335,7 @@ const createIndex = (
                 namespace,
                 batch
               );
+
               if (ids.length > 0) {
                 await indexes.deleteByIDs(name, { account_id: accountId, ids });
               }
@@ -323,11 +345,13 @@ const createIndex = (
           });
         });
       }
+
       if ("filter" in selector) {
         return Promise.resolve(
           err(unsupported(PROVIDER, "deleteByFilter", DELETE_BY_FILTER_MESSAGE))
         );
       }
+
       return Promise.resolve(
         err(unsupported(PROVIDER, "deleteAll", DELETE_ALL_MESSAGE))
       );
@@ -340,19 +364,24 @@ const createIndex = (
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(name, async () => {
         if (ids.length === 0) {
           return [];
         }
+
         const includeVector = fetchOptions.includeVector ?? false;
         const stored = ids.map((id) => toVectorizeId(namespace, id));
+
         const responses = await mapBatches({
           action: (batch) =>
             indexes.getByIDs(name, { account_id: accountId, ids: batch }),
           items: stored,
           size: ID_BATCH,
         });
+
         const records: VectorRecord[] = [];
+
         for (const response of responses) {
           for (const found of isUnknownArray(response) ? response : []) {
             if (isStoredVector(found) && belongsToNamespace(namespace, found)) {
@@ -364,6 +393,7 @@ const createIndex = (
             }
           }
         }
+
         return sortByIds(ids, records);
       });
     },
@@ -376,15 +406,20 @@ const createIndex = (
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       const invalidQuery = queryOptionsError(PROVIDER, query);
+
       if (invalidQuery !== undefined) {
         return Promise.resolve(err(invalidQuery));
       }
+
       const compiled =
         query.filter === undefined ? undefined : compileFilter(query.filter);
+
       if (compiled?.ok === false) {
         return Promise.resolve(compiled);
       }
+
       const params: VectorizeQueryParams = {
         account_id: accountId,
         filter: compiled?.ok === true ? compiled.value : undefined,
@@ -394,11 +429,13 @@ const createIndex = (
         topK: query.topK,
         vector: [...query.vector],
       };
+
       return run(name, async () => {
         const includeMetadata = query.includeMetadata ?? true;
         const includeVector = query.includeVector === true;
         const response = await indexes.query(name, params);
         const records: ScoredRecord[] = [];
+
         for (const match of response?.matches ?? []) {
           if (
             isScoredVector(match) &&
@@ -412,6 +449,7 @@ const createIndex = (
             });
           }
         }
+
         return records;
       });
     },
@@ -419,16 +457,20 @@ const createIndex = (
     upsert: (records): VecResult<void> => {
       const rejected =
         invalid ?? reservedKeyError(PROVIDER, records, RESERVED_KEYS);
+
       if (rejected !== undefined) {
         return Promise.resolve(err(rejected));
       }
+
       return run(name, async () => {
         if (records.length === 0) {
           return;
         }
+
         const lines = lastById(records).map((record) =>
           toLine(namespace, record)
         );
+
         await mapBatches({
           action: (batch) =>
             indexes.upsert(name, {
@@ -450,12 +492,15 @@ export const createVectorizeStore = <Client extends VectorizeClient>(
   const { accountId, client } = options;
   const { indexes } = client.vectorize;
   const metadataIndexes = options.metadataIndexes ?? [];
+
   return {
     createIndex: (spec: IndexSpec) => {
       const invalid = indexSpecError(PROVIDER, spec);
+
       if (invalid !== undefined) {
         return Promise.resolve(err(invalid));
       }
+
       return run(spec.name, async () => {
         await indexes.create({
           account_id: accountId,
@@ -465,6 +510,7 @@ export const createVectorizeStore = <Client extends VectorizeClient>(
           },
           name: spec.name,
         });
+
         try {
           await Promise.all(
             metadataIndexes.map((metadataIndex) =>
@@ -497,11 +543,13 @@ export const createVectorizeStore = <Client extends VectorizeClient>(
       run("", async () => {
         const page = await indexes.list({ account_id: accountId });
         const names: string[] = [];
+
         for (const index of page.result) {
           if (isString(index.name)) {
             names.push(index.name);
           }
         }
+
         return names;
       }),
 
diff --git a/packages/vecstore-sdk/test/adapters/pgvector.test.ts b/packages/vecstore-sdk/test/adapters/pgvector.test.ts
index cf21969..c59ac08 100644
--- a/packages/vecstore-sdk/test/adapters/pgvector.test.ts
+++ b/packages/vecstore-sdk/test/adapters/pgvector.test.ts
@@ -33,16 +33,21 @@ const fakeClient = (responses: object[][] = [], failures = 0) => {
   const calls: Call[] = [];
   const pending = [...responses];
   let remaining = failures;
+
   const client: PgQueryable = {
     query: (text, params) => {
       calls.push({ params, text });
+
       if (remaining > 0) {
         remaining -= 1;
+
         return Promise.reject(pgError("XX000"));
       }
+
       return Promise.resolve({ rows: pending.shift() ?? [] });
     },
   };
+
   return { calls, client };
 };
 
@@ -81,11 +86,13 @@ describe(createPgvectorStore, () => {
 
   test("createIndex creates the table, the HNSW index and a GIN index", async () => {
     const { client, calls } = fakeClient();
+
     const result = await createPgvectorStore({ client }).createIndex({
       dimension: 3,
       metric: "euclidean",
       name: "docs",
     });
+
     expect(result.ok).toBeTruthy();
     expect(calls).toHaveLength(1);
     const statement = calls[0]?.text ?? "";
@@ -107,10 +114,12 @@ describe(createPgvectorStore, () => {
 
   test("createIndex rejects a non-integer dimension before touching the database", async () => {
     const { client, calls } = fakeClient();
+
     const result = await createPgvectorStore({ client }).createIndex({
       dimension: 1.5,
       name: "docs",
     });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(calls).toHaveLength(0);
   });
@@ -118,10 +127,12 @@ describe(createPgvectorStore, () => {
   test("createIndex rejects a name longer than 49 bytes before touching the database", async () => {
     const { client, calls } = fakeClient();
     const store = createPgvectorStore({ client });
+
     const tooLong = await store.createIndex({
       dimension: 2,
       name: "a".repeat(50),
     });
+
     expect(!tooLong.ok && tooLong.error.kind).toBe("invalid_argument");
     expect(calls).toHaveLength(0);
 
@@ -129,16 +140,19 @@ describe(createPgvectorStore, () => {
       dimension: 2,
       name: "a".repeat(49),
     });
+
     expect(atLimit.ok).toBeTruthy();
     expect(calls).toHaveLength(1);
   });
 
   test("createIndex rejects a name that holds the dollar tag", async () => {
     const { client, calls } = fakeClient();
+
     const result = await createPgvectorStore({ client }).createIndex({
       dimension: 2,
       name: "x$vecstore$y",
     });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(calls).toHaveLength(0);
   });
@@ -223,13 +237,16 @@ describe(createPgvectorStore, () => {
         },
       ],
     ]);
+
     const store = createPgvectorStore({ client });
+
     const result = await store.index("docs").query({
       filter: and(eq("genre", "drama"), gt("year", 2000)),
       includeVector: true,
       topK: 3,
       vector: [1, 2],
     });
+
     expect(result).toStrictEqual({
       ok: true,
       value: [
@@ -259,9 +276,11 @@ describe(createPgvectorStore, () => {
 
   test("query rejects a non-positive topK before calling the provider", async () => {
     const { client, calls } = fakeClient();
+
     const result = await createPgvectorStore({ client })
       .index("docs")
       .query({ topK: 0, vector: [1] });
+
     expect(result.ok).toBeFalsy();
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(calls).toStrictEqual([]);
@@ -270,11 +289,13 @@ describe(createPgvectorStore, () => {
   test("query and delete reject a malformed filter or selector before calling the provider", async () => {
     const { client, calls } = fakeClient();
     const index = createPgvectorStore({ client }).index("docs");
+
     const queried = await index.query({
       filter: filterWithoutValue,
       topK: 1,
       vector: [1, 0, 0],
     });
+
     const filtered = await index.delete({ filter: filterWithoutValue });
     const emptied = await index.delete(emptySelector);
     expect([queried, filtered, emptied]).toMatchObject([
@@ -295,6 +316,7 @@ describe(createPgvectorStore, () => {
         },
       ],
     ]);
+
     await createPgvectorStore({ client })
       .index("docs")
       .query({ topK: 3, vector: [1, 2] });
@@ -317,6 +339,7 @@ describe(createPgvectorStore, () => {
           },
         ],
       ]);
+
       await createPgvectorStore({ client })
         .index("docs")
         .query({ topK: 3, vector: [1, 2] });
@@ -331,10 +354,12 @@ describe(createPgvectorStore, () => {
       indexdef:
         "CREATE INDEX docs_embedding_idx ON public.docs USING hnsw (embedding vector_ip_ops)",
     };
+
     const l2OpsRow = {
       indexdef:
         "CREATE INDEX docs_embedding_idx ON public.docs USING hnsw (embedding vector_l2_ops)",
     };
+
     const { client, calls } = fakeClient([
       [ipOpsRow],
       [],
@@ -343,6 +368,7 @@ describe(createPgvectorStore, () => {
       [l2OpsRow],
       [],
     ]);
+
     const store = createPgvectorStore({ client });
     await store.index("docs").query({ topK: 1, vector: [1, 2] });
     await store.deleteIndex("docs");
@@ -361,6 +387,7 @@ describe(createPgvectorStore, () => {
       indexdef:
         "CREATE INDEX docs_embedding_idx ON public.docs USING hnsw (embedding vector_l2_ops)",
     };
+
     const { client, calls } = fakeClient([[], [], [], [l2OpsRow], []]);
     const store = createPgvectorStore({ client });
     await store.index("docs").query({ topK: 1, vector: [1, 2] });
@@ -383,6 +410,7 @@ describe(createPgvectorStore, () => {
         },
       ],
     ]);
+
     const store = createPgvectorStore({ client });
     await Promise.all([
       store.index("docs").query({ topK: 1, vector: [1, 2] }),
@@ -409,6 +437,7 @@ describe(createPgvectorStore, () => {
         { id: "a", metadata: { n: 1 } },
       ],
     ]);
+
     const index = createPgvectorStore({ client }).index("docs");
     await expect(index.fetch(["a", "b"])).resolves.toStrictEqual({
       ok: true,
@@ -478,6 +507,7 @@ describe(createPgvectorStore, () => {
     const cause = new Error("Connection terminated due to connection timeout", {
       cause: new Error("socket hang up"),
     });
+
     expect(normalizePgvectorError(cause, "docs").kind).toBe("connection");
   });
 
diff --git a/packages/vecstore-sdk/test/adapters/pinecone.test.ts b/packages/vecstore-sdk/test/adapters/pinecone.test.ts
index 9e6d91d..7e67356 100644
--- a/packages/vecstore-sdk/test/adapters/pinecone.test.ts
+++ b/packages/vecstore-sdk/test/adapters/pinecone.test.ts
@@ -49,6 +49,7 @@ interface Recorded {
 
 const fakeClient = () => {
   const stored = new Map<string, PineconeRecordLike>();
+
   const recorded: Recorded = {
     createIndexes: [],
     deleteAlls: [],
@@ -56,27 +57,34 @@ const fakeClient = () => {
     queries: [],
     upserts: [],
   };
+
   const index: PineconeIndexLike = {
     deleteAll: (options) => {
       recorded.deleteAlls.push(options ?? {});
+
       return Promise.resolve();
     },
     deleteMany: (options) => {
       recorded.deleteManys.push(options);
+
       return Promise.resolve();
     },
     fetch: (options) => {
       const found: Record<string, PineconeRecordLike> = {};
+
       for (const id of options.ids) {
         const record = stored.get(id);
+
         if (record !== undefined) {
           found[id] = record;
         }
       }
+
       return Promise.resolve({ records: found });
     },
     query: (options) => {
       recorded.queries.push(options);
+
       return Promise.resolve({
         matches: [...stored.values()].map((record) => ({
           ...record,
@@ -86,21 +94,26 @@ const fakeClient = () => {
     },
     upsert: (options) => {
       recorded.upserts.push(options);
+
       for (const record of options.records) {
         stored.set(record.id, record);
       }
+
       return Promise.resolve();
     },
   };
+
   const client: PineconeClientLike = {
     createIndex: (options) => {
       recorded.createIndexes.push(options);
+
       return Promise.resolve();
     },
     deleteIndex: () => Promise.resolve(),
     index: () => index,
     listIndexes: () => Promise.resolve({ indexes: [{ name: "docs" }] }),
   };
+
   return { client, recorded };
 };
 
@@ -141,19 +154,23 @@ describe(createPineconeStore, () => {
 
   test("createIndex rejects a non-positive dimension before touching the client", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createPineconeStore({ client }).createIndex({
       dimension: 0,
       name: "docs",
     });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(recorded.createIndexes).toHaveLength(0);
   });
 
   test("namespaced verbs pass the namespace through", async () => {
     const { client, recorded } = fakeClient();
+
     const index = createPineconeStore({ client }).index("docs", {
       namespace: "tenant-a",
     });
+
     await index.upsert([
       { id: "doc-1", metadata: { genre: "drama" }, vector: [1, 2, 3] },
     ]);
@@ -225,10 +242,12 @@ describe(createPineconeStore, () => {
 
   test("delete by id splits into batches of 1000", async () => {
     const { client, recorded } = fakeClient();
+
     const ids: NonEmpty<string> = [
       "id-0",
       ...Array.from({ length: 1000 }, (_, i) => `id-${i + 1}`),
     ];
+
     await createPineconeStore({ client }).index("docs").delete({ ids });
     expect(recorded.deleteManys).toHaveLength(2);
     expect(recorded.deleteManys.map((call) => call.ids?.length)).toStrictEqual([
@@ -240,6 +259,7 @@ describe(createPineconeStore, () => {
     const index = createPineconeStore({ client: fakeClient().client }).index(
       "docs"
     );
+
     await index.upsert([
       { id: "b", vector: [2] },
       { id: "a", metadata: { n: 1 }, vector: [1] },
@@ -259,29 +279,36 @@ describe(createPineconeStore, () => {
     const index = createPineconeStore({ client: fakeClient().client }).index(
       "docs"
     );
+
     await index.upsert([{ id: "a", metadata: { n: 1 }, vector: [1] }]);
+
     const bare = await index.query({
       includeMetadata: false,
       topK: 1,
       vector: [1],
     });
+
     expect(bare.ok && bare.value[0]?.id).toBe("a");
     expect(bare.ok && bare.value[0]?.metadata).toBeUndefined();
     expect(bare.ok && bare.value[0]?.vector).toBeUndefined();
+
     const full = await index.query({
       includeVector: true,
       topK: 1,
       vector: [1],
     });
+
     expect(full.ok && full.value[0]?.metadata).toStrictEqual({ n: 1 });
     expect(full.ok && full.value[0]?.vector).toStrictEqual([1]);
   });
 
   test("query rejects a non-positive topK before calling the provider", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createPineconeStore({ client })
       .index("docs")
       .query({ topK: 0, vector: [1] });
+
     expect(result.ok).toBeFalsy();
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(recorded.queries).toStrictEqual([]);
@@ -290,11 +317,13 @@ describe(createPineconeStore, () => {
   test("query and delete reject a malformed filter or selector before calling the provider", async () => {
     const { client, recorded } = fakeClient();
     const index = createPineconeStore({ client }).index("docs");
+
     const queried = await index.query({
       filter: filterWithoutValue,
       topK: 1,
       vector: [1, 0, 0],
     });
+
     const filtered = await index.delete({ filter: filterWithoutValue });
     const emptied = await index.delete(emptySelector);
     expect([queried, filtered, emptied]).toMatchObject([
@@ -309,8 +338,10 @@ describe(createPineconeStore, () => {
 
   test("delete by filter on an index that rejects it is unsupported", async () => {
     const { client } = fakeClient();
+
     const message =
       "Serverless indexes do not support deleting with metadata filtering";
+
     const rejecting: PineconeClientLike = {
       ...client,
       index: (options) => ({
@@ -319,9 +350,11 @@ describe(createPineconeStore, () => {
           Promise.reject(namedError("PineconeBadRequestError", message)),
       }),
     };
+
     const result = await createPineconeStore({ client: rejecting })
       .index("docs")
       .delete({ filter: eq("genre", "drama") });
+
     expect(result).toStrictEqual({
       error: {
         feature: "deleteByFilter",
diff --git a/packages/vecstore-sdk/test/adapters/qdrant.test.ts b/packages/vecstore-sdk/test/adapters/qdrant.test.ts
index 30f2623..7667b03 100644
--- a/packages/vecstore-sdk/test/adapters/qdrant.test.ts
+++ b/packages/vecstore-sdk/test/adapters/qdrant.test.ts
@@ -48,6 +48,7 @@ interface Recorded {
 
 const fakeClient = () => {
   const stored: QdrantStoredPoint[] = [];
+
   const recorded: Recorded = {
     createCollections: [],
     deletedCollections: [],
@@ -57,21 +58,26 @@ const fakeClient = () => {
     retrieves: [],
     upserts: [],
   };
+
   const client: QdrantClientLike = {
     createCollection: (name, args) => {
       recorded.createCollections.push({ name, vectors: args.vectors });
+
       return Promise.resolve(true);
     },
     createPayloadIndex: (_name, args) => {
       recorded.payloadIndexes.push(args.field_name);
+
       return Promise.resolve({ status: "completed" });
     },
     delete: (_name, args) => {
       recorded.deletes.push(args);
+
       return Promise.resolve({ status: "completed" });
     },
     deleteCollection: (name) => {
       recorded.deletedCollections.push(name);
+
       return Promise.resolve(true);
     },
     getCollections: () =>
@@ -82,14 +88,17 @@ const fakeClient = () => {
         limit: args.limit,
         query: args.query,
       });
+
       const points: QdrantScoredPoint[] = stored.map((point) => ({
         ...point,
         score: 0.5,
       }));
+
       return Promise.resolve({ points });
     },
     retrieve: (_name, args) => {
       recorded.retrieves.push(args.ids.length);
+
       return Promise.resolve(
         stored.filter((point) => args.ids.includes(point.id))
       );
@@ -97,9 +106,11 @@ const fakeClient = () => {
     upsert: (_name, args) => {
       recorded.upserts.push(args.points);
       stored.push(...args.points);
+
       return Promise.resolve({ status: "completed" });
     },
   };
+
   return { client, recorded };
 };
 
@@ -132,11 +143,13 @@ describe(createQdrantStore, () => {
 
   test("createIndex creates the collection and a tenant index", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createQdrantStore({ client }).createIndex({
       dimension: 3,
       metric: "dot",
       name: "docs",
     });
+
     expect(result.ok).toBeTruthy();
     expect(recorded.createCollections).toStrictEqual([
       { name: "docs", vectors: { distance: "Dot", size: 3 } },
@@ -146,14 +159,17 @@ describe(createQdrantStore, () => {
 
   test("createIndex drops the collection when the tenant index cannot be created", async () => {
     const { client, recorded } = fakeClient();
+
     const failing: QdrantClientLike = {
       ...client,
       createPayloadIndex: () => Promise.reject(httpFailure(400)),
     };
+
     const result = await createQdrantStore({ client: failing }).createIndex({
       dimension: 3,
       name: "docs",
     });
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "qdrant" },
       ok: false,
@@ -163,10 +179,12 @@ describe(createQdrantStore, () => {
 
   test("createIndex rejects a non-positive dimension before touching the client", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createQdrantStore({ client }).createIndex({
       dimension: 0,
       name: "docs",
     });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(recorded.createCollections).toHaveLength(0);
   });
@@ -181,10 +199,12 @@ describe(createQdrantStore, () => {
 
   test("deleteIndex reports a collection the server does not hold", async () => {
     const { client } = fakeClient();
+
     const empty: QdrantClientLike = {
       ...client,
       deleteCollection: () => Promise.resolve(false),
     };
+
     await expect(
       createQdrantStore({ client: empty }).deleteIndex("missing")
     ).resolves.toMatchObject({
@@ -221,6 +241,7 @@ describe(createQdrantStore, () => {
       "vecstore-sdk/qdrant/point-id",
       "tenant-a/5/doc-1"
     );
+
     expect(foreign).toBe("73f328fb-a7ca-81f7-a86a-06f5a7282959");
     const { client, recorded } = fakeClient();
     await createQdrantStore({ client })
@@ -234,6 +255,7 @@ describe(createQdrantStore, () => {
   test("upsert never runs more than four batches at once", async () => {
     const { client } = fakeClient();
     const inFlight = { current: 0, max: 0 };
+
     const tracked: QdrantClientLike = {
       ...client,
       upsert: async (name, args) => {
@@ -241,14 +263,18 @@ describe(createQdrantStore, () => {
         inFlight.max = Math.max(inFlight.max, inFlight.current);
         await Promise.resolve();
         inFlight.current -= 1;
+
         return client.upsert(name, args);
       },
     };
+
     const index = createQdrantStore({ client: tracked }).index("docs");
+
     const records = Array.from({ length: 4001 }, (_, i) => ({
       id: `doc-${i}`,
       vector: [i, 0, 0],
     }));
+
     await index.upsert(records);
     expect(inFlight.max).toBe(4);
   });
@@ -271,6 +297,7 @@ describe(createQdrantStore, () => {
       "docs",
       { namespace: "tenant-a" }
     );
+
     await index.upsert([
       { id: "doc-1", metadata: { genre: "drama" }, vector: [1, 2, 3] },
     ]);
@@ -296,10 +323,12 @@ describe(createQdrantStore, () => {
   test("upsert, fetch, and delete split into batches", async () => {
     const { client, recorded } = fakeClient();
     const index = createQdrantStore({ client }).index("docs");
+
     const records = Array.from({ length: 501 }, (_, i) => ({
       id: `doc-${i}`,
       vector: [i, 0, 0],
     }));
+
     await index.upsert(records);
     expect(recorded.upserts).toHaveLength(2);
     expect(recorded.upserts[0]).toHaveLength(500);
@@ -309,6 +338,7 @@ describe(createQdrantStore, () => {
       "doc-0",
       ...Array.from({ length: 1000 }, (_, i) => `doc-${i + 1}`),
     ];
+
     await index.fetch(ids);
     expect(recorded.retrieves).toStrictEqual([1000, 1]);
 
@@ -337,9 +367,11 @@ describe(createQdrantStore, () => {
 
   test("query rejects a non-positive topK before calling the provider", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createQdrantStore({ client })
       .index("docs")
       .query({ topK: 0, vector: [1] });
+
     expect(result.ok).toBeFalsy();
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(recorded.queries).toStrictEqual([]);
@@ -348,11 +380,13 @@ describe(createQdrantStore, () => {
   test("query and delete reject a malformed filter or selector before calling the provider", async () => {
     const { client, recorded } = fakeClient();
     const index = createQdrantStore({ client }).index("docs");
+
     const queried = await index.query({
       filter: filterWithoutValue,
       topK: 1,
       vector: [1, 0, 0],
     });
+
     const filtered = await index.delete({ filter: filterWithoutValue });
     const emptied = await index.delete(emptySelector);
     expect([queried, filtered, emptied]).toMatchObject([
@@ -417,9 +451,11 @@ describe(createQdrantStore, () => {
 
   test("a namespace containing a slash is rejected before the request", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createQdrantStore({ client })
       .index("docs", { namespace: "a/3" })
       .upsert([{ id: "b", vector: [1] }]);
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "qdrant" },
       ok: false,
@@ -429,9 +465,11 @@ describe(createQdrantStore, () => {
 
   test("upsert rejects a record that sets a reserved payload key", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createQdrantStore({ client })
       .index("docs")
       .upsert([{ id: "x", metadata: { _id: "other" }, vector: [1] }]);
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "qdrant" },
       ok: false,
@@ -448,6 +486,7 @@ describe(createQdrantStore, () => {
       data: { status: { error: "bad vector" } },
       status: 400,
     });
+
     expect(normalizeQdrantError(cause, "docs")).toStrictEqual({
       cause,
       kind: "invalid_argument",
@@ -490,13 +529,16 @@ describe(createQdrantStore, () => {
 
   test("a failing call returns an error result instead of throwing", async () => {
     const cause = httpFailure(404);
+
     const failing: QdrantClientLike = {
       ...fakeClient().client,
       upsert: () => Promise.reject(cause),
     };
+
     const result = await createQdrantStore({ client: failing })
       .index("missing")
       .upsert([{ id: "x", vector: [1] }]);
+
     expect(result).toStrictEqual({
       error: {
         cause,
diff --git a/packages/vecstore-sdk/test/adapters/redis.test.ts b/packages/vecstore-sdk/test/adapters/redis.test.ts
index 6946d06..79b9f04 100644
--- a/packages/vecstore-sdk/test/adapters/redis.test.ts
+++ b/packages/vecstore-sdk/test/adapters/redis.test.ts
@@ -47,6 +47,7 @@ const jsonEntry = (value: RedisJsonValue, key: string): RedisJsonValue => {
   if (!isObjectLike(value) || Array.isArray(value) || value instanceof Date) {
     return null;
   }
+
   return Object.entries(value).find(([name]) => name === key)?.[1] ?? null;
 };
 
@@ -58,14 +59,17 @@ const documentValue = (
   options?: RedisSearchOptions
 ): object => {
   const fields: [string, string][] = [];
+
   for (const field of options?.RETURN ?? []) {
     if (field === "vector_distance") {
       fields.push([field, "0.25"]);
       continue;
     }
+
     const key = field.replace("$.", "");
     fields.push([field, JSON.stringify(jsonEntry(stored, key))]);
   }
+
   return Object.fromEntries(fields);
 };
 
@@ -76,6 +80,7 @@ const createFakeClient = (): FakeClient => {
   const unlinked: string[][] = [];
   const mGetCalls: string[][] = [];
   const indexes = new Set<string>();
+
   const client: RedisClientLike = {
     ft: {
       _list: () => Promise.resolve([...indexes]),
@@ -83,26 +88,33 @@ const createFakeClient = (): FakeClient => {
         if (indexes.has(index)) {
           return Promise.reject(new Error("Index already exists"));
         }
+
         indexes.add(index);
         creates.push({ index, options, schema });
+
         return Promise.resolve("OK");
       },
       dropIndex: (index, options) => {
         if (!indexes.delete(index)) {
           return Promise.reject(new Error("Unknown index name"));
         }
+
         if (options?.DD === true) {
           documents.clear();
         }
+
         return Promise.resolve("OK");
       },
       search: (index, query, options): Promise<RedisSearchReply> => {
         searches.push({ index, options, query });
         const namespace = namespaceOf(query);
+
         const matched = [...documents].filter(
           ([, stored]) => jsonEntry(stored, "namespace") === namespace
         );
+
         const size = options?.LIMIT?.size ?? matched.length;
+
         return Promise.resolve({
           documents: matched.slice(0, size).map(([id, stored]) => ({
             id,
@@ -115,22 +127,27 @@ const createFakeClient = (): FakeClient => {
     json: {
       mGet: (keys) => {
         mGetCalls.push(keys);
+
         return Promise.resolve(keys.map((key) => documents.get(key) ?? null));
       },
       set: (key, _path, json) => {
         documents.set(key, json);
+
         return Promise.resolve("OK");
       },
     },
     unlink: (keys) => {
       unlinked.push(keys);
       let removed = 0;
+
       for (const key of keys) {
         removed += documents.delete(key) ? 1 : 0;
       }
+
       return Promise.resolve(removed);
     },
   };
+
   return { client, creates, documents, mGetCalls, searches, unlinked };
 };
 
@@ -146,13 +163,16 @@ const metadataFields = [
 
 const setup = async (namespace = NAMESPACE) => {
   const fake = createFakeClient();
+
   const store = createRedisStore({
     client: fake.client,
     metadataFields: [...metadataFields],
   });
+
   await store.createIndex({ dimension: DIMENSION, name: INDEX });
   const index = store.index(INDEX, { namespace });
   await index.upsert(records);
+
   return { fake, index, store };
 };
 
@@ -160,6 +180,7 @@ const unwrap = <T>(result: { ok: true; value: T } | { ok: false }): T => {
   if (!result.ok) {
     throw new Error("expected a value");
   }
+
   return result.value;
 };
 
@@ -216,24 +237,29 @@ describe(createRedisStore, () => {
 
   test("createIndex rejects a non-positive dimension before touching the client", async () => {
     const fake = createFakeClient();
+
     const result = await createRedisStore({ client: fake.client }).createIndex({
       dimension: 0,
       name: INDEX,
     });
+
     expect(result).toMatchObject({ error: { kind: "invalid_argument" } });
     expect(fake.creates).toHaveLength(0);
   });
 
   test("createIndex refuses a metadata field the adapter keeps", async () => {
     const fake = createFakeClient();
+
     const store = createRedisStore({
       client: fake.client,
       metadataFields: [{ field: "vector", type: "tag" }],
     });
+
     const result = await store.createIndex({
       dimension: DIMENSION,
       name: INDEX,
     });
+
     expect(result).toMatchObject({ error: { kind: "invalid_argument" } });
     expect(fake.creates).toHaveLength(0);
   });
@@ -254,9 +280,11 @@ describe(createRedisStore, () => {
   test("upsert refuses metadata the schema has no room for", async () => {
     const { fake, index } = await setup();
     const written = fake.documents.size;
+
     const result = await index.upsert([
       { id: "doc-c", metadata: { year: "1999" }, vector: [0, 0, 1] },
     ]);
+
     expect(result).toMatchObject({ error: { kind: "invalid_argument" } });
     expect(fake.documents.size).toBe(written);
   });
@@ -288,11 +316,13 @@ describe(createRedisStore, () => {
 
   test("query and delete reject a malformed filter or selector before calling the provider", async () => {
     const { fake, index } = await setup();
+
     const queried = await index.query({
       filter: filterWithoutValue,
       topK: 1,
       vector: [1, 0, 0],
     });
+
     const filtered = await index.delete({ filter: filterWithoutValue });
     const emptied = await index.delete(emptySelector);
     expect([queried, filtered, emptied]).toMatchObject([
@@ -308,10 +338,12 @@ describe(createRedisStore, () => {
     const { fake, index } = await setup();
     await index.query({ topK: 1, vector: [1, 0.5, 0] });
     const blob = fake.searches[0]?.options?.PARAMS?.BLOB;
+
     const floats =
       blob instanceof Buffer
         ? new Float32Array(blob.buffer, blob.byteOffset, DIMENSION)
         : new Float32Array();
+
     expect([...floats]).toStrictEqual([1, 0.5, 0]);
   });
 
@@ -326,20 +358,24 @@ describe(createRedisStore, () => {
 
   test("query returns the vector when asked", async () => {
     const { fake, index } = await setup();
+
     const matches = unwrap(
       await index.query({ includeVector: true, topK: 1, vector: [1, 0, 0] })
     );
+
     expect(fake.searches[0]?.options?.RETURN).toContain("$.vector");
     expect(matches[0]?.vector).toStrictEqual([1, 0, 0]);
   });
 
   test("query rejects a filter Redis cannot run before it sends one", async () => {
     const { fake, index } = await setup();
+
     const result = await index.query({
       filter: eq("director", "lynch"),
       topK: 1,
       vector: [1, 0, 0],
     });
+
     expect(result).toMatchObject({ error: { kind: "invalid_argument" } });
     expect(fake.searches).toHaveLength(0);
   });
@@ -368,10 +404,12 @@ describe(createRedisStore, () => {
 
   test("fetch splits JSON.MGET into batches of 500", async () => {
     const { fake, index } = await setup();
+
     const ids: NonEmpty<string> = [
       "r0",
       ...Array.from({ length: 500 }, (_, i) => `r${i + 1}`),
     ];
+
     await index.fetch(ids);
     expect(fake.mGetCalls).toHaveLength(2);
     expect(fake.mGetCalls[0]).toHaveLength(500);
@@ -389,22 +427,26 @@ describe(createRedisStore, () => {
 
   test("upsert writes in bounded batches", async () => {
     const { fake, index } = await setup();
+
     const result = await index.upsert(
       Array.from({ length: 1001 }, (_, i) => ({
         id: `r${i}`,
         vector: [i, 0, 0],
       }))
     );
+
     expect(result.ok).toBeTruthy();
     expect(fake.documents.size).toBe(1003);
   });
 
   test("delete by id unlinks in bounded batches", async () => {
     const { fake, index } = await setup();
+
     const ids: NonEmpty<string> = [
       "r0",
       ...Array.from({ length: 1000 }, (_, i) => `r${i + 1}`),
     ];
+
     await index.delete({ ids });
     expect(fake.unlinked).toHaveLength(3);
     expect(fake.unlinked[0]).toHaveLength(500);
@@ -430,6 +472,7 @@ describe(createRedisStore, () => {
     });
     await index.delete({ all: true });
     expect(fake.documents.has(foreign)).toBe(true);
+
     for (const keys of fake.unlinked) {
       expect(keys).not.toContain(foreign);
     }
@@ -438,6 +481,7 @@ describe(createRedisStore, () => {
   test("delete all stops paging when a full page unlinks nothing", async () => {
     const { fake, index } = await setup();
     await index.delete({ ids: ["doc-a", "doc-b"] });
+
     for (let i = 0; i < DELETE_PAGE; i += 1) {
       const foreign = `vecstore:docs:v2:tenant-a:x${i}`;
       fake.documents.set(foreign, {
@@ -446,6 +490,7 @@ describe(createRedisStore, () => {
         vector: [0, 0, 1],
       });
     }
+
     const startingSize = fake.documents.size;
     const result = await index.delete({ all: true });
     expect(result.ok).toBeTruthy();
@@ -456,15 +501,19 @@ describe(createRedisStore, () => {
   test("an index name with a colon is rejected before any request", async () => {
     const fake = createFakeClient();
     const store = createRedisStore({ client: fake.client });
+
     const created = await store.createIndex({
       dimension: DIMENSION,
       name: "docs:v2",
     });
+
     expect(created).toMatchObject({ error: { kind: "invalid_argument" } });
     expect(fake.creates).toHaveLength(0);
+
     const upserted = await store
       .index("docs:v2")
       .upsert([{ id: "a", vector: [0, 0, 1] }]);
+
     expect(upserted).toMatchObject({ error: { kind: "invalid_argument" } });
     expect(fake.documents.size).toBe(0);
   });
diff --git a/packages/vecstore-sdk/test/adapters/supabase.test.ts b/packages/vecstore-sdk/test/adapters/supabase.test.ts
index 27fc2c2..27c80be 100644
--- a/packages/vecstore-sdk/test/adapters/supabase.test.ts
+++ b/packages/vecstore-sdk/test/adapters/supabase.test.ts
@@ -43,12 +43,15 @@ const fakeClient = (options: FakeOptions = {}) => {
   const calls: Call[] = [];
   const pending = [...(options.responses ?? [])];
   const error = options.error ?? null;
+
   const client: SupabaseClientLike = {
     rpc: (fn, args) => {
       calls.push({ args, fn });
+
       return Promise.resolve({ data: pending.shift() ?? [], error });
     },
   };
+
   return { calls, client };
 };
 
@@ -91,11 +94,13 @@ describe(createSupabaseStore, () => {
 
   test("createIndex passes the dimension and metric to the SQL function", async () => {
     const { client, calls } = fakeClient();
+
     const result = await createSupabaseStore({ client }).createIndex({
       dimension: 3,
       metric: "euclidean",
       name: "docs",
     });
+
     expect(result.ok).toBeTruthy();
     expect(calls).toStrictEqual([
       {
@@ -112,20 +117,24 @@ describe(createSupabaseStore, () => {
 
   test("createIndex rejects a non-integer dimension before calling the database", async () => {
     const { client, calls } = fakeClient();
+
     const result = await createSupabaseStore({ client }).createIndex({
       dimension: 1.5,
       name: "docs",
     });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(calls).toHaveLength(0);
   });
 
   test("createIndex rejects a name longer than 49 bytes before calling the database", async () => {
     const { client, calls } = fakeClient();
+
     const result = await createSupabaseStore({ client }).createIndex({
       dimension: 3,
       name: "a".repeat(50),
     });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(calls).toHaveLength(0);
   });
@@ -134,6 +143,7 @@ describe(createSupabaseStore, () => {
     const { client, calls } = fakeClient({
       responses: [[], [{ name: "docs" }]],
     });
+
     const store = createSupabaseStore({ client, schema: "vec" });
     await store.deleteIndex("docs");
     await expect(store.listIndexes()).resolves.toStrictEqual({
@@ -183,8 +193,10 @@ describe(createSupabaseStore, () => {
       ]);
     expect(calls).toHaveLength(1);
     const [call] = calls;
+
     const records =
       call !== undefined && "records" in call.args ? call.args.records : [];
+
     expect(records).toStrictEqual([
       { embedding: "[2]", id: "a", metadata: {} },
     ]);
@@ -225,10 +237,13 @@ describe(createSupabaseStore, () => {
         ],
       ],
     });
+
     const filter = and(eq("genre", "drama"), gt("year", 2000));
+
     const result = await createSupabaseStore({ client })
       .index("docs")
       .query({ filter, includeVector: true, topK: 3, vector: [1, 2] });
+
     expect(result).toStrictEqual({
       ok: true,
       value: [
@@ -256,9 +271,11 @@ describe(createSupabaseStore, () => {
 
   test("query rejects a non-positive topK before calling the provider", async () => {
     const { client, calls } = fakeClient();
+
     const result = await createSupabaseStore({ client })
       .index("docs")
       .query({ topK: 0, vector: [1] });
+
     expect(result.ok).toBeFalsy();
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(calls).toStrictEqual([]);
@@ -267,11 +284,13 @@ describe(createSupabaseStore, () => {
   test("query and delete reject a malformed filter or selector before calling the provider", async () => {
     const { client, calls } = fakeClient();
     const index = createSupabaseStore({ client }).index("docs");
+
     const queried = await index.query({
       filter: filterWithoutValue,
       topK: 1,
       vector: [1, 0, 0],
     });
+
     const filtered = await index.delete({ filter: filterWithoutValue });
     const emptied = await index.delete(emptySelector);
     expect([queried, filtered, emptied]).toMatchObject([
@@ -291,6 +310,7 @@ describe(createSupabaseStore, () => {
         ],
       ],
     });
+
     const index = createSupabaseStore({ client }).index("docs");
     await expect(index.fetch(["a", "b"])).resolves.toStrictEqual({
       ok: true,
@@ -319,14 +339,18 @@ describe(createSupabaseStore, () => {
 
   test("fetch splits ids into batches of 500", async () => {
     const { client, calls } = fakeClient();
+
     const ids = Array.from(
       { length: 1200 },
       (_, position) => `doc-${position}`
     );
+
     await createSupabaseStore({ client }).index("docs").fetch(ids);
+
     const sizes = calls.map((call) =>
       "ids" in call.args ? call.args.ids?.length : undefined
     );
+
     expect(calls.map((call) => call.fn)).toStrictEqual([
       "vecstore_fetch",
       "vecstore_fetch",
@@ -378,12 +402,14 @@ describe(createSupabaseStore, () => {
 
   test("an RPC error becomes a result rather than a throw", async () => {
     const { client } = fakeClient({ error: rpcError("42P01") });
+
     const result = await createSupabaseStore({ client })
       .index("docs")
       .query({
         topK: 1,
         vector: [1],
       });
+
     expect(!result.ok && result.error.kind).toBe("not_found");
     expect(!result.ok && result.error.provider).toBe("supabase");
   });
@@ -400,6 +426,7 @@ describe(createSupabaseStore, () => {
       fn: "vecstore_query",
       index: "docs",
     });
+
     expect(error.kind).toBe(kind);
   });
 
@@ -408,6 +435,7 @@ describe(createSupabaseStore, () => {
       fn: "vecstore_query",
       index: "docs",
     });
+
     expect(error.kind).toBe("connection");
   });
 
@@ -417,6 +445,7 @@ describe(createSupabaseStore, () => {
       const result = await createSupabaseStore({
         client: statusClient(message, 0),
       }).listIndexes();
+
       expect(result).toMatchObject({
         error: { kind: "connection", provider: "supabase" },
         ok: false,
@@ -433,6 +462,7 @@ describe(createSupabaseStore, () => {
       const result = await createSupabaseStore({
         client: statusClient("TypeError: x is not a function", status),
       }).listIndexes();
+
       expect(!result.ok && result.error.kind).toBe("provider");
     }
   );
@@ -441,6 +471,7 @@ describe(createSupabaseStore, () => {
     const result = await createSupabaseStore({
       client: statusClient("TypeError: x is not a function"),
     }).listIndexes();
+
     expect(!result.ok && result.error.kind).toBe("provider");
   });
 
@@ -448,6 +479,7 @@ describe(createSupabaseStore, () => {
     const result = await createSupabaseStore({
       client: statusClient("TypeError: Failed to fetch"),
     }).listIndexes();
+
     expect(!result.ok && result.error.kind).toBe("connection");
   });
 
@@ -455,6 +487,7 @@ describe(createSupabaseStore, () => {
     const result = await createSupabaseStore({
       client: statusClient("TypeError: getaddrinfo ENOTFOUND x", 0),
     }).listIndexes();
+
     expect(!result.ok && result.error.cause).toMatchObject({
       cause: { message: "TypeError: getaddrinfo ENOTFOUND x" },
     });
@@ -467,6 +500,7 @@ describe(createSupabaseStore, () => {
         fn: "vecstore_query",
         index: "docs",
       });
+
       expect(error.kind).toBe("connection");
     }
   );
@@ -478,6 +512,7 @@ describe(createSupabaseStore, () => {
         fn: "vecstore_query",
         index: "docs",
       });
+
       expect(error.kind).toBe("connection");
     }
   );
@@ -490,6 +525,7 @@ describe(createSupabaseStore, () => {
       fn: "vecstore_query",
       index: "docs",
     });
+
     expect(error.kind).toBe("provider");
   });
 
@@ -498,6 +534,7 @@ describe(createSupabaseStore, () => {
       fn: "vecstore_query",
       index: "docs",
     });
+
     expect(error.kind).toBe("provider");
   });
 
@@ -506,6 +543,7 @@ describe(createSupabaseStore, () => {
       fn: "vecstore_query",
       index: "docs",
     });
+
     expect(error.kind).toBe("provider");
   });
 });
diff --git a/packages/vecstore-sdk/test/adapters/upstash.test.ts b/packages/vecstore-sdk/test/adapters/upstash.test.ts
index 05a3ba9..78dda3f 100644
--- a/packages/vecstore-sdk/test/adapters/upstash.test.ts
+++ b/packages/vecstore-sdk/test/adapters/upstash.test.ts
@@ -60,6 +60,7 @@ interface Recorded {
 
 const fakeClient = (info: UpstashInfo = DEFAULT_INFO) => {
   const stored = new Map<string, Map<string, UpstashRecordLike>>();
+
   const recorded: Recorded = {
     deletedNamespaces: [],
     deletes: [],
@@ -68,43 +69,55 @@ const fakeClient = (info: UpstashInfo = DEFAULT_INFO) => {
     resets: [],
     upserts: [],
   };
+
   const bucket = (namespace = ""): Map<string, UpstashRecordLike> => {
     const found = stored.get(namespace);
+
     if (found !== undefined) {
       return found;
     }
+
     const created = new Map<string, UpstashRecordLike>();
     stored.set(namespace, created);
+
     return created;
   };
+
   const client: UpstashIndexLike = {
     delete: (args, options: UpstashNamespaceOptions = {}) => {
       recorded.deletes.push({ args, namespace: options.namespace });
+
       if ("ids" in args) {
         for (const id of args.ids) {
           bucket(options.namespace).delete(id);
         }
       }
+
       return Promise.resolve({ deleted: 0 });
     },
     deleteNamespace: (namespace: string) => {
       recorded.deletedNamespaces.push(namespace);
       stored.delete(namespace);
+
       return Promise.resolve("Success");
     },
     fetch: (ids, options = {}) => {
       recorded.fetches.push({ ids, namespace: options.namespace });
       const records = bucket(options.namespace);
+
       return Promise.resolve(
         ids.map((id): UpstashStoredRecord | null => {
           const record = records.get(id);
+
           if (record === undefined) {
             return null;
           }
+
           const found: UpstashStoredRecord = {
             id: record.id,
             metadata: record.metadata,
           };
+
           return options.includeVectors === true
             ? { ...found, vector: record.vector }
             : found;
@@ -115,6 +128,7 @@ const fakeClient = (info: UpstashInfo = DEFAULT_INFO) => {
     listNamespaces: () => Promise.resolve([...stored.keys()]),
     query: (args, options: UpstashNamespaceOptions = {}) => {
       recorded.queries.push({ ...args, namespace: options.namespace });
+
       return Promise.resolve(
         [...bucket(options.namespace).values()].map((record) => {
           const match: UpstashScoredRecord = {
@@ -122,6 +136,7 @@ const fakeClient = (info: UpstashInfo = DEFAULT_INFO) => {
             metadata: record.metadata,
             score: 0.9,
           };
+
           return args.includeVectors === true
             ? { ...match, vector: record.vector }
             : match;
@@ -131,16 +146,20 @@ const fakeClient = (info: UpstashInfo = DEFAULT_INFO) => {
     reset: (options: UpstashNamespaceOptions = {}) => {
       recorded.resets.push(options.namespace);
       bucket(options.namespace).clear();
+
       return Promise.resolve("Success");
     },
     upsert: (records, options: UpstashNamespaceOptions = {}) => {
       recorded.upserts.push({ namespace: options.namespace, records });
+
       for (const record of records) {
         bucket(options.namespace).set(record.id, record);
       }
+
       return Promise.resolve("Success");
     },
   };
+
   return { client, recorded };
 };
 
@@ -190,15 +209,18 @@ describe(createUpstashStore, () => {
       token: "test-token",
       url: "https://example.upstash.io",
     });
+
     const raw: Index = createUpstashStore({ client }).raw;
     expect(raw).toBe(client);
   });
 
   test("an index is an Upstash namespace and the namespace is metadata", async () => {
     const { client, recorded } = fakeClient();
+
     const index = createUpstashStore({ client }).index("docs", {
       namespace: "tenant-a",
     });
+
     await index.upsert([
       { id: "doc-1", metadata: { genre: "drama" }, vector: [1, 2, 3] },
     ]);
@@ -222,9 +244,11 @@ describe(createUpstashStore, () => {
 
   test("query rejects a non-positive topK before calling the provider", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createUpstashStore({ client })
       .index("docs")
       .query({ topK: 0, vector: [1] });
+
     expect(result.ok).toBeFalsy();
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(recorded.queries).toStrictEqual([]);
@@ -233,11 +257,13 @@ describe(createUpstashStore, () => {
   test("query and delete reject a malformed filter or selector before calling the provider", async () => {
     const { client, recorded } = fakeClient();
     const index = createUpstashStore({ client }).index("docs");
+
     const queried = await index.query({
       filter: filterWithoutValue,
       topK: 1,
       vector: [1, 0, 0],
     });
+
     const filtered = await index.delete({ filter: filterWithoutValue });
     const emptied = await index.delete(emptySelector);
     expect([queried, filtered, emptied]).toMatchObject([
@@ -256,11 +282,13 @@ describe(createUpstashStore, () => {
     await index.upsert([
       { id: "doc-1", metadata: { genre: "drama" }, vector: [1, 2, 3] },
     ]);
+
     const result = await index.query({
       filter: eq("genre", "drama"),
       topK: 2,
       vector: [1, 2, 3],
     });
+
     expect(recorded.queries).toStrictEqual([
       {
         filter: "(_namespace = 'tenant-a' AND genre = 'drama')",
@@ -311,9 +339,11 @@ describe(createUpstashStore, () => {
 
   test("fetch and delete by id address the namespaced stored id", async () => {
     const { client, recorded } = fakeClient();
+
     const index = createUpstashStore({ client }).index("docs", {
       namespace: "tenant-a",
     });
+
     await index.upsert([
       { id: "b", vector: [2, 0, 0] },
       { id: "a", metadata: { n: 1 }, vector: [1, 0, 0] },
@@ -350,35 +380,45 @@ describe(createUpstashStore, () => {
   test("a default namespace upsert rejects an id shaped like a namespaced stored id", async () => {
     const { client, recorded } = fakeClient();
     const index = createUpstashStore({ client }).index("docs");
+
     const result = await index.upsert([
       { id: "tenant-a/5/doc-1", vector: [1, 2, 3] },
     ]);
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(recorded.upserts).toStrictEqual([]);
     const rejected = await index.upsert([{ id: "docs/3/abc", vector: [1] }]);
     expect(!rejected.ok && rejected.error.kind).toBe("invalid_argument");
+
     const lengthMismatch = await index.upsert([
       { id: "docs/4/abc", vector: [1] },
     ]);
+
     expect(lengthMismatch.ok).toBeTruthy();
+
     const noLengthSegment = await index.upsert([
       { id: "docs/abc", vector: [1] },
     ]);
+
     expect(noLengthSegment.ok).toBeTruthy();
+
     const emptyNamespace = await index.upsert([
       { id: "/5/doc-1", vector: [1] },
     ]);
+
     expect(emptyNamespace.ok).toBeTruthy();
   });
 
   test("a default namespace upsert in native mode accepts any id", async () => {
     const { client } = fakeClient();
+
     const result = await createUpstashStore({
       client,
       namespaceMode: "native",
     })
       .index("docs")
       .upsert([{ id: "tenant-a/5/doc-1", vector: [1, 2, 3] }]);
+
     expect(result.ok).toBeTruthy();
   });
 
@@ -408,9 +448,11 @@ describe(createUpstashStore, () => {
 
   test("delete by filter scopes the filter to the namespace", async () => {
     const { client, recorded } = fakeClient();
+
     const index = createUpstashStore({ client }).index("docs", {
       namespace: "tenant-a",
     });
+
     await index.delete({ filter: eq("genre", "drama") });
     expect(recorded.deletes).toStrictEqual([
       {
@@ -444,41 +486,49 @@ describe(createUpstashStore, () => {
 
   test("createIndex rejects a non-positive dimension before touching the client", async () => {
     const { client } = fakeClient();
+
     const result = await createUpstashStore({ client }).createIndex({
       dimension: 0,
       name: "docs",
     });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
   });
 
   test("createIndex rejects a dimension the Upstash index cannot serve", async () => {
     const { client } = fakeClient();
+
     const result = await createUpstashStore({ client }).createIndex({
       dimension: 1536,
       name: "docs",
     });
+
     expect(result.ok).toBe(false);
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
   });
 
   test("createIndex rejects a metric the Upstash index cannot serve", async () => {
     const { client } = fakeClient();
+
     const result = await createUpstashStore({ client }).createIndex({
       dimension: 3,
       metric: "dot",
       name: "docs",
     });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
   });
 
   test("createIndex accepts a matching spec and reports an existing namespace", async () => {
     const { client } = fakeClient();
     const store = createUpstashStore({ client });
+
     const created = await store.createIndex({
       dimension: 3,
       metric: "cosine",
       name: "docs",
     });
+
     expect(created.ok).toBe(true);
     await store.index("docs").upsert([{ id: "a", vector: [1, 0, 0] }]);
     const again = await store.createIndex({ dimension: 3, name: "docs" });
@@ -503,9 +553,11 @@ describe(createUpstashStore, () => {
 
   test("metadata mode rejects a namespace containing a slash", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createUpstashStore({ client })
       .index("docs", { namespace: "a/3" })
       .upsert([{ id: "b", vector: [1] }]);
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "upstash" },
       ok: false,
@@ -564,9 +616,11 @@ describe(createUpstashStore, () => {
     "metadata mode %s rejects the namespace %j before calling the provider",
     async (_verb, namespace, call) => {
       const { client, recorded } = fakeClient();
+
       const result = await call(
         createUpstashStore({ client }).index("docs", { namespace })
       );
+
       expect(result).toMatchObject({
         error: { kind: "invalid_argument", provider: "upstash" },
         ok: false,
@@ -606,9 +660,11 @@ describe(createUpstashStore, () => {
 
   test("metadata mode rejects a record that sets a reserved metadata key", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await createUpstashStore({ client })
       .index("docs")
       .upsert([{ id: "x", metadata: { _id: "other" }, vector: [1] }]);
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "upstash" },
       ok: false,
@@ -618,9 +674,11 @@ describe(createUpstashStore, () => {
 
   test("a filter Upstash cannot express is an invalid argument", async () => {
     const { client } = fakeClient();
+
     const result = await createUpstashStore({ client })
       .index("docs")
       .query({ filter: eq("my field", 1), topK: 1, vector: [1, 0, 0] });
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
   });
 
@@ -678,6 +736,7 @@ describe(createUpstashStore, () => {
     const cause = Object.assign(upstashError("fetch failed"), {
       code: "ECONNREFUSED",
     });
+
     expect(normalizeUpstashError(cause, "docs").kind).toBe("provider");
   });
 });
@@ -796,21 +855,27 @@ describe("upstash native namespaces", () => {
 
   test("a name Upstash cannot put in a path is an invalid argument", async () => {
     const { client } = fakeClient();
+
     const separator = await nativeStore(client)
       .index("docs~v2")
       .upsert([{ id: "a", vector: [1, 0, 0] }]);
+
     expect(!separator.ok && separator.error.kind).toBe("invalid_argument");
+
     const escaped = await nativeStore(client)
       .index("docs", { namespace: "tenant a" })
       .upsert([{ id: "a", vector: [1, 0, 0] }]);
+
     expect(!escaped.ok && escaped.error.kind).toBe("invalid_argument");
   });
 
   test("native mode rejects a namespace containing a slash too", async () => {
     const { client, recorded } = fakeClient();
+
     const result = await nativeStore(client)
       .index("docs", { namespace: "a/3" })
       .upsert([{ id: "b", vector: [1] }]);
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "upstash" },
       ok: false,
@@ -832,9 +897,11 @@ describe("upstash native namespaces", () => {
 
   test("metadata mode rejects an index name that needs URL escaping", async () => {
     const { client } = fakeClient();
+
     const result = await createUpstashStore({ client })
       .index("docs/v2")
       .upsert([{ id: "a", vector: [1, 0, 0] }]);
+
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
   });
 
@@ -854,9 +921,11 @@ describe("upstash native namespaces", () => {
     "native mode %s rejects the namespace %j before calling the provider",
     async (_verb, namespace, call) => {
       const { client, recorded } = fakeClient();
+
       const result = await call(
         nativeStore(client).index("docs", { namespace })
       );
+
       expect(result).toMatchObject({
         error: { kind: "invalid_argument", provider: "upstash" },
         ok: false,
diff --git a/packages/vecstore-sdk/test/adapters/vectorize.test.ts b/packages/vecstore-sdk/test/adapters/vectorize.test.ts
index ce53a4d..9c2ff45 100644
--- a/packages/vecstore-sdk/test/adapters/vectorize.test.ts
+++ b/packages/vecstore-sdk/test/adapters/vectorize.test.ts
@@ -64,9 +64,11 @@ const statusError = (status: number, message: string) =>
 
 const bodyOf = async (init: RequestInit): Promise<string> => {
   const { body } = init;
+
   if (body === undefined || body === null) {
     return "";
   }
+
   return await new Response(body).text();
 };
 
@@ -80,17 +82,21 @@ const upsertAction = (body: string, stored: Store): Response => {
     const vector = parse<StoredVector>(line);
     stored.set(vector.id, vector);
   }
+
   return envelope({ mutationId: "mutation" });
 };
 
 const getByIdsAction = (body: string, stored: Store): Response => {
   const found: StoredVector[] = [];
+
   for (const id of parse<IdsBody>(body).ids) {
     const vector = stored.get(id);
+
     if (vector !== undefined) {
       found.push(vector);
     }
   }
+
   return envelope(found);
 };
 
@@ -98,12 +104,14 @@ const deleteByIdsAction = (body: string, stored: Store): Response => {
   for (const id of parse<IdsBody>(body).ids) {
     stored.delete(id);
   }
+
   return envelope({ mutationId: "mutation" });
 };
 
 const queryAction = (body: string, stored: Store): Response => {
   const request = parse<QueryBody>(body);
   const matches = [];
+
   for (const vector of stored.values()) {
     if (
       request.namespace === undefined ||
@@ -118,6 +126,7 @@ const queryAction = (body: string, stored: Store): Response => {
       });
     }
   }
+
   return envelope({ count: matches.length, matches });
 };
 
@@ -126,15 +135,19 @@ const runAction = (action: string, body: string, stored: Store): Response => {
     case "upsert": {
       return upsertAction(body, stored);
     }
+
     case "get_by_ids": {
       return getByIdsAction(body, stored);
     }
+
     case "delete_by_ids": {
       return deleteByIdsAction(body, stored);
     }
+
     case "query": {
       return queryAction(body, stored);
     }
+
     default: {
       return envelope({ mutationId: "mutation" });
     }
@@ -153,14 +166,17 @@ const fakeCloudflare = (failing: ReadonlySet<string> = new Set()) => {
     const segments = tail.split("/").filter((part) => part !== "");
     calls.push({ body, method, path: tail, search });
     const [indexName, action] = segments;
+
     if (indexName === undefined) {
       return method === "GET"
         ? envelope([{ name: "docs" }, { name: "logs" }])
         : envelope({ name: parse<CreateBody>(body).name });
     }
+
     if (action === undefined) {
       return envelope(null);
     }
+
     if (failing.has(action)) {
       return Response.json(
         {
@@ -172,6 +188,7 @@ const fakeCloudflare = (failing: ReadonlySet<string> = new Set()) => {
         { status: 400 }
       );
     }
+
     return runAction(action, body, stored);
   };
 
@@ -179,16 +196,19 @@ const fakeCloudflare = (failing: ReadonlySet<string> = new Set()) => {
     apiToken: "test-token",
     fetch: (input, init) => handle(String(input), init ?? {}),
   });
+
   return { calls, client, stored };
 };
 
 const bodiesFor = (calls: readonly Call[], suffix: string): string[] => {
   const bodies: string[] = [];
+
   for (const call of calls) {
     if (call.path.endsWith(suffix)) {
       bodies.push(call.body);
     }
   }
+
   return bodies;
 };
 
@@ -225,10 +245,12 @@ describe(toVectorizeId, () => {
 describe(createVectorizeStore, () => {
   test("the Cloudflare client comes back as raw", () => {
     const { client } = fakeCloudflare();
+
     const raw: Cloudflare = createVectorizeStore({
       accountId: ACCOUNT_ID,
       client,
     }).raw;
+
     expect(raw).toBe(client);
   });
 
@@ -253,10 +275,12 @@ describe(createVectorizeStore, () => {
 
   test("createIndex rejects a non-positive dimension before touching the client", async () => {
     const { calls, client } = fakeCloudflare();
+
     const result = await createVectorizeStore({
       accountId: ACCOUNT_ID,
       client,
     }).createIndex({ dimension: 0, name: "docs" });
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "vectorize" },
       ok: false,
@@ -266,21 +290,26 @@ describe(createVectorizeStore, () => {
 
   test("createIndex deletes the index when a metadata index cannot be created", async () => {
     const { calls, client } = fakeCloudflare(new Set(["metadata_index"]));
+
     const result = await createVectorizeStore({
       accountId: ACCOUNT_ID,
       client,
       metadataIndexes: [{ property: "genre", type: "string" }],
     }).createIndex({ dimension: 3, name: "docs" });
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "vectorize" },
       ok: false,
     });
+
     const metadataIndexCall = calls.findIndex((call) =>
       call.path.endsWith("/metadata_index/create")
     );
+
     const deleteCall = calls.findIndex(
       (call) => call.method === "DELETE" && call.path === "/docs"
     );
+
     expect(metadataIndexCall).toBeGreaterThanOrEqual(0);
     expect(deleteCall).toBeGreaterThan(metadataIndexCall);
   });
@@ -391,18 +420,22 @@ describe(createVectorizeStore, () => {
 
   test("query scopes by namespace and returns the original id", async () => {
     const { calls, client } = fakeCloudflare();
+
     const docs = createVectorizeStore({ accountId: ACCOUNT_ID, client }).index(
       "docs",
       { namespace: "tenant-a" }
     );
+
     await docs.upsert([
       { id: "doc-1", metadata: { genre: "drama" }, vector: [1, 2, 3] },
     ]);
+
     const result = await docs.query({
       filter: eq("genre", "drama"),
       topK: 5,
       vector: [1, 2, 3],
     });
+
     const [sent] = bodiesFor(calls, "/query");
     expect(parse<QueryBody>(sent ?? "{}")).toStrictEqual({
       filter: { genre: { $eq: "drama" } },
@@ -425,9 +458,11 @@ describe(createVectorizeStore, () => {
       .index("docs", { namespace: "tenant-a" })
       .upsert([{ id: "doc-a", vector: [1, 2, 3] }]);
     await store.index("docs").upsert([{ id: "doc-root", vector: [1, 2, 3] }]);
+
     const result = await store
       .index("docs")
       .query({ topK: 5, vector: [1, 2, 3] });
+
     expect(result.ok && result.value.map((match) => match.id)).toStrictEqual([
       "doc-root",
     ]);
@@ -435,9 +470,11 @@ describe(createVectorizeStore, () => {
 
   test("query rejects a non-positive topK before calling the provider", async () => {
     const { calls, client } = fakeCloudflare();
+
     const result = await createVectorizeStore({ accountId: ACCOUNT_ID, client })
       .index("docs")
       .query({ topK: 0, vector: [1] });
+
     expect(result.ok).toBeFalsy();
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
     expect(bodiesFor(calls, "/query")).toStrictEqual([]);
@@ -445,14 +482,17 @@ describe(createVectorizeStore, () => {
 
   test("query and delete reject a malformed filter or selector before calling the provider", async () => {
     const { calls, client } = fakeCloudflare();
+
     const index = createVectorizeStore({ accountId: ACCOUNT_ID, client }).index(
       "docs"
     );
+
     const queried = await index.query({
       filter: filterWithoutValue,
       topK: 1,
       vector: [1, 0, 0],
     });
+
     const filtered = await index.delete({ filter: filterWithoutValue });
     const emptied = await index.delete(emptySelector);
     expect([queried, filtered, emptied]).toMatchObject([
@@ -465,9 +505,11 @@ describe(createVectorizeStore, () => {
 
   test("a filter Vectorize cannot express is reported before the request", async () => {
     const { calls, client } = fakeCloudflare();
+
     const result = await createVectorizeStore({ accountId: ACCOUNT_ID, client })
       .index("docs")
       .query({ filter: or(eq("a", 1), eq("b", 2)), topK: 5, vector: [1] });
+
     expect(result).toMatchObject({
       error: {
         feature: "orFilter",
@@ -481,10 +523,12 @@ describe(createVectorizeStore, () => {
 
   test("fetch preserves request order and drops the vector unless asked", async () => {
     const { client } = fakeCloudflare();
+
     const docs = createVectorizeStore({ accountId: ACCOUNT_ID, client }).index(
       "docs",
       { namespace: "tenant-a" }
     );
+
     await docs.upsert([
       { id: "doc-b", vector: [2] },
       { id: "doc-a", metadata: { n: 1 }, vector: [1] },
@@ -546,9 +590,11 @@ describe(createVectorizeStore, () => {
 
   test("delete by filter and delete all are unsupported", async () => {
     const { client } = fakeCloudflare();
+
     const docs = createVectorizeStore({ accountId: ACCOUNT_ID, client }).index(
       "docs"
     );
+
     await expect(docs.delete({ filter: eq("a", 1) })).resolves.toMatchObject({
       error: { feature: "deleteByFilter", kind: "unsupported" },
       ok: false,
@@ -561,9 +607,11 @@ describe(createVectorizeStore, () => {
 
   test("a namespace containing a slash is rejected before the request", async () => {
     const { calls, client } = fakeCloudflare();
+
     const result = await createVectorizeStore({ accountId: ACCOUNT_ID, client })
       .index("docs", { namespace: "a/3" })
       .upsert([{ id: "b", vector: [1] }]);
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "vectorize" },
       ok: false,
@@ -573,9 +621,11 @@ describe(createVectorizeStore, () => {
 
   test("upsert rejects a record that sets a reserved metadata key", async () => {
     const { calls, client } = fakeCloudflare();
+
     const result = await createVectorizeStore({ accountId: ACCOUNT_ID, client })
       .index("docs")
       .upsert([{ id: "x", metadata: { _id: "other" }, vector: [1] }]);
+
     expect(result).toMatchObject({
       error: { kind: "invalid_argument", provider: "vectorize" },
       ok: false,
diff --git a/packages/vecstore-sdk/test/filter/pgvector.test.ts b/packages/vecstore-sdk/test/filter/pgvector.test.ts
index 719a7d0..6b8adec 100644
--- a/packages/vecstore-sdk/test/filter/pgvector.test.ts
+++ b/packages/vecstore-sdk/test/filter/pgvector.test.ts
@@ -68,6 +68,7 @@ describe(compilePgvectorFilter, () => {
     const sql = compilePgvectorFilter(
       and(eq("a", 1), or(eq("b", 2), not(eq("c", 3))))
     );
+
     expect(sql.text).toBe(
       "((metadata @> $1::jsonb OR metadata @> $2::jsonb) AND ((metadata @> $3::jsonb OR metadata @> $4::jsonb) OR NOT ((metadata @> $5::jsonb OR metadata @> $6::jsonb))))"
     );
diff --git a/packages/vecstore-sdk/test/filter/qdrant.test.ts b/packages/vecstore-sdk/test/filter/qdrant.test.ts
index 67c8b13..ad1ede3 100644
--- a/packages/vecstore-sdk/test/filter/qdrant.test.ts
+++ b/packages/vecstore-sdk/test/filter/qdrant.test.ts
@@ -102,6 +102,7 @@ describe(compileQdrantFilter, () => {
       eq("genre", "drama"),
       or(gt("year", 2000), not(exists("year")))
     );
+
     expect(compileQdrantFilter(filter)).toStrictEqual({
       must: [
         { key: "genre", match: { value: "drama" } },
@@ -119,6 +120,7 @@ describe(compileQdrantFilter, () => {
     const native: Schemas["Filter"] = compileQdrantFilter(
       and(eq("a", 1), isIn("b", ["x"]), not(exists("c")))
     );
+
     expect(native.must).toHaveLength(3);
   });
 });
diff --git a/packages/vecstore-sdk/test/filter/redis.test.ts b/packages/vecstore-sdk/test/filter/redis.test.ts
index f376d92..28c7482 100644
--- a/packages/vecstore-sdk/test/filter/redis.test.ts
+++ b/packages/vecstore-sdk/test/filter/redis.test.ts
@@ -27,9 +27,11 @@ const fields: RedisMetadataField[] = [
 
 const compiled = (filter: Filter): string => {
   const result = compileRedisFilter(filter, fields);
+
   if (!result.ok) {
     throw new Error(result.error.message);
   }
+
   return result.value;
 };
 
diff --git a/packages/vecstore-sdk/test/filter/upstash.test.ts b/packages/vecstore-sdk/test/filter/upstash.test.ts
index ee59b86..2126372 100644
--- a/packages/vecstore-sdk/test/filter/upstash.test.ts
+++ b/packages/vecstore-sdk/test/filter/upstash.test.ts
@@ -93,6 +93,7 @@ describe(compileUpstashFilter, () => {
 
   test.each(rejected)("%s is rejected", (_name, filter) => {
     expect(() => compileUpstashFilter(filter)).toThrow();
+
     try {
       compileUpstashFilter(filter);
     } catch (error) {
diff --git a/packages/vecstore-sdk/test/filter/vectorize.test.ts b/packages/vecstore-sdk/test/filter/vectorize.test.ts
index 2848b10..ee7b134 100644
--- a/packages/vecstore-sdk/test/filter/vectorize.test.ts
+++ b/packages/vecstore-sdk/test/filter/vectorize.test.ts
@@ -20,9 +20,11 @@ import { compileVectorizeFilter } from "../../src/filter/vectorize";
 
 const compiled = (filter: Filter): VectorizeFilter => {
   const result = compileVectorizeFilter(filter);
+
   if (!result.ok) {
     throw new Error(result.error.message);
   }
+
   return result.value;
 };
 
diff --git a/packages/vecstore-sdk/test/internal.test.ts b/packages/vecstore-sdk/test/internal.test.ts
index 336c772..48101f9 100644
--- a/packages/vecstore-sdk/test/internal.test.ts
+++ b/packages/vecstore-sdk/test/internal.test.ts
@@ -151,6 +151,7 @@ describe("metadata entries", () => {
       e: { nested: 1 },
       f: null,
     }).filter(isMetadataEntry);
+
     expect(metadataFromEntries(entries, new Set(["_id"]))).toStrictEqual({
       a: "x",
       b: 1,
@@ -166,11 +167,13 @@ describe(reservedKeyError, () => {
     expect(
       reservedKeyError("qdrant", [{ id: "a", vector: [1] }], reserved)
     ).toBeUndefined();
+
     const error = reservedKeyError(
       "qdrant",
       [{ id: "a", metadata: { _id: "other" }, vector: [1] }],
       reserved
     );
+
     expect(error?.kind).toBe("invalid_argument");
     expect(error?.message).toContain('Record "a"');
   });
@@ -265,6 +268,7 @@ describe(mapBatches, () => {
       items: [1, 2, 3, 4, 5],
       size: 2,
     });
+
     expect(results).toStrictEqual([3, 7, 5]);
   });
 
@@ -277,6 +281,7 @@ describe(mapBatches, () => {
         inFlight.max = Math.max(inFlight.max, inFlight.current);
         await Promise.resolve();
         inFlight.current -= 1;
+
         return batch;
       },
       concurrency: 4,
@@ -289,14 +294,17 @@ describe(mapBatches, () => {
   test("resolves to an empty array without calling the action", async () => {
     const counter = { calls: 0 };
     const empty: number[] = [];
+
     const results = await mapBatches({
       action: (batch) => {
         counter.calls += 1;
+
         return Promise.resolve(batch);
       },
       items: empty,
       size: 2,
     });
+
     expect(results).toStrictEqual([]);
     expect(counter.calls).toBe(0);
   });
@@ -309,9 +317,11 @@ describe(mapBatches, () => {
         action: async (batch) => {
           started.push(...batch);
           await Promise.resolve();
+
           if (batch.includes(1)) {
             throw new Error("batch failed");
           }
+
           return batch;
         },
         concurrency: 2,
@@ -333,6 +343,7 @@ describe(mapBatches, () => {
           if (item === 0) {
             throw new Error("first batch failed");
           }
+
           await sleep(10);
           finished.push(item ?? -1);
         },
diff --git a/packages/vecstore-sdk/test/live/conformance.ts b/packages/vecstore-sdk/test/live/conformance.ts
index 2eb63dc..aa982b0 100644
--- a/packages/vecstore-sdk/test/live/conformance.ts
+++ b/packages/vecstore-sdk/test/live/conformance.ts
@@ -53,6 +53,7 @@ const unwrap = <T>(
   if (!result.ok) {
     throw new Error(JSON.stringify(result.error));
   }
+
   return result.value;
 };
 
@@ -64,12 +65,15 @@ const waitForRecords = async (
   attempt = 0
 ): Promise<void> => {
   const found = unwrap(await index.fetch(["doc-a", "doc-d"]));
+
   if (found.length === 2) {
     return;
   }
+
   if (attempt >= READY_RETRIES) {
     throw new Error("records did not become visible in time");
   }
+
   await sleep(READY_DELAY_MS);
   await waitForRecords(index, attempt + 1);
 };
@@ -79,6 +83,7 @@ export const setupLive = (
   options: LiveOptions = {}
 ): (() => Live) => {
   let live: Live | null = null;
+
   const [before, after] = options.isolated
     ? [beforeEach, afterEach]
     : [beforeAll, afterAll];
@@ -86,8 +91,10 @@ export const setupLive = (
   before(async () => {
     const store = makeStore();
     indexSequence += 1;
+
     const indexName =
       options.indexName?.() ?? `vecstore_live_${Date.now()}_${indexSequence}`;
+
     unwrap(await store.createIndex({ dimension: DIMENSION, name: indexName }));
     const index = store.index(indexName, { namespace: NAMESPACE });
     unwrap(await index.upsert(records));
@@ -103,14 +110,13 @@ export const setupLive = (
     }
   });
 
-  const current = (): Live => {
+  return function current(): Live {
     if (live === null) {
       throw new Error("live store is not ready");
     }
+
     return live;
   };
-
-  return current;
 };
 
 export const containsCases: LiveCase[] = [
@@ -124,6 +130,7 @@ export const containsCases: LiveCase[] = [
           vector: vectors.d,
         })
       );
+
       expect(idsOf(matches)).toStrictEqual(["doc-d"]);
     },
   ],
@@ -137,6 +144,7 @@ export const containsCases: LiveCase[] = [
           vector: vectors.d,
         })
       );
+
       expect(idsOf(matches)).toStrictEqual(["doc-d"]);
     },
   ],
@@ -150,6 +158,7 @@ export const containsCases: LiveCase[] = [
           vector: vectors.a,
         })
       );
+
       expect(idsOf(matches).toSorted()).toStrictEqual([
         "doc-a",
         "doc-b",
@@ -170,6 +179,7 @@ export const negatedRangeCases: LiveCase[] = [
           vector: vectors.a,
         })
       );
+
       expect(idsOf(matches).toSorted()).toStrictEqual(["doc-a", "doc-d"]);
     },
   ],
@@ -177,9 +187,11 @@ export const negatedRangeCases: LiveCase[] = [
     "delete by not around a range removes a record that lacks the field",
     async ({ index }) => {
       unwrap(await index.delete({ filter: not(gt("year", 2000)) }));
+
       const found = unwrap(
         await index.fetch(["doc-a", "doc-b", "doc-c", "doc-d"])
       );
+
       expect(idsOf(found)).toStrictEqual(["doc-b", "doc-c"]);
     },
   ],
@@ -209,6 +221,7 @@ export const liveCases: LiveCase[] = [
           vector: vectors.a,
         })
       );
+
       expect(idsOf(matches)).toStrictEqual(["doc-b"]);
     },
   ],
@@ -222,6 +235,7 @@ export const liveCases: LiveCase[] = [
           vector: vectors.d,
         })
       );
+
       expect(idsOf(matches)).toStrictEqual(["doc-d"]);
     },
   ],
@@ -236,6 +250,7 @@ export const liveCases: LiveCase[] = [
           vector: vectors.d,
         })
       );
+
       expect(match?.metadata).toStrictEqual({
         genre: "horror",
         tags: ["x", "y"],
@@ -254,9 +269,11 @@ export const liveCases: LiveCase[] = [
     "another namespace sees nothing",
     async ({ store, indexName }) => {
       const other = store.index(indexName, { namespace: "tenant-b" });
+
       const matches = unwrap(
         await other.query({ topK: 10, vector: vectors.a })
       );
+
       expect(matches).toStrictEqual([]);
     },
   ],
@@ -273,9 +290,11 @@ export const liveCases: LiveCase[] = [
     async ({ index }) => {
       unwrap(await index.delete({ all: true }));
       await sleep(READY_DELAY_MS);
+
       const matches = unwrap(
         await index.query({ topK: 10, vector: vectors.a })
       );
+
       expect(matches).toStrictEqual([]);
     },
   ],
diff --git a/packages/vecstore-sdk/test/live/pgvector-live.test.ts b/packages/vecstore-sdk/test/live/pgvector-live.test.ts
index d156a46..69b0286 100644
--- a/packages/vecstore-sdk/test/live/pgvector-live.test.ts
+++ b/packages/vecstore-sdk/test/live/pgvector-live.test.ts
@@ -6,6 +6,7 @@ import { createPgvectorStore } from "../../src/pgvector";
 import { containsCases, liveCases, setupLive } from "./conformance";
 
 const connectionString = process.env.PGVECTOR_URL;
+
 const enabled =
   process.env.VECSTORE_LIVE === "1" && connectionString !== undefined;
 
diff --git a/packages/vecstore-sdk/test/live/redis-live.test.ts b/packages/vecstore-sdk/test/live/redis-live.test.ts
index c8ef1e9..bb986b9 100644
--- a/packages/vecstore-sdk/test/live/redis-live.test.ts
+++ b/packages/vecstore-sdk/test/live/redis-live.test.ts
@@ -41,6 +41,7 @@ const unwrap = <T>(
   if (!result.ok) {
     throw new Error(JSON.stringify(result.error));
   }
+
   return result.value;
 };
 
@@ -82,6 +83,7 @@ describe.skipIf(!enabled)("redis live filters", () => {
     const present = unwrap(
       await index.query({ filter: exists("tags"), topK: 10, vector: [1, 0, 0] })
     );
+
     const missing = unwrap(
       await index.query({
         filter: not(exists("tags")),
@@ -89,6 +91,7 @@ describe.skipIf(!enabled)("redis live filters", () => {
         vector: [1, 0, 0],
       })
     );
+
     expect(idsOf(present)).toStrictEqual(["doc-a"]);
     expect(idsOf(missing)).toStrictEqual(["doc-b"]);
   });
@@ -101,6 +104,7 @@ describe.skipIf(!enabled)("redis live filters", () => {
         vector: [1, 0, 0],
       })
     );
+
     expect(idsOf(matches)).toStrictEqual(["doc-a"]);
   });
 
@@ -112,6 +116,7 @@ describe.skipIf(!enabled)("redis live filters", () => {
         vector: [1, 0, 0],
       })
     );
+
     expect(idsOf(matches)).toStrictEqual(["doc-a"]);
   });
 
diff --git a/packages/vecstore-sdk/test/live/supabase-live.test.ts b/packages/vecstore-sdk/test/live/supabase-live.test.ts
index 338e0d8..26bd117 100644
--- a/packages/vecstore-sdk/test/live/supabase-live.test.ts
+++ b/packages/vecstore-sdk/test/live/supabase-live.test.ts
@@ -7,6 +7,7 @@ import { containsCases, liveCases, setupLive } from "./conformance";
 
 const url = process.env.SUPABASE_URL;
 const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
 const enabled =
   process.env.VECSTORE_LIVE === "1" && url !== undefined && key !== undefined;
 
diff --git a/packages/vecstore-sdk/test/live/vectorize-live.test.ts b/packages/vecstore-sdk/test/live/vectorize-live.test.ts
index a012f20..79fc9b3 100644
--- a/packages/vecstore-sdk/test/live/vectorize-live.test.ts
+++ b/packages/vecstore-sdk/test/live/vectorize-live.test.ts
@@ -7,6 +7,7 @@ import { liveCases, setupLive } from "./conformance";
 
 const apiToken = process.env.CLOUDFLARE_API_TOKEN ?? "";
 const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? "";
+
 const enabled =
   process.env.VECSTORE_LIVE === "1" && apiToken !== "" && accountId !== "";
 
diff --git a/packages/vecstore-sdk/test/postgres/filter-differential.test.ts b/packages/vecstore-sdk/test/postgres/filter-differential.test.ts
index c2040a7..573e8dc 100644
--- a/packages/vecstore-sdk/test/postgres/filter-differential.test.ts
+++ b/packages/vecstore-sdk/test/postgres/filter-differential.test.ts
@@ -77,23 +77,29 @@ describe("the two pgvector filter compilers", () => {
       `select id from d where ${where} order by id`,
       params
     );
+
     return result.rows.map((row) => row.id);
   };
 
   test.each(corpus)("%s", async (_name, filter, expected) => {
     const compiled = compilePgvectorFilter(filter);
     const fromTypescript = await idsFor(compiled.text, compiled.params);
+
     const sql = await db().query<{ s: string }>(
       `select vecstore_filter_sql($1::jsonb, 'metadata') as s`,
       [JSON.stringify(filter)]
     );
+
     const predicate = sql.rows[0]?.s;
     expect(isString(predicate) && predicate.length > 0).toBe(true);
+
     if (!isString(predicate)) {
       throw new Error("vecstore_filter_sql returned no predicate");
     }
+
     const fromPlpgsql = await idsFor(predicate);
     expect(fromPlpgsql).toStrictEqual(fromTypescript);
+
     if (expected !== undefined) {
       expect(fromTypescript).toStrictEqual(expected);
     }
diff --git a/packages/vecstore-sdk/test/postgres/pglite.ts b/packages/vecstore-sdk/test/postgres/pglite.ts
index 3e6ceca..8405864 100644
--- a/packages/vecstore-sdk/test/postgres/pglite.ts
+++ b/packages/vecstore-sdk/test/postgres/pglite.ts
@@ -32,6 +32,7 @@ export const usePostgres = (
     if (db === undefined) {
       throw new Error("postgres is not ready");
     }
+
     return db;
   };
 };
@@ -44,6 +45,7 @@ export const ensureRoles = async (
     (name) =>
       `do $$ begin if not exists (select 1 from pg_roles where rolname = '${name}') then create role ${name} nologin; end if; end $$`
   );
+
   await db.exec(statements.join(";"));
 };
 
diff --git a/packages/vecstore-sdk/test/postgres/pgvector.test.ts b/packages/vecstore-sdk/test/postgres/pgvector.test.ts
index 02ff8b5..b0166d0 100644
--- a/packages/vecstore-sdk/test/postgres/pgvector.test.ts
+++ b/packages/vecstore-sdk/test/postgres/pgvector.test.ts
@@ -25,6 +25,7 @@ import {
 
 describe("pgvector on PGlite", () => {
   const db = usePostgres();
+
   const live = setupLive(() => createPgvectorStore({ client: db() }), {
     isolated: true,
   });
@@ -42,10 +43,12 @@ describe("index lifecycle on PGlite", () => {
 
   test("recreating an index with a different metric changes ordering and scoring", async () => {
     const store = createPgvectorStore({ client: db() });
+
     const created = await store.createIndex({
       dimension: 3,
       name: "docs_cosine",
     });
+
     expect(created.ok).toBeTruthy();
     await store.index("docs_cosine").query({ topK: 1, vector: [1, 0, 0] });
 
@@ -57,6 +60,7 @@ describe("index lifecycle on PGlite", () => {
       metric: "euclidean",
       name: "docs_cosine",
     });
+
     expect(recreated.ok).toBeTruthy();
 
     const index = store.index("docs_cosine");
@@ -66,6 +70,7 @@ describe("index lifecycle on PGlite", () => {
     ]);
     const result = await index.query({ topK: 2, vector: [1, 0, 0] });
     expect(result.ok).toBeTruthy();
+
     if (result.ok) {
       expect(result.value[0]?.score).toBe(0);
     }
@@ -74,11 +79,13 @@ describe("index lifecycle on PGlite", () => {
   test("a euclidean index named after an opclass keeps its metric", async () => {
     const store = createPgvectorStore({ client: db() });
     const name = "x_vector_cosine_ops";
+
     const created = await store.createIndex({
       dimension: 3,
       metric: "euclidean",
       name,
     });
+
     expect(created.ok).toBeTruthy();
     const index = store.index(name);
     await index.upsert([
@@ -99,9 +106,11 @@ describe("index lifecycle on PGlite", () => {
     const store = createPgvectorStore({ client: db() });
     const result = await store.createIndex({ dimension: 3, name });
     expect(!result.ok && result.error.kind).toBe("invalid_argument");
+
     const rows = await db().query<{ count: number }>(
       "select count(*) from pg_tables where tablename like 'aaaa%'"
     );
+
     expect(rows.rows[0]?.count).toBe(0);
   });
 });
@@ -118,6 +127,7 @@ describe("queries through the HNSW index on PGlite", () => {
       .upsert(spreadRecords("b"));
     await client.exec(FORCE_INDEX_SCAN);
   });
+
   const index = () =>
     createPgvectorStore({ client: db() }).index("filled", {
       namespace: "tenant-a",
@@ -136,6 +146,7 @@ describe("queries through the HNSW index on PGlite", () => {
       topK: 10,
       vector: [1, 0, 0],
     });
+
     expect(result.ok && result.value).toHaveLength(10);
   });
 
@@ -174,6 +185,7 @@ describe("a cosine query that meets a zero vector on PGlite", () => {
       const result = await createPgvectorStore({ client: db() })
         .index(name)
         .query({ topK: 4, vector: [1, 0] });
+
       expect(result.ok && result.value.map((match) => match.id)).toStrictEqual(
         NEAREST_FIRST_ZERO_LAST
       );
@@ -186,18 +198,22 @@ describe("a store that met a missing table on PGlite", () => {
 
   test("reads the metric again once another store creates the table", async () => {
     const early = createPgvectorStore({ client: db() });
+
     const missing = await early
       .index("late")
       .query({ topK: 1, vector: [1, 0, 0] });
+
     await createPgvectorStore({ client: db() }).createIndex({
       dimension: 3,
       metric: "euclidean",
       name: "late",
     });
     await early.index("late").upsert([{ id: "a", vector: [1, 0, 0] }]);
+
     const found = await early
       .index("late")
       .query({ topK: 1, vector: [1, 0, 0] });
+
     expect(!missing.ok && missing.error.kind).toBe("not_found");
     expect(found.ok && found.value[0]?.score).toBe(0);
   });
@@ -228,6 +244,7 @@ describe("delete fails closed on PGlite", () => {
     const index = createPgvectorStore({ client: db() }).index("guarded", {
       namespace: "tenant-a",
     });
+
     const deleted = await index.delete(selector);
     const found = await index.fetch(["a", "b"]);
     expect(!deleted.ok && deleted.error.kind).toBe("invalid_argument");
@@ -246,6 +263,7 @@ const rowSecurity = async (
     "select relrowsecurity from pg_class where relname = $1",
     [table]
   );
+
   return result.rows[0]?.relrowsecurity;
 };
 
@@ -275,6 +293,7 @@ describe("row level security with an anon role on PGlite", () => {
     await db().exec(
       "create extension if not exists vector; grant create on schema public to app_owner; set role app_owner"
     );
+
     try {
       const store = createPgvectorStore({ client: db() });
       const created = await store.createIndex({ dimension: 3, name: "owned" });
@@ -295,10 +314,12 @@ describe("row level security with an anon role on PGlite", () => {
     await store.createIndex({ dimension: 3, name: "hidden" });
     await store.index("hidden").upsert([{ id: "a", vector: [1, 0, 0] }]);
     await db().exec("grant select on hidden to anon; set role anon");
+
     try {
       const rows = await db().query<{ count: number }>(
         "select count(*) from hidden"
       );
+
       expect(rows.rows[0]?.count).toBe(0);
     } finally {
       await db().exec("reset role");
diff --git a/packages/vecstore-sdk/test/postgres/supabase.test.ts b/packages/vecstore-sdk/test/postgres/supabase.test.ts
index 5cf8f0f..2af9a26 100644
--- a/packages/vecstore-sdk/test/postgres/supabase.test.ts
+++ b/packages/vecstore-sdk/test/postgres/supabase.test.ts
@@ -30,6 +30,7 @@ import {
 } from "./pglite";
 
 type ValueOf<T> = T extends object ? T[keyof T] : never;
+
 type RpcArgValue = ValueOf<SupabaseCall["args"]>;
 
 type RpcParam = string | number | boolean | null;
@@ -43,15 +44,19 @@ const placeholder = (key: string, position: number): string => {
   if (JSONB_ARGS.has(key)) {
     return `$${position}::jsonb`;
   }
+
   if (INT_ARGS.has(key)) {
     return `$${position}::int`;
   }
+
   if (BOOLEAN_ARGS.has(key)) {
     return `$${position}::boolean`;
   }
+
   if (TEXT_ARRAY_ARGS.has(key)) {
     return `(select array(select jsonb_array_elements_text(v)) from (select $${position}::jsonb as v) t where v is not null)`;
   }
+
   return `$${position}::text`;
 };
 
@@ -59,30 +64,38 @@ const toParam = (key: string, value: RpcArgValue): RpcParam => {
   if (value === null || value === undefined) {
     return null;
   }
+
   if (JSONB_ARGS.has(key) || TEXT_ARRAY_ARGS.has(key)) {
     return JSON.stringify(value);
   }
+
   if (isString(value) || isNumber(value) || isBoolean(value)) {
     return value;
   }
+
   throw new Error(`unexpected rpc argument type for ${key}`);
 };
 
 export const rpcClient = (db: PGlite): SupabaseClientLike => ({
   rpc: async (fn, args) => {
     const entries = Object.entries(args);
+
     const named = entries
       .map(([key], index) => `${key} => ${placeholder(key, index + 1)}`)
       .join(", ");
+
     const params = entries.map(([key, value]) => toParam(key, value));
+
     try {
       const result = await db.query<object>(
         `select * from ${fn}(${named})`,
         params
       );
+
       return { data: result.rows, error: null };
     } catch (error) {
       const code = hasCode(error) ? error.code : undefined;
+
       return { data: null, error: { code, message: errorMessage(error) } };
     }
   },
@@ -90,6 +103,7 @@ export const rpcClient = (db: PGlite): SupabaseClientLike => ({
 
 describe("supabase on PGlite", () => {
   const db = usePostgres(installSupabaseSql);
+
   const live = setupLive(
     () => createSupabaseStore({ client: rpcClient(db()) }),
     { isolated: true }
@@ -108,19 +122,23 @@ describe("vecstore_create_index index lifecycle on PGlite", () => {
 
   test("rejects a name over 49 bytes with a 22023 error", async () => {
     const name = "a".repeat(50);
+
     const response = await rpcClient(db()).rpc("vecstore_create_index", {
       dimension: 3,
       index_name: name,
       index_schema: null,
       metric: "cosine",
     });
+
     expect(response.error?.code).toBe("22023");
+
     const mapped = normalizeSupabaseError(
       Object.assign(new Error(response.error?.message ?? ""), {
         code: response.error?.code,
       }),
       { fn: "vecstore_create_index", index: name }
     );
+
     expect(mapped.kind).toBe("invalid_argument");
   });
 });
@@ -131,11 +149,13 @@ describe("vecstore_metric on PGlite", () => {
   test("a euclidean index named after an opclass keeps its metric", async () => {
     const store = createSupabaseStore({ client: rpcClient(db()) });
     const name = "x_vector_cosine_ops";
+
     const created = await store.createIndex({
       dimension: 3,
       metric: "euclidean",
       name,
     });
+
     expect(created.ok).toBeTruthy();
     const index = store.index(name);
     await index.upsert([
@@ -165,6 +185,7 @@ describe("a cosine vecstore_query that meets a zero vector on PGlite", () => {
     const result = await createSupabaseStore({ client: rpcClient(db()) })
       .index("zeroed")
       .query({ topK: 4, vector: [1, 0] });
+
     expect(result.ok && result.value.map((match) => match.id)).toStrictEqual(
       NEAREST_FIRST_ZERO_LAST
     );
@@ -179,6 +200,7 @@ describe("supabase install script", () => {
     fn: () => PromiseLike<T>
   ): Promise<T> => {
     await db().exec(`set role ${role}`);
+
     try {
       return await fn();
     } finally {
@@ -196,6 +218,7 @@ describe("supabase install script", () => {
     const result = await db().query<{ count: number }>(
       `select count(*) from ${table}`
     );
+
     return result.rows[0]?.count ?? -1;
   };
 
@@ -205,15 +228,18 @@ describe("supabase install script", () => {
     const rows = await db().query<{ relrowsecurity: boolean }>(
       "select relrowsecurity from pg_class where relname = 'secured_rls'"
     );
+
     expect(rows.rows[0]?.relrowsecurity).toBe(true);
   });
 
   test("anon reads nothing from a secured table until a policy exists", async () => {
     await createSecured("secured_anon");
     const store = createSupabaseStore({ client: rpcClient(db()) });
+
     const upserted = await store
       .index("secured_anon")
       .upsert([{ id: "a", vector: [0, 0, 1] }]);
+
     expect(upserted.ok).toBe(true);
 
     await ensureRoles(db(), ["anon"]);
@@ -230,6 +256,7 @@ describe("supabase install script", () => {
     const functions = await db().query<{ definer: boolean; name: string }>(
       "select proname as name, prosecdef as definer from pg_proc where proname like 'vecstore\\_%'"
     );
+
     expect(functions.rows.length).toBeGreaterThan(0);
     expect(functions.rows.filter((row) => row.definer)).toStrictEqual([]);
   });
@@ -239,9 +266,11 @@ describe("supabase install script", () => {
     async (role) => {
       const name = `secured_${role}_verbs`;
       await createSecured(name);
+
       const index = createSupabaseStore({ client: rpcClient(db()) }).index(
         name
       );
+
       await index.upsert([{ id: "a", vector: [0, 0, 1] }]);
 
       await ensureRoles(db(), [role]);
@@ -252,19 +281,24 @@ describe("supabase install script", () => {
       const queried = await asRole(role, () =>
         index.query({ topK: 1, vector: [0, 0, 1] })
       );
+
       const fetched = await asRole(role, () => index.fetch(["a"]));
+
       const upserted = await asRole(role, () =>
         index.upsert([{ id: "b", vector: [1, 0, 0] }])
       );
+
       const deleted = await asRole(role, () => index.delete({ ids: ["a"] }));
 
       expect(queried.ok && queried.value).toStrictEqual([]);
       expect(fetched.ok && fetched.value).toStrictEqual([]);
       expect(upserted.ok || upserted.error.kind).toBe("unauthorized");
       expect(deleted.ok).toBe(true);
+
       const remaining = await db().query<{ id: string }>(
         `select id from ${name}`
       );
+
       expect(remaining.rows.map((row) => row.id)).toStrictEqual(["a"]);
     }
   );
@@ -281,6 +315,7 @@ describe("supabase install script", () => {
         metric: "cosine",
       })
     );
+
     expect(response.error?.code).toBe("42501");
   });
 
@@ -296,6 +331,7 @@ describe("supabase install script", () => {
       `select vecstore_filter_sql('{"kind":"and","filters":[{"kind":"eq","field":"t","value":"a"},{"kind":"lt","field":"p"}]}'::jsonb, 'metadata')`,
       `select vecstore_filter_sql('{"kind":"in","field":"g","values":[]}'::jsonb, 'metadata')`,
     ];
+
     await Promise.all(
       malformedQueries.map((query) =>
         expect(db().query(query)).rejects.toMatchObject({ code: "22023" })
@@ -303,6 +339,7 @@ describe("supabase install script", () => {
     );
 
     let deleteError: unknown;
+
     try {
       await db().query(
         "select vecstore_delete($1::text, null::text, $2::text, null::text[], $3::jsonb)",
@@ -311,6 +348,7 @@ describe("supabase install script", () => {
     } catch (error) {
       deleteError = error;
     }
+
     expect(hasCode(deleteError) && deleteError.code).toBe("22023");
 
     expect(await countRows("secured_closed")).toBe(1);
@@ -330,6 +368,7 @@ describe("vecstore_query through the HNSW index on PGlite", () => {
       .upsert(spreadRecords("b"));
     await client.exec(FORCE_INDEX_SCAN);
   });
+
   const index = () =>
     createSupabaseStore({ client: rpcClient(db()) }).index("filled", {
       namespace: "tenant-a",
@@ -348,6 +387,7 @@ describe("vecstore_query through the HNSW index on PGlite", () => {
       topK: 10,
       vector: [1, 0, 0],
     });
+
     expect(result.ok && result.value).toHaveLength(10);
   });
 });
diff --git a/scripts/glyph-path.ts b/scripts/glyph-path.ts
index e1a4e21..38d6c93 100644
--- a/scripts/glyph-path.ts
+++ b/scripts/glyph-path.ts
@@ -7,11 +7,13 @@ export const cubicPathData = (glyphs: Path, precision: number): string => {
   let previousX = 0;
   let previousY = 0;
   const segments: string[] = [];
+
   for (const command of glyphs.commands) {
     if (command.type === "Z") {
       segments.push("Z");
       continue;
     }
+
     if (command.type === "Q") {
       const control1X = previousX + TWO_THIRDS * (command.x1 - previousX);
       const control1Y = previousY + TWO_THIRDS * (command.y1 - previousY);
@@ -27,8 +29,10 @@ export const cubicPathData = (glyphs: Path, precision: number): string => {
     } else {
       segments.push(`${command.type}${format(command.x)} ${format(command.y)}`);
     }
+
     previousX = command.x;
     previousY = command.y;
   }
+
   return segments.join("");
 };
diff --git a/scripts/render-hero.ts b/scripts/render-hero.ts
index ad3bc06..ef05fca 100644
--- a/scripts/render-hero.ts
+++ b/scripts/render-hero.ts
@@ -30,6 +30,7 @@ const HASH_Y = 78.233;
 const HASH_SCALE = 43_758.5453;
 
 const HEADLINE = "One API for vector stores";
+
 const SUBTITLE = [
   "vecstore-sdk is an open-source TypeScript library that compiles one",
   "filter to Qdrant, pgvector, Pinecone, Supabase, Upstash Vector,",
@@ -69,6 +70,7 @@ const THEMES: Theme[] = [
 
 const hash = (column: number, row: number): number => {
   const value = Math.sin(column * HASH_X + row * HASH_Y) * HASH_SCALE;
+
   return value - Math.floor(value);
 };
 
@@ -81,21 +83,27 @@ const halftone = (theme: Theme): string => {
   const top = FRAME_INSET;
   const bottom = HEIGHT - FRAME_INSET;
   const dots: string[] = [];
+
   for (let y = top + DOT_SPACING; y < bottom; y += DOT_SPACING) {
     for (let x = left + DOT_SPACING; x < right; x += DOT_SPACING) {
       const progress = (x - left) / (right - left);
+
       const density =
         DENSITY_START + (DENSITY_END - DENSITY_START) * progress ** 2;
+
       if (hash(x, y) > density) {
         continue;
       }
+
       const radius =
         DOT_MIN_RADIUS + (DOT_MAX_RADIUS - DOT_MIN_RADIUS) * progress;
+
       dots.push(
         `<circle cx="${x}" cy="${y}" r="${radius.toFixed(2)}" fill="${theme.dot}"/>`
       );
     }
   }
+
   return `<rect x="${left}" y="${top}" width="${right - left}" height="${bottom - top}" fill="${theme.panel}"/>${dots.join(
     ""
   )}`;
@@ -103,6 +111,7 @@ const halftone = (theme: Theme): string => {
 
 const loadFont = (file: string): Font => {
   const bytes = readFileSync(file);
+
   return parse(
     bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
   );
@@ -173,11 +182,13 @@ const run = (): void => {
       throw new Error(`missing ${file}`);
     }
   }
+
   for (const theme of THEMES) {
     const svg = heroSvg(theme);
     writeFileSync(`assets/hero-${theme.name}.svg`, `${svg}\n`);
     writeFileSync(`assets/hero-${theme.name}.png`, renderPng(svg));
   }
+
   process.stdout.write(`${THEMES.length} themes rendered\n`);
 };
 
diff --git a/scripts/render-logo.ts b/scripts/render-logo.ts
index 9fca394..ecb06f8 100644
--- a/scripts/render-logo.ts
+++ b/scripts/render-logo.ts
@@ -49,6 +49,7 @@ interface Box {
 
 const loadFont = (file: string): Font => {
   const bytes = readFileSync(file);
+
   return parse(
     bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
   );
@@ -63,6 +64,7 @@ const textPath = (text: string, size: number, tracking: number): Path =>
 
 const bounds = (path: Path): Box => {
   const box = path.getBoundingBox();
+
   return {
     height: box.y2 - box.y1,
     width: box.x2 - box.x1,
@@ -98,6 +100,7 @@ const wordmark = (ink: string): Piece => {
   const suffixX = pillX + (pillWidth - suffixBox.width) / 2 - suffixBox.x;
   const suffixY = pillY + (pillHeight - suffixBox.height) / 2 - suffixBox.y;
   const radius = (pillHeight - stroke) / 2;
+
   const svg = [
     translate(
       -nameBox.x,
@@ -111,6 +114,7 @@ const wordmark = (ink: string): Piece => {
       `<path fill="${ink}" d="${cubicPathData(suffix, PATH_PRECISION)}"/>`
     ),
   ].join("");
+
   return { height, svg, width: pillX + pillWidth };
 };
 
@@ -125,22 +129,28 @@ const cell = (
   const radius = unit * CELL_RADIUS;
   const x = column * unit + (unit - size) / 2;
   const y = row * unit + (unit - size) / 2;
+
   if (filled) {
     return `<rect x="${format(x)}" y="${format(y)}" width="${format(size)}" height="${format(size)}" rx="${format(radius)}" fill="${ink}"/>`;
   }
+
   const inset = unit * HOLLOW_INSET;
   const stroke = unit * HOLLOW_STROKE;
+
   return `<rect x="${format(x + inset)}" y="${format(y + inset)}" width="${format(size - inset * 2)}" height="${format(size - inset * 2)}" rx="${format(radius)}" fill="none" stroke="${ink}" stroke-width="${format(stroke)}"/>`;
 };
 
 const mark = (ink: string, unit: number): Piece => {
   const cells: string[] = [];
+
   for (let row = 0; row < GRID; row += 1) {
     for (let column = 0; column < GRID; column += 1) {
       cells.push(cell(column, row, unit, ink, column === row));
     }
   }
+
   const side = unit * GRID;
+
   return { height: side, svg: cells.join(""), width: side };
 };
 
@@ -148,6 +158,7 @@ const document = (piece: Piece): string => {
   const pad = NAME_SIZE * PADDING;
   const width = piece.width + pad * 2;
   const height = piece.height + pad * 2;
+
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${format(width)}" height="${format(height)}" viewBox="0 0 ${format(width)} ${format(height)}">${translate(pad, pad, piece.svg)}</svg>`;
 };
 
@@ -156,6 +167,7 @@ const lockup = (ink: string): Piece => {
   const icon = mark(ink, NAME_SIZE * CELL_UNIT);
   const gap = NAME_SIZE * MARK_GAP;
   const height = Math.max(word.height, icon.height);
+
   return {
     height,
     svg:
@@ -182,6 +194,7 @@ const run = (): void => {
   if (!existsSync(SEMIBOLD_FILE)) {
     throw new Error(`missing ${SEMIBOLD_FILE}`);
   }
+
   for (const theme of THEMES) {
     write(
       `mark-${theme.name}`,
@@ -189,6 +202,7 @@ const run = (): void => {
     );
     write(`logo-${theme.name}`, document(lockup(theme.ink)));
   }
+
   process.stdout.write(`${THEMES.length} themes rendered\n`);
 };
 
diff --git a/scripts/render-provider-marks.ts b/scripts/render-provider-marks.ts
index 0a041bb..ac09d6a 100644
--- a/scripts/render-provider-marks.ts
+++ b/scripts/render-provider-marks.ts
@@ -15,6 +15,7 @@ const MAX_CHANNEL = 255;
 
 const root = path.join(import.meta.dir, "..");
 const assets = path.join(root, "assets", "providers");
+
 const output = path.join(
   root,
   "apps",
@@ -40,6 +41,7 @@ const inkAt = (pixels: Uint8Array, index: number): number => {
   const green = pixels[index + 1] ?? 0;
   const blue = pixels[index + 2] ?? 0;
   const luma = (LUMA.r * red + LUMA.g * green + LUMA.b * blue) / MAX_CHANNEL;
+
   return (alpha / MAX_CHANNEL) * (1 - luma);
 };
 
@@ -52,6 +54,7 @@ interface Bounds {
 
 const measure = (pixels: Uint8Array, width: number, height: number): Bounds => {
   let bounds: Bounds = { maxX: 0, maxY: 0, minX: width, minY: height };
+
   for (let y = 0; y < height; y += 1) {
     for (let x = 0; x < width; x += 1) {
       if (inkAt(pixels, (y * width + x) * RGBA) > INK_THRESHOLD) {
@@ -64,6 +67,7 @@ const measure = (pixels: Uint8Array, width: number, height: number): Bounds => {
       }
     }
   }
+
   return bounds;
 };
 
@@ -72,6 +76,7 @@ const toGrid = (svg: string): boolean[][] => {
     background: "transparent",
     fitTo: { mode: "width", value: SAMPLE_WIDTH },
   }).render();
+
   const { height, pixels, width } = image;
   const bounds = measure(pixels, width, height);
   const boxWidth = bounds.maxX - bounds.minX + 1;
@@ -82,8 +87,10 @@ const toGrid = (svg: string): boolean[][] => {
   const step = side / CELLS;
   const coverage: number[][] = [];
   let peak = 0;
+
   for (let cy = 0; cy < CELLS; cy += 1) {
     const row: number[] = [];
+
     for (let cx = 0; cx < CELLS; cx += 1) {
       let sum = 0;
       let count = 0;
@@ -91,21 +98,26 @@ const toGrid = (svg: string): boolean[][] => {
       const endY = originY + (cy + 1) * step;
       const startX = Math.floor(originX + cx * step);
       const endX = originX + (cx + 1) * step;
+
       for (let y = startY; y < endY; y += 1) {
         for (let x = startX; x < endX; x += 1) {
           count += 1;
           const inside = x >= 0 && y >= 0 && x < width && y < height;
+
           if (inside) {
             sum += inkAt(pixels, (y * width + x) * RGBA);
           }
         }
       }
+
       const value = sum / count;
       row.push(value);
       peak = Math.max(peak, value);
     }
+
     coverage.push(row);
   }
+
   return coverage.map((row) =>
     row.map((value) => value >= RELATIVE_THRESHOLD * peak)
   );
@@ -113,6 +125,7 @@ const toGrid = (svg: string): boolean[][] => {
 
 const toPath = (grid: boolean[][]): string => {
   const dots: string[] = [];
+
   for (const [y, row] of grid.entries()) {
     for (const [x, filled] of row.entries()) {
       if (filled) {
@@ -124,6 +137,7 @@ const toPath = (grid: boolean[][]): string => {
       }
     }
   }
+
   return dots.join("");
 };
 
diff --git a/scripts/render-web-icons.ts b/scripts/render-web-icons.ts
index 1e91faf..e3c5f5f 100644
--- a/scripts/render-web-icons.ts
+++ b/scripts/render-web-icons.ts
@@ -46,6 +46,7 @@ const ogOutput = path.join(output, "og", "docs", "[...slug]");
 
 const loadFont = (file: string): Font => {
   const bytes = readFileSync(file);
+
   return parse(
     bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
   );
@@ -61,6 +62,7 @@ const markSvg = (size: number, scale: number, radius: number): string => {
   const inner = size * scale;
   const offset = (size - inner) / 2;
   const factor = inner / MARK_SIZE;
+
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}"><rect width="${size}" height="${size}" rx="${format(size * radius)}" fill="${BACKGROUND}"/><g transform="translate(${format(offset)} ${format(offset)}) scale(${format(factor)})">${markInner}</g></svg>`;
 };
 
@@ -79,6 +81,7 @@ const ico = (entries: readonly { size: number; png: Buffer }[]): Buffer => {
   header.writeUInt16LE(entries.length, 4);
   const directory = Buffer.alloc(ICO_ENTRY_BYTES * entries.length);
   let offset = ICO_HEADER_BYTES + directory.length;
+
   for (const [index, entry] of entries.entries()) {
     const base = index * ICO_ENTRY_BYTES;
     directory.writeUInt8(entry.size, base);
@@ -91,6 +94,7 @@ const ico = (entries: readonly { size: number; png: Buffer }[]): Buffer => {
     directory.writeUInt32LE(offset, base + 12);
     offset += entry.png.length;
   }
+
   return Buffer.concat([
     header,
     directory,
@@ -145,12 +149,15 @@ const providers: readonly ProviderRow[] = [
 
 const providerIcon = (file: string, size: number, tint: string): string => {
   const svg = readFileSync(path.join(assets, "providers", file), "utf-8");
+
   const viewBox =
     /viewBox="[\d.]+ [\d.]+ (?<width>[\d.]+) (?<height>[\d.]+)"/u.exec(svg);
+
   const width = Number(viewBox?.groups?.width ?? size);
   const height = Number(viewBox?.groups?.height ?? size);
   const scale = size / Math.max(width, height);
   const d = /\sd="(?<d>[^"]+)"/u.exec(svg)?.groups?.d ?? "";
+
   return `<g transform="scale(${format(scale)})"><path d="${d}" fill="${tint}"/></g>`;
 };
 
@@ -158,8 +165,10 @@ const providerBody = (row: ProviderRow, labelFont: Font): string => {
   const label = labelFont.getPath(row.label, 0, 0, CARD_LABEL_SIZE, {
     kerning: true,
   });
+
   const box = label.getBoundingBox();
   const textY = CARD_HEIGHT / 2 - (box.y1 + box.y2) / 2;
+
   return `<g transform="translate(${CARD_ICON_INSET} ${format(CARD_ICON_Y)})">${providerIcon(row.file, CARD_ICON, row.tint)}</g><g transform="translate(${format(CARD_LABEL_X - box.x1)} ${format(textY)})"><path d="${cubicPathData(label, PATH_PRECISION)}" fill="${INK}"/></g>`;
 };
 
@@ -171,6 +180,7 @@ const card = (
 ): string => {
   const body = providerBody(row, labelFont);
   const stroke = active ? CARD_STROKE_ACTIVE : CARD_STROKE;
+
   return `<g transform="translate(0 ${format(y)})"><rect width="${CARD_WIDTH}" height="${CARD_HEIGHT}" rx="${CARD_RADIUS}" fill="${CARD_FILL}" stroke="${stroke}" stroke-width="${CARD_STROKE_WIDTH}"/>${body}</g>`;
 };
 
@@ -187,15 +197,18 @@ const column = (
   const height = items.length * CARD_HEIGHT + (items.length - 1) * CARD_GAP;
   const top = (OG_HEIGHT - height) / 2 - COLUMN_LIFT;
   const lastTop = top + (items.length - 1) * CARD_PITCH;
+
   const cards = items
     .map((row, index) =>
       card(row, top + index * CARD_PITCH, labelFont, row.id === activeId)
     )
     .join("");
+
   const solidFrom = (top + CARD_HEIGHT) / OG_HEIGHT;
   const solidTo = lastTop / OG_HEIGHT;
   const clearTo = (lastTop + CARD_PITCH) / OG_HEIGHT;
   const fade = `<linearGradient id="column-fade" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#000000"/><stop offset="${format(solidFrom)}" stop-color="#ffffff"/><stop offset="${format(solidTo)}" stop-color="#ffffff"/><stop offset="${format(clearTo)}" stop-color="#000000"/></linearGradient><mask id="column-mask"><rect width="${OG_WIDTH}" height="${OG_HEIGHT}" fill="url(#column-fade)"/></mask>`;
+
   return { cards, mask: fade };
 };
 
@@ -206,9 +219,11 @@ const frame = (mask: string, body: string): string =>
 
 const logoSvg = readFileSync(path.join(assets, "logo-dark.svg"), "utf-8");
 const logoData = Buffer.from(logoSvg).toString("base64");
+
 const logoBox = /viewBox="0 0 (?<width>[\d.]+) (?<height>[\d.]+)"/u.exec(
   logoSvg
 );
+
 const logoRatio =
   Number(logoBox?.groups?.height ?? 1) / Number(logoBox?.groups?.width ?? 1);
 
@@ -226,15 +241,19 @@ const rotate = (by: number): readonly ProviderRow[] => [
 
 const windowFor = (activeId?: string): readonly ProviderRow[] => {
   const index = providers.findIndex((row) => row.id === activeId);
+
   if (index === -1) {
     return providers.slice(0, COLUMN_WINDOW);
   }
+
   const offset = (index - ACTIVE_SLOT + providers.length) % providers.length;
+
   return rotate(offset).slice(0, COLUMN_WINDOW);
 };
 
 const socialCard = (activeId?: string): string => {
   const { cards, mask } = column(windowFor(activeId), labelFont, activeId);
+
   return frame(
     mask,
     `${logoImage(OG_LOGO_WIDTH, logoTop)}<g mask="url(#column-mask)"><g transform="translate(${format(columnX)} 0)">${cards}</g></g>`
@@ -267,12 +286,14 @@ const run = (): void => {
   );
   mkdirSync(ogOutput, { recursive: true });
   writeFileSync(path.join(ogOutput, "background.png"), defaultCard);
+
   for (const row of providers) {
     writeFileSync(
       path.join(ogOutput, `background-${row.id}.png`),
       renderPng(socialCard(row.id), OG_WIDTH)
     );
   }
+
   process.stdout.write("icons rendered\n");
 };