@hatk/hatk 0.0.1-alpha.9 → 0.0.1-alpha.92

package/dist/spaces/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../src/spaces/visibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAaH;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE9E;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAElE;AAED,+DAA+D;AAC/D,wBAAgB,cAAc,IAAI,WAAW,CAAC,MAAM,CAAC,CAEpD;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAGzE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAUlH"}

package/dist/spaces/visibility.js

@@ -0,0 +1,81 @@
+/**
+ * Which permissioned spaces the read in flight is allowed to serve.
+ *
+ * Space records are not public data. A space's authority decides who may read
+ * it, and it decides that one caller at a time — so a row indexed out of a
+ * space carries an audience, and serving it to a request that has not proven
+ * it belongs to that audience discloses private data no matter how the query
+ * was written.
+ *
+ * hatk has no other per-row visibility concept. The takedown join is
+ * viewer-independent and `privateCollections` is all-or-nothing, so neither
+ * could carry this. The rule here is instead:
+ *
+ *   a row with `space IS NULL` is public repo data and always readable;
+ *   a row with a space is readable only inside a scope that names that space.
+ *
+ * The default is an empty scope, which serves no space rows at all. That is
+ * deliberate: a read path nobody remembered to scope fails closed and shows a
+ * member nothing, rather than failing open and showing a stranger everything.
+ * Every query over a record table applies `spaceFilterSql`; the scope is
+ * established per request by whoever established the viewer.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+const EMPTY = new Set();
+/**
+ * Async-local rather than a module global: a server answers requests
+ * concurrently, and one viewer's readable set must never be observable from
+ * another's request while an await is outstanding.
+ */
+const store = new AsyncLocalStorage();
+/**
+ * Run `fn` with exactly these spaces readable.
+ *
+ * Replaces rather than extends any enclosing scope: widening what a nested read
+ * may see is never what a caller means, and a scope that only ever narrows is
+ * one that can be reasoned about locally.
+ */
+export function withReadableSpaces(spaces, fn) {
+    return store.run(new Set(spaces), fn);
+}
+/**
+ * Set the readable spaces for the rest of the current async context.
+ *
+ * `withReadableSpaces` wants a callback, and a request handler is a long body
+ * rather than something to wrap — restructuring it around a closure to hold a
+ * scope would be the tail wagging the dog. A server handler already runs in its
+ * own async context per request, which is the case `enterWith` exists for.
+ */
+export function enterReadableSpaces(spaces) {
+    store.enterWith(new Set(spaces));
+}
+/** The spaces this read may serve. Empty outside any scope. */
+export function readableSpaces() {
+    return store.getStore() ?? EMPTY;
+}
+/** Whether a space would be served to the read in flight. */
+export function isSpaceReadable(space) {
+    if (space == null)
+        return true;
+    return readableSpaces().has(space);
+}
+/**
+ * The space gate as a SQL predicate, for a table aliased `alias` (pass '' for
+ * an unaliased table).
+ *
+ * `startIdx` is the next free `$N` placeholder; the returned `nextIdx` is the
+ * next one after this predicate's own. With nothing readable the predicate
+ * binds no parameters at all, which is the shape almost every request takes.
+ */
+export function spaceFilterSql(alias, startIdx) {
+    const col = alias ? `${alias}.space` : 'space';
+    const spaces = [...readableSpaces()];
+    if (spaces.length === 0)
+        return { sql: `${col} IS NULL`, params: [], nextIdx: startIdx };
+    const placeholders = spaces.map((_, i) => `$${startIdx + i}`).join(', ');
+    return {
+        sql: `(${col} IS NULL OR ${col} IN (${placeholders}))`,
+        params: spaces,
+        nextIdx: startIdx + spaces.length,
+    };
+}

package/dist/templates/feed.tpl

@@ -0,0 +1,18 @@
+import { defineFeed } from '$hatk'
+
+export default defineFeed({
+  collection: 'your.collection.here',
+  label: '{{Name}}',
+
+  async generate(ctx) {
+    // ctx.paginate applies the permissioned-space gate for you, so this page
+    // shows a member the spaces they may read and everyone else the public
+    // rows alone. A feed that builds its own SQL over a space-backed table is
+    // refused with an error naming the table; see ctx.spaceFilter.
+    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 })
+  },
+})

package/dist/templates/hook.tpl

@@ -0,0 +1,5 @@
+import { defineHook } from '$hatk'
+
+export default defineHook('{{name}}', async (ctx) => {
+  // Hook logic here
+})

package/dist/templates/label.tpl

@@ -0,0 +1,15 @@
+import { defineLabel } from '$hatk'
+
+export default defineLabel({
+  definition: {
+    identifier: '{{name}}',
+    severity: 'inform',
+    blurs: 'none',
+    defaultSetting: 'warn',
+    locales: [{ lang: 'en', name: '{{Name}}', description: 'Description here' }],
+  },
+  async evaluate(ctx) {
+    // Return array of label identifiers to apply, or empty array
+    return []
+  },
+})

package/dist/templates/og.tpl

@@ -0,0 +1,17 @@
+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,
+        },
+      },
+    }
+  },
+}

package/dist/templates/seed.tpl

@@ -0,0 +1,11 @@
+import { seed } from '$hatk'
+
+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!')

package/dist/templates/setup.tpl

@@ -0,0 +1,5 @@
+import { defineSetup } from '$hatk'
+
+export default defineSetup(async (ctx) => {
+  // Setup logic here — runs before the server starts
+})

package/dist/templates/test-feed.tpl

@@ -0,0 +1,19 @@
+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()
+  })
+})

package/dist/templates/test-xrpc.tpl

@@ -0,0 +1,19 @@
+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()
+  })
+})

package/dist/templates/xrpc.tpl

@@ -0,0 +1,53 @@
+import { defineQuery } from '$hatk'
+
+export default defineQuery('{{name}}', async (ctx) => {
+  const { ok, db, params, packCursor, unpackCursor, spaceFilter } = ctx
+  const limit = params.limit ?? 30
+  const cursor = params.cursor
+
+  const conditions: string[] = []
+  const sqlParams: (string | number)[] = []
+  let paramIdx = 1
+
+  // Which permissioned spaces this viewer may be shown. Typed helpers like
+  // ctx.lookup and ctx.getRecords apply this already; hand-written SQL cannot,
+  // because nothing can inject a predicate into a string you wrote. Drop it on
+  // a collection a space writes into and hatk refuses the query by name.
+  //
+  // Outside a viewer's scope it is `s.space IS NULL` and binds nothing, so on an
+  // instance that indexes no space it costs one test on an indexed column.
+  const spaces = spaceFilter('s', paramIdx)
+  conditions.push(spaces.sql)
+  sqlParams.push(...spaces.params)
+  paramIdx = spaces.nextIdx
+
+  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]),
+  )) as {
+    uri: string
+    cid: string
+    did: string
+    indexed_at: string
+  }[]
+
+  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,
+  })
+})

package/dist/test.d.ts

@@ -4,7 +4,9 @@ import type { FeedContext } from './feeds.ts';
 export interface TestContext {
     db: {
         query: (sql: string, params?: any[]) => Promise<any[]>;
-        run: (sql: string, ...params: any[]) => Promise<void>;
+        run: (sql: string, params?: any[]) => Promise<void>;
+        /** Raw SQL with the permissioned-space guard off, as the runtime contexts have it. */
+        unfiltered: (sql: string, params?: any[]) => Promise<any[]>;
     };
     loadFixtures: (dir?: string) => Promise<void>;
     loadFeed: (name: string) => {

package/dist/test.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAIA,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAmBzD,OAAO,EAAE,IAAI,IAAI,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAA;AAIpE,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,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;QACnD,sFAAsF;QACtF,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;KAC5D,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,CAyL9D;AA8BD,wBAAsB,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,CAiD3D"}

package/dist/test.js

@@ -1,27 +1,32 @@
 import { resolve, dirname } from 'node:path';
 import { readdirSync, readFileSync } from 'node:fs';
+import { registerHatkResolveHook } from "./resolve-hatk.js";
 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 { validatableLexicons, loadLexicons, storeLexicons, discoverCollections, generateTableSchema, generateCreateTableSQL, } from "./database/schema.js";
+import { initDatabase, querySQL, runSQL, insertRecord, closeDatabase } from "./database/db.js";
+import { createAdapter } from "./database/adapter-factory.js";
+import { SQLITE_DIALECT } from "./database/dialect.js";
+import { rebuildAllIndexes, setSearchPort } from "./database/fts.js";
+import { executeFeed, listFeeds, createPaginate } from "./feeds.js";
+import { executeXrpc, listXrpc, configureRelay, configureCdn } from "./xrpc.js";
+import { initServer } from "./server-init.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 { packCursor, unpackCursor, isTakendownDid, filterTakendownDids } from "./database/db.js";
 import { seed as createSeedHelpers } from "./seed.js";
+import { setPrivateCollections } from "./private-collections.js";
+import { spaceFilterSql } from "./spaces/visibility.js";
+import { guardedQuerySQL, unfilteredQuerySQL } from "./spaces/guard.js";
 /**
- * Find the project's config.yaml by walking up from cwd.
- * Returns the resolved config path, or falls back to 'config.yaml'.
+ * Find the project's hatk.config.ts by walking up from cwd.
+ * Returns the resolved config path, or falls back to 'hatk.config.ts'.
  */
 function findConfigPath() {
     const explicit = process.env.APPVIEW_CONFIG;
     if (explicit)
         return resolve(explicit);
-    return resolve('config.yaml');
+    return resolve('hatk.config.ts');
 }
 /**
  * Boot an in-memory hatk context for unit tests.
@@ -33,13 +38,15 @@ function findConfigPath() {
  * but it will NOT work with --pool=threads (multiple tests sharing a process).
  */
 export async function createTestContext() {
+    registerHatkResolveHook();
     const configPath = findConfigPath();
-    const config = loadConfig(configPath);
+    const config = await loadConfig(configPath);
     const configDir = dirname(resolve(configPath));
     configureRelay(config.relay);
+    configureCdn(config.cdn);
     // Load and validate lexicons
     const lexicons = loadLexicons(resolve(configDir, 'lexicons'));
-    const lexiconErrors = validateLexicons([...lexicons.values()]);
+    const lexiconErrors = validateLexicons(validatableLexicons(lexicons));
     if (lexiconErrors) {
         const messages = Object.entries(lexiconErrors).flatMap(([nsid, errs]) => errs.map((e) => `${nsid}: ${e}`));
         throw new Error(`Invalid lexicons:\n${messages.join('\n')}`);
@@ -56,25 +63,30 @@ export async function createTestContext() {
             continue;
         const schema = generateTableSchema(nsid, lexicon, lexicons);
         schemas.push(schema);
-        ddlStatements.push(generateCreateTableSQL(schema));
+        ddlStatements.push(generateCreateTableSQL(schema, SQLITE_DIALECT));
     }
-    // In-memory DuckDB
-    await initDatabase(':memory:', schemas, ddlStatements);
-    // Discover views + hooks
+    // In-memory SQLite — faster startup, no native module issues in Vite's module runner
+    const { adapter, searchPort } = await createAdapter('sqlite');
+    setSearchPort(searchPort);
+    await initDatabase(adapter, ':memory:', schemas, ddlStatements);
+    // Create the FTS shadow tables up front. main.ts does this after backfill;
+    // a test has no backfill, so without it the tables never exist and every
+    // ctx.search() fails its BM25 phase with "no such table: _fts_...". SQLite
+    // has no fuzzy phase to fall back on — jaroWinklerSimilarity is null there —
+    // so the failure surfaces as an empty result rather than an error, which is
+    // why it went unnoticed.
+    //
+    // The indexes are empty at this point; what matters is that this also fills
+    // the search-column cache, which is what lets insertRecord() index each
+    // record as it is written. Records inserted with raw SQL bypass that path and
+    // remain unsearchable, as they do in production.
+    await rebuildAllIndexes(collections);
+    // Discover views
     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'));
+    // Discover feeds, xrpc, labels, hooks, og from server/ directory (skip setup scripts in tests)
+    await initServer(resolve(configDir, 'server'), { skipSetup: true });
     return {
-        db: { query: querySQL, run: runSQL },
+        db: { query: guardedQuerySQL, run: runSQL, unfiltered: unfilteredQuerySQL },
         _config: config,
         _collections: collections,
         loadFixtures: async (dir) => {
@@ -94,7 +106,12 @@ export async function createTestContext() {
                 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());
+                        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(),
+                        ]);
                     }
                 }
             }
@@ -119,7 +136,7 @@ export async function createTestContext() {
                         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);
+                        await runSQL(`INSERT INTO "${tableName}" (${keys.map((k) => `"${k}"`).join(', ')}) VALUES (${placeholders})`, vals);
                     }
                     continue;
                 }
@@ -133,7 +150,12 @@ export async function createTestContext() {
                     // 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 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);
                 }
@@ -164,14 +186,14 @@ export async function createTestContext() {
         },
         feedContext: (opts) => {
             const paginateDeps = {
-                db: { query: querySQL },
+                db: { query: guardedQuerySQL, unfiltered: unfilteredQuerySQL },
                 cursor: opts?.cursor,
                 limit: opts?.limit || 30,
                 packCursor,
                 unpackCursor,
             };
             return {
-                db: { query: querySQL },
+                db: { query: guardedQuerySQL, unfiltered: unfilteredQuerySQL },
                 params: opts?.params || {},
                 cursor: opts?.cursor,
                 limit: opts?.limit || 30,
@@ -181,6 +203,7 @@ export async function createTestContext() {
                 isTakendown: isTakendownDid,
                 filterTakendownDids,
                 paginate: createPaginate(paginateDeps),
+                spaceFilter: spaceFilterSql,
             };
         },
         close: async () => {
@@ -220,10 +243,11 @@ export async function startTestServer() {
     // 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'];
+    const resolveViewer = (request) => {
+        const did = request.headers.get('x-test-viewer');
         return typeof did === 'string' ? { did } : null;
     };
+    setPrivateCollections(ctx._config.privateCollections);
     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;

package/dist/views.js

@@ -3,7 +3,7 @@
 //   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";
+import { getAllLexicons, getLexicon } from "./database/schema.js";
 // --- Registry ---
 /** All views keyed by full NSID (e.g., "fm.teal.alpha.feed.play#playView") */
 const views = new Map();

package/dist/vite-plugin.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from 'vite';
+import { type Plugin } from 'vite';
 export declare function hatk(opts?: {
     port?: number;
 }): Plugin;

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

@@ -1 +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,CAuFrD"}
+{"version":3,"file":"vite-plugin.d.ts","sourceRoot":"","sources":["../src/vite-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,KAAK,MAAM,EAA6C,MAAM,MAAM,CAAA;AA8D3G,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAoOrD"}