@aigne/afs-index 1.12.0-beta.5

package/dist/text/cjk.mjs

@@ -0,0 +1,30 @@
+//#region src/text/cjk.ts
+/**
+* CJK text segmentation for FTS5 compatibility.
+*
+* FTS5's unicode61 tokenizer treats consecutive CJK characters as a single token,
+* which prevents character-level matching. This module inserts spaces between CJK
+* characters so FTS5 indexes them individually.
+*
+* Design note: Character-level segmentation is intentional for a recall-optimized
+* memory system. Word-level (Intl.Segmenter) was tested and caused -10%~-46%
+* regression due to vocabulary mismatch between query and corpus word boundaries.
+* Character-level gives broader matching at the cost of precision — the right
+* trade-off when results are top-K ranked and embeddings handle semantic matching.
+*
+* Example: "空调使用模式" → "空 调 使 用 模 式"
+*/
+/** CJK Unified Ideographs + Extension A + Compatibility + Hiragana + Katakana */
+const CJK_CHAR = /[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff\u3040-\u309f\u30a0-\u30ff]/g;
+/**
+* Insert spaces around each CJK character so FTS5 treats them as individual tokens.
+* Non-CJK text passes through unchanged.
+*/
+function segmentCJK(text) {
+	if (!text) return text;
+	return text.replace(CJK_CHAR, " $& ").replace(/\s+/g, " ").trim();
+}
+
+//#endregion
+export { segmentCJK };
+//# sourceMappingURL=cjk.mjs.map

