Building Privacy-First Browser Extensions with Chrome Nano AI: A Technical Guide

User Browser → Extension → Cloud Servers → AI Provider → Cloud Servers → Extension → User Browser

┌─────────────────────────────────────────────────────────────┐
│                      User's Device                          │
│                                                             │
│  ┌──────────────┐    ┌────────────────┐    ┌────────────┐ │
│  │   Browser    │───▶│  Gemini Nano   │───▶│   Result   │ │
│  │  Extension   │    │  Language Model │    │  Display   │ │
│  └──────────────┘    └────────────────┘    └────────────┘ │
│         │                     │                     │      │
│         │                     │                     │      │
│         └─────────────────────┴─────────────────────┘      │
│                    All Processing Local                    │
│              No Network Transmission Required              │
└─────────────────────────────────────────────────────────────┘

interface LanguageModel {
  // Check if model is available on device
  availability(): Promise<"readily-available" | "downloadable" | "downloading" | "unavailable">;

  // Get default model parameters
  params(): Promise<LanguageModelParams>;

  // Create inference session
  create(options?: LanguageModelCreateOptions): Promise<LanguageModelSession>;
}

interface LanguageModelSession {
  // Synchronous inference
  prompt(input: string): Promise<string>;

  // Streaming inference for real-time UI updates
  promptStreaming(input: string): AsyncIterable<string>;

  // Cleanup resources
  destroy(): void;
}

User Input → Extension → HTTPS → Cloud Load Balancer
  → API Gateway → Auth Service → Logging Service
  → AI Inference Service → Response Pipeline
  → Analytics → Extension → User

User Input → Extension → Local AI Session → User

Security = Enc_TLS(data) + Auth_API(credentials) + Storage_Enc(logs)

Security = Browser_Isolation(extension) + OS_Security(process)

/**
 * Zero-Persistence Session Pattern
 * - Creates new session per operation
 * - No state retention between operations
 * - Automatic cleanup after use
 * - Maximum privacy, zero data leakage
 */
class EphemeralAiService {
  async processPrivateData(sensitiveInput: string): Promise<string> {
    // Create session only when needed
    let session: LanguageModelSession | null = null;

    try {
      // Check availability without retaining state
      if (!await this.checkAvailability()) {
        throw new Error("AI not available");
      }

      // Create temporary session
      session = await LanguageModel.create({
        temperature: 0.7,
        topK: 5,
        // Explicitly no initial prompts to avoid state
        initialPrompts: [],
      });

      // Process data with no logging
      const result = await session.prompt(sensitiveInput);

      // Return result immediately
      return result;

    } finally {
      // Guaranteed cleanup even on error
      if (session) {
        session.destroy();
        session = null;
      }
      // sensitiveInput and result go out of scope
      // Garbage collection clears memory
    }
  }

  private async checkAvailability(): Promise<boolean> {
    const availability = await LanguageModel.availability();
    return availability === "readily-available";
  }
}

/**
 * Stateful Session Pattern
 * - Retains context across multiple operations
 * - Explicit lifecycle control
 * - Privacy-conscious state management
 * - Manual cleanup required
 */
class StatefulAiService {
  private session: LanguageModelSession | null = null;
  private context: ConversationContext = new ConversationContext();

  /**
   * Initialize session with user consent
   * Must be called in user gesture context
   */
  async initialize(): Promise<void> {
    if (this.session) {
      throw new Error("Session already initialized");
    }

    this.session = await LanguageModel.create({
      temperature: 0.7,
      topK: 5,
      initialPrompts: this.context.getSystemPrompts(),
    });

    logger.info("Session initialized", {
      timestamp: Date.now(),
      // No user data in logs
    });
  }

  /**
   * Process input with retained context
   */
  async processWithContext(input: string): Promise<string> {
    if (!this.session) {
      throw new Error("Session not initialized");
    }

    // Add input to context before processing
    this.context.addUserMessage(input);

    try {
      const result = await this.session.prompt(input);

      // Store only minimal context, not raw data
      this.context.addAssistantMessage(result);

      return result;
    } catch (error) {
      logger.error("Processing failed", {
        error: error.message,
        // No input data logged
      });
      throw error;
    }
  }

  /**
   * Explicit cleanup - MUST be called by consumers
   */
  async cleanup(): Promise<void> {
    if (this.session) {
      this.session.destroy();
      this.session = null;
    }

    // Clear conversation context
    this.context.clear();

    logger.info("Session cleaned up");
  }

  /**
   * Get sanitized session status
   */
  getStatus(): SessionStatus {
    return {
      active: this.session !== null,
      messageCount: this.context.getMessageCount(),
      // No actual message content exposed
    };
  }
}

/**
 * Privacy-conscious context management
 */
class ConversationContext {
  private messages: Message[] = [];
  private readonly maxMessages = 50; // Prevent unbounded growth

  addUserMessage(content: string): void {
    this.messages.push({
      role: "user",
      timestamp: Date.now(),
      // Content stored transiently in memory only
      content,
    });

    this.enforceLimit();
  }

  addAssistantMessage(content: string): void {
    this.messages.push({
      role: "assistant",
      timestamp: Date.now(),
      content,
    });

    this.enforceLimit();
  }

  private enforceLimit(): void {
    // Automatic cleanup of old messages
    if (this.messages.length > this.maxMessages) {
      // Remove oldest messages to prevent memory bloat
      this.messages = this.messages.slice(-this.maxMessages);
    }
  }

