massively simplify and improve file parsing

src/hooks/useFileUpload.ts

···
-import { parseFile, PlatformParseError } from '../lib/platforms/parser';
-import type { SocialUser } from '../lib/platforms/types';
+import { parseDataFile } from '../lib/fileExtractor';
 import type { SearchResult } from '../types';
 
 export function useFileUpload(
···
     if (!file) return;
 
     onStatusUpdate(`Processing ${file.name}...`);
-    let users: SocialUser[] = [];
+    let usernames: string[] = [];
 
     try {
-      // Use the new platform-based parser
-      users = await parseFile(file, platform);
+      usernames = await parseDataFile(file, platform);
       
-      console.log(`Loaded ${users.length} users from ${platform} data`);
-      onStatusUpdate(`Loaded ${users.length} users from ${platform} data`);
+      console.log(`Loaded ${usernames.length} users from ${platform} data`);
+      onStatusUpdate(`Loaded ${usernames.length} users from ${platform} data`);
     } catch (error) {
       console.error("Error processing file:", error);
       
-      const errorMsg = error instanceof PlatformParseError 
+      const errorMsg = error instanceof Error 
         ? error.message
         : "There was a problem processing the file. Please check that it's a valid data export.";
       
···
       return;
     }
     
-    if (users.length === 0) {
+    if (usernames.length === 0) {
       const errorMsg = "No users found in the file.";
       onStatusUpdate(errorMsg);
       alert(errorMsg);
       return;
     }
 
-    // Initialize search results
-    const initialResults: SearchResult[] = users.map(user => ({
-      sourceUser: user,
+    // Initialize search results - convert usernames to SearchResult format
+    const initialResults: SearchResult[] = usernames.map(username => ({
+      sourceUser: {
+        username: username,
+        date: ''
+      },
       atprotoMatches: [],
       isSearching: false,
       selectedMatches: new Set<string>(),
       sourcePlatform: platform
     }));
 
-    onStatusUpdate(`Starting search for ${users.length} users...`);
+    onStatusUpdate(`Starting search for ${usernames.length} users...`);
     onSearchStart(initialResults, platform);
   }
 

src/lib/fileExtractor.ts

···
+import JSZip from 'jszip';
+import { ParseRule, getRulesForPlatform, FileFormat } from './platformDefinitions';
+import { parseContent } from './parserLogic';
+
+// Type for the final aggregated results
+export interface ExtractionResults {
+    allExtracted: Record<string, string[]>;
+    uniqueUsernames: string[];
+}
+
+export class DataExtractor {
+    private file: File | ArrayBuffer | Blob;
+
+    constructor(file: File | ArrayBuffer | Blob) {
+        this.file = file;
+    }
+
+    public async processZipArchive(zip: JSZip, rules: ParseRule[]): Promise<ExtractionResults> {
+        /** Core logic for extracting usernames from a successfully loaded ZIP archive. */
+        const allExtracted: Record<string, string[]> = {};
+        const uniqueUsernames: Set<string> = new Set();
+
+        for (let i = 0; i < rules.length; i++) {
+            const rule = rules[i];
+            const ruleId = `Rule_${i + 1}_${rule.zipPath}`;
+            console.log(`Processing ZIP file path ${rule.zipPath} (Format: ${rule.format})`);
+            
+            // 1. Get file object from ZIP
+            const fileInZip = zip.file(rule.zipPath);
+            if (!fileInZip) {
+                console.warn(`WARNING: File not found in ZIP: '${rule.zipPath}'. Skipping rule.`);
+                continue;
+            }
+
+            try {
+                // 2. Read content asynchronously
+                const content = await fileInZip.async("string");
+                
+                // 3. Apply appropriate parsing logic
+                const extracted = parseContent(content, rule);
+                
+                // 4. Store results
+                allExtracted[ruleId] = extracted;
+                extracted.forEach(name => uniqueUsernames.add(name));
+
+            } catch (e) {
+                console.error(`ERROR reading file ${rule.zipPath} from ZIP:`, e);
+            }
+        }
+
+        return {
+            allExtracted,
+            uniqueUsernames: Array.from(uniqueUsernames).sort()
+        };
+    }
+}
+
+/**
+ * Public facing function handling both ZIP and single files.
+ * @param file A File object (or ArrayBuffer/Blob) representing the uploaded data.
+ * @param platform The platform name (e.g., 'instagram', 'tiktok').
+ * @returns A promise that resolves to an array of unique usernames (string[]).
+ */
+export async function parseDataFile(file: File | ArrayBuffer | Blob, platform: string): Promise<string[]> {
+    const rules = getRulesForPlatform(platform);
+    
+    if (rules.length === 0) {
+        console.error(`No parsing rules found for platform: ${platform}`);
+        return [];
+    }
+
+    // 1. --- ATTEMPT ZIP LOAD ---
+    try {
+        console.log("Attempting to load file as ZIP archive...");
+        const zip = await JSZip.loadAsync(file);
+        
+        const extractor = new DataExtractor(file);
+        const results = await extractor.processZipArchive(zip, rules);
+        
+        console.log(`Successfully extracted ${results.uniqueUsernames.length} usernames from ZIP archive.`);
+        return results.uniqueUsernames;
+
+    } catch (e) {
+        // 2. --- ZIP LOAD FAILED, ATTEMPT SINGLE FILE ---
+        console.warn("ZIP load failed. Attempting to parse file as a single data file...");
+        
+        // We need a File object to get the name and content easily
+        if (!(file instanceof File) && !(file instanceof Blob)) {
+            console.error("Input failed ZIP check and lacks a name/content structure for single file parsing (must be File or Blob).");
+            return [];
+        }
+
+        const singleFile = file as File;
+        
+        // Find the rule that matches the uploaded file name
+        // We check if the uploaded filename ends with the final part of a rule's zipPath (e.g., "following.html")
+        const matchingRule = rules.find(rule => 
+            singleFile.name.toLowerCase().endsWith((rule.zipPath.split('/').pop() || '').toLowerCase())
+        );
+
+        if (!matchingRule) {
+            console.error(`Could not match single file '${singleFile.name}' to any rule for platform ${platform}. Check rules in platformDefinitions.ts.`);
+            return [];
+        }
+
+        console.log(`Matched single file '${singleFile.name}' to rule: ${matchingRule.zipPath}`);
+
+        // 3. Process as single file content
+        try {
+            const content = await singleFile.text();
+            const extracted = parseContent(content, matchingRule);
+
+            const uniqueUsernames = Array.from(new Set(extracted)).sort();
+            console.log(`Successfully extracted ${uniqueUsernames.length} unique usernames from single file.`);
+            
+            return uniqueUsernames;
+            
+        } catch (contentError) {
+            console.error("Error reading content of single file:", contentError);
+            return [];
+        }
+    }
+}

src/lib/parserLogic.ts

···
+import { ParseRule, FileFormat } from './platformDefinitions';
+
+/**
+ * Parses content using a regular expression.
+ * @param content The string content (HTML or plain text) to search within.
+ * @param regexPattern The regex string defining the capture group for the username.
+ * @returns An array of extracted usernames.
+ */
+export function parseTextOrHtml(content: string, regexPattern: string): string[] {
+    try {
+        // 'g' for global matching, 's' for multiline (DOTALL equivalent)
+        const pattern = new RegExp(regexPattern, 'gs');
+        
+        // matchAll returns an iterator of matches; we spread it into an array.
+        const matches = [...content.matchAll(pattern)];
+        
+        // We map the results to the first captured group (match[1]), filtering out empty results.
+        return matches.map(match => match[1]).filter(name => !!name); 
+        
+    } catch (e) {
+        console.error(`ERROR: Invalid regex pattern '${regexPattern}':`, e);
+        return [];
+    }
+}
+
+/**
+ * Traverses a JSON object structure to extract usernames from a nested array of objects.
+ * Assumes the common pattern: navigate to an array, and extract a key from each object in that array.
+ * @param content The JSON content as a string.
+ * @param pathKeys The array of keys defining the path, where the second to last key is the array key, and the last key is the target username field.
+ * @returns An array of extracted usernames.
+ */
+export function parseJson(content: string, pathKeys: string[]): string[] {
+    try {
+        const data = JSON.parse(content);
+        const usernames: string[] = [];
+
+        if (pathKeys.length < 2) {
+            console.error("JSON rule must have at least two path keys (list key and target key).");
+            return [];
+        }
+
+        // Determine the navigation path
+        let currentData: any = data;
+        const listContainerPath = pathKeys.slice(0, -2);
+        const listKey = pathKeys[pathKeys.length - 2];
+        const targetKey = pathKeys[pathKeys.length - 1];
+
+        // 1. Traverse down to the object containing the target array
+        for (const key of listContainerPath) {
+            if (typeof currentData === 'object' && currentData !== null && key in currentData) {
+                currentData = currentData[key];
+            } else {
+                console.error(`ERROR: Could not traverse JSON path up to key: ${key}. Path: ${listContainerPath.join(' -> ')}`);
+                return [];
+            }
+        }
+
+        // 2. Check if the penultimate key holds the array
+        if (typeof currentData === 'object' && currentData !== null && listKey in currentData) {
+            const userList = currentData[listKey];
+
+            if (Array.isArray(userList)) {
+                // 3. Iterate over the array and extract the final target key
+                for (const item of userList) {
+                    if (typeof item === 'object' && item !== null && targetKey in item) {
+                        // Found the username
+                        usernames.push(String(item[targetKey]));
+                    }
+                }
+            } else {
+                console.error(`ERROR: Expected an array at key '${listKey}' but found a different type.`);
+            }
+        } else {
+            console.error(`ERROR: List key '${listKey}' not found at its expected position.`);
+        }
+
+        return usernames;
+
+    } catch (e) {
+        if (e instanceof SyntaxError) {
+            console.error(`ERROR: Could not decode JSON content:`, e);
+        } else {
+            console.error(`An unexpected error occurred during JSON parsing:`, e);
+        }
+        return [];
+    }
+}
+
+/**
+ * Universal wrapper to apply the correct parsing method based on the rule's format.
+ * @param content The file content as a string.
+ * @param rule The ParseRule to apply.
+ * @returns An array of extracted usernames.
+ */
+export function parseContent(content: string, rule: ParseRule): string[] {
+    if (rule.format === 'HTML' || rule.format === 'TEXT') {
+        if (typeof rule.rule === 'string') {
+            return parseTextOrHtml(content, rule.rule);
+        }
+    } else if (rule.format === 'JSON') {
+        if (Array.isArray(rule.rule)) {
+            return parseJson(content, rule.rule);
+        }
+    }
+    console.error(`ERROR: Unsupported format or invalid rule type for rule with path: ${rule.zipPath}`);
+    return [];
+}

src/lib/platformDefinitions.ts

···
+// Use string literals for type safety on formats
+export type FileFormat = 'HTML' | 'TEXT' | 'JSON';
+
+// Define the structure for a single parsing rule
+export interface ParseRule {
+    zipPath: string; // File path *inside* the ZIP archive
+    format: FileFormat; // Expected format of the file, e.g. 'HTML', 'TEXT', 'JSON'
+    rule: string | string[]; // specific extraction rule (regex pattern string or JSON key path array)
+}
+
+/*
+    PLATFORM DEFINITIONS
+    This constant holds all the defined extraction rules, grouped by platform.
+*/
+
+export const PLATFORM_RULES: Record<string, ParseRule[]> = {
+    
+    "instagram": [
+        {
+            zipPath: "connections/followers_and_following/following.html",
+            format: "HTML",
+            // Regex captures the username group 'beautyscicomm' from the URL:
+            // https://www.instagram.com/_u/beautyscicomm
+            // Note: The 'g' and 's' flags are handled in the extractor method.
+            rule: '<a target="_blank" href="https://www.instagram.com/_u/([^"]+)"'
+        },
+        {
+            zipPath: "connections/followers_and_following/following.json",
+            format: "JSON",
+            rule: ["relationships_following", "title"]
+        }
+    ],
+
+    "tiktok": [
+        {
+            zipPath: "TikTok/Profile and Settings/Following.txt",
+            format: "TEXT",
+            // Regex captures the text after "Username: " on the same line
+            rule: "Username:\s*([^\r\n]+)"
+        },
+        {
+            zipPath: "tiktok.json",
+            format: "JSON",
+            // JSON key path to traverse: ['Your Activity'] -> ['Following'] -> ['Following'] -> 'UserName'
+            rule: ["Your Activity", "Following", "Following", "UserName"]
+        }
+    ],
+};
+
+export function getRulesForPlatform(platformName: string): ParseRule[] {
+    // Retrieves the list of parsing rules for a given platform.
+    return PLATFORM_RULES[platformName.toLowerCase()] || [];
+}

src/lib/platforms/instagram.ts

···
-// src/lib/platforms/instagram.ts
-
-import type { PlatformConfig, PlatformParser, FileBundle, SocialUser } from './types';
-import { PlatformParseError } from './types';
-
-// HTML Parser for Instagram following.html
-const htmlParser: PlatformParser = {
-  name: 'Instagram HTML',
-  canParse: (bundle: FileBundle) => {
-    for (const [_, file] of bundle.files) {
-      if (file.type === 'html' && file.name.toLowerCase().includes('following')) {
-        return file.content.includes('_a6-g') || file.content.includes('uiBoxWhite');
-      }
-    }
-    return false;
-  },
-  parse: async (bundle: FileBundle) => {
-    const users: SocialUser[] = [];
-    
-    // Find HTML file
-    let htmlContent = '';
-    for (const [_, file] of bundle.files) {
-      if (file.type === 'html' && file.name.toLowerCase().includes('following')) {
-        htmlContent = file.content;
-        break;
-      }
-    }
-    
-    if (!htmlContent) {
-      throw new PlatformParseError('No Instagram following.html file found', 'instagram');
-    }
-    
-    // Parse the HTML
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(htmlContent, 'text/html');
-    
-    // Instagram following data is in specific divs
-    const userDivs = doc.querySelectorAll('div.pam._3-95._2ph-._a6-g.uiBoxWhite.noborder');
-    
-    userDivs.forEach((div) => {
-      const h2 = div.querySelector('h2._3-95._2pim._a6-h._a6-i');
-      const dateDiv = div.querySelector('div._a6-p > div > div:nth-child(2)');
-      
-      if (h2) {
-        const username = h2.textContent?.trim();
-        const date = dateDiv?.textContent?.trim() || '';
-        
-        if (username) {
-          users.push({
-            username: username,
-            date: date
-          });
-        }
-      }
-    });
-    
-    if (users.length === 0) {
-      throw new PlatformParseError(
-        'No following data found in Instagram HTML file',
-        'instagram'
-      );
-    }
-    
-    return users;
-  }
-};
-
-// JSON Parser for Instagram JSON exports
-const jsonParser: PlatformParser = {
-  name: 'Instagram JSON',
-  canParse: (bundle: FileBundle) => {
-    for (const [_, file] of bundle.files) {
-      if (file.type === 'json') {
-        try {
-          const data = JSON.parse(file.content);
-          return !!(data?.relationships_following || data?.following);
-        } catch {
-          return false;
-        }
-      }
-    }
-    return false;
-  },
-  parse: async (bundle: FileBundle) => {
-    const users: SocialUser[] = [];
-    
-    // Find and parse JSON file
-    for (const [_, file] of bundle.files) {
-      if (file.type === 'json') {
-        try {
-          const jsonData = JSON.parse(file.content);
-          
-          // Instagram JSON exports can have different structures
-          let followingArray = jsonData?.relationships_following;
-          
-          if (!followingArray && jsonData?.following) {
-            followingArray = jsonData.following;
-          }
-          
-          if (!Array.isArray(followingArray)) {
-            continue;
-          }
-          
-          for (const entry of followingArray) {
-            const username = entry.string_list_data?.[0]?.value || entry.username || entry.handle;
-            const timestamp = entry.string_list_data?.[0]?.timestamp || entry.timestamp;
-            
-            if (username) {
-              users.push({
-                username: username,
-                date: timestamp ? new Date(timestamp * 1000).toISOString() : ''
-              });
-            }
-          }
-          
-          if (users.length > 0) {
-            return users;
-          }
-        } catch (e) {
-          continue;
-        }
-      }
-    }
-    
-    throw new PlatformParseError(
-      'No valid Instagram JSON data found. Expected relationships_following or following array',
-      'instagram'
-    );
-  }
-};
-
-// Instagram Platform Configuration
-export const instagramPlatform: PlatformConfig = {
-  id: 'instagram',
-  name: 'Instagram',
-  parsers: [htmlParser, jsonParser], // Try HTML first (most common)
-  expectedFiles: ['following.html', 'connections.json', 'followers_and_following.json'],
-  validate: (bundle: FileBundle) => {
-    // Check if bundle contains Instagram-like files
-    for (const [path, file] of bundle.files) {
-      if (path.toLowerCase().includes('instagram') ||
-          path.toLowerCase().includes('connections') ||
-          (file.name.toLowerCase().includes('following') && file.type === 'html')) {
-        return true;
-      }
-    }
-    return false;
-  }
-};

src/lib/platforms/parser.ts

···
-import JSZip from "jszip";
-import type { FileBundle, SocialUser } from './types';
-import { PlatformParseError } from './types';
-import { getPlatform } from './registry';
-
-// Convert a file into a FileBundle (extract ZIP if needed)
-async function createBundle(file: File): Promise<FileBundle> {
-  const bundle: FileBundle = {
-    files: new Map(),
-    originalFileName: file.name
-  };
-
-  if (file.name.endsWith('.zip')) {
-    // Extract ZIP contents
-    const zip = await JSZip.loadAsync(file);
-    
-    for (const [path, zipEntry] of Object.entries(zip.files)) {
-      if (zipEntry.dir) continue; // Skip directories
-      
-      const content = await zipEntry.async('string');
-      const fileName = path.split('/').pop() || path;
-      
-      // Determine file type
-      let type: 'text' | 'html' | 'json' = 'text';
-      if (fileName.endsWith('.html')) type = 'html';
-      else if (fileName.endsWith('.json')) type = 'json';
-      else if (fileName.endsWith('.txt')) type = 'text';
-      
-      bundle.files.set(path, {
-        name: fileName,
-        content,
-        type
-      });
-    }
-  } else {
-    // Single file
-    const content = await file.text();
-    let type: 'text' | 'html' | 'json' = 'text';
-    
-    if (file.name.endsWith('.html')) type = 'html';
-    else if (file.name.endsWith('.json')) type = 'json';
-    else if (file.name.endsWith('.txt')) type = 'text';
-    
-    bundle.files.set(file.name, {
-      name: file.name,
-      content,
-      type
-    });
-  }
-
-  return bundle;
-}
-
-/**
- * Parse a file for a specific platform
- */
-export async function parseFile(file: File, platformId: string): Promise<SocialUser[]> {
-  // Get platform config
-  const platform = getPlatform(platformId);
-  if (!platform) {
-    throw new PlatformParseError(
-      `Platform '${platformId}' is not supported`,
-      platformId
-    );
-  }
-
-  // Create file bundle
-  const bundle = await createBundle(file);
-
-  if (bundle.files.size === 0) {
-    throw new PlatformParseError(
-      'No files found in upload',
-      platformId
-    );
-  }
-
-  // Validate bundle contains expected files (optional check)
-  if (!platform.validate(bundle)) {
-    const expectedFiles = platform.expectedFiles.join(', ');
-    throw new PlatformParseError(
-      `File doesn't appear to be ${platform.name} data. Expected files like: ${expectedFiles}`,
-      platformId
-    );
-  }
-
-  // Try each parser in order
-  const errors: string[] = [];
-  
-  for (const parser of platform.parsers) {
-    if (!parser.canParse(bundle)) {
-      continue; // Skip parsers that can't handle this bundle
-    }
-    
-    try {
-      const users = await parser.parse(bundle);
-      
-      if (users.length === 0) {
-        errors.push(`${parser.name}: No users found`);
-        continue;
-      }
-      
-      console.log(`Successfully parsed ${users.length} users using ${parser.name}`);
-      return users;
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : 'Unknown error';
-      errors.push(`${parser.name}: ${errorMsg}`);
-      console.warn(`${parser.name} failed:`, errorMsg);
-    }
-  }
-
-  // All parsers failed
-  throw new PlatformParseError(
-    `Could not parse ${platform.name} data. Tried: ${errors.join('; ')}`,
-    platformId
-  );
-}
-
-// Export for backwards compatibility
-export { PlatformParseError } from './types';
-export type { SocialUser } from './types';

src/lib/platforms/registry.ts

···
-import type { PlatformConfig } from './types';
-import { tiktokPlatform } from './tiktok';
-import { instagramPlatform } from './instagram';
-
-// Registry of all supported platforms
-const platformRegistry = new Map<string, PlatformConfig>();
-
-// Register platforms
-platformRegistry.set('tiktok', tiktokPlatform);
-platformRegistry.set('instagram', instagramPlatform);
-
-// Future platforms can be added here:
-// platformRegistry.set('twitter', twitterPlatform);
-// platformRegistry.set('youtube', youtubePlatform);
-
-export function getPlatform(platformId: string): PlatformConfig | undefined {
-  return platformRegistry.get(platformId);
-}
-
-export function getAllPlatforms(): PlatformConfig[] {
-  return Array.from(platformRegistry.values());
-}
-
-export function isPlatformSupported(platformId: string): boolean {
-  return platformRegistry.has(platformId);
-}

src/lib/platforms/tiktok.ts

···
-import type { PlatformConfig, PlatformParser, FileBundle, SocialUser } from './types';
-import { PlatformParseError } from './types';
-
-// TXT Parser for TikTok Following.txt format
-const txtParser: PlatformParser = {
-  name: 'TikTok TXT',
-  canParse: (bundle: FileBundle) => {
-    // Look for .txt files that might be TikTok format
-    for (const [_, file] of bundle.files) {
-      if (file.name.toLowerCase().includes('following') && file.type === 'text') {
-        return file.content.includes('Username:');
-      }
-    }
-    return false;
-  },
-  parse: async (bundle: FileBundle) => {
-    const users: SocialUser[] = [];
-    
-    // Find the TikTok following.txt file
-    let content = '';
-    for (const [_, file] of bundle.files) {
-      if (file.name.toLowerCase().includes('following') && file.type === 'text') {
-        content = file.content;
-        break;
-      }
-    }
-    
-    if (!content) {
-      throw new PlatformParseError('No TikTok following.txt file found', 'tiktok');
-    }
-    
-    const entries = content.split("\n\n").map((b) => b.trim()).filter(Boolean);
-    
-    for (const entry of entries) {
-      const userMatch = entry.match(/Username:\s*(.+)/);
-      if (userMatch) {
-        users.push({ username: userMatch[1].trim(), date: "" });
-      }
-    }
-    
-    return users;
-  }
-};
-
-// JSON Parser for TikTok JSON exports
-const jsonParser: PlatformParser = {
-  name: 'TikTok JSON',
-  canParse: (bundle: FileBundle) => {
-    for (const [_, file] of bundle.files) {
-      if (file.type === 'json') {
-        try {
-          const data = JSON.parse(file.content);
-          return !!data?.["Your Activity"]?.["Following"]?.["Following"];
-        } catch {
-          return false;
-        }
-      }
-    }
-    return false;
-  },
-  parse: async (bundle: FileBundle) => {
-    const users: SocialUser[] = [];
-    
-    // Find and parse JSON file
-    for (const [_, file] of bundle.files) {
-      if (file.type === 'json') {
-        try {
-          const jsonData = JSON.parse(file.content);
-          const followingArray = jsonData?.["Your Activity"]?.["Following"]?.["Following"];
-          
-          if (!followingArray || !Array.isArray(followingArray)) {
-            continue;
-          }
-          
-          for (const entry of followingArray) {
-            users.push({
-              username: entry.UserName,
-              date: entry.Date || "",
-            });
-          }
-          
-          if (users.length > 0) {
-            return users;
-          }
-        } catch (e) {
-          continue;
-        }
-      }
-    }
-    
-    throw new PlatformParseError(
-      'No valid TikTok JSON data found. Expected path: Your Activity > Following > Following',
-      'tiktok'
-    );
-  }
-};
-
-// TikTok Platform Configuration
-export const tiktokPlatform: PlatformConfig = {
-  id: 'tiktok',
-  name: 'TikTok',
-  parsers: [txtParser, jsonParser], // Try TXT first (most common)
-  expectedFiles: ['Following.txt', 'user_data.json'],
-  validate: (bundle: FileBundle) => {
-    // Check if bundle contains TikTok-like files
-    for (const [path, file] of bundle.files) {
-      if (path.toLowerCase().includes('tiktok') || 
-          (file.name.toLowerCase().includes('following') && file.type === 'text')) {
-        return true;
-      }
-    }
-    return false;
-  }
-};

src/lib/platforms/types.ts

···
-export interface SocialUser {
-  username: string;
-  date: string;
-}
-
-export interface FileBundle {
-  files: Map<string, { name: string; content: string; type: 'text' | 'html' | 'json' }>;
-  originalFileName: string;
-}
-
-export interface PlatformParser {
-  name: string;
-  parse: (bundle: FileBundle) => Promise<SocialUser[]>;
-  canParse: (bundle: FileBundle) => boolean;
-}
-
-export interface PlatformConfig {
-  id: string;
-  name: string;
-  parsers: PlatformParser[];
-  expectedFiles: string[]; // File patterns to look for
-  validate: (bundle: FileBundle) => boolean;
-}
-
-export class PlatformParseError extends Error {
-  constructor(message: string, public platform: string) {
-    super(message);
-    this.name = 'PlatformParseError';
-  }
-}