@helyx/core 0.2.1 → 0.2.3

package/dist/help-direct-answer.d.ts

@@ -0,0 +1,14 @@
+import { type HelpRetrievalPolicy, type HelpRuntimeResult } from "./help-retrieval.js";
+import type { HelpRuntimeFaq } from "./help-runtime.js";
+/** Candidate count alone cannot establish relevance. Only the explicitly
+ * versioned policy may promote a well-corroborated semantic singleton. */
+export declare function helpReliableDirectAnswer(input: {
+    faqs: readonly HelpRuntimeFaq[];
+    question: string;
+    queryVector: readonly number[];
+    vectors: ReadonlyMap<string, readonly number[]>;
+    result: HelpRuntimeResult;
+    area?: string;
+    policy: HelpRetrievalPolicy;
+}): HelpRuntimeResult;
+//# sourceMappingURL=help-direct-answer.d.ts.map

package/dist/help-direct-answer.js

@@ -0,0 +1,52 @@
+import { helpKeywordEvidence } from "./help-keywords.js";
+import { helpSearchQuestion, scopeHelpFaqs, } from "./help-retrieval.js";
+/** Candidate count alone cannot establish relevance. Only the explicitly
+ * versioned policy may promote a well-corroborated semantic singleton. */
+export function helpReliableDirectAnswer(input) {
+    const { result, queryVector } = input;
+    if (input.policy !== "conservative-v5" ||
+        result.mode !== "hybrid" ||
+        result.degraded ||
+        result.kind !== "choices" ||
+        result.faqs.length !== 1 ||
+        queryVector.length !== 384 ||
+        queryVector.some((value) => !Number.isFinite(value)) ||
+        Math.abs(Math.hypot(...queryVector) - 1) > 0.0001)
+        return result;
+    const faqs = scopeHelpFaqs(input.faqs, input.area);
+    const candidate = faqs.find((faq) => faq.id === result.faqs[0].id);
+    if (!candidate ||
+        candidate.contentHash !== result.faqs[0].contentHash ||
+        candidate.approvedRevision !== result.faqs[0].approvedRevision)
+        return result;
+    const evidence = helpKeywordEvidence(faqs, helpSearchQuestion(faqs, input.question, input.policy));
+    if (!evidence.rareTitles.has(candidate.id))
+        return result;
+    const semantic = faqs.map((faq) => {
+        const vector = input.vectors.get(faq.id);
+        if (vector?.length !== 384 ||
+            vector.some((value) => !Number.isFinite(value)) ||
+            Math.abs(Math.hypot(...vector) - 1) > 0.0001)
+            return { id: faq.id, similarity: Number.NaN };
+        return {
+            id: faq.id,
+            similarity: vector.reduce((sum, value, index) => sum + value * queryVector[index], 0),
+        };
+    });
+    // Missing evidence cannot establish a lead over other eligible candidates.
+    if (semantic.some((row) => !Number.isFinite(row.similarity)))
+        return result;
+    semantic.sort((a, b) => b.similarity - a.similarity || a.id.localeCompare(b.id));
+    if (semantic.length < 2 ||
+        semantic[0].id !== candidate.id ||
+        semantic[0].similarity < 0.7 ||
+        semantic[0].similarity - semantic[1].similarity < 0.05)
+        return result;
+    return {
+        mode: result.mode,
+        revision: result.revision,
+        kind: "answer",
+        faq: structuredClone(candidate),
+    };
+}
+//# sourceMappingURL=help-direct-answer.js.map

package/dist/help-keywords.d.ts

@@ -0,0 +1,10 @@
+import type { HelpRuntimeFaq } from "./help-runtime.js";
+/** BM25 field ranks support semantic choices; their raw scores are never added
+ * to cosine scores or treated as confidence. Input is current eligible content.
+ */
+export declare function helpKeywordEvidence(faqs: readonly HelpRuntimeFaq[], question: string): {
+    ranks: Map<string, number>;
+    areas: Set<string>;
+    rareTitles: Set<string>;
+};
+//# sourceMappingURL=help-keywords.d.ts.map

