@agentxm/knowledge-query 0.28.4-bootstrap.0

package/dist/src/knowledge-index.js

@@ -0,0 +1,373 @@
+import * as Effect from "effect/Effect";
+import * as Data from "effect/Data";
+import * as Result from "effect/Result";
+import * as ServiceMap from "effect/Context";
+import { createHash } from "node:crypto";
+import {} from "@agentxm/extension-model/unstable/knowledge/concept-ref";
+import { resolveKnowledgeFrontmatterPointer } from "./knowledge-projection.js";
+import { projectKnowledgeConcepts, } from "./knowledge-projection.js";
+import { knowledgeQueryIdentity, } from "./knowledge-query.js";
+import { computeKnowledgeCorpusFingerprint, computeKnowledgeProjectionRevision, } from "./knowledge-revision.js";
+import { tokenizeKnowledgeSearchText } from "@agentxm/registry-protocol/unstable/knowledge/knowledge-search";
+export class KnowledgeCursorInvalidError extends Data.TaggedError("KnowledgeCursorInvalidError") {
+}
+const CURSOR_VERSION = "axm-knowledge-cursor-v1";
+const CURSOR_MAX_AGE_MS = 86_400_000;
+const queryDigest = (query) => createHash("sha256")
+    .update(JSON.stringify(knowledgeQueryIdentity(query)))
+    .digest("hex");
+const encodeCursor = (payload) => Buffer.from(JSON.stringify(payload)).toString("base64url");
+const isCursorPayload = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    return ("version" in value &&
+        value.version === CURSOR_VERSION &&
+        "corpusFingerprint" in value &&
+        typeof value.corpusFingerprint === "string" &&
+        "queryDigest" in value &&
+        typeof value.queryDigest === "string" &&
+        "offset" in value &&
+        typeof value.offset === "number" &&
+        Number.isSafeInteger(value.offset) &&
+        value.offset >= 0 &&
+        "issuedAt" in value &&
+        typeof value.issuedAt === "number" &&
+        Number.isSafeInteger(value.issuedAt));
+};
+const decodeCursor = (cursor, snapshot, query, now) => {
+    let decoded;
+    try {
+        if (!/^[A-Za-z0-9_-]+$/u.test(cursor)) {
+            return Result.fail(new KnowledgeCursorInvalidError({ reason: "invalid" }));
+        }
+        decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    }
+    catch {
+        return Result.fail(new KnowledgeCursorInvalidError({ reason: "invalid" }));
+    }
+    if (!isCursorPayload(decoded)) {
+        return Result.fail(new KnowledgeCursorInvalidError({ reason: "invalid" }));
+    }
+    if (decoded.issuedAt > now || now - decoded.issuedAt > CURSOR_MAX_AGE_MS) {
+        return Result.fail(new KnowledgeCursorInvalidError({ reason: "expired" }));
+    }
+    if (decoded.corpusFingerprint !== snapshot.fingerprint) {
+        return Result.fail(new KnowledgeCursorInvalidError({ reason: "corpus-changed" }));
+    }
+    if (decoded.queryDigest !== queryDigest(query)) {
+        return Result.fail(new KnowledgeCursorInvalidError({ reason: "query-changed" }));
+    }
+    return Result.succeed(decoded);
+};
+const sourceForConcept = (bundle, concept) => bundle.sources.find((source) => source.relativePath === concept.relativePath);
+export const makeKnowledgeIndexSnapshot = (bundles) => {
+    const sources = bundles.flatMap(({ sources }) => sources);
+    const concepts = [];
+    for (const bundle of [...bundles].sort((left, right) => left.bundle.localeCompare(right.bundle))) {
+        const bundleFingerprint = computeKnowledgeCorpusFingerprint(bundle.sources);
+        const projected = projectKnowledgeConcepts(bundle.bundle, bundle.inspection.concepts);
+        for (const [index, source] of bundle.inspection.concepts.entries()) {
+            const projection = projected[index];
+            const captured = sourceForConcept(bundle, source);
+            if (projection === undefined || captured === undefined)
+                continue;
+            concepts.push({
+                ref: {
+                    bundle: bundle.bundle,
+                    conceptId: source.id,
+                    bundleVersion: bundle.version,
+                    bundleFingerprint,
+                    contentRevision: captured.sourceRevision,
+                },
+                projectionRevision: computeKnowledgeProjectionRevision(projection),
+                projected: projection,
+                source,
+                sourceBytes: captured.bytes,
+            });
+        }
+    }
+    return {
+        fingerprint: computeKnowledgeCorpusFingerprint(sources),
+        concepts: concepts.sort((left, right) => left.ref.bundle.localeCompare(right.ref.bundle) ||
+            left.ref.conceptId.localeCompare(right.ref.conceptId)),
+    };
+};
+const normalizedLiteral = (value) => value.normalize("NFKC").toUpperCase().toLowerCase();
+const containsPhrase = (fieldTokens, phraseTokens) => {
+    if (phraseTokens.length > fieldTokens.length)
+        return false;
+    for (let start = 0; start <= fieldTokens.length - phraseTokens.length; start += 1) {
+        if (phraseTokens.every((token, offset) => fieldTokens[start + offset] === token))
+            return true;
+    }
+    return false;
+};
+const textMatches = (text, clause) => {
+    switch (clause.kind) {
+        case "term":
+            return tokenizeKnowledgeSearchText(text).includes(tokenizeKnowledgeSearchText(clause.value)[0] ?? "");
+        case "phrase":
+            return containsPhrase(tokenizeKnowledgeSearchText(text), tokenizeKnowledgeSearchText(clause.value));
+        case "literal":
+            return normalizedLiteral(text).includes(normalizedLiteral(clause.value));
+        default:
+            return clause;
+    }
+};
+const valueMatches = (candidate, operator, expected) => {
+    const left = normalizedLiteral(candidate);
+    const right = normalizedLiteral(expected);
+    if (operator === "equals")
+        return left === right;
+    if (operator === "not-equals")
+        return left !== right;
+    return left.includes(right);
+};
+const stringValues = (value) => {
+    if (typeof value === "string")
+        return [value];
+    if (typeof value === "number" || typeof value === "boolean")
+        return [String(value)];
+    if (Array.isArray(value))
+        return value.flatMap(stringValues);
+    return [];
+};
+const metadataValues = (concept, field) => {
+    switch (field) {
+        case "bundle":
+            return [concept.bundle];
+        case "conceptId":
+            return [concept.conceptId];
+        case "kind":
+            return [concept.kind];
+        case "title":
+            return concept.title === undefined ? [] : [concept.title];
+        case "description":
+            return concept.description === undefined ? [] : [concept.description];
+        case "tag":
+            return concept.tags ?? [];
+        case "type":
+            return concept.type === undefined ? [] : [concept.type];
+        case "resource":
+            return concept.resource === undefined ? [] : [concept.resource];
+        default:
+            return field;
+    }
+};
+const lifecycleValues = (concept, field) => {
+    switch (field) {
+        case "status":
+            return concept.status === undefined ? [] : [concept.status];
+        case "staleAfter":
+            return concept.staleAfter === undefined ? [] : [concept.staleAfter];
+        case "generated":
+            return concept.generated === undefined ? [] : [concept.generated.by];
+        case "verified":
+            return concept.verified?.map(({ by }) => by) ?? [];
+        case "trust":
+            return concept.trust === undefined ? [] : [concept.trust];
+        default:
+            return field;
+    }
+};
+const collectionMatches = (values, operator, expected) => operator === "not-equals"
+    ? values.every((value) => valueMatches(value, operator, expected))
+    : values.some((value) => valueMatches(value, operator, expected));
+const matchingUnits = (concept, clause) => {
+    if (clause.kind === "term" || clause.kind === "phrase" || clause.kind === "literal") {
+        return concept.searchableUnits.filter((unit) => textMatches(unit.text, clause));
+    }
+    if (clause.kind === "field") {
+        return concept.searchableUnits.filter((unit) => unit.field === clause.field && textMatches(unit.text, clause.clause));
+    }
+    return [];
+};
+const clauseMatches = (concept, clause) => {
+    switch (clause.kind) {
+        case "term":
+        case "phrase":
+        case "literal":
+        case "field":
+            return matchingUnits(concept, clause).length > 0;
+        case "metadata":
+            return collectionMatches(metadataValues(concept, clause.field), clause.operator, clause.value);
+        case "lifecycle":
+            return collectionMatches(lifecycleValues(concept, clause.field), clause.operator, clause.value);
+        case "property": {
+            const resolved = resolveKnowledgeFrontmatterPointer(concept.frontmatter, clause.pointer);
+            return (resolved.found &&
+                collectionMatches(stringValues(resolved.value), clause.operator, clause.value));
+        }
+        default:
+            return clause;
+    }
+};
+const hasExplicitFilter = (query, kind, field) => query.clauses.some((clause) => clause.kind === kind && clause.field === field);
+const fieldWeight = (field) => {
+    switch (field) {
+        case "title":
+            return 8;
+        case "conceptId":
+        case "tag":
+            return 6;
+        case "description":
+        case "type":
+            return 4;
+        case "body":
+            return 2;
+        default:
+            return 1;
+    }
+};
+const locateTokenSequence = (text, tokens) => {
+    if (tokens.length === 0)
+        return undefined;
+    const normalized = normalizedLiteral(text);
+    const visit = (tokenIndex, searchStart, firstStart) => {
+        const token = tokens[tokenIndex];
+        if (token === undefined) {
+            return firstStart === undefined ? undefined : { start: firstStart, end: searchStart };
+        }
+        const needle = normalizedLiteral(token);
+        let start = normalized.indexOf(needle, searchStart);
+        while (start >= 0) {
+            const between = text.slice(searchStart, start);
+            if (tokenIndex === 0 || tokenizeKnowledgeSearchText(between).length === 0) {
+                const end = start + needle.length;
+                const found = visit(tokenIndex + 1, end, firstStart ?? start);
+                if (found !== undefined)
+                    return found;
+            }
+            start = normalized.indexOf(needle, start + 1);
+        }
+        return undefined;
+    };
+    return visit(0, 0);
+};
+const exactSpan = (text, clause, clauseIndex, field) => {
+    if (clause.kind === "literal") {
+        const needle = normalizedLiteral(clause.value);
+        const start = normalizedLiteral(text).indexOf(needle);
+        if (start < 0)
+            return undefined;
+        return { clauseIndex, field, start, end: Math.min(text.length, start + needle.length) };
+    }
+    const located = locateTokenSequence(text, tokenizeKnowledgeSearchText(clause.value));
+    return located === undefined ? undefined : { clauseIndex, field, ...located };
+};
+const rankConcept = (concept, query) => {
+    if (!hasExplicitFilter(query, "metadata", "kind") && concept.projected.kind !== "concept") {
+        return undefined;
+    }
+    if (!hasExplicitFilter(query, "lifecycle", "status") &&
+        normalizedLiteral(concept.projected.status ?? "") === "deprecated") {
+        return undefined;
+    }
+    if (!query.clauses.every((clause) => clauseMatches(concept.projected, clause)))
+        return undefined;
+    const fields = new Set();
+    const passageSpans = new Map();
+    let score = 0;
+    for (const [clauseIndex, clause] of query.clauses.entries()) {
+        const units = matchingUnits(concept.projected, clause);
+        const clauseFields = new Set(units.map(({ field }) => field));
+        for (const field of clauseFields)
+            score += fieldWeight(field);
+        for (const unit of units) {
+            fields.add(unit.field);
+            if (unit.passageIndex === undefined)
+                continue;
+            const textClause = clause.kind === "field" ? clause.clause : clause;
+            if (textClause.kind !== "term" &&
+                textClause.kind !== "phrase" &&
+                textClause.kind !== "literal") {
+                continue;
+            }
+            const span = exactSpan(unit.text, textClause, clauseIndex, unit.field);
+            if (span === undefined)
+                continue;
+            const spans = passageSpans.get(unit.passageIndex) ?? [];
+            spans.push(span);
+            passageSpans.set(unit.passageIndex, spans);
+        }
+    }
+    const passages = [...passageSpans]
+        .sort(([left], [right]) => left - right)
+        .slice(0, query.passageLimit)
+        .flatMap(([passageIndex, spans]) => {
+        const passage = concept.projected.bodyPassages[passageIndex];
+        if (passage === undefined)
+            return [];
+        const text = passage.text.slice(0, query.passageLength);
+        return [{ ...passage, text, spans: spans.filter(({ start }) => start < text.length) }];
+    });
+    return { concept, score, matchedFields: [...fields].sort(), passages };
+};
+const toResult = (ranked) => {
+    const { projected } = ranked.concept;
+    return {
+        ref: ranked.concept.ref,
+        orderingKey: `${ranked.concept.ref.bundle}#${ranked.concept.ref.conceptId}`,
+        matchedFields: ranked.matchedFields,
+        passages: ranked.passages,
+        kind: projected.kind,
+        ...(projected.title === undefined ? {} : { title: projected.title }),
+        ...(projected.description === undefined ? {} : { description: projected.description }),
+        ...(projected.status === undefined ? {} : { status: projected.status }),
+        ...(projected.staleAfter === undefined ? {} : { staleAfter: projected.staleAfter }),
+        ...(projected.generated === undefined ? {} : { generated: projected.generated }),
+        ...(projected.verified === undefined ? {} : { verified: projected.verified }),
+        ...(projected.trust === undefined ? {} : { trust: projected.trust }),
+        relativePath: projected.relativePath,
+    };
+};
+export const queryKnowledgeIndexResult = (snapshot, query, now) => {
+    const ranked = snapshot.concepts.flatMap((concept) => {
+        const candidate = rankConcept(concept, query);
+        return candidate === undefined ? [] : [candidate];
+    });
+    ranked.sort((left, right) => {
+        if (query.ordering === "relevance" && left.score !== right.score)
+            return right.score - left.score;
+        return (left.concept.ref.bundle.localeCompare(right.concept.ref.bundle) ||
+            left.concept.ref.conceptId.localeCompare(right.concept.ref.conceptId));
+    });
+    const decoded = query.cursor === undefined
+        ? Result.succeed({ offset: 0 })
+        : decodeCursor(query.cursor, snapshot, query, now);
+    if (!Result.isSuccess(decoded))
+        return Result.fail(decoded.failure);
+    const offset = decoded.success.offset;
+    if (offset > ranked.length) {
+        return Result.fail(new KnowledgeCursorInvalidError({ reason: "invalid" }));
+    }
+    const items = ranked.slice(offset, offset + query.resultLimit).map(toResult);
+    const nextOffset = offset + items.length;
+    const hasMore = nextOffset < ranked.length;
+    return Result.succeed({
+        items,
+        count: ranked.length,
+        hasMore,
+        ...(hasMore
+            ? {
+                cursor: encodeCursor({
+                    version: CURSOR_VERSION,
+                    corpusFingerprint: snapshot.fingerprint,
+                    queryDigest: queryDigest(query),
+                    offset: nextOffset,
+                    issuedAt: now,
+                }),
+            }
+            : {}),
+    });
+};
+export const queryKnowledgeIndex = (snapshot, query, now) => {
+    const result = queryKnowledgeIndexResult(snapshot, query, now);
+    if (Result.isSuccess(result))
+        return result.success;
+    throw result.failure;
+};
+export const getKnowledgeIndexConcept = (snapshot, bundle, conceptId) => snapshot.concepts.find((concept) => concept.ref.bundle === bundle && concept.ref.conceptId === conceptId);
+export class KnowledgeIndex extends ServiceMap.Service()("@agentxm/knowledge-query/knowledge-index/KnowledgeIndex") {
+}
+//# sourceMappingURL=knowledge-index.js.map

