elementary-assertions 1.0.1

package/src/core/mention-builder.js

@@ -0,0 +1,272 @@
+const { findSelector, normalizeSpanKey, normalizeIds } = require("./determinism");
+const { getMweHeadEvidence, getMweLexiconEvidence } = require("./mention-materialization");
+const {
+  buildChunkHeadMaps,
+  buildDependencyObservationMaps,
+  resolveMentionHead,
+} = require("./mention-head-resolution");
+const { buildMentionLexiconEvidence } = require("./mention-evidence");
+
+function mentionSortKey(mention) {
+  return `${mention.segment_id}|${String(mention.span.start).padStart(8, "0")}|${String(mention.span.end).padStart(8, "0")}|${mention.kind}|${mention.id}`;
+}
+
+function buildMentions({ relationsSeed, mweSeed, headsSeed, tokenById, tokenWikiById }) {
+  const annotations = Array.isArray(mweSeed?.annotations) ? mweSeed.annotations : [];
+  const mweCandidates = [];
+  for (const annotation of annotations) {
+    if (!annotation || annotation.kind !== "mwe" || annotation.status !== "accepted") continue;
+    const tokenSelector = findSelector(annotation, "TokenSelector");
+    const textPos = findSelector(annotation, "TextPositionSelector");
+    if (!tokenSelector || !Array.isArray(tokenSelector.token_ids) || tokenSelector.token_ids.length === 0) continue;
+    if (!textPos || !textPos.span || typeof textPos.span.start !== "number" || typeof textPos.span.end !== "number") continue;
+    const ids = normalizeIds(tokenSelector.token_ids);
+    const missing = ids.some((id) => !tokenById.has(id));
+    if (missing) continue;
+    const segmentId = tokenById.get(ids[0]).segment_id;
+    if (!ids.every((id) => tokenById.get(id).segment_id === segmentId)) continue;
+    mweCandidates.push({
+      annotation_id: typeof annotation.id === "string" ? annotation.id : "",
+      token_ids: ids,
+      span: { start: textPos.span.start, end: textPos.span.end },
+      segment_id: segmentId,
+      explicit_head: getMweHeadEvidence(annotation),
+      lexicon_evidence: getMweLexiconEvidence(annotation),
+    });
+  }
+
+  mweCandidates.sort((a, b) => {
+    if (b.token_ids.length !== a.token_ids.length) return b.token_ids.length - a.token_ids.length;
+    const al = a.span.end - a.span.start;
+    const bl = b.span.end - b.span.start;
+    if (bl !== al) return bl - al;
+    if (a.span.start !== b.span.start) return a.span.start - b.span.start;
+    return a.annotation_id.localeCompare(b.annotation_id);
+  });
+
+  const claimed = new Set();
+  const winners = [];
+  const alternatives = [];
+  for (const candidate of mweCandidates) {
+    if (candidate.token_ids.some((id) => claimed.has(id))) {
+      alternatives.push(candidate);
+      continue;
+    }
+    winners.push(candidate);
+    for (const id of candidate.token_ids) claimed.add(id);
+  }
+
+  const { chunkById, headByChunkId } = buildChunkHeadMaps(headsSeed);
+  const { incomingInside } = buildDependencyObservationMaps(relationsSeed, tokenById);
+
+  const mentions = [];
+  const unresolvedHeadMap = new Map();
+
+  for (const winner of winners) {
+    const head = resolveMentionHead({
+      tokenIds: winner.token_ids,
+      explicitHead: winner.explicit_head,
+      chunkById,
+      headByChunkId,
+      incomingInsideMap: incomingInside,
+      tokenById,
+      findSelector,
+    });
+    const mentionLexiconEvidence = buildMentionLexiconEvidence({
+      tokenIds: winner.token_ids,
+      tokenWikiById,
+      mweLexiconEvidence: winner.lexicon_evidence,
+    });
+    const idBase = `m:${winner.segment_id}:${normalizeSpanKey(winner.span)}:mwe`;
+    mentions.push({
+      id: idBase,
+      kind: "mwe",
+      priority: 0,
+      token_ids: winner.token_ids,
+      head_token_id: head.head,
+      span: winner.span,
+      segment_id: winner.segment_id,
+      is_primary: true,
+      provenance: {
+        source_annotation_id: winner.annotation_id || undefined,
+        source_kind: "mwe_materialized",
+        head_strategy: head.strategy,
+        lexicon_source: mentionLexiconEvidence ? "wikipedia-title-index" : undefined,
+        lexicon_evidence: mentionLexiconEvidence || undefined,
+      },
+    });
+    if (head.unresolved) unresolvedHeadMap.set(idBase, head.unresolved);
+  }
+
+  for (const winner of alternatives) {
+    const head = resolveMentionHead({
+      tokenIds: winner.token_ids,
+      explicitHead: winner.explicit_head,
+      chunkById,
+      headByChunkId,
+      incomingInsideMap: incomingInside,
+      tokenById,
+      findSelector,
+    });
+    const mentionLexiconEvidence = buildMentionLexiconEvidence({
+      tokenIds: winner.token_ids,
+      tokenWikiById,
+      mweLexiconEvidence: winner.lexicon_evidence,
+    });
+    const idBase = `m:${winner.segment_id}:${normalizeSpanKey(winner.span)}:mwe_alt`;
+    mentions.push({
+      id: idBase,
+      kind: "mwe",
+      priority: 2,
+      token_ids: winner.token_ids,
+      head_token_id: head.head,
+      span: winner.span,
+      segment_id: winner.segment_id,
+      is_primary: false,
+      provenance: {
+        source_annotation_id: winner.annotation_id || undefined,
+        source_kind: "mwe_alternative",
+        head_strategy: head.strategy,
+        lexicon_source: mentionLexiconEvidence ? "wikipedia-title-index" : undefined,
+        lexicon_evidence: mentionLexiconEvidence || undefined,
+      },
+    });
+    if (head.unresolved) unresolvedHeadMap.set(idBase, head.unresolved);
+  }
+
+  const allTokensSorted = Array.from(tokenById.values()).sort((a, b) => a.i - b.i);
+  for (const token of allTokensSorted) {
+    if (claimed.has(token.id)) continue;
+    const mentionLexiconEvidence = buildMentionLexiconEvidence({
+      tokenIds: [token.id],
+      tokenWikiById,
+      mweLexiconEvidence: null,
+    });
+    const idBase = `m:${token.segment_id}:${token.span.start}-${token.span.end}:token`;
+    mentions.push({
+      id: idBase,
+      kind: "token",
+      priority: 1,
+      token_ids: [token.id],
+      head_token_id: token.id,
+      span: { start: token.span.start, end: token.span.end },
+      segment_id: token.segment_id,
+      is_primary: true,
+      provenance: {
+        source_kind: "token_fallback",
+        head_strategy: "explicit",
+        lexicon_source: mentionLexiconEvidence ? "wikipedia-title-index" : undefined,
+        lexicon_evidence: mentionLexiconEvidence || undefined,
+      },
+    });
+  }
+
+  for (const token of allTokensSorted) {
+    if (!claimed.has(token.id)) continue;
+    const mentionLexiconEvidence = buildMentionLexiconEvidence({
+      tokenIds: [token.id],
+      tokenWikiById,
+      mweLexiconEvidence: null,
+    });
+    const idBase = `m:${token.segment_id}:${token.span.start}-${token.span.end}:token_shadow`;
+    mentions.push({
+      id: idBase,
+      kind: "token",
+      priority: 4,
+      token_ids: [token.id],
+      head_token_id: token.id,
+      span: { start: token.span.start, end: token.span.end },
+      segment_id: token.segment_id,
+      is_primary: false,
+      provenance: {
+        source_kind: "token_shadow",
+        head_strategy: "explicit",
+        lexicon_source: mentionLexiconEvidence ? "wikipedia-title-index" : undefined,
+        lexicon_evidence: mentionLexiconEvidence || undefined,
+      },
+    });
+  }
+
+  for (const [chunkId, chunk] of chunkById.entries()) {
+    const tokenSelector = findSelector(chunk, "TokenSelector");
+    const textPos = findSelector(chunk, "TextPositionSelector");
+    if (!tokenSelector || !Array.isArray(tokenSelector.token_ids) || tokenSelector.token_ids.length === 0) continue;
+    if (!textPos || !textPos.span || typeof textPos.span.start !== "number" || typeof textPos.span.end !== "number") continue;
+    const tokenIds = normalizeIds(tokenSelector.token_ids);
+    if (tokenIds.some((id) => !tokenById.has(id))) continue;
+    const segmentId = tokenById.get(tokenIds[0]).segment_id;
+    if (!tokenIds.every((id) => tokenById.get(id).segment_id === segmentId)) continue;
+    const explicitHead = headByChunkId.get(chunkId) || null;
+    const head = resolveMentionHead({
+      tokenIds,
+      explicitHead,
+      chunkById,
+      headByChunkId,
+      incomingInsideMap: incomingInside,
+      tokenById,
+      findSelector,
+    });
+    const mentionLexiconEvidence = buildMentionLexiconEvidence({
+      tokenIds,
+      tokenWikiById,
+      mweLexiconEvidence: null,
+    });
+    const idBase = `m:${segmentId}:${normalizeSpanKey(textPos.span)}:chunk`;
+    mentions.push({
+      id: idBase,
+      kind: "chunk",
+      priority: 3,
+      token_ids: tokenIds,
+      head_token_id: head.head,
+      span: { start: textPos.span.start, end: textPos.span.end },
+      segment_id: segmentId,
+      is_primary: false,
+      provenance: {
+        source_annotation_id: chunkId,
+        source_kind: "chunk_accepted",
+        head_strategy: head.strategy,
+        lexicon_source: mentionLexiconEvidence ? "wikipedia-title-index" : undefined,
+        lexicon_evidence: mentionLexiconEvidence || undefined,
+      },
+    });
+    if (head.unresolved) unresolvedHeadMap.set(idBase, head.unresolved);
+  }
+
+  mentions.sort((a, b) => mentionSortKey(a).localeCompare(mentionSortKey(b)));
+
+  const baseIdCounts = new Map();
+  const assignedIds = new Set();
+  for (const mention of mentions) {
+    const baseId = mention.id;
+    let n = (baseIdCounts.get(baseId) || 0) + 1;
+    let candidate = n === 1 ? baseId : `${baseId}:${n}`;
+    while (assignedIds.has(candidate)) {
+      n += 1;
+      candidate = `${baseId}:${n}`;
+    }
+    baseIdCounts.set(baseId, n);
+    assignedIds.add(candidate);
+    mention.id = candidate;
+  }
+
+  const tokenToPrimaryMention = new Map();
+  const tokenToAllMentions = new Map();
+  for (const mention of mentions) {
+    if (!mention.is_primary) continue;
+    for (const tokenId of mention.token_ids) tokenToPrimaryMention.set(tokenId, mention.id);
+  }
+  for (const mention of mentions) {
+    for (const tokenId of mention.token_ids) {
+      if (!tokenToAllMentions.has(tokenId)) tokenToAllMentions.set(tokenId, []);
+      tokenToAllMentions.get(tokenId).push(mention.id);
+    }
+  }
+  for (const mentionIds of tokenToAllMentions.values()) mentionIds.sort((a, b) => a.localeCompare(b));
+
+  return { mentions, tokenToPrimaryMention, tokenToAllMentions, unresolvedHeadMap };
+}
+
+module.exports = {
+  mentionSortKey,
+  buildMentions,
+};

