format codebase and fix all lint warnings

Remove unused functions (flattenRow, resolveBlobOverrides), fix
empty destructuring pattern, exclude minified admin-auth.js from
lint, exclude docs/superpowers from formatter.

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

.oxfmtrc.json

···
   "singleQuote": true,
   "trailingComma": "all",
   "printWidth": 120,
-  "tabWidth": 2
+  "tabWidth": 2,
+  "ignorePatterns": ["docs/superpowers"]
 }

.oxlintrc.json

···
   "env": {
     "builtin": true
   },
-  "ignorePatterns": ["node_modules", "dist", "data", "*.min.js"]
+  "ignorePatterns": ["node_modules", "dist", "data", "*.min.js", "packages/hatk/public/admin-auth.js"]
 }

docs/site/astro.config.mjs

···
 // @ts-check
-import { defineConfig } from 'astro/config';
-import starlight from '@astrojs/starlight';
+import { defineConfig } from 'astro/config'
+import starlight from '@astrojs/starlight'
 
 export default defineConfig({
-	integrations: [
-		starlight({
-			title: 'Hatk',
-			social: [
-				{ icon: 'github', label: 'GitHub', href: 'https://github.com/bigmoves/atconf-workshop' },
-			],
-			sidebar: [
-				{
-					label: 'Getting Started',
-					items: [
-						{ label: 'Quickstart', slug: 'getting-started/quickstart' },
-						{ label: 'Project Structure', slug: 'getting-started/project-structure' },
-						{ label: 'Configuration', slug: 'getting-started/configuration' },
-					],
-				},
-				{
-					label: 'Guides',
-					items: [
-						{ label: 'Frontend (SvelteKit)', slug: 'guides/frontend' },
-						{ label: 'API Client', slug: 'guides/api-client' },
-						{ label: 'OAuth', slug: 'guides/oauth' },
-						{ label: 'Feeds', slug: 'guides/feeds' },
-						{ label: 'XRPC Handlers', slug: 'guides/xrpc-handlers' },
-						{ label: 'Labels', slug: 'guides/labels' },
-						{ label: 'Seeds', slug: 'guides/seeds' },
-						{ label: 'OpenGraph Images', slug: 'guides/opengraph' },
-						{ label: 'Hooks', slug: 'guides/hooks' },
-					],
-				},
-				{
-					label: 'CLI Reference',
-					items: [
-						{ label: 'Overview', slug: 'cli' },
-						{ label: 'Scaffolding', slug: 'cli/scaffold' },
-						{ label: 'Development', slug: 'cli/development' },
-						{ label: 'Testing', slug: 'cli/testing' },
-						{ label: 'Build & Deploy', slug: 'cli/build' },
-					],
-				},
-				{
-					label: 'API Reference',
-					items: [
-						{ label: 'Overview', slug: 'api' },
-						{ label: 'Records', slug: 'api/records' },
-						{ label: 'Feeds', slug: 'api/feeds' },
-						{ label: 'Search', slug: 'api/search' },
-						{ label: 'Blobs', slug: 'api/blobs' },
-						{ label: 'Preferences', slug: 'api/preferences' },
-						{ label: 'Labels', slug: 'api/labels' },
-					],
-				},
-			],
-		}),
-	],
-});
+  integrations: [
+    starlight({
+      title: 'Hatk',
+      social: [{ icon: 'github', label: 'GitHub', href: 'https://github.com/bigmoves/atconf-workshop' }],
+      sidebar: [
+        {
+          label: 'Getting Started',
+          items: [
+            { label: 'Quickstart', slug: 'getting-started/quickstart' },
+            { label: 'Project Structure', slug: 'getting-started/project-structure' },
+            { label: 'Configuration', slug: 'getting-started/configuration' },
+          ],
+        },
+        {
+          label: 'Guides',
+          items: [
+            { label: 'Frontend (SvelteKit)', slug: 'guides/frontend' },
+            { label: 'API Client', slug: 'guides/api-client' },
+            { label: 'OAuth', slug: 'guides/oauth' },
+            { label: 'Feeds', slug: 'guides/feeds' },
+            { label: 'XRPC Handlers', slug: 'guides/xrpc-handlers' },
+            { label: 'Labels', slug: 'guides/labels' },
+            { label: 'Seeds', slug: 'guides/seeds' },
+            { label: 'OpenGraph Images', slug: 'guides/opengraph' },
+            { label: 'Hooks', slug: 'guides/hooks' },
+          ],
+        },
+        {
+          label: 'CLI Reference',
+          items: [
+            { label: 'Overview', slug: 'cli' },
+            { label: 'Scaffolding', slug: 'cli/scaffold' },
+            { label: 'Development', slug: 'cli/development' },
+            { label: 'Testing', slug: 'cli/testing' },
+            { label: 'Build & Deploy', slug: 'cli/build' },
+          ],
+        },
+        {
+          label: 'API Reference',
+          items: [
+            { label: 'Overview', slug: 'api' },
+            { label: 'Records', slug: 'api/records' },
+            { label: 'Feeds', slug: 'api/feeds' },
+            { label: 'Search', slug: 'api/search' },
+            { label: 'Blobs', slug: 'api/blobs' },
+            { label: 'Preferences', slug: 'api/preferences' },
+            { label: 'Labels', slug: 'api/labels' },
+          ],
+        },
+      ],
+    }),
+  ],
+})

docs/site/package.json

···
     "astro": "^5.6.1",
     "sharp": "^0.34.2"
   }
-}
+}

docs/site/src/content.config.ts

···
-import { defineCollection } from 'astro:content';
-import { docsLoader } from '@astrojs/starlight/loaders';
-import { docsSchema } from '@astrojs/starlight/schema';
+import { defineCollection } from 'astro:content'
+import { docsLoader } from '@astrojs/starlight/loaders'
+import { docsSchema } from '@astrojs/starlight/schema'
 
 export const collections = {
-	docs: defineCollection({ loader: docsLoader(), schema: docsSchema() }),
-};
+  docs: defineCollection({ loader: docsLoader(), schema: docsSchema() }),
+}

docs/site/src/content/docs/api/feeds.mdx

···
 
 ### Parameters
 
-| Name | Type | Required | Default | Description |
-|------|------|----------|---------|-------------|
-| `feed` | string | Yes | — | Feed name |
-| `limit` | integer | No | `30` | Results per page (1–100) |
-| `cursor` | string | No | — | Pagination cursor |
+| Name     | Type    | Required | Default | Description              |
+| -------- | ------- | -------- | ------- | ------------------------ |
+| `feed`   | string  | Yes      | —       | Feed name                |
+| `limit`  | integer | No       | `30`    | Results per page (1–100) |
+| `cursor` | string  | No       | —       | Pagination cursor        |
 
 ### Example
 

docs/site/src/content/docs/api/index.mdx

···
 
 ## Built-in endpoints
 
-| Endpoint | Type | Auth | Description |
-|----------|------|------|-------------|
-| [`getRecord`](/api/records/) | Query | No | Fetch a single record by AT URI |
-| [`getRecords`](/api/records/) | Query | No | List records with filters |
-| [`createRecord`](/api/records/) | Procedure | Yes | Create a record via user's PDS |
-| [`putRecord`](/api/records/) | Procedure | Yes | Create or update a record |
-| [`deleteRecord`](/api/records/) | Procedure | Yes | Delete a record |
-| [`getFeed`](/api/feeds/) | Query | No | Retrieve a named feed |
-| [`describeFeeds`](/api/feeds/) | Query | No | List available feeds |
-| [`searchRecords`](/api/search/) | Query | No | Full-text search |
-| [`uploadBlob`](/api/blobs/) | Procedure | Yes | Upload a binary blob |
-| [`getPreferences`](/api/preferences/) | Query | Yes | Get user preferences |
-| [`putPreference`](/api/preferences/) | Procedure | Yes | Set a preference |
-| [`describeLabels`](/api/labels/) | Query | No | List label definitions |
-| `describeCollections` | Query | No | List indexed collections |
+| Endpoint                              | Type      | Auth | Description                     |
+| ------------------------------------- | --------- | ---- | ------------------------------- |
+| [`getRecord`](/api/records/)          | Query     | No   | Fetch a single record by AT URI |
+| [`getRecords`](/api/records/)         | Query     | No   | List records with filters       |
+| [`createRecord`](/api/records/)       | Procedure | Yes  | Create a record via user's PDS  |
+| [`putRecord`](/api/records/)          | Procedure | Yes  | Create or update a record       |
+| [`deleteRecord`](/api/records/)       | Procedure | Yes  | Delete a record                 |
+| [`getFeed`](/api/feeds/)              | Query     | No   | Retrieve a named feed           |
+| [`describeFeeds`](/api/feeds/)        | Query     | No   | List available feeds            |
+| [`searchRecords`](/api/search/)       | Query     | No   | Full-text search                |
+| [`uploadBlob`](/api/blobs/)           | Procedure | Yes  | Upload a binary blob            |
+| [`getPreferences`](/api/preferences/) | Query     | Yes  | Get user preferences            |
+| [`putPreference`](/api/preferences/)  | Procedure | Yes  | Set a preference                |
+| [`describeLabels`](/api/labels/)      | Query     | No   | List label definitions          |
+| `describeCollections`                 | Query     | No   | List indexed collections        |

docs/site/src/content/docs/api/preferences.mdx

···
 
 ### Input
 
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `key` | string | Yes | Preference key |
-| `value` | any | Yes | Preference value |
+| Name    | Type   | Required | Description      |
+| ------- | ------ | -------- | ---------------- |
+| `key`   | string | Yes      | Preference key   |
+| `value` | any    | Yes      | Preference value |
 
 ### Example
 

docs/site/src/content/docs/api/records.mdx

···
 
 ### Parameters
 
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `uri` | string (AT URI) | Yes | The AT URI of the record |
+| Name  | Type            | Required | Description              |
+| ----- | --------------- | -------- | ------------------------ |
+| `uri` | string (AT URI) | Yes      | The AT URI of the record |
 
 ### Example
 
···
 
 ### Parameters
 
-| Name | Type | Required | Default | Description |
-|------|------|----------|---------|-------------|
-| `collection` | string | Yes | — | Collection NSID |
-| `limit` | integer | No | `20` | Results per page (1–100) |
-| `cursor` | string | No | — | Pagination cursor |
-| `sort` | string | No | — | Sort field |
-| `order` | string | No | — | Sort order |
+| Name         | Type    | Required | Default | Description              |
+| ------------ | ------- | -------- | ------- | ------------------------ |
+| `collection` | string  | Yes      | —       | Collection NSID          |
+| `limit`      | integer | No       | `20`    | Results per page (1–100) |
+| `cursor`     | string  | No       | —       | Pagination cursor        |
+| `sort`       | string  | No       | —       | Sort field               |
+| `order`      | string  | No       | —       | Sort order               |
 
 Additional filter parameters are accepted based on the collection's schema — any field defined in the record lexicon can be used as a query parameter.
 
···
 
 ### Input
 
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `collection` | string | Yes | Collection NSID |
-| `repo` | string (DID) | Yes | The user's DID |
-| `record` | object | Yes | The record data |
+| Name         | Type         | Required | Description     |
+| ------------ | ------------ | -------- | --------------- |
+| `collection` | string       | Yes      | Collection NSID |
+| `repo`       | string (DID) | Yes      | The user's DID  |
+| `record`     | object       | Yes      | The record data |
 
 ### Example
 
···
 
 ### Input
 
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `collection` | string | Yes | Collection NSID |
-| `rkey` | string | Yes | Record key |
-| `record` | object | Yes | The record data |
-| `repo` | string (DID) | No | The user's DID (inferred from auth if omitted) |
+| Name         | Type         | Required | Description                                    |
+| ------------ | ------------ | -------- | ---------------------------------------------- |
+| `collection` | string       | Yes      | Collection NSID                                |
+| `rkey`       | string       | Yes      | Record key                                     |
+| `record`     | object       | Yes      | The record data                                |
+| `repo`       | string (DID) | No       | The user's DID (inferred from auth if omitted) |
 
 ### Example
 
