thevoidforge 21.0.0

package/dist/wizard/lib/safety-tiers.js

@@ -0,0 +1,134 @@
+/**
+ * Safety Tier Schema — Budget authorization and spend control.
+ *
+ * Half-open intervals for budget tiers (§9.17):
+ *   [0, 2500) cents/day: auto-approve (ongoing spend only — new campaigns need vault password)
+ *   [2500, 10000) cents/day: agent approval (Dockson + Steris)
+ *   [10000, 50000) cents/day: human confirmation + TOTP
+ *   >= 50000 cents/day: hard stop + TOTP + vault password
+ *
+ * Aggregate auto-approve limit: $100/day across all campaigns (§9.17)
+ * Hard stop buffer: platform cap set 10% below VoidForge hard stop (§9.17)
+ *
+ * Campaign creation rate limits (§9.19.14 + §9.20.3d):
+ *   Max 5 daemon-initiated campaigns per 24h
+ *   Max 10 active campaigns per platform
+ *   Burst detection: >3 within 15 minutes → pause and alert
+ *
+ * PRD Reference: §9.4, §9.17, §9.19.5, §9.19.14, §9.20.5
+ */
+const DEFAULT_TIERS = {
+    autoApproveBelow: 2500,
+    agentApproveBelow: 10000,
+    humanConfirmBelow: 50000,
+    hardStopAbove: 50000,
+    aggregateAutoApproveMax: 10000,
+    hardStopBuffer: 0.10,
+};
+/**
+ * Classify a daily budget amount into its safety tier.
+ * Also considers aggregate spend across all campaigns.
+ */
+function classifyTier(dailyBudget, aggregateDailySpend, config = DEFAULT_TIERS) {
+    // Check if aggregate would push into a higher tier
+    const newAggregate = (aggregateDailySpend + dailyBudget);
+    if (dailyBudget >= config.hardStopAbove) {
+        return {
+            tier: 'hard_stop',
+            requiresVaultPassword: true,
+            requiresTotp: true,
+            reason: `Daily budget $${dailyBudget / 100} exceeds hard stop ($${config.hardStopAbove / 100}/day)`,
+        };
+    }
+    if (dailyBudget >= config.humanConfirmBelow || newAggregate >= config.humanConfirmBelow) {
+        return {
+            tier: 'human_confirm',
+            requiresVaultPassword: true,
+            requiresTotp: true,
+            reason: dailyBudget >= config.humanConfirmBelow
+                ? `Daily budget $${dailyBudget / 100} requires human confirmation`
+                : `Aggregate $${newAggregate / 100}/day pushes into human confirmation tier`,
+        };
+    }
+    if (dailyBudget >= config.agentApproveBelow || newAggregate >= config.agentApproveBelow) {
+        return {
+            tier: 'agent_approve',
+            requiresVaultPassword: true,
+            requiresTotp: false,
+            reason: dailyBudget >= config.agentApproveBelow
+                ? `Daily budget $${dailyBudget / 100} requires agent approval (Dockson + Steris)`
+                : `Aggregate $${newAggregate / 100}/day pushes into agent approval tier`,
+        };
+    }
+    // Auto-approve tier — but check aggregate cap
+    if (newAggregate > config.aggregateAutoApproveMax) {
+        return {
+            tier: 'agent_approve',
+            requiresVaultPassword: true,
+            requiresTotp: false,
+            reason: `Individual budget $${dailyBudget / 100} is auto-approve, but aggregate $${newAggregate / 100}/day exceeds $${config.aggregateAutoApproveMax / 100} cap`,
+        };
+    }
+    return {
+        tier: 'auto_approve',
+        requiresVaultPassword: false, // For ONGOING spend. New campaign creation always needs vault password.
+        requiresTotp: false,
+        reason: `Daily budget $${dailyBudget / 100} within auto-approve tier`,
+    };
+}
+/**
+ * Calculate the platform-level daily cap (10% below VoidForge hard stop).
+ * This is set on the ad platform side so the platform enforces the cap
+ * even if VoidForge crashes.
+ */
+function platformDailyCap(config = DEFAULT_TIERS) {
+    return Math.floor(config.hardStopAbove * (1 - config.hardStopBuffer));
+}
+const DEFAULT_RATE_LIMITS = {
+    maxPerDay: 5,
+    maxActivePerPlatform: 10,
+    burstThreshold: 3,
+    burstWindowMs: 15 * 60 * 1000,
+};
+/**
+ * Check if a campaign creation is allowed by rate limits.
+ * Only applies to daemon-initiated creation (Tier 1/3).
+ * Human-triggered /grow Phase 4 is exempt (§9.20.3d).
+ */
+function checkCreationRateLimit(state, platform, isDaemonInitiated, config = DEFAULT_RATE_LIMITS) {
+    // Human-triggered is exempt from per-day limit
+    if (!isDaemonInitiated) {
+        // Still check per-platform active limit and burst detection
+        if ((state.activeCampaignsByPlatform[platform] ?? 0) >= config.maxActivePerPlatform) {
+            return { allowed: false, reason: `Maximum ${config.maxActivePerPlatform} active campaigns on ${platform}` };
+        }
+        // Burst detection applies to all sources
+        const now = Date.now();
+        const recentCount = state.creationTimestamps.filter(t => now - t < config.burstWindowMs).length;
+        if (recentCount >= config.burstThreshold) {
+            return { allowed: false, reason: `Burst detected: ${recentCount} campaigns in ${config.burstWindowMs / 60000} minutes`, burst: true };
+        }
+        return { allowed: true };
+    }
+    // Daemon-initiated — full rate limit check
+    if (state.creationsToday >= config.maxPerDay) {
+        return { allowed: false, reason: `Maximum ${config.maxPerDay} daemon-initiated campaigns per 24 hours` };
+    }
+    if ((state.activeCampaignsByPlatform[platform] ?? 0) >= config.maxActivePerPlatform) {
+        return { allowed: false, reason: `Maximum ${config.maxActivePerPlatform} active campaigns on ${platform}` };
+    }
+    const now = Date.now();
+    const recentCount = state.creationTimestamps.filter(t => now - t < config.burstWindowMs).length;
+    if (recentCount >= config.burstThreshold) {
+        return { allowed: false, reason: `Burst detected: ${recentCount} campaigns in ${config.burstWindowMs / 60000} minutes`, burst: true };
+    }
+    return { allowed: true };
+}
+function isAutonomouslyAllowed(action) {
+    const allowed = [
+        'pause_campaign', 'kill_campaign', 'evaluate_ab_test',
+        'rebalance_budget', 'generate_report', 'refresh_token',
+    ];
+    return allowed.includes(action);
+}
+export { DEFAULT_TIERS, DEFAULT_RATE_LIMITS, classifyTier, platformDailyCap, checkCreationRateLimit, isAutonomouslyAllowed };

