@ainyc/canonry 1.7.1 → 1.8.0

package/dist/{chunk-WTI5ALRV.js → chunk-3FHF3YVA.js}

@@ -175,6 +175,7 @@ var projects = sqliteTable("projects", {
   name: text("name").notNull().unique(),
   displayName: text("display_name").notNull(),
   canonicalDomain: text("canonical_domain").notNull(),
+  ownedDomains: text("owned_domains").notNull().default("[]"),
   country: text("country").notNull(),
   language: text("language").notNull(),
   tags: text("tags").notNull().default("[]"),
@@ -313,6 +314,7 @@ CREATE TABLE IF NOT EXISTS projects (
   name              TEXT NOT NULL UNIQUE,
   display_name      TEXT NOT NULL,
   canonical_domain  TEXT NOT NULL,
+  owned_domains     TEXT NOT NULL DEFAULT '[]',
   country           TEXT NOT NULL,
   language          TEXT NOT NULL,
   tags              TEXT NOT NULL DEFAULT '[]',
@@ -439,7 +441,9 @@ var MIGRATIONS = [
   // v2: Add providers column to projects for multi-provider support
   `ALTER TABLE projects ADD COLUMN providers TEXT NOT NULL DEFAULT '[]'`,
   // v3: Add webhook_secret column to notifications for HMAC signing
-  `ALTER TABLE notifications ADD COLUMN webhook_secret TEXT`
+  `ALTER TABLE notifications ADD COLUMN webhook_secret TEXT`,
+  // v4: Add owned_domains column to projects for multi-domain citation matching
+  `ALTER TABLE projects ADD COLUMN owned_domains TEXT NOT NULL DEFAULT '[]'`
 ];
 function migrate(db) {
   const statements = MIGRATION_SQL.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
@@ -515,6 +519,7 @@ var configNotificationSchema = z3.object({
 var configSpecSchema = z3.object({
   displayName: z3.string().min(1),
   canonicalDomain: z3.string().min(1),
+  ownedDomains: z3.array(z3.string().min(1)).optional().default([]),
   country: z3.string().length(2),
   language: z3.string().min(2),
   keywords: z3.array(z3.string().min(1)).optional().default([]),
@@ -579,6 +584,7 @@ var projectDtoSchema = z4.object({
   name: z4.string(),
   displayName: z4.string().optional(),
   canonicalDomain: z4.string(),
+  ownedDomains: z4.array(z4.string()).default([]),
   country: z4.string().length(2),
   language: z4.string().min(2),
   tags: z4.array(z4.string()).default([]),
@@ -588,6 +594,30 @@ var projectDtoSchema = z4.object({
   createdAt: z4.string().optional(),
   updatedAt: z4.string().optional()
 });
+function normalizeProjectDomain(input) {
+  let domain = input.trim().toLowerCase();
+  try {
+    if (domain.includes("://")) {
+      domain = new URL(domain).hostname.toLowerCase();
+    }
+  } catch {
+  }
+  return domain.replace(/^www\./, "");
+}
+function effectiveDomains(project) {
+  const all = [project.canonicalDomain, ...project.ownedDomains ?? []];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const d of all) {
+    const trimmed = d.trim();
+    if (!trimmed) continue;
+    const norm = normalizeProjectDomain(trimmed);
+    if (seen.has(norm)) continue;
+    seen.add(norm);
+    result.push(trimmed);
+  }
+  return result;
+}
 
 // ../contracts/src/run.ts
 import { z as z5 } from "zod";
@@ -726,12 +756,17 @@ async function projectRoutes(app, opts) {
       const err = validationError("Missing required fields: displayName, canonicalDomain, country, language");
       return reply.status(err.statusCode).send(err.toJSON());
     }
+    if (body.ownedDomains !== void 0 && (!Array.isArray(body.ownedDomains) || body.ownedDomains.some((d) => typeof d !== "string" || d.trim() === ""))) {
+      const err = validationError("ownedDomains must be an array of non-empty strings");
+      return reply.status(err.statusCode).send(err.toJSON());
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = app.db.select().from(projects).where(eq3(projects.name, name)).get();
     if (existing) {
       app.db.update(projects).set({
         displayName: body.displayName,
         canonicalDomain: body.canonicalDomain,
+        ownedDomains: JSON.stringify(body.ownedDomains ?? []),
         country: body.country,
         language: body.language,
         tags: JSON.stringify(body.tags ?? []),
@@ -757,6 +792,7 @@ async function projectRoutes(app, opts) {
       name,
       displayName: body.displayName,
       canonicalDomain: body.canonicalDomain,
+      ownedDomains: JSON.stringify(body.ownedDomains ?? []),
       country: body.country,
       language: body.language,
       tags: JSON.stringify(body.tags ?? []),
@@ -840,6 +876,7 @@ async function projectRoutes(app, opts) {
       spec: {
         displayName: project.displayName,
         canonicalDomain: project.canonicalDomain,
+        ownedDomains: JSON.parse(project.ownedDomains || "[]"),
         country: project.country,
         language: project.language,
         keywords: kws.map((k) => k.keyword),
@@ -871,6 +908,7 @@ function formatProject(row) {
     name: row.name,
     displayName: row.displayName,
     canonicalDomain: row.canonicalDomain,
+    ownedDomains: JSON.parse(row.ownedDomains || "[]"),
     country: row.country,
     language: row.language,
     tags: JSON.parse(row.tags),
@@ -1552,6 +1590,7 @@ async function applyRoutes(app, opts) {
       app.db.update(projects).set({
         displayName: config.spec.displayName,
         canonicalDomain: config.spec.canonicalDomain,
+        ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
         country: config.spec.country,
         language: config.spec.language,
         labels: JSON.stringify(config.metadata.labels),
@@ -1574,6 +1613,7 @@ async function applyRoutes(app, opts) {
         name,
         displayName: config.spec.displayName,
         canonicalDomain: config.spec.canonicalDomain,
+        ownedDomains: JSON.stringify(config.spec.ownedDomains ?? []),
         country: config.spec.country,
         language: config.spec.language,
         tags: "[]",
@@ -1724,6 +1764,7 @@ async function applyRoutes(app, opts) {
       name: project.name,
       displayName: project.displayName,
       canonicalDomain: project.canonicalDomain,
+      ownedDomains: JSON.parse(project.ownedDomains || "[]"),
       country: project.country,
       language: project.language,
       tags: JSON.parse(project.tags),
@@ -1929,6 +1970,669 @@ function resolveProjectSafe4(app, name, reply) {
   }
 }
 
+// ../api-routes/src/openapi.ts
+var stringSchema = { type: "string" };
+var booleanSchema = { type: "boolean" };
+var integerSchema = { type: "integer" };
+var objectSchema = { type: "object", additionalProperties: true };
+var stringArraySchema = { type: "array", items: stringSchema };
+var nameParameter = {
+  name: "name",
+  in: "path",
+  required: true,
+  description: "Project name.",
+  schema: stringSchema
+};
+var runIdParameter = {
+  name: "id",
+  in: "path",
+  required: true,
+  description: "Run ID.",
+  schema: stringSchema
+};
+var notificationIdParameter = {
+  name: "id",
+  in: "path",
+  required: true,
+  description: "Notification ID.",
+  schema: stringSchema
+};
+var providerNameParameter = {
+  name: "name",
+  in: "path",
+  required: true,
+  description: "Provider name.",
+  schema: { type: "string", enum: ["gemini", "openai", "claude", "local"] }
+};
+var routeCatalog = [
+  {
+    method: "get",
+    path: "/api/v1/openapi.json",
+    summary: "Get the OpenAPI document",
+    description: "Machine-readable description of the Canonry API surface.",
+    tags: ["meta"],
+    auth: false,
+    responses: {
+      200: { description: "OpenAPI document." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/projects/{name}",
+    summary: "Create or update a project",
+    tags: ["projects"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["displayName", "canonicalDomain", "country", "language"],
+            properties: {
+              displayName: stringSchema,
+              canonicalDomain: stringSchema,
+              country: stringSchema,
+              language: stringSchema,
+              tags: stringArraySchema,
+              labels: objectSchema,
+              providers: stringArraySchema,
+              configSource: stringSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Project updated." },
+      201: { description: "Project created." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects",
+    summary: "List projects",
+    tags: ["projects"],
+    responses: {
+      200: { description: "Projects returned." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}",
+    summary: "Get a project",
+    tags: ["projects"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Project returned." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "delete",
+    path: "/api/v1/projects/{name}",
+    summary: "Delete a project",
+    tags: ["projects"],
+    parameters: [nameParameter],
+    responses: {
+      204: { description: "Project deleted." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/export",
+    summary: "Export a project as config",
+    tags: ["projects"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Project configuration returned." },
+      404: { description: "Project not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/keywords",
+    summary: "List keywords",
+    tags: ["keywords"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Keywords returned." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/projects/{name}/keywords",
+    summary: "Replace keywords",
+    tags: ["keywords"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["keywords"],
+            properties: {
+              keywords: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Keywords replaced." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/keywords",
+    summary: "Append keywords",
+    tags: ["keywords"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["keywords"],
+            properties: {
+              keywords: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Keywords appended." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/keywords/generate",
+    summary: "Generate keyword suggestions",
+    tags: ["keywords"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["provider"],
+            properties: {
+              provider: { type: "string", enum: ["gemini", "openai", "claude", "local"] },
+              count: integerSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Keyword suggestions returned." },
+      501: { description: "Keyword generation is not available." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/competitors",
+    summary: "List competitors",
+    tags: ["competitors"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Competitors returned." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/projects/{name}/competitors",
+    summary: "Replace competitors",
+    tags: ["competitors"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["competitors"],
+            properties: {
+              competitors: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Competitors replaced." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/runs",
+    summary: "Trigger a project run",
+    tags: ["runs"],
+    parameters: [nameParameter],
+    requestBody: {
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              kind: stringSchema,
+              trigger: stringSchema,
+              providers: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      201: { description: "Run queued." },
+      409: { description: "Run already in progress." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/runs",
+    summary: "List project runs",
+    tags: ["runs"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Runs returned." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/runs",
+    summary: "List all runs",
+    tags: ["runs"],
+    responses: {
+      200: { description: "Runs returned." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/runs",
+    summary: "Trigger runs for all projects",
+    tags: ["runs"],
+    requestBody: {
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              kind: stringSchema,
+              providers: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      207: { description: "Run results returned." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/runs/{id}",
+    summary: "Get a run and its snapshots",
+    tags: ["runs"],
+    parameters: [runIdParameter],
+    responses: {
+      200: { description: "Run returned." },
+      404: { description: "Run not found." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/apply",
+    summary: "Apply a Canonry config document",
+    tags: ["config"],
+    requestBody: {
+      required: true,
+      description: "Canonry project configuration as JSON.",
+      content: {
+        "application/json": {
+          schema: objectSchema
+        }
+      }
+    },
+    responses: {
+      200: { description: "Config applied." },
+      400: { description: "Invalid config." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/history",
+    summary: "Get project audit history",
+    tags: ["history"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Audit history returned." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/history",
+    summary: "Get global audit history",
+    tags: ["history"],
+    responses: {
+      200: { description: "Audit history returned." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/snapshots",
+    summary: "List query snapshots",
+    tags: ["history"],
+    parameters: [
+      nameParameter,
+      {
+        name: "limit",
+        in: "query",
+        description: "Maximum number of snapshots to return.",
+        schema: integerSchema
+      },
+      {
+        name: "offset",
+        in: "query",
+        description: "Number of snapshots to skip.",
+        schema: integerSchema
+      }
+    ],
+    responses: {
+      200: { description: "Snapshots returned." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/timeline",
+    summary: "Get keyword timeline",
+    tags: ["history"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Timeline returned." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/snapshots/diff",
+    summary: "Compare two runs",
+    tags: ["history"],
+    parameters: [
+      nameParameter,
+      {
+        name: "run1",
+        in: "query",
+        required: true,
+        description: "First run ID.",
+        schema: stringSchema
+      },
+      {
+        name: "run2",
+        in: "query",
+        required: true,
+        description: "Second run ID.",
+        schema: stringSchema
+      }
+    ],
+    responses: {
+      200: { description: "Diff returned." },
+      400: { description: "Missing run IDs." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/settings",
+    summary: "Get provider settings summary",
+    tags: ["settings"],
+    responses: {
+      200: { description: "Settings returned." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/settings/providers/{name}",
+    summary: "Update provider settings",
+    tags: ["settings"],
+    parameters: [providerNameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              apiKey: stringSchema,
+              baseUrl: stringSchema,
+              model: stringSchema,
+              quota: objectSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Provider updated." },
+      400: { description: "Invalid provider settings." },
+      501: { description: "Provider updates are not supported." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/projects/{name}/schedule",
+    summary: "Create or update a schedule",
+    tags: ["schedules"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            properties: {
+              preset: stringSchema,
+              cron: stringSchema,
+              timezone: stringSchema,
+              providers: stringArraySchema,
+              enabled: booleanSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Schedule updated." },
+      201: { description: "Schedule created." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/schedule",
+    summary: "Get a schedule",
+    tags: ["schedules"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Schedule returned." },
+      404: { description: "Schedule not found." }
+    }
+  },
+  {
+    method: "delete",
+    path: "/api/v1/projects/{name}/schedule",
+    summary: "Delete a schedule",
+    tags: ["schedules"],
+    parameters: [nameParameter],
+    responses: {
+      204: { description: "Schedule deleted." },
+      404: { description: "Schedule not found." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/notifications/events",
+    summary: "List notification event types",
+    tags: ["notifications"],
+    responses: {
+      200: { description: "Events returned." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/notifications",
+    summary: "Create a notification",
+    tags: ["notifications"],
+    parameters: [nameParameter],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["channel", "url", "events"],
+            properties: {
+              channel: stringSchema,
+              url: stringSchema,
+              events: stringArraySchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      201: { description: "Notification created." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/projects/{name}/notifications",
+    summary: "List notifications",
+    tags: ["notifications"],
+    parameters: [nameParameter],
+    responses: {
+      200: { description: "Notifications returned." }
+    }
+  },
+  {
+    method: "delete",
+    path: "/api/v1/projects/{name}/notifications/{id}",
+    summary: "Delete a notification",
+    tags: ["notifications"],
+    parameters: [nameParameter, notificationIdParameter],
+    responses: {
+      204: { description: "Notification deleted." },
+      404: { description: "Notification not found." }
+    }
+  },
+  {
+    method: "post",
+    path: "/api/v1/projects/{name}/notifications/{id}/test",
+    summary: "Send a test notification",
+    tags: ["notifications"],
+    parameters: [nameParameter, notificationIdParameter],
+    responses: {
+      200: { description: "Test notification sent." },
+      400: { description: "Stored notification config is invalid." },
+      404: { description: "Notification not found." },
+      502: { description: "Notification delivery failed." }
+    }
+  },
+  {
+    method: "get",
+    path: "/api/v1/telemetry",
+    summary: "Get telemetry status",
+    tags: ["telemetry"],
+    responses: {
+      200: { description: "Telemetry status returned." },
+      501: { description: "Telemetry status is not available." }
+    }
+  },
+  {
+    method: "put",
+    path: "/api/v1/telemetry",
+    summary: "Update telemetry status",
+    tags: ["telemetry"],
+    requestBody: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: {
+            type: "object",
+            required: ["enabled"],
+            properties: {
+              enabled: booleanSchema
+            }
+          }
+        }
+      }
+    },
+    responses: {
+      200: { description: "Telemetry updated." },
+      400: { description: "Invalid telemetry request." },
+      501: { description: "Telemetry configuration is not available." }
+    }
+  }
+];
+function buildOpenApiDocument(info = {}) {
+  const paths = routeCatalog.reduce((acc, route) => {
+    const operation = {
+      summary: route.summary,
+      tags: route.tags,
+      responses: route.responses,
+      operationId: buildOperationId(route.method, route.path)
+    };
+    if (route.description) operation.description = route.description;
+    if (route.parameters) operation.parameters = route.parameters;
+    if (route.requestBody) operation.requestBody = route.requestBody;
+    if (route.auth === false) operation.security = [];
+    const pathItem = acc[route.path] ?? {};
+    pathItem[route.method] = operation;
+    acc[route.path] = pathItem;
+    return acc;
+  }, {});
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: info.title ?? "Canonry API",
+      version: info.version ?? "0.0.0",
+      description: info.description ?? "REST API for Canonry projects, runs, schedules, and notifications."
+    },
+    servers: [
+      {
+        url: "/"
+      }
+    ],
+    security: [{ bearerAuth: [] }],
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          bearerFormat: "API key"
+        }
+      }
+    },
+    paths
+  };
+}
+async function openApiRoutes(app, opts = {}) {
+  app.get("/openapi.json", async (_request, reply) => {
+    return reply.type("application/json").send(buildOpenApiDocument(opts));
+  });
+}
+function buildOperationId(method, path3) {
+  const parts = path3.split("/").filter(Boolean).map((part) => {
+    if (part.startsWith("{") && part.endsWith("}")) {
+      return `by-${part.slice(1, -1)}`;
+    }
+    return part;
+  });
+  return [method, ...parts].join("-").replace(/[^a-zA-Z0-9]+(.)/g, (_match, char) => char.toUpperCase()).replace(/^[^a-zA-Z]+/, "");
+}
+
 // ../api-routes/src/settings.ts
 async function settingsRoutes(app, opts) {
   app.get("/settings", async () => ({
@@ -2307,6 +3011,7 @@ async function apiRoutes(app, opts) {
     await app.register(authPlugin);
   }
   await app.register(async (api) => {
+    await api.register(openApiRoutes, opts.openApiInfo ?? {});
     await api.register(projectRoutes, {
       onProjectDeleted: opts.onProjectDeleted
     });
@@ -3315,17 +4020,21 @@ var JobRunner = class {
               minuteWindows.get(providerName),
               config.quotaPolicy.maxRequestsPerMinute
             );
+            const allDomains = effectiveDomains({
+              canonicalDomain: project.canonicalDomain,
+              ownedDomains: JSON.parse(project.ownedDomains || "[]")
+            });
             const raw = await adapter.executeTrackedQuery(
               {
                 keyword: kw.keyword,
-                canonicalDomains: [project.canonicalDomain],
+                canonicalDomains: allDomains,
                 competitorDomains
               },
               config
             );
             const normalized = adapter.normalizeResult(raw);
-            console.log(`[JobRunner] ${providerName}: "${kw.keyword}" citedDomains=${JSON.stringify(normalized.citedDomains)}, groundingSources=${JSON.stringify(normalized.groundingSources.map((s) => s.uri))}, canonical="${project.canonicalDomain}"`);
-            const citationState = determineCitationState(normalized, project.canonicalDomain);
+            console.log(`[JobRunner] ${providerName}: "${kw.keyword}" citedDomains=${JSON.stringify(normalized.citedDomains)}, groundingSources=${JSON.stringify(normalized.groundingSources.map((s) => s.uri))}, domains=${JSON.stringify(allDomains)}`);
+            const citationState = determineCitationState(normalized, allDomains);
             const overlap = computeCompetitorOverlap(normalized, competitorDomains);
             this.db.insert(querySnapshots).values({
               id: crypto12.randomUUID(),
@@ -3444,39 +4153,31 @@ function getCurrentPeriod() {
   const d = /* @__PURE__ */ new Date();
   return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
 }
-function normalizeDomain(input) {
-  let domain = input;
-  try {
-    if (domain.includes("://")) {
-      domain = new URL(domain).hostname;
-    }
-  } catch {
-  }
-  return domain.replace(/^www\./, "");
-}
 function domainMatches(domain, canonicalDomain) {
-  const normalized = normalizeDomain(canonicalDomain);
-  const d = normalizeDomain(domain);
+  const normalized = normalizeProjectDomain(canonicalDomain);
+  const d = normalizeProjectDomain(domain);
   return d === normalized || d.endsWith(`.${normalized}`);
 }
-function determineCitationState(normalized, canonicalDomain) {
-  const bareDomain = normalizeDomain(canonicalDomain);
-  if (normalized.citedDomains.some((d) => domainMatches(d, bareDomain))) {
-    return "cited";
-  }
-  const lowerDomain = bareDomain.toLowerCase();
-  for (const source of normalized.groundingSources) {
-    try {
-      const uri = source.uri.toLowerCase();
-      if (uri.includes(lowerDomain)) {
-        return "cited";
-      }
-    } catch {
+function determineCitationState(normalized, domains) {
+  for (const canonicalDomain of domains) {
+    const bareDomain = normalizeProjectDomain(canonicalDomain);
+    if (normalized.citedDomains.some((d) => domainMatches(d, bareDomain))) {
+      return "cited";
     }
-    if (source.title) {
-      const titleLower = source.title.toLowerCase().replace(/^www\./, "");
-      if (titleLower === lowerDomain || titleLower.endsWith(`.${lowerDomain}`)) {
-        return "cited";
+    const lowerDomain = bareDomain.toLowerCase();
+    for (const source of normalized.groundingSources) {
+      try {
+        const uri = source.uri.toLowerCase();
+        if (lowerDomain.includes(".") && uri.includes(lowerDomain)) {
+          return "cited";
+        }
+      } catch {
+      }
+      if (source.title) {
+        const titleLower = source.title.toLowerCase().replace(/^www\./, "");
+        if (titleLower === lowerDomain || titleLower.endsWith(`.${lowerDomain}`)) {
+          return "cited";
+        }
       }
     }
   }
@@ -4026,6 +4727,10 @@ async function createServer(opts) {
   await app.register(apiRoutes, {
     db: opts.db,
     skipAuth: false,
+    openApiInfo: {
+      title: "Canonry API",
+      version: PKG_VERSION
+    },
     providerSummary,
     onRunCreated: (runId, projectId, providers2) => {
       jobRunner.executeRun(runId, projectId, providers2).catch((err) => {
@@ -4205,6 +4910,7 @@ function parseKeywordResponse(raw, count) {
 export {
   providerQuotaPolicySchema,
   notificationEventSchema,
+  effectiveDomains,
   apiKeys,
   createClient,
   migrate,