@jungjaehoon/mama-core 1.4.1 → 1.5.0

package/dist/entities/exact-merge-backfill.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backfillExactDuplicateCanonicals = backfillExactDuplicateCanonicals;
+const db_manager_js_1 = require("../db-manager.js");
+const store_js_1 = require("./store.js");
+const lineage_store_js_1 = require("./lineage-store.js");
+function normalizeExactLabel(input) {
+    return input.normalize('NFKC').trim().replace(/\s+/gu, ' ').toLowerCase();
+}
+function buildExactGroupKey(row) {
+    if (row.normalized_form) {
+        return {
+            key: JSON.stringify([row.kind, row.scope_kind, row.scope_id ?? '', row.normalized_form]),
+            fromObservation: true,
+        };
+    }
+    const fallback = normalizeExactLabel(row.preferred_label);
+    if (!fallback) {
+        return null;
+    }
+    return {
+        key: JSON.stringify([row.kind, row.scope_kind, row.scope_id ?? '', fallback]),
+        fromObservation: false,
+    };
+}
+function compareRows(left, right) {
+    if (left.created_at !== right.created_at) {
+        return left.created_at - right.created_at;
+    }
+    return left.id.localeCompare(right.id);
+}
+function runAdapterTransaction(adapter, fn) {
+    const result = adapter.transaction(fn);
+    return typeof result === 'function' ? result() : result;
+}
+function requireTransactionAdapter(adapter) {
+    if (!('transaction' in adapter) || typeof adapter.transaction !== 'function') {
+        throw new Error('exact-merge-backfill requires adapter.transaction');
+    }
+    return adapter;
+}
+function mergeAndAdoptLineage(input) {
+    const mergeResult = (0, store_js_1.mergeEntityNodes)({
+        adapter: input.adapter,
+        source_id: input.source.id,
+        target_id: input.target.id,
+        actor_type: 'system',
+        actor_id: 'exact-duplicate-backfill',
+        reason: 'Exact duplicate canonical backfill',
+        candidate_id: null,
+        evidence_json: JSON.stringify({
+            strategy: 'exact_duplicate_backfill',
+            group_key: input.groupKey,
+            normalized_form: input.source.normalized_form,
+            target_id: input.target.id,
+        }),
+    });
+    (0, lineage_store_js_1.adoptLineageAfterMergeSync)({
+        adapter: input.adapter,
+        source_entity_id: input.source.id,
+        target_entity_id: input.target.id,
+        candidate_id: null,
+        review_action_id: mergeResult.merge_action_id,
+    });
+}
+async function backfillExactDuplicateCanonicals(opts = {}) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const dryRun = opts.dryRun === true;
+    let groups = 0;
+    let merged = 0;
+    let incomplete = 0;
+    let skipped = 0;
+    const rows = adapter
+        .prepare(`
+        SELECT
+          n.id,
+          n.kind,
+          n.preferred_label,
+          n.scope_kind,
+          n.scope_id,
+          n.created_at,
+          MIN(o.normalized_form) AS normalized_form
+        FROM entity_nodes n
+        LEFT JOIN entity_lineage_links l
+          ON l.canonical_entity_id = n.id
+         AND l.status = 'active'
+        LEFT JOIN entity_observations o
+          ON o.id = l.entity_observation_id
+        WHERE n.status = 'active'
+          AND n.merged_into IS NULL
+        GROUP BY n.id, n.kind, n.preferred_label, n.scope_kind, n.scope_id, n.created_at
+      `)
+        .all();
+    const grouped = new Map();
+    const fallbackRows = new Set();
+    for (const row of rows) {
+        const keyInfo = buildExactGroupKey(row);
+        if (!keyInfo) {
+            incomplete += 1;
+            continue;
+        }
+        if (!keyInfo.fromObservation) {
+            fallbackRows.add(row.id);
+        }
+        const bucket = grouped.get(keyInfo.key) ?? [];
+        bucket.push(row);
+        grouped.set(keyInfo.key, bucket);
+    }
+    for (const bucket of grouped.values()) {
+        if (bucket.length >= 2) {
+            continue;
+        }
+        for (const row of bucket) {
+            if (fallbackRows.has(row.id)) {
+                incomplete += 1;
+            }
+        }
+    }
+    for (const [groupKey, bucket] of grouped.entries()) {
+        if (bucket.length < 2) {
+            continue;
+        }
+        groups += 1;
+        const sorted = [...bucket].sort(compareRows);
+        const target = sorted[0];
+        const sources = sorted.slice(1);
+        if (dryRun) {
+            merged += sources.length;
+            continue;
+        }
+        try {
+            const transactionalAdapter = requireTransactionAdapter(adapter);
+            runAdapterTransaction(transactionalAdapter, () => {
+                for (const source of sources) {
+                    mergeAndAdoptLineage({
+                        adapter,
+                        source,
+                        target,
+                        groupKey,
+                    });
+                }
+            });
+            merged += sources.length;
+        }
+        catch (error) {
+            if (error instanceof store_js_1.EntityMergeError) {
+                skipped += sources.length;
+                continue;
+            }
+            throw error;
+        }
+    }
+    return {
+        groups,
+        merged,
+        incomplete,
+        skipped,
+    };
+}
+//# sourceMappingURL=exact-merge-backfill.js.map