package/dist/text/cjk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cjk.mjs","names":[],"sources":["../../src/text/cjk.ts"],"sourcesContent":["/**\n * CJK text segmentation for FTS5 compatibility.\n *\n * FTS5's unicode61 tokenizer treats consecutive CJK characters as a single token,\n * which prevents character-level matching. This module inserts spaces between CJK\n * characters so FTS5 indexes them individually.\n *\n * Design note: Character-level segmentation is intentional for a recall-optimized\n * memory system. Word-level (Intl.Segmenter) was tested and caused -10%~-46%\n * regression due to vocabulary mismatch between query and corpus word boundaries.\n * Character-level gives broader matching at the cost of precision — the right\n * trade-off when results are top-K ranked and embeddings handle semantic matching.\n *\n * Example: \"空调使用模式\" → \"空 调 使 用 模 式\"\n */\n\n/** CJK Unified Ideographs + Extension A + Compatibility + Hiragana + Katakana */\nconst CJK_CHAR = /[\\u4e00-\\u9fff\\u3400-\\u4dbf\\uf900-\\ufaff\\u3040-\\u309f\\u30a0-\\u30ff]/g;\n\n/**\n * Insert spaces around each CJK character so FTS5 treats them as individual tokens.\n * Non-CJK text passes through unchanged.\n */\nexport function segmentCJK(text: string): string {\n  if (!text) return text;\n  return text.replace(CJK_CHAR, \" $& \").replace(/\\s+/g, \" \").trim();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,MAAM,WAAW;;;;;AAMjB,SAAgB,WAAW,MAAsB;AAC/C,KAAI,CAAC,KAAM,QAAO;AAClB,QAAO,KAAK,QAAQ,UAAU,OAAO,CAAC,QAAQ,QAAQ,IAAI,CAAC,MAAM"}

package/dist/text/fts.cjs

@@ -0,0 +1,244 @@
+const require_cjk = require('./cjk.cjs');
+
+//#region src/text/fts.ts
+/**
+* FTS query transformation for FTS5 compatibility.
+*
+* Decision lock (#933, owner ruling 2026-07-03 on PR #946): the central
+* transform produces an AND query, not OR. FTS5's default MATCH semantics
+* is AND-all; broadening every query to OR-any silently drops precision
+* for every consumer (anchor+FTS combined queries, aside's tag/keyword
+* filters) in exchange for recall that only one caller (memory) ever
+* wanted — and memory gets that recall from its own metaFilter + anchor
+* layers, not from FTS breadth. Transformation order is non-negotiable:
+*
+*   1. Strip bare AND/OR/NOT first — so legacy "空 OR 调" pre-segmented output
+*      from memory degrades gracefully (strip OR → re-join with a plain
+*      space = idempotent). Reversing the order turns pre-segmented strings
+*      into malformed FTS5 on D1.
+*   2. CJK segmentation — insert spaces between consecutive CJK characters so
+*      FTS5 unicode61 indexes them individually (symmetric with write-side).
+*   3. Stopword filtering — common English/Chinese function words carry no
+*      retrieval signal; under AND semantics they only narrow the result set
+*      for no benefit (a query padded with "tell me about X" would otherwise
+*      require "tell", "me", "about" to all literally appear in the summary).
+*      Ported verbatim from the memory provider's private STOPWORDS list
+*      (`providers/core/memory/src/index.ts`, removed there by #933 — this
+*      transform is now the single place FTS query text is built).
+*   4. Join all surviving tokens with a single space — FTS5's implicit MATCH
+*      semantics is AND, so a space-separated token list is already an AND
+*      query. Single-token queries pass through untouched. If every token is
+*      filtered as a stopword, fall back to the boolean-stripped text from
+*      step 1 (not the fully raw input) so a bare-AND/OR/NOT never reaches
+*      FTS5 even in this fallback path.
+*/
+/**
+* Common English/Chinese stopwords, filtered out before the FTS5 MATCH
+* query is built. Ported verbatim from the memory provider's private
+* STOPWORDS list (pre-#933) — the index provider is now the single owner
+* of FTS query transformation, so this list lives here instead.
+*/
+const STOPWORDS = new Set([
+	"a",
+	"an",
+	"the",
+	"is",
+	"are",
+	"was",
+	"were",
+	"be",
+	"been",
+	"am",
+	"do",
+	"does",
+	"did",
+	"will",
+	"would",
+	"could",
+	"should",
+	"can",
+	"may",
+	"might",
+	"shall",
+	"have",
+	"has",
+	"had",
+	"having",
+	"i",
+	"me",
+	"my",
+	"we",
+	"our",
+	"you",
+	"your",
+	"he",
+	"she",
+	"it",
+	"they",
+	"them",
+	"its",
+	"his",
+	"her",
+	"their",
+	"this",
+	"that",
+	"these",
+	"those",
+	"in",
+	"on",
+	"at",
+	"to",
+	"for",
+	"of",
+	"with",
+	"by",
+	"from",
+	"as",
+	"into",
+	"about",
+	"between",
+	"through",
+	"during",
+	"and",
+	"or",
+	"but",
+	"not",
+	"if",
+	"then",
+	"so",
+	"than",
+	"too",
+	"very",
+	"just",
+	"how",
+	"what",
+	"when",
+	"where",
+	"who",
+	"which",
+	"why",
+	"all",
+	"each",
+	"some",
+	"any",
+	"no",
+	"there",
+	"here",
+	"up",
+	"out",
+	"also",
+	"tell",
+	"的",
+	"了",
+	"在",
+	"是",
+	"我",
+	"有",
+	"和",
+	"就",
+	"不",
+	"人",
+	"都",
+	"一",
+	"上",
+	"也",
+	"很",
+	"到",
+	"说",
+	"要",
+	"去",
+	"你",
+	"会",
+	"着",
+	"看",
+	"好",
+	"这",
+	"他",
+	"她",
+	"它",
+	"们",
+	"么",
+	"吗",
+	"吧",
+	"啊",
+	"呢",
+	"嗯",
+	"哦",
+	"那",
+	"把",
+	"被",
+	"让",
+	"给",
+	"跟",
+	"用",
+	"帮",
+	"请",
+	"下",
+	"能",
+	"哪",
+	"什",
+	"怎",
+	"为",
+	"还",
+	"或",
+	"但",
+	"然",
+	"所",
+	"因",
+	"如",
+	"虽",
+	"只",
+	"已",
+	"正",
+	"一个",
+	"没有",
+	"自己",
+	"什么",
+	"可以",
+	"怎么",
+	"怎样",
+	"如何",
+	"哪个",
+	"哪些",
+	"为什么",
+	"什么时候",
+	"多少",
+	"关于",
+	"还是",
+	"或者",
+	"以及",
+	"但是",
+	"然后",
+	"所以",
+	"因为",
+	"如果",
+	"虽然",
+	"只是",
+	"已经",
+	"正在",
+	"一下",
+	"回忆"
+]);
+/**
+* Transform a natural-language query into a safe FTS5 MATCH expression.
+*
+* - Strips isolated AND/OR/NOT keywords (they cause D1 syntax errors at
+*   phrase boundaries, e.g. trailing "空调 AND").
+* - Applies CJK character-level segmentation symmetric with the write side.
+* - Filters common stopwords (no retrieval signal, only narrows AND recall).
+* - Joins remaining tokens using the specified mode:
+*   - "and" (default): space-separated — FTS5 implicit AND. Good for precision.
+*   - "or": " OR "-joined — broadens recall. Use for memory/similarity search.
+*   Single-token queries are returned as-is regardless of mode.
+*/
+function transformFtsQuery(text, mode = "and") {
+	const stripped = text.replace(/\b(AND|OR|NOT)\b/gi, " ").replace(/\s+/g, " ").trim();
+	if (!stripped) return "";
+	const tokens = require_cjk.segmentCJK(stripped).toLowerCase().split(/[\s,;.!?，。！？；：、]+/).filter((t) => t.length > 0 && !STOPWORDS.has(t));
+	if (tokens.length === 0) return stripped;
+	if (tokens.length === 1) return tokens[0];
+	return mode === "or" ? tokens.join(" OR ") : tokens.join(" ");
+}
+
+//#endregion
+exports.transformFtsQuery = transformFtsQuery;

package/dist/text/fts.mjs

@@ -0,0 +1,245 @@
+import { segmentCJK } from "./cjk.mjs";
+
+//#region src/text/fts.ts
+/**
+* FTS query transformation for FTS5 compatibility.
+*
+* Decision lock (#933, owner ruling 2026-07-03 on PR #946): the central
+* transform produces an AND query, not OR. FTS5's default MATCH semantics
+* is AND-all; broadening every query to OR-any silently drops precision
+* for every consumer (anchor+FTS combined queries, aside's tag/keyword
+* filters) in exchange for recall that only one caller (memory) ever
+* wanted — and memory gets that recall from its own metaFilter + anchor
+* layers, not from FTS breadth. Transformation order is non-negotiable:
+*
+*   1. Strip bare AND/OR/NOT first — so legacy "空 OR 调" pre-segmented output
+*      from memory degrades gracefully (strip OR → re-join with a plain
+*      space = idempotent). Reversing the order turns pre-segmented strings
+*      into malformed FTS5 on D1.
+*   2. CJK segmentation — insert spaces between consecutive CJK characters so
+*      FTS5 unicode61 indexes them individually (symmetric with write-side).
+*   3. Stopword filtering — common English/Chinese function words carry no
+*      retrieval signal; under AND semantics they only narrow the result set
+*      for no benefit (a query padded with "tell me about X" would otherwise
+*      require "tell", "me", "about" to all literally appear in the summary).
+*      Ported verbatim from the memory provider's private STOPWORDS list
+*      (`providers/core/memory/src/index.ts`, removed there by #933 — this
+*      transform is now the single place FTS query text is built).
+*   4. Join all surviving tokens with a single space — FTS5's implicit MATCH
+*      semantics is AND, so a space-separated token list is already an AND
+*      query. Single-token queries pass through untouched. If every token is
+*      filtered as a stopword, fall back to the boolean-stripped text from
+*      step 1 (not the fully raw input) so a bare-AND/OR/NOT never reaches
+*      FTS5 even in this fallback path.
+*/
+/**
+* Common English/Chinese stopwords, filtered out before the FTS5 MATCH
+* query is built. Ported verbatim from the memory provider's private
+* STOPWORDS list (pre-#933) — the index provider is now the single owner
+* of FTS query transformation, so this list lives here instead.
+*/
+const STOPWORDS = new Set([
+	"a",
+	"an",
+	"the",
+	"is",
+	"are",
+	"was",
+	"were",
+	"be",
+	"been",
+	"am",
+	"do",
+	"does",
+	"did",
+	"will",
+	"would",
+	"could",
+	"should",
+	"can",
+	"may",
+	"might",
+	"shall",
+	"have",
+	"has",
+	"had",
+	"having",
+	"i",
+	"me",
+	"my",
+	"we",
+	"our",
+	"you",
+	"your",
+	"he",
+	"she",
+	"it",
+	"they",
+	"them",
+	"its",
+	"his",
+	"her",
+	"their",
+	"this",
+	"that",
+	"these",
+	"those",
+	"in",
+	"on",
+	"at",
+	"to",
+	"for",
+	"of",
+	"with",
+	"by",
+	"from",
+	"as",
+	"into",
+	"about",
+	"between",
+	"through",
+	"during",
+	"and",
+	"or",
+	"but",
+	"not",
+	"if",
+	"then",
+	"so",
+	"than",
+	"too",
+	"very",
+	"just",
+	"how",
+	"what",
+	"when",
+	"where",
+	"who",
+	"which",
+	"why",
+	"all",
+	"each",
+	"some",
+	"any",
+	"no",
+	"there",
+	"here",
+	"up",
+	"out",
+	"also",
+	"tell",
+	"的",
+	"了",
+	"在",
+	"是",
+	"我",
+	"有",
+	"和",
+	"就",
+	"不",
+	"人",
+	"都",
+	"一",
+	"上",
+	"也",
+	"很",
+	"到",
+	"说",
+	"要",
+	"去",
+	"你",
+	"会",
+	"着",
+	"看",
+	"好",
+	"这",
+	"他",
+	"她",
+	"它",
+	"们",
+	"么",
+	"吗",
+	"吧",
+	"啊",
+	"呢",
+	"嗯",
+	"哦",
+	"那",
+	"把",
+	"被",
+	"让",
+	"给",
+	"跟",
+	"用",
+	"帮",
+	"请",
+	"下",
+	"能",
+	"哪",
+	"什",
+	"怎",
+	"为",
+	"还",
+	"或",
+	"但",
+	"然",
+	"所",
+	"因",
+	"如",
+	"虽",
+	"只",
+	"已",
+	"正",
+	"一个",
+	"没有",
+	"自己",
+	"什么",
+	"可以",
+	"怎么",
+	"怎样",
+	"如何",
+	"哪个",
+	"哪些",
+	"为什么",
+	"什么时候",
+	"多少",
+	"关于",
+	"还是",
+	"或者",
+	"以及",
+	"但是",
+	"然后",
+	"所以",
+	"因为",
+	"如果",
+	"虽然",
+	"只是",
+	"已经",
+	"正在",
+	"一下",
+	"回忆"
+]);
+/**
+* Transform a natural-language query into a safe FTS5 MATCH expression.
+*
+* - Strips isolated AND/OR/NOT keywords (they cause D1 syntax errors at
+*   phrase boundaries, e.g. trailing "空调 AND").
+* - Applies CJK character-level segmentation symmetric with the write side.
+* - Filters common stopwords (no retrieval signal, only narrows AND recall).
+* - Joins remaining tokens using the specified mode:
+*   - "and" (default): space-separated — FTS5 implicit AND. Good for precision.
+*   - "or": " OR "-joined — broadens recall. Use for memory/similarity search.
+*   Single-token queries are returned as-is regardless of mode.
+*/
+function transformFtsQuery(text, mode = "and") {
+	const stripped = text.replace(/\b(AND|OR|NOT)\b/gi, " ").replace(/\s+/g, " ").trim();
+	if (!stripped) return "";
+	const tokens = segmentCJK(stripped).toLowerCase().split(/[\s,;.!?，。！？；：、]+/).filter((t) => t.length > 0 && !STOPWORDS.has(t));
+	if (tokens.length === 0) return stripped;
+	if (tokens.length === 1) return tokens[0];
+	return mode === "or" ? tokens.join(" OR ") : tokens.join(" ");
+}
+
+//#endregion
+export { transformFtsQuery };
+//# sourceMappingURL=fts.mjs.map

package/dist/text/fts.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fts.mjs","names":[],"sources":["../../src/text/fts.ts"],"sourcesContent":["/**\n * FTS query transformation for FTS5 compatibility.\n *\n * Decision lock (#933, owner ruling 2026-07-03 on PR #946): the central\n * transform produces an AND query, not OR. FTS5's default MATCH semantics\n * is AND-all; broadening every query to OR-any silently drops precision\n * for every consumer (anchor+FTS combined queries, aside's tag/keyword\n * filters) in exchange for recall that only one caller (memory) ever\n * wanted — and memory gets that recall from its own metaFilter + anchor\n * layers, not from FTS breadth. Transformation order is non-negotiable:\n *\n *   1. Strip bare AND/OR/NOT first — so legacy \"空 OR 调\" pre-segmented output\n *      from memory degrades gracefully (strip OR → re-join with a plain\n *      space = idempotent). Reversing the order turns pre-segmented strings\n *      into malformed FTS5 on D1.\n *   2. CJK segmentation — insert spaces between consecutive CJK characters so\n *      FTS5 unicode61 indexes them individually (symmetric with write-side).\n *   3. Stopword filtering — common English/Chinese function words carry no\n *      retrieval signal; under AND semantics they only narrow the result set\n *      for no benefit (a query padded with \"tell me about X\" would otherwise\n *      require \"tell\", \"me\", \"about\" to all literally appear in the summary).\n *      Ported verbatim from the memory provider's private STOPWORDS list\n *      (`providers/core/memory/src/index.ts`, removed there by #933 — this\n *      transform is now the single place FTS query text is built).\n *   4. Join all surviving tokens with a single space — FTS5's implicit MATCH\n *      semantics is AND, so a space-separated token list is already an AND\n *      query. Single-token queries pass through untouched. If every token is\n *      filtered as a stopword, fall back to the boolean-stripped text from\n *      step 1 (not the fully raw input) so a bare-AND/OR/NOT never reaches\n *      FTS5 even in this fallback path.\n */\nimport { segmentCJK } from \"./cjk.js\";\n\n/**\n * Common English/Chinese stopwords, filtered out before the FTS5 MATCH\n * query is built. Ported verbatim from the memory provider's private\n * STOPWORDS list (pre-#933) — the index provider is now the single owner\n * of FTS query transformation, so this list lives here instead.\n */\nconst STOPWORDS = new Set([\n  // English\n  \"a\",\n  \"an\",\n  \"the\",\n  \"is\",\n  \"are\",\n  \"was\",\n  \"were\",\n  \"be\",\n  \"been\",\n  \"am\",\n  \"do\",\n  \"does\",\n  \"did\",\n  \"will\",\n  \"would\",\n  \"could\",\n  \"should\",\n  \"can\",\n  \"may\",\n  \"might\",\n  \"shall\",\n  \"have\",\n  \"has\",\n  \"had\",\n  \"having\",\n  \"i\",\n  \"me\",\n  \"my\",\n  \"we\",\n  \"our\",\n  \"you\",\n  \"your\",\n  \"he\",\n  \"she\",\n  \"it\",\n  \"they\",\n  \"them\",\n  \"its\",\n  \"his\",\n  \"her\",\n  \"their\",\n  \"this\",\n  \"that\",\n  \"these\",\n  \"those\",\n  \"in\",\n  \"on\",\n  \"at\",\n  \"to\",\n  \"for\",\n  \"of\",\n  \"with\",\n  \"by\",\n  \"from\",\n  \"as\",\n  \"into\",\n  \"about\",\n  \"between\",\n  \"through\",\n  \"during\",\n  \"and\",\n  \"or\",\n  \"but\",\n  \"not\",\n  \"if\",\n  \"then\",\n  \"so\",\n  \"than\",\n  \"too\",\n  \"very\",\n  \"just\",\n  \"how\",\n  \"what\",\n  \"when\",\n  \"where\",\n  \"who\",\n  \"which\",\n  \"why\",\n  \"all\",\n  \"each\",\n  \"some\",\n  \"any\",\n  \"no\",\n  \"there\",\n  \"here\",\n  \"up\",\n  \"out\",\n  \"also\",\n  \"tell\",\n  // Chinese single-character particles/function words\n  // (after CJK segmentation, multi-char stopwords become individual chars)\n  \"的\",\n  \"了\",\n  \"在\",\n  \"是\",\n  \"我\",\n  \"有\",\n  \"和\",\n  \"就\",\n  \"不\",\n  \"人\",\n  \"都\",\n  \"一\",\n  \"上\",\n  \"也\",\n  \"很\",\n  \"到\",\n  \"说\",\n  \"要\",\n  \"去\",\n  \"你\",\n  \"会\",\n  \"着\",\n  \"看\",\n  \"好\",\n  \"这\",\n  \"他\",\n  \"她\",\n  \"它\",\n  \"们\",\n  \"么\",\n  \"吗\",\n  \"吧\",\n  \"啊\",\n  \"呢\",\n  \"嗯\",\n  \"哦\",\n  \"那\",\n  \"把\",\n  \"被\",\n  \"让\",\n  \"给\",\n  \"跟\",\n  \"用\",\n  \"帮\",\n  \"请\",\n  \"下\",\n  \"能\",\n  \"哪\",\n  \"什\",\n  \"怎\",\n  \"为\",\n  \"还\",\n  \"或\",\n  \"但\",\n  \"然\",\n  \"所\",\n  \"因\",\n  \"如\",\n  \"虽\",\n  \"只\",\n  \"已\",\n  \"正\",\n  // Multi-char CJK stopwords (still useful before segmentation in some paths)\n  \"一个\",\n  \"没有\",\n  \"自己\",\n  \"什么\",\n  \"可以\",\n  \"怎么\",\n  \"怎样\",\n  \"如何\",\n  \"哪个\",\n  \"哪些\",\n  \"为什么\",\n  \"什么时候\",\n  \"多少\",\n  \"关于\",\n  \"还是\",\n  \"或者\",\n  \"以及\",\n  \"但是\",\n  \"然后\",\n  \"所以\",\n  \"因为\",\n  \"如果\",\n  \"虽然\",\n  \"只是\",\n  \"已经\",\n  \"正在\",\n  \"一下\",\n  \"回忆\",\n]);\n\n/**\n * Transform a natural-language query into a safe FTS5 MATCH expression.\n *\n * - Strips isolated AND/OR/NOT keywords (they cause D1 syntax errors at\n *   phrase boundaries, e.g. trailing \"空调 AND\").\n * - Applies CJK character-level segmentation symmetric with the write side.\n * - Filters common stopwords (no retrieval signal, only narrows AND recall).\n * - Joins remaining tokens using the specified mode:\n *   - \"and\" (default): space-separated — FTS5 implicit AND. Good for precision.\n *   - \"or\": \" OR \"-joined — broadens recall. Use for memory/similarity search.\n *   Single-token queries are returned as-is regardless of mode.\n */\nexport function transformFtsQuery(text: string, mode: \"and\" | \"or\" = \"and\"): string {\n  // Step 1: strip standalone AND / OR / NOT (word-boundary anchored, case-insensitive)\n  const stripped = text\n    .replace(/\\b(AND|OR|NOT)\\b/gi, \" \")\n    .replace(/\\s+/g, \" \")\n    .trim();\n  if (!stripped) return \"\";\n\n  // Step 2: CJK segmentation (symmetric with write-side segmentCJK in backends)\n  const segmented = segmentCJK(stripped);\n\n  // Step 3: tokenise, lowercase, drop stopwords\n  const tokens = segmented\n    .toLowerCase()\n    .split(/[\\s,;.!?，。！？；：、]+/)\n    .filter((t) => t.length > 0 && !STOPWORDS.has(t));\n\n  // Every token was a stopword (e.g. \"the is a an\") — fall back to the\n  // boolean-stripped text rather than silently emptying the query. Mirrors\n  // the prior memory `toFtsOrQuery` fallback (`return text`), but returns\n  // the step-1 output (not the fully raw input) so a bare AND/OR/NOT can't\n  // slip back in through this path.\n  if (tokens.length === 0) return stripped;\n\n  // Step 4: single token passes through; otherwise join per mode\n  if (tokens.length === 1) return tokens[0]!;\n  return mode === \"or\" ? tokens.join(\" OR \") : tokens.join(\" \");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,MAAM,YAAY,IAAI,IAAI;CAExB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAGA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;;;;;;;;AAcF,SAAgB,kBAAkB,MAAc,OAAqB,OAAe;CAElF,MAAM,WAAW,KACd,QAAQ,sBAAsB,IAAI,CAClC,QAAQ,QAAQ,IAAI,CACpB,MAAM;AACT,KAAI,CAAC,SAAU,QAAO;CAMtB,MAAM,SAHY,WAAW,SAAS,CAInC,aAAa,CACb,MAAM,oBAAoB,CAC1B,QAAQ,MAAM,EAAE,SAAS,KAAK,CAAC,UAAU,IAAI,EAAE,CAAC;AAOnD,KAAI,OAAO,WAAW,EAAG,QAAO;AAGhC,KAAI,OAAO,WAAW,EAAG,QAAO,OAAO;AACvC,QAAO,SAAS,OAAO,OAAO,KAAK,OAAO,GAAG,OAAO,KAAK,IAAI"}

