@hatk/hatk 0.0.1-alpha.0

package/dist/setup.d.ts

@@ -0,0 +1,8 @@
+export interface SetupContext {
+    db: {
+        query: (sql: string, params?: any[]) => Promise<any[]>;
+        run: (sql: string, ...params: any[]) => Promise<void>;
+    };
+}
+export declare function initSetup(setupDir: string): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map

package/dist/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE;QACF,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;QACtD,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KACtD,CAAA;CACF;AAiBD,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB/D"}

package/dist/setup.js

@@ -0,0 +1,48 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { resolve, relative } from 'node:path';
+import { readdirSync, statSync } from 'node:fs';
+import { log } from "./logger.js";
+import { querySQL, runSQL } from "./db.js";
+function walkDir(dir) {
+    const results = [];
+    try {
+        for (const entry of readdirSync(dir)) {
+            const full = resolve(dir, entry);
+            if (statSync(full).isDirectory()) {
+                results.push(...walkDir(full));
+            }
+            else if ((entry.endsWith('.ts') || entry.endsWith('.js')) && !entry.startsWith('_')) {
+                results.push(full);
+            }
+        }
+    }
+    catch { }
+    return results.sort();
+}
+export async function initSetup(setupDir) {
+    const files = walkDir(setupDir);
+    if (files.length === 0)
+        return;
+    for (const scriptPath of files) {
+        const name = relative(setupDir, scriptPath).replace(/\.(ts|js)$/, '');
+        const mod = await import(__rewriteRelativeImportExtension(scriptPath));
+        const handler = mod.default?.handler || mod.default;
+        if (typeof handler !== 'function') {
+            console.warn(`[setup] ${name}: no handler function found, skipping`);
+            continue;
+        }
+        const ctx = {
+            db: { query: querySQL, run: runSQL },
+        };
+        log(`[setup] running: ${name}`);
+        await handler(ctx);
+        log(`[setup] done: ${name}`);
+    }
+}

package/dist/test-browser.d.ts

@@ -0,0 +1,14 @@
+import { expect, type Page } from '@playwright/test';
+import type { TestServer } from './test.ts';
+type WorkerFixtures = {
+    server: TestServer;
+};
+/** Inject __TEST_AUTH__ into a page so isLoggedIn() and viewerDid() work. */
+export declare function loginAs(page: Page, did: string): Promise<void>;
+/**
+ * Extended Playwright test with an auto-started hatk server fixture.
+ * The server starts once per test file (worker scope) and is shared across tests.
+ */
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions & WorkerFixtures>;
+export { expect };
+//# sourceMappingURL=test-browser.d.ts.map

package/dist/test-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-browser.d.ts","sourceRoot":"","sources":["../src/test-browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAG3C,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,UAAU,CAAA;CACnB,CAAA;AAED,6EAA6E;AAC7E,wBAAsB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpE;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,8PAWf,CAAA;AAEF,OAAO,EAAE,MAAM,EAAE,CAAA"}

package/dist/test-browser.js

@@ -0,0 +1,26 @@
+import { test as base, expect } from '@playwright/test';
+import { startTestServer } from "./test.js";
+/** Inject __TEST_AUTH__ into a page so isLoggedIn() and viewerDid() work. */
+export async function loginAs(page, did) {
+    await page.addInitScript((d) => {
+        ;
+        window.__TEST_AUTH__ = { did: d };
+    }, did);
+}
+/**
+ * Extended Playwright test with an auto-started hatk server fixture.
+ * The server starts once per test file (worker scope) and is shared across tests.
+ */
+export const test = base.extend({
+    // eslint-disable-next-line no-empty-pattern -- Playwright fixture API requires the deps arg
+    server: [
+        async (_deps, use) => {
+            const server = await startTestServer();
+            await server.loadFixtures();
+            await use(server);
+            await server.close();
+        },
+        { scope: 'worker' },
+    ],
+});
+export { expect };

package/dist/test.d.ts