package/dist/src/knowledge-projection.d.ts

@@ -0,0 +1,61 @@
+import type { KnowledgeActorRecord, KnowledgeAuthoredLink, KnowledgeConcept, KnowledgeDocumentKind, KnowledgeTrustTier } from "@agentxm/registry-protocol/unstable/knowledge/okf";
+export type KnowledgeSearchableField = "bundle" | "conceptId" | "title" | "description" | "tag" | "type" | "body" | "resource" | "status" | "staleAfter" | "generated" | "verified" | "trust";
+export interface KnowledgeBodyPassage {
+    readonly text: string;
+    readonly section: ReadonlyArray<string>;
+    /** One-based line within the frontmatter-stripped body. */
+    readonly startLine: number;
+    /** One-based inclusive line within the frontmatter-stripped body. */
+    readonly endLine: number;
+}
+export interface KnowledgeSearchableUnit {
+    readonly field: KnowledgeSearchableField;
+    readonly text: string;
+    readonly passageIndex?: number;
+}
+export interface KnowledgeOutgoingLink extends KnowledgeAuthoredLink {
+    readonly origin: "authored";
+    readonly sourceConceptId: string;
+    readonly sourceRelativePath: string;
+}
+export interface KnowledgeBacklink {
+    readonly origin: "derived-backlink";
+    readonly sourceConceptId: string;
+    readonly sourceRelativePath: string;
+    readonly targetConceptId: string;
+    readonly line: number;
+}
+export interface KnowledgeProjectedConcept {
+    readonly bundle: string;
+    readonly conceptId: string;
+    readonly kind: KnowledgeDocumentKind;
+    readonly title?: string;
+    readonly description?: string;
+    readonly tags?: ReadonlyArray<string>;
+    readonly type?: string;
+    readonly resource?: string;
+    readonly status?: string;
+    readonly staleAfter?: string;
+    readonly generated?: KnowledgeActorRecord;
+    readonly verified?: ReadonlyArray<KnowledgeActorRecord>;
+    readonly trust?: KnowledgeTrustTier;
+    /** Complete parsed frontmatter, including producer-defined extension properties. */
+    readonly frontmatter?: Readonly<Record<string, unknown>>;
+    readonly relativePath: string;
+    readonly bodyPassages: ReadonlyArray<KnowledgeBodyPassage>;
+    readonly searchableUnits: ReadonlyArray<KnowledgeSearchableUnit>;
+    readonly outgoingLinks: ReadonlyArray<KnowledgeOutgoingLink>;
+    readonly backlinks: ReadonlyArray<KnowledgeBacklink>;
+}
+export type KnowledgeFrontmatterPointerResult = {
+    readonly found: true;
+    readonly value: unknown;
+} | {
+    readonly found: false;
+    readonly reason: "invalid-pointer" | "not-found";
+};
+/** Resolve one RFC 6901 JSON Pointer against the preserved frontmatter mapping. */
+export declare const resolveKnowledgeFrontmatterPointer: (frontmatter: Readonly<Record<string, unknown>> | undefined, pointer: string) => KnowledgeFrontmatterPointerResult;
+/** Build one bundle's immutable, graph-aware discovery projection. */
+export declare const projectKnowledgeConcepts: (bundle: string, concepts: ReadonlyArray<KnowledgeConcept>) => ReadonlyArray<KnowledgeProjectedConcept>;
+//# sourceMappingURL=knowledge-projection.d.ts.map