package/dist/text/host.cjs

@@ -0,0 +1,39 @@
+
+//#region src/text/host.ts
+/**
+* Host normalization — the single source of truth for turning a raw hostname
+* into a canonical anchor/FTS token, shared by BOTH sides of the index so the
+* same host always collapses to the same key:
+*
+*   - write side: `host()` extraction (extraction/field-map.ts) + FTS summary
+*   - query side: anchor key generation (keys/normalized.ts, `stripWwwPrefix`)
+*
+* Without a shared normalizer the `www.` prefix drifts between write and query
+* (issue #1249): `site: host($.url)` indexes `www.example.com` while a `site:`
+* query for `example.com` never matches — two distinct `idx_anchor_key` rows.
+*
+* Scope (issue #1249): strip a single leading `www.` label only. Numbered
+* variants (`www2.`) and other host aliases are intentionally NOT stripped —
+* they usually address distinct hosts, so collapsing them would over-match.
+*/
+/** Leading `www.` label stripped so `www.example.com` ≡ `example.com`. */
+const WWW_PREFIX_RE = /^www\./;
+/**
+* Strip a leading `www.` prefix from an already-lowercased host string.
+* Case-preserving otherwise — callers that need lowercasing use
+* {@link normalizeHost} instead.
+*/
+function stripWwwPrefix(host) {
+	return host.replace(WWW_PREFIX_RE, "");
+}
+/**
+* Canonicalize a hostname: trim, lowercase, then strip a leading `www.`.
+* `WWW.Example.com`, `www.example.com`, and `example.com` all → `example.com`.
+*/
+function normalizeHost(host) {
+	return stripWwwPrefix(host.trim().toLowerCase());
+}
+
+//#endregion
+exports.normalizeHost = normalizeHost;
+exports.stripWwwPrefix = stripWwwPrefix;