···
 
 ### Input
 
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `collection` | string | Yes | Collection NSID |
-| `rkey` | string | Yes | Record key |
+| Name         | Type   | Required | Description     |
+| ------------ | ------ | -------- | --------------- |
+| `collection` | string | Yes      | Collection NSID |
+| `rkey`       | string | Yes      | Record key      |
 
 ### Example
 

docs/site/src/content/docs/api/search.mdx

···
 
 ### Parameters
 
-| Name | Type | Required | Default | Description |
-|------|------|----------|---------|-------------|
-| `collection` | string | Yes | — | Collection NSID to search |
-| `q` | string | Yes | — | Search query |
-| `limit` | integer | No | `20` | Results per page (1–100) |
-| `cursor` | string | No | — | Pagination cursor |
-| `fuzzy` | boolean | No | `true` | Enable fuzzy matching |
+| Name         | Type    | Required | Default | Description               |
+| ------------ | ------- | -------- | ------- | ------------------------- |
+| `collection` | string  | Yes      | —       | Collection NSID to search |
+| `q`          | string  | Yes      | —       | Search query              |
+| `limit`      | integer | No       | `20`    | Results per page (1–100)  |
+| `cursor`     | string  | No       | —       | Pagination cursor         |
+| `fuzzy`      | boolean | No       | `true`  | Enable fuzzy matching     |
 
 ### Example
 

docs/site/src/content/docs/cli/build.mdx

···
 To run in production:
 
 1. Build the frontend:
+
    ```bash
    hatk build
    ```
 
 2. Start the server:
+
    ```bash
    hatk start
    ```

docs/site/src/content/docs/cli/development.mdx

···
 ```
 
 This runs three steps in sequence:
+
 1. **Starts the local PDS** via Docker Compose (if `docker-compose.yml` exists)
 2. **Seeds test data** by running `seeds/seed.ts`
 3. **Starts the Hatk server** with file watching for hot reload

docs/site/src/content/docs/cli/index.mdx

···
 
 ## Getting Started
 
-| Command | Description |
-|---------|-------------|
+| Command           | Description               |
+| ----------------- | ------------------------- |
 | `hatk new <name>` | Create a new hatk project |
 
 ## Generators
 
-| Command | Description |
-|---------|-------------|
-| `hatk generate record <nsid>` | Generate a record lexicon |
-| `hatk generate query <nsid>` | Generate a query lexicon |
-| `hatk generate procedure <nsid>` | Generate a procedure lexicon |
-| `hatk generate feed <name>` | Generate a feed generator |
-| `hatk generate xrpc <nsid>` | Generate an XRPC handler |
-| `hatk generate label <name>` | Generate a label definition |
-| `hatk generate og <name>` | Generate an OpenGraph route |
-| `hatk generate job <name>` | Generate a periodic job |
-| `hatk generate types` | Regenerate TypeScript from lexicons |
-| `hatk destroy <type> <name>` | Remove a generated file |
-| `hatk resolve <nsid>` | Fetch a lexicon from the network |
+| Command                          | Description                         |
+| -------------------------------- | ----------------------------------- |
+| `hatk generate record <nsid>`    | Generate a record lexicon           |
+| `hatk generate query <nsid>`     | Generate a query lexicon            |
+| `hatk generate procedure <nsid>` | Generate a procedure lexicon        |
+| `hatk generate feed <name>`      | Generate a feed generator           |
+| `hatk generate xrpc <nsid>`      | Generate an XRPC handler            |
+| `hatk generate label <name>`     | Generate a label definition         |
+| `hatk generate og <name>`        | Generate an OpenGraph route         |
+| `hatk generate job <name>`       | Generate a periodic job             |
+| `hatk generate types`            | Regenerate TypeScript from lexicons |
+| `hatk destroy <type> <name>`     | Remove a generated file             |
+| `hatk resolve <nsid>`            | Fetch a lexicon from the network    |
 
 ## Development
 
-| Command | Description |
-|---------|-------------|
-| `hatk dev` | Start PDS, seed data, and run server with watch |
-| `hatk start` | Start the server (production mode) |
-| `hatk seed` | Run seed data against local PDS |
-| `hatk reset` | Wipe database and PDS |
-| `hatk schema` | Print DuckDB schema from lexicons |
+| Command       | Description                                     |
+| ------------- | ----------------------------------------------- |
+| `hatk dev`    | Start PDS, seed data, and run server with watch |
+| `hatk start`  | Start the server (production mode)              |
+| `hatk seed`   | Run seed data against local PDS                 |
+| `hatk reset`  | Wipe database and PDS                           |
+| `hatk schema` | Print DuckDB schema from lexicons               |
 
 ## Code Quality
 
-| Command | Description |
-|---------|-------------|
-| `hatk test` | Run all tests |
-| `hatk check` | Type-check, lint, and format check |
-| `hatk format` | Auto-format code |
+| Command       | Description                        |
+| ------------- | ---------------------------------- |
+| `hatk test`   | Run all tests                      |
+| `hatk check`  | Type-check, lint, and format check |
+| `hatk format` | Auto-format code                   |
 
 ## Build
 
-| Command | Description |
-|---------|-------------|
+| Command      | Description                       |
+| ------------ | --------------------------------- |
 | `hatk build` | Build the frontend for production |

docs/site/src/content/docs/cli/scaffold.mdx

···
 hatk new <name> [--svelte]
 ```
 
-| Option | Description |
-|--------|-------------|
-| `<name>` | Project directory name (required) |
+| Option     | Description                                               |
+| ---------- | --------------------------------------------------------- |
+| `<name>`   | Project directory name (required)                         |
 | `--svelte` | Include a Svelte frontend with `src/routes` and `src/lib` |
 
 The command creates the project directory with `config.yaml`, `lexicons/`, `feeds/`, `xrpc/`, `labels/`, `jobs/`, `og/`, `seeds/`, `public/`, `test/`, and the core framework lexicons under `lexicons/dev/hatk/`.

docs/site/src/content/docs/cli/testing.mdx

···
 hatk test --browser          # Playwright browser tests
 ```
 
-| Flag | Description |
-|------|-------------|
-| `--unit` | Run unit tests in `test/feeds/` and `test/xrpc/` |
-| `--integration` | Run integration tests in `test/integration/` |
-| `--browser` | Run Playwright browser tests in `test/browser/` |
+| Flag            | Description                                      |
+| --------------- | ------------------------------------------------ |
+| `--unit`        | Run unit tests in `test/feeds/` and `test/xrpc/` |
+| `--integration` | Run integration tests in `test/integration/`     |
+| `--browser`     | Run Playwright browser tests in `test/browser/`  |
 
 Without flags, all test types are run.
 
···
 
 ### Test context API
 
-| Method | Description |
-|--------|-------------|
-| `ctx.loadFixtures(dir?)` | Load YAML fixture files from `test/fixtures/` (or a custom path) |
-| `ctx.loadFeed(name)` | Load a feed by name. Returns `{ generate(feedContext) }` |
-| `ctx.loadXrpc(name)` | Load an XRPC handler by name. Returns `{ handler(ctx) }` |
-| `ctx.feedContext(opts?)` | Create a feed context with `limit`, `cursor`, `viewer`, and `params` |
-| `ctx.db.query(sql, params?)` | Run a SQL query against the in-memory database |
-| `ctx.db.run(sql, ...params)` | Execute a SQL statement |
-| `ctx.close()` | Shut down the database |
+| Method                       | Description                                                          |
+| ---------------------------- | -------------------------------------------------------------------- |
+| `ctx.loadFixtures(dir?)`     | Load YAML fixture files from `test/fixtures/` (or a custom path)     |
+| `ctx.loadFeed(name)`         | Load a feed by name. Returns `{ generate(feedContext) }`             |
+| `ctx.loadXrpc(name)`         | Load an XRPC handler by name. Returns `{ handler(ctx) }`             |
+| `ctx.feedContext(opts?)`     | Create a feed context with `limit`, `cursor`, `viewer`, and `params` |
+| `ctx.db.query(sql, params?)` | Run a SQL query against the in-memory database                       |
+| `ctx.db.run(sql, ...params)` | Execute a SQL statement                                              |
+| `ctx.close()`                | Shut down the database                                               |
 
 ### Testing a feed
 
···
   const page1 = await feed.generate(ctx.feedContext({ limit: 3 }))
   expect(page1.cursor).toBeDefined()
 
-  const page2 = await feed.generate(
-    ctx.feedContext({ limit: 3, cursor: page1.cursor }),
-  )
+  const page2 = await feed.generate(ctx.feedContext({ limit: 3, cursor: page1.cursor }))
   expect(page2.items).toHaveLength(3)
 })
 ```
···
 
 Use `$now` in fixture values to generate timestamps relative to the current time:
 
-| Expression | Result |
-|------------|--------|
-| `$now` | Current time |
-| `$now(-5m)` | 5 minutes ago |
-| `$now(-2h)` | 2 hours ago |
-| `$now(-1d)` | 1 day ago |
+| Expression  | Result              |
+| ----------- | ------------------- |
+| `$now`      | Current time        |
+| `$now(-5m)` | 5 minutes ago       |
+| `$now(-2h)` | 2 hours ago         |
+| `$now(-1d)` | 1 day ago           |
 | `$now(30s)` | 30 seconds from now |
 
 This keeps fixtures time-relative so tests for "recent" feeds and time-based sorting always work.
···
 afterAll(async () => server?.close())
 
 test('GET /xrpc/dev.hatk.getFeed returns items', async () => {
-  const res = await server.fetch(
-    '/xrpc/dev.hatk.getFeed?feed=recent&limit=5',
-  )
+  const res = await server.fetch('/xrpc/dev.hatk.getFeed?feed=recent&limit=5')
   const data = await res.json()
   expect(data.items.length).toBeGreaterThan(0)
 })
···
 
 The test server extends the test context with:
 
-| Method | Description |
-|--------|-------------|
-| `server.url` | The base URL (e.g., `http://127.0.0.1:54321`) |
-| `server.fetch(path, init?)` | Fetch a path on the test server |
+| Method                             | Description                                                  |
+| ---------------------------------- | ------------------------------------------------------------ |
+| `server.url`                       | The base URL (e.g., `http://127.0.0.1:54321`)                |
+| `server.fetch(path, init?)`        | Fetch a path on the test server                              |
 | `server.fetchAs(did, path, init?)` | Fetch as an authenticated user (sets `x-test-viewer` header) |
-| `server.seed(opts?)` | Get seed helpers for creating records against a real PDS |
+| `server.seed(opts?)`               | Get seed helpers for creating records against a real PDS     |

docs/site/src/content/docs/getting-started/configuration.mdx

···
 
 Controls how the server backfills historical data from the network.
 
-| Option | Default | Env | Description |
-|--------|---------|-----|-------------|
-| `parallelism` | `5` | `BACKFILL_PARALLELISM` | Concurrent repo fetches |
-| `fetchTimeout` | `300` | `BACKFILL_FETCH_TIMEOUT` | Timeout per repo (seconds) |
-| `maxRetries` | `5` | `BACKFILL_MAX_RETRIES` | Max retry attempts for failed repos |
-| `fullNetwork` | `false` | `BACKFILL_FULL_NETWORK` | Backfill the entire network |
-| `repos` | — | `BACKFILL_REPOS` | Pin specific DIDs to backfill (comma-separated) |
-| `signalCollections` | — | — | Collections that trigger backfill (defaults to top-level `collections`) |
+| Option              | Default | Env                      | Description                                                             |
+| ------------------- | ------- | ------------------------ | ----------------------------------------------------------------------- |
+| `parallelism`       | `5`     | `BACKFILL_PARALLELISM`   | Concurrent repo fetches                                                 |
+| `fetchTimeout`      | `300`   | `BACKFILL_FETCH_TIMEOUT` | Timeout per repo (seconds)                                              |
+| `maxRetries`        | `5`     | `BACKFILL_MAX_RETRIES`   | Max retry attempts for failed repos                                     |
+| `fullNetwork`       | `false` | `BACKFILL_FULL_NETWORK`  | Backfill the entire network                                             |
+| `repos`             | —       | `BACKFILL_REPOS`         | Pin specific DIDs to backfill (comma-separated)                         |
+| `signalCollections` | —       | —                        | Collections that trigger backfill (defaults to top-level `collections`) |
 
 ## Full-text search
 
