// Merge order (lowest to highest priority):
// 1. Plugin 1 serverConfig
// 2. Plugin 2 serverConfig
// 3. Plugin N serverConfig
// 4. Your HTTPServer config (highest priority)

function deepMergeServerConfig(target: any, source: any): any {
  const result = { ...target };
  
  for (const [key, sourceValue] of Object.entries(source)) {
    const targetValue = result[key];
    
    // Detect conflicts
    if (targetValue !== sourceValue && 
        typeof targetValue !== "object") {
      throw new Error(`Conflict: ${key} has different values`);
    }
    
    // Deep merge objects
    if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
      result[key] = deepMergeServerConfig(targetValue, sourceValue);
    }
    // Concatenate arrays
    else if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
      result[key] = [...targetValue, ...sourceValue];
    }
    // Source overrides target
    else {
      result[key] = sourceValue;
    }
  }
  
  return result;
}

class masterRequest<ContextType extends Record<string, unknown> = {}> {
  // Core properties
  public request: Request;
  public currentState: RequestState;
  public match?: RequestMatch;
  public isAskingHTML: boolean;
  public URL: URL;
  public serverInstance: Bun.Server<undefined>;
  public serverConfig: FrameMasterConfig;
  
  // Cookie management
  public getCookie<T extends Record<string, unknown>>(
    name: string, 
    encrypted?: boolean
  ): T | undefined;
  
  public setCookie<T extends Record<string, unknown>>(
    name: string, 
    data: T, 
    options?: CookieOptions,
    dataOptions?: SetDataOptions
  ): this;
  
  public deleteCookie(
    name: string, 
    options?: DeleteCookieOptions
  ): this;
  
  // Response management
  public setResponse(body: BodyInit | null, init?: ResponseInit): this;
  public unsetResponse(): void;
  public isResponseSetted(): boolean;
  public sendNow(): void;
  public get response(): Response | undefined;
  
  // Context management
  public setContext<T>(context: T): T;
  public getContext<T = ContextType>(): T;
  
  // Global values injection
  public setGlobalValues<T extends Partial<typeof globalThis>>(
    values: T
  ): this;
  public preventGlobalValuesInjection(): this;
  public isGlobalValuesInjectionPrevented(): boolean;
  
  // HTML rewrite control
  public preventRewrite(): this;
  
  // Header management
  public setHeader(name: string, value: string): this;
  
  // Internal
  public async handleRequest(): Promise<Response>;
  public async toResponse(): Promise<Response>;
}

GET    → /
POST   → /api/users
PUT    → /api/users/123
DELETE → /api/users/123
PATCH  → /api/users/123

const config: FrameMasterConfig = {
  HTTPServer: {
    port: 3000,
    
    // Static routes (Bun native routing)
    routes: {
      "/api/health": () => Response.json({ status: "ok" }),
      
      "/api/version": () => Response.json({ 
        version: "1.0.0",
        framework: "Frame-Master" 
      }),
    },
  },
  plugins: [],
};

const myPlugin: FrameMasterPlugin = {
  name: "my-api-plugin",
  version: "1.0.0",
  
  serverConfig: {
    routes: {
      "/api/custom": () => Response.json({ 
        message: "From plugin" 
      }),
    },
  },
  
  // Or use the request hook for complex routing
  router: {
    request(master) {
      if (master.pathname === "/api/complex") {
        master.setResponse(
          JSON.stringify({ data: "Complex logic" }),
          { headers: { "Content-Type": "application/json" } }
        );
      }
    },
  },
};

# Start with hot reload
bun --hot frame-master dev

# Or via package.json script
bun run dev

Bun.serve({
  development: {
    chromeDevToolsAutomaticWorkspaceFolders: true,
  },
  // ... rest of config
});

const myPlugin: FrameMasterPlugin = {
  name: "my-plugin",
  version: "1.0.0",
  
  // Specify directories to watch
  fileSystemWatchDir: ["src/pages", "src/components"],
  
  // Handle file changes
  onFileSystemChange(event, file, absolutePath) {
    console.log(`${event}: ${file}`);
    
    if (event === "change" && file.endsWith(".tsx")) {
      // Trigger rebuild or processing
      rebuildComponent(absolutePath);
    }
  },
};