package/dist/text/host.mjs

@@ -0,0 +1,38 @@
+//#region src/text/host.ts
+/**
+* Host normalization — the single source of truth for turning a raw hostname
+* into a canonical anchor/FTS token, shared by BOTH sides of the index so the
+* same host always collapses to the same key:
+*
+*   - write side: `host()` extraction (extraction/field-map.ts) + FTS summary
+*   - query side: anchor key generation (keys/normalized.ts, `stripWwwPrefix`)
+*
+* Without a shared normalizer the `www.` prefix drifts between write and query
+* (issue #1249): `site: host($.url)` indexes `www.example.com` while a `site:`
+* query for `example.com` never matches — two distinct `idx_anchor_key` rows.
+*
+* Scope (issue #1249): strip a single leading `www.` label only. Numbered
+* variants (`www2.`) and other host aliases are intentionally NOT stripped —
+* they usually address distinct hosts, so collapsing them would over-match.
+*/
+/** Leading `www.` label stripped so `www.example.com` ≡ `example.com`. */
+const WWW_PREFIX_RE = /^www\./;
+/**
+* Strip a leading `www.` prefix from an already-lowercased host string.
+* Case-preserving otherwise — callers that need lowercasing use
+* {@link normalizeHost} instead.
+*/
+function stripWwwPrefix(host) {
+	return host.replace(WWW_PREFIX_RE, "");
+}
+/**
+* Canonicalize a hostname: trim, lowercase, then strip a leading `www.`.
+* `WWW.Example.com`, `www.example.com`, and `example.com` all → `example.com`.
+*/
+function normalizeHost(host) {
+	return stripWwwPrefix(host.trim().toLowerCase());
+}
+
+//#endregion
+export { normalizeHost, stripWwwPrefix };
+//# sourceMappingURL=host.mjs.map

