@hatk/hatk 0.0.1-alpha.0

package/dist/hydrate.d.ts

@@ -0,0 +1,23 @@
+import type { Row } from './lex-types.ts';
+export type { Row };
+export interface HydrateContext<T = unknown> {
+    items: Row<T>[];
+    viewer: {
+        did: string;
+    } | null;
+    db: {
+        query: (sql: string, params?: unknown[]) => Promise<unknown[]>;
+    };
+    getRecords: <R = unknown>(collection: string, uris: string[]) => Promise<Map<string, Row<R>>>;
+    lookup: <R = unknown>(collection: string, field: string, values: string[]) => Promise<Map<string, Row<R>>>;
+    count: (collection: string, field: string, values: string[]) => Promise<Map<string, number>>;
+    labels: (uris: string[]) => Promise<Map<string, unknown[]>>;
+    blobUrl: (did: string, ref: unknown, preset?: 'avatar' | 'banner' | 'feed_thumbnail' | 'feed_fullsize') => string | undefined;
+}
+/** Fetch records for URIs, reshape them, and filter out taken-down DIDs. */
+export declare function resolveRecords(uris: string[]): Promise<Row<unknown>[]>;
+/** Build a HydrateContext for a feed's hydrate function. */
+export declare function buildHydrateContext(items: Row<unknown>[], viewer: {
+    did: string;
+} | null): HydrateContext;
+//# sourceMappingURL=hydrate.d.ts.map

package/dist/hydrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../src/hydrate.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAEzC,YAAY,EAAE,GAAG,EAAE,CAAA;AAInB,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IACzC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,CAAA;IACf,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IAC9B,EAAE,EAAE;QAAE,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAA;KAAE,CAAA;IACtE,UAAU,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC7F,MAAM,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC1G,KAAK,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5F,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAAA;IAC3D,OAAO,EAAE,CACP,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,OAAO,EACZ,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,gBAAgB,GAAG,eAAe,KAC9D,MAAM,GAAG,SAAS,CAAA;CACxB;AAID,4EAA4E;AAC5E,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAoC5E;AAID,4DAA4D;AAC5D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,cAAc,CA4BzG"}

package/dist/hydrate.js

@@ -0,0 +1,75 @@
+import { getRecordsByUris, countByFieldBatch, lookupByFieldBatch, querySQL, reshapeRow, queryLabelsForUris, filterTakendownDids, } from "./db.js";
+import { blobUrl } from "./xrpc.js";
+// --- Record Resolution ---
+/** Fetch records for URIs, reshape them, and filter out taken-down DIDs. */
+export async function resolveRecords(uris) {
+    if (uris.length === 0)
+        return [];
+    // Group URIs by collection for batch fetching
+    const byCollection = new Map();
+    for (const uri of uris) {
+        const parts = uri.replace('at://', '').split('/');
+        const col = parts[1];
+        if (!byCollection.has(col))
+            byCollection.set(col, []);
+        byCollection.get(col).push(uri);
+    }
+    const primaryRecords = new Map();
+    for (const [col, colUris] of byCollection) {
+        const records = await getRecordsByUris(col, colUris);
+        for (const r of records) {
+            primaryRecords.set(r.uri, r);
+        }
+    }
+    // Filter out records from taken-down DIDs
+    const allDids = [...new Set([...primaryRecords.values()].map((r) => r.did).filter(Boolean))];
+    const takendownDids = await filterTakendownDids(allDids);
+    if (takendownDids.size > 0) {
+        for (const [uri, rec] of primaryRecords) {
+            if (takendownDids.has(rec.did))
+                primaryRecords.delete(uri);
+        }
+    }
+    // Return in original URI order, reshaped
+    return uris
+        .map((uri) => {
+        const row = primaryRecords.get(uri);
+        return reshapeRow(row, row?.__childData, row?.__unionData);
+    })
+        .filter((r) => r != null);
+}
+// --- Context Builder ---
+/** Build a HydrateContext for a feed's hydrate function. */
+export function buildHydrateContext(items, viewer) {
+    return {
+        items,
+        viewer,
+        db: { query: querySQL },
+        getRecords: async (collection, uris) => {
+            if (uris.length === 0)
+                return new Map();
+            const records = await getRecordsByUris(collection, uris);
+            const map = new Map();
+            for (const r of records) {
+                const shaped = reshapeRow(r, r?.__childData, r?.__unionData);
+                if (shaped)
+                    map.set(shaped.uri, shaped);
+            }
+            return map;
+        },
+        lookup: async (collection, field, values) => {
+            if (values.length === 0)
+                return new Map();
+            const unique = [...new Set(values.filter(Boolean))];
+            return lookupByFieldBatch(collection, field, unique);
+        },
+        count: async (collection, field, values) => {
+            if (values.length === 0)
+                return new Map();
+            const unique = [...new Set(values.filter(Boolean))];
+            return countByFieldBatch(collection, field, unique);
+        },
+        labels: queryLabelsForUris,
+        blobUrl,
+    };
+}