package/dist/entities/lineage-backfill.d.ts

@@ -0,0 +1,12 @@
+interface BackfillEntityLineageOptions {
+    dryRun?: boolean;
+    now?: number;
+}
+interface BackfillEntityLineageResult {
+    seeded: number;
+    adopted: number;
+    incomplete: number;
+}
+export declare function backfillEntityLineage(opts?: BackfillEntityLineageOptions): Promise<BackfillEntityLineageResult>;
+export {};
+//# sourceMappingURL=lineage-backfill.d.ts.map

package/dist/entities/lineage-backfill.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backfillEntityLineage = backfillEntityLineage;
+const db_manager_js_1 = require("../db-manager.js");
+const lineage_store_js_1 = require("./lineage-store.js");
+async function backfillEntityLineage(opts = {}) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const dryRun = opts.dryRun === true;
+    const seedConfidence = 0.75;
+    const adoptConfidence = 0.6;
+    let seeded = 0;
+    let adopted = 0;
+    let incomplete = 0;
+    const activeRows = adapter
+        .prepare(`
+        SELECT n.id, o.id AS observation_id
+        FROM entity_nodes n
+        LEFT JOIN entity_observations o ON o.id = n.id
+        WHERE n.status = 'active'
+          AND n.merged_into IS NULL
+      `)
+        .all();
+    for (const row of activeRows) {
+        if (!row.observation_id) {
+            incomplete += 1;
+            continue;
+        }
+        const existing = adapter
+            .prepare(`
+          SELECT id
+          FROM entity_lineage_links
+          WHERE canonical_entity_id = ?
+            AND entity_observation_id = ?
+            AND status = 'active'
+          LIMIT 1
+        `)
+            .get(row.id, row.observation_id);
+        if (existing) {
+            continue;
+        }
+        seeded += 1;
+        if (!dryRun) {
+            await (0, lineage_store_js_1.appendEntityLineageLink)({
+                canonical_entity_id: row.id,
+                entity_observation_id: row.observation_id,
+                source_entity_id: null,
+                contribution_kind: 'seed',
+                run_id: null,
+                candidate_id: null,
+                review_action_id: null,
+                capture_mode: 'backfilled',
+                confidence: seedConfidence,
+            });
+        }
+    }
+    const mergedRows = adapter
+        .prepare(`
+        SELECT n.id AS source_entity_id, n.merged_into AS target_entity_id, o.id AS observation_id
+        FROM entity_nodes n
+        LEFT JOIN entity_observations o ON o.id = n.id
+        WHERE n.status = 'merged'
+          AND n.merged_into IS NOT NULL
+      `)
+        .all();
+    for (const row of mergedRows) {
+        if (!row.observation_id) {
+            incomplete += 1;
+            continue;
+        }
+        const existing = adapter
+            .prepare(`
+          SELECT id
+          FROM entity_lineage_links
+          WHERE canonical_entity_id = ?
+            AND entity_observation_id = ?
+            AND status = 'active'
+          LIMIT 1
+        `)
+            .get(row.target_entity_id, row.observation_id);
+        if (existing) {
+            continue;
+        }
+        adopted += 1;
+        if (!dryRun) {
+            await (0, lineage_store_js_1.appendEntityLineageLink)({
+                canonical_entity_id: row.target_entity_id,
+                entity_observation_id: row.observation_id,
+                source_entity_id: row.source_entity_id,
+                contribution_kind: 'merge_adopt',
+                run_id: null,
+                candidate_id: null,
+                review_action_id: null,
+                capture_mode: 'backfilled',
+                confidence: adoptConfidence,
+            });
+        }
+    }
+    return { seeded, adopted, incomplete };
+}
+//# sourceMappingURL=lineage-backfill.js.map

