chore: formatting, lint fixes, and minor improvements from prior sessions

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

docs/site/.vitepress/config.ts

···
       },
     ],
 
-    socialLinks: [
-      { icon: 'github', link: 'https://github.com/bigmoves/atconf-workshop' },
-    ],
+    socialLinks: [{ icon: 'github', link: 'https://github.com/bigmoves/atconf-workshop' }],
   },
 })

docs/site/api/index.md

···
 
 ## Built-in endpoints
 
-| Endpoint                              | Type      | Auth | Description                     |
-| ------------------------------------- | --------- | ---- | ------------------------------- |
+| 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  |
···
 | [`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        |
+| `describeCollections`                | Query     | No   | List indexed collections        |

docs/site/guides/deployment.md

···
 
 ```ts
 export default defineConfig({
-  databaseEngine: "sqlite",
-  database: process.env.NODE_ENV === "production" ? "/data/app.db" : "data/app.db",
-});
+  databaseEngine: 'sqlite',
+  database: process.env.NODE_ENV === 'production' ? '/data/app.db' : 'data/app.db',
+})
 ```
 
 ### Health checks
···
 
 ```ts
 // server/setup/create-indexes.ts
-import { defineSetup } from "$hatk";
+import { defineSetup } from '$hatk'
 
 export default defineSetup(async (ctx) => {
-  const { db } = ctx;
+  const { db } = ctx
   await db.run(
     `CREATE INDEX IF NOT EXISTS idx_plays_played_time
      ON "fm.teal.alpha.feed.play"(played_time DESC)`,
-  );
-});
+  )
+})
 ```
 
 Setup scripts run on every startup. `CREATE INDEX IF NOT EXISTS` makes them idempotent.
···
 For expensive aggregation queries (trending lists, category counts), use stale-while-revalidate caching:
 
 ```ts
-let cache: { data: any; expires: number } | null = null;
-const TTL = 5 * 60 * 1000;
+let cache: { data: any; expires: number } | null = null
+const TTL = 5 * 60 * 1000
 
 async function refresh(db) {
-  const rows = await db.query(`...`);
-  cache = { data: rows, expires: Date.now() + TTL };
-  return rows;
+  const rows = await db.query(`...`)
+  cache = { data: rows, expires: Date.now() + TTL }
+  return rows
 }
 
 // In handler:
 if (cache) {
-  if (Date.now() >= cache.expires) refresh(db); // background refresh
-  return ok(cache.data); // serve stale immediately
+  if (Date.now() >= cache.expires) refresh(db) // background refresh
+  return ok(cache.data) // serve stale immediately
 }