@@ -0,0 +1,47 @@
+import { type HatkConfig } from './config.ts';
+import { seed as createSeedHelpers, type SeedOpts } from './seed.ts';
+import type { FeedContext } from './feeds.ts';
+export interface TestContext {
+    db: {
+        query: (sql: string, params?: any[]) => Promise<any[]>;
+        run: (sql: string, ...params: any[]) => Promise<void>;
+    };
+    loadFixtures: (dir?: string) => Promise<void>;
+    loadFeed: (name: string) => {
+        generate: (ctx: FeedContext) => Promise<any>;
+    };
+    loadXrpc: (name: string) => {
+        handler: (ctx: any) => Promise<any>;
+    };
+    feedContext: (opts?: {
+        limit?: number;
+        cursor?: string;
+        viewer?: {
+            did: string;
+        } | null;
+        params?: Record<string, string>;
+    }) => FeedContext;
+    close: () => Promise<void>;
+    /** @internal */ _config: HatkConfig;
+    /** @internal */ _collections: string[];
+}
+export interface TestServer extends TestContext {
+    url: string;
+    port: number;
+    fetch: (path: string, init?: RequestInit) => Promise<Response>;
+    fetchAs: (did: string, path: string, init?: RequestInit) => Promise<Response>;
+    seed: (opts?: SeedOpts) => ReturnType<typeof createSeedHelpers>;
+    waitForRecord: (uri: string, timeoutMs?: number) => Promise<void>;
+}
+/**
+ * Boot an in-memory hatk context for unit tests.
+ * Loads lexicons, creates in-memory DuckDB, discovers feeds/xrpc/labels.
+ * No HTTP server, no PDS, no indexer.
+ *
+ * Note: uses module-level singletons (DB, feeds, xrpc, labels).
+ * Each vitest worker runs in its own process so this is safe by default,
+ * but it will NOT work with --pool=threads (multiple tests sharing a process).
+ */
+export declare function createTestContext(): Promise<TestContext>;
+export declare function startTestServer(): Promise<TestServer>;
+//# sourceMappingURL=test.d.ts.map

package/dist/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAIA,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAiBzD,OAAO,EAAE,IAAI,IAAI,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE;QACF,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;QACtD,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KACtD,CAAA;IACD,YAAY,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;KAAE,CAAA;IAC5E,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;KAAE,CAAA;IACnE,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE;QACnB,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,MAAM,CAAC,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAA;QAC/B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAChC,KAAK,WAAW,CAAA;IACjB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAA;IACpC,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CACxC;AAED,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC7C,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC9D,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC7E,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;IAC/D,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAClE;AAYD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,WAAW,CAAC,CAiL9D;AA8BD,wBAAsB,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,CAgD3D"}

package/dist/test.js

