@warlock.js/core 4.8.0 → 4.8.1

package/esm/ai/src/rag/chunk/fixed.mjs

@@ -1,32 +0,0 @@
-//#region ../@warlock.js/ai/src/rag/chunk/fixed.ts
-/**
-* Fixed-window character splitter.
-*
-* The simplest strategy: slices the text into back-to-back windows of
-* `size` characters, stepping forward by `size - overlap` so adjacent
-* windows share `overlap` characters. Boundary-unaware — it will cut
-* mid-word — but deterministic and dep-free. Spans are exact by
-* construction.
-*/
-function fixedChunk(text, size, overlap) {
-	if (text.length === 0) return [];
-	const step = Math.max(1, size - overlap);
-	const chunks = [];
-	let index = 0;
-	for (let cursor = 0; cursor < text.length; cursor += step) {
-		const start = cursor;
-		const end = Math.min(cursor + size, text.length);
-		chunks.push({
-			text: text.slice(start, end),
-			index,
-			span: [start, end]
-		});
-		index += 1;
-		if (end >= text.length) break;
-	}
-	return chunks;
-}
-
-//#endregion
-export { fixedChunk };
-//# sourceMappingURL=fixed.mjs.map

package/esm/ai/src/rag/chunk/fixed.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"fixed.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/rag/chunk/fixed.ts"],"sourcesContent":["import type { Chunk } from \"../contracts/chunk-options.type\";\n\n/**\n * Fixed-window character splitter.\n *\n * The simplest strategy: slices the text into back-to-back windows of\n * `size` characters, stepping forward by `size - overlap` so adjacent\n * windows share `overlap` characters. Boundary-unaware — it will cut\n * mid-word — but deterministic and dep-free. Spans are exact by\n * construction.\n */\nexport function fixedChunk(text: string, size: number, overlap: number): Chunk[] {\n  if (text.length === 0) {\n    return [];\n  }\n\n  const step = Math.max(1, size - overlap);\n  const chunks: Chunk[] = [];\n  let index = 0;\n\n  for (let cursor = 0; cursor < text.length; cursor += step) {\n    const start = cursor;\n    const end = Math.min(cursor + size, text.length);\n\n    chunks.push({ text: text.slice(start, end), index, span: [start, end] });\n    index += 1;\n\n    if (end >= text.length) {\n      break;\n    }\n  }\n\n  return chunks;\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,WAAW,MAAc,MAAc,SAA0B;CAC/E,IAAI,KAAK,WAAW,GAClB,OAAO,CAAC;CAGV,MAAM,OAAO,KAAK,IAAI,GAAG,OAAO,OAAO;CACvC,MAAM,SAAkB,CAAC;CACzB,IAAI,QAAQ;CAEZ,KAAK,IAAI,SAAS,GAAG,SAAS,KAAK,QAAQ,UAAU,MAAM;EACzD,MAAM,QAAQ;EACd,MAAM,MAAM,KAAK,IAAI,SAAS,MAAM,KAAK,MAAM;EAE/C,OAAO,KAAK;GAAE,MAAM,KAAK,MAAM,OAAO,GAAG;GAAG;GAAO,MAAM,CAAC,OAAO,GAAG;EAAE,CAAC;EACvE,SAAS;EAET,IAAI,OAAO,KAAK,QACd;CAEJ;CAEA,OAAO;AACT"}

package/esm/ai/src/rag/chunk/markdown.mjs

@@ -1,75 +0,0 @@
-import { DEFAULT_SEPARATORS, recursiveChunk } from "./recursive.mjs";
-
-//#region ../@warlock.js/ai/src/rag/chunk/markdown.ts
-/** Matches an ATX Markdown heading line (`#` … `######`) at line start. */
-const HEADING_LINE = /^#{1,6}[ \t].*$/gm;
-/**
-* Markdown heading/section-aware splitter.
-*
-* Splits the document on ATX heading boundaries (`#`…`######`) first so a
-* section's heading stays glued to its body, then applies the recursive
-* character splitter WITHIN each section so any section larger than `size`
-* is broken down further. Sections at or under `size` are emitted whole.
-* Spans are exact relative to the original document.
-*/
-function markdownChunk(text, size, overlap, separators = DEFAULT_SEPARATORS) {
-	if (text.length === 0) return [];
-	const sections = splitSections(text);
-	const chunks = [];
-	let index = 0;
-	for (const section of sections) {
-		const body = text.slice(section.start, section.end);
-		if (body.trim().length === 0) continue;
-		if (body.length <= size) {
-			chunks.push({
-				text: body,
-				index,
-				span: [section.start, section.end]
-			});
-			index += 1;
-			continue;
-		}
-		const inner = recursiveChunk(body, size, overlap, separators);
-		for (const piece of inner) {
-			chunks.push({
-				text: piece.text,
-				index,
-				span: [section.start + piece.span[0], section.start + piece.span[1]]
-			});
-			index += 1;
-		}
-	}
-	return chunks;
-}
-/**
-* Carve the document into sections, each beginning at a heading line and
-* running until the next heading (the preamble before the first heading is
-* its own section). Spans cover the whole document with no gaps.
-*/
-function splitSections(text) {
-	const starts = [];
-	let match;
-	HEADING_LINE.lastIndex = 0;
-	while ((match = HEADING_LINE.exec(text)) !== null) starts.push(match.index);
-	if (starts.length === 0) return [{
-		start: 0,
-		end: text.length
-	}];
-	const sections = [];
-	if (starts[0] > 0) sections.push({
-		start: 0,
-		end: starts[0]
-	});
-	starts.forEach((start, position) => {
-		const end = position + 1 < starts.length ? starts[position + 1] : text.length;
-		sections.push({
-			start,
-			end
-		});
-	});
-	return sections;
-}
-
-//#endregion
-export { markdownChunk };
-//# sourceMappingURL=markdown.mjs.map

