Function bodies 165 total

    function __emval_new_cstring(v) {
      v >>>= 0;
      return Emval.toHandle(getStringOrSymbol(v))
    }

    function __emval_new_object() {
      return Emval.toHandle({})
    }

    function __emval_run_destructors(handle) {
      handle >>>= 0;
      var destructors = Emval.toValue(handle);
      runDestructors(destructors);
      __emval_decref(handle)
    }

    function __emval_set_property(handle, key, value) {
      handle >>>= 0;
      key >>>= 0;
      value >>>= 0;
      handle = Emval.toValue(handle);
      key = Emval.toValue(key);
      value = Emval.toValue(value);
      handle[key] = value
    }

    function __emval_take_value(type, arg) {
      type >>>= 0;
      arg >>>= 0;
      type = requireRegisteredType(type, '_emval_take_value');
      var v = type['readValueFromPointer'](arg);
      return Emval.toHandle(v)
    }

    function _emscripten_resize_heap(requestedSize) {
      requestedSize >>>= 0;
      var oldSize = HEAPU8.length;
      var maxHeapSize = getHeapMax();
      if (requestedSize > maxHeapSize) {
        return false
      }
      for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
        var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
        overGrownHeapSize =
            Math.min(overGrownHeapSize, requestedSize + 100663296);
        var newSize = Math.min(
            maxHeapSize,
            alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
        var replacement = growMemory(newSize);
        if (replacement) {
          return true
        }
      }
      return false
    }

    function applySignatureConversions(wasmExports) {
      wasmExports = Object.assign({}, wasmExports);
      var makeWrapper_pp = f => a0 => f(a0) >>> 0;
      var makeWrapper_p = f => () => f() >>> 0;
      wasmExports['K'] = makeWrapper_pp(wasmExports['K']);
      wasmExports['N'] = makeWrapper_pp(wasmExports['N']);
      wasmExports['_emscripten_stack_alloc'] =
          makeWrapper_pp(wasmExports['_emscripten_stack_alloc']);
      wasmExports['emscripten_stack_get_current'] =
          makeWrapper_p(wasmExports['emscripten_stack_get_current']);
      return wasmExports
    }

    function run() {
      if (runDependencies > 0) {
        dependenciesFulfilled = run;
        return
      }
      preRun();
      if (runDependencies > 0) {
        dependenciesFulfilled = run;
        return
      }
      function doRun() {
        Module['calledRun'] = true;
        if (ABORT) return;
        initRuntime();
        readyPromiseResolve(Module);
        Module['onRuntimeInitialized']?.();
        postRun()
      }
      if (Module['setStatus']) {
        Module['setStatus']('Running...');
        setTimeout(() => {
          setTimeout(() => Module['setStatus'](''), 1);
          doRun()
        }, 1)
      } else {
        doRun()
      }
    }

      function doRun() {
        Module['calledRun'] = true;
        if (ABORT) return;
        initRuntime();
        readyPromiseResolve(Module);
        Module['onRuntimeInitialized']?.();
        postRun()
      }

export default function App() {
  return (
    <div className="min-h-screen flex flex-col">
      <Header />
      <main className="flex-1 pt-14">
        <Routes>
          <Route path="/" element={<Landing />} />
          <Route path="/generate" element={<Generate />} />
          <Route path="/success" element={<Success />} />
          <Route path="/docs" element={<Docs />} />
          <Route path="/recover" element={<Recover />} />
        </Routes>
      </main>
      <Footer />
    </div>
  );
}

export default function CopyToken({ token }: Props) {
  const [copied, setCopied] = useState(false);

  const handleCopy = async () => {
    await navigator.clipboard.writeText(token);
    setCopied(true);
    setTimeout(() => setCopied(false), 2000);
  };

  return (
    <div className="flex items-center gap-3 rounded-xl p-4 max-w-[500px] mx-auto my-4 border border-accent/20 bg-accent-glow">
      <code className="font-mono text-xs text-accent flex-1 break-all">{token}</code>
      <button
        className="bg-accent text-base border-none px-4 py-2 rounded-lg cursor-pointer text-sm font-medium whitespace-nowrap hover:brightness-110 transition-all"
        onClick={handleCopy}
      >
        {copied ? "Copied!" : "Copy"}
      </button>
    </div>
  );
}

