background playback

Merge branch 'fix-cv-animations'
refactor to use existing animated components
2026-06-16 19:00:59 +02:00 · 2026-06-16 18:56:05 +02:00 · 2026-06-16 18:56:02 +02:00 · 2026-06-16 18:42:19 +02:00 · 2026-06-16 18:42:06 +02:00 · 2026-06-16 18:40:14 +02:00
49 changed files with 2226 additions and 713 deletions
--- a/.ignore
+++ b/.ignore
@@ -1,2 +1,4 @@
 node_modules/**
 .next/**
+.worktrees
+.clerk
--- a/bun.lock
+++ b/bun.lock
--- a/next.config.js
+++ b/next.config.js
@@ -6,9 +6,10 @@ import "./src/env.js";

 /** @type {import("next").NextConfig} */
 const config = {
- typescript: {
-  ignoreBuildErrors: true
- }
+  transpilePackages: ["next-mdx-remote"],
+  typescript: {
+    ignoreBuildErrors: true,
+  },
 };

 export default config;
--- a/package.json
+++ b/package.json
@@ -5,6 +5,7 @@
  "type": "module",
  "scripts": {
    "build": "next build",
+    "build:ffmpeg-worker": "bun build node_modules/@ffmpeg/ffmpeg/dist/esm/worker.js --target browser --format esm --minify --outfile public/ffmpeg/worker.js",
    "check": "biome check .",
    "check:unsafe": "biome check --write --unsafe .",
    "check:write": "biome check --write .",
@@ -19,16 +20,18 @@
    "test": "vitest --typecheck"
  },
  "dependencies": {
-    "@ai-sdk/openai": "^3.0.41",
-    "@ai-sdk/react": "^3.0.118",
-    "@clerk/nextjs": "^7.0.2",
-    "@electric-sql/pglite": "^0.3.16",
+    "@ai-sdk/openai": "^3.0.67",
+    "@ai-sdk/react": "^3.0.195",
+    "@clerk/nextjs": "^7.4.2",
+    "@electric-sql/pglite": "^0.4.6",
+    "@ffmpeg/ffmpeg": "^0.12.15",
+    "@ffmpeg/util": "^0.12.2",
    "@fortawesome/fontawesome-svg-core": "^7.2.0",
    "@fortawesome/free-solid-svg-icons": "^7.2.0",
-    "@fortawesome/react-fontawesome": "^3.2.0",
+    "@fortawesome/react-fontawesome": "^3.3.1",
    "@gsap/react": "^2.1.2",
-    "@hookform/resolvers": "^5.2.2",
-    "@neondatabase/serverless": "^1.0.2",
+    "@hookform/resolvers": "^5.4.0",
+    "@neondatabase/serverless": "^1.1.0",
    "@radix-ui/react-accordion": "^1.2.12",
    "@radix-ui/react-alert-dialog": "^1.1.15",
    "@radix-ui/react-aspect-ratio": "^1.1.8",
@@ -55,84 +58,86 @@
    "@radix-ui/react-toggle": "^1.1.10",
    "@radix-ui/react-toggle-group": "^1.1.11",
    "@radix-ui/react-tooltip": "^1.2.8",
-    "@t3-oss/env-nextjs": "^0.13.10",
+    "@t3-oss/env-nextjs": "^0.13.11",
    "@tailwindcss/typography": "^0.5.19",
-    "@tanstack/react-query": "^5.90.21",
-    "@tanstack/react-query-next-experimental": "^5.91.0",
+    "@tanstack/react-query": "^5.100.14",
+    "@tanstack/react-query-next-experimental": "^5.100.14",
    "@testing-library/user-event": "^14.6.1",
-    "@trpc/client": "^11.12.0",
-    "@trpc/next": "^11.12.0",
-    "@trpc/react-query": "^11.12.0",
-    "@trpc/server": "^11.12.0",
-    "@uiw/react-md-editor": "^4.0.11",
+    "@trpc/client": "^11.17.0",
+    "@trpc/next": "^11.17.0",
+    "@trpc/react-query": "^11.17.0",
+    "@trpc/server": "^11.17.0",
+    "@uiw/react-md-editor": "^4.1.1",
    "@uploadthing/react": "^7.3.3",
-    "ai": "^6.0.116",
+    "@vercel/speed-insights": "^2.0.0",
+    "ai": "^6.0.193",
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
    "cmdk": "^1.1.1",
-    "date-fns": "^4.1.0",
+    "date-fns": "^4.4.0",
    "date-format": "^4.0.14",
-    "drizzle-orm": "^0.45.1",
+    "drizzle-orm": "^0.45.2",
    "drizzle-zod": "^0.8.3",
    "embla-carousel-react": "^8.6.0",
    "glazejs": "^2.0.1",
-    "googleapis": "^171.4.0",
+    "googleapis": "^173.0.0",
    "gray-matter": "^4.0.3",
-    "gsap": "^3.14.2",
+    "gsap": "^3.15.0",
    "input-otp": "^1.4.2",
-    "lucide-react": "^0.577.0",
-    "next": "16.1.6",
+    "lucide-react": "^1.17.0",
+    "next": "16.2.6",
    "next-mdx-remote": "^6.0.0",
    "next-themes": "^0.4.6",
-    "postgres": "^3.4.8",
+    "postgres": "^3.4.9",
    "radix-ui": "^1.4.3",
-    "react": "^19.2.4",
-    "react-day-picker": "^9.14.0",
-    "react-dom": "^19.2.4",
-    "react-hook-form": "^7.71.2",
+    "react": "^19.2.6",
+    "react-day-picker": "^10.0.1",
+    "react-dom": "^19.2.6",
+    "react-hook-form": "^7.77.0",
    "react-markdown": "^10.1.0",
-    "react-resizable-panels": "^4.7.2",
-    "recharts": "2.15.4",
+    "react-resizable-panels": "^4.11.2",
+    "recharts": "3.8.1",
    "rehype-highlight": "^7.0.2",
    "rehype-raw": "^7.0.0",
    "remark-gfm": "^4.0.1",
    "server-only": "^0.0.1",
-    "shadcn": "^4.0.2",
+    "shadcn": "^4.10.0",
    "sonner": "^2.0.7",
-    "tailwind-merge": "^3.5.0",
+    "tailwind-merge": "^3.6.0",
    "tailwindcss-motion": "^1.1.1",
-    "type-fest": "^5.4.4",
+    "type-fest": "^5.7.0",
    "uploadthing": "^7.7.4",
    "vaul": "^1.1.2",
-    "zod": "^4.3.6"
+    "wavesurfer.js": "^7.12.8",
+    "zod": "^4.4.3"
  },
  "devDependencies": {
-    "@biomejs/biome": "2.4.6",
+    "@biomejs/biome": "2.4.16",
    "@swc/jest": "^0.2.39",
-    "@tailwindcss/postcss": "^4.2.1",
+    "@tailwindcss/postcss": "^4.3.0",
    "@testing-library/dom": "^10.4.1",
    "@testing-library/jest-dom": "^6.9.1",
    "@testing-library/react": "^16.3.2",
    "@types/jest": "^30.0.0",
-    "@types/node": "^25.4.0",
-    "@types/react": "^19.2.14",
+    "@types/node": "^25.9.1",
+    "@types/react": "^19.2.15",
    "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^5.1.4",
-    "@vitest/coverage-v8": "^4.0.18",
-    "dotenv": "^17.3.1",
-    "drizzle-kit": "^0.31.9",
-    "jest": "^30.3.0",
-    "jest-environment-jsdom": "^30.3.0",
-    "jsdom": "^28.1.0",
+    "@vitejs/plugin-react": "^6.0.2",
+    "@vitest/coverage-v8": "^4.1.8",
+    "dotenv": "^17.4.2",
+    "drizzle-kit": "^0.31.10",
+    "jest": "^30.4.2",
+    "jest-environment-jsdom": "^30.4.1",
+    "jsdom": "^29.1.1",
    "next-router-mock": "^1.0.5",
    "pg-mem": "^3.0.14",
-    "postcss": "^8.5.8",
-    "tailwindcss": "^4.2.1",
+    "postcss": "^8.5.15",
+    "tailwindcss": "^4.3.0",
    "ts-node": "^10.9.2",
    "tw-animate-css": "^1.4.0",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
    "vite-tsconfig-paths": "^6.1.1",
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.8"
  },
  "ct3aMetadata": {
    "initVersion": "7.39.3"
--- a/public/favicon.ico
+++ b/public/favicon.ico
--- a/public/ffmpeg/worker.js
+++ b/public/ffmpeg/worker.js
@@ -0,0 +1 @@
+var C="https://unpkg.com/@ffmpeg/core@0.12.9/dist/umd/ffmpeg-core.js",N;(function(E){E.LOAD="LOAD",E.EXEC="EXEC",E.FFPROBE="FFPROBE",E.WRITE_FILE="WRITE_FILE",E.READ_FILE="READ_FILE",E.DELETE_FILE="DELETE_FILE",E.RENAME="RENAME",E.CREATE_DIR="CREATE_DIR",E.LIST_DIR="LIST_DIR",E.DELETE_DIR="DELETE_DIR",E.ERROR="ERROR",E.DOWNLOAD="DOWNLOAD",E.PROGRESS="PROGRESS",E.LOG="LOG",E.MOUNT="MOUNT",E.UNMOUNT="UNMOUNT"})(N||(N={}));var G=Error("unknown message type"),V=Error("ffmpeg is not loaded, call `await ffmpeg.load()` first"),b=Error("called FFmpeg.terminate()"),v=Error("failed to import ffmpeg-core.js");var I,X=async({coreURL:E,wasmURL:D,workerURL:O})=>{let S=!I;try{if(!E)E=C;importScripts(E)}catch{if(!E||E===C)E=C.replace("/umd/","/esm/");if(self.createFFmpegCore=(await import(E)).default,!self.createFFmpegCore)throw v}let A=E,x=D?D:E.replace(/.js$/g,".wasm"),B=O?O:E.replace(/.js$/g,".worker.js");return I=await self.createFFmpegCore({mainScriptUrlOrBlob:`${A}#${btoa(JSON.stringify({wasmURL:x,workerURL:B}))}`}),I.setLogger((W)=>self.postMessage({type:N.LOG,data:W})),I.setProgress((W)=>self.postMessage({type:N.PROGRESS,data:W})),S},Y=({args:E,timeout:D=-1})=>{I.setTimeout(D),I.exec(...E);let O=I.ret;return I.reset(),O},j=({args:E,timeout:D=-1})=>{I.setTimeout(D),I.ffprobe(...E);let O=I.ret;return I.reset(),O},J=({path:E,data:D})=>{return I.FS.writeFile(E,D),!0},$=({path:E,encoding:D})=>I.FS.readFile(E,{encoding:D}),q=({path:E})=>{return I.FS.unlink(E),!0},z=({oldPath:E,newPath:D})=>{return I.FS.rename(E,D),!0},H=({path:E})=>{return I.FS.mkdir(E),!0},K=({path:E})=>{let D=I.FS.readdir(E),O=[];for(let S of D){let A=I.FS.stat(`${E}/${S}`),x=I.FS.isDir(A.mode);O.push({name:S,isDir:x})}return O},Q=({path:E})=>{return I.FS.rmdir(E),!0},R=({fsType:E,options:D,mountPoint:O})=>{let S=E,A=I.FS.filesystems[S];if(!A)return!1;return I.FS.mount(A,D,O),!0},Z=({mountPoint:E})=>{return I.FS.unmount(E),!0};self.onmessage=async({data:{id:E,type:D,data:O}})=>{let S=[],A;try{if(D!==N.LOAD&&!I)throw V;switch(D){case N.LOAD:A=await X(O);break;case N.EXEC:A=Y(O);break;case N.FFPROBE:A=j(O);break;case N.WRITE_FILE:A=J(O);break;case N.READ_FILE:A=$(O);break;case N.DELETE_FILE:A=q(O);break;case N.RENAME:A=z(O);break;case N.CREATE_DIR:A=H(O);break;case N.LIST_DIR:A=K(O);break;case N.DELETE_DIR:A=Q(O);break;case N.MOUNT:A=R(O);break;case N.UNMOUNT:A=Z(O);break;default:throw G}}catch(x){self.postMessage({id:E,type:N.ERROR,data:x.toString()});return}if(A instanceof Uint8Array)S.push(A.buffer);self.postMessage({id:E,type:D,data:A},S)};
--- a/src/app/_components/Animated/AnimateIn.tsx
+++ b/src/app/_components/Animated/AnimateIn.tsx
@@ -1,62 +1,43 @@
-import { useGSAP } from "@gsap/react";
 import { useRef, type HTMLAttributes, type ReactNode } from "react";
-import { useGsapContext } from "~/app/_providers/GsapProvicer";
 import { SplitText } from "gsap/SplitText";
 import gsap from 'gsap'
 import { cn } from "~/lib/utils";
+import { useReveal } from "./useReveal";
+
 const AnimateTextIn = ({
  children,
  animation = "type",
  position = 0,
-  tlId = undefined,
  speed = 1,
  scrollOnly = false,
+  once = false,
  className
 }: {
  children: ReactNode,
  animation?: "type" | "slide",
  position?: gsap.Position,
-  tlId?: string,
  scrollOnly?: boolean,
+  once?: boolean,
  speed?: number,
  className?: HTMLAttributes<HTMLDivElement>['className']
 }) => {
  const el = useRef<HTMLDivElement>(null)
-  const gsapContext = useGsapContext();
-  useGSAP(() => {
-    const rect = el.current?.getBoundingClientRect()
-    const scroller = gsapContext?.getScroller()
-    console.log(scroller)
-    let viewportTop = 0
-    let viewportBottom = window.innerHeight
-    if (scroller && scroller instanceof Element) {
-      const scrollerRect = scroller.getBoundingClientRect()
-      viewportTop = scrollerRect.top
-      viewportBottom = scrollerRect.top + scrollerRect.height
-    }
-    const isInView = rect && rect.bottom > viewportTop && rect.top < viewportBottom
-    console.log(isInView)
-    const chars = new SplitText(el.current, { type: 'chars' })
-    gsapContext?.addAnimation(gsap.to(el.current, { opacity: 100, duration: 0 }), 0, tlId)
-    const fromVars = animation === "slide"
-      ? { opacity: 0, x: -10, duration: 0.2 * speed, stagger: { each: 0.08 * speed }, ease: 'bounce.inOut', onComplete: () => chars.revert() }
-      : { opacity: 0, duration: 0.01 * speed, stagger: { each: 0.04 * speed }, ease: 'bounce.inOut', onComplete: () => chars.revert() }
-    if (isInView && !scrollOnly) {
-      gsapContext?.addAnimation(gsap.from(chars.chars, fromVars), position, tlId)
-    } else {
-      gsap.from(chars.chars,
-        {
-          ...fromVars,
-          scrollTrigger: {
-            trigger: el.current,
-            start: 'top bottom',
-            end: 'bottom top',
-            toggleActions: "play reverse play reverse",
-            scroller
-          }
-        })
-    }
-  }, { dependencies: [] })
+  useReveal(el, {
+    position,
+    scrollOnly,
+    once,
+    debugId: `text-${position}`,
+    makeReveal: (node) => {
+      // The wrapper starts at opacity 0 (so there's no flash of unsplit text);
+      // reveal the wrapper and let the per-character tween do the animation.
+      gsap.set(node, { opacity: 1 })
+      const split = new SplitText(node, { type: 'chars' })
+      const fromVars = animation === "slide"
+        ? { opacity: 0, x: -10, duration: 0.2 * speed, stagger: { each: 0.08 * speed }, ease: 'bounce.inOut' }
+        : { opacity: 0, duration: 0.01 * speed, stagger: { each: 0.04 * speed }, ease: 'bounce.inOut' }
+      return gsap.from(split.chars, { ...fromVars, paused: true })
+    },
+  })
  return (
    <div ref={el} className={cn(className, "opacity-0")}>
      {children}
--- a/src/app/_components/Animated/AnimatePopUp.tsx
+++ b/src/app/_components/Animated/AnimatePopUp.tsx
@@ -6,16 +6,20 @@ const AnimatePopUp = ({
  position,
  className,
  duration=1,
-  ease='elastic'
+  ease='elastic',
+  scrollOnly=false,
+  once=false,
 }:{
    children:ReactNode
    position:gsap.Position,
    className?:HTMLAttributes<HTMLDivElement>['className']
    duration?:number,
-    ease?:gsap.EaseString|gsap.EaseFunction
+    ease?:gsap.EaseString|gsap.EaseFunction,
+    scrollOnly?:boolean,
+    once?:boolean,
  }) => {
  return (
-    <AnimatedDiv children={children} position={position} className={cn(className,'h-0 translate-y-[50] overflow-hidden')} height='auto' y={0} overflow='' ease={ease} duration={duration} />
+    <AnimatedDiv children={children} position={position} scrollOnly={scrollOnly} once={once} className={cn(className,'h-0 translate-y-[50] overflow-hidden')} height='auto' y={0} overflow='' ease={ease} duration={duration} />
  )
 }

--- a/src/app/_components/Animated/AnimatedBackGroundContainer.tsx
+++ b/src/app/_components/Animated/AnimatedBackGroundContainer.tsx
@@ -1,16 +1,11 @@
 "use client";

-import React, { useRef, useEffect, useCallback, useState } from "react";
-import { useGSAP } from "@gsap/react";
-import gsap from "gsap";
 import { useTheme } from "next-themes";
+import type React from "react";
+import { useCallback, useEffect, useRef } from "react";

-/* ─────────────────────────────────────────────
- *  Config — grayscale palettes
- * ───────────────────────────────────────────── */
 const PALETTES = {
  dark: {
-    base: "#0a0a0a",
    particles: [
      "rgba(255,255,255,0.70)",
      "rgba(255,255,255,0.45)",
@@ -18,9 +13,9 @@ const PALETTES = {
      "rgba(200,200,200,0.35)",
      "rgba(255,255,255,0.22)",
    ],
+    grainOpacity: 0.05,
  },
  light: {
-    base: "#f5f5f5",
    particles: [
      "rgba(0,0,0,0.55)",
      "rgba(0,0,0,0.35)",
@@ -28,22 +23,10 @@ const PALETTES = {
      "rgba(80,80,80,0.25)",
      "rgba(0,0,0,0.18)",
    ],
+    grainOpacity: 0.03,
  },
 } as const;

-/* ─────────────────────────────────────────────
- *  Helpers
- * ───────────────────────────────────────────── */
-const isMobileDevice = (): boolean => {
-  if (typeof window === "undefined") return false;
-  return window.matchMedia("(pointer: coarse)").matches || window.innerWidth < 768;
-};
-
-const rand = (min: number, max: number) => Math.random() * (max - min) + min;
-
-/* ─────────────────────────────────────────────
- *  Particle
- * ───────────────────────────────────────────── */
 interface Particle {
  angle: number;
  radius: number;
@@ -55,33 +38,52 @@ interface Particle {
  wobblePhase: number;
 }

-const spawnParticle = (): Particle => ({
-  angle: rand(0, Math.PI * 2),
-  radius: rand(30, 240),
-  speed: rand(0.003, 0.002) * (Math.random() > 0.5 ? 1 : -1),
-  size: rand(1.2, 4),
-  colorIndex: Math.floor(rand(0, 5)),
-  wobbleAmp: rand(6, 30),
-  wobbleSpeed: rand(0.008, 0.035),
-  wobblePhase: rand(0, Math.PI * 2),
-});
+interface CanvasSize {
+  dpr: number;
+  height: number;
+  width: number;
+}

-/* ─────────────────────────────────────────────
- *  Component
- * ───────────────────────────────────────────── */
 interface AnimatedBackgroundContainerProps {
  children: React.ReactNode;
  className?: string;
-  /** Number of orbiting particles. Default 60 */
  particleCount?: number;
-  /** Max orbit radius in px — controls how far particles spread from the cursor. Default 240 */
  orbitRadius?: number;
-  /** How quickly particles catch up to cursor (0–1). Default 0.06 */
  followSpeed?: number;
-  /** Speed multiplier for mobile random anchor drift. Default 1 */
  mobileSpeed?: number;
 }

+const DEFAULT_PARTICLE_COLORS: readonly string[] = PALETTES.dark.particles;
+const PARTICLE_COLOR_COUNT = DEFAULT_PARTICLE_COLORS.length;
+const EDGE_FADE_DISTANCE = 80;
+const MAX_DEVICE_PIXEL_RATIO = 2;
+const MOBILE_TARGET_DISTANCE = 30;
+
+const rand = (min: number, max: number) => Math.random() * (max - min) + min;
+
+const isMobileDevice = () => {
+  if (typeof window === "undefined") {
+    return false;
+  }
+
+  return window.matchMedia("(pointer: coarse)").matches || window.innerWidth < 768;
+};
+
+const createParticle = (orbitRadius: number): Particle => {
+  const minRadius = Math.max(10, orbitRadius * 0.12);
+
+  return {
+    angle: rand(0, Math.PI * 2),
+    radius: rand(minRadius, orbitRadius),
+    speed: rand(0.002, 0.003) * (Math.random() > 0.5 ? 1 : -1),
+    size: rand(1.2, 4),
+    colorIndex: Math.floor(rand(0, PARTICLE_COLOR_COUNT)),
+    wobbleAmp: rand(orbitRadius * 0.025, orbitRadius * 0.12),
+    wobbleSpeed: rand(0.008, 0.035),
+    wobblePhase: rand(0, Math.PI * 2),
+  };
+};
+
 export default function AnimatedBackgroundContainer({
  children,
  className = "",
@@ -92,172 +94,304 @@ export default function AnimatedBackgroundContainer({
 }: AnimatedBackgroundContainerProps) {
  const canvasRef = useRef<HTMLCanvasElement>(null);
  const containerRef = useRef<HTMLDivElement>(null);
-  const mousePos = useRef({ x: 0, y: 0 });
-  const smoothMouse = useRef({ x: 0, y: 0 });
-  const mobileAnchor = useRef({ x: 0, y: 0 });
-  const mobileTarget = useRef({ x: 0, y: 0 });
-  const isMobile = useRef(false);
-  const particles = useRef<Particle[]>([]);
-  const frame = useRef(0);
-  const [mounted, setMounted] = useState(false);
+  const frameRef = useRef(0);
+  const animationFrameRef = useRef<number | null>(null);
+  const isMobileRef = useRef(false);
+  const isVisibleRef = useRef(true);
+  const prefersReducedMotionRef = useRef(false);
+  const particlesRef = useRef<Particle[]>([]);
+  const mousePosRef = useRef({ x: 0, y: 0 });
+  const smoothMouseRef = useRef({ x: 0, y: 0 });
+  const mobileAnchorRef = useRef({ x: 0, y: 0 });
+  const mobileTargetRef = useRef({ x: 0, y: 0 });
+  const canvasSizeRef = useRef<CanvasSize>({ dpr: 1, height: 0, width: 0 });
+  const containerRectRef = useRef<DOMRect | null>(null);
+  const followSpeedRef = useRef(followSpeed);
+  const mobileSpeedRef = useRef(mobileSpeed);
+  const particleColorsRef = useRef<readonly string[]>(DEFAULT_PARTICLE_COLORS);

  const { resolvedTheme } = useTheme();
-  let isDark = resolvedTheme === "dark";
-  if (resolvedTheme == undefined) {
-    isDark = true;
-  }
+  const isDark = resolvedTheme === undefined || resolvedTheme === "dark";
  const palette = isDark ? PALETTES.dark : PALETTES.light;

-  /* Spawn particles */
  useEffect(() => {
-    const minR = Math.max(10, orbitRadius * 0.12);
-    particles.current = Array.from({ length: particleCount }, () => ({
-      ...spawnParticle(),
-      radius: rand(minR, orbitRadius),
-      wobbleAmp: rand(orbitRadius * 0.025, orbitRadius * 0.12),
-    }));
+    particleColorsRef.current = palette.particles;
+  }, [palette]);
+
+  useEffect(() => {
+    followSpeedRef.current = followSpeed;
+  }, [followSpeed]);
+
+  useEffect(() => {
+    mobileSpeedRef.current = mobileSpeed;
+  }, [mobileSpeed]);
+
+  useEffect(() => {
+    particlesRef.current = Array.from({ length: particleCount }, () =>
+      createParticle(orbitRadius),
+    );
  }, [particleCount, orbitRadius]);

-  /* Detect mobile & seed positions */
-  useEffect(() => {
-    setMounted(true);
-    isMobile.current = isMobileDevice();
-    if (containerRef.current) {
-      const cx = containerRef.current.clientWidth / 2;
-      const cy = containerRef.current.clientHeight / 2;
-      mousePos.current = { x: cx, y: cy };
-      smoothMouse.current = { x: cx, y: cy };
-      mobileAnchor.current = { x: cx, y: cy };
-      mobileTarget.current = {
-        x: rand(cx * 0.4, cx * 1.6),
-        y: rand(cy * 0.4, cy * 1.6),
-      };
+  const seedPositions = useCallback(() => {
+    const { height, width } = canvasSizeRef.current;
+    if (width === 0 || height === 0) {
+      return;
+    }
+
+    const centerX = width / 2;
+    const centerY = height / 2;
+
+    mousePosRef.current = { x: centerX, y: centerY };
+    smoothMouseRef.current = { x: centerX, y: centerY };
+    mobileAnchorRef.current = { x: centerX, y: centerY };
+    mobileTargetRef.current = {
+      x: rand(centerX * 0.4, centerX * 1.6),
+      y: rand(centerY * 0.4, centerY * 1.6),
+    };
+  }, []);
+
+  const updateContainerRect = useCallback(() => {
+    const container = containerRef.current;
+    if (container) {
+      containerRectRef.current = container.getBoundingClientRect();
    }
  }, []);

-  /* Resize canvas to match container */
-  useEffect(() => {
-    const resize = () => {
-      const canvas = canvasRef.current;
-      const container = containerRef.current;
-      if (!canvas || !container) return;
-      const dpr = window.devicePixelRatio || 1;
-      const w = container.clientWidth;
-      const h = container.clientHeight;
-      canvas.width = w * dpr;
-      canvas.height = h * dpr;
-      canvas.style.width = `${w}px`;
-      canvas.style.height = `${h}px`;
-      const ctx = canvas.getContext("2d");
-      if (ctx) ctx.scale(dpr, dpr);
-    };
-    resize();
-    window.addEventListener("resize", resize);
-    return () => window.removeEventListener("resize", resize);
-  }, []);
+  const resizeCanvas = useCallback(() => {
+    const canvas = canvasRef.current;
+    const container = containerRef.current;
+    if (!canvas || !container) {
+      return;
+    }

-  /* Mouse tracking (desktop only) */
-  const handleMouseMove = useCallback((e: MouseEvent) => {
-    if (!containerRef.current || isMobile.current) return;
-    const rect = containerRef.current.getBoundingClientRect();
-    mousePos.current = {
-      x: e.clientX - rect.left,
-      y: e.clientY - rect.top,
+    const width = container.clientWidth;
+    const height = container.clientHeight;
+    const dpr = Math.min(window.devicePixelRatio || 1, MAX_DEVICE_PIXEL_RATIO);
+    const nextWidth = Math.round(width * dpr);
+    const nextHeight = Math.round(height * dpr);
+
+    canvasSizeRef.current = { dpr, height, width };
+    updateContainerRect();
+
+    if (canvas.width !== nextWidth) {
+      canvas.width = nextWidth;
+    }
+    if (canvas.height !== nextHeight) {
+      canvas.height = nextHeight;
+    }
+    canvas.style.width = `${width}px`;
+    canvas.style.height = `${height}px`;
+
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return;
+    }
+
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.scale(dpr, dpr);
+    seedPositions();
+  }, [seedPositions, updateContainerRect]);
+
+  useEffect(() => {
+    isMobileRef.current = isMobileDevice();
+    resizeCanvas();
+
+    const handleResize = () => {
+      isMobileRef.current = isMobileDevice();
+      resizeCanvas();
+    };
+
+    const resizeObserver =
+      "ResizeObserver" in window
+        ? new ResizeObserver(() => {
+            handleResize();
+          })
+        : null;
+
+    if (containerRef.current && resizeObserver) {
+      resizeObserver.observe(containerRef.current);
+    }
+
+    window.addEventListener("resize", handleResize);
+    window.addEventListener("scroll", updateContainerRect, {
+      capture: true,
+      passive: true,
+    });
+    return () => {
+      resizeObserver?.disconnect();
+      window.removeEventListener("resize", handleResize);
+      window.removeEventListener("scroll", updateContainerRect, { capture: true });
+    };
+  }, [resizeCanvas, updateContainerRect]);
+
+  const handleMouseMove = useCallback((event: MouseEvent) => {
+    const rect = containerRectRef.current;
+    if (!rect || isMobileRef.current) {
+      return;
+    }
+
+    mousePosRef.current = {
+      x: event.clientX - rect.left,
+      y: event.clientY - rect.top,
    };
  }, []);

  useEffect(() => {
-    const el = containerRef.current;
-    if (!el) return;
-    el.addEventListener("mousemove", handleMouseMove, { passive: true });
-    return () => el.removeEventListener("mousemove", handleMouseMove);
+    const container = containerRef.current;
+    if (!container) {
+      return;
+    }
+
+    container.addEventListener("mousemove", handleMouseMove, { passive: true });
+    return () => container.removeEventListener("mousemove", handleMouseMove);
  }, [handleMouseMove]);

-  /* ── GSAP ticker — draw loop ── */
-  useGSAP(
-    () => {
-      if (!mounted) return;
-      const canvas = canvasRef.current;
-      const container = containerRef.current;
-      if (!canvas || !container) return;
-      const ctx = canvas.getContext("2d");
-      if (!ctx) return;
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) {
+      return;
+    }

-      const tick = () => {
-        const w = container.clientWidth;
-        const h = container.clientHeight;
-        frame.current++;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return;
+    }

-        /* Anchor: smooth-follow cursor or drift on mobile */
-        if (isMobile.current) {
-          mobileAnchor.current.x +=
-            (mobileTarget.current.x - mobileAnchor.current.x) * 0.008 * mobileSpeed;
-          mobileAnchor.current.y +=
-            (mobileTarget.current.y - mobileAnchor.current.y) * 0.008 * mobileSpeed;
+    const stopAnimation = () => {
+      if (animationFrameRef.current !== null) {
+        window.cancelAnimationFrame(animationFrameRef.current);
+        animationFrameRef.current = null;
+      }
+    };

-          const dx = mobileTarget.current.x - mobileAnchor.current.x;
-          const dy = mobileTarget.current.y - mobileAnchor.current.y;
-          if (Math.sqrt(dx * dx + dy * dy) < 30) {
-            mobileTarget.current = {
-              x: rand(w * 0.15, w * 0.85),
-              y: rand(h * 0.15, h * 0.85),
-            };
-          }
-          smoothMouse.current.x = mobileAnchor.current.x;
-          smoothMouse.current.y = mobileAnchor.current.y;
-        } else {
-          smoothMouse.current.x +=
-            (mousePos.current.x - smoothMouse.current.x) * followSpeed;
-          smoothMouse.current.y +=
-            (mousePos.current.y - smoothMouse.current.y) * followSpeed;
+    const draw = () => {
+      if (!isVisibleRef.current || prefersReducedMotionRef.current) {
+        animationFrameRef.current = null;
+        return;
+      }
+
+      const { height, width } = canvasSizeRef.current;
+      if (width === 0 || height === 0) {
+        animationFrameRef.current = window.requestAnimationFrame(draw);
+        return;
+      }
+
+      frameRef.current += 1;
+
+      if (isMobileRef.current) {
+        const mobileLerp = 0.008 * mobileSpeedRef.current;
+        mobileAnchorRef.current.x +=
+          (mobileTargetRef.current.x - mobileAnchorRef.current.x) * mobileLerp;
+        mobileAnchorRef.current.y +=
+          (mobileTargetRef.current.y - mobileAnchorRef.current.y) * mobileLerp;
+
+        const dx = mobileTargetRef.current.x - mobileAnchorRef.current.x;
+        const dy = mobileTargetRef.current.y - mobileAnchorRef.current.y;
+        if (Math.hypot(dx, dy) < MOBILE_TARGET_DISTANCE) {
+          mobileTargetRef.current = {
+            x: rand(width * 0.15, width * 0.85),
+            y: rand(height * 0.15, height * 0.85),
+          };
        }

-        const cx = smoothMouse.current.x;
-        const cy = smoothMouse.current.y;
+        smoothMouseRef.current.x = mobileAnchorRef.current.x;
+        smoothMouseRef.current.y = mobileAnchorRef.current.y;
+      } else {
+        const desktopLerp = followSpeedRef.current;
+        smoothMouseRef.current.x +=
+          (mousePosRef.current.x - smoothMouseRef.current.x) * desktopLerp;
+        smoothMouseRef.current.y +=
+          (mousePosRef.current.y - smoothMouseRef.current.y) * desktopLerp;
+      }

-        /* Clear frame */
-        ctx.clearRect(0, 0, w, h);
+      const centerX = smoothMouseRef.current.x;
+      const centerY = smoothMouseRef.current.y;
+      const colors = particleColorsRef.current;

-        /* Draw each particle */
-        particles.current.forEach((p) => {
-          p.angle += p.speed;
+      ctx.clearRect(0, 0, width, height);

-          const wobble =
-            Math.sin(frame.current * p.wobbleSpeed + p.wobblePhase) * p.wobbleAmp;
-          const r = p.radius + wobble;
+      for (const particle of particlesRef.current) {
+        particle.angle += particle.speed;

-          const x = cx + Math.cos(p.angle) * r;
-          const y = cy + Math.sin(p.angle) * r;
+        const wobble =
+          Math.sin(frameRef.current * particle.wobbleSpeed + particle.wobblePhase) *
+          particle.wobbleAmp;
+        const radius = particle.radius + wobble;
+        const x = centerX + Math.cos(particle.angle) * radius;
+        const y = centerY + Math.sin(particle.angle) * radius;

-          /* Soft fade near viewport edges */
-          const edgeFade = Math.max(
-            0,
-            Math.min(x / 80, (w - x) / 80, y / 80, (h - y) / 80, 1),
-          );
-          if (edgeFade <= 0) return;
+        const edgeFade = Math.max(
+          0,
+          Math.min(
+            x / EDGE_FADE_DISTANCE,
+            (width - x) / EDGE_FADE_DISTANCE,
+            y / EDGE_FADE_DISTANCE,
+            (height - y) / EDGE_FADE_DISTANCE,
+            1,
+          ),
+        );

-          ctx.globalAlpha = edgeFade;
-          ctx.fillStyle = palette.particles[p.colorIndex];
-          ctx.beginPath();
-          ctx.arc(x, y, p.size, 0, Math.PI * 2);
-          ctx.fill();
-        });
+        if (edgeFade <= 0) {
+          continue;
+        }

-        ctx.globalAlpha = 1;
-      };
+        ctx.globalAlpha = edgeFade;
+        ctx.fillStyle = colors[particle.colorIndex] ?? colors[0] ?? "#ffffff";
+        ctx.beginPath();
+        ctx.arc(x, y, particle.size, 0, Math.PI * 2);
+        ctx.fill();
+      }

-      gsap.ticker.add(tick);
-      return () => {
-        gsap.ticker.remove(tick);
-      };
-    },
-    {
-      scope: containerRef,
-      dependencies: [mounted, isDark, followSpeed, mobileSpeed, orbitRadius, palette],
-    },
-  );
+      ctx.globalAlpha = 1;
+      animationFrameRef.current = window.requestAnimationFrame(draw);
+    };
+
+    const startAnimation = () => {
+      if (
+        animationFrameRef.current === null &&
+        isVisibleRef.current &&
+        !prefersReducedMotionRef.current
+      ) {
+        animationFrameRef.current = window.requestAnimationFrame(draw);
+      }
+    };
+
+    const handleVisibilityChange = () => {
+      isVisibleRef.current = document.visibilityState === "visible";
+
+      if (isVisibleRef.current) {
+        startAnimation();
+      } else {
+        stopAnimation();
+      }
+    };
+
+    const motionMedia = window.matchMedia("(prefers-reduced-motion: reduce)");
+    const handleMotionChange = () => {
+      prefersReducedMotionRef.current = motionMedia.matches;
+
+      if (prefersReducedMotionRef.current) {
+        stopAnimation();
+        ctx.clearRect(0, 0, canvasSizeRef.current.width, canvasSizeRef.current.height);
+      } else {
+        startAnimation();
+      }
+    };
+
+    isVisibleRef.current = document.visibilityState === "visible";
+    prefersReducedMotionRef.current = motionMedia.matches;
+    startAnimation();
+
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+    motionMedia.addEventListener("change", handleMotionChange);
+
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibilityChange);
+      motionMedia.removeEventListener("change", handleMotionChange);
+      stopAnimation();
+    };
+  }, []);

-  /* ── Render ── */
  return (
    <div
      ref={containerRef}
@@ -281,14 +415,13 @@ export default function AnimatedBackgroundContainer({
        }}
      />

-      {/* Grain texture */}
      <div
        aria-hidden
        style={{
          position: "absolute",
          inset: 0,
          zIndex: 1,
-          opacity: isDark ? 0.05 : 0.03,
+          opacity: palette.grainOpacity,
          pointerEvents: "none",
          backgroundImage: `url("data:image/svg+xml,%3Csvg viewBox='0 0 256 256' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E")`,
          backgroundRepeat: "repeat",
--- a/src/app/_components/Animated/AnimatedDiv.tsx
+++ b/src/app/_components/Animated/AnimatedDiv.tsx
@@ -1,36 +1,39 @@
 import gsap from "gsap";
-import { type HTMLAttributes,
-type ReactNode, useLayoutEffect, useRef } from "react";
-import { useGsapContext } from "~/app/_providers/GsapProvicer";
+import { type HTMLAttributes, type ReactNode, useRef } from "react";
+import { useReveal } from "./useReveal";
+
 const AnimatedDiv = (
  {
    children,
    position,
    className,
-    animationMode='to',
+    animationMode = 'to',
+    scrollOnly = false,
+    once = false,
+    debugId,
    ...tweenVars
  }:
  gsap.TweenVars & {
-    children:ReactNode,
-    position:gsap.Position,
-    animationMode?: 'from'|'to',
-    className?:HTMLAttributes<HTMLDivElement>['className']
+    children: ReactNode,
+    position: gsap.Position,
+    animationMode?: 'from' | 'to',
+    scrollOnly?: boolean,
+    once?: boolean,
+    debugId?: string,
+    className?: HTMLAttributes<HTMLDivElement>['className']
  }
 ) => {
-  const div = useRef<HTMLDivElement>(null);
-  const gsapContext = useGsapContext()
-  useLayoutEffect(() => {
-    let tween:gsap.core.Tween;
-    switch(animationMode) {
-      case 'from':
-        tween = gsap.from(div.current,tweenVars);
-        break;
-      case 'to':
-        tween = gsap.to(div.current,tweenVars);
-        break;
-    }
-    gsapContext?.addAnimation(tween,position)
-  },[])
+  const div = useRef<HTMLDivElement>(null)
+  useReveal(div, {
+    position,
+    scrollOnly,
+    once,
+    debugId,
+    makeReveal: (el) =>
+      animationMode === 'from'
+        ? gsap.from(el, { ...tweenVars, paused: true })
+        : gsap.to(el, { ...tweenVars, paused: true }),
+  })
  return (
    <div ref={div} className={className}>
      {children}
--- a/src/app/_components/Animated/useReveal.ts
+++ b/src/app/_components/Animated/useReveal.ts
@@ -0,0 +1,102 @@
+'use client'
+
+import { useGSAP } from "@gsap/react"
+import { ScrollTrigger } from "gsap/all"
+import type { RefObject } from "react"
+import { GSAP_DEBUG, useGsapContext } from "~/app/_providers/GsapProvicer"
+
+export type UseRevealOptions = {
+  position: gsap.Position
+  /** Skip the orchestrated entrance and let ScrollTrigger drive from the start. */
+  scrollOnly?: boolean
+  /**
+   * Reveal once and keep it: after the element animates in (entrance or first
+   * scroll-in) it never reverses on leave. Default false = animate out at the
+   * top and back in on scroll-up.
+   */
+  once?: boolean
+  debugId?: string
+  /**
+   * Build the hidden -> shown animation for `el`. It must be a single,
+   * *independent* animation (not added to any timeline): `play()` reveals,
+   * `reverse()` hides. The hook pauses it, schedules its entrance through the
+   * shared timeline, and lets a ScrollTrigger drive the very same animation on
+   * scroll — so the two modes never fight over the element.
+   */
+  makeReveal: (el: HTMLElement) => gsap.core.Tween | gsap.core.Timeline
+}
+
+/**
+ * Shared reveal behavior for cards, text and pop-ups: an element in view at
+ * load plays an orchestrated timeline entrance, then hands the *same* tween to
+ * a ScrollTrigger that animates it out at the top and back in on scroll-up. An
+ * element off-screen at load is ScrollTrigger-driven from the start.
+ */
+export function useReveal(
+  ref: RefObject<HTMLElement | null>,
+  { position, scrollOnly = false, once = false, debugId, makeReveal }: UseRevealOptions,
+) {
+  const ctx = useGsapContext()
+  useGSAP(() => {
+    const el = ref.current
+    if (!el || !ctx) return
+
+    const scroller = ctx.getScroller()
+    const scrollerEl = scroller instanceof Element ? scroller : undefined
+
+    const rect = el.getBoundingClientRect()
+    let top = 0
+    let bottom = window.innerHeight
+    if (scrollerEl) {
+      const r = scrollerEl.getBoundingClientRect()
+      top = r.top
+      bottom = r.top + r.height
+    }
+    const isInView = rect.bottom > top && rect.top < bottom
+
+    const reveal = makeReveal(el)
+    // A reveal that animates height (pop-ups) shifts every trigger below it.
+    // Re-measure as it animates so positions track the real layout instead of
+    // only correcting at the very end. requestRefresh is throttled + deferred to
+    // the next frame, so this won't re-enter a ScrollTrigger callback.
+    reveal.eventCallback("onUpdate", () => ctx.requestRefresh())
+    reveal.pause()
+
+    const baseTrigger = {
+      trigger: el,
+      start: "top bottom",
+      end: "bottom top",
+      scroller: scrollerEl,
+      markers: GSAP_DEBUG,
+      id: GSAP_DEBUG ? debugId : undefined,
+    }
+    // Full behavior: in at the bottom, out at the top, and back on scroll-up.
+    const addReplayTrigger = () =>
+      ScrollTrigger.create({
+        ...baseTrigger,
+        onEnter: () => reveal.play(),
+        onEnterBack: () => reveal.play(),
+        onLeave: () => reveal.reverse(),
+        onLeaveBack: () => reveal.reverse(),
+      })
+
+    if (isInView && !scrollOnly) {
+      // The shared timeline only decides *when* the entrance starts; the reveal
+      // plays independently so the ScrollTrigger can take it over afterwards.
+      ctx.schedule(() => reveal.play(), position)
+      // `once` elements keep their revealed state — no scroll trigger at all.
+      if (!once) ctx.onReady(addReplayTrigger)
+    } else if (isInView) {
+      // scrollOnly + already on screen: no enter crossing will fire, so reveal
+      // now. Keep a trigger for scroll-out unless this is a `once` element.
+      reveal.play()
+      if (!once) addReplayTrigger()
+    } else if (once) {
+      // Off-screen: reveal when first reached, then self-destruct so it never
+      // reverses.
+      ScrollTrigger.create({ ...baseTrigger, once: true, onEnter: () => reveal.play() })
+    } else {
+      addReplayTrigger()
+    }
+  }, { dependencies: [] })
+}
--- a/src/app/_components/Form/Fields/IntInputFormField.tsx
+++ b/src/app/_components/Form/Fields/IntInputFormField.tsx
@@ -0,0 +1,53 @@
+import type { ComponentProps } from "react";
+import type { Control, FieldValues, Path } from "react-hook-form";
+import { FormControl, FormField, FormItem, FormLabel } from "~/components/ui/form";
+import { Input } from "~/components/ui/input";
+
+type IntInputFormFieldProps<T extends FieldValues> = Omit<
+  ComponentProps<typeof Input>,
+  "defaultValue" | "name" | "onChange" | "type" | "value"
+> & {
+  control: Control<T>;
+  emptyValue?: null | undefined;
+  label: string;
+  name: Path<T>;
+};
+
+export default function IntInputFormField<T extends FieldValues>({
+  control,
+  emptyValue,
+  label,
+  name,
+  ...inputProps
+}: IntInputFormFieldProps<T>) {
+  return (
+    <FormField
+      control={control}
+      name={name}
+      render={({ field }) => (
+        <FormItem className="flex flex-col">
+          <FormLabel>{label}</FormLabel>
+          <FormControl>
+            <Input
+              {...inputProps}
+              inputMode="numeric"
+              onBlur={field.onBlur}
+              onChange={(event) => {
+                const value = event.currentTarget.value;
+
+                field.onChange(
+                  value === "" ? emptyValue : Number.parseInt(value, 10),
+                );
+              }}
+              placeholder={inputProps.placeholder ?? name}
+              ref={field.ref}
+              step={inputProps.step ?? 1}
+              type="number"
+              value={field.value ?? ""}
+            />
+          </FormControl>
+        </FormItem>
+      )}
+    />
+  );
+}
--- a/src/app/_components/Form/Fields/MultiBooleanFormField.tsx
+++ b/src/app/_components/Form/Fields/MultiBooleanFormField.tsx
@@ -1,6 +1,7 @@
 import type { CheckedState } from "@radix-ui/react-checkbox";
 import { ChevronDownIcon } from "lucide-react";
-import { createContext,useContext, useState } from "react";
+import { ScrollArea } from "~/components/ui/scroll-area";
+import { createContext,useContext, useState, type KeyboardEventHandler } from "react";
 import { useFormContext, type Control, type ControllerRenderProps, type FieldValues, type Path } from "react-hook-form";
 import type { Entries } from "type-fest";
 import { Button } from "~/components/ui/button";
@@ -16,6 +17,7 @@ const MultiBooleanFieldContext = createContext<MultiBooleanFieldContextProps|und

 function InnerMultiBooleanFormField(params: { options: string[], onChange: (arg0: string[]) => void }) {
  const context = useContext(MultiBooleanFieldContext)
+  const [searchBuffer, setSearchBuffer] = useState<string>("")
  if (context === undefined) {
    return (<></>)
  }
@@ -43,19 +45,40 @@ function InnerMultiBooleanFormField(params: { options: string[], onChange: (arg0
    }
    return context.checkedValues[key]
  }
+
+  const handleKeyDown:KeyboardEventHandler = (e) => {
+    if (e.ctrlKey && e.key == "c") {
+      setSearchBuffer("")
+    } else if (e.code == "Backspace") {
+      setSearchBuffer((prev) => {
+        const newVal = prev.substring(0,prev.length - 2)
+        console.log(newVal)
+        return newVal
+      })
+    }
+
+   else if (e.key.length === 1) {
+      setSearchBuffer((prev) => {
+        const newVal = prev + e.key;
+        console.log(newVal)
+        return newVal;
+      })
+    }
+  }
+
  return (
-    <>
+    <ScrollArea onKeyDown={handleKeyDown} className="flex h-60">
      {
        params.options.map((opt) => (
-          <FormItem key={opt}>
-            <div className="flex flex-row justify-between py-2 border-b-1">
+           opt.startsWith(searchBuffer) && <FormItem key={opt}>
+            <div className="flex flex-row justify-between py-2 border-b">
            <FormLabel>{opt}</FormLabel>
            <Checkbox data-testid="multiboolean-checkbox" checked={checked(opt)} onCheckedChange={onCheckedItemChange(opt)} />
            </div>
          </FormItem>
        ))
      }
-    </>
+    </ScrollArea>
  )
 }
 export default function MultiBooleanFormField<T extends FieldValues>(params: { control: Control<T>, name: Path<T>, label: string, options: string[], defaultValues?: string[] }) {
@@ -76,9 +99,9 @@ export default function MultiBooleanFormField<T extends FieldValues>(params: { c
          </PopoverTrigger>
          <FormControl>
          <PopoverContent data-testid="multiboolean-content">
-            <MultiBooleanFieldContext.Provider value={{checkedValues: checkedValues, setCheckedValue: setCheckedValues}}>
-              <InnerMultiBooleanFormField onChange={field.onChange} options={params.options} />
-            </MultiBooleanFieldContext.Provider>
+              <MultiBooleanFieldContext.Provider value={{checkedValues: checkedValues, setCheckedValue: setCheckedValues}}>
+                <InnerMultiBooleanFormField onChange={field.onChange} options={params.options} />
+              </MultiBooleanFieldContext.Provider>
          </PopoverContent>
          </FormControl>
          </Popover>
--- a/src/app/_components/Form/Fields/index.ts
+++ b/src/app/_components/Form/Fields/index.ts
@@ -1,5 +1,6 @@
 export { default as BooleanFormField } from './BooleanFormField'
 export { default as TextInputFormField } from './TextInputFormField'
+export { default as IntInputFormField } from './IntInputFormField'
 export { default as MultiBooleanFormField } from './MultiBooleanFormField'
 export { default as SelectFormField } from './SelectFormField'
 export { default as MdeFormField } from './MdeFormField'
--- a/src/app/_providers/GsapProvicer.tsx
+++ b/src/app/_providers/GsapProvicer.tsx
@@ -9,11 +9,32 @@ gsap.registerPlugin(useGSAP)
 gsap.registerPlugin(ScrollTrigger)
 gsap.registerPlugin(SplitText)
 gsap.registerPlugin(GSDevTools)
+
+// iOS Safari shows/hides its address bar at the scroll extremes, which resizes
+// the viewport and makes ScrollTrigger refresh + fire spurious onLeave/onEnter
+// toggles (text animating out at the bottom and not coming back). Ignoring those
+// mobile-toolbar resizes keeps the real enter/leave reverse behavior intact.
+ScrollTrigger.config({ ignoreMobileResize: true })
+
+// Flip to true to draw ScrollTrigger start/end markers on every animated
+// element and mount the GSDevTools timeline scrubber. Handy for seeing exactly
+// where each card's enter/exit lines sit relative to the viewport.
+export const GSAP_DEBUG = false
 const GsapContext = createContext<{
+  // Add a real animation (with its own duration) to the entrance timeline.
  addAnimation: (
    animation: gsap.core.TimelineChild,
    position: gsap.Position
  ) => void,
+  // Schedule a zero-duration callback at `position` — used to *start* an
+  // independent reveal tween so the timeline only orchestrates timing.
+  schedule: (fn: () => void, position: gsap.Position) => void,
+  // Run `cb` once the entrance is done (timeline complete or first user scroll).
+  onReady: (cb: () => void) => void,
+  // Re-measure all ScrollTriggers (throttled to once per frame). Call it
+  // whenever an animation changes content height so trigger positions stay
+  // aligned with the real layout.
+  requestRefresh: () => void,
  resetTimeline: () => void,
  resumeTimeline: () => void,
  getScroller: () => Element | Window | null
@@ -70,29 +91,112 @@ export default function GsapProvider({ children }: { children: ReactNode }) {
    // }
    return scrollerRef.current
  }, [])
+  const devToolsCreated = useRef(false)
  useGSAP(() => {
    if (!tl.current) {
      tl.current = gsap.timeline({ paused: true })
    }
+    if (GSAP_DEBUG && tl.current && !devToolsCreated.current) {
+      devToolsCreated.current = true
+      GSDevTools.create({ animation: tl.current })
+    }
    return () => { console.log("gsap cleanup") }
  })

+  // Handoff: fire registered callbacks once, when the entrance finishes.
+  const readyFired = useRef(false)
+  const readyCbs = useRef<Array<() => void>>([])
+  const fireReady = useCallback(() => {
+    if (readyFired.current) return
+    readyFired.current = true
+    readyCbs.current.forEach((cb) => cb())
+    readyCbs.current = []
+  },[])
+  const onReady = useCallback((cb: () => void) => {
+    if (readyFired.current) cb()
+    else readyCbs.current.push(cb)
+  },[])
+
  const addAnimation = useCallback((animation: gsap.core.TimelineChild, position: gsap.Position) => {
-    console.log("add animation to:", position, tl.current !== undefined)
+    // Content can mount in waves (e.g. nested queries resolving after the
+    // entrance already played). Parking a tween in a finished, paused timeline
+    // would freeze it at its from-state, so once the entrance is done let the
+    // (live) tween play on its own instead.
+    if (readyFired.current) return
    tl.current?.add(animation, position);
  },[])
+  const schedule = useCallback((fn: () => void, position: gsap.Position) => {
+    // Same late-arrival case: a callback added past the playhead never fires, so
+    // run the reveal immediately once the entrance has finished.
+    if (readyFired.current) { fn(); return }
+    tl.current?.add(fn, position)
+  },[])
+
+  // Throttle ScrollTrigger.refresh() to once per frame so the ResizeObserver
+  // can fire freely while content height animates.
+  const refreshQueued = useRef(false)
+  const scheduleRefresh = useCallback(() => {
+    if (refreshQueued.current) return
+    refreshQueued.current = true
+    requestAnimationFrame(() => {
+      refreshQueued.current = false
+      ScrollTrigger.refresh()
+    })
+  },[])
+
+  const scrollCleanup = useRef<(() => void) | null>(null)
+  const resizeObserver = useRef<ResizeObserver | null>(null)
+
  const resetTimeline = useCallback(() => {
    tl.current?.kill()
    tl.current?.revert()
    ScrollTrigger.getAll().forEach(st => st.kill())
+    resizeObserver.current?.disconnect()
+    scrollCleanup.current?.()
+    scrollCleanup.current = null
+    readyFired.current = false
+    readyCbs.current = []
    tl.current = gsap.timeline({paused:true})
  },[])
+
  const resumeTimeline = useCallback(() => {
-    console.log("resuming timeline:",tl.current)
-    tl.current?.resume()
-  },[])
+    const t = tl.current
+    if (!t) return
+    // When the orchestrated entrance finishes, hand off to scroll control and
+    // realign triggers against the now-settled layout.
+    t.eventCallback("onComplete", () => { fireReady(); ScrollTrigger.refresh() })
+
+    const scroller = getScroller()
+    // If the user scrolls before the entrance finishes, snap it to the end and
+    // switch to scroll control so the timeline and ScrollTriggers never fight
+    // over the same elements.
+    scrollCleanup.current?.()
+    const onFirstScroll = () => { t.progress(1); fireReady() }
+    scroller?.addEventListener("scroll", onFirstScroll, { once: true, passive: true })
+    scrollCleanup.current = () => scroller?.removeEventListener("scroll", onFirstScroll)
+
+    // Continuously realign triggers while content height changes — entrance
+    // growth, scroll-driven collapses, late-loading media.
+    if (scroller instanceof Element) {
+      const target = scroller.firstElementChild ?? scroller
+      resizeObserver.current?.disconnect()
+      resizeObserver.current = new ResizeObserver(scheduleRefresh)
+      resizeObserver.current.observe(target)
+    }
+
+    t.resume()
+  },[getScroller, fireReady, scheduleRefresh])
+
+  // Fonts/markdown/images loading also change content height after the triggers
+  // were created; refresh so start/end stay aligned with the real card sizes.
+  useEffect(() => {
+    const refresh = () => ScrollTrigger.refresh()
+    window.addEventListener("load", refresh)
+    document.fonts?.ready.then(refresh).catch(() => {})
+    return () => window.removeEventListener("load", refresh)
+  }, [])
  return (
-    <GsapContext.Provider value={{ addAnimation, resetTimeline, resumeTimeline, getScroller }}>
+    <GsapContext.Provider value={{ addAnimation, schedule, onReady, requestRefresh: scheduleRefresh, resetTimeline, resumeTimeline, getScroller }}>
      {children}
    </GsapContext.Provider>
  )
--- a/src/app/_providers/MessagesProvider.tsx
+++ b/src/app/_providers/MessagesProvider.tsx
@@ -3,7 +3,7 @@ import type { inferRouterOutputs } from '@trpc/server';
 import { useUser } from '@clerk/nextjs'
 import { createContext, useContext, useEffect, useState, type ReactNode } from 'react'
 import { trpc } from '~/app/_trpc/Client'
-import { type ChatRouter } from '~/server/routers/chat'
+import type { ChatRouter } from '~/server/routers/chat'
 const MessageContext = createContext<{
  session?: inferRouterOutputs<ChatRouter>['getSession']
  messages?: inferRouterOutputs<ChatRouter>['getMessages']
--- a/src/app/admin/_components/AdminSideBar.tsx
+++ b/src/app/admin/_components/AdminSideBar.tsx
@@ -6,8 +6,8 @@ import SimpleSidebarGroup from "~/components/ui/simple-sidebar-group";
 export default function AdminSideBar() {
  return (
    <>
-        <Sidebar variant="floating" className="h-[96%] mt-10 z-[51]">
-          <SidebarTrigger className="absolute z-[52] left-65 top-100" />
+        <Sidebar variant="floating" className="h-full lg:h-[96%] lg:mt-10 z-51">
+          <SidebarTrigger className="absolute z-52 left-65 top-100" />
          <SidebarContent>
            <ScrollArea>
            <SimpleSidebarGroup lable="CV">
--- a/src/app/admin/chat/_components/ModelSelector.tsx
+++ b/src/app/admin/chat/_components/ModelSelector.tsx
@@ -0,0 +1,48 @@
+'use client'
+import { trpc } from '~/app/_trpc/Client'
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from '~/components/ui/select'
+
+export default function ModelSelector({ initialValue }: { initialValue: string }) {
+	const utils = trpc.useUtils()
+	const { data: models, isLoading, error } = trpc.chat.listModels.useQuery()
+	const { data: model = initialValue } = trpc.chat.getModel.useQuery(undefined, {
+		initialData: initialValue,
+	})
+
+	const mutation = trpc.chat.updateModel.useMutation({
+		onSuccess: () => utils.chat.getModel.invalidate(),
+	})
+
+	// Ensure the currently-saved model is always selectable, even if the
+	// OpenAI list doesn't include it (e.g. a deprecated model).
+	const options = Array.from(new Set([model, ...(models ?? [])])).filter(Boolean)
+
+	return (
+		<div className="flex flex-col gap-2">
+			<Select value={model} onValueChange={(v) => mutation.mutate({ model: v })}>
+				<SelectTrigger className="w-72">
+					<SelectValue placeholder={isLoading ? 'Loading models…' : 'Select a model'} />
+				</SelectTrigger>
+				<SelectContent>
+					{options.map((id) => (
+						<SelectItem key={id} value={id}>
+							{id}
+						</SelectItem>
+					))}
+				</SelectContent>
+			</Select>
+			<div className="flex items-center gap-3 text-sm text-muted-foreground">
+				{mutation.isPending && <span>Saving…</span>}
+				{mutation.isSuccess && !mutation.isPending && <span>Saved</span>}
+				{error && <span className="text-destructive">Failed to load models: {error.message}</span>}
+				{mutation.error && <span className="text-destructive">{mutation.error.message}</span>}
+			</div>
+		</div>
+	)
+}
--- a/src/app/admin/chat/page.tsx
+++ b/src/app/admin/chat/page.tsx
@@ -1,22 +1,31 @@
-import { isAdmin } from '~/app/actions'
-import { redirect } from 'next/navigation'
 import { servTrpc } from '~/app/_trpc/ServerClient'
 import SystemPromptForm from './_components/SystemPromptForm'
+import ModelSelector from './_components/ModelSelector'

 export default async function SystemPromptPage() {
-	if (!(await isAdmin())) redirect('/admin')
-
 	const prompt = await servTrpc.chat.getSystemPrompt()
+	const model = await servTrpc.chat.getModel()

 	return (
-		<div className="w-full max-w-2xl p-6 flex flex-col gap-4">
-			<div>
-				<h1 className="text-lg font-semibold">AI System Prompt</h1>
-				<p className="text-sm text-muted-foreground">
-					This prompt is sent to the model on every chat request.
-				</p>
+		<div className="w-full max-w-2xl p-6 flex flex-col gap-8">
+			<div className="flex flex-col gap-4">
+				<div>
+					<h1 className="text-lg font-semibold">AI Model</h1>
+					<p className="text-sm text-muted-foreground">
+						The OpenAI model used to respond to chat requests.
+					</p>
+				</div>
+				<ModelSelector initialValue={model} />
+			</div>
+			<div className="flex flex-col gap-4">
+				<div>
+					<h1 className="text-lg font-semibold">AI System Prompt</h1>
+					<p className="text-sm text-muted-foreground">
+						This prompt is sent to the model on every chat request.
+					</p>
+				</div>
+				<SystemPromptForm initialValue={prompt} />
 			</div>
-			<SystemPromptForm initialValue={prompt} />
 		</div>
 	)
 }
--- a/src/app/admin/layout.tsx
+++ b/src/app/admin/layout.tsx
@@ -1,10 +1,14 @@
+import { redirect } from "next/navigation";
+import { isAdmin } from "~/app/actions";
 import { SidebarProvider } from "~/components/ui/sidebar";
 import AdminSideBar from "./_components/AdminSideBar";
 import { ScrollArea } from "~/components/ui/scroll-area";

 export const dynamic = 'force-dynamic';

-export default function Admin({children}: Readonly<{children: React.ReactNode}>) {
+export default async function Admin({children}: Readonly<{children: React.ReactNode}>) {
+  if (!(await isAdmin())) redirect("/");
+
  return (
    <>
      <SidebarProvider>
--- a/src/app/admin/music/_components/ConvertToStreamButton.tsx
+++ b/src/app/admin/music/_components/ConvertToStreamButton.tsx
@@ -0,0 +1,100 @@
+'use client'
+
+import { useState } from "react";
+import { AudioLines, Loader2, RefreshCw } from "lucide-react";
+import { Button } from "~/components/ui/button";
+import { trpc } from "~/app/_trpc/Client";
+import { useUploadThing } from "~/lib/uploadthing";
+import { transcodeToAac } from "~/lib/ffmpeg/transcode";
+import { toast } from "sonner";
+import type { RouterOutputs } from "~/server/routers/_app";
+import type { IterableElement } from "type-fest";
+
+export default function ConvertToStreamButton(props: {
+	track: IterableElement<RouterOutputs['music']['list']>;
+}) {
+	const { track } = props;
+	const utils = trpc.useUtils();
+	const [busy, setBusy] = useState(false);
+	const [stage, setStage] = useState("");
+	const [progress, setProgress] = useState(0);
+
+	const setStream = trpc.music.setStream.useMutation({
+		onSuccess: () => utils.music.list.invalidate(),
+	});
+
+	const { startUpload } = useUploadThing("musicUploader");
+
+	async function handleConvert() {
+		setBusy(true);
+		setProgress(0);
+		let currentStage = "Loading ffmpeg";
+		const goto = (s: string) => {
+			currentStage = s;
+			setStage(s);
+		};
+		try {
+			goto("Transcoding");
+			const file = await transcodeToAac({
+				sourceUrl: track.fileUrl,
+				outputName: `${track.title || "track"}.m4a`,
+				onProgress: setProgress,
+			});
+
+			goto("Uploading");
+			const uploaded = await startUpload([file]);
+			const res = uploaded?.[0];
+			if (!res) throw new Error("Upload returned no file");
+
+			goto("Saving");
+			await setStream.mutateAsync({
+				id: track.id,
+				streamUrl: res.serverData.fileUrl,
+				streamKey: res.serverData.fileKey,
+				streamName: res.serverData.fileName,
+			});
+			toast("Streaming version saved");
+		} catch (e) {
+			console.error("[ConvertToStream] failed during", currentStage, e);
+			const detail =
+				e instanceof Error
+					? e.message
+					: typeof e === "string"
+						? e
+						: (() => {
+								try {
+									return JSON.stringify(e);
+								} catch {
+									return String(e);
+								}
+							})();
+			toast(`Conversion failed (${currentStage}): ${detail || "see console for details"}`);
+		} finally {
+			setBusy(false);
+			setStage("");
+			setProgress(0);
+		}
+	}
+
+	return (
+		<div className="flex items-center gap-2">
+			<Button type="button" variant="outline" size="sm" disabled={busy} onClick={handleConvert}>
+				{busy ? (
+					<Loader2 className="animate-spin" />
+				) : track.streamUrl ? (
+					<RefreshCw />
+				) : (
+					<AudioLines />
+				)}
+				{busy
+					? `${stage}${stage === "Transcoding" && progress ? ` ${Math.round(progress * 100)}%` : "…"}`
+					: track.streamUrl
+						? "Re-generate stream"
+						: "Generate stream (AAC)"}
+			</Button>
+			{track.streamUrl && !busy && (
+				<span className="text-xs text-muted-foreground">Streaming version ready</span>
+			)}
+		</div>
+	);
+}
--- a/src/app/admin/music/page.tsx
+++ b/src/app/admin/music/page.tsx
@@ -3,6 +3,7 @@
 import { trpc } from "~/app/_trpc/Client";
 import * as Card from "~/components/ui/card";
 import UploadMusicForm from "./_components/UploadMusicForm";
+import ConvertToStreamButton from "./_components/ConvertToStreamButton";
 import { CollapsibleForm } from "~/app/_components/Form/Components";
 import { useEffect } from "react";

@@ -14,8 +15,9 @@ export default function AdminMusicPage() {
 			{tracks && <>
 				{tracks.map((t) => (
 					<Card.Card key={t.id}>
-						<Card.CardContent>
+						<Card.CardContent className="flex flex-col gap-4">
 							<UploadMusicForm entity={t} className="w-full"/>
+							<ConvertToStreamButton track={t} />
 						</Card.CardContent>
 					</Card.Card>
 				))}
--- a/src/app/admin/page.tsx
+++ b/src/app/admin/page.tsx
@@ -1,15 +1,9 @@
-'use server'
-
-import { Show } from "@clerk/nextjs";
-
 export default async function AdminPage() {
  return (
-    <Show when="signed-in">
-  		<main className="flex min-h-screen flex-col items-center justify-center">
-  			<div>
-  				hello admin
-  			</div>
-  		</main>
-  	</Show>
+		<main className="flex min-h-screen flex-col items-center justify-center">
+			<div>
+				hello admin
+			</div>
+		</main>
  )
 }
--- a/src/app/admin/project/_components/CreateUpdateProjectForm.tsx
+++ b/src/app/admin/project/_components/CreateUpdateProjectForm.tsx
@@ -8,7 +8,7 @@ import type { IterableElement } from 'type-fest'
 import { entitySchemas, makeOnSuccess } from "~/lib/utils";
 import { useEffect, useState } from "react";
 import type { RouterOutputs } from '~/server/routers/_app';
-import { SelectFormField, TextInputFormField, MdeFormField } from '~/app/_components/Form/Fields'
+import { SelectFormField, TextInputFormField, MdeFormField, IntInputFormField } from '~/app/_components/Form/Fields'
 import { FormScaffold } from '~/app/_components/Form/Components';
 import { usePathname, useRouter } from 'next/navigation';
 import { useTheme } from 'next-themes';
@@ -29,7 +29,8 @@ export default function CreateUpdateProjectForm(params: { className?: string, en
      releaseStatus: params.entity ? params.entity.releaseStatus : "unreleased",
      releaseLink: params.entity ? params.entity.releaseLink : "",
      sourceType: params.entity ? params.entity.sourceType : "open",
-      sourceLink: params.entity ? params.entity.sourceLink : ""
+      sourceLink: params.entity ? params.entity.sourceLink : "",
+      orderPos: params.entity ? params.entity.orderPos : 0
    }
  })
  let path = usePathname()
@@ -79,6 +80,7 @@ export default function CreateUpdateProjectForm(params: { className?: string, en
          <SelectItem value="unreleased"> unreleased </SelectItem>
        </SelectFormField>
        <TextInputFormField control={form.control} label='Release Link' name='releaseLink' />
+        <IntInputFormField control={form.control} label='Order Position' name='orderPos'/>
      </FormScaffold>
    </FormMutationContextProvider>
  )
--- a/src/app/admin/project/techStack/_components/CreateUpdateForm.tsx
+++ b/src/app/admin/project/techStack/_components/CreateUpdateForm.tsx
@@ -46,7 +46,7 @@ export default function CreateUpdateStackForm(params: { className?: string, enti
          id={id}
          className={params.className}
        >
-          <MultiBooleanFormField control={form.control} name='stackItems' label='Stack Items' options={stackItemEnum.enumValues} defaultValues={params.entity?.stackItems ?? [""]} />
+          <MultiBooleanFormField control={form.control} name='stackItems' label='Stack Items' options={stackItemEnum.enumValues} defaultValues={params.entity?.stackItems ?? []} />
        </FormScaffold>
      </FormMutationContextProvider>
    </>
--- a/src/app/api/chat/route.ts
+++ b/src/app/api/chat/route.ts
@@ -32,6 +32,7 @@ export async function POST(req: Request) {
 	if (!session) return new Response('Session not found', { status: 404 })

 	const systemPrompt = await servTrpc.chat.getSystemPrompt() || 'You are an AI recruiter assistant.'
+	const model = await servTrpc.chat.getModel()

 	// Save the latest user message
 	const lastMessage = messages[messages.length - 1]
@@ -46,7 +47,7 @@ export async function POST(req: Request) {
 	}

 	const result = streamText({
-		model: openai('gpt-5-mini'),
+		model: openai(model),
 		system: systemPrompt,
 		messages: await convertToModelMessages(messages),
 		tools: {
--- a/src/app/chat/_components/AssistantMessage.tsx
+++ b/src/app/chat/_components/AssistantMessage.tsx
@@ -16,7 +16,7 @@ export const AssistantMessage = (props: { message: UIMessage }) => {
        {message.parts.map((part, i) => {
          if (part.type === 'text') {
            return (
-              <Markdown>
+              <Markdown key={crypto.randomUUID()}>
                {part.text}
              </Markdown>
            )
--- a/src/app/cv/_components/CvCategory.tsx
+++ b/src/app/cv/_components/CvCategory.tsx
@@ -1,35 +1,42 @@
 'use client'
 import { trpc } from "~/app/_trpc/Client"
 import CvEntry from "./CvEntry"
-import type { servTrpc } from "~/app/_trpc/ServerClient"
-import type { inferProcedureOutput } from "@trpc/server"
 import type { RouterOutputs } from "~/server/routers/_app"
 import { cn } from "~/lib/utils"
-import { Card, CardContent, CardHeader, CardTitle } from "~/components/ui/card"
+import { AnimatedCard, CardContent, CardHeader, CardTitle } from "~/components/ui/card"
 import type { ArrayElement } from "type-fest"
+import AnimatePopUp from "~/app/_components/Animated/AnimatePopUp";
+import { ScrollArea } from "~/components/ui/scroll-area";
 type CvCategoryProps = {
  initialData: ArrayElement<RouterOutputs['categoryv2']['listByLayoutPosition']>,
  layout: "row"|"col",
+  position?: number,
  children?: React.ReactElement<Parameters<typeof CvEntry>>
 }
 export default function CvCategory(props:CvCategoryProps)  {
  const category = trpc.categoryv2.getById.useQuery(props.initialData? props.initialData.id : "");
+  const entries = trpc.entryv2.byCategoryAndToDateDescending.useQuery(category.data?.id || "")
+  const position = props.position ?? 0
 		return (
-			<Card className={cn(props.layout == "row" ? "w-full" : "","gsapan")}>
+			<AnimatedCard position={position} className={cn(props.layout == "row" ? "w-full" : "", "h-screen")}>
 				<CardHeader>
 					<CardTitle>
 						{category.data?.name}
 					</CardTitle>
 				</CardHeader>
-				{(category.data?.cvEntry.length ? category.data?.cvEntry.length : 0 ) > 0 ?
+				{(entries.data?.length ? entries.data?.length : 0 ) > 0 ?
 					<CardContent className={cn(props.layout == "row" ? "flex flex-row flex-wrap justify-center lg:justify-between" : "flex flex-col","gap-4","overflow-scroll")}>
-						{category.data?.cvEntry.map((entry) => (
-							<CvEntry className={props.layout == "row" ? "w-full lg:w-fit" : undefined} key={entry.id} initialData={entry}/>
+						<ScrollArea>
+						{entries.data?.map((entry,i) => (
+							<AnimatePopUp position={position + 0.4 + i * 0.2} key={entry.id}>
+							<CvEntry className={props.layout == "row" ? "w-full lg:w-fit" : undefined}  initialData={entry}/>
+							</AnimatePopUp>
 						))}
+					</ScrollArea>
 					</CardContent>
 					:
 					<></>
 				}
-			</Card>
+			</AnimatedCard>
 		)
 }
--- a/src/app/cv/_components/CvEntry.tsx
+++ b/src/app/cv/_components/CvEntry.tsx
@@ -30,9 +30,9 @@ export default function CvEntry(params: {
 							{
 								data.description ?
 									<CardContent className="text-sm lg:text-base">
-										<div>
+										<article className="prose prose-zinc dark:prose-invert max-w-none">
 											<Markdown rehypePlugins={[rehypeHighlight, rehypeRaw]}>{data.description}</Markdown>
-										</div>
+										</article>
 									</CardContent> :
 									<></>
 							}
--- a/src/app/cv/page.tsx
+++ b/src/app/cv/page.tsx
@@ -1,62 +1,27 @@
 'use client'
-import { useGSAP } from "@gsap/react";
-import { useGsapContext,useTimeLine } from "../_providers/GsapProvicer";
+import { useTimeLine } from "../_providers/GsapProvicer";
 import { trpc } from "../_trpc/Client";
-import { useRef } from "react";
 import { SidebarContent, SidebarProvider, Sidebar } from "~/components/ui/sidebar";
 import SidebarTriggerDisappearsOnMobile from "./_components/SidebarTriggerDisappearsOnMobile";
 import CvCategory from "./_components/CvCategory";
-import gsap from 'gsap'
 export default function CvPage() {
  const sidebarCategories = trpc.categoryv2.listByLayoutPosition.useQuery("sidebar");
  const col1Categories = trpc.categoryv2.listByLayoutPosition.useQuery("col1");
  const headerCategories = trpc.categoryv2.listByLayoutPosition.useQuery("header");
  const col2Categories = trpc.categoryv2.listByLayoutPosition.useQuery("col2");
-  const gsapContext = useGsapContext()
-  const container = useRef<HTMLDivElement>(null)
-  enum Direction {
-    Left = 1,
-    Up,
-    Right,
-    Down
-  }
-  const nextGsapConf = (direction: Direction) => {
-    switch (direction) {
-      case Direction.Left:
-        return { x: -100, opacity: 0, duration: 0.5 }
-      case Direction.Up:
-        return { y: -100, opacity: 0, duration: 0.5 }
-      case Direction.Right:
-        return { x: 100, opacity: 0, duration: 0.5 }
-      case Direction.Down:
-        return { y: 100, opacity: 0, duration: 0.5 }
-    }
-  }
-  useTimeLine(col2Categories)
-  useGSAP(() => {
-    const items = gsap?.utils.toArray<GSAPTweenTarget>('.gsapan');
-    let dir = Direction.Left;
-    items?.forEach(item => {
-      gsapContext?.addAnimation(gsap.from(item, nextGsapConf(dir)),0)
-      if (dir == Direction.Down) {
-        dir = Direction.Left
-      } else {
-        dir = dir + 1
-      }
-    })
-  }, { scope: container, dependencies: [headerCategories.data, sidebarCategories.data], revertOnUpdate: true })
+  useTimeLine(col2Categories.data)
  return (
    <>
-      <SidebarProvider ref={container}>
+      <SidebarProvider>
        {sidebarCategories.data &&
          <>
            <SidebarTriggerDisappearsOnMobile />
-            <Sidebar className="gsapan ">
+            <Sidebar>
              <SidebarContent className="p-2 lg:pt-[3.2rem]">
-                {sidebarCategories.data?.map((cat) => {
+                {sidebarCategories.data?.map((cat, i) => {
                  if (cat !== undefined) {
                    return (
-                      <CvCategory layout="col" initialData={cat} key={cat.id} />
+                      <CvCategory layout="col" position={i} initialData={cat} key={cat.id} />
                    )
                  }
                })}
@@ -67,26 +32,20 @@ export default function CvPage() {
        <div className="h-full w-full flex flex-wrap flex-row p-4 pt-8 ">
          <div id="mainwrap" className="flex w-full flex-col gap-4 lg:px-[15vw]">
            <div id="header" className="flex  w-full h-fit flex-row gap-4 flex-wrap">
-              {headerCategories.data?.map((cat) => {
-                return (
-                  <CvCategory layout="row" initialData={cat} key={cat.id} />
-                )
-              })}
+              {headerCategories.data?.map((cat, i) => (
+                <CvCategory layout="row" position={i} initialData={cat} key={cat.id} />
+              ))}
            </div>
            <div id="colwrapper" className="flex flex-col lg:flex-row w-full h-3/4 gap-4">
              <div id="col1" className={`flex flex-col w-full ${col1Categories.data?.length ? col1Categories.data?.length : 0 > 0 ? "lg:w-1/2" : ""} h-full gap-4`}>
-                {col1Categories.data?.map((cat) => {
-                  return (
-                    <CvCategory layout="col" initialData={cat} key={cat.id} />
-                  )
-                })}
+                {col1Categories.data?.map((cat, i) => (
+                  <CvCategory layout="col" position={i} initialData={cat} key={cat.id} />
+                ))}
              </div>
              <div id="col2" className={`flex flex-col w-full ${col2Categories.data?.length ? col2Categories.data?.length : 0 > 0 ? "lg:w-1/2" : ""} h-full gap-4`}>
-                {col2Categories.data?.map((cat) => {
-                  return (
-                    <CvCategory layout="col" initialData={cat} key={cat.id} />
-                  )
-                })}
+                {col2Categories.data?.map((cat, i) => (
+                  <CvCategory layout="col" position={i} initialData={cat} key={cat.id} />
+                ))}
              </div>
            </div>
          </div>
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -12,10 +12,11 @@ import TrpcProvider from "./_trpc/TrpcProvider";
 import ThemeProvider from './_providers/ThemeProvider'
 import GsapProvider from "./_providers/GsapProvicer";
 import {MessagesProvider} from "./_providers/MessagesProvider";
+import { MusicPlayerProvider } from "./music/_components/MusicPlayerProvider";
 import { CodeHighlightStyle } from "./_components/CodeHighlightSyle";
 import { cn } from "~/lib/utils";
 import AnimatedBackGroundContainer from "./_components/Animated/AnimatedBackGroundContainer";
-
+import  {SpeedInsights} from "@vercel/speed-insights/next"
 const inter = Inter({ subsets: ['latin'], variable: '--font-sans' });


@@ -37,6 +38,8 @@ export default async function RootLayout({
 }: Readonly<{ children: React.ReactNode, modal: React.ReactNode }>) {

 	return (
+		<>
+		<SpeedInsights/>
 		<ClerkProvider>
 			<TrpcProvider>
 				<GsapProvider>
@@ -47,6 +50,7 @@ export default async function RootLayout({
 						<body className="flex flex-col bg-background text-foreground">
 							<ThemeProvider>
 							<MessagesProvider>
+								<MusicPlayerProvider>
 								<AnimatedBackGroundContainer followSpeed={0.003} particleCount={100} orbitRadius={2000}>
 									<TopNav />
 									<main className="absolute lg:top-10 h-screen lg:h-[calc(100vh-var(--spacing)*10)] w-screen">
@@ -55,6 +59,7 @@ export default async function RootLayout({
 									{modal}
 								</AnimatedBackGroundContainer>
 								<ChatFAB />
+								</MusicPlayerProvider>
 								</MessagesProvider>
 							</ThemeProvider>
 						</body>
@@ -62,5 +67,6 @@ export default async function RootLayout({
 				</GsapProvider>
 			</TrpcProvider>
 		</ClerkProvider>
+		</>
 	);
 }
--- a/src/app/music/_components/AudioPlayer.tsx
+++ b/src/app/music/_components/AudioPlayer.tsx
@@ -0,0 +1,190 @@
+'use client'
+
+import { useEffect, useRef, useState } from "react";
+import { useTheme } from "next-themes";
+import type WaveSurfer from "wavesurfer.js";
+import { Download, Loader2, Pause, Play } from "lucide-react";
+import { Button } from "~/components/ui/button";
+import { toast } from "sonner";
+import { useMusicPlayer } from "./MusicPlayerProvider";
+
+function formatTime(seconds: number) {
+	if (!Number.isFinite(seconds)) return "0:00";
+	const m = Math.floor(seconds / 60);
+	const s = Math.floor(seconds % 60);
+	return `${m}:${s.toString().padStart(2, "0")}`;
+}
+
+function cssVar(name: string, fallback: string) {
+	if (typeof window === "undefined") return fallback;
+	const v = getComputedStyle(document.documentElement).getPropertyValue(name).trim();
+	return v || fallback;
+}
+
+function waveColors() {
+	return {
+		waveColor: cssVar("--muted-foreground", "#9ca3af"),
+		progressColor: cssVar("--primary", "#e2761b"),
+		cursorColor: cssVar("--foreground", "#111827"),
+	};
+}
+
+/**
+ * Per-track waveform. Playback itself is owned by the shared MusicPlayer engine
+ * (so it keeps running across navigation); this wavesurfer instance is only a
+ * visual + seek surface that mirrors the engine when its track is active.
+ */
+export default function AudioPlayer(props: {
+	id: string;
+	src: string;
+	downloadUrl: string;
+	downloadName: string;
+}) {
+	const containerRef = useRef<HTMLDivElement>(null);
+	const wsRef = useRef<WaveSurfer | null>(null);
+	const [ready, setReady] = useState(false);
+	const [duration, setDuration] = useState(0);
+	const [downloading, setDownloading] = useState(false);
+	const { resolvedTheme } = useTheme();
+
+	const { currentId, isPlaying, currentTime, toggle, seek, subscribeTime } = useMusicPlayer();
+	const isActive = currentId === props.id;
+
+	// Reach live values from the once-created wavesurfer callbacks.
+	const isActiveRef = useRef(isActive);
+	isActiveRef.current = isActive;
+	const currentTimeRef = useRef(currentTime);
+	currentTimeRef.current = currentTime;
+	const toggleRef = useRef(toggle);
+	toggleRef.current = toggle;
+	const seekRef = useRef(seek);
+	seekRef.current = seek;
+
+	useEffect(() => {
+		let ws: WaveSurfer | null = null;
+		let cancelled = false;
+		setReady(false);
+
+		(async () => {
+			const WaveSurferClass = (await import("wavesurfer.js")).default;
+			if (cancelled || !containerRef.current) return;
+			const instance = WaveSurferClass.create({
+				container: containerRef.current,
+				url: props.src,
+				height: 44,
+				barWidth: 2,
+				barGap: 1,
+				barRadius: 2,
+				normalize: true,
+				cursorWidth: 1,
+				...waveColors(),
+			});
+			ws = instance;
+			wsRef.current = instance;
+			instance.on("ready", () => {
+				// This media is for drawing only — never let it make sound.
+				instance.setMuted(true);
+				setReady(true);
+				setDuration(instance.getDuration());
+				if (isActiveRef.current) instance.setTime(currentTimeRef.current);
+			});
+			// Clicking the waveform: start this track if it isn't playing, then seek.
+			instance.on("interaction", (time: number) => {
+				if (!isActiveRef.current) toggleRef.current(props.id);
+				seekRef.current(time);
+			});
+		})();
+
+		return () => {
+			cancelled = true;
+			ws?.destroy();
+			wsRef.current = null;
+		};
+	}, [props.src]);
+
+	// Mirror the engine's playback position onto the cursor while active.
+	useEffect(() => {
+		const ws = wsRef.current;
+		if (!ws || !ready) return;
+		if (!isActive) {
+			ws.setTime(0);
+			return;
+		}
+		ws.setTime(currentTimeRef.current);
+		return subscribeTime((t) => wsRef.current?.setTime(t));
+	}, [isActive, ready, subscribeTime]);
+
+	// Re-tint the waveform when the user toggles light/dark.
+	useEffect(() => {
+		wsRef.current?.setOptions(waveColors());
+	}, [resolvedTheme]);
+
+	async function handleDownload() {
+		setDownloading(true);
+		try {
+			// The download file is cross-origin, so the <a download> attribute is
+			// ignored — fetch it as a blob to force a real download.
+			const res = await fetch(props.downloadUrl);
+			if (!res.ok) throw new Error(`HTTP ${res.status}`);
+			const blob = await res.blob();
+			const url = URL.createObjectURL(blob);
+			const a = document.createElement("a");
+			a.href = url;
+			a.download = props.downloadName;
+			document.body.appendChild(a);
+			a.click();
+			a.remove();
+			URL.revokeObjectURL(url);
+		} catch (e) {
+			toast(`Download failed: ${e instanceof Error ? e.message : "unknown error"}`);
+		} finally {
+			setDownloading(false);
+		}
+	}
+
+	const playing = isActive && isPlaying;
+
+	return (
+		<div className="flex items-center gap-3 rounded-lg border bg-transparent px-3 py-2">
+			<Button
+				type="button"
+				size="icon"
+				variant="ghost"
+				aria-label={playing ? "Pause" : "Play"}
+				disabled={!ready}
+				onClick={() => toggle(props.id)}
+			>
+				{playing ? <Pause /> : <Play />}
+			</Button>
+
+			<span className="w-10 shrink-0 text-right font-mono text-xs text-muted-foreground tabular-nums">
+				{formatTime(isActive ? currentTime : 0)}
+			</span>
+
+			<div className="relative flex-1">
+				<div ref={containerRef} className="w-full" />
+				{!ready && (
+					<div className="absolute inset-0 flex items-center">
+						<div className="h-7 w-full animate-pulse rounded bg-muted-foreground/15" />
+					</div>
+				)}
+			</div>
+
+			<span className="w-10 shrink-0 font-mono text-xs text-muted-foreground tabular-nums">
+				{formatTime(duration)}
+			</span>
+
+			<Button
+				type="button"
+				size="icon"
+				variant="ghost"
+				aria-label="Download lossless file"
+				title="Download lossless file"
+				disabled={downloading}
+				onClick={handleDownload}
+			>
+				{downloading ? <Loader2 className="animate-spin" /> : <Download />}
+			</Button>
+		</div>
+	);
+}
--- a/src/app/music/_components/MusicMiniPlayer.tsx
+++ b/src/app/music/_components/MusicMiniPlayer.tsx
@@ -0,0 +1,73 @@
+'use client'
+
+import { useState } from "react";
+import { Music } from "lucide-react";
+import {
+	Drawer,
+	DrawerContent,
+	DrawerHeader,
+	DrawerTitle,
+	DrawerTrigger,
+} from "~/components/ui/drawer";
+import { Slider } from "~/components/ui/slider";
+import { useMusicPlayer } from "./MusicPlayerProvider";
+import PlayerControls from "./PlayerControls";
+
+function formatTime(seconds: number) {
+	if (!Number.isFinite(seconds)) return "0:00";
+	const m = Math.floor(seconds / 60);
+	const s = Math.floor(seconds % 60);
+	return `${m}:${s.toString().padStart(2, "0")}`;
+}
+
+/**
+ * Global, persistent mini-player: a floating button (shown once something is
+ * loaded) that opens a drawer with the transport controls and a scrubber, so
+ * playback can be controlled from any page while it keeps running in the
+ * background.
+ */
+export default function MusicMiniPlayer() {
+	const { currentTrack, isPlaying, currentTime, duration, seek } = useMusicPlayer();
+	const [open, setOpen] = useState(false);
+
+	if (!currentTrack) return null;
+
+	return (
+		<Drawer open={open} onOpenChange={setOpen}>
+			<DrawerTrigger asChild>
+				<button
+					type="button"
+					aria-label="Open player"
+					className="fixed bottom-4 left-4 z-40 flex max-w-[60vw] items-center gap-2 rounded-full border bg-background/80 px-4 py-2 shadow-lg backdrop-blur-md transition-colors hover:bg-background"
+				>
+					<Music className={isPlaying ? "animate-pulse" : ""} />
+					<span className="truncate text-sm">{currentTrack.title}</span>
+				</button>
+			</DrawerTrigger>
+			<DrawerContent>
+				<DrawerHeader>
+					<DrawerTitle>{currentTrack.title}</DrawerTitle>
+				</DrawerHeader>
+				<div className="mx-auto flex w-full max-w-md flex-col gap-4 px-4 pb-8">
+					<div className="flex items-center gap-2">
+						<span className="w-10 text-right font-mono text-xs text-muted-foreground tabular-nums">
+							{formatTime(currentTime)}
+						</span>
+						<Slider
+							className="flex-1"
+							min={0}
+							max={duration || 1}
+							step={0.1}
+							value={[currentTime]}
+							onValueChange={([v]) => seek(v ?? 0)}
+						/>
+						<span className="w-10 font-mono text-xs text-muted-foreground tabular-nums">
+							{formatTime(duration)}
+						</span>
+					</div>
+					<PlayerControls />
+				</div>
+			</DrawerContent>
+		</Drawer>
+	);
+}
--- a/src/app/music/_components/MusicPlayerProvider.tsx
+++ b/src/app/music/_components/MusicPlayerProvider.tsx
@@ -0,0 +1,231 @@
+'use client'
+
+import {
+	createContext,
+	useCallback,
+	useContext,
+	useEffect,
+	useMemo,
+	useRef,
+	useState,
+	type ReactNode,
+} from "react";
+import { trpc } from "~/app/_trpc/Client";
+import MusicMiniPlayer from "./MusicMiniPlayer";
+
+export type PlayerTrack = {
+	id: string;
+	title: string;
+	/** Streaming-friendly source actually played. */
+	src: string;
+	/** Original high-quality file for the download button. */
+	downloadUrl: string;
+	downloadName: string;
+};
+
+type MusicPlayerValue = {
+	tracks: PlayerTrack[];
+	currentId: string | null;
+	currentTrack: PlayerTrack | null;
+	isPlaying: boolean;
+	shuffle: boolean;
+	currentTime: number;
+	duration: number;
+	/** Play button on a track: start it, or toggle play/pause if already current. */
+	toggle: (id: string) => void;
+	/** Global play/pause — acts on the current track (or starts the first one). */
+	togglePlayCurrent: () => void;
+	next: () => void;
+	previous: () => void;
+	toggleShuffle: () => void;
+	seek: (seconds: number) => void;
+	/** Subscribe to playback time updates (for waveform cursors). */
+	subscribeTime: (cb: (time: number) => void) => () => void;
+};
+
+const MusicPlayerContext = createContext<MusicPlayerValue | null>(null);
+
+export function useMusicPlayer() {
+	const ctx = useContext(MusicPlayerContext);
+	if (!ctx) throw new Error("useMusicPlayer must be used within a MusicPlayerProvider");
+	return ctx;
+}
+
+export function MusicPlayerProvider({ children }: { children: ReactNode }) {
+	// The provider owns the playlist so playback survives navigating away from
+	// the music page. The query is cached, so the music page shares this request.
+	const { data } = trpc.music.list.useQuery();
+	const tracks = useMemo<PlayerTrack[]>(
+		() =>
+			(data ?? []).map((t) => ({
+				id: t.id,
+				title: t.title,
+				src: t.streamUrl ?? t.fileUrl,
+				downloadUrl: t.fileUrl,
+				downloadName: t.fileName,
+			})),
+		[data],
+	);
+
+	const [currentId, setCurrentId] = useState<string | null>(null);
+	const [isPlaying, setIsPlaying] = useState(false);
+	const [shuffle, setShuffle] = useState(false);
+	const [currentTime, setCurrentTime] = useState(0);
+	const [duration, setDuration] = useState(0);
+
+	const audioRef = useRef<HTMLAudioElement | null>(null);
+	const tracksRef = useRef(tracks);
+	tracksRef.current = tracks;
+
+	// Lightweight pub/sub so each waveform can follow playback time without every
+	// player re-rendering on the audio element's frequent timeupdate.
+	const timeSubs = useRef<Set<(t: number) => void>>(new Set());
+	const subscribeTime = useCallback((cb: (t: number) => void) => {
+		timeSubs.current.add(cb);
+		return () => {
+			timeSubs.current.delete(cb);
+		};
+	}, []);
+	const emitTime = useCallback((t: number) => {
+		timeSubs.current.forEach((cb) => cb(t));
+	}, []);
+
+	const currentTrack = useMemo(
+		() => tracks.find((t) => t.id === currentId) ?? null,
+		[tracks, currentId],
+	);
+
+	const toggle = useCallback((id: string) => {
+		setCurrentId((prev) => {
+			if (prev === id) {
+				setIsPlaying((p) => !p);
+				return prev;
+			}
+			setIsPlaying(true);
+			return id;
+		});
+	}, []);
+
+	const togglePlayCurrent = useCallback(() => {
+		setCurrentId((prev) => {
+			if (prev) {
+				setIsPlaying((p) => !p);
+				return prev;
+			}
+			const first = tracksRef.current[0]?.id ?? null;
+			if (first) setIsPlaying(true);
+			return first;
+		});
+	}, []);
+
+	const step = useCallback((dir: 1 | -1) => {
+		const ids = tracksRef.current.map((t) => t.id);
+		if (ids.length === 0) return;
+		setCurrentId((prev) => {
+			let nextId: string;
+			if (shuffle && dir === 1 && ids.length > 1) {
+				do {
+					nextId = ids[Math.floor(Math.random() * ids.length)]!;
+				} while (nextId === prev);
+			} else {
+				const idx = prev ? ids.indexOf(prev) : -1;
+				nextId = ids[(idx + dir + ids.length) % ids.length]!;
+			}
+			setIsPlaying(true);
+			return nextId;
+		});
+	}, [shuffle]);
+	const next = useCallback(() => step(1), [step]);
+	const previous = useCallback(() => step(-1), [step]);
+	const toggleShuffle = useCallback(() => setShuffle((s) => !s), []);
+
+	const stepRef = useRef(step);
+	stepRef.current = step;
+
+	const seek = useCallback(
+		(s: number) => {
+			if (audioRef.current) audioRef.current.currentTime = s;
+			setCurrentTime(s);
+			emitTime(s);
+		},
+		[emitTime],
+	);
+
+	// Persistent audio element + listeners, created once on the client.
+	useEffect(() => {
+		const audio = new Audio();
+		audio.preload = "metadata";
+		audioRef.current = audio;
+		const onTime = () => {
+			setCurrentTime(audio.currentTime);
+			emitTime(audio.currentTime);
+		};
+		const onMeta = () => setDuration(audio.duration || 0);
+		const onEnded = () => stepRef.current(1);
+		audio.addEventListener("timeupdate", onTime);
+		audio.addEventListener("loadedmetadata", onMeta);
+		audio.addEventListener("ended", onEnded);
+		return () => {
+			audio.pause();
+			audio.removeEventListener("timeupdate", onTime);
+			audio.removeEventListener("loadedmetadata", onMeta);
+			audio.removeEventListener("ended", onEnded);
+			audioRef.current = null;
+		};
+	}, [emitTime]);
+
+	// Swap the source when the current track changes.
+	useEffect(() => {
+		const audio = audioRef.current;
+		if (!audio) return;
+		if (!currentTrack) {
+			audio.removeAttribute("src");
+			audio.load();
+			return;
+		}
+		if (audio.src !== currentTrack.src) {
+			audio.src = currentTrack.src;
+			audio.load();
+			setCurrentTime(0);
+			setDuration(0);
+		}
+	}, [currentTrack]);
+
+	// Reflect the desired play state onto the element.
+	useEffect(() => {
+		const audio = audioRef.current;
+		if (!audio || !currentTrack) return;
+		if (isPlaying) audio.play().catch(() => {});
+		else audio.pause();
+	}, [isPlaying, currentTrack]);
+
+	const value = useMemo<MusicPlayerValue>(
+		() => ({
+			tracks,
+			currentId,
+			currentTrack,
+			isPlaying,
+			shuffle,
+			currentTime,
+			duration,
+			toggle,
+			togglePlayCurrent,
+			next,
+			previous,
+			toggleShuffle,
+			seek,
+			subscribeTime,
+		}),
+		[
+			tracks, currentId, currentTrack, isPlaying, shuffle, currentTime, duration,
+			toggle, togglePlayCurrent, next, previous, toggleShuffle, seek, subscribeTime,
+		],
+	);
+
+	return (
+		<MusicPlayerContext.Provider value={value}>
+			{children}
+			<MusicMiniPlayer />
+		</MusicPlayerContext.Provider>
+	);
+}
--- a/src/app/music/_components/PlayerControls.tsx
+++ b/src/app/music/_components/PlayerControls.tsx
@@ -0,0 +1,40 @@
+'use client'
+
+import { Pause, Play, Shuffle, SkipBack, SkipForward } from "lucide-react";
+import { Button } from "~/components/ui/button";
+import { useMusicPlayer } from "./MusicPlayerProvider";
+
+export default function PlayerControls() {
+	const { isPlaying, shuffle, togglePlayCurrent, next, previous, toggleShuffle } =
+		useMusicPlayer();
+
+	return (
+		<div className="flex items-center justify-center gap-1">
+			<Button type="button" size="icon" variant="ghost" aria-label="Previous track" onClick={previous}>
+				<SkipBack />
+			</Button>
+			<Button
+				type="button"
+				size="icon-lg"
+				variant="secondary"
+				aria-label={isPlaying ? "Pause" : "Play"}
+				onClick={togglePlayCurrent}
+			>
+				{isPlaying ? <Pause /> : <Play />}
+			</Button>
+			<Button type="button" size="icon" variant="ghost" aria-label="Skip to next track" onClick={next}>
+				<SkipForward />
+			</Button>
+			<Button
+				type="button"
+				size="icon"
+				variant={shuffle ? "secondary" : "ghost"}
+				aria-label={shuffle ? "Shuffle on" : "Shuffle off"}
+				aria-pressed={shuffle}
+				onClick={toggleShuffle}
+			>
+				<Shuffle />
+			</Button>
+		</div>
+	);
+}
--- a/src/app/music/page.tsx
+++ b/src/app/music/page.tsx
@@ -7,6 +7,7 @@ import { Spinner } from "~/components/ui/spinner";
 import AnimateTextIn from "../_components/Animated/AnimateIn";
 import { ScrollArea } from "~/components/ui/scroll-area";
 import AnimatePopUp from "../_components/Animated/AnimatePopUp";
+import AudioPlayer from "./_components/AudioPlayer";
 export default function MusicPage() {
 	const { data: tracks, isLoading } = trpc.music.list.useQuery();
 	useTimeLine(tracks)
@@ -14,11 +15,11 @@ export default function MusicPage() {
    <ScrollArea className="px-10 lg:px-0 w-full h-full max-w-4xl mx-auto pt-10">
 			<AnimatedPageTitle position={0}><span>Just Some </span> <span>Music I Made</span> </AnimatedPageTitle>
 			<div className="flex flex-wrap h-fit content-center">
-				<AnimateTextIn className="flex flex-wrap mr-[1em]" position={0.5}>
+				<AnimateTextIn once className="flex flex-wrap mr-[1em]" position={0.5}>
 					<div><p className="break-after-avoid mr-[1em]">All works on this page are licensed under:</p></div>
 					<div><a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">CC BY-NC-SA 4.0</a></div>
 				</AnimateTextIn>
-				<AnimatePopUp position={2} className="items-center content-center">
+				<AnimatePopUp duration={1} ease='elastic.inOut' position={2} once className="items-center content-center">
 					<div className="flex flex-row">
 						<img className="max-w-[1em]" src="https://mirrors.creativecommons.org/presskit/icons/cc.svg" alt="" />
 						<img className="max-w-[1em] ml-[1em]" src="https://mirrors.creativecommons.org/presskit/icons/by.svg" alt="" />
@@ -32,7 +33,7 @@ export default function MusicPage() {
 				<div key={track.id}>
 					<Card.AnimatedCard position={i + 1}>
 						<Card.CardHeader>
-							<AnimateTextIn position={i + 1.2} animation="slide">
+							<AnimateTextIn once position={i + 1.2} animation="slide">
 								<Card.CardTitle>{track.title}</Card.CardTitle>
 							</AnimateTextIn>
 						</Card.CardHeader>
@@ -40,10 +41,13 @@ export default function MusicPage() {
 							{track.description && (
 								<p className="text-sm text-muted-foreground gsapant">{track.description}</p>
 							)}
-							<AnimatePopUp position={i + 1.3}>
-								<audio controls className="w-full player" src={track.fileUrl}>
-									Your browser does not support the audio element.
-								</audio>
+							<AnimatePopUp duration={2} ease='elastic.inOut'  position={i + 1.3} once>
+								<AudioPlayer
+									id={track.id}
+									src={track.streamUrl ?? track.fileUrl}
+									downloadUrl={track.fileUrl}
+									downloadName={track.fileName}
+								/>
 							</AnimatePopUp>
 						</Card.CardContent>
 					</Card.AnimatedCard>
--- a/src/app/projects/page.tsx
+++ b/src/app/projects/page.tsx
@@ -34,17 +34,17 @@ export default function ProjectsPage() {

  return (
    <ScrollArea className="px-10 lg:px-0 w-full h-full max-w-4xl mx-auto pt-10">
-      <AnimatedPageTitle position={0}><span>Project I've Been</span><span> Working on</span> </AnimatedPageTitle>
+      <AnimatedPageTitle position={0}><span>Projects I've Been</span><span> Working on</span> </AnimatedPageTitle>
      <div className="pt-10" />
      {projects.map((project, i) => (
        <div id={project.id} key={i} className="scroll-mt-10">
          <Card.AnimatedCard position={i + 1.2} key={project.id}>
            <Card.CardHeader>
              <div className="flex items-start justify-between gap-2 flex-wrap">
-                <AnimateTextIn position={i + 1.4} animation="slide"><Card.CardTitle>{project.title}</Card.CardTitle></AnimateTextIn>
+                <AnimateTextIn once position={i + 1.4} animation="slide"><Card.CardTitle>{project.title}</Card.CardTitle></AnimateTextIn>
                <div className="flex gap-2 flex-wrap">
                  {project.sourceType && (
-                    <AnimatePopUp position={i + 2} duration={2}>
+                    <AnimatePopUp position={i + 2} duration={2} once>
                      <Badge variant={project.sourceType === "open" ? "secondary" : "outline"}>
                        {project.sourceType === "open" ? "Open Source" : "Closed Source"}
                      </Badge>
@@ -62,7 +62,7 @@ export default function ProjectsPage() {
              <Card.CardContent className="flex flex-col gap-3">
                {project.description && (
                  <div className="prose prose-sm dark:prose-invert max-w-none text-muted-foreground">
-                    <AnimatePopUp position={i + 1.4} duration={10}>
+                    <AnimatePopUp once position={i + 1.4} duration={10}>
                      <Markdown remarkPlugins={[remarkGfm]}>{project.description}</Markdown>
                    </AnimatePopUp>
                  </div>
@@ -71,7 +71,7 @@ export default function ProjectsPage() {
                  {project.techStack?.stackItems && project.techStack.stackItems.length > 0 && (
                    <div className="flex flex-wrap gap-1.5">
                      {project.techStack.stackItems.map((item, k) => (
-                        <AnimatePopUp key={k} position={(i + 2) + k * 0.5}>  <StackBadge key={item} item={item} /> </AnimatePopUp>
+                        <AnimatePopUp key={k} position={(i + 2) + k * 0.5} once>  <StackBadge key={item} item={item} /> </AnimatePopUp>
                      ))}
                    </div>
                  )}
@@ -111,6 +111,11 @@ export default function ProjectsPage() {
          <div className="pt-5" />
        </div>
      ))}
+      {/* Scroll runway: lets the last cards' ScrollTrigger exit points be
+          reached past the visible area, so on short viewports the second-to-last
+          card animates out off-screen instead of being frozen mid-exit at the
+          bottom of the scroll. Tune the height if a card is still caught. */}
+      <div aria-hidden className="h-[70dvh] shrink-0" />
    </ScrollArea>
  );
 }
--- a/src/components/StackBadge.tsx
+++ b/src/components/StackBadge.tsx
@@ -125,6 +125,30 @@ const STACK_META: Record<string, { label: string; icon?: SvglIcon }> = {
      dark: "https://svgl.app/library/neon.svg",
    },
  },
+  typescript: {
+    label: "TypeScript",
+    icon: {
+      light: "https://svgl.app/library/typescript.svg",
+      dark: "https://svgl.app/library/typescript.svg",
+    },
+  },
+  javafx: { label: "JavaFX" },
+  x11: { label: "X11" },
+  zig: {
+    label: "Zig",
+    icon: {
+      light: "https://svgl.app/library/zig.svg",
+      dark: "https://svgl.app/library/zig.svg",
+    },
+  },
+  libghostty: { label: "libghostty" },
+  zod: {
+    label: "Zod",
+    icon: {
+      light: "https://svgl.app/library/zod.svg",
+      dark: "https://svgl.app/library/zod.svg",
+    },
+  },
 };

 export function StackBadge({ item }: { item: string }) {
--- a/src/components/ui/card.tsx
+++ b/src/components/ui/card.tsx
@@ -1,7 +1,7 @@
-import { useGSAP } from "@gsap/react"; import * as React from "react"
+import * as React from "react"
 import { useRef } from "react";
-import { useGsapContext } from "~/app/_providers/GsapProvicer";
 import gsap from 'gsap'
+import { useReveal } from "~/app/_components/Animated/useReveal";
 import { cn } from "~/lib/utils"

 function Card({
@@ -27,40 +27,17 @@ function AnimatedCard({
  position = 0,
  size = "default",
  scrollOnly = false,
+  once = false,
  ...props
-}: React.ComponentProps<"div"> & { size?: "default" | "sm", position?: gsap.Position,  scrollOnly?: boolean }) {
-  const gsapContext = useGsapContext()
+}: React.ComponentProps<"div"> & { size?: "default" | "sm", position?: gsap.Position,  scrollOnly?: boolean, once?: boolean }) {
  const ref = useRef<HTMLDivElement | null>(null)
-  useGSAP(() => {
-    const rect = ref.current?.getBoundingClientRect()
-    const scroller = gsapContext?.getScroller()
-    console.log(scroller)
-    let viewportTop = 0
-    let viewportBottom = window.innerHeight
-    if (scroller && scroller instanceof Element) {
-      const scrollerRect = scroller.getBoundingClientRect()
-      viewportTop = scrollerRect.top
-      viewportBottom = scrollerRect.top + scrollerRect.height
-    }
-    const isInView = rect && rect.bottom > viewportTop && rect.top < viewportBottom
-    console.log(isInView)
-    const fromVars = { x: -100, opacity: 0, duration: 0.5 }
-    if (isInView && !scrollOnly) {
-      gsapContext?.addAnimation(gsap.from(ref.current, fromVars), position)
-    } else {
-      gsap.from(ref.current,
-        {
-          ...fromVars,
-          scrollTrigger: {
-            trigger: ref.current,
-            start: 'top bottom',
-            end: 'bottom top',
-            toggleActions: "play reverse play reverse",
-            scroller
-          }
-        })
-    }
-  }, { dependencies: [] })
+  useReveal(ref, {
+    position,
+    scrollOnly,
+    once,
+    debugId: `card-${position}`,
+    makeReveal: (el) => gsap.from(el, { x: -100, opacity: 0, duration: 0.5, paused: true }),
+  })
  return (
    <div
      ref={ref}
--- a/src/lib/ffmpeg/transcode.ts
+++ b/src/lib/ffmpeg/transcode.ts
@@ -0,0 +1,114 @@
+import { FFmpeg } from "@ffmpeg/ffmpeg";
+import { fetchFile, toBlobURL } from "@ffmpeg/util";
+
+// Single-threaded core: works without SharedArrayBuffer, so no COOP/COEP
+// cross-origin-isolation headers are required. Slower than the MT core, which
+// is fine for occasional admin-side transcodes.
+const CORE_VERSION = "0.12.10";
+// @ffmpeg/ffmpeg 0.12.x always spawns a `type: "module"` worker. A module
+// worker can't `importScripts`, so the worker dynamically `import()`s the core —
+// which means the core must be the ESM build, not UMD.
+const CORE_BASE = `https://unpkg.com/@ffmpeg/core@${CORE_VERSION}/dist/esm`;
+// Self-hosted worker, bundled from @ffmpeg/ffmpeg's ESM `worker.js` via the
+// `build:ffmpeg-worker` package script (rerun it when bumping @ffmpeg/ffmpeg).
+// The shipped UMD worker is unusable here: its
+// dynamic import is webpack-compiled into a stub that throws MODULE_NOT_FOUND,
+// and letting Next bundle the worker hits the same problem. Serving our own
+// same-origin module worker keeps the native `import()` intact.
+// Must be an absolute URL: the library resolves classWorkerURL against
+// `import.meta.url`, which is a file:// base under Next, so a root-relative path
+// would wrongly become `file:///ffmpeg/worker.js`.
+const WORKER_PATH = "/ffmpeg/worker.js";
+
+let instance: FFmpeg | null = null;
+let loadPromise: Promise<FFmpeg> | null = null;
+
+function load(onLog?: (msg: string) => void): Promise<FFmpeg> {
+	if (instance) return Promise.resolve(instance);
+	if (!loadPromise) {
+		loadPromise = (async () => {
+			const ffmpeg = new FFmpeg();
+			ffmpeg.on("log", ({ message }) => {
+				console.debug("[ffmpeg]", message);
+				onLog?.(message);
+			});
+			const ok = await ffmpeg.load({
+				coreURL: await toBlobURL(`${CORE_BASE}/ffmpeg-core.js`, "text/javascript"),
+				wasmURL: await toBlobURL(`${CORE_BASE}/ffmpeg-core.wasm`, "application/wasm"),
+				classWorkerURL: new URL(WORKER_PATH, window.location.origin).href,
+			});
+			if (!ok) throw new Error("ffmpeg.load() returned false — core failed to initialise");
+			instance = ffmpeg;
+			return ffmpeg;
+		})();
+		// If loading fails, clear the cached promise so the next click retries.
+		loadPromise.catch(() => {
+			loadPromise = null;
+		});
+	}
+	return loadPromise;
+}
+
+/**
+ * Transcodes a (FLAC) source URL to a streaming-friendly AAC/m4a file in the
+ * browser. Returns a File ready to hand to UploadThing's startUpload.
+ */
+export async function transcodeToAac(opts: {
+	sourceUrl: string;
+	outputName?: string;
+	bitrate?: string;
+	onProgress?: (ratio: number) => void;
+	onLog?: (msg: string) => void;
+}): Promise<File> {
+	let lastLog = "";
+	const onLog = (msg: string) => {
+		if (msg.trim()) lastLog = msg;
+		opts.onLog?.(msg);
+	};
+	const ffmpeg = await load(onLog);
+	// `load` only wires the persisted instance's log handler on first init; make
+	// sure this call's logs are captured even when the instance was cached.
+	const logHandler = ({ message }: { message: string }) => onLog(message);
+	ffmpeg.on("log", logHandler);
+	const progressHandler = opts.onProgress
+		? ({ progress }: { progress: number }) =>
+				opts.onProgress?.(Math.min(1, Math.max(0, progress)))
+		: null;
+	if (progressHandler) ffmpeg.on("progress", progressHandler);
+	try {
+		// fetchFile pulls the source cross-origin; surface a clear message if the
+		// host (UploadThing) blocks it.
+		let sourceData: Uint8Array;
+		try {
+			sourceData = await fetchFile(opts.sourceUrl);
+		} catch (e) {
+			throw new Error(
+				`Could not fetch source file (CORS or network): ${e instanceof Error ? e.message : String(e)}`,
+			);
+		}
+		await ffmpeg.writeFile("input.flac", sourceData);
+		const code = await ffmpeg.exec([
+			"-i", "input.flac",
+			"-c:a", "aac",
+			"-b:a", opts.bitrate ?? "192k",
+			// Move the moov atom to the front so the player can start before the
+			// whole file has downloaded — the whole point of the stream version.
+			"-movflags", "+faststart",
+			"output.m4a",
+		]);
+		if (code !== 0) {
+			throw new Error(`ffmpeg exited with code ${code}: ${lastLog || "no log output"}`);
+		}
+		const data = await ffmpeg.readFile("output.m4a");
+		await ffmpeg.deleteFile("input.flac");
+		await ffmpeg.deleteFile("output.m4a");
+		// Copy into a fresh ArrayBuffer-backed view so the Blob typing is happy
+		// (readFile may be typed against a SharedArrayBuffer-backed Uint8Array).
+		const bytes = new Uint8Array(data as Uint8Array);
+		const blob = new Blob([bytes], { type: "audio/mp4" });
+		return new File([blob], opts.outputName ?? "stream.m4a", { type: "audio/mp4" });
+	} finally {
+		ffmpeg.off("log", logHandler);
+		if (progressHandler) ffmpeg.off("progress", progressHandler);
+	}
+}
--- a/src/lib/trpc/music/schemas.ts
+++ b/src/lib/trpc/music/schemas.ts
@@ -7,6 +7,9 @@ export const createMusicInputSchema = z.object({
 				fileUrl: z.string(),
 				fileKey: z.string(),
 				fileName: z.string(),
+				streamUrl: z.string().optional().nullable(),
+				streamKey: z.string().optional().nullable(),
+				streamName: z.string().optional().nullable(),
 			})
 export const updateMusicInputSchema = z.object({
 				id: z.string().uuid(),
@@ -15,4 +18,14 @@ export const updateMusicInputSchema = z.object({
 				fileUrl: z.string().optional(),
 				fileKey: z.string().optional(),
 				fileName: z.string().optional(),
+				streamUrl: z.string().optional().nullable(),
+				streamKey: z.string().optional().nullable(),
+				streamName: z.string().optional().nullable(),
+			})
+
+export const setStreamInputSchema = z.object({
+				id: z.string().uuid(),
+				streamUrl: z.string(),
+				streamKey: z.string(),
+				streamName: z.string(),
 			})
--- a/src/lib/uploadthing.ts
+++ b/src/lib/uploadthing.ts
@@ -1,5 +1,7 @@
-import { generateUploadButton, generateUploadDropzone } from "@uploadthing/react";
+import { generateReactHelpers, generateUploadButton, generateUploadDropzone } from "@uploadthing/react";
 import type { FileRouter } from "~/server/uploadthing";

 export const UploadButton = generateUploadButton<FileRouter>();
 export const UploadDropzone = generateUploadDropzone<FileRouter>();
+
+export const { useUploadThing } = generateReactHelpers<FileRouter>();
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -1,13 +1,16 @@
-import { clerkMiddleware, createRouteMatcher, currentUser } from "@clerk/nextjs/server";
+import { clerkMiddleware, createRouteMatcher } from "@clerk/nextjs/server";
+import { NextResponse } from "next/server";
 import { env } from "~/env";

-const isTenantAdminRoute = createRouteMatcher(['/admin(.*)'])
-export default clerkMiddleware(async (auth,req) => {
+const isTenantAdminRoute = createRouteMatcher(["/admin(.*)"]);
+
+export default clerkMiddleware(async (auth, req) => {
  if (isTenantAdminRoute(req)) {
-    console.log("running clerk middleware");
-    let userid = (await auth()).userId
-    if (userid != env.ADMIN_USER_CLERK_ID) {
-      await auth.protect()
+    await auth.protect();
+
+    const { userId } = await auth();
+    if (userId !== env.ADMIN_USER_CLERK_ID) {
+      return NextResponse.redirect(new URL("/", req.url));
    }
  }
 });
--- a/src/server/dbschema/schema.ts
+++ b/src/server/dbschema/schema.ts
@@ -43,6 +43,7 @@ export const cvEntry = createTable(
 			.default(sql`CURRENT_TIMESTAMP`)
 			.notNull().$type<Date>(),
 		updatedAt: d.timestamp({ withTimezone: true }).$onUpdate(() => new Date()).$type<Date>(),
+		position: d.integer(),
 	})
 )

@@ -55,7 +56,7 @@ export const cvEntryRelations = relations(cvEntry, ({one}) => ({

 export const sourceTypeEnum = pgEnum('source_type',['open','closed'])
 export const releaseStatus = pgEnum('release_status',['released','unreleased'])
-export const stackItemEnum = pgEnum('stack_item',['drizzle','postgres','nextjs','react','servercomponents','php','laravel','reactnative','expo','mysql','nginx','protobuf','grpc','java','graalvm','spring','aws','s3','react-native','linux','debian','htmx','neon'])
+export const stackItemEnum = pgEnum('stack_item',['drizzle','postgres','nextjs','react','servercomponents','php','laravel','reactnative','expo','mysql','nginx','protobuf','grpc','java','graalvm','spring','aws','s3','react-native','linux','debian','htmx','neon','typescript','javafx','x11','zig','libghostty','zod'])

 export const project = createTable(
 	"project",
@@ -68,6 +69,7 @@ export const project = createTable(
 		releaseStatus: releaseStatus(),
 		releaseLink: d.varchar({length: 200}),
 		stackId: d.uuid(),
+		orderPos: d.integer(),
 	})
 )

@@ -92,9 +94,14 @@ export const music = createTable(
 		id: d.uuid().primaryKey().notNull(),
 		title: d.varchar({ length: 100 }).notNull(),
 		description: d.text(),
+		// Original high-quality upload (e.g. FLAC), offered as a download.
 		fileUrl: d.varchar("file_url", { length: 500 }).notNull(),
 		fileKey: d.varchar("file_key", { length: 200 }).notNull(),
 		fileName: d.varchar("file_name", { length: 200 }).notNull(),
+		// Lighter, streaming-friendly transcode (e.g. AAC) used by the player.
+		streamUrl: d.varchar("stream_url", { length: 500 }),
+		streamKey: d.varchar("stream_key", { length: 200 }),
+		streamName: d.varchar("stream_name", { length: 200 }),
 		createdAt: d
 			.timestamp({ withTimezone: true })
 			.default(sql`CURRENT_TIMESTAMP`)
@@ -168,6 +175,7 @@ export const chatMessageRelations = relations(chatMessage, ({ one }) => ({
 export const systemSettings = createTable(
 	"systemSetting",
 	(d) => ({
-		systemPropmt: d.text()
+		systemPropmt: d.text(),
+		model: d.text()
 	})
 )
--- a/src/server/routers/chat.ts
+++ b/src/server/routers/chat.ts
@@ -7,14 +7,34 @@ import { isAdmin } from '~/app/actions';
 import { z } from 'zod';
 import { eq } from 'drizzle-orm';
 import { clerkClient, auth } from '@clerk/nextjs/server'
+import { env } from '~/env'
+
+export const DEFAULT_MODEL = 'gpt-5-mini'
+
+// Models returned by the OpenAI API that aren't usable for chat completions.
+const NON_CHAT_MODEL = /embedding|image|audio|realtime|transcribe|tts|whisper|moderation|dall-e|search|codex|instruct/
+
+async function readSettings() {
+	return db.select().from(systemSettings).limit(1).then((r) => r[0])
+}
+
+async function writeSettings(values: { systemPropmt?: string | null; model?: string | null }) {
+	const current = await readSettings()
+	await db.delete(systemSettings)
+	await db.insert(systemSettings).values({
+		systemPropmt: values.systemPropmt ?? current?.systemPropmt ?? null,
+		model: values.model ?? current?.model ?? null,
+	})
+}
+
 export const chatRouter = router({
  getSession: publicProcedure.query(async () => {
-		const clerk = await clerkClient()
    const { userId } = await auth();
-    const user = await clerk.users.getUser(userId?userId:"")
-    if (user == undefined) {
+    if (!userId) {
      throw new TRPCError({ message: "chat is only available to signed in users", code: 'UNAUTHORIZED' });
    }
+		const clerk = await clerkClient()
+    const user = await clerk.users.getUser(userId)
    let session = await db.query.chatSession.findFirst({
      where(fields, operators) {
        return operators.eq(fields.userId, user.id)
@@ -66,13 +86,34 @@ export const chatRouter = router({

  }),
  getSystemPrompt: publicProcedure.query(async () => {
-    const row = await db.select().from(systemSettings).limit(1).then((r) => r[0])
+    const row = await readSettings()
    return row?.systemPropmt ?? ''
  }),
  updateSystemPrompt: publicProcedure.input(z.object({ prompt: z.string() })).mutation(async ({ input }) => {
    if (!(await isAdmin())) throw new TRPCError({ code: 'FORBIDDEN' })
-    await db.delete(systemSettings)
-    await db.insert(systemSettings).values({ systemPropmt: input.prompt })
+    await writeSettings({ systemPropmt: input.prompt })
+  }),
+  getModel: publicProcedure.query(async () => {
+    const row = await readSettings()
+    return row?.model ?? DEFAULT_MODEL
+  }),
+  listModels: publicProcedure.query(async () => {
+    if (!(await isAdmin())) throw new TRPCError({ code: 'FORBIDDEN' })
+    const res = await fetch('https://api.openai.com/v1/models', {
+      headers: { Authorization: `Bearer ${env.OPENAI_API_KEY}` },
+    })
+    if (!res.ok) {
+      throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `failed to fetch models (${res.status})` })
+    }
+    const json = (await res.json()) as { data: { id: string }[] }
+    return json.data
+      .map((m) => m.id)
+      .filter((id) => (id.startsWith('gpt') || /^o\d/.test(id) || id.startsWith('chatgpt')) && !NON_CHAT_MODEL.test(id))
+      .sort()
+  }),
+  updateModel: publicProcedure.input(z.object({ model: z.string() })).mutation(async ({ input }) => {
+    if (!(await isAdmin())) throw new TRPCError({ code: 'FORBIDDEN' })
+    await writeSettings({ model: input.model })
  }),
 })

--- a/src/server/routers/cvCategory.ts
+++ b/src/server/routers/cvCategory.ts
@@ -15,9 +15,6 @@ export const cvCategoryRouter = router({
  }),
  getById: publicProcedure.input(z.string()).query(async ({input}) => {
    const res = await db.query.cvCategory.findFirst({
-      with: {
-        cvEntry: true
-      },
      where(fields, operators) {
        return operators.eq(fields.id, input)    
      },
--- a/src/server/routers/cvEntry.ts
+++ b/src/server/routers/cvEntry.ts
@@ -13,4 +13,14 @@ export const cvEntryRouter = router({
    })
    return res;
  }),
+  byCategoryAndToDateDescending: publicProcedure.input(z.string()).query(async ({input}) => {
+    const res = await db.query.cvEntry.findMany({
+      with: {
+        category: true
+      },
+      where: (fields, {eq}) => eq(fields.categoryId,input),
+      orderBy: (t,{desc}) => desc(t.toTime),
+    })
+    return res;
+  })
 });
--- a/src/server/routers/music.ts
+++ b/src/server/routers/music.ts
@@ -5,7 +5,7 @@ import { eq } from "drizzle-orm";
 import { isAdmin } from "~/app/actions";
 import { TRPCError } from "@trpc/server";
 import { z } from "zod";
-import { createMusicInputSchema, updateMusicInputSchema } from "~/lib/trpc/music/schemas"; 
+import { createMusicInputSchema, updateMusicInputSchema, setStreamInputSchema } from "~/lib/trpc/music/schemas";
 import { utapi } from "../uploadthing";
 export const musicRouter = router({
 	list: publicProcedure.query(async () => {
@@ -33,6 +33,22 @@ export const musicRouter = router({
 			const { id, ...data } = input;
 			return db.update(music).set(data).where(eq(music.id, id)).returning();
 		}),
+	setStream: publicProcedure
+		.input(setStreamInputSchema)
+		.mutation(async ({ input }) => {
+			const admin = await isAdmin();
+			if (!admin) throw new TRPCError({ code: "FORBIDDEN", message: "Access denied" });
+			const { id, ...data } = input;
+			const existing = await db.select().from(music).where(eq(music.id, id)).limit(1);
+			const prev = existing.at(0);
+			if (!prev) throw new TRPCError({ code: "NOT_FOUND", message: "Track not found" });
+			const res = await db.update(music).set(data).where(eq(music.id, id)).returning();
+			// Drop the previous stream transcode so we don't orphan it on UploadThing.
+			if (prev.streamKey && prev.streamKey !== data.streamKey) {
+				utapi.deleteFiles(prev.streamKey);
+			}
+			return res.at(0);
+		}),
 	delete: publicProcedure
 		.input(z.object({id:z.string().uuid()}))
 		.mutation(async ({ input }) => {
@@ -41,7 +57,8 @@ export const musicRouter = router({
 			let res = await db.delete(music).where(eq(music.id, input.id)).returning();
 			let ret = res.at(0)
 			if (ret) {
-				utapi.deleteFiles(ret.fileKey)
+				const keys = [ret.fileKey, ret.streamKey].filter((k): k is string => !!k);
+				utapi.deleteFiles(keys)
 			}
 			return ret;
 		}),
--- a/src/server/routers/project.ts
+++ b/src/server/routers/project.ts
@@ -1,5 +1,5 @@
-import { publicProcedure, router } from "~/server/trpc";
 import { db } from "~/server/db";
+import { publicProcedure, router } from "~/server/trpc";

 type ReadmeRequest = {
  url: string;
@@ -71,6 +71,11 @@ async function fetchReadme(sourceLink: string) {
 export const projectRouter = router({
  listWithStack: publicProcedure.query(async () => {
    const projects = await db.query.project.findMany({
+      orderBy: (project, { asc }) => [
+        asc(project.orderPos),
+        asc(project.title),
+        asc(project.id),
+      ],
      with: {
        techStack: true,
      },
Author	SHA1	Message	Date
Gregor Lohaus	91315730ac	background playback	2026-06-16 19:00:59 +02:00
Gregor Lohaus	13649cd6dc	Merge branch 'fix-cv-animations'	2026-06-16 18:56:05 +02:00
Gregor Lohaus	1e0f033d07	refactor to use existing animated components	2026-06-16 18:56:02 +02:00
Gregor Lohaus	39563b6740	Merge branch 'fix-cv-animations'	2026-06-16 18:42:19 +02:00
Gregor Lohaus	dcc4f47ccf	fix cv animations	2026-06-16 18:42:06 +02:00
Gregor Lohaus	c8a9ab5984	Merge branch 'ai-model-select'	2026-06-16 18:40:14 +02:00
Gregor Lohaus	54f108ac8d	model selector	2026-06-16 18:40:08 +02:00
Gregor Lohaus	865ef0b316	refactor animations once again	2026-06-16 15:41:03 +02:00
Gregor Lohaus	63b0405a7a	display waveform	2026-06-16 13:07:41 +02:00
Gregor Lohaus	7aa1746f97	convert flacs to aac for streaming	2026-06-16 12:49:30 +02:00
Gregor Lohaus	f5e8b87846	package updates, minor bug fixes, stack items, background animation fixes	2026-06-06 12:15:01 +02:00
Gregor Lohaus	65b9184a22	refactor animated background, fix type	2026-04-24 14:23:52 +02:00
Gregor Lohaus	ea7ddb8e51	fix admin redirect loop	2026-04-24 12:41:27 +02:00
Gregor Lohaus	bcefe397ca	speedinsights next	2026-04-24 12:26:44 +02:00
Gregor Lohaus	8ce95f2b5c	add speed insides	2026-04-24 12:23:31 +02:00
Gregor Lohaus	da43b31aa3	chat interface, validate user id	2026-04-24 12:11:29 +02:00
Gregor Lohaus	538d896b0e	Merge branch 'blog'	2026-04-24 11:58:34 +02:00
				`@@ -0,0 +1 @@`
				var C="https://unpkg.com/@ffmpeg/core@0.12.9/dist/umd/ffmpeg-core.js",N;(function(E){E.LOAD="LOAD",E.EXEC="EXEC",E.FFPROBE="FFPROBE",E.WRITE_FILE="WRITE_FILE",E.READ_FILE="READ_FILE",E.DELETE_FILE="DELETE_FILE",E.RENAME="RENAME",E.CREATE_DIR="CREATE_DIR",E.LIST_DIR="LIST_DIR",E.DELETE_DIR="DELETE_DIR",E.ERROR="ERROR",E.DOWNLOAD="DOWNLOAD",E.PROGRESS="PROGRESS",E.LOG="LOG",E.MOUNT="MOUNT",E.UNMOUNT="UNMOUNT"})(N\|\|(N={}));var G=Error("unknown message type"),V=Error("ffmpeg is not loaded, call `await ffmpeg.load()` first"),b=Error("called FFmpeg.terminate()"),v=Error("failed to import ffmpeg-core.js");var I,X=async({coreURL:E,wasmURL:D,workerURL:O})=>{let S=!I;try{if(!E)E=C;importScripts(E)}catch{if(!E\|\|E===C)E=C.replace("/umd/","/esm/");if(self.createFFmpegCore=(await import(E)).default,!self.createFFmpegCore)throw v}let A=E,x=D?D:E.replace(/.js$/g,".wasm"),B=O?O:E.replace(/.js$/g,".worker.js");return I=await self.createFFmpegCore({mainScriptUrlOrBlob:`${A}#${btoa(JSON.stringify({wasmURL:x,workerURL:B}))}`}),I.setLogger((W)=>self.postMessage({type:N.LOG,data:W})),I.setProgress((W)=>self.postMessage({type:N.PROGRESS,data:W})),S},Y=({args:E,timeout:D=-1})=>{I.setTimeout(D),I.exec(...E);let O=I.ret;return I.reset(),O},j=({args:E,timeout:D=-1})=>{I.setTimeout(D),I.ffprobe(...E);let O=I.ret;return I.reset(),O},J=({path:E,data:D})=>{return I.FS.writeFile(E,D),!0},$=({path:E,encoding:D})=>I.FS.readFile(E,{encoding:D}),q=({path:E})=>{return I.FS.unlink(E),!0},z=({oldPath:E,newPath:D})=>{return I.FS.rename(E,D),!0},H=({path:E})=>{return I.FS.mkdir(E),!0},K=({path:E})=>{let D=I.FS.readdir(E),O=[];for(let S of D){let A=I.FS.stat(`${E}/${S}`),x=I.FS.isDir(A.mode);O.push({name:S,isDir:x})}return O},Q=({path:E})=>{return I.FS.rmdir(E),!0},R=({fsType:E,options:D,mountPoint:O})=>{let S=E,A=I.FS.filesystems[S];if(!A)return!1;return I.FS.mount(A,D,O),!0},Z=({mountPoint:E})=>{return I.FS.unmount(E),!0};self.onmessage=async({data:{id:E,type:D,data:O}})=>{let S=[],A;try{if(D!==N.LOAD&&!I)throw V;switch(D){case N.LOAD:A=await X(O);break;case N.EXEC:A=Y(O);break;case N.FFPROBE:A=j(O);break;case N.WRITE_FILE:A=J(O);break;case N.READ_FILE:A=$(O);break;case N.DELETE_FILE:A=q(O);break;case N.RENAME:A=z(O);break;case N.CREATE_DIR:A=H(O);break;case N.LIST_DIR:A=K(O);break;case N.DELETE_DIR:A=Q(O);break;case N.MOUNT:A=R(O);break;case N.UNMOUNT:A=Z(O);break;default:throw G}}catch(x){self.postMessage({id:E,type:N.ERROR,data:x.toString()});return}if(A instanceof Uint8Array)S.push(A.buffer);self.postMessage({id:E,type:D,data:A},S)};