-return ok(await refresh(db)); // first request waits
+return ok(await refresh(db)) // first request waits
 ```

packages/hatk/src/adapter.ts

···
 }
 
 /** Routes handled by hatk — everything else can fall through to a framework handler. */
-export const HATK_ROUTES = ['/xrpc/', '/oauth/', '/oauth-client-metadata.json', '/.well-known/', '/og/', '/admin', '/repos', '/info/', '/_health', '/robots.txt', '/auth/logout', '/__dev/']
+export const HATK_ROUTES = [
+  '/xrpc/',
+  '/oauth/',
+  '/oauth-client-metadata.json',
+  '/.well-known/',
+  '/og/',
+  '/admin',
+  '/repos',
+  '/info/',
+  '/_health',
+  '/robots.txt',
+  '/auth/logout',
+  '/__dev/',
+]
 
 export function isHatkRoute(pathname: string): boolean {
-  return HATK_ROUTES.some(r => pathname.startsWith(r) || pathname === r)
+  return HATK_ROUTES.some((r) => pathname.startsWith(r) || pathname === r)
 }
 
 /**

packages/hatk/src/database/adapters/sqlite-search.ts

···
   constructor(private port: DatabasePort) {}
 
   async indexExists(shadowTable: string): Promise<boolean> {
-    const rows = await this.port.query(
-      `SELECT 1 FROM sqlite_master WHERE type='table' AND name IN ($1, $2)`,
-      [shadowTable, `${shadowTable}_fts`],
-    )
+    const rows = await this.port.query(`SELECT 1 FROM sqlite_master WHERE type='table' AND name IN ($1, $2)`, [
+      shadowTable,
+      `${shadowTable}_fts`,
+    ])
     return rows.length >= 2
   }
 
···
 
     // Create shadow data table from source query
     await this.port.execute(`CREATE TABLE ${shadowTable} AS ${sourceQuery}`, [])
-    await this.port.execute(
-      `CREATE UNIQUE INDEX IF NOT EXISTS ${shadowTable}_uri ON ${shadowTable}(uri)`,
-      [],
-    )
+    await this.port.execute(`CREATE UNIQUE INDEX IF NOT EXISTS ${shadowTable}_uri ON ${shadowTable}(uri)`, [])
 
     // Create FTS5 virtual table with external content pointing to shadow table
     const colList = searchColumns.join(', ')
···
     await this.port.execute(`DELETE FROM ${shadowTable} WHERE uri = $1`, [uri])
   }
 
-  private async _deleteFromFts(
-    shadowTable: string,
-    uri: string,
-    searchColumns: string[],
-  ): Promise<void> {
+  private async _deleteFromFts(shadowTable: string, uri: string, searchColumns: string[]): Promise<void> {
     const colList = searchColumns.join(', ')
-    const rows = await this.port.query(
-      `SELECT rowid, uri, ${colList} FROM ${shadowTable} WHERE uri = $1`,
-      [uri],
-    )
+    const rows = await this.port.query(`SELECT rowid, uri, ${colList} FROM ${shadowTable} WHERE uri = $1`, [uri])
     if (rows.length === 0) return
 
     const old = rows[0] as any

packages/hatk/src/database/fts.ts

···
   lastRebuiltAt.set(collection, new Date().toISOString())
 }
 
-export async function buildFtsRow(
-  collection: string,
-  uri: string,
-): Promise<Record<string, string | null> | null> {
+export async function buildFtsRow(collection: string, uri: string): Promise<Record<string, string | null> | null> {
   const { searchColNames, sourceQuery } = computeFtsSchema(collection)
   if (searchColNames.length === 0) return null
 

packages/hatk/src/database/ports.ts

···
   buildIndex(shadowTable: string, sourceQuery: string, searchColumns: string[]): Promise<void>
 
   /** Incrementally update a single record in the FTS index */
-  updateIndex?(shadowTable: string, uri: string, row: Record<string, string | null>, searchColumns: string[]): Promise<void>
+  updateIndex?(
+    shadowTable: string,
+    uri: string,
+    row: Record<string, string | null>,
+    searchColumns: string[],
+  ): Promise<void>
 
   /** Remove a single record from the FTS index */
   deleteFromIndex?(shadowTable: string, uri: string, searchColumns: string[]): Promise<void>

packages/hatk/src/labels.ts

···
 }
 
 /** Register a single label module from a scanned server/ module. */
-export function registerLabelModule(name: string, labelMod: { definition?: LabelDefinition; evaluate?: (ctx: LabelRuleContext) => Promise<string[]> }): void {
+export function registerLabelModule(
+  name: string,
+  labelMod: { definition?: LabelDefinition; evaluate?: (ctx: LabelRuleContext) => Promise<string[]> },
+): void {
   if (labelMod.definition) {
     labelDefs.push(labelMod.definition)
   }

packages/hatk/src/oauth/server.ts

···
 
 // --- Server-initiated login (no DPoP required from browser) ---
 
-export async function serverLogin(
-  config: OAuthConfig,
-  handle: string,
-): Promise<string> {
+export async function serverLogin(config: OAuthConfig, handle: string): Promise<string> {
   // Resolve handle to DID
   let did = handle
   if (!did.startsWith('did:')) {
···
   const pdsState = randomToken()
 
   // PAR to the PDS
-  const parEndpoint =
-    discovery.authServerMetadata.pushed_authorization_request_endpoint || `${pdsAuthServer}/oauth/par`
+  const parEndpoint = discovery.authServerMetadata.pushed_authorization_request_endpoint || `${pdsAuthServer}/oauth/par`
   const serverDpopProof = await createDpopProof(serverPrivateJwk, serverPublicJwk, 'POST', parEndpoint)
 
   const scope = config.scopes?.join(' ') || 'atproto transition:generic'
···
     if (errBody.error === 'use_dpop_nonce') {
       const nonce = pdsParRes.headers.get('DPoP-Nonce')
       if (nonce) {
-        const retryProof = await createDpopProof(serverPrivateJwk, serverPublicJwk, 'POST', parEndpoint, undefined, nonce)
+        const retryProof = await createDpopProof(
+          serverPrivateJwk,
+          serverPublicJwk,
+          'POST',
+          parEndpoint,
+          undefined,
+          nonce,
+        )
         const retryRes = await fetch(parEndpoint, {
           method: 'POST',
           headers: { 'Content-Type': 'application/x-www-form-urlencoded', DPoP: retryProof },

packages/hatk/src/opengraph.ts

···
   meta?: { title?: string; description?: string }
 }
 
-export function defineOG(
-  path: string,
-  generate: (ctx: OpengraphContext) => Promise<OpengraphResult>,
-) {
+export function defineOG(path: string, generate: (ctx: OpengraphContext) => Promise<OpengraphResult>) {
   return { __type: 'og' as const, path, generate }
 }
 
···
 }
 
 /** Register a single OG handler from a scanned server/ module. */
-export function registerOgHandler(ogMod: { path: string; generate: (ctx: OpengraphContext) => Promise<OpengraphResult> }): void {
+export function registerOgHandler(ogMod: {
+  path: string
+  generate: (ctx: OpengraphContext) => Promise<OpengraphResult>
+}): void {
   const { pattern, paramNames } = compilePath(ogMod.path)
   const name = ogMod.path.replace(/^\//, '').replace(/\//g, '-').replace(/:/g, '')
 

packages/hatk/src/renderer.ts

···
  * @param ogMeta - Optional OG meta tags to inject
  * @returns Assembled HTML string, or null if no renderer is registered
  */
-export async function renderPage(
-  template: string,
-  request: Request,
-  ogMeta?: string | null,
-): Promise<string | null> {
+export async function renderPage(template: string, request: Request, ogMeta?: string | null): Promise<string | null> {
   if (!renderer) return null
 
   const manifest = ssrManifest || { getPreloadTags: () => '' }

packages/hatk/src/response.ts

···
       headers: {
         'Content-Type': 'application/json',
         'Content-Encoding': 'gzip',
-        'Vary': 'Accept-Encoding',
+        Vary: 'Accept-Encoding',
         ...(status === 200 ? { 'Cache-Control': 'no-store' } : {}),
       },
     })

packages/hatk/src/server-init.ts

···
   }
 
   log(`[server] Initialized from server/ directory:`)
-  log(`  Feeds: ${listFeeds().map((f) => f.name).join(', ') || 'none'}`)
+  log(
+    `  Feeds: ${
+      listFeeds()
+        .map((f) => f.name)
+        .join(', ') || 'none'
+    }`,
+  )
   log(`  XRPC: ${listXrpc().join(', ') || 'none'}`)
   log(`  Labels: ${getLabelDefinitions().length} definitions`)
 }