@ainyc/canonry 1.30.0 → 1.31.0

package/dist/{chunk-LMSO32GF.js → chunk-YW4IZ34Z.js}

@@ -494,6 +494,9 @@ function unsupportedKind(kind) {
 function notImplemented(message) {
   return new AppError("NOT_IMPLEMENTED", message, 501);
 }
+function deliveryFailed(message) {
+  return new AppError("DELIVERY_FAILED", message, 502);
+}
 
 // ../contracts/src/google.ts
 import { z as z5 } from "zod";
@@ -1406,6 +1409,16 @@ function createClient(databasePath) {
   return drizzle(sqlite, { schema: schema_exports });
 }
 
+// ../db/src/json.ts
+function parseJsonColumn(value, fallback) {
+  if (value == null || value === "") return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
 // ../db/src/migrate.ts
 import { sql } from "drizzle-orm";
 var MIGRATION_SQL = `
@@ -1806,7 +1819,7 @@ import { eq as eq3 } from "drizzle-orm";
 
 // ../api-routes/src/helpers.ts
 import crypto3 from "crypto";
-import { eq as eq2, and } from "drizzle-orm";
+import { eq as eq2, sql as sql2 } from "drizzle-orm";
 function resolveProject(db, name) {
   const project = db.select().from(projects).where(eq2(projects.name, name)).get();
   if (!project) {
@@ -1834,43 +1847,39 @@ async function projectRoutes(app, opts) {
     const { name } = request.params;
     const parsedBody = projectUpsertRequestSchema.safeParse(request.body);
     if (!parsedBody.success) {
-      const err = validationError("Invalid project payload", {
+      throw validationError("Invalid project payload", {
         issues: parsedBody.error.issues.map((issue) => ({
           path: issue.path.join("."),
           message: issue.message
         }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const body = parsedBody.data;
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && body.providers?.length) {
       const invalid = body.providers.filter((p) => !validNames.includes(p));
       if (invalid.length) {
-        const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+        throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
           invalidProviders: invalid,
           validProviders: validNames
         });
-        return reply.status(err.statusCode).send(err.toJSON());
       }
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = app.db.select().from(projects).where(eq3(projects.name, name)).get();
-    const existingLocations = existing ? JSON.parse(existing.locations || "[]") : [];
+    const existingLocations = existing ? parseJsonColumn(existing.locations, []) : [];
     const nextLocations = body.locations ?? existingLocations;
     const duplicateLabels = findDuplicateLocationLabels(nextLocations);
     if (duplicateLabels.length > 0) {
-      const err = validationError(`Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`, {
+      throw validationError(`Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`, {
         duplicateLabels
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const nextDefaultLocation = body.defaultLocation !== void 0 ? body.defaultLocation ?? null : existing?.defaultLocation ?? null;
     if (!hasLocationLabel(nextLocations, nextDefaultLocation)) {
-      const err = validationError(`defaultLocation "${nextDefaultLocation}" must match a configured location label`, {
+      throw validationError(`defaultLocation "${nextDefaultLocation}" must match a configured location label`, {
         defaultLocation: nextDefaultLocation
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (existing) {
       app.db.update(projects).set({
@@ -1932,28 +1941,11 @@ async function projectRoutes(app, opts) {
     return reply.send(rows.map(formatProject));
   });
   app.get("/projects/:name", async (request, reply) => {
-    try {
-      const project = resolveProject(app.db, request.params.name);
-      return reply.send(formatProject(project));
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
+    return reply.send(formatProject(project));
   });
   app.delete("/projects/:name", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     writeAuditLog(app.db, {
       projectId: project.id,
       actor: "api",
@@ -1966,26 +1958,15 @@ async function projectRoutes(app, opts) {
     return reply.status(204).send();
   });
   app.post("/projects/:name/locations", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const parsed = locationContextSchema.safeParse(request.body);
     if (!parsed.success) {
-      const err = validationError(parsed.error.issues.map((i) => i.message).join(", "));
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(parsed.error.issues.map((i) => i.message).join(", "));
     }
     const location = parsed.data;
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     if (existing.some((l) => l.label === location.label)) {
-      const err = validationError(`Location "${location.label}" already exists`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${location.label}" already exists`);
     }
     existing.push(location);
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -2003,39 +1984,20 @@ async function projectRoutes(app, opts) {
     return reply.status(201).send(location);
   });
   app.get("/projects/:name/locations", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
-    const locations = JSON.parse(project.locations || "[]");
+    const project = resolveProject(app.db, request.params.name);
+    const locations = parseJsonColumn(project.locations, []);
     return reply.send({
       locations,
       defaultLocation: project.defaultLocation
     });
   });
   app.delete("/projects/:name/locations/:label", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const label = decodeURIComponent(request.params.label);
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     const filtered = existing.filter((l) => l.label !== label);
     if (filtered.length === existing.length) {
-      const err = validationError(`Location "${label}" not found`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${label}" not found`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const updates = {
@@ -2056,25 +2018,14 @@ async function projectRoutes(app, opts) {
     return reply.status(204).send();
   });
   app.put("/projects/:name/locations/default", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const label = request.body?.label;
     if (!label) {
-      const err = validationError("label is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("label is required");
     }
-    const existing = JSON.parse(project.locations || "[]");
+    const existing = parseJsonColumn(project.locations, []);
     if (!existing.some((l) => l.label === label)) {
-      const err = validationError(`Location "${label}" not found. Add it first.`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Location "${label}" not found. Add it first.`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.update(projects).set({
@@ -2091,16 +2042,7 @@ async function projectRoutes(app, opts) {
     return reply.send({ defaultLocation: label });
   });
   app.get("/projects/:name/export", async (request, reply) => {
-    let project;
-    try {
-      project = resolveProject(app.db, request.params.name);
-    } catch (e) {
-      if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-        const err = e;
-        return reply.status(err.statusCode).send(err.toJSON());
-      }
-      throw e;
-    }
+    const project = resolveProject(app.db, request.params.name);
     const kws = app.db.select().from(keywords).where(eq3(keywords.projectId, project.id)).all();
     const comps = app.db.select().from(competitors).where(eq3(competitors.projectId, project.id)).all();
     const schedule = app.db.select().from(schedules).where(eq3(schedules.projectId, project.id)).get();
@@ -2110,21 +2052,21 @@ async function projectRoutes(app, opts) {
       kind: "Project",
       metadata: {
         name: project.name,
-        labels: JSON.parse(project.labels)
+        labels: parseJsonColumn(project.labels, {})
       },
       spec: {
         displayName: project.displayName,
         canonicalDomain: project.canonicalDomain,
-        ownedDomains: JSON.parse(project.ownedDomains || "[]"),
+        ownedDomains: parseJsonColumn(project.ownedDomains, []),
         country: project.country,
         language: project.language,
         keywords: kws.map((k) => k.keyword),
         competitors: comps.map((c) => c.domain),
-        providers: JSON.parse(project.providers || "[]"),
-        locations: JSON.parse(project.locations || "[]"),
+        providers: parseJsonColumn(project.providers, []),
+        locations: parseJsonColumn(project.locations, []),
         ...project.defaultLocation ? { defaultLocation: project.defaultLocation } : {},
         notifications: notificationRows.map((row) => {
-          const cfg = JSON.parse(row.config);
+          const cfg = parseJsonColumn(row.config, { url: "", events: [] });
           return {
             channel: row.channel,
             url: cfg.url,
@@ -2135,7 +2077,7 @@ async function projectRoutes(app, opts) {
           schedule: {
             ...schedule.preset ? { preset: schedule.preset } : { cron: schedule.cronExpr },
             timezone: schedule.timezone,
-            providers: JSON.parse(schedule.providers || "[]")
+            providers: parseJsonColumn(schedule.providers, [])
           }
         } : {}
       }
@@ -2149,13 +2091,13 @@ function formatProject(row) {
     name: row.name,
     displayName: row.displayName,
     canonicalDomain: row.canonicalDomain,
-    ownedDomains: JSON.parse(row.ownedDomains || "[]"),
+    ownedDomains: parseJsonColumn(row.ownedDomains, []),
     country: row.country,
     language: row.language,
-    tags: JSON.parse(row.tags),
-    labels: JSON.parse(row.labels),
-    providers: JSON.parse(row.providers || "[]"),
-    locations: JSON.parse(row.locations || "[]"),
+    tags: parseJsonColumn(row.tags, []),
+    labels: parseJsonColumn(row.labels, {}),
+    providers: parseJsonColumn(row.providers, []),
+    locations: parseJsonColumn(row.locations, []),
     defaultLocation: row.defaultLocation,
     configSource: row.configSource,
     configRevision: row.configRevision,
@@ -2169,18 +2111,15 @@ import crypto5 from "crypto";
 import { eq as eq4 } from "drizzle-orm";
 async function keywordRoutes(app, opts) {
   app.get("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.put("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords)) {
-      const err = validationError('Body must contain a "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "keywords" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
@@ -2205,12 +2144,10 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.delete("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords) || body.keywords.length === 0) {
-      const err = validationError('Body must contain a non-empty "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a non-empty "keywords" array');
     }
     const existing = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     const toDelete = new Set(body.keywords);
@@ -2233,12 +2170,10 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.post("/projects/:name/keywords", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.keywords)) {
-      const err = validationError('Body must contain a "keywords" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "keywords" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
@@ -2269,30 +2204,25 @@ async function keywordRoutes(app, opts) {
     return reply.send(rows.map((r) => ({ id: r.id, keyword: r.keyword, createdAt: r.createdAt })));
   });
   app.post("/projects/:name/keywords/generate", async (request, reply) => {
-    const project = resolveProjectSafe(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body?.provider || typeof body.provider !== "string") {
-      const err = validationError('Body must contain a "provider" string');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "provider" string');
     }
     const provider = body.provider.trim().toLowerCase();
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && !validNames.includes(provider)) {
-      const err = validationError(`Unknown provider "${body.provider}". Valid providers: ${validNames.join(", ")}`, {
+      throw validationError(`Unknown provider "${body.provider}". Valid providers: ${validNames.join(", ")}`, {
         provider: body.provider,
         validProviders: validNames
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (body.count !== void 0 && (typeof body.count !== "number" || !Number.isFinite(body.count) || !Number.isInteger(body.count))) {
-      const err = validationError('"count" must be an integer');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('"count" must be an integer');
     }
     const count = Math.min(Math.max(body.count ?? 5, 1), 20);
     if (!opts.onGenerateKeywords) {
-      const err = notImplemented("Key phrase generation is not supported in this deployment");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notImplemented("Key phrase generation is not supported in this deployment");
     }
     const existingRows = app.db.select().from(keywords).where(eq4(keywords.projectId, project.id)).all();
     const existingKeywords = existingRows.map((r) => r.keyword);
@@ -2316,36 +2246,21 @@ async function keywordRoutes(app, opts) {
     }
   });
 }
-function resolveProjectSafe(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/competitors.ts
 import crypto6 from "crypto";
 import { eq as eq5 } from "drizzle-orm";
 async function competitorRoutes(app) {
   app.get("/projects/:name/competitors", async (request, reply) => {
-    const project = resolveProjectSafe2(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(competitors).where(eq5(competitors.projectId, project.id)).all();
     return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
   });
   app.put("/projects/:name/competitors", async (request, reply) => {
-    const project = resolveProjectSafe2(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const body = request.body;
     if (!body || !Array.isArray(body.competitors)) {
-      const err = validationError('Body must contain a "competitors" array');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('Body must contain a "competitors" array');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
@@ -2370,18 +2285,6 @@ async function competitorRoutes(app) {
     return reply.send(rows.map((r) => ({ id: r.id, domain: r.domain, createdAt: r.createdAt })));
   });
 }
-function resolveProjectSafe2(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/runs.ts
 import crypto8 from "crypto";
@@ -2389,7 +2292,7 @@ import { eq as eq7, asc, desc } from "drizzle-orm";
 
 // ../api-routes/src/run-queue.ts
 import crypto7 from "crypto";
-import { and as and2, eq as eq6, or } from "drizzle-orm";
+import { and, eq as eq6, or } from "drizzle-orm";
 function queueRunIfProjectIdle(db, params) {
   const createdAt = params.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const kind = params.kind ?? "answer-visibility";
@@ -2397,7 +2300,7 @@ function queueRunIfProjectIdle(db, params) {
   const runId = crypto7.randomUUID();
   return db.transaction((tx) => {
     const activeRun = tx.select().from(runs).where(
-      and2(
+      and(
         eq6(runs.projectId, params.projectId),
         or(eq6(runs.status, "queued"), eq6(runs.status, "running"))
       )
@@ -2421,13 +2324,9 @@ function queueRunIfProjectIdle(db, params) {
 // ../api-routes/src/runs.ts
 async function runRoutes(app, opts) {
   app.post("/projects/:name/runs", async (request, reply) => {
-    const project = resolveProjectSafe3(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const kind = request.body?.kind ?? "answer-visibility";
-    if (kind !== "answer-visibility") {
-      const err = unsupportedKind(kind);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (kind !== "answer-visibility") throw unsupportedKind(kind);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const trigger = request.body?.trigger ?? "manual";
     const rawProviders = request.body?.providers;
@@ -2437,31 +2336,30 @@ async function runRoutes(app, opts) {
       if (validNames.length) {
         const invalid = normalized.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: invalid,
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
       rawProviders.splice(0, rawProviders.length, ...normalized);
     }
     const providers = rawProviders?.length ? rawProviders : void 0;
     let resolvedLocation;
-    const projectLocations = JSON.parse(project.locations || "[]");
+    const projectLocations = parseJsonColumn(project.locations, []);
     if (request.body?.noLocation) {
       resolvedLocation = null;
     } else if (request.body?.allLocations) {
     } else if (request.body?.location) {
       const loc = projectLocations.find((l) => l.label === request.body.location);
       if (!loc) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `Location "${request.body.location}" not found. Configure it first.` } });
+        throw validationError(`Location "${request.body.location}" not found. Configure it first.`);
       }
       resolvedLocation = loc;
     }
     if (request.body?.allLocations) {
       if (projectLocations.length === 0) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: "No locations configured for this project" } });
+        throw validationError("No locations configured for this project");
       }
       const newRuns = [];
       for (const loc of projectLocations) {
@@ -2502,10 +2400,7 @@ async function runRoutes(app, opts) {
       trigger,
       location: locationLabel
     });
-    if (queueResult.conflict) {
-      const err = runInProgress(project.name);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (queueResult.conflict) throw runInProgress(project.name);
     const runId = queueResult.runId;
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -2521,8 +2416,7 @@ async function runRoutes(app, opts) {
     return reply.status(201).send(formatRun(run));
   });
   app.get("/projects/:name/runs", async (request, reply) => {
-    const project = resolveProjectSafe3(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const parsedLimit = parseInt(request.query.limit ?? "", 10);
     const limit = Number.isNaN(parsedLimit) || parsedLimit <= 0 ? void 0 : parsedLimit;
     const rows = limit == null ? app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(asc(runs.createdAt)).all() : app.db.select().from(runs).where(eq7(runs.projectId, project.id)).orderBy(desc(runs.createdAt)).limit(limit).all().reverse();
@@ -2538,10 +2432,7 @@ async function runRoutes(app, opts) {
       return reply.status(207).send([]);
     }
     const kind = request.body?.kind ?? "answer-visibility";
-    if (kind !== "answer-visibility") {
-      const err = unsupportedKind(kind);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (kind !== "answer-visibility") throw unsupportedKind(kind);
     const rawProviders = request.body?.providers;
     if (rawProviders?.length) {
       const normalized = rawProviders.map((p) => p.trim().toLowerCase()).filter(Boolean);
@@ -2549,11 +2440,10 @@ async function runRoutes(app, opts) {
       if (validNames.length) {
         const invalid = normalized.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: invalid,
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
       rawProviders.splice(0, rawProviders.length, ...normalized);
@@ -2590,15 +2480,9 @@ async function runRoutes(app, opts) {
   });
   app.post("/runs/:id/cancel", async (request, reply) => {
     const run = app.db.select().from(runs).where(eq7(runs.id, request.params.id)).get();
-    if (!run) {
-      const err = notFound("Run", request.params.id);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (!run) throw notFound("Run", request.params.id);
     const terminalStatuses = /* @__PURE__ */ new Set(["completed", "partial", "failed", "cancelled"]);
-    if (terminalStatuses.has(run.status)) {
-      const err = runNotCancellable(run.id, run.status);
-      return reply.status(err.statusCode).send(err.toJSON());
-    }
+    if (terminalStatuses.has(run.status)) throw runNotCancellable(run.id, run.status);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.update(runs).set({ status: "cancelled", finishedAt: now, error: "Cancelled by user" }).where(eq7(runs.id, run.id)).run();
     writeAuditLog(app.db, {
@@ -2613,9 +2497,7 @@ async function runRoutes(app, opts) {
   });
   app.get("/runs/:id", async (request, reply) => {
     const run = app.db.select().from(runs).where(eq7(runs.id, request.params.id)).get();
-    if (!run) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `Run '${request.params.id}' not found` } });
-    }
+    if (!run) throw notFound("Run", request.params.id);
     const snapshots = app.db.select({
       id: querySnapshots.id,
       runId: querySnapshots.runId,
@@ -2644,9 +2526,9 @@ async function runRoutes(app, opts) {
           provider: s.provider,
           citationState: s.citationState,
           answerText: s.answerText,
-          citedDomains: tryParseJson(s.citedDomains, []),
-          competitorOverlap: tryParseJson(s.competitorOverlap, []),
-          recommendedCompetitors: tryParseJson(s.recommendedCompetitors, []),
+          citedDomains: parseJsonColumn(s.citedDomains, []),
+          competitorOverlap: parseJsonColumn(s.competitorOverlap, []),
+          recommendedCompetitors: parseJsonColumn(s.recommendedCompetitors, []),
           model: s.model ?? rawParsed.model,
           location: s.location,
           groundingSources: rawParsed.groundingSources,
@@ -2672,32 +2554,13 @@ function formatRun(row) {
   };
 }
 function parseSnapshotRawResponse(raw) {
-  const parsed = tryParseJson(raw ?? "{}", {});
+  const parsed = parseJsonColumn(raw, {});
   return {
     groundingSources: parsed.groundingSources ?? [],
     searchQueries: parsed.searchQueries ?? [],
     model: parsed.model ?? null
   };
 }
-function tryParseJson(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-function resolveProjectSafe3(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/apply.ts
 import crypto10 from "crypto";
@@ -2955,10 +2818,9 @@ async function applyRoutes(app, opts) {
   app.post("/apply", async (request, reply) => {
     const parsed = projectConfigSchema.safeParse(request.body);
     if (!parsed.success) {
-      const err = validationError("Invalid project config", {
+      throw validationError("Invalid project config", {
         issues: parsed.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const config = parsed.data;
     const validNames = opts?.validProviderNames ?? [];
@@ -2970,70 +2832,104 @@ async function applyRoutes(app, opts) {
       if (allProviders.length) {
         const invalid = allProviders.filter((p) => !validNames.includes(p));
         if (invalid.length) {
-          const err = validationError(`Invalid provider(s): ${[...new Set(invalid)].join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+          throw validationError(`Invalid provider(s): ${[...new Set(invalid)].join(", ")}. Must be one of: ${validNames.join(", ")}`, {
             invalidProviders: [...new Set(invalid)],
             validProviders: validNames
           });
-          return reply.status(err.statusCode).send(err.toJSON());
         }
       }
     }
+    let resolvedSchedule = null;
+    let deleteSchedule = false;
+    if (config.spec.schedule) {
+      const schedSpec = config.spec.schedule;
+      let cronExpr;
+      let preset = null;
+      if (schedSpec.preset) {
+        preset = schedSpec.preset;
+        try {
+          cronExpr = resolvePreset(schedSpec.preset);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          throw validationError(msg);
+        }
+      } else if (schedSpec.cron) {
+        cronExpr = schedSpec.cron;
+        if (!validateCron(cronExpr)) throw validationError(`Invalid cron expression in schedule: ${cronExpr}`);
+      } else {
+        throw validationError('Schedule requires either "preset" or "cron"');
+      }
+      const timezone = schedSpec.timezone ?? "UTC";
+      if (!isValidTimezone(timezone)) throw validationError(`Invalid timezone: ${timezone}`);
+      resolvedSchedule = { cronExpr, preset, timezone };
+    } else {
+      deleteSchedule = true;
+    }
+    const rawSpec = request.body?.spec ?? {};
+    const hasNotifications = "notifications" in rawSpec;
+    if (hasNotifications) {
+      for (const notif of config.spec.notifications) {
+        const urlCheck = await resolveWebhookTarget(notif.url ?? "");
+        if (!urlCheck.ok) throw validationError(`Notification URL invalid: ${urlCheck.message}`);
+      }
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const name = config.metadata.name;
-    const existing = app.db.select().from(projects).where(eq8(projects.name, name)).get();
     let projectId;
-    if (existing) {
-      projectId = existing.id;
-      app.db.update(projects).set({
-        displayName: config.spec.displayName,
-        canonicalDomain: config.spec.canonicalDomain,
-        ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
-        country: config.spec.country,
-        language: config.spec.language,
-        labels: JSON.stringify(config.metadata.labels),
-        providers: JSON.stringify(config.spec.providers ?? []),
-        locations: JSON.stringify(config.spec.locations ?? []),
-        defaultLocation: config.spec.defaultLocation ?? null,
-        configSource: "config-file",
-        configRevision: existing.configRevision + 1,
-        updatedAt: now
-      }).where(eq8(projects.id, existing.id)).run();
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "project.applied",
-        entityType: "project",
-        entityId: projectId
-      });
-    } else {
-      projectId = crypto10.randomUUID();
-      app.db.insert(projects).values({
-        id: projectId,
-        name,
-        displayName: config.spec.displayName,
-        canonicalDomain: config.spec.canonicalDomain,
-        ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
-        country: config.spec.country,
-        language: config.spec.language,
-        tags: "[]",
-        labels: JSON.stringify(config.metadata.labels),
-        providers: JSON.stringify(config.spec.providers ?? []),
-        locations: JSON.stringify(config.spec.locations ?? []),
-        defaultLocation: config.spec.defaultLocation ?? null,
-        configSource: "config-file",
-        configRevision: 1,
-        createdAt: now,
-        updatedAt: now
-      }).run();
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "project.created",
-        entityType: "project",
-        entityId: projectId
-      });
-    }
+    let scheduleAction = null;
     app.db.transaction((tx) => {
+      const existing = tx.select().from(projects).where(eq8(projects.name, name)).get();
+      if (existing) {
+        projectId = existing.id;
+        tx.update(projects).set({
+          displayName: config.spec.displayName,
+          canonicalDomain: config.spec.canonicalDomain,
+          ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
+          country: config.spec.country,
+          language: config.spec.language,
+          labels: JSON.stringify(config.metadata.labels),
+          providers: JSON.stringify(config.spec.providers ?? []),
+          locations: JSON.stringify(config.spec.locations ?? []),
+          defaultLocation: config.spec.defaultLocation ?? null,
+          configSource: "config-file",
+          configRevision: existing.configRevision + 1,
+          updatedAt: now
+        }).where(eq8(projects.id, existing.id)).run();
+        writeAuditLog(tx, {
+          projectId,
+          actor: "api",
+          action: "project.applied",
+          entityType: "project",
+          entityId: projectId
+        });
+      } else {
+        projectId = crypto10.randomUUID();
+        tx.insert(projects).values({
+          id: projectId,
+          name,
+          displayName: config.spec.displayName,
+          canonicalDomain: config.spec.canonicalDomain,
+          ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
+          country: config.spec.country,
+          language: config.spec.language,
+          tags: "[]",
+          labels: JSON.stringify(config.metadata.labels),
+          providers: JSON.stringify(config.spec.providers ?? []),
+          locations: JSON.stringify(config.spec.locations ?? []),
+          defaultLocation: config.spec.defaultLocation ?? null,
+          configSource: "config-file",
+          configRevision: 1,
+          createdAt: now,
+          updatedAt: now
+        }).run();
+        writeAuditLog(tx, {
+          projectId,
+          actor: "api",
+          action: "project.created",
+          entityType: "project",
+          entityId: projectId
+        });
+      }
       tx.delete(keywords).where(eq8(keywords.projectId, projectId)).run();
       for (const kw of config.spec.keywords) {
         tx.insert(keywords).values({
@@ -3066,98 +2962,63 @@ async function applyRoutes(app, opts) {
         entityType: "competitor",
         diff: { competitors: config.spec.competitors }
       });
-    });
-    if (config.spec.schedule) {
-      const schedSpec = config.spec.schedule;
-      let cronExpr;
-      let preset = null;
-      if (schedSpec.preset) {
-        preset = schedSpec.preset;
-        try {
-          cronExpr = resolvePreset(schedSpec.preset);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: msg } });
+      if (resolvedSchedule) {
+        const existingSched = tx.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
+        if (existingSched) {
+          tx.update(schedules).set({
+            cronExpr: resolvedSchedule.cronExpr,
+            preset: resolvedSchedule.preset,
+            timezone: resolvedSchedule.timezone,
+            providers: JSON.stringify(config.spec.schedule?.providers ?? []),
+            enabled: 1,
+            updatedAt: now
+          }).where(eq8(schedules.id, existingSched.id)).run();
+        } else {
+          tx.insert(schedules).values({
+            id: crypto10.randomUUID(),
+            projectId,
+            cronExpr: resolvedSchedule.cronExpr,
+            preset: resolvedSchedule.preset,
+            timezone: resolvedSchedule.timezone,
+            enabled: 1,
+            providers: JSON.stringify(config.spec.schedule?.providers ?? []),
+            createdAt: now,
+            updatedAt: now
+          }).run();
         }
-      } else if (schedSpec.cron) {
-        cronExpr = schedSpec.cron;
-        if (!validateCron(cronExpr)) {
-          return reply.status(400).send({
-            error: { code: "VALIDATION_ERROR", message: `Invalid cron expression in schedule: ${cronExpr}` }
-          });
+        scheduleAction = "upsert";
+      } else if (deleteSchedule) {
+        const existingSched = tx.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
+        if (existingSched) {
+          tx.delete(schedules).where(eq8(schedules.projectId, projectId)).run();
+          scheduleAction = "delete";
         }
-      } else {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: 'Schedule requires either "preset" or "cron"' }
-        });
-      }
-      const timezone = schedSpec.timezone ?? "UTC";
-      if (!isValidTimezone(timezone)) {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: `Invalid timezone: ${timezone}` }
-        });
       }