  clear(): void {
    // Explicit memory clearing
    this.messages = [];
  }

  getMessageCount(): number {
    return this.messages.length;
  }

  getSystemPrompts(): string[] {
    // Return only system-level prompts, no user data
    return [
      "You are a helpful assistant focused on user privacy.",
    ];
  }
}

/**
 * Hybrid Architecture Pattern
 * - Privacy-first by default (Chrome Nano AI)
 * - Cloud fallback only for complex tasks requiring consent
 * - Clear privacy tier separation
 */
class HybridAiService {
  private localAi: EphemeralAiService;
  private cloudAi: CloudAiService | null;
  private privacySettings: PrivacySettings;

  constructor(privacySettings: PrivacySettings) {
    this.localAi = new EphemeralAiService();
    this.privacySettings = privacySettings;

    // Cloud AI only initialized if user explicitly enables
    this.cloudAi = privacySettings.allowCloudProcessing
      ? new CloudAiService()
      : null;
  }

  /**
   * Process with automatic tier selection
   */
  async process(
    input: string,
    metadata: TaskMetadata
  ): Promise<ProcessingResult> {
    // Assess privacy sensitivity
    const privacyLevel = this.assessPrivacyLevel(input, metadata);

    // Route based on privacy and complexity
    const route = this.determineRoute(privacyLevel, metadata.complexity);

    switch (route) {
      case "local-only":
        return await this.processLocal(input, privacyLevel);

      case "local-preferred":
        return await this.processLocalWithFallback(input, privacyLevel);

      case "cloud-allowed":
        return await this.processCloud(input, privacyLevel);

      case "blocked":
        throw new Error(
          "Task requires cloud processing but privacy settings disallow it"
        );
    }
  }

  /**
   * Assess privacy sensitivity of input
   */
  private assessPrivacyLevel(
    input: string,
    metadata: TaskMetadata
  ): PrivacyLevel {
    // Pattern matching for sensitive data
    const sensitivePatterns = {
      credentials: /password|api[_-]?key|token|secret/i,
      financial: /account|routing|card[_-]?number|ssn/i,
      personal: /email|phone|address|dob|birth/i,
      health: /medical|diagnosis|prescription|health/i,
    };

    // Check for sensitive patterns
    for (const [category, pattern] of Object.entries(sensitivePatterns)) {
      if (pattern.test(input)) {
        return PrivacyLevel.HIGH;
      }
    }

    // Check metadata flags
    if (metadata.containsCredentials || metadata.containsPII) {
      return PrivacyLevel.HIGH;
    }

    // Check domain context
    if (this.isSensitiveDomain(metadata.domain)) {
      return PrivacyLevel.MEDIUM;
    }

    return PrivacyLevel.LOW;
  }

  /**
   * Determine processing route based on privacy and complexity
   */
  private determineRoute(
    privacy: PrivacyLevel,
    complexity: TaskComplexity
  ): ProcessingRoute {
    // High privacy always stays local
    if (privacy === PrivacyLevel.HIGH) {
      return "local-only";
    }

    // Medium privacy prefers local, allows cloud if permitted
    if (privacy === PrivacyLevel.MEDIUM) {
      if (complexity === TaskComplexity.HIGH && this.cloudAi) {
        return "cloud-allowed";
      }
      return "local-preferred";
    }

    // Low privacy can use cloud for complex tasks
    if (complexity === TaskComplexity.HIGH && this.cloudAi) {
      return "cloud-allowed";
    }

    return "local-only";
  }

  /**
   * Process locally with maximum privacy
   */
  private async processLocal(
    input: string,
    privacyLevel: PrivacyLevel
  ): Promise<ProcessingResult> {
    const result = await this.localAi.processPrivateData(input);

    return {
      output: result,
      processingLocation: "local",
      privacyLevel,
      timestamp: Date.now(),
    };
  }

  /**
   * Try local first, fallback to cloud if local fails
   */
  private async processLocalWithFallback(
    input: string,
    privacyLevel: PrivacyLevel
  ): Promise<ProcessingResult> {
    try {
      return await this.processLocal(input, privacyLevel);
    } catch (error) {
      logger.warn("Local processing failed, attempting cloud fallback");

      // Prompt user for consent before cloud processing
      const consent = await this.requestCloudConsent(privacyLevel);
      if (!consent) {
        throw new Error("Cloud processing declined by user");
      }

      return await this.processCloud(input, privacyLevel);
    }
  }

  /**
   * Process via cloud with explicit user consent
   */
  private async processCloud(
    input: string,
    privacyLevel: PrivacyLevel
  ): Promise<ProcessingResult> {
    if (!this.cloudAi) {
      throw new Error("Cloud processing not enabled");
    }

    // Sanitize input before cloud transmission if medium privacy
    const sanitizedInput = privacyLevel === PrivacyLevel.MEDIUM
      ? this.sanitizeInput(input)
      : input;

    const result = await this.cloudAi.process(sanitizedInput);

    return {
      output: result,
      processingLocation: "cloud",
      privacyLevel,
      timestamp: Date.now(),
    };
  }