package/src/core/mention-evidence.js

@@ -0,0 +1,52 @@
+const { deepCloneJson, normalizeIds } = require("./determinism");
+
+function buildMentionLexiconEvidence({ tokenIds, tokenWikiById, mweLexiconEvidence }) {
+  const tokenEvidence = normalizeIds(tokenIds || [])
+    .filter((tokenId) => tokenWikiById.has(tokenId))
+    .map((tokenId) => ({
+      token_id: tokenId,
+      evidence: deepCloneJson(tokenWikiById.get(tokenId)),
+    }));
+
+  if (tokenEvidence.length === 0 && !mweLexiconEvidence) return null;
+
+  const out = {};
+  if (mweLexiconEvidence) out.mwe = deepCloneJson(mweLexiconEvidence);
+  if (tokenEvidence.length > 0) out.tokens = tokenEvidence;
+  return out;
+}
+
+function buildAssertionWikiSignals({ predicateMentionId, relations, mentionById }) {
+  const mentionIds = new Set([predicateMentionId]);
+  for (const relation of relations || []) {
+    if (relation && typeof relation.dep_mention_id === "string") mentionIds.add(relation.dep_mention_id);
+  }
+
+  const mentionEvidence = Array.from(mentionIds)
+    .sort((a, b) => a.localeCompare(b))
+    .map((mentionId) => {
+      const mention = mentionById.get(mentionId);
+      const lexiconEvidence =
+        mention &&
+        mention.provenance &&
+        mention.provenance.lexicon_evidence &&
+        typeof mention.provenance.lexicon_evidence === "object"
+          ? deepCloneJson(mention.provenance.lexicon_evidence)
+          : null;
+      if (!mention || !lexiconEvidence) return null;
+      return {
+        mention_id: mentionId,
+        token_ids: normalizeIds(mention.token_ids || []),
+        evidence: lexiconEvidence,
+      };
+    })
+    .filter(Boolean);
+
+  if (mentionEvidence.length === 0) return null;
+  return { mention_evidence: mentionEvidence };
+}
+
+module.exports = {
+  buildMentionLexiconEvidence,
+  buildAssertionWikiSignals,
+};