···
 
 Array of allowed OAuth clients. Each client needs:
 
-| Field | Description |
-|-------|-------------|
-| `client_id` | Client identifier URL |
-| `client_name` | Human-readable name |
-| `redirect_uris` | Allowed redirect URIs |
-| `scope` | Optional scope override |
+| Field           | Description             |
+| --------------- | ----------------------- |
+| `client_id`     | Client identifier URL   |
+| `client_name`   | Human-readable name     |
+| `redirect_uris` | Allowed redirect URIs   |
+| `scope`         | Optional scope override |

docs/site/src/content/docs/getting-started/project-structure.mdx

···
 
 Test files organized by type:
 
-| Directory | Purpose |
-|-----------|---------|
-| `test/feeds/` | Feed generator unit tests |
-| `test/xrpc/` | XRPC handler tests |
+| Directory           | Purpose                      |
+| ------------------- | ---------------------------- |
+| `test/feeds/`       | Feed generator unit tests    |
+| `test/xrpc/`        | XRPC handler tests           |
 | `test/integration/` | End-to-end integration tests |
-| `test/browser/` | Playwright browser tests |
-| `test/fixtures/` | Shared test data and helpers |
+| `test/browser/`     | Playwright browser tests     |
+| `test/fixtures/`    | Shared test data and helpers |
 
 Run all tests with `hatk test`. See [Testing](/cli/testing/) for details.
 

docs/site/src/content/docs/getting-started/quickstart.mdx

···
 ```
 
 This starts:
+
 1. A local PDS via Docker
 2. Runs your seed data
 3. Starts the Hatk server with file watching

docs/site/src/content/docs/guides/api-client.mdx

···
 import type { XrpcSchema } from '$hatk'
 import { getAuthFetch } from './auth'
 
-export const api = createClient<XrpcSchema>(
-  typeof window !== 'undefined' ? window.location.origin : '',
-  {
-    fetch: (url, opts) => getAuthFetch()(url as string, opts),
-  },
-)
+export const api = createClient<XrpcSchema>(typeof window !== 'undefined' ? window.location.origin : '', {
+  fetch: (url, opts) => getAuthFetch()(url as string, opts),
+})
 ```
 
 The `XrpcSchema` type is generated from your lexicons and provides full type safety for endpoint names, parameters, inputs, and outputs.
···
 Upload binary data (e.g., images):
 
 ```typescript
-const result = await api.upload(
-  'dev.hatk.uploadBlob',
-  file,
-  'image/jpeg',
-)
+const result = await api.upload('dev.hatk.uploadBlob', file, 'image/jpeg')
 // result: { blob: { ref: { $link: '...' }, ... } }
 ```
 

docs/site/src/content/docs/guides/feeds.mdx

···
 
 ## `defineFeed` options
 
-| Field | Required | Description |
-|-------|----------|-------------|
-| `collection` | Yes (unless `hydrate` provided) | The collection this feed queries |
-| `label` | Yes | Human-readable name shown in `describeFeeds` |
-| `view` | No | View definition to use for auto-hydration |
-| `generate` | Yes | Function that returns record URIs |
-| `hydrate` | No | Function that enriches resolved records |
+| Field        | Required                        | Description                                  |
+| ------------ | ------------------------------- | -------------------------------------------- |
+| `collection` | Yes (unless `hydrate` provided) | The collection this feed queries             |
+| `label`      | Yes                             | Human-readable name shown in `describeFeeds` |
+| `view`       | No                              | View definition to use for auto-hydration    |
+| `generate`   | Yes                             | Function that returns record URIs            |
+| `hydrate`    | No                              | Function that enriches resolved records      |
 
 ---
 
···
 
 ### Context
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `db.query` | function | Run SQL queries against DuckDB |
-| `params` | `Record<string, string>` | Query string parameters from the request |
-| `limit` | number | Requested page size |
-| `cursor` | string \| undefined | Pagination cursor from the client |
-| `viewer` | `{ did: string }` \| null | The authenticated user, or null |
-| `ok` | function | Wraps your return value with type checking |
-| `packCursor` | function | Encode a `(primary, cid)` pair into an opaque cursor string |
-| `unpackCursor` | function | Decode a cursor back into `{ primary, cid }` or null |
-| `isTakendown` | function | Check if a DID has been taken down |
-| `filterTakendownDids` | function | Filter a list of DIDs, returning those that are taken down |
-| `paginate` | function | Run a paginated query — handles cursor, ORDER BY, LIMIT automatically |
+| Field                 | Type                      | Description                                                           |
+| --------------------- | ------------------------- | --------------------------------------------------------------------- |
+| `db.query`            | function                  | Run SQL queries against DuckDB                                        |
+| `params`              | `Record<string, string>`  | Query string parameters from the request                              |
+| `limit`               | number                    | Requested page size                                                   |
+| `cursor`              | string \| undefined       | Pagination cursor from the client                                     |
+| `viewer`              | `{ did: string }` \| null | The authenticated user, or null                                       |
+| `ok`                  | function                  | Wraps your return value with type checking                            |
+| `packCursor`          | function                  | Encode a `(primary, cid)` pair into an opaque cursor string           |
+| `unpackCursor`        | function                  | Decode a cursor back into `{ primary, cid }` or null                  |
+| `isTakendown`         | function                  | Check if a DID has been taken down                                    |
+| `filterTakendownDids` | function                  | Filter a list of DIDs, returning those that are taken down            |
+| `paginate`            | function                  | Run a paginated query — handles cursor, ORDER BY, LIMIT automatically |
 
 ### Cursor pagination
 
···
 
 ### Context
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `items` | `Row[]` | The resolved records (each has `uri`, `did`, `handle`, `value`) |
-| `viewer` | `{ did: string }` \| null | The authenticated user, or null |
-| `db.query` | function | Run SQL queries against DuckDB |
-| `getRecords` | function | Fetch records by URI from another collection |
-| `lookup` | function | Look up records by a field value (e.g. profiles by DID) |
-| `count` | function | Count records by field value |
-| `labels` | function | Query labels for a list of URIs |
-| `blobUrl` | function | Resolve a blob reference to a CDN URL |
+| Field        | Type                      | Description                                                     |
+| ------------ | ------------------------- | --------------------------------------------------------------- |
+| `items`      | `Row[]`                   | The resolved records (each has `uri`, `did`, `handle`, `value`) |
+| `viewer`     | `{ did: string }` \| null | The authenticated user, or null                                 |
+| `db.query`   | function                  | Run SQL queries against DuckDB                                  |
+| `getRecords` | function                  | Fetch records by URI from another collection                    |
+| `lookup`     | function                  | Look up records by a field value (e.g. profiles by DID)         |
+| `count`      | function                  | Count records by field value                                    |
+| `labels`     | function                  | Query labels for a list of URIs                                 |
+| `blobUrl`    | function                  | Resolve a blob reference to a CDN URL                           |
 
 ### Example
 

docs/site/src/content/docs/guides/hooks.mdx

···
 
 ### Context
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `did` | string | The DID of the user who just logged in |
+| Field        | Type     | Description                                              |
+| ------------ | -------- | -------------------------------------------------------- |
+| `did`        | string   | The DID of the user who just logged in                   |
 | `ensureRepo` | function | Marks the user's repo as pending and triggers a backfill |
 
 ### How `ensureRepo` works

docs/site/src/content/docs/guides/labels.mdx

···
 ```typescript
 import type { LabelRuleContext } from 'hatk/labels'
 
-const EXPLICIT_PATTERNS = [
-  /\(explicit\)/i,
-  /\[explicit\]/i,
-  /\bexplicit version\b/i,
-]
+const EXPLICIT_PATTERNS = [/\(explicit\)/i, /\[explicit\]/i, /\bexplicit version\b/i]
 
 export default {
   definition: {
···
 
 ## `LabelDefinition`
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `identifier` | string | Unique label ID |
-| `severity` | `'alert'` \| `'inform'` \| `'none'` | How urgently to surface the label |
-| `blurs` | `'media'` \| `'content'` \| `'none'` | What to blur when label is applied |
-| `defaultSetting` | `'warn'` \| `'hide'` \| `'ignore'` | Default user-facing behavior |
-| `locales` | array | Localized name and description |
+| Field            | Type                                 | Description                        |
+| ---------------- | ------------------------------------ | ---------------------------------- |
+| `identifier`     | string                               | Unique label ID                    |
+| `severity`       | `'alert'` \| `'inform'` \| `'none'`  | How urgently to surface the label  |
+| `blurs`          | `'media'` \| `'content'` \| `'none'` | What to blur when label is applied |
+| `defaultSetting` | `'warn'` \| `'hide'` \| `'ignore'`   | Default user-facing behavior       |
+| `locales`        | array                                | Localized name and description     |
 
 ## Evaluation context
 
 The `evaluate` function receives a `LabelRuleContext` with:
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `db.query` | function | Run SQL queries against DuckDB |
-| `db.run` | function | Execute SQL statements |
-| `record.uri` | string | AT URI of the record being evaluated |
-| `record.cid` | string | CID of the record |
-| `record.did` | string | DID of the record author |
-| `record.collection` | string | Collection NSID |
-| `record.value` | object | The record's fields |
+| Field               | Type     | Description                          |
+| ------------------- | -------- | ------------------------------------ |
+| `db.query`          | function | Run SQL queries against DuckDB       |
+| `db.run`            | function | Execute SQL statements               |
+| `record.uri`        | string   | AT URI of the record being evaluated |
+| `record.cid`        | string   | CID of the record                    |
+| `record.did`        | string   | DID of the record author             |
+| `record.collection` | string   | Collection NSID                      |
+| `record.value`      | object   | The record's fields                  |
 
 Label rules run automatically when records are indexed. Return an array of label identifier strings to apply, or an empty array to skip.
 
···
     const last = rows[rows.length - 1]
     return ctx.ok({
       uris: rows.map((r) => r.uri),
-      cursor: hasMore && last
-        ? ctx.packCursor(last.indexed_at, last.cid)
-        : undefined,
+      cursor: hasMore && last ? ctx.packCursor(last.indexed_at, last.cid) : undefined,
     })
   },
 
···
 
 The `ctx.labels()` method returns a `Map<string, Label[]>` where each label has:
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `src` | string | DID of the label creator |
-| `uri` | string | AT URI of the labeled resource |
-| `val` | string | Label identifier (e.g. `"explicit"`) |
-| `neg` | boolean | If true, this negates a previous label |
-| `cts` | string | Timestamp when the label was created |
-| `exp` | string \| null | Expiration timestamp |
+| Field | Type           | Description                            |
+| ----- | -------------- | -------------------------------------- |
+| `src` | string         | DID of the label creator               |
+| `uri` | string         | AT URI of the labeled resource         |
+| `val` | string         | Label identifier (e.g. `"explicit"`)   |
+| `neg` | boolean        | If true, this negates a previous label |
+| `cts` | string         | Timestamp when the label was created   |
+| `exp` | string \| null | Expiration timestamp                   |
 
 Only active labels are returned — expired labels and labels that have been negated are automatically filtered out.
 

docs/site/src/content/docs/guides/oauth.mdx

···
 
 ### Constructor options
 
-| Option | Default | Description |
-|--------|---------|-------------|
-| `server` | — | Hatk server URL |
-| `clientId` | `window.location.origin` | OAuth client ID (must match client metadata endpoint) |
-| `redirectUri` | current page URL | Where to redirect after authorization |
-| `scope` | `'atproto'` | OAuth scopes to request |
+| Option        | Default                  | Description                                           |
+| ------------- | ------------------------ | ----------------------------------------------------- |
+| `server`      | —                        | Hatk server URL                                       |
+| `clientId`    | `window.location.origin` | OAuth client ID (must match client metadata endpoint) |
+| `redirectUri` | current page URL         | Where to redirect after authorization                 |
+| `scope`       | `'atproto'`              | OAuth scopes to request                               |
 
 ### Scopes
 
···
 
 The OAuth flow uses these endpoints on your hatk server:
 
-| Endpoint | Purpose |
-|----------|---------|
-| `POST /oauth/par` | Pushed Authorization Request — initiates the flow |
-| `GET /oauth/authorize` | Redirects to the user's PDS |
-| `POST /oauth/token` | Exchanges authorization code for tokens |
-| `GET /oauth/jwks` | Public keys for token verification |
-| `GET /oauth/client-metadata.json` | Client metadata discovery |
+| Endpoint                          | Purpose                                           |
+| --------------------------------- | ------------------------------------------------- |
+| `POST /oauth/par`                 | Pushed Authorization Request — initiates the flow |
+| `GET /oauth/authorize`            | Redirects to the user's PDS                       |
+| `POST /oauth/token`               | Exchanges authorization code for tokens           |
+| `GET /oauth/jwks`                 | Public keys for token verification                |
+| `GET /oauth/client-metadata.json` | Client metadata discovery                         |
 
 All token requests include DPoP proofs (ECDSA P-256 key pairs stored in IndexedDB), which bind access tokens to the specific browser that requested them.
 

docs/site/src/content/docs/guides/opengraph.mdx

···
 This means your page routes and OG routes stay in sync automatically. If you have `og/artist.ts` with `path: '/og/artist/:name'`, then any visitor to `/artist/radiohead` gets meta tags injected:
 
 ```html
