docs: update site docs and remove hatk schema command

- Rename hero to hat://k, update tagline
- Remove hatk schema CLI command and docs
- Add createReport to API reference
- Update hooks guide to use ctx. style and hooks/ directory
- Simplify mutations guide to callXrpc only
- Remove experimental SvelteKit features section

Co-Authored-By: Claude Opus 4.6 <[e-mail]>

docs/site/api/index.md

···
 | [`getPreferences`](/api/preferences) | Query     | Yes  | Get user preferences            |
 | [`putPreference`](/api/preferences)  | Procedure | Yes  | Set a preference                |
 | [`describeLabels`](/api/labels)      | Query     | No   | List label definitions          |
+| [`createReport`](/api/labels)        | Procedure | Yes  | Report an account or record     |
 | `describeCollections`                | Query     | No   | List indexed collections        |

docs/site/api/labels.md

···
 }
 ```
 
+## `dev.hatk.createReport`
+
+Report an account or record for moderation review. Reports appear in the admin interface for review.
+
+- **Type:** Procedure (POST)
+- **Auth:** Required (OAuth)
+
+### Input
+
+| Field     | Type   | Required | Description                                |
+| --------- | ------ | -------- | ------------------------------------------ |
+| `subject` | union  | Yes      | `{ did }` for accounts, `{ uri, cid }` for records |
+| `label`   | string | Yes      | Label identifier (must match a defined label) |
+| `reason`  | string | No       | Free-text explanation (max 2000 chars)     |
+
+### Example
+
+```bash
+curl -X POST "http://127.0.0.1:3000/xrpc/dev.hatk.createReport" \
+  -H "Authorization: DPoP <token>" \
+  -H "Content-Type: application/json" \
+  -d '{"subject": {"uri": "at://did:plc:abc/app.bsky.feed.post/123", "cid": "bafyrei..."}, "label": "spam"}'
+```
+
+### Response
+
+```json
+{
+  "id": 1,
+  "subject": { "uri": "at://did:plc:abc/app.bsky.feed.post/123", "cid": "bafyrei..." },
+  "label": "spam",
+  "reportedBy": "did:plc:reporter",
+  "createdAt": "2026-03-24T12:00:00.000Z"
+}
+```
+
 ---
 
 See [Labels guide](/guides/labels) for how to define labels and hydrate them in responses.

docs/site/cli/development.md

···
 
 This removes the SQLite database file and resets the local PDS container, giving you a fresh start.
 
-## `hatk schema`
-
-Print the SQLite table schema derived from your lexicon definitions.
-
-```bash
-hatk schema
-```
-
-Shows the SQL `CREATE TABLE` statements that would be generated from your record lexicons. Useful for understanding how lexicon fields map to database columns.

docs/site/cli/index.md

···
 | `hatk start`  | Start the server (production mode)              |
 | `hatk seed`   | Run seed data against local PDS                 |
 | `hatk reset`  | Wipe database and PDS                           |
-| `hatk schema` | Print SQLite schema from lexicons                |
 
 ## Code Quality
 

docs/site/frontend/mutations.md

···
 ---
 title: Mutations
-description: Create, update, and delete records from your frontend using remote functions and callXrpc.
+description: Create, update, and delete records from your frontend using callXrpc.
 ---
 
 # Mutations
 
-hatk provides two patterns for mutations from the frontend: **remote functions** for server-side logic callable from components, and **`callXrpc`** for direct API calls. Remote functions are the recommended approach -- they run on the server but are imported and called like normal functions.
-
-## Remote functions
-
-Remote functions use SvelteKit's experimental remote functions feature. You define server-side functions in `.remote.ts` files, then import and call them from your components as if they were local.
-
-### Defining remote functions
-
-Create a `.remote.ts` file in your routes directory:
+Mutations use `callXrpc` to call hatk's built-in record management endpoints. `callXrpc` is isomorphic, it works in server load functions, Svelte components, and anywhere else you have access to it.
 
 ```typescript