package/src/core/mention-head-resolution.js

@@ -0,0 +1,108 @@
+function buildChunkHeadMaps(headsSeed) {
+  const chunkById = new Map();
+  const headByChunkId = new Map();
+  if (!headsSeed || !Array.isArray(headsSeed.annotations)) return { chunkById, headByChunkId };
+  for (const annotation of headsSeed.annotations) {
+    if (!annotation || annotation.status !== "accepted") continue;
+    if (annotation.kind === "chunk" && typeof annotation.id === "string") {
+      chunkById.set(annotation.id, annotation);
+    }
+    if (
+      annotation.kind === "chunk_head" &&
+      typeof annotation.chunk_id === "string" &&
+      annotation.head &&
+      typeof annotation.head.id === "string"
+    ) {
+      headByChunkId.set(annotation.chunk_id, annotation.head.id);
+    }
+  }
+  return { chunkById, headByChunkId };
+}
+
+function buildDependencyObservationMaps(relationsSeed, tokenById) {
+  const incomingInside = new Map();
+  const outgoingInside = new Map();
+  const annotations = Array.isArray(relationsSeed && relationsSeed.annotations) ? relationsSeed.annotations : [];
+  for (const annotation of annotations) {
+    if (!annotation || annotation.kind !== "dependency" || annotation.status !== "observation") continue;
+    if (!annotation.dep || typeof annotation.dep.id !== "string" || !tokenById.has(annotation.dep.id)) continue;
+    if (annotation.is_root || !annotation.head || typeof annotation.head.id !== "string" || !tokenById.has(annotation.head.id)) {
+      continue;
+    }
+    const dep = annotation.dep.id;
+    const head = annotation.head.id;
+    if (!incomingInside.has(dep)) incomingInside.set(dep, []);
+    if (!outgoingInside.has(head)) outgoingInside.set(head, []);
+    incomingInside.get(dep).push(head);
+    outgoingInside.get(head).push(dep);
+  }
+  return { incomingInside, outgoingInside };
+}
+
+function posFallbackHead(tokenIds, tokenById) {
+  const tokens = (tokenIds || []).map((id) => tokenById.get(id)).filter(Boolean).sort((a, b) => a.i - b.i);
+  const nouns = tokens.filter((token) => /^(NN|NNS|NNP|NNPS|PRP|CD)/.test(token.pos.tag));
+  if (nouns.length > 0) return nouns[nouns.length - 1].id;
+  const verbs = tokens.filter((token) => /^VB/.test(token.pos.tag));
+  if (verbs.length > 0) return verbs[0].id;
+  return tokens.length > 0 ? tokens[tokens.length - 1].id : null;
+}
+
+function resolveMentionHead({
+  tokenIds,
+  explicitHead,
+  chunkById,
+  headByChunkId,
+  incomingInsideMap,
+  tokenById,
+  findSelector,
+}) {
+  const tokenSet = new Set(tokenIds);
+  if (explicitHead && tokenSet.has(explicitHead)) {
+    return { head: explicitHead, strategy: "explicit", unresolved: null };
+  }
+
+  for (const [chunkId, chunk] of chunkById.entries()) {
+    const tokenSelector = findSelector(chunk, "TokenSelector");
+    if (!tokenSelector || !Array.isArray(tokenSelector.token_ids)) continue;
+    const ids = tokenSelector.token_ids;
+    if (ids.length !== tokenIds.length) continue;
+    let same = true;
+    for (const id of ids) {
+      if (!tokenSet.has(id)) {
+        same = false;
+        break;
+      }
+    }
+    if (!same) continue;
+    const head = headByChunkId.get(chunkId);
+    if (head && tokenSet.has(head)) return { head, strategy: "chunk_head", unresolved: null };
+  }
+
+  const rootCandidates = tokenIds.filter((id) => {
+    const incoming = incomingInsideMap.get(id) || [];
+    const insideIncoming = incoming.filter((headId) => tokenSet.has(headId));
+    return insideIncoming.length === 0;
+  });
+  if (rootCandidates.length === 1) return { head: rootCandidates[0], strategy: "dependency_head", unresolved: null };
+
+  const fallback = posFallbackHead(tokenIds, tokenById);
+  if (fallback) {
+    return {
+      head: fallback,
+      strategy: "pos_fallback",
+      unresolved:
+        rootCandidates.length === 0
+          ? "no_dependency_head_in_mention"
+          : "multiple_dependency_head_candidates",
+    };
+  }
+  return { head: tokenIds[0], strategy: "unresolved", unresolved: "empty_mention_tokens" };
+}
+
+module.exports = {
+  buildChunkHeadMaps,
+  buildDependencyObservationMaps,
+  posFallbackHead,
+  resolveMentionHead,
+};