package/dist/indexer.d.ts

@@ -0,0 +1,14 @@
+export declare function triggerAutoBackfill(did: string, attempt?: number): Promise<void>;
+interface IndexerOpts {
+    relayUrl: string;
+    collections: Set<string>;
+    signalCollections?: Set<string>;
+    pinnedRepos?: Set<string>;
+    cursor?: string | null;
+    fetchTimeout: number;
+    maxRetries: number;
+    ftsRebuildInterval?: number;
+}
+export declare function startIndexer(opts: IndexerOpts): Promise<WebSocket>;
+export {};
+//# sourceMappingURL=indexer.d.ts.map

package/dist/indexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexer.d.ts","sourceRoot":"","sources":["../src/indexer.ts"],"names":[],"mappings":"AAkIA,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,SAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDjF;AAED,UAAU,WAAW;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACxB,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC/B,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAyBD,wBAAsB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAkDxE"}

package/dist/indexer.js

@@ -0,0 +1,316 @@
+import { cborDecode } from "./cbor.js";
+import { parseCarFrame } from "./car.js";
+import { insertRecord, deleteRecord, setCursor, setRepoStatus, getRepoRetryInfo, listAllRepoStatuses } from "./db.js";
+import { backfillRepo } from "./backfill.js";
+import { rebuildAllIndexes } from "./fts.js";
+import { log, emit, timer } from "./logger.js";
+import { runLabelRules } from "./labels.js";
+import { getLexiconArray } from "./schema.js";
+import { validateRecord } from '@bigmoves/lexicon';
+let buffer = [];
+let flushTimer = null;
+let lastSeq = null;
+const BATCH_SIZE = 100;
+const FLUSH_INTERVAL_MS = 500;
+let writesSinceRebuild = 0;
+let ftsRebuildInterval = 500;
+// Event buffer for DIDs mid-backfill
+const pendingBuffers = new Map();
+// Track in-flight backfills to avoid duplicates
+const backfillInFlight = new Set();
+const MAX_CONCURRENT_BACKFILLS = 5;
+// In-memory cache of repo status to avoid flooding the DB read queue
+const repoStatusCache = new Map();
+// Set by startIndexer
+let indexerCollections;
+let indexerSignalCollections;
+let indexerPinnedRepos = null;
+let indexerFetchTimeout;
+let indexerMaxRetries;
+async function flushBuffer() {
+    if (buffer.length === 0)
+        return;
+    const elapsed = timer();
+    const batch = buffer.splice(0);
+    let insertedCount = 0;
+    const errors = [];
+    let cursorError;
+    const inserted = [];
+    for (const item of batch) {
+        try {
+            await insertRecord(item.collection, item.uri, item.cid, item.authorDid, item.record);
+            insertedCount++;
+            inserted.push(item);
+        }
+        catch (err) {
+            errors.push(err.message);
+        }
+    }
+    if (lastSeq !== null) {
+        try {
+            await setCursor('relay', String(lastSeq));
+        }
+        catch (err) {
+            cursorError = err.message;
+        }
+    }
+    // Run label rules on successfully inserted records (async, non-blocking)
+    for (const item of inserted) {
+        runLabelRules({
+            uri: item.uri,
+            cid: item.cid,
+            did: item.authorDid,
+            collection: item.collection,
+            value: item.record,
+        }).catch(() => { });
+    }
+    // Aggregate collection counts and unique DIDs for wide event
+    const collections = {};
+    const dids = new Set();
+    for (const item of batch) {
+        collections[item.collection] = (collections[item.collection] || 0) + 1;
+        dids.add(item.authorDid);
+    }
+    emit('indexer', 'flush', {
+        batch_size: batch.length,
+        inserted_count: insertedCount,
+        error_count: errors.length,
+        cursor_seq: lastSeq,
+        duration_ms: elapsed(),
+        collections,
+        unique_dids: dids.size,
+        sample_dids: [...dids].slice(0, 5),
+        cursor_error: cursorError,
+        sample_errors: errors.length > 0 ? errors.slice(0, 3) : undefined,
+    });
+    writesSinceRebuild += batch.length;
+    if (writesSinceRebuild >= ftsRebuildInterval) {
+        writesSinceRebuild = 0;
+        rebuildAllIndexes([...indexerCollections]).catch(() => { });
+    }
+}
+function scheduleFlush() {
+    if (flushTimer)
+        return;
+    flushTimer = setTimeout(async () => {
+        flushTimer = null;
+        await flushBuffer();
+    }, FLUSH_INTERVAL_MS);
+}
+function bufferWrite(item) {
+    buffer.push(item);
+    if (buffer.length >= BATCH_SIZE) {
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+        flushBuffer();
+    }
+    else {
+        scheduleFlush();
+    }
+}
+export async function triggerAutoBackfill(did, attempt = 0) {
+    if (backfillInFlight.has(did))
+        return;
+    backfillInFlight.add(did);
+    pendingBuffers.set(did, []);
+    if (attempt === 0)
+        await setRepoStatus(did, 'pending');
+    const elapsed = timer();
+    let recordCount = 0;
+    let status = 'success';
+    let error;
+    let replayErrors = 0;
+    try {
+        recordCount = await backfillRepo(did, indexerCollections, indexerFetchTimeout);
+    }
+    catch (err) {
+        status = 'error';
+        error = err.message;
+    }
+    // Replay buffered events
+    const buffered = pendingBuffers.get(did) || [];
+    pendingBuffers.delete(did);
+    backfillInFlight.delete(did);
+    for (const item of buffered) {
+        try {
+            await insertRecord(item.collection, item.uri, item.cid, item.authorDid, item.record);
+        }
+        catch {
+            replayErrors++;
+        }
+    }
+    // Schedule retry if failed and under maxRetries
+    const retryInfo = status === 'error' ? await getRepoRetryInfo(did) : null;
+    const currentRetryCount = retryInfo?.retryCount ?? 0;
+    emit('indexer', 'auto_backfill', {
+        did,
+        record_count: recordCount,
+        buffered_events: buffered.length,
+        replay_errors: replayErrors,
+        duration_ms: elapsed(),
+        status,
+        error,
+        retry_count: currentRetryCount,
+    });
+    if (status === 'error' && currentRetryCount < indexerMaxRetries) {
+        const delaySecs = Math.min(currentRetryCount * 60, 3600);
+        const delayMs = Math.max(delaySecs, 60) * 1000;
+        setTimeout(() => {
+            triggerAutoBackfill(did, currentRetryCount);
+        }, delayMs);
+    }
+}
+// Periodic memory diagnostics
+function startMemoryDiagnostics() {
+    setInterval(() => {
+        const mem = process.memoryUsage();
+        let pendingBufferItems = 0;
+        for (const [, items] of pendingBuffers) {
+            pendingBufferItems += items.length;
+        }
+        emit('diagnostics', 'memory', {
+            heap_used_mb: Math.round(mem.heapUsed / 1024 / 1024),
+            heap_total_mb: Math.round(mem.heapTotal / 1024 / 1024),
+            rss_mb: Math.round(mem.rss / 1024 / 1024),
+            external_mb: Math.round(mem.external / 1024 / 1024),
+            array_buffers_mb: Math.round(mem.arrayBuffers / 1024 / 1024),
+            write_buffer_len: buffer.length,
+            pending_buffer_dids: pendingBuffers.size,
+            pending_buffer_items: pendingBufferItems,
+            backfill_in_flight: backfillInFlight.size,
+            repo_status_cache_size: repoStatusCache.size,
+        });
+    }, 30_000);
+}
+export async function startIndexer(opts) {
+    const { relayUrl, collections, cursor, fetchTimeout } = opts;
+    if (opts.ftsRebuildInterval != null)
+        ftsRebuildInterval = opts.ftsRebuildInterval;
+    indexerCollections = collections;
+    indexerSignalCollections = opts.signalCollections || collections;
+    indexerPinnedRepos = opts.pinnedRepos || null;
+    indexerFetchTimeout = fetchTimeout;
+    indexerMaxRetries = opts.maxRetries;
+    // Pre-populate repo status cache from DB so non-signal updates
+    // (e.g. profile changes) are processed for already-tracked DIDs
+    if (repoStatusCache.size === 0) {
+        const statuses = await listAllRepoStatuses();
+        for (const { did, status } of statuses) {
+            repoStatusCache.set(did, status);
+        }
+        log(`[indexer] Warmed repo status cache with ${statuses.length} entries`);
+    }
+    startMemoryDiagnostics();
+    let wsUrl = `${relayUrl}/xrpc/com.atproto.sync.subscribeRepos`;
+    if (cursor) {
+        wsUrl += `?cursor=${cursor}`;
+        log(`[indexer] Resuming from cursor ${cursor}`);
+    }
+    log(`[indexer] Connecting to ${relayUrl}...`);
+    const ws = new WebSocket(wsUrl);
+    ws.binaryType = 'arraybuffer';
+    ws.addEventListener('message', (event) => {
+        try {
+            // Process synchronously to drain the event queue as fast as possible.
+            // Each pending event holds its ArrayBuffer; async handlers let them pile up.
+            if (!(event.data instanceof ArrayBuffer))
+                return;
+            const bytes = new Uint8Array(event.data);
+            processMessage(bytes, collections);
+        }
+        catch {
+            // Skip unparseable firehose messages silently
+        }
+    });
+    ws.addEventListener('open', () => log('[indexer] Connected to relay'));
+    ws.addEventListener('close', () => {
+        log('[indexer] Disconnected, reconnecting in 3s...');
+        setTimeout(() => startIndexer(opts), 3000);
+    });
+    return ws;
+}
+function processMessage(bytes, collections) {
+    const header = cborDecode(bytes, 0);
+    const body = cborDecode(bytes, header.offset);
+    if (header.value.op !== 1 || header.value.t !== '#commit')
+        return;
+    if (!body.value.blocks || !body.value.ops)
+        return;
+    // Track sequence number for cursor
+    if (body.value.seq)
+        lastSeq = body.value.seq;
+    const did = body.value.repo;
+    if (!did)
+        return;
+    // When repos are pinned, only process events from those DIDs
+    if (indexerPinnedRepos && !indexerPinnedRepos.has(did))
+        return;
+    // Check if any ops in this commit are for collections we care about
+    const relevantOps = body.value.ops.filter((op) => collections.has(op.path.split('/')[0]));
+    if (relevantOps.length === 0)
+        return;
+    // Copy blocks out of the original buffer before it can be GC'd
+    const { blocks } = parseCarFrame(new Uint8Array(body.value.blocks));
+    // Only auto-backfill when we see activity in a signal collection
+    const hasSignalOp = relevantOps.some((op) => indexerSignalCollections.has(op.path.split('/')[0]));
+    // Use in-memory cache only — never hit DB from the hot path.
+    // Unknown DIDs stay unknown until backfill or auto-backfill discovers them.
+    // The cache is populated by triggerAutoBackfill and setRepoStatus calls.
+    const cachedStatus = repoStatusCache.get(did);
+    const repoStatus = cachedStatus === undefined || cachedStatus === 'unknown' ? null : cachedStatus;
+    if (cachedStatus === undefined) {
+        repoStatusCache.set(did, 'unknown');
+    }
+    if (hasSignalOp && (!indexerPinnedRepos || indexerPinnedRepos.has(did))) {
+        if (repoStatus === null && backfillInFlight.size < MAX_CONCURRENT_BACKFILLS) {
+            repoStatusCache.set(did, 'pending');
+            triggerAutoBackfill(did);
+        }
+        else if (repoStatus === null) {
+            repoStatusCache.set(did, 'pending');
+            setRepoStatus(did, 'pending');
+        }
+    }
+    // For non-signal ops (e.g. profile updates), only process if this DID is already tracked
+    if (!hasSignalOp) {
+        if (repoStatus === null)
+            return;
+    }
+    for (const op of relevantOps) {
+        const collection = op.path.split('/')[0];
+        const uri = `at://${did}/${op.path}`;
+        if (op.action === 'delete') {
+            deleteRecord(collection, uri);
+            continue;
+        }
+        for (const [cid, data] of blocks) {
+            try {
+                const { value: record } = cborDecode(data);
+                if (record?.$type === collection) {
+                    const validationError = validateRecord(getLexiconArray(), collection, record);
+                    if (validationError) {
+                        emit('indexer', 'validation_skip', {
+                            uri,
+                            collection,
+                            path: validationError.path,
+                            error: validationError.message,
+                        });
+                        break;
+                    }
+                    const item = { collection, uri, cid, authorDid: did, record };
+                    // If DID is mid-backfill, buffer instead of writing directly
+                    if (pendingBuffers.has(did)) {
+                        pendingBuffers.get(did).push(item);
+                    }
+                    else {
+                        bufferWrite(item);
+                    }
+                    break;
+                }
+            }
+            catch { }
+        }
+    }
+}