package/esm/ai/src/rag/chunk/markdown.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/rag/chunk/markdown.ts"],"sourcesContent":["import type { Chunk } from \"../contracts/chunk-options.type\";\nimport { DEFAULT_SEPARATORS, recursiveChunk } from \"./recursive\";\n\n/** Matches an ATX Markdown heading line (`#` … `######`) at line start. */\nconst HEADING_LINE = /^#{1,6}[ \\t].*$/gm;\n\n/**\n * Markdown heading/section-aware splitter.\n *\n * Splits the document on ATX heading boundaries (`#`…`######`) first so a\n * section's heading stays glued to its body, then applies the recursive\n * character splitter WITHIN each section so any section larger than `size`\n * is broken down further. Sections at or under `size` are emitted whole.\n * Spans are exact relative to the original document.\n */\nexport function markdownChunk(\n  text: string,\n  size: number,\n  overlap: number,\n  separators: string[] = DEFAULT_SEPARATORS,\n): Chunk[] {\n  if (text.length === 0) {\n    return [];\n  }\n\n  const sections = splitSections(text);\n  const chunks: Chunk[] = [];\n  let index = 0;\n\n  for (const section of sections) {\n    const body = text.slice(section.start, section.end);\n\n    if (body.trim().length === 0) {\n      continue;\n    }\n\n    if (body.length <= size) {\n      chunks.push({\n        text: body,\n        index,\n        span: [section.start, section.end],\n      });\n      index += 1;\n\n      continue;\n    }\n\n    // Recurse within the section, then shift the relative spans to\n    // absolute document offsets and renumber sequentially.\n    const inner = recursiveChunk(body, size, overlap, separators);\n\n    for (const piece of inner) {\n      chunks.push({\n        text: piece.text,\n        index,\n        span: [section.start + piece.span[0], section.start + piece.span[1]],\n      });\n      index += 1;\n    }\n  }\n\n  return chunks;\n}\n\n/** A section's absolute `[start, end)` span (heading line + body until next heading). */\ntype SectionSpan = {\n  start: number;\n  end: number;\n};\n\n/**\n * Carve the document into sections, each beginning at a heading line and\n * running until the next heading (the preamble before the first heading is\n * its own section). Spans cover the whole document with no gaps.\n */\nfunction splitSections(text: string): SectionSpan[] {\n  const starts: number[] = [];\n  let match: RegExpExecArray | null;\n\n  HEADING_LINE.lastIndex = 0;\n\n  while ((match = HEADING_LINE.exec(text)) !== null) {\n    starts.push(match.index);\n  }\n\n  // No headings at all — the whole document is one section.\n  if (starts.length === 0) {\n    return [{ start: 0, end: text.length }];\n  }\n\n  const sections: SectionSpan[] = [];\n\n  // Preamble before the first heading, if any.\n  if (starts[0] > 0) {\n    sections.push({ start: 0, end: starts[0] });\n  }\n\n  starts.forEach((start, position) => {\n    const end = position + 1 < starts.length ? starts[position + 1] : text.length;\n\n    sections.push({ start, end });\n  });\n\n  return sections;\n}\n"],"mappings":";;;;AAIA,MAAM,eAAe;;;;;;;;;;AAWrB,SAAgB,cACd,MACA,MACA,SACA,aAAuB,oBACd;CACT,IAAI,KAAK,WAAW,GAClB,OAAO,CAAC;CAGV,MAAM,WAAW,cAAc,IAAI;CACnC,MAAM,SAAkB,CAAC;CACzB,IAAI,QAAQ;CAEZ,KAAK,MAAM,WAAW,UAAU;EAC9B,MAAM,OAAO,KAAK,MAAM,QAAQ,OAAO,QAAQ,GAAG;EAElD,IAAI,KAAK,KAAK,CAAC,CAAC,WAAW,GACzB;EAGF,IAAI,KAAK,UAAU,MAAM;GACvB,OAAO,KAAK;IACV,MAAM;IACN;IACA,MAAM,CAAC,QAAQ,OAAO,QAAQ,GAAG;GACnC,CAAC;GACD,SAAS;GAET;EACF;EAIA,MAAM,QAAQ,eAAe,MAAM,MAAM,SAAS,UAAU;EAE5D,KAAK,MAAM,SAAS,OAAO;GACzB,OAAO,KAAK;IACV,MAAM,MAAM;IACZ;IACA,MAAM,CAAC,QAAQ,QAAQ,MAAM,KAAK,IAAI,QAAQ,QAAQ,MAAM,KAAK,EAAE;GACrE,CAAC;GACD,SAAS;EACX;CACF;CAEA,OAAO;AACT;;;;;;AAaA,SAAS,cAAc,MAA6B;CAClD,MAAM,SAAmB,CAAC;CAC1B,IAAI;CAEJ,aAAa,YAAY;CAEzB,QAAQ,QAAQ,aAAa,KAAK,IAAI,OAAO,MAC3C,OAAO,KAAK,MAAM,KAAK;CAIzB,IAAI,OAAO,WAAW,GACpB,OAAO,CAAC;EAAE,OAAO;EAAG,KAAK,KAAK;CAAO,CAAC;CAGxC,MAAM,WAA0B,CAAC;CAGjC,IAAI,OAAO,KAAK,GACd,SAAS,KAAK;EAAE,OAAO;EAAG,KAAK,OAAO;CAAG,CAAC;CAG5C,OAAO,SAAS,OAAO,aAAa;EAClC,MAAM,MAAM,WAAW,IAAI,OAAO,SAAS,OAAO,WAAW,KAAK,KAAK;EAEvE,SAAS,KAAK;GAAE;GAAO;EAAI,CAAC;CAC9B,CAAC;CAED,OAAO;AACT"}

package/esm/ai/src/rag/chunk/recursive.mjs

