@ainyc/canonry 5.1.3 → 5.2.0

package/dist/demo-server-BIPT53EY.js

@@ -0,0 +1,2125 @@
+import {
+  DEFAULT_DEMO_TRUSTED_PROXIES
+} from "./chunk-RB2F4D3Z.js";
+import {
+  layoutSiteCrawlGraphInput,
+  persistSiteCrawlGraphLayout
+} from "./chunk-5VONCLVQ.js";
+import {
+  PACKAGE_VERSION
+} from "./chunk-AOJU5LKX.js";
+import {
+  HISTORY_WINDOW_RUNS,
+  IntelligenceService,
+  adsAdGroups,
+  adsAds,
+  adsCampaigns,
+  adsConnections,
+  adsInsightsDaily,
+  aiReferralEventsHourly,
+  aiUserFetchEventsHourly,
+  apiKeys,
+  apiRoutes,
+  assessConversionTrackingIntegrity,
+  auditLog,
+  backlinkDomains,
+  backlinkSummaries,
+  bingConnections,
+  bingCoverageSnapshots,
+  bingKeywordStats,
+  bingUrlInspections,
+  competitors,
+  computeCompetitorOverlap,
+  conversionTrackingContracts,
+  crawlerEventsHourly,
+  createClient,
+  determineCitationState,
+  discoveryProbes,
+  discoverySessions,
+  extractRecommendedCompetitors,
+  gaAcquisitionDaily,
+  gaAiReferrals,
+  gaDailyTotals,
+  gaLeadEventsDaily,
+  gaMeasurementSyncStates,
+  gaTrafficSnapshots,
+  gaTrafficSummaries,
+  gaTrafficWindowSummaries,
+  gbpDailyMetrics,
+  gbpKeywordImpressions,
+  gbpKeywordMonthly,
+  gbpLocations,
+  gbpPlaceActions,
+  googleAdsConnections,
+  googleAdsRawSnapshots,
+  googleConnections,
+  gscCoverageSnapshots,
+  gscDailyTotals,
+  gscDataWatermarks,
+  gscQueryDailyTotals,
+  gscSearchData,
+  gscUrlInspections,
+  gtmConnections,
+  gtmRawSnapshots,
+  healthSnapshots,
+  insights,
+  measurementPlanDrafts,
+  measurementPlanVersions,
+  measurementPlans,
+  measurementSegments,
+  migrate,
+  projects,
+  queries,
+  querySnapshots,
+  researchRunQueries,
+  researchRuns,
+  runs,
+  simpleMeasurementDefinitions,
+  siteAuditPages,
+  siteAuditSnapshots,
+  siteCrawlAttempts,
+  siteCrawlEdges,
+  siteCrawlFindings,
+  siteCrawlPages,
+  siteCrawlSnapshots,
+  trafficSources
+} from "./chunk-YQNKULAD.js";
+import {
+  RunKinds,
+  SiteCrawlFetchStates,
+  SiteCrawlIndexabilityReasons,
+  SiteCrawlIndexabilityStates,
+  buildMeasurementExecutionIdentity,
+  buildMeasurementRunManifestV1,
+  buildSimpleMeasurementDefinition,
+  canonicalMeasurementExecutionIdentityJson,
+  canonicalMeasurementPlanV2Json,
+  canonicalSimpleMeasurementDefinitionJson,
+  deriveSiteHealthState,
+  determineAnswerMentioned,
+  effectiveBrandNames,
+  effectiveDomains,
+  factorStatusFromScore,
+  measurementPlanV2ChecksumJson,
+  measurementPlanV2Schema,
+  placementLinkDecision,
+  siteAuditPageFactorSchema
+} from "./chunk-2U5IW3G5.js";
+
+// src/demo-server.ts
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/demo/http.ts
+import { createHash, randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { desc, eq } from "drizzle-orm";
+import Fastify from "fastify";
+import fastifyStatic from "@fastify/static";
+import rateLimit from "@fastify/rate-limit";
+
+// src/demo/access.ts
+var DEMO_READ_ROUTES = /* @__PURE__ */ new Set([
+  "/api/v1/auth/session",
+  "/api/v1/backlinks/releases",
+  "/api/v1/backlinks/status",
+  "/api/v1/backlinks/syncs",
+  "/api/v1/backlinks/syncs/latest",
+  "/api/v1/demo",
+  "/api/v1/history",
+  "/api/v1/keys/self",
+  "/api/v1/notifications/events",
+  "/api/v1/projects",
+  "/api/v1/projects/:name",
+  "/api/v1/projects/:name/ads/campaigns",
+  "/api/v1/projects/:name/ads/delivery-diagnostics",
+  "/api/v1/projects/:name/ads/insights",
+  "/api/v1/projects/:name/ads/operations",
+  "/api/v1/projects/:name/ads/operations/:operationKey",
+  "/api/v1/projects/:name/ads/status",
+  "/api/v1/projects/:name/ads/summary",
+  "/api/v1/projects/:name/analytics/competitors",
+  "/api/v1/projects/:name/analytics/gaps",
+  "/api/v1/projects/:name/analytics/metrics",
+  "/api/v1/projects/:name/analytics/sources",
+  "/api/v1/projects/:name/backlinks/domains",
+  "/api/v1/projects/:name/backlinks/history",
+  "/api/v1/projects/:name/backlinks/sources",
+  "/api/v1/projects/:name/backlinks/summary",
+  "/api/v1/projects/:name/bing/coverage",
+  "/api/v1/projects/:name/bing/coverage/history",
+  "/api/v1/projects/:name/bing/inspections",
+  "/api/v1/projects/:name/bing/performance",
+  "/api/v1/projects/:name/bing/status",
+  "/api/v1/projects/:name/citations/visibility",
+  "/api/v1/projects/:name/competitors",
+  "/api/v1/projects/:name/content/dismissals",
+  "/api/v1/projects/:name/content/domain-classifications",
+  "/api/v1/projects/:name/content/gaps",
+  "/api/v1/projects/:name/content/recommendations/:targetRef/analysis",
+  "/api/v1/projects/:name/content/recommendations/:targetRef/brief",
+  "/api/v1/projects/:name/content/sources",
+  "/api/v1/projects/:name/content/targets",
+  "/api/v1/projects/:name/conversion-tracking/contracts",
+  "/api/v1/projects/:name/conversion-tracking/contracts/:contractId",
+  "/api/v1/projects/:name/conversion-tracking/contracts/:contractId/integrity",
+  "/api/v1/projects/:name/conversion-tracking/options",
+  "/api/v1/projects/:name/discover/sessions",
+  "/api/v1/projects/:name/discover/sessions/:id",
+  "/api/v1/projects/:name/export",
+  "/api/v1/projects/:name/ga/ai-referral-daily",
+  "/api/v1/projects/:name/ga/ai-referral-history",
+  "/api/v1/projects/:name/ga/attribution-trend",
+  "/api/v1/projects/:name/ga/coverage",
+  "/api/v1/projects/:name/ga/measurement-analysis",
+  "/api/v1/projects/:name/ga/session-history",
+  "/api/v1/projects/:name/ga/social-referral-history",
+  "/api/v1/projects/:name/ga/social-referral-trend",
+  "/api/v1/projects/:name/ga/status",
+  "/api/v1/projects/:name/ga/traffic",
+  "/api/v1/projects/:name/gbp/attributes",
+  "/api/v1/projects/:name/gbp/keywords",
+  "/api/v1/projects/:name/gbp/locations",
+  "/api/v1/projects/:name/gbp/lodging",
+  "/api/v1/projects/:name/gbp/metrics",
+  "/api/v1/projects/:name/gbp/place-actions",
+  "/api/v1/projects/:name/gbp/places",
+  "/api/v1/projects/:name/gbp/summary",
+  "/api/v1/projects/:name/google-ads/performance",
+  "/api/v1/projects/:name/google-ads/snapshots",
+  "/api/v1/projects/:name/google-ads/snapshots/:snapshotId",
+  "/api/v1/projects/:name/google-ads/status",
+  "/api/v1/projects/:name/google/connections",
+  "/api/v1/projects/:name/google/gsc/coverage",
+  "/api/v1/projects/:name/google/gsc/coverage/history",
+  "/api/v1/projects/:name/google/gsc/deindexed",
+  "/api/v1/projects/:name/google/gsc/inspections",
+  "/api/v1/projects/:name/google/gsc/performance",
+  "/api/v1/projects/:name/google/gsc/performance/daily",
+  "/api/v1/projects/:name/google/gsc/top-pages",
+  "/api/v1/projects/:name/gtm/snapshots",
+  "/api/v1/projects/:name/gtm/snapshots/:snapshotId",
+  "/api/v1/projects/:name/gtm/status",
+  "/api/v1/projects/:name/health/history",
+  "/api/v1/projects/:name/health/latest",
+  "/api/v1/projects/:name/history",
+  "/api/v1/projects/:name/insights",
+  "/api/v1/projects/:name/insights/:id",
+  "/api/v1/projects/:name/keywords",
+  "/api/v1/projects/:name/locations",
+  "/api/v1/projects/:name/measurement-changes",
+  "/api/v1/projects/:name/measurement-data-quality",
+  "/api/v1/projects/:name/measurement-overview",
+  "/api/v1/projects/:name/measurement-plan",
+  "/api/v1/projects/:name/measurement-plan/draft",
+  "/api/v1/projects/:name/measurement-plan/draft/assignments",
+  "/api/v1/projects/:name/measurement-plan/draft/groups",
+  "/api/v1/projects/:name/measurement-plan/draft/targets",
+  "/api/v1/projects/:name/measurement-plan/versions",
+  "/api/v1/projects/:name/measurement-plan/versions/:revision",
+  "/api/v1/projects/:name/measurement-portfolio-summary",
+  "/api/v1/projects/:name/measurement-property-competitors",
+  "/api/v1/projects/:name/measurement-property-evidence",
+  "/api/v1/projects/:name/measurement-property-questions",
+  "/api/v1/projects/:name/measurement-query-sets",
+  "/api/v1/projects/:name/measurement-query-sets/:setId",
+  "/api/v1/projects/:name/measurement-query-templates",
+  "/api/v1/projects/:name/measurement-question-result",
+  "/api/v1/projects/:name/measurement-report",
+  "/api/v1/projects/:name/measurement-setup",
+  "/api/v1/projects/:name/notifications",
+  "/api/v1/projects/:name/overview",
+  "/api/v1/projects/:name/queries",
+  "/api/v1/projects/:name/query-tracking",
+  "/api/v1/projects/:name/report",
+  "/api/v1/projects/:name/report.html",
+  "/api/v1/projects/:name/research/runs",
+  "/api/v1/projects/:name/research/runs/:runId",
+  "/api/v1/projects/:name/results/export",
+  "/api/v1/projects/:name/runs",
+  "/api/v1/projects/:name/runs/latest",
+  "/api/v1/projects/:name/schedule",
+  "/api/v1/projects/:name/schedules",
+  "/api/v1/projects/:name/search",
+  "/api/v1/projects/:name/snapshots",
+  "/api/v1/projects/:name/snapshots/diff",
+  "/api/v1/projects/:name/technical-aeo",
+  "/api/v1/projects/:name/technical-aeo/changes",
+  "/api/v1/projects/:name/technical-aeo/crawl",
+  "/api/v1/projects/:name/technical-aeo/crawl/pages",
+  "/api/v1/projects/:name/technical-aeo/crawl/pages/audit",
+  "/api/v1/projects/:name/technical-aeo/dead-links",
+  "/api/v1/projects/:name/technical-aeo/graph",
+  "/api/v1/projects/:name/technical-aeo/internal-links",
+  "/api/v1/projects/:name/technical-aeo/internal-links/neighbors",
+  "/api/v1/projects/:name/technical-aeo/pages",
+  "/api/v1/projects/:name/technical-aeo/path",
+  "/api/v1/projects/:name/technical-aeo/runs",
+  "/api/v1/projects/:name/technical-aeo/runs/:runId/page-health-preview",
+  "/api/v1/projects/:name/technical-aeo/runs/:runId/progress",
+  "/api/v1/projects/:name/technical-aeo/structure",
+  "/api/v1/projects/:name/technical-aeo/subgraph",
+  "/api/v1/projects/:name/technical-aeo/trend",
+  "/api/v1/projects/:name/timeline",
+  "/api/v1/projects/:name/traffic/events",
+  "/api/v1/projects/:name/traffic/sources",
+  "/api/v1/projects/:name/traffic/sources/:id",
+  "/api/v1/projects/:name/traffic/status",
+  "/api/v1/projects/:name/visibility-compare",
+  "/api/v1/projects/:name/visibility-report",
+  "/api/v1/projects/:name/visibility-stats",
+  "/api/v1/runs",
+  "/api/v1/runs/:id",
+  "/api/v1/session"
+]);
+function isDemoApiReadAllowed(method, registeredRoute) {
+  return (method === "GET" || method === "HEAD") && registeredRoute !== void 0 && DEMO_READ_ROUTES.has(registeredRoute);
+}
+
+// src/demo/http.ts
+var DEMO_VIEWER = { id: "public-demo-viewer", name: "Public demo", scopes: ["read"], projectId: null };
+var DEMO_CLIENT_CONFIG = {
+  demo: { enabled: true, readOnly: true, sampleData: true },
+  dashboard: { showAgentBar: false, showUpdateNotification: false }
+};
+var INLINE_SCRIPT = /<script(?<attributes>[^>]*)>(?<body>[\s\S]*?)<\/script>/gi;
+var DEMO_DOCUMENT_PATH = /^\/(?:projects(?:\/[^/.]+(?:\/(?:portfolio|discovery|search-console|activity|technical-aeo|conversions|local|queries|backlinks|report|history|settings|properties)(?:\/[^/.]+)*)?)?|runs|history|traffic(?:\/[^/.]+(?:\/[^/.]+)?)?)\/?$/;
+var UNDECODABLE_PATH = "/.undecodable-path";
+var DEMO_REPORT_DISCLOSURE = '<aside role="note" style="box-sizing:border-box;margin:0;padding:12px 24px;background:#fff7d6;border-bottom:1px solid #e5c75c;color:#4a3a00;font:600 14px/1.5 system-ui,sans-serif;text-align:center">Public Canonry demo: this report contains fictional sample data from stored demo records. No live provider query produced it.</aside>';
+function demoContentSecurityPolicy(document) {
+  const inlineHashes = [...document.matchAll(INLINE_SCRIPT)].filter((match) => !/\ssrc\s*=/i.test(match.groups?.attributes ?? "")).map((match) => `'sha256-${createHash("sha256").update(match.groups?.body ?? "", "utf8").digest("base64")}'`);
+  return [
+    "default-src 'self'",
+    ["script-src 'self'", ...inlineHashes].join(" "),
+    "style-src 'self' 'unsafe-inline'",
+    "img-src 'self' data:",
+    "font-src 'self'",
+    "connect-src 'self'",
+    "worker-src 'self' blob:",
+    "object-src 'none'",
+    "base-uri 'self'",
+    "form-action 'none'",
+    "frame-ancestors 'self'"
+  ].join("; ");
+}
+function isDemoDocumentRequest(request) {
+  return (request.method === "GET" || request.method === "HEAD") && DEMO_DOCUMENT_PATH.test(request.url.split("?")[0] ?? "");
+}
+function isOutsideDemoApiBudget(request) {
+  const route = request.routeOptions.url;
+  return route === void 0 ? isDemoDocumentRequest(request) : !route.startsWith("/api/");
+}
+async function createDemoHttpServer(options) {
+  const { db, assetsDir, now } = options;
+  const html = readFileSync(join(assetsDir, "index.html"), "utf8").replace("<head>", '<head><base href="/">').replace("</head>", `<script>window.__CANONRY_CONFIG__=${JSON.stringify(DEMO_CLIENT_CONFIG)}</script></head>`);
+  const contentSecurityPolicy = demoContentSecurityPolicy(html);
+  db.insert(apiKeys).values({
+    ...DEMO_VIEWER,
+    keyHash: randomUUID(),
+    keyPrefix: "demo",
+    createdAt: now.toISOString()
+  }).run();
+  const undecodable = /* @__PURE__ */ new WeakSet();
+  const app = Fastify({
+    logger: false,
+    bodyLimit: 1024 * 1024,
+    // The API budget is keyed by visitor address. Believe X-Forwarded-For only
+    // from the named proxies (a same-machine proxy by default), so a directly
+    // connected client cannot pick the address it is counted under.
+    trustProxy: [...options.trustProxy ?? DEFAULT_DEMO_TRUSTED_PROXIES],
+    // The router answers an undecodable path itself, before any hook, so the
+    // request would skip the visitor's budget. Route it again under a fixed
+    // path instead: the normal hooks then charge it to the forwarded visitor
+    // address and add the usual headers before the not-found handler refuses it.
+    frameworkErrors: (error, request, reply) => {
+      if (error.code !== "FST_ERR_BAD_URL") {
+        const body = JSON.stringify({ error: { code: "INTERNAL_ERROR", message: "An unexpected error occurred" } });
+        reply.raw.writeHead(500, { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) });
+        reply.raw.end(body);
+        return;
+      }
+      undecodable.add(request.raw);
+      request.raw.url = UNDECODABLE_PATH;
+      app.routing(request.raw, reply.raw);
+    }
+  });
+  await app.register(rateLimit, {
+    // Not attached per route: route hooks never run for the not-found handler
+    // and run after the refusals below. The single hook charges first instead.
+    global: false,
+    max: options.apiRateLimitMax ?? 600,
+    timeWindow: "1 minute",
+    // A dashboard load fans out across many immutable chunks. Those reads do
+    // not touch the API budget, which stays available for stored-data calls.
+    allowList: isOutsideDemoApiBudget
+  });
+  const chargeApiBudget = app.rateLimit();
+  app.addHook("onRequest", async (request, reply) => {
+    reply.header("X-Robots-Tag", "noindex, nofollow");
+    reply.header("X-Content-Type-Options", "nosniff");
+    reply.header("Referrer-Policy", "no-referrer");
+    reply.header("Content-Security-Policy", contentSecurityPolicy);
+    await chargeApiBudget.call(app, request, reply);
+    const method = request.method;
+    if (method !== "GET" && method !== "HEAD") {
+      return reply.code(403).send({ error: { code: "DEMO_READ_ONLY", message: "This public demo is view only. Changes and live runs are disabled." } });
+    }
+    const route = request.routeOptions.url;
+    if (request.url.startsWith("/api/") || route?.startsWith("/api/")) {
+      if (!isDemoApiReadAllowed(method, route)) {
+        return reply.code(403).send({ error: { code: "DEMO_READ_ONLY", message: "This action is unavailable in the view-only demo." } });
+      }
+      request.apiKey = { ...DEMO_VIEWER };
+      request.principal = { kind: "api-key", ...DEMO_VIEWER, viaCookie: false };
+      reply.header("Cache-Control", "no-store");
+      if (route === "/api/v1/projects/:name/bing/coverage") {
+        const name = request.params.name;
+        const project = db.select().from(projects).where(eq(projects.name, name)).get();
+        if (!project) return reply.code(404).send({ error: { code: "NOT_FOUND", message: "Project not found." } });
+        const rows = db.select().from(bingUrlInspections).where(eq(bingUrlInspections.projectId, project.id)).orderBy(desc(bingUrlInspections.inspectedAt)).all();
+        const latest = /* @__PURE__ */ new Map();
+        for (const row of rows) if (!latest.has(row.url)) latest.set(row.url, row);
+        const format = (row) => ({ url: row.url, httpCode: row.httpCode, inIndex: row.inIndex, lastCrawledDate: row.lastCrawledDate, inIndexDate: row.inIndexDate, inspectedAt: row.inspectedAt, documentSize: row.documentSize, anchorCount: row.anchorCount, discoveryDate: row.discoveryDate });
+        const indexed = [...latest.values()].filter((row) => row.inIndex === true).map(format);
+        const notIndexed = [...latest.values()].filter((row) => row.inIndex === false).map(format);
+        const unknown = [...latest.values()].filter((row) => row.inIndex === null).map(format);
+        const total = latest.size;
+        return reply.send({ summary: { total, indexed: indexed.length, notIndexed: notIndexed.length, unknown: unknown.length, percentage: total ? Math.round(indexed.length / total * 1e3) / 10 : 0 }, lastInspectedAt: rows[0]?.inspectedAt ?? null, indexed, notIndexed, unknown });
+      }
+      if (route === "/api/v1/projects/:name/bing/performance") {
+        const name = request.params.name;
+        const project = db.select().from(projects).where(eq(projects.name, name)).get();
+        if (!project) return reply.code(404).send({ error: { code: "NOT_FOUND", message: "Project not found." } });
+        return reply.send(db.select().from(bingKeywordStats).where(eq(bingKeywordStats.projectId, project.id)).limit(200).all().map((row) => ({
+          query: row.query,
+          impressions: row.impressions,
+          clicks: row.clicks,
+          ctr: Number(row.ctr),
+          averagePosition: Number(row.averagePosition)
+        })));
+      }
+    }
+  });
+  app.addHook("onSend", async (request, reply, payload) => {
+    if (request.routeOptions.url !== "/api/v1/projects/:name/report.html" || typeof payload !== "string" || !String(reply.getHeader("content-type")).startsWith("text/html")) {
+      return payload;
+    }
+    reply.removeHeader("content-length");
+    return payload.replace(/<body([^>]*)>/i, `<body$1>${DEMO_REPORT_DISCLOSURE}`);
+  });
+  app.get("/health", async () => ({ status: "ok", service: "canonry-demo", version: PACKAGE_VERSION, demo: true, workerEnabled: false }));
+  app.get("/api/v1/session", async () => ({ authenticated: true, setupRequired: false }));
+  app.get("/api/v1/demo", async () => ({ mode: "view-only", sampleData: true, seededAt: now.toISOString() }));
+  await app.register(apiRoutes, { db, skipAuth: true, ...options.readOptions });
+  await app.register(fastifyStatic, {
+    root: join(assetsDir, "assets"),
+    prefix: "/assets/",
+    index: false,
+    dotfiles: "deny"
+  });
+  const sendDocument = (_request, reply) => {
+    return reply.header("Cache-Control", "no-cache").type("text/html").send(html);
+  };
+  for (const [filename, contentType] of [["favicon.svg", "image/svg+xml"], ["favicon-32.png", "image/png"], ["apple-touch-icon.png", "image/png"]]) {
+    const path = join(assetsDir, filename);
+    if (existsSync(path)) {
+      const icon = readFileSync(path);
+      app.get(`/${filename}`, async (_request, reply) => reply.type(contentType).send(icon));
+    }
+  }
+  app.get("/", sendDocument);
+  app.get("/robots.txt", async (_request, reply) => reply.type("text/plain").send("User-agent: *\nDisallow: /\n"));
+  app.setNotFoundHandler(async (request, reply) => {
+    if (undecodable.has(request.raw)) {
+      return reply.code(400).send({ error: { code: "VALIDATION_ERROR", message: "The request path is not a valid URL." } });
+    }
+    if (isDemoDocumentRequest(request)) return sendDocument(request, reply);
+    return reply.code(404).send({ error: { code: "NOT_FOUND", message: "Page not found." } });
+  });
+  return app;
+}
+
+// src/demo/seed-marketing.ts
+var checksum = "d".repeat(64);
+function dateAt(now, offset) {
+  const result = new Date(now);
+  result.setUTCDate(result.getUTCDate() + offset);
+  return result.toISOString().slice(0, 10);
+}
+function seedDemoMarketing(db, context) {
+  for (const project of [context.simple, context.portfolio]) seedProjectMarketing(db, project, context.now);
+}
+function seedProjectMarketing(db, project, now) {
+  const capturedAt = now.toISOString();
+  const prefix = `demo-marketing-${project.id}`;
+  const campaignId = `demo-signals-${project.id}-campaign`;
+  const adsConnectionId = `${prefix}-google-ads`;
+  const gtmConnectionId = `${prefix}-gtm`;
+  const adsRunId = `${prefix}-google-ads-run`;
+  const gtmRunId = `${prefix}-gtm-run`;
+  const customerSnapshotId = `${prefix}-customers`;
+  const inventorySnapshotId = `${prefix}-inventory`;
+  const metricsSnapshotId = `${prefix}-metrics`;
+  const gtmSnapshotId = `${prefix}-gtm-live`;
+  db.insert(googleConnections).values({
+    id: `${prefix}-gbp`,
+    domain: project.domain,
+    connectionType: "gbp",
+    propertyId: `accounts/sample-${project.id}`,
+    scopes: [],
+    createdByProjectId: project.id,
+    createdAt: capturedAt,
+    updatedAt: capturedAt
+  }).run();
+  db.insert(runs).values([
+    { id: adsRunId, projectId: project.id, kind: "google-ads-sync", status: "completed", trigger: "manual", createdAt: capturedAt, finishedAt: capturedAt },
+    { id: gtmRunId, projectId: project.id, kind: "gtm-sync", status: "completed", trigger: "manual", createdAt: capturedAt, finishedAt: capturedAt }
+  ]).run();
+  db.insert(googleAdsConnections).values({
+    id: adsConnectionId,
+    projectId: project.id,
+    selectedCustomerId: "demo-customer",
+    selectedCustomerName: "Sample Google Ads account",
+    selectedCustomerCurrencyCode: "USD",
+    selectedCustomerTimeZone: "UTC",
+    selectedCustomerStatus: "enabled",
+    scopes: [],
+    lastValidatedAt: capturedAt,
+    lastCustomerSnapshotId: customerSnapshotId,
+    lastInventorySnapshotAt: capturedAt,
+    lastInventorySnapshotId: inventorySnapshotId,
+    lastMetricsSnapshotAt: capturedAt,
+    lastMetricsSnapshotId: metricsSnapshotId,
+    createdAt: capturedAt,
+    updatedAt: capturedAt
+  }).run();
+  db.insert(gtmConnections).values({
+    id: gtmConnectionId,
+    projectId: project.id,
+    selectedAccountId: "demo-account",
+    selectedAccountName: "Sample account",
+    selectedContainerId: "demo-container",
+    selectedContainerName: "Sample web container",
+    selectedContainerPublicId: "GTM-SAMPLE",
+    selectedWorkspaceId: "demo-workspace",
+    selectedWorkspaceName: "Sample workspace",
+    scopes: [],
+    lastValidatedAt: capturedAt,
+    lastSnapshotAt: capturedAt,
+    lastSnapshotId: gtmSnapshotId,
+    createdAt: capturedAt,
+    updatedAt: capturedAt
+  }).run();
+  db.insert(googleAdsRawSnapshots).values([
+    {
+      id: customerSnapshotId,
+      projectId: project.id,
+      connectionId: adsConnectionId,
+      runId: adsRunId,
+      kind: "accessible-customers",
+      customerId: "demo-customer",
+      payloadChecksum: checksum,
+      rawPayloadSha256: null,
+      rawPayloadBytes: null,
+      redactedFieldCount: 0,
+      capturedAt,
+      createdAt: capturedAt,
+      payload: {
+        kind: "accessible-customers",
+        data: {
+          customers: [{
+            resourceName: "customers/demo-customer",
+            customerId: "demo-customer",
+            parentCustomerId: null,
+            descriptiveName: "Sample Google Ads account",
+            currencyCode: "USD",
+            timeZone: "UTC",
+            manager: false,
+            hidden: false,
+            testAccount: true,
+            level: 0,
+            status: "enabled"
+          }],
+          totalAccessible: 1,
+          truncated: false,
+          selection: { loginCustomerId: null, customerId: "demo-customer", selectedAt: capturedAt },
+          fetchedAt: capturedAt
+        }
+      }
+    },
+    {
+      id: inventorySnapshotId,
+      projectId: project.id,
+      connectionId: adsConnectionId,
+      runId: adsRunId,
+      kind: "inventory",
+      customerId: "demo-customer",
+      payloadChecksum: checksum,
+      rawPayloadSha256: null,
+      rawPayloadBytes: null,
+      redactedFieldCount: 0,
+      capturedAt,
+      createdAt: capturedAt,
+      payload: {
+        kind: "inventory",
+        data: {
+          customerId: "demo-customer",
+          fetchedAt: capturedAt,
+          campaigns: [{ id: campaignId, resourceName: `customers/demo-customer/campaigns/${campaignId}`, name: "Sample search campaign", status: "enabled", advertisingChannelType: "SEARCH", biddingStrategyType: "MAXIMIZE_CONVERSIONS" }],
+          conversionActions: [{ id: "demo-action", resourceName: "customers/demo-customer/conversionActions/demo-action", name: "Sample lead", status: "enabled", category: "SUBMIT_LEAD_FORM", origin: "WEBSITE", primaryForGoal: true, includeInConversionsMetric: true }],
+          customerConversionGoals: [{ category: "SUBMIT_LEAD_FORM", origin: "WEBSITE", biddable: true }],
+          campaignConversionGoals: [],
+          customConversionGoals: [],
+          campaignGoalConfigurations: [{ campaignId, goalConfigLevel: "customer", customGoalId: null }]
+        }
+      }
+    },
+    {
+      id: metricsSnapshotId,
+      projectId: project.id,
+      connectionId: adsConnectionId,
+      runId: adsRunId,
+      kind: "campaign-metrics",
+      customerId: "demo-customer",
+      payloadChecksum: checksum,
+      rawPayloadSha256: null,
+      rawPayloadBytes: null,
+      redactedFieldCount: 0,
+      capturedAt,
+      createdAt: capturedAt,
+      payload: {
+        kind: "campaign-metrics",
+        data: {
+          query: { campaignIds: [campaignId], startDate: dateAt(now, -30), endDate: dateAt(now, 0) },
+          rows: Array.from({ length: 14 }, (_, index) => ({ campaignId, date: dateAt(now, -14 + index), impressions: 260 + index * 17, clicks: 14 + index, costMicros: 15e5 + index * 75e3, conversions: 1 + index % 3 / 2, conversionValueMicros: 75e5 + index * 3e5 })),
+          truncated: false,
+          fetchedAt: capturedAt
+        }
+      }
+    }
+  ]).run();
+  db.insert(gtmRawSnapshots).values({
+    id: gtmSnapshotId,
+    projectId: project.id,
+    connectionId: gtmConnectionId,
+    runId: gtmRunId,
+    kind: "container",
+    accountId: "demo-account",
+    containerId: "demo-container",
+    workspaceId: "demo-workspace",
+    payloadChecksum: checksum,
+    rawPayloadSha256: null,
+    rawPayloadBytes: null,
+    redactedFieldCount: 0,
+    capturedAt,
+    createdAt: capturedAt,
+    payload: {
+      kind: "container",
+      data: {
+        account: { id: "demo-account", path: "accounts/demo-account", name: "Sample account", shareData: null },
+        container: { accountId: "demo-account", id: "demo-container", path: "accounts/demo-account/containers/demo-container", name: "Sample web container", publicId: "GTM-SAMPLE", domainName: project.domain, usageContexts: ["web"] },
+        workspaces: [],
+        draft: null,
+        fetchedAt: capturedAt,
+        live: {
+          source: "live",
+          version: { accountId: "demo-account", containerId: "demo-container", id: "demo-version", path: "accounts/demo-account/containers/demo-container/versions/demo-version", name: "Sample published version", description: null, fingerprint: "sample-version", deleted: false },
+          graph: {
+            accountId: "demo-account",
+            containerId: "demo-container",
+            workspaceId: null,
+            tags: [{ id: "demo-tag", name: "Sample lead conversion", type: "awct", paused: false, firingTriggerIds: ["demo-trigger"], blockingTriggerIds: [], referencedVariableIds: ["demo-value", "demo-transaction", "demo-currency"], parameterKeys: ["conversionId", "conversionLabel", "conversionValue", "orderId", "currencyCode"], fingerprint: "sample-tag" }],
+            triggers: [{ id: "demo-trigger", name: "generate_lead", type: "customEvent", customEventNames: ["generate_lead"], filterKeys: ["event"], autoEventFilterKeys: [], fingerprint: "sample-trigger" }],
+            variables: [
+              { id: "demo-value", name: "value", type: "v", dataLayerVariableName: "value", parameterKeys: [], fingerprint: "sample-value" },
+              { id: "demo-transaction", name: "transaction_id", type: "v", dataLayerVariableName: "transaction_id", parameterKeys: [], fingerprint: "sample-transaction" },
+              { id: "demo-currency", name: "currency", type: "v", dataLayerVariableName: "currency", parameterKeys: [], fingerprint: "sample-currency" }
+            ],
+            googleAdsTagAssessments: [{ tagId: "demo-tag", tagType: "awct", recognition: "recognized", recognitionReason: null, conversionId: { source: "literal", literal: "AW-123456", variableRef: null }, conversionLabel: { source: "literal", literal: "demo-label", variableRef: null }, value: { source: "variable-ref", literal: null, variableRef: "{{value}}" }, transactionId: { source: "variable-ref", literal: null, variableRef: "{{transaction_id}}" }, currency: { source: "variable-ref", literal: null, variableRef: "{{currency}}" }, triggerStrategy: "custom-event", triggerIds: ["demo-trigger"], triggerPredicates: [{ triggerId: "demo-trigger", triggerType: "customEvent", eventPredicates: [{ operator: "equals", value: "generate_lead", negated: false, ignoreCase: false }], hostnamePredicates: [{ operator: "equals", value: project.domain, negated: false, ignoreCase: false }], unsupportedConditionCount: 0 }], reviewReasons: [] }]
+          },
+          fetchedAt: capturedAt
+        }
+      }
+    }
+  }).run();
+}
+
+// src/demo/seed-exploration.ts
+import { and, eq as eq2 } from "drizzle-orm";
+function seedDemoExploration(db, context) {
+  const createdAt = context.now.toISOString();
+  for (const project of [context.simple, context.portfolio]) {
+    const sourceId = `${project.id}-traffic`;
+    const shared = { projectId: project.id, sourceId, createdAt, updatedAt: createdAt };
+    db.insert(trafficSources).values({ id: sourceId, projectId: project.id, sourceType: "cloudflare", displayName: `${project.displayName} website`, status: "active", lastSyncedAt: createdAt, configJson: { zoneName: project.domain }, createdAt, updatedAt: createdAt }).run();
+    for (let hour = 1; hour <= 24; hour++) {
+      const date = new Date(context.now.getTime() - hour * 36e5);
+      date.setUTCMinutes(0, 0, 0);
+      const tsHour = date.toISOString();
+      db.insert(crawlerEventsHourly).values({ ...shared, tsHour, botId: "gptbot", operator: "openai", verificationStatus: "claimed_unverified", pathNormalized: "/", status: 200, hits: 3 + hour % 4 }).run();
+      db.insert(aiUserFetchEventsHourly).values({ ...shared, tsHour, botId: "chatgpt-user", operator: "openai", verificationStatus: "claimed_unverified", pathNormalized: "/services/", status: 200, hits: 1 + hour % 2 }).run();
+      db.insert(aiReferralEventsHourly).values({ ...shared, tsHour, product: "chatgpt", operator: "openai", sourceDomain: "demo-answer-engine.example", evidenceType: "referer", landingPathNormalized: "/services/", status: 200, sessionsOrHits: 2, organicSessionsOrHits: 2 }).run();
+    }
+    const runId = `demo-signals-${project.id}-crawl`;
+    const root = `https://${project.domain}/`;
+    seedPageAudits(db, project.id, runId, root, createdAt);
+    const researchRunId = `${project.id}-research`;
+    db.insert(researchRuns).values({ id: researchRunId, projectId: project.id, status: "completed", provider: "openai", requestedModel: "demo-model", resolvedModel: "demo-model", totalQueries: 2, completedQueries: 2, failedQueries: 0, startedAt: createdAt, finishedAt: createdAt, createdAt }).run();
+    const topics = project.id === context.simple.id ? ["How do homeowners compare roofing materials?", "What should a roof repair estimate include?"] : ["What amenities matter most for a family resort stay?", "How should travelers compare coastal resorts?"];
+    const discoveryId = `${project.id}-discovery`;
+    db.insert(discoverySessions).values({ id: discoveryId, projectId: project.id, status: "completed", icpDescription: `Fictional research example for ${project.displayName}.`, buyerDescription: "People comparing local services and planning a purchase.", seedProvider: "openai", seedProviders: ["openai"], seedCountRaw: 2, seedCount: 2, canonicalCount: 2, probeCount: 2, citedCount: 1, aspirationalCount: 1, wastedCount: 0, startedAt: createdAt, finishedAt: createdAt, createdAt }).run();
+    db.insert(discoveryProbes).values(topics.map((query, i) => ({ id: `${discoveryId}-${i}`, sessionId: discoveryId, projectId: project.id, query, bucket: i === 0 ? "cited" : "aspirational", citationState: i === 0 ? "cited" : "not-cited", answerMentioned: i === 0, citedDomains: i === 0 ? [project.domain] : ["comparison-guide.example"], createdAt }))).run();
+    db.insert(researchRunQueries).values(topics.map((queryText, position) => ({ id: `${researchRunId}-${position}`, researchRunId, position, queryText, status: "completed", requestedModel: "demo-model", resolvedModel: "demo-model", servedModel: "demo-model", answerText: `Fictional sample answer: compare clear pricing, service details, and independent reviews. ${project.displayName} illustrates a business with useful comparison guidance.`, groundingSources: [{ uri: `${root}guides/`, title: `${project.displayName} comparison guide` }], citedDomains: [project.domain], answerMentioned: true, citationState: "cited", startedAt: createdAt, finishedAt: createdAt, createdAt }))).run();
+  }
+}
+function seedPageAudits(db, projectId, runId, root, createdAt) {
+  const crawlPages = db.select().from(siteCrawlPages).where(and(eq2(siteCrawlPages.projectId, projectId), eq2(siteCrawlPages.runId, runId))).all();
+  const audited = crawlPages.filter((page) => page.auditState === "success" && page.auditScore !== null);
+  const pages = audited.map((page, index) => {
+    const factors2 = siteAuditPageFactorSchema.array().parse(page.auditFields.factors);
+    return { id: `${projectId}-audit-page-${index}`, projectId, runId, url: page.url, overallScore: page.auditScore, status: "success", factors: factors2, createdAt };
+  });
+  const factors = pages.flatMap((page) => page.factors);
+  const factorAverages = [...new Set(factors.map((factor) => factor.id))].map((id) => {
+    const matching = factors.filter((factor) => factor.id === id);
+    const first = matching[0];
+    const avgScore = Math.round(matching.reduce((sum, factor) => sum + factor.score, 0) / matching.length);
+    return {
+      id,
+      name: first.name,
+      weight: first.weight,
+      avgScore,
+      status: factorStatusFromScore(avgScore),
+      pagesPassing: matching.filter((factor) => factorStatusFromScore(factor.score) === "pass").length,
+      pagesPartial: matching.filter((factor) => factorStatusFromScore(factor.score) === "partial").length,
+      pagesFailing: matching.filter((factor) => factorStatusFromScore(factor.score) === "fail").length
+    };
+  });
+  const crossCuttingIssues = factorAverages.filter((factor) => factor.pagesPartial + factor.pagesFailing > 0).map((factor) => ({
+    factorId: factor.id,
+    factorName: factor.name,
+    avgScore: factor.avgScore,
+    affectedPages: factor.pagesPartial + factor.pagesFailing,
+    totalPages: pages.length,
+    affectedPct: Math.round((factor.pagesPartial + factor.pagesFailing) / pages.length * 100),
+    topRecommendations: [`Complete ${factor.name.toLowerCase()} details on the affected pages.`]
+  }));
+  db.insert(siteAuditSnapshots).values({
+    id: `${projectId}-audit`,
+    projectId,
+    runId,
+    sitemapUrl: `${root}sitemap.xml`,
+    auditedAt: createdAt,
+    aggregateScore: Math.round(pages.reduce((sum, page) => sum + page.overallScore, 0) / pages.length),
+    pagesDiscovered: crawlPages.length,
+    pagesAudited: pages.length,
+    pagesErrored: crawlPages.filter((page) => page.fetchState === "fetch-error").length,
+    pagesSkipped: crawlPages.filter((page) => page.auditState === "not-applicable").length,
+    factorAverages,
+    crossCuttingIssues,
+    prioritizedFixes: crossCuttingIssues.flatMap((issue) => issue.topRecommendations),
+    createdAt
+  }).run();
+  for (let i = 0; i < pages.length; i += 100) db.insert(siteAuditPages).values(pages.slice(i, i + 100)).run();
+}
+
+// src/demo/seed-core.ts
+import crypto from "crypto";
+
+// src/demo/portfolio.ts
+var HARBOR_MARKETS = [
+  { key: "key-west", label: "Key West", city: "Key West", region: "FL" },
+  { key: "coastal-maine", label: "Coastal Maine", city: "Portland", region: "ME" },
+  { key: "pacific-northwest", label: "Pacific Northwest", city: "Seattle", region: "WA" }
+];
+function harborProperties() {
+  return HARBOR_MARKETS.flatMap((market) => [1, 2, 3, 4].map((number) => ({
+    key: `harbor-${market.key}-${number}`,
+    number,
+    label: `Harbor ${market.label} ${number === 1 ? "Resort" : `Villas ${number}`}`,
+    market,
+    path: `/destinations/${market.key}/${number === 1 ? "resort" : `villas-${number}`}`
+  })));
+}
+
+// src/demo/seed-answer-intelligence.ts
+import { and as and2, asc, eq as eq3 } from "drizzle-orm";
+function seedDemoAnswerIntelligence(db, project) {
+  const service2 = new IntelligenceService(db);
+  const sweeps = db.select().from(runs).where(and2(eq3(runs.projectId, project.id), eq3(runs.kind, RunKinds["answer-visibility"]))).orderBy(asc(runs.createdAt)).all();
+  for (const [index, sweep] of sweeps.entries()) {
+    const previous = index > 0 ? sweeps[index - 1] : null;
+    const history = sweeps.slice(Math.max(0, index - (HISTORY_WINDOW_RUNS - 1)), index + 1);
+    const result = service2.analyzeRunWithPrevious(sweep, previous, history, { dryRun: true });
+    if (!result) continue;
+    db.transaction((tx) => {
+      tx.insert(healthSnapshots).values({
+        id: `${sweep.id}-health`,
+        projectId: project.id,
+        runId: sweep.id,
+        overallCitedRate: String(result.health.overallCitedRate),
+        overallMentionRate: String(result.health.overallMentionRate),
+        totalPairs: result.health.totalPairs,
+        citedPairs: result.health.citedPairs,
+        mentionedPairs: result.health.mentionedPairs,
+        providerBreakdown: result.health.providerBreakdown,
+        createdAt: sweep.createdAt
+      }).run();
+      const found = previous ? result.insights : [];
+      for (const [position, insight] of found.entries()) {
+        tx.insert(insights).values({
+          id: `${sweep.id}-insight-${position + 1}`,
+          projectId: project.id,
+          runId: sweep.id,
+          type: insight.type,
+          severity: insight.severity,
+          title: insight.title,
+          query: insight.query,
+          provider: insight.provider,
+          recommendation: insight.recommendation ?? null,
+          cause: insight.cause ?? null,
+          dismissed: false,
+          createdAt: sweep.createdAt
+        }).run();
+      }
+    });
+  }
+}
+
+// src/demo/summit-sweeps.ts
+var SUMMIT_SWEEP_COUNT = 6;
+var SUMMIT_ENGINES = ["openai", "gemini", "claude"];
+var RIVALS = {
+  roofcraft: { name: "RoofCraft", domain: "roofcraft.example", path: "/roof-replacement/", blurb: "A replacement contractor known for metal and shingle installs." },
+  everlast: { name: "Everlast Roofing", domain: "everlast-roofing.example", path: "/services/", blurb: "A repair and gutter company with a large emergency crew." }
+};
+var SUMMIT_COMPETITORS = Object.values(RIVALS).map((rival) => ({ domain: rival.domain, label: rival.name }));
+var SUMMIT_QUERIES = [
+  { key: "reviews", text: "Summit Roofing reviews", pages: ["/reviews/"], rivals: [], source: "https://home-services-reviews.example/roofers/", lead: "Recent homeowner reviews are mostly positive.", blurb: "Reviewers mention clear estimates, tidy crews and quick follow-up on warranty visits." },
+  { key: "near-me", text: "roof repair contractor near me", pages: ["/services/roof-repair/", "/service-areas/"], rivals: ["everlast", "roofcraft"], source: "https://local-contractor-directory.example/roofing/", lead: "Several roofers in the area handle repair work.", blurb: "A local roofer covering leak repairs, storm damage and inspections across two dozen towns." },
+  { key: "emergency-leak", text: "emergency roof leak repair", pages: ["/services/roof-repair/leak-repair/", "/services/roof-repair/emergency-tarping/"], rivals: ["everlast"], source: "https://homeowner-guides.example/roof-leaks/", lead: "For an active leak, look for a crew that can tarp the roof the same day.", blurb: "Offers emergency tarping and leak repair, with same-day visits in its service area." },
+  { key: "metal-installer", text: "best metal roof installer", pages: ["/services/roof-replacement/metal-roofing/", "/guides/metal-vs-asphalt-shingles/"], rivals: ["roofcraft"], source: "https://metal-roofing-council.example/find-an-installer/", lead: "Metal roofs need an installer with standing-seam experience.", blurb: "Installs standing-seam and metal shingle roofs and publishes a metal versus asphalt comparison." },
+  { key: "warranty", text: "Summit Roofing warranty", pages: ["/about/warranty/"], rivals: [], source: "https://homeowner-guides.example/roof-warranties/", lead: "Roofing warranties usually combine manufacturer and workmanship coverage.", blurb: "Backs replacements with a written workmanship warranty on top of the manufacturer coverage." },
+  { key: "replacement-cost", text: "how much does a roof replacement cost", pages: ["/guides/how-much-does-a-roof-replacement-cost/", "/financing/"], rivals: ["roofcraft"], source: "https://home-cost-report.example/roof-replacement/", lead: "Most full replacements land between 9,000 and 18,000 dollars, depending on size and material.", blurb: "Publishes a cost guide with typical price ranges and offers financing on full replacements." },
+  { key: "storm-claims", text: "storm damage roof repair and insurance claims", pages: ["/services/roof-repair/storm-damage/", "/guides/filing-a-roof-insurance-claim/"], rivals: ["everlast"], source: "https://homeowner-guides.example/storm-claims/", lead: "Photograph the damage before any repair and call your insurer early.", blurb: "Documents storm damage for insurance claims and joins the adjuster visit." },
+  { key: "asphalt-shingles", text: "asphalt shingle roof replacement", pages: ["/services/roof-replacement/asphalt-shingles/"], rivals: ["roofcraft"], source: "https://home-cost-report.example/asphalt-shingles/", lead: "Architectural shingles are the most common replacement choice.", blurb: "Replaces asphalt shingle roofs with a choice of architectural shingle lines." },
+  { key: "seamless-gutters", text: "seamless gutter installation", pages: ["/services/gutters/seamless-gutters/"], rivals: ["everlast"], source: "https://homeowner-guides.example/gutters/", lead: "Seamless gutters are formed on site, so they leak less at the joints.", blurb: "Installs seamless gutters and gutter guards, often alongside a roof replacement." },
+  { key: "pre-purchase-inspection", text: "roof inspection before buying a house", pages: ["/services/roof-inspection/real-estate-inspection/", "/guides/real-estate-roof-inspections/"], rivals: ["roofcraft", "everlast"], source: "https://home-buyer-checklist.example/roof-inspection/", lead: "A roof inspection before closing can surface repairs to negotiate.", blurb: "Runs pre-purchase roof inspections with photo reports for buyers and agents." }
+];
+var SUMMIT_BRANDED_QUERY_KEYS = ["reviews", "warranty"];
+var SUMMIT_ENGINE_PLANS = {
+  // Climbs steadily.
+  openai: {
+    mentioned: [2, 3, 3, 4, 5, 6],
+    mentionOrder: ["emergency-leak", "replacement-cost", "near-me", "storm-claims", "pre-purchase-inspection", "seamless-gutters", "asphalt-shingles", "metal-installer"],
+    cited: [1, 2, 2, 3, 4, 5],
+    citationOrder: ["replacement-cost", "storm-claims", "pre-purchase-inspection", "emergency-leak", "asphalt-shingles", "metal-installer", "seamless-gutters", "near-me"]
+  },
+  // Steady, then a dip and a recovery.
+  gemini: {
+    mentioned: [4, 4, 4, 2, 3, 5],
+    mentionOrder: ["near-me", "emergency-leak", "replacement-cost", "storm-claims", "seamless-gutters", "pre-purchase-inspection", "metal-installer", "asphalt-shingles"],
+    cited: [3, 3, 3, 1, 2, 3],
+    citationOrder: ["replacement-cost", "pre-purchase-inspection", "storm-claims", "metal-installer", "emergency-leak", "asphalt-shingles", "seamless-gutters", "near-me"]
+  },
+  // Swings from week to week.
+  claude: {
+    mentioned: [3, 1, 4, 2, 4, 3],
+    mentionOrder: ["emergency-leak", "replacement-cost", "storm-claims", "near-me", "pre-purchase-inspection", "asphalt-shingles", "seamless-gutters", "metal-installer"],
+    cited: [2, 1, 2, 1, 3, 2],
+    citationOrder: ["pre-purchase-inspection", "replacement-cost", "storm-claims", "emergency-leak", "asphalt-shingles", "near-me", "metal-installer", "seamless-gutters"]
+  }
+};
+var BRANDED_PLAN = {
+  reviews: {
+    openai: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
+    gemini: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
+    claude: { mentioned: [true, true, true, true, true, true], cited: [false, false, false, false, false, false] }
+  },
+  warranty: {
+    openai: { mentioned: [true, true, true, true, true, true], cited: [true, true, true, true, true, true] },
+    gemini: { mentioned: [true, true, true, false, true, true], cited: [true, true, true, false, true, true] },
+    claude: { mentioned: [true, true, true, true, true, true], cited: [false, false, true, false, true, true] }
+  }
+};
+function isBranded(key) {
+  return SUMMIT_BRANDED_QUERY_KEYS.includes(key);
+}
+function summitAnswerPlan(sweep, engine, queryKey) {
+  if (isBranded(queryKey)) {
+    const plan2 = BRANDED_PLAN[queryKey][engine];
+    return { mentioned: plan2.mentioned[sweep], cited: plan2.cited[sweep] };
+  }
+  const plan = SUMMIT_ENGINE_PLANS[engine];
+  return {
+    mentioned: plan.mentionOrder.slice(0, plan.mentioned[sweep]).includes(queryKey),
+    cited: plan.citationOrder.slice(0, plan.cited[sweep]).includes(queryKey)
+  };
+}
+function summitAnswer(input) {
+  const { sweep, engine, queryIndex, displayName, domain } = input;
+  const query = SUMMIT_QUERIES[queryIndex];
+  const engineIndex = SUMMIT_ENGINES.indexOf(engine);
+  const plan = summitAnswerPlan(sweep, engine, query.key);
+  const rivals = plan.mentioned ? (sweep + engineIndex + queryIndex) % 2 === 0 ? query.rivals.slice(0, 1) : [] : query.rivals;
+  const entries = [
+    ...plan.mentioned ? [{ name: displayName, blurb: query.blurb }] : [],
+    ...rivals.map((key) => ({ name: RIVALS[key].name, blurb: RIVALS[key].blurb }))
+  ];
+  const answerText = isBranded(query.key) && !plan.mentioned ? `Fictional answer.
+
+I could not find published details for that company. ${query.lead} Most residential roofers offer 5 to 10 years of workmanship coverage.` : [
+    "Fictional answer.",
+    query.lead,
+    entries.map((entry, index) => `${index + 1}. **${entry.name}**: ${entry.blurb}`).join("\n"),
+    "Get two or three written estimates before you commit."
+  ].join("\n\n");
+  const citedRivals = rivals.filter((_, index) => (sweep + engineIndex + queryIndex + index) % 3 !== 0);
+  const citedUrls = [
+    ...plan.cited ? [`https://${domain}${query.pages[(sweep + engineIndex) % query.pages.length]}`] : [],
+    ...citedRivals.map((key) => `https://${RIVALS[key].domain}${RIVALS[key].path}`),
+    query.source
+  ];
+  const citedDomains = citedUrls.map((url) => new URL(url).hostname);
+  const normalized = {
+    provider: engine,
+    answerText,
+    citedDomains,
+    groundingSources: citedUrls.map((uri) => ({ uri, title: "" })),
+    searchQueries: [query.text],
+    retrievalStatus: "used"
+  };
+  const domains = effectiveDomains({ canonicalDomain: domain, ownedDomains: [domain] });
+  const brandNames = effectiveBrandNames({ displayName, canonicalDomain: domain, ownedDomains: [domain] });
+  const competitorDomains = SUMMIT_COMPETITORS.map((competitor) => competitor.domain);
+  return {
+    answerText,
+    answerMentioned: determineAnswerMentioned(answerText, brandNames, domains),
+    citationState: determineCitationState(normalized, domains),
+    citedDomains,
+    citedUrls,
+    competitorOverlap: computeCompetitorOverlap(normalized, competitorDomains),
+    recommendedCompetitors: extractRecommendedCompetitors(answerText, domains, citedDomains, competitorDomains, brandNames)
+  };
+}
+
+// src/demo/seed-core.ts
+var PROVIDERS = [
+  { provider: "openai", requestedModel: "gpt-5-demo", servedModel: "gpt-5-demo-2026-08-15" },
+  { provider: "gemini", requestedModel: "gemini-2.5-pro-demo", servedModel: "gemini-2.5-pro" },
+  { provider: "claude", requestedModel: "claude-sonnet-demo", servedModel: "claude-sonnet-4-demo" }
+];
+function isoAtWeek(now, weeksAgo) {
+  return new Date(now.getTime() - weeksAgo * 7 * 24 * 60 * 60 * 1e3).toISOString();
+}
+function sha256(value) {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+function harborLocations() {
+  return HARBOR_MARKETS.map((market) => ({
+    label: market.label,
+    city: market.city,
+    region: market.region,
+    country: "US"
+  }));
+}
+function harborPlan(context, capturedAt) {
+  const properties = harborProperties();
+  const locations = new Map(harborLocations().map((location) => [location.label, location]));
+  const querySnapshots2 = properties.flatMap((property) => [
+    { queryId: `${property.key}-brand`, queryText: `${property.label} reviews` },
+    { queryId: `${property.key}-nonbrand`, queryText: `best luxury resort in ${property.market.label} for ${["oceanfront pools", "family suites", "spa weekends", "sunset dining"][property.number - 1]}` }
+  ].map((query) => ({ ...query, provenance: { source: "manual", sourceId: "demo-core", capturedAt } })));
+  const assignments = properties.flatMap((property) => [
+    { suffix: "brand", queryClass: "branded" },
+    { suffix: "nonbrand", queryClass: "non-brand" }
+  ].map((item) => ({
+    targetKey: property.key,
+    queryId: `${property.key}-${item.suffix}`,
+    queryClass: item.queryClass,
+    classificationSource: "operator",
+    executionNodeKey: `exec-${property.key}-${item.suffix}`
+  })));
+  const executionNodes = assignments.map((assignment) => {
+    const property = properties.find((candidate) => candidate.key === assignment.targetKey);
+    const query = querySnapshots2.find((candidate) => candidate.queryId === assignment.queryId);
+    return {
+      stableKey: assignment.executionNodeKey,
+      queryId: query.queryId,
+      queryText: query.queryText,
+      context: {
+        providers: PROVIDERS.map((identity) => identity.provider),
+        models: Object.fromEntries(PROVIDERS.map((identity) => [identity.provider, identity.requestedModel])),
+        location: locations.get(property.market.label)
+      },
+      expectedSnapshots: PROVIDERS.length
+    };
+  });
+  const usageEdges = assignments.map((assignment) => ({
+    executionNodeKey: assignment.executionNodeKey,
+    targetKey: assignment.targetKey,
+    queryId: assignment.queryId
+  }));
+  const provisional = {
+    schemaVersion: 2,
+    identities: {
+      projectBrand: {
+        canonicalHost: context.portfolio.domain,
+        ownedHosts: [context.portfolio.domain],
+        names: ["Harbor Resorts", "Harbor"]
+      }
+    },
+    targets: properties.map((property) => ({
+      stableKey: property.key,
+      label: property.label,
+      aliases: [property.label, `Harbor ${property.market.label}`],
+      urlMatchers: [{ kind: "prefix", host: context.portfolio.domain, pathPrefix: property.path, pathCase: "insensitive" }],
+      mentionNotApplicable: false,
+      discoveryIdentity: `demo:${property.key}`
+    })),
+    groups: HARBOR_MARKETS.map((market) => ({
+      stableKey: `market-${market.key}`,
+      label: `${market.label} market`,
+      targetKeys: properties.filter((property) => property.market.key === market.key).map((property) => property.key),
+      competitors: [
+        { stableKey: "seaside-collection", label: "Seaside Collection", domain: "seaside-collection.example", aliases: ["Seaside Collection"] },
+        { stableKey: "coastal-stays", label: "Coastal Stays", domain: "coastal-stays.example", aliases: ["Coastal Stays"] }
+      ]
+    })),
+    querySnapshots: querySnapshots2,
+    assignments,
+    executionNodes,
+    usageEdges,
+    reportingScopes: HARBOR_MARKETS.map((market) => ({
+      stableKey: `market-${market.key}`,
+      label: `${market.label} market`,
+      kind: "market",
+      usageEdges: usageEdges.filter((edge) => edge.targetKey.includes(market.key))
+    })),
+    compiledChecksum: "0".repeat(64)
+  };
+  const parsed = measurementPlanV2Schema.parse(provisional);
+  return measurementPlanV2Schema.parse({
+    ...parsed,
+    compiledChecksum: sha256(measurementPlanV2ChecksumJson(parsed))
+  });
+}
+function harborDraft(plan) {
+  const targets = plan.targets.map((target) => ({
+    stableKey: target.stableKey,
+    label: target.label,
+    status: "included",
+    aliases: target.aliases,
+    urlMatchers: target.urlMatchers.map((matcher) => matcher.kind === "prefix" ? `https://${matcher.host}${matcher.pathPrefix}/*` : matcher.kind === "host" ? matcher.host : matcher.url),
+    source: "sitemap",
+    discoveredUrl: `https://${target.urlMatchers[0].kind === "prefix" ? target.urlMatchers[0].host + target.urlMatchers[0].pathPrefix : "harbor-resorts.example"}`,
+    discoveryIdentity: target.discoveryIdentity ?? void 0
+  }));
+  return {
+    defaultContext: { providers: PROVIDERS.map((identity) => identity.provider), models: Object.fromEntries(PROVIDERS.map((identity) => [identity.provider, identity.requestedModel])), locations: HARBOR_MARKETS.map((market) => market.label) },
+    targets,
+    assignments: plan.assignments.map((assignment) => ({
+      targetKey: assignment.targetKey,
+      queryId: assignment.queryId,
+      queryClass: assignment.queryClass,
+      classificationSource: "operator",
+      executionContexts: [plan.executionNodes.find((node) => node.stableKey === assignment.executionNodeKey).context]
+    })),
+    groups: plan.groups.map((group) => ({
+      stableKey: group.stableKey,
+      label: group.label,
+      targetKeys: group.targetKeys,
+      competitors: group.competitors
+    })),
+    reportingScopes: plan.reportingScopes
+  };
+}
+function seedDemoCore(db, context) {
+  const now = context.now.toISOString();
+  const simpleQueries = SUMMIT_QUERIES.map((plan, index) => ({ id: `demo-summit-query-${index + 1}`, query: plan.text }));
+  const portfolioPlan = harborPlan(context, now);
+  const planVersionId = "demo-harbor-plan-v2";
+  const execution = { providers: PROVIDERS.map((identity) => identity.provider), models: Object.fromEntries(PROVIDERS.map((identity) => [identity.provider, identity.requestedModel])) };
+  const executionIdentity = buildMeasurementExecutionIdentity(execution, sha256(canonicalMeasurementExecutionIdentityJson(execution)));
+  const planManifest = buildMeasurementRunManifestV1({
+    expectedSlots: portfolioPlan.executionNodes.flatMap((node) => node.context.providers.map((provider) => ({
+      executionId: node.stableKey,
+      queryText: node.queryText,
+      provider,
+      context: node.context.location,
+      requestedModel: node.context.models[provider]
+    })))
+  });
+  db.transaction((tx) => {
+    tx.insert(projects).values([
+      {
+        id: context.simple.id,
+        name: context.simple.name,
+        displayName: context.simple.displayName,
+        canonicalDomain: context.simple.domain,
+        ownedDomains: [context.simple.domain],
+        country: "US",
+        language: "en",
+        providers: PROVIDERS.map((identity) => identity.provider),
+        providerModels: Object.fromEntries(PROVIDERS.map((identity) => [identity.provider, identity.requestedModel])),
+        createdAt: now,
+        updatedAt: now
+      },
+      {
+        id: context.portfolio.id,
+        name: context.portfolio.name,
+        displayName: context.portfolio.displayName,
+        canonicalDomain: context.portfolio.domain,
+        ownedDomains: [context.portfolio.domain],
+        country: "US",
+        language: "en",
+        providers: PROVIDERS.map((identity) => identity.provider),
+        providerModels: Object.fromEntries(PROVIDERS.map((identity) => [identity.provider, identity.requestedModel])),
+        locations: harborLocations(),
+        defaultLocation: "Key West",
+        createdAt: now,
+        updatedAt: now
+      }
+    ]).run();
+    tx.insert(queries).values([
+      ...simpleQueries.map((item) => ({ id: item.id, projectId: context.simple.id, query: item.query, provenance: "demo-core", createdAt: now })),
+      ...portfolioPlan.querySnapshots.map((snapshot) => ({ id: snapshot.queryId, projectId: context.portfolio.id, query: snapshot.queryText, provenance: "demo-core", createdAt: now }))
+    ]).run();
+    tx.insert(competitors).values([
+      { id: "demo-summit-competitor-1", projectId: context.simple.id, domain: "roofcraft.example", provenance: "demo-core", createdAt: now },
+      { id: "demo-summit-competitor-2", projectId: context.simple.id, domain: "everlast-roofing.example", provenance: "demo-core", createdAt: now },
+      { id: "demo-harbor-competitor-1", projectId: context.portfolio.id, domain: "seaside-collection.example", provenance: "demo-core", createdAt: now },
+      { id: "demo-harbor-competitor-2", projectId: context.portfolio.id, domain: "coastal-stays.example", provenance: "demo-core", createdAt: now }
+    ]).run();
+    tx.insert(measurementPlanVersions).values({
+      id: planVersionId,
+      projectId: context.portfolio.id,
+      revision: 2,
+      canonicalJson: canonicalMeasurementPlanV2Json(portfolioPlan),
+      checksum: sha256(canonicalMeasurementPlanV2Json(portfolioPlan)),
+      schemaVersion: 2,
+      compiledChecksum: portfolioPlan.compiledChecksum,
+      publishedBy: "demo-reviewed",
+      createdAt: now
+    }).run();
+    tx.insert(measurementPlans).values({ projectId: context.portfolio.id, activeVersionId: planVersionId, createdAt: now, updatedAt: now }).run();
+    tx.insert(measurementSegments).values([
+      ...portfolioPlan.targets.map((target) => ({ id: `segment-${target.stableKey}`, projectId: context.portfolio.id, stableKey: target.stableKey, kind: "target", createdAt: now })),
+      ...portfolioPlan.groups.map((group) => ({ id: `segment-${group.stableKey}`, projectId: context.portfolio.id, stableKey: group.stableKey, kind: "group", createdAt: now }))
+    ]).run();
+    tx.insert(measurementPlanDrafts).values({
+      id: "demo-harbor-authoring-draft",
+      projectId: context.portfolio.id,
+      schemaVersion: 2,
+      baseActiveVersionId: planVersionId,
+      baseActiveRevision: 2,
+      authoringJson: JSON.stringify(harborDraft(portfolioPlan)),
+      etagVersion: 7,
+      createdBy: JSON.stringify({ kind: "system", id: "demo", label: "Demo authoring" }),
+      updatedBy: JSON.stringify({ kind: "system", id: "demo", label: "Demo authoring" }),
+      createdAt: now,
+      updatedAt: now
+    }).run();
+    for (let week = SUMMIT_SWEEP_COUNT - 1; week >= 0; week--) {
+      const createdAt = isoAtWeek(context.now, week);
+      const sweep = SUMMIT_SWEEP_COUNT - 1 - week;
+      const simpleRunId = `demo-summit-week-${sweep + 1}`;
+      const simpleDefinition = buildSimpleMeasurementDefinition({
+        capturedAt: createdAt,
+        identity: { displayName: context.simple.displayName, aliases: ["Summit", "Summit Roofing"], canonicalDomain: context.simple.domain, ownedDomains: [context.simple.domain] },
+        country: "US",
+        language: "en",
+        location: null,
+        engines: PROVIDERS.map((identity) => ({ provider: identity.provider, requestedModel: identity.requestedModel })),
+        competitors: [
+          { domain: SUMMIT_COMPETITORS[0].domain, label: SUMMIT_COMPETITORS[0].label, aliases: ["RoofCraft"] },
+          { domain: SUMMIT_COMPETITORS[1].domain, label: SUMMIT_COMPETITORS[1].label, aliases: ["Everlast"] }
+        ],
+        queries: simpleQueries.map((item) => ({ queryId: item.id, queryText: item.query, provenance: "demo-core" }))
+      });
+      tx.insert(runs).values({ id: simpleRunId, projectId: context.simple.id, kind: "answer-visibility", status: "completed", trigger: "manual", queries: simpleQueries.map((item) => item.query), startedAt: createdAt, finishedAt: createdAt, createdAt }).run();
+      tx.insert(simpleMeasurementDefinitions).values({
+        runId: simpleRunId,
+        projectId: context.simple.id,
+        definition: simpleDefinition,
+        checksum: sha256(canonicalSimpleMeasurementDefinitionJson(simpleDefinition)),
+        capturedAt: createdAt
+      }).run();
+      tx.insert(querySnapshots).values(simpleQueries.flatMap((query, queryIndex) => PROVIDERS.map((identity) => {
+        const engine = SUMMIT_ENGINES.find((candidate) => candidate === identity.provider);
+        const answer = summitAnswer({ sweep, engine, queryIndex, displayName: context.simple.displayName, domain: context.simple.domain });
+        return {
+          id: `${simpleRunId}-${identity.provider}-${queryIndex}`,
+          runId: simpleRunId,
+          queryId: query.id,
+          queryText: query.query,
+          provider: identity.provider,
+          model: identity.requestedModel,
+          servedModel: identity.servedModel,
+          ...answer,
+          captureStatus: "complete",
+          sourceCount: answer.citedUrls.length,
+          resolvedCount: answer.citedUrls.length,
+          captureVersion: 1,
+          retrievalStatus: "used",
+          createdAt
+        };
+      }))).run();
+      const portfolioRunId = `demo-harbor-week-${6 - week}`;
+      tx.insert(runs).values({
+        id: portfolioRunId,
+        projectId: context.portfolio.id,
+        kind: "answer-visibility",
+        status: "completed",
+        trigger: "manual",
+        measurementPlanVersionId: planVersionId,
+        measurementManifest: planManifest,
+        measurementExecutionIdentity: executionIdentity,
+        startedAt: createdAt,
+        finishedAt: createdAt,
+        createdAt
+      }).run();
+      tx.insert(querySnapshots).values(portfolioPlan.executionNodes.flatMap((node, nodeIndex) => PROVIDERS.map((identity, providerIndex) => {
+        const target = portfolioPlan.targets.find((candidate) => node.stableKey.includes(candidate.stableKey));
+        const cited = !(week === 0 && identity.provider === "gemini" && node.stableKey.endsWith("nonbrand")) && (week + nodeIndex + providerIndex) % 4 !== 0;
+        const competitor = providerIndex === 1 ? "coastal-stays.example" : "seaside-collection.example";
+        return {
+          id: `${portfolioRunId}-${node.stableKey}-${identity.provider}`,
+          runId: portfolioRunId,
+          queryId: node.queryId,
+          queryText: node.queryText,
+          provider: identity.provider,
+          model: identity.requestedModel,
+          servedModel: identity.servedModel,
+          citationState: cited ? "cited" : "not-cited",
+          answerMentioned: cited,
+          answerText: cited ? `Fictional answer: ${target.label} is a Harbor Resorts option for this stay.` : `Fictional answer: ${providerIndex === 1 ? "Coastal Stays" : "Seaside Collection"} is recommended instead.`,
+          citedDomains: cited ? [context.portfolio.domain] : [competitor],
+          citedUrls: cited ? [`https://${context.portfolio.domain}${target.urlMatchers[0].kind === "prefix" ? target.urlMatchers[0].pathPrefix : "/"}`] : [`https://${competitor}/guides/luxury-stays`],
+          captureStatus: "complete",
+          sourceCount: 1,
+          resolvedCount: 1,
+          captureVersion: 1,
+          retrievalStatus: "used",
+          competitorOverlap: cited ? [] : [competitor],
+          recommendedCompetitors: [competitor],
+          measurementExecutionId: node.stableKey,
+          requestedContext: node.context.location,
+          supportedContext: { status: "applied", resolved: node.context.location },
+          location: node.context.location.label,
+          createdAt
+        };
+      }))).run();
+    }
+  });
+  seedDemoAnswerIntelligence(db, context.simple);
+}
+
+// src/demo/seed-site-crawl.ts
+var DEMO_AUDIT_FACTORS = [
+  { id: "structured-data", name: "Structured Data (JSON-LD)", weight: 12, bias: 4, found: "JSON-LD markup describes this page.", missing: "JSON-LD markup is missing or incomplete.", recommendation: "Add JSON-LD that describes the business and this page." },
+  { id: "content-depth", name: "Content Depth", weight: 10, bias: 0, found: "The page covers its topic in depth.", missing: "The page has little original text.", recommendation: "Expand the page with specific details and examples." },
+  { id: "faq-content", name: "FAQ Content", weight: 8, bias: -10, found: "The page has an FAQ section with direct answers.", missing: "No FAQ content was found.", recommendation: "Add an FAQ section that answers what visitors ask about this topic." },
+  { id: "schema-completeness", name: "Schema Completeness", weight: 8, bias: -4, found: "Schema properties cover the key details.", missing: "Key schema properties are missing.", recommendation: "Fill in the missing schema properties." },
+  { id: "eeat-signals", name: "E-E-A-T Signals", weight: 8, bias: 2, found: "Author, credentials, and business details are visible.", missing: "No author or credentials are shown.", recommendation: "Name the author and show relevant credentials." },
+  { id: "citations", name: "Citations & Authority Signals", weight: 8, bias: -8, found: "The page cites supporting sources.", missing: "The page makes claims without supporting sources.", recommendation: "Link to the sources that support the claims on this page." },
+  { id: "lighthouse", name: "Lighthouse (Performance/A11y/Best Practices)", weight: 8, bias: 3, found: "Performance and accessibility checks pass.", missing: "Performance or accessibility checks need work.", recommendation: "Compress large images and fix the flagged accessibility issues." },
+  { id: "geographic-signals", name: "Geographic Signals", weight: 7, bias: 2, found: "The places this business serves are named on the page.", missing: "The page does not say where the business operates.", recommendation: "Name the towns and regions this page serves." },
+  { id: "content-freshness", name: "Content Freshness", weight: 7, bias: -3, found: "The page shows a recent update date.", missing: "No recent update date was found.", recommendation: "Review the page and show when it was last updated." },
+  { id: "entity-consistency", name: "Entity Consistency", weight: 7, bias: 6, found: "Business name and contact details match across the site.", missing: "Business name or contact details differ from other pages.", recommendation: "Use the same business name, phone, and address everywhere." },
+  { id: "agent-skill-exposure", name: "Agent Skill Exposure", weight: 6, bias: -12, found: "Key actions are described in a machine-readable form.", missing: "No machine-readable actions were found.", recommendation: "Describe key actions, such as booking or requesting a quote, in a machine-readable form." },
+  { id: "content-extractability", name: "Content Extractability", weight: 6, bias: 5, found: "Main content is plain HTML that is easy to extract.", missing: "Main content is hard to extract from the page markup.", recommendation: "Keep the main content in plain HTML rather than scripts or images." },
+  { id: "definition-blocks", name: "Definition Blocks", weight: 6, bias: -6, found: "Key terms are defined in short, direct passages.", missing: "Key terms are not defined directly.", recommendation: "Add a short, direct definition of the main topic." },
+  { id: "named-entities", name: "Named Entities", weight: 6, bias: 1, found: "Products, places, and organizations are named specifically.", missing: "Few specific products, places, or organizations are named.", recommendation: "Name the specific products, places, and organizations involved." },
+  { id: "snippet-eligibility", name: "Snippet Eligibility", weight: 6, bias: -2, found: "A concise answer passage is available.", missing: "No concise answer passage was found.", recommendation: "Open with a two or three sentence answer to the main query." },
+  { id: "ai-access-files", name: "AI Access Files (llms.txt, sitemap)", weight: 5, bias: 8, found: "llms.txt and the sitemap are available.", missing: "AI access files are missing or incomplete.", recommendation: "Publish llms.txt and keep the sitemap current." },
+  { id: "schema-validity", name: "Schema Validity", weight: 5, bias: 7, found: "Structured data parses without errors.", missing: "Structured data has validation errors.", recommendation: "Fix the invalid structured data fields." },
+  { id: "technical-seo", name: "Technical SEO", weight: 5, bias: 6, found: "Title, description, and headings are in place.", missing: "The title or meta description needs attention.", recommendation: "Write a unique title and meta description." },
+  { id: "ai-crawler-access", name: "AI Crawler Access", weight: 4, bias: 9, found: "AI crawlers are allowed to fetch this page.", missing: "Some AI crawlers are blocked from this page.", recommendation: "Review the robots.txt rules for AI crawlers." }
+];
+var ROOT_PATH = "/";
+var BROKEN_STATUS = 404;
+var HTML_KINDS = /* @__PURE__ */ new Set(["html", "noindex", "canonicalized"]);
+function unitHash(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) / 4294967296;
+}
+function anchorText(path) {
+  if (path === ROOT_PATH) return "Home";
+  const segment = path.split("/").filter(Boolean).at(-1) ?? path;
+  if (segment.endsWith(".pdf")) return `${anchorText(`/${segment.slice(0, -4)}/`)} (PDF)`;
+  if (segment.includes(".")) return segment;
+  const words = segment.replaceAll("-", " ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function parentPath(path) {
+  if (path === ROOT_PATH) return ROOT_PATH;
+  const trimmed = path.endsWith("/") ? path.slice(0, -1) : path;
+  const slash = trimmed.lastIndexOf("/");
+  return slash <= 0 ? ROOT_PATH : `${trimmed.slice(0, slash)}/`;
+}
+function auditFactors(page) {
+  const totalWeight = DEMO_AUDIT_FACTORS.reduce((sum, factor) => sum + factor.weight, 0);
+  const offsets = DEMO_AUDIT_FACTORS.map((factor) => factor.bias + (unitHash(`${page.path}#${factor.id}`) * 2 - 1) * 12);
+  const meanOffset = DEMO_AUDIT_FACTORS.reduce((sum, factor, index) => sum + offsets[index] * factor.weight, 0) / totalWeight;
+  const factors = DEMO_AUDIT_FACTORS.map((factor, index) => {
+    const score2 = page.factorScores?.[factor.id] ?? Math.max(0, Math.min(100, Math.round(page.score + offsets[index] - meanOffset)));
+    const status = factorStatusFromScore(score2);
+    const passing = status === "pass";
+    return {
+      id: factor.id,
+      name: factor.name,
+      weight: factor.weight,
+      score: score2,
+      status,
+      applicable: true,
+      findings: [{ type: passing ? "found" : "missing", code: `${factor.id}.${passing ? "present" : "gap"}`, message: passing ? factor.found : factor.missing }],
+      recommendations: passing ? [] : [factor.recommendation]
+    };
+  });
+  const score = Math.round(factors.reduce((sum, factor) => sum + factor.score * factor.weight, 0) / totalWeight);
+  return { score, factors };
+}
+function buildDemoSiteCrawl(input) {
+  const { inventory, root, prefix, nowIso } = input;
+  const scope = { projectId: input.project.id, runId: input.crawlRunId, attemptId: input.attemptId };
+  const url = (path) => new URL(path, root).href;
+  const sitemapUrl = url("/sitemap.xml");
+  const pagesByPath = /* @__PURE__ */ new Map();
+  for (const page of inventory.pages) {
+    if (pagesByPath.has(page.path)) throw new Error(`Demo site inventory lists ${page.path} more than once`);
+    pagesByPath.set(page.path, page);
+  }
+  if (!pagesByPath.has(ROOT_PATH)) throw new Error("Demo site inventory has no root page");
+  const requirePage = (path, role) => {
+    if (!pagesByPath.has(path)) throw new Error(`Demo site ${role} ${path} is not a page in the inventory`);
+  };
+  const requireIndexable = (from, relation, target) => {
+    if (pagesByPath.get(target)?.kind !== "html") {
+      throw new Error(`Demo site page ${from} ${relation} ${target}, which is not an indexable HTML page`);
+    }
+  };
+  for (const page of inventory.pages) {
+    if (page.kind === "redirect") requireIndexable(page.path, "redirects to", page.redirectTo);
+    if (page.kind === "canonicalized") requireIndexable(page.path, "declares its canonical as", page.canonicalTo);
+  }
+  const drafts = /* @__PURE__ */ new Map();
+  const observe = (source, target, placement) => {
+    requirePage(source, "link source");
+    requirePage(target, "link target");
+    if (!HTML_KINDS.has(pagesByPath.get(source).kind)) {
+      throw new Error(`Demo site link source ${source} is not an HTML page, so no crawl could record links from it`);
+    }
+    if (source === target) return;
+    const key = `${source}->${target}`;
+    let draft = drafts.get(key);
+    if (!draft) {
+      draft = { source, target, navigation: 0, content: 0, anchors: /* @__PURE__ */ new Set() };
+      drafts.set(key, draft);
+    }
+    draft[placement]++;
+    draft.anchors.add(anchorText(target));
+  };
+  for (const target of inventory.templateLinks) requirePage(target, "menu or footer link target");
+  for (const page of inventory.pages) {
+    if (!HTML_KINDS.has(page.kind)) continue;
+    for (const target of inventory.templateLinks) observe(page.path, target, "navigation");
+  }
+  for (const [source, target, placement = "content"] of inventory.links) observe(source, target, placement);
+  const edges = [...drafts.entries()].map(([edgeKey, draft]) => {
+    const occurrences = draft.navigation + draft.content;
+    return {
+      ...scope,
+      id: `${prefix}-edge-${edgeKey}`,
+      edgeKey,
+      sourceNodeKey: draft.source,
+      sourceUrl: url(draft.source),
+      targetNodeKey: draft.target,
+      targetUrl: url(draft.target),
+      relation: "anchor",
+      internal: true,
+      followable: true,
+      occurrences,
+      followableOccurrences: occurrences,
+      nofollowOccurrences: 0,
+      anchors: [...draft.anchors],
+      isTemplate: placementLinkDecision({ navigation: draft.navigation, content: draft.content, unknown: 0 }) === "navigation",
+      templateRatio: null,
+      placementNavigationOccurrences: draft.navigation,
+      placementContentOccurrences: draft.content,
+      placementUnknownOccurrences: 0,
+      createdAt: nowIso,
+      updatedAt: nowIso
+    };
+  });
+  const inbound = /* @__PURE__ */ new Map();
+  const outbound = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    inbound.set(edge.targetNodeKey, [...inbound.get(edge.targetNodeKey) ?? [], edge]);
+    outbound.set(edge.sourceNodeKey, [...outbound.get(edge.sourceNodeKey) ?? [], edge]);
+  }
+  const inSitemap = (page) => page.sitemap ?? page.kind === "html";
+  for (const page of inventory.pages) {
+    if (page.path !== ROOT_PATH && !inbound.has(page.path) && !inSitemap(page)) {
+      throw new Error(`Demo site page ${page.path} has no inbound link and is not in the sitemap, so no crawl could find it`);
+    }
+  }
+  const depths = /* @__PURE__ */ new Map([[ROOT_PATH, 0]]);
+  for (const queue = [ROOT_PATH]; queue.length > 0; ) {
+    const from = queue.shift();
+    for (const edge of outbound.get(from) ?? []) {
+      if (depths.has(edge.targetNodeKey)) continue;
+      depths.set(edge.targetNodeKey, depths.get(from) + 1);
+      queue.push(edge.targetNodeKey);
+    }
+  }
+  const htmlPaths = inventory.pages.filter((page) => HTML_KINDS.has(page.kind)).map((page) => page.path).sort();
+  const rankIndex = new Map(htmlPaths.map((path, index) => [path, index]));
+  const rankTargets = htmlPaths.map((path) => (outbound.get(path) ?? []).map((edge) => rankIndex.get(edge.targetNodeKey)).filter((index) => index !== void 0));
+  let ranks = htmlPaths.map(() => 1 / htmlPaths.length);
+  for (let iteration = 0; iteration < 50; iteration++) {
+    const next = htmlPaths.map(() => 0.15 / htmlPaths.length);
+    let dangling = 0;
+    for (const [index, targets] of rankTargets.entries()) {
+      if (targets.length === 0) dangling += ranks[index];
+      for (const target of targets) next[target] += 0.85 * ranks[index] / targets.length;
+    }
+    ranks = next.map((value) => value + 0.85 * dangling / htmlPaths.length);
+  }
+  const maxInbound = Math.max(1, ...[...inbound.values()].map((edges2) => edges2.length));
+  const firstInbound = (path) => inbound.get(path)?.[0]?.sourceUrl ?? null;
+  const pages = inventory.pages.map((page) => {
+    const fetchState = page.kind === "broken" ? SiteCrawlFetchStates.fetchError : page.kind === "redirect" ? SiteCrawlFetchStates.redirect : page.kind === "resource" ? SiteCrawlFetchStates.nonHtml : SiteCrawlFetchStates.html;
+    const indexabilityState = page.kind === "html" ? SiteCrawlIndexabilityStates.indexable : page.kind === "noindex" ? SiteCrawlIndexabilityStates.noindex : SiteCrawlIndexabilityStates.unknown;
+    const indexabilityReasons = page.kind === "html" ? [] : page.kind === "noindex" ? [SiteCrawlIndexabilityReasons.metaRobotsNoindex] : page.kind === "canonicalized" ? [SiteCrawlIndexabilityReasons.canonicalToOther] : page.kind === "redirect" ? [SiteCrawlIndexabilityReasons.redirectTerminal] : [SiteCrawlIndexabilityReasons.notHtmlOrUnavailable];
+    const canonicalNodeKey = page.kind === "canonicalized" ? page.canonicalTo : HTML_KINDS.has(page.kind) ? page.path : null;
+    const audit = "score" in page ? auditFactors(page) : null;
+    const inboundEdges = inbound.get(page.path) ?? [];
+    const outboundEdges = outbound.get(page.path) ?? [];
+    const rank = rankIndex.has(page.path) ? ranks[rankIndex.get(page.path)] : 0;
+    const sitemapSources = inSitemap(page) ? [sitemapUrl] : [];
+    return {
+      ...scope,
+      id: `${prefix}-page-${page.path}`,
+      nodeKey: page.path,
+      url: url(page.path),
+      path: page.path,
+      parentPath: parentPath(page.path),
+      discoverySource: page.path === ROOT_PATH ? "root" : sitemapSources.length > 0 ? "sitemap" : "link",
+      discoveryProvenance: [{ discoveredFrom: firstInbound(page.path), sitemapSources, root: page.path === ROOT_PATH }],
+      sitemapMetadata: { sources: sitemapSources },
+      fetchState,
+      fetchedAt: nowIso,
+      httpStatus: page.kind === "broken" ? BROKEN_STATUS : page.kind === "redirect" ? 301 : 200,
+      contentType: page.kind === "resource" ? page.contentType : page.kind === "redirect" ? null : "text/html; charset=utf-8",
+      finalUrl: url(page.kind === "redirect" ? page.redirectTo : page.path),
+      redirectChain: page.kind === "redirect" ? [url(page.redirectTo)] : [],
+      directives: { metaRobots: page.kind === "noindex" ? ["follow", "noindex"] : [], xRobots: [] },
+      canonicalUrl: canonicalNodeKey ? url(canonicalNodeKey) : null,
+      canonicalNodeKey,
+      indexabilityState,
+      indexabilityReasons,
+      healthState: deriveSiteHealthState({ nodeKey: page.path, fetchState, indexabilityState, indexabilityReasons, canonicalNodeKey }),
+      auditState: audit ? "success" : page.kind === "broken" ? "error" : "not-applicable",
+      auditScore: audit?.score ?? null,
+      auditFields: audit ? { schemaVersion: "1.0", factors: audit.factors, criticalDefects: [] } : {},
+      inventoryEligible: page.kind === "html",
+      depth: depths.get(page.path) ?? null,
+      inboundUniqueEdges: inboundEdges.length,
+      outboundUniqueEdges: outboundEdges.length,
+      inboundOccurrences: inboundEdges.reduce((sum, edge) => sum + edge.occurrences, 0),
+      outboundOccurrences: outboundEdges.reduce((sum, edge) => sum + edge.occurrences, 0),
+      // Raw score is PageRank, as the crawler computes it. Node size reads the normalized value on a 0 to 1
+      // log scale of inbound links, so hub pages stay visibly larger than the pages they link to.
+      linkScoreRaw: Number(rank.toFixed(12)),
+      linkScoreNormalized: Math.log1p(inboundEdges.length) / Math.log1p(maxInbound),
+      createdAt: nowIso,
+      updatedAt: nowIso
+    };
+  });
+  const findings = edges.flatMap((edge) => pagesByPath.get(edge.targetNodeKey)?.kind === "broken" ? [{
+    ...scope,
+    id: `${prefix}-finding-${edge.edgeKey}`,
+    findingKey: `dead-link:${edge.edgeKey}`,
+    findingType: "dead-link",
+    severity: "error",
+    sourceNodeKey: edge.sourceNodeKey,
+    sourceUrl: edge.sourceUrl,
+    targetNodeKey: edge.targetNodeKey,
+    targetUrl: edge.targetUrl,
+    evidence: { statusCode: BROKEN_STATUS, reason: "http-error" },
+    createdAt: nowIso,
+    updatedAt: nowIso
+  }] : []);
+  const counts = {
+    pagesDiscovered: pages.length,
+    pagesFetched: pages.length,
+    pagesEligible: pages.filter((page) => page.inventoryEligible).length,
+    pagesErrored: pages.filter((page) => page.fetchState === SiteCrawlFetchStates.fetchError).length,
+    edgesDiscovered: edges.length
+  };
+  const attempt = {
+    ...scope,
+    id: input.attemptId,
+    attemptNumber: 1,
+    state: "completed",
+    lastEventSequence: pages.length + edges.length + findings.length + 1,
+    ...counts,
+    startedAt: nowIso,
+    finishedAt: nowIso,
+    createdAt: nowIso,
+    updatedAt: nowIso
+  };
+  const pageBudget = Math.max(1e3, pages.length);
+  const edgeBudget = Math.max(5e3, edges.length);
+  const snapshot = {
+    ...scope,
+    id: `${prefix}-crawl-snapshot`,
+    rootUrl: root,
+    requestedRootUrl: root,
+    crawlSchemaVersion: "demo-2",
+    engineVersion: "sample-seed",
+    normalizationVersion: "demo-1",
+    indexabilityVersion: "demo-1",
+    linkScoreVersion: "demo-1",
+    effectiveOptions: { mode: "summary", sitemapUrl, maxPages: pageBudget, maxEdges: edgeBudget, maxDepth: null, checkDeadLinks: true, sampleData: true },
+    pageBudget,
+    edgeBudget,
+    maxDepth: null,
+    checkDeadLinks: true,
+    complete: true,
+    termination: "complete",
+    detailsAvailable: true,
+    ...counts,
+    findingsCount: findings.length,
+    deadLinkState: "complete",
+    deadLinksChecked: new Set(edges.map((edge) => edge.targetNodeKey)).size,
+    deadLinksFound: findings.length,
+    deadLinksUnverified: 0,
+    templateDetection: "applied-placement",
+    linkPlacementRulesetVersion: "demo-1",
+    createdAt: nowIso,
+    updatedAt: nowIso
+  };
+  const order = [...pages].sort((left, right) => Number(right.nodeKey === ROOT_PATH) - Number(left.nodeKey === ROOT_PATH) || right.linkScoreNormalized - left.linkScoreNormalized || (left.nodeKey < right.nodeKey ? -1 : 1));
+  const layoutEdges = [...edges].sort((left, right) => right.occurrences - left.occurrences || (left.edgeKey < right.edgeKey ? -1 : 1));
+  const layoutInput = {
+    rootNodeKey: ROOT_PATH,
+    totalNodes: pages.length,
+    totalEdges: edges.length,
+    totalTemplateEdges: edges.filter((edge) => edge.isTemplate).length,
+    nodes: order.map((page, sampleRank) => ({ nodeKey: page.nodeKey, path: page.path, depth: page.depth ?? null, sampleRank })),
+    edges: layoutEdges.map((edge) => ({
+      edgeKey: edge.edgeKey,
+      sourceNodeKey: edge.sourceNodeKey,
+      targetNodeKey: edge.targetNodeKey,
+      followable: true,
+      occurrences: edge.occurrences,
+      isTemplate: edge.isTemplate
+    }))
+  };
+  return { pages, edges, findings, attempt, snapshot, layoutInput };
+}
+async function seedSiteCrawl(db, input) {
+  const crawl = buildDemoSiteCrawl(input);
+  db.transaction((tx) => {
+    tx.insert(siteCrawlAttempts).values(crawl.attempt).run();
+    tx.insert(siteCrawlSnapshots).values(crawl.snapshot).run();
+    for (let i = 0; i < crawl.pages.length; i += 100) tx.insert(siteCrawlPages).values(crawl.pages.slice(i, i + 100)).run();
+    for (let i = 0; i < crawl.edges.length; i += 250) tx.insert(siteCrawlEdges).values(crawl.edges.slice(i, i + 250)).run();
+    if (crawl.findings.length > 0) tx.insert(siteCrawlFindings).values(crawl.findings).run();
+  });
+  const layout = await layoutSiteCrawlGraphInput(crawl.layoutInput);
+  if (layout.state !== "ready") throw new Error(`Demo site map for ${input.project.name} is unavailable: ${layout.failureCode}`);
+  persistSiteCrawlGraphLayout(db, { projectId: input.project.id, runId: input.crawlRunId, attemptId: input.attemptId }, layout, input.nowIso);
+  return { ...crawl, layout };
+}
+
+// src/demo/site-inventories/harbor-resorts.ts
+var SECTIONS = [
+  ["rooms", ["ocean-suite", "family-suite", "garden-studio", "accessible-suite", "penthouse", "two-bedroom-villa", "king-room", "connecting-rooms"]],
+  ["dining", ["waterfront-grill", "poolside-cafe", "lobby-bar", "breakfast", "private-dining"]],
+  ["amenities", ["pool", "spa", "fitness-center", "beach", "kids-club", "pet-friendly-stays"]],
+  ["experiences", ["kayaking", "sunset-cruise", "local-food-tour", "nature-trails", "art-walk", "family-activities"]],
+  ["offers", ["family-getaway", "weekend-escape", "extended-stay", "spa-retreat"]],
+  ["meetings", ["ballroom", "boardroom", "waterfront-terrace"]]
+];
+var GUIDE_TOPICS = ["getting-here", "family-travel", "seasonal-events", "local-restaurants", "weekend-itinerary"];
+function parentOf(path) {
+  const parts = path.split("/").filter(Boolean);
+  return parts.length > 1 ? `/${parts.slice(0, -1).join("/")}/` : "/";
+}
+function harborResortsInventory() {
+  const pages = [];
+  const links = [];
+  const html = (path, score = 92) => pages.push({ path, kind: "html", score });
+  const content = (source, target) => links.push([source, target, "content"]);
+  for (const path of ["/", "/destinations/", "/offers/", "/experiences/", "/guides/", "/contact/", "/services/"]) html(path);
+  for (const market of HARBOR_MARKETS) {
+    html(`/destinations/${market.key}/`);
+    html(`/destinations/${market.key}/guides/`);
+    for (const topic of GUIDE_TOPICS) html(`/destinations/${market.key}/guides/${topic}/`, 82);
+    content("/guides/", `/destinations/${market.key}/guides/`);
+  }
+  const properties = harborProperties();
+  for (const [propertyIndex, property] of properties.entries()) {
+    const home = `${property.path}/`;
+    html(home, 94);
+    for (const [sectionIndex, [section, topics]] of SECTIONS.entries()) {
+      html(`${home}${section}/`, 88 - propertyIndex % 5);
+      for (const [topicIndex, topic] of topics.entries()) {
+        const pagePath = `${home}${section}/${topic}/`;
+        html(pagePath, 94 - (propertyIndex * 7 + sectionIndex * 3 + topicIndex * 9) % 39);
+        content(pagePath, `${home}${section}/${topics[(topicIndex + 1) % topics.length]}/`);
+        content(pagePath, `${home}${section}/${topics[(topicIndex + 2) % topics.length]}/`);
+        content(pagePath, `${home}offers/family-getaway/`);
+        content(pagePath, `${home}amenities/spa/`);
+      }
+    }
+    for (const section of ["gallery", "location", "faq", "reviews", "contact"]) html(`${home}${section}/`, 86);
+    pages.push(
+      { path: `${home}booking-confirmation/`, kind: "noindex", score: 90 },
+      { path: `${home}offers/expired-summer-package/`, kind: "broken" },
+      { path: `${home}property-guide.pdf`, kind: "resource", contentType: "application/pdf" },
+      { path: `${home}rooms/old-ocean-suite/`, kind: "redirect", redirectTo: `${home}rooms/ocean-suite/` }
+    );
+    content("/offers/", `${home}offers/`);
+    const siblings = properties.filter((candidate) => candidate.market.key === property.market.key);
+    content(home, `${siblings[property.number % siblings.length].path}/`);
+    content(`/destinations/${property.market.key}/guides/family-travel/`, home);
+  }
+  for (const page of pages) {
+    const parent = parentOf(page.path);
+    if (page.path !== "/") content(parent, page.path);
+    if (page.kind === "broken" || page.kind === "resource" || page.kind === "redirect") continue;
+    links.push([page.path, "/", "navigation"], [page.path, parent, "navigation"]);
+    const property = properties.find((candidate) => page.path.startsWith(`${candidate.path}/`));
+    if (property) links.push([page.path, `${property.path}/`, "navigation"]);
+  }
+  return { pages, templateLinks: [], links };
+}
+
+// src/demo/site-inventories/summit-roofing.ts
+var SERVICES = [
+  ["roof-replacement", ["asphalt-shingles", "metal-roofing", "tile-roofing", "flat-roofing", "cedar-shake"]],
+  ["roof-repair", ["leak-repair", "storm-damage", "emergency-tarping", "flashing-repair", "shingle-replacement"]],
+  ["roof-inspection", ["drone-inspection", "insurance-claims", "real-estate-inspection"]],
+  ["gutters", ["seamless-gutters", "gutter-guards", "downspouts"]],
+  ["skylights", ["skylight-installation", "skylight-repair"]],
+  ["commercial-roofing", ["tpo-roofing", "epdm-roofing", "roof-coatings"]],
+  ["siding", ["vinyl-siding", "fiber-cement-siding"]]
+];
+var TOWNS = [
+  "alder-creek",
+  "birch-hollow",
+  "cedar-bluff",
+  "copper-ridge",
+  "elm-crossing",
+  "fox-meadow",
+  "hawthorn-glen",
+  "ironwood-flats",
+  "juniper-springs",
+  "kestrel-point",
+  "larkspur-hills",
+  "millbrook",
+  "north-quarry",
+  "oak-terrace",
+  "pine-hollow",
+  "quail-run",
+  "redfern",
+  "stonegate",
+  "thistle-ridge",
+  "upper-brookside",
+  "vale-junction",
+  "willow-bend",
+  "yarrow-heights",
+  "zephyr-lake"
+];
+var TOWN_SERVICES = ["roof-replacement", "roof-repair", "gutters"];
+var PROJECT_TYPES = [
+  ["metal-roof-replacement", "roof-replacement", "metal-roofing"],
+  ["asphalt-shingle-roof", "roof-replacement", "asphalt-shingles"],
+  ["storm-damage-repair", "roof-repair", "storm-damage"],
+  ["seamless-gutter-install", "gutters", "seamless-gutters"],
+  ["skylight-replacement", "skylights", "skylight-installation"],
+  ["tpo-commercial-roof", "commercial-roofing", "tpo-roofing"],
+  ["cedar-shake-restoration", "roof-replacement", "cedar-shake"],
+  ["fiber-cement-siding", "siding", "fiber-cement-siding"],
+  ["emergency-leak-repair", "roof-repair", "leak-repair"]
+];
+var GUIDE_TOPICS2 = ["materials", "repair", "insurance", "maintenance", "costs", "commercial"];
+var GUIDES = [
+  ["how-much-does-a-roof-replacement-cost", "roof-replacement", "costs"],
+  ["signs-you-need-a-new-roof", "roof-replacement", "maintenance"],
+  ["metal-vs-asphalt-shingles", "roof-replacement", "materials"],
+  ["how-long-does-a-roof-last", "roof-replacement", "materials"],
+  ["roof-repair-vs-replacement", "roof-repair", "costs"],
+  ["what-to-do-after-hail-damage", "roof-repair", "insurance"],
+  ["filing-a-roof-insurance-claim", "roof-inspection", "insurance"],
+  ["choosing-a-roofing-contractor", "roof-replacement", "costs"],
+  ["ice-dam-prevention", "roof-repair", "maintenance"],
+  ["how-to-spot-a-roof-leak", "roof-repair", "repair"],
+  ["attic-ventilation-basics", "roof-replacement", "maintenance"],
+  ["flat-roof-materials-compared", "commercial-roofing", "materials"],
+  ["tpo-vs-epdm", "commercial-roofing", "commercial"],
+  ["gutter-guard-types", "gutters", "maintenance"],
+  ["when-to-replace-gutters", "gutters", "repair"],
+  ["skylight-leak-causes", "skylights", "repair"],
+  ["cedar-shake-maintenance", "roof-replacement", "maintenance"],
+  ["tile-roof-lifespan", "roof-replacement", "materials"],
+  ["roof-inspection-checklist", "roof-inspection", "maintenance"],
+  ["what-a-roof-warranty-covers", "roof-replacement", "costs"],
+  ["financing-a-new-roof", "roof-replacement", "costs"],
+  ["storm-season-preparation", "roof-repair", "insurance"],
+  ["emergency-tarping-what-to-expect", "roof-repair", "repair"],
+  ["roof-flashing-explained", "roof-repair", "repair"],
+  ["shingle-color-and-energy-costs", "roof-replacement", "materials"],
+  ["roof-coatings-for-commercial-buildings", "commercial-roofing", "commercial"],
+  ["vinyl-vs-fiber-cement-siding", "siding", "materials"],
+  ["how-drone-roof-inspections-work", "roof-inspection", "insurance"],
+  ["preparing-for-roof-replacement-day", "roof-replacement", "costs"],
+  ["roof-replacement-timeline", "roof-replacement", "costs"],
+  ["moss-and-algae-removal", "roof-repair", "maintenance"],
+  ["chimney-flashing-repair", "roof-repair", "repair"],
+  ["roof-underlayment-types", "roof-replacement", "materials"],
+  ["solar-ready-roofing", "roof-replacement", "materials"],
+  ["commercial-roof-maintenance-plans", "commercial-roofing", "commercial"],
+  ["downspout-drainage-tips", "gutters", "maintenance"],
+  ["real-estate-roof-inspections", "roof-inspection", "insurance"],
+  ["winter-roof-care", "roof-repair", "maintenance"],
+  ["wind-damage-signs", "roof-repair", "insurance"],
+  ["roof-pitch-explained", "roof-replacement", "materials"],
+  ["recycling-old-shingles", "roof-replacement", "materials"],
+  ["metal-roof-noise", "roof-replacement", "materials"],
+  ["what-to-ask-before-signing", "roof-replacement", "costs"],
+  ["skylight-sizing-guide", "skylights", "materials"]
+];
+var HEADER = ["/", "/services/", "/service-areas/", "/projects/", "/reviews/", "/financing/", "/about/", "/contact/", "/get-a-quote/"];
+var FOOTER = [
+  "/services/roof-replacement/",
+  "/services/roof-repair/",
+  "/services/gutters/",
+  "/services/commercial-roofing/",
+  "/guides/",
+  "/about/warranty/",
+  "/careers/",
+  "/contact/",
+  "/privacy-policy/",
+  "/terms/",
+  "/accessibility/"
+];
+var ORPHAN_TOWN_SERVICE = `/service-areas/${TOWNS[5]}/gutters/`;
+var THIN_TOWN_SERVICES = /* @__PURE__ */ new Set([
+  `/service-areas/${TOWNS[2]}/roof-repair/`,
+  `/service-areas/${TOWNS[3]}/gutters/`,
+  `/service-areas/${TOWNS[4]}/roof-repair/`,
+  `/service-areas/${TOWNS[5]}/roof-replacement/`
+]);
+var THIN_PROJECTS = /* @__PURE__ */ new Set([8, 19, 30]);
+var service = (key) => `/services/${key}/`;
+var town = (key) => `/service-areas/${key}/`;
+var guide = (slug) => `/guides/${slug}/`;
+function summitRoofingInventory() {
+  const pages = [];
+  const links = [];
+  const link = (source, ...targets) => {
+    for (const target of targets) links.push([source, target]);
+  };
+  const projects2 = Array.from({ length: 36 }, (_, index) => {
+    const [type, category, sub] = PROJECT_TYPES[index % PROJECT_TYPES.length];
+    const townKey = TOWNS[index % TOWNS.length];
+    return { index, path: `/projects/${townKey}-${type}/`, townKey, category, sub };
+  });
+  pages.push(
+    { path: "/", kind: "html", score: 88 },
+    { path: "/llms.txt", kind: "resource", contentType: "text/plain; charset=utf-8", sitemap: true },
+    { path: "/services/", kind: "html", score: 84 }
+  );
+  link(
+    "/",
+    ...SERVICES.map(([key]) => service(key)),
+    "/service-areas/",
+    ...projects2.slice(0, 3).map((project) => project.path),
+    guide(GUIDES[0][0]),
+    guide(GUIDES[2][0]),
+    guide(GUIDES[5][0]),
+    "/reviews/",
+    "/financing/",
+    "/get-a-quote/"
+  );
+  link("/services/", ...SERVICES.map(([key]) => service(key)), "/service-areas/");
+  for (const [categoryIndex, [category, subs]] of SERVICES.entries()) {
+    pages.push({ path: service(category), kind: "html", score: 86 - categoryIndex * 2 });
+    const categoryGuides = GUIDES.filter(([, key]) => key === category);
+    const categoryProjects = projects2.filter((project) => project.category === category);
+    link(
+      service(category),
+      ...subs.map((sub) => service(`${category}/${sub}`)),
+      "/get-a-quote/",
+      "/financing/",
+      ...categoryGuides.slice(0, 2).map(([slug]) => guide(slug)),
+      ...categoryProjects.slice(0, 2).map((project) => project.path)
+    );
+    for (const [subIndex, sub] of subs.entries()) {
+      const path = service(`${category}/${sub}`);
+      pages.push({ path, kind: "html", score: 83 - (subIndex * 7 + categoryIndex * 3) % 17 });
+      const project = categoryProjects.find((candidate) => candidate.sub === sub) ?? categoryProjects.at(0);
+      link(path, service(category), service(`${category}/${subs[(subIndex + 1) % subs.length]}`), "/get-a-quote/");
+      if (project) link(path, project.path);
+      const related = categoryGuides.at(subIndex % Math.max(1, categoryGuides.length));
+      if (related) link(path, guide(related[0]));
+    }
+  }
+  pages.push({ path: "/service-areas/", kind: "html", score: 78 });
+  link("/service-areas/", ...TOWNS.map(town));
+  for (const [townIndex, townKey] of TOWNS.entries()) {
+    pages.push({ path: town(townKey), kind: "html", score: 76 - townIndex % 6 * 2, factorScores: { "geographic-signals": 92 } });
+    link(
+      town(townKey),
+      service("roof-replacement"),
+      service("roof-repair"),
+      service("gutters"),
+      service("roof-inspection"),
+      town(TOWNS[(townIndex + 1) % TOWNS.length]),
+      ...projects2.filter((project) => project.townKey === townKey).map((project) => project.path),
+      "/reviews/",
+      "/get-a-quote/"
+    );
+    if (townIndex >= 6) continue;
+    for (const serviceKey of TOWN_SERVICES) {
+      const path = `${town(townKey)}${serviceKey}/`;
+      const thin = THIN_TOWN_SERVICES.has(path);
+      pages.push({ path, kind: "html", score: thin ? 58 : 72, factorScores: thin ? { "content-depth": 34, "geographic-signals": 88 } : { "geographic-signals": 94 } });
+      link(path, town(townKey), service(serviceKey), "/get-a-quote/");
+      if (path !== ORPHAN_TOWN_SERVICE) link(town(townKey), path);
+    }
+  }
+  pages.push({ path: "/projects/", kind: "html", score: 80 });
+  link("/projects/", ...projects2.map((project) => project.path));
+  for (const project of projects2) {
+    const thin = THIN_PROJECTS.has(project.index);
+    pages.push({ path: project.path, kind: "html", score: thin ? 60 : 77 - project.index % 7 * 2, factorScores: thin ? { "content-depth": 31 } : void 0 });
+    link(
+      project.path,
+      service(project.category),
+      service(`${project.category}/${project.sub}`),
+      town(project.townKey),
+      projects2[(project.index + 1) % projects2.length].path,
+      "/get-a-quote/",
+      "/reviews/"
+    );
+  }
+  pages.push(
+    { path: "/guides/", kind: "html", score: 83 },
+    { path: "/guides/page/2/", kind: "canonicalized", canonicalTo: "/guides/", score: 72 },
+    { path: "/guides/page/3/", kind: "canonicalized", canonicalTo: "/guides/", score: 70 },
+    { path: "/guides/topic/", kind: "noindex", score: 70 },
+    { path: "/guides/roof-maintenance-checklist.pdf", kind: "resource", contentType: "application/pdf" }
+  );
+  link("/guides/", ...GUIDES.slice(0, 20).map(([slug]) => guide(slug)), "/guides/page/2/", "/guides/topic/");
+  link("/guides/page/2/", ...GUIDES.slice(20, 40).map(([slug]) => guide(slug)), "/guides/", "/guides/page/3/");
+  link("/guides/page/3/", ...GUIDES.slice(40).map(([slug]) => guide(slug)), "/guides/page/2/");
+  link("/guides/topic/", ...GUIDE_TOPICS2.map((topic) => `/guides/topic/${topic}/`));
+  for (const topic of GUIDE_TOPICS2) {
+    pages.push({ path: `/guides/topic/${topic}/`, kind: "noindex", score: 68 });
+    link(`/guides/topic/${topic}/`, "/guides/", ...GUIDES.filter(([, , guideTopic]) => guideTopic === topic).map(([slug]) => guide(slug)));
+  }
+  for (const [guideIndex, [slug, serviceKey, topic]] of GUIDES.entries()) {
+    const noAuthor = guideIndex % 5 === 4;
+    pages.push({ path: guide(slug), kind: "html", score: 81 - guideIndex % 6 * 3, factorScores: noAuthor ? { "eeat-signals": 28 } : void 0 });
+    link(guide(slug), service(serviceKey), guide(GUIDES[(guideIndex + 1) % GUIDES.length][0]), `/guides/topic/${topic}/`, "/get-a-quote/");
+  }
+  link(guide(GUIDES[18][0]), "/guides/roof-maintenance-checklist.pdf");
+  link(guide("what-a-roof-warranty-covers"), "/about/warranty/");
+  pages.push(
+    { path: "/financing/", kind: "html", score: 79 },
+    { path: "/financing/apply/", kind: "html", score: 71 },
+    { path: "/financing/faq/", kind: "html", score: 86, factorScores: { "faq-content": 95 } },
+    { path: "/financing/financing-terms.pdf", kind: "resource", contentType: "application/pdf" },
+    { path: "/reviews/", kind: "html", score: 85 },
+    { path: "/reviews/leave-a-review/", kind: "noindex", score: 60 },
+    { path: "/about/", kind: "html", score: 82 },
+    { path: "/about/team/", kind: "html", score: 80, factorScores: { "eeat-signals": 93 } },
+    { path: "/about/certifications/", kind: "html", score: 83 },
+    { path: "/about/warranty/", kind: "html", score: 81 },
+    { path: "/about/community/", kind: "html", score: 72 },
+    { path: "/about/warranty/warranty-guide.pdf", kind: "resource", contentType: "application/pdf" },
+    { path: "/careers/", kind: "html", score: 70 },
+    { path: "/careers/roofing-crew-lead/", kind: "html", score: 66 },
+    { path: "/careers/project-manager/", kind: "html", score: 67 },
+    { path: "/careers/sales-estimator/", kind: "html", score: 65 },
+    { path: "/contact/", kind: "html", score: 84 },
+    { path: "/contact/thank-you/", kind: "noindex", score: 50 },
+    { path: "/get-a-quote/", kind: "html", score: 80 },
+    { path: "/get-a-quote/roof-details/", kind: "noindex", score: 62 },
+    { path: "/get-a-quote/schedule/", kind: "noindex", score: 62 },
+    { path: "/get-a-quote/thank-you/", kind: "noindex", score: 50 },
+    { path: "/privacy-policy/", kind: "html", score: 64 },
+    { path: "/terms/", kind: "html", score: 63 },
+    { path: "/accessibility/", kind: "html", score: 69 }
+  );
+  link("/financing/", "/financing/apply/", "/financing/faq/", "/financing/financing-terms.pdf", "/get-a-quote/");
+  link("/financing/faq/", "/financing/apply/");
+  link("/reviews/", "/reviews/leave-a-review/", ...projects2.slice(0, 6).map((project) => project.path));
+  link("/about/", "/about/team/", "/about/certifications/", "/about/warranty/", "/about/community/", "/reviews/");
+  link("/about/warranty/", "/about/warranty/warranty-guide.pdf", guide("what-a-roof-warranty-covers"));
+  link("/about/certifications/", service("roof-replacement"));
+  link("/about/community/", "/projects/");
+  link("/careers/", "/careers/roofing-crew-lead/", "/careers/project-manager/", "/careers/sales-estimator/");
+  for (const role of ["roofing-crew-lead", "project-manager", "sales-estimator"]) link(`/careers/${role}/`, "/careers/");
+  link("/contact/", "/contact/thank-you/");
+  link("/get-a-quote/", "/get-a-quote/roof-details/", "/financing/");
+  link("/get-a-quote/roof-details/", "/get-a-quote/schedule/");
+  link("/get-a-quote/schedule/", "/get-a-quote/thank-you/");
+  pages.push(
+    { path: "/roof-repair/", kind: "redirect", redirectTo: service("roof-repair") },
+    { path: "/blog/", kind: "redirect", redirectTo: "/guides/" },
+    { path: "/services/metal-roofs/", kind: "redirect", redirectTo: service("roof-replacement/metal-roofing") },
+    { path: "/guides/ice-dam-prevention-2023/", kind: "redirect", redirectTo: guide("ice-dam-prevention") },
+    { path: "/service-areas/old-county/", kind: "redirect", redirectTo: "/service-areas/" },
+    { path: "/free-estimate/", kind: "redirect", redirectTo: "/get-a-quote/" }
+  );
+  link(service("roof-repair/leak-repair"), "/roof-repair/");
+  link(guide("how-to-spot-a-roof-leak"), "/roof-repair/");
+  link(guide("signs-you-need-a-new-roof"), "/blog/");
+  link(guide("roof-repair-vs-replacement"), "/blog/");
+  link(guide("metal-vs-asphalt-shingles"), "/services/metal-roofs/");
+  link(guide("winter-roof-care"), "/guides/ice-dam-prevention-2023/");
+  link(town(TOWNS.at(-1)), "/service-areas/old-county/");
+  link(projects2[0].path, "/free-estimate/");
+  link("/financing/faq/", "/free-estimate/");
+  pages.push(
+    { path: "/careers/estimator-2025/", kind: "broken" },
+    { path: "/financing/spring-promo/", kind: "broken" },
+    { path: "/guides/hail-season-update/", kind: "broken" },
+    { path: `/projects/${TOWNS[2]}-reroof-draft/`, kind: "broken" }
+  );
+  link("/careers/", "/careers/estimator-2025/");
+  link("/financing/", "/financing/spring-promo/");
+  link(guide("what-to-do-after-hail-damage"), "/guides/hail-season-update/");
+  link(guide("storm-season-preparation"), "/guides/hail-season-update/");
+  link("/projects/", `/projects/${TOWNS[2]}-reroof-draft/`);
+  pages.push(
+    { path: "/spring-roof-special/", kind: "html", score: 52, factorScores: { "content-freshness": 18 } },
+    { path: "/guides/choosing-roof-color/", kind: "html", score: 74 }
+  );
+  link("/spring-roof-special/", "/get-a-quote/");
+  link("/guides/choosing-roof-color/", service("roof-replacement"));
+  return { pages, templateLinks: [...HEADER, ...FOOTER], links };
+}
+
+// src/demo/seed-signals.ts
+var day = (at2, offset) => {
+  const value = new Date(at2);
+  value.setUTCDate(value.getUTCDate() + offset);
+  return value.toISOString().slice(0, 10);
+};
+var at = (date) => `${date}T12:00:00.000Z`;
+async function seedDemoSignals(db, context) {
+  for (const [index, project] of [context.simple, context.portfolio].entries()) {
+    await seedProjectSignals(db, project, context.now, index);
+  }
+}
+async function seedProjectSignals(db, project, now, variant) {
+  const nowIso = now.toISOString();
+  const prefix = `demo-signals-${project.id}`;
+  const syncRunId = `${prefix}-sync`;
+  const crawlRunId = `${prefix}-crawl`;
+  const root = `https://${project.domain}/`;
+  const attemptId = `${prefix}-crawl-attempt`;
+  const campaignId = `${prefix}-campaign`;
+  const groupId = `${prefix}-ad-group`;
+  const locationName = `locations/demo-${variant + 1}`;
+  db.insert(runs).values([
+    { id: syncRunId, projectId: project.id, kind: "data-refresh", status: "completed", trigger: "manual", startedAt: nowIso, finishedAt: nowIso, createdAt: nowIso },
+    { id: crawlRunId, projectId: project.id, kind: "site-audit", status: "completed", trigger: "manual", startedAt: nowIso, finishedAt: nowIso, createdAt: nowIso }
+  ]).run();
+  db.insert(googleConnections).values({ id: `${prefix}-gsc`, domain: project.domain, connectionType: "gsc", propertyId: `sc-domain:${project.domain}`, scopes: [], createdByProjectId: project.id, createdAt: nowIso, updatedAt: nowIso }).run();
+  db.insert(bingConnections).values({ id: `${prefix}-bing`, domain: project.domain, siteUrl: root, createdByProjectId: project.id, createdAt: nowIso, updatedAt: nowIso }).run();
+  const searchTerms = variant === 0 ? ["roof replacement costs", "emergency roof repair options"] : ["family resorts near the coast", "coastal resort amenities"];
+  const dates = Array.from({ length: 14 }, (_, i) => day(now, i - 14));
+  for (const [i, date] of dates.entries()) {
+    const clicks = 34 + i * 3 + variant * 5;
+    const impressions = 620 + i * 31 + variant * 55;
+    db.insert(gscDailyTotals).values({ id: `${prefix}-gsc-total-${date}`, projectId: project.id, date, clicks, impressions, position: (8.8 - i * 0.08).toFixed(2), createdAt: at(date) }).run();
+    for (const [termIndex, query] of searchTerms.entries()) {
+      const queryClicks = Math.max(3, Math.round(clicks / (termIndex + 2)));
+      const queryImpressions = Math.round(impressions / (termIndex + 2));
+      db.insert(gscQueryDailyTotals).values({ id: `${prefix}-gsc-query-${i}-${termIndex}`, projectId: project.id, date, query, clicks: queryClicks, impressions: queryImpressions, position: (7.1 + termIndex + i * 0.03).toFixed(2), syncedAt: nowIso, syncRunId, createdAt: at(date) }).run();
+      db.insert(gscSearchData).values({ id: `${prefix}-gsc-page-${i}-${termIndex}`, projectId: project.id, syncRunId, date, query, page: termIndex === 0 ? root : `${root}services/`, country: "usa", device: "DESKTOP", clicks: queryClicks, impressions: queryImpressions, ctr: (queryClicks / queryImpressions).toFixed(4), position: (7.1 + termIndex).toFixed(2), createdAt: at(date) }).run();
+    }
+    db.insert(gaDailyTotals).values({ id: `${prefix}-ga-total-${date}`, projectId: project.id, date, sessions: 92 + i * 4 + variant * 11, users: 71 + i * 3 + variant * 8, engagementRate: 0.58 + i * 4e-3, newUsers: 29 + i, syncedAt: nowIso, syncRunId, createdAt: at(date) }).run();
+    db.insert(gaTrafficSnapshots).values({ id: `${prefix}-ga-page-${date}`, projectId: project.id, date, landingPage: "/", landingPageNormalized: "/", sessions: 62 + i * 3, organicSessions: 39 + i * 2, directSessions: 14 + i, users: 48 + i * 2, syncedAt: nowIso, syncRunId }).run();
+    db.insert(gaAcquisitionDaily).values({ id: `${prefix}-ga-acquisition-${date}`, projectId: project.id, date, channelGroup: "Organic Search", source: "google", medium: "organic", hostName: project.domain, landingPage: "/", landingPageNormalized: "/", sessions: 39 + i * 2, syncedAt: nowIso, syncRunId, createdAt: at(date) }).run();
+    db.insert(gaLeadEventsDaily).values({ id: `${prefix}-ga-lead-${date}`, projectId: project.id, date, eventName: "generate_lead", channelGroup: "Organic Search", source: "google", medium: "organic", hostName: project.domain, landingPage: "/", landingPageNormalized: "/", attributionScope: "landing-page", eventCount: 3 + i % 4, syncedAt: nowIso, syncRunId, createdAt: at(date) }).run();
+    db.insert(gaAiReferrals).values({ id: `${prefix}-ga-ai-${date}`, projectId: project.id, date, source: i % 2 ? "demo-answer-engine.example" : "demo-ai-referral.example", medium: "referral", trafficClass: "organic", sourceDimension: "session", channelGroup: "Referral", landingPage: "/", landingPageNormalized: "/", sessions: 4 + i % 3, users: 3 + i % 2, syncedAt: nowIso, syncRunId }).run();
+    db.insert(bingCoverageSnapshots).values({ id: `${prefix}-bing-coverage-${date}`, projectId: project.id, syncRunId, date, indexed: 48 + i, notIndexed: 3, unknown: 2, createdAt: at(date) }).run();
+  }
+  db.insert(gscDataWatermarks).values({ projectId: project.id, dataThroughDate: dates.at(-1), syncedThroughDate: dates.at(-1), updatedAt: nowIso }).run();
+  db.insert(gscCoverageSnapshots).values({ id: `${prefix}-gsc-coverage`, projectId: project.id, syncRunId, date: dates.at(-1), indexed: 1, notIndexed: 0, unknownPages: 0, verifiedByInspection: 1, derivedFromImpressions: 0, reasonBreakdown: {}, createdAt: nowIso }).run();
+  db.insert(gscUrlInspections).values({ id: `${prefix}-gsc-inspection`, projectId: project.id, syncRunId, url: `${root}services/`, indexingState: "INDEXING_ALLOWED", verdict: "PASS", coverageState: "Submitted and indexed", pageFetchState: "SUCCESSFUL", robotsTxtState: "ALLOWED", crawlTime: nowIso, lastCrawlResult: "SUCCESSFUL", isMobileFriendly: true, richResults: ["Sample FAQ"], referringUrls: [root], inspectedAt: nowIso, createdAt: nowIso }).run();
+  db.insert(bingKeywordStats).values(searchTerms.map((query, i) => ({ id: `${prefix}-bing-keyword-${i}`, projectId: project.id, query, impressions: 310 - i * 70, clicks: 22 - i * 4, ctr: "0.071", averagePosition: String(6 + i), syncedAt: nowIso, createdAt: nowIso }))).run();
+  db.insert(bingUrlInspections).values({ id: `${prefix}-bing-inspection`, projectId: project.id, url: root, httpCode: 200, inIndex: true, lastCrawledDate: dates.at(-2), inIndexDate: dates.at(-8), inspectedAt: nowIso, syncRunId, createdAt: nowIso, documentSize: 24120, anchorCount: 18, discoveryDate: dates[0] }).run();
+  db.insert(gaMeasurementSyncStates).values({ projectId: project.id, acquisitionStatus: "ready", acquisitionSyncedAt: nowIso, leadStatus: "ready", leadSyncedAt: nowIso, leadAttributionScope: "landing-page", updatedAt: nowIso }).run();
+  db.insert(gaTrafficSummaries).values({ id: `${prefix}-ga-summary`, projectId: project.id, periodStart: dates[0], periodEnd: dates.at(-1), totalSessions: 1610, totalOrganicSessions: 980, totalUsers: 1214, syncedAt: nowIso, syncRunId }).run();
+  db.insert(gaTrafficWindowSummaries).values({ id: `${prefix}-ga-window`, projectId: project.id, windowKey: "30d", periodStart: dates[0], periodEnd: dates.at(-1), totalSessions: 1610, totalOrganicSessions: 980, totalDirectSessions: 284, totalUsers: 1214, syncedAt: nowIso, syncRunId }).run();
+  const inventory = variant === 0 ? summitRoofingInventory() : harborResortsInventory();
+  const crawl = await seedSiteCrawl(db, { project, prefix, root, crawlRunId, attemptId, nowIso, inventory });
+  const brokenLinkSource = (crawl.findings.find((finding) => finding.sourceNodeKey?.startsWith("/guides/")) ?? crawl.findings.at(0))?.sourceUrl ?? root;
+  seedLocalAndCommercialSignals(db, { project, prefix, root, syncRunId, campaignId, groupId, locationName, nowIso, dates, variant });
+  if (variant === 1) {
+    db.insert(healthSnapshots).values({ id: `${prefix}-health`, projectId: project.id, runId: syncRunId, overallCitedRate: "0.61", overallMentionRate: "0.74", totalPairs: 42, citedPairs: 26, mentionedPairs: 31, providerBreakdown: { openai: { citedRate: 0.62, mentionRate: 0.76, cited: 13, mentioned: 16, total: 21 }, perplexity: { citedRate: 0.6, mentionRate: 0.71, cited: 13, mentioned: 15, total: 21 } }, createdAt: nowIso }).run();
+    db.insert(insights).values([
+      { id: `${prefix}-insight-1`, projectId: project.id, runId: syncRunId, type: "opportunity", severity: "medium", title: "Expand service comparison guidance", query: searchTerms[0], provider: "openai", recommendation: { action: "Draft a comparison section", target: `${root}services/`, reason: "Sample insight for the public dashboard." }, cause: { cause: "Sample answer-history gap", details: "This is stored sample data." }, dismissed: false, createdAt: nowIso },
+      { id: `${prefix}-insight-2`, projectId: project.id, runId: syncRunId, type: "persistent-gap", severity: "low", title: "Review one internal link target", query: searchTerms[1], provider: "perplexity", recommendation: { action: "Repair the illustrative link", target: brokenLinkSource, reason: "Sample finding for the public dashboard." }, cause: { cause: "Sample crawl finding", details: "This is stored sample data." }, dismissed: false, createdAt: nowIso }
+    ]).run();
+  }
+  db.insert(auditLog).values([
+    { id: `${prefix}-audit-1`, projectId: project.id, actor: "sample-data", action: "demo.seeded", entityType: "project", entityId: project.id, diff: "Synthetic public demo signals seeded; no provider was contacted.", createdAt: nowIso },
+    { id: `${prefix}-audit-2`, projectId: project.id, actor: "sample-data", action: "demo.site-health.snapshot", entityType: "site-crawl", entityId: crawlRunId, diff: "Synthetic completed crawl graph and findings stored.", createdAt: nowIso }
+  ]).run();
+}
+function seedLocalAndCommercialSignals(db, input) {
+  const { project, prefix, root, syncRunId, campaignId, groupId, locationName, nowIso, dates, variant } = input;
+  const business = variant === 0 ? { category: "Roofing contractor", campaign: "Spring roof inspection campaign" } : { category: "Resort hotel", campaign: "Spring resort stays campaign" };
+  db.insert(gbpLocations).values({ id: `${prefix}-gbp-location`, projectId: project.id, accountName: "accounts/demo-fixture", locationName, displayName: `${project.displayName} - Sample`, primaryCategoryDisplayName: business.category, storefrontAddress: "100 Example Avenue, Demo City", websiteUri: root, placeId: `demo-place-${project.id}`, mapsUri: `https://maps.example/${project.id}`, description: "Sample listing for the public, view-only Canonry dashboard.", selected: true, syncedAt: nowIso, createdAt: nowIso, updatedAt: nowIso }).run();
+  db.insert(gbpDailyMetrics).values(dates.slice(-7).flatMap((date, i) => [
+    { id: `${prefix}-gbp-impressions-${date}`, projectId: project.id, locationName, date, metric: "BUSINESS_IMPRESSIONS_DESKTOP_MAPS", value: 44 + i * 2, syncRunId },
+    { id: `${prefix}-gbp-clicks-${date}`, projectId: project.id, locationName, date, metric: "WEBSITE_CLICKS", value: 7 + i % 3, syncRunId }
+  ])).run();
+  db.insert(gbpKeywordImpressions).values({ id: `${prefix}-gbp-keyword`, projectId: project.id, locationName, periodStart: dates[0].slice(0, 7), periodEnd: dates.at(-1).slice(0, 7), keyword: "sample local service", valueCount: 148, valueThreshold: null, syncRunId }).run();
+  db.insert(gbpKeywordMonthly).values({ id: `${prefix}-gbp-monthly`, projectId: project.id, locationName, month: dates.at(-1).slice(0, 7), keyword: "sample local service", valueCount: 148, valueThreshold: null, syncRunId, syncedAt: nowIso }).run();
+  db.insert(gbpPlaceActions).values({ id: `${prefix}-gbp-action`, projectId: project.id, locationName, placeActionLinkName: `${locationName}/placeActionLinks/demo`, placeActionType: "APPOINTMENT", uri: `${root}contact/`, isPreferred: true, providerType: "MERCHANT", syncRunId }).run();
+  db.insert(backlinkSummaries).values({ id: `${prefix}-backlinks`, projectId: project.id, source: "commoncrawl", release: "DEMO-2026-09", targetDomain: project.domain, totalLinkingDomains: 3, totalHosts: 12, top10HostsShare: "0.42", queriedAt: nowIso, createdAt: nowIso }).run();
+  db.insert(backlinkDomains).values(["partners.demo.example", "local-guides.demo.example", "trade-directory.demo.example"].map((linkingDomain, i) => ({ id: `${prefix}-backlink-domain-${i}`, projectId: project.id, source: "commoncrawl", release: "DEMO-2026-09", targetDomain: project.domain, linkingDomain, numHosts: 5 - i, createdAt: nowIso }))).run();
+  db.insert(adsConnections).values({ id: `${prefix}-ads-connection`, projectId: project.id, adAccountId: `demo-account-${project.id}`, displayName: "Sample Ad Account", currencyCode: "USD", timezone: "UTC", status: "active", reviewStatus: "approved", integrityReviewStatus: "sample", integrityDecision: "synthetic", lastSyncedAt: nowIso, conversionTrackingConfigured: true, createdAt: nowIso, updatedAt: nowIso }).run();
+  db.insert(adsCampaigns).values({ id: campaignId, projectId: project.id, name: business.campaign, description: "Sample stored campaign for the public dashboard.", status: "ACTIVE", biddingType: "MAXIMIZE_CONVERSIONS", dailySpendLimitMicros: 45e6, conversionEventSettingIds: ["demo-conversion-setting"], targeting: { sampleData: true }, syncRunId, syncedAt: nowIso }).run();
+  db.insert(adsAdGroups).values({ id: groupId, projectId: project.id, campaignId, name: "Service comparison intent", description: "Sample stored ad group.", status: "ACTIVE", billingEventType: "CPC", maxBidMicros: 32e5, contextHints: ["sample service\nsample comparison"], syncRunId, syncedAt: nowIso }).run();
+  db.insert(adsAds).values({ id: `${prefix}-ad`, projectId: project.id, adGroupId: groupId, name: "Sample responsive ad", status: "ACTIVE", creative: { sampleData: true, headline: "Sample service guidance" }, reviewStatus: "APPROVED", syncRunId, syncedAt: nowIso }).run();
+  db.insert(adsInsightsDaily).values(dates.slice(-7).map((date, i) => ({ id: `${prefix}-ads-insight-${date}`, projectId: project.id, level: "campaign", entityId: campaignId, date, impressions: 340 + i * 20, clicks: 22 + i, spendMicros: 18e5 + i * 1e5, conversions: 2 + i % 3, syncRunId }))).run();
+  db.insert(conversionTrackingContracts).values({ id: `${prefix}-conversion`, projectId: project.id, name: "Sample lead", eventName: "generate_lead", googleAds: { customerId: "demo-customer", conversionActionId: "demo-action", conversionId: "AW-123456", conversionLabel: "demo-label", campaignIds: [campaignId], requireBiddableGoal: true, requirePrimaryAction: true }, gtm: { accountId: "demo-account", containerId: "demo-container", tagId: "demo-tag", triggerIds: ["demo-trigger"], variableIds: ["demo-value", "demo-currency"] }, runtime: { verificationRequired: true, requireTransactionId: true, requireValue: true, requireCurrency: true, productionHosts: [project.domain] }, createdAt: nowIso, updatedAt: nowIso }).run();
+}
+
+// src/demo/stores.ts
+import { and as and3, eq as eq4 } from "drizzle-orm";
+function refuseMutation() {
+  throw new Error("The public demo stores are view only.");
+}
+function demoReadOptions(db, context) {
+  const mapGoogle = (row) => ({
+    domain: row.domain,
+    connectionType: row.connectionType,
+    propertyId: row.propertyId,
+    createdByProjectId: row.createdByProjectId,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    scopes: []
+  });
+  return {
+    // Required to register stored Google readers. No OAuth callbacks are
+    // allowed, and no Google client id, secret, token, or transport is wired.
+    googleStateSecret: "public-demo-no-oauth-callbacks",
+    googleConnectionStore: {
+      listConnections: (domain) => db.select().from(googleConnections).where(eq4(googleConnections.domain, domain)).all().map(mapGoogle),
+      getConnection: (domain, type) => {
+        const row = db.select().from(googleConnections).where(and3(eq4(googleConnections.domain, domain), eq4(googleConnections.connectionType, type))).get();
+        return row ? mapGoogle(row) : void 0;
+      },
+      upsertConnection: refuseMutation,
+      updateConnection: refuseMutation,
+      deleteConnection: refuseMutation
+    },
+    bingConnectionStore: {
+      getConnection: (domain) => {
+        const row = db.select().from(bingConnections).where(eq4(bingConnections.domain, domain)).get();
+        return row ? { domain, siteUrl: row.siteUrl, apiKey: "", createdAt: row.createdAt, updatedAt: row.updatedAt } : void 0;
+      },
+      upsertConnection: refuseMutation,
+      updateConnection: refuseMutation,
+      deleteConnection: refuseMutation
+    },
+    ga4CredentialStore: {
+      getConnection: (projectName) => {
+        const project = [context.simple, context.portfolio].find((item) => item.name === projectName);
+        return project ? { projectName, propertyId: "demo-property", clientEmail: "sample@analytics.example", privateKey: "", createdAt: context.now.toISOString(), updatedAt: context.now.toISOString() } : void 0;
+      },
+      upsertConnection: refuseMutation,
+      deleteConnection: refuseMutation
+    },
+    googleMarketingCredentialStore: {
+      get: (project, provider) => {
+        const knownProject = [context.simple, context.portfolio].some((item) => item.id === project.id && item.name === project.name);
+        if (!knownProject) return void 0;
+        return {
+          // This only satisfies the status route's connection-state seam. It
+          // is deliberately unusable for OAuth or any provider request.
+          accessToken: `demo-status-only-${provider}-not-a-real-token`,
+          refreshToken: null,
+          expiresAt: null,
+          scopes: [],
+          developerToken: null,
+          createdAt: context.now.toISOString(),
+          updatedAt: context.now.toISOString()
+        };
+      },
+      upsert: refuseMutation,
+      delete: refuseMutation,
+      hasGoogleAdsDeveloperToken: () => false
+    },
+    assessConversionTrackingIntegrity: ({ contract, googleAdsSnapshot, gtmSnapshot }) => assessConversionTrackingIntegrity({
+      contract,
+      googleAdsInventory: googleAdsSnapshot?.payload.kind === "inventory" ? googleAdsSnapshot.payload.data : null,
+      googleAdsEvidenceId: googleAdsSnapshot?.metadata.id,
+      gtmLiveGraph: gtmSnapshot?.payload.kind === "container" ? gtmSnapshot.payload.data.live : gtmSnapshot?.payload.kind === "live" ? gtmSnapshot.payload.data : null,
+      gtmEvidenceId: gtmSnapshot?.metadata.id,
+      evaluatedAt: context.now.toISOString()
+    }),
+    getBacklinksStatus: () => ({ duckdbInstalled: false, duckdbSpec: "Demo uses stored sample backlinks", pluginDir: "" }),
+    listCachedReleases: () => [{ release: "DEMO-2026-09", syncStatus: "ready", bytes: 0, lastUsedAt: context.now.toISOString() }]
+  };
+}
+
+// src/demo/types.ts
+function createDemoSeedContext(now = /* @__PURE__ */ new Date()) {
+  return {
+    now,
+    simple: { id: "demo-project-summit", name: "summit-roofing", displayName: "Summit Roofing", domain: "summit-roofing.example" },
+    portfolio: { id: "demo-project-harbor", name: "harbor-resorts", displayName: "Harbor Resorts", domain: "harbor-resorts.example" }
+  };
+}
+
+// src/demo-server.ts
+async function createDemoServer(options = {}) {
+  const db = createClient(":memory:");
+  try {
+    migrate(db);
+    const context = createDemoSeedContext(options.now);
+    seedDemoCore(db, context);
+    await seedDemoSignals(db, context);
+    seedDemoExploration(db, context);
+    seedDemoMarketing(db, context);
+    const app = await createDemoHttpServer({
+      db,
+      now: context.now,
+      trustProxy: options.trustProxy,
+      assetsDir: options.assetsDir ?? join2(dirname(fileURLToPath(import.meta.url)), "..", "assets"),
+      readOptions: demoReadOptions(db, context)
+    });
+    db.$client.pragma("query_only = ON");
+    app.addHook("onClose", async () => {
+      db.$client.close();
+    });
+    return app;
+  } catch (error) {
+    db.$client.close();
+    throw error;
+  }
+}
+export {
+  createDemoServer
+};