package/dist/wizard/lib/sentry-generator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Optional Sentry error tracking integration (ADR-024).
+ * Generates SDK initialization code when sentry-dsn exists in vault.
+ * Framework-aware: Next.js, Express, Django.
+ */
+import type { ProvisionEmitter } from './provisioners/types.js';
+export interface SentryResult {
+    success: boolean;
+    file?: string;
+    pkg?: string;
+}
+/**
+ * Generate Sentry initialization code if sentry-dsn exists in credentials.
+ */
+export declare function generateSentryInit(projectDir: string, framework: string, sentryDsn: string | undefined, emit: ProvisionEmitter): Promise<SentryResult>;

package/dist/wizard/lib/sentry-generator.js

@@ -0,0 +1,116 @@
+/**
+ * Optional Sentry error tracking integration (ADR-024).
+ * Generates SDK initialization code when sentry-dsn exists in vault.
+ * Framework-aware: Next.js, Express, Django.
+ */
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { appendEnvSection } from './env-writer.js';
+function generateNodeSentry(framework) {
+    if (framework === 'next.js') {
+        return {
+            filename: 'sentry.client.config.ts',
+            pkg: '@sentry/nextjs',
+            content: `// Sentry client-side initialization — generated by VoidForge (ADR-024)
+// Install: npm install @sentry/nextjs
+// See: https://docs.sentry.io/platforms/javascript/guides/nextjs/
+
+import * as Sentry from '@sentry/nextjs';
+
+Sentry.init({
+  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN || process.env.SENTRY_DSN,
+  tracesSampleRate: 0.1, // 10% of transactions — increase for debugging, decrease for cost
+  environment: process.env.NODE_ENV,
+});
+`,
+        };
+    }
+    return {
+        filename: 'sentry.ts',
+        pkg: '@sentry/node',
+        content: `// Sentry server-side initialization — generated by VoidForge (ADR-024)
+// Install: npm install @sentry/node
+// Import this file at the top of your entry point (e.g., index.ts)
+
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  tracesSampleRate: 0.1, // 10% of transactions — increase for debugging, decrease for cost
+  environment: process.env.NODE_ENV || 'production',
+});
+
+export { Sentry };
+`,
+    };
+}
+function generatePythonSentry(framework) {
+    if (framework === 'django') {
+        return {
+            filename: 'sentry_config.py',
+            pkg: 'sentry-sdk[django]',
+            content: `# Sentry Django initialization — generated by VoidForge (ADR-024)
+# Install: pip install sentry-sdk[django]
+# Add to settings.py: import sentry_config  # noqa: F401
+
+import os
+import sentry_sdk
+from sentry_sdk.integrations.django import DjangoIntegration
+
+sentry_sdk.init(
+    dsn=os.environ.get("SENTRY_DSN", ""),
+    integrations=[DjangoIntegration()],
+    traces_sample_rate=0.1,  # 10% — increase for debugging, decrease for cost
+    environment=os.environ.get("DJANGO_ENV", "production"),
+)
+`,
+        };
+    }
+    return {
+        filename: 'sentry_config.py',
+        pkg: 'sentry-sdk[flask]',
+        content: `# Sentry Flask initialization — generated by VoidForge (ADR-024)
+# Install: pip install sentry-sdk[flask]
+# Import at the top of your app: import sentry_config  # noqa: F401
+
+import os
+import sentry_sdk
+from sentry_sdk.integrations.flask import FlaskIntegration
+
+sentry_sdk.init(
+    dsn=os.environ.get("SENTRY_DSN", ""),
+    integrations=[FlaskIntegration()],
+    traces_sample_rate=0.1,  # 10% — increase for debugging, decrease for cost
+    environment=os.environ.get("FLASK_ENV", "production"),
+)
+`,
+    };
+}
+/**
+ * Generate Sentry initialization code if sentry-dsn exists in credentials.
+ */
+export async function generateSentryInit(projectDir, framework, sentryDsn, emit) {
+    if (!sentryDsn) {
+        emit({ step: 'sentry', status: 'skipped', message: 'No Sentry DSN in vault — error tracking skipped. Add sentry-dsn to enable.' });
+        return { success: true };
+    }
+    emit({ step: 'sentry', status: 'started', message: 'Generating Sentry error tracking initialization' });
+    const isPython = framework === 'django' || framework === 'flask';
+    try {
+        const config = isPython
+            ? generatePythonSentry(framework)
+            : generateNodeSentry(framework);
+        await writeFile(join(projectDir, config.filename), config.content, 'utf-8');
+        // Write SENTRY_DSN to .env so the generated code can read it
+        await appendEnvSection(projectDir, [
+            `# Sentry error tracking — generated by VoidForge (ADR-024)`,
+            `SENTRY_DSN=${sentryDsn}`,
+        ]);
+        emit({ step: 'sentry', status: 'done', message: `Generated ${config.filename} — install: ${isPython ? 'pip' : 'npm'} install ${config.pkg}` });
+        return { success: true, file: config.filename, pkg: config.pkg };
+    }
+    catch (err) {
+        emit({ step: 'sentry', status: 'error', message: 'Failed to generate Sentry config', detail: err.message });
+        return { success: false };
+    }
+}

