@hatk/hatk 0.0.1-alpha.3 → 0.0.1-alpha.30

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { mkdirSync, writeFileSync, existsSync, unlinkSync, readdirSync, readFileSync } from 'node:fs';
-import { resolve, join } from 'node:path';
-import { execSync } from 'node:child_process';
-import { loadLexicons } from "./schema.js";
+import { resolve, join, dirname } from 'node:path';
+import { execSync, spawn } from 'node:child_process';
+import { loadLexicons, discoverCollections, buildSchemas } from "./database/schema.js";
 import { loadConfig } from "./config.js";
 const args = process.argv.slice(2);
 const command = args[0];
@@ -34,6 +34,31 @@ async function ensurePds() {
     console.error('[dev] PDS failed to start');
     process.exit(1);
 }
+/** Spawn a long-running process and forward SIGINT/SIGTERM for clean shutdown. */
+function spawnForward(cmd, args, env) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            stdio: 'inherit',
+            cwd: process.cwd(),
+            env: { ...process.env, ...env },
+        });
+        const onSignal = (sig) => {
+            child.kill(sig);
+        };
+        process.on('SIGINT', onSignal);
+        process.on('SIGTERM', onSignal);
+        child.on('close', (code, signal) => {
+            process.removeListener('SIGINT', onSignal);
+            process.removeListener('SIGTERM', onSignal);
+            if (signal === 'SIGINT' || signal === 'SIGTERM')
+                process.exit(0);
+            if (code === 0 || code === null)
+                resolve();
+            else
+                reject(new Error(`Process exited with code ${code}`));
+        });
+    });
+}
 function runSeed() {
     const seedFile = resolve('seeds/seed.ts');
     if (!existsSync(seedFile))
@@ -45,7 +70,7 @@ function usage() {
   Usage: hatk <command> [options]
 
   Getting Started
-    new <name> [--svelte] [--template <t>] Create a new hatk project
+    new <name> [--svelte] [--duckdb] [--template <t>] Create a new hatk project
 
   Running
     start                                  Start the hatk server
@@ -71,6 +96,8 @@ function usage() {
     generate label <name>                  Generate a label definition
     generate og <name>                     Generate an OpenGraph route
     generate job <name>                    Generate a periodic job
+    generate hook <name>                   Generate a lifecycle hook
+    generate setup <name>                  Generate a setup script
     generate types                         Regenerate TypeScript types from lexicons
     destroy <type> <name>                  Remove a generated file
 
@@ -98,7 +125,7 @@ export default defineFeed({
   },
 })
 `,
-    xrpc: (name) => `import { defineQuery } from '${xrpcImportPath(name)}'
+    xrpc: (name) => `import { defineQuery } from '../hatk.generated.ts'
 
 export default defineQuery('${name}', async (ctx) => {
   const { ok, db, params, packCursor, unpackCursor } = ctx
@@ -175,16 +202,20 @@ export default {
     // Periodic task logic here
   },
 }
+`,
+    hook: (name) => `import { defineHook } from '../hatk.generated.ts'
+
+export default defineHook('${name}', async (ctx) => {
+  // Hook logic here
+})
+`,
+    setup: (_name) => `import { defineSetup } from '../hatk.generated.ts'
+
+export default defineSetup(async (ctx) => {
+  // Setup logic here — runs before the server starts
+})
 `,
 };
-// Compute relative import path from xrpc/ns/id/method.ts back to hatk.generated.ts
-// e.g. fm.teal.getStats → xrpc/fm/teal/getStats.ts → needs ../../../hatk.generated.ts
-// Parts: [fm, teal, getStats] → 2 namespace dirs + xrpc/ dir = 3 levels up
-function xrpcImportPath(nsid) {
-    const parts = nsid.split('.');
-    const namespaceDirs = parts.length - 1; // dirs created from namespace segments
-    return '../'.repeat(namespaceDirs + 1) + 'hatk.generated.ts'; // +1 for xrpc/ dir itself
-}
 const testTemplates = {
     feed: (name) => `import { describe, test, expect, beforeAll, afterAll } from 'vitest'
 import { createTestContext } from '@hatk/hatk/test'
@@ -293,17 +324,19 @@ const lexiconTemplates = {
     }),
 };
 const dirs = {
-    feed: 'feeds',
-    xrpc: 'xrpc',
-    label: 'labels',
-    og: 'og',
-    job: 'jobs',
+    feed: 'server',
+    xrpc: 'server',
+    label: 'server',
+    og: 'server',
+    job: 'server',
+    hook: 'server',
+    setup: 'server',
 };
 // --- Commands ---
 if (command === 'new') {
     const name = args[1];
     if (!name) {
-        console.error('Usage: hatk new <name> [--svelte] [--template <template-name>]');
+        console.error('Usage: hatk new <name> [--svelte] [--duckdb] [--template <template-name>]');
         process.exit(1);
     }
     const templateIdx = args.indexOf('--template');
@@ -341,20 +374,16 @@ if (command === 'new') {
         process.exit(0);
     }
     const withSvelte = args.includes('--svelte');
+    const withDuckdb = args.includes('--duckdb');
+    const dbEngine = withDuckdb ? 'duckdb' : 'sqlite';
     mkdirSync(dir);
     const subs = [
         'lexicons',
-        'feeds',
-        'xrpc',
-        'og',
-        'labels',
-        'jobs',
+        'server',
         'seeds',
-        'setup',
         'public',
         'test',
-        'test/feeds',
-        'test/xrpc',
+        'test/server',
         'test/integration',
         'test/browser',
         'test/fixtures',
@@ -364,14 +393,19 @@ if (command === 'new') {
     for (const sub of subs) {
         mkdirSync(join(dir, sub));
     }
-    writeFileSync(join(dir, 'config.yaml'), `relay: ws://localhost:2583
-plc: http://localhost:2582
-port: 3000
-database: data/hatk.db
-admins: []
+    writeFileSync(join(dir, 'hatk.config.ts'), `import { defineConfig } from '@hatk/hatk/config'
 
-backfill:
-  parallelism: 10
+export default defineConfig({
+  relay: 'ws://localhost:2583',
+  plc: 'http://localhost:2582',
+  port: 3000,
+  databaseEngine: '${dbEngine}',
+  database: 'data/hatk.db',
+  admins: [],
+  backfill: {
+    parallelism: 10,
+  },
+})
 `);
     writeFileSync(join(dir, 'public', 'index.html'), `<!DOCTYPE html>
 <html><head><title>${name}</title></head>
@@ -507,6 +541,14 @@ backfill:
                         properties: {
                             uri: { type: 'string', format: 'at-uri' },
                             cid: { type: 'string', format: 'cid' },
+                            commit: {
+                                type: 'object',
+                                properties: {
+                                    cid: { type: 'string', format: 'cid' },
+                                    rev: { type: 'string' },
+                                },
+                            },
+                            validationStatus: { type: 'string' },
                         },
                     },
                 },
@@ -562,6 +604,14 @@ backfill:
                         properties: {
                             uri: { type: 'string', format: 'at-uri' },
                             cid: { type: 'string', format: 'cid' },
+                            commit: {
+                                type: 'object',
+                                properties: {
+                                    cid: { type: 'string', format: 'cid' },
+                                    rev: { type: 'string' },
+                                },
+                            },
+                            validationStatus: { type: 'string' },
                         },
                     },
                 },
@@ -591,6 +641,53 @@ backfill:
             },
         },
     }, null, 2) + '\n');
+    writeFileSync(join(coreLexDir, 'getPreferences.json'), JSON.stringify({
+        lexicon: 1,
+        id: 'dev.hatk.getPreferences',
+        defs: {
+            main: {
+                type: 'query',
+                description: 'Get all preferences for the authenticated user.',
+                output: {
+                    encoding: 'application/json',
+                    schema: {
+                        type: 'object',
+                        properties: {
+                            preferences: { type: 'unknown' },
+                        },
+                    },
+                },
+            },
+        },
+    }, null, 2) + '\n');
+    writeFileSync(join(coreLexDir, 'putPreference.json'), JSON.stringify({
+        lexicon: 1,
+        id: 'dev.hatk.putPreference',
+        defs: {
+            main: {
+                type: 'procedure',
+                description: 'Set a single preference by key.',
+                input: {
+                    encoding: 'application/json',
+                    schema: {
+                        type: 'object',
+                        required: ['key', 'value'],
+                        properties: {
+                            key: { type: 'string' },
+                            value: { type: 'unknown' },
+                        },
+                    },
+                },
+                output: {
+                    encoding: 'application/json',
+                    schema: {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+            },
+        },
+    }, null, 2) + '\n');
     writeFileSync(join(coreLexDir, 'getFeed.json'), JSON.stringify({
         lexicon: 1,
         id: 'dev.hatk.getFeed',
@@ -611,6 +708,7 @@ backfill:
                     encoding: 'application/json',
                     schema: {
                         type: 'object',
+                        required: ['items'],
                         properties: {
                             items: { type: 'array', items: { type: 'unknown' } },
                             cursor: { type: 'string' },
@@ -668,6 +766,7 @@ backfill:
                     encoding: 'application/json',
                     schema: {
                         type: 'object',
+                        required: ['items'],
                         properties: {
                             items: { type: 'array', items: { type: 'unknown' } },
                             cursor: { type: 'string' },
@@ -699,6 +798,7 @@ backfill:
                     encoding: 'application/json',
                     schema: {
                         type: 'object',
+                        required: ['items'],
                         properties: {
                             items: { type: 'array', items: { type: 'unknown' } },
                             cursor: { type: 'string' },
@@ -793,13 +893,17 @@ public
     writeFileSync(join(dir, 'Dockerfile'), `FROM node:25-slim
 WORKDIR /app
 COPY package.json package-lock.json ./
-RUN npm ci --omit=dev
+RUN npm ci
 COPY . .
 RUN node_modules/.bin/hatk build
+RUN npm prune --omit=dev
 EXPOSE 3000
-CMD ["node", "node_modules/@hatk/hatk/dist/main.js", "config.yaml"]
+CMD ["node", "--experimental-strip-types", "--max-old-space-size=512", "node_modules/@hatk/hatk/dist/main.js", "hatk.config.ts"]
 `);
     const pkgDeps = { '@hatk/oauth-client': '*', hatk: '*' };
+    if (!withDuckdb) {
+        pkgDeps['better-sqlite3'] = '^11';
+    }
     const pkgDevDeps = {
         '@playwright/test': '^1',
         oxfmt: '^0.35.0',
@@ -807,6 +911,7 @@ CMD ["node", "node_modules/@hatk/hatk/dist/main.js", "config.yaml"]
         typescript: '^5',
         vite: '^6',
         vitest: '^4',
+        '@types/node': '^22',
     };
     if (withSvelte) {
         pkgDevDeps['@sveltejs/adapter-static'] = '^3';
@@ -841,7 +946,7 @@ CMD ["node", "node_modules/@hatk/hatk/dist/main.js", "config.yaml"]
             allowImportingTsExtensions: true,
             resolveJsonModule: true,
         },
-        include: ['feeds', 'xrpc', 'og', 'seeds', 'labels', 'jobs', 'setup', 'hatk.generated.ts'],
+        include: ['server', 'seeds', 'hatk.generated.ts', 'hatk.config.ts'],
     }, null, 2) + '\n');
     writeFileSync(join(dir, 'playwright.config.ts'), `import { defineConfig } from '@playwright/test'
 
@@ -1026,16 +1131,42 @@ a {
 </div>
 `);
     }
+    writeFileSync(join(dir, 'AGENTS.md'), `# hatk project
+
+This is an AT Protocol application built with [hatk](https://github.com/hatk-dev/hatk).
+Read the project's lexicons in \`lexicons/\` to understand the data model.
+Types are generated from lexicons into \`hatk.generated.ts\` — never edit this file directly.
+
+## Project structure
+
+| Directory    | Purpose                                              |
+|-------------|------------------------------------------------------|
+| \`lexicons/\`  | AT Protocol lexicon schemas (JSON). Defines collections and XRPC methods |
+| \`server/\`    | All server-side code: feeds, XRPC handlers, hooks, labels, OG routes, jobs, setup scripts |
+| \`seeds/\`     | Test data seeding scripts for local development       |
+| \`test/\`      | Test files (vitest). Run with \`hatk test\`              |
+| \`public/\`    | Static files served at the root                       |
+
+## Key files
+
+- \`hatk.config.ts\` — project configuration (see \`defineConfig\` for type info)
+- \`hatk.generated.ts\` — auto-generated types and typed helpers. Regenerate with \`hatk generate types\`
+
+## Commands
+
+Run \`npx hatk --help\` for the full list of commands.
+
+Use \`npx hatk generate\` to scaffold new feeds, xrpc handlers, labels, and lexicons
+rather than creating files manually. These generate files with the correct imports
+from \`hatk.generated.ts\`.
+
+After modifying lexicons, always run \`npx hatk generate types\` to update the generated types.
+`);
     console.log(`Created ${name}/`);
-    console.log(`  config.yaml`);
+    console.log(`  hatk.config.ts`);
     console.log(`  lexicons/   — lexicon JSON files (core + your own)`);
-    console.log(`  feeds/      — feed generators`);
-    console.log(`  xrpc/       — XRPC method handlers`);
-    console.log(`  og/         — OpenGraph image routes`);
-    console.log(`  labels/     — label definitions + rules`);
-    console.log(`  jobs/       — periodic tasks`);
+    console.log(`  server/     — feeds, XRPC handlers, hooks, labels, OG routes, jobs, setup`);
     console.log(`  seeds/      — seed fixture data (hatk seed)`);
-    console.log(`  setup/      — boot-time setup scripts (run before server starts)`);
     console.log(`  test/       — test files (hatk test)`);
     console.log(`  public/     — static files`);
     console.log(`  docker-compose.yml — local PDS for development`);
@@ -1074,6 +1205,21 @@ else if (command === 'generate') {
             }
         }
         entries.sort((a, b) => a.nsid.localeCompare(b.nsid));
+        // Collect procedure nsids and blob-input nsids for client callXrpc
+        const procedureNsids = [];
+        const blobInputNsids = [];
+        for (const { nsid, defType } of entries) {
+            if (defType === 'procedure') {
+                const lex = lexicons.get(nsid);
+                const inputEncoding = lex?.defs?.main?.input?.encoding;
+                if (inputEncoding === '*/*') {
+                    blobInputNsids.push(nsid);
+                }
+                else {
+                    procedureNsids.push(nsid);
+                }
+            }
+        }
         if (entries.length === 0) {
             console.error('No lexicons found');
             process.exit(1);
@@ -1121,6 +1267,7 @@ else if (command === 'generate') {
         let out = '// Auto-generated from lexicons. Do not edit.\n';
         out += `import type { ${[...usedWrappers].sort().join(', ')}, LexServerParams, Checked, Prettify, StrictArg } from '@hatk/hatk/lex-types'\n`;
         out += `import type { XrpcContext } from '@hatk/hatk/xrpc'\n`;
+        out += `import { callXrpc as _callXrpc } from '@hatk/hatk/xrpc'\n`;
         out += `import { defineFeed as _defineFeed, type FeedResult, type FeedContext, type HydrateContext } from '@hatk/hatk/feeds'\n`;
         out += `import { seed as _seed, type SeedOpts } from '@hatk/hatk/seed'\n`;
         // Emit ALL lexicons as `const ... = {...} as const` (including defs-only)
@@ -1279,6 +1426,11 @@ else if (command === 'generate') {
         out += `\n// ─── XRPC Helpers ───────────────────────────────────────────────────\n\n`;
         out += `export type { HydrateContext } from '@hatk/hatk/feeds'\n`;
         out += `export { InvalidRequestError, NotFoundError } from '@hatk/hatk/xrpc'\n`;
+        out += `export { defineSetup } from '@hatk/hatk/setup'\n`;
+        out += `export { defineHook } from '@hatk/hatk/hooks'\n`;
+        out += `export { defineLabels } from '@hatk/hatk/labels'\n`;
+        out += `export { defineOG } from '@hatk/hatk/opengraph'\n`;
+        out += `export { defineRenderer } from '@hatk/hatk/renderer'\n`;
         out += `export type Ctx<K extends keyof XrpcSchema & keyof Registry> = XrpcContext<\n`;
         out += `  LexServerParams<Registry[K], Registry>,\n`;
         out += `  RecordRegistry,\n`;
@@ -1291,13 +1443,21 @@ else if (command === 'generate') {
         out += `  nsid: K,\n`;
         out += `  handler: (ctx: Ctx<K> & { ok: <T extends OutputOf<K>>(value: StrictArg<T, OutputOf<K>>) => Checked<OutputOf<K>> }) => Promise<Checked<OutputOf<K>>>,\n`;
         out += `) {\n`;
-        out += `  return { handler: (ctx: any) => handler({ ...ctx, ok: (v: any) => v }) }\n`;
+        out += `  return { __type: 'query' as const, nsid, handler: (ctx: any) => handler({ ...ctx, ok: (v: any) => v }) }\n`;
         out += `}\n\n`;
         out += `export function defineProcedure<K extends keyof XrpcSchema & string>(\n`;
         out += `  nsid: K,\n`;
         out += `  handler: (ctx: Ctx<K> & { ok: <T extends OutputOf<K>>(value: StrictArg<T, OutputOf<K>>) => Checked<OutputOf<K>> }) => Promise<Checked<OutputOf<K>>>,\n`;
         out += `) {\n`;
-        out += `  return { handler: (ctx: any) => handler({ ...ctx, ok: (v: any) => v }) }\n`;
+        out += `  return { __type: 'procedure' as const, nsid, handler: (ctx: any) => handler({ ...ctx, ok: (v: any) => v }) }\n`;
+        out += `}\n\n`;
+        out += `// ─── Server-side XRPC Caller ────────────────────────────────────────\n\n`;
+        out += `type ExtractParams<T> = T extends { params: infer P } ? P : Record<string, unknown>\n`;
+        out += `export async function callXrpc<K extends keyof XrpcSchema & string>(\n`;
+        out += `  nsid: K,\n`;
+        out += `  params?: ExtractParams<XrpcSchema[K]>,\n`;
+        out += `): Promise<OutputOf<K>> {\n`;
+        out += `  return _callXrpc(nsid, params as any) as Promise<OutputOf<K>>\n`;
         out += `}\n\n`;
         out += `// ─── Feed & Seed Helpers ────────────────────────────────────────────\n\n`;
         out += `type FeedGenerate = (ctx: FeedContext & { ok: (value: FeedResult) => Checked<FeedResult> }) => Promise<Checked<FeedResult>>\n`;
@@ -1328,7 +1488,125 @@ else if (command === 'generate') {
             out = out.replace(/import type \{ ([^}]+) \} from '@hatk\/hatk\/lex-types'/, `import type { ${[...usedWrappers].sort().join(', ')}, LexServerParams, Checked, Prettify, StrictArg } from '@hatk/hatk/lex-types'`);
         }
         writeFileSync(outPath, out);
+        // Generate client-safe version (types + callXrpc only, no server module re-exports)
+        // Types use `export type` from main file (erased at compile time, no runtime import).
+        // callXrpc imports from @hatk/hatk/xrpc directly to avoid pulling in server deps.
+        let clientOut = '// Auto-generated client-safe subset. Do not edit.\n';
+        clientOut += `// Import this in app components instead of hatk.generated.ts\n`;
+        clientOut += `// to avoid pulling in server-only dependencies.\n`;
+        clientOut += `export type { XrpcSchema } from './hatk.generated.ts'\n`;
+        clientOut += `import type { XrpcSchema } from './hatk.generated.ts'\n`;
+        // Re-export all types
+        const typeExports = [];
+        for (const { nsid, defType } of entries) {
+            if (!defType)
+                continue;
+            if (nsid === 'dev.hatk.createRecord' || nsid === 'dev.hatk.deleteRecord' || nsid === 'dev.hatk.putRecord')
+                continue;
+            typeExports.push(capitalize(varNames.get(nsid)));
+        }
+        if (recordEntries.length > 0) {
+            typeExports.push('RecordRegistry', 'CreateRecord', 'DeleteRecord', 'PutRecord');
+        }
+        // Named defs (views, objects) — collect from emittedDefNames minus main types
+        const mainTypeNames = new Set(entries.filter(e => e.defType).map(e => capitalize(varNames.get(e.nsid))));
+        for (const name of emittedDefNames) {
+            if (!mainTypeNames.has(name) && !typeExports.includes(name)) {
+                typeExports.push(name);
+            }
+        }
+        if (typeExports.length > 0) {
+            clientOut += `export type { ${typeExports.join(', ')} } from './hatk.generated.ts'\n`;
+        }
+        // Typed callXrpc — environment-aware:
+        // SSR: uses globalThis.__hatk_callXrpc bridge (direct handler invocation)
+        // Client: fetches via HTTP (GET for queries, POST for procedures, raw POST for blobs)
+        if (procedureNsids.length > 0) {
+            clientOut += `\nconst _procedures = new Set([${procedureNsids.map(n => `'${n}'`).join(', ')}])\n`;
+        }
+        if (blobInputNsids.length > 0) {
+            clientOut += `const _blobInputs = new Set([${blobInputNsids.map(n => `'${n}'`).join(', ')}])\n`;
+        }
+        clientOut += `\ntype CallArg<K extends keyof XrpcSchema> =\n`;
+        clientOut += `  XrpcSchema[K] extends { input: infer I } ? I :\n`;
+        clientOut += `  XrpcSchema[K] extends { params: infer P } ? P :\n`;
+        clientOut += `  Record<string, unknown>\n`;
+        clientOut += `type OutputOf<K extends keyof XrpcSchema> = XrpcSchema[K]['output']\n\n`;
+        clientOut += `export async function callXrpc<K extends keyof XrpcSchema & string>(\n`;
+        clientOut += `  nsid: K,\n`;
+        clientOut += `  arg?: CallArg<K>,\n`;
+        clientOut += `): Promise<OutputOf<K>> {\n`;
+        // Server-side bridge
+        clientOut += `  if (typeof window === 'undefined') {\n`;
+        clientOut += `    const bridge = (globalThis as any).__hatk_callXrpc\n`;
+        clientOut += `    if (!bridge) throw new Error('callXrpc: server bridge not available — is hatk initialized?')\n`;
+        if (procedureNsids.length > 0 || blobInputNsids.length > 0) {
+            const checks = [];
+            if (procedureNsids.length > 0)
+                checks.push('_procedures.has(nsid)');
+            if (blobInputNsids.length > 0)
+                checks.push('_blobInputs.has(nsid)');
+            clientOut += `    if (${checks.join(' || ')}) return bridge(nsid, {}, arg) as Promise<OutputOf<K>>\n`;
+        }
+        clientOut += `    return bridge(nsid, arg) as Promise<OutputOf<K>>\n`;
+        clientOut += `  }\n`;
+        // Client-side fetch
+        clientOut += `  const url = new URL(\`/xrpc/\${nsid}\`, window.location.origin)\n`;
+        if (blobInputNsids.length > 0) {
+            clientOut += `  if (_blobInputs.has(nsid)) {\n`;
+            clientOut += `    const blob = arg as Blob | ArrayBuffer\n`;
+            clientOut += `    const ct = blob instanceof Blob ? blob.type : 'application/octet-stream'\n`;
+            clientOut += `    const res = await fetch(url, { method: 'POST', headers: { 'Content-Type': ct }, body: blob })\n`;
+            clientOut += `    if (!res.ok) throw new Error(\`XRPC \${nsid} failed: \${res.status}\`)\n`;
+            clientOut += `    return res.json() as Promise<OutputOf<K>>\n`;
+            clientOut += `  }\n`;
+        }
+        if (procedureNsids.length > 0) {
+            clientOut += `  if (_procedures.has(nsid)) {\n`;
+            clientOut += `    const res = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(arg) })\n`;
+            clientOut += `    if (!res.ok) throw new Error(\`XRPC \${nsid} failed: \${res.status}\`)\n`;
+            clientOut += `    return res.json() as Promise<OutputOf<K>>\n`;
+            clientOut += `  }\n`;
+        }
+        clientOut += `  for (const [k, v] of Object.entries(arg || {})) {\n`;
+        clientOut += `    if (v != null) url.searchParams.set(k, String(v))\n`;
+        clientOut += `  }\n`;
+        clientOut += `  const res = await fetch(url)\n`;
+        clientOut += `  if (!res.ok) throw new Error(\`XRPC \${nsid} failed: \${res.status}\`)\n`;
+        clientOut += `  return res.json() as Promise<OutputOf<K>>\n`;
+        clientOut += `}\n`;
+        // getViewer — async, resolves from cookies on server via getRequestEvent()
+        clientOut += `\nexport async function getViewer(): Promise<{ did: string } | null> {\n`;
+        clientOut += `  if (typeof window === 'undefined') {\n`;
+        clientOut += `    try {\n`;
+        clientOut += `      const parse = (globalThis as any).__hatk_parseSessionCookie\n`;
+        clientOut += `      if (parse) {\n`;
+        clientOut += `        const { getRequestEvent } = await import('$app/server')\n`;
+        clientOut += `        const event = getRequestEvent()\n`;
+        clientOut += `        const cookieName = (globalThis as any).__hatk_sessionCookieName ?? '__hatk_session'\n`;
+        clientOut += `        const cookieValue = event.cookies.get(cookieName)\n`;
+        clientOut += `        if (cookieValue) {\n`;
+        clientOut += `          const request = new Request('http://localhost', {\n`;
+        clientOut += `            headers: { cookie: \`\${cookieName}=\${cookieValue}\` },\n`;
+        clientOut += `          })\n`;
+        clientOut += `          return parse(request)\n`;
+        clientOut += `        }\n`;
+        clientOut += `      }\n`;
+        clientOut += `    } catch {}\n`;
+        clientOut += `    return (globalThis as any).__hatk_viewer ?? null\n`;
+        clientOut += `  }\n`;
+        clientOut += `  try {\n`;
+        clientOut += `    const mod = (globalThis as any).__hatk_auth\n`;
+        clientOut += `    if (mod?.viewerDid) {\n`;
+        clientOut += `      const did = mod.viewerDid()\n`;
+        clientOut += `      if (did) return { did }\n`;
+        clientOut += `    }\n`;
+        clientOut += `  } catch {}\n`;
+        clientOut += `  return (globalThis as any).__hatk_viewer ?? null\n`;
+        clientOut += `}\n`;
+        writeFileSync('./hatk.generated.client.ts', clientOut);
         console.log(`Generated ${outPath} with ${entries.length} types: ${entries.map((e) => capitalize(varNames.get(e.nsid))).join(', ')}`);
+        console.log(`Generated ./hatk.generated.client.ts (client-safe subset)`);
     }
     else if (lexiconTemplates[type]) {
         const nsid = args[2];
@@ -1356,18 +1634,9 @@ else if (command === 'generate') {
             process.exit(1);
         }
         const baseDir = dirs[type];
-        let filePath;
-        if (type === 'xrpc') {
-            // NSID → folder path: fm.teal.getStats → xrpc/fm/teal/getStats.ts
-            const parts = name.split('.');
-            const subDir = join(baseDir, ...parts.slice(0, -1));
-            mkdirSync(subDir, { recursive: true });
-            filePath = join(subDir, `${parts[parts.length - 1]}.ts`);
-        }
-        else {
-            mkdirSync(baseDir, { recursive: true });
-            filePath = join(baseDir, `${name}.ts`);
-        }
+        mkdirSync(baseDir, { recursive: true });
+        const fileName = type === 'xrpc' ? name.split('.').pop() : name;
+        const filePath = join(baseDir, `${fileName}.ts`);
         if (existsSync(filePath)) {
             console.error(`${filePath} already exists`);
             process.exit(1);
@@ -1377,7 +1646,7 @@ else if (command === 'generate') {
         // Scaffold test file if template exists
         const testTemplate = testTemplates[type];
         if (testTemplate) {
-            const testDir = type === 'xrpc' ? 'test/xrpc' : `test/${baseDir}`;
+            const testDir = 'test/server';
             mkdirSync(testDir, { recursive: true });
             const testName = type === 'xrpc' ? name.split('.').pop() : name;
             const testPath = join(testDir, `${testName}.test.ts`);
@@ -1396,18 +1665,9 @@ else if (command === 'destroy') {
         process.exit(1);
     }
     const baseDir = dirs[type];
-    let tsPath, jsPath;
-    if (type === 'xrpc') {
-        const parts = name.split('.');
-        const leaf = parts[parts.length - 1];
-        const subDir = join(baseDir, ...parts.slice(0, -1));
-        tsPath = join(subDir, `${leaf}.ts`);
-        jsPath = join(subDir, `${leaf}.js`);
-    }
-    else {
-        tsPath = join(baseDir, `${name}.ts`);
-        jsPath = join(baseDir, `${name}.js`);
-    }
+    const fileName = type === 'xrpc' ? name.split('.').pop() : name;
+    const tsPath = join(baseDir, `${fileName}.ts`);
+    const jsPath = join(baseDir, `${fileName}.js`);
     const filePath = existsSync(tsPath) ? tsPath : existsSync(jsPath) ? jsPath : null;
     if (!filePath) {
         console.error(`No file found for ${type} "${name}"`);
@@ -1416,7 +1676,7 @@ else if (command === 'destroy') {
     unlinkSync(filePath);
     console.log(`Removed ${filePath}`);
     // Clean up test file
-    const testDir = type === 'xrpc' ? 'test/xrpc' : `test/${baseDir}`;
+    const testDir = 'test/server';
     const testName = type === 'xrpc' ? name.split('.').pop() : name;
     const testFile = join(testDir, `${testName}.test.ts`);
     if (existsSync(testFile)) {
@@ -1430,25 +1690,14 @@ else if (command === 'destroy') {
 else if (command === 'dev') {
     await ensurePds();
     runSeed();
-    try {
-        if (existsSync(resolve('svelte.config.js')) && existsSync(resolve('src/app.html'))) {
-            // SvelteKit project — vite dev starts the hatk server via the plugin
-            execSync('npx vite dev', { stdio: 'inherit', cwd: process.cwd() });
-        }
-        else {
-            // No frontend — just run the hatk server directly
-            const mainPath = resolve(import.meta.dirname, 'main.js');
-            execSync(`npx tsx ${mainPath} config.yaml`, {
-                stdio: 'inherit',
-                cwd: process.cwd(),
-                env: { ...process.env, DEV_MODE: '1' },
-            });
-        }
+    if (existsSync(resolve('vite.config.ts')) || existsSync(resolve('vite.config.js'))) {
+        // Vite project — vite dev starts the hatk server via the plugin
+        await spawnForward('npx', ['vite', 'dev']);
     }
-    catch (e) {
-        if (e.signal === 'SIGINT' || e.signal === 'SIGTERM')
-            process.exit(0);
-        throw e;
+    else {
+        // No frontend — just run the hatk server directly
+        const mainPath = resolve(import.meta.dirname, 'main.js');
+        await spawnForward('npx', ['tsx', mainPath, 'hatk.config.ts'], { DEV_MODE: '1' });
     }
 }
 else if (command === 'format' || command === 'fmt') {
@@ -1468,9 +1717,9 @@ else if (command === 'build') {
     }
 }
 else if (command === 'reset') {
-    const config = loadConfig(resolve('config.yaml'));
+    const config = await loadConfig(resolve('hatk.config.ts'));
     if (config.database !== ':memory:') {
-        for (const suffix of ['', '.wal']) {
+        for (const suffix of ['', '.wal', '-shm', '-wal']) {
             const file = config.database + suffix;
             if (existsSync(file)) {
                 unlinkSync(file);
@@ -1628,40 +1877,24 @@ else if (command === 'resolve') {
     execSync('npx hatk generate types', { stdio: 'inherit', cwd: process.cwd() });
 }
 else if (command === 'schema') {
-    const config = loadConfig(resolve('config.yaml'));
-    if (config.database === ':memory:') {
-        console.error('No database file configured (database is :memory:)');
-        process.exit(1);
-    }
-    if (!existsSync(config.database)) {
-        console.error(`Database not found: ${config.database}`);
-        console.error('Run "hatk dev" first to create it.');
-        process.exit(1);
-    }
-    const { DuckDBInstance } = await import('@duckdb/node-api');
-    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());
-    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());
-        for (const col of cols) {
-            const nullable = col.is_nullable === 'YES' ? '' : ' NOT NULL';
-            console.log(`  ${col.column_name.padEnd(20)} ${col.data_type}${nullable}`);
-        }
-        console.log();
+    const config = await loadConfig(resolve('hatk.config.ts'));
+    const { initDatabase, getSchemaDump } = await import("./database/db.js");
+    const { createAdapter } = await import("./database/adapter-factory.js");
+    const { getDialect } = await import("./database/dialect.js");
+    const configDir2 = resolve('.');
+    const lexicons2 = loadLexicons(resolve(configDir2, 'lexicons'));
+    const collections2 = config.collections.length > 0 ? config.collections : discoverCollections(lexicons2);
+    const { schemas: schemas2, ddlStatements: ddl2 } = buildSchemas(lexicons2, collections2, getDialect(config.databaseEngine));
+    if (config.database !== ':memory:') {
+        mkdirSync(dirname(config.database), { recursive: true });
     }
+    const { adapter: adapter2 } = await createAdapter(config.databaseEngine);
+    await initDatabase(adapter2, config.database, schemas2, ddl2);
+    console.log(await getSchemaDump());
 }
 else if (command === 'start') {
-    try {
-        const mainPath = resolve(import.meta.dirname, 'main.js');
-        execSync(`npx tsx ${mainPath} config.yaml`, { stdio: 'inherit', cwd: process.cwd() });
-    }
-    catch (e) {
-        if (e.signal === 'SIGINT' || e.signal === 'SIGTERM')
-            process.exit(0);
-        throw e;
-    }
+    const mainPath = resolve(import.meta.dirname, 'main.js');
+    await spawnForward('npx', ['tsx', mainPath, 'hatk.config.ts']);
 }
 else {
     usage();