@jungjaehoon/mama-core 1.8.1 → 2.0.0

package/dist/entities/candidate-generator.js

@@ -2,299 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ENTITY_EMBEDDING_TOPN = void 0;
 exports.dedupeObservationsBySource = dedupeObservationsBySource;
-exports.generateResolutionCandidates = generateResolutionCandidates;
-const errors_js_1 = require("./errors.js");
-const normalization_js_1 = require("./normalization.js");
 exports.ENTITY_EMBEDDING_TOPN = 50;
-const CROSS_SCOPE_PROBE_MIN_EMBEDDING_SCORE = 0.84;
-const MAX_DETERMINISTIC_SCOPE_BUCKET = 32;
-const MAX_CROSS_SCOPE_SCOPE_BUCKET = 8;
-function tokenize(input) {
-    return input
-        .toLowerCase()
-        .split(/[\s,.!?;:()[\]{}"'/_-]+/u)
-        .map((token) => token.trim())
-        .filter((token) => token.length > 1);
-}
-function contextScore(left, right) {
-    const leftTokens = new Set(tokenize(left.context_summary ?? ''));
-    const rightTokens = new Set(tokenize(right.context_summary ?? ''));
-    if (leftTokens.size === 0 || rightTokens.size === 0) {
-        return 0;
-    }
-    let overlap = 0;
-    for (const token of leftTokens) {
-        if (rightTokens.has(token)) {
-            overlap += 1;
-        }
-    }
-    return overlap / Math.max(Math.min(leftTokens.size, rightTokens.size), 1);
-}
-function structuralScore(left, right) {
-    if (left.normalized_form === right.normalized_form) {
-        return 1;
-    }
-    const leftIds = (0, normalization_js_1.extractStructuredIdentifiers)(left.surface_form);
-    const rightIds = (0, normalization_js_1.extractStructuredIdentifiers)(right.surface_form);
-    const hasSharedEmail = leftIds.emails.some((value) => rightIds.emails.includes(value));
-    const hasSharedHandle = leftIds.handles.some((value) => rightIds.handles.includes(value));
-    const hasSharedDomain = leftIds.domains.some((value) => rightIds.domains.includes(value));
-    if (hasSharedEmail || hasSharedHandle || hasSharedDomain) {
-        return 0.75;
-    }
-    return 0;
-}
-function stringScore(left, right) {
-    if (left.normalized_form === right.normalized_form) {
-        return 1;
-    }
-    const leftText = left.surface_form.toLowerCase();
-    const rightText = right.surface_form.toLowerCase();
-    const sharedPrefix = leftText.length > 0 && rightText.length > 0 && leftText[0] === rightText[0];
-    return sharedPrefix ? 0.1 : 0;
-}
-function scorePair(left, right, probeKind) {
-    const score_structural = structuralScore(left, right);
-    const score_string = stringScore(left, right);
-    const score_context = contextScore(left, right);
-    const score_graph = 0;
-    const score_total = score_structural + score_string + score_context + score_graph;
-    return {
-        left,
-        right,
-        score_structural,
-        score_string,
-        score_context,
-        score_graph,
-        score_total,
-        probe_kind: probeKind,
-    };
-}
-function shouldConsiderPair(left, right) {
-    if (left.entity_kind_hint &&
-        right.entity_kind_hint &&
-        left.entity_kind_hint !== right.entity_kind_hint) {
-        return false;
-    }
-    if (left.scope_kind !== right.scope_kind) {
-        return false;
-    }
-    if (left.scope_id !== right.scope_id) {
-        return false;
-    }
-    return true;
-}
-function shouldConsiderCrossScopeProbe(left, right) {
-    if (!left.entity_kind_hint ||
-        !right.entity_kind_hint ||
-        left.entity_kind_hint !== right.entity_kind_hint) {
-        return false;
-    }
-    if (left.observation_type !== right.observation_type) {
-        return false;
-    }
-    if (left.scope_kind !== right.scope_kind) {
-        return false;
-    }
-    if (left.scope_id === right.scope_id) {
-        return false;
-    }
-    return true;
-}
-function buildBlockKeys(observation) {
-    const keys = new Set();
-    keys.add(`norm:${observation.normalized_form}`);
-    for (const related of observation.related_surface_forms) {
-        keys.add(`related:${related}`);
-    }
-    const ids = (0, normalization_js_1.extractStructuredIdentifiers)(observation.surface_form);
-    for (const email of ids.emails) {
-        keys.add(`email:${email}`);
-    }
-    for (const handle of ids.handles) {
-        keys.add(`handle:${handle}`);
-    }
-    for (const domain of ids.domains) {
-        keys.add(`domain:${domain}`);
-    }
-    const contextTokens = tokenize(observation.context_summary ?? '').slice(0, 3);
-    for (const token of contextTokens) {
-        keys.add(`ctx:${observation.scope_kind}:${observation.scope_id ?? 'global'}:${token}`);
-    }
-    return Array.from(keys);
-}
-function normalizeSurfaceForm(value) {
-    if (value.trim().length === 0) {
-        return '';
-    }
-    return (0, normalization_js_1.normalizeEntityLabel)(value).normalized;
-}
-function sharedNormalizedRelatedCount(left, right) {
-    const leftRelated = new Set(left.related_surface_forms.map((value) => normalizeSurfaceForm(value)));
-    const rightRelated = new Set(right.related_surface_forms.map((value) => normalizeSurfaceForm(value)));
-    if (leftRelated.size === 0 || rightRelated.size === 0) {
-        return 0;
-    }
-    let overlap = 0;
-    for (const related of leftRelated) {
-        if (rightRelated.has(related)) {
-            overlap += 1;
-        }
-    }
-    return overlap;
-}
-function getTimestampDistance(left, right) {
-    if (left.timestamp_observed === null || right.timestamp_observed === null) {
-        return Number.POSITIVE_INFINITY;
-    }
-    return Math.abs(left.timestamp_observed - right.timestamp_observed);
-}
-function buildPairKey(left, right) {
-    return `${left.id}::${right.id}`;
-}
-function compareObservationForSampling(left, right) {
-    const leftRelated = left.related_surface_forms.length;
-    const rightRelated = right.related_surface_forms.length;
-    if (rightRelated !== leftRelated) {
-        return rightRelated - leftRelated;
-    }
-    const leftContext = left.context_summary?.length ?? 0;
-    const rightContext = right.context_summary?.length ?? 0;
-    if (rightContext !== leftContext) {
-        return rightContext - leftContext;
-    }
-    const leftObserved = left.timestamp_observed ?? Number.NEGATIVE_INFINITY;
-    const rightObserved = right.timestamp_observed ?? Number.NEGATIVE_INFINITY;
-    if (rightObserved !== leftObserved) {
-        return rightObserved - leftObserved;
-    }
-    return left.id.localeCompare(right.id);
-}
-function capObservationGroup(observations, limit) {
-    if (observations.length <= limit) {
-        return observations;
-    }
-    return [...observations].sort(compareObservationForSampling).slice(0, limit);
-}
-function pushTopProbe(probes, candidate, maxPairs) {
-    probes.push(candidate);
-    probes.sort(compareProbePairs);
-    if (probes.length > maxPairs) {
-        probes.length = maxPairs;
-    }
-}
-function buildCrossLanguageFamilyKey(left, right) {
-    if (!left.lang || !right.lang || left.lang === right.lang) {
-        return null;
-    }
-    const forms = [
-        `${left.lang}:${left.normalized_form}`,
-        `${right.lang}:${right.normalized_form}`,
-    ].sort();
-    const observationTypes = [left.observation_type, right.observation_type].sort();
-    return JSON.stringify([
-        left.entity_kind_hint ?? right.entity_kind_hint ?? 'unknown',
-        observationTypes,
-        forms,
-    ]);
-}
-function compareProbePairs(left, right) {
-    const relatedDelta = sharedNormalizedRelatedCount(right.left, right.right) -
-        sharedNormalizedRelatedCount(left.left, left.right);
-    if (relatedDelta !== 0) {
-        return relatedDelta;
-    }
-    if (right.score_total !== left.score_total) {
-        return right.score_total - left.score_total;
-    }
-    const timestampDelta = getTimestampDistance(left.left, left.right) - getTimestampDistance(right.left, right.right);
-    if (timestampDelta !== 0) {
-        return timestampDelta;
-    }
-    return buildPairKey(left.left, left.right).localeCompare(buildPairKey(right.left, right.right));
-}
-function dedupeCrossLanguageFamilies(candidates, observationLookup) {
-    const deduped = [];
-    const bestByFamily = new Map();
-    for (const candidate of candidates) {
-        const left = observationLookup.get(candidate.left_ref);
-        const right = observationLookup.get(candidate.right_ref);
-        if (!left || !right) {
-            deduped.push(candidate);
-            continue;
-        }
-        const familyKey = buildCrossLanguageFamilyKey(left, right);
-        if (!familyKey) {
-            deduped.push(candidate);
-            continue;
-        }
-        const existing = bestByFamily.get(familyKey);
-        if (!existing ||
-            candidate.score_total > existing.score_total ||
-            (candidate.score_total === existing.score_total &&
-                candidate.id.localeCompare(existing.id) < 0)) {
-            bestByFamily.set(familyKey, candidate);
-        }
-    }
-    return deduped.concat(Array.from(bestByFamily.values()));
-}
-function buildCrossScopeProbePairs(observations, seenPairs, maxPairs) {
-    if (maxPairs <= 0) {
-        return [];
-    }
-    const probes = [];
-    const bucketMap = new Map();
-    for (const observation of observations) {
-        if (!observation.entity_kind_hint) {
-            continue;
-        }
-        const bucketKey = JSON.stringify([
-            observation.entity_kind_hint,
-            observation.observation_type,
-            observation.scope_kind,
-        ]);
-        const bucket = bucketMap.get(bucketKey) ?? [];
-        bucket.push(observation);
-        bucketMap.set(bucketKey, bucket);
-    }
-    for (const bucket of bucketMap.values()) {
-        const scopeBuckets = new Map();
-        for (const observation of bucket) {
-            const scopeKey = observation.scope_id ?? 'global';
-            const scopeBucket = scopeBuckets.get(scopeKey) ?? [];
-            scopeBucket.push(observation);
-            scopeBuckets.set(scopeKey, scopeBucket);
-        }
-        const limitedScopeBuckets = Array.from(scopeBuckets.values())
-            .filter((scopeBucket) => scopeBucket.length > 0)
-            .map((scopeBucket) => capObservationGroup(scopeBucket, MAX_CROSS_SCOPE_SCOPE_BUCKET));
-        for (let i = 0; i < limitedScopeBuckets.length; i += 1) {
-            for (let j = i + 1; j < limitedScopeBuckets.length; j += 1) {
-                const leftBucket = limitedScopeBuckets[i];
-                const rightBucket = limitedScopeBuckets[j];
-                for (const first of leftBucket) {
-                    for (const second of rightBucket) {
-                        const [left, right] = first.id.localeCompare(second.id) <= 0 ? [first, second] : [second, first];
-                        const pairKey = buildPairKey(left, right);
-                        if (seenPairs.has(pairKey)) {
-                            continue;
-                        }
-                        if (!shouldConsiderCrossScopeProbe(left, right)) {
-                            continue;
-                        }
-                        seenPairs.add(pairKey);
-                        pushTopProbe(probes, scorePair(left, right, 'cross_scope'), maxPairs);
-                    }
-                }
-            }
-        }
-    }
-    return probes;
-}
-function hasMultipleScopes(observations) {
-    const scopes = new Set(observations.map((observation) => `${observation.scope_kind}:${observation.scope_id ?? 'global'}`));
-    return scopes.size > 1;
-}
 function dedupeObservationsBySource(observations) {
     const seen = new Set();
     const deduped = [];
@@ -313,124 +21,4 @@ function dedupeObservationsBySource(observations) {
     }
     return deduped;
 }
-async function generateResolutionCandidates(observations, options = {}) {
-    const deduped = dedupeObservationsBySource(observations);
-    const observationLookup = new Map(deduped.map((observation) => [observation.id, observation]));
-    const blockMap = new Map();
-    for (const observation of deduped) {
-        const keys = buildBlockKeys(observation);
-        for (const key of keys) {
-            const existing = blockMap.get(key) ?? [];
-            existing.push(observation);
-            blockMap.set(key, existing);
-        }
-    }
-    const preliminary = [];
-    const seenPairs = new Set();
-    for (const bucket of blockMap.values()) {
-        if (bucket.length < 2) {
-            continue;
-        }
-        const scopeBuckets = new Map();
-        for (const observation of bucket) {
-            const scopeKey = `${observation.scope_kind}:${observation.scope_id ?? 'global'}`;
-            const scopeBucket = scopeBuckets.get(scopeKey) ?? [];
-            scopeBucket.push(observation);
-            scopeBuckets.set(scopeKey, scopeBucket);
-        }
-        for (const scopeBucket of scopeBuckets.values()) {
-            const limitedBucket = capObservationGroup(scopeBucket, MAX_DETERMINISTIC_SCOPE_BUCKET);
-            if (limitedBucket.length < 2) {
-                continue;
-            }
-            for (let i = 0; i < limitedBucket.length; i += 1) {
-                for (let j = i + 1; j < limitedBucket.length; j += 1) {
-                    const first = limitedBucket[i];
-                    const second = limitedBucket[j];
-                    const [left, right] = first.id.localeCompare(second.id) <= 0 ? [first, second] : [second, first];
-                    const pairKey = `${left.id}::${right.id}`;
-                    if (seenPairs.has(pairKey)) {
-                        continue;
-                    }
-                    if (!shouldConsiderPair(left, right)) {
-                        continue;
-                    }
-                    seenPairs.add(pairKey);
-                    const scored = scorePair(left, right, 'deterministic');
-                    if (scored.score_total <= 0 && !options.embeddingScorer) {
-                        continue;
-                    }
-                    preliminary.push(scored);
-                }
-            }
-        }
-    }
-    preliminary.sort((left, right) => right.score_total - left.score_total);
-    const topNLimit = options.topN ?? exports.ENTITY_EMBEDDING_TOPN;
-    const topN = preliminary.slice(0, topNLimit);
-    topN.sort((left, right) => right.score_total - left.score_total);
-    const pairBudget = Math.ceil(topNLimit ** 2 / 2);
-    const crossScopeBudget = options.embeddingScorer ? Math.max(0, pairBudget - topN.length) : 0;
-    const crossScopePairs = options.embeddingScorer && crossScopeBudget > 0 && hasMultipleScopes(deduped)
-        ? buildCrossScopeProbePairs(deduped, seenPairs, crossScopeBudget)
-        : [];
-    const candidates = [];
-    for (const item of [...topN, ...crossScopePairs]) {
-        let score_embedding = 0;
-        if (options.embeddingScorer) {
-            try {
-                score_embedding = await options.embeddingScorer(item.left, item.right);
-            }
-            catch (error) {
-                if (error instanceof errors_js_1.EmbeddingUnavailableError) {
-                    throw error;
-                }
-                throw new errors_js_1.EmbeddingUnavailableError({
-                    reason: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        const finalScore = item.score_total + score_embedding;
-        if (finalScore <= 0) {
-            continue;
-        }
-        if (item.probe_kind === 'cross_scope' &&
-            score_embedding < CROSS_SCOPE_PROBE_MIN_EMBEDDING_SCORE) {
-            continue;
-        }
-        const createdAt = Date.now();
-        candidates.push({
-            id: `candidate_${item.left.id}_${item.right.id}`,
-            candidate_kind: 'cluster',
-            left_ref: item.left.id,
-            right_ref: item.right.id,
-            status: 'pending',
-            score_total: finalScore,
-            score_structural: item.score_structural,
-            score_string: item.score_string,
-            score_context: item.score_context,
-            score_graph: item.score_graph,
-            score_embedding,
-            rule_trace: JSON.stringify({
-                structural: item.score_structural,
-                string: item.score_string,
-                context: item.score_context,
-            }),
-            extractor_version: item.left.extractor_version,
-            embedding_model_version: item.left.embedding_model_version ?? item.right.embedding_model_version,
-            created_at: createdAt,
-            updated_at: createdAt,
-        });
-    }
-    const dedupedFamilies = options.embeddingScorer
-        ? dedupeCrossLanguageFamilies(candidates, observationLookup)
-        : candidates;
-    dedupedFamilies.sort((left, right) => {
-        if (right.score_total !== left.score_total) {
-            return right.score_total - left.score_total;
-        }
-        return left.id.localeCompare(right.id);
-    });
-    return dedupedFamilies.slice(0, topNLimit);
-}
 //# sourceMappingURL=candidate-generator.js.map

package/dist/entities/entity-list.d.ts

@@ -19,5 +19,4 @@ export interface ListCanonicalEntitiesResult {
     total_count: number;
     visible_count: number;
 }
-export declare function listCanonicalEntities(input: ListCanonicalEntitiesInput): Promise<ListCanonicalEntitiesResult>;
 //# sourceMappingURL=entity-list.d.ts.map

package/dist/entities/entity-list.js

@@ -1,99 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listCanonicalEntities = listCanonicalEntities;
-const db_manager_js_1 = require("../db-manager.js");
-const entity_linked_decision_counts_js_1 = require("./entity-linked-decision-counts.js");
-function normalizeBrowseLabel(input) {
-    return input.normalize('NFKC').trim().replace(/\s+/gu, ' ').toLowerCase();
-}
-function buildBrowseCollapseKey(row) {
-    return JSON.stringify([
-        row.kind,
-        row.scope_kind,
-        row.scope_id ?? '',
-        normalizeBrowseLabel(row.preferred_label),
-    ]);
-}
-function compareCanonicalRows(left, right) {
-    if (right.created_at !== left.created_at) {
-        return right.created_at - left.created_at;
-    }
-    const labelCompare = left.preferred_label.localeCompare(right.preferred_label);
-    if (labelCompare !== 0) {
-        return labelCompare;
-    }
-    return left.id.localeCompare(right.id);
-}
-function decodeCursor(cursor) {
-    if (!cursor) {
-        return 0;
-    }
-    try {
-        const decoded = Number(Buffer.from(cursor, 'base64').toString('utf8'));
-        return Number.isFinite(decoded) && decoded >= 0 ? decoded : 0;
-    }
-    catch {
-        return 0;
-    }
-}
-function encodeCursor(offset) {
-    return Buffer.from(String(offset), 'utf8').toString('base64');
-}
-function isNoisyCanonicalEntity(row) {
-    const label = row.preferred_label.trim().toLowerCase();
-    if (row.kind === 'person') {
-        return label === 'user' || label === 'claude';
-    }
-    if (row.kind === 'project') {
-        return label === 'workspace';
-    }
-    return false;
-}
-async function listCanonicalEntities(input) {
-    await (0, db_manager_js_1.initDB)();
-    const adapter = (0, db_manager_js_1.getAdapter)();
-    const rows = adapter
-        .prepare(`
-        SELECT id, kind, preferred_label, scope_kind, scope_id, created_at
-        FROM entity_nodes
-        WHERE status = 'active'
-          AND merged_into IS NULL
-      `)
-        .all();
-    const sorted = rows.sort(compareCanonicalRows);
-    const collapsedByKey = new Map();
-    for (const row of sorted) {
-        const key = buildBrowseCollapseKey(row);
-        const existing = collapsedByKey.get(key);
-        if (!existing) {
-            collapsedByKey.set(key, row);
-            continue;
-        }
-        if (row.created_at > existing.created_at ||
-            (row.created_at === existing.created_at && row.id.localeCompare(existing.id) < 0)) {
-            collapsedByKey.set(key, row);
-        }
-    }
-    const collapsed = Array.from(collapsedByKey.values()).sort(compareCanonicalRows);
-    const totalCount = sorted.length;
-    const visibleBase = input.include_noisy === false
-        ? collapsed.filter((row) => !isNoisyCanonicalEntity(row))
-        : collapsed;
-    const offset = decodeCursor(input.cursor);
-    const limit = Math.max(1, input.limit);
-    const page = visibleBase.slice(offset, offset + limit);
-    const linkedCounts = (0, entity_linked_decision_counts_js_1.loadLinkedDecisionCounts)(adapter, page.map((row) => row.id));
-    const entities = page.map((row) => ({
-        ...row,
-        linked_decision_count: linkedCounts.get(row.id) ?? 0,
-    }));
-    const visibleCount = visibleBase.length;
-    const nextCursor = offset + limit < visibleBase.length ? encodeCursor(offset + limit) : null;
-    return {
-        entities,
-        next_cursor: nextCursor,
-        total_count: totalCount,
-        visible_count: visibleCount,
-    };
-}
 //# sourceMappingURL=entity-list.js.map

package/dist/entities/entity-orphan-list.d.ts

@@ -14,13 +14,4 @@ export interface CanonicalEntityOrphanRow {
         last_seen_at: number | null;
     };
 }
-interface ReadAdapter {
-    prepare(sql: string): {
-        all: (...params: unknown[]) => unknown[];
-    };
-}
-export declare function listCanonicalEntityOrphans(adapter?: ReadAdapter, options?: {
-    min_age_ms?: number | null;
-}): CanonicalEntityOrphanRow[];
-export {};
 //# sourceMappingURL=entity-orphan-list.d.ts.map

package/dist/entities/entity-orphan-list.js

@@ -1,91 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listCanonicalEntityOrphans = listCanonicalEntityOrphans;
-const db_manager_js_1 = require("../db-manager.js");
-const entity_linked_decision_counts_js_1 = require("./entity-linked-decision-counts.js");
-function buildScopeLabel(scopeKind, scopeId) {
-    return scopeKind ? `${scopeKind}:${scopeId ?? ''}` : 'global';
-}
-function isNoisyCanonicalEntity(row) {
-    const label = row.title.trim().toLowerCase();
-    if (row.kind === 'person') {
-        return label === 'user' || label === 'claude';
-    }
-    if (row.kind === 'project') {
-        return label === 'workspace';
-    }
-    return false;
-}
-function compareOrphanRows(left, right) {
-    const leftSeen = typeof left.evidence_summary.last_seen_at === 'number' ? left.evidence_summary.last_seen_at : 0;
-    const rightSeen = typeof right.evidence_summary.last_seen_at === 'number'
-        ? right.evidence_summary.last_seen_at
-        : 0;
-    if (rightSeen !== leftSeen) {
-        return rightSeen - leftSeen;
-    }
-    return left.entity_id.localeCompare(right.entity_id);
-}
-function listCanonicalEntityOrphans(adapter = (0, db_manager_js_1.getAdapter)(), options = {}) {
-    const minAgeMs = typeof options.min_age_ms === 'number' && Number.isFinite(options.min_age_ms)
-        ? Math.max(0, options.min_age_ms)
-        : 0;
-    const minCreatedAt = Date.now() - minAgeMs;
-    const rows = adapter
-        .prepare(`
-        SELECT
-          n.id AS entity_id,
-          n.kind AS kind,
-          n.preferred_label AS title,
-          n.scope_kind AS scope_kind,
-          n.scope_id AS scope_id,
-          n.created_at AS created_at,
-          COUNT(DISTINCT l.entity_observation_id) AS lineage_rows,
-          COUNT(
-            DISTINCT CASE
-              WHEN COALESCE(o.source_raw_record_id, '') <> '' THEN l.entity_observation_id
-              ELSE NULL
-            END
-          ) AS raw_evidence_rows,
-          MAX(COALESCE(o.timestamp_observed, o.created_at)) AS last_seen_at
-        FROM entity_nodes n
-        INNER JOIN entity_lineage_links l
-          ON l.canonical_entity_id = n.id
-         AND l.status = 'active'
-        INNER JOIN entity_observations o
-          ON o.id = l.entity_observation_id
-        WHERE n.status = 'active'
-          AND n.merged_into IS NULL
-          AND n.created_at <= ?
-        GROUP BY n.id, n.kind, n.preferred_label, n.scope_kind, n.scope_id, n.created_at
-      `)
-        .all(minCreatedAt);
-    const orphanRows = rows.map((row) => ({
-        entity_id: row.entity_id,
-        title: row.title,
-        kind: row.kind,
-        scope_kind: row.scope_kind,
-        scope_id: row.scope_id,
-        scope_label: buildScopeLabel(row.scope_kind, row.scope_id),
-        created_at: Number(row.created_at),
-        linked_decision_count: 0,
-        evidence_summary: {
-            lineage_rows: Number(row.lineage_rows ?? 0),
-            raw_evidence_rows: Number(row.raw_evidence_rows ?? 0),
-            last_seen_at: row.last_seen_at === null || row.last_seen_at === undefined
-                ? null
-                : Number(row.last_seen_at),
-        },
-    }));
-    const linkedCounts = (0, entity_linked_decision_counts_js_1.loadLinkedDecisionCounts)(adapter, orphanRows.map((row) => row.entity_id));
-    return orphanRows
-        .map((row) => ({
-        ...row,
-        linked_decision_count: linkedCounts.get(row.entity_id) ?? 0,
-    }))
-        .filter((row) => row.evidence_summary.lineage_rows > 0 &&
-        row.linked_decision_count === 0 &&
-        !isNoisyCanonicalEntity(row))
-        .sort(compareOrphanRows);
-}
 //# sourceMappingURL=entity-orphan-list.js.map

package/dist/entities/entity-search.d.ts

@@ -17,5 +17,4 @@ export interface SearchCanonicalEntitiesResult {
     entities: EntitySearchRow[];
     next_cursor: string | null;
 }
-export declare function searchCanonicalEntities(input: SearchCanonicalEntitiesInput): Promise<SearchCanonicalEntitiesResult>;
 //# sourceMappingURL=entity-search.d.ts.map