@@ -1,132 +0,0 @@
-//#region ../@warlock.js/ai/src/rag/chunk/recursive.ts
-/** Default separators for the recursive splitter, tried largest-unit first. */
-const DEFAULT_SEPARATORS = [
-	"\n\n",
-	"\n",
-	". ",
-	" ",
-	""
-];
-/**
-* Recursive character splitter (the default strategy).
-*
-* Walks `separators` largest-unit-first: it splits the text on the first
-* separator, then packs the resulting pieces into chunks up to `size`
-* characters, carrying `overlap` characters forward between adjacent
-* chunks. Any single piece that is itself larger than `size` is split
-* again on the next-finer separator, recursing until a piece fits (the
-* `""` separator is the final char-by-char fallback).
-*
-* Every emitted chunk records its exact `[start, end)` character span in
-* the ORIGINAL text so a citation can point back precisely — spans are
-* tracked by index-of search as packed pieces are joined.
-*
-* Character-based and deliberately tokenizer-free.
-*/
-function recursiveChunk(text, size, overlap, separators = DEFAULT_SEPARATORS) {
-	return packPieces(text, anchorPieces(text, splitToPieces(text, size, separators)), size, overlap);
-}
-/**
-* Recursively split `text` into pieces no larger than `size` using the
-* ordered separator list. Pieces preserve original characters (no
-* trimming) so downstream span anchoring stays exact.
-*/
-function splitToPieces(text, size, separators) {
-	if (text.length <= size) return text.length > 0 ? [text] : [];
-	const [separator, ...rest] = separators;
-	if (separator === void 0 || separator === "") return hardSplit(text, size);
-	const segments = splitKeepingSeparator(text, separator);
-	const pieces = [];
-	for (const segment of segments) {
-		if (segment.length === 0) continue;
-		if (segment.length <= size) {
-			pieces.push(segment);
-			continue;
-		}
-		pieces.push(...splitToPieces(segment, size, rest));
-	}
-	return pieces;
-}
-/**
-* Split on `separator` but re-attach the separator to the end of each
-* preceding segment, so concatenating the segments reconstructs the
-* original text verbatim (keeping spans exact).
-*/
-function splitKeepingSeparator(text, separator) {
-	const raw = text.split(separator);
-	const segments = [];
-	raw.forEach((part, position) => {
-		const isLast = position === raw.length - 1;
-		segments.push(isLast ? part : part + separator);
-	});
-	return segments;
-}
-/** Hard char-window split for a unit larger than `size` with no usable separator. */
-function hardSplit(text, size) {
-	const pieces = [];
-	for (let cursor = 0; cursor < text.length; cursor += size) pieces.push(text.slice(cursor, cursor + size));
-	return pieces;
-}
-/**
-* Map each piece back to its absolute offset using a monotonic cursor —
-* pieces are emitted in document order, so the next occurrence at-or-after
-* the cursor is the correct one even for repeated substrings.
-*/
-function anchorPieces(text, pieces) {
-	const anchored = [];
-	let cursor = 0;
-	for (const piece of pieces) {
-		const start = text.indexOf(piece, cursor);
-		const resolvedStart = start === -1 ? cursor : start;
-		const end = resolvedStart + piece.length;
-		anchored.push({
-			text: piece,
-			start: resolvedStart,
-			end
-		});
-		cursor = end;
-	}
-	return anchored;
-}
-/**
-* Greedily pack anchored pieces into chunks up to `size` characters, then
-* carry `overlap` trailing characters from each emitted chunk into the
-* next so context is not lost at a boundary. Spans are taken straight
-* from the anchored pieces, so the overlap text is part of the next
-* chunk's span exactly.
-*/
-function packPieces(text, pieces, size, overlap) {
-	const chunks = [];
-	let bufferStart = -1;
-	let bufferEnd = -1;
-	let index = 0;
-	const flush = () => {
-		if (bufferStart === -1) return;
-		chunks.push({
-			text: text.slice(bufferStart, bufferEnd),
-			index,
-			span: [bufferStart, bufferEnd]
-		});
-		index += 1;
-	};
-	for (const piece of pieces) {
-		if (bufferStart === -1) {
-			bufferStart = piece.start;
-			bufferEnd = piece.end;
-			continue;
-		}
-		if (piece.end - bufferStart <= size) {
-			bufferEnd = piece.end;
-			continue;
-		}
-		flush();
-		bufferStart = overlap > 0 ? Math.max(bufferStart, piece.start - overlap) : piece.start;
-		bufferEnd = piece.end;
-	}
-	flush();
-	return chunks;
-}
-
-//#endregion
-export { DEFAULT_SEPARATORS, recursiveChunk };
-//# sourceMappingURL=recursive.mjs.map

