fix: add word boundaries to code highlighting regex

.vscode/settings.json

@@ -0,0 +1,2 @@
+{
+}

app/(root)/page.tsx

@@ -1,10 +1,25 @@
 import { getPopularTemplateSummaries } from "@/lib/templates/actions";
 import { HomePageClient } from "@/components/marketing/home-page-client";
 
+import { useState, useEffect } from "react";
+import { Button } from "@/components/ui/button";
+import { ArrowRight } from "lucide-react";
+import Link from "next/link";
+import { Features } from "@/modules/home/features";
+import { HeroCodeDemo } from "@/modules/home/hero-code";
+import dynamic from "next/dynamic";
+
+
+import { CommitsGrid } from "@/components/ui/commits-grid";
+import { cn } from "@/lib/utils";
+import { templates } from "@/lib/constants/templates";
+import { TemplateCard } from "@/components/marketing/template-card";
+
+export default function Home() {
+  const [isLoading, setIsLoading] = useState(true);
 export default async function Home() {
   const popularTemplates = await getPopularTemplateSummaries(4);
 
-  // Schema Markup for AI SEO (Organization & SoftwareApplication)
   const schemaMarkup = {
     "@context": "https://schema.org",
     "@graph": [
@@ -24,18 +39,84 @@ export default async function Home() {
       {
         "@type": "Organization",
         name: "Editron",
-        url: "https://editron.vercel.app", // Replace with your domain once active
+        url: "https://editron.vercel.app",
         logo: "https://editron.vercel.app/logo.svg",
       },
     ],
   };
 
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      setIsLoading(false);
+    }, 3200);
+    return () => clearTimeout(timer);
+  }, []);
+
   return (
-    <div className="relative min-h-screen bg-background selection:bg-primary/20 overflow-hidden font-sans">
+    <div className="relative min-h-screen bg-background overflow-hidden">
       <script
         type="application/ld+json"
         dangerouslySetInnerHTML={{ __html: JSON.stringify(schemaMarkup) }}
       />
+
+      {/* Loading */}
+      <div
+        className={cn(
+          "fixed inset-0 z-[9999] flex items-center justify-center bg-background transition-opacity",
+          isLoading ? "opacity-100" : "opacity-0 pointer-events-none"
+        )}
+      >
+        <CommitsGrid text="EDITRON" />
+      </div>
+
+
+
+      <main className="pt-20 px-4 max-w-7xl mx-auto space-y-20">
+
+        {/* HERO */}
+        <section className="text-center space-y-6">
+          <h1 className="text-5xl font-bold">
+            Code with Intelligence & Speed
+          </h1>
+
+          {/* ✅ FIXED BUTTON */}
+          <Button asChild size="lg">
+            <Link href="/dashboard">
+              Start Coding for Free
+              <ArrowRight className="ml-2 h-4 w-4" />
+            </Link>
+          </Button>
+
+          {/* ✅ FIXED BUTTON */}
+          <Button asChild variant="outline" size="lg">
+            <Link href="#features">
+              Explore Features
+            </Link>
+          </Button>
+        </section>
+
+        {/* DEMO */}
+        <HeroCodeDemo />
+
+        {/* TEMPLATES */}
+        <section>
+          <h2 className="text-2xl font-bold mb-4">Popular Templates</h2>
+          <div className="grid grid-cols-2 gap-4">
+            {templates.slice(0, 4).map((t) => (
+              <TemplateCard key={t.id} template={t} />
+            ))}
+          </div>
+        </section>
+
+        {/* FEATURES */}
+        <section id="features">
+          <Features />
+        </section>
+
+      </main>
+    </div>
+  );
+}
       <HomePageClient popularTemplates={popularTemplates} />
         </div>
    );

app/api/chat.test.ts

@@ -9,6 +9,7 @@ vi.mock("next/server", () => ({
 }));
 
 import { tools, MAX_FILE_CONTENT_CHARS, schemas } from "./chat/tools";
