@ainyc/canonry 2.4.2 → 2.4.5

package/dist/{chunk-Y7GCG4GD.js → chunk-6UY2PETG.js}

@@ -30,7 +30,7 @@ import {
   runs,
   schedules,
   usageCounters
-} from "./chunk-GZF3YIHY.js";
+} from "./chunk-32YTAZBL.js";
 
 // src/config.ts
 import fs from "fs";
@@ -625,6 +625,9 @@ function agentBusy(projectName) {
 function missingDependency(message, details) {
   return new AppError("MISSING_DEPENDENCY", message, 422, details);
 }
+function internalError(message, details) {
+  return new AppError("INTERNAL_ERROR", message, 500, details);
+}
 
 // ../contracts/src/google.ts
 import { z as z5 } from "zod";
@@ -1549,7 +1552,7 @@ function parseCookies(header) {
   }, {});
 }
 async function authPlugin(app, opts = {}) {
-  app.addHook("onRequest", async (request, reply) => {
+  app.addHook("onRequest", async (request) => {
     const url = request.url.split("?")[0];
     if (shouldSkipAuth(url)) return;
     const header = request.headers.authorization;
@@ -1557,15 +1560,13 @@ async function authPlugin(app, opts = {}) {
     if (header) {
       const parts = header.split(" ");
       if (parts.length !== 2 || parts[0] !== "Bearer") {
-        const err = authRequired();
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw authRequired();
       }
       const token = parts[1];
       const hash = hashKey(token);
       key = app.db.select().from(apiKeys).where(eq(apiKeys.keyHash, hash)).get();
       if (!key || key.revokedAt) {
-        const err = authInvalid();
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw authInvalid();
       }
     } else if (opts.resolveSessionApiKeyId && opts.sessionCookieName) {
       const sessionId = parseCookies(request.headers.cookie)[opts.sessionCookieName];
@@ -1576,12 +1577,10 @@ async function authPlugin(app, opts = {}) {
         }
       }
       if (!key || key.revokedAt) {
-        const err = authRequired();
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw authRequired();
       }
     } else {
-      const err = authRequired();
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw authRequired();
     }
     app.db.update(apiKeys).set({ lastUsedAt: (/* @__PURE__ */ new Date()).toISOString() }).where(eq(apiKeys.id, key.id)).run();
   });
@@ -2049,12 +2048,7 @@ async function keywordRoutes(app, opts) {
       return reply.send({ keywords: generated, provider });
     } catch (err) {
       request.log.error({ err }, "Key phrase generation failed");
-      return reply.status(500).send({
-        error: {
-          code: "INTERNAL_ERROR",
-          message: err instanceof Error ? err.message : "Failed to generate key phrases"
-        }
-      });
+      throw internalError(err instanceof Error ? err.message : "Failed to generate key phrases");
     }
   });
 }
@@ -6068,7 +6062,7 @@ async function settingsRoutes(app, opts) {
     google: opts.google ?? { configured: false },
     bing: opts.bing ?? { configured: false }
   }));