package/dist/wizard/lib/server-config.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Server configuration — port and host state, shared across modules.
+ * Extracted from server.ts to break circular import:
+ * server.ts → danger-room.ts → dashboard-ws.ts → server.ts
+ * Now: server.ts → server-config.ts ← dashboard-ws.ts (no cycle)
+ * (Gauntlet Picard DR-02)
+ */
+export declare function setServerPort(port: number): void;
+export declare function setServerHost(host: string): void;
+/** Get the server port for WebSocket origin validation. */
+export declare function getServerPort(): number;
+/** Get the server host for remote-mode WebSocket origin validation. */
+export declare function getServerHost(): string;

package/dist/wizard/lib/server-config.js

@@ -0,0 +1,23 @@
+/**
+ * Server configuration — port and host state, shared across modules.
+ * Extracted from server.ts to break circular import:
+ * server.ts → danger-room.ts → dashboard-ws.ts → server.ts
+ * Now: server.ts → server-config.ts ← dashboard-ws.ts (no cycle)
+ * (Gauntlet Picard DR-02)
+ */
+let serverPort = 0;
+let serverHost = '';
+export function setServerPort(port) {
+    serverPort = port;
+}
+export function setServerHost(host) {
+    serverHost = host;
+}
+/** Get the server port for WebSocket origin validation. */
+export function getServerPort() {
+    return serverPort;
+}
+/** Get the server host for remote-mode WebSocket origin validation. */
+export function getServerHost() {
+    return serverHost;
+}