@@ -0,0 +1,256 @@
+import { resolve, dirname } from 'node:path';
+import { readdirSync, readFileSync } from 'node:fs';
+import YAML from 'yaml';
+import { loadConfig } from "./config.js";
+import { loadLexicons, storeLexicons, discoverCollections, generateTableSchema, generateCreateTableSQL, } from "./schema.js";
+import { initDatabase, querySQL, runSQL, insertRecord, closeDatabase } from "./db.js";
+import { initFeeds, executeFeed, listFeeds, createPaginate } from "./feeds.js";
+import { initXrpc, executeXrpc, listXrpc, configureRelay } from "./xrpc.js";
+import { initOpengraph } from "./opengraph.js";
+import { initLabels } from "./labels.js";
+import { discoverViews } from "./views.js";
+import { loadOnLoginHook } from "./oauth/hooks.js";
+import { validateLexicons } from '@bigmoves/lexicon';
+import { packCursor, unpackCursor, isTakendownDid, filterTakendownDids } from "./db.js";
+import { seed as createSeedHelpers } from "./seed.js";
+/**
+ * Find the project's config.yaml by walking up from cwd.
+ * Returns the resolved config path, or falls back to 'config.yaml'.
+ */
+function findConfigPath() {
+    const explicit = process.env.APPVIEW_CONFIG;
+    if (explicit)
+        return resolve(explicit);
+    return resolve('config.yaml');
+}
+/**
+ * Boot an in-memory hatk context for unit tests.
+ * Loads lexicons, creates in-memory DuckDB, discovers feeds/xrpc/labels.
+ * No HTTP server, no PDS, no indexer.
+ *
+ * Note: uses module-level singletons (DB, feeds, xrpc, labels).
+ * Each vitest worker runs in its own process so this is safe by default,
+ * but it will NOT work with --pool=threads (multiple tests sharing a process).
+ */
+export async function createTestContext() {
+    const configPath = findConfigPath();
+    const config = loadConfig(configPath);
+    const configDir = dirname(resolve(configPath));
+    configureRelay(config.relay);
+    // Load and validate lexicons
+    const lexicons = loadLexicons(resolve(configDir, 'lexicons'));
+    const lexiconErrors = validateLexicons([...lexicons.values()]);
+    if (lexiconErrors) {
+        const messages = Object.entries(lexiconErrors).flatMap(([nsid, errs]) => errs.map((e) => `${nsid}: ${e}`));
+        throw new Error(`Invalid lexicons:\n${messages.join('\n')}`);
+    }
+    storeLexicons(lexicons);
+    // Discover collections
+    const collections = config.collections.length > 0 ? config.collections : discoverCollections(lexicons);
+    // Generate schemas
+    const schemas = [];
+    const ddlStatements = [];
+    for (const nsid of collections) {
+        const lexicon = lexicons.get(nsid);
+        if (!lexicon)
+            continue;
+        const schema = generateTableSchema(nsid, lexicon, lexicons);
+        schemas.push(schema);
+        ddlStatements.push(generateCreateTableSQL(schema));
+    }
+    // In-memory DuckDB
+    await initDatabase(':memory:', schemas, ddlStatements);
+    // Discover views + hooks
+    discoverViews();
+    try {
+        await loadOnLoginHook(resolve(configDir, 'hooks'));
+    }
+    catch { }
+    // Skip setup hooks in test context — they're for server boot-time
+    // initialization (e.g. importing large datasets) and not appropriate for tests
+    // Discover feeds, xrpc, labels
+    await initFeeds(resolve(configDir, 'feeds'));
+    await initXrpc(resolve(configDir, 'xrpc'));
+    await initOpengraph(resolve(configDir, 'og'));
+    await initLabels(resolve(configDir, 'labels'));
+    return {
+        db: { query: querySQL, run: runSQL },
+        _config: config,
+        _collections: collections,
+        loadFixtures: async (dir) => {
+            const fixturesDir = resolve(dir || 'test/fixtures');
+            let files;
+            try {
+                files = readdirSync(fixturesDir).filter((f) => f.endsWith('.yaml') || f.endsWith('.yml'));
+            }
+            catch {
+                throw new Error(`Fixtures directory not found: ${fixturesDir}`);
+            }
+            // Load _repos.yaml first if it exists, so handles are registered before records
+            const reposFile = files.find((f) => f.replace(/\.ya?ml$/, '') === '_repos');
+            if (reposFile) {
+                const content = readFileSync(resolve(fixturesDir, reposFile), 'utf-8');
+                const records = YAML.parse(content);
+                if (Array.isArray(records)) {
+                    for (const rec of records) {
+                        const row = interpolateHelpers(rec);
+                        await runSQL(`INSERT OR IGNORE INTO _repos (did, status, handle, backfilled_at) VALUES ($1, $2, $3, $4)`, row.did, row.status || 'active', row.handle || row.did.split(':').pop() + '.test', new Date().toISOString());
+                    }
+                }
+            }
+            const seenDids = new Set();
+            for (const file of files) {
+                const tableName = file.replace(/\.ya?ml$/, '');
+                if (tableName === '_repos')
+                    continue;
+                const content = readFileSync(resolve(fixturesDir, file), 'utf-8');
+                const records = YAML.parse(content);
+                if (!Array.isArray(records))
+                    continue;
+                const isCollection = collections.includes(tableName);
+                if (!isCollection) {
+                    // Custom table: auto-create from first record's keys, then INSERT
+                    if (records.length === 0)
+                        continue;
+                    const keys = Object.keys(interpolateHelpers(records[0]));
+                    const colDefs = keys.map((k) => `"${k}" VARCHAR`).join(', ');
+                    await runSQL(`CREATE TABLE IF NOT EXISTS "${tableName}" (${colDefs})`);
+                    for (const rec of records) {
+                        const row = interpolateHelpers(rec);
+                        const vals = keys.map((k) => row[k]);
+                        const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
+                        await runSQL(`INSERT INTO "${tableName}" (${keys.map((k) => `"${k}"`).join(', ')}) VALUES (${placeholders})`, ...vals);
+                    }
+                    continue;
+                }
+                for (let i = 0; i < records.length; i++) {
+                    const rec = interpolateHelpers(records[i]);
+                    const did = rec.did || 'did:plc:test';
+                    const rkey = rec.rkey || rec.uri?.split('/').pop() || String(i);
+                    const uri = rec.uri || `at://${did}/${tableName}/${rkey}`;
+                    const cid = rec.cid || `cid${i}`;
+                    const fields = Object.fromEntries(Object.entries(rec).filter(([k]) => !['uri', 'cid', 'did', 'rkey'].includes(k)));
+                    // Auto-register DID in _repos if not already present
+                    if (!seenDids.has(did)) {
+                        seenDids.add(did);
+                        await runSQL(`INSERT OR IGNORE INTO _repos (did, status, handle, backfilled_at) VALUES ($1, $2, $3, $4)`, did, 'active', did.split(':').pop() + '.test', new Date().toISOString());
+                    }
+                    await insertRecord(tableName, uri, cid, did, fields);
+                }
+            }
+        },
+        loadFeed: (name) => {
+            const feedList = listFeeds();
+            if (!feedList.find((f) => f.name === name))
+                throw new Error(`Feed "${name}" not found. Available: ${feedList.map((f) => f.name).join(', ')}`);
+            return {
+                generate: (ctx) => executeFeed(name, ctx.params || {}, ctx.cursor, ctx.limit, ctx.viewer),
+            };
+        },
+        loadXrpc: (name) => {
+            const xrpcList = listXrpc();
+            if (!xrpcList.includes(name))
+                throw new Error(`XRPC handler "${name}" not found. Available: ${xrpcList.join(', ')}`);
+            return {
+                handler: (ctx) => {
+                    const params = { ...ctx.params };
+                    if (ctx.cursor != null && params.cursor == null)
+                        params.cursor = ctx.cursor;
+                    if (ctx.limit != null && params.limit == null)
+                        params.limit = String(ctx.limit);
+                    return executeXrpc(name, params, ctx.cursor, ctx.limit ?? 30, ctx.viewer);
+                },
+            };
+        },
+        feedContext: (opts) => {
+            const paginateDeps = {
+                db: { query: querySQL },
+                cursor: opts?.cursor,
+                limit: opts?.limit || 30,
+                packCursor,
+                unpackCursor,
+            };
+            return {
+                db: { query: querySQL },
+                params: opts?.params || {},
+                cursor: opts?.cursor,
+                limit: opts?.limit || 30,
+                viewer: opts?.viewer ?? null,
+                packCursor,
+                unpackCursor,
+                isTakendown: isTakendownDid,
+                filterTakendownDids,
+                paginate: createPaginate(paginateDeps),
+            };
+        },
+        close: async () => {
+            closeDatabase();
+        },
+    };
+}
+/**
+ * Boot a full hatk HTTP server on a random port for integration tests.
+ * Includes everything from createTestContext plus an HTTP server.
+ */
+const NOW_RE = /^\$now(?:\(([+-]?\d+)([smhd])\))?$/;
+function interpolateHelpers(value) {
+    if (typeof value === 'string') {
+        const m = value.match(NOW_RE);
+        if (m) {
+            const offset = m[1] ? parseInt(m[1]) : 0;
+            const unit = m[2] || 's';
+            const ms = offset * { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[unit];
+            return new Date(Date.now() + ms).toISOString();
+        }
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(interpolateHelpers);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = interpolateHelpers(v);
+        }
+        return out;
+    }
+    return value;
+}
+export async function startTestServer() {
+    const ctx = await createTestContext();
+    // Import startServer — it creates the HTTP server and returns it
+    const { startServer } = await import("./server.js");
+    // Start server on port 0 (random available port)
+    const resolveViewer = (req) => {
+        const did = req.headers['x-test-viewer'];
+        return typeof did === 'string' ? { did } : null;
+    };
+    const httpServer = startServer(0, ctx._collections, ctx._config.publicDir, ctx._config.oauth, ctx._config.admins, resolveViewer);
+    await new Promise((resolve) => httpServer.on('listening', resolve));
+    const port = httpServer.address().port;
+    const url = `http://127.0.0.1:${port}`;
+    return {
+        ...ctx,
+        url,
+        port,
+        fetch: (path, init) => fetch(`${url}${path}`, init),
+        fetchAs: (did, path, init) => fetch(`${url}${path}`, {
+            ...init,
+            headers: { ...init?.headers, 'x-test-viewer': did },
+        }),
+        seed: (seedOpts) => createSeedHelpers(seedOpts),
+        waitForRecord: async (uri, timeoutMs = 10_000) => {
+            const start = Date.now();
+            while (Date.now() - start < timeoutMs) {
+                const record = await querySQL(`SELECT uri FROM "${uri.split('/')[3]}" WHERE uri = $1`, [uri]).catch(() => []);
+                if (record.length > 0)
+                    return;
+                await new Promise((r) => setTimeout(r, 100));
+            }
+            throw new Error(`Timed out waiting for record: ${uri}`);
+        },
+        close: async () => {
+            httpServer.close();
+            await ctx.close();
+        },
+    };
+}