package/dist/help-keywords.js

@@ -0,0 +1,98 @@
+import { normaliseHelpQuestion } from "./help.js";
+const stop = new Set("a an and are as at be been but by can could did do does for from had has have how i if in is it its me my of on or our should that the their them there these they this to us was we were what when where which who why will with would you your help helyx module please all any another anyone someone just ordinary".split(" "));
+function terms(text) {
+    return normaliseHelpQuestion(text)
+        .split(/\s+/u)
+        .filter((term) => term && !stop.has(term))
+        .map((term) => {
+        if (["mods", "moderators", "moderator", "manager", "managers"].includes(term))
+            return "manager";
+        if (["cannot", "cant", "unable"].includes(term))
+            return "not";
+        if (["access", "open"].includes(term))
+            return "access";
+        if (["user", "users", "member", "members"].includes(term))
+            return "member";
+        if (term.length > 4 && term.endsWith("ies"))
+            return term.slice(0, -3) + "y";
+        if (term.length > 4 && term.endsWith("s") && !term.endsWith("ss"))
+            return term.slice(0, -1);
+        if (term.length > 5 && term.endsWith("ing"))
+            return term.slice(0, -3).replace(/(.)\1$/u, "$1");
+        if (term.length > 4 && term.endsWith("ed"))
+            return term.slice(0, -2);
+        return term;
+    });
+}
+/** BM25 field ranks support semantic choices; their raw scores are never added
+ * to cosine scores or treated as confidence. Input is current eligible content.
+ */
+export function helpKeywordEvidence(faqs, question) {
+    const query = new Set(terms(question));
+    const documents = faqs.map((faq) => {
+        const fields = [
+            terms(faq.question),
+            terms(faq.answerText),
+            terms(faq.areaName),
+        ].map((tokens) => {
+            const frequency = new Map();
+            for (const token of tokens)
+                frequency.set(token, (frequency.get(token) ?? 0) + 1);
+            return { length: tokens.length, frequency };
+        });
+        return {
+            faq,
+            fields,
+            vocabulary: new Set(fields.flatMap((field) => [...field.frequency.keys()])),
+        };
+    });
+    const frequency = new Map();
+    for (const doc of documents)
+        for (const term of doc.vocabulary)
+            frequency.set(term, (frequency.get(term) ?? 0) + 1);
+    const averages = [0, 1, 2].map((index) => documents.reduce((sum, doc) => sum + doc.fields[index].length, 0) /
+        documents.length || 1);
+    const areas = new Set();
+    for (const faq of faqs) {
+        const name = terms(faq.areaName);
+        if (!["900", "901"].includes(faq.areaCode) &&
+            name.length &&
+            name.every((term) => query.has(term)))
+            areas.add(faq.areaCode);
+    }
+    const scored = documents.map((doc) => {
+        const matched = [...query].filter((term) => doc.vocabulary.has(term)).length;
+        const rareTitleMatch = [...query].some((term) => term.length >= 3 &&
+            doc.fields[0].frequency.has(term) &&
+            Math.log(1 +
+                (documents.length - (frequency.get(term) ?? 0) + 0.5) /
+                    ((frequency.get(term) ?? 0) + 0.5)) >= 3);
+        const score = doc.fields.reduce((sum, field, index) => sum +
+            [...query].reduce((total, term) => {
+                const count = field.frequency.get(term) ?? 0;
+                const occurrences = frequency.get(term) ?? 0;
+                const inverseFrequency = Math.log(1 + (documents.length - occurrences + 0.5) / (occurrences + 0.5));
+                return (total +
+                    (inverseFrequency * count * 2.2) /
+                        (count + 1.2 * (0.25 + (0.75 * field.length) / averages[index])));
+            }, 0) *
+                [2, 1, 0.5][index], 0);
+        return {
+            id: doc.faq.id,
+            matched,
+            rareTitleMatch,
+            coverage: matched / query.size,
+            score,
+        };
+    });
+    const ranked = scored
+        .filter((doc) => (doc.matched >= 2 || (doc.matched === 1 && doc.rareTitleMatch)) &&
+        doc.coverage >= 0.4)
+        .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+    return {
+        ranks: new Map(ranked.slice(0, 3).map((doc, index) => [doc.id, index + 1])),
+        areas,
+        rareTitles: new Set(scored.filter((doc) => doc.rareTitleMatch).map((doc) => doc.id)),
+    };
+}
+//# sourceMappingURL=help-keywords.js.map