package/dist/labels.d.ts

@@ -0,0 +1,29 @@
+import type { LabelDefinition } from './config.ts';
+/** Context passed to label rule evaluate() functions */
+export interface LabelRuleContext {
+    db: {
+        query: (sql: string, params?: any[]) => Promise<any[]>;
+        run: (sql: string, ...params: any[]) => Promise<void>;
+    };
+    record: {
+        uri: string;
+        cid: string;
+        did: string;
+        collection: string;
+        value: Record<string, any>;
+    };
+}
+export declare function initLabels(labelsDir: string): Promise<void>;
+export declare function runLabelRules(record: {
+    uri: string;
+    cid: string;
+    did: string;
+    collection: string;
+    value: Record<string, any>;
+}): Promise<void>;
+export declare function rescanLabels(collections: string[]): Promise<{
+    scanned: number;
+    labeled: number;
+}>;
+export declare function getLabelDefinitions(): LabelDefinition[];
+//# sourceMappingURL=labels.d.ts.map

package/dist/labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../src/labels.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAIlD,wDAAwD;AACxD,MAAM,WAAW,gBAAgB;IAC/B,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,MAAM,EAAE;QACN,GAAG,EAAE,MAAM,CAAA;QACX,GAAG,EAAE,MAAM,CAAA;QACX,GAAG,EAAE,MAAM,CAAA;QACX,UAAU,EAAE,MAAM,CAAA;QAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAC3B,CAAA;CACF;AAWD,wBAAsB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmCjE;AAED,wBAAsB,aAAa,CAAC,MAAM,EAAE;IAC1C,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAC3B,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBhB;AAED,wBAAsB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAuCvG;AAED,wBAAgB,mBAAmB,IAAI,eAAe,EAAE,CAEvD"}

