KHIX Site

.env.example

@@ -37,6 +37,7 @@ MINIO_SECRET_KEY="minioadmin"
 BLADE_URL="http://localhost:3000"
 NEXT_PUBLIC_BLADE_URL="http://localhost:3000"
 BLOOMKNIGHTS_URL="http://localhost:3006"
+KHIX_URL="http://localhost:3007"
 
 # Passkit
 WWDR_CERT_BASE64="wwdr-cert-b64"

apps/blade/src/app/_components/admin/hackathon/manage/hackathon-manager.tsx

@@ -775,7 +775,7 @@ export function HackathonManager() {
                       <div className="space-y-1">
                         <FormLabel>Email Template Override</FormLabel>
                         <FormDescription>
-                          Leave off to use the current Knight Hacks VIII email
+                          Leave off to use the default hackathon email
                           templates.
                         </FormDescription>
                       </div>

apps/blade/src/app/auth/khix-return/route.ts

@@ -0,0 +1,57 @@
+import { NextResponse } from "next/server";
+
+import { env } from "~/env";
+
+const DEFAULT_KHIX_RETURN_PATH = "/dashboard";
+const PRODUCTION_KHIX_RETURN_ORIGIN = "https://2026.knighthacks.org";
+const LOCAL_KHIX_RETURN_ORIGIN = "http://localhost:3007";
+
+function getAllowedKhixReturnOrigins(configuredKhixOrigin: string) {
+  const allowedOrigins = new Set([
+    configuredKhixOrigin,
+    PRODUCTION_KHIX_RETURN_ORIGIN,
+  ]);
+
+  if (env.NODE_ENV !== "production") {
+    allowedOrigins.add(LOCAL_KHIX_RETURN_ORIGIN);
+  }
+
+  return allowedOrigins;
+}
+
+function getKhixReturnURL(returnTo: string | null) {
+  const configuredKhixOrigin = new URL(env.KHIX_URL).origin;
+  const allowedOrigins = getAllowedKhixReturnOrigins(configuredKhixOrigin);
+  const defaultReturnURL = new URL(
+    DEFAULT_KHIX_RETURN_PATH,
+    configuredKhixOrigin,
+  );
+
+  if (!returnTo) return defaultReturnURL;
+
+  try {
+    const requestedReturnURL = new URL(returnTo, configuredKhixOrigin);
+
+    if (
+      !allowedOrigins.has(requestedReturnURL.origin) ||
+      !requestedReturnURL.pathname.startsWith("/")
+    ) {
+      return defaultReturnURL;
+    }
+
+    return requestedReturnURL;
+  } catch {
+    return defaultReturnURL;
+  }
+}
+
+export function GET(request: Request) {
+  const requestUrl = new URL(request.url);
+  const returnTo = getKhixReturnURL(requestUrl.searchParams.get("returnTo"));
+
+  if (requestUrl.searchParams.has("authError")) {
+    returnTo.searchParams.set("authError", "oauth");
+  }
+
+  return NextResponse.redirect(returnTo);
+}

apps/blade/src/env.ts

@@ -10,6 +10,11 @@ const bloomKnightsUrlSchema =
     ? z.string().url()
     : z.string().url().default("http://localhost:3006");
 
+const khixUrlSchema =
+  process.env.NODE_ENV === "production"
+    ? z.string().url()
+    : z.string().url().default("http://localhost:3007");
+
 export const env = createEnv({
   extends: [authEnv, apiEnv, dbEnv],
   shared: {
@@ -24,6 +29,7 @@ export const env = createEnv({
    */
   server: {
     BLOOMKNIGHTS_URL: bloomKnightsUrlSchema,
+    KHIX_URL: khixUrlSchema,
   },
 
   /**

apps/khix/next.config.js

@@ -1,13 +1,23 @@
+import { networkInterfaces } from "node:os";
+
+const localDevOrigins = Object.values(networkInterfaces()).flatMap(
+  (addresses) =>
+    (addresses ?? [])
+      .filter(({ family, internal }) => family === "IPv4" && !internal)
+      .map(({ address }) => address),
+);
+
 /** @type {import("next").NextConfig} */
 const config = {
   reactStrictMode: true,
+  allowedDevOrigins: ["127.0.0.1", ...localDevOrigins],
   images: {
-    formats: ["image/avif", "image/webp"],
-    minimumCacheTTL: 60 * 60 * 24 * 30,
+    unoptimized: true,
     remotePatterns: [
       {
         protocol: "https",
         hostname: "assets.knighthacks.org",
+        pathname: "/khix/**",
       },
     ],
   },

apps/khix/package.json

@@ -15,12 +15,26 @@
     "with-env": "dotenv -e ../../.env --"
   },
   "dependencies": {
+    "@forge/api": "workspace:*",
+    "@forge/auth": "workspace:*",
+    "@forge/consts": "workspace:*",
+    "@forge/db": "workspace:*",
+    "@forge/hackathon": "workspace:*",
+    "@forge/ui": "workspace:*",
+    "@forge/validators": "workspace:*",
+    "@gsap/react": "^2.1.2",
+    "@t3-oss/env-nextjs": "^0.13.10",
+    "@trpc/client": "catalog:",
+    "@trpc/server": "catalog:",
     "framer-motion": "^12.34.3",
+    "gsap": "^3.14.2",
     "lucide-react": "^0.575.0",
     "next": "^16.2.7",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "react-icons": "^5.5.0"
+    "react-icons": "^5.5.0",
+    "superjson": "2.2.6",
+    "zod": "catalog:"
   },
   "devDependencies": {
     "@forge/eslint-config": "workspace:*",
@@ -35,7 +49,6 @@
     "eslint": "catalog:",
     "prettier": "catalog:",
     "tailwindcss": "catalog:",
-    "tw-animate-css": "^1.4.0",
     "typescript": "catalog:"
   },
   "prettier": "@forge/prettier-config"

apps/khix/src/PARALLAX.MD

@@ -0,0 +1,77 @@
+# Parallax Implementation Notes
+
+Temporary handoff for agents working on KHIX or future Forge parallax sections.
+This documents the Chromium fix from Carlos's 39fc6795 commit so it can be
+reused without rediscovering the same failure mode.
+
+## What Broke
+
+The KHIX hero parallax broke when the art stack was treated like a page
+background instead of a normal hero section. The problematic shape was:
+
+- a long or sticky scroll zone that made the hero behave like a background
+- a large transformed `.art` container using `scale(...)`
+- per-layer parallax values that did not account for that container scale
+- unthrottled pointer writes fighting Chromium's rendering pipeline
+
+The visible symptoms were rapid inline style churn in DevTools, unstable
+Chromium parallax, and the hero reading as the entire page background instead
+of a section that can scroll away.
+
+## Carlos's Fix
+
+Keep the hero itself as a normal section:
+
+- `section#home` owns the hero and stays in document flow
+- `.stage` is `position: relative`, not sticky, for a normal hero
+- the hero is `100vh` / `100svh`; extra page scroll should come from following
+  sections, not from a fake hero scroll zone
+
+Keep the artwork full-bleed inside the hero without scaling the whole .art
+container:
+
+- store the old visual scale as `--khix-art-motion-scale: 0.64`
+- use a smaller art inset, currently `inset: -6.32svh -3.76vw`
+- do not put `transform: scale(...)` on `.art`
+- apply `--khix-art-motion-scale` inside each layer's parallax transform math
+
+Scope motion variables to the stage and throttle writes:
+
+- write `--khix-hero-pointer-x`, `--khix-hero-pointer-y`, and
+  `--khix-hero-scroll-progress` on the hero stage
+- coalesce pointer movement with `requestAnimationFrame`
+- only write motion values when they changed by a meaningful epsilon
+- cancel pending pointer frames during cleanup and when reduced motion is
+  enabled
+
+## Reusable Pattern
+
+For future parallax components:
+
+- make the section normal page flow first; avoid sticky or oversized scroll
+  zones unless the design explicitly calls for pinned storytelling
+- keep the art stack visually oversized with insets, not by scaling the whole
+  container
+- if the art needs a visual scale, put that number in a CSS variable and
+  multiply the pointer and scroll offsets by it
+- put all layer movement on `transform: translate3d(...)` and keep depth values
+  as CSS vars on each layer
+- use one local stage for motion vars; do not inject global `:root` motion state
+  for a component-specific parallax
+- throttle pointer writes with `requestAnimationFrame`; throttle scroll writes
+  too, and skip writes when the value barely changed
+- respect `prefers-reduced-motion` by resetting pointer and scroll progress to
+  `0` and disabling nonessential animated layers
+
+## Verification Checklist
+
+Before handing off a parallax change:
+
+- the hero/section scrolls away like a normal section when content follows it
+- the stage is not sticky unless pinned scroll storytelling is the requirement
+- Chrome/Chromium DevTools does not show unrelated title/glow/art nodes
+  constantly changing inline style attributes
+- pointer movement still changes layer transforms differently by depth
+- scroll changes `--khix-hero-scroll-progress` without causing layout shifts
+- `pnpm --filter=@forge/khix lint` and
+  `pnpm --filter=@forge/khix typecheck` pass for KHIX changes

apps/khix/src/app/(portal)/_components/application/hackbackgrounds/index.ts

@@ -0,0 +1,48 @@
+import type { ApplicationVisualConfig } from "./types";
+import { khixApplicationBackground } from "./khix";
+
+export const DEFAULT_APPLICATION_VISUAL = {
+  key: "default",
+  label: "Stock purple",
+  mode: "dynamic",
+  showStockEffects: true,
+} satisfies ApplicationVisualConfig;
+
+export type HackerApplicationBackgroundKey = "khix";
+
+export const HACKER_APPLICATION_BACKGROUNDS = {
+  khix: khixApplicationBackground,
+} satisfies Record<HackerApplicationBackgroundKey, ApplicationVisualConfig>;
+
+function isHackerApplicationBackgroundKey(
+  backgroundKey: string,
+): backgroundKey is HackerApplicationBackgroundKey {
+  return backgroundKey === "khix";
+}
+
+export function getHackerApplicationBackgroundKey(
+  backgroundKey?: string | null,
+): HackerApplicationBackgroundKey | null {
+  if (!backgroundKey) return null;
+  if (isHackerApplicationBackgroundKey(backgroundKey)) return backgroundKey;
+
+  if (backgroundKey === "knighthacksix") return "khix";
+  if (backgroundKey === "knight-hacks-ix") return "khix";
+
+  return null;
+}
+
+export function getHackerApplicationBackground(
+  backgroundKey?: string | null,
+): ApplicationVisualConfig {
+  const applicationBackgroundKey =
+    getHackerApplicationBackgroundKey(backgroundKey);
+
+  if (!applicationBackgroundKey) {
+    return DEFAULT_APPLICATION_VISUAL;
+  }
+
+  return HACKER_APPLICATION_BACKGROUNDS[applicationBackgroundKey];
+}
+
+export type { ApplicationVisualConfig, ApplicationVisualLayer } from "./types";