  /**
   * Request user consent for cloud processing
   */
  private async requestCloudConsent(
    privacyLevel: PrivacyLevel
  ): Promise<boolean> {
    // Show privacy-aware consent dialog
    return await showConsentDialog({
      message: `This task requires cloud processing. Your data will be sent to external servers.`,
      privacyLevel,
      allowRemember: true,
    });
  }

  /**
   * Sanitize input by removing sensitive patterns
   */
  private sanitizeInput(input: string): string {
    return input
      .replace(/\b[\w.%-]+@[\w.-]+\.[A-Z]{2,}\b/gi, "[EMAIL]")
      .replace(/\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g, "[PHONE]")
      .replace(/\b\d{3}-\d{2}-\d{4}\b/g, "[SSN]");
  }

  private isSensitiveDomain(domain: string): boolean {
    const sensitiveTLDs = [".bank", ".financial", ".health", ".gov"];
    return sensitiveTLDs.some(tld => domain.endsWith(tld));
  }
}

enum PrivacyLevel {
  HIGH = "high",      // Contains credentials, PII, financial data
  MEDIUM = "medium",  // Contains potentially sensitive context
  LOW = "low",        // Public or non-sensitive data
}

enum TaskComplexity {
  LOW = "low",        // Simple tasks: summarization, extraction
  MEDIUM = "medium",  // Moderate tasks: classification, Q&A
  HIGH = "high",      // Complex tasks: reasoning, planning
}

type ProcessingRoute = "local-only" | "local-preferred" | "cloud-allowed" | "blocked";

/**
 * Data Minimization Example
 * Only extract required fields from page content
 */
class PrivacyAwareDataExtractor {
  async extractForSummary(pageContent: string): Promise<string> {
    // Instead of sending entire page content
    // Extract only relevant sections

    const dom = new DOMParser().parseFromString(pageContent, "text/html");

    // Extract only main content, skip navigation/ads/tracking
    const mainContent = dom.querySelector("main, article, .content");
    const title = dom.querySelector("h1, title");

    // Build minimal context
    const minimalContext = `
      Title: ${title?.textContent?.trim() || "Untitled"}
      Content: ${mainContent?.textContent?.trim().slice(0, 5000) || ""}
    `.trim();

    return minimalContext;
  }

  async extractForClassification(
    pageContent: string
  ): Promise<PageMetadata> {
    // For classification, extract only metadata
    const dom = new DOMParser().parseFromString(pageContent, "text/html");

    return {
      title: dom.querySelector("title")?.textContent?.trim(),
      headings: Array.from(dom.querySelectorAll("h1, h2, h3"))
        .map(h => h.textContent?.trim())
        .filter(Boolean)
        .slice(0, 5), // Limit to first 5 headings
      wordCount: dom.body?.textContent?.split(/\s+/).length || 0,
      // No actual content included
    };
  }
}

/**
 * Purpose Limitation Example
 * Separate services for different purposes
 */
interface PurposeScope {
  purpose: "summarization" | "classification" | "extraction" | "question-answering";
  allowedDataTypes: Set<DataType>;
  retentionPolicy: "ephemeral" | "session" | "persistent";
}

class PurposeLimitedAiService {
  private readonly purposeConfig: Map<string, PurposeScope> = new Map([
    ["summarization", {
      purpose: "summarization",
      allowedDataTypes: new Set(["page-content", "article-text"]),
      retentionPolicy: "ephemeral",
    }],
    ["classification", {
      purpose: "classification",
      allowedDataTypes: new Set(["page-metadata", "headings"]),
      retentionPolicy: "ephemeral",
    }],
  ]);

  async process(
    data: any,
    purpose: string,
    dataType: DataType
  ): Promise<string> {
    // Validate purpose
    const scope = this.purposeConfig.get(purpose);
    if (!scope) {
      throw new Error(`Unknown purpose: ${purpose}`);
    }

    // Validate data type against purpose
    if (!scope.allowedDataTypes.has(dataType)) {
      throw new Error(
        `Data type ${dataType} not allowed for purpose ${purpose}`
      );
    }

    // Process according to retention policy
    switch (scope.retentionPolicy) {
      case "ephemeral":
        return await this.processEphemeral(data);
      case "session":
        return await this.processSession(data);
      case "persistent":
        throw new Error("Persistent retention not implemented for privacy");
    }
  }

  private async processEphemeral(data: any): Promise<string> {
    // Ephemeral processing with no retention
    const session = await LanguageModel.create();
    try {
      return await session.prompt(JSON.stringify(data));
    } finally {
      session.destroy();
    }
  }

  private async processSession(data: any): Promise<string> {
    // Session-scoped processing
    // Implementation details...
    throw new Error("Not implemented");
  }
}

/**
 * Transparency Example
 * Provide clear visibility into data processing
 */
class TransparentAiService {
  async processWithTransparency(
    input: string,
    options: ProcessingOptions
  ): Promise<TransparentResult> {
    const startTime = Date.now();

    // Generate privacy report before processing
    const privacyReport: PrivacyReport = {
      processingLocation: "local",
      dataTypes: this.detectDataTypes(input),
      sensitivityLevel: this.assessSensitivity(input),
      retentionPolicy: "ephemeral",
      thirdPartySharing: false,
    };

    // Process locally
    const result = await this.localProcess(input);

    // Return result with privacy metadata
    return {
      output: result,
      privacyReport,
      processingTime: Date.now() - startTime,
      modelInfo: {
        provider: "Chrome Nano AI",
        model: "Gemini Nano",
        version: await this.getModelVersion(),
      },
    };
  }