-<meta property="og:image" content="https://yourapp.com/og/artist/radiohead">
-<meta property="og:image:width" content="1200">
-<meta property="og:image:height" content="630">
-<meta name="twitter:card" content="summary_large_image">
+<meta property="og:image" content="https://yourapp.com/og/artist/radiohead" />
+<meta property="og:image:width" content="1200" />
+<meta property="og:image:height" content="630" />
+<meta name="twitter:card" content="summary_large_image" />
 ```
 
 ## The generate function
···
 
 The `generate` function receives an `OpengraphContext` with:
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `db.query` | function | Run SQL queries against DuckDB |
-| `params` | object | URL path parameters (e.g. `{ artist: 'Radiohead' }`) |
+| Field        | Type     | Description                                             |
+| ------------ | -------- | ------------------------------------------------------- |
+| `db.query`   | function | Run SQL queries against DuckDB                          |
+| `params`     | object   | URL path parameters (e.g. `{ artist: 'Radiohead' }`)    |
 | `fetchImage` | function | Fetch a remote image and return it as a base64 data URL |
-| `lookup` | function | Look up records by field value |
-| `count` | function | Count records by field value |
-| `labels` | function | Query labels for record URIs |
-| `blobUrl` | function | Resolve a blob reference to a CDN URL |
+| `lookup`     | function | Look up records by field value                          |
+| `count`      | function | Count records by field value                            |
+| `labels`     | function | Query labels for record URIs                            |
+| `blobUrl`    | function | Resolve a blob reference to a CDN URL                   |
 
 ### Return value
 
 Return an `OpengraphResult`:
 
-| Field | Required | Description |
-|-------|----------|-------------|
-| `element` | Yes | A satori virtual DOM tree (see below) |
-| `options` | No | Override `width` (default 1200), `height` (default 630), or provide custom `fonts` |
-| `meta` | No | `title` and `description` for the injected meta tags |
+| Field     | Required | Description                                                                        |
+| --------- | -------- | ---------------------------------------------------------------------------------- |
+| `element` | Yes      | A satori virtual DOM tree (see below)                                              |
+| `options` | No       | Override `width` (default 1200), `height` (default 630), or provide custom `fonts` |
+| `meta`    | No       | `title` and `description` for the injected meta tags                               |
 
 ### Virtual DOM
 
···
           children: [
             // Artist image
             ...(artUrl
-              ? [{
-                  type: 'img',
-                  props: {
-                    src: artUrl,
-                    width: 300,
-                    height: 300,
-                    style: { borderRadius: '20px', objectFit: 'cover' },
+              ? [
+                  {
+                    type: 'img',
+                    props: {
+                      src: artUrl,
+                      width: 300,
+                      height: 300,
+                      style: { borderRadius: '20px', objectFit: 'cover' },
+                    },
                   },
-                }]
+                ]
               : []),
             // Text content
             {

docs/site/src/content/docs/guides/seeds.mdx

···
 
 ## `seed()` helpers
 
-| Function | Description |
-|----------|-------------|
-| `createAccount(handle)` | Create a test account on the local PDS. Returns `{ did, handle }` |
-| `createRecord(account, collection, record, opts?)` | Create a record. Pass `{ rkey }` in opts for a specific record key |
-| `uploadBlob(account, filePath)` | Upload a file as a blob. Returns a blob reference for use in records |
+| Function                                           | Description                                                          |
+| -------------------------------------------------- | -------------------------------------------------------------------- |
+| `createAccount(handle)`                            | Create a test account on the local PDS. Returns `{ did, handle }`    |
+| `createRecord(account, collection, record, opts?)` | Create a record. Pass `{ rkey }` in opts for a specific record key   |
+| `uploadBlob(account, filePath)`                    | Upload a file as a blob. Returns a blob reference for use in records |
 
 ## Tips
 

docs/site/src/content/docs/guides/xrpc-handlers.mdx

···
 
 Both `defineQuery` and `defineProcedure` receive the same context:
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `db.query` | function | Run SQL queries against DuckDB |
-| `db.run` | function | Execute SQL statements |
-| `params` | object | Typed parameters from the lexicon schema |
-| `input` | object | Request body (procedures only), typed from the lexicon's input schema |
-| `limit` | number | Requested page size |
-| `cursor` | string \| undefined | Pagination cursor |
-| `viewer` | `{ did: string }` \| null | The authenticated user, or null |
-| `ok` | function | Wraps your return value with type checking |
-| `packCursor` | function | Encode a `(primary, cid)` pair into a cursor string |
-| `unpackCursor` | function | Decode a cursor back into `{ primary, cid }` |
-| `search` | function | Full-text search a collection |
-| `resolve` | function | Resolve AT URIs into full records |
-| `lookup` | function | Look up records by a field value |
-| `count` | function | Count records by field value |
-| `exists` | function | Check if a record exists matching field filters |
-| `labels` | function | Query labels for a list of URIs |
-| `blobUrl` | function | Resolve a blob reference to a CDN URL |
-| `isTakendown` | function | Check if a DID has been taken down |
-| `filterTakendownDids` | function | Filter a list of DIDs, returning those taken down |
+| Field                 | Type                      | Description                                                           |
+| --------------------- | ------------------------- | --------------------------------------------------------------------- |
+| `db.query`            | function                  | Run SQL queries against DuckDB                                        |
+| `db.run`              | function                  | Execute SQL statements                                                |
+| `params`              | object                    | Typed parameters from the lexicon schema                              |
+| `input`               | object                    | Request body (procedures only), typed from the lexicon's input schema |
+| `limit`               | number                    | Requested page size                                                   |
+| `cursor`              | string \| undefined       | Pagination cursor                                                     |
+| `viewer`              | `{ did: string }` \| null | The authenticated user, or null                                       |
+| `ok`                  | function                  | Wraps your return value with type checking                            |
+| `packCursor`          | function                  | Encode a `(primary, cid)` pair into a cursor string                   |
+| `unpackCursor`        | function                  | Decode a cursor back into `{ primary, cid }`                          |
+| `search`              | function                  | Full-text search a collection                                         |
+| `resolve`             | function                  | Resolve AT URIs into full records                                     |
+| `lookup`              | function                  | Look up records by a field value                                      |
+| `count`               | function                  | Count records by field value                                          |
+| `exists`              | function                  | Check if a record exists matching field filters                       |
+| `labels`              | function                  | Query labels for a list of URIs                                       |
+| `blobUrl`             | function                  | Resolve a blob reference to a CDN URL                                 |
+| `isTakendown`         | function                  | Check if a DID has been taken down                                    |
+| `filterTakendownDids` | function                  | Filter a list of DIDs, returning those taken down                     |
 
 ## Errors
 

packages/hatk/package.json

···
     "build": "vite build"
   },
   "dependencies": {
-    "@hatk/oauth-client": "*",
     "@bigmoves/lexicon": "^0.2.1",
     "@duckdb/node-api": "^1.4.4-r.1",
+    "@hatk/oauth-client": "*",
     "@resvg/resvg-js": "^2.6.2",
     "satori": "^0.19.2",
     "vitest": "^4",

packages/hatk/src/cli.ts

···
   try {
     const res = await fetch('http://localhost:2583/xrpc/_health')
     if (res.ok) return
-  } catch { }
+  } catch {}
   // Start it
   console.log('[dev] starting PDS...')
   execSync('docker compose up -d', { stdio: 'inherit', cwd: process.cwd() })
···
   for (let i = 0; i < 30; i++) {
     try {
       const res = await fetch('http://localhost:2583/xrpc/_health')
-      if (res.ok) { console.log('[dev] PDS ready'); return }
-    } catch { }
+      if (res.ok) {
+        console.log('[dev] PDS ready')
+        return
+      }
+    } catch {}
     await new Promise((r) => setTimeout(r, 1000))
   }
   console.error('[dev] PDS failed to start')
···
 
   const withSvelte = args.includes('--svelte')
   mkdirSync(dir)
-  const subs = ['lexicons', 'feeds', 'xrpc', 'og', 'labels', 'jobs', 'seeds', 'setup', 'public', 'test', 'test/feeds', 'test/xrpc', 'test/integration', 'test/browser', 'test/fixtures']
+  const subs = [
+    'lexicons',
+    'feeds',
+    'xrpc',
+    'og',
+    'labels',
+    'jobs',
+    'seeds',
+    'setup',
+    'public',
+    'test',
+    'test/feeds',
+    'test/xrpc',
+    'test/integration',
+    'test/browser',
+    'test/fixtures',
+  ]
   if (withSvelte) subs.push('src', 'src/routes', 'src/lib')
   for (const sub of subs) {
     mkdirSync(join(dir, sub))
···
     for (const { nsid, defType } of entries) {
       if (!defType) continue
       // createRecord/deleteRecord/putRecord get typed overrides after RecordRegistry
-      if (nsid === 'dev.hatk.createRecord' || nsid === 'dev.hatk.deleteRecord' || nsid === 'dev.hatk.putRecord') continue
+      if (nsid === 'dev.hatk.createRecord' || nsid === 'dev.hatk.deleteRecord' || nsid === 'dev.hatk.putRecord')
+        continue
       const varName = varNames.get(nsid)!
       const typeName = capitalize(varName)
       const wrapper = wrapperMap[defType]
···
               // Pattern 3: cross-namespace view — has explicit ref to a record-type lexicon
               if (!found) {
                 const recordRef = Object.values(def.properties).find(
-                  (p: any) => p.type === 'ref' && !p.ref.startsWith('#') && lexicons.get(p.ref)?.defs?.main?.type === 'record',
+                  (p: any) =>
+                    p.type === 'ref' && !p.ref.startsWith('#') && lexicons.get(p.ref)?.defs?.main?.type === 'record',
                 ) as any
                 if (recordRef) {
                   viewEntries.push({ fullNsid, typeName: name, collection: recordRef.ref })
···
   } else {
     const name = args[2]
     if (!type || !name || !templates[type]) {
-      console.error(`Usage: hatk generate <${[...Object.keys(templates), ...Object.keys(lexiconTemplates)].join('|')}|types> <name>`)
+      console.error(
+        `Usage: hatk generate <${[...Object.keys(templates), ...Object.keys(lexiconTemplates)].join('|')}|types> <name>`,
+      )
       process.exit(1)
     }
 
···
     console.log('[check] tsc (server)...')
     try {
       execSync('npx tsc --noEmit -p tsconfig.server.json', { stdio: 'inherit', cwd: process.cwd() })
-    } catch { failed = true }
+    } catch {
+      failed = true
+    }
   }
 
   // Svelte type checking (if SvelteKit project)
   if (existsSync(resolve('svelte.config.js')) && existsSync(resolve('src/app.html'))) {
     console.log('[check] svelte-check...')
     try {
-      execSync('npx svelte-kit sync && npx svelte-check --tsconfig ./tsconfig.json', { stdio: 'inherit', cwd: process.cwd() })
-    } catch { failed = true }
+      execSync('npx svelte-kit sync && npx svelte-check --tsconfig ./tsconfig.json', {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      })
+    } catch {
+      failed = true
+    }
   }
 
   // Lint
   console.log('[check] oxlint...')
   try {
     execSync('npx oxlint .', { stdio: 'inherit', cwd: process.cwd() })
-  } catch { failed = true }
+  } catch {
+    failed = true
+  }
 
   if (failed) process.exit(1)
 } else if (command === 'test') {
   const knownFlags = new Set(['--unit', '--integration', '--browser', '--verbose'])
   const parsedFlags = args.slice(1).filter((a) => knownFlags.has(a))
-  const extraArgs = args.slice(1).filter((a) => !knownFlags.has(a)).join(' ')
+  const extraArgs = args
+    .slice(1)
+    .filter((a) => !knownFlags.has(a))
+    .join(' ')
   const flag = parsedFlags.find((f) => f !== '--verbose') || null
   const verbose = parsedFlags.includes('--verbose')
   if (!verbose && !process.env.DEBUG) process.env.DEBUG = '0'
···
 
   if (runBrowser) {
     const browserDir = resolve(process.cwd(), 'test/browser')
-    const hasBrowserTests = existsSync(browserDir) && readdirSync(browserDir).some((f) => f.endsWith('.test.ts') || f.endsWith('.spec.ts'))
+    const hasBrowserTests =
+      existsSync(browserDir) && readdirSync(browserDir).some((f) => f.endsWith('.test.ts') || f.endsWith('.spec.ts'))
     if (hasBrowserTests) {
       console.log('[test] running browser tests...')
       try {
···
   const instance = await DuckDBInstance.create(config.database)
   const con = await instance.connect()
 
-  const tables = (await (await con.runAndReadAll(
-    `SELECT table_name FROM information_schema.tables WHERE table_schema = 'main' ORDER BY table_name`,
-  )).getRowObjects()) as { table_name: string }[]
+  const tables = (await (
+    await con.runAndReadAll(
+      `SELECT table_name FROM information_schema.tables WHERE table_schema = 'main' ORDER BY table_name`,
+    )
+  ).getRowObjects()) as { table_name: string }[]
 
   for (const { table_name } of tables) {
     console.log(`"${table_name}"`)
-    const cols = (await (await con.runAndReadAll(
-      `SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_name = '${table_name}' ORDER BY ordinal_position`,
-    )).getRowObjects()) as { column_name: string; data_type: string; is_nullable: string }[]
+    const cols = (await (
+      await con.runAndReadAll(
+        `SELECT column_name, data_type, is_nullable FROM information_schema.columns WHERE table_name = '${table_name}' ORDER BY ordinal_position`,
+      )
+    ).getRowObjects()) as { column_name: string; data_type: string; is_nullable: string }[]
 
     for (const col of cols) {
       const nullable = col.is_nullable === 'YES' ? '' : ' NOT NULL'

packages/hatk/src/db.ts

···
 const schemas = new Map<string, TableSchema>()
 
 export function closeDatabase(): void {
-  try { readCon?.closeSync() } catch {}
-  try { con?.closeSync() } catch {}
-  try { instance?.closeSync() } catch {}
+  try {
+    readCon?.closeSync()
+  } catch {}
+  try {
+    con?.closeSync()
+  } catch {}
+  try {
+    instance?.closeSync()
+  } catch {}
 }
 
 let writeQueue = Promise.resolve()
···
     const unionValue = record[union.fieldName]
     if (!unionValue || !unionValue.$type) continue
 
-    const branch = union.branches.find(b => b.type === unionValue.$type)
+    const branch = union.branches.find((b) => b.type === unionValue.$type)
     if (!branch) continue
 
     // Delete existing branch rows (handles INSERT OR REPLACE)
···
 
         // Delete existing child rows for these URIs, then merge staging
         const uriPlaceholders = recs.map((_, i) => `$${i + 1}`).join(',')
-        const delStmt = await con.prepare(
-          `DELETE FROM ${child.tableName} WHERE parent_uri IN (${uriPlaceholders})`,
+        const delStmt = await con.prepare(`DELETE FROM ${child.tableName} WHERE parent_uri IN (${uriPlaceholders})`)
+        bindParams(
+          delStmt,
+          recs.map((r) => r.uri),
         )
-        bindParams(delStmt, recs.map((r) => r.uri))
         await delStmt.run()
 
         const childSelectCols = childAllCols.map((name) => {
···
 
           // Delete existing branch rows for these URIs, then merge staging
           const uriPlaceholders = recs.map((_, i) => `$${i + 1}`).join(',')
-          const delStmt = await con.prepare(
-            `DELETE FROM ${branch.tableName} WHERE parent_uri IN (${uriPlaceholders})`,
+          const delStmt = await con.prepare(`DELETE FROM ${branch.tableName} WHERE parent_uri IN (${uriPlaceholders})`)
+          bindParams(
+            delStmt,
+            recs.map((r) => r.uri),
           )
-          bindParams(delStmt, recs.map((r) => r.uri))
           await delStmt.run()
 
           const branchSelectCols = branchAllCols.map((name) => {
···
       childData.set(child.fieldName, childRows)
     }
     for (const row of rows) {
-      (row as any).__childData = childData
+      ;(row as any).__childData = childData
     }
   }
 
···
       unionData.set(union.fieldName, branchData)
     }
     for (const row of rows) {
-      (row as any).__unionData = unionData
+      ;(row as any).__unionData = unionData
     }
   }
 
···
 
   // Attach child data to rows for reshapeRow
   for (const row of rows) {
-    (row as any).__childData = childData
+    ;(row as any).__childData = childData
     if (unionData.size > 0) (row as any).__unionData = unionData
   }
 
···
       childData.set(child.fieldName, childRows)
     }
     for (const row of rows) {
-      (row as any).__childData = childData
+      ;(row as any).__childData = childData
     }
   }
 
···
   return v
 }
 
-export async function getChildRows(
-  childTableName: string,
-  parentUris: string[],
-): Promise<Map<string, any[]>> {
+export async function getChildRows(childTableName: string, parentUris: string[]): Promise<Map<string, any[]>> {
   if (parentUris.length === 0) return new Map()
   const placeholders = parentUris.map((_, i) => `$${i + 1}`).join(',')
-  const rows = await all(
-    `SELECT * FROM ${childTableName} WHERE parent_uri IN (${placeholders})`,
-    ...parentUris,
-  )
+  const rows = await all(`SELECT * FROM ${childTableName} WHERE parent_uri IN (${placeholders})`, ...parentUris)
   const result = new Map<string, any[]>()
   for (const row of rows) {
     const key = row.parent_uri as string
···
 }
 
 export async function backfillChildTables(): Promise<void> {
-  for (const [collection, schema] of schemas) {
+  for (const [, schema] of schemas) {
     for (const child of schema.children) {
       // Check if child table needs backfill (significantly fewer rows than parent)
       const mainCount = (await all(`SELECT COUNT(*)::INTEGER as n FROM ${schema.tableName}`))[0]?.n || 0
       if (mainCount === 0) continue
-      const childCount = (await all(`SELECT COUNT(DISTINCT parent_uri)::INTEGER as n FROM ${child.tableName}`))[0]?.n || 0
+      const childCount =
+        (await all(`SELECT COUNT(DISTINCT parent_uri)::INTEGER as n FROM ${child.tableName}`))[0]?.n || 0
       if (childCount >= mainCount * 0.9) continue
 
       console.log(`[db] Backfilling ${child.tableName} from ${schema.tableName}...`)

packages/hatk/src/feeds.ts

···
 
 // --- Typed feed helper ---
 
-type FeedGenerate = (ctx: FeedContext & { ok: (value: FeedResult) => Checked<FeedResult> }) => Promise<Checked<FeedResult>>
+type FeedGenerate = (
+  ctx: FeedContext & { ok: (value: FeedResult) => Checked<FeedResult> },
+) => Promise<Checked<FeedResult>>
 
 type FeedOpts =
-  | { collection: string; view?: string; label: string; generate: FeedGenerate; hydrate?: (ctx: HydrateContext<any>) => Promise<unknown[]> }
-  | { collection?: never; view?: never; label: string; generate: FeedGenerate; hydrate: (ctx: HydrateContext<any>) => Promise<unknown[]> }
+  | {
+      collection: string
+      view?: string
+      label: string
+      generate: FeedGenerate
+      hydrate?: (ctx: HydrateContext<any>) => Promise<unknown[]>
+    }
+  | {
+      collection?: never
+      view?: never
+      label: string
+      generate: FeedGenerate
+      hydrate: (ctx: HydrateContext<any>) => Promise<unknown[]>
+    }
 
 export function createPaginate(deps: {
   db: { query: (sql: string, params?: any[]) => Promise<any[]> }
···
 
   return { uris: result.uris, cursor: result.cursor }
 }
-
 
 export function listFeeds(): { name: string; label: string }[] {
   return Array.from(feeds.values()).map((f) => ({ name: f.name, label: f.label }))

packages/hatk/src/fts.ts

···
  */
 // DuckDB's built-in English stop words (571 words) — must match stopwords='english' in create_fts_index
 const ENGLISH_STOP_WORDS = new Set([
-  "a","a's","able","about","above","according","accordingly","across","actually","after","afterwards","again","against","ain't","all","allow","allows","almost","alone","along","already","also","although","always","am","among","amongst","an","and","another","any","anybody","anyhow","anyone","anything","anyway","anyways","anywhere","apart","appear","appreciate","appropriate","are","aren't","around","as","aside","ask","asking","associated","at","available","away","awfully","b","be","became","because","become","becomes","becoming","been","before","beforehand","behind","being","believe","below","beside","besides","best","better","between","beyond","both","brief","but","by","c","c'mon","c's","came","can","can't","cannot","cant","cause","causes","certain","certainly","changes","clearly","co","com","come","comes","concerning","consequently","consider","considering","contain","containing","contains","corresponding","could","couldn't","course","currently","d","definitely","described","despite","did","didn't","different","do","does","doesn't","doing","don't","done","down","downwards","during","e","each","edu","eg","eight","either","else","elsewhere","enough","entirely","especially","et","etc","even","ever","every","everybody","everyone","everything","everywhere","ex","exactly","example","except","f","far","few","fifth","first","five","followed","following","follows","for","former","formerly","forth","four","from","further","furthermore","g","get","gets","getting","given","gives","go","goes","going","gone","got","gotten","greetings","h","had","hadn't","happens","hardly","has","hasn't","have","haven't","having","he","he's","hello","help","hence","her","here","here's","hereafter","hereby","herein","hereupon","hers","herself","hi","him","himself","his","hither","hopefully","how","howbeit","however","i","i'd","i'll","i'm","i've","ie","if","ignored","immediate","in","inasmuch","inc","indeed","indicate","indicated","indicates","inner","insofar","instead","into","inward","is","isn't","it","it'd","it'll","it's","its","itself","j","just","k","keep","keeps","kept","know","known","knows","l","last","lately","later","latter","latterly","least","less","lest","let","let's","like","liked","likely","little","look","looking","looks","ltd","m","mainly","many","may","maybe","me","mean","meanwhile","merely","might","more","moreover","most","mostly","much","must","my","myself","n","name","namely","nd","near","nearly","necessary","need","needs","neither","never","nevertheless","new","next","nine","no","nobody","non","none","noone","nor","normally","not","nothing","novel","now","nowhere","o","obviously","of","off","often","oh","ok","okay","old","on","once","one","ones","only","onto","or","other","others","otherwise","ought","our","ours","ourselves","out","outside","over","overall","own","p","particular","particularly","per","perhaps","placed","please","plus","possible","presumably","probably","provides","q","que","quite","qv","r","rather","rd","re","really","reasonably","regarding","regardless","regards","relatively","respectively","right","s","said","same","saw","say","saying","says","second","secondly","see","seeing","seem","seemed","seeming","seems","seen","self","selves","sensible","sent","serious","seriously","seven","several","shall","she","should","shouldn't","since","six","so","some","somebody","somehow","someone","something","sometime","sometimes","somewhat","somewhere","soon","sorry","specified","specify","specifying","still","sub","such","sup","sure","t","t's","take","taken","tell","tends","th","than","thank","thanks","thanx","that","that's","thats","the","their","theirs","them","themselves","then","thence","there","there's","thereafter","thereby","therefore","therein","theres","thereupon","these","they","they'd","they'll","they're","they've","think","third","this","thorough","thoroughly","those","though","three","through","throughout","thru","thus","to","together","too","took","toward","towards","tried","tries","truly","try","trying","twice","two","u","un","under","unfortunately","unless","unlikely","until","unto","up","upon","us","use","used","useful","uses","using","usually","uucp","v","value","various","very","via","viz","vs","w","want","wants","was","wasn't","way","we","we'd","we'll","we're","we've","welcome","well","went","were","weren't","what","what's","whatever","when","whence","whenever","where","where's","whereafter","whereas","whereby","wherein","whereupon","wherever","whether","which","while","whither","who","who's","whoever","whole","whom","whose","why","will","willing","wish","with","within","without","won't","wonder","would","would","wouldn't","x","y","yes","yet","you","you'd","you'll","you're","you've","your","yours","yourself","yourselves","z","zero",
+  'a',
+  "a's",
+  'able',
+  'about',
+  'above',
+  'according',
+  'accordingly',
+  'across',
+  'actually',
+  'after',
+  'afterwards',
+  'again',
+  'against',
+  "ain't",
+  'all',
+  'allow',
+  'allows',
+  'almost',
+  'alone',
+  'along',
+  'already',
+  'also',
+  'although',
+  'always',
+  'am',
+  'among',
+  'amongst',
+  'an',
+  'and',
+  'another',
+  'any',
+  'anybody',
+  'anyhow',
+  'anyone',
+  'anything',
+  'anyway',
+  'anyways',
+  'anywhere',
+  'apart',
+  'appear',
+  'appreciate',
+  'appropriate',
+  'are',
+  "aren't",
+  'around',
+  'as',
+  'aside',
+  'ask',
+  'asking',
+  'associated',
+  'at',
+  'available',
+  'away',
+  'awfully',
+  'b',
+  'be',
+  'became',
+  'because',
+  'become',
+  'becomes',
+  'becoming',
+  'been',
+  'before',
+  'beforehand',
+  'behind',
+  'being',
+  'believe',
+  'below',
+  'beside',
+  'besides',
+  'best',
+  'better',
+  'between',
+  'beyond',
+  'both',
+  'brief',
+  'but',
+  'by',
+  'c',
+  "c'mon",
+  "c's",
+  'came',
+  'can',
+  "can't",
+  'cannot',
+  'cant',
+  'cause',
+  'causes',
+  'certain',
+  'certainly',
+  'changes',
+  'clearly',
+  'co',
+  'com',
+  'come',
+  'comes',
+  'concerning',
+  'consequently',
+  'consider',
+  'considering',
+  'contain',
+  'containing',
+  'contains',
+  'corresponding',
+  'could',
+  "couldn't",
+  'course',
+  'currently',
+  'd',
+  'definitely',
+  'described',
+  'despite',
+  'did',
+  "didn't",
+  'different',
+  'do',
+  'does',
+  "doesn't",
+  'doing',
+  "don't",
+  'done',
+  'down',
+  'downwards',
+  'during',
+  'e',
+  'each',
+  'edu',
+  'eg',
+  'eight',
+  'either',
+  'else',
+  'elsewhere',
+  'enough',
+  'entirely',
+  'especially',
+  'et',
+  'etc',
+  'even',
+  'ever',
+  'every',
+  'everybody',
+  'everyone',
+  'everything',
+  'everywhere',
+  'ex',
+  'exactly',
+  'example',
+  'except',
+  'f',
+  'far',
+  'few',
+  'fifth',
+  'first',
+  'five',
+  'followed',
+  'following',
+  'follows',
+  'for',
+  'former',
+  'formerly',
+  'forth',
+  'four',
+  'from',
+  'further',
+  'furthermore',
+  'g',
+  'get',
+  'gets',
+  'getting',
+  'given',
+  'gives',
+  'go',
+  'goes',
+  'going',
+  'gone',
+  'got',
+  'gotten',
+  'greetings',
+  'h',
+  'had',
+  "hadn't",
+  'happens',
+  'hardly',
+  'has',
+  "hasn't",
+  'have',
+  "haven't",
+  'having',
+  'he',
+  "he's",
+  'hello',
+  'help',
+  'hence',
+  'her',
+  'here',
+  "here's",
+  'hereafter',
+  'hereby',
+  'herein',
+  'hereupon',
+  'hers',
+  'herself',
+  'hi',
+  'him',
+  'himself',
+  'his',
+  'hither',
+  'hopefully',
+  'how',
+  'howbeit',
+  'however',
+  'i',
+  "i'd",
+  "i'll",
+  "i'm",
+  "i've",
+  'ie',
+  'if',
+  'ignored',
+  'immediate',
+  'in',
+  'inasmuch',
+  'inc',
+  'indeed',
+  'indicate',
+  'indicated',
+  'indicates',
+  'inner',
+  'insofar',
+  'instead',
+  'into',
+  'inward',
+  'is',
+  "isn't",
+  'it',
+  "it'd",
+  "it'll",
+  "it's",
+  'its',
+  'itself',
+  'j',
+  'just',
+  'k',
+  'keep',
+  'keeps',
+  'kept',
+  'know',
+  'known',
+  'knows',
+  'l',
+  'last',
+  'lately',
+  'later',
+  'latter',
+  'latterly',
+  'least',
+  'less',
+  'lest',
+  'let',
+  "let's",
+  'like',
+  'liked',
+  'likely',
+  'little',
+  'look',
+  'looking',
+  'looks',
+  'ltd',
+  'm',
+  'mainly',
+  'many',
+  'may',
+  'maybe',
+  'me',
+  'mean',
+  'meanwhile',
+  'merely',
+  'might',
+  'more',
+  'moreover',
+  'most',
+  'mostly',
+  'much',
+  'must',
+  'my',
+  'myself',
+  'n',
+  'name',
+  'namely',
+  'nd',
+  'near',
+  'nearly',
+  'necessary',
+  'need',
+  'needs',
+  'neither',
+  'never',
+  'nevertheless',
+  'new',
+  'next',
+  'nine',
+  'no',
+  'nobody',
+  'non',
+  'none',
+  'noone',
+  'nor',
+  'normally',
+  'not',
+  'nothing',
+  'novel',
+  'now',
+  'nowhere',
+  'o',
+  'obviously',
+  'of',
+  'off',
+  'often',
+  'oh',
+  'ok',
+  'okay',
+  'old',
+  'on',
+  'once',
+  'one',
+  'ones',
+  'only',
+  'onto',
+  'or',
+  'other',
+  'others',
+  'otherwise',
+  'ought',
+  'our',
+  'ours',
+  'ourselves',
+  'out',
+  'outside',
+  'over',
+  'overall',
+  'own',
+  'p',
+  'particular',
+  'particularly',
+  'per',
+  'perhaps',
+  'placed',
+  'please',
+  'plus',
+  'possible',
+  'presumably',
+  'probably',
+  'provides',
+  'q',
+  'que',
+  'quite',
+  'qv',
+  'r',
+  'rather',
+  'rd',
+  're',
+  'really',
+  'reasonably',
+  'regarding',
+  'regardless',
+  'regards',
+  'relatively',
+  'respectively',
+  'right',
+  's',
+  'said',
+  'same',
+  'saw',
+  'say',
+  'saying',
+  'says',
+  'second',
+  'secondly',
+  'see',
+  'seeing',
+  'seem',
+  'seemed',
+  'seeming',
+  'seems',
+  'seen',
+  'self',
+  'selves',
+  'sensible',
+  'sent',
+  'serious',
+  'seriously',
+  'seven',
+  'several',
+  'shall',
+  'she',
+  'should',
+  "shouldn't",
+  'since',
+  'six',
+  'so',
+  'some',
+  'somebody',
+  'somehow',
+  'someone',
+  'something',
+  'sometime',
+  'sometimes',
+  'somewhat',
+  'somewhere',
+  'soon',
+  'sorry',
+  'specified',
+  'specify',
+  'specifying',
+  'still',
+  'sub',
+  'such',
+  'sup',
+  'sure',
+  't',
+  "t's",
+  'take',
+  'taken',
+  'tell',
+  'tends',
+  'th',
+  'than',
+  'thank',
+  'thanks',
+  'thanx',
+  'that',
+  "that's",
+  'thats',
+  'the',
+  'their',
+  'theirs',
+  'them',
+  'themselves',
+  'then',
+  'thence',
+  'there',
+  "there's",
+  'thereafter',
+  'thereby',
+  'therefore',
+  'therein',
+  'theres',
+  'thereupon',
+  'these',
+  'they',
+  "they'd",
+  "they'll",
+  "they're",
+  "they've",
+  'think',
+  'third',
+  'this',
+  'thorough',
+  'thoroughly',
+  'those',
+  'though',
+  'three',
+  'through',
+  'throughout',
+  'thru',
+  'thus',
+  'to',
+  'together',
+  'too',
+  'took',
+  'toward',
+  'towards',
+  'tried',
+  'tries',
+  'truly',
+  'try',
+  'trying',
+  'twice',
+  'two',
+  'u',
+  'un',
+  'under',
+  'unfortunately',
+  'unless',
+  'unlikely',
+  'until',
+  'unto',
+  'up',
+  'upon',
+  'us',
+  'use',
+  'used',
+  'useful',
+  'uses',
+  'using',
+  'usually',
+  'uucp',
+  'v',
+  'value',
+  'various',
+  'very',
+  'via',
+  'viz',
+  'vs',
+  'w',
+  'want',
+  'wants',
+  'was',
+  "wasn't",
+  'way',
+  'we',
+  "we'd",
+  "we'll",
+  "we're",
+  "we've",
+  'welcome',
+  'well',
+  'went',
+  'were',
+  "weren't",
+  'what',
+  "what's",
+  'whatever',
+  'when',
+  'whence',
+  'whenever',
+  'where',
+  "where's",
+  'whereafter',
+  'whereas',
+  'whereby',
+  'wherein',
+  'whereupon',
+  'wherever',
+  'whether',
+  'which',
+  'while',
+  'whither',
+  'who',
+  "who's",
+  'whoever',
+  'whole',
+  'whom',
+  'whose',
+  'why',
+  'will',
+  'willing',
+  'wish',
+  'with',
+  'within',
+  'without',
+  "won't",
+  'wonder',
+  'would',
+  'would',
+  "wouldn't",
+  'x',
+  'y',
+  'yes',
+  'yet',
+  'you',
+  "you'd",
+  "you'll",
+  "you're",
+  "you've",
+  'your',
+  'yours',
+  'yourself',
+  'yourselves',
+  'z',
+  'zero',
 ])
 
 /**

packages/hatk/src/hydrate.ts

···
   }
 
   // Return in original URI order, reshaped
-  return uris.map((uri) => {
-    const row = primaryRecords.get(uri)
-    return reshapeRow(row, row?.__childData, row?.__unionData)
-  }).filter((r): r is Row<unknown> => r != null)
+  return uris
+    .map((uri) => {
+      const row = primaryRecords.get(uri)
+      return reshapeRow(row, row?.__childData, row?.__unionData)
+    })
+    .filter((r): r is Row<unknown> => r != null)
 }
 
 // --- Context Builder ---

packages/hatk/src/lexicon-resolve.ts

···
     const data = await response.json()
     if (!data.Answer) return []
 
-    return data.Answer
-      .filter((record: any) => record.type === 16)
-      .map((record: any) => (record.data?.replace(/^"|"$/g, '') ?? ''))
+    return data.Answer.filter((record: any) => record.type === 16).map(
+      (record: any) => record.data?.replace(/^"|"$/g, '') ?? '',
+    )
   } catch {
     return []
   }
···
 
 function extractPdsEndpoint(didDoc: any): string | null {
   if (!didDoc?.service || !Array.isArray(didDoc.service)) return null
-  const pdsService = didDoc.service.find(
-    (s: any) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer',
-  )
+  const pdsService = didDoc.service.find((s: any) => s.id === '#atproto_pds' || s.type === 'AtprotoPersonalDataServer')
   return pdsService?.serviceEndpoint ?? null
 }
 
···
 // --- Built-in core schemas (not published via DNS) ---
 
 const coreSchemas: Record<string, Lexicon> = {
-  'com.atproto.repo.strongRef': {"lexicon":1,"id":"com.atproto.repo.strongRef","description":"A URI with a content-hash fingerprint.","defs":{"main":{"type":"object","required":["uri","cid"],"properties":{"uri":{"type":"string","format":"at-uri"},"cid":{"type":"string","format":"cid"}}}}},
-  'com.atproto.label.defs': {"lexicon":1,"id":"com.atproto.label.defs","defs":{"label":{"type":"object","description":"Metadata tag on an atproto resource (eg, repo or record).","required":["src","uri","val","cts"],"properties":{"ver":{"type":"integer"},"src":{"type":"string","format":"did"},"uri":{"type":"string","format":"uri"},"cid":{"type":"string","format":"cid"},"val":{"type":"string","maxLength":128},"neg":{"type":"boolean"},"cts":{"type":"string","format":"datetime"},"exp":{"type":"string","format":"datetime"},"sig":{"type":"bytes"}}},"selfLabels":{"type":"object","description":"Metadata tags on an atproto record, published by the author within the record.","required":["values"],"properties":{"values":{"type":"array","items":{"type":"ref","ref":"#selfLabel"},"maxLength":10}}},"selfLabel":{"type":"object","required":["val"],"properties":{"val":{"type":"string","maxLength":128}}},"labelValueDefinition":{"type":"object","description":"Declares a label value and its expected interpretations and behaviors.","required":["identifier","severity","blurs","locales"],"properties":{"identifier":{"type":"string","maxLength":100},"severity":{"type":"string","knownValues":["inform","alert","none"]},"blurs":{"type":"string","knownValues":["content","media","none"]},"defaultSetting":{"type":"string","knownValues":["ignore","warn","hide"]},"adultOnly":{"type":"boolean"},"locales":{"type":"array","items":{"type":"ref","ref":"#labelValueDefinitionStrings"}}}},"labelValueDefinitionStrings":{"type":"object","required":["lang","name","description"],"properties":{"lang":{"type":"string","format":"language"},"name":{"type":"string","maxLength":640},"description":{"type":"string","maxLength":100000}}},"labelValue":{"type":"string","knownValues":["!hide","!no-promote","!warn","!no-unauthenticated","dmca-violation","doxxing","porn","sexual","nudity","nsfl","gore"]}}},
-  'com.atproto.moderation.defs': {"lexicon":1,"id":"com.atproto.moderation.defs","defs":{"reasonType":{"type":"string","knownValues":["com.atproto.moderation.defs#reasonSpam","com.atproto.moderation.defs#reasonViolation","com.atproto.moderation.defs#reasonMisleading","com.atproto.moderation.defs#reasonSexual","com.atproto.moderation.defs#reasonRude","com.atproto.moderation.defs#reasonOther","com.atproto.moderation.defs#reasonAppeal"]},"reasonSpam":{"type":"token","description":"Spam: frequent unwanted promotion, replies, mentions."},"reasonViolation":{"type":"token","description":"Direct violation of server rules, laws, terms of service."},"reasonMisleading":{"type":"token","description":"Misleading identity, affiliation, or content."},"reasonSexual":{"type":"token","description":"Unwanted or mislabeled sexual content."},"reasonRude":{"type":"token","description":"Rude, harassing, explicit, or otherwise unwelcoming behavior."},"reasonOther":{"type":"token","description":"Reports not falling under another report category."},"reasonAppeal":{"type":"token","description":"Appeal a previously taken moderation action."},"subjectType":{"type":"string","description":"Tag describing a type of subject that might be reported.","knownValues":["account","record","chat"]}}},
+  'com.atproto.repo.strongRef': {
+    lexicon: 1,
+    id: 'com.atproto.repo.strongRef',
+    description: 'A URI with a content-hash fingerprint.',
+    defs: {
+      main: {
+        type: 'object',
+        required: ['uri', 'cid'],
+        properties: { uri: { type: 'string', format: 'at-uri' }, cid: { type: 'string', format: 'cid' } },
+      },
+    },
+  },
+  'com.atproto.label.defs': {
+    lexicon: 1,
+    id: 'com.atproto.label.defs',
+    defs: {
+      label: {
+        type: 'object',
+        description: 'Metadata tag on an atproto resource (eg, repo or record).',
+        required: ['src', 'uri', 'val', 'cts'],
+        properties: {
+          ver: { type: 'integer' },
+          src: { type: 'string', format: 'did' },
+          uri: { type: 'string', format: 'uri' },
+          cid: { type: 'string', format: 'cid' },
+          val: { type: 'string', maxLength: 128 },
+          neg: { type: 'boolean' },
+          cts: { type: 'string', format: 'datetime' },
+          exp: { type: 'string', format: 'datetime' },
+          sig: { type: 'bytes' },
+        },
+      },
+      selfLabels: {
+        type: 'object',
+        description: 'Metadata tags on an atproto record, published by the author within the record.',
+        required: ['values'],
+        properties: { values: { type: 'array', items: { type: 'ref', ref: '#selfLabel' }, maxLength: 10 } },
+      },
+      selfLabel: { type: 'object', required: ['val'], properties: { val: { type: 'string', maxLength: 128 } } },
+      labelValueDefinition: {
+        type: 'object',
+        description: 'Declares a label value and its expected interpretations and behaviors.',
+        required: ['identifier', 'severity', 'blurs', 'locales'],
+        properties: {
+          identifier: { type: 'string', maxLength: 100 },
+          severity: { type: 'string', knownValues: ['inform', 'alert', 'none'] },
+          blurs: { type: 'string', knownValues: ['content', 'media', 'none'] },
+          defaultSetting: { type: 'string', knownValues: ['ignore', 'warn', 'hide'] },
+          adultOnly: { type: 'boolean' },
+          locales: { type: 'array', items: { type: 'ref', ref: '#labelValueDefinitionStrings' } },
+        },
+      },
+      labelValueDefinitionStrings: {
+        type: 'object',
+        required: ['lang', 'name', 'description'],
+        properties: {
+          lang: { type: 'string', format: 'language' },
+          name: { type: 'string', maxLength: 640 },
+          description: { type: 'string', maxLength: 100000 },
+        },
+      },
+      labelValue: {
+        type: 'string',
+        knownValues: [
+          '!hide',
+          '!no-promote',
+          '!warn',
+          '!no-unauthenticated',
+          'dmca-violation',
+          'doxxing',
+          'porn',
+          'sexual',
+          'nudity',
+          'nsfl',
+          'gore',
+        ],
+      },
+    },
+  },
+  'com.atproto.moderation.defs': {
+    lexicon: 1,
+    id: 'com.atproto.moderation.defs',
+    defs: {
+      reasonType: {
+        type: 'string',
+        knownValues: [
+          'com.atproto.moderation.defs#reasonSpam',
+          'com.atproto.moderation.defs#reasonViolation',
+          'com.atproto.moderation.defs#reasonMisleading',
+          'com.atproto.moderation.defs#reasonSexual',
+          'com.atproto.moderation.defs#reasonRude',
+          'com.atproto.moderation.defs#reasonOther',
+          'com.atproto.moderation.defs#reasonAppeal',
+        ],
+      },
+      reasonSpam: { type: 'token', description: 'Spam: frequent unwanted promotion, replies, mentions.' },
+      reasonViolation: { type: 'token', description: 'Direct violation of server rules, laws, terms of service.' },
+      reasonMisleading: { type: 'token', description: 'Misleading identity, affiliation, or content.' },
+      reasonSexual: { type: 'token', description: 'Unwanted or mislabeled sexual content.' },
+      reasonRude: { type: 'token', description: 'Rude, harassing, explicit, or otherwise unwelcoming behavior.' },
+      reasonOther: { type: 'token', description: 'Reports not falling under another report category.' },
+      reasonAppeal: { type: 'token', description: 'Appeal a previously taken moderation action.' },
+      subjectType: {
+        type: 'string',
+        description: 'Tag describing a type of subject that might be reported.',
+        knownValues: ['account', 'record', 'chat'],
+      },
+    },
+  },
 }
 
 // --- Resolver ---

packages/hatk/src/oauth/discovery.ts

···
   return res.json()
 }
 
-export async function discoverAuthServer(did: string, plcUrl: string): Promise<{
+export async function discoverAuthServer(
+  did: string,
+  plcUrl: string,
+): Promise<{
   pdsEndpoint: string
   authServerEndpoint: string
   authServerMetadata: AuthServerMetadata
···
 }
 
 export async function resolveHandle(handle: string, relayUrl?: string): Promise<string> {
-  const baseUrl = relayUrl?.includes('localhost:2583')
-    ? 'http://localhost:2583'
-    : 'https://bsky.social'
-  const res = await fetch(
-    `${baseUrl}/xrpc/com.atproto.identity.resolveHandle?handle=${encodeURIComponent(handle)}`,
-  )
+  const baseUrl = relayUrl?.includes('localhost:2583') ? 'http://localhost:2583' : 'https://bsky.social'
+  const res = await fetch(`${baseUrl}/xrpc/com.atproto.identity.resolveHandle?handle=${encodeURIComponent(handle)}`)
   if (!res.ok) throw new Error(`resolveHandle failed: ${res.status}`)
   const data = await res.json()
   return data.did

packages/hatk/src/oauth/server.ts

···
 const SERVER_KEY_KID = 'appview-oauth-key'
 
 async function resolveHandleForDid(did: string): Promise<string | undefined> {
-  const rows = await querySQL('SELECT handle FROM _repos WHERE did = $1', [did]) as { handle: string }[]
+  const rows = (await querySQL('SELECT handle FROM _repos WHERE did = $1', [did])) as { handle: string }[]
   return rows[0]?.handle || undefined
 }
 

packages/hatk/src/schema.ts

···
 }
 
 export interface UnionBranchSchema {
-  type: string           // full $type string (e.g., 'app.bsky.embed.images')
-  branchName: string     // short name for table suffix (e.g., 'images')
-  tableName: string      // quoted table name
-  columns: ColumnDef[]   // branch properties as columns
-  isArray: boolean       // true if the branch wraps an array of objects
-  arrayField?: string    // if isArray, the property name containing the array
-  wrapperField?: string  // if set, data is nested under this key (e.g., 'external' for embed.external)
+  type: string // full $type string (e.g., 'app.bsky.embed.images')
+  branchName: string // short name for table suffix (e.g., 'images')
+  tableName: string // quoted table name
+  columns: ColumnDef[] // branch properties as columns
+  isArray: boolean // true if the branch wraps an array of objects
+  arrayField?: string // if isArray, the property name containing the array
+  wrapperField?: string // if set, data is nested under this key (e.g., 'external' for embed.external)
 }
 
 export interface UnionFieldSchema {
-  fieldName: string      // original camelCase field name (e.g., 'embed')
+  fieldName: string // original camelCase field name (e.g., 'embed')
   branches: UnionBranchSchema[]
 }
 
···
 }
 
 export interface ChildTableSchema {
-  parentCollection: string   // parent NSID
-  fieldName: string          // original camelCase field name (e.g., "artists")
-  tableName: string          // quoted "{collection}__{fieldName}"
-  columns: ColumnDef[]       // columns from the item object properties
+  parentCollection: string // parent NSID
+  fieldName: string // original camelCase field name (e.g., "artists")
+  tableName: string // quoted "{collection}__{fieldName}"
+  columns: ColumnDef[] // columns from the item object properties
 }
 
 // Convert camelCase to snake_case
···
   return [...storedLexicons.values()]
 }
 
-function resolveArrayItemProperties(
-  items: any,
-  defs: Record<string, any>,
-): Record<string, any> | null {
+function resolveArrayItemProperties(items: any, defs: Record<string, any>): Record<string, any> | null {
   if (!items) return null
 
   // Inline object with properties
···
 }
 
 /** Resolve a ref string to its definition object */
-function resolveRefDef(
-  ref: string,
-  defs: Record<string, any>,
-  lexicons?: Map<string, any>,
-): any | null {
+function resolveRefDef(ref: string, defs: Record<string, any>, lexicons?: Map<string, any>): any | null {
   if (ref.startsWith('#')) {
     return defs?.[ref.slice(1)] || null
   }
···
     if ((onlyProp as any).type === 'array' && (onlyProp as any).items) {
       // Single array property (like embed.images wrapping images[])
       const items = (onlyProp as any).items
-      const itemDef = items.type === 'ref' && items.ref
-        ? resolveRefDef(items.ref, branchDefs, lexicons)
-        : items
+      const itemDef = items.type === 'ref' && items.ref ? resolveRefDef(items.ref, branchDefs, lexicons) : items
       if (itemDef?.type === 'object' && itemDef.properties) {
         isArray = true
         arrayField = onlyField
···
   // Child table DDL
   const childDDL: string[] = []
   for (const child of schema.children) {
-    const childLines: string[] = [
-      '  parent_uri TEXT NOT NULL',
-      '  parent_did TEXT NOT NULL',
-    ]
+    const childLines: string[] = ['  parent_uri TEXT NOT NULL', '  parent_did TEXT NOT NULL']
     for (const col of child.columns) {
       const nullable = col.notNull ? ' NOT NULL' : ''
       childLines.push(`  ${col.name} ${col.duckdbType}${nullable}`)
···
   // Union branch table DDL
   for (const union of schema.unions) {
     for (const branch of union.branches) {
-      const branchLines: string[] = [
-        '  parent_uri TEXT NOT NULL',
-        '  parent_did TEXT NOT NULL',
-      ]
+      const branchLines: string[] = ['  parent_uri TEXT NOT NULL', '  parent_did TEXT NOT NULL']
       for (const col of branch.columns) {
         const nullable = col.notNull ? ' NOT NULL' : ''
         branchLines.push(`  ${col.name} ${col.duckdbType}${nullable}`)

packages/hatk/src/seed.ts

···
   ): Promise<{ uri: string; cid: string }> {
     const error = validateRecord(lexiconArray, collection, record)
     if (error) {
-      throw new Error(`[seed] validation error in ${collection}: ${error.path ? error.path + ': ' : ''}${error.message}`)
+      throw new Error(
+        `[seed] validation error in ${collection}: ${error.path ? error.path + ': ' : ''}${error.message}`,
+      )
     }
 
     const body: Record<string, unknown> = {

packages/hatk/src/server.ts

···
           const rec = await getRecordByUri(q)
           if (rec) {
             const labelsMap = await queryLabelsForUris([rec.uri])
-            jsonResponse(res, { records: [{ ...reshapeRow(rec, rec?.__childData), labels: labelsMap.get(rec.uri) || [] }] })
+            jsonResponse(res, {
+              records: [{ ...reshapeRow(rec, rec?.__childData), labels: labelsMap.get(rec.uri) || [] }],
+            })
           } else {
             jsonResponse(res, { records: [] })
           }
···
 
 function jsonResponse(res: any, data: any): void {
   res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' })
-  res.end(
-    JSON.stringify(data, (_, v) => normalizeValue(v)),
-  )
+  res.end(JSON.stringify(data, (_, v) => normalizeValue(v)))
 }
 
 function jsonError(res: any, status: number, message: string): void {

packages/hatk/src/test-browser.ts

···
  */
 export const test = base.extend<{}, WorkerFixtures>({
   // eslint-disable-next-line no-empty-pattern -- Playwright fixture API requires the deps arg
-  server: [async ({}, use) => {
-    const server = await startTestServer()
-    await server.loadFixtures()
-    await use(server)
-    await server.close()
-  }, { scope: 'worker' }],
+  server: [
+    async (_deps, use) => {
+      const server = await startTestServer()
+      await server.loadFixtures()
+      await use(server)
+      await server.close()
+    },
+    { scope: 'worker' },
+  ],
 })
 
 export { expect }

packages/hatk/src/test.ts

···
 import { readdirSync, readFileSync } from 'node:fs'
 import YAML from 'yaml'
 import { loadConfig, type HatkConfig } from './config.ts'
-import { loadLexicons, storeLexicons, discoverCollections, generateTableSchema, generateCreateTableSQL } from './schema.ts'
+import {
+  loadLexicons,
+  storeLexicons,
+  discoverCollections,
+  generateTableSchema,
+  generateCreateTableSQL,
+} from './schema.ts'
 import { initDatabase, querySQL, runSQL, insertRecord, closeDatabase } from './db.ts'
 import { initFeeds, executeFeed, listFeeds, createPaginate } from './feeds.ts'
 import { initXrpc, executeXrpc, listXrpc, configureRelay } from './xrpc.ts'
···
   loadFixtures: (dir?: string) => Promise<void>
   loadFeed: (name: string) => { generate: (ctx: FeedContext) => Promise<any> }
   loadXrpc: (name: string) => { handler: (ctx: any) => Promise<any> }
-  feedContext: (opts?: { limit?: number; cursor?: string; viewer?: { did: string } | null; params?: Record<string, string> }) => FeedContext
+  feedContext: (opts?: {
+    limit?: number
+    cursor?: string
+    viewer?: { did: string } | null
+    params?: Record<string, string>
+  }) => FeedContext
   close: () => Promise<void>
   /** @internal */ _config: HatkConfig
   /** @internal */ _collections: string[]
···
 
   // Discover views + hooks
   discoverViews()
-  try { await loadOnLoginHook(resolve(configDir, 'hooks')) } catch {}
+  try {
+    await loadOnLoginHook(resolve(configDir, 'hooks'))
+  } catch {}
 
   // Skip setup hooks in test context — they're for server boot-time
   // initialization (e.g. importing large datasets) and not appropriate for tests
···
             const row = interpolateHelpers(rec)
             await runSQL(
               `INSERT OR IGNORE INTO _repos (did, status, handle, backfilled_at) VALUES ($1, $2, $3, $4)`,
-              row.did, row.status || 'active', row.handle || row.did.split(':').pop() + '.test', new Date().toISOString(),
+              row.did,
+              row.status || 'active',
+              row.handle || row.did.split(':').pop() + '.test',
+              new Date().toISOString(),
             )
           }
         }
···
             const row = interpolateHelpers(rec)
             const vals = keys.map((k) => row[k])
             const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ')
-            await runSQL(`INSERT INTO "${tableName}" (${keys.map((k) => `"${k}"`).join(', ')}) VALUES (${placeholders})`, ...vals)
+            await runSQL(
+              `INSERT INTO "${tableName}" (${keys.map((k) => `"${k}"`).join(', ')}) VALUES (${placeholders})`,
+              ...vals,
+            )
           }
           continue
         }
···
             seenDids.add(did)
             await runSQL(
               `INSERT OR IGNORE INTO _repos (did, status, handle, backfilled_at) VALUES ($1, $2, $3, $4)`,
-              did, 'active', did.split(':').pop() + '.test', new Date().toISOString(),
+              did,
+              'active',
+              did.split(':').pop() + '.test',
+              new Date().toISOString(),
             )
           }
           await insertRecord(tableName, uri, cid, did, fields)
···
     },
     loadFeed: (name) => {
       const feedList = listFeeds()
-      if (!feedList.find((f) => f.name === name)) throw new Error(`Feed "${name}" not found. Available: ${feedList.map((f) => f.name).join(', ')}`)
+      if (!feedList.find((f) => f.name === name))
+        throw new Error(`Feed "${name}" not found. Available: ${feedList.map((f) => f.name).join(', ')}`)
       return {
         generate: (ctx: FeedContext) => executeFeed(name, ctx.params || {}, ctx.cursor, ctx.limit, ctx.viewer),
       }
     },
     loadXrpc: (name) => {
       const xrpcList = listXrpc()
-      if (!xrpcList.includes(name)) throw new Error(`XRPC handler "${name}" not found. Available: ${xrpcList.join(', ')}`)
+      if (!xrpcList.includes(name))
+        throw new Error(`XRPC handler "${name}" not found. Available: ${xrpcList.join(', ')}`)
       return {
         handler: (ctx: any) => {
           const params = { ...ctx.params }
···
     const did = req.headers['x-test-viewer']
     return typeof did === 'string' ? { did } : null
   }
-  const httpServer = startServer(0, ctx._collections, ctx._config.publicDir, ctx._config.oauth, ctx._config.admins, resolveViewer)
+  const httpServer = startServer(
+    0,
+    ctx._collections,
+    ctx._config.publicDir,
+    ctx._config.oauth,
+    ctx._config.admins,
+    resolveViewer,
+  )
   await new Promise<void>((resolve) => httpServer.on('listening', resolve))
   const port = (httpServer.address() as any).port
   const url = `http://127.0.0.1:${port}`
