@@ -12,6 +12,7 @@
 // EMITTED <Report>.routes.ts files unmodified and mount them.
 
 import Fastify, { type FastifyInstance } from "fastify";
+import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -161,17 +162,19 @@ export async function startSqliteReportServer(
 async function openEngine(engine: SqliteReportEngine, tmp: string): Promise<EngineClient> {
   if (engine === "d1") {
     const local = await startLocalD1();
-    (globalThis as { __reportD1?: unknown }).__reportD1 = local.d1;
+    // One key per server, so two servers in flight never read each other's binding.
+    const key = `__reportD1_${randomUUID().replaceAll("-", "")}`;
+    (globalThis as Record<string, unknown>)[key] = local.d1;
     writeFileSync(join(tmp, "db.ts"), `
 import { drizzle } from "drizzle-orm/d1";
-export const db = drizzle((globalThis as { __reportD1?: never }).__reportD1 as never);
+export const db = drizzle((globalThis as Record<string, never>)[${JSON.stringify(key)}]);
 `, "utf8");
     return {
       run: async (sql, params = []) => {
         await local.d1.prepare(sql).bind(...params).all();
       },
       close: async () => {
-        delete (globalThis as { __reportD1?: unknown }).__reportD1;
+        delete (globalThis as Record<string, unknown>)[key];
         await local.dispose();
       },
     };
 
@@ -15,7 +15,7 @@ import { CANONICAL_COLUMN_NAMING, generateCanonicalSchemaSql } from "./canonical
 import { d1Dialect, type D1Like } from "./d1-kysely.ts";
 import { loadMetadataDir } from "./load-metadata.ts";
 import { runScenarioQueries } from "./query-scenario.ts";
-import { stripSqlComments } from "./query-scenario-sqlite.ts";
+import { splitStatements } from "./sql-script.ts";
 import type { QueryScenario } from "./scenario.ts";
 
 interface D1Database extends D1Like {
@@ -43,7 +43,7 @@ export async function startLocalD1(): Promise<LocalD1> {
 
 /** D1's `exec` runs one statement per line; fold each statement onto one line first. */
 export async function execScript(d1: D1Database, script: string): Promise<void> {
-  for (const stmt of stripSqlComments(script).split(";").map((s) => s.trim()).filter(Boolean)) {
+  for (const stmt of splitStatements(script)) {
     await d1.exec(stmt.replace(/\s*\n\s*/g, " "));
   }
 }
 
@@ -18,6 +18,10 @@ import { Kysely, MysqlDialect } from "kysely";
 import { createPool } from "mysql2";
 import mysql from "mysql2/promise";
 
+import { splitStatements } from "./sql-script.ts";
+
+export { splitStatements };
+
 import { CANONICAL_COLUMN_NAMING } from "./canonical-schema.ts";
 import { readCanonicalMysqlSchemaSql } from "./canonical-schema-mysql.ts";
 import { loadMetadataDir } from "./load-metadata.ts";
@@ -55,13 +59,6 @@ export function toMysqlSeed(seed: string): string {
   return out.replace(/'(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?)Z'/g, "'$1'");
 }
 
-/** The statements of a script: split on `;` at the end of a line (no body carries one mid-line). */
-export function splitStatements(script: string): string[] {
-  return script
-    .split("\n").filter((l) => !l.trim().startsWith("--")).join("\n")
-    .split(/;[ \t]*(?:\n|$)/).map((s) => s.trim()).filter(Boolean);
-}
-
 /** Every table and view the schema artifact creates, dropped first so a rerun starts clean. */
 export async function resetSchema(conn: mysql.Connection, schemaSql: string): Promise<void> {
   const statements = splitStatements(schemaSql);
 
@@ -19,20 +19,16 @@ import { join } from "node:path";
 import { CANONICAL_COLUMN_NAMING, readCanonicalSchemaSql } from "./canonical-schema.ts";
 import { loadMetadataDir } from "./load-metadata.ts";
 import { runScenarioQueries } from "./query-scenario.ts";
+import { splitStatements } from "./sql-script.ts";
 import type { QueryScenario } from "./scenario.ts";
 
-/** libsql executes one statement per call; no schema or seed statement carries an inner `;`. */
+/** libsql executes one statement per call. */
 export async function applySqlScript(db: Kysely<never>, script: string): Promise<void> {
-  for (const stmt of script.split(";").map((s) => s.trim()).filter(Boolean)) {
+  for (const stmt of splitStatements(script)) {
     await sql.raw(stmt).execute(db);
   }
 }
 
-/** `sql` is `--` comment lines + statements; drop the comments before splitting on `;`. */
-export function stripSqlComments(script: string): string {
-  return script.split("\n").filter((l) => !l.trim().startsWith("--")).join("\n");
-}
-
 export async function runQueryScenarioSqlite(
   scenario: QueryScenario,
   canonicalDir: string,
@@ -41,7 +37,7 @@ export async function runQueryScenarioSqlite(
   const dir = mkdtempSync(join(tmpdir(), "query-scenario-sqlite-"));
   const kysely = new Kysely<never>({ dialect: new LibsqlDialect({ url: `file:${join(dir, "test.db")}` }) });
   try {
-    await applySqlScript(kysely, stripSqlComments(schemaSql));
+    await applySqlScript(kysely, schemaSql);
     const seed = scenario.seedDataEngine?.sqlite ?? scenario.seedData;
     if (seed && seed.trim().length > 0) await applySqlScript(kysely, seed);
 
 
@@ -0,0 +1,11 @@
+// sql-script.ts — split a committed SQL script (the schema artifacts, a scenario's seed) into
+// statements for a driver that runs one statement per call.
+//
+// A `;` ends a statement only at the end of a line, so one inside a string literal's data (a
+// title, a JSON payload) does not break it. `--` comment lines are dropped first.
+
+export function splitStatements(script: string): string[] {
+  return script
+    .split("\n").filter((l) => !l.trim().startsWith("--")).join("\n")
+    .split(/;[ \t]*(?:\n|$)/).map((s) => s.trim()).filter(Boolean);
+}