package/esm/ai/src/rag/chunk/recursive.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"recursive.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/rag/chunk/recursive.ts"],"sourcesContent":["import type { Chunk } from \"../contracts/chunk-options.type\";\n\n/** Default separators for the recursive splitter, tried largest-unit first. */\nexport const DEFAULT_SEPARATORS: string[] = [\"\\n\\n\", \"\\n\", \". \", \" \", \"\"];\n\n/**\n * Recursive character splitter (the default strategy).\n *\n * Walks `separators` largest-unit-first: it splits the text on the first\n * separator, then packs the resulting pieces into chunks up to `size`\n * characters, carrying `overlap` characters forward between adjacent\n * chunks. Any single piece that is itself larger than `size` is split\n * again on the next-finer separator, recursing until a piece fits (the\n * `\"\"` separator is the final char-by-char fallback).\n *\n * Every emitted chunk records its exact `[start, end)` character span in\n * the ORIGINAL text so a citation can point back precisely — spans are\n * tracked by index-of search as packed pieces are joined.\n *\n * Character-based and deliberately tokenizer-free.\n */\nexport function recursiveChunk(\n  text: string,\n  size: number,\n  overlap: number,\n  separators: string[] = DEFAULT_SEPARATORS,\n): Chunk[] {\n  const pieces = splitToPieces(text, size, separators);\n\n  // Re-anchor each packed piece to its absolute offset in `text`. Pieces\n  // are non-overlapping and in document order, so a forward cursor finds\n  // each one's true start even when the same substring repeats.\n  const spans = anchorPieces(text, pieces);\n\n  return packPieces(text, spans, size, overlap);\n}\n\n/**\n * Recursively split `text` into pieces no larger than `size` using the\n * ordered separator list. Pieces preserve original characters (no\n * trimming) so downstream span anchoring stays exact.\n */\nfunction splitToPieces(text: string, size: number, separators: string[]): string[] {\n  if (text.length <= size) {\n    return text.length > 0 ? [text] : [];\n  }\n\n  const [separator, ...rest] = separators;\n\n  // Exhausted every separator (or hit the char fallback) — hard-split by\n  // size so an oversize unit never blows the budget.\n  if (separator === undefined || separator === \"\") {\n    return hardSplit(text, size);\n  }\n\n  const segments = splitKeepingSeparator(text, separator);\n  const pieces: string[] = [];\n\n  for (const segment of segments) {\n    if (segment.length === 0) {\n      continue;\n    }\n\n    if (segment.length <= size) {\n      pieces.push(segment);\n\n      continue;\n    }\n\n    pieces.push(...splitToPieces(segment, size, rest));\n  }\n\n  return pieces;\n}\n\n/**\n * Split on `separator` but re-attach the separator to the end of each\n * preceding segment, so concatenating the segments reconstructs the\n * original text verbatim (keeping spans exact).\n */\nfunction splitKeepingSeparator(text: string, separator: string): string[] {\n  const raw = text.split(separator);\n  const segments: string[] = [];\n\n  raw.forEach((part, position) => {\n    const isLast = position === raw.length - 1;\n\n    segments.push(isLast ? part : part + separator);\n  });\n\n  return segments;\n}\n\n/** Hard char-window split for a unit larger than `size` with no usable separator. */\nfunction hardSplit(text: string, size: number): string[] {\n  const pieces: string[] = [];\n\n  for (let cursor = 0; cursor < text.length; cursor += size) {\n    pieces.push(text.slice(cursor, cursor + size));\n  }\n\n  return pieces;\n}\n\n/** A piece plus its absolute `[start, end)` span in the original text. */\ntype AnchoredPiece = {\n  text: string;\n  start: number;\n  end: number;\n};\n\n/**\n * Map each piece back to its absolute offset using a monotonic cursor —\n * pieces are emitted in document order, so the next occurrence at-or-after\n * the cursor is the correct one even for repeated substrings.\n */\nfunction anchorPieces(text: string, pieces: string[]): AnchoredPiece[] {\n  const anchored: AnchoredPiece[] = [];\n  let cursor = 0;\n\n  for (const piece of pieces) {\n    const start = text.indexOf(piece, cursor);\n    const resolvedStart = start === -1 ? cursor : start;\n    const end = resolvedStart + piece.length;\n\n    anchored.push({ text: piece, start: resolvedStart, end });\n    cursor = end;\n  }\n\n  return anchored;\n}\n\n/**\n * Greedily pack anchored pieces into chunks up to `size` characters, then\n * carry `overlap` trailing characters from each emitted chunk into the\n * next so context is not lost at a boundary. Spans are taken straight\n * from the anchored pieces, so the overlap text is part of the next\n * chunk's span exactly.\n */\nfunction packPieces(\n  text: string,\n  pieces: AnchoredPiece[],\n  size: number,\n  overlap: number,\n): Chunk[] {\n  const chunks: Chunk[] = [];\n\n  let bufferStart = -1;\n  let bufferEnd = -1;\n  let index = 0;\n\n  const flush = (): void => {\n    if (bufferStart === -1) {\n      return;\n    }\n\n    chunks.push({\n      text: text.slice(bufferStart, bufferEnd),\n      index,\n      span: [bufferStart, bufferEnd],\n    });\n    index += 1;\n  };\n\n  for (const piece of pieces) {\n    if (bufferStart === -1) {\n      bufferStart = piece.start;\n      bufferEnd = piece.end;\n\n      continue;\n    }\n\n    const projected = piece.end - bufferStart;\n\n    if (projected <= size) {\n      bufferEnd = piece.end;\n\n      continue;\n    }\n\n    flush();\n\n    // Start the next buffer `overlap` chars before this piece (clamped to\n    // the previous chunk's start) so adjacent chunks share context.\n    const overlapStart = overlap > 0 ? Math.max(bufferStart, piece.start - overlap) : piece.start;\n\n    bufferStart = overlapStart;\n    bufferEnd = piece.end;\n  }\n\n  flush();\n\n  return chunks;\n}\n"],"mappings":";;AAGA,MAAa,qBAA+B;CAAC;CAAQ;CAAM;CAAM;CAAK;AAAE;;;;;;;;;;;;;;;;;AAkBxE,SAAgB,eACd,MACA,MACA,SACA,aAAuB,oBACd;CAQT,OAAO,WAAW,MAFJ,aAAa,MALZ,cAAc,MAAM,MAAM,UAKH,CAEV,GAAG,MAAM,OAAO;AAC9C;;;;;;AAOA,SAAS,cAAc,MAAc,MAAc,YAAgC;CACjF,IAAI,KAAK,UAAU,MACjB,OAAO,KAAK,SAAS,IAAI,CAAC,IAAI,IAAI,CAAC;CAGrC,MAAM,CAAC,WAAW,GAAG,QAAQ;CAI7B,IAAI,cAAc,UAAa,cAAc,IAC3C,OAAO,UAAU,MAAM,IAAI;CAG7B,MAAM,WAAW,sBAAsB,MAAM,SAAS;CACtD,MAAM,SAAmB,CAAC;CAE1B,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,QAAQ,WAAW,GACrB;EAGF,IAAI,QAAQ,UAAU,MAAM;GAC1B,OAAO,KAAK,OAAO;GAEnB;EACF;EAEA,OAAO,KAAK,GAAG,cAAc,SAAS,MAAM,IAAI,CAAC;CACnD;CAEA,OAAO;AACT;;;;;;AAOA,SAAS,sBAAsB,MAAc,WAA6B;CACxE,MAAM,MAAM,KAAK,MAAM,SAAS;CAChC,MAAM,WAAqB,CAAC;CAE5B,IAAI,SAAS,MAAM,aAAa;EAC9B,MAAM,SAAS,aAAa,IAAI,SAAS;EAEzC,SAAS,KAAK,SAAS,OAAO,OAAO,SAAS;CAChD,CAAC;CAED,OAAO;AACT;;AAGA,SAAS,UAAU,MAAc,MAAwB;CACvD,MAAM,SAAmB,CAAC;CAE1B,KAAK,IAAI,SAAS,GAAG,SAAS,KAAK,QAAQ,UAAU,MACnD,OAAO,KAAK,KAAK,MAAM,QAAQ,SAAS,IAAI,CAAC;CAG/C,OAAO;AACT;;;;;;AAcA,SAAS,aAAa,MAAc,QAAmC;CACrE,MAAM,WAA4B,CAAC;CACnC,IAAI,SAAS;CAEb,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,QAAQ,KAAK,QAAQ,OAAO,MAAM;EACxC,MAAM,gBAAgB,UAAU,KAAK,SAAS;EAC9C,MAAM,MAAM,gBAAgB,MAAM;EAElC,SAAS,KAAK;GAAE,MAAM;GAAO,OAAO;GAAe;EAAI,CAAC;EACxD,SAAS;CACX;CAEA,OAAO;AACT;;;;;;;;AASA,SAAS,WACP,MACA,QACA,MACA,SACS;CACT,MAAM,SAAkB,CAAC;CAEzB,IAAI,cAAc;CAClB,IAAI,YAAY;CAChB,IAAI,QAAQ;CAEZ,MAAM,cAAoB;EACxB,IAAI,gBAAgB,IAClB;EAGF,OAAO,KAAK;GACV,MAAM,KAAK,MAAM,aAAa,SAAS;GACvC;GACA,MAAM,CAAC,aAAa,SAAS;EAC/B,CAAC;EACD,SAAS;CACX;CAEA,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,gBAAgB,IAAI;GACtB,cAAc,MAAM;GACpB,YAAY,MAAM;GAElB;EACF;EAIA,IAFkB,MAAM,MAAM,eAEb,MAAM;GACrB,YAAY,MAAM;GAElB;EACF;EAEA,MAAM;EAMN,cAFqB,UAAU,IAAI,KAAK,IAAI,aAAa,MAAM,QAAQ,OAAO,IAAI,MAAM;EAGxF,YAAY,MAAM;CACpB;CAEA,MAAM;CAEN,OAAO;AACT"}

package/esm/ai/src/rag/chunk/sentence.mjs