  /**
   * Generate human-readable privacy summary
   */
  getPrivacySummary(report: PrivacyReport): string {
    return `
Privacy Summary:
- Processing Location: ${report.processingLocation}
- Data Sensitivity: ${report.sensitivityLevel}
- Third-Party Sharing: ${report.thirdPartySharing ? "Yes" : "No"}
- Data Retention: ${report.retentionPolicy}
- Detected Data Types: ${report.dataTypes.join(", ")}
    `.trim();
  }

  private detectDataTypes(input: string): string[] {
    const types: string[] = [];

    if (/\b[\w.%-]+@[\w.-]+\.[A-Z]{2,}\b/gi.test(input)) {
      types.push("email");
    }
    if (/\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/.test(input)) {
      types.push("phone");
    }
    if (/password|credential/i.test(input)) {
      types.push("credentials");
    }

    return types.length > 0 ? types : ["general-text"];
  }

  private assessSensitivity(input: string): string {
    const types = this.detectDataTypes(input);

    if (types.includes("credentials")) return "high";
    if (types.includes("email") || types.includes("phone")) return "medium";
    return "low";
  }

  private async getModelVersion(): Promise<string> {
    // Retrieve model version if available
    return "gemini-nano-latest";
  }

  private async localProcess(input: string): Promise<string> {
    const session = await LanguageModel.create();
    try {
      return await session.prompt(input);
    } finally {
      session.destroy();
    }
  }
}

interface TransparentResult {
  output: string;
  privacyReport: PrivacyReport;
  processingTime: number;
  modelInfo: {
    provider: string;
    model: string;
    version: string;
  };
}

interface PrivacyReport {
  processingLocation: "local" | "cloud";
  dataTypes: string[];
  sensitivityLevel: string;
  retentionPolicy: string;
  thirdPartySharing: boolean;
}

/**
 * User Control Example
 * Comprehensive privacy settings
 */
interface PrivacyPreferences {
  // Processing preferences
  allowCloudProcessing: boolean;
  allowSessionRetention: boolean;

  // Data type controls
  allowCredentialProcessing: boolean;
  allowPIIProcessing: boolean;

  // Opt-in features
  allowTelemetry: boolean;
  allowCrashReports: boolean;
}

class UserControlledAiService {
  private preferences: PrivacyPreferences;

  constructor() {
    // Load user preferences from secure storage
    this.preferences = this.loadPreferences();
  }

  async process(input: string, context: ProcessingContext): Promise<string> {
    // Enforce privacy preferences
    this.enforcePreferences(input, context);

    // Process according to preferences
    if (this.preferences.allowCloudProcessing && context.requiresCloud) {
      return await this.cloudProcess(input);
    }

    return await this.localProcess(input);
  }

  private enforcePreferences(
    input: string,
    context: ProcessingContext
  ): void {
    // Check credential processing preference
    if (this.containsCredentials(input) &&
        !this.preferences.allowCredentialProcessing) {
      throw new Error(
        "Credential processing disabled in privacy settings"
      );
    }

    // Check PII processing preference
    if (this.containsPII(input) &&
        !this.preferences.allowPIIProcessing) {
      throw new Error(
        "PII processing disabled in privacy settings"
      );
    }

    // Check session retention preference
    if (context.requiresSessionRetention &&
        !this.preferences.allowSessionRetention) {
      throw new Error(
        "Session retention disabled in privacy settings"
      );
    }
  }

  /**
   * Allow users to update preferences
   */
  async updatePreferences(
    updates: Partial<PrivacyPreferences>
  ): Promise<void> {
    // Validate updates
    this.validatePreferences(updates);

    // Update preferences
    this.preferences = {
      ...this.preferences,
      ...updates,
    };

    // Persist to secure storage
    await this.savePreferences(this.preferences);

    // Emit event for UI updates
    this.emitPreferencesChanged(this.preferences);
  }

  /**
   * Provide export of all user data and settings
   */
  async exportUserData(): Promise<UserDataExport> {
    return {
      preferences: this.preferences,
      sessionHistory: await this.getSessionHistory(),
      exportDate: new Date().toISOString(),
      format: "JSON",
    };
  }

  /**
   * Allow complete data deletion
   */
  async deleteAllUserData(): Promise<void> {
    // Clear all stored data
    await this.clearSessionHistory();
    await this.clearPreferences();
    await this.clearCache();

    // Reset to defaults
    this.preferences = this.getDefaultPreferences();
  }

  private loadPreferences(): PrivacyPreferences {
    // Load from chrome.storage.local (secure, isolated)
    // Implementation details...
    return this.getDefaultPreferences();
  }

  private getDefaultPreferences(): PrivacyPreferences {
    return {
      allowCloudProcessing: false,      // Privacy-first default
      allowSessionRetention: false,     // No retention by default
      allowCredentialProcessing: false, // Explicit opt-in required
      allowPIIProcessing: false,        // Explicit opt-in required
      allowTelemetry: false,            // No telemetry by default
      allowCrashReports: false,         // No crash reports by default
    };
  }

  private validatePreferences(updates: Partial<PrivacyPreferences>): void {
    // Validate preference updates
    // Ensure no invalid combinations
  }

  private async savePreferences(prefs: PrivacyPreferences): Promise<void> {
    // Persist to chrome.storage.local
  }