export default function FileDropZone({ onFile, disabled }: Props) {
  const [isDragging, setIsDragging] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [fileName, setFileName] = useState<string | null>(null);
  const inputRef = useRef<HTMLInputElement>(null);

  const handleFile = useCallback(
    (file: File) => {
      const ext = '.' + file.name.toLowerCase().split('.').pop();
      if (!ACCEPTED.includes(ext)) {
        setError(`Unsupported format: ${ext}. Use STL, OBJ, or STEP files.`);
        return;
      }
      setError(null);
      setFileName(file.name);
      onFile(file);
    },
    [onFile]
  );

  const onDrop = useCallback(
    (e: React.DragEvent) => {
      e.preventDefault();
      setIsDragging(false);
      if (disabled) return;
      const file = e.dataTransfer.files[0];
      if (file) handleFile(file);
    },
    [handleFile, disabled]
  );

  const onDragOver = useCallback(
    (e: React.DragEvent) => {
      e.preventDef

export default function Footer() {
  return (
    <footer className='border-t border-border py-10'>
      <div className='max-w-[1200px] mx-auto px-6 flex items-center justify-between max-sm:flex-col max-sm:gap-4'>
        <p className='font-mono text-[10px] tracking-[0.08em] text-primary/20'>
          &copy; {new Date().getFullYear()} negative-support
        </p>
        <div className='flex items-center gap-6'>
          <a
            href='https://github.com/drcmda/negative-support/blob/master/LICENSE.md'
            target='_blank'
            rel='noopener noreferrer'
            className='font-mono text-[10px] tracking-[0.08em] text-primary/20 hover:text-primary/50 transition-colors'>
            License
          </a>
          <a
            href='https://github.com/drcmda/negative-support/blob/master/TERMS.md'
            target='_blank'
            rel='noopener noreferrer'
            className='font-mono text-[10px] tracking-[0.08em] text-primary/20 hover:text-primary/5

export default function Header() {
  const navigate = useNavigate()
  const location = useLocation()
  const { user, license, freeRemaining, loading } = useAuth()
  const [open, setOpen] = useState(false)
  const [menuOpen, setMenuOpen] = useState(false)
  const [copied, setCopied] = useState(false)
  const dropdownRef = useRef<HTMLDivElement>(null)

  const handlePricing = useCallback(
    (e: React.MouseEvent) => {
      e.preventDefault()
      setMenuOpen(false)
      if (location.pathname === '/') {
        document.getElementById('pricing')?.scrollIntoView({ behavior: 'smooth' })
      } else {
        navigate('/')
        setTimeout(() => {
          document.getElementById('pricing')?.scrollIntoView({ behavior: 'smooth' })
        }, 100)
      }
    },
    [navigate, location.pathname],
  )

  const handleLogout = useCallback(async () => {
    await logout()
    setOpen(false)
    setMenuOpen(false)
    window.location.href = '/'
  }, [])

  const handleCopyToken = useCallbac

function useParsedGeometry(vertices: Float32Array, faces: Uint32Array) {
  const geo = useMemo(() => {
    const g = new THREE.BufferGeometry()
    g.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3))
    g.setIndex(new THREE.Uint32BufferAttribute(faces, 1))
    g.computeVertexNormals()
    return g
  }, [vertices, faces])

  useEffect(() => () => geo.dispose(), [geo])
  return geo
}

function ModelMesh({ vertices, faces }: { vertices: Float32Array; faces: Uint32Array }) {
  const geo = useParsedGeometry(vertices, faces)
  return (
    <mesh geometry={geo} renderOrder={1}>
      <meshStandardMaterial color='#a6accd' transparent opacity={0.15} depthWrite={false} side={THREE.DoubleSide} />
    </mesh>
  )
}

function SupportMesh({ vertices, faces }: { vertices: Float32Array; faces: Uint32Array }) {
  const geo = useParsedGeometry(vertices, faces)
  return (
    <mesh geometry={geo} renderOrder={0}>
      <meshStandardMaterial color='#5de4c7' transparent opacity={0.85} roughness={1} metalness={0.1} />
      <Edges threshold={15} color='white' />
    </mesh>
  )
}

function SetZUp() {
  const { camera } = useThree()
  useEffect(() => {
    camera.up.set(0, 0, 1)
    camera.updateProjectionMatrix()
  }, [camera])
  return null
}

export default function MeshViewer({ modelVertices, modelFaces, supportVertices, supportFaces }: MeshViewerProps) {
  return (
    <div className='w-full min-h-[400px] lg:h-full lg:aspect-auto aspect-[16/10] rounded-xl overflow-hidden border border-border'>
      <Canvas camera={{ fov: 45, near: 0.1, far: 100000, up: [0, 0, 1] }} style={{ background: 'transparent' }}>
        <ambientLight intensity={0.6} />
        <directionalLight position={[5, 5, 10]} intensity={1} />
        <directionalLight position={[-5, -5, -5]} intensity={0.3} />
        <Bounds fit clip observe margin={1.2}>
          <group>
            <SupportMesh vertices={supportVertices} faces={supportFaces} />
            <ModelMesh vertices={modelVertices} faces={modelFaces} />
          </group>
        </Bounds>
        <SetZUp />
        <OrbitControls makeDefault enableDamping dampingFactor={0.1} />
      </Canvas>
    </div>
  )
}

export default function ProgressSteps({ steps }: Props) {
  return (
    <div className="mb-6">
      {steps.map((step, i) => (
        <div key={i} className={`flex items-center gap-3 py-2.5 ${
          step.status === 'done' ? 'text-accent' : step.status === 'active' ? 'text-primary' : 'text-muted'
        }`}>
          <div className="w-6 h-6 flex items-center justify-center shrink-0">
            {step.status === 'done' && (
              <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="3">
                <polyline points="20 6 9 17 4 12" />
              </svg>
            )}
            {step.status === 'active' && (
              <div className="w-4 h-4 border-2 border-border border-t-accent rounded-full animate-spin" />
            )}
            {step.status === 'pending' && (
              <div className="w-1.5 h-1.5 rounded-full bg-border" />
            )}
          </div>
          <div className="flex gap-3 items-baseline">

export function AuthProvider({ children }: { children: ReactNode }) {
  const [user, setUser] = useState<User | null>(null);
  const [license, setLicense] = useState<License | null>(null);
  const [freeRemaining, setFreeRemaining] = useState(0);
  const [loading, setLoading] = useState(true);

  const refresh = useCallback(async () => {
    const state = await fetchMe();
    setUser(state.user);
    setLicense(state.license);
    setFreeRemaining(state.freeRemaining);
    setLoading(false);
  }, []);

  useEffect(() => {
    refresh();
  }, [refresh]);

  return (
    <AuthContext.Provider value={{ user, license, freeRemaining, loading, refresh }}>
      {children}
    </AuthContext.Provider>
  );
}

export function useAuth() {
  return useContext(AuthContext);
}

export async function fetchMe(): Promise<AuthState> {
  try {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), 3000);
    const resp = await fetch("/api/auth/me", { credentials: "include", signal: controller.signal });
    clearTimeout(timeout);
    if (!resp.ok) return { user: null, license: null, freeRemaining: 0 };
    const data = await resp.json();
    return {
      user: data.user || null,
      license: data.license || null,
      freeRemaining: data.freeRemaining ?? 0,
    };
  } catch {
    return { user: null, license: null, freeRemaining: 0 };
  }
}

export function loginUrl(): string {
  return "/api/auth/github";
}

export async function logout(): Promise<void> {
  await fetch("/api/auth/logout", { method: "POST", credentials: "include" });
}

export function getStoredToken(): string | null {
  try {
    return localStorage.getItem(TOKEN_KEY);
  } catch {
    return null;
  }
}

export function storeToken(token: string): void {
  try {
    localStorage.setItem(TOKEN_KEY, token);
    localStorage.setItem(VALID_KEY, '1');
  } catch {
    // ignore
  }
}

export function clearToken(): void {
  try {
    localStorage.removeItem(TOKEN_KEY);
    localStorage.removeItem(VALID_KEY);
  } catch {
    // ignore
  }
}

export function isTokenFormat(token: string): boolean {
  return /^ns_live_[a-f0-9]{32}$/.test(token);
}

export async function validateToken(token: string): Promise<boolean> {
  if (!isTokenFormat(token)) return false;

  try {
    const resp = await fetch('/api/validate', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ token }),
    });
    const data = await resp.json();
    if (data.valid) {
      storeToken(token);
      return true;
    } else {
      clearToken();
      return false;
    }
  } catch {
    // Offline — trust cached validation
    try {
      return localStorage.getItem(VALID_KEY) === '1';
    } catch {
      return false;
    }
  }
}

  export default function occtimportjs(options?: OcctInitOptions): Promise<{
    ReadStepFile(buffer: Uint8Array, params: null): OcctResult;
  }>;

async function getOcct() {
  if (occtInstance) return occtInstance
  occtInstance = await occtInit({
    locateFile: (path: string) => {
      if (path.endsWith('.wasm')) return occtWasmUrl
      return path
    },
  })
  return occtInstance
}

export async function parseSTEP(buffer: ArrayBuffer, params?: any): Promise<STEPParseResult> {
  const occt = await getOcct()
  const fileContent = new Uint8Array(buffer)
  const result = occt.ReadStepFile(fileContent, params ?? null)

  if (!result.success || !result.meshes || result.meshes.length === 0) {
    throw new Error('Failed to parse STEP file — no geometry found.')
  }

  return processOcctResult(result.meshes)
}

export default function Docs() {
  return (
    <div className="py-16">
      <div className="max-w-[1200px] mx-auto px-6">
        <p className="label-xs mb-4 tracking-[0.14em]">Reference</p>
        <h1 className="text-2xl font-semibold mb-12 tracking-[-0.01em]">Documentation</h1>

        {/* Install */}
        <section className="mb-14">
          <div className="flex items-center gap-3 mb-5 pt-5 border-t border-border">
            <h2 className="text-lg font-medium">1. Install</h2>
          </div>
          <div className="rounded-xl p-5 glass mb-4">
            <p className="label-xs mb-3">npm</p>
            <div className="bg-base/60 border border-border rounded-md px-3 py-2.5 mb-3 overflow-x-auto">
              <code className="font-mono text-xs text-code whitespace-pre">npm install -g negative-support</code>
            </div>
            <p className="text-dim text-sm mb-3 leading-relaxed">
              Or run directly with npx (no install needed):
            </p>
    

export default function Recover() {
  const [email, setEmail] = useState("");
  const [loading, setLoading] = useState(false);
  const [sent, setSent] = useState(false);
  const [error, setError] = useState("");

  const handleSubmit = useCallback(async (e: React.FormEvent) => {
    e.preventDefault();
    const trimmed = email.trim();
    if (!trimmed || !trimmed.includes("@")) {
      setError("Please enter a valid email address.");
      return;
    }

    setLoading(true);
    setError("");

    try {
      const resp = await fetch("/api/recover", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ email: trimmed }),
      });
      const data = await resp.json();
      if (data.ok) {
        setSent(true);
      } else {
        setError(data.error || "Something went wrong.");
      }
    } catch {
      setError("Failed to connect. Please try again.");
    } finally {
      setLoading(false);
    }
  }, [email]);

  re

export default function Success() {
  const [searchParams] = useSearchParams();
  const sessionId = searchParams.get("session_id");
  const auth = useAuth();

  const [token, setToken] = useState<string | null>(null);
  const [error, setError] = useState<string | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    if (!sessionId) {
      setError("No session ID found.");
      setLoading(false);
      return;
    }

    const fetchToken = async () => {
      try {
        const resp = await fetch(`/api/token?session_id=${sessionId}`, { credentials: "include" });
        const data = await resp.json();
        if (data.token) {
          setToken(data.token);
          // Refresh auth context so the header updates
          auth.refresh();
        } else {
          setError(data.error || "Token not found.");
        }
      } catch {
        setError("Failed to fetch token. Please try refreshing.");
      } finally {
        setLoading(false);
      }

function progress(step: string, detail?: string) {
  self.postMessage({ type: 'progress', step, detail } satisfies ProgressMessage);
}

function json(data: unknown, status = 200): Response {
  return new Response(JSON.stringify(data), {
    status,
    headers: {
      "Content-Type": "application/json",
      "Access-Control-Allow-Origin": "https://negative.support",
      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
      "Access-Control-Allow-Headers": "Content-Type",
      "Access-Control-Allow-Credentials": "true",
    },
  });
}

function isValidMachineId(id: unknown): id is string {
  return typeof id === "string" && /^[a-f0-9]{64}$/.test(id);
}

function isValidToken(token: unknown): token is string {
  return typeof token === "string" && /^ns_live_[a-f0-9]{32}$/.test(token);
}

function generateToken(): string {
  const bytes = new Uint8Array(16);
  crypto.getRandomValues(bytes);
  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
  return `ns_live_${hex}`;
}

function now(): string {
  return new Date().toISOString();
}

async function readJson(request: Request): Promise<Record<string, unknown>> {
  try {
    return (await request.json()) as Record<string, unknown>;
  } catch {
    return {};
  }
}

async function verifyStripeSignature(
  payload: string,
  sigHeader: string,
  secret: string
): Promise<boolean> {
  const parts = sigHeader.split(",");
  const timestamp = parts.find((p) => p.startsWith("t="))?.slice(2);
  const signatures = parts
    .filter((p) => p.startsWith("v1="))
    .map((p) => p.slice(3));

  if (!timestamp || signatures.length === 0) return false;

  // Reject events older than 5 minutes
  const age = Math.floor(Date.now() / 1000) - parseInt(timestamp, 10);
  if (Math.abs(age) > 300) return false;

  const signedPayload = `${timestamp}.${payload}`;
  const key = await crypto.subtle.importKey(
    "raw",
    new TextEncoder().encode(secret),
    { name: "HMAC", hash: "SHA-256" },
    false,
    ["sign"]
  );
  const sig = await crypto.subtle.sign(
    "HMAC",
    key,
    new TextEncoder().encode(signedPayload)
  );
  const expected = Array.from(new Uint8Array(sig), (b) =>
    b.toString(16).padStart(2, "0")
  ).join("");

  // Constant-time comparison
  re

function timingSafeEqual(a: string, b: string): boolean {
  if (a.length !== b.length) return false;
  let result = 0;
  for (let i = 0; i < a.length; i++) {
    result |= a.charCodeAt(i) ^ b.charCodeAt(i);
  }
  return result === 0;
}

export async function handleFreeTier(request: Request, env: Env): Promise<Response> {
  const body = await readJson(request);

  // Token-based tracking (web + CLI)
  if (isValidToken(body.token)) {
    const row = await env.DB.prepare(
      `SELECT plan, runs_used FROM licenses WHERE token = ?`
    )
      .bind(body.token)
      .first<{ plan: string; runs_used: number }>();

    if (!row) {
      return json({ error: "Token not found" }, 404);
    }

    // Lifetime licenses have unlimited runs
    if (row.plan === "lifetime") {
      return json({ free_remaining: -1 });
    }

    // Increment and return remaining
    if (row.runs_used < FREE_RUNS) {
      await env.DB.prepare(
        `UPDATE licenses SET runs_used = runs_used + 1 WHERE token = ? AND runs_used < ?`
      )
        .bind(body.token, FREE_RUNS)
        .run();
      return json({ free_remaining: Math.max(0, FREE_RUNS - row.runs_used - 1) });
    }

    return json({ free_remaining: 0 });
  }

  // Legacy machine-ba

export async function handleValidate(request: Request, env: Env): Promise<Response> {
  const body = await readJson(request);
  if (!isValidToken(body.token)) {
    return json({ valid: false, error: "Invalid token format" }, 400);
  }

  const row = await env.DB.prepare(
    `SELECT plan, runs_used FROM licenses WHERE token = ?`
  )
    .bind(body.token)
    .first<{ plan: string; runs_used: number }>();

  if (!row) {
    return json({ valid: false, error: "Token not found" });
  }

  const freeRemaining = row.plan === "lifetime" ? -1 : Math.max(0, FREE_RUNS - row.runs_used);
  return json({ valid: true, plan: row.plan, free_remaining: freeRemaining });
}

export async function handleActivate(request: Request, env: Env): Promise<Response> {
  const body = await readJson(request);
  if (!isValidToken(body.token)) {
    return json({ ok: false, error: "Invalid token format" }, 400);
  }
  if (!isValidMachineId(body.machine_id)) {
    return json({ ok: false, error: "Invalid machine_id" }, 400);
  }

  // Check token exists
  const license = await env.DB.prepare(
    `SELECT plan FROM licenses WHERE token = ?`
  )
    .bind(body.token)
    .first<{ plan: string }>();

  if (!license) {
    return json({ ok: false, error: "Token not found" });
  }

  // Check machine count
  const count = await env.DB.prepare(
    `SELECT COUNT(*) as cnt FROM machine_licenses WHERE token = ?`
  )
    .bind(body.token)
    .first<{ cnt: number }>();

  if ((count?.cnt ?? 0) >= MAX_MACHINES_PER_TOKEN) {
    // Check if this machine is already activated (re-activation is OK)
    const existing = await env.DB.prepare(
      `SELECT 1 FROM machine_licenses WHERE 

export async function handleStripeWebhook(request: Request, env: Env): Promise<Response> {
  const rawBody = await request.text();
  const sigHeader = request.headers.get("Stripe-Signature");

  if (!sigHeader) {
    return json({ error: "Missing signature" }, 400);
  }

  const valid = await verifyStripeSignature(rawBody, sigHeader, env.STRIPE_WEBHOOK_SECRET);
  if (!valid) {
    return json({ error: "Invalid signature" }, 400);
  }

  const event = JSON.parse(rawBody);
  if (event.type !== "checkout.session.completed") {
    return json({ received: true });
  }

  const session = event.data.object;
  const email = session.customer_details?.email ?? session.customer_email ?? "unknown";
  const sessionId = session.id;
  const userId = session.metadata?.user_id ? parseInt(session.metadata.user_id, 10) : null;

  // Idempotent: skip if we already processed this session
  const existing = await env.DB.prepare(
    `SELECT token FROM licenses WHERE stripe_session_id = ?`
  )
    .bind(sess

export async function handleGetToken(url: URL, env: Env): Promise<Response> {
  const sessionId = url.searchParams.get("session_id");
  if (!sessionId) {
    return json({ error: "Missing session_id" }, 400);
  }

  const row = await env.DB.prepare(
    `SELECT token, plan FROM licenses WHERE stripe_session_id = ?`
  )
    .bind(sessionId)
    .first<{ token: string; plan: string }>();

  if (!row) {
    return json({ error: "Session not found" }, 404);
  }

  return json({ token: row.token, plan: row.plan });
}