package/dist/text/host.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.mjs","names":[],"sources":["../../src/text/host.ts"],"sourcesContent":["/**\n * Host normalization — the single source of truth for turning a raw hostname\n * into a canonical anchor/FTS token, shared by BOTH sides of the index so the\n * same host always collapses to the same key:\n *\n *   - write side: `host()` extraction (extraction/field-map.ts) + FTS summary\n *   - query side: anchor key generation (keys/normalized.ts, `stripWwwPrefix`)\n *\n * Without a shared normalizer the `www.` prefix drifts between write and query\n * (issue #1249): `site: host($.url)` indexes `www.example.com` while a `site:`\n * query for `example.com` never matches — two distinct `idx_anchor_key` rows.\n *\n * Scope (issue #1249): strip a single leading `www.` label only. Numbered\n * variants (`www2.`) and other host aliases are intentionally NOT stripped —\n * they usually address distinct hosts, so collapsing them would over-match.\n */\n\n/** Leading `www.` label stripped so `www.example.com` ≡ `example.com`. */\nconst WWW_PREFIX_RE = /^www\\./;\n\n/**\n * Strip a leading `www.` prefix from an already-lowercased host string.\n * Case-preserving otherwise — callers that need lowercasing use\n * {@link normalizeHost} instead.\n */\nexport function stripWwwPrefix(host: string): string {\n  return host.replace(WWW_PREFIX_RE, \"\");\n}\n\n/**\n * Canonicalize a hostname: trim, lowercase, then strip a leading `www.`.\n * `WWW.Example.com`, `www.example.com`, and `example.com` all → `example.com`.\n */\nexport function normalizeHost(host: string): string {\n  return stripWwwPrefix(host.trim().toLowerCase());\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,MAAM,gBAAgB;;;;;;AAOtB,SAAgB,eAAe,MAAsB;AACnD,QAAO,KAAK,QAAQ,eAAe,GAAG;;;;;;AAOxC,SAAgB,cAAc,MAAsB;AAClD,QAAO,eAAe,KAAK,MAAM,CAAC,aAAa,CAAC"}

package/dist/types.cjs

@@ -0,0 +1,44 @@
+
+//#region src/types.ts
+/**
+* Query recall strategy for `.actions/query` / `QueryEngine.query`. Per-mode
+* semantics live in `query/engine.ts`:
+* - "anchor"   — pure anchor-based query
+* - "fts"      — pure full-text search
+* - "combined" — RRF fusion of anchor + FTS ranked lists
+* - "semantic" — RRF fusion + embedding fallback
+*
+* `SEARCH_MODES` is the single source of truth — the `.actions/query` zod enum,
+* `QueryInput.mode`, and the `AFS_INDEX_SEARCH_MODE` env coercion all derive
+* from it, so a new mode is added in exactly one place.
+*/
+const SEARCH_MODES = [
+	"anchor",
+	"fts",
+	"combined",
+	"semantic"
+];
+/**
+* Default query mode when a caller doesn't pass `mode` and the deployment
+* didn't configure `AFSIndexOptions.defaultSearchMode`. Kept at the historical
+* `.actions/query` default so an unconfigured deployment is byte-identical.
+*/
+const DEFAULT_SEARCH_MODE = "combined";
+/**
+* Coerce an untrusted string (typically the `AFS_INDEX_SEARCH_MODE` env var)
+* into a `SearchMode`. Source-agnostic — receives an already-read string and
+* never touches `process.env`/`env`, so it behaves identically in Cloudflare
+* Workers and Node (same discipline as `parseBool` from `@aigne/afs/utils/env`).
+* lower-case + trim + allow-list; anything unrecognized (including
+* `undefined`/empty) falls back to `DEFAULT_SEARCH_MODE` and never throws —
+* mirrors the CF `resolveVectorIndexBackend` shape for `AFS_INDEX_VECTOR_BACKEND`.
+*/
+function coerceSearchMode(value) {
+	const v = value?.toLowerCase().trim();
+	return SEARCH_MODES.includes(v ?? "") ? v : DEFAULT_SEARCH_MODE;
+}
+
+//#endregion
+exports.DEFAULT_SEARCH_MODE = DEFAULT_SEARCH_MODE;
+exports.SEARCH_MODES = SEARCH_MODES;
+exports.coerceSearchMode = coerceSearchMode;