  private emitPreferencesChanged(prefs: PrivacyPreferences): void {
    // Emit event for reactive UI updates
  }

  private containsCredentials(input: string): boolean {
    return /password|api[_-]?key|token|secret/i.test(input);
  }

  private containsPII(input: string): boolean {
    return /email|phone|ssn|address/i.test(input);
  }

  private async cloudProcess(input: string): Promise<string> {
    throw new Error("Not implemented");
  }

  private async localProcess(input: string): Promise<string> {
    const session = await LanguageModel.create();
    try {
      return await session.prompt(input);
    } finally {
      session.destroy();
    }
  }

  private async getSessionHistory(): Promise<any[]> {
    // Return session history if retention allowed
    return [];
  }

  private async clearSessionHistory(): Promise<void> {
    // Clear all session history
  }

  private async clearPreferences(): Promise<void> {
    // Clear user preferences
  }

  private async clearCache(): Promise<void> {
    // Clear all cached data
  }
}

/**
 * Secure Storage Best Practices
 * Use Chrome's encrypted storage APIs
 */
class SecureStorageService {
  /**
   * Store data in chrome.storage.local (encrypted at rest by Chrome)
   */
  async storeSecurely(key: string, value: any): Promise<void> {
    try {
      await chrome.storage.local.set({ [key]: value });
    } catch (error) {
      logger.error("Storage failed", { key, error });
      throw new Error("Failed to store data securely");
    }
  }

  /**
   * Retrieve data from secure storage
   */
  async retrieveSecurely(key: string): Promise<any> {
    try {
      const result = await chrome.storage.local.get(key);
      return result[key];
    } catch (error) {
      logger.error("Retrieval failed", { key, error });
      throw new Error("Failed to retrieve data securely");
    }
  }

  /**
   * Securely delete data
   */
  async deleteSecurely(key: string): Promise<void> {
    try {
      await chrome.storage.local.remove(key);
    } catch (error) {
      logger.error("Deletion failed", { key, error });
      throw new Error("Failed to delete data securely");
    }
  }
}

/**
 * NEVER store sensitive data in:
 * - localStorage (accessible to any same-origin script)
 * - sessionStorage (accessible to any same-origin script)
 * - Cookies (transmitted with every request)
 * - IndexedDB without encryption (accessible to any same-origin script)
 *
 * ALWAYS use:
 * - chrome.storage.local (encrypted at rest, isolated per-extension)
 * - chrome.storage.session (encrypted, session-scoped)
 */

/**
 * Input Validation Best Practices
 */
class InputValidator {
  /**
   * Validate and sanitize user input before AI processing
   */
  validateInput(input: string, options: ValidationOptions): ValidationResult {
    // Check length limits
    if (input.length > options.maxLength) {
      return {
        valid: false,
        error: `Input exceeds maximum length of ${options.maxLength}`,
      };
    }

    // Check for suspicious patterns
    if (this.containsSuspiciousPatterns(input)) {
      return {
        valid: false,
        error: "Input contains suspicious patterns",
      };
    }

    // Sanitize HTML if present
    const sanitized = options.allowHTML
      ? this.sanitizeHTML(input)
      : this.stripHTML(input);

    return {
      valid: true,
      sanitized,
    };
  }

  /**
   * Detect injection attempts
   */
  private containsSuspiciousPatterns(input: string): boolean {
    // Check for SQL injection patterns
    if (/(\b(SELECT|INSERT|UPDATE|DELETE|DROP)\b)/i.test(input)) {
      return true;
    }

    // Check for XSS patterns
    if (/<script|javascript:|onerror=/i.test(input)) {
      return true;
    }

    // Check for path traversal
    if (/\.\.(\/|\\)/.test(input)) {
      return true;
    }

    return false;
  }

  /**
   * Strip HTML tags
   */
  private stripHTML(input: string): string {
    return input.replace(/<[^>]*>/g, "");
  }

  /**
   * Sanitize HTML while preserving safe tags
   */
  private sanitizeHTML(input: string): string {
    // Use DOMPurify or similar for production
    // Simplified example:
    const allowedTags = ["p", "br", "strong", "em", "u"];
    const doc = new DOMParser().parseFromString(input, "text/html");

    // Remove disallowed tags
    const allTags = doc.querySelectorAll("*");
    allTags.forEach(tag => {
      if (!allowedTags.includes(tag.tagName.toLowerCase())) {
        tag.remove();
      }
    });

    return doc.body.innerHTML;
  }
}

interface ValidationOptions {
  maxLength: number;
  allowHTML: boolean;
}

interface ValidationResult {
  valid: boolean;
  sanitized?: string;
  error?: string;
}

{
  "manifest_version": 3,
  "name": "Privacy-First Extension",
  "content_security_policy": {
    "extension_pages": "script-src 'self'; object-src 'none'; base-uri 'self'; form-action 'none';"
  },
  "permissions": [
    "storage",
    "activeTab"
  ],
  "host_permissions": []
}

/**
 * Secure Communication Best Practices
 */