package/dist/wizard/lib/service-install.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Service Install — launchd/systemd/Task Scheduler integration (§9.18, §9.19.2).
+ *
+ * Creates system services for:
+ * 1. Heartbeat daemon (com.voidforge.heartbeat)
+ * 2. Wizard server (com.voidforge.server) — persistent when Cultivation is installed
+ *
+ * PRD Reference: §9.18 (macOS LaunchAgent), §9.19.2 (two services)
+ */
+export declare function installHeartbeatService(): Promise<{
+    method: string;
+    path: string;
+}>;
+export declare function installServerService(port?: number): Promise<{
+    method: string;
+    path: string;
+}>;
+export declare function uninstallServices(): Promise<void>;

package/dist/wizard/lib/service-install.js

@@ -0,0 +1,182 @@
+/**
+ * Service Install — launchd/systemd/Task Scheduler integration (§9.18, §9.19.2).
+ *
+ * Creates system services for:
+ * 1. Heartbeat daemon (com.voidforge.heartbeat)
+ * 2. Wizard server (com.voidforge.server) — persistent when Cultivation is installed
+ *
+ * PRD Reference: §9.18 (macOS LaunchAgent), §9.19.2 (two services)
+ */
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir, platform } from 'node:os';
+import { execSync } from 'node:child_process';
+const VOIDFORGE_DIR = join(homedir(), '.voidforge');
+// ── macOS LaunchAgent ─────────────────────────────────
+function heartbeatPlist() {
+    const nodePath = process.execPath;
+    // Assuming the heartbeat entry point is at wizard/lib/heartbeat.js
+    // In production, this would be the installed package path
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.voidforge.heartbeat</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${join(VOIDFORGE_DIR, 'heartbeat-entry.js')}</string>
+  </array>
+  <key>KeepAlive</key>
+  <true/>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${join(VOIDFORGE_DIR, 'heartbeat-launchd.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(VOIDFORGE_DIR, 'heartbeat-launchd.log')}</string>
+</dict>
+</plist>`;
+}
+function serverPlist(port = 3141) {
+    const nodePath = process.execPath;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.voidforge.server</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${join(VOIDFORGE_DIR, 'server-entry.js')}</string>
+  </array>
+  <key>KeepAlive</key>
+  <true/>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>VOIDFORGE_PORT</key>
+    <string>${port}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${join(VOIDFORGE_DIR, 'server-launchd.log')}</string>
+  <key>StandardErrorPath</key>
+  <string>${join(VOIDFORGE_DIR, 'server-launchd.log')}</string>
+</dict>
+</plist>`;
+}
+// ── Linux systemd ─────────────────────────────────────
+function heartbeatSystemdUnit() {
+    return `[Unit]
+Description=VoidForge Heartbeat Daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${join(VOIDFORGE_DIR, 'heartbeat-entry.js')}
+Restart=always
+RestartSec=10
+StandardOutput=append:${join(VOIDFORGE_DIR, 'heartbeat-systemd.log')}
+StandardError=append:${join(VOIDFORGE_DIR, 'heartbeat-systemd.log')}
+
+[Install]
+WantedBy=default.target`;
+}
+function serverSystemdUnit(port = 3141) {
+    return `[Unit]
+Description=VoidForge Server (Danger Room + Cultivation)
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${join(VOIDFORGE_DIR, 'server-entry.js')}
+Environment=VOIDFORGE_PORT=${port}
+Restart=always
+RestartSec=10
+StandardOutput=append:${join(VOIDFORGE_DIR, 'server-systemd.log')}
+StandardError=append:${join(VOIDFORGE_DIR, 'server-systemd.log')}
+
+[Install]
+WantedBy=default.target`;
+}
+// ── Install Functions ─────────────────────────────────
+export async function installHeartbeatService() {
+    if (platform() === 'darwin') {
+        const plistDir = join(homedir(), 'Library', 'LaunchAgents');
+        const plistPath = join(plistDir, 'com.voidforge.heartbeat.plist');
+        await mkdir(plistDir, { recursive: true });
+        await writeFile(plistPath, heartbeatPlist());
+        execSync(`launchctl load "${plistPath}" 2>/dev/null || true`);
+        return { method: 'launchd', path: plistPath };
+    }
+    if (platform() === 'linux') {
+        const unitDir = join(homedir(), '.config', 'systemd', 'user');
+        const unitPath = join(unitDir, 'voidforge-heartbeat.service');
+        await mkdir(unitDir, { recursive: true });
+        await writeFile(unitPath, heartbeatSystemdUnit());
+        execSync('systemctl --user daemon-reload 2>/dev/null || true');
+        execSync('systemctl --user enable voidforge-heartbeat 2>/dev/null || true');
+        return { method: 'systemd', path: unitPath };
+    }
+    // Windows: Task Scheduler (recommend WSL2 for full support per §9.17)
+    return { method: 'manual', path: 'Windows: use WSL2 or run `voidforge heartbeat start --daemon` manually' };
+}
+export async function installServerService(port = 3141) {
+    if (platform() === 'darwin') {
+        const plistDir = join(homedir(), 'Library', 'LaunchAgents');
+        const plistPath = join(plistDir, 'com.voidforge.server.plist');
+        await mkdir(plistDir, { recursive: true });
+        await writeFile(plistPath, serverPlist(port));
+        execSync(`launchctl load "${plistPath}" 2>/dev/null || true`);
+        return { method: 'launchd', path: plistPath };
+    }
+    if (platform() === 'linux') {
+        const unitDir = join(homedir(), '.config', 'systemd', 'user');
+        const unitPath = join(unitDir, 'voidforge-server.service');
+        await mkdir(unitDir, { recursive: true });
+        await writeFile(unitPath, serverSystemdUnit(port));
+        execSync('systemctl --user daemon-reload 2>/dev/null || true');
+        execSync('systemctl --user enable voidforge-server 2>/dev/null || true');
+        return { method: 'systemd', path: unitPath };
+    }
+    return { method: 'manual', path: 'Windows: use WSL2 or run the wizard server manually' };
+}
+export async function uninstallServices() {
+    if (platform() === 'darwin') {
+        const agents = ['com.voidforge.heartbeat', 'com.voidforge.server'];
+        for (const label of agents) {
+            const path = join(homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+            try {
+                execSync(`launchctl unload "${path}" 2>/dev/null`);
+                const { unlink } = await import('node:fs/promises');
+                await unlink(path);
+            }
+            catch { /* not installed */ }
+        }
+    }
+    if (platform() === 'linux') {
+        const units = ['voidforge-heartbeat', 'voidforge-server'];
+        for (const unit of units) {
+            try {
+                execSync(`systemctl --user stop ${unit} 2>/dev/null`);
+                execSync(`systemctl --user disable ${unit} 2>/dev/null`);
+                const path = join(homedir(), '.config', 'systemd', 'user', `${unit}.service`);
+                const { unlink } = await import('node:fs/promises');
+                await unlink(path);
+            }
+            catch { /* not installed */ }
+        }
+        execSync('systemctl --user daemon-reload 2>/dev/null || true');
+    }
+}

package/dist/wizard/lib/site-scanner.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Torres's Site Scanner — HTTP-based technical reconnaissance.
+ *
+ * Scans a deployed site without browser dependencies:
+ * - Response times and status codes on main routes
+ * - Meta tags (title, description, OG, JSON-LD)
+ * - Security headers (HTTPS, HSTS, CSP, CORS, X-Frame-Options)
+ * - Cache headers, compression (gzip/brotli)
+ * - Analytics detection (GA4, Plausible, PostHog snippets)
+ * - Mobile viewport, favicon, sitemap.xml, robots.txt
+ * - Growth infrastructure (email capture forms, cookie consent)
+ *
+ * Zero dependencies — uses node:https only.
+ *
+ * PRD Reference: ROADMAP v12.0 deliverables (Torres's site scanner)
+ */
+interface SiteScanResult {
+    url: string;
+    scannedAt: string;
+    reachable: boolean;
+    error?: string;
+    performance: PerformanceScan;
+    seo: SeoScan;
+    security: SecurityScan;
+    growth: GrowthScan;
+    health: HealthScan;
+}
+interface PerformanceScan {
+    ttfbMs: number | null;
+    totalTimeMs: number | null;
+    contentLength: number | null;
+    compressed: boolean;
+    cacheControl: string | null;
+}
+interface SeoScan {
+    title: string | null;
+    description: string | null;
+    ogTitle: string | null;
+    ogDescription: string | null;
+    ogImage: string | null;
+    canonicalUrl: string | null;
+    viewport: boolean;
+    favicon: boolean;
+    jsonLd: boolean;
+    sitemapExists: boolean;
+    robotsExists: boolean;
+    h1Count: number;
+}
+interface SecurityScan {
+    https: boolean;
+    hsts: boolean;
+    csp: string | null;
+    xFrameOptions: string | null;
+    xContentTypeOptions: boolean;
+    referrerPolicy: string | null;
+    corsAllowOrigin: string | null;
+}
+interface GrowthScan {
+    analyticsDetected: string[];
+    cookieConsentDetected: boolean;
+    emailCaptureDetected: boolean;
+    socialMetaComplete: boolean;
+}
+interface HealthScan {
+    statusCode: number | null;
+    redirectChain: string[];
+    responseHeaders: Record<string, string>;
+}
+export declare function scanSite(siteUrl: string): Promise<SiteScanResult>;
+/**
+ * Score the scan result across the 5 Deep Current dimensions.
+ * Returns partial scores for performance, SEO (part of growth), and security.
+ */
+export declare function scoreScan(scan: SiteScanResult): {
+    performance: number;
+    seoScore: number;
+    securityScore: number;
+    growthReadiness: number;
+};
+export type { SiteScanResult, PerformanceScan, SeoScan, SecurityScan, GrowthScan, HealthScan };