## Demo: rate-limit

### RateLimit.svelte
```svelte
<script lang="ts">
  import DemoPage from '../../components/DemoPage.svelte';
  import { loadSources } from '../../components/utils.ts';
  import { files } from './files.ts';

  const sources = await loadSources(files);

  let { used, limit, resetIn }: { used: number; limit: number; resetIn: number } = $props();
</script>

<DemoPage
  title="Rate Limiting"
  description="Add rateLimit to any Mochi.page() or Mochi.api() route — or globally on Mochi.serve() — to throttle requests per client. Requests are keyed by the proxy-aware client IP by default, memory-backed out of the box, with sqliteStore and postgresStore for persistence. Blocked page routes render the error page with a 429; API routes return JSON with RateLimit-* headers."
  {sources}
>
  <div class="card">
    <dl>
      <dt>Requests used</dt>
      <dd><code>{used} of {limit}</code></dd>
      <dt>Window resets in</dt>
      <dd><code>{resetIn}s</code></dd>
    </dl>
    <p class="hint">
      Reload this page. This route allows {limit} requests per minute per IP — after the {limit}th reload you'll get a 429 error page. Wait for the window to reset, then reload to
      get back in.
    </p>
  </div>
</DemoPage>

<style>
  .card {
    background: var(--surface);
    color: var(--text);
    border-radius: var(--radius-lg);
    border: 1px solid var(--border);
    padding: 1.5rem;
    max-width: 560px;
    margin: 0 auto;
  }

  dl {
    display: grid;
    grid-template-columns: max-content 1fr;
    column-gap: 1.25rem;
    row-gap: 0.75rem;
    margin: 0 0 1rem 0;
  }

  dt {
    font-weight: 600;
    color: var(--text-muted);
  }

  dd {
    margin: 0;
    color: var(--text);
  }

  code {
    font-family: var(--font-mono);
    background: var(--code-bg);
    color: var(--code-accent);
    padding: 0.2rem 0.45rem;
    border-radius: var(--radius-sm);
    font-size: 0.9em;
  }

  .hint {
    color: var(--text-subtle);
    font-size: 0.9rem;
    margin: 0;
  }
</style>
```

### routes.ts
```ts
import { mkdirSync } from 'node:fs';
import { Mochi, getRequestContext, sqliteStore } from 'mochi-framework';
import type { MochiRouteValue } from 'mochi-framework';

// Persist rate-limit counters to SQLite so they survive restarts — the default
// store is in-memory (and sqliteStore() without a path is too). bun:sqlite won't
// create the parent dir, and ./db is gitignored.
mkdirSync('./db', { recursive: true });
const store = sqliteStore({ path: './db/rate-limit.sqlite' });

export const routes: Record<string, MochiRouteValue> = {
  '/demos/rate-limit': Mochi.page('./src/demos/rate-limit/RateLimit.svelte', {
    rateLimit: { limit: 5, window: '1m', store },
    serverProps: () => {
      const rateLimit = getRequestContext().rateLimit;
      return {
        used: rateLimit ? rateLimit.limit - rateLimit.remaining : 1,
        limit: rateLimit?.limit ?? 5,
        resetIn: rateLimit?.resetIn ?? 60,
      };
    },
  }),
};
```

### index.ts
```ts
import { Mochi, logger } from 'mochi-framework';
import { routes } from './routes';

await Mochi.serve({
  port: 3333,
  development: process.env.MODE === 'development',
  routes,
});

logger.info('Server running at http://localhost:3333');
```