@@ -1,73 +0,0 @@
-//#region ../@warlock.js/ai/src/rag/chunk/sentence.ts
-/** Matches a sentence terminator (`.`, `!`, `?`) followed by whitespace. */
-const SENTENCE_BOUNDARY = /([.!?])\s+/g;
-/**
-* Sentence-aware character splitter.
-*
-* Splits the text on sentence terminators (`. `, `! `, `? `), keeping the
-* terminator attached, then greedily packs whole sentences into chunks up
-* to `size` characters, carrying `overlap` characters forward between
-* adjacent chunks. A single sentence longer than `size` becomes its own
-* (oversize) chunk rather than being cut mid-sentence. Spans are exact.
-*/
-function sentenceChunk(text, size, overlap) {
-	if (text.trim().length === 0) return [];
-	const sentences = splitSentences(text);
-	const chunks = [];
-	let bufferStart = -1;
-	let bufferEnd = -1;
-	let index = 0;
-	const flush = () => {
-		if (bufferStart === -1) return;
-		chunks.push({
-			text: text.slice(bufferStart, bufferEnd),
-			index,
-			span: [bufferStart, bufferEnd]
-		});
-		index += 1;
-	};
-	for (const sentence of sentences) {
-		if (bufferStart === -1) {
-			bufferStart = sentence.start;
-			bufferEnd = sentence.end;
-			continue;
-		}
-		if (sentence.end - bufferStart <= size) {
-			bufferEnd = sentence.end;
-			continue;
-		}
-		flush();
-		bufferStart = overlap > 0 ? Math.max(bufferStart, sentence.start - overlap) : sentence.start;
-		bufferEnd = sentence.end;
-	}
-	flush();
-	return chunks;
-}
-/**
-* Split `text` into sentence spans on terminator + whitespace, keeping the
-* terminator with its sentence and absorbing the trailing whitespace into
-* the boundary so reconstructing the spans loses no characters.
-*/
-function splitSentences(text) {
-	const spans = [];
-	let start = 0;
-	let match;
-	SENTENCE_BOUNDARY.lastIndex = 0;
-	while ((match = SENTENCE_BOUNDARY.exec(text)) !== null) {
-		const end = match.index + match[0].length;
-		spans.push({
-			start,
-			end
-		});
-		start = end;
-	}
-	if (start < text.length) spans.push({
-		start,
-		end: text.length
-	});
-	return spans;
-}
-
-//#endregion
-export { sentenceChunk };
-//# sourceMappingURL=sentence.mjs.map

package/esm/ai/src/rag/chunk/sentence.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sentence.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/rag/chunk/sentence.ts"],"sourcesContent":["import type { Chunk } from \"../contracts/chunk-options.type\";\n\n/** Matches a sentence terminator (`.`, `!`, `?`) followed by whitespace. */\nconst SENTENCE_BOUNDARY = /([.!?])\\s+/g;\n\n/**\n * Sentence-aware character splitter.\n *\n * Splits the text on sentence terminators (`. `, `! `, `? `), keeping the\n * terminator attached, then greedily packs whole sentences into chunks up\n * to `size` characters, carrying `overlap` characters forward between\n * adjacent chunks. A single sentence longer than `size` becomes its own\n * (oversize) chunk rather than being cut mid-sentence. Spans are exact.\n */\nexport function sentenceChunk(text: string, size: number, overlap: number): Chunk[] {\n  if (text.trim().length === 0) {\n    return [];\n  }\n\n  const sentences = splitSentences(text);\n  const chunks: Chunk[] = [];\n\n  let bufferStart = -1;\n  let bufferEnd = -1;\n  let index = 0;\n\n  const flush = (): void => {\n    if (bufferStart === -1) {\n      return;\n    }\n\n    chunks.push({\n      text: text.slice(bufferStart, bufferEnd),\n      index,\n      span: [bufferStart, bufferEnd],\n    });\n    index += 1;\n  };\n\n  for (const sentence of sentences) {\n    if (bufferStart === -1) {\n      bufferStart = sentence.start;\n      bufferEnd = sentence.end;\n\n      continue;\n    }\n\n    if (sentence.end - bufferStart <= size) {\n      bufferEnd = sentence.end;\n\n      continue;\n    }\n\n    flush();\n\n    const overlapStart =\n      overlap > 0 ? Math.max(bufferStart, sentence.start - overlap) : sentence.start;\n\n    bufferStart = overlapStart;\n    bufferEnd = sentence.end;\n  }\n\n  flush();\n\n  return chunks;\n}\n\n/** A sentence with its absolute `[start, end)` span in the original text. */\ntype SentenceSpan = {\n  start: number;\n  end: number;\n};\n\n/**\n * Split `text` into sentence spans on terminator + whitespace, keeping the\n * terminator with its sentence and absorbing the trailing whitespace into\n * the boundary so reconstructing the spans loses no characters.\n */\nfunction splitSentences(text: string): SentenceSpan[] {\n  const spans: SentenceSpan[] = [];\n  let start = 0;\n  let match: RegExpExecArray | null;\n\n  SENTENCE_BOUNDARY.lastIndex = 0;\n\n  while ((match = SENTENCE_BOUNDARY.exec(text)) !== null) {\n    const end = match.index + match[0].length;\n\n    spans.push({ start, end });\n    start = end;\n  }\n\n  if (start < text.length) {\n    spans.push({ start, end: text.length });\n  }\n\n  return spans;\n}\n"],"mappings":";;AAGA,MAAM,oBAAoB;;;;;;;;;;AAW1B,SAAgB,cAAc,MAAc,MAAc,SAA0B;CAClF,IAAI,KAAK,KAAK,CAAC,CAAC,WAAW,GACzB,OAAO,CAAC;CAGV,MAAM,YAAY,eAAe,IAAI;CACrC,MAAM,SAAkB,CAAC;CAEzB,IAAI,cAAc;CAClB,IAAI,YAAY;CAChB,IAAI,QAAQ;CAEZ,MAAM,cAAoB;EACxB,IAAI,gBAAgB,IAClB;EAGF,OAAO,KAAK;GACV,MAAM,KAAK,MAAM,aAAa,SAAS;GACvC;GACA,MAAM,CAAC,aAAa,SAAS;EAC/B,CAAC;EACD,SAAS;CACX;CAEA,KAAK,MAAM,YAAY,WAAW;EAChC,IAAI,gBAAgB,IAAI;GACtB,cAAc,SAAS;GACvB,YAAY,SAAS;GAErB;EACF;EAEA,IAAI,SAAS,MAAM,eAAe,MAAM;GACtC,YAAY,SAAS;GAErB;EACF;EAEA,MAAM;EAKN,cAFE,UAAU,IAAI,KAAK,IAAI,aAAa,SAAS,QAAQ,OAAO,IAAI,SAAS;EAG3E,YAAY,SAAS;CACvB;CAEA,MAAM;CAEN,OAAO;AACT;;;;;;AAaA,SAAS,eAAe,MAA8B;CACpD,MAAM,QAAwB,CAAC;CAC/B,IAAI,QAAQ;CACZ,IAAI;CAEJ,kBAAkB,YAAY;CAE9B,QAAQ,QAAQ,kBAAkB,KAAK,IAAI,OAAO,MAAM;EACtD,MAAM,MAAM,MAAM,QAAQ,MAAM,EAAE,CAAC;EAEnC,MAAM,KAAK;GAAE;GAAO;EAAI,CAAC;EACzB,QAAQ;CACV;CAEA,IAAI,QAAQ,KAAK,QACf,MAAM,KAAK;EAAE;EAAO,KAAK,KAAK;CAAO,CAAC;CAGxC,OAAO;AACT"}

