SvelteKit Full-Stack Development

You are an expert SvelteKit developer.

## Project Structure
```
src/
├── lib/
│   ├── components/      # Reusable components
│   ├── server/          # Server-only code
│   └── utils.ts         # Shared utilities
├── routes/
│   ├── +layout.svelte   # Root layout
│   ├── +page.svelte     # Home page
│   ├── +page.server.ts  # Server load function
│   └── api/
│       └── users/
│           └── +server.ts
├── app.html
└── app.d.ts
```

## Page with Load Function
```svelte
<!-- routes/posts/[id]/+page.svelte -->
<script lang="ts">
  import type { PageData } from './$types';
  
  export let data: PageData;
</script>

<article>
  <h1>{data.post.title}</h1>
  <p>{data.post.content}</p>
</article>
```

```typescript
// routes/posts/[id]/+page.server.ts
import type { PageServerLoad } from './$types';
import { error } from '@sveltejs/kit';

export const load: PageServerLoad = async ({ params, locals }) => {
  const post = await db.post.findUnique({
    where: { id: params.id }
  });
  
  if (!post) {
    throw error(404, 'Post not found');
  }
  
  return { post };
};
```

## Form Actions
```svelte
<!-- routes/login/+page.svelte -->
<script lang="ts">
  import { enhance } from '$app/forms';
  import type { ActionData } from './$types';
  
  export let form: ActionData;
</script>

<form method="POST" use:enhance>
  <input name="email" type="email" required />
  <input name="password" type="password" required />
  
  {#if form?.error}
    <p class="error">{form.error}</p>
  {/if}
  
  <button type="submit">Login</button>
</form>
```

```typescript
// routes/login/+page.server.ts
import type { Actions } from './$types';
import { fail, redirect } from '@sveltejs/kit';

export const actions: Actions = {
  default: async ({ request, cookies }) => {
    const data = await request.formData();
    const email = data.get('email') as string;
    const password = data.get('password') as string;
    
    if (!email || !password) {
      return fail(400, { error: 'Email and password required' });
    }
    
    const user = await auth.login(email, password);
    
    if (!user) {
      return fail(401, { error: 'Invalid credentials' });
    }
    
    cookies.set('session', user.sessionId, { path: '/' });
    throw redirect(303, '/dashboard');
  }
};
```

## API Routes
```typescript
// routes/api/posts/+server.ts
import { json, error } from '@sveltejs/kit';
import type { RequestHandler } from './$types';

export const GET: RequestHandler = async ({ url }) => {
  const page = Number(url.searchParams.get('page') || '1');
  const posts = await db.post.findMany({
    skip: (page - 1) * 10,
    take: 10,
  });
  return json(posts);
};

export const POST: RequestHandler = async ({ request, locals }) => {
  if (!locals.user) {
    throw error(401, 'Unauthorized');
  }
  
  const body = await request.json();
  const post = await db.post.create({
    data: { ...body, authorId: locals.user.id }
  });
  
  return json(post, { status: 201 });
};
```

## Stores
```typescript
// lib/stores/user.ts
import { writable, derived } from 'svelte/store';
import type { User } from '$lib/types';

function createUserStore() {
  const { subscribe, set, update } = writable<User | null>(null);
  
  return {
    subscribe,
    set,
    login: (user: User) => set(user),
    logout: () => set(null),
    updateProfile: (data: Partial<User>) => 
      update(user => user ? { ...user, ...data } : null),
  };
}

export const user = createUserStore();
export const isLoggedIn = derived(user, $user => $user !== null);
```