package/dist/entities/lineage-store.d.ts

@@ -0,0 +1,51 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { EntityIngestRun, EntityLineageLink } from './types.js';
+import type { EntityStoreAdapter } from './store.js';
+type CreateEntityIngestRunInput = Omit<EntityIngestRun, 'status' | 'raw_count' | 'observation_count' | 'candidate_count' | 'reviewable_count' | 'audit_run_id' | 'audit_classification' | 'error_reason' | 'created_at' | 'completed_at'> & {
+    id?: string;
+};
+type AppendEntityLineageLinkInput = Omit<EntityLineageLink, 'id' | 'status' | 'created_at' | 'superseded_at'>;
+interface CompleteEntityIngestRunInput {
+    raw_count: number;
+    observation_count: number;
+    candidate_count: number;
+    reviewable_count: number;
+    audit_run_id?: string | null;
+    audit_classification?: EntityIngestRun['audit_classification'];
+}
+interface AdoptLineageAfterMergeInput {
+    adapter?: LineageMutationAdapter;
+    source_entity_id: string;
+    target_entity_id: string;
+    candidate_id?: string | null;
+    review_action_id?: string | null;
+    confidence?: number;
+    capture_mode?: EntityLineageLink['capture_mode'];
+}
+type LineageMutationAdapter = Pick<DatabaseAdapter, 'prepare'>;
+export interface AppendEntityLineageLinkResult {
+    link: EntityLineageLink;
+    created: boolean;
+}
+interface AdoptLineageAfterMergeSyncInput extends Omit<AdoptLineageAfterMergeInput, 'adapter'> {
+    adapter: LineageMutationAdapter;
+}
+export declare function parseEntityIngestRunRow(row: Record<string, unknown>): EntityIngestRun;
+export declare function createEntityIngestRun(input: CreateEntityIngestRunInput): Promise<EntityIngestRun>;
+export declare function completeEntityIngestRun(id: string, input: CompleteEntityIngestRunInput): Promise<EntityIngestRun>;
+export declare function failEntityIngestRun(id: string, errorReason: string): Promise<EntityIngestRun>;
+export declare function appendEntityLineageLink(input: AppendEntityLineageLinkInput): Promise<AppendEntityLineageLinkResult>;
+export declare function supersedeEntityLineageForEntity(entityId: string): Promise<number>;
+export declare function seedLineageForEntityMaterialization(input: {
+    canonical_entity_id: string;
+    entity_observation_id: string;
+    run_id?: string | null;
+    confidence?: number;
+    capture_mode?: EntityLineageLink['capture_mode'];
+}): Promise<EntityLineageLink>;
+export declare function adoptLineageAfterMerge(input: AdoptLineageAfterMergeInput): Promise<EntityLineageLink[]>;
+export declare function adoptLineageAfterMergeSync(input: AdoptLineageAfterMergeSyncInput): EntityLineageLink[];
+export declare function listActiveEntityLineage(entityId: string, adapter?: EntityStoreAdapter): Promise<EntityLineageLink[]>;
+export declare function listEntityLineageHistory(entityId: string, adapter?: EntityStoreAdapter): Promise<EntityLineageLink[]>;
+export {};
+//# sourceMappingURL=lineage-store.d.ts.map