package/dist/views.d.ts

@@ -0,0 +1,40 @@
+interface ViewFieldRef {
+    kind: 'ref';
+    fieldName: string;
+    collection: string;
+    joinField: string;
+    blobFields: Map<string, string>;
+}
+interface ViewFieldScalar {
+    kind: 'scalar';
+    fieldName: string;
+    type: string;
+    format?: string;
+}
+interface ViewFieldLabels {
+    kind: 'labels';
+    fieldName: string;
+}
+type ViewField = ViewFieldRef | ViewFieldScalar | ViewFieldLabels;
+export interface ViewDef {
+    /** Full NSID key (e.g., "fm.teal.alpha.feed.play#playView") */
+    nsid: string;
+    /** The record collection this view hydrates */
+    collection: string;
+    /** The def name (e.g., "playView") */
+    name: string;
+    /** The record field name, or null for flattened views (bsky pattern) */
+    recordField: string | null;
+    /** Blob fields on the record itself — for flattened views */
+    blobFields: Map<string, string>;
+    /** All other fields and their hydration instructions */
+    fields: ViewField[];
+}
+/** Get a view def by full NSID. */
+export declare function getViewDef(nsid: string): ViewDef | undefined;
+/** Get the default view def for a collection (used by feed auto-hydration). */
+export declare function getDefaultView(collection: string): ViewDef | undefined;
+/** Discover view defs from all loaded lexicons. */
+export declare function discoverViews(): void;
+export {};
+//# sourceMappingURL=views.d.ts.map