-  app.put("/settings/providers/:name", async (request, reply) => {
+  app.put("/settings/providers/:name", async (request) => {
     const { apiKey, baseUrl, model, quota } = request.body ?? {};
     const name = request.params.name;
     const adapters = opts.providerAdapters ?? [];
@@ -6076,107 +6070,81 @@ async function settingsRoutes(app, opts) {
     const adapterInfo = apiAdapters.find((a) => a.name === name);
     if (!adapterInfo) {
       const validNames = apiAdapters.map((a) => a.name);
-      const err = validationError(`Invalid provider: ${name}. Must be one of: ${validNames.join(", ")}`, {
+      throw validationError(`Invalid provider: ${name}. Must be one of: ${validNames.join(", ")}`, {
         provider: name,
         validProviders: validNames
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (name === "local") {
       if (!baseUrl || typeof baseUrl !== "string") {
-        const err = validationError("baseUrl is required for local provider");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("baseUrl is required for local provider");
       }
     } else if (name === "gemini" && !apiKey) {
       const geminiSummary = (opts.providerSummary ?? []).find((p) => p.name === "gemini");
       if (!geminiSummary?.vertexConfigured) {
-        const err = validationError(
+        throw validationError(
           "apiKey is required for Gemini unless Vertex AI is configured (set GEMINI_VERTEX_PROJECT env var or vertexProject in config file)"
         );
-        return reply.status(err.statusCode).send(err.toJSON());
       }
     } else {
       if (!apiKey || typeof apiKey !== "string") {
-        const err = validationError("apiKey is required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("apiKey is required");
       }
     }
     if (model !== void 0) {
       if (!adapterInfo.modelValidationPattern.test(model)) {
-        return reply.status(400).send({
-          error: { code: "VALIDATION_ERROR", message: `Invalid model "${model}" for provider "${name}" \u2014 ${adapterInfo.modelValidationHint}` }
-        });
+        throw validationError(
+          `Invalid model "${model}" for provider "${name}" \u2014 ${adapterInfo.modelValidationHint}`
+        );
       }
     }
     if (!opts.onProviderUpdate) {
-      const err = notImplemented("Provider configuration updates are not supported in this deployment");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notImplemented("Provider configuration updates are not supported in this deployment");
     }
     if (quota !== void 0) {
       if (typeof quota !== "object" || quota === null) {
-        return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: "quota must be an object" } });
+        throw validationError("quota must be an object");
       }
       for (const [key, val] of Object.entries(quota)) {
         if (!["maxConcurrency", "maxRequestsPerMinute", "maxRequestsPerDay"].includes(key)) {
-          return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `Unknown quota field: ${key}` } });
+          throw validationError(`Unknown quota field: ${key}`);
         }
         if (typeof val !== "number" || !Number.isInteger(val) || val <= 0) {
-          return reply.status(400).send({ error: { code: "VALIDATION_ERROR", message: `${key} must be a positive integer` } });
+          throw validationError(`${key} must be a positive integer`);
         }
       }
     }
     const result = opts.onProviderUpdate(name, apiKey ?? "", model, baseUrl, quota);
     if (!result) {
-      return reply.status(500).send({
-        error: {
-          code: "INTERNAL_ERROR",
-          message: "Failed to update provider configuration"
-        }
-      });
+      throw internalError("Failed to update provider configuration");
     }
     return result;
   });
-  app.put("/settings/google", async (request, reply) => {
+  app.put("/settings/google", async (request) => {
     const { clientId, clientSecret } = request.body ?? {};
     if (!clientId || typeof clientId !== "string" || !clientSecret || typeof clientSecret !== "string") {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: "clientId and clientSecret are required" }
-      });
+      throw validationError("clientId and clientSecret are required");
     }
     if (!opts.onGoogleUpdate) {
-      const err = notImplemented("Google OAuth configuration updates are not supported in this deployment");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notImplemented("Google OAuth configuration updates are not supported in this deployment");
     }
     const result = opts.onGoogleUpdate(clientId, clientSecret);
     if (!result) {
-      return reply.status(500).send({
-        error: {
-          code: "INTERNAL_ERROR",
-          message: "Failed to update Google OAuth configuration"
-        }
-      });
+      throw internalError("Failed to update Google OAuth configuration");
     }
     return result;
   });
-  app.put("/settings/bing", async (request, reply) => {
+  app.put("/settings/bing", async (request) => {
     const { apiKey } = request.body ?? {};
     if (!apiKey || typeof apiKey !== "string") {
-      return reply.status(400).send({
-        error: { code: "VALIDATION_ERROR", message: "apiKey is required" }
-      });
+      throw validationError("apiKey is required");
     }
     if (!opts.onBingUpdate) {
-      const err = notImplemented("Bing configuration updates are not supported in this deployment");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notImplemented("Bing configuration updates are not supported in this deployment");
     }
     const result = opts.onBingUpdate(apiKey);
     if (!result) {
-      return reply.status(500).send({
-        error: {
-          code: "INTERNAL_ERROR",
-          message: "Failed to update Bing configuration"
-        }
-      });
+      throw internalError("Failed to update Bing configuration");
     }
     return result;
   });
@@ -6184,32 +6152,24 @@ async function settingsRoutes(app, opts) {
 
 // ../api-routes/src/snapshot.ts
 async function snapshotRoutes(app, opts) {
-  app.post("/snapshot", async (request, reply) => {
+  app.post("/snapshot", async (request) => {
     const parsed = snapshotRequestSchema.safeParse(request.body);
     if (!parsed.success) {
-      const err = validationError("Invalid snapshot payload", {
+      throw validationError("Invalid snapshot payload", {
         issues: parsed.error.issues.map((issue) => ({
           path: issue.path.join("."),
           message: issue.message
         }))
       });
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     if (!opts.onSnapshotRequested) {
-      const err = notImplemented("Snapshot reporting is not supported in this deployment");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notImplemented("Snapshot reporting is not supported in this deployment");
     }
     try {
-      const report = await opts.onSnapshotRequested(parsed.data);
-      return reply.send(report);
+      return await opts.onSnapshotRequested(parsed.data);
     } catch (err) {
       request.log.error({ err }, "Snapshot report generation failed");
-      return reply.status(500).send({
-        error: {
-          code: "INTERNAL_ERROR",
-          message: err instanceof Error ? err.message : "Failed to generate snapshot report"
-        }
-      });
+      throw internalError(err instanceof Error ? err.message : "Failed to generate snapshot report");
     }
   });
 }
@@ -7401,11 +7361,9 @@ async function googleRoutes(app, opts) {
   function getAuthConfig() {
     return opts.getGoogleAuthConfig?.() ?? {};
   }
-  function requireConnectionStore(reply) {
+  function requireConnectionStore() {
     if (opts.googleConnectionStore) return opts.googleConnectionStore;
-    const err = validationError("Google auth storage is not configured for this deployment");
-    reply.status(err.statusCode).send(err.toJSON());
-    return null;
+    throw validationError("Google auth storage is not configured for this deployment");
   }
   app.get("/projects/:name/google/connections", async (request) => {
     const project = resolveProject(app.db, request.params.name);
@@ -7421,16 +7379,14 @@ async function googleRoutes(app, opts) {
       updatedAt: connection.updatedAt
     }));
   });
-  app.post("/projects/:name/google/connect", async (request, reply) => {
+  app.post("/projects/:name/google/connect", async (request) => {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getAuthConfig();
     if (!googleClientId || !googleClientSecret) {
-      const err = validationError("Google OAuth is not configured. Set Google OAuth credentials in the local Canonry config.");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("Google OAuth is not configured. Set Google OAuth credentials in the local Canonry config.");
     }
     const { type, propertyId, publicUrl } = request.body ?? {};
     if (!type || type !== "gsc" && type !== "ga4") {
-      const err = validationError('type must be "gsc" or "ga4"');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('type must be "gsc" or "ga4"');
     }
     const project = resolveProject(app.db, request.params.name);
     let redirectUri;
@@ -7456,8 +7412,7 @@ async function googleRoutes(app, opts) {
     if (!googleClientId || !googleClientSecret) {
       return reply.status(500).send("Google OAuth not configured");
     }
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+    const store = requireConnectionStore();
     const escapeHtml = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
     const { code, state, error } = request.query;
     if (error) {
@@ -7547,13 +7502,11 @@ async function googleRoutes(app, opts) {
     return handleOAuthCallback(request, reply);
   });
   app.delete("/projects/:name/google/connections/:type", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const deleted = store.deleteConnection(project.canonicalDomain, request.params.type);
     if (!deleted) {
-      const err = notFound("Google connection", request.params.type);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notFound("Google connection", request.params.type);
     }
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -7564,27 +7517,23 @@ async function googleRoutes(app, opts) {
     });
     return reply.status(204).send();
   });
-  app.get("/projects/:name/google/properties", async (request, reply) => {
+  app.get("/projects/:name/google/properties", async (request) => {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getAuthConfig();
     if (!googleClientId || !googleClientSecret) {
-      const err = validationError("Google OAuth is not configured");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("Google OAuth is not configured");
     }
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { accessToken } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret);
     const sites = await listSites(accessToken);
     return { sites };
   });
-  app.post("/projects/:name/google/gsc/sync", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.post("/projects/:name/google/gsc/sync", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const conn = store.getConnection(project.canonicalDomain, "gsc");
     if (!conn) {
-      const err = validationError('No GSC connection found for this domain. Run "canonry google connect" first.');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('No GSC connection found for this domain. Run "canonry google connect" first.');
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const runId = crypto14.randomUUID();
@@ -7626,24 +7575,20 @@ async function googleRoutes(app, opts) {
       position: parseFloat(r.position)
     }));
   });
-  app.post("/projects/:name/google/gsc/inspect", async (request, reply) => {
+  app.post("/projects/:name/google/gsc/inspect", async (request) => {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getAuthConfig();
     if (!googleClientId || !googleClientSecret) {
-      const err = validationError("Google OAuth is not configured");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("Google OAuth is not configured");
     }
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { url } = request.body ?? {};
     if (!url) {
-      const err = validationError("url is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("url is required");
     }
     const { accessToken, propertyId } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret);
     if (!propertyId) {
-      const err = validationError("No GSC property configured for this connection");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("No GSC property configured for this connection");
     }
     const result = await inspectUrl(accessToken, url, propertyId);
     const ir = result.inspectionResult;
@@ -7843,46 +7788,38 @@ async function googleRoutes(app, opts) {
       reasonBreakdown: JSON.parse(r.reasonBreakdown)
     })).reverse();
   });
-  app.get("/projects/:name/google/gsc/sitemaps", async (request, reply) => {
+  app.get("/projects/:name/google/gsc/sitemaps", async (request) => {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getAuthConfig();
     if (!googleClientId || !googleClientSecret) {
-      const err = validationError("Google OAuth is not configured");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("Google OAuth is not configured");
     }
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { accessToken, propertyId } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret);
     if (!propertyId) {
-      const err = validationError('No GSC property configured for this connection. Set one with "canonry google set-property".');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('No GSC property configured for this connection. Set one with "canonry google set-property".');
     }
     const sitemaps = await listSitemaps(accessToken, propertyId);
     return { sitemaps };
   });
-  app.post("/projects/:name/google/gsc/discover-sitemaps", async (request, reply) => {
+  app.post("/projects/:name/google/gsc/discover-sitemaps", async (request) => {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getAuthConfig();
     if (!googleClientId || !googleClientSecret) {
-      const err = validationError("Google OAuth is not configured");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("Google OAuth is not configured");
     }
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const conn = store.getConnection(project.canonicalDomain, "gsc");
     if (!conn) {
-      const err = validationError('No GSC connection found for this domain. Run "canonry google connect" first.');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('No GSC connection found for this domain. Run "canonry google connect" first.');
     }
     if (!conn.propertyId) {
-      const err = validationError("No GSC property configured for this connection");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("No GSC property configured for this connection");
     }
     const { accessToken } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret);
     const sitemaps = await listSitemaps(accessToken, conn.propertyId);
     if (sitemaps.length === 0) {
-      const err = validationError("No sitemaps found for this GSC property. Submit a sitemap in Google Search Console first.");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("No sitemaps found for this GSC property. Submit a sitemap in Google Search Console first.");
     }
     const primary = sitemaps.find((s) => !s.isSitemapsIndex) ?? sitemaps[0];
     const sitemapUrl = primary.path;
@@ -7906,18 +7843,15 @@ async function googleRoutes(app, opts) {
     const run = app.db.select().from(runs).where(eq14(runs.id, runId)).get();
     return { sitemaps, primarySitemapUrl: sitemapUrl, run };
   });
-  app.post("/projects/:name/google/gsc/inspect-sitemap", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.post("/projects/:name/google/gsc/inspect-sitemap", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const conn = store.getConnection(project.canonicalDomain, "gsc");
     if (!conn) {
-      const err = validationError('No GSC connection found for this domain. Run "canonry google connect" first.');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('No GSC connection found for this domain. Run "canonry google connect" first.');
     }
     if (!conn.propertyId) {
-      const err = validationError("No GSC property configured for this connection");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("No GSC property configured for this connection");
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const runId = crypto14.randomUUID();
@@ -7936,14 +7870,12 @@ async function googleRoutes(app, opts) {
     const run = app.db.select().from(runs).where(eq14(runs.id, runId)).get();
     return run;
   });
-  app.put("/projects/:name/google/connections/:type/sitemap", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.put("/projects/:name/google/connections/:type/sitemap", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { sitemapUrl } = request.body ?? {};
     if (!sitemapUrl || !sitemapUrl.trim()) {
-      const err = validationError("sitemapUrl is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("sitemapUrl is required");
     }
     const conn = store.updateConnection(
       project.canonicalDomain,
@@ -7951,19 +7883,16 @@ async function googleRoutes(app, opts) {
       { sitemapUrl: sitemapUrl.trim(), updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
     );
     if (!conn) {
-      const err = notFound("Google connection", request.params.type);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notFound("Google connection", request.params.type);
     }
     return { sitemapUrl: sitemapUrl.trim() };
   });
-  app.put("/projects/:name/google/connections/:type/property", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.put("/projects/:name/google/connections/:type/property", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { propertyId } = request.body ?? {};
     if (!propertyId) {
-      const err = validationError("propertyId is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("propertyId is required");
     }
     const conn = store.updateConnection(
       project.canonicalDomain,
@@ -7971,19 +7900,16 @@ async function googleRoutes(app, opts) {
       { propertyId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }
     );
     if (!conn) {
-      const err = notFound("Google connection", request.params.type);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notFound("Google connection", request.params.type);
     }
     return { propertyId };
   });
-  app.post("/projects/:name/google/indexing/request", async (request, reply) => {
+  app.post("/projects/:name/google/indexing/request", async (request) => {
     const { clientId: googleClientId, clientSecret: googleClientSecret } = getAuthConfig();
     if (!googleClientId || !googleClientSecret) {
-      const err = validationError("Google OAuth is not configured");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("Google OAuth is not configured");
     }
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { accessToken } = await getValidToken(store, project.canonicalDomain, "gsc", googleClientId, googleClientSecret);
     let urlsToNotify = request.body?.urls ?? [];
@@ -8002,18 +7928,15 @@ async function googleRoutes(app, opts) {
         }
       }
       if (unindexedUrls.length === 0) {
-        const err = validationError('No unindexed URLs found. Run "canonry google inspect-sitemap" first.');
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError('No unindexed URLs found. Run "canonry google inspect-sitemap" first.');
       }
       urlsToNotify = unindexedUrls;
     }
     if (urlsToNotify.length === 0) {
-      const err = validationError("At least one URL is required (or use allUnindexed: true)");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("At least one URL is required (or use allUnindexed: true)");
     }
     if (urlsToNotify.length > INDEXING_API_DAILY_LIMIT) {
-      const err = validationError(`Cannot request indexing for more than ${INDEXING_API_DAILY_LIMIT} URLs per request (got ${urlsToNotify.length})`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Cannot request indexing for more than ${INDEXING_API_DAILY_LIMIT} URLs per request (got ${urlsToNotify.length})`);
     }
     const projectDomain = normalizeProjectDomain(project.canonicalDomain);
     const invalidUrls = urlsToNotify.filter((url) => {
@@ -8025,10 +7948,9 @@ async function googleRoutes(app, opts) {
       }
     });
     if (invalidUrls.length > 0) {
-      const err = validationError(
+      throw validationError(
         `URLs must belong to project domain "${project.canonicalDomain}". Invalid: ${invalidUrls.slice(0, 5).join(", ")}`
       );
-      return reply.status(err.statusCode).send(err.toJSON());
     }
     const results = [];
     for (const url of urlsToNotify) {
@@ -8226,6 +8148,13 @@ async function getKeywordStats(apiKey, siteUrl) {
   const data = await bingFetch(apiKey, `GetQueryStats?siteUrl=${encodedSite}`);
   return data ?? [];
 }
+async function getCrawlIssues(apiKey, siteUrl) {
+  validateApiKey(apiKey);
+  validateSiteUrl2(siteUrl);
+  const encodedSite = encodeURIComponent(siteUrl);
+  const data = await bingFetch(apiKey, `GetCrawlIssues?siteUrl=${encodedSite}`);
+  return data ?? [];
+}
 
 // ../api-routes/src/bing.ts
 function parseBingDate(value) {
@@ -8241,29 +8170,47 @@ function bingLog(level, action, ctx) {
   const stream = level === "error" ? process.stderr : process.stdout;
   stream.write(JSON.stringify(entry) + "\n");
 }
+var CRAWL_ISSUES_CACHE_TTL_MS = 6e4;
+var crawlIssuesCache = /* @__PURE__ */ new Map();
+function isBlockingIssueType(issueType) {
+  if (!issueType) return true;
+  const trimmed = issueType.trim();
+  if (!trimmed) return true;
+  return trimmed.split(/\s+/).some((flag) => !/^(None|Seo(Issues|Concerns))$/i.test(flag));
+}
+async function loadBlockingCrawlIssues(apiKey, siteUrl, domain) {
+  const now = Date.now();
+  const cached = crawlIssuesCache.get(domain);
+  if (cached && now - cached.fetchedAt < CRAWL_ISSUES_CACHE_TTL_MS) {
+    return cached.blockedUrls;
+  }
+  const issues = await getCrawlIssues(apiKey, siteUrl);
+  const blockedUrls = /* @__PURE__ */ new Set();
+  for (const issue of issues) {
+    if (issue.Url && isBlockingIssueType(issue.IssueType ?? null)) {
+      blockedUrls.add(issue.Url);
+    }
+  }
+  crawlIssuesCache.set(domain, { blockedUrls, fetchedAt: now });
+  return blockedUrls;
+}
 async function bingRoutes(app, opts) {
-  function requireConnectionStore(reply) {
+  function requireConnectionStore() {
     if (opts.bingConnectionStore) return opts.bingConnectionStore;
-    const err = validationError("Bing connection storage is not configured for this deployment");
-    reply.status(err.statusCode).send(err.toJSON());
-    return null;
+    throw validationError("Bing connection storage is not configured for this deployment");
   }
-  function requireConnection(store, domain, reply) {
+  function requireConnection(store, domain) {
     const conn = store.getConnection(domain);
     if (!conn) {
-      const err = validationError('No Bing connection found for this domain. Run "canonry bing connect <project>" first.');
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
+      throw validationError('No Bing connection found for this domain. Run "canonry bing connect <project>" first.');
     }
     return conn;
   }
-  app.post("/projects/:name/bing/connect", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.post("/projects/:name/bing/connect", async (request) => {
+    const store = requireConnectionStore();
     const { apiKey } = request.body ?? {};
     if (!apiKey || typeof apiKey !== "string") {
-      const err = validationError("apiKey is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("apiKey is required");
     }
     const project = resolveProject(app.db, request.params.name);
     let sites;
@@ -8273,8 +8220,7 @@ async function bingRoutes(app, opts) {
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       bingLog("error", "connect.verify-key-failed", { domain: project.canonicalDomain, error: msg });
-      const err = validationError(`Failed to verify Bing API key: ${msg}`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Failed to verify Bing API key: ${msg}`);
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = store.getConnection(project.canonicalDomain);
@@ -8300,13 +8246,11 @@ async function bingRoutes(app, opts) {
     };
   });
   app.delete("/projects/:name/bing/disconnect", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const deleted = store.deleteConnection(project.canonicalDomain);
     if (!deleted) {
-      const err = notFound("Bing connection", project.canonicalDomain);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notFound("Bing connection", project.canonicalDomain);
     }
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -8317,9 +8261,8 @@ async function bingRoutes(app, opts) {
     });
     return reply.status(204).send();
   });
-  app.get("/projects/:name/bing/status", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.get("/projects/:name/bing/status", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const conn = store.getConnection(project.canonicalDomain);
     return {
@@ -8330,25 +8273,20 @@ async function bingRoutes(app, opts) {
       updatedAt: conn?.updatedAt ?? null
     };
   });
-  app.get("/projects/:name/bing/sites", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.get("/projects/:name/bing/sites", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
-    const conn = requireConnection(store, project.canonicalDomain, reply);
-    if (!conn) return;
+    const conn = requireConnection(store, project.canonicalDomain);
     const sites = await getSites(conn.apiKey);
     return { sites: sites.map((s) => ({ url: s.Url, verified: s.Verified ?? false })) };
   });
-  app.post("/projects/:name/bing/set-site", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.post("/projects/:name/bing/set-site", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
-    const conn = requireConnection(store, project.canonicalDomain, reply);
-    if (!conn) return;
+    requireConnection(store, project.canonicalDomain);
     const { siteUrl } = request.body ?? {};
     if (!siteUrl || typeof siteUrl !== "string") {
-      const err = validationError("siteUrl is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("siteUrl is required");
     }
     store.updateConnection(project.canonicalDomain, {
       siteUrl,
@@ -8356,12 +8294,10 @@ async function bingRoutes(app, opts) {
     });
     return { siteUrl };
   });
-  app.get("/projects/:name/bing/coverage", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.get("/projects/:name/bing/coverage", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
-    const conn = requireConnection(store, project.canonicalDomain, reply);
-    if (!conn) return;
+    requireConnection(store, project.canonicalDomain);
     const allInspections = app.db.select().from(bingUrlInspections).where(eq15(bingUrlInspections.projectId, project.id)).orderBy(desc6(bingUrlInspections.inspectedAt)).all();
     const latestByUrl = /* @__PURE__ */ new Map();
     const definitiveByUrl = /* @__PURE__ */ new Map();
@@ -8446,9 +8382,8 @@ async function bingRoutes(app, opts) {
       unknown: unknownUrls.map(formatRow)
     };
   });
-  app.get("/projects/:name/bing/coverage/history", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.get("/projects/:name/bing/coverage/history", async (request) => {
+    requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const parsed = parseInt(request.query.limit ?? "90", 10);
     const limit = Number.isNaN(parsed) || parsed <= 0 ? 90 : parsed;
@@ -8460,9 +8395,8 @@ async function bingRoutes(app, opts) {
       unknown: r.unknown
     }));
   });
-  app.get("/projects/:name/bing/inspections", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.get("/projects/:name/bing/inspections", async (request) => {
+    requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
     const { url, limit } = request.query;
     const whereClause = url ? and4(eq15(bingUrlInspections.projectId, project.id), eq15(bingUrlInspections.url, url)) : eq15(bingUrlInspections.projectId, project.id);
@@ -8480,20 +8414,16 @@ async function bingRoutes(app, opts) {
       discoveryDate: r.discoveryDate ?? null
     }));
   });
-  app.post("/projects/:name/bing/inspect-url", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.post("/projects/:name/bing/inspect-url", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
-    const conn = requireConnection(store, project.canonicalDomain, reply);
-    if (!conn) return;
+    const conn = requireConnection(store, project.canonicalDomain);
     if (!conn.siteUrl) {
-      const err = validationError('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
     }
     const { url } = request.body ?? {};
     if (!url) {
-      const err = validationError("url is required");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("url is required");
     }
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const runId = crypto15.randomUUID();
@@ -8512,22 +8442,38 @@ async function bingRoutes(app, opts) {
         domain: project.canonicalDomain,
         url,
         httpStatus: result.HttpStatus ?? result.HttpCode ?? null,
-        inIndex: result.InIndex ?? null,
         documentSize: result.DocumentSize ?? null,
-        lastCrawledDate: result.LastCrawledDate ?? null
+        lastCrawledDate: result.LastCrawledDate ?? null,
+        discoveryDate: result.DiscoveryDate ?? null
       });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const id = crypto15.randomUUID();
       const httpCode = result.HttpStatus ?? result.HttpCode ?? null;
-      let derivedInIndex = null;
-      if (result.InIndex != null) {
-        derivedInIndex = result.InIndex;
-      } else if (result.DocumentSize != null && result.DocumentSize > 0) {
-        derivedInIndex = true;
-      }
       const lastCrawledDate = parseBingDate(result.LastCrawledDate);
       const inIndexDate = parseBingDate(result.InIndexDate);
       const discoveryDate = parseBingDate(result.DiscoveryDate);
+      let derivedInIndex = null;
+      if (result.DocumentSize != null && result.DocumentSize > 0) {
+        derivedInIndex = true;
+      } else if (lastCrawledDate != null) {
+        const httpStatus = result.HttpStatus ?? result.HttpCode;
+        derivedInIndex = httpStatus != null && httpStatus >= 400 ? false : true;
+      } else if (discoveryDate != null) {
+        derivedInIndex = false;
+      }
+      if (derivedInIndex === true) {
+        try {
+          const blockedUrls = await loadBlockingCrawlIssues(conn.apiKey, conn.siteUrl, project.canonicalDomain);
+          if (blockedUrls.has(url)) {
+            derivedInIndex = false;
+          }
+        } catch (e) {
+          bingLog("warn", "inspect-url.crawl-issues-lookup-failed", {
+            domain: project.canonicalDomain,
+            error: e instanceof Error ? e.message : String(e)
+          });
+        }
+      }
       app.db.insert(bingUrlInspections).values({
         id,
         projectId: project.id,
@@ -8563,15 +8509,12 @@ async function bingRoutes(app, opts) {
       throw e;
     }
   });
-  app.post("/projects/:name/bing/request-indexing", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.post("/projects/:name/bing/request-indexing", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
-    const conn = requireConnection(store, project.canonicalDomain, reply);
-    if (!conn) return;
+    const conn = requireConnection(store, project.canonicalDomain);
     if (!conn.siteUrl) {
-      const err = validationError('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
     }
     let urlsToSubmit = request.body?.urls ?? [];
     if (request.body?.allUnindexed) {
@@ -8589,18 +8532,15 @@ async function bingRoutes(app, opts) {
         }
       }
       if (unindexedUrls.length === 0) {
-        const err = validationError('No unindexed or unknown URLs found. Run "canonry bing inspect <project> <url>" first.');
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError('No unindexed or unknown URLs found. Run "canonry bing inspect <project> <url>" first.');
       }
       urlsToSubmit = unindexedUrls;
     }
     if (urlsToSubmit.length === 0) {
-      const err = validationError("At least one URL is required (or use allUnindexed: true)");
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError("At least one URL is required (or use allUnindexed: true)");
     }
     if (urlsToSubmit.length > BING_SUBMIT_URL_DAILY_LIMIT) {
-      const err = validationError(`Cannot submit more than ${BING_SUBMIT_URL_DAILY_LIMIT} URLs per day (got ${urlsToSubmit.length})`);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError(`Cannot submit more than ${BING_SUBMIT_URL_DAILY_LIMIT} URLs per day (got ${urlsToSubmit.length})`);
     }
     const results = [];
     bingLog("info", "index-submit.start", { domain: project.canonicalDomain, siteUrl: conn.siteUrl, urlCount: urlsToSubmit.length, allUnindexed: !!request.body?.allUnindexed });
@@ -8643,15 +8583,12 @@ async function bingRoutes(app, opts) {
       results
     };
   });
-  app.get("/projects/:name/bing/performance", async (request, reply) => {
-    const store = requireConnectionStore(reply);
-    if (!store) return;
+  app.get("/projects/:name/bing/performance", async (request) => {
+    const store = requireConnectionStore();
     const project = resolveProject(app.db, request.params.name);
-    const conn = requireConnection(store, project.canonicalDomain, reply);
-    if (!conn) return;
+    const conn = requireConnection(store, project.canonicalDomain);
     if (!conn.siteUrl) {
-      const err = validationError('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw validationError('No Bing site configured. Run "canonry bing set-site <project> <url>" first.');
     }
     const stats = await getKeywordStats(conn.apiKey, conn.siteUrl);
     return stats.map((s) => ({
@@ -10558,68 +10495,51 @@ function parseEnvInput(value, fieldName = "env") {
   }
   return env;
 }
-function sendWordpressError(reply, error) {
-  if (!(error instanceof WordpressApiError)) return false;
-  let appError;
+function toAppError(error) {
   switch (error.code) {
     case "AUTH_INVALID":
-      appError = new AppError("AUTH_INVALID", error.message, error.statusCode);
-      break;
+      return new AppError("AUTH_INVALID", error.message, error.statusCode);
     case "NOT_FOUND":
-      appError = new AppError("NOT_FOUND", error.message, error.statusCode);
-      break;
-    case "UPSTREAM_ERROR":
-      appError = providerError(error.message, { statusCode: error.statusCode });
-      break;
+      return new AppError("NOT_FOUND", error.message, error.statusCode);
     case "UNSUPPORTED":
     case "VALIDATION_ERROR":
-      appError = validationError(error.message);
-      break;
+      return validationError(error.message);
+    case "UPSTREAM_ERROR":
     default:
-      appError = providerError(error.message, { statusCode: error.statusCode });
-      break;
+      return providerError(error.message, { statusCode: error.statusCode });
   }
-  reply.status(appError.statusCode).send(appError.toJSON());
-  return true;
 }
-async function withWordpressErrorHandling(reply, handler) {
+async function withWordpressErrorHandling(handler) {
   try {
     return await handler();
   } catch (error) {
-    if (sendWordpressError(reply, error)) return;
+    if (error instanceof WordpressApiError) throw toAppError(error);
     throw error;
   }
 }
 async function wordpressRoutes(app, opts) {
-  function requireStore(reply) {
+  function requireStore() {
     if (opts.wordpressConnectionStore) return opts.wordpressConnectionStore;
-    const err = validationError("WordPress connection storage is not configured for this deployment");
-    reply.status(err.statusCode).send(err.toJSON());
-    return null;
+    throw validationError("WordPress connection storage is not configured for this deployment");
   }
-  function requireConnection(store, projectName, reply) {
+  function requireConnection(store, projectName) {
     const connection = store.getConnection(projectName);
     if (!connection) {
-      const err = validationError(`No WordPress connection found for project "${projectName}". Run "canonry wordpress connect ${projectName}" first.`);
-      reply.status(err.statusCode).send(err.toJSON());
-      return null;
+      throw validationError(`No WordPress connection found for project "${projectName}". Run "canonry wordpress connect ${projectName}" first.`);
     }
     return connection;
   }
-  app.post("/projects/:name/wordpress/connect", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/connect", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
       const { url, stagingUrl, username, appPassword } = request.body ?? {};
       if (!url || !username || !appPassword) {
-        const err = validationError("url, username, and appPassword are required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("url, username, and appPassword are required");
       }
       const defaultEnv = parseEnvInput(request.body?.defaultEnv, "defaultEnv") ?? (stagingUrl ? "staging" : "live");
       if (defaultEnv === "staging" && !stagingUrl) {
-        const err = validationError('defaultEnv "staging" requires stagingUrl');
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError('defaultEnv "staging" requires stagingUrl');
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const existing = store.getConnection(project.name);
@@ -10655,13 +10575,11 @@ async function wordpressRoutes(app, opts) {
     });
   });
   app.delete("/projects/:name/wordpress/disconnect", async (request, reply) => {
-    const store = requireStore(reply);
-    if (!store) return;
+    const store = requireStore();
     const project = resolveProject(app.db, request.params.name);
     const deleted = store.deleteConnection(project.name);
     if (!deleted) {
-      const err = notFound("WordPress connection", project.name);
-      return reply.status(err.statusCode).send(err.toJSON());
+      throw notFound("WordPress connection", project.name);
     }
     writeAuditLog(app.db, {
       projectId: project.id,
@@ -10696,13 +10614,11 @@ async function wordpressRoutes(app, opts) {
       adminUrl: getWpStagingAdminUrl(connection.url)
     };
   });
-  app.get("/projects/:name/wordpress/pages", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.get("/projects/:name/wordpress/pages", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const env = parseEnvInput(request.query?.env);
       return {
         env: env ?? connection.defaultEnv,
@@ -10710,34 +10626,28 @@ async function wordpressRoutes(app, opts) {
       };
     });
   });
-  app.get("/projects/:name/wordpress/page", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.get("/projects/:name/wordpress/page", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const slug = request.query?.slug?.trim();
       if (!slug) {
-        const err = validationError("slug is required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("slug is required");
       }
       const env = parseEnvInput(request.query?.env);
       return getPageDetail(connection, slug, env);
     });
   });
-  app.post("/projects/:name/wordpress/pages", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/pages", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const { title, slug, content, status } = request.body ?? {};
       const env = parseEnvInput(request.body?.env);
       if (!title || !slug || !content) {
-        const err = validationError("title, slug, and content are required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("title, slug, and content are required");
       }
       const created = await createPage(connection, { title, slug, content, status }, env);
       writeAuditLog(app.db, {
@@ -10750,17 +10660,14 @@ async function wordpressRoutes(app, opts) {
       return created;
     });
   });
-  app.put("/projects/:name/wordpress/page", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.put("/projects/:name/wordpress/page", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const currentSlug = request.body?.currentSlug?.trim();
       if (!currentSlug) {
-        const err = validationError("currentSlug is required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("currentSlug is required");
       }
       const env = parseEnvInput(request.body?.env);
       const updated = await updatePageBySlug(connection, currentSlug, {
@@ -10779,17 +10686,14 @@ async function wordpressRoutes(app, opts) {
       return updated;
     });
   });
-  app.post("/projects/:name/wordpress/page/meta", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/page/meta", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const slug = request.body?.slug?.trim();
       if (!slug) {
-        const err = validationError("slug is required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("slug is required");
       }
       const env = parseEnvInput(request.body?.env);
       const updated = await setSeoMeta(connection, slug, {
@@ -10807,22 +10711,18 @@ async function wordpressRoutes(app, opts) {
       return updated;
     });
   });
-  app.post("/projects/:name/wordpress/pages/meta/bulk", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/pages/meta/bulk", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const entries = request.body?.entries;
       if (!Array.isArray(entries) || entries.length === 0) {
-        const err = validationError("entries array is required and must not be empty");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("entries array is required and must not be empty");
       }
       for (const entry of entries) {
         if (!entry.slug?.trim()) {
-          const err = validationError("each entry must have a slug");
-          return reply.status(err.statusCode).send(err.toJSON());
+          throw validationError("each entry must have a slug");
         }
       }
       const env = parseEnvInput(request.body?.env);
@@ -10840,126 +10740,103 @@ async function wordpressRoutes(app, opts) {
       return result;
     });
   });
-  app.get("/projects/:name/wordpress/schema", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.get("/projects/:name/wordpress/schema", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const slug = request.query?.slug?.trim();
       if (!slug) {
-        const err = validationError("slug is required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("slug is required");
       }
       const env = parseEnvInput(request.query?.env);
       return getPageSchema(connection, slug, env);
     });
   });
-  app.post("/projects/:name/wordpress/schema/manual", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/schema/manual", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const slug = request.body?.slug?.trim();
       const json = request.body?.json;
       if (!slug || !json) {
-        const err = validationError("slug and json are required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("slug and json are required");
       }
       const env = parseEnvInput(request.body?.env);
       return buildManualSchemaUpdate(connection, slug, { type: request.body?.type, json }, env);
     });
   });
-  app.post("/projects/:name/wordpress/schema/deploy", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/schema/deploy", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const profile = request.body?.profile;
       if (!profile?.business?.name || !profile?.pages || Object.keys(profile.pages).length === 0) {
-        const err = validationError("profile with business.name and non-empty pages is required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("profile with business.name and non-empty pages is required");
       }
       const env = parseEnvInput(request.body?.env);
       return deploySchemaFromProfile(connection, profile, env);
     });
   });
-  app.get("/projects/:name/wordpress/schema/status", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.get("/projects/:name/wordpress/schema/status", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const env = parseEnvInput(request.query?.env);
       return getSchemaStatus(connection, env);
     });
   });
-  app.get("/projects/:name/wordpress/llms-txt", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.get("/projects/:name/wordpress/llms-txt", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const env = parseEnvInput(request.query?.env);
       return getLlmsTxt(connection, env);
     });
   });
-  app.post("/projects/:name/wordpress/llms-txt/manual", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/llms-txt/manual", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const content = request.body?.content;
       if (!content) {
-        const err = validationError("content is required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("content is required");
       }
       const env = parseEnvInput(request.body?.env);
       return buildManualLlmsTxtUpdate(connection, content, env);
     });
   });
-  app.get("/projects/:name/wordpress/audit", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.get("/projects/:name/wordpress/audit", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const env = parseEnvInput(request.query?.env);
       return runAudit(connection, env);
     });
   });
-  app.get("/projects/:name/wordpress/diff", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.get("/projects/:name/wordpress/diff", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const slug = request.query?.slug?.trim();
       if (!slug) {
-        const err = validationError("slug is required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("slug is required");
       }
       return diffPageAcrossEnvironments(connection, slug);
     });
   });
-  app.get("/projects/:name/wordpress/staging/status", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.get("/projects/:name/wordpress/staging/status", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       const plugins = await listActivePlugins(connection, "live");
       return {
         stagingConfigured: Boolean(connection.stagingUrl),
@@ -10969,34 +10846,28 @@ async function wordpressRoutes(app, opts) {
       };
     });
   });
-  app.post("/projects/:name/wordpress/staging/push", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/staging/push", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
-      const connection = requireConnection(store, project.name, reply);
-      if (!connection) return;
+      const connection = requireConnection(store, project.name);
       if (!connection.stagingUrl) {
-        const err = validationError("No staging URL configured for this project. Reconnect with --staging-url before using staging push.");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("No staging URL configured for this project. Reconnect with --staging-url before using staging push.");
       }
       return buildManualStagingPush(connection);
     });
   });
-  app.post("/projects/:name/wordpress/onboard", async (request, reply) => {
-    return withWordpressErrorHandling(reply, async () => {
-      const store = requireStore(reply);
-      if (!store) return;
+  app.post("/projects/:name/wordpress/onboard", async (request) => {
+    return withWordpressErrorHandling(async () => {
+      const store = requireStore();
       const project = resolveProject(app.db, request.params.name);
       const { url, username, appPassword, stagingUrl, profile, skipSchema, skipSubmit } = request.body ?? {};
       if (!url || !username || !appPassword) {
-        const err = validationError("url, username, and appPassword are required");
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError("url, username, and appPassword are required");
       }
       const defaultEnv = parseEnvInput(request.body?.defaultEnv, "defaultEnv") ?? (stagingUrl ? "staging" : "live");
       if (defaultEnv === "staging" && !stagingUrl) {
-        const err = validationError('defaultEnv "staging" requires stagingUrl');
-        return reply.status(err.statusCode).send(err.toJSON());
+        throw validationError('defaultEnv "staging" requires stagingUrl');
       }
       const steps = [];
       let connection = null;
@@ -14543,6 +14414,26 @@ var ProviderExecutionGate = class {
     }
   }
 };
+async function runWithConcurrency(items, limit, worker) {
+  if (items.length === 0) return;
+  const cap = Math.max(1, Math.min(limit, items.length));
+  let cursor = 0;
+  const next = async () => {
+    while (true) {
+      const idx = cursor++;
+      if (idx >= items.length) return;
+      await worker(items[idx]);
+    }
+  };
+  await Promise.all(Array.from({ length: cap }, next));
+}
+var PROVIDER_FANOUT_DEFAULT = 8;
+function resolveProviderFanout() {
+  const raw = process.env.CANONRY_PROVIDER_FANOUT;
+  if (!raw) return PROVIDER_FANOUT_DEFAULT;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : PROVIDER_FANOUT_DEFAULT;
+}
 var JobRunner = class {
   db;
   registry;
@@ -14750,11 +14641,11 @@ var JobRunner = class {
           }
         }
       };
-      await Promise.all(apiProviders.map(async (registeredProvider) => {
+      await runWithConcurrency(apiProviders, resolveProviderFanout(), async (registeredProvider) => {
         await Promise.all(projectKeywords.map(async (kw) => {
           await processKeywordForProvider(registeredProvider, kw);
         }));
-      }));
+      });
       for (const registeredProvider of browserProviders) {
         for (const kw of projectKeywords) {
           await processKeywordForProvider(registeredProvider, kw);