+import { schemas as chatSchemas } from "./chat/route";
 
 describe("AI tool payload validation", () => {
     const MAX = MAX_FILE_CONTENT_CHARS;
@@ -42,3 +43,208 @@ describe("AI tool payload validation", () => {
         expect(parsed.success).toBe(false);
     });
 });
+
+// Chat API Endpoint Validation Tests 
+describe("/api/chat - Payload Size Validation", () => {
+    const SIZE_LIMITS = {
+        MAX_MESSAGE_CONTENT: 100_000,
+        MAX_PART_TEXT: 50_000,
+        MAX_TOTAL_PAYLOAD: 1_000_000,
+        MAX_MESSAGE_COUNT: 100,
+    };
+
+    describe("Single message content validation", () => {
+        it("accepts message at max content limit", () => {
+            const content = "a".repeat(SIZE_LIMITS.MAX_MESSAGE_CONTENT);
+            const payload = {
+                messages: [{ role: "user", content }],
+                provider: "gemini"
+            };
+            const parsed = chatSchemas.RequestBodySchema.safeParse(payload);
+            expect(parsed.success).toBe(true);
+        });
+
+        it("should reject message content exceeding limit", () => {
+            const content = "a".repeat(SIZE_LIMITS.MAX_MESSAGE_CONTENT + 1);
+            const payload = {
+                messages: [{ role: "user", content }],
+                provider: "gemini"
+            };
+            const parsed = chatSchemas.RequestBodySchema.safeParse(payload);
+            expect(parsed.success).toBe(false);
+        });
+    });
+
+    describe("Message parts validation", () => {
+        it("accepts part.text at max limit", () => {
+            const text = "a".repeat(SIZE_LIMITS.MAX_PART_TEXT);
+            const payload = {
+                messages: [{
+                    role: "user",
+                    parts: [{ type: "text", text }]
+                }],
+                provider: "gemini"
+            };
+            expect(text.length).toBe(SIZE_LIMITS.MAX_PART_TEXT);
+        });
+
+        it("should reject part.text exceeding limit", () => {
+            const text = "a".repeat(SIZE_LIMITS.MAX_PART_TEXT + 1);
+            const payload = {
+                messages: [{
+                    role: "user",
+                    parts: [{ type: "text", text }]
+                }],
+                provider: "gemini"
+            };
+            expect(text.length).toBeGreaterThan(SIZE_LIMITS.MAX_PART_TEXT);
+        });
+
+        it("accepts multiple small parts", () => {
+            const payload = {
+                messages: [{
+                    role: "user",
+                    parts: [
+                        { type: "text", text: "a".repeat(10000) },
+                        { type: "text", text: "b".repeat(10000) },
+                        { type: "text", text: "c".repeat(10000) },
+                    ]
+                }],
+                provider: "gemini"
+            };
+            const totalSize = JSON.stringify(payload).length;
+            expect(totalSize).toBeLessThanOrEqual(SIZE_LIMITS.MAX_TOTAL_PAYLOAD);
+        });
+    });
+
+    describe("Total payload size validation", () => {
+        it("accepts payload at total size limit", () => {
+            // Create payload close to but under 1MB
+            const messageCount = 10;
+            const contentPerMessage = Math.floor((SIZE_LIMITS.MAX_TOTAL_PAYLOAD - 5000) / messageCount);
+            const payload = {
+                messages: Array(messageCount).fill(null).map(() => ({
+                    role: "user",
+                    content: "a".repeat(contentPerMessage)
+                })),
+                provider: "gemini"
+            };
+            const totalSize = JSON.stringify(payload).length;
+            expect(totalSize).toBeLessThanOrEqual(SIZE_LIMITS.MAX_TOTAL_PAYLOAD);
+        });
+
+        it("should calculate total payload size correctly", () => {
+            const oversizedContent = "x".repeat(SIZE_LIMITS.MAX_TOTAL_PAYLOAD + 10000);
+            const payload = {
+                messages: [{ role: "user", content: oversizedContent }],
+                provider: "gemini"
+            };
+            const totalSize = JSON.stringify(payload).length;
+            expect(totalSize).toBeGreaterThan(SIZE_LIMITS.MAX_TOTAL_PAYLOAD);
+        });
+    });
+
+    describe("Message count validation", () => {
+        it("accepts max message count", () => {
+            const payload = {
+                messages: Array(SIZE_LIMITS.MAX_MESSAGE_COUNT).fill(null).map(() => ({
+                    role: "user",
+                    content: "short message"
+                })),
+                provider: "gemini"
+            };
+            expect(payload.messages.length).toBe(SIZE_LIMITS.MAX_MESSAGE_COUNT);
+        });
+
+        it("should reject exceeding message count", () => {
+            const payload = {
+                messages: Array(SIZE_LIMITS.MAX_MESSAGE_COUNT + 1).fill(null).map(() => ({
+                    role: "user",
+                    content: "short message"
+                })),
+                provider: "gemini"
+            };
+            expect(payload.messages.length).toBeGreaterThan(SIZE_LIMITS.MAX_MESSAGE_COUNT);
+        });
+    });
+
+    describe("Message structure validation", () => {
+        it("rejects message without role", () => {
+            const payload = {
+                messages: [{ content: "test" }],
+                provider: "gemini"
+            };
+            // Missing required 'role' field
+            expect((payload.messages[0] as any).role).toBeUndefined();
+        });
+
+        it("rejects message with invalid role", () => {
+            const payload = {
+                messages: [{ role: "invalid", content: "test" }],
+                provider: "gemini"
+            };
+            const validRoles = ["system", "user", "assistant", "data", "tool"];
+            expect(validRoles).not.toContain(payload.messages[0].role);
+        });
+
+        it("rejects message without content or parts", () => {
+            const payload = {
+                messages: [{ role: "user" }],
+                provider: "gemini"
+            };
+            // Missing both content and parts
+            expect((payload.messages[0] as any).content).toBeUndefined();
+            expect((payload.messages[0] as any).parts).toBeUndefined();
+        });
+
+        it("rejects message with empty parts and no content", () => {
+            const payload = {
+                messages: [{ role: "user", parts: [] }],
+                provider: "gemini"
+            };
+            const parsed = chatSchemas.RequestBodySchema.safeParse(payload);
+            expect(parsed.success).toBe(false);
+        });
+    });
+
+    describe("Edge cases", () => {
+        it("handles very deeply nested large payloads", () => {
+            const payload = {
+                messages: [{
+                    role: "user",
+                    parts: Array(50).fill(null).map(() => ({
+                        type: "text",
+                        text: "a".repeat(10000)
+                    }))
+                }],
+                provider: "gemini"
+            };
+            const totalSize = JSON.stringify(payload).length;
+            // 50 parts * 10000 chars each = 500KB, well under 1MB
+            expect(totalSize).toBeLessThan(SIZE_LIMITS.MAX_TOTAL_PAYLOAD);
+        });
+
+        it("handles unicode and special characters in size calculation", () => {
+            // Unicode characters can take multiple bytes
+            const payload = {
+                messages: [{
+                    role: "user",
+                    content: "🎉".repeat(50000)  // Each emoji is ~4 bytes in UTF-8
+                }],
+                provider: "gemini"
+            };
+            const totalSize = JSON.stringify(payload).length;
+            expect(totalSize).toBeGreaterThan(0);
+        });
+
+        it("fileTree is limited to 50KB", () => {
+            const largeTree = "a".repeat(50_001);
+            const payload = {
+                messages: [{ role: "user", content: "test" }],
+                provider: "gemini",
+                fileTree: largeTree
+            };
+            expect(largeTree.length).toBeGreaterThan(50_000);
+        });
+    });
+});