@fortemi/core 2026.6.9 → 2026.7.1

package/dist/aiwg-index.js

@@ -15,8 +15,6 @@ var REQUIRED_RECORD_FIELDS = [
   "id",
   "type",
   "source",
-  "title",
-  "text",
   "facets",
   "tags",
   "concepts",
@@ -25,19 +23,14 @@ var REQUIRED_RECORD_FIELDS = [
   "privacy",
   "updated_at"
 ];
-var VALID_TYPES = /* @__PURE__ */ new Set([
-  "crm.contact",
-  "crm.organization",
-  "crm.event",
-  "crm.interaction",
-  "aiwg.artifact",
-  "docs.page"
-]);
 var DEFAULT_QUERY_WEIGHTS = {
   title: 4,
   tag: 3,
   concept: 2,
-  text: 1
+  text: 1,
+  facet: 2,
+  id: 1,
+  source: 0.25
 };
 function hasString(value) {
   return typeof value === "string" && value.length > 0;
@@ -62,6 +55,12 @@ function isPlainRecord(value) {
 function isOptionalStringArray(value) {
   return value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
 }
+function isSupportedIndexSchemaVersion(value) {
+  return value === "aiwg.fortemi.index.export.v1" || value === "aiwg.fortemi.index.export.v2";
+}
+function isSupportedRecordSchemaVersion(value) {
+  return value === "aiwg.fortemi.index.record.v1" || value === "aiwg.fortemi.index.record.v2";
+}
 function validateOptionalRichMetadata(item, index, errors) {
   if (item.skos_concepts !== void 0) {
     if (!Array.isArray(item.skos_concepts)) {
@@ -108,28 +107,80 @@ function validateOptionalRichMetadata(item, index, errors) {
       if (relationship.metadata !== void 0 && !isPlainRecord(relationship.metadata)) {
         errors.push("items[" + index + "].relationships[" + relationshipIndex + "].metadata must be an object");
       }
+      if (relationship.direction !== void 0 && relationship.direction !== "upstream" && relationship.direction !== "downstream" && relationship.direction !== "related") {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].direction must be upstream, downstream, or related");
+      }
+      if (relationship.target_path !== void 0 && typeof relationship.target_path !== "string") {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].target_path must be a string");
+      }
+    }
+  }
+  if (item.search !== void 0) {
+    if (!isPlainRecord(item.search)) {
+      errors.push("items[" + index + "].search must be an object");
+    } else {
+      if (!isOptionalStringArray(item.search.triggers)) errors.push("items[" + index + "].search.triggers must be a string array");
+      if (!isOptionalStringArray(item.search.aliases)) errors.push("items[" + index + "].search.aliases must be a string array");
+      if (!isOptionalStringArray(item.search.tags)) errors.push("items[" + index + "].search.tags must be a string array");
+      if (item.search.frontmatter !== void 0 && !isPlainRecord(item.search.frontmatter)) {
+        errors.push("items[" + index + "].search.frontmatter must be an object");
+      }
+    }
+  }
+  if (item.chunks !== void 0) {
+    if (!Array.isArray(item.chunks)) {
+      errors.push("items[" + index + "].chunks must be an array when present");
+    } else {
+      for (const [chunkIndex, chunk] of item.chunks.entries()) {
+        if (!isPlainRecord(chunk)) errors.push("items[" + index + "].chunks[" + chunkIndex + "] must be an object");
+        if (chunk.metadata !== void 0 && !isPlainRecord(chunk.metadata)) {
+          errors.push("items[" + index + "].chunks[" + chunkIndex + "].metadata must be an object");
+        }
+      }
     }
   }
+  if (item.embeddings !== void 0) {
+    if (!Array.isArray(item.embeddings)) {
+      errors.push("items[" + index + "].embeddings must be an array when present");
+    } else {
+      for (const [embeddingIndex, embedding] of item.embeddings.entries()) {
+        if (!isPlainRecord(embedding)) errors.push("items[" + index + "].embeddings[" + embeddingIndex + "] must be an object");
+        const vector = embedding.embedding ?? embedding.vector;
+        if (vector !== void 0 && (!Array.isArray(vector) || !vector.every((entry) => typeof entry === "number"))) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].embedding/vector must be a number array");
+        }
+        if (embedding.metadata !== void 0 && !isPlainRecord(embedding.metadata)) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].metadata must be an object");
+        }
+      }
+    }
+  }
+  if (item.compatibility !== void 0 && !isPlainRecord(item.compatibility)) {
+    errors.push("items[" + index + "].compatibility must be an object");
+  }
 }
 function validateAiwgFortemiIndexExport(value) {
   const errors = [];
   const counts = {};
   const data = value;
-  if (data?.schema_version !== "aiwg.fortemi.index.export.v1") {
-    errors.push("schema_version must be aiwg.fortemi.index.export.v1");
+  if (!isSupportedIndexSchemaVersion(data?.schema_version)) {
+    errors.push("schema_version must be aiwg.fortemi.index.export.v1 or aiwg.fortemi.index.export.v2");
   }
   if (!hasString(data?.generated_at)) errors.push("generated_at is required");
   if (!hasString(data?.source?.repo)) errors.push("source.repo is required");
   if (!hasString(data?.source?.privacy)) errors.push("source.privacy is required");
   if (!Array.isArray(data?.items)) errors.push("items must be an array");
+  if (data.compatibility !== void 0 && !isPlainRecord(data.compatibility)) {
+    errors.push("compatibility must be an object");
+  }
   const ids = /* @__PURE__ */ new Set();
   let previousId = "";
   for (const [index, item] of (data.items ?? []).entries()) {
     for (const field of REQUIRED_RECORD_FIELDS) {
       if (!(field in item)) errors.push("items[" + index + "]." + field + " is required");
     }
-    if (item.schema_version !== "aiwg.fortemi.index.record.v1") {
-      errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1");
+    if (!isSupportedRecordSchemaVersion(item.schema_version)) {
+      errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1 or aiwg.fortemi.index.record.v2");
     }
     if (!hasString(item.id)) errors.push("items[" + index + "].id is required");
     if (hasString(item.id) && ids.has(item.id)) errors.push("duplicate id: " + item.id);
@@ -138,11 +189,17 @@ function validateAiwgFortemiIndexExport(value) {
       errors.push("items must be sorted by id: " + previousId + " before " + item.id);
     }
     if (hasString(item.id)) previousId = item.id;
-    if (!VALID_TYPES.has(item.type)) errors.push("items[" + index + "].type is invalid");
+    if (!hasString(item.type)) errors.push("items[" + index + "].type must be a non-empty string");
     else counts[item.type] = (counts[item.type] ?? 0) + 1;
     if (!hasString(item.source?.path)) errors.push("items[" + index + "].source.path is required");
     if (!hasString(item.source?.repo_relative_path)) errors.push("items[" + index + "].source.repo_relative_path is required");
     if (!hasString(item.source?.locator)) errors.push("items[" + index + "].source.locator is required");
+    if (typeof item.title !== "string" && typeof item.search?.title !== "string" && typeof item.search?.name !== "string") {
+      errors.push("items[" + index + "].title or search.title/search.name is required");
+    }
+    if (typeof item.text !== "string" && typeof item.search?.body !== "string" && typeof item.search?.summary !== "string") {
+      errors.push("items[" + index + "].text or search.body/search.summary is required");
+    }
     if (!Array.isArray(item.tags)) errors.push("items[" + index + "].tags must be an array");
     if (!Array.isArray(item.concepts)) errors.push("items[" + index + "].concepts must be an array");
     if (!Array.isArray(item.relationships)) errors.push("items[" + index + "].relationships must be an array");
@@ -223,8 +280,8 @@ function validateProjectedRecords(items) {
   const ids = /* @__PURE__ */ new Set();
   let previousId = "";
   for (const [index, item] of items.entries()) {
-    if (item.schema_version !== "aiwg.fortemi.index.record.v1") {
-      errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1");
+    if (!isSupportedRecordSchemaVersion(item.schema_version)) {
+      errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1 or aiwg.fortemi.index.record.v2");
     }
     if (!hasString(item.id)) errors.push("items[" + index + "].id is required");
     if (hasString(item.id) && ids.has(item.id)) errors.push("duplicate id: " + item.id);
@@ -233,9 +290,13 @@ function validateProjectedRecords(items) {
       errors.push("items must be sorted by id: " + previousId + " before " + item.id);
     }
     if (hasString(item.id)) previousId = item.id;
-    if (!item.type || !VALID_TYPES.has(item.type)) errors.push("items[" + index + "].type is invalid");
-    if (!hasString(item.title)) errors.push("items[" + index + "].title is required");
-    if (typeof item.text !== "string") errors.push("items[" + index + "].text is required");
+    if (!hasString(item.type)) errors.push("items[" + index + "].type must be a non-empty string");
+    if (typeof item.title !== "string" && typeof item.search?.title !== "string" && typeof item.search?.name !== "string") {
+      errors.push("items[" + index + "].title or search.title/search.name is required");
+    }
+    if (typeof item.text !== "string" && typeof item.search?.body !== "string" && typeof item.search?.summary !== "string") {
+      errors.push("items[" + index + "].text or search.body/search.summary is required");
+    }
     if (!item.facets || typeof item.facets !== "object" || Array.isArray(item.facets)) {
       errors.push("items[" + index + "].facets must be an object");
     }
@@ -327,6 +388,38 @@ function getAiwgFortemiFacets(items) {
   }
   return result;
 }
+function recordTitle(item) {
+  return item.title ?? item.search?.title ?? item.search?.name ?? item.id;
+}
+function recordText(item) {
+  return item.text ?? item.search?.body ?? item.search?.summary ?? item.chunks?.map((chunk) => chunk.text ?? chunk.body ?? chunk.summary ?? "").filter(Boolean).join("\n") ?? "";
+}
+function recordSearchValues(item) {
+  const search = item.search;
+  const values = [
+    item.id,
+    recordTitle(item),
+    recordText(item),
+    search?.title,
+    search?.name,
+    search?.summary,
+    search?.body,
+    search?.capability,
+    search?.phase,
+    search?.type,
+    ...search?.triggers ?? [],
+    ...search?.aliases ?? [],
+    ...search?.tags ?? [],
+    ...(item.chunks ?? []).flatMap((chunk) => [chunk.text, chunk.body, chunk.summary, chunk.source_path])
+  ];
+  if (search?.frontmatter) {
+    for (const value of Object.values(search.frontmatter)) {
+      if (typeof value === "string") values.push(value);
+      else if (Array.isArray(value)) values.push(...value.filter((entry) => typeof entry === "string"));
+    }
+  }
+  return values.filter((value) => typeof value === "string" && value.length > 0);
+}
 function buildAiwgChunkedIndex(index, options = {}) {
   const partSize = hasPositiveInteger(options.partSize) ? options.partSize : 500;
   const projection = options.projection;
@@ -388,18 +481,129 @@ function matchesFacetFilters(item, filters) {
 function queryMatches(item, q) {
   if (!q) return [];
   const matches = [];
-  if (item.title.toLowerCase().includes(q)) matches.push({ field: "title", value: item.title });
-  if (item.text.toLowerCase().includes(q)) matches.push({ field: "text", value: item.text });
+  const title = recordTitle(item);
+  const text = recordText(item);
+  if (title.toLowerCase().includes(q)) matches.push({ field: "title", value: title });
+  if (text.toLowerCase().includes(q)) matches.push({ field: "text", value: text });
   for (const tag of item.tags) {
     if (tag.toLowerCase().includes(q)) matches.push({ field: "tag", value: tag });
   }
   for (const concept of item.concepts) {
     if (concept.toLowerCase().includes(q)) matches.push({ field: "concept", value: concept });
   }
+  for (const value of recordSearchValues(item)) {
+    if (value !== title && value !== text && value.toLowerCase().includes(q)) {
+      matches.push({ field: "text", value, score: DEFAULT_QUERY_WEIGHTS.text });
+    }
+  }
+  return matches;
+}
+var DISCOVERY_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "for",
+  "from",
+  "how",
+  "i",
+  "in",
+  "is",
+  "me",
+  "of",
+  "on",
+  "or",
+  "please",
+  "the",
+  "to",
+  "use",
+  "with"
+]);
+function normalizeDiscoveryText(value) {
+  return value.toLowerCase().replace(/[_/]+/g, " ").replace(/[^a-z0-9.-]+/g, " ").trim();
+}
+function canonicalDiscoveryName(value) {
+  return normalizeDiscoveryText(value).replace(/[\s.-]+/g, "");
+}
+function discoveryTokens(value) {
+  return normalizeDiscoveryText(value).split(/\s+/).filter((token) => token.length > 1 && !DISCOVERY_STOPWORDS.has(token));
+}
+function facetValues(item, names) {
+  return names.flatMap((name) => item.facets[name] ?? []);
+}
+function addDiscoveryMatch(matches, match) {
+  if (!matches.some((existing) => existing.field === match.field && existing.value === match.value && existing.reason === match.reason)) {
+    matches.push(match);
+  }
+}
+function tokenOverlapScore(tokens, value) {
+  if (tokens.length === 0 || !value) return 0;
+  const normalized = normalizeDiscoveryText(value);
+  const hits = tokens.filter((token) => normalized.includes(token)).length;
+  return hits / tokens.length;
+}
+function discoveryMatches(item, query) {
+  if (!query) return [];
+  const matches = [];
+  const tokens = discoveryTokens(query);
+  const canonicalQuery = canonicalDiscoveryName(query);
+  const idParts = item.id.split(/[:/]/);
+  const names = [
+    item.id,
+    recordTitle(item),
+    item.search?.name,
+    item.search?.title,
+    ...item.search?.aliases ?? [],
+    ...idParts,
+    ...facetValues(item, ["name", "canonical_name", "command", "skill", "agent", "rule"])
+  ].filter((value) => hasString(value));
+  const triggers = [
+    ...facetValues(item, ["trigger", "triggers", "trigger_phrase", "trigger_phrases"]),
+    ...item.search?.triggers ?? []
+  ];
+  const capabilities = [
+    ...facetValues(item, ["capability", "capabilities", "summary", "description"]),
+    item.search?.capability,
+    item.search?.summary,
+    item.search?.phase,
+    item.search?.type,
+    ...item.search?.tags ?? [],
+    ...item.concepts,
+    ...item.tags
+  ].filter((value) => hasString(value));
+  const sourceValues = [item.source?.path, item.source?.repo_relative_path, item.source?.locator].filter((value) => hasString(value));
+  for (const name of names) {
+    const canonicalName = canonicalDiscoveryName(name);
+    if (!canonicalName) continue;
+    if (canonicalName === canonicalQuery) {
+      addDiscoveryMatch(matches, { field: "id", value: name, score: 80, reason: "exact canonical name" });
+    } else if (canonicalName.includes(canonicalQuery) || canonicalQuery.includes(canonicalName)) {
+      addDiscoveryMatch(matches, { field: "id", value: name, score: 48, reason: "near canonical name" });
+    }
+  }
+  const title = recordTitle(item);
+  const titleOverlap = tokenOverlapScore(tokens, title);
+  if (titleOverlap > 0) addDiscoveryMatch(matches, { field: "title", value: title, score: 18 * titleOverlap, reason: "title token overlap" });
+  for (const trigger of triggers) {
+    const overlap = tokenOverlapScore(tokens, trigger);
+    if (overlap > 0) addDiscoveryMatch(matches, { field: "facet", value: trigger, score: 34 * overlap, reason: "trigger phrase" });
+  }
+  for (const capability of capabilities) {
+    const overlap = tokenOverlapScore(tokens, capability);
+    if (overlap > 0) addDiscoveryMatch(matches, { field: "concept", value: capability, score: 22 * overlap, reason: "capability overlap" });
+  }
+  const text = recordText(item);
+  const textOverlap = tokenOverlapScore(tokens, text);
+  if (textOverlap > 0) addDiscoveryMatch(matches, { field: "text", value: text, score: 8 * textOverlap, reason: "body token overlap" });
+  for (const source of sourceValues) {
+    const overlap = tokenOverlapScore(tokens, source);
+    if (overlap > 0) addDiscoveryMatch(matches, { field: "source", value: source, score: 2 * overlap, reason: "path overlap" });
+  }
   return matches;
 }
 function rankMatches(matches, weights) {
-  return matches.reduce((total, match) => total + weights[match.field], 0);
+  return matches.reduce((total, match) => total + (match.score ?? weights[match.field]), 0);
 }
 function clipSnippet(value, q, maxLength) {
   const normalizedLength = Math.max(20, maxLength);
@@ -419,11 +623,16 @@ function createSnippet(item, matches, q, maxLength) {
   const textMatch = matches.find((match) => match.field === "text");
   const titleMatch = matches.find((match) => match.field === "title");
   const firstMatch = textMatch ?? titleMatch ?? matches[0];
-  return clipSnippet(firstMatch?.value ?? item.text, q, maxLength);
+  return clipSnippet(firstMatch?.value ?? recordText(item), q, maxLength);
 }
 function createRankedEntries(items, q, options, ordinalBase = 0) {
   const weights = { ...DEFAULT_QUERY_WEIGHTS, ...options.weights };
-  return items.map((item, ordinal) => ({ item, ordinal: ordinalBase + ordinal, matches: queryMatches(item, q) })).filter(({ item, matches }) => {
+  const profile = options.searchProfile ?? "default";
+  return items.map((item, ordinal) => ({
+    item,
+    ordinal: ordinalBase + ordinal,
+    matches: profile === "aiwg-discovery" ? discoveryMatches(item, q) : queryMatches(item, q)
+  })).filter(({ item, matches }) => {
     if (q && matches.length === 0) return false;
     if (options.types && !options.types.includes(item.type)) return false;
     if (options.privacy && !options.privacy.includes(item.privacy.classification)) return false;
@@ -470,7 +679,106 @@ function createQueryResultFromRankedEntries(entries, query, options) {
 }
 function queryAiwgFortemiIndex(index, query = "", options = {}) {
   const q = query.trim().toLowerCase();
-  return createQueryResultFromRankedEntries(createRankedEntries(index.items, q, options), q, options);
+  const entries = createRankedEntries(index.items, q, options);
+  if (entries.length === 0 && q && options.searchProfile === "aiwg-discovery") {
+    const relaxed = discoveryTokens(q).join(" ");
+    return createQueryResultFromRankedEntries(createRankedEntries(index.items, relaxed, options), relaxed, options);
+  }
+  return createQueryResultFromRankedEntries(entries, q, options);
+}
+function cosineSimilarity(left, right) {
+  if (left.length !== right.length || left.length === 0) return 0;
+  let dot = 0;
+  let leftMag = 0;
+  let rightMag = 0;
+  for (let i = 0; i < left.length; i += 1) {
+    const l = left[i];
+    const r = right[i];
+    dot += l * r;
+    leftMag += l * l;
+    rightMag += r * r;
+  }
+  if (leftMag === 0 || rightMag === 0) return 0;
+  return dot / (Math.sqrt(leftMag) * Math.sqrt(rightMag));
+}
+function validateAiwgStaticEmbeddingSet(value) {
+  const errors = [];
+  const data = value;
+  if (data?.schema_version !== "aiwg.fortemi.embedding.set.v1") errors.push("schema_version must be aiwg.fortemi.embedding.set.v1");
+  if (!hasString(data?.id)) errors.push("id is required");
+  if (!hasString(data?.model)) errors.push("model is required");
+  if (!hasPositiveInteger(data?.dimensions)) errors.push("dimensions must be a positive integer");
+  if (!hasString(data?.generated_at)) errors.push("generated_at is required");
+  if (!hasString(data?.granularity)) errors.push("granularity is required");
+  if (!Array.isArray(data?.embeddings)) errors.push("embeddings must be an array");
+  for (const [index, embedding] of (data.embeddings ?? []).entries()) {
+    if (!hasString(embedding.record_id)) errors.push("embeddings[" + index + "].record_id is required");
+    if (!hasString(embedding.input_hash)) errors.push("embeddings[" + index + "].input_hash is required");
+    if (!Array.isArray(embedding.embedding)) errors.push("embeddings[" + index + "].embedding must be an array");
+    else if (hasPositiveInteger(data?.dimensions) && embedding.embedding.length !== data.dimensions) {
+      errors.push("embeddings[" + index + "].embedding length must match dimensions");
+    } else if (!embedding.embedding.every((number) => typeof number === "number" && Number.isFinite(number))) {
+      errors.push("embeddings[" + index + "].embedding must contain finite numbers");
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function assertAiwgStaticEmbeddingSet(value) {
+  const result = validateAiwgStaticEmbeddingSet(value);
+  if (!result.valid) throw new Error("Invalid AIWG Fortemi embedding set:\n" + result.errors.join("\n"));
+  return value;
+}
+function queryAiwgSemanticIndex(index, embeddingSet, queryEmbedding, options = {}) {
+  assertAiwgStaticEmbeddingSet(embeddingSet);
+  if (queryEmbedding.length !== embeddingSet.dimensions) throw new Error("query embedding length must match embedding set dimensions");
+  const byId = new Map(index.items.map((item) => [item.id, item]));
+  const offset = options.offset ?? 0;
+  const limit = options.limit ?? 20;
+  return embeddingSet.embeddings.map((embedding) => {
+    const item = byId.get(embedding.record_id);
+    if (!item) return null;
+    return { item, embedding, score: cosineSimilarity(queryEmbedding, embedding.embedding) };
+  }).filter((result) => result !== null && result.score >= (options.minScore ?? -1)).sort((left, right) => right.score - left.score || left.item.id.localeCompare(right.item.id)).slice(offset, offset + limit);
+}
+function queryAiwgHybridIndex(index, embeddingSet, query, queryEmbedding, options = {}) {
+  const lexical = queryAiwgFortemiIndex(index, query, { ...options, rank: true });
+  const semantic = queryAiwgSemanticIndex(index, embeddingSet, queryEmbedding, { limit: index.items.length });
+  const lexicalWeight = options.lexicalWeight ?? 0.5;
+  const semanticWeight = options.semanticWeight ?? 0.5;
+  const lexicalScores = new Map(lexical.rankedItems?.map((entry) => [entry.item.id, entry.rank]) ?? []);
+  const maxLexical = Math.max(1, ...lexicalScores.values());
+  const embeddingById = new Map(semantic.flatMap((entry) => entry.embedding ? [[entry.item.id, entry.embedding]] : []));
+  const semanticScores = new Map(semantic.map((entry) => [entry.item.id, entry.score]));
+  const ids = /* @__PURE__ */ new Set([...lexicalScores.keys(), ...semanticScores.keys()]);
+  const offset = options.offset ?? 0;
+  const limit = options.limit ?? 20;
+  return [...ids].map((id) => {
+    const item = index.items.find((candidate) => candidate.id === id);
+    const embedding = embeddingById.get(id);
+    if (!item) return null;
+    return {
+      item,
+      ...embedding ? { embedding } : {},
+      score: (lexicalScores.get(id) ?? 0) / maxLexical * lexicalWeight + (semanticScores.get(id) ?? 0) * semanticWeight
+    };
+  }).filter((result) => result !== null && result.score >= (options.minScore ?? -1)).sort((left, right) => right.score - left.score || left.item.id.localeCompare(right.item.id)).slice(offset, offset + limit);
+}
+function findAiwgStaticDuplicatePairs(index, embeddingSet, threshold = 0.9) {
+  assertAiwgStaticEmbeddingSet(embeddingSet);
+  const byId = new Map(index.items.map((item) => [item.id, item]));
+  const pairs = [];
+  for (let leftIndex = 0; leftIndex < embeddingSet.embeddings.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < embeddingSet.embeddings.length; rightIndex += 1) {
+      const leftEmbedding = embeddingSet.embeddings[leftIndex];
+      const rightEmbedding = embeddingSet.embeddings[rightIndex];
+      const left = byId.get(leftEmbedding.record_id);
+      const right = byId.get(rightEmbedding.record_id);
+      if (!left || !right) continue;
+      const score = cosineSimilarity(leftEmbedding.embedding, rightEmbedding.embedding);
+      if (score >= threshold) pairs.push({ left, right, score });
+    }
+  }
+  return pairs.sort((left, right) => right.score - left.score || left.left.id.localeCompare(right.left.id));
 }
 function chunkPartCacheKey(part) {
   return `${part.offset}:${part.href}`;
@@ -569,6 +877,107 @@ async function getChunkRecord(runtime, id) {
   }
   return record;
 }
+function relationshipTypeFilter(options) {
+  return options?.relationshipType ?? options?.type;
+}
+function edgeFromRelationship(sourceId, relationship) {
+  return {
+    source_id: sourceId,
+    target_id: relationship.target_id,
+    type: relationship.type,
+    ...relationship.source_path ? { source_path: relationship.source_path } : {},
+    ...relationship.target_path ? { target_path: relationship.target_path } : {},
+    ...relationship.direction ? { direction: relationship.direction } : {}
+  };
+}
+function relationshipMatches(edge, options = {}) {
+  const type = relationshipTypeFilter(options);
+  const direction = options.direction ?? "both";
+  if (type && edge.type !== type) return false;
+  if (options.relationshipDirection && edge.direction !== options.relationshipDirection) return false;
+  if (options.sourceId && edge.source_id !== options.sourceId) return false;
+  if (options.targetId && edge.target_id !== options.targetId) return false;
+  if (direction === "out" && options.targetId && edge.target_id !== options.targetId) return false;
+  if (direction === "in" && options.sourceId && edge.source_id !== options.sourceId) return false;
+  return true;
+}
+function nodeSummary(item) {
+  return { id: item.id, type: item.type, title: recordTitle(item) };
+}
+function addNode(nodes, item) {
+  if (item) nodes.set(item.id, nodeSummary(item));
+}
+function relationshipResultFromRecords(records, options = {}) {
+  const byId = new Map(records.map((record) => [record.id, record]));
+  const edges = [];
+  for (const record of records) {
+    for (const relationship of record.relationships ?? []) {
+      const edge = edgeFromRelationship(record.id, relationship);
+      if (!relationshipMatches(edge, options)) continue;
+      edges.push(edge);
+    }
+  }
+  const limitedEdges = (options.limit ? edges.slice(0, options.limit) : edges).sort((left, right) => left.source_id.localeCompare(right.source_id) || left.target_id.localeCompare(right.target_id) || left.type.localeCompare(right.type));
+  const nodes = /* @__PURE__ */ new Map();
+  for (const edge of limitedEdges) {
+    addNode(nodes, byId.get(edge.source_id));
+    addNode(nodes, byId.get(edge.target_id));
+  }
+  return {
+    nodes: [...nodes.values()].sort((left, right) => left.id.localeCompare(right.id)),
+    edges: limitedEdges,
+    complete: true
+  };
+}
+function neighborQueryOptions(id, options = {}) {
+  const direction = options.direction ?? "both";
+  return {
+    ...options,
+    ...direction === "out" ? { sourceId: id } : {},
+    ...direction === "in" ? { targetId: id } : {}
+  };
+}
+function filterNeighborResult(id, result, options = {}) {
+  const direction = options.direction ?? "both";
+  const edges = result.edges.filter((edge) => {
+    if (direction === "out") return edge.source_id === id;
+    if (direction === "in") return edge.target_id === id;
+    return edge.source_id === id || edge.target_id === id;
+  });
+  const ids = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    ids.add(edge.source_id);
+    ids.add(edge.target_id);
+  }
+  return {
+    ...result,
+    edges,
+    nodes: result.nodes.filter((node) => ids.has(node.id))
+  };
+}
+async function recordsFromChunkedRuntime(runtime, onProgress) {
+  let scannedParts = 0;
+  let fetchedParts = 0;
+  const records = [];
+  for (const partRef of runtime.manifest.parts) {
+    const loaded = await loadChunkPart(runtime, partRef);
+    if (loaded.fetched) fetchedParts += 1;
+    scannedParts += 1;
+    onProgress?.({ phase: "part", done: scannedParts, total: runtime.manifest.parts.length, href: partRef.href });
+    for (const item of loaded.part.items) {
+      records.push(item.relationships ? item : await getChunkRecord(runtime, item.id));
+    }
+  }
+  return { records, scannedParts, fetchedParts };
+}
+async function relationshipResultFromChunkedRuntime(runtime, options = {}) {
+  const loaded = await recordsFromChunkedRuntime(runtime);
+  return {
+    ...relationshipResultFromRecords(loaded.records, options),
+    scannedParts: loaded.scannedParts,
+    fetchedParts: loaded.fetchedParts
+  };
+}
 async function queryChunkedAiwgFortemiIndex(runtime, query = "", options = {}) {
   const q = query.trim().toLowerCase();
   let scannedParts = 0;
@@ -749,6 +1158,39 @@ function createAiwgIndexController(initialIndex) {
       if (!found) throw new Error("Record not found: " + id);
       return found;
     },
+    async neighbors(id, options) {
+      try {
+        const queryOptions = neighborQueryOptions(id, options);
+        const result = chunked ? await relationshipResultFromChunkedRuntime(chunked, queryOptions) : relationshipResultFromRecords(requireIndex().items, queryOptions);
+        return filterNeighborResult(id, result, options);
+      } catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+        notify();
+        throw error;
+      }
+    },
+    async relationshipQuery(options) {
+      try {
+        return chunked ? await relationshipResultFromChunkedRuntime(chunked, options) : relationshipResultFromRecords(requireIndex().items, options);
+      } catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+        notify();
+        throw error;
+      }
+    },
+    async relationshipSet(options) {
+      const [left, right] = await Promise.all([
+        this.neighbors(options.a, options),
+        this.neighbors(options.b, options)
+      ]);
+      const leftIds = new Set(left.nodes.map((node) => node.id).filter((id) => id !== options.a));
+      const rightIds = new Set(right.nodes.map((node) => node.id).filter((id) => id !== options.b));
+      let ids;
+      if (options.op === "intersection") ids = [...leftIds].filter((id) => rightIds.has(id));
+      else if (options.op === "difference") ids = [...leftIds].filter((id) => !rightIds.has(id));
+      else ids = [.../* @__PURE__ */ new Set([...leftIds, ...rightIds])];
+      return { op: options.op, ids: ids.sort() };
+    },
     clearChunkCache() {
       chunked?.partCache.clear();
       chunked?.detailCache.clear();
@@ -759,6 +1201,15 @@ function createAiwgIndexController(initialIndex) {
     toCommunityGraph(options) {
       return aiwgFortemiIndexToCommunityGraph(requireIndex(), options);
     },
+    async toCommunityGraphChunked(options) {
+      if (!chunked) return aiwgFortemiIndexToCommunityGraph(requireIndex(), options);
+      const loaded = await recordsFromChunkedRuntime(chunked, options?.onProgress);
+      return aiwgFortemiIndexToCommunityGraph({
+        generated_at: chunked.manifest.generated_at,
+        source: chunked.manifest.source,
+        items: loaded.records
+      }, options);
+    },
     setReviewDecision(input) {
       const decision = {
         ...input,
@@ -834,6 +1285,6 @@ function communityIdsFor(item, options) {
   return [`type:${item.type}`];
 }
 
-export { AIWG_SCAN_REQUIRED_FIELDS, aiwgDetailHrefForId, aiwgFortemiIndexToCommunityGraph, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, buildAiwgChunkedIndex, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, encodeAiwgDetailId, getAiwgFortemiFacets, queryAiwgFortemiIndex, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport };
+export { AIWG_SCAN_REQUIRED_FIELDS, aiwgDetailHrefForId, aiwgFortemiIndexToCommunityGraph, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, assertAiwgStaticEmbeddingSet, buildAiwgChunkedIndex, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, encodeAiwgDetailId, findAiwgStaticDuplicatePairs, getAiwgFortemiFacets, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgStaticEmbeddingSet };
 //# sourceMappingURL=aiwg-index.js.map
 //# sourceMappingURL=aiwg-index.js.map