-      const existingSched = app.db.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
-      if (existingSched) {
-        app.db.update(schedules).set({
-          cronExpr,
-          preset,
-          timezone,
-          providers: JSON.stringify(schedSpec.providers ?? []),
-          enabled: 1,
-          updatedAt: now
-        }).where(eq8(schedules.id, existingSched.id)).run();
-      } else {
-        app.db.insert(schedules).values({
-          id: crypto10.randomUUID(),
-          projectId,
-          cronExpr,
-          preset,
-          timezone,
-          enabled: 1,
-          providers: JSON.stringify(schedSpec.providers ?? []),
-          createdAt: now,
-          updatedAt: now
-        }).run();
-      }
-      opts?.onScheduleUpdated?.("upsert", projectId);
-    } else {
-      const existingSched = app.db.select().from(schedules).where(eq8(schedules.projectId, projectId)).get();
-      if (existingSched) {
-        app.db.delete(schedules).where(eq8(schedules.projectId, projectId)).run();
-        opts?.onScheduleUpdated?.("delete", projectId);
-      }
-    }
-    const rawSpec = request.body?.spec ?? {};
-    if ("notifications" in rawSpec) {
-      for (const notif of config.spec.notifications) {
-        const urlCheck = await resolveWebhookTarget(notif.url ?? "");
-        if (!urlCheck.ok) {
-          return reply.status(400).send({
-            error: { code: "VALIDATION_ERROR", message: `Notification URL invalid: ${urlCheck.message}` }
-          });
+      if (hasNotifications) {
+        tx.delete(notifications).where(eq8(notifications.projectId, projectId)).run();
+        for (const notif of config.spec.notifications) {
+          tx.insert(notifications).values({
+            id: crypto10.randomUUID(),
+            projectId,
+            channel: notif.channel,
+            config: JSON.stringify({ url: notif.url, events: notif.events }),
+            webhookSecret: crypto10.randomBytes(32).toString("hex"),
+            enabled: 1,
+            createdAt: now,
+            updatedAt: now
+          }).run();
         }
-      }
-      app.db.delete(notifications).where(eq8(notifications.projectId, projectId)).run();
-      for (const notif of config.spec.notifications) {
-        app.db.insert(notifications).values({
-          id: crypto10.randomUUID(),
+        writeAuditLog(tx, {
           projectId,
-          channel: notif.channel,
-          config: JSON.stringify({ url: notif.url, events: notif.events }),
-          webhookSecret: crypto10.randomBytes(32).toString("hex"),
-          enabled: 1,
-          createdAt: now,
-          updatedAt: now
-        }).run();
+          actor: "api",
+          action: "notifications.replaced",
+          entityType: "notification",
+          diff: { notifications: config.spec.notifications }
+        });
       }
-      writeAuditLog(app.db, {
-        projectId,
-        actor: "api",
-        action: "notifications.replaced",
-        entityType: "notification",
-        diff: { notifications: config.spec.notifications }
-      });
+    });
+    if (scheduleAction) {
+      opts?.onScheduleUpdated?.(scheduleAction, projectId);
     }
     if ("google" in rawSpec && config.spec.google?.gsc?.propertyUrl) {
       opts?.onGoogleConnectionPropertyUpdated?.(config.spec.canonicalDomain, "gsc", config.spec.google.gsc.propertyUrl);
@@ -3168,13 +3029,13 @@ async function applyRoutes(app, opts) {
       name: project.name,
       displayName: project.displayName,
       canonicalDomain: project.canonicalDomain,
-      ownedDomains: JSON.parse(project.ownedDomains || "[]"),
+      ownedDomains: parseJsonColumn(project.ownedDomains, []),
       country: project.country,
       language: project.language,
-      tags: JSON.parse(project.tags),
-      labels: JSON.parse(project.labels),
-      providers: JSON.parse(project.providers || "[]"),
-      locations: JSON.parse(project.locations || "[]"),
+      tags: parseJsonColumn(project.tags, []),
+      labels: parseJsonColumn(project.labels, {}),
+      providers: parseJsonColumn(project.providers, []),
+      locations: parseJsonColumn(project.locations, []),
       defaultLocation: project.defaultLocation,
       configSource: project.configSource,
       configRevision: project.configRevision,
@@ -3230,8 +3091,7 @@ function redactNotificationDiff(value) {
 // ../api-routes/src/history.ts
 async function historyRoutes(app) {
   app.get("/projects/:name/history", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(auditLog).where(eq9(auditLog.projectId, project.id)).orderBy(desc2(auditLog.createdAt)).all();
     return reply.send(rows.map(formatAuditEntry));
   });
@@ -3240,8 +3100,7 @@ async function historyRoutes(app) {
     return reply.send(rows.map(formatAuditEntry));
   });
   app.get("/projects/:name/snapshots", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const limit = parseInt(request.query.limit ?? "50", 10);
     const offset = parseInt(request.query.offset ?? "0", 10);
     const projectRuns = app.db.select({ id: runs.id }).from(runs).where(eq9(runs.projectId, project.id)).all();
@@ -3277,9 +3136,9 @@ async function historyRoutes(app) {
         model: s.model,
         citationState: s.citationState,
         answerText: s.answerText,
-        citedDomains: tryParseJson2(s.citedDomains, []),
-        competitorOverlap: tryParseJson2(s.competitorOverlap, []),
-        recommendedCompetitors: tryParseJson2(s.recommendedCompetitors, []),
+        citedDomains: parseJsonColumn(s.citedDomains, []),
+        competitorOverlap: parseJsonColumn(s.competitorOverlap, []),
+        recommendedCompetitors: parseJsonColumn(s.recommendedCompetitors, []),
         location: s.location,
         createdAt: s.createdAt
       })),
@@ -3287,8 +3146,7 @@ async function historyRoutes(app) {
     });
   });
   app.get("/projects/:name/timeline", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const projectKeywords = app.db.select().from(keywords).where(eq9(keywords.projectId, project.id)).all();
     const projectRuns = app.db.select().from(runs).where(eq9(runs.projectId, project.id)).orderBy(runs.createdAt).all();
     if (projectRuns.length === 0 || projectKeywords.length === 0) {
@@ -3370,11 +3228,10 @@ async function historyRoutes(app) {
     return reply.send(timeline);
   });
   app.get("/projects/:name/snapshots/diff", async (request, reply) => {
-    const project = resolveProjectSafe4(app, request.params.name, reply);
-    if (!project) return;
+    resolveProject(app.db, request.params.name);
     const { run1, run2 } = request.query;
     if (!run1 || !run2) {
-      return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: "Both run1 and run2 query params are required" } });
+      throw validationError("Both run1 and run2 query params are required");
     }
     const snaps1 = app.db.select({
       keywordId: querySnapshots.keywordId,
@@ -3419,36 +3276,16 @@ function formatAuditEntry(row) {
     action: row.action,
     entityType: row.entityType,
     entityId: row.entityId,
-    diff: row.diff ? row.entityType === "notification" ? redactNotificationDiff(tryParseJson2(row.diff, null)) : tryParseJson2(row.diff, null) : null,
+    diff: row.diff ? row.entityType === "notification" ? redactNotificationDiff(parseJsonColumn(row.diff, null)) : parseJsonColumn(row.diff, null) : null,
     createdAt: row.createdAt
   };
 }
-function tryParseJson2(value, fallback) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-function resolveProjectSafe4(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/analytics.ts
 import { eq as eq10, desc as desc3, inArray as inArray2 } from "drizzle-orm";
 async function analyticsRoutes(app) {
   app.get("/projects/:name/analytics/metrics", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const projectRuns = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(runs.createdAt).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
@@ -3488,8 +3325,7 @@ async function analyticsRoutes(app) {
     return reply.send({ window, buckets, overall, byProvider, trend, keywordChanges });
   });
   app.get("/projects/:name/analytics/gaps", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const latestRun = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(desc3(runs.createdAt)).all().find((r) => r.status === "completed" || r.status === "partial");
@@ -3537,7 +3373,7 @@ async function analyticsRoutes(app) {
       const citedProviders = kwSnapshots.filter((s) => s.citationState === "cited").map((s) => s.provider);
       const competitorsCiting = /* @__PURE__ */ new Set();
       for (const s of kwSnapshots) {
-        const overlap = tryParseJson3(s.competitorOverlap, []);
+        const overlap = parseJsonColumn(s.competitorOverlap, []);
         for (const c of overlap) competitorsCiting.add(c);
       }
       let category;
@@ -3570,8 +3406,7 @@ async function analyticsRoutes(app) {
     return reply.send({ cited, gap, uncited, runId: latestRun.id, window });
   });
   app.get("/projects/:name/analytics/sources", async (request, reply) => {
-    const project = resolveProjectSafe5(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const window = parseWindow(request.query.window);
     const cutoff = windowCutoff(window);
     const windowRuns = app.db.select().from(runs).where(eq10(runs.projectId, project.id)).orderBy(desc3(runs.createdAt)).all().filter((r) => r.status === "completed" || r.status === "partial").filter((r) => !cutoff || r.createdAt >= cutoff);
@@ -3607,26 +3442,6 @@ async function analyticsRoutes(app) {
     return reply.send({ overall, byKeyword, runId: latestRunId, window });
   });
 }
-function resolveProjectSafe5(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
-function tryParseJson3(value, fallback) {
-  if (!value) return fallback;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
 var PROVIDER_INFRA_DOMAINS = /* @__PURE__ */ new Set([
   "vertexaisearch.cloud.google.com",
   "openai.com",
@@ -3644,7 +3459,7 @@ function isProviderInfraDomain(uri) {
   return false;
 }
 function parseGroundingSources(rawResponse) {
-  const parsed = tryParseJson3(rawResponse, {});
+  const parsed = parseJsonColumn(rawResponse, {});
   const sources = parsed.groundingSources;
   if (!Array.isArray(sources)) return [];
   return sources.filter(
@@ -6014,34 +5829,29 @@ import crypto11 from "crypto";
 import { eq as eq11 } from "drizzle-orm";
 async function scheduleRoutes(app, opts) {
   app.put("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const parsedBody = scheduleUpsertRequestSchema.safeParse(request.body);
     if (!parsedBody.success) {
-      const err = validationError("Invalid schedule payload", {
+      throw validationError("Invalid schedule payload", {
         issues: parsedBody.error.issues.map((issue) => ({
           path: issue.path.join("."),
           message: issue.message
         }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const { preset, cron: cron2, timezone, providers, enabled } = parsedBody.data;
     const validNames = opts.validProviderNames ?? [];
     if (validNames.length && providers?.length) {
       const invalid = providers.filter((p) => !validNames.includes(p));
       if (invalid.length) {
-        const err = validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
+        throw validationError(`Invalid provider(s): ${invalid.join(", ")}. Must be one of: ${validNames.join(", ")}`, {
           invalidProviders: invalid,
           validProviders: validNames
         });
-        return reply.status(err.statusCode).send(err.toJSON());
       }
     }
     if (!isValidTimezone(timezone)) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Invalid timezone: ${timezone}` }
-      });
+      throw validationError(`Invalid timezone: ${timezone}`);
     }
     let cronExpr;
     if (preset) {
@@ -6049,14 +5859,12 @@ async function scheduleRoutes(app, opts) {
         cronExpr = resolvePreset(preset);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: msg } });
+        throw validationError(msg);
       }
     } else {
       cronExpr = cron2;
       if (!validateCron(cronExpr)) {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: `Invalid cron expression: ${cronExpr}` }
-        });
+        throw validationError(`Invalid cron expression: ${cronExpr}`);
       }
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -6096,20 +5904,18 @@ async function scheduleRoutes(app, opts) {
     return reply.status(existing ? 200 : 201).send(formatSchedule(schedule));
   });
   app.get("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const schedule = app.db.select().from(schedules).where(eq11(schedules.projectId, project.id)).get();
     if (!schedule) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `No schedule for project '${request.params.name}'` } });
+      throw notFound("Schedule", request.params.name);
     }
     return reply.send(formatSchedule(schedule));
   });
   app.delete("/projects/:name/schedule", async (request, reply) => {
-    const project = resolveProjectSafe6(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const schedule = app.db.select().from(schedules).where(eq11(schedules.projectId, project.id)).get();
     if (!schedule) {
-      return reply.status(404).send({ error: { code: "NOT_FOUND", message: `No schedule for project '${request.params.name}'` } });
+      throw notFound("Schedule", request.params.name);
     }
     app.db.delete(schedules).where(eq11(schedules.id, schedule.id)).run();
     writeAuditLog(app.db, {
@@ -6131,25 +5937,13 @@ function formatSchedule(row) {
     preset: row.preset,
     timezone: row.timezone,
     enabled: row.enabled === 1,
-    providers: JSON.parse(row.providers),
+    providers: parseJsonColumn(row.providers, []),
     lastRunAt: row.lastRunAt,
     nextRunAt: row.nextRunAt,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt
   };
 }
-function resolveProjectSafe6(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/notifications.ts
 import crypto12 from "crypto";
@@ -6160,30 +5954,15 @@ async function notificationRoutes(app) {
     return reply.send(VALID_EVENTS);
   });
   app.post("/projects/:name/notifications", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const { channel, url, events } = request.body ?? {};
-    if (channel !== "webhook") {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: 'Only "webhook" channel is supported' }
-      });
-    }
+    if (channel !== "webhook") throw validationError('Only "webhook" channel is supported');
     const urlCheck = await resolveWebhookTarget(url ?? "");
-    if (!urlCheck.ok) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: urlCheck.message }
-      });
-    }
-    if (!events?.length) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: '"events" must be a non-empty array' }
-      });
-    }
+    if (!urlCheck.ok) throw validationError(urlCheck.message);
+    if (!events?.length) throw validationError('"events" must be a non-empty array');
     const invalid = events.filter((e) => !VALID_EVENTS.includes(e));
     if (invalid.length) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Invalid event(s): ${invalid.join(", ")}. Must be one of: ${VALID_EVENTS.join(", ")}` }
-      });
+      throw validationError(`Invalid event(s): ${invalid.join(", ")}. Must be one of: ${VALID_EVENTS.join(", ")}`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const id = crypto12.randomUUID();
@@ -6212,19 +5991,15 @@ async function notificationRoutes(app) {
     });
   });
   app.get("/projects/:name/notifications", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const rows = app.db.select().from(notifications).where(eq12(notifications.projectId, project.id)).all();
     return reply.send(rows.map(formatNotification));
   });
   app.delete("/projects/:name/notifications/:id", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const notification = app.db.select().from(notifications).where(eq12(notifications.id, request.params.id)).get();
     if (!notification || notification.projectId !== project.id) {
-      return reply.status(404).send({
-        error: { code: "NOT_FOUND", message: `Notification '${request.params.id}' not found` }
-      });
+      throw notFound("Notification", request.params.id);
     }
     app.db.delete(notifications).where(eq12(notifications.id, notification.id)).run();
     writeAuditLog(app.db, {
@@ -6237,21 +6012,14 @@ async function notificationRoutes(app) {
     return reply.status(204).send();
   });
   app.post("/projects/:name/notifications/:id/test", async (request, reply) => {
-    const project = resolveProjectSafe7(app, request.params.name, reply);
-    if (!project) return;
+    const project = resolveProject(app.db, request.params.name);
     const notification = app.db.select().from(notifications).where(eq12(notifications.id, request.params.id)).get();
     if (!notification || notification.projectId !== project.id) {
-      return reply.status(404).send({
-        error: { code: "NOT_FOUND", message: `Notification '${request.params.id}' not found` }
-      });
+      throw notFound("Notification", request.params.id);
     }
-    const config = JSON.parse(notification.config);
+    const config = parseJsonColumn(notification.config, { url: "", events: [] });
     const urlCheck = await resolveWebhookTarget(config.url);
-    if (!urlCheck.ok) {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: `Stored webhook URL is invalid: ${urlCheck.message}` }
-      });
-    }
+    if (!urlCheck.ok) throw validationError(`Stored webhook URL is invalid: ${urlCheck.message}`);
     const payload = {
       source: "canonry",
       event: "run.completed",
@@ -6274,14 +6042,12 @@ async function notificationRoutes(app) {
       entityId: notification.id,
       diff: { status, error }
     });
-    if (error) {
-      return reply.status(502).send({ error: { code: "DELIVERY_FAILED", message: error } });
-    }
+    if (error) throw deliveryFailed(error);
     return reply.send({ status, ok: status >= 200 && status < 300 });
   });
 }
 function formatNotification(row) {
-  const config = JSON.parse(row.config);
+  const config = parseJsonColumn(row.config, { url: "", events: [] });
   const redacted = redactNotificationUrl(config.url);
   return {
     id: row.id,
@@ -6296,22 +6062,10 @@ function formatNotification(row) {
     updatedAt: row.updatedAt
   };
 }
-function resolveProjectSafe7(app, name, reply) {
-  try {
-    return resolveProject(app.db, name);
-  } catch (e) {
-    if (e && typeof e === "object" && "statusCode" in e && "toJSON" in e) {
-      const err = e;
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
-    }
-    throw e;
-  }
-}
 
 // ../api-routes/src/google.ts
 import crypto13 from "crypto";
-import { eq as eq13, and as and3, desc as desc4, sql as sql2 } from "drizzle-orm";
+import { eq as eq13, and as and2, desc as desc4, sql as sql3 } from "drizzle-orm";
 
 // ../integration-google/src/constants.ts
 var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
@@ -6758,11 +6512,11 @@ async function googleRoutes(app, opts) {
     const project = resolveProject(app.db, request.params.name);
     const { startDate, endDate, query, page, limit } = request.query;
     const conditions = [eq13(gscSearchData.projectId, project.id)];
-    if (startDate) conditions.push(sql2`${gscSearchData.date} >= ${startDate}`);
-    if (endDate) conditions.push(sql2`${gscSearchData.date} <= ${endDate}`);
-    if (query) conditions.push(sql2`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
-    if (page) conditions.push(sql2`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
-    const rows = app.db.select().from(gscSearchData).where(and3(...conditions)).orderBy(desc4(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
+    if (startDate) conditions.push(sql3`${gscSearchData.date} >= ${startDate}`);
+    if (endDate) conditions.push(sql3`${gscSearchData.date} <= ${endDate}`);
+    if (query) conditions.push(sql3`${gscSearchData.query} LIKE ${"%" + query + "%"}`);
+    if (page) conditions.push(sql3`${gscSearchData.page} LIKE ${"%" + page + "%"}`);
+    const rows = app.db.select().from(gscSearchData).where(and2(...conditions)).orderBy(desc4(gscSearchData.date)).limit(parseInt(limit ?? "500", 10)).all();
     return rows.map((r) => ({
       date: r.date,
       query: r.query,
@@ -6840,7 +6594,7 @@ async function googleRoutes(app, opts) {
     const { url, limit } = request.query;
     const conditions = [eq13(gscUrlInspections.projectId, project.id)];
     if (url) conditions.push(eq13(gscUrlInspections.url, url));
-    const rows = app.db.select().from(gscUrlInspections).where(and3(...conditions)).orderBy(desc4(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
+    const rows = app.db.select().from(gscUrlInspections).where(and2(...conditions)).orderBy(desc4(gscUrlInspections.inspectedAt)).limit(parseInt(limit ?? "100", 10)).all();
     return rows.map((r) => ({
       id: r.id,
       url: r.url,
@@ -7212,7 +6966,7 @@ async function googleRoutes(app, opts) {
 
 // ../api-routes/src/bing.ts
 import crypto14 from "crypto";
-import { eq as eq14, and as and4, desc as desc5 } from "drizzle-orm";
+import { eq as eq14, and as and3, desc as desc5 } from "drizzle-orm";
 
 // ../integration-bing/src/constants.ts
 var BING_WMT_API_BASE = "https://ssl.bing.com/webmaster/api.svc/json";
@@ -7511,7 +7265,7 @@ async function bingRoutes(app, opts) {
     if (!store) return;
     const project = resolveProject(app.db, request.params.name);
     const { url, limit } = request.query;
-    const whereClause = url ? and4(eq14(bingUrlInspections.projectId, project.id), eq14(bingUrlInspections.url, url)) : eq14(bingUrlInspections.projectId, project.id);
+    const whereClause = url ? and3(eq14(bingUrlInspections.projectId, project.id), eq14(bingUrlInspections.url, url)) : eq14(bingUrlInspections.projectId, project.id);
     const filtered = app.db.select().from(bingUrlInspections).where(whereClause).orderBy(desc5(bingUrlInspections.inspectedAt)).limit(Math.max(1, Math.min(parseInt(limit ?? "100", 10) || 100, 1e3))).all();
     return filtered.map((r) => ({
       id: r.id,
@@ -7701,7 +7455,7 @@ async function bingRoutes(app, opts) {
 import fs2 from "fs";
 import path2 from "path";
 import os2 from "os";
-import { eq as eq15, and as and5 } from "drizzle-orm";
+import { eq as eq15, and as and4 } from "drizzle-orm";
 function getScreenshotDir() {
   return path2.join(os2.homedir(), ".canonry", "screenshots");
 }
@@ -7774,7 +7528,7 @@ async function cdpRoutes(app, opts) {
     async (request, reply) => {
       const project = resolveProject(app.db, request.params.name);
       const { runId } = request.params;
-      const run = app.db.select().from(runs).where(and5(eq15(runs.id, runId), eq15(runs.projectId, project.id))).get();
+      const run = app.db.select().from(runs).where(and4(eq15(runs.id, runId), eq15(runs.projectId, project.id))).get();
       if (!run) {
         const err = notFound("Run", runId);
         return reply.code(err.statusCode).send(err.toJSON());
@@ -7871,7 +7625,7 @@ async function cdpRoutes(app, opts) {
 
 // ../api-routes/src/ga.ts
 import crypto16 from "crypto";
-import { eq as eq16, desc as desc6, and as and6, sql as sql3 } from "drizzle-orm";
+import { eq as eq16, desc as desc6, and as and5, sql as sql4 } from "drizzle-orm";
 
 // ../integration-google-analytics/src/ga4-client.ts
 import crypto15 from "crypto";
@@ -8351,10 +8105,10 @@ async function ga4Routes(app, opts) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     app.db.transaction((tx) => {
       tx.delete(gaTrafficSnapshots).where(
-        and6(
+        and5(
           eq16(gaTrafficSnapshots.projectId, project.id),
-          sql3`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
-          sql3`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
+          sql4`${gaTrafficSnapshots.date} >= ${summary.periodStart}`,
+          sql4`${gaTrafficSnapshots.date} <= ${summary.periodEnd}`
         )
       ).run();
       if (rows.length > 0) {
@@ -8372,10 +8126,10 @@ async function ga4Routes(app, opts) {
         }
       }
       tx.delete(gaAiReferrals).where(
-        and6(
+        and5(
           eq16(gaAiReferrals.projectId, project.id),
-          sql3`${gaAiReferrals.date} >= ${summary.periodStart}`,
-          sql3`${gaAiReferrals.date} <= ${summary.periodEnd}`
+          sql4`${gaAiReferrals.date} >= ${summary.periodStart}`,
+          sql4`${gaAiReferrals.date} <= ${summary.periodEnd}`
         )
       ).run();
       if (aiReferrals.length > 0) {
@@ -8436,16 +8190,16 @@ async function ga4Routes(app, opts) {
     }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).get();
     const rows = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql3`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql3`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql3`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
+      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql4`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).limit(limit).all();
     const aiReferrals = app.db.select({
       source: gaAiReferrals.source,
       medium: gaAiReferrals.medium,
-      sessions: sql3`SUM(${gaAiReferrals.sessions})`,
-      users: sql3`SUM(${gaAiReferrals.users})`
-    }).from(gaAiReferrals).where(eq16(gaAiReferrals.projectId, project.id)).groupBy(gaAiReferrals.source, gaAiReferrals.medium).orderBy(sql3`SUM(${gaAiReferrals.sessions}) DESC`).all();
+      sessions: sql4`SUM(${gaAiReferrals.sessions})`,
+      users: sql4`SUM(${gaAiReferrals.users})`
+    }).from(gaAiReferrals).where(eq16(gaAiReferrals.projectId, project.id)).groupBy(gaAiReferrals.source, gaAiReferrals.medium).orderBy(sql4`SUM(${gaAiReferrals.sessions}) DESC`).all();
     const latestSync = app.db.select({ syncedAt: gaTrafficSummaries.syncedAt }).from(gaTrafficSummaries).where(eq16(gaTrafficSummaries.projectId, project.id)).orderBy(desc6(gaTrafficSummaries.syncedAt)).limit(1).get();
     return {
       totalSessions: summary?.totalSessions ?? 0,
@@ -8477,10 +8231,10 @@ async function ga4Routes(app, opts) {
     }
     const trafficPages = app.db.select({
       landingPage: gaTrafficSnapshots.landingPage,
-      sessions: sql3`SUM(${gaTrafficSnapshots.sessions})`,
-      organicSessions: sql3`SUM(${gaTrafficSnapshots.organicSessions})`,
-      users: sql3`SUM(${gaTrafficSnapshots.users})`
-    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql3`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
+      sessions: sql4`SUM(${gaTrafficSnapshots.sessions})`,
+      organicSessions: sql4`SUM(${gaTrafficSnapshots.organicSessions})`,
+      users: sql4`SUM(${gaTrafficSnapshots.users})`
+    }).from(gaTrafficSnapshots).where(eq16(gaTrafficSnapshots.projectId, project.id)).groupBy(gaTrafficSnapshots.landingPage).orderBy(sql4`SUM(${gaTrafficSnapshots.sessions}) DESC`).all();
     return {
       pages: trafficPages.map((r) => ({
         landingPage: r.landingPage,
@@ -12186,7 +11940,7 @@ import crypto18 from "crypto";
 import fs4 from "fs";
 import path5 from "path";
 import os4 from "os";
-import { and as and7, eq as eq17, inArray as inArray3 } from "drizzle-orm";
+import { and as and6, eq as eq17, inArray as inArray3 } from "drizzle-orm";
 
 // src/logger.ts
 var IS_TTY = process.stdout.isTTY === true;
@@ -12336,7 +12090,7 @@ var JobRunner = class {
         throw new Error(`Run ${runId} is not executable from status '${existingRun.status}'`);
       }
       if (existingRun.status === "queued") {
-        this.db.update(runs).set({ status: "running", startedAt: now }).where(and7(eq17(runs.id, runId), eq17(runs.status, "queued"))).run();
+        this.db.update(runs).set({ status: "running", startedAt: now }).where(and6(eq17(runs.id, runId), eq17(runs.status, "queued"))).run();
       }
       this.throwIfRunCancelled(runId);
       const project = this.db.select().from(projects).where(eq17(projects.id, projectId)).get();
@@ -12787,7 +12541,7 @@ function matchesBrandKey(candidateKey, brandKeys) {
 
 // src/gsc-sync.ts
 import crypto19 from "crypto";
-import { eq as eq18, and as and8, sql as sql4 } from "drizzle-orm";
+import { eq as eq18, and as and7, sql as sql5 } from "drizzle-orm";
 var log2 = createLogger("GscSync");
 function formatDate2(d) {
   return d.toISOString().split("T")[0];
@@ -12839,10 +12593,10 @@ async function executeGscSync(db, runId, projectId, opts) {
     });
     log2.info("fetch.complete", { runId, projectId, rowCount: rows.length });
     db.delete(gscSearchData).where(
-      and8(
+      and7(
         eq18(gscSearchData.projectId, projectId),
-        sql4`${gscSearchData.date} >= ${startDate}`,
-        sql4`${gscSearchData.date} <= ${endDate}`
+        sql5`${gscSearchData.date} >= ${startDate}`,
+        sql5`${gscSearchData.date} <= ${endDate}`
       )
     ).run();
     const batchSize = 500;
@@ -12928,7 +12682,7 @@ async function executeGscSync(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = formatDate2(/* @__PURE__ */ new Date());
-    db.delete(gscCoverageSnapshots).where(and8(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and7(eq18(gscCoverageSnapshots.projectId, projectId), eq18(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto19.randomUUID(),
       projectId,
@@ -12951,7 +12705,7 @@ async function executeGscSync(db, runId, projectId, opts) {
 
 // src/gsc-inspect-sitemap.ts
 import crypto20 from "crypto";
-import { eq as eq19, and as and9 } from "drizzle-orm";
+import { eq as eq19, and as and8 } from "drizzle-orm";
 
 // src/sitemap-parser.ts
 var LOC_REGEX = /<loc>\s*([^<]+?)\s*<\/loc>/gi;
@@ -13115,7 +12869,7 @@ async function executeInspectSitemap(db, runId, projectId, opts) {
       }
     }
     const snapshotDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    db.delete(gscCoverageSnapshots).where(and9(eq19(gscCoverageSnapshots.projectId, projectId), eq19(gscCoverageSnapshots.date, snapshotDate))).run();
+    db.delete(gscCoverageSnapshots).where(and8(eq19(gscCoverageSnapshots.projectId, projectId), eq19(gscCoverageSnapshots.date, snapshotDate))).run();
     db.insert(gscCoverageSnapshots).values({
       id: crypto20.randomUUID(),
       projectId,
@@ -13308,7 +13062,7 @@ var Scheduler = class {
 };
 
 // src/notifier.ts
-import { eq as eq21, desc as desc7, and as and10, or as or2 } from "drizzle-orm";
+import { eq as eq21, desc as desc7, and as and9, or as or2 } from "drizzle-orm";
 import crypto21 from "crypto";
 var log5 = createLogger("Notifier");
 var Notifier = class {
@@ -13372,7 +13126,7 @@ var Notifier = class {
   }
   computeTransitions(runId, projectId) {
     const recentRuns = this.db.select().from(runs).where(
-      and10(
+      and9(
         eq21(runs.projectId, projectId),
         or2(eq21(runs.status, "completed"), eq21(runs.status, "partial"))
       )