package/dist/views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../src/views.ts"],"names":[],"mappings":"AAUA,UAAU,YAAY;IACpB,IAAI,EAAE,KAAK,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAChC;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,KAAK,SAAS,GAAG,YAAY,GAAG,eAAe,GAAG,eAAe,CAAA;AAEjE,MAAM,WAAW,OAAO;IACtB,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAA;IACZ,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAA;IAClB,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,wEAAwE;IACxE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,6DAA6D;IAC7D,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wDAAwD;IACxD,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB;AAUD,mCAAmC;AACnC,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAE5D;AAED,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAGtE;AAED,mDAAmD;AACnD,wBAAgB,aAAa,IAAI,IAAI,CA4CpC"}

package/dist/views.js

@@ -0,0 +1,178 @@
+// views.ts — View registry: discovers view defs from lexicons, builds hydration pipelines.
+// Supports two patterns:
+//   1. Inline views: defined in the record lexicon with ref: "#main" (e.g., playView)
+//   2. Defs views: defined in a defs lexicon, associated by naming convention (e.g., profileView)
+import { log } from "./logger.js";
+import { getAllLexicons, getLexicon } from "./schema.js";
+// --- Registry ---
+/** All views keyed by full NSID (e.g., "fm.teal.alpha.feed.play#playView") */
+const views = new Map();
+/** Reverse index: collection → default view NSID (the {name}View variant) */
+const collectionDefaults = new Map();
+/** Get a view def by full NSID. */
+export function getViewDef(nsid) {
+    return views.get(nsid);
+}
+/** Get the default view def for a collection (used by feed auto-hydration). */
+export function getDefaultView(collection) {
+    const viewNsid = collectionDefaults.get(collection);
+    return viewNsid ? views.get(viewNsid) : undefined;
+}
+/** Discover view defs from all loaded lexicons. */
+export function discoverViews() {
+    views.clear();
+    collectionDefaults.clear();
+    const lexicons = getAllLexicons();
+    for (const { nsid, lexicon } of lexicons) {
+        if (!lexicon.defs)
+            continue;
+        const namespace = nsid.split('.').slice(0, -1).join('.');
+        for (const [defName, def] of Object.entries(lexicon.defs)) {
+            if (defName === 'main')
+                continue;
+            if (def.type !== 'object')
+                continue;
+            if (!def.properties)
+                continue;
+            if (!defName.includes('View') && !defName.includes('view'))
+                continue;
+            // Pattern 1: Inline view — has a property that refs #main
+            const recordFieldEntry = Object.entries(def.properties).find(([_, prop]) => prop.type === 'ref' && prop.ref === '#main');
+            if (recordFieldEntry) {
+                // Inline view: the record lexicon IS the collection
+                const viewDef = buildInlineViewDef(nsid, defName, recordFieldEntry[0], def);
+                const fullNsid = `${nsid}#${defName}`;
+                views.set(fullNsid, viewDef);
+                registerDefault(viewDef.collection, defName, fullNsid);
+                log(`[views] discovered: ${fullNsid} → ${viewDef.collection} (inline, ${viewDef.fields.length} fields)`);
+                continue;
+            }
+            // Pattern 2: Defs view — associate by naming convention
+            const recordName = extractRecordName(defName);
+            if (!recordName)
+                continue;
+            const collection = findRecordCollection(recordName, namespace, lexicons);
+            if (!collection)
+                continue;
+            const viewDef = buildDefsViewDef(nsid, defName, collection, def);
+            const fullNsid = `${nsid}#${defName}`;
+            views.set(fullNsid, viewDef);
+            registerDefault(collection, defName, fullNsid);
+            log(`[views] discovered: ${fullNsid} → ${collection} (defs, ${viewDef.fields.length} fields)`);
+        }
+    }
+}
+// --- View Builders ---
+/** Build a ViewDef for an inline view (has ref: "#main"). */
+function buildInlineViewDef(nsid, defName, recordFieldName, def) {
+    const fields = [];
+    for (const [fieldName, prop] of Object.entries(def.properties)) {
+        if (fieldName === recordFieldName)
+            continue;
+        if (prop.type === 'ref') {
+            const resolved = resolveRefCollection(prop.ref, nsid);
+            if (resolved) {
+                const refLexicon = getLexicon(resolved);
+                const mainDef = refLexicon?.defs?.main;
+                const joinField = mainDef?.key === 'literal:self' ? 'did' : 'uri';
+                const blobs = discoverBlobFields(mainDef);
+                fields.push({ kind: 'ref', fieldName, collection: resolved, joinField, blobFields: blobs });
+            }
+        }
+        else if (prop.type === 'array' && prop.items?.type === 'ref' && prop.items.ref?.includes('label')) {
+            fields.push({ kind: 'labels', fieldName });
+        }
+        else {
+            fields.push({ kind: 'scalar', fieldName, type: prop.type, format: prop.format });
+        }
+    }
+    return {
+        nsid: `${nsid}#${defName}`,
+        collection: nsid,
+        name: defName,
+        recordField: recordFieldName,
+        blobFields: new Map(),
+        fields,
+    };
+}
+/** Build a ViewDef for a defs-pattern view (flattened, no ref: "#main"). */
+function buildDefsViewDef(defsNsid, defName, collection, def) {
+    const fields = [];
+    // Get the record's schema to detect blob fields
+    const recordLexicon = getLexicon(collection);
+    const mainDef = recordLexicon?.defs?.main;
+    const blobFields = discoverBlobFields(mainDef);
+    for (const [fieldName, prop] of Object.entries(def.properties)) {
+        // Skip envelope fields — these come from the row, not hydration
+        if (['did', 'handle', 'indexedAt'].includes(fieldName))
+            continue;
+        // Skip fields that are record properties (they come from flattening the record)
+        if (mainDef?.record?.properties?.[fieldName])
+            continue;
+        if (prop.type === 'array' && prop.items?.type === 'ref' && prop.items.ref?.includes('label')) {
+            fields.push({ kind: 'labels', fieldName });
+        }
+        else if (prop.type === 'ref') {
+            // Could be viewer state or other refs — treat as scalar for now
+            // Viewer hooks handle viewer state enrichment
+            fields.push({ kind: 'scalar', fieldName, type: 'ref' });
+        }
+        else {
+            fields.push({ kind: 'scalar', fieldName, type: prop.type, format: prop.format });
+        }
+    }
+    return {
+        nsid: `${defsNsid}#${defName}`,
+        collection,
+        name: defName,
+        recordField: null,
+        blobFields,
+        fields,
+    };
+}
+// --- Helpers ---
+/** Register a view as the default for its collection if it's the base {name}View variant. */
+function registerDefault(collection, defName, fullNsid) {
+    // {name}View is the default; {name}ViewBasic / {name}ViewDetailed are not
+    if (defName.endsWith('View') && !collectionDefaults.has(collection)) {
+        collectionDefaults.set(collection, fullNsid);
+    }
+}
+/** Extract the record name from a view def name. profileView → profile, playViewDetailed → play */
+function extractRecordName(defName) {
+    const match = defName.match(/^(.+?)View(Basic|Detailed)?$/);
+    return match ? match[1] : null;
+}
+/** Find a record-type lexicon matching a name in the given namespace. */
+function findRecordCollection(recordName, namespace, lexicons) {
+    const target = `${namespace}.${recordName}`;
+    const lex = lexicons.find((l) => l.nsid === target);
+    if (lex?.lexicon?.defs?.main?.type === 'record')
+        return target;
+    return null;
+}
+/** Resolve a ref string to a collection NSID. */
+function resolveRefCollection(ref, currentNsid) {
+    if (ref.startsWith('#'))
+        return currentNsid;
+    if (ref.includes('#'))
+        return ref.split('#')[0];
+    return ref;
+}
+/** Find blob-typed fields in a record def and assign CDN presets by field name. */
+function discoverBlobFields(mainDef) {
+    const blobs = new Map();
+    if (!mainDef?.record?.properties)
+        return blobs;
+    const presetMap = {
+        avatar: 'avatar',
+        banner: 'banner',
+        thumbnail: 'feed_thumbnail',
+    };
+    for (const [name, prop] of Object.entries(mainDef.record.properties)) {
+        if (prop.type === 'blob') {
+            blobs.set(name, presetMap[name] || 'feed_fullsize');
+        }
+    }
+    return blobs;
+}

package/dist/vite-plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+export declare function hatk(opts?: {
+    port?: number;
+}): Plugin;
+//# sourceMappingURL=vite-plugin.d.ts.map

package/dist/vite-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin.d.ts","sourceRoot":"","sources":["../src/vite-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAKlC,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAsFrD"}