package/dist/help-lexical.d.ts

@@ -0,0 +1,27 @@
+/** Provider-free matching shared by bundled Help and the staff approved preview. */
+export interface HelpLexicalDocument {
+    id: string;
+    question: string;
+    area: string;
+    areaName: string;
+    answerText: string;
+}
+export type HelpLexicalResult<T> = {
+    mode: "lexical";
+    revision: string;
+} & ({
+    kind: "answer";
+    faq: T;
+} | {
+    kind: "choices";
+    faqs: T[];
+} | {
+    kind: "no_match";
+    reason: "empty" | "weak_match";
+    docsUrl: string;
+} | {
+    kind: "invalid";
+    reason: "too_long";
+});
+export declare function createHelpLexicalSearch<T extends HelpLexicalDocument>(faqs: readonly T[], revision: string, copy?: (faq: T) => T): (question: string) => HelpLexicalResult<T>;
+//# sourceMappingURL=help-lexical.d.ts.map

package/dist/help-lexical.js

@@ -0,0 +1,99 @@
+const stopWords = new Set("a an and are as at be been but by can could did do does for from had has have how i if in is it its me my of on or our should that the their them there these they this to us was we were what when where which who why will with would you your help helyx module please".split(" "));
+const normalise = (text) => text
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[\p{Cc}\p{Cf}]/gu, " ")
+    .replace(/[^\p{L}\p{N}]+/gu, " ")
+    .trim();
+const terms = (text) => new Set(normalise(text)
+    .split(/\s+/u)
+    .filter((term) => term && !stopWords.has(term)));
+export function createHelpLexicalSearch(faqs, revision, copy = (faq) => structuredClone(faq)) {
+    const documents = faqs.map((faq) => ({
+        faq,
+        normalised: normalise(faq.question),
+        question: terms(faq.question),
+        area: terms(`${faq.area} ${faq.areaName}`),
+        answer: terms(faq.answerText),
+    }));
+    const frequency = new Map();
+    for (const doc of documents)
+        for (const term of doc.question)
+            frequency.set(term, (frequency.get(term) ?? 0) + 1);
+    const weight = (term) => 1 + Math.log(1 + documents.length / (1 + (frequency.get(term) ?? 0)));
+    const base = { mode: "lexical", revision };
+    const choose = (results) => results.length === 1
+        ? { ...base, kind: "answer", faq: copy(results[0]) }
+        : { ...base, kind: "choices", faqs: results.slice(0, 3).map(copy) };
+    return (question) => {
+        if (question.length > 600)
+            return { ...base, kind: "invalid", reason: "too_long" };
+        const query = normalise(question), tokens = terms(question);
+        if (!query || !tokens.size)
+            return {
+                ...base,
+                kind: "no_match",
+                reason: "empty",
+                docsUrl: "https://docs.helyx.gg/",
+            };
+        const byId = documents.find(({ faq }) => faq.id === question.trim().replace(/^#/u, ""));
+        if (byId)
+            return choose([byId.faq]);
+        const exact = documents.filter((doc) => doc.normalised === query);
+        if (exact.length)
+            return choose(exact.map(({ faq }) => faq));
+        const total = [...tokens].reduce((sum, term) => sum + weight(term), 0);
+        const ranked = documents
+            .map((doc) => {
+            let matched = 0, overlap = 0, areaOverlap = 0, answerOverlap = 0;
+            for (const term of tokens) {
+                if (doc.question.has(term)) {
+                    overlap += weight(term);
+                    matched++;
+                }
+                if (doc.area.has(term))
+                    areaOverlap += weight(term);
+                if (doc.answer.has(term))
+                    answerOverlap += weight(term);
+            }
+            const coverage = overlap / total, length = [...doc.question].reduce((sum, term) => sum + weight(term), 0);
+            const score = (2 * overlap) / (total + length || 1) +
+                (0.2 * areaOverlap) / total +
+                (0.05 * answerOverlap) / total;
+            return { ...doc, score, coverage, matched };
+        })
+            .filter((doc) => doc.matched > 0 && doc.score >= 0.3)
+            .sort((a, b) => b.score - a.score ||
+            (a.faq.id < b.faq.id ? -1 : a.faq.id > b.faq.id ? 1 : 0));
+        const best = ranked[0];
+        if (!best)
+            return {
+                ...base,
+                kind: "no_match",
+                reason: "weak_match",
+                docsUrl: "https://docs.helyx.gg/",
+            };
+        const next = ranked[1];
+        if (best.matched >= 2 &&
+            best.coverage >= 0.8 &&
+            best.score >= 0.65 &&
+            (!next || best.score - next.score >= 0.18))
+            return choose([best.faq]);
+        const alternatives = ranked
+            .filter((doc) => doc.coverage >= 0.4 && doc.score >= best.score - 0.18)
+            .slice(0, 3);
+        if (alternatives.length >= 2)
+            return {
+                ...base,
+                kind: "choices",
+                faqs: alternatives.map(({ faq }) => copy(faq)),
+            };
+        return {
+            ...base,
+            kind: "no_match",
+            reason: "weak_match",
+            docsUrl: "https://docs.helyx.gg/",
+        };
+    };
+}
+//# sourceMappingURL=help-lexical.js.map

package/dist/help-retrieval.d.ts

@@ -0,0 +1,34 @@
+import type { HelpRuntimeFaq, HelpSemanticArtifact } from "./help-runtime.js";
+export type HelpRetrievalPolicy = HelpSemanticArtifact["manifest"]["retrievalPolicy"];
+/** Only repair a transposed long word when the eligible vocabulary has one candidate.
+ * IDs, known words and ambiguous corrections are left as written. This is search
+ * evidence, never permission to turn a corrected question into an exact answer.
+ */
+export declare function helpSearchQuestion(faqs: readonly HelpRuntimeFaq[], question: string, policy?: HelpRetrievalPolicy): string;
+export type HelpRuntimeResult = {
+    mode: "lexical" | "hybrid";
+    revision: string;
+    degraded?: "provider_disabled" | "provider_unavailable" | "budget_exhausted";
+} & ({
+    kind: "answer";
+    faq: HelpRuntimeFaq;
+} | {
+    kind: "choices";
+    faqs: HelpRuntimeFaq[];
+} | {
+    kind: "no_match";
+    reason: "empty" | "weak_match";
+    docsUrl: string;
+} | {
+    kind: "invalid";
+    reason: "too_long";
+});
+export declare function scopeHelpFaqs(faqs: readonly HelpRuntimeFaq[], area?: string): HelpRuntimeFaq[];
+/** Module-specific exact questions precede a manually approved generic comparison. */
+export declare function helpExactMatch(faqs: readonly HelpRuntimeFaq[], question: string, revision: string, area?: string): HelpRuntimeResult | null;
+export declare function helpLexicalResult(faqs: readonly HelpRuntimeFaq[], question: string, revision: string, area?: string, policy?: HelpRetrievalPolicy): HelpRuntimeResult;
+export declare const HELP_SEMANTIC_CHOICE_FLOOR = 0.75;
+export declare const HELP_SHARED_SUPPORT_FLOOR = 0.7;
+/** Development-calibrated ranking; approximate evidence still requires selection. */
+export declare function helpHybridChoices(faqs: readonly HelpRuntimeFaq[], queryVector: readonly number[], vectors: ReadonlyMap<string, readonly number[]>, lexical: HelpRuntimeResult, area?: string, policy?: HelpRetrievalPolicy, question?: string): HelpRuntimeResult;
+//# sourceMappingURL=help-retrieval.d.ts.map

package/dist/help-retrieval.js

@@ -0,0 +1,263 @@
+import { createHelpLexicalSearch, normaliseHelpQuestion, HELP_DOCS_URL, } from "./help.js";
+import { helpKeywordEvidence } from "./help-keywords.js";
+/** Only repair a transposed long word when the eligible vocabulary has one candidate.
+ * IDs, known words and ambiguous corrections are left as written. This is search
+ * evidence, never permission to turn a corrected question into an exact answer.
+ */
+export function helpSearchQuestion(faqs, question, policy = "conservative-v2") {
+    const vocabulary = new Set(faqs.flatMap((faq) => normaliseHelpQuestion(`${faq.areaName} ${faq.question} ${faq.answerText}`).split(/\s+/u)));
+    const moduleTerms = new Set(faqs
+        .filter((faq) => !["900", "901"].includes(faq.areaCode))
+        .flatMap((faq) => normaliseHelpQuestion(faq.areaName).split(/\s+/u))
+        .map((term) => term.endsWith("s") && !term.endsWith("ss") ? term.slice(0, -1) : term)
+        .filter((term) => term.length >= 8));
+    const transposed = (a, b) => {
+        if (a.length !== b.length)
+            return false;
+        let index = 0;
+        while (index < a.length && a[index] === b[index])
+            index++;
+        return (a[index] === b[index + 1] &&
+            a[index + 1] === b[index] &&
+            a.slice(index + 2) === b.slice(index + 2));
+    };
+    return question
+        .replace(/\b(?:cant|mods)\b/giu, (word) => word.toLowerCase() === "cant" ? "cannot" : "moderators")
+        .replace(/\b[a-zA-Z]{6,}\b/gu, (word) => {
+        const lower = word.toLowerCase();
+        if (vocabulary.has(lower))
+            return word;
+        let correction;
+        for (const candidate of vocabulary) {
+            if (!transposed(lower, candidate))
+                continue;
+            if (correction)
+                return word;
+            correction = candidate;
+        }
+        if (correction)
+            return correction;
+        if (!["conservative-v3", "conservative-v4", "conservative-v5"].includes(policy) ||
+            lower.length < 8)
+            return word;
+        // Only recover missing letters in long, known module/area names. Broad
+        // edit-distance correction can turn valid words such as rules into roles.
+        const candidates = [...moduleTerms].filter((term) => {
+            if (term.length <= lower.length || term.length - lower.length > 2)
+                return false;
+            let index = 0;
+            for (const character of term)
+                if (character === lower[index])
+                    index++;
+            return index === lower.length;
+        });
+        return candidates.length === 1 ? candidates[0] : word;
+    });
+}
+// Search synonyms describe the subject of a question; they do not grant a
+// dashboard role or change any stored question/answer/permission policy.
+function lexicalQuestion(question) {
+    return normaliseHelpQuestion(question)
+        .split(/\s+/u)
+        .map((term) => {
+        if ([
+            "mod",
+            "mods",
+            "moderator",
+            "moderators",
+            "manager",
+            "managers",
+        ].includes(term))
+            return "manager";
+        if (["open", "access"].includes(term))
+            return "access";
+        if (["cannot", "cant", "unable"].includes(term))
+            return "not";
+        if (["role", "roles"].includes(term))
+            return "role";
+        if (["member", "members"].includes(term))
+            return "member";
+        if (["add", "adding", "assign", "assigned", "assigning"].includes(term))
+            return "assign";
+        return term;
+    })
+        .join(" ");
+}
+export function scopeHelpFaqs(faqs, area) {
+    if (!area)
+        return [...faqs];
+    return faqs.filter((faq) => faq.areaCode === area ||
+        faq.area === area ||
+        faq.moduleId === area ||
+        (faq.source.kind === "generic" &&
+            faq.source.comparisons.some((ref) => ref.id.slice(0, 3) === area ||
+                ref.area === area ||
+                `helyx.${ref.area}` === area)));
+}
+/** Module-specific exact questions precede a manually approved generic comparison. */
+export function helpExactMatch(faqs, question, revision, area) {
+    const scoped = scopeHelpFaqs(faqs, area), query = normaliseHelpQuestion(question);
+    const byId = scoped.find((faq) => faq.id === question.trim().replace(/^#/u, ""));
+    if (byId)
+        return {
+            mode: "lexical",
+            revision,
+            kind: "answer",
+            faq: structuredClone(byId),
+        };
+    const specific = scoped.filter((faq) => faq.source.kind !== "generic" &&
+        normaliseHelpQuestion(faq.question) === query);
+    const generic = scoped.filter((faq) => faq.source.kind === "generic" &&
+        (normaliseHelpQuestion(faq.question) === query ||
+            faq.source.comparisons.some((ref) => normaliseHelpQuestion(ref.question) === query)));
+    const choose = (records) => records.length === 1
+        ? {
+            mode: "lexical",
+            revision,
+            kind: "answer",
+            faq: structuredClone(records[0]),
+        }
+        : {
+            mode: "lexical",
+            revision,
+            kind: "choices",
+            faqs: records.slice(0, 3).map((faq) => structuredClone(faq)),
+        };
+    if (area && specific.length)
+        return choose(specific);
+    const shared = generic.filter((faq) => faq.source.kind === "generic" &&
+        specific.every((record) => faq.source.kind === "generic" &&
+            faq.source.comparisons.some((ref) => ref.id === record.id)));
+    if (shared.length === 1)
+        return choose(shared);
+    if (specific.length || generic.length)
+        return choose([...specific, ...generic]);
+    return null;
+}
+export function helpLexicalResult(faqs, question, revision, area, policy = "conservative-v2") {
+    const exact = helpExactMatch(faqs, question, revision, area);
+    if (exact)
+        return exact;
+    const scoped = scopeHelpFaqs(faqs, area);
+    const records = new Map(scoped.map((faq) => [faq.id, faq]));
+    const transform = (text) => policy !== "conservative-v1" ? lexicalQuestion(text) : text;
+    const ranked = createHelpLexicalSearch(scoped.map((faq) => ({
+        ...faq,
+        question: transform(faq.question),
+        answerText: transform(faq.answerText),
+    })), revision, (faq) => structuredClone(records.get(faq.id)))(transform(policy !== "conservative-v1"
+        ? helpSearchQuestion(scoped, question, policy)
+        : question));
+    // Uncalibrated ranking scores cannot authorise an automatic answer. Even one
+    // plausible approximate match needs the member to select it explicitly.
+    return ranked.kind === "answer"
+        ? { mode: "lexical", revision, kind: "choices", faqs: [ranked.faq] }
+        : ranked;
+}
+export const HELP_SEMANTIC_CHOICE_FLOOR = 0.75;
+export const HELP_SHARED_SUPPORT_FLOOR = 0.7;
+/** Development-calibrated ranking; approximate evidence still requires selection. */
+export function helpHybridChoices(faqs, queryVector, vectors, lexical, area, policy = "conservative-v2", question) {
+    if (queryVector.length !== 384 ||
+        queryVector.some((value) => !Number.isFinite(value)) ||
+        Math.abs(Math.hypot(...queryVector) - 1) > 0.0001)
+        throw new Error("Invalid Help query vector");
+    if (["conservative-v3", "conservative-v4", "conservative-v5"].includes(policy) &&
+        (!question || question.length > 600))
+        throw new Error("Invalid Help search context");
+    const scoped = scopeHelpFaqs(faqs, area), semantic = scoped
+        .map((faq) => {
+        const vector = vectors.get(faq.id);
+        return {
+            faq,
+            similarity: vector?.length === 384
+                ? vector.reduce((sum, value, index) => sum + value * queryVector[index], 0)
+                : -1,
+        };
+    })
+        .sort((a, b) => b.similarity - a.similarity || a.faq.id.localeCompare(b.faq.id));
+    const collapsed = new Set();
+    const lexicalIds = lexical.kind === "choices" ? lexical.faqs.map((faq) => faq.id) : [];
+    const keyword = [
+        "conservative-v3",
+        "conservative-v4",
+        "conservative-v5",
+    ].includes(policy)
+        ? helpKeywordEvidence(scoped, helpSearchQuestion(scoped, question, policy))
+        : null;
+    const candidates = semantic.map((candidate) => {
+        if (area || candidate.faq.source.kind !== "generic")
+            return candidate;
+        const comparisons = new Set(candidate.faq.source.comparisons.map((ref) => ref.id));
+        const support = semantic.filter((other) => comparisons.has(other.faq.id) &&
+            other.similarity >= HELP_SHARED_SUPPORT_FLOOR);
+        if (new Set(support.map((other) => other.faq.areaCode)).size < 2)
+            return candidate;
+        // An approved comparison can represent several matching module questions.
+        // Its ranking support is not a probability and never authorises a direct answer.
+        for (const other of support)
+            collapsed.add(other.faq.id);
+        return {
+            ...candidate,
+            similarity: Math.max(candidate.similarity, support[0].similarity),
+            sharedSupport: true,
+        };
+    });
+    const semanticRanks = new Map([...candidates]
+        .sort((a, b) => b.similarity - a.similarity || a.faq.id.localeCompare(b.faq.id))
+        .map((candidate, index) => [candidate.faq.id, index + 1]));
+    const ranked = candidates
+        .filter((candidate) => !collapsed.has(candidate.faq.id) &&
+        candidate.similarity >=
+            ("sharedSupport" in candidate
+                ? HELP_SHARED_SUPPORT_FLOOR
+                : keyword
+                    ? keyword.ranks.has(candidate.faq.id)
+                        ? 0.65
+                        : area ||
+                            keyword.areas.has(candidate.faq.areaCode) ||
+                            (["conservative-v4", "conservative-v5"].includes(policy) &&
+                                keyword.rareTitles.has(candidate.faq.id) &&
+                                semantic[0]?.faq.id === candidate.faq.id &&
+                                candidate.similarity - (semantic[1]?.similarity ?? -1) >=
+                                    0.05)
+                            ? 0.7
+                            : HELP_SEMANTIC_CHOICE_FLOOR
+                    : policy === "conservative-v2" &&
+                        lexicalIds.includes(candidate.faq.id)
+                        ? 0.65
+                        : policy === "conservative-v2" &&
+                            semantic[0].similarity >= HELP_SEMANTIC_CHOICE_FLOOR
+                            ? Math.max(HELP_SHARED_SUPPORT_FLOOR, semantic[0].similarity - 0.05)
+                            : HELP_SEMANTIC_CHOICE_FLOOR))
+        .sort((a, b) => {
+        const score = (candidate) => keyword
+            ? 1 / (10 + semanticRanks.get(candidate.faq.id)) +
+                (keyword.ranks.has(candidate.faq.id)
+                    ? 0.5 / (10 + keyword.ranks.get(candidate.faq.id))
+                    : 0)
+            : candidate.similarity +
+                (policy === "conservative-v2" &&
+                    lexicalIds.includes(candidate.faq.id)
+                    ? 0.05 / (lexicalIds.indexOf(candidate.faq.id) + 1)
+                    : 0);
+        return score(b) - score(a) || a.faq.id.localeCompare(b.faq.id);
+    });
+    return ranked.length
+        ? {
+            mode: "hybrid",
+            revision: lexical.revision,
+            kind: "choices",
+            faqs: ranked
+                .slice(0, 3)
+                .map((candidate) => structuredClone(candidate.faq)),
+        }
+        : {
+            mode: "hybrid",
+            revision: lexical.revision,
+            kind: "no_match",
+            reason: "weak_match",
+            docsUrl: HELP_DOCS_URL,
+        };
+}
+//# sourceMappingURL=help-retrieval.js.map

package/dist/help-runtime-collection.d.ts

@@ -0,0 +1,4 @@
+import type { HelpRuntimeCollection } from "./help-runtime.js";
+/** Approved published public FAQs only. Generated by prepare-help-runtime-bundle.mjs. */
+export declare const BUNDLED_HELP_RUNTIME_COLLECTION: HelpRuntimeCollection;
+//# sourceMappingURL=help-runtime-collection.d.ts.map