package/src/core/mention-materialization.js

@@ -0,0 +1,31 @@
+const { deepCloneJson } = require("./determinism");
+
+function getMweHeadEvidence(mwe) {
+  if (!Array.isArray(mwe && mwe.sources)) return null;
+  const src = mwe.sources.find(
+    (entry) =>
+      entry &&
+      entry.name === "mwe-materialization" &&
+      entry.evidence &&
+      typeof entry.evidence.head_token_id === "string"
+  );
+  return src ? src.evidence.head_token_id : null;
+}
+
+function getMweLexiconEvidence(mwe) {
+  if (!Array.isArray(mwe && mwe.sources)) return null;
+  const src = mwe.sources.find(
+    (entry) =>
+      entry &&
+      entry.name === "wikipedia-title-index" &&
+      entry.evidence &&
+      typeof entry.evidence === "object"
+  );
+  if (!src) return null;
+  return deepCloneJson(src.evidence);
+}
+
+module.exports = {
+  getMweHeadEvidence,
+  getMweLexiconEvidence,
+};

package/src/core/mentions.js

@@ -0,0 +1,149 @@
+const { findSelector, normalizeSpanKey, normalizeIds, deepCloneJson } = require('./determinism');
+const { annotationHasSource, collectStep11Relations } = require('./upstream');
+const { buildTokenIndex, getTokenWikipediaEvidence, buildTokenWikiById, getTokenMetadataProjection } = require('./tokens');
+const { getMweHeadEvidence, getMweLexiconEvidence } = require('./mention-materialization');
+const { toAnnotationSummary, buildAcceptedAnnotationsInventory } = require('./accepted-annotations');
+const { buildChunkHeadMaps, buildDependencyObservationMaps, posFallbackHead, resolveMentionHead } = require('./mention-head-resolution');
+const { buildMentionLexiconEvidence, buildAssertionWikiSignals } = require('./mention-evidence');
+const { mentionSortKey, buildMentions } = require('./mention-builder');
+
+function normalizeWikiSurface(surface) {
+  if (typeof surface !== 'string') return '';
+  return surface
+    .normalize('NFKC')
+    .replace(/[\u2018\u2019\u02bc]/g, "'")
+    .replace(/[\u2010-\u2015]/g, '-')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function hasPositiveWikiSignal(evidence) {
+  if (!evidence || typeof evidence !== 'object') return false;
+  if (evidence.wiki_exact_match === true) return true;
+  if (typeof evidence.wiki_prefix_count === 'number' && evidence.wiki_prefix_count > 0) return true;
+  if (
+    typeof evidence.wiki_parenthetical_variant_count === 'number' &&
+    evidence.wiki_parenthetical_variant_count > 0
+  ) {
+    return true;
+  }
+  if (evidence.wiki_hyphen_space_variant_match === true) return true;
+  if (evidence.wiki_apostrophe_variant_match === true) return true;
+  if (evidence.wiki_singular_plural_variant_match === true) return true;
+  if (evidence.wiki_any_signal === true) return true;
+  return false;
+}
+
+const SUBJECT_ROLE_LABELS = new Set([
+  'actor',
+  'agent',
+  'subject',
+  'subj',
+  'nsubj',
+  'nsubjpass',
+  'csubj',
+  'csubjpass',
+  'agent_passive',
+]);
+
+function isSubjectRoleLabel(role) {
+  return SUBJECT_ROLE_LABELS.has(String(role || ''));
+}
+
+function roleToSlot(role) {
+  if (isSubjectRoleLabel(role)) return { slot: 'actor', role: null };
+  if (role === 'theme') return { slot: 'theme', role: null };
+  if (role === 'patient') return { slot: 'theme', role: null };
+  if (role === 'attribute') return { slot: 'attr', role: null };
+  if (role === 'topic') return { slot: 'topic', role: null };
+  if (role === 'location') return { slot: 'location', role: null };
+  if (role === 'recipient') return { slot: 'other', role: 'recipient' };
+  return { slot: 'other', role };
+}
+
+function isCompareLabel(label) {
+  const l = String(label || '');
+  return l === 'compare' || l === 'compare_gt' || l === 'compare_lt';
+}
+
+function isQuantifierLabel(label) {
+  const l = String(label || '');
+  return l === 'quantifier' || l === 'quantifier_scope' || l === 'scope_quantifier';
+}
+
+function mentionHasLexiconEvidence(mention) {
+  return !!(
+    mention &&
+    mention.provenance &&
+    mention.provenance.lexicon_evidence &&
+    typeof mention.provenance.lexicon_evidence === 'object'
+  );
+}
+
+function compareMentionProjectionPriority(a, b) {
+  const aSpanLen = Array.isArray(a && a.token_ids) ? a.token_ids.length : 0;
+  const bSpanLen = Array.isArray(b && b.token_ids) ? b.token_ids.length : 0;
+  if (aSpanLen !== bSpanLen) return bSpanLen - aSpanLen;
+  const aPriority = Number.isFinite(a && a.priority) ? a.priority : Number.MAX_SAFE_INTEGER;
+  const bPriority = Number.isFinite(b && b.priority) ? b.priority : Number.MAX_SAFE_INTEGER;
+  if (aPriority !== bPriority) return aPriority - bPriority;
+  const aLex = mentionHasLexiconEvidence(a) ? 0 : 1;
+  const bLex = mentionHasLexiconEvidence(b) ? 0 : 1;
+  if (aLex !== bLex) return aLex - bLex;
+  return String(a && a.id ? a.id : '').localeCompare(String(b && b.id ? b.id : ''));
+}
+
+function chooseBestMentionForToken({ tokenId, segmentId, mentionById, candidateMentionIds, excludeMentionId }) {
+  const sourceIds = (candidateMentionIds || [])
+    .filter((id) => typeof id === 'string')
+    .slice();
+  const filteredIds = sourceIds.filter((id) => {
+    if (excludeMentionId && id === excludeMentionId) return false;
+    const mention = mentionById.get(id);
+    if (!mention || mention.segment_id !== segmentId) return false;
+    if (mention.suppressed === true) return false;
+    return Array.isArray(mention.token_ids) && mention.token_ids.includes(tokenId);
+  });
+  if (filteredIds.length === 0) {
+    return { mention_id: null, candidate_count: 0, chosen_was_first: true };
+  }
+  const chosenSorted = filteredIds.slice().sort((a, b) => {
+    const ma = mentionById.get(a);
+    const mb = mentionById.get(b);
+    return compareMentionProjectionPriority(ma, mb);
+  });
+  const chosenId = chosenSorted[0];
+  return {
+    mention_id: chosenId,
+    candidate_count: filteredIds.length,
+    chosen_was_first: sourceIds.length > 0 ? sourceIds[0] === chosenId : true,
+  };
+}
+
+module.exports = {
+  normalizeWikiSurface,
+  hasPositiveWikiSignal,
+  mentionSortKey,
+  SUBJECT_ROLE_LABELS,
+  isSubjectRoleLabel,
+  roleToSlot,
+  isCompareLabel,
+  isQuantifierLabel,
+  mentionHasLexiconEvidence,
+  compareMentionProjectionPriority,
+  chooseBestMentionForToken,
+  getMweHeadEvidence,
+  getMweLexiconEvidence,
+  toAnnotationSummary,
+  buildAcceptedAnnotationsInventory,
+  buildMentionLexiconEvidence,
+  buildAssertionWikiSignals,
+  buildChunkHeadMaps,
+  buildDependencyObservationMaps,
+  posFallbackHead,
+  resolveMentionHead,
+  buildMentions,
+};
+
+