class SecureCommunicationService {
  /**
   * Make secure API requests with proper error handling
   */
  async secureRequest(
    url: string,
    options: SecureRequestOptions
  ): Promise<any> {
    // Validate URL
    if (!this.isAllowedDomain(url)) {
      throw new Error(`Domain not allowed: ${url}`);
    }

    // Ensure HTTPS
    if (!url.startsWith("https://")) {
      throw new Error("Only HTTPS connections allowed");
    }

    // Add security headers
    const headers = {
      ...options.headers,
      "X-Content-Type-Options": "nosniff",
      "X-Frame-Options": "DENY",
      "X-XSS-Protection": "1; mode=block",
    };

    try {
      const response = await fetch(url, {
        ...options,
        headers,
        credentials: "omit", // Never send cookies
        mode: "cors",
      });

      // Validate response
      if (!response.ok) {
        throw new Error(`Request failed: ${response.status}`);
      }

      return await response.json();
    } catch (error) {
      logger.error("Secure request failed", {
        url: this.sanitizeURL(url), // Don't log full URL
        error: error.message,
      });
      throw error;
    }
  }

  /**
   * Allowlist of permitted domains
   */
  private isAllowedDomain(url: string): boolean {
    const allowedDomains = [
      "api.openai.com",
      "api.anthropic.com",
      // Add other trusted domains
    ];

    try {
      const urlObj = new URL(url);
      return allowedDomains.some(domain =>
        urlObj.hostname === domain ||
        urlObj.hostname.endsWith(`.${domain}`)
      );
    } catch {
      return false;
    }
  }

  /**
   * Sanitize URL for logging (remove sensitive parameters)
   */
  private sanitizeURL(url: string): string {
    try {
      const urlObj = new URL(url);
      // Remove query parameters (may contain sensitive data)
      urlObj.search = "";
      return urlObj.toString();
    } catch {
      return "[invalid-url]";
    }
  }
}

/**
 * Privacy-Conscious Logging
 */
class PrivacyLogger {
  /**
   * Log events without exposing user data
   */
  info(message: string, metadata?: Record<string, any>): void {
    const sanitized = this.sanitizeMetadata(metadata);
    console.info(`[INFO] ${message}`, sanitized);
  }

  error(message: string, metadata?: Record<string, any>): void {
    const sanitized = this.sanitizeMetadata(metadata);
    console.error(`[ERROR] ${message}`, sanitized);
  }

  /**
   * Remove sensitive data from metadata
   */
  private sanitizeMetadata(
    metadata?: Record<string, any>
  ): Record<string, any> | undefined {
    if (!metadata) return undefined;

    const sanitized: Record<string, any> = {};

    for (const [key, value] of Object.entries(metadata)) {
      // Never log sensitive keys
      if (this.isSensitiveKey(key)) {
        sanitized[key] = "[REDACTED]";
        continue;
      }

      // Sanitize string values
      if (typeof value === "string") {
        sanitized[key] = this.sanitizeString(value);
      } else {
        sanitized[key] = value;
      }
    }

    return sanitized;
  }

  private isSensitiveKey(key: string): boolean {
    const sensitiveKeys = [
      "password",
      "token",
      "apiKey",
      "secret",
      "credential",
      "email",
      "ssn",
    ];

    return sensitiveKeys.some(sensitive =>
      key.toLowerCase().includes(sensitive)
    );
  }

  private sanitizeString(value: string): string {
    // Redact emails
    value = value.replace(
      /\b[\w.%-]+@[\w.-]+\.[A-Z]{2,}\b/gi,
      "[EMAIL]"
    );

    // Redact phone numbers
    value = value.replace(
      /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,
      "[PHONE]"
    );

    // Redact SSN
    value = value.replace(
      /\b\d{3}-\d{2}-\d{4}\b/g,
      "[SSN]"
    );

    return value;
  }
}

// Export singleton instance
export const logger = new PrivacyLogger();

┌─────────────────────────────────────────────────────────────────┐
│                        User's Device                            │
│                                                                 │
│  ┌──────────────┐                                               │
│  │  User Input  │                                               │
│  └──────┬───────┘                                               │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────────────┐                                       │
│  │  Input Validation    │                                       │
│  │  - Length check      │                                       │
│  │  - Pattern detection │                                       │
│  │  - Sanitization      │                                       │
│  └──────┬───────────────┘                                       │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────────────┐                                       │
│  │  Privacy Assessment  │                                       │
│  │  - Sensitivity check │                                       │
│  │  - Route decision    │                                       │
│  └──────┬───────────────┘                                       │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────────────┐                                       │
│  │  Session Creation    │                                       │
│  │  - Ephemeral session │                                       │
│  │  - No persistence    │                                       │
│  └──────┬───────────────┘                                       │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────────────┐                                       │
│  │  Gemini Nano Model   │                                       │
│  │  - Local inference   │                                       │
│  │  - No network calls  │                                       │
│  └──────┬───────────────┘                                       │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────────────┐                                       │
│  │  Result Processing   │                                       │
│  │  - Format result     │                                       │
│  │  - Privacy metadata  │                                       │
│  └──────┬───────────────┘                                       │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────────────┐                                       │
│  │  Session Cleanup     │                                       │
│  │  - Destroy session   │                                       │
│  │  - Clear memory      │                                       │
│  └──────┬───────────────┘                                       │
│         │                                                       │
│         ▼                                                       │
│  ┌──────────────────────┐                                       │
│  │  Display to User     │                                       │
│  └──────────────────────┘                                       │
│                                                                 │
│  NO DATA LEAVES DEVICE AT ANY POINT                             │
└─────────────────────────────────────────────────────────────────┘