package/esm/ai/src/rag/hybrid/bm25.mjs

@@ -1,51 +0,0 @@
-//#region ../@warlock.js/ai/src/rag/hybrid/bm25.ts
-const BM25_K1 = 1.5;
-const BM25_B = .75;
-/** Lowercase + split on non-word characters; drop empties. */
-function tokenize(text) {
-	return text.toLowerCase().split(/[^a-z0-9]+/i).filter(Boolean);
-}
-/**
-* Rank `docs` against `query` with BM25 (A4) — the lexical half of hybrid
-* retrieval. Scores keyword overlap with TF saturation (`k1`) and length
-* normalization (`b`) over the candidate set, so an exact-term match
-* surfaces even when dense embeddings miss it. Returns docs sorted by
-* score (highest first); zero-score docs are dropped.
-*
-* Operates over the supplied candidate set (typically the dense retriever's
-* over-fetch), so it needs no global corpus index — ideal for fusing with
-* a vector ranking via {@link reciprocalRankFusion}.
-*/
-function bm25Rank(query, docs) {
-	const queryTerms = [...new Set(tokenize(query))];
-	if (queryTerms.length === 0 || docs.length === 0) return [];
-	const tokenized = docs.map((doc) => ({
-		id: doc.id,
-		terms: tokenize(doc.text)
-	}));
-	const avgLen = tokenized.reduce((sum, d) => sum + d.terms.length, 0) / tokenized.length || 1;
-	const df = /* @__PURE__ */ new Map();
-	for (const term of queryTerms) df.set(term, tokenized.filter((d) => d.terms.includes(term)).length);
-	const n = tokenized.length;
-	return tokenized.map((doc) => {
-		const len = doc.terms.length || 1;
-		let score = 0;
-		for (const term of queryTerms) {
-			const tf = doc.terms.filter((t) => t === term).length;
-			if (tf === 0) continue;
-			const docFreq = df.get(term) ?? 0;
-			const idf = Math.log(1 + (n - docFreq + .5) / (docFreq + .5));
-			const numerator = tf * 2.5;
-			const denominator = tf + BM25_K1 * (1 - BM25_B + BM25_B * (len / avgLen));
-			score += idf * (numerator / denominator);
-		}
-		return {
-			id: doc.id,
-			score
-		};
-	}).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
-}
-
-//#endregion
-export { bm25Rank };
-//# sourceMappingURL=bm25.mjs.map

package/esm/ai/src/rag/hybrid/bm25.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"bm25.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/rag/hybrid/bm25.ts"],"sourcesContent":["import type { RankedItem } from \"./rrf\";\n\n/** A document to score lexically. */\nexport type LexicalDoc = { id: string; text: string };\n\nconst BM25_K1 = 1.5;\nconst BM25_B = 0.75;\n\n/** Lowercase + split on non-word characters; drop empties. */\nfunction tokenize(text: string): string[] {\n  return text\n    .toLowerCase()\n    .split(/[^a-z0-9]+/i)\n    .filter(Boolean);\n}\n\n/**\n * Rank `docs` against `query` with BM25 (A4) — the lexical half of hybrid\n * retrieval. Scores keyword overlap with TF saturation (`k1`) and length\n * normalization (`b`) over the candidate set, so an exact-term match\n * surfaces even when dense embeddings miss it. Returns docs sorted by\n * score (highest first); zero-score docs are dropped.\n *\n * Operates over the supplied candidate set (typically the dense retriever's\n * over-fetch), so it needs no global corpus index — ideal for fusing with\n * a vector ranking via {@link reciprocalRankFusion}.\n */\nexport function bm25Rank(query: string, docs: ReadonlyArray<LexicalDoc>): RankedItem[] {\n  const queryTerms = [...new Set(tokenize(query))];\n  if (queryTerms.length === 0 || docs.length === 0) return [];\n\n  const tokenized = docs.map(doc => ({ id: doc.id, terms: tokenize(doc.text) }));\n  const avgLen =\n    tokenized.reduce((sum, d) => sum + d.terms.length, 0) / tokenized.length || 1;\n\n  // Document frequency per query term, across the candidate set.\n  const df = new Map<string, number>();\n  for (const term of queryTerms) {\n    df.set(\n      term,\n      tokenized.filter(d => d.terms.includes(term)).length,\n    );\n  }\n\n  const n = tokenized.length;\n\n  const scored = tokenized.map(doc => {\n    const len = doc.terms.length || 1;\n    let score = 0;\n\n    for (const term of queryTerms) {\n      const tf = doc.terms.filter(t => t === term).length;\n      if (tf === 0) continue;\n\n      const docFreq = df.get(term) ?? 0;\n      // BM25 idf (with the +1 to keep it non-negative).\n      const idf = Math.log(1 + (n - docFreq + 0.5) / (docFreq + 0.5));\n      const numerator = tf * (BM25_K1 + 1);\n      const denominator = tf + BM25_K1 * (1 - BM25_B + BM25_B * (len / avgLen));\n      score += idf * (numerator / denominator);\n    }\n\n    return { id: doc.id, score };\n  });\n\n  return scored.filter(item => item.score > 0).sort((a, b) => b.score - a.score);\n}\n"],"mappings":";AAKA,MAAM,UAAU;AAChB,MAAM,SAAS;;AAGf,SAAS,SAAS,MAAwB;CACxC,OAAO,KACJ,YAAY,CAAC,CACb,MAAM,aAAa,CAAC,CACpB,OAAO,OAAO;AACnB;;;;;;;;;;;;AAaA,SAAgB,SAAS,OAAe,MAA+C;CACrF,MAAM,aAAa,CAAC,GAAG,IAAI,IAAI,SAAS,KAAK,CAAC,CAAC;CAC/C,IAAI,WAAW,WAAW,KAAK,KAAK,WAAW,GAAG,OAAO,CAAC;CAE1D,MAAM,YAAY,KAAK,KAAI,SAAQ;EAAE,IAAI,IAAI;EAAI,OAAO,SAAS,IAAI,IAAI;CAAE,EAAE;CAC7E,MAAM,SACJ,UAAU,QAAQ,KAAK,MAAM,MAAM,EAAE,MAAM,QAAQ,CAAC,IAAI,UAAU,UAAU;CAG9E,MAAM,qBAAK,IAAI,IAAoB;CACnC,KAAK,MAAM,QAAQ,YACjB,GAAG,IACD,MACA,UAAU,QAAO,MAAK,EAAE,MAAM,SAAS,IAAI,CAAC,CAAC,CAAC,MAChD;CAGF,MAAM,IAAI,UAAU;CAqBpB,OAnBe,UAAU,KAAI,QAAO;EAClC,MAAM,MAAM,IAAI,MAAM,UAAU;EAChC,IAAI,QAAQ;EAEZ,KAAK,MAAM,QAAQ,YAAY;GAC7B,MAAM,KAAK,IAAI,MAAM,QAAO,MAAK,MAAM,IAAI,CAAC,CAAC;GAC7C,IAAI,OAAO,GAAG;GAEd,MAAM,UAAU,GAAG,IAAI,IAAI,KAAK;GAEhC,MAAM,MAAM,KAAK,IAAI,KAAK,IAAI,UAAU,OAAQ,UAAU,GAAI;GAC9D,MAAM,YAAY,KAAM;GACxB,MAAM,cAAc,KAAK,WAAW,IAAI,SAAS,UAAU,MAAM;GACjE,SAAS,OAAO,YAAY;EAC9B;EAEA,OAAO;GAAE,IAAI,IAAI;GAAI;EAAM;CAC7B,CAEY,CAAC,CAAC,QAAO,SAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;AAC/E"}