-// app/routes/status.remote.ts
-import { command } from "$app/server";
-import { callXrpc, getViewer } from "$hatk/client";
-
-export const createStatus = command("unchecked", async (emoji: string) => {
-  const viewer = await getViewer();
-  if (!viewer) throw new Error("Not authenticated");
-  return callXrpc("dev.hatk.createRecord", {
-    collection: "xyz.statusphere.status" as const,
-    repo: viewer.did,
-    record: { status: emoji, createdAt: new Date().toISOString() },
-  });
-});
-
-export const deleteStatus = command("unchecked", async (rkey: string) => {
-  const viewer = await getViewer();
-  if (!viewer) throw new Error("Not authenticated");
-  return callXrpc("dev.hatk.deleteRecord", {
-    collection: "xyz.statusphere.status" as const,
-    rkey,
-  });
-});
-```
-
-Key points:
-- `command` comes from SvelteKit's `$app/server` -- it marks a function as a server-only remote function
-- `"unchecked"` is the validation mode (SvelteKit experimental API)
-- `getViewer()` reads the current user from the session
-- `callXrpc("dev.hatk.createRecord", ...)` and `callXrpc("dev.hatk.deleteRecord", ...)` are typed calls to hatk's built-in record management endpoints
-
-### Calling remote functions from components
-
-Import remote functions directly in your Svelte components:
-
-```svelte
-<script lang="ts">
-  import {
-    createStatus as serverCreateStatus,
-    deleteStatus as serverDeleteStatus,
-  } from './status.remote'
-
-  async function handleCreate(emoji: string) {
-    const res = await serverCreateStatus(emoji)
-    // res.uri contains the AT URI of the created record
+// Server-side: in a +layout.server.ts or +page.server.ts
+export const load = async () => {
+  return {
+    feed: callXrpc("dev.hatk.getFeed", { feed: "recent", limit: 50 }),
   }
+}
 
-  async function handleDelete(uri: string) {
-    const rkey = uri.split('/').pop()!
-    await serverDeleteStatus(rkey)
-  }
-</script>
+// Client-side: in a Svelte component or query helper
+const res = await callXrpc("dev.hatk.createRecord", {
+  collection: "xyz.statusphere.status" as const,
+  repo: viewer.did,
+  record: { status: "🚀", createdAt: new Date().toISOString() },
+})
 ```
 
-Even though these functions run on the server, you call them like any async function. SvelteKit handles the serialization and transport automatically.
-
-### Enabling remote functions
-
-Remote functions require two settings in `svelte.config.js`:
+Pass SvelteKit's `fetch` as the optional third argument in load functions for request deduplication:
 
-```javascript
-// svelte.config.js
-export default {
-  compilerOptions: {
-    experimental: {
-      async: true,
-    },
-  },
-  kit: {
-    experimental: {
-      remoteFunctions: true,
-    },
-  },
-};
+```typescript
+callXrpc("dev.hatk.getFeed", { feed: "recent" }, fetch)
 ```
 
-## Record mutations with `callXrpc`
+## Record mutations
 
 hatk generates three built-in procedures for managing records:
 
···
 
 ## Optimistic UI
 
-For a responsive feel, update the UI before the server responds and roll back on failure. Here's the pattern from the statusphere template:
+For a responsive feel, update the UI before the server responds and roll back on failure:
 
 ```svelte
 <script lang="ts">
   import { callXrpc } from '$hatk/client'
-  import { createStatus as serverCreateStatus } from './status.remote'
   import type { StatusView } from '$hatk/client'
 
   let { data } = $props()
···
 
     try {
       // 2. Call the server
-      const res = await serverCreateStatus(emoji)
+      const res = await callXrpc('dev.hatk.createRecord', {
+        collection: 'xyz.statusphere.status' as const,
+        repo: did,
+        record: { status: emoji, createdAt: new Date().toISOString() },
+      })
       // 3. Replace optimistic item with real URI
       items = items.map(i =>
         i.uri === optimisticItem.uri
···
     isMutating = true
 
     try {
-      await serverDeleteStatus(uri.split('/').pop()!)
+      const rkey = uri.split('/').pop()!
+      await callXrpc('dev.hatk.deleteRecord', {
+        collection: 'xyz.statusphere.status' as const,
+        rkey,
+      })
     } catch {
       if (removed) items = [removed, ...items]
     } finally {
···
   }
 </script>
 ```
-
-## When to use remote functions vs. `callXrpc`
-
-| Use case | Approach |
-|---|---|
-| Mutations that need auth checks | Remote functions -- call `getViewer()` server-side |
-| Multi-step server logic | Remote functions -- keep it in one server round-trip |
-| Simple reads from components | `callXrpc` directly -- no server function needed |
-| Client-side infinite scroll | `callXrpc` directly in the component |

docs/site/frontend/setup.md

···
 
 This is a convention, not a requirement -- but all hatk templates use it and the CLI scaffolding expects it.
 
-## Experimental SvelteKit features
-
-hatk templates enable two experimental SvelteKit features:
-
-```javascript
-// svelte.config.js
-export default {
-  compilerOptions: {
-    experimental: {
-      async: true,       // Async Svelte 5 components
-    },
-  },
-  kit: {
-    experimental: {
-      remoteFunctions: true,  // Server functions callable from components
-    },
-  },
-};
-```
-
-The `remoteFunctions` feature powers the `.remote.ts` pattern described in the [mutations guide](./mutations).
-
 ## Regenerating types
 
 After adding or changing lexicons, regenerate the typed files:

docs/site/guides/hooks.md

···
 description: Run custom logic at key points in the server lifecycle.
 ---
 
-Hooks let you run custom logic at key points in the Hatk lifecycle, like when a user logs in via OAuth. Define them with `defineHook()` in the `server/` directory.
+Hooks let you run custom logic at key points in the hatk lifecycle, like when a user logs in via OAuth. Define them with `defineHook()` in the `hooks/` directory.
 
 ## `on-login`
 
 The `on-login` hook runs after a successful OAuth login. The most common use is calling `ensureRepo` to backfill the user's data so it's available immediately:
 
 ```typescript
-// server/on-login.ts
+// hooks/on-login.ts
 import { defineHook } from '$hatk'
 
-export default defineHook('on-login', async ({ did, ensureRepo }) => {
-  await ensureRepo(did)
+export default defineHook('on-login', async (ctx) => {
+  await ctx.ensureRepo(ctx.did)
 })
 ```
 
···
 Since the hook has full database and record access, you can check for records and create them if needed. For example, copying a user's Bluesky profile to a custom profile collection on first login:
 
 ```typescript
-// server/on-login.ts
+// hooks/on-login.ts
 import { defineHook, type BskyActorProfile, type MyAppProfile } from '$hatk'
 
 export default defineHook('on-login', async (ctx) => {
-  const { did, ensureRepo, lookup } = ctx
-
-  await ensureRepo(did)
+  await ctx.ensureRepo(ctx.did)
 
   // Check if user already has an app profile
-  const existing = await lookup<MyAppProfile>('my.app.profile', 'did', [did])
-  if (existing.has(did)) return
+  const existing = await ctx.lookup<MyAppProfile>('my.app.profile', 'did', [ctx.did])
+  if (existing.has(ctx.did)) return
 
   // Copy from Bluesky profile
-  const bsky = await lookup<BskyActorProfile>('app.bsky.actor.profile', 'did', [did])
-  const profile = bsky.get(did)
+  const bsky = await ctx.lookup<BskyActorProfile>('app.bsky.actor.profile', 'did', [ctx.did])
+  const profile = bsky.get(ctx.did)
   if (!profile) return
 
   await ctx.createRecord('my.app.profile', {

docs/site/index.md

···
 layout: home
 
 hero:
-  name: hatk
-  tagline: Build AT Protocol apps with typed XRPC endpoints.
+  name: "hat://k"
+  tagline: Extends your Vite application with an AT Protocol server. Add feeds, labels, and XRPC endpoints to your app, all typed from your lexicons.
   actions:
     - theme: brand
       text: Get Started

packages/hatk/src/cli.ts

···
     dev                                    Start PDS, seed, and run hatk
     seed                                   Seed local PDS with fixture data
     reset                                  Reset database and PDS for a clean slate
-    schema                                 Show database schema from lexicons
 
   Code Quality
     check                                  Type-check and lint the project
···
 
   console.log(`\nResolved ${resolved.size} lexicon(s). Regenerating types...`)
   execSync('npx hatk generate types', { stdio: 'inherit', cwd: process.cwd() })
-} else if (command === 'schema') {
-  const config = await loadConfig(resolve('hatk.config.ts'))
-
-  const { initDatabase, getSchemaDump } = await import('./database/db.ts')
-  const { createAdapter } = await import('./database/adapter-factory.ts')
-  const { getDialect } = await import('./database/dialect.ts')
-  const configDir2 = resolve('.')
-  const lexicons2 = loadLexicons(resolve(configDir2, 'lexicons'))
-  const collections2 = config.collections.length > 0 ? config.collections : discoverCollections(lexicons2)
-  const { schemas: schemas2, ddlStatements: ddl2 } = buildSchemas(
-    lexicons2,
-    collections2,
-    getDialect(config.databaseEngine),
-  )
-
-  if (config.database !== ':memory:') {
-    mkdirSync(dirname(config.database), { recursive: true })
-  }
-  const { adapter: adapter2 } = await createAdapter(config.databaseEngine)
-  await initDatabase(adapter2, config.database, schemas2, ddl2)
-
-  console.log(await getSchemaDump())
 } else if (command === 'start') {
   const mainPath = resolve(import.meta.dirname!, 'main.js')
   await spawnForward('npx', ['tsx', mainPath, 'hatk.config.ts'])