···
     url,
     port,
     fetch: (path, init) => fetch(`${url}${path}`, init),
-    fetchAs: (did, path, init) => fetch(`${url}${path}`, {
-      ...init,
-      headers: { ...init?.headers, 'x-test-viewer': did },
-    }),
+    fetchAs: (did, path, init) =>
+      fetch(`${url}${path}`, {
+        ...init,
+        headers: { ...init?.headers, 'x-test-viewer': did },
+      }),
     seed: (seedOpts) => createSeedHelpers(seedOpts),
     waitForRecord: async (uri, timeoutMs = 10_000) => {
       const start = Date.now()

packages/hatk/src/views.ts

···
 
 import { log } from './logger.ts'
 import { getAllLexicons, getLexicon } from './schema.ts'
-import { blobUrl } from './xrpc.ts'
-import type { Row, FlatRow } from './lex-types.ts'
 
 // --- Types ---
 
···
   return blobs
 }
 
-
-/** Flatten a Row<T> into a view object: { uri, did, handle, ...value, ...overrides } */
-function flattenRow<T>(row: Row<T>, overrides?: Record<string, unknown>): FlatRow<T> {
-  if (!row) return null as any
-  return {
-    uri: row.uri,
-    did: row.did,
-    handle: row.handle,
-    ...(row.value as any),
-    ...overrides,
-  } as FlatRow<T>
-}
-
-/** Resolve blob fields on a record to CDN URLs. */
-function resolveBlobOverrides(item: Row<unknown>, blobFields: Map<string, string>): Record<string, unknown> {
-  const overrides: Record<string, unknown> = {}
-  for (const [fieldName, preset] of blobFields) {
-    overrides[fieldName] = blobUrl(item.did, (item.value as any)?.[fieldName], preset as any)
-  }
-  return overrides
-}