@ainyc/canonry 3.3.9 → 3.4.5

package/dist/chunk-D4YFX3X4.js

@@ -0,0 +1,1918 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../contracts/src/run.ts
+import { z as z2 } from "zod";
+
+// ../contracts/src/provider.ts
+import { z } from "zod";
+var providerQuotaPolicySchema = z.object({
+  maxConcurrency: z.number().int().positive(),
+  maxRequestsPerMinute: z.number().int().positive(),
+  maxRequestsPerDay: z.number().int().positive()
+});
+var ProviderNames = {
+  gemini: "gemini",
+  openai: "openai",
+  claude: "claude",
+  perplexity: "perplexity",
+  local: "local",
+  cdpChatgpt: "cdp:chatgpt"
+};
+var providerNameSchema = z.string().min(1);
+var apiProviderNameSchema = z.string().min(1);
+function isBrowserProvider(name) {
+  return name.startsWith("cdp:");
+}
+var CDP_TARGETS = ["cdp:chatgpt"];
+function resolveProviderInput(input) {
+  const lower = input.trim().toLowerCase();
+  if (lower === "cdp") {
+    return [...CDP_TARGETS];
+  }
+  return lower ? [lower] : [];
+}
+var locationContextSchema = z.object({
+  label: z.string().min(1),
+  city: z.string().min(1),
+  region: z.string().min(1),
+  country: z.string().length(2),
+  timezone: z.string().optional()
+});
+
+// ../contracts/src/run.ts
+var runStatusSchema = z2.enum(["queued", "running", "completed", "partial", "failed", "cancelled"]);
+var RunStatuses = runStatusSchema.enum;
+var runKindSchema = z2.enum([
+  "answer-visibility",
+  "site-audit",
+  "gsc-sync",
+  "inspect-sitemap",
+  "ga-sync",
+  "bing-inspect",
+  "bing-inspect-sitemap",
+  "backlink-extract"
+]);
+var RunKinds = runKindSchema.enum;
+var runTriggerSchema = z2.enum(["manual", "scheduled", "config-apply"]);
+var RunTriggers = runTriggerSchema.enum;
+var citationStateSchema = z2.enum(["cited", "not-cited"]);
+var CitationStates = citationStateSchema.enum;
+var visibilityStateSchema = z2.enum(["visible", "not-visible"]);
+var VisibilityStates = visibilityStateSchema.enum;
+var computedTransitionSchema = z2.enum(["new", "cited", "lost", "emerging", "not-cited"]);
+var ComputedTransitions = computedTransitionSchema.enum;
+var runTriggerRequestSchema = z2.object({
+  kind: z2.literal(RunKinds["answer-visibility"]).optional(),
+  trigger: z2.literal(RunTriggers.manual).optional(),
+  providers: z2.array(providerNameSchema).optional(),
+  location: z2.string().min(1).optional(),
+  allLocations: z2.boolean().optional(),
+  noLocation: z2.boolean().optional()
+}).refine(
+  (data) => Number(Boolean(data.location)) + Number(Boolean(data.allLocations)) + Number(Boolean(data.noLocation)) <= 1,
+  { message: 'Only one of "location", "allLocations", or "noLocation" may be provided' }
+);
+var runProviderErrorSchema = z2.object({
+  /** Human-readable error message (best-effort extracted from `raw.error.message` / `raw.message`, otherwise the raw text with any `[provider-X]` prefix stripped). */
+  message: z2.string(),
+  /** Original provider response payload, if the underlying error body parsed as JSON. Use this for structured fields like HTTP status, error code, etc. */
+  raw: z2.unknown().optional()
+});
+var runErrorSchema = z2.object({
+  /** Top-level message for runs that failed without a per-provider error (e.g. user cancellation, internal scheduling failures). */
+  message: z2.string().optional(),
+  /** Per-provider errors for visibility-sweep runs that had at least one provider fail. */
+  providers: z2.record(z2.string(), runProviderErrorSchema).optional()
+});
+var runDtoSchema = z2.object({
+  id: z2.string(),
+  projectId: z2.string(),
+  kind: runKindSchema,
+  status: runStatusSchema,
+  trigger: runTriggerSchema.default("manual"),
+  location: z2.string().nullable().optional(),
+  startedAt: z2.string().nullable().optional(),
+  finishedAt: z2.string().nullable().optional(),
+  error: runErrorSchema.nullable().optional(),
+  createdAt: z2.string()
+});
+var PROVIDER_PREFIX = /^\[provider-[a-zA-Z0-9_-]+\]\s+/;
+function parseProviderErrorMessage(msg) {
+  const stripped = msg.replace(PROVIDER_PREFIX, "");
+  try {
+    const raw = JSON.parse(stripped);
+    if (raw && typeof raw === "object") {
+      const inner = raw;
+      const fromErrorMessage = typeof inner.error?.message === "string" ? inner.error.message : void 0;
+      const fromMessage = typeof inner.message === "string" ? inner.message : void 0;
+      return { message: fromErrorMessage ?? fromMessage ?? stripped, raw };
+    }
+  } catch {
+  }
+  return { message: stripped };
+}
+function parseRunError(raw) {
+  if (!raw) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { message: raw };
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return { message: raw };
+  }
+  const obj = parsed;
+  const hasProviders = obj.providers && typeof obj.providers === "object";
+  const hasMessage = typeof obj.message === "string";
+  if (hasProviders || hasMessage) {
+    return parsed;
+  }
+  const providers = {};
+  for (const [name, val] of Object.entries(obj)) {
+    providers[name] = parseProviderErrorMessage(typeof val === "string" ? val : JSON.stringify(val));
+  }
+  return { providers };
+}
+function buildRunErrorFromMessages(messages) {
+  const providers = {};
+  for (const [name, msg] of messages) {
+    providers[name] = parseProviderErrorMessage(msg);
+  }
+  return { providers };
+}
+function serializeRunError(err) {
+  return JSON.stringify(err);
+}
+function formatRunErrorOneLine(err) {
+  if (err.providers) {
+    const entries = Object.entries(err.providers);
+    if (entries.length === 1) {
+      const [provider, detail] = entries[0];
+      return `${provider}: ${detail.message}`;
+    }
+    if (entries.length > 1) {
+      return entries.map(([p, d]) => `${p}: ${d.message}`).join(" \u2022 ");
+    }
+  }
+  return err.message ?? "Run failed.";
+}
+var groundingSourceSchema = z2.object({
+  uri: z2.string(),
+  title: z2.string()
+});
+var querySnapshotDtoSchema = z2.object({
+  id: z2.string(),
+  runId: z2.string(),
+  keywordId: z2.string(),
+  keyword: z2.string().optional(),
+  provider: providerNameSchema,
+  citationState: citationStateSchema,
+  answerMentioned: z2.boolean().optional(),
+  visibilityState: visibilityStateSchema.optional(),
+  transition: computedTransitionSchema.optional(),
+  answerText: z2.string().nullable().optional(),
+  citedDomains: z2.array(z2.string()).default([]),
+  competitorOverlap: z2.array(z2.string()).default([]),
+  recommendedCompetitors: z2.array(z2.string()).default([]),
+  matchedTerms: z2.array(z2.string()).default([]),
+  groundingSources: z2.array(groundingSourceSchema).default([]),
+  searchQueries: z2.array(z2.string()).default([]),
+  model: z2.string().nullable().optional(),
+  location: z2.string().nullable().optional(),
+  createdAt: z2.string()
+});
+var snapshotListResponseSchema = z2.object({
+  snapshots: z2.array(querySnapshotDtoSchema),
+  total: z2.number().int().nonnegative()
+});
+var snapshotDiffRowSchema = z2.object({
+  keywordId: z2.string().nullable(),
+  keyword: z2.string().nullable(),
+  run1State: citationStateSchema.nullable(),
+  run2State: citationStateSchema.nullable(),
+  run1AnswerMentioned: z2.boolean().nullable(),
+  run2AnswerMentioned: z2.boolean().nullable(),
+  run1VisibilityState: visibilityStateSchema.nullable(),
+  run2VisibilityState: visibilityStateSchema.nullable(),
+  changed: z2.boolean(),
+  visibilityChanged: z2.boolean()
+});
+var snapshotDiffResponseSchema = z2.object({
+  run1: z2.string(),
+  run2: z2.string(),
+  diff: z2.array(snapshotDiffRowSchema)
+});
+var runDetailDtoSchema = runDtoSchema.extend({
+  snapshots: z2.array(querySnapshotDtoSchema).optional()
+});
+var latestProjectRunDtoSchema = z2.object({
+  totalRuns: z2.number().int().nonnegative(),
+  run: runDetailDtoSchema.nullable()
+});
+var auditLogEntrySchema = z2.object({
+  id: z2.string(),
+  projectId: z2.string().nullable().optional(),
+  actor: z2.string(),
+  action: z2.string(),
+  entityType: z2.string(),
+  entityId: z2.string().nullable().optional(),
+  diff: z2.unknown().optional(),
+  createdAt: z2.string()
+});
+
+// ../contracts/src/config-schema.ts
+import { z as z5 } from "zod";
+
+// ../contracts/src/notification.ts
+import { z as z3 } from "zod";
+var notificationEventSchema = z3.enum([
+  "citation.lost",
+  "citation.gained",
+  "run.completed",
+  "run.failed",
+  "insight.critical",
+  "insight.high"
+]);
+var notificationDtoSchema = z3.object({
+  id: z3.string(),
+  projectId: z3.string(),
+  channel: z3.literal("webhook"),
+  url: z3.string().url(),
+  urlDisplay: z3.string(),
+  urlHost: z3.string(),
+  events: z3.array(notificationEventSchema),
+  enabled: z3.boolean().default(true),
+  /** Opaque tag identifying the creator (e.g. `"agent"` for Aero webhooks). */
+  source: z3.string().optional(),
+  webhookSecret: z3.string().optional(),
+  createdAt: z3.string(),
+  updatedAt: z3.string()
+});
+var notificationCreateRequestSchema = z3.object({
+  channel: z3.literal("webhook"),
+  url: z3.string().url(),
+  events: z3.array(notificationEventSchema).min(1),
+  source: z3.string().optional()
+});
+
+// ../contracts/src/project.ts
+import { z as z4 } from "zod";
+var configSourceSchema = z4.enum(["cli", "api", "config-file"]);
+function findDuplicateLocationLabels(locations) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const location of locations) {
+    if (seen.has(location.label)) {
+      duplicates.add(location.label);
+      continue;
+    }
+    seen.add(location.label);
+  }
+  return [...duplicates];
+}
+function hasLocationLabel(locations, label) {
+  if (!label) return true;
+  return locations.some((location) => location.label === label);
+}
+var projectUpsertRequestSchema = z4.object({
+  displayName: z4.string().min(1),
+  canonicalDomain: z4.string().min(1),
+  ownedDomains: z4.array(z4.string().min(1)).optional(),
+  country: z4.string().length(2),
+  language: z4.string().min(2),
+  tags: z4.array(z4.string()).optional(),
+  labels: z4.record(z4.string(), z4.string()).optional(),
+  providers: z4.array(providerNameSchema).optional(),
+  locations: z4.array(locationContextSchema).optional(),
+  defaultLocation: z4.string().nullable().optional(),
+  autoExtractBacklinks: z4.boolean().optional(),
+  configSource: configSourceSchema.optional()
+});
+var projectDtoSchema = z4.object({
+  id: z4.string(),
+  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([]),
+  labels: z4.record(z4.string(), z4.string()).default({}),
+  locations: z4.array(locationContextSchema).default([]),
+  defaultLocation: z4.string().nullable().optional(),
+  autoExtractBacklinks: z4.boolean().default(false),
+  configSource: configSourceSchema.default("cli"),
+  configRevision: z4.number().int().positive().default(1),
+  createdAt: z4.string().optional(),
+  updatedAt: z4.string().optional()
+});
+var keywordDtoSchema = z4.object({
+  id: z4.string(),
+  keyword: z4.string(),
+  createdAt: z4.string()
+});
+var keywordBatchRequestSchema = z4.object({
+  keywords: z4.array(z4.string().trim().min(1)).min(1)
+});
+var keywordGenerateRequestSchema = z4.object({
+  provider: providerNameSchema,
+  count: z4.number().int().min(1).max(20).optional()
+});
+var competitorDtoSchema = z4.object({
+  id: z4.string(),
+  domain: z4.string(),
+  createdAt: z4.string()
+});
+var competitorBatchRequestSchema = z4.object({
+  competitors: z4.array(z4.string().trim().min(1)).min(1)
+});
+function normalizeProjectDomain(input) {
+  let domain = input.trim().toLowerCase();
+  try {
+    if (domain.includes("://")) {
+      domain = new URL(domain).hostname.toLowerCase();
+    }
+  } catch {
+  }
+  return domain.replace(/^www\./, "");
+}
+var MULTI_LABEL_PUBLIC_SUFFIXES = /* @__PURE__ */ new Set([
+  "ac.uk",
+  "co.id",
+  "co.il",
+  "co.in",
+  "co.jp",
+  "co.kr",
+  "co.nz",
+  "co.th",
+  "co.uk",
+  "co.za",
+  "com.au",
+  "com.br",
+  "com.cn",
+  "com.mx",
+  "com.ph",
+  "com.sg",
+  "com.tr",
+  "edu.au",
+  "edu.sg",
+  "gov.au",
+  "gov.uk",
+  "me.uk",
+  "ne.jp",
+  "net.au",
+  "net.br",
+  "net.cn",
+  "net.in",
+  "net.tr",
+  "or.jp",
+  "or.kr",
+  "org.au",
+  "org.br",
+  "org.in",
+  "org.nz",
+  "org.tr",
+  "org.uk",
+  "org.za"
+]);
+function registrableDomain(input) {
+  const normalized = normalizeProjectDomain(input);
+  if (!normalized) return "";
+  const hostname = normalized.split("/")[0]?.split(":")[0] ?? "";
+  if (!hostname) return "";
+  const labels = hostname.split(".").filter(Boolean);
+  if (labels.length < 2) return "";
+  if (labels.length === 2) return labels.join(".");
+  const lastTwo = labels.slice(-2).join(".");
+  if (MULTI_LABEL_PUBLIC_SUFFIXES.has(lastTwo)) {
+    return labels.length >= 3 ? labels.slice(-3).join(".") : "";
+  }
+  return labels.slice(-2).join(".");
+}
+function brandLabelFromDomain(input) {
+  const reg = registrableDomain(input);
+  if (!reg) return "";
+  return reg.split(".")[0] ?? "";
+}
+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/config-schema.ts
+var configMetadataSchema = z5.object({
+  name: z5.string().min(1).max(63).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, {
+    message: "Name must be a lowercase slug (letters, numbers, hyphens)"
+  }),
+  labels: z5.record(z5.string(), z5.string()).optional().default({})
+});
+var configScheduleSchema = z5.object({
+  preset: z5.string().optional(),
+  cron: z5.string().optional(),
+  timezone: z5.string().optional().default("UTC"),
+  providers: z5.array(providerNameSchema).optional().default([])
+}).refine(
+  (data) => data.preset && !data.cron || !data.preset && data.cron,
+  { message: 'Exactly one of "preset" or "cron" must be provided' }
+).optional();
+var configNotificationSchema = z5.object({
+  channel: z5.literal("webhook"),
+  url: z5.string().url(),
+  events: z5.array(notificationEventSchema).min(1)
+});
+var configGoogleSchema = z5.object({
+  gsc: z5.object({
+    propertyUrl: z5.string()
+  }).optional(),
+  syncSchedule: z5.object({
+    preset: z5.string().optional(),
+    cron: z5.string().optional()
+  }).optional()
+}).optional();
+var configSpecSchema = z5.object({
+  displayName: z5.string().min(1),
+  canonicalDomain: z5.string().min(1),
+  ownedDomains: z5.array(z5.string().min(1)).optional().default([]),
+  country: z5.string().length(2),
+  language: z5.string().min(2),
+  keywords: z5.array(z5.string().min(1)).optional().default([]),
+  competitors: z5.array(z5.string().min(1)).optional().default([]),
+  providers: z5.array(providerNameSchema).optional().default([]),
+  locations: z5.array(locationContextSchema).optional().default([]),
+  defaultLocation: z5.string().optional(),
+  schedule: configScheduleSchema,
+  notifications: z5.array(configNotificationSchema).optional().default([]),
+  google: configGoogleSchema,
+  autoExtractBacklinks: z5.boolean().optional().default(false)
+}).superRefine((spec, ctx) => {
+  const duplicateLabels = findDuplicateLocationLabels(spec.locations);
+  if (duplicateLabels.length > 0) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Duplicate location labels are not allowed: ${duplicateLabels.join(", ")}`,
+      path: ["locations"]
+    });
+  }
+  if (!hasLocationLabel(spec.locations, spec.defaultLocation)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `defaultLocation "${spec.defaultLocation}" must match a configured location label`,
+      path: ["defaultLocation"]
+    });
+  }
+});
+var projectConfigSchema = z5.object({
+  apiVersion: z5.literal("canonry/v1"),
+  kind: z5.literal("Project"),
+  metadata: configMetadataSchema,
+  spec: configSpecSchema
+});
+
+// ../contracts/src/errors.ts
+var AppError = class extends Error {
+  code;
+  statusCode;
+  details;
+  constructor(code, message, statusCode, details) {
+    super(message);
+    this.name = "AppError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        ...this.details ? { details: this.details } : {}
+      }
+    };
+  }
+};
+function notFound(entity, id) {
+  return new AppError("NOT_FOUND", `${entity} '${id}' not found`, 404);
+}
+function validationError(message, details) {
+  return new AppError("VALIDATION_ERROR", message, 400, details);
+}
+function authRequired() {
+  return new AppError("AUTH_REQUIRED", "Authentication required", 401);
+}
+function authInvalid() {
+  return new AppError("AUTH_INVALID", "Invalid API key", 401);
+}
+function providerError(message, details) {
+  return new AppError("PROVIDER_ERROR", message, 502, details);
+}
+function runInProgress(projectName) {
+  return new AppError("RUN_IN_PROGRESS", `A run is already in progress for '${projectName}'`, 409);
+}
+function runNotCancellable(runId, status) {
+  return new AppError("RUN_NOT_CANCELLABLE", `Run '${runId}' is already in terminal state '${status}' and cannot be cancelled`, 409);
+}
+function unsupportedKind(kind) {
+  return new AppError("UNSUPPORTED_KIND", `Kind '${kind}' is not supported in this version`, 400);
+}
+function notImplemented(message) {
+  return new AppError("NOT_IMPLEMENTED", message, 501);
+}
+function deliveryFailed(message) {
+  return new AppError("DELIVERY_FAILED", message, 502);
+}
+function agentBusy(projectName) {
+  return new AppError(
+    "AGENT_BUSY",
+    `Aero is already running a turn for '${projectName}'. Retry after the current turn settles.`,
+    409
+  );
+}
+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 z6 } from "zod";
+var googleConnectionTypeSchema = z6.enum(["gsc", "ga4"]);
+var googleConnectionDtoSchema = z6.object({
+  id: z6.string(),
+  domain: z6.string(),
+  connectionType: googleConnectionTypeSchema,
+  propertyId: z6.string().nullable().optional(),
+  sitemapUrl: z6.string().nullable().optional(),
+  scopes: z6.array(z6.string()).default([]),
+  createdAt: z6.string(),
+  updatedAt: z6.string()
+});
+var gscSearchDataDtoSchema = z6.object({
+  date: z6.string(),
+  query: z6.string(),
+  page: z6.string(),
+  country: z6.string().nullable().optional(),
+  device: z6.string().nullable().optional(),
+  clicks: z6.number(),
+  impressions: z6.number(),
+  ctr: z6.number(),
+  position: z6.number()
+});
+var gscUrlInspectionDtoSchema = z6.object({
+  id: z6.string(),
+  url: z6.string(),
+  indexingState: z6.string().nullable().optional(),
+  verdict: z6.string().nullable().optional(),
+  coverageState: z6.string().nullable().optional(),
+  pageFetchState: z6.string().nullable().optional(),
+  robotsTxtState: z6.string().nullable().optional(),
+  crawlTime: z6.string().nullable().optional(),
+  lastCrawlResult: z6.string().nullable().optional(),
+  isMobileFriendly: z6.boolean().nullable().optional(),
+  richResults: z6.array(z6.string()).default([]),
+  inspectedAt: z6.string()
+});
+var indexTransitionSchema = z6.enum(["stable", "reindexed", "deindexed", "still-missing", "new"]);
+var gscDeindexedRowSchema = z6.object({
+  url: z6.string(),
+  previousState: z6.string().nullable(),
+  currentState: z6.string().nullable(),
+  transitionDate: z6.string()
+});
+var gscReasonGroupSchema = z6.object({
+  reason: z6.string(),
+  count: z6.number(),
+  urls: z6.array(gscUrlInspectionDtoSchema).default([])
+});
+var gscCoverageSummaryDtoSchema = z6.object({
+  summary: z6.object({
+    total: z6.number(),
+    indexed: z6.number(),
+    notIndexed: z6.number(),
+    deindexed: z6.number(),
+    percentage: z6.number()
+  }),
+  lastInspectedAt: z6.string().nullable(),
+  indexed: z6.array(gscUrlInspectionDtoSchema).default([]),
+  notIndexed: z6.array(gscUrlInspectionDtoSchema).default([]),
+  deindexed: z6.array(gscDeindexedRowSchema).default([]),
+  reasonGroups: z6.array(gscReasonGroupSchema).default([])
+});
+var indexingNotificationDtoSchema = z6.object({
+  url: z6.string(),
+  type: z6.enum(["URL_UPDATED", "URL_DELETED"]),
+  notifiedAt: z6.string()
+});
+var indexingRequestResultDtoSchema = z6.object({
+  url: z6.string(),
+  type: z6.enum(["URL_UPDATED", "URL_DELETED"]),
+  notifiedAt: z6.string(),
+  status: z6.enum(["success", "error"]),
+  error: z6.string().optional()
+});
+var gscCoverageSnapshotDtoSchema = z6.object({
+  date: z6.string(),
+  indexed: z6.number(),
+  notIndexed: z6.number(),
+  reasonBreakdown: z6.record(z6.string(), z6.number()).default({})
+});
+
+// ../contracts/src/bing.ts
+import { z as z7 } from "zod";
+var bingConnectionDtoSchema = z7.object({
+  id: z7.string(),
+  domain: z7.string(),
+  siteUrl: z7.string().nullable().optional(),
+  createdAt: z7.string(),
+  updatedAt: z7.string()
+});
+var bingUrlInspectionDtoSchema = z7.object({
+  id: z7.string(),
+  url: z7.string(),
+  httpCode: z7.number().nullable().optional(),
+  inIndex: z7.boolean().nullable().optional(),
+  lastCrawledDate: z7.string().nullable().optional(),
+  inIndexDate: z7.string().nullable().optional(),
+  inspectedAt: z7.string(),
+  // Fields derived from GetUrlInfo response (more reliable than InIndex)
+  documentSize: z7.number().nullable().optional(),
+  anchorCount: z7.number().nullable().optional(),
+  discoveryDate: z7.string().nullable().optional()
+});
+var bingCoverageSummaryDtoSchema = z7.object({
+  summary: z7.object({
+    total: z7.number(),
+    indexed: z7.number(),
+    notIndexed: z7.number(),
+    unknown: z7.number().optional(),
+    percentage: z7.number()
+  }),
+  lastInspectedAt: z7.string().nullable(),
+  indexed: z7.array(bingUrlInspectionDtoSchema).default([]),
+  notIndexed: z7.array(bingUrlInspectionDtoSchema).default([]),
+  unknown: z7.array(bingUrlInspectionDtoSchema).default([]).optional()
+});
+var bingKeywordStatsDtoSchema = z7.object({
+  query: z7.string(),
+  impressions: z7.number(),
+  clicks: z7.number(),
+  ctr: z7.number(),
+  averagePosition: z7.number()
+});
+var bingCoverageSnapshotDtoSchema = z7.object({
+  date: z7.string(),
+  indexed: z7.number(),
+  notIndexed: z7.number(),
+  unknown: z7.number()
+});
+var bingSubmitResultDtoSchema = z7.object({
+  url: z7.string(),
+  status: z7.enum(["success", "error"]),
+  submittedAt: z7.string(),
+  error: z7.string().optional()
+});
+
+// ../contracts/src/wordpress.ts
+import { z as z8 } from "zod";
+var wordpressEnvSchema = z8.enum(["live", "staging"]);
+var wordpressConnectionDtoSchema = z8.object({
+  projectName: z8.string(),
+  url: z8.string(),
+  stagingUrl: z8.string().optional(),
+  username: z8.string(),
+  defaultEnv: wordpressEnvSchema,
+  createdAt: z8.string(),
+  updatedAt: z8.string()
+});
+var wordpressSiteStatusDtoSchema = z8.object({
+  url: z8.string(),
+  reachable: z8.boolean(),
+  pageCount: z8.number().nullable().optional(),
+  version: z8.string().nullable().optional(),
+  error: z8.string().nullable().optional(),
+  plugins: z8.array(z8.string()).optional(),
+  authenticatedUser: z8.object({
+    id: z8.number(),
+    slug: z8.string()
+  }).nullable().optional()
+});
+var wordpressStatusDtoSchema = z8.object({
+  connected: z8.boolean(),
+  projectName: z8.string(),
+  defaultEnv: wordpressEnvSchema,
+  live: wordpressSiteStatusDtoSchema.nullable(),
+  staging: wordpressSiteStatusDtoSchema.nullable(),
+  adminUrl: z8.string().nullable().optional()
+});
+var wordpressPageSummaryDtoSchema = z8.object({
+  id: z8.number(),
+  slug: z8.string(),
+  title: z8.string(),
+  status: z8.string(),
+  modifiedAt: z8.string().nullable().optional(),
+  link: z8.string().nullable().optional()
+});
+var wordpressSeoStateDtoSchema = z8.object({
+  title: z8.string().nullable(),
+  description: z8.string().nullable(),
+  noindex: z8.boolean().nullable(),
+  writable: z8.boolean().default(false),
+  writeTargets: z8.array(z8.string()).default([])
+});
+var wordpressSchemaBlockDtoSchema = z8.object({
+  type: z8.string(),
+  json: z8.record(z8.string(), z8.unknown())
+});
+var wordpressPageDetailDtoSchema = wordpressPageSummaryDtoSchema.extend({
+  env: wordpressEnvSchema,
+  content: z8.string(),
+  seo: wordpressSeoStateDtoSchema,
+  schemaBlocks: z8.array(wordpressSchemaBlockDtoSchema).default([])
+});
+var wordpressDiffPageDtoSchema = wordpressPageDetailDtoSchema.extend({
+  contentHash: z8.string(),
+  contentSnippet: z8.string()
+});
+var wordpressManualAssistDtoSchema = z8.object({
+  manualRequired: z8.literal(true),
+  targetUrl: z8.string(),
+  adminUrl: z8.string().nullable().optional(),
+  content: z8.string(),
+  nextSteps: z8.array(z8.string()).default([])
+});
+var wordpressAuditIssueDtoSchema = z8.object({
+  slug: z8.string(),
+  severity: z8.enum(["high", "medium", "low"]),
+  code: z8.enum([
+    "noindex",
+    "missing-seo-title",
+    "missing-meta-description",
+    "missing-schema",
+    "thin-content"
+  ]),
+  message: z8.string()
+});
+var wordpressAuditPageDtoSchema = z8.object({
+  slug: z8.string(),
+  title: z8.string(),
+  status: z8.string(),
+  wordCount: z8.number(),
+  seo: wordpressSeoStateDtoSchema,
+  schemaPresent: z8.boolean(),
+  issues: z8.array(wordpressAuditIssueDtoSchema).default([])
+});
+var wordpressBulkMetaEntryResultDtoSchema = z8.object({
+  slug: z8.string(),
+  status: z8.enum(["applied", "skipped", "manual"]),
+  error: z8.string().optional(),
+  manualAssist: wordpressManualAssistDtoSchema.optional()
+});
+var wordpressBulkMetaResultDtoSchema = z8.object({
+  env: wordpressEnvSchema,
+  strategy: z8.enum(["plugin", "manual"]),
+  results: z8.array(wordpressBulkMetaEntryResultDtoSchema)
+});
+var wordpressSchemaDeployEntryResultDtoSchema = z8.object({
+  slug: z8.string(),
+  status: z8.enum(["deployed", "stripped", "skipped", "failed"]),
+  schemasInjected: z8.array(z8.string()).optional(),
+  manualAssist: wordpressManualAssistDtoSchema.optional(),
+  error: z8.string().optional()
+});
+var wordpressSchemaDeployResultDtoSchema = z8.object({
+  env: wordpressEnvSchema,
+  results: z8.array(wordpressSchemaDeployEntryResultDtoSchema)
+});
+var wordpressSchemaStatusPageDtoSchema = z8.object({
+  slug: z8.string(),
+  title: z8.string(),
+  canonrySchemas: z8.array(z8.string()),
+  thirdPartySchemas: z8.array(z8.string()),
+  hasCanonrySchema: z8.boolean()
+});
+var wordpressSchemaStatusResultDtoSchema = z8.object({
+  env: wordpressEnvSchema,
+  pages: z8.array(wordpressSchemaStatusPageDtoSchema)
+});
+var wordpressOnboardStepDtoSchema = z8.object({
+  name: z8.string(),
+  status: z8.enum(["completed", "skipped", "failed"]),
+  summary: z8.string().optional(),
+  error: z8.string().optional()
+});
+var wordpressOnboardResultDtoSchema = z8.object({
+  projectName: z8.string(),
+  steps: z8.array(wordpressOnboardStepDtoSchema)
+});
+var wordpressDiffDtoSchema = z8.object({
+  slug: z8.string(),
+  live: wordpressDiffPageDtoSchema,
+  staging: wordpressDiffPageDtoSchema,
+  hasDifferences: z8.boolean(),
+  differences: z8.object({
+    title: z8.boolean(),
+    slug: z8.boolean(),
+    content: z8.boolean(),
+    seoTitle: z8.boolean(),
+    seoDescription: z8.boolean(),
+    noindex: z8.boolean(),
+    schema: z8.boolean()
+  })
+});
+
+// ../contracts/src/providers.ts
+var ProviderIds = {
+  claude: "claude",
+  openai: "openai",
+  gemini: "gemini",
+  perplexity: "perplexity",
+  local: "local",
+  cdpChatgpt: "cdp:chatgpt",
+  zai: "zai"
+};
+var PROVIDER_IDS = Object.values(ProviderIds);
+var SweepProviderIds = {
+  claude: ProviderIds.claude,
+  openai: ProviderIds.openai,
+  gemini: ProviderIds.gemini,
+  perplexity: ProviderIds.perplexity,
+  local: ProviderIds.local,
+  cdpChatgpt: ProviderIds.cdpChatgpt
+};
+var SWEEP_PROVIDER_IDS = Object.values(SweepProviderIds);
+var AgentProviderIds = {
+  claude: ProviderIds.claude,
+  openai: ProviderIds.openai,
+  gemini: ProviderIds.gemini,
+  zai: ProviderIds.zai
+};
+var AGENT_PROVIDER_IDS = Object.values(AgentProviderIds);
+function isAgentProviderId(value) {
+  return AGENT_PROVIDER_IDS.includes(value);
+}
+
+// ../contracts/src/snapshot.ts
+import { z as z9 } from "zod";
+var snapshotAccuracySchema = z9.enum(["yes", "no", "unknown", "not-mentioned"]);
+var snapshotRequestSchema = z9.object({
+  companyName: z9.string().min(1),
+  domain: z9.string().min(1),
+  phrases: z9.array(z9.string().min(1)).optional().default([]),
+  competitors: z9.array(z9.string().min(1)).optional().default([])
+});
+var snapshotCompetitorEntrySchema = z9.object({
+  name: z9.string(),
+  count: z9.number().int().nonnegative()
+});
+var snapshotAuditFactorSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  weight: z9.number(),
+  score: z9.number(),
+  grade: z9.string(),
+  status: z9.enum(["pass", "partial", "fail"]),
+  findings: z9.array(z9.object({
+    type: z9.string(),
+    message: z9.string()
+  })).default([]),
+  recommendations: z9.array(z9.string()).default([])
+});
+var snapshotAuditSchema = z9.object({
+  url: z9.string(),
+  finalUrl: z9.string(),
+  auditedAt: z9.string(),
+  overallScore: z9.number(),
+  overallGrade: z9.string(),
+  summary: z9.string(),
+  factors: z9.array(snapshotAuditFactorSchema).default([])
+});
+var snapshotProfileSchema = z9.object({
+  industry: z9.string(),
+  summary: z9.string(),
+  services: z9.array(z9.string()).default([]),
+  categoryTerms: z9.array(z9.string()).default([])
+});
+var snapshotProviderResultSchema = z9.object({
+  provider: z9.string(),
+  displayName: z9.string(),
+  model: z9.string().nullable().optional(),
+  mentioned: z9.boolean(),
+  cited: z9.boolean(),
+  describedAccurately: snapshotAccuracySchema,
+  accuracyNotes: z9.string().nullable().optional(),
+  incorrectClaims: z9.array(z9.string()).default([]),
+  recommendedCompetitors: z9.array(z9.string()).default([]),
+  citedDomains: z9.array(z9.string()).default([]),
+  groundingSources: z9.array(groundingSourceSchema).default([]),
+  searchQueries: z9.array(z9.string()).default([]),
+  answerText: z9.string(),
+  error: z9.string().nullable().optional()
+});
+var snapshotQueryResultSchema = z9.object({
+  phrase: z9.string(),
+  providerResults: z9.array(snapshotProviderResultSchema).default([])
+});
+var snapshotSummarySchema = z9.object({
+  totalQueries: z9.number().int().nonnegative(),
+  totalProviders: z9.number().int().nonnegative(),
+  totalComparisons: z9.number().int().nonnegative(),
+  mentionCount: z9.number().int().nonnegative(),
+  citationCount: z9.number().int().nonnegative(),
+  topCompetitors: z9.array(snapshotCompetitorEntrySchema).default([]),
+  visibilityGap: z9.string(),
+  whatThisMeans: z9.array(z9.string()).default([]),
+  recommendedActions: z9.array(z9.string()).default([])
+});
+var snapshotReportSchema = z9.object({
+  companyName: z9.string(),
+  domain: z9.string(),
+  homepageUrl: z9.string(),
+  generatedAt: z9.string(),
+  phrases: z9.array(z9.string()).default([]),
+  competitors: z9.array(z9.string()).default([]),
+  profile: snapshotProfileSchema,
+  audit: snapshotAuditSchema,
+  queryResults: z9.array(snapshotQueryResultSchema).default([]),
+  summary: snapshotSummarySchema
+});
+
+// ../contracts/src/schedule.ts
+import { z as z10 } from "zod";
+var scheduleDtoSchema = z10.object({
+  id: z10.string(),
+  projectId: z10.string(),
+  cronExpr: z10.string(),
+  preset: z10.string().nullable().optional(),
+  timezone: z10.string().default("UTC"),
+  enabled: z10.boolean().default(true),
+  providers: z10.array(providerNameSchema).default([]),
+  lastRunAt: z10.string().nullable().optional(),
+  nextRunAt: z10.string().nullable().optional(),
+  createdAt: z10.string(),
+  updatedAt: z10.string()
+});
+var scheduleUpsertRequestSchema = z10.object({
+  preset: z10.string().optional(),
+  cron: z10.string().optional(),
+  timezone: z10.string().optional().default("UTC"),
+  enabled: z10.boolean().optional().default(true),
+  providers: z10.array(providerNameSchema).optional().default([])
+}).refine(
+  (data) => data.preset && !data.cron || !data.preset && data.cron,
+  { message: 'Exactly one of "preset" or "cron" must be provided' }
+);
+
+// ../contracts/src/analytics.ts
+import { z as z11 } from "zod";
+var visibilityMetricModeSchema = z11.enum(["mentioned", "cited"]);
+var VisibilityMetricModes = visibilityMetricModeSchema.enum;
+function parseWindow(value) {
+  if (value === "7d" || value === "30d" || value === "90d" || value === "all") return value;
+  return "all";
+}
+function windowCutoff(window) {
+  if (window === "all") return null;
+  const days = window === "7d" ? 7 : window === "30d" ? 30 : 90;
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - days);
+  return d.toISOString();
+}
+
+// ../contracts/src/source-categories.ts
+var SOURCE_CATEGORY_RULES = [
+  // Forums
+  { pattern: "reddit.com", category: "forum", label: "Reddit" },
+  { pattern: "quora.com", category: "forum", label: "Quora" },
+  { pattern: "stackexchange.com", category: "forum", label: "Stack Exchange" },
+  { pattern: "stackoverflow.com", category: "forum", label: "Stack Overflow" },
+  { pattern: "discourse.org", category: "forum", label: "Discourse" },
+  // Social
+  { pattern: "linkedin.com", category: "social", label: "LinkedIn" },
+  { pattern: "twitter.com", category: "social", label: "X (Twitter)" },
+  { pattern: "x.com", category: "social", label: "X (Twitter)" },
+  { pattern: "facebook.com", category: "social", label: "Facebook" },
+  { pattern: "instagram.com", category: "social", label: "Instagram" },
+  { pattern: "threads.net", category: "social", label: "Threads" },
+  { pattern: "pinterest.com", category: "social", label: "Pinterest" },
+  { pattern: "tiktok.com", category: "social", label: "TikTok" },
+  // Video
+  { pattern: "youtube.com", category: "video", label: "YouTube" },
+  { pattern: "youtu.be", category: "video", label: "YouTube" },
+  { pattern: "vimeo.com", category: "video", label: "Vimeo" },
+  // News
+  { pattern: "nytimes.com", category: "news", label: "NY Times" },
+  { pattern: "bbc.com", category: "news", label: "BBC" },
+  { pattern: "bbc.co.uk", category: "news", label: "BBC" },
+  { pattern: "cnn.com", category: "news", label: "CNN" },
+  { pattern: "reuters.com", category: "news", label: "Reuters" },
+  { pattern: "apnews.com", category: "news", label: "AP News" },
+  { pattern: "theguardian.com", category: "news", label: "The Guardian" },
+  { pattern: "washingtonpost.com", category: "news", label: "Washington Post" },
+  { pattern: "wsj.com", category: "news", label: "WSJ" },
+  { pattern: "forbes.com", category: "news", label: "Forbes" },
+  { pattern: "techcrunch.com", category: "news", label: "TechCrunch" },
+  { pattern: "theverge.com", category: "news", label: "The Verge" },
+  { pattern: "wired.com", category: "news", label: "Wired" },
+  { pattern: "arstechnica.com", category: "news", label: "Ars Technica" },
+  // Reference
+  { pattern: "wikipedia.org", category: "reference", label: "Wikipedia" },
+  { pattern: "wikimedia.org", category: "reference", label: "Wikimedia" },
+  { pattern: "britannica.com", category: "reference", label: "Britannica" },
+  { pattern: "merriam-webster.com", category: "reference", label: "Merriam-Webster" },
+  // Blog / Content platforms
+  { pattern: "medium.com", category: "blog", label: "Medium" },
+  { pattern: "substack.com", category: "blog", label: "Substack" },
+  { pattern: "dev.to", category: "blog", label: "DEV Community" },
+  { pattern: "hashnode.dev", category: "blog", label: "Hashnode" },
+  { pattern: "wordpress.com", category: "blog", label: "WordPress" },
+  { pattern: "blogger.com", category: "blog", label: "Blogger" },
+  { pattern: "hubspot.com", category: "blog", label: "HubSpot" },
+  // E-commerce
+  { pattern: "amazon.com", category: "ecommerce", label: "Amazon" },
+  { pattern: "amazon.co.uk", category: "ecommerce", label: "Amazon UK" },
+  { pattern: "shopify.com", category: "ecommerce", label: "Shopify" },
+  { pattern: "ebay.com", category: "ecommerce", label: "eBay" },
+  // Academic
+  { pattern: "scholar.google.com", category: "academic", label: "Google Scholar" },
+  { pattern: "arxiv.org", category: "academic", label: "arXiv" },
+  { pattern: "pubmed.ncbi.nlm.nih.gov", category: "academic", label: "PubMed" },
+  { pattern: "researchgate.net", category: "academic", label: "ResearchGate" },
+  { pattern: ".edu", category: "academic", label: "Academic (.edu)" }
+];
+var CATEGORY_LABELS = {
+  social: "Social Media",
+  forum: "Forums & Q&A",
+  news: "News & Media",
+  reference: "Reference",
+  blog: "Blogs & Content",
+  ecommerce: "E-commerce",
+  video: "Video",
+  academic: "Academic",
+  other: "Other"
+};
+function categorizeSource(uri) {
+  let domain;
+  try {
+    const url = new URL(uri.startsWith("http") ? uri : `https://${uri}`);
+    domain = url.hostname.replace(/^www\./, "");
+  } catch {
+    domain = uri.replace(/^https?:\/\//, "").replace(/^www\./, "").split("/")[0] ?? uri;
+  }
+  const domainLower = domain.toLowerCase();
+  for (const rule of SOURCE_CATEGORY_RULES) {
+    if (domainLower === rule.pattern || domainLower.endsWith(`.${rule.pattern}`) || rule.pattern.startsWith(".") && domainLower.endsWith(rule.pattern)) {
+      return { category: rule.category, label: rule.label, domain };
+    }
+  }
+  return { category: "other", label: CATEGORY_LABELS.other, domain };
+}
+function categoryLabel(category) {
+  return CATEGORY_LABELS[category];
+}
+
+// ../contracts/src/ga.ts
+import { z as z12 } from "zod";
+var ga4ConnectionDtoSchema = z12.object({
+  id: z12.string(),
+  projectId: z12.string(),
+  propertyId: z12.string(),
+  clientEmail: z12.string(),
+  connected: z12.boolean(),
+  createdAt: z12.string(),
+  updatedAt: z12.string()
+});
+var ga4TrafficSnapshotDtoSchema = z12.object({
+  date: z12.string(),
+  landingPage: z12.string(),
+  sessions: z12.number(),
+  organicSessions: z12.number(),
+  users: z12.number()
+});
+var ga4SourceDimensionSchema = z12.enum(["session", "first_user", "manual_utm"]);
+var ga4AiReferralDtoSchema = z12.object({
+  source: z12.string(),
+  medium: z12.string(),
+  sessions: z12.number(),
+  users: z12.number(),
+  sourceDimension: ga4SourceDimensionSchema
+});
+var ga4AiReferralLandingPageDtoSchema = z12.object({
+  source: z12.string(),
+  medium: z12.string(),
+  sourceDimension: ga4SourceDimensionSchema,
+  landingPage: z12.string(),
+  sessions: z12.number(),
+  users: z12.number()
+});
+var ga4SocialReferralDtoSchema = z12.object({
+  source: z12.string(),
+  medium: z12.string(),
+  sessions: z12.number(),
+  users: z12.number(),
+  /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
+  channelGroup: z12.string()
+});
+var ga4TrafficSummaryDtoSchema = z12.object({
+  totalSessions: z12.number(),
+  totalOrganicSessions: z12.number(),
+  /** Direct-channel sessions (sessions with no source — bookmarks, typed URLs, AI-driven traffic with stripped referrer). 0 for legacy rows from before the column was added. */
+  totalDirectSessions: z12.number(),
+  totalUsers: z12.number(),
+  topPages: z12.array(z12.object({
+    landingPage: z12.string(),
+    sessions: z12.number(),
+    organicSessions: z12.number(),
+    /** Per-page Direct-channel sessions. 0 for legacy rows. */
+    directSessions: z12.number(),
+    users: z12.number()
+  })),
+  aiReferrals: z12.array(ga4AiReferralDtoSchema),
+  aiReferralLandingPages: z12.array(ga4AiReferralLandingPageDtoSchema),
+  /** Deduped AI session total: MAX(sessions) per date+source+medium across attribution dimensions, then summed. Cross-cutting: can overlap with Direct/Organic/Social via firstUserSource. */
+  aiSessionsDeduped: z12.number(),
+  /** Deduped AI user total: MAX(users) per date+source+medium across attribution dimensions, then summed. */
+  aiUsersDeduped: z12.number(),
+  /** AI sessions whose CURRENT sessionSource matched an AI engine. Disjoint from Direct/Organic/Social — safe for the channel breakdown. */
+  aiSessionsBySession: z12.number(),
+  /** AI users whose CURRENT sessionSource matched an AI engine. Disjoint from Direct/Organic/Social — safe for the channel breakdown. */
+  aiUsersBySession: z12.number(),
+  socialReferrals: z12.array(ga4SocialReferralDtoSchema),
+  /** Total social sessions (session-scoped, no cross-dimension dedup needed). */
+  socialSessions: z12.number(),
+  /** Total social users (session-scoped, no cross-dimension dedup needed). */
+  socialUsers: z12.number(),
+  /** Organic sessions as a percentage of total sessions (0–100, rounded). */
+  organicSharePct: z12.number(),
+  /** Deduped AI sessions as a percentage of total sessions (0–100, rounded). Cross-cutting: can overlap with Direct/Organic/Social. */
+  aiSharePct: z12.number(),
+  /** Session-source-only AI sessions as a percentage of total sessions (0–100, rounded). Disjoint from Direct/Organic/Social. */
+  aiSharePctBySession: z12.number(),
+  /** Direct-channel sessions as a percentage of total sessions (0–100, rounded). */
+  directSharePct: z12.number(),
+  /** Social sessions as a percentage of total sessions (0–100, rounded). */
+  socialSharePct: z12.number(),
+  /** Display string for organicSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
+  organicSharePctDisplay: z12.string(),
+  /** Display string for aiSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
+  aiSharePctDisplay: z12.string(),
+  /** Display string for aiSharePctBySession: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
+  aiSharePctBySessionDisplay: z12.string(),
+  /** Display string for directSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
+  directSharePctDisplay: z12.string(),
+  /** Display string for socialSharePct: 'X%', '<1%' for non-zero shares that round below 1, or '—' when sessions exist but total is unknown (partial sync). */
+  socialSharePctDisplay: z12.string(),
+  lastSyncedAt: z12.string().nullable()
+});
+var ga4AiReferralHistoryEntrySchema = z12.object({
+  date: z12.string(),
+  source: z12.string(),
+  medium: z12.string(),
+  landingPage: z12.string(),
+  sessions: z12.number(),
+  users: z12.number(),
+  /** Which GA4 dimension this row came from: session (sessionSource), first_user (firstUserSource), or manual_utm (utm_source parameter) */
+  sourceDimension: ga4SourceDimensionSchema
+});
+var ga4SocialReferralHistoryEntrySchema = z12.object({
+  date: z12.string(),
+  source: z12.string(),
+  medium: z12.string(),
+  sessions: z12.number(),
+  users: z12.number(),
+  /** GA4 default channel group (e.g. 'Organic Social', 'Paid Social') */
+  channelGroup: z12.string()
+});
+var ga4SessionHistoryEntrySchema = z12.object({
+  date: z12.string(),
+  sessions: z12.number(),
+  organicSessions: z12.number(),
+  users: z12.number()
+});
+
+// ../contracts/src/answer-visibility.ts
+var GENERIC_TOKENS = /* @__PURE__ */ new Set([
+  "agency",
+  "app",
+  "company",
+  "corp",
+  "group",
+  "health",
+  "inc",
+  "llc",
+  "online",
+  "platform",
+  "services",
+  "site",
+  "solutions",
+  "software",
+  "systems",
+  "tech"
+]);
+var MIN_BRAND_KEY_LENGTH = 6;
+var BUSINESS_SUFFIXES = [
+  "incorporated",
+  "corporation",
+  "limited",
+  "company",
+  "gmbh",
+  "pllc",
+  "corp",
+  "group",
+  "llp",
+  "plc",
+  "llc",
+  "inc",
+  "ltd"
+];
+function extractAnswerMentions(answerText, displayName, domains) {
+  if (!answerText) return { mentioned: false, matchedTerms: [] };
+  const matchedTerms = [];
+  const lowerAnswer = answerText.toLowerCase();
+  for (const domain of domains) {
+    const normalizedDomain = normalizeProjectDomain(domain);
+    if (!normalizedDomain || !normalizedDomain.includes(".")) continue;
+    if (domainMentioned(lowerAnswer, normalizedDomain)) {
+      matchedTerms.push(normalizedDomain);
+    }
+  }
+  const answerNormalized = normalizeText(answerText);
+  const answerBrandKey = brandKeyFromText(answerText);
+  const normalizedCandidates = brandNormalizedCandidates(displayName);
+  const brandKeyCandidates = brandKeyCandidatesForMatch(displayName);
+  const matchesNormalized = normalizedCandidates.some(
+    (c) => new RegExp(`\\b${escapeRegExp(c)}\\b`).test(answerNormalized)
+  );
+  const matchesBrandKey = brandKeyCandidates.some(
+    (c) => c.length >= MIN_BRAND_KEY_LENGTH && answerBrandKey.includes(c)
+  );
+  if (matchesNormalized || matchesBrandKey) {
+    matchedTerms.push(displayName);
+  }
+  const tokens = collectDistinctiveTokens(displayName, domains);
+  let tokenMatches = 0;
+  const matchedTokens = [];
+  for (const token of tokens) {
+    if (new RegExp(`\\b${escapeRegExp(token)}\\b`).test(lowerAnswer)) {
+      tokenMatches++;
+      matchedTokens.push(token);
+    }
+  }
+  const tokenThresholdMet = tokens.length > 0 && (tokens.length === 1 && tokenMatches >= 1 || tokenMatches >= Math.min(2, tokens.length));
+  if (tokenThresholdMet) {
+    matchedTerms.push(...matchedTokens);
+  }
+  const unique = [...new Set(matchedTerms)];
+  const domainMatches = unique.filter((t) => t.includes("."));
+  const dedupedFinal = unique.filter((term) => {
+    if (term.includes(".")) return true;
+    return !domainMatches.some((d) => d.toLowerCase().startsWith(term.toLowerCase() + "."));
+  });
+  return { mentioned: dedupedFinal.length > 0, matchedTerms: dedupedFinal };
+}
+function determineAnswerMentioned(answerText, displayName, domains) {
+  return extractAnswerMentions(answerText, displayName, domains).mentioned;
+}
+function visibilityStateFromAnswerMentioned(answerMentioned) {
+  return answerMentioned ? "visible" : "not-visible";
+}
+function brandKeyFromText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function domainMentioned(lowerAnswer, normalizedDomain) {
+  const escapedDomain = escapeRegExp(normalizedDomain.toLowerCase());
+  const patterns = [
+    new RegExp(`(^|[^a-z0-9-])${escapedDomain}($|[^a-z0-9-])`),
+    new RegExp(`https?://(?:www\\.)?${escapedDomain}(?:[/:?#]|$)`),
+    new RegExp(`www\\.${escapedDomain}(?:[/:?#]|$)`)
+  ];
+  return patterns.some((pattern) => pattern.test(lowerAnswer));
+}
+function collectDistinctiveTokens(displayName, domains) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const token of extractDistinctiveTokens(displayName)) {
+    tokens.add(token);
+  }
+  for (const domain of domains) {
+    const reg = registrableDomain(domain);
+    const brand = reg ? brandLabelFromDomain(reg) : normalizeProjectDomain(domain).split("/")[0]?.split(".")[0] ?? "";
+    const token = brand.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    if (isDistinctiveToken(token)) tokens.add(token);
+  }
+  return [...tokens];
+}
+function extractDistinctiveTokens(value) {
+  return normalizeText(value).split(" ").filter(isDistinctiveToken);
+}
+function isDistinctiveToken(token) {
+  if (token.length < 4) return false;
+  return !GENERIC_TOKENS.has(token);
+}
+function normalizeText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function brandNormalizedCandidates(displayName) {
+  const original = normalizeText(displayName);
+  if (!original) return [];
+  const stripped = stripBusinessSuffix(original, " ");
+  if (!stripped || stripped === original) return [original];
+  return [original, stripped];
+}
+function brandKeyCandidatesForMatch(displayName) {
+  const original = brandKeyFromText(displayName);
+  if (!original) return [];
+  const stripped = stripBusinessSuffix(original, "");
+  return stripped && stripped !== original ? [original, stripped] : [original];
+}
+function stripBusinessSuffix(value, separator) {
+  for (const suffix of BUSINESS_SUFFIXES) {
+    const trailing = `${separator}${suffix}`;
+    if (value.endsWith(trailing) && value.length - trailing.length >= 3) {
+      return value.slice(0, -trailing.length);
+    }
+  }
+  return value;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ../contracts/src/agent.ts
+import { z as z13 } from "zod";
+var memorySourceSchema = z13.enum(["aero", "user", "compaction"]);
+var MemorySources = memorySourceSchema.enum;
+var AGENT_MEMORY_VALUE_MAX_BYTES = 2 * 1024;
+var AGENT_MEMORY_KEY_MAX_LENGTH = 128;
+var agentMemoryUpsertRequestSchema = z13.object({
+  key: z13.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH),
+  value: z13.string().min(1)
+});
+var agentMemoryDeleteRequestSchema = z13.object({
+  key: z13.string().min(1).max(AGENT_MEMORY_KEY_MAX_LENGTH)
+});
+
+// ../contracts/src/backlinks.ts
+import { z as z14 } from "zod";
+var ccReleaseSyncStatusSchema = z14.enum(["queued", "downloading", "querying", "ready", "failed"]);
+var CcReleaseSyncStatuses = ccReleaseSyncStatusSchema.enum;
+var ccReleaseSyncDtoSchema = z14.object({
+  id: z14.string(),
+  release: z14.string(),
+  status: ccReleaseSyncStatusSchema,
+  phaseDetail: z14.string().nullable().optional(),
+  vertexPath: z14.string().nullable().optional(),
+  edgesPath: z14.string().nullable().optional(),
+  vertexSha256: z14.string().nullable().optional(),
+  edgesSha256: z14.string().nullable().optional(),
+  vertexBytes: z14.number().int().nullable().optional(),
+  edgesBytes: z14.number().int().nullable().optional(),
+  projectsProcessed: z14.number().int().nullable().optional(),
+  domainsDiscovered: z14.number().int().nullable().optional(),
+  downloadStartedAt: z14.string().nullable().optional(),
+  downloadFinishedAt: z14.string().nullable().optional(),
+  queryStartedAt: z14.string().nullable().optional(),
+  queryFinishedAt: z14.string().nullable().optional(),
+  error: z14.string().nullable().optional(),
+  createdAt: z14.string(),
+  updatedAt: z14.string()
+});
+var backlinkDomainDtoSchema = z14.object({
+  linkingDomain: z14.string(),
+  numHosts: z14.number().int()
+});
+var backlinkSummaryDtoSchema = z14.object({
+  projectId: z14.string(),
+  release: z14.string(),
+  targetDomain: z14.string(),
+  totalLinkingDomains: z14.number().int(),
+  totalHosts: z14.number().int(),
+  top10HostsShare: z14.string(),
+  queriedAt: z14.string(),
+  // Populated when the response is filtered (e.g. ?excludeCrawlers=1).
+  // Counts the rows omitted from totalLinkingDomains/totalHosts so callers
+  // can show "N hidden" hints without re-deriving them.
+  excludedLinkingDomains: z14.number().int().optional(),
+  excludedHosts: z14.number().int().optional()
+});
+var backlinkListResponseSchema = z14.object({
+  summary: backlinkSummaryDtoSchema.nullable(),
+  total: z14.number().int(),
+  rows: z14.array(backlinkDomainDtoSchema)
+});
+var backlinkHistoryEntrySchema = z14.object({
+  release: z14.string(),
+  totalLinkingDomains: z14.number().int(),
+  totalHosts: z14.number().int(),
+  top10HostsShare: z14.string(),
+  queriedAt: z14.string()
+});
+var backlinksInstallStatusDtoSchema = z14.object({
+  duckdbInstalled: z14.boolean(),
+  duckdbVersion: z14.string().nullable().optional(),
+  duckdbSpec: z14.string(),
+  pluginDir: z14.string()
+});
+var backlinksInstallResultDtoSchema = z14.object({
+  installed: z14.boolean(),
+  version: z14.string(),
+  path: z14.string(),
+  alreadyPresent: z14.boolean()
+});
+var ccAvailableReleaseSchema = z14.object({
+  release: z14.string(),
+  vertexUrl: z14.string(),
+  edgesUrl: z14.string(),
+  vertexBytes: z14.number().int().nullable(),
+  edgesBytes: z14.number().int().nullable(),
+  lastModified: z14.string().nullable()
+});
+var ccCachedReleaseSchema = z14.object({
+  release: z14.string(),
+  syncStatus: ccReleaseSyncStatusSchema.nullable(),
+  bytes: z14.number().int(),
+  lastUsedAt: z14.string().nullable()
+});
+
+// ../contracts/src/composites.ts
+import { z as z15 } from "zod";
+var searchHitKindSchema = z15.enum(["snapshot", "insight"]);
+var projectSearchSnapshotHitSchema = z15.object({
+  kind: z15.literal("snapshot"),
+  id: z15.string(),
+  runId: z15.string(),
+  keyword: z15.string(),
+  provider: z15.string(),
+  model: z15.string().nullable(),
+  citationState: citationStateSchema,
+  matchedField: z15.enum(["answerText", "citedDomains", "searchQueries", "keyword"]),
+  snippet: z15.string(),
+  createdAt: z15.string()
+});
+var projectSearchInsightHitSchema = z15.object({
+  kind: z15.literal("insight"),
+  id: z15.string(),
+  runId: z15.string().nullable(),
+  type: z15.enum(["regression", "gain", "opportunity"]),
+  severity: z15.enum(["critical", "high", "medium", "low"]),
+  title: z15.string(),
+  keyword: z15.string(),
+  provider: z15.string(),
+  matchedField: z15.enum(["title", "keyword", "recommendation", "cause"]),
+  snippet: z15.string(),
+  dismissed: z15.boolean(),
+  createdAt: z15.string()
+});
+var projectSearchHitSchema = z15.discriminatedUnion("kind", [
+  projectSearchSnapshotHitSchema,
+  projectSearchInsightHitSchema
+]);
+var projectSearchResponseSchema = z15.object({
+  query: z15.string(),
+  totalHits: z15.number().int().nonnegative(),
+  truncated: z15.boolean(),
+  hits: z15.array(projectSearchHitSchema)
+});
+
+// ../contracts/src/content.ts
+import { z as z16 } from "zod";
+var contentActionSchema = z16.enum(["create", "expand", "refresh", "add-schema"]);
+var ContentActions = contentActionSchema.enum;
+var demandSourceSchema = z16.enum(["gsc", "competitor-evidence", "both"]);
+var DemandSources = demandSourceSchema.enum;
+var actionConfidenceSchema = z16.enum(["high", "medium", "low"]);
+var ActionConfidences = actionConfidenceSchema.enum;
+var pageTypeSchema = z16.enum([
+  "blog-post",
+  "comparison",
+  "listicle",
+  "how-to",
+  "guide",
+  "glossary"
+]);
+var PageTypes = pageTypeSchema.enum;
+var contentActionStateSchema = z16.enum([
+  "proposed",
+  "briefed",
+  "payload-generated",
+  "draft-created",
+  "published",
+  "validated",
+  "dismissed"
+]);
+var ContentActionStates = contentActionStateSchema.enum;
+var ourBestPageSchema = z16.object({
+  url: z16.string(),
+  gscImpressions: z16.number().nonnegative(),
+  gscClicks: z16.number().nonnegative(),
+  // Null when the page came from the inventory fallback (no GSC ranking data).
+  gscAvgPosition: z16.number().nonnegative().nullable(),
+  organicSessions: z16.number().nonnegative()
+});
+var winningCompetitorSchema = z16.object({
+  domain: z16.string(),
+  url: z16.string(),
+  title: z16.string(),
+  citationCount: z16.number().int().nonnegative()
+});
+var scoreBreakdownSchema = z16.object({
+  demand: z16.number(),
+  competitor: z16.number(),
+  absence: z16.number(),
+  gapSeverity: z16.number()
+});
+var existingActionRefSchema = z16.object({
+  actionId: z16.string(),
+  state: contentActionStateSchema,
+  lastUpdated: z16.string()
+});
+var contentTargetRowDtoSchema = z16.object({
+  targetRef: z16.string(),
+  query: z16.string(),
+  action: contentActionSchema,
+  ourBestPage: ourBestPageSchema.nullable(),
+  winningCompetitor: winningCompetitorSchema.nullable(),
+  score: z16.number(),
+  scoreBreakdown: scoreBreakdownSchema,
+  drivers: z16.array(z16.string()),
+  demandSource: demandSourceSchema,
+  actionConfidence: actionConfidenceSchema,
+  existingAction: existingActionRefSchema.nullable()
+});
+var contentTargetsResponseDtoSchema = z16.object({
+  targets: z16.array(contentTargetRowDtoSchema),
+  contextMetrics: z16.object({
+    totalAiReferralSessions: z16.number().int().nonnegative(),
+    latestRunId: z16.string(),
+    runTimestamp: z16.string()
+  })
+});
+var contentGroundingSourceSchema = z16.object({
+  uri: z16.string(),
+  title: z16.string(),
+  domain: z16.string(),
+  isOurDomain: z16.boolean(),
+  isCompetitor: z16.boolean(),
+  citationCount: z16.number().int().nonnegative(),
+  providers: z16.array(providerNameSchema)
+});
+var contentSourceRowDtoSchema = z16.object({
+  query: z16.string(),
+  groundingSources: z16.array(contentGroundingSourceSchema)
+});
+var contentSourcesResponseDtoSchema = z16.object({
+  sources: z16.array(contentSourceRowDtoSchema),
+  latestRunId: z16.string()
+});
+var contentGapRowDtoSchema = z16.object({
+  query: z16.string(),
+  competitorDomains: z16.array(z16.string()),
+  competitorCount: z16.number().int().nonnegative(),
+  missRate: z16.number().min(0).max(1),
+  lastSeenInRunId: z16.string()
+});
+var contentGapsResponseDtoSchema = z16.object({
+  gaps: z16.array(contentGapRowDtoSchema),
+  latestRunId: z16.string()
+});
+
+// ../contracts/src/doctor.ts
+import { z as z17 } from "zod";
+var checkStatusSchema = z17.enum(["ok", "warn", "fail", "skipped"]);
+var CheckStatuses = checkStatusSchema.enum;
+var checkScopeSchema = z17.enum(["global", "project"]);
+var CheckScopes = checkScopeSchema.enum;
+var checkCategorySchema = z17.enum([
+  "auth",
+  "config",
+  "providers",
+  "integrations",
+  "database",
+  "schedules"
+]);
+var CheckCategories = checkCategorySchema.enum;
+var checkResultSchema = z17.object({
+  id: z17.string(),
+  category: checkCategorySchema,
+  scope: checkScopeSchema,
+  title: z17.string(),
+  status: checkStatusSchema,
+  code: z17.string().describe('Stable machine-readable code (e.g. "google.token.refresh-failed"). Use this for filtering and remediation logic.'),
+  summary: z17.string(),
+  remediation: z17.string().nullable().optional().describe('Operator-facing next step. Null when status is "ok" or no specific remediation applies.'),
+  details: z17.record(z17.string(), z17.unknown()).optional().describe("Structured context \u2014 principal email, redirect URI, missing scopes, etc. Stable per check id."),
+  durationMs: z17.number().int().nonnegative().describe("How long the check took to execute.")
+});
+var doctorReportSchema = z17.object({
+  scope: checkScopeSchema,
+  project: z17.string().nullable().describe('Project name when scope is "project", null otherwise.'),
+  generatedAt: z17.string().describe("ISO-8601 timestamp when this doctor run started."),
+  durationMs: z17.number().int().nonnegative(),
+  summary: z17.object({
+    total: z17.number().int().nonnegative(),
+    ok: z17.number().int().nonnegative(),
+    warn: z17.number().int().nonnegative(),
+    fail: z17.number().int().nonnegative(),
+    skipped: z17.number().int().nonnegative()
+  }),
+  checks: z17.array(checkResultSchema)
+});
+function summarizeCheckResults(results) {
+  const summary = { total: results.length, ok: 0, warn: 0, fail: 0, skipped: 0 };
+  for (const result of results) {
+    switch (result.status) {
+      case CheckStatuses.ok:
+        summary.ok += 1;
+        break;
+      case CheckStatuses.warn:
+        summary.warn += 1;
+        break;
+      case CheckStatuses.fail:
+        summary.fail += 1;
+        break;
+      case CheckStatuses.skipped:
+        summary.skipped += 1;
+        break;
+    }
+  }
+  return summary;
+}
+
+// ../contracts/src/url-normalize.ts
+var STRIP_KEYS = /* @__PURE__ */ new Set([
+  // Click identifiers
+  "fbclid",
+  "gclid",
+  "msclkid",
+  "ttclid",
+  "li_fat_id",
+  "igshid",
+  "yclid",
+  "dclid",
+  "gbraid",
+  "wbraid",
+  "bingid",
+  // Mailchimp
+  "mc_cid",
+  "mc_eid",
+  // Google Analytics linkers
+  "_ga",
+  "_gl",
+  // Google Tag Manager debug
+  "gtm_latency",
+  "gtm_debug",
+  // WordPress internal noise
+  "preview",
+  "preview_id",
+  "preview_nonce",
+  "_thumbnail_id",
+  // Common cache-busters/versioning
+  "v",
+  "ver",
+  "version"
+]);
+function shouldStrip(key) {
+  if (STRIP_KEYS.has(key)) return true;
+  if (key.startsWith("utm_")) return true;
+  return false;
+}
+function parseQuery(query) {
+  if (query === "") return [];
+  return query.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq === -1) return { key: pair, value: null };
+    return { key: pair.slice(0, eq), value: pair.slice(eq + 1) };
+  });
+}
+function encodeQuery(pairs) {
+  return pairs.map((p) => p.value === null ? p.key : `${p.key}=${p.value}`).join("&");
+}
+function collapseRootIndex(path) {
+  if (path === "/index.html" || path === "/index.php") return "/";
+  return path;
+}
+function dropTrailingSlash(path) {
+  if (path.length > 1 && path.endsWith("/")) {
+    return path.replace(/\/+$/, "");
+  }
+  return path;
+}
+function normalizeUrlPath(input) {
+  if (input == null) return null;
+  let trimmed = input.trim();
+  if (trimmed === "") return null;
+  trimmed = trimmed.replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
+  if (trimmed === "" || trimmed === "/") return "/";
+  if (trimmed === "(not set)") return null;
+  trimmed = trimmed.replace(/([a-zA-Z0-9])([).]+)$/, "$1");
+  if (trimmed.startsWith("/)") || trimmed.startsWith("/ ")) {
+    trimmed = "/";
+  }
+  if (trimmed.includes(" ")) {
+    trimmed = trimmed.split(" ")[0];
+  }
+  if (trimmed === "" || trimmed === "/") return "/";
+  let pathPart;
+  let queryPart;
+  if (/^https?:\/\//i.test(trimmed)) {
+    let url;
+    try {
+      url = new URL(trimmed);
+    } catch {
+      return null;
+    }
+    pathPart = url.pathname || "/";
+    queryPart = url.search.startsWith("?") ? url.search.slice(1) : url.search;
+  } else {
+    let raw = trimmed;
+    const hashIdx = raw.indexOf("#");
+    if (hashIdx !== -1) raw = raw.slice(0, hashIdx);
+    const qIdx = raw.indexOf("?");
+    if (qIdx === -1) {
+      pathPart = raw;
+      queryPart = "";
+    } else {
+      pathPart = raw.slice(0, qIdx);
+      queryPart = raw.slice(qIdx + 1);
+    }
+  }
+  if (pathPart === "") pathPart = "/";
+  pathPart = collapseRootIndex(pathPart);
+  pathPart = dropTrailingSlash(pathPart);
+  const pairs = parseQuery(queryPart).filter((p) => !shouldStrip(p.key));
+  pairs.sort((a, b) => {
+    if (a.key < b.key) return -1;
+    if (a.key > b.key) return 1;
+    return 0;
+  });
+  if (pairs.length === 0) return pathPart;
+  return `${pathPart}?${encodeQuery(pairs)}`;
+}
+
+// ../contracts/src/citations.ts
+import { z as z18 } from "zod";
+var citationCoverageProviderSchema = z18.object({
+  provider: z18.string(),
+  citationState: citationStateSchema,
+  cited: z18.boolean(),
+  mentioned: z18.boolean(),
+  runId: z18.string(),
+  runCreatedAt: z18.string()
+});
+var citationCoverageRowSchema = z18.object({
+  keywordId: z18.string(),
+  keyword: z18.string(),
+  providers: z18.array(citationCoverageProviderSchema),
+  citedCount: z18.number().int().nonnegative(),
+  mentionedCount: z18.number().int().nonnegative(),
+  totalProviders: z18.number().int().nonnegative()
+});
+var competitorGapRowSchema = z18.object({
+  keywordId: z18.string(),
+  keyword: z18.string(),
+  provider: z18.string(),
+  citingCompetitors: z18.array(z18.string()),
+  runId: z18.string(),
+  runCreatedAt: z18.string()
+});
+var citationVisibilitySummarySchema = z18.object({
+  providersConfigured: z18.number().int().nonnegative(),
+  providersCiting: z18.number().int().nonnegative(),
+  providersMentioning: z18.number().int().nonnegative(),
+  totalKeywords: z18.number().int().nonnegative(),
+  // Cross-tab buckets — each tracked keyword with at least one snapshot lands
+  // in exactly one of these. Keywords with zero snapshots are not counted in
+  // any bucket; (sum of buckets) ≤ totalKeywords.
+  keywordsCitedAndMentioned: z18.number().int().nonnegative(),
+  keywordsCitedOnly: z18.number().int().nonnegative(),
+  keywordsMentionedOnly: z18.number().int().nonnegative(),
+  keywordsInvisible: z18.number().int().nonnegative(),
+  latestRunId: z18.string().nullable(),
+  latestRunAt: z18.string().nullable()
+});
+var citationVisibilityResponseSchema = z18.object({
+  summary: citationVisibilitySummarySchema,
+  byKeyword: z18.array(citationCoverageRowSchema),
+  competitorGaps: z18.array(competitorGapRowSchema),
+  status: z18.enum(["ready", "no-data"]),
+  reason: z18.enum(["no-runs-yet", "no-keywords"]).optional()
+});
+function emptyCitationVisibility(reason) {
+  return {
+    summary: {
+      providersConfigured: 0,
+      providersCiting: 0,
+      providersMentioning: 0,
+      totalKeywords: 0,
+      keywordsCitedAndMentioned: 0,
+      keywordsCitedOnly: 0,
+      keywordsMentionedOnly: 0,
+      keywordsInvisible: 0,
+      latestRunId: null,
+      latestRunAt: null
+    },
+    byKeyword: [],
+    competitorGaps: [],
+    status: "no-data",
+    reason
+  };
+}
+function citationStateToCited(state) {
+  return state === "cited";
+}
+
+// ../contracts/src/skills.ts
+import { z as z19 } from "zod";
+var codingAgentSchema = z19.enum(["claude", "codex"]);
+var CodingAgents = codingAgentSchema.enum;
+var skillsClientSchema = z19.enum(["claude", "codex", "all"]);
+var SkillsClients = skillsClientSchema.enum;
+
+export {
+  __export,
+  providerQuotaPolicySchema,
+  ProviderNames,
+  isBrowserProvider,
+  resolveProviderInput,
+  locationContextSchema,
+  notificationEventSchema,
+  notificationCreateRequestSchema,
+  findDuplicateLocationLabels,
+  hasLocationLabel,
+  projectUpsertRequestSchema,
+  keywordBatchRequestSchema,
+  keywordGenerateRequestSchema,
+  competitorBatchRequestSchema,
+  normalizeProjectDomain,
+  registrableDomain,
+  brandLabelFromDomain,
+  effectiveDomains,
+  projectConfigSchema,
+  AppError,
+  notFound,
+  validationError,
+  authRequired,
+  authInvalid,
+  providerError,
+  runInProgress,
+  runNotCancellable,
+  unsupportedKind,
+  notImplemented,
+  deliveryFailed,
+  agentBusy,
+  missingDependency,
+  internalError,
+  wordpressEnvSchema,
+  AgentProviderIds,
+  AGENT_PROVIDER_IDS,
+  isAgentProviderId,
+  RunStatuses,
+  RunKinds,
+  RunTriggers,
+  CitationStates,
+  runTriggerRequestSchema,
+  parseRunError,
+  buildRunErrorFromMessages,
+  serializeRunError,
+  formatRunErrorOneLine,
+  snapshotRequestSchema,
+  scheduleUpsertRequestSchema,
+  parseWindow,
+  windowCutoff,
+  categorizeSource,
+  categoryLabel,
+  extractAnswerMentions,
+  determineAnswerMentioned,
+  visibilityStateFromAnswerMentioned,
+  brandKeyFromText,
+  MemorySources,
+  AGENT_MEMORY_VALUE_MAX_BYTES,
+  AGENT_MEMORY_KEY_MAX_LENGTH,
+  agentMemoryUpsertRequestSchema,
+  agentMemoryDeleteRequestSchema,
+  CcReleaseSyncStatuses,
+  ContentActions,
+  CheckStatuses,
+  CheckScopes,
+  CheckCategories,
+  summarizeCheckResults,
+  normalizeUrlPath,
+  emptyCitationVisibility,
+  citationStateToCited,
+  CodingAgents,
+  skillsClientSchema,
+  SkillsClients
+};