package/dist/entities/lineage-store.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEntityIngestRunRow = parseEntityIngestRunRow;
+exports.createEntityIngestRun = createEntityIngestRun;
+exports.completeEntityIngestRun = completeEntityIngestRun;
+exports.failEntityIngestRun = failEntityIngestRun;
+exports.appendEntityLineageLink = appendEntityLineageLink;
+exports.supersedeEntityLineageForEntity = supersedeEntityLineageForEntity;
+exports.seedLineageForEntityMaterialization = seedLineageForEntityMaterialization;
+exports.adoptLineageAfterMerge = adoptLineageAfterMerge;
+exports.adoptLineageAfterMergeSync = adoptLineageAfterMergeSync;
+exports.listActiveEntityLineage = listActiveEntityLineage;
+exports.listEntityLineageHistory = listEntityLineageHistory;
+const node_crypto_1 = require("node:crypto");
+const db_manager_js_1 = require("../db-manager.js");
+function now() {
+    return Date.now();
+}
+function parseEntityIngestRunRow(row) {
+    return {
+        id: String(row.id),
+        connector: String(row.connector),
+        run_kind: row.run_kind,
+        status: row.status,
+        scope_key: String(row.scope_key),
+        source_window_start: typeof row.source_window_start === 'number' ? row.source_window_start : null,
+        source_window_end: typeof row.source_window_end === 'number' ? row.source_window_end : null,
+        raw_count: Number(row.raw_count ?? 0),
+        observation_count: Number(row.observation_count ?? 0),
+        candidate_count: Number(row.candidate_count ?? 0),
+        reviewable_count: Number(row.reviewable_count ?? 0),
+        audit_run_id: typeof row.audit_run_id === 'string' ? row.audit_run_id : null,
+        audit_classification: typeof row.audit_classification === 'string'
+            ? row.audit_classification
+            : null,
+        error_reason: typeof row.error_reason === 'string' ? row.error_reason : null,
+        created_at: Number(row.created_at),
+        completed_at: typeof row.completed_at === 'number' ? row.completed_at : null,
+    };
+}
+function parseEntityLineageLinkRow(row) {
+    return {
+        id: String(row.id),
+        canonical_entity_id: String(row.canonical_entity_id),
+        entity_observation_id: String(row.entity_observation_id),
+        source_entity_id: typeof row.source_entity_id === 'string' ? row.source_entity_id : null,
+        contribution_kind: row.contribution_kind,
+        run_id: typeof row.run_id === 'string' ? row.run_id : null,
+        candidate_id: typeof row.candidate_id === 'string' ? row.candidate_id : null,
+        review_action_id: typeof row.review_action_id === 'string' ? row.review_action_id : null,
+        status: row.status,
+        capture_mode: row.capture_mode,
+        confidence: Number(row.confidence),
+        created_at: Number(row.created_at),
+        superseded_at: typeof row.superseded_at === 'number' ? row.superseded_at : null,
+    };
+}
+async function createEntityIngestRun(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const createdAt = now();
+    const id = input.id || `eir_${(0, node_crypto_1.randomUUID)()}`;
+    adapter
+        .prepare(`
+        INSERT INTO entity_ingest_runs (
+          id, connector, run_kind, status, scope_key, source_window_start, source_window_end,
+          raw_count, observation_count, candidate_count, reviewable_count, audit_run_id,
+          audit_classification, error_reason, created_at, completed_at
+        ) VALUES (?, ?, ?, 'running', ?, ?, ?, 0, 0, 0, 0, NULL, NULL, NULL, ?, NULL)
+      `)
+        .run(id, input.connector, input.run_kind, input.scope_key, input.source_window_start, input.source_window_end, createdAt);
+    const row = adapter.prepare(`SELECT * FROM entity_ingest_runs WHERE id = ?`).get(id);
+    return parseEntityIngestRunRow(row);
+}
+async function completeEntityIngestRun(id, input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const completedAt = now();
+    const completion = adapter
+        .prepare(`
+        UPDATE entity_ingest_runs
+        SET status = 'complete',
+            raw_count = ?,
+            observation_count = ?,
+            candidate_count = ?,
+            reviewable_count = ?,
+            audit_run_id = ?,
+            audit_classification = ?,
+            error_reason = NULL,
+            completed_at = ?
+        WHERE id = ?
+      `)
+        .run(input.raw_count, input.observation_count, input.candidate_count, input.reviewable_count, input.audit_run_id ?? null, input.audit_classification ?? null, completedAt, id);
+    if (completion.changes !== 1) {
+        throw new Error(`Entity ingest run not found: ${id}`);
+    }
+    const row = adapter.prepare(`SELECT * FROM entity_ingest_runs WHERE id = ?`).get(id);
+    return parseEntityIngestRunRow(row);
+}
+async function failEntityIngestRun(id, errorReason) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const completedAt = now();
+    const completion = adapter
+        .prepare(`
+        UPDATE entity_ingest_runs
+        SET status = 'failed',
+            error_reason = ?,
+            completed_at = ?
+        WHERE id = ?
+      `)
+        .run(errorReason, completedAt, id);
+    if (completion.changes !== 1) {
+        throw new Error(`Entity ingest run not found: ${id}`);
+    }
+    const row = adapter.prepare(`SELECT * FROM entity_ingest_runs WHERE id = ?`).get(id);
+    return parseEntityIngestRunRow(row);
+}
+async function appendEntityLineageLink(input) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const existing = adapter
+        .prepare(`
+        SELECT *
+        FROM entity_lineage_links
+        WHERE canonical_entity_id = ?
+          AND entity_observation_id = ?
+          AND status = 'active'
+        LIMIT 1
+      `)
+        .get(input.canonical_entity_id, input.entity_observation_id);
+    // Idempotent by (canonical_entity_id, entity_observation_id, status='active').
+    // If an active row already exists for the pair, the existing row is returned
+    // and the caller-provided metadata is ignored.
+    if (existing) {
+        return {
+            link: parseEntityLineageLinkRow(existing),
+            created: false,
+        };
+    }
+    const id = `elin_${(0, node_crypto_1.randomUUID)()}`;
+    const createdAt = now();
+    adapter
+        .prepare(`
+        INSERT INTO entity_lineage_links (
+          id, canonical_entity_id, entity_observation_id, source_entity_id,
+          contribution_kind, run_id, candidate_id, review_action_id,
+          status, capture_mode, confidence, created_at, superseded_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?, ?, NULL)
+      `)
+        .run(id, input.canonical_entity_id, input.entity_observation_id, input.source_entity_id, input.contribution_kind, input.run_id, input.candidate_id, input.review_action_id, input.capture_mode, input.confidence, createdAt);
+    const row = adapter.prepare(`SELECT * FROM entity_lineage_links WHERE id = ?`).get(id);
+    return {
+        link: parseEntityLineageLinkRow(row),
+        created: true,
+    };
+}
+async function supersedeEntityLineageForEntity(entityId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const supersededAt = now();
+    const result = adapter
+        .prepare(`
+        UPDATE entity_lineage_links
+        SET status = 'superseded',
+            superseded_at = ?
+        WHERE canonical_entity_id = ?
+          AND status = 'active'
+      `)
+        .run(supersededAt, entityId);
+    return Number(result.changes ?? 0);
+}
+async function seedLineageForEntityMaterialization(input) {
+    const result = await appendEntityLineageLink({
+        canonical_entity_id: input.canonical_entity_id,
+        entity_observation_id: input.entity_observation_id,
+        source_entity_id: null,
+        contribution_kind: 'seed',
+        run_id: input.run_id ?? null,
+        candidate_id: null,
+        review_action_id: null,
+        capture_mode: input.capture_mode ?? 'direct',
+        confidence: input.confidence ?? 1,
+    });
+    return result.link;
+}
+function runLineageTransaction(adapter, fn) {
+    const savepoint = `adopt_lineage_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
+    adapter.prepare(`SAVEPOINT ${savepoint}`).run();
+    try {
+        const result = fn();
+        adapter.prepare(`RELEASE SAVEPOINT ${savepoint}`).run();
+        return result;
+    }
+    catch (error) {
+        try {
+            adapter.prepare(`ROLLBACK TO SAVEPOINT ${savepoint}`).run();
+        }
+        catch {
+            // Ignore rollback errors when the connection already unwound the savepoint.
+        }
+        try {
+            adapter.prepare(`RELEASE SAVEPOINT ${savepoint}`).run();
+        }
+        catch {
+            // Ignore cleanup failures after rollback.
+        }
+        throw error;
+    }
+}
+async function adoptLineageAfterMerge(input) {
+    if (!input.adapter) {
+        await (0, db_manager_js_1.initDB)();
+        const adapter = (0, db_manager_js_1.getAdapter)();
+        return adoptLineageAfterMergeSync({ ...input, adapter });
+    }
+    return adoptLineageAfterMergeSync(input);
+}
+function adoptLineageAfterMergeSync(input) {
+    return runLineageTransaction(input.adapter, () => adoptLineageAfterMergeWithAdapter(input.adapter, input));
+}
+function adoptLineageAfterMergeWithAdapter(adapter, input) {
+    const createdAt = now();
+    const supersededAt = now();
+    const sourceRows = adapter
+        .prepare(`
+        SELECT *
+        FROM entity_lineage_links
+        WHERE canonical_entity_id = ?
+          AND status = 'active'
+        ORDER BY created_at ASC
+      `)
+        .all(input.source_entity_id);
+    adapter
+        .prepare(`
+        UPDATE entity_lineage_links
+        SET status = 'superseded',
+            superseded_at = ?
+        WHERE canonical_entity_id = ?
+          AND status = 'active'
+      `)
+        .run(supersededAt, input.source_entity_id);
+    const adopted = [];
+    for (const row of sourceRows) {
+        const observationId = String(row.entity_observation_id);
+        const existing = adapter
+            .prepare(`
+          SELECT *
+          FROM entity_lineage_links
+          WHERE canonical_entity_id = ?
+            AND entity_observation_id = ?
+            AND status = 'active'
+          LIMIT 1
+        `)
+            .get(input.target_entity_id, observationId);
+        if (existing) {
+            adopted.push(parseEntityLineageLinkRow(existing));
+            continue;
+        }
+        const id = `elin_${(0, node_crypto_1.randomUUID)()}`;
+        adapter
+            .prepare(`
+          INSERT INTO entity_lineage_links (
+            id, canonical_entity_id, entity_observation_id, source_entity_id,
+            contribution_kind, run_id, candidate_id, review_action_id,
+            status, capture_mode, confidence, created_at, superseded_at
+          ) VALUES (?, ?, ?, ?, 'merge_adopt', ?, ?, ?, 'active', ?, ?, ?, NULL)
+        `)
+            .run(id, input.target_entity_id, observationId, input.source_entity_id, typeof row.run_id === 'string' ? row.run_id : null, input.candidate_id ?? null, input.review_action_id ?? null, input.capture_mode ?? 'direct', input.confidence ?? Number(row.confidence ?? 1), createdAt);
+        const created = adapter
+            .prepare(`SELECT * FROM entity_lineage_links WHERE id = ?`)
+            .get(id);
+        adopted.push(parseEntityLineageLinkRow(created));
+    }
+    return adopted;
+}
+async function listActiveEntityLineage(entityId, adapter) {
+    if (!adapter) {
+        await (0, db_manager_js_1.initDB)();
+    }
+    const effectiveAdapter = adapter ?? (0, db_manager_js_1.getAdapter)();
+    const rows = effectiveAdapter
+        .prepare(`
+        SELECT *
+        FROM entity_lineage_links
+        WHERE canonical_entity_id = ?
+          AND status = 'active'
+        ORDER BY created_at ASC
+      `)
+        .all(entityId);
+    return rows.map(parseEntityLineageLinkRow);
+}
+async function listEntityLineageHistory(entityId, adapter) {
+    if (!adapter) {
+        await (0, db_manager_js_1.initDB)();
+    }
+    const effectiveAdapter = adapter ?? (0, db_manager_js_1.getAdapter)();
+    const rows = effectiveAdapter
+        .prepare(`
+        SELECT *
+        FROM entity_lineage_links
+        WHERE canonical_entity_id = ?
+        ORDER BY created_at ASC
+      `)
+        .all(entityId);
+    return rows.map(parseEntityLineageLinkRow);
+}
+//# sourceMappingURL=lineage-store.js.map

package/dist/entities/normalization.d.ts

@@ -0,0 +1,14 @@
+export type EntityScript = 'Latn' | 'Hang' | 'Jpan' | 'Mixed' | 'Unknown';
+export interface NormalizedEntityLabel {
+    original: string;
+    normalized: string;
+    script: EntityScript;
+}
+export declare function detectScript(input: string): EntityScript;
+export declare function normalizeEntityLabel(input: unknown): NormalizedEntityLabel;
+export declare function extractStructuredIdentifiers(input: string): {
+    emails: string[];
+    handles: string[];
+    domains: string[];
+};
+//# sourceMappingURL=normalization.d.ts.map