/**
 * Network traffic verification test
 */
async function verifyNoNetworkTraffic(): Promise<boolean> {
  // Monitor network requests during AI processing
  const requestsBeforeProcessing = performance.getEntriesByType("resource").length;

  // Perform AI processing
  const service = new EphemeralAiService();
  await service.processPrivateData("Test sensitive input");

  // Check network requests after processing
  const requestsAfterProcessing = performance.getEntriesByType("resource").length;

  // Verify no new network requests
  const newRequests = requestsAfterProcessing - requestsBeforeProcessing;

  if (newRequests > 0) {
    console.error(`Privacy violation: ${newRequests} network requests detected`);
    return false;
  }

  console.log("✓ Privacy verified: No network traffic generated");
  return true;
}

/**
 * Storage audit test
 */
async function auditDataPersistence(): Promise<AuditReport> {
  const report: AuditReport = {
    passed: true,
    violations: [],
  };

  // Check chrome.storage.local
  const localStorage = await chrome.storage.local.get(null);
  for (const [key, value] of Object.entries(localStorage)) {
    if (this.containsSensitiveData(value)) {
      report.passed = false;
      report.violations.push({
        location: "chrome.storage.local",
        key,
        issue: "Sensitive data found in storage",
      });
    }
  }

  // Check chrome.storage.session
  const sessionStorage = await chrome.storage.session.get(null);
  for (const [key, value] of Object.entries(sessionStorage)) {
    if (this.containsSensitiveData(value)) {
      report.passed = false;
      report.violations.push({
        location: "chrome.storage.session",
        key,
        issue: "Sensitive data found in session storage",
      });
    }
  }

  if (report.passed) {
    console.log("✓ Storage audit passed: No sensitive data persisted");
  } else {
    console.error("✗ Storage audit failed:", report.violations);
  }

  return report;
}

interface AuditReport {
  passed: boolean;
  violations: Array<{
    location: string;
    key: string;
    issue: string;
  }>;
}

/**
 * Memory leak detection test
 */
async function detectMemoryLeaks(): Promise<void> {
  // Take initial memory snapshot
  const initialMemory = (performance as any).memory?.usedJSHeapSize || 0;

  // Perform multiple AI operations
  for (let i = 0; i < 100; i++) {
    const service = new EphemeralAiService();
    await service.processPrivateData(`Test input ${i}`);
    // Service should go out of scope and be garbage collected
  }

  // Force garbage collection if available
  if (global.gc) {
    global.gc();
  }

  // Take final memory snapshot
  await new Promise(resolve => setTimeout(resolve, 1000)); // Wait for GC
  const finalMemory = (performance as any).memory?.usedJSHeapSize || 0;

  const memoryGrowth = finalMemory - initialMemory;
  const maxAcceptableGrowth = 10 * 1024 * 1024; // 10MB

  if (memoryGrowth > maxAcceptableGrowth) {
    console.error(
      `Potential memory leak: ${memoryGrowth} bytes growth after 100 operations`
    );
  } else {
    console.log("✓ No memory leaks detected");
  }
}

/**
 * Code integrity verification
 */
async function verifyCodeIntegrity(): Promise<boolean> {
  // Verify critical code hasn't been tampered with
  const expectedHashes = {
    "aiService.js": "abc123...",
    "storageService.js": "def456...",
  };

  for (const [file, expectedHash] of Object.entries(expectedHashes)) {
    const code = await fetchExtensionFile(file);
    const actualHash = await sha256(code);

    if (actualHash !== expectedHash) {
      console.error(`Integrity violation: ${file} has been modified`);
      return false;
    }
  }

  return true;
}

/**
 * Constant-time string comparison
 */
function constantTimeEquals(a: string, b: string): boolean {
  if (a.length !== b.length) {
    return false;
  }

  let result = 0;
  for (let i = 0; i < a.length; i++) {
    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
  }

  return result === 0;
}

/**
 * Session timeout for enhanced security
 */
class TimeoutProtectedAiService {
  private session: LanguageModelSession | null = null;
  private sessionTimeout: number = 10 * 60 * 1000; // 10 minutes
  private sessionTimer: ReturnType<typeof setTimeout> | null = null;

  async createSession(): Promise<void> {
    this.session = await LanguageModel.create();
    this.resetSessionTimer();
  }

  async process(input: string): Promise<string> {
    if (!this.session) {
      throw new Error("No active session");
    }

    const result = await this.session.prompt(input);
    this.resetSessionTimer(); // Reset on activity

    return result;
  }

  private resetSessionTimer(): void {
    if (this.sessionTimer) {
      clearTimeout(this.sessionTimer);
    }

    this.sessionTimer = setTimeout(() => {
      this.destroySession();
      console.log("Session expired due to inactivity");
    }, this.sessionTimeout);
  }

  private destroySession(): void {
    if (this.session) {
      this.session.destroy();
      this.session = null;
    }

    if (this.sessionTimer) {
      clearTimeout(this.sessionTimer);
      this.sessionTimer = null;
    }
  }
}

/**
 * GDPR-compliant data management
 */
class GDPRCompliantService {
  /**
   * Right to Access (Article 15)
   */
  async exportUserData(userId: string): Promise<UserDataExport> {
    return {
      userData: await this.getUserData(userId),
      processingHistory: await this.getProcessingHistory(userId),
      preferences: await this.getUserPreferences(userId),
      exportDate: new Date().toISOString(),
      format: "JSON",
    };
  }