package/dist/labels.js

@@ -0,0 +1,111 @@
+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 } from 'node:path';
+import { readdirSync } from 'node:fs';
+import { querySQL, runSQL, insertLabels, getSchema } from "./db.js";
+import { log, emit } from "./logger.js";
+const rules = [];
+let labelDefs = [];
+let labelSrc = 'self';
+export async function initLabels(labelsDir) {
+    let files;
+    try {
+        files = readdirSync(labelsDir)
+            .filter((f) => (f.endsWith('.ts') || f.endsWith('.js')) && !f.startsWith('_'))
+            .sort();
+    }
+    catch {
+        return;
+    }
+    for (const file of files) {
+        const name = file.replace(/\.(ts|js)$/, '');
+        const scriptPath = resolve(labelsDir, file);
+        const mod = await import(__rewriteRelativeImportExtension(scriptPath));
+        const handler = mod.default;
+        if (handler.definition) {
+            labelDefs.push(handler.definition);
+        }
+        if (handler.evaluate) {
+            rules.push({
+                name,
+                evaluate: async (ctx) => {
+                    return handler.evaluate(ctx);
+                },
+            });
+        }
+        log(`[labels] discovered: ${name}${handler.evaluate ? ' (rule)' : ''}`);
+    }
+    if (labelDefs.length > 0) {
+        log(`[labels] ${labelDefs.length} label definitions loaded`);
+    }
+}
+export async function runLabelRules(record) {
+    if (rules.length === 0)
+        return;
+    const ctx = {
+        db: { query: querySQL, run: runSQL },
+        record,
+    };
+    const allLabels = [];
+    for (const rule of rules) {
+        try {
+            const vals = await rule.evaluate(ctx);
+            for (const val of vals) {
+                allLabels.push({ src: labelSrc, uri: record.uri, val });
+            }
+        }
+        catch (err) {
+            emit('labels', 'rule_error', { rule: rule.name, error: err.message });
+        }
+    }
+    if (allLabels.length > 0) {
+        await insertLabels(allLabels);
+        emit('labels', 'applied', { count: allLabels.length, uri: record.uri, vals: allLabels.map((l) => l.val) });
+    }
+}
+export async function rescanLabels(collections) {
+    const beforeRows = await querySQL(`SELECT COUNT(*) as count FROM _labels`);
+    const beforeCount = Number(beforeRows[0]?.count || 0);
+    let scanned = 0;
+    for (const collection of collections) {
+        const schema = getSchema(collection);
+        if (!schema)
+            continue;
+        const rows = await querySQL(`SELECT * FROM ${schema.tableName}`);
+        for (const row of rows) {
+            scanned++;
+            const value = {};
+            for (const col of schema.columns) {
+                let v = row[col.name];
+                if (v === null || v === undefined)
+                    continue;
+                if (col.duckdbType === 'JSON' && typeof v === 'string') {
+                    try {
+                        v = JSON.parse(v);
+                    }
+                    catch { }
+                }
+                value[col.originalName] = v;
+            }
+            await runLabelRules({
+                uri: row.uri,
+                cid: row.cid,
+                did: row.did,
+                collection,
+                value,
+            });
+        }
+    }
+    const afterRows = await querySQL(`SELECT COUNT(*) as count FROM _labels`);
+    const afterCount = Number(afterRows[0]?.count || 0);
+    return { scanned, labeled: afterCount - beforeCount };
+}
+export function getLabelDefinitions() {
+    return labelDefs;
+}