package/esm/ai/src/rag/hybrid/hybrid-rank.mjs

@@ -1,29 +0,0 @@
-import { reciprocalRankFusion } from "./rrf.mjs";
-import { bm25Rank } from "./bm25.mjs";
-
-//#region ../@warlock.js/ai/src/rag/hybrid/hybrid-rank.ts
-/**
-* Hybrid rank (A4) — fuse a dense (vector) ranking with a BM25 lexical
-* ranking over the same candidate set via Reciprocal Rank Fusion. Dense
-* retrieval captures semantic similarity; BM25 captures exact-term
-* matches dense embeddings miss (names, ids, rare tokens). Fusing both
-* beats either alone for keyword-heavy queries.
-*
-* `dense` is the vector retriever's result in rank order; `candidates`
-* supplies the text for the lexical pass (typically the same over-fetched
-* set). Returns the fused ranking, highest score first.
-*
-* @example
-* const fused = hybridRank({
-*   query: "invoice 8842 refund",
-*   dense: vectorHits,                 // [{ id }, ...] in similarity order
-*   candidates: vectorHits.map(h => ({ id: h.id, text: h.text })),
-* });
-*/
-function hybridRank(params) {
-	return reciprocalRankFusion([params.dense.map((d) => d.id), bm25Rank(params.query, params.candidates).map((r) => r.id)], params.k);
-}
-
-//#endregion
-export { hybridRank };
-//# sourceMappingURL=hybrid-rank.mjs.map

package/esm/ai/src/rag/hybrid/hybrid-rank.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hybrid-rank.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/rag/hybrid/hybrid-rank.ts"],"sourcesContent":["import { bm25Rank, type LexicalDoc } from \"./bm25\";\nimport { reciprocalRankFusion, type RankedItem } from \"./rrf\";\n\n/**\n * Hybrid rank (A4) — fuse a dense (vector) ranking with a BM25 lexical\n * ranking over the same candidate set via Reciprocal Rank Fusion. Dense\n * retrieval captures semantic similarity; BM25 captures exact-term\n * matches dense embeddings miss (names, ids, rare tokens). Fusing both\n * beats either alone for keyword-heavy queries.\n *\n * `dense` is the vector retriever's result in rank order; `candidates`\n * supplies the text for the lexical pass (typically the same over-fetched\n * set). Returns the fused ranking, highest score first.\n *\n * @example\n * const fused = hybridRank({\n *   query: \"invoice 8842 refund\",\n *   dense: vectorHits,                 // [{ id }, ...] in similarity order\n *   candidates: vectorHits.map(h => ({ id: h.id, text: h.text })),\n * });\n */\nexport function hybridRank(params: {\n  query: string;\n  dense: ReadonlyArray<{ id: string }>;\n  candidates: ReadonlyArray<LexicalDoc>;\n  k?: number;\n}): RankedItem[] {\n  const denseIds = params.dense.map(d => d.id);\n  const lexicalIds = bm25Rank(params.query, params.candidates).map(r => r.id);\n\n  return reciprocalRankFusion([denseIds, lexicalIds], params.k);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,WAAW,QAKV;CAIf,OAAO,qBAAqB,CAHX,OAAO,MAAM,KAAI,MAAK,EAAE,EAGL,GAFjB,SAAS,OAAO,OAAO,OAAO,UAAU,CAAC,CAAC,KAAI,MAAK,EAAE,EAExB,CAAC,GAAG,OAAO,CAAC;AAC9D"}

package/esm/ai/src/rag/hybrid/rrf.mjs

@@ -1,30 +0,0 @@
-//#region ../@warlock.js/ai/src/rag/hybrid/rrf.ts
-/**
-* Reciprocal Rank Fusion (A4) — combine several independently-ranked
-* lists of ids into one consensus ranking. Each list contributes
-* `1 / (k + rank)` to an id's score (rank is 0-based within that list), so
-* an id near the top of multiple lists rises even if no single list ranks
-* it first. The classic fusion for hybrid (dense + lexical) retrieval
-* because it needs no score calibration between the lists.
-*
-* `k` (default 60, the standard) dampens the contribution of lower ranks.
-* Returns ids sorted by fused score, highest first.
-*
-* @example
-* reciprocalRankFusion([["a", "b", "c"], ["b", "a"]]);
-* // → [{ id: "b", ... }, { id: "a", ... }, { id: "c", ... }]
-*/
-function reciprocalRankFusion(rankedLists, k = 60) {
-	const scores = /* @__PURE__ */ new Map();
-	for (const list of rankedLists) list.forEach((id, rank) => {
-		scores.set(id, (scores.get(id) ?? 0) + 1 / (k + rank));
-	});
-	return [...scores.entries()].map(([id, score]) => ({
-		id,
-		score
-	})).sort((a, b) => b.score - a.score);
-}
-
-//#endregion
-export { reciprocalRankFusion };
-//# sourceMappingURL=rrf.mjs.map

