@hatk/hatk 0.0.1-alpha.4 → 0.0.1-alpha.40

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
@@ -70,7 +95,8 @@ function usage() {
     generate xrpc <nsid>                   Generate an XRPC handler
     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 +124,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
@@ -169,22 +195,19 @@ export default {
   },
 }
 `,
-    job: (_name) => `export default {
-  interval: 300, // seconds
-  async run(_ctx: any) {
-    // 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 +316,18 @@ const lexiconTemplates = {
     }),
 };
 const dirs = {
-    feed: 'feeds',
-    xrpc: 'xrpc',
-    label: 'labels',
-    og: 'og',
-    job: 'jobs',
+    feed: 'server',
+    xrpc: 'server',
+    label: 'server',
+    og: '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 +365,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 +384,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 +532,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 +595,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 +632,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',
@@ -801,9 +889,12 @@ 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',
@@ -846,7 +937,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'
 
@@ -1031,16 +1122,87 @@ a {
 </div>
 `);
     }
+    let agentsMd = `# 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, setup scripts |
+| \`seeds/\`     | Test data seeding scripts for local development       |
+| \`test/\`      | Test files (vitest). Run with \`vp test\`               |
+| \`public/\`    | Static files served at the root                       |
+`;
+    if (withSvelte) {
+        agentsMd += `| \`src/\`       | SvelteKit frontend (routes, components, styles)       |
+
+`;
+    }
+    else {
+        agentsMd += `
+`;
+    }
+    agentsMd += `## Key files
+
+- \`hatk.config.ts\` — project configuration (see \`defineConfig\` for type info)
+- \`hatk.generated.ts\` — auto-generated server types and helpers. Regenerate with \`hatk generate types\`
+- \`hatk.generated.client.ts\` — auto-generated client-safe types and \`callXrpc\`. Never import \`hatk.generated.ts\` from frontend code
+
+## The \`$hatk\` alias
+
+Server files in \`server/\` import from \`$hatk\`:
+\`\`\`ts
+import { defineFeed, views, type Status } from "$hatk"
+\`\`\`
+`;
+    if (withSvelte) {
+        agentsMd += `
+SvelteKit routes and components import from \`$hatk/client\`:
+\`\`\`ts
+import { callXrpc, getViewer } from "$hatk/client"
+\`\`\`
+
+\`$hatk\` resolves to \`hatk.generated.ts\` and \`$hatk/client\` to \`hatk.generated.client.ts\`.
+The Vite plugin handles this in dev/build. In tests and production, a Node.js module resolve hook handles it.
+`;
+    }
+    else {
+        agentsMd += `
+\`$hatk\` resolves to \`hatk.generated.ts\`. The Vite plugin handles this in dev/build.
+In tests and production, a Node.js module resolve hook handles it.
+`;
+    }
+    agentsMd += `
+## 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.
+
+After modifying lexicons, always run \`npx hatk generate types\` to update the generated types.
+`;
+    if (withSvelte) {
+        agentsMd += `
+## Running
+
+- \`vp dev\` — start dev server (hatk + SvelteKit + PDS)
+- \`vp build\` — build for production (SvelteKit outputs to \`build/\`)
+- \`hatk start\` — start production server (hatk + SvelteKit via \`build/handler.js\`)
+- \`vp test\` — run tests
+`;
+    }
+    writeFileSync(join(dir, 'AGENTS.md'), agentsMd);
     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, 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`);
@@ -1079,6 +1241,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);
@@ -1126,7 +1303,8 @@ 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 { defineFeed as _defineFeed, type FeedResult, type FeedContext, type HydrateContext } from '@hatk/hatk/feeds'\n`;
+        out += `import { callXrpc as _callXrpc } from '@hatk/hatk/xrpc'\n`;
+        out += `import { defineFeed as _defineFeed, type FeedResult, type FeedContext, type BaseContext, type Row } 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)
         out += `\n// ─── Lexicon Definitions ────────────────────────────────────────────\n\n`;
@@ -1282,8 +1460,13 @@ else if (command === 'generate') {
         out += `}\n`;
         // Emit Ctx helper for typesafe XRPC handler contexts
         out += `\n// ─── XRPC Helpers ───────────────────────────────────────────────────\n\n`;
-        out += `export type { HydrateContext } from '@hatk/hatk/feeds'\n`;
+        out += `export type { BaseContext, Row } 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 { defineLabel } 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`;
@@ -1296,21 +1479,29 @@ 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`;
         out += `export function defineFeed<K extends keyof RecordRegistry>(\n`;
-        out += `  opts: { collection: K; view?: string; label: string; generate: FeedGenerate; hydrate?: (ctx: HydrateContext<RecordRegistry[K]>) => Promise<unknown[]> }\n`;
+        out += `  opts: { collection: K; view?: string; label: string; generate: FeedGenerate; hydrate?: (ctx: BaseContext, items: Row<RecordRegistry[K]>[]) => Promise<unknown[]> }\n`;
         out += `): ReturnType<typeof _defineFeed>\n`;
         out += `export function defineFeed(\n`;
-        out += `  opts: { collection?: never; view?: never; label: string; generate: FeedGenerate; hydrate: (ctx: HydrateContext<any>) => Promise<unknown[]> }\n`;
+        out += `  opts: { collection?: never; view?: never; label: string; generate: FeedGenerate; hydrate: (ctx: BaseContext, items: Row<unknown>[]) => Promise<unknown[]> }\n`;
         out += `): ReturnType<typeof _defineFeed>\n`;
         out += `export function defineFeed(opts: any) { return _defineFeed(opts) }\n`;
         out += `export function seed(opts?: SeedOpts) { return _seed<RecordRegistry>(opts) }\n`;
@@ -1333,7 +1524,145 @@ 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 += `  customFetch?: typeof globalThis.fetch,\n`;
+        clientOut += `): Promise<OutputOf<K>> {\n`;
+        // Server-side bridge (skip when customFetch is provided — let SvelteKit's fetch handle it)
+        clientOut += `  if (typeof window === 'undefined' && !customFetch) {\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 (or server-side with customFetch for SSR deduplication)
+        clientOut += `  const _fetch = customFetch ?? globalThis.fetch\n`;
+        clientOut += `  // Use relative URL so SvelteKit's fetch can deduplicate server/client requests\n`;
+        clientOut += `  let path = \`/xrpc/\${nsid}\`\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(path, { 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(path, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(arg) })\n`;
+            clientOut += `    if (typeof window !== 'undefined' && res.status === 401) { const _h = getViewer()?.handle; window.location.href = _h ? \`/oauth/login?handle=\${encodeURIComponent(_h)}\` : '/oauth/login'; return new Promise(() => {}) as any }\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 += `  const params = new URLSearchParams()\n`;
+        clientOut += `  for (const [k, v] of Object.entries(arg || {})) {\n`;
+        clientOut += `    if (v != null) params.set(k, String(v))\n`;
+        clientOut += `  }\n`;
+        clientOut += `  const qs = params.toString()\n`;
+        clientOut += `  if (qs) path += \`?\${qs}\`\n`;
+        clientOut += `  const res = await _fetch(path)\n`;
+        clientOut += `  if (typeof window !== 'undefined' && res.status === 401) { window.location.href = '/oauth/login'; return new Promise(() => {}) as any }\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 — returns the viewer set by layout load (server) or $effect (client)
+        clientOut += `\nexport function getViewer(): { did: string; handle: string } | null {\n`;
+        clientOut += `  return (globalThis as any).__hatk_viewer ?? null\n`;
+        clientOut += `}\n`;
+        // Auth helpers — login, logout, viewerDid
+        clientOut += `\n// ─── Auth Helpers ────────────────────────────────────────────────────\n\n`;
+        clientOut += `export async function login(handle: string): Promise<void> {\n`;
+        clientOut += `  const res = await fetch(\`/oauth/login?handle=\${encodeURIComponent(handle)}\`, { redirect: 'manual' })\n`;
+        clientOut += `  if (res.type === 'opaqueredirect') {\n`;
+        clientOut += `    window.location.href = \`/oauth/login?handle=\${encodeURIComponent(handle)}\`\n`;
+        clientOut += `    return\n`;
+        clientOut += `  }\n`;
+        clientOut += `  if (res.ok) return\n`;
+        clientOut += `  const body = await res.json().catch(() => ({ error: 'Login failed' }))\n`;
+        clientOut += `  throw new Error(body.error || 'Login failed')\n`;
+        clientOut += `}\n\n`;
+        clientOut += `export async function logout(): Promise<void> {\n`;
+        clientOut += `  ;(globalThis as any).__hatk_viewer = null\n`;
+        clientOut += `  await fetch('/auth/logout', { method: 'POST' }).catch(() => {})\n`;
+        clientOut += `}\n\n`;
+        clientOut += `export function viewerDid(): string | null {\n`;
+        clientOut += `  if (typeof window === 'undefined') return null\n`;
+        clientOut += `  const viewer = (globalThis as any).__hatk_viewer\n`;
+        clientOut += `  return viewer?.did ?? null\n`;
+        clientOut += `}\n\n`;
+        clientOut += `// Expose viewer for getViewer() bridge\n`;
+        clientOut += `;(globalThis as any).__hatk_auth = { viewerDid }\n`;
+        // parseViewer — server-side session cookie resolution for +layout.server.ts
+        clientOut += `\n// ─── Server Helpers ──────────────────────────────────────────────────\n\n`;
+        clientOut += `export async function parseViewer(cookies: { get(name: string): string | undefined }): Promise<{ did: string; handle?: string } | null> {\n`;
+        clientOut += `  const parseSessionCookie = (globalThis as any).__hatk_parseSessionCookie\n`;
+        clientOut += `  if (!parseSessionCookie) return null\n`;
+        clientOut += `  const cookieValue = cookies.get('__hatk_session')\n`;
+        clientOut += `  if (!cookieValue) return null\n`;
+        clientOut += `  try {\n`;
+        clientOut += `    const request = new Request('http://localhost', { headers: { cookie: \`__hatk_session=\${cookieValue}\` } })\n`;
+        clientOut += `    const viewer = await parseSessionCookie(request)\n`;
+        clientOut += `    if (viewer) (globalThis as any).__hatk_viewer = viewer\n`;
+        clientOut += `    return viewer\n`;
+        clientOut += `  } catch { return 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];
@@ -1361,18 +1690,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);
@@ -1382,7 +1702,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`);
@@ -1401,18 +1721,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}"`);
@@ -1421,7 +1732,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)) {
@@ -1435,25 +1746,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') {
@@ -1473,9 +1773,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);
@@ -1633,40 +1933,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();