@ainyc/canonry 2.3.1 → 2.4.3

package/dist/{chunk-JXOUZ6JH.js → chunk-KGOT5OFT.js}

@@ -30,7 +30,7 @@ import {
   runs,
   schedules,
   usageCounters
-} from "./chunk-CW6CAPBQ.js";
+} from "./chunk-GZF3YIHY.js";
 
 // src/config.ts
 import fs from "fs";
@@ -347,7 +347,7 @@ function printCliError(err, format) {
 // src/server.ts
 import { createRequire as createRequire3 } from "module";
 import crypto27 from "crypto";
-import fs12 from "fs";
+import fs13 from "fs";
 import path15 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { eq as eq29 } from "drizzle-orm";
@@ -448,6 +448,7 @@ var projectUpsertRequestSchema = z3.object({
   providers: z3.array(providerNameSchema).optional(),
   locations: z3.array(locationContextSchema).optional(),
   defaultLocation: z3.string().nullable().optional(),
+  autoExtractBacklinks: z3.boolean().optional(),
   configSource: configSourceSchema.optional()
 });
 var projectDtoSchema = z3.object({
@@ -462,6 +463,7 @@ var projectDtoSchema = z3.object({
   labels: z3.record(z3.string(), z3.string()).default({}),
   locations: z3.array(locationContextSchema).default([]),
   defaultLocation: z3.string().nullable().optional(),
+  autoExtractBacklinks: z3.boolean().default(false),
   configSource: configSourceSchema.default("cli"),
   configRevision: z3.number().int().positive().default(1),
   createdAt: z3.string().optional(),
@@ -535,7 +537,8 @@ var configSpecSchema = z4.object({
   defaultLocation: z4.string().optional(),
   schedule: configScheduleSchema,
   notifications: z4.array(configNotificationSchema).optional().default([]),
-  google: configGoogleSchema
+  google: configGoogleSchema,
+  autoExtractBacklinks: z4.boolean().optional().default(false)
 }).superRefine((spec, ctx) => {
   const duplicateLabels = findDuplicateLocationLabels(spec.locations);
   if (duplicateLabels.length > 0) {
@@ -622,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";
@@ -1546,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;
@@ -1554,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];
@@ -1573,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();
   });
@@ -1679,6 +1681,7 @@ async function projectRoutes(app, opts) {
         defaultLocation: nextDefaultLocation
       });
     }
+    const nextAutoExtractBacklinks = body.autoExtractBacklinks !== void 0 ? body.autoExtractBacklinks ? 1 : 0 : existing?.autoExtractBacklinks ?? 0;
     if (existing) {
       app.db.transaction((tx) => {
         tx.update(projects).set({
@@ -1692,6 +1695,7 @@ async function projectRoutes(app, opts) {
           providers: JSON.stringify(body.providers ?? []),
           locations: JSON.stringify(nextLocations),
           defaultLocation: nextDefaultLocation,
+          autoExtractBacklinks: nextAutoExtractBacklinks,
           configSource: body.configSource ?? "api",
           configRevision: existing.configRevision + 1,
           updatedAt: now
@@ -1723,6 +1727,7 @@ async function projectRoutes(app, opts) {
         providers: JSON.stringify(body.providers ?? []),
         locations: JSON.stringify(nextLocations),
         defaultLocation: nextDefaultLocation,
+        autoExtractBacklinks: nextAutoExtractBacklinks,
         configSource: body.configSource ?? "api",
         configRevision: 1,
         createdAt: now,
@@ -1869,6 +1874,7 @@ async function projectRoutes(app, opts) {
         providers: parseJsonColumn(project.providers, []),
         locations: parseJsonColumn(project.locations, []),
         ...project.defaultLocation ? { defaultLocation: project.defaultLocation } : {},
+        ...project.autoExtractBacklinks === 1 ? { autoExtractBacklinks: true } : {},
         notifications: notificationRows.map((row) => {
           const cfg = parseJsonColumn(row.config, { url: "", events: [] });
           return {
@@ -1903,6 +1909,7 @@ function formatProject(row) {
     providers: parseJsonColumn(row.providers, []),
     locations: parseJsonColumn(row.locations, []),
     defaultLocation: row.defaultLocation,
+    autoExtractBacklinks: row.autoExtractBacklinks === 1,
     configSource: row.configSource,
     configRevision: row.configRevision,
     createdAt: row.createdAt,
@@ -2041,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");
     }
   });
 }
@@ -2742,6 +2744,7 @@ async function applyRoutes(app, opts) {
           providers: JSON.stringify(config.spec.providers ?? []),
           locations: JSON.stringify(config.spec.locations ?? []),
           defaultLocation: config.spec.defaultLocation ?? null,
+          autoExtractBacklinks: config.spec.autoExtractBacklinks ? 1 : 0,
           configSource: "config-file",
           configRevision: existing.configRevision + 1,
           updatedAt: now
@@ -2768,6 +2771,7 @@ async function applyRoutes(app, opts) {
           providers: JSON.stringify(config.spec.providers ?? []),
           locations: JSON.stringify(config.spec.locations ?? []),
           defaultLocation: config.spec.defaultLocation ?? null,
+          autoExtractBacklinks: config.spec.autoExtractBacklinks ? 1 : 0,
           configSource: "config-file",
           configRevision: 1,
           createdAt: now,
@@ -2891,6 +2895,7 @@ async function applyRoutes(app, opts) {
       providers: parseJsonColumn(project.providers, []),
       locations: parseJsonColumn(project.locations, []),
       defaultLocation: project.defaultLocation,
+      autoExtractBacklinks: project.autoExtractBacklinks === 1,
       configSource: project.configSource,
       configRevision: project.configRevision,
       createdAt: project.createdAt,
@@ -6057,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 ?? [];
@@ -6065,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;
   });
@@ -6173,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");
     }
   });
 }
@@ -7390,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);
@@ -7410,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;
@@ -7445,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) {
@@ -7536,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,
@@ -7553,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();
@@ -7615,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;
@@ -7832,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;
@@ -7895,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();
@@ -7925,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,
@@ -7940,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,
@@ -7960,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 ?? [];
@@ -7991,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) => {
@@ -8014,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) {
@@ -8231,28 +8164,22 @@ function bingLog(level, action, ctx) {
   stream.write(JSON.stringify(entry) + "\n");
 }
 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;
@@ -8262,8 +8189,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);
@@ -8289,13 +8215,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,
@@ -8306,9 +8230,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 {
@@ -8319,25 +8242,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,
@@ -8345,12 +8263,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();
@@ -8435,9 +8351,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;
@@ -8449,9 +8364,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);
@@ -8469,20 +8383,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();
@@ -8552,15 +8462,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) {
@@ -8578,18 +8485,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 });
@@ -8632,15 +8536,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) => ({
@@ -10547,68 +10448,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);
@@ -10644,13 +10528,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,
@@ -10685,13 +10567,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,
@@ -10699,34 +10579,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, {
@@ -10739,17 +10613,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, {
@@ -10768,17 +10639,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, {
@@ -10796,22 +10664,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);
@@ -10829,126 +10693,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),
@@ -10958,34 +10799,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;
@@ -14532,6 +14367,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;
@@ -14739,11 +14594,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);
@@ -15361,6 +15216,21 @@ async function executeReleaseSync(db, syncId, opts) {
       projectsProcessed: allProjects.length,
       domainsDiscovered: rows.length
     });
+    if (deps.enqueueAutoExtract) {
+      const autoExtractProjects = allProjects.filter((p) => p.autoExtractBacklinks === 1);
+      for (const p of autoExtractProjects) {
+        try {
+          deps.enqueueAutoExtract({ projectId: p.id, release });
+        } catch (err) {
+          log4.error("auto-extract.enqueue-failed", {
+            syncId,
+            release,
+            projectId: p.id,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
     const finishedAt = deps.now().toISOString();
@@ -15404,6 +15274,7 @@ function computeSummary(rows) {
 
 // src/backlink-extract.ts
 import crypto23 from "crypto";
+import fs9 from "fs";
 import { and as and12, desc as desc9, eq as eq23 } from "drizzle-orm";
 var log5 = createLogger("BacklinkExtract");
 function defaultDeps2() {
@@ -15432,6 +15303,11 @@ async function executeBacklinkExtract(db, runId, projectId, opts = {}) {
     if (!sync.vertexPath || !sync.edgesPath) {
       throw new Error(`Release ${sync.release} is missing cached file paths`);
     }
+    if (!fs9.existsSync(sync.vertexPath) || !fs9.existsSync(sync.edgesPath)) {
+      throw new Error(
+        `Cache for release ${sync.release} is missing from disk (expected at ${sync.vertexPath}). The sync record exists in the database, but the ~16 GB dump was deleted or never present on this machine. Re-sync this release from the Backlinks admin page to restore the cache.`
+      );
+    }
     const duckdb = deps.loadDuckdb();
     const rows = await deps.queryBacklinks({
       vertexPath: sync.vertexPath,
@@ -15946,7 +15822,7 @@ import crypto26 from "crypto";
 import { eq as eq27 } from "drizzle-orm";
 
 // src/agent/session.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path14 from "path";
 import { Agent } from "@mariozechner/pi-agent-core";
 import { registerBuiltInApiProviders } from "@mariozechner/pi-ai";
@@ -16048,7 +15924,7 @@ function buildAgentProvidersResponse(config) {
 }
 
 // src/agent/skill-paths.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path12 from "path";
 import { fileURLToPath } from "url";
 function resolveAeroSkillDir(pkgDir) {
@@ -16059,14 +15935,14 @@ function resolveAeroSkillDir(pkgDir) {
     path12.join(here, "../../../../skills/aero")
   ];
   for (const candidate of candidates) {
-    if (fs9.existsSync(path12.join(candidate, "SKILL.md"))) return candidate;
+    if (fs10.existsSync(path12.join(candidate, "SKILL.md"))) return candidate;
   }
   throw new Error(`Aero skill not found. Searched:
   ${candidates.join("\n  ")}`);
 }
 
 // src/agent/skill-tools.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path13 from "path";
 import { Type } from "@sinclair/typebox";
 var MAX_DOC_CHARS = 2e4;
@@ -16089,12 +15965,12 @@ function parseDescription(body) {
 }
 function scanSkillDocs(skillDir) {
   const refsDir = path13.join(skillDir ?? resolveAeroSkillDir(), "references");
-  if (!fs10.existsSync(refsDir)) return [];
+  if (!fs11.existsSync(refsDir)) return [];
   const entries = [];
-  for (const file of fs10.readdirSync(refsDir)) {
+  for (const file of fs11.readdirSync(refsDir)) {
     if (!file.endsWith(".md")) continue;
     const filePath = path13.join(refsDir, file);
-    const body = fs10.readFileSync(filePath, "utf-8");
+    const body = fs11.readFileSync(filePath, "utf-8");
     entries.push({
       slug: file.replace(/\.md$/, ""),
       description: parseDescription(body),
@@ -16138,7 +16014,7 @@ function buildReadSkillDocTool() {
         });
       }
       const filePath = path13.join(skillDir, "references", `${match.slug}.md`);
-      const content = fs10.readFileSync(filePath, "utf-8");
+      const content = fs11.readFileSync(filePath, "utf-8");
       if (content.length > MAX_DOC_CHARS) {
         return textResult({
           slug: match.slug,
@@ -16692,10 +16568,10 @@ function ensureBuiltinsRegistered() {
 }
 function loadAeroSystemPrompt(pkgDir) {
   const skillDir = resolveAeroSkillDir(pkgDir);
-  const skillBody = fs11.readFileSync(path14.join(skillDir, "SKILL.md"), "utf-8");
+  const skillBody = fs12.readFileSync(path14.join(skillDir, "SKILL.md"), "utf-8");
   const soulPath = path14.join(skillDir, "soul.md");
-  if (!fs11.existsSync(soulPath)) return skillBody;
-  const soulBody = fs11.readFileSync(soulPath, "utf-8");
+  if (!fs12.existsSync(soulPath)) return skillBody;
+  const soulBody = fs12.readFileSync(soulPath, "utf-8");
   return `${soulBody.trimEnd()}
 
 ---
@@ -18990,7 +18866,7 @@ async function createServer(opts) {
   jobRunner.onRunCompleted = (runId, projectId) => runCoordinator.onRunCompleted(runId, projectId);
   const snapshotService = new SnapshotService(registry);
   const orphanedOpenClawDir = path15.join(os6.homedir(), ".openclaw-aero");
-  if (fs12.existsSync(orphanedOpenClawDir)) {
+  if (fs13.existsSync(orphanedOpenClawDir)) {
     app.log.warn(
       { path: orphanedOpenClawDir },
       "OpenClaw gateway is no longer used. Remove ~/.openclaw-aero/ manually to reclaim the directory."
@@ -19314,7 +19190,26 @@ async function createServer(opts) {
       };
     },
     onReleaseSyncRequested: (syncId, release) => {
-      executeReleaseSync(opts.db, syncId, { release }).catch((err) => {
+      executeReleaseSync(opts.db, syncId, {
+        release,
+        deps: {
+          enqueueAutoExtract: ({ projectId, release: r }) => {
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            const runId = crypto27.randomUUID();
+            opts.db.insert(runs).values({
+              id: runId,
+              projectId,
+              kind: RunKinds["backlink-extract"],
+              status: RunStatuses.queued,
+              trigger: RunTriggers.scheduled,
+              createdAt: now
+            }).run();
+            executeBacklinkExtract(opts.db, runId, projectId, { release: r }).catch((err) => {
+              app.log.error({ runId, projectId, err }, "Auto backlink extract failed");
+            });
+          }
+        }
+      }).catch((err) => {
         app.log.error({ syncId, err }, "Common Crawl release sync failed");
       });
     },
@@ -19559,7 +19454,7 @@ async function createServer(opts) {
   });
   const dirname = path15.dirname(fileURLToPath2(import.meta.url));
   const assetsDir = path15.join(dirname, "..", "assets");
-  if (fs12.existsSync(assetsDir)) {
+  if (fs13.existsSync(assetsDir)) {
     const indexPath = path15.join(assetsDir, "index.html");
     const injectConfig = (html) => {
       const clientConfig = {};
@@ -19578,8 +19473,8 @@ async function createServer(opts) {
       index: false
     });
     const serveIndex = (_request, reply) => {
-      if (fs12.existsSync(indexPath)) {
-        const html = fs12.readFileSync(indexPath, "utf-8");
+      if (fs13.existsSync(indexPath)) {
+        const html = fs13.readFileSync(indexPath, "utf-8");
         return reply.type("text/html").send(injectConfig(html));
       }
       return reply.status(404).send({ error: "Dashboard not built" });
@@ -19599,8 +19494,8 @@ async function createServer(opts) {
       if (basePath && !url.startsWith(basePath)) {
         return reply.status(404).send({ error: "Not found", path: request.url });
       }
-      if (fs12.existsSync(indexPath)) {
-        const html = fs12.readFileSync(indexPath, "utf-8");
+      if (fs13.existsSync(indexPath)) {
+        const html = fs13.readFileSync(indexPath, "utf-8");
         return reply.type("text/html").send(injectConfig(html));
       }
       return reply.status(404).send({ error: "Not found" });
@@ -19690,8 +19585,10 @@ export {
   resolveProviderInput,
   notificationEventSchema,
   effectiveDomains,
+  RunStatuses,
   RunKinds,
   determineAnswerMentioned,
+  CcReleaseSyncStatuses,
   reparseStoredResult2 as reparseStoredResult,
   reparseStoredResult3 as reparseStoredResult2,
   reparseStoredResult as reparseStoredResult3,