@hatk/hatk 0.0.1-alpha.6 → 0.0.1-alpha.60

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 { execSync, spawn } from 'node:child_process';
+import { loadLexicons } 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))
@@ -44,15 +69,11 @@ function usage() {
     console.log(`
   Usage: hatk <command> [options]
 
-  Getting Started
-    new <name> [--svelte] [--template <t>] Create a new hatk project
-
   Running
     start                                  Start the hatk server
     dev                                    Start PDS, seed, and run hatk
     seed                                   Seed local PDS with fixture data
     reset                                  Reset database and PDS for a clean slate
-    schema                                 Show database schema from lexicons
 
   Code Quality
     check                                  Type-check and lint the project
@@ -70,7 +91,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
 
@@ -82,151 +104,16 @@ function usage() {
 if (!command)
     usage();
 // --- Templates ---
-const templates = {
-    feed: (name) => `import { defineFeed } from '../hatk.generated.ts'
-
-export default defineFeed({
-  collection: 'your.collection.here',
-  label: '${name.charAt(0).toUpperCase() + name.slice(1)}',
-
-  async generate(ctx) {
-    const { rows, cursor } = await ctx.paginate<{ uri: string }>(
-      \`SELECT uri, cid, indexed_at FROM "your.collection.here"\`,
-    )
-
-    return ctx.ok({ uris: rows.map((r) => r.uri), cursor })
-  },
-})
-`,
-    xrpc: (name) => `import { defineQuery } from '${xrpcImportPath(name)}'
-
-export default defineQuery('${name}', async (ctx) => {
-  const { ok, db, params, packCursor, unpackCursor } = ctx
-  const limit = params.limit ?? 30
-  const cursor = params.cursor
-
-  const conditions: string[] = []
-  const sqlParams: (string | number)[] = []
-  let paramIdx = 1
-
-  if (cursor) {
-    const parsed = unpackCursor(cursor)
-    if (parsed) {
-      conditions.push(\`(s.indexed_at < $\${paramIdx} OR (s.indexed_at = $\${paramIdx + 1} AND s.cid < $\${paramIdx + 2}))\`)
-      sqlParams.push(parsed.primary, parsed.primary, parsed.cid)
-      paramIdx += 3
-    }
-  }
-
-  const where = conditions.length ? 'WHERE ' + conditions.join(' AND ') : ''
-
-  const rows = await db.query(
-    \`SELECT s.* FROM "your.collection.here" s \${where} ORDER BY s.indexed_at DESC, s.cid DESC LIMIT $\${paramIdx}\`,
-    sqlParams.concat([limit + 1]),
-  )
-
-  const hasMore = rows.length > limit
-  if (hasMore) rows.pop()
-  const lastRow = rows[rows.length - 1]
-
-  return ok({
-    items: rows,
-    cursor: hasMore && lastRow ? packCursor(lastRow.indexed_at, lastRow.cid) : undefined,
-  })
-})
-`,
-    label: (name) => `import type { LabelRuleContext } from '@hatk/hatk/labels'
-
-export default {
-  definition: {
-    identifier: '${name}',
-    severity: 'inform',
-    blurs: 'none',
-    defaultSetting: 'warn',
-    locales: [{ lang: 'en', name: '${name.charAt(0).toUpperCase() + name.slice(1)}', description: 'Description here' }],
-  },
-  async evaluate(ctx: LabelRuleContext) {
-    // Return array of label identifiers to apply, or empty array
-    return []
-  },
+const templateDir = join(import.meta.dirname, 'templates');
+function loadTemplate(file, name) {
+    const raw = readFileSync(join(templateDir, file), 'utf-8');
+    const capitalized = name.charAt(0).toUpperCase() + name.slice(1);
+    return raw.replaceAll('{{name}}', name).replaceAll('{{Name}}', capitalized);
 }
-`,
-    og: (name) => `import type { OpengraphContext, OpengraphResult } from '@hatk/hatk/opengraph'
-
-export default {
-  path: '/og/${name}/:id',
-  async generate(ctx: OpengraphContext): Promise<OpengraphResult> {
-    const { db, params } = ctx
-    return {
-      element: {
-        type: 'div',
-        props: {
-          style: { display: 'flex', width: '100%', height: '100%', background: '#080b12', color: 'white', alignItems: 'center', justifyContent: 'center' },
-          children: params.id,
-        },
-      },
-    }
-  },
-}
-`,
-    job: (_name) => `export default {
-  interval: 300, // seconds
-  async run(_ctx: any) {
-    // Periodic task logic here
-  },
-}
-`,
-};
-// 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'
-
-let ctx: Awaited<ReturnType<typeof createTestContext>>
-
-beforeAll(async () => {
-  ctx = await createTestContext()
-  await ctx.loadFixtures()
-})
-
-afterAll(async () => ctx?.close())
-
-describe('${name} feed', () => {
-  test('returns results', async () => {
-    const feed = ctx.loadFeed('${name}')
-    const result = await feed.generate(ctx.feedContext({ limit: 10 }))
-    expect(result).toBeDefined()
-  })
-})
-`,
-    xrpc: (name) => `import { describe, test, expect, beforeAll, afterAll } from 'vitest'
-import { createTestContext } from '@hatk/hatk/test'
-
-let ctx: Awaited<ReturnType<typeof createTestContext>>
-
-beforeAll(async () => {
-  ctx = await createTestContext()
-  await ctx.loadFixtures()
-})
-
-afterAll(async () => ctx?.close())
-
-describe('${name}', () => {
-  test('returns response', async () => {
-    const handler = ctx.loadXrpc('${name}')
-    const result = await handler.handler({ params: {} })
-    expect(result).toBeDefined()
-  })
-})
-`,
-};
+const templateTypes = ['feed', 'xrpc', 'label', 'og', 'hook', 'setup'];
+const testTemplateTypes = ['feed', 'xrpc'];
+const templates = Object.fromEntries(templateTypes.map((t) => [t, (name) => loadTemplate(`${t}.tpl`, name)]));
+const testTemplates = Object.fromEntries(testTemplateTypes.map((t) => [t, (name) => loadTemplate(`test-${t}.tpl`, name)]));
 const lexiconTemplates = {
     record: (nsid) => ({
         lexicon: 1,
@@ -293,815 +180,21 @@ 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>]');
-        process.exit(1);
-    }
-    const templateIdx = args.indexOf('--template');
-    const templateName = templateIdx !== -1 ? args[templateIdx + 1] : null;
-    if (templateIdx !== -1 && !templateName) {
-        console.error('Usage: hatk new <name> --template <template-name>');
-        process.exit(1);
-    }
-    const dir = resolve(name);
-    if (existsSync(dir)) {
-        console.error(`Directory ${name} already exists`);
-        process.exit(1);
-    }
-    if (templateName) {
-        const repo = `https://github.com/hatk-dev/hatk-template-${templateName}.git`;
-        console.log(`Cloning template ${templateName}...`);
-        try {
-            execSync(`git clone --depth 1 ${repo} ${dir}`, { stdio: 'inherit' });
-        }
-        catch {
-            console.error(`Failed to clone template: ${repo}`);
-            process.exit(1);
-        }
-        execSync(`rm -rf ${join(dir, '.git')}`);
-        const pkgPath = join(dir, 'package.json');
-        if (existsSync(pkgPath)) {
-            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-            pkg.name = name;
-            writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-        }
-        console.log(`\nCreated ${name}/ from template ${templateName}`);
-        console.log(`\n  cd ${name}`);
-        console.log(`  npm install`);
-        console.log(`  hatk dev`);
-        process.exit(0);
-    }
-    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',
-    ];
-    if (withSvelte)
-        subs.push('src', 'src/routes', 'src/lib');
-    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: []
-
-backfill:
-  parallelism: 10
-`);
-    writeFileSync(join(dir, 'public', 'index.html'), `<!DOCTYPE html>
-<html><head><title>${name}</title></head>
-<body><h1>${name}</h1></body></html>
-`);
-    // Scaffold core framework lexicons under dev.hatk namespace
-    const coreLexDir = join(dir, 'lexicons', 'dev', 'hatk');
-    mkdirSync(coreLexDir, { recursive: true });
-    writeFileSync(join(coreLexDir, 'describeCollections.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.describeCollections',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'List indexed collections and their schemas.',
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            collections: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    required: ['collection'],
-                                    properties: {
-                                        collection: { type: 'string' },
-                                        columns: {
-                                            type: 'array',
-                                            items: {
-                                                type: 'object',
-                                                required: ['name', 'originalName', 'type', 'required'],
-                                                properties: {
-                                                    name: { type: 'string' },
-                                                    originalName: { type: 'string' },
-                                                    type: { type: 'string' },
-                                                    required: { type: 'boolean' },
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'describeFeeds.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.describeFeeds',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'List available feeds.',
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            feeds: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    required: ['name', 'label'],
-                                    properties: {
-                                        name: { type: 'string' },
-                                        label: { type: 'string' },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'describeLabels.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.describeLabels',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'List available label definitions.',
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            definitions: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    required: ['identifier', 'severity', 'blurs', 'defaultSetting'],
-                                    properties: {
-                                        identifier: { type: 'string' },
-                                        severity: { type: 'string' },
-                                        blurs: { type: 'string' },
-                                        defaultSetting: { type: 'string' },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'createRecord.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.createRecord',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: "Create a record via the user's PDS.",
-                input: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['collection', 'repo', 'record'],
-                        properties: {
-                            collection: { type: 'string' },
-                            repo: { type: 'string', format: 'did' },
-                            record: { type: 'unknown' },
-                        },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            uri: { type: 'string', format: 'at-uri' },
-                            cid: { type: 'string', format: 'cid' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'deleteRecord.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.deleteRecord',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: "Delete a record via the user's PDS.",
-                input: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['collection', 'rkey'],
-                        properties: {
-                            collection: { type: 'string' },
-                            rkey: { type: 'string' },
-                        },
-                    },
-                },
-                output: { encoding: 'application/json', schema: { type: 'object', properties: {} } },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'putRecord.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.putRecord',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: "Create or update a record via the user's PDS.",
-                input: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['collection', 'rkey', 'record'],
-                        properties: {
-                            collection: { type: 'string' },
-                            rkey: { type: 'string' },
-                            record: { type: 'unknown' },
-                            repo: { type: 'string', format: 'did' },
-                        },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            uri: { type: 'string', format: 'at-uri' },
-                            cid: { type: 'string', format: 'cid' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'uploadBlob.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.uploadBlob',
-        defs: {
-            main: {
-                type: 'procedure',
-                description: "Upload a blob via the user's PDS.",
-                input: {
-                    encoding: '*/*',
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['blob'],
-                        properties: {
-                            blob: { type: 'blob' },
-                        },
-                    },
-                },
-            },
-        },
-    }, 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',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'Retrieve a named feed of items.',
-                parameters: {
-                    type: 'params',
-                    required: ['feed'],
-                    properties: {
-                        feed: { type: 'string', description: 'Feed name' },
-                        limit: { type: 'integer', minimum: 1, maximum: 100, default: 30 },
-                        cursor: { type: 'string' },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['items'],
-                        properties: {
-                            items: { type: 'array', items: { type: 'unknown' } },
-                            cursor: { type: 'string' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'getRecord.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.getRecord',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'Fetch a single record by AT URI.',
-                parameters: {
-                    type: 'params',
-                    required: ['uri'],
-                    properties: {
-                        uri: { type: 'string', format: 'at-uri' },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            record: { type: 'unknown' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'getRecords.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.getRecords',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'List records from a collection with optional filters.',
-                parameters: {
-                    type: 'params',
-                    required: ['collection'],
-                    properties: {
-                        collection: { type: 'string' },
-                        limit: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
-                        cursor: { type: 'string' },
-                        sort: { type: 'string' },
-                        order: { type: 'string' },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['items'],
-                        properties: {
-                            items: { type: 'array', items: { type: 'unknown' } },
-                            cursor: { type: 'string' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(coreLexDir, 'searchRecords.json'), JSON.stringify({
-        lexicon: 1,
-        id: 'dev.hatk.searchRecords',
-        defs: {
-            main: {
-                type: 'query',
-                description: 'Full-text search across a collection.',
-                parameters: {
-                    type: 'params',
-                    required: ['collection', 'q'],
-                    properties: {
-                        collection: { type: 'string' },
-                        q: { type: 'string', description: 'Search query' },
-                        limit: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
-                        cursor: { type: 'string' },
-                        fuzzy: { type: 'boolean', default: true },
-                    },
-                },
-                output: {
-                    encoding: 'application/json',
-                    schema: {
-                        type: 'object',
-                        required: ['items'],
-                        properties: {
-                            items: { type: 'array', items: { type: 'unknown' } },
-                            cursor: { type: 'string' },
-                        },
-                    },
-                },
-            },
-        },
-    }, null, 2) + '\n');
-    writeFileSync(join(dir, 'seeds', 'seed.ts'), `import { seed } from '../hatk.generated.ts'
-
-const { createAccount, createRecord } = seed()
-
-const alice = await createAccount('alice.test')
-
-// await createRecord(alice, 'your.collection.here', {
-//   field: 'value',
-// }, { rkey: 'my-record' })
-
-console.log('\\n[seed] Done!')
-`);
-    writeFileSync(join(dir, 'docker-compose.yml'), `services:
-  plc:
-    build:
-      context: https://github.com/did-method-plc/did-method-plc.git
-      dockerfile: packages/server/Dockerfile
-    ports:
-      - '2582:2582'
-    environment:
-      - DATABASE_URL=postgres://plc:plc@postgres:5432/plc
-      - PORT=2582
-    command: ['dumb-init', 'node', '--enable-source-maps', '../dist/bin.js']
-    depends_on:
-      postgres:
-        condition: service_healthy
-    healthcheck:
-      test: ['CMD-SHELL', 'wget -q --spider http://localhost:2582/_health || exit 1']
-      interval: 2s
-      timeout: 5s
-      retries: 15
-
-  pds:
-    image: ghcr.io/bluesky-social/pds:latest
-    ports:
-      - '2583:2583'
-    environment:
-      - PDS_HOSTNAME=localhost
-      - PDS_PORT=2583
-      - PDS_DID_PLC_URL=http://plc:2582
-      - PDS_DATA_DIRECTORY=/pds
-      - PDS_BLOBSTORE_DISK_LOCATION=/pds/blobs
-      - PDS_JWT_SECRET=dev-jwt-secret
-      - PDS_ADMIN_PASSWORD=dev-admin
-      - PDS_PLC_ROTATION_KEY_K256_PRIVATE_KEY_HEX=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
-      - PDS_INVITE_REQUIRED=false
-      - PDS_DEV_MODE=true
-      - LOG_ENABLED=true
-    volumes:
-      - pds_data:/pds
-    depends_on:
-      plc:
-        condition: service_healthy
-    healthcheck:
-      test: ['CMD-SHELL', 'wget -q --spider http://localhost:2583/xrpc/_health || exit 1']
-      interval: 2s
-      timeout: 5s
-      retries: 15
-
-  postgres:
-    image: postgres:16-alpine
-    environment:
-      - POSTGRES_USER=plc
-      - POSTGRES_PASSWORD=plc
-      - POSTGRES_DB=plc
-    volumes:
-      - plc_data:/var/lib/postgresql/data
-    healthcheck:
-      test: ['CMD-SHELL', 'pg_isready -U plc']
-      interval: 2s
-      timeout: 5s
-      retries: 10
-
-volumes:
-  pds_data:
-  plc_data:
-`);
-    writeFileSync(join(dir, '.dockerignore'), `node_modules
-data
-.svelte-kit
-public
-`);
-    writeFileSync(join(dir, 'Dockerfile'), `FROM node:25-slim
-WORKDIR /app
-COPY package.json package-lock.json ./
-RUN npm ci
-COPY . .
-RUN node_modules/.bin/hatk build
-RUN npm prune --omit=dev
-EXPOSE 3000
-CMD ["node", "--max-old-space-size=256", "node_modules/@hatk/hatk/dist/main.js", "config.yaml"]
-`);
-    const pkgDeps = { '@hatk/oauth-client': '*', hatk: '*' };
-    const pkgDevDeps = {
-        '@playwright/test': '^1',
-        oxfmt: '^0.35.0',
-        oxlint: '^1',
-        typescript: '^5',
-        vite: '^6',
-        vitest: '^4',
-        '@types/node': '^22',
-    };
-    if (withSvelte) {
-        pkgDevDeps['@sveltejs/adapter-static'] = '^3';
-        pkgDevDeps['@sveltejs/kit'] = '^2';
-        pkgDevDeps['@sveltejs/vite-plugin-svelte'] = '^5';
-        pkgDevDeps['svelte'] = '^5';
-        pkgDevDeps['svelte-check'] = '^4';
-    }
-    writeFileSync(join(dir, 'package.json'), JSON.stringify({
-        name,
-        private: true,
-        type: 'module',
-        scripts: {
-            start: 'hatk start',
-            dev: 'hatk dev',
-            build: 'hatk build',
-            check: 'hatk check',
-            format: 'hatk format',
-        },
-        dependencies: pkgDeps,
-        devDependencies: pkgDevDeps,
-    }, null, 2) + '\n');
-    writeFileSync(join(dir, 'tsconfig.server.json'), JSON.stringify({
-        compilerOptions: {
-            target: 'ES2022',
-            module: 'Node16',
-            moduleResolution: 'Node16',
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            noEmit: true,
-            allowImportingTsExtensions: true,
-            resolveJsonModule: true,
-        },
-        include: ['feeds', 'xrpc', 'og', 'seeds', 'labels', 'jobs', 'setup', 'hatk.generated.ts'],
-    }, null, 2) + '\n');
-    writeFileSync(join(dir, 'playwright.config.ts'), `import { defineConfig } from '@playwright/test'
-
-export default defineConfig({
-  testDir: 'test/browser',
-  use: { baseURL: 'http://127.0.0.1:3000' },
-  globalSetup: './test/browser/global-setup.ts',
-})
-`);
-    writeFileSync(join(dir, 'test/browser/global-setup.ts'), `import { execSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
-
-export default function globalSetup() {
-  if (existsSync('src/app.html')) {
-    execSync('npx vite build', { stdio: 'inherit' })
-  }
-}
-`);
-    writeFileSync(join(dir, '.gitignore'), `node_modules/
-*.db
-data/
-test-results/
-.svelte-kit/
-.DS_Store
-public/
-`);
-    writeFileSync(join(dir, '.oxlintrc.json'), `{
-  "ignorePatterns": ["public", "data", ".svelte-kit", "hatk.generated.ts"]
-}
-`);
-    writeFileSync(join(dir, '.oxfmtrc.json'), `{
-  "semi": false,
-  "singleQuote": true,
-  "trailingComma": "all",
-  "printWidth": 120,
-  "tabWidth": 2,
-  "ignorePatterns": ["public", "data", ".svelte-kit", "hatk.generated.ts"]
-}
-`);
-    if (withSvelte) {
-        writeFileSync(join(dir, 'svelte.config.js'), `import adapter from '@sveltejs/adapter-static'
-
-export default {
-  kit: {
-    adapter: adapter({
-      pages: 'public',
-      assets: 'public',
-      fallback: 'index.html',
-    }),
-    paths: { base: '' },
-    alias: {
-      $hatk: './hatk.generated.ts',
-    },
-  },
-}
-`);
-        writeFileSync(join(dir, 'vite.config.ts'), `import { sveltekit } from '@sveltejs/kit/vite'
-import { hatk } from '@hatk/hatk/vite-plugin'
-import { defineConfig } from 'vite'
-
-export default defineConfig({
-  plugins: [sveltekit(), hatk()],
-})
-`);
-        writeFileSync(join(dir, 'tsconfig.json'), JSON.stringify({
-            extends: './.svelte-kit/tsconfig.json',
-            compilerOptions: {
-                allowJs: true,
-                checkJs: false,
-                esModuleInterop: true,
-                forceConsistentCasingInFileNames: true,
-                resolveJsonModule: true,
-                skipLibCheck: true,
-                sourceMap: true,
-                strict: true,
-                moduleResolution: 'bundler',
-                allowImportingTsExtensions: true,
-            },
-        }, null, 2) + '\n');
-        writeFileSync(join(dir, 'src/app.html'), `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="description" content="${name}" />
-    <title>${name}</title>
-    %sveltekit.head%
-  </head>
-  <body data-sveltekit-preload-data="hover">
-    <div style="display: contents">%sveltekit.body%</div>
-  </body>
-</html>
-`);
-        writeFileSync(join(dir, 'src/app.css'), `*,
-*::before,
-*::after {
-  box-sizing: border-box;
-  margin: 0;
-  padding: 0;
-}
-
-:root {
-  --bg-root: #080b12;
-  --bg-surface: #0f1419;
-  --bg-elevated: #161d27;
-  --bg-hover: #1c2633;
-  --border: #1e293b;
-  --teal: #14b8a6;
-  --text-primary: #e2e8f0;
-  --text-secondary: #94a3b8;
-  --text-muted: #64748b;
-}
-
-html {
-  background: var(--bg-root);
-  color: var(--text-primary);
-}
-
-body {
-  font-family: -apple-system, system-ui, sans-serif;
-  font-size: 15px;
-  line-height: 1.5;
-  min-height: 100vh;
-}
-
-a {
-  color: inherit;
-  text-decoration: none;
-}
-`);
-        writeFileSync(join(dir, 'src/routes/+layout.svelte'), `<script lang="ts">
-  import type { Snippet } from 'svelte'
-  import '../app.css'
-
-  let { children }: { children: Snippet } = $props()
-</script>
-
-{@render children()}
-`);
-        writeFileSync(join(dir, 'src/routes/+page.svelte'), `<h1>${name}</h1>
-<p>Your hatk server is running.</p>
-`);
-        writeFileSync(join(dir, 'src/error.html'), `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>%sveltekit.error.message% — ${name}</title>
-    <style>
-      * { box-sizing: border-box; margin: 0; padding: 0; }
-      body {
-        font-family: -apple-system, system-ui, sans-serif;
-        background: #080b12; color: #e2e8f0;
-        min-height: 100vh; display: flex; align-items: center; justify-content: center;
-      }
-      .error-page { display: flex; flex-direction: column; align-items: center; text-align: center; gap: 8px; padding: 24px; }
-      .error-code { font-size: 72px; font-weight: 800; color: #14b8a6; line-height: 1; }
-      .error-title { font-size: 24px; font-weight: 800; }
-      .error-link {
-        margin-top: 16px; padding: 10px 24px; background: #14b8a6; color: #000;
-        border-radius: 20px; font-weight: 600; font-size: 14px; text-decoration: none;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="error-page">
-      <span class="error-code">%sveltekit.status%</span>
-      <h1 class="error-title">%sveltekit.error.message%</h1>
-      <a href="/" class="error-link">Back to home</a>
-    </div>
-  </body>
-</html>
-`);
-        writeFileSync(join(dir, 'src/routes/+error.svelte'), `<script lang="ts">
-  import { page } from '$app/state'
-</script>
-
-<div style="display: flex; flex-direction: column; align-items: center; justify-content: center; min-height: 80vh; gap: 8px;">
-  <span style="font-size: 72px; font-weight: 800; color: var(--teal);">{page.status}</span>
-  <h1 style="font-size: 24px; font-weight: 800;">{page.error?.message}</h1>
-  <a href="/" style="margin-top: 16px; padding: 10px 24px; background: var(--teal); color: #000; border-radius: 20px; font-weight: 600; font-size: 14px;">Back to home</a>
-</div>
-`);
-    }
-    console.log(`Created ${name}/`);
-    console.log(`  config.yaml`);
-    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(`  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`);
-    console.log(`  Dockerfile     — production container`);
-    if (withSvelte) {
-        console.log(`  src/        — SvelteKit frontend`);
-        console.log(`  svelte.config.js`);
-        console.log(`  vite.config.ts`);
-    }
-    // Generate types so the project is ready to go
-    execSync('npx hatk generate types', { stdio: 'inherit', cwd: dir });
-    if (withSvelte) {
-        execSync('npx svelte-kit sync', { stdio: 'inherit', cwd: dir });
-    }
+    console.error('`hatk new` has been removed. Create a new project with:');
+    console.error('');
+    console.error('  vp create github:hatk-dev/hatk-template-starter');
+    console.error('');
+    console.error('Install vp first: curl -fsSL https://vite.plus | bash');
+    process.exit(1);
 }
 else if (command === 'generate') {
     const type = args[1];
@@ -1126,6 +219,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);
@@ -1173,7 +281,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`;
@@ -1329,8 +438,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`;
@@ -1343,21 +457,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`;
@@ -1380,7 +502,146 @@ 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 (typeof window !== 'undefined' && res.status === 401) { const _b = await res.json().catch(() => ({})); const _h = _b.handle ?? 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`;
+        }
+        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 _b = await res.json().catch(() => ({})); const _h = _b.handle ?? 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) { const _b = await res.json().catch(() => ({})); const _h = _b.handle ?? 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`;
+        // 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];
@@ -1408,18 +669,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);
@@ -1429,7 +681,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`);
@@ -1448,18 +700,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}"`);
@@ -1468,7 +711,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)) {
@@ -1482,25 +725,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') {
@@ -1520,9 +752,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);
@@ -1679,41 +911,9 @@ else if (command === 'resolve') {
     console.log(`\nResolved ${resolved.size} lexicon(s). Regenerating types...`);
     execSync('npx hatk generate types', { stdio: 'inherit', cwd: process.cwd() });
 }
-else if (command === 'schema') {
-    const config = 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();
-    }
-}
 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();