package/esm/ai/src/rag/hybrid/rrf.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"rrf.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/rag/hybrid/rrf.ts"],"sourcesContent":["/** One item's id paired with a fused relevance score. */\nexport type RankedItem = { id: string; score: number };\n\n/**\n * Reciprocal Rank Fusion (A4) — combine several independently-ranked\n * lists of ids into one consensus ranking. Each list contributes\n * `1 / (k + rank)` to an id's score (rank is 0-based within that list), so\n * an id near the top of multiple lists rises even if no single list ranks\n * it first. The classic fusion for hybrid (dense + lexical) retrieval\n * because it needs no score calibration between the lists.\n *\n * `k` (default 60, the standard) dampens the contribution of lower ranks.\n * Returns ids sorted by fused score, highest first.\n *\n * @example\n * reciprocalRankFusion([[\"a\", \"b\", \"c\"], [\"b\", \"a\"]]);\n * // → [{ id: \"b\", ... }, { id: \"a\", ... }, { id: \"c\", ... }]\n */\nexport function reciprocalRankFusion(\n  rankedLists: ReadonlyArray<ReadonlyArray<string>>,\n  k = 60,\n): RankedItem[] {\n  const scores = new Map<string, number>();\n\n  for (const list of rankedLists) {\n    list.forEach((id, rank) => {\n      scores.set(id, (scores.get(id) ?? 0) + 1 / (k + rank));\n    });\n  }\n\n  return [...scores.entries()]\n    .map(([id, score]) => ({ id, score }))\n    .sort((a, b) => b.score - a.score);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,SAAgB,qBACd,aACA,IAAI,IACU;CACd,MAAM,yBAAS,IAAI,IAAoB;CAEvC,KAAK,MAAM,QAAQ,aACjB,KAAK,SAAS,IAAI,SAAS;EACzB,OAAO,IAAI,KAAK,OAAO,IAAI,EAAE,KAAK,KAAK,KAAK,IAAI,KAAK;CACvD,CAAC;CAGH,OAAO,CAAC,GAAG,OAAO,QAAQ,CAAC,CAAC,CACzB,KAAK,CAAC,IAAI,YAAY;EAAE;EAAI;CAAM,EAAE,CAAC,CACrC,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,KAAK;AACrC"}

package/esm/ai/src/rag/index.mjs

@@ -1,18 +0,0 @@
-import { chunk } from "./chunk/chunk.mjs";
-import { cacheVectorStore } from "./store/cache-vector-store.mjs";
-import { rag } from "./rag.mjs";
-import { pgVectorStore, vectorLiteral } from "./store/pg-vector-store.mjs";
-import { loadText } from "./loaders/load-text.mjs";
-import { loadHtml } from "./loaders/load-html.mjs";
-import { loadWeb } from "./loaders/load-web.mjs";
-import { PDF_PARSE_INSTALL_INSTRUCTIONS } from "./loaders/errors.mjs";
-import { loadPdf } from "./loaders/load-pdf.mjs";
-import "./loaders/index.mjs";
-import { keywordReranker } from "./rerank/keyword-reranker.mjs";
-import { llmReranker } from "./rerank/llm-reranker.mjs";
-import { reciprocalRankFusion } from "./hybrid/rrf.mjs";
-import { bm25Rank } from "./hybrid/bm25.mjs";
-import { hybridRank } from "./hybrid/hybrid-rank.mjs";
-import { multiQuery } from "./transforms/multi-query.mjs";
-
-export {  };

package/esm/ai/src/rag/loaders/errors.mjs

@@ -1,25 +0,0 @@
-//#region ../@warlock.js/ai/src/rag/loaders/errors.ts
-/**
-* Loader error surface. The only loader-specific failure is a missing
-* OPTIONAL peer (`pdf-parse`), which — like the moderation detector's
-* missing `openai` peer — is an *infrastructure* fault, not a content
-* problem, so {@link loadPdf} throws a plain `Error` carrying the curated
-* {@link PDF_PARSE_INSTALL_INSTRUCTIONS} rather than an `AIError`. Mirrors
-* the guard's `OPENAI_INSTALL_INSTRUCTIONS` / ai-panoptic's
-* `LANGFUSE_INSTALL_INSTRUCTIONS`.
-*/
-/**
-* Curated install string thrown by {@link loadPdf} on first call when the
-* `pdf-parse` peer is absent. Surfaced instead of a raw
-* module-resolution stack trace.
-*/
-const PDF_PARSE_INSTALL_INSTRUCTIONS = `
-The @warlock.js/ai PDF loader requires the optional "pdf-parse" peer.
-Install it with:
-
-  npm install pdf-parse
-`.trim();
-
-//#endregion
-export { PDF_PARSE_INSTALL_INSTRUCTIONS };
-//# sourceMappingURL=errors.mjs.map

package/esm/ai/src/rag/loaders/errors.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/rag/loaders/errors.ts"],"sourcesContent":["/**\n * Loader error surface. The only loader-specific failure is a missing\n * OPTIONAL peer (`pdf-parse`), which — like the moderation detector's\n * missing `openai` peer — is an *infrastructure* fault, not a content\n * problem, so {@link loadPdf} throws a plain `Error` carrying the curated\n * {@link PDF_PARSE_INSTALL_INSTRUCTIONS} rather than an `AIError`. Mirrors\n * the guard's `OPENAI_INSTALL_INSTRUCTIONS` / ai-panoptic's\n * `LANGFUSE_INSTALL_INSTRUCTIONS`.\n */\n\n/**\n * Curated install string thrown by {@link loadPdf} on first call when the\n * `pdf-parse` peer is absent. Surfaced instead of a raw\n * module-resolution stack trace.\n */\nexport const PDF_PARSE_INSTALL_INSTRUCTIONS = `\nThe @warlock.js/ai PDF loader requires the optional \"pdf-parse\" peer.\nInstall it with:\n\n  npm install pdf-parse\n`.trim();\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAa,iCAAiC;;;;;EAK5C,KAAK"}

package/esm/ai/src/rag/loaders/index.mjs

@@ -1,7 +0,0 @@
-import { loadText } from "./load-text.mjs";
-import { loadHtml } from "./load-html.mjs";
-import { loadWeb } from "./load-web.mjs";
-import { PDF_PARSE_INSTALL_INSTRUCTIONS } from "./errors.mjs";
-import { loadPdf } from "./load-pdf.mjs";
-
-export {  };