  /**
   * Right to Erasure (Article 17)
   */
  async deleteUserData(userId: string): Promise<void> {
    await Promise.all([
      this.deleteUserSettings(userId),
      this.deleteProcessingHistory(userId),
      this.deleteCache(userId),
    ]);

    logger.info("User data deleted per GDPR Article 17", { userId });
  }

  /**
   * Right to Data Portability (Article 20)
   */
  async exportInStandardFormat(userId: string): Promise<StandardExport> {
    const data = await this.exportUserData(userId);

    return {
      version: "1.0",
      standard: "GDPR Article 20",
      data,
    };
  }

  /**
   * Processing transparency (Article 13/14)
   */
  getProcessingInformation(): ProcessingInfo {
    return {
      controller: "Extension Developer Name",
      purpose: "Browser automation and AI assistance",
      legalBasis: "Legitimate interest (on-device processing)",
      retentionPeriod: "Session-only (ephemeral)",
      recipients: "None (on-device only)",
      thirdCountryTransfer: "None",
      userRights: [
        "Access (Article 15)",
        "Rectification (Article 16)",
        "Erasure (Article 17)",
        "Portability (Article 20)",
      ],
    };
  }

  private async getUserData(userId: string): Promise<any> {
    // Implementation
    return {};
  }

  private async getProcessingHistory(userId: string): Promise<any[]> {
    // Implementation
    return [];
  }

  private async getUserPreferences(userId: string): Promise<any> {
    // Implementation
    return {};
  }

  private async deleteUserSettings(userId: string): Promise<void> {
    // Implementation
  }

  private async deleteProcessingHistory(userId: string): Promise<void> {
    // Implementation
  }

  private async deleteCache(userId: string): Promise<void> {
    // Implementation
  }
}

/**
 * HIPAA-compliant healthcare extension
 */
class HIPAACompliantService {
  /**
   * Process healthcare data with audit trail
   */
  async processHealthData(
    phi: HealthData,
    context: ProcessingContext
  ): Promise<ProcessedResult> {
    // Log access (without logging actual PHI)
    await this.auditLog.recordAccess({
      userId: context.userId,
      action: "process_health_data",
      timestamp: Date.now(),
      dataType: phi.type,
      // No actual PHI logged
    });

    // Process on-device only
    const session = await LanguageModel.create();
    try {
      const result = await session.prompt(
        `Analyze health data: ${JSON.stringify(phi)}`
      );

      return {
        result,
        processingLocation: "local",
        complianceMetadata: {
          hipaaCompliant: true,
          phiTransmitted: false,
          baaCovered: false,
        },
      };
    } finally {
      session.destroy();
    }
  }
}

class OptimizedHybridService {
  async process(
    input: string,
    requirements: TaskRequirements
  ): Promise<string> {
    // Privacy-sensitive → always local
    if (requirements.privacySensitive) {
      return await this.processLocal(input);
    }

    // Complex reasoning + not sensitive → cloud OK
    if (requirements.complexReasoning && !requirements.privacySensitive) {
      return await this.processCloud(input);
    }

    // Simple tasks → local (faster + free)
    return await this.processLocal(input);
  }
}

class ContextOptimizer {
  async optimizeForLocalProcessing(
    pageContent: string
  ): Promise<string> {
    // Extract only relevant sections
    const dom = new DOMParser().parseFromString(pageContent, "text/html");

    // Remove script, style, nav, footer
    dom.querySelectorAll("script, style, nav, footer, aside").forEach(
      el => el.remove()
    );

    // Extract main content
    const main = dom.querySelector("main, article, .content");

    // Limit to 5000 characters (fits comfortably in Nano's context)
    const extracted = main?.textContent?.trim().slice(0, 5000) || "";

    return extracted;
  }
}

class CachingAiService {
  private cache: Map<string, CachedResult> = new Map();
  private cacheTTL: number = 60 * 60 * 1000; // 1 hour

  async processWithCache(
    input: string,
    cacheable: boolean
  ): Promise<string> {
    // Check cache for non-sensitive, cacheable requests
    if (cacheable) {
      const cacheKey = await this.hashInput(input);
      const cached = this.cache.get(cacheKey);

      if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
        logger.info("Cache hit", { cacheKey });
        return cached.result;
      }
    }

    // Process with on-device AI
    const result = await this.processLocal(input);

    // Cache result if appropriate
    if (cacheable && !this.containsSensitiveData(result)) {
      const cacheKey = await this.hashInput(input);
      this.cache.set(cacheKey, {
        result,
        timestamp: Date.now(),
      });
    }

    return result;
  }

  private async hashInput(input: string): Promise<string> {
    const encoder = new TextEncoder();
    const data = encoder.encode(input);
    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
    const hashArray = Array.from(new Uint8Array(hashBuffer));
    return hashArray.map(b => b.toString(16).padStart(2, "0")).join("");
  }

  private containsSensitiveData(data: string): boolean {
    // Check for patterns indicating sensitive data
    return /password|token|credential|ssn|account/i.test(data);
  }

  private async processLocal(input: string): Promise<string> {
    const session = await LanguageModel.create();
    try {
      return await session.prompt(input);
    } finally {
      session.destroy();
    }
  }
}