package/dist/src/knowledge-projection.js

@@ -0,0 +1,161 @@
+const pointerToken = (token) => {
+    if (/~(?:[^01]|$)/u.test(token))
+        return undefined;
+    return token.replace(/~1/gu, "/").replace(/~0/gu, "~");
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Resolve one RFC 6901 JSON Pointer against the preserved frontmatter mapping. */
+export const resolveKnowledgeFrontmatterPointer = (frontmatter, pointer) => {
+    if (frontmatter === undefined)
+        return { found: false, reason: "not-found" };
+    if (pointer === "")
+        return { found: true, value: frontmatter };
+    if (!pointer.startsWith("/"))
+        return { found: false, reason: "invalid-pointer" };
+    let current = frontmatter;
+    for (const encoded of pointer.slice(1).split("/")) {
+        const token = pointerToken(encoded);
+        if (token === undefined)
+            return { found: false, reason: "invalid-pointer" };
+        if (Array.isArray(current)) {
+            if (!/^(?:0|[1-9][0-9]*)$/u.test(token)) {
+                return { found: false, reason: "not-found" };
+            }
+            const index = Number(token);
+            if (!Number.isSafeInteger(index) || index >= current.length) {
+                return { found: false, reason: "not-found" };
+            }
+            current = current[index];
+            continue;
+        }
+        if (isRecord(current)) {
+            if (!Object.prototype.hasOwnProperty.call(current, token)) {
+                return { found: false, reason: "not-found" };
+            }
+            current = current[token];
+            continue;
+        }
+        return { found: false, reason: "not-found" };
+    }
+    return { found: true, value: current };
+};
+const bodyPassages = (body) => {
+    const lines = body.split(/\r?\n/u);
+    const headings = [];
+    const passages = [];
+    let passageLines = [];
+    let passageStart = 1;
+    const flush = (endLine) => {
+        let leading = 0;
+        while (passageLines[leading]?.trim().length === 0)
+            leading += 1;
+        let trailing = passageLines.length;
+        while (trailing > leading && passageLines[trailing - 1]?.trim().length === 0)
+            trailing -= 1;
+        if (trailing > leading) {
+            passages.push({
+                text: passageLines.slice(leading, trailing).join("\n"),
+                section: headings.map(({ title }) => title),
+                startLine: passageStart + leading,
+                endLine: endLine - (passageLines.length - trailing),
+            });
+        }
+        passageLines = [];
+    };
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const heading = /^(#{1,6})\s+(.+?)\s*$/u.exec(line);
+        if (heading?.[1] !== undefined && heading[2] !== undefined) {
+            flush(index);
+            const level = heading[1].length;
+            while ((headings.at(-1)?.level ?? 0) >= level)
+                headings.pop();
+            headings.push({ level, title: heading[2] });
+            passageStart = index + 2;
+            continue;
+        }
+        if (passageLines.length === 0)
+            passageStart = index + 1;
+        passageLines.push(line);
+    }
+    flush(lines.length);
+    return passages;
+};
+const actorText = (actor) => actor.at === undefined ? actor.by : `${actor.by} ${actor.at}`;
+const projectionBase = (bundle, concept) => {
+    const passages = bodyPassages(concept.body);
+    const units = [];
+    const addUnit = (field, text, passageIndex) => {
+        if (text === undefined || text.length === 0)
+            return;
+        units.push({ field, text, ...(passageIndex === undefined ? {} : { passageIndex }) });
+    };
+    addUnit("bundle", bundle);
+    addUnit("conceptId", concept.id);
+    addUnit("title", concept.authoredTitle);
+    addUnit("description", concept.description);
+    for (const tag of concept.tags ?? [])
+        addUnit("tag", tag);
+    addUnit("type", concept.type);
+    for (const [passageIndex, passage] of passages.entries()) {
+        addUnit("body", passage.text, passageIndex);
+    }
+    addUnit("resource", concept.resource);
+    addUnit("status", concept.status);
+    addUnit("staleAfter", concept.staleAfter);
+    if (concept.generated !== undefined)
+        addUnit("generated", actorText(concept.generated));
+    for (const verified of concept.verified ?? [])
+        addUnit("verified", actorText(verified));
+    addUnit("trust", concept.trust);
+    return {
+        bundle,
+        conceptId: concept.id,
+        kind: concept.kind,
+        ...(concept.authoredTitle === undefined ? {} : { title: concept.authoredTitle }),
+        ...(concept.description === undefined ? {} : { description: concept.description }),
+        ...(concept.tags === undefined ? {} : { tags: concept.tags }),
+        ...(concept.type === undefined ? {} : { type: concept.type }),
+        ...(concept.resource === undefined ? {} : { resource: concept.resource }),
+        ...(concept.status === undefined ? {} : { status: concept.status }),
+        ...(concept.staleAfter === undefined ? {} : { staleAfter: concept.staleAfter }),
+        ...(concept.generated === undefined ? {} : { generated: concept.generated }),
+        ...(concept.verified === undefined ? {} : { verified: concept.verified }),
+        ...(concept.trust === undefined ? {} : { trust: concept.trust }),
+        ...(concept.frontmatter === undefined ? {} : { frontmatter: concept.frontmatter }),
+        relativePath: concept.relativePath,
+        bodyPassages: passages,
+        searchableUnits: units,
+        outgoingLinks: concept.authoredLinks.map((link) => ({
+            ...link,
+            origin: "authored",
+            sourceConceptId: concept.id,
+            sourceRelativePath: concept.relativePath,
+        })),
+    };
+};
+/** Build one bundle's immutable, graph-aware discovery projection. */
+export const projectKnowledgeConcepts = (bundle, concepts) => {
+    const projected = concepts.map((concept) => projectionBase(bundle, concept));
+    const backlinks = new Map();
+    for (const concept of projected) {
+        for (const link of concept.outgoingLinks) {
+            if (link.resolvedConceptId === undefined)
+                continue;
+            const current = backlinks.get(link.resolvedConceptId) ?? [];
+            current.push({
+                origin: "derived-backlink",
+                sourceConceptId: concept.conceptId,
+                sourceRelativePath: concept.relativePath,
+                targetConceptId: link.resolvedConceptId,
+                line: link.line,
+            });
+            backlinks.set(link.resolvedConceptId, current);
+        }
+    }
+    return projected.map((concept) => ({
+        ...concept,
+        backlinks: [...(backlinks.get(concept.conceptId) ?? [])].sort((left, right) => left.sourceConceptId.localeCompare(right.sourceConceptId) || left.line - right.line),
+    }));
+};
+//# sourceMappingURL=knowledge-projection.js.map