@hatk/hatk 0.0.1-alpha.41 → 0.0.1-alpha.42

package/dist/oauth/hooks.d.ts

@@ -1,10 +0,0 @@
-/** onLogin hook: called after each successful OAuth login. */
-export type OnLoginCtx = {
-    did: string;
-    ensureRepo: (did: string) => Promise<void>;
-};
-/** Load on-login hook from the exercise's hooks/ directory. */
-export declare function loadOnLoginHook(hooksDir: string): Promise<void>;
-/** Fire the onLogin hook if loaded. Errors are logged but don't block login. */
-export declare function fireOnLoginHook(did: string): Promise<void>;
-//# sourceMappingURL=hooks.d.ts.map

package/dist/oauth/hooks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/oauth/hooks.ts"],"names":[],"mappings":"AAMA,8DAA8D;AAC9D,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3C,CAAA;AAMD,+DAA+D;AAC/D,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQrE;AAOD,gFAAgF;AAChF,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOhE"}

package/dist/oauth/hooks.js

@@ -1,40 +0,0 @@
-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 { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { log } from "../logger.js";
-import { setRepoStatus } from "../db.js";
-import { triggerAutoBackfill } from "../indexer.js";
-let onLoginHook = null;
-/** Load on-login hook from the exercise's hooks/ directory. */
-export async function loadOnLoginHook(hooksDir) {
-    const tsPath = resolve(hooksDir, 'on-login.ts');
-    const jsPath = resolve(hooksDir, 'on-login.js');
-    const path = existsSync(tsPath) ? tsPath : existsSync(jsPath) ? jsPath : null;
-    if (!path)
-        return;
-    const mod = await import(__rewriteRelativeImportExtension(path));
-    onLoginHook = mod.default;
-    log('[oauth] on-login hook loaded');
-}
-async function ensureRepo(did) {
-    await setRepoStatus(did, 'pending');
-    triggerAutoBackfill(did);
-}
-/** Fire the onLogin hook if loaded. Errors are logged but don't block login. */
-export async function fireOnLoginHook(did) {
-    if (!onLoginHook)
-        return;
-    try {
-        await onLoginHook({ did, ensureRepo });
-    }
-    catch (err) {
-        console.error('[oauth] onLogin hook error:', err.message);
-    }
-}

package/dist/schema.d.ts

@@ -1,59 +0,0 @@
-export interface ColumnDef {
-    name: string;
-    originalName: string;
-    duckdbType: string;
-    notNull: boolean;
-    isRef: boolean;
-}
-export interface UnionBranchSchema {
-    type: string;
-    branchName: string;
-    tableName: string;
-    columns: ColumnDef[];
-    isArray: boolean;
-    arrayField?: string;
-    wrapperField?: string;
-}
-export interface UnionFieldSchema {
-    fieldName: string;
-    branches: UnionBranchSchema[];
-}
-export interface TableSchema {
-    collection: string;
-    tableName: string;
-    columns: ColumnDef[];
-    refColumns: string[];
-    children: ChildTableSchema[];
-    unions: UnionFieldSchema[];
-}
-export interface ChildTableSchema {
-    parentCollection: string;
-    fieldName: string;
-    tableName: string;
-    columns: ColumnDef[];
-}
-export declare function toSnakeCase(str: string): string;
-export declare function loadLexicons(lexiconsDir: string): Map<string, any>;
-/**
- * Discover collections by scanning lexicons for record-type definitions.
- */
-export declare function discoverCollections(lexicons: Map<string, any>): string[];
-export declare function storeLexicons(lexicons: Map<string, any>): void;
-export declare function getLexicon(nsid: string): any | undefined;
-export declare function getAllLexicons(): Array<{
-    nsid: string;
-    lexicon: any;
-}>;
-/** Get all stored lexicons as a flat array (for @bigmoves/lexicon validators) */
-export declare function getLexiconArray(): any[];
-export declare function generateTableSchema(nsid: string, lexicon: any, lexicons?: Map<string, any>): TableSchema;
-export declare function generateCreateTableSQL(schema: TableSchema): string;
-/**
- * Build table schemas and DDL from lexicons and collections.
- * Shared by main.ts (server boot) and cli.ts (hatk schema command).
- */
-export declare function buildSchemas(lexicons: Map<string, any>, collections: string[]): {
-    schemas: TableSchema[];
-    ddlStatements: string[];
-};
-//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,iBAAiB,EAAE,CAAA;CAC9B;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,QAAQ,EAAE,gBAAgB,EAAE,CAAA;IAC5B,MAAM,EAAE,gBAAgB,EAAE,CAAA;CAC3B;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,SAAS,EAAE,CAAA;CACrB;AAGD,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AA8CD,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CASlE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,EAAE,CASxE;AAID,wBAAgB,aAAa,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAI9D;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAExD;AAED,wBAAgB,cAAc,IAAI,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CAEtE;AAED,iFAAiF;AACjF,wBAAgB,eAAe,IAAI,GAAG,EAAE,CAEvC;AAuHD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,WAAW,CA0GxG;AAGD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAoElE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,WAAW,EAAE,MAAM,EAAE,GACpB;IAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAE,CA2BrD"}

package/dist/schema.js

@@ -1,387 +0,0 @@
-import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-// Convert camelCase to snake_case
-export function toSnakeCase(str) {
-    return str.replace(/([A-Z])/g, '_$1').toLowerCase();
-}
-function mapType(prop) {
-    if (prop.type === 'string') {
-        if (prop.format === 'datetime')
-            return { duckdbType: 'TIMESTAMP', isRef: false };
-        if (prop.format === 'at-uri')
-            return { duckdbType: 'TEXT', isRef: true };
-        return { duckdbType: 'TEXT', isRef: false };
-    }
-    if (prop.type === 'integer')
-        return { duckdbType: 'INTEGER', isRef: false };
-    if (prop.type === 'boolean')
-        return { duckdbType: 'BOOLEAN', isRef: false };
-    if (prop.type === 'bytes')
-        return { duckdbType: 'BLOB', isRef: false };
-    if (prop.type === 'cid-link')
-        return { duckdbType: 'TEXT', isRef: false };
-    if (prop.type === 'array')
-        return { duckdbType: 'JSON', isRef: false };
-    if (prop.type === 'blob')
-        return { duckdbType: 'JSON', isRef: false };
-    if (prop.type === 'union')
-        return { duckdbType: 'JSON', isRef: false };
-    if (prop.type === 'unknown')
-        return { duckdbType: 'JSON', isRef: false };
-    if (prop.type === 'object')
-        return { duckdbType: 'JSON', isRef: false };
-    if (prop.type === 'ref') {
-        // strongRef contains { uri, cid } — handled specially in generateTableSchema
-        if (prop.ref === 'com.atproto.repo.strongRef')
-            return { duckdbType: 'STRONG_REF', isRef: true };
-        return { duckdbType: 'JSON', isRef: false };
-    }
-    return { duckdbType: 'TEXT', isRef: false };
-}
-// Recursively find all .json files in a directory
-function findJsonFiles(dir) {
-    const results = [];
-    for (const entry of readdirSync(dir)) {
-        const full = join(dir, entry);
-        if (statSync(full).isDirectory()) {
-            results.push(...findJsonFiles(full));
-        }
-        else if (entry.endsWith('.json')) {
-            results.push(full);
-        }
-    }
-    return results;
-}
-// Load all lexicon files and index by NSID
-export function loadLexicons(lexiconsDir) {
-    const lexicons = new Map();
-    for (const file of findJsonFiles(lexiconsDir)) {
-        const content = JSON.parse(readFileSync(file, 'utf-8'));
-        if (content.lexicon === 1 && content.id) {
-            lexicons.set(content.id, content);
-        }
-    }
-    return lexicons;
-}
-/**
- * Discover collections by scanning lexicons for record-type definitions.
- */
-export function discoverCollections(lexicons) {
-    const collections = [];
-    for (const [nsid, lexicon] of lexicons) {
-        const mainDef = lexicon.defs?.main;
-        if (mainDef?.type === 'record') {
-            collections.push(nsid);
-        }
-    }
-    return collections.sort();
-}
-const storedLexicons = new Map();
-export function storeLexicons(lexicons) {
-    for (const [nsid, lex] of lexicons) {
-        storedLexicons.set(nsid, lex);
-    }
-}
-export function getLexicon(nsid) {
-    return storedLexicons.get(nsid);
-}
-export function getAllLexicons() {
-    return [...storedLexicons.entries()].map(([nsid, lexicon]) => ({ nsid, lexicon }));
-}
-/** Get all stored lexicons as a flat array (for @bigmoves/lexicon validators) */
-export function getLexiconArray() {
-    return [...storedLexicons.values()];
-}
-function resolveArrayItemProperties(items, defs) {
-    if (!items)
-        return null;
-    // Inline object with properties
-    if (items.type === 'object' && items.properties) {
-        return items.properties;
-    }
-    // Ref to a named def (e.g., "#artist")
-    if (items.type === 'ref' && items.ref?.startsWith('#')) {
-        const defName = items.ref.slice(1);
-        const def = defs?.[defName];
-        if (def?.type === 'object' && def.properties) {
-            return def.properties;
-        }
-    }
-    return null;
-}
-/** Resolve a ref string to its definition object */
-function resolveRefDef(ref, defs, lexicons) {
-    if (ref.startsWith('#')) {
-        return defs?.[ref.slice(1)] || null;
-    }
-    if (ref.includes('#')) {
-        const [nsid, defName] = ref.split('#');
-        return lexicons?.get(nsid)?.defs?.[defName] || null;
-    }
-    return lexicons?.get(ref)?.defs?.main || null;
-}
-/** Resolve a single union ref to a branch schema */
-function resolveUnionBranch(ref, collection, fieldName, defs, lexicons) {
-    let branchDef = null;
-    let branchName;
-    let fullType;
-    let branchDefs = defs; // defs context for resolving inner refs
-    if (ref.startsWith('#')) {
-        const defName = ref.slice(1);
-        branchDef = defs?.[defName];
-        branchName = toSnakeCase(defName);
-        fullType = `${collection}#${defName}`;
-    }
-    else if (ref.includes('#')) {
-        const [nsid, defName] = ref.split('#');
-        const lex = lexicons?.get(nsid);
-        branchDef = lex?.defs?.[defName];
-        branchName = toSnakeCase(defName);
-        fullType = ref;
-        branchDefs = lex?.defs || defs;
-    }
-    else {
-        const lex = lexicons?.get(ref);
-        branchDef = lex?.defs?.main;
-        branchName = ref.split('.').pop();
-        fullType = ref;
-        branchDefs = lex?.defs || defs;
-    }
-    if (!branchDef || branchDef.type !== 'object' || !branchDef.properties)
-        return null;
-    let isArray = false;
-    let arrayField;
-    let wrapperField;
-    let propSource = branchDef.properties;
-    const branchRequired = new Set(branchDef.required || []);
-    // Check for single-property wrapper patterns
-    const propEntries = Object.entries(branchDef.properties);
-    if (propEntries.length === 1) {
-        const [onlyField, onlyProp] = propEntries[0];
-        if (onlyProp.type === 'array' && onlyProp.items) {
-            // Single array property (like embed.images wrapping images[])
-            const items = onlyProp.items;
-            const itemDef = items.type === 'ref' && items.ref ? resolveRefDef(items.ref, branchDefs, lexicons) : items;
-            if (itemDef?.type === 'object' && itemDef.properties) {
-                isArray = true;
-                arrayField = onlyField;
-                propSource = itemDef.properties;
-            }
-        }
-        else if (onlyProp.type === 'ref' && onlyProp.ref) {
-            // Single ref property (like embed.external wrapping external{})
-            const refDef = resolveRefDef(onlyProp.ref, branchDefs, lexicons);
-            if (refDef?.type === 'object' && refDef.properties) {
-                wrapperField = onlyField;
-                propSource = refDef.properties;
-            }
-        }
-    }
-    const snakeField = toSnakeCase(fieldName);
-    const tableName = `"${collection}__${snakeField}_${branchName}"`;
-    const columns = [];
-    for (const [propName, prop] of Object.entries(propSource)) {
-        const { duckdbType, isRef } = mapType(prop);
-        // Skip STRONG_REF expansion in branch tables — treat as JSON
-        const finalType = duckdbType === 'STRONG_REF' ? 'JSON' : duckdbType;
-        columns.push({
-            name: toSnakeCase(propName),
-            originalName: propName,
-            duckdbType: finalType,
-            notNull: branchRequired.has(propName),
-            isRef: finalType !== 'JSON' && isRef,
-        });
-    }
-    return { type: fullType, branchName, tableName, columns, isArray, arrayField, wrapperField };
-}
-// Generate a TableSchema from a lexicon record definition
-export function generateTableSchema(nsid, lexicon, lexicons) {
-    const mainDef = lexicon.defs?.main;
-    if (!mainDef || mainDef.type !== 'record') {
-        throw new Error(`Lexicon ${nsid} does not define a record type`);
-    }
-    const record = mainDef.record;
-    if (!record || record.type !== 'object') {
-        throw new Error(`Lexicon ${nsid} record is not an object type`);
-    }
-    const required = new Set(record.required || []);
-    const columns = [];
-    const children = [];
-    const unions = [];
-    for (const [fieldName, prop] of Object.entries(record.properties || {})) {
-        const p = prop;
-        // Check for union fields — decompose into branch child tables
-        if (p.type === 'union' && p.refs) {
-            const branches = [];
-            for (const ref of p.refs) {
-                const branch = resolveUnionBranch(ref, nsid, fieldName, lexicon.defs, lexicons);
-                if (branch)
-                    branches.push(branch);
-            }
-            if (branches.length > 0) {
-                unions.push({ fieldName, branches });
-            }
-            // Still add the JSON column for the raw union value
-            columns.push({
-                name: toSnakeCase(fieldName),
-                originalName: fieldName,
-                duckdbType: 'JSON',
-                notNull: required.has(fieldName),
-                isRef: false,
-            });
-            continue;
-        }
-        // Check if this is a decomposable array (array of structured objects)
-        if (p.type === 'array') {
-            const itemProps = resolveArrayItemProperties(p.items, lexicon.defs);
-            if (itemProps) {
-                const childColumns = [];
-                const itemRequired = new Set(p.items?.required || lexicon.defs?.[p.items?.ref?.slice(1)]?.required || []);
-                for (const [itemField, itemProp] of Object.entries(itemProps)) {
-                    const { duckdbType, isRef } = mapType(itemProp);
-                    childColumns.push({
-                        name: toSnakeCase(itemField),
-                        originalName: itemField,
-                        duckdbType,
-                        notNull: itemRequired.has(itemField),
-                        isRef,
-                    });
-                }
-                const snakeField = toSnakeCase(fieldName);
-                children.push({
-                    parentCollection: nsid,
-                    fieldName,
-                    tableName: `"${nsid}__${snakeField}"`,
-                    columns: childColumns,
-                });
-                continue;
-            }
-        }
-        const { duckdbType, isRef } = mapType(p);
-        if (duckdbType === 'STRONG_REF') {
-            // Expand strongRef into two columns: {name}_uri and {name}_cid
-            columns.push({
-                name: toSnakeCase(fieldName) + '_uri',
-                originalName: fieldName,
-                duckdbType: 'TEXT',
-                notNull: required.has(fieldName),
-                isRef: true,
-            });
-            columns.push({
-                name: toSnakeCase(fieldName) + '_cid',
-                originalName: fieldName + '__cid',
-                duckdbType: 'TEXT',
-                notNull: required.has(fieldName),
-                isRef: false,
-            });
-        }
-        else {
-            columns.push({
-                name: toSnakeCase(fieldName),
-                originalName: fieldName,
-                duckdbType,
-                notNull: required.has(fieldName),
-                isRef,
-            });
-        }
-    }
-    const refColumns = columns.filter((c) => c.isRef).map((c) => c.name);
-    return {
-        collection: nsid,
-        tableName: `"${nsid}"`,
-        columns,
-        refColumns,
-        children,
-        unions,
-    };
-}
-// Generate CREATE TABLE SQL from a TableSchema
-export function generateCreateTableSQL(schema) {
-    const lines = [
-        '  uri TEXT PRIMARY KEY',
-        '  cid TEXT',
-        '  did TEXT NOT NULL',
-        '  indexed_at TIMESTAMP NOT NULL',
-    ];
-    for (const col of schema.columns) {
-        const nullable = col.notNull ? ' NOT NULL' : '';
-        lines.push(`  ${col.name} ${col.duckdbType}${nullable}`);
-    }
-    const createTable = `CREATE TABLE IF NOT EXISTS ${schema.tableName} (\n${lines.join(',\n')}\n);`;
-    const prefix = schema.collection.replace(/\./g, '_');
-    const indexes = [
-        `CREATE INDEX IF NOT EXISTS idx_${prefix}_indexed ON ${schema.tableName}(indexed_at DESC);`,
-        `CREATE INDEX IF NOT EXISTS idx_${prefix}_author ON ${schema.tableName}(did);`,
-    ];
-    // Index ref columns for hydration lookups
-    for (const refCol of schema.refColumns) {
-        indexes.push(`CREATE INDEX IF NOT EXISTS idx_${prefix}_${refCol} ON ${schema.tableName}(${refCol});`);
-    }
-    // Child table DDL
-    const childDDL = [];
-    for (const child of schema.children) {
-        const childLines = ['  parent_uri TEXT NOT NULL', '  parent_did TEXT NOT NULL'];
-        for (const col of child.columns) {
-            const nullable = col.notNull ? ' NOT NULL' : '';
-            childLines.push(`  ${col.name} ${col.duckdbType}${nullable}`);
-        }
-        childDDL.push(`CREATE TABLE IF NOT EXISTS ${child.tableName} (\n${childLines.join(',\n')}\n);`);
-        const childPrefix = `${prefix}__${toSnakeCase(child.fieldName)}`;
-        childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${childPrefix}_parent ON ${child.tableName}(parent_uri);`);
-        childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${childPrefix}_did ON ${child.tableName}(parent_did);`);
-        for (const col of child.columns) {
-            if (col.duckdbType === 'JSON' || col.duckdbType === 'BLOB')
-                continue;
-            childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${childPrefix}_${col.name} ON ${child.tableName}(${col.name});`);
-        }
-    }
-    // Union branch table DDL
-    for (const union of schema.unions) {
-        for (const branch of union.branches) {
-            const branchLines = ['  parent_uri TEXT NOT NULL', '  parent_did TEXT NOT NULL'];
-            for (const col of branch.columns) {
-                const nullable = col.notNull ? ' NOT NULL' : '';
-                branchLines.push(`  ${col.name} ${col.duckdbType}${nullable}`);
-            }
-            childDDL.push(`CREATE TABLE IF NOT EXISTS ${branch.tableName} (\n${branchLines.join(',\n')}\n);`);
-            const branchPrefix = branch.tableName.replace(/"/g, '').replace(/\./g, '_');
-            childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${branchPrefix}_parent ON ${branch.tableName}(parent_uri);`);
-            childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${branchPrefix}_did ON ${branch.tableName}(parent_did);`);
-            for (const col of branch.columns) {
-                if (col.duckdbType === 'JSON' || col.duckdbType === 'BLOB')
-                    continue;
-                childDDL.push(`CREATE INDEX IF NOT EXISTS idx_${branchPrefix}_${col.name} ON ${branch.tableName}(${col.name});`);
-            }
-        }
-    }
-    return [createTable, ...indexes, ...childDDL].join('\n');
-}
-/**
- * Build table schemas and DDL from lexicons and collections.
- * Shared by main.ts (server boot) and cli.ts (hatk schema command).
- */
-export function buildSchemas(lexicons, collections) {
-    const schemas = [];
-    const ddlStatements = [];
-    for (const nsid of collections) {
-        const lexicon = lexicons.get(nsid);
-        if (!lexicon) {
-            const genericDDL = `CREATE TABLE IF NOT EXISTS "${nsid}" (
-      uri TEXT PRIMARY KEY,
-      cid TEXT,
-      did TEXT NOT NULL,
-      indexed_at TIMESTAMP NOT NULL,
-      data JSON
-    );
-    CREATE INDEX IF NOT EXISTS idx_${nsid.replace(/\./g, '_')}_indexed ON "${nsid}"(indexed_at DESC);
-    CREATE INDEX IF NOT EXISTS idx_${nsid.replace(/\./g, '_')}_author ON "${nsid}"(did);`;
-            schemas.push({ collection: nsid, tableName: `"${nsid}"`, columns: [], refColumns: [], children: [], unions: [] });
-            ddlStatements.push(genericDDL);
-            continue;
-        }
-        const schema = generateTableSchema(nsid, lexicon, lexicons);
-        schemas.push(schema);
-        ddlStatements.push(generateCreateTableSQL(schema));
-    }
-    return { schemas, ddlStatements };
-}

package/dist/test-browser.d.ts